Join fwp send/recv ops with fna send/recv ops

diff --git a/fwp/lib/core/fwp_endpoint.c b/fwp/lib/core/fwp_endpoint.c
index 9d7f90a73e48b03104d09d448f95d555fc57b313..13b87cc21d1915b02775568351443d5d409ee923 100644 (file)
--- a/fwp/lib/core/fwp_endpoint.c
+++ b/fwp/lib/core/fwp_endpoint.c
@@ -110,15 +110,17 @@ int fwp_endpoint_attr_init(fwp_endpoint_attr_t *attr)
  * \return Zero on success, -1 on error and sets errno appropriately. 
  *
  */
-int fwp_send_endpoint_create_callback(const fwp_endpoint_d_t *epointd)
+int fwp_send_endpoint_create(unsigned int node,
+                               unsigned int port, 
+                               fwp_endpoint_attr_t *attr,
+                               fwp_endpoint_d_t *epointdp)
 {      
        struct sockaddr_in *addr;
        fwp_endpoint_attr_t *attr, 
-       fwp_endpoint_t *fwp_epoint = (fwp_endpoint_t*) 
-                               epointd->endpoint_protocol_info.receive;
+       fwp_endpoint_t *fwp_epoint;
 
        fwp_epoint = fwp_endpoint_alloc();      
-        if (!epoint) {
+        if (!fwp_epoint) {
                errno = ENOMEM;
                return -1;
        }
@@ -128,20 +130,19 @@ int fwp_send_endpoint_create_callback(const fwp_endpoint_d_t *epointd)
        epoint->node = node;
        epoint->port = port;
        */
-       attr = (fwp_endpoint_attr_t*) endpoint->protocol_info;
-       if (attr == NULL) {  
-               body = &fwp_epoint_attr_default;
-               endpoint->size = sizeof(fwp_endpoint_attr_t);
-       }
+       if (attr)
+               fwp_epoint->attr  = *attr;
+       else
+               fwp_epoint->attr = fwp_epoint_attr_default;
                
        addr = (struct sockaddr_in *)&(fwp_epoint->peer.addr);
        bzero((char*) addr, sizeof(*addr));
        addr->sin_family = AF_INET;
-       addr->sin_addr.s_addr = endpoint->destination;
-       addr->sin_port = htons(endpoint->stream_id);
+       addr->sin_addr.s_addr = node;
+       addr->sin_port = htons(port);
         fwp_epoint->peer.addrlen = sizeof(struct sockaddr_in);
        
-       if (attr->reliability == FWP_EPOINT_RELIABLE) {
+       if (fwp_epoint->attr.reliability == FWP_EPOINT_RELIABLE) {
                fwp_epoint->sockd = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
                if (fwp_epoint->sockd < 0) {
                        goto err;
@@ -169,8 +170,7 @@ int fwp_send_endpoint_create_callback(const fwp_endpoint_d_t *epointd)
        }
        
        FWP_DEBUG("FWP Send endpoint created.\n"); 
-       endpoint->endpoint_protocol_info.send.body = &fwp_epoint;
-       endpoint->endpoint_protocol_info.send.size = sizeof(fwp_epoint);
+       *epointdp = epoint;
        return 0;               
 err:
        fwp_endpoint_destroy(fwp_epoint);
@@ -186,11 +186,12 @@ err:
  *
  * \return Zero on success, -1 on error and errno is set.
  */
-int fwp_receive_endpoint_create_callback(const fwp_endpoint_d_t *epointd)
+int fwp_receive_endpoint_create(unsigned int port,
+                               fwp_endpoint_attr_t *attr,
+                               fwp_endpoint_d_t *epointdp)
 {
        struct sockaddr_in *addr;
-       fwp_endpoint_t *fwp_epoint = (fwp_endpoint_t*) 
-                               epointd->endpoint_protocol_info.receive;
+       fwp_endpoint_t *fwp_epoint;
 
        fwp_epoint = fwp_endpoint_alloc();      
         if (!fwp_epoint) {
@@ -201,17 +202,16 @@ int fwp_receive_endpoint_create_callback(const fwp_endpoint_d_t *epointd)
        /*epoint->type = FWP_RECV_EPOINT;
        epoint->status = FWP_EPOINT_UNBOUND;*/
        
-       attr = (fwp_endpoint_attr_t*) epointd->protocol_info.body;
-       if (attr == NULL) {  
-               endpoint->body = &fwp_epoint_attr_default;
-               endpoint->size = sizeof(fwp_endpoint_attr_t);
-       }
+       if (attr)
+               fwp_epoint->attr  = *attr;
+       else
+               fwp_epoint->attr = fwp_epoint_attr_default;
 
        addr = (struct sockaddr_in *)&(fwp_epoint->peer.addr);
        addr->sin_family = AF_INET;
        /* TODO: set listen interface, maybe through config struct*/
        addr->sin_addr.s_addr = INADDR_ANY;
-       addr->sin_port = htons(endpoint->stream_id);
+       addr->sin_port = htons(port);
         fwp_epoint->peer.addrlen = sizeof(struct sockaddr_in);
        
        if (fwp_epoint->attr.reliability == FWP_EPOINT_RELIABLE) {
@@ -243,7 +243,7 @@ int fwp_receive_endpoint_create_callback(const fwp_endpoint_d_t *epointd)
                fwp_epoint->testfds = fwp_epoint->fdset;
                fwp_epoint->c_sockd = 
                                (int*)malloc(fwp_epoint->attr.max_connections);
-               bzero(epoint->c_sockd, epoint->attr.max_connections);
+               bzero(fwp_epoint->c_sockd, fwp_epoint->attr.max_connections);
                fwp_epoint->nr_connections = 0;
 
                FWP_DEBUG("Receive endpoint\n");
@@ -277,11 +277,8 @@ int fwp_receive_endpoint_create_callback(const fwp_endpoint_d_t *epointd)
        getsockname(fwp_epoint->sockd, (struct sockaddr*)&fwp_epoint->peer.addr, 
                        &fwp_epoint->peer.addrlen);
        
-       endpoint->stream_id = ntohs(addr->sin_port);
-       /*TODO: set node*/
-       endpoint->destination =  ntohl(addr->sin_addr.s_addr);
        FWP_DEBUG("Receive endpoint port=%d created.\n", fwp_epoint->port); 
-       
+       *epointdp = epoint;     
        return 0;
 err:
        fwp_endpoint_destroy(fwp_epoint);
@@ -417,19 +414,16 @@ ssize_t fwp_recv_conn(fwp_endpoint_d_t epointd, void *buffer,
  * On error, -1 is returned and errno is set appropriately.
  *
  */
-ssize_t fwp_recv(fwp_endpoint_d_t epointd, void *buffer, size_t buffer_size, 
-                int flags)
-
+ssize_t fwp_recv(fwp_endpoint_t *endpoint,
+                       void *buffer, const size_t buffer_size,
+                       size_t *received_bytes, frsh_network_address_t *from)
 {
-       fwp_sockaddr_t *peer = &epoint->peer;
+       fwp_sockaddr_t *peer = &endpoint->peer;
        ssize_t len;
        fd_set fdset;
        int csockd, i;
        fwp_endpoint_t *fwp_epoint;
        
-       fwp_epoint = (fwp_endpoint_t*) 
-                       epointd->endpoint_protocol_info.receive;
-       
 /*     if (!fwp_endpoint_is_valid(epointd)) {
                errno = EINVAL;
                return -1;

diff --git a/fwp/lib/fwp_fna.c b/fwp/lib/fwp_fna.c
index f21f4285956829c734777e48f7f86416a83e73cf..f95b3ff51ac3e68ffe872814539125c8998575f1 100644 (file)
--- a/fwp/lib/fwp_fna.c
+++ b/fwp/lib/fwp_fna.c
@@ -1,59 +1,92 @@
 #include "fna.h"
 #include "fwp_vres.h"
-#include "fwp_msg.h"
-#include "fwp_ctable.h"
 
 int fwp_fna_init(const frsh_resource_id_t resource_id);
 {
        return fwp_init();
 }
 
+int fwp_fna_send_endpoint_create(fna_endpoint_data_t  *endpoint)
+{
+       unsigned int node;
+       unsigned int port;
+       fwp_endpoint_attr_t *attr;
+       fwp_endpoint_t *fwp_epoint;
+
+       node = (unsigned int) destination;
+       port = (unsigned int) port;
+       attr = (fwp_endpoint_attr*) endpoint->protocol_info.body; 
+       rv = fwp_send_endpoint_create(node, port, attr, fwp_epoint);
+       if (rv)
+               return rv;
+       endpoint->endpoint_protocol_info.send = fwp_epoint;
+       return 0;
+}
+
+int fwp_fna_recv_endpoint_create(fna_endpoint_data_t  *endpoint)
+{
+       unsigned int port;
+       fwp_endpoint_attr_t *attr;
+       fwp_endpoint_t *fwp_epoint;
+
+       node = (unsigned int) destination;
+       port = (unsigned int) port;
+       attr = (fwp_endpoint_attr*) endpoint->protocol_info.body; 
+       rv = fwp_receive_endpoint_create(port, attr, fwp_epoint);
+       if (rv)
+               return rv;
+       endpoint->endpoint_protocol_info.receive = fwp_epoint;
+       return 0;
+}
 
 /** FNA send routine */
 
-int fwp_fna_send(const fna_endpoint_data_t *endpoint,const void *msg,
-                  const size_t size, int flags)
+int fwp_fna_send(const fna_endpoint_data_t *endpoint,const void *msg, 
+                       const size_t size)
 {
-       struct sockaddr_in to_addr;
+       fwp_endpoint_t *fwp_epoint;
 
-       to_addr.sin_family = AF_INET;
-       to_addr.sin_addr.s_addr = inet_addr(endpoint->destination);
-       to_addr.sin_port = htons(endpoint->stream_id);
-       
-       fwp_send(endpoint->vres, msg, size, flags, to_addr,
-                     sizeof(to_addr));
+       fwp_epoint = endpoint->endpoint_protocol_info.send;
+       return fwp_send(fwp_epoint, msg, size, flags);
 }
 
 int fwp_fna_send_sync(const fna_endpoint_data_t *endpoint,const void *msg,
                   const size_t size)
 {
-       return fwp_fna_send(endpoint, msg, size, 0)
+       fwp_endpoint_t *fwp_epoint;
+
+       fwp_epoint = endpoint->endpoint_protocol_info.send;
+       return fwp_send(fwp_epoint, msg, size, 0);
 {
 
 
 int fwp_fna_send_async(const fna_endpoint_data_t *endpoint,const void *msg,
                   const size_t size)
 {
+       fwp_endpoint_t *fwp_epoint;
+
+       fwp_epoint = endpoint->endpoint_protocol_info.send;
        return fwp_fna_send(endpoint, msg, size, MSG_DONTWAIT)
-{
+}
 
 /** FNA receive routines */
-
-int fwp_fna_receive(const fna_endpoint_data_t *endpoint, void *buffer, 
-                        const size_t buffer_size, size_t *received_bytes, 
-                        frsh_network_address_t *from, int flags)
-
+int fwp_fna_receive(const fna_endpoint_data_t *endpoint,
+                       void *buffer, const size_t buffer_size,
+                       size_t *received_bytes, frsh_network_address_t *from)
 {
-       struct  sockaddr_in from_addr;
-       socklen_t fromlen = sizeof(from_in);
+       unsigned int from_addr;
+       size_t len;
+       fwp_endpoint_t *fwp_epoint;
+       
+       fwp_epoint = (fwp_endpoint_t*) 
+                       epointd->endpoint_protocol_info.receive;
 
-       len = fwp_receive(endpoint->stream_id, buffer, buffer_size, flags, 
-                         &from_addr, &fromlen);
-       if (!len) 
-               return FNA_ERR_INTERNAL_ERR;
+       len = fwp_recv(fwp_epoint, buffer, buffer_size, flags, &from_addr);
+       if (len < 0) 
+               return len;
        
        *received_bytes = len;
-       *from = from_addr.sin_addr.s_addr;
+       *from = from_addr;
        
        return 0;
 }
@@ -62,23 +95,48 @@ int fwp_fna_receive_sync(const fna_endpoint_data_t *endpoint, void *buffer,
                         const size_t buffer_size, size_t *received_bytes, 
                         frsh_network_address_t *from)
 {
+       unsigned int from_addr;
+       size_t len;
+       fwp_endpoint_t *fwp_epoint;
+       
+       fwp_epoint = (fwp_endpoint_t*) 
+                       epointd->endpoint_protocol_info.receive;
 
-       return fwp_fna_receive(endpoint, buffer, buffer_size, received_bytes,
-                              from, 0);
+       len = fwp_recv(fwp_epoint, buffer, buffer_size, flags, &from_addr);
+       if (len < 0) 
+               return len;
+       
+       *received_bytes = len;
+       *from = from_addr;
+       
+       return 0;
 }
 
 int fwp_fna_receive_async(const fna_endpoint_data_t *endpoint, void *buffer, 
                         const size_t buffer_size, size_t *received_bytes, 
                         frsh_network_address_t *from)
 {
-       return fwp_fna_receive(endpoint, buffer, buffer_size, received_bytes,
-                              from, MSG_DONTWAIT);
+       unsigned int from_addr;
+       size_t len;
+       fwp_endpoint_t *fwp_epoint;
+       
+       fwp_epoint = (fwp_endpoint_t*) 
+                       epointd->endpoint_protocol_info.receive;
+
+       len = fwp_recv(fwp_epoint, buffer, buffer_size, flags, &from_addr);
+       if (len < 0) 
+               return len;
+       
+       *received_bytes = len;
+       *from = from_addr;
+       
+       return 0;
 }
 
 int fwp_fna_vres_destroy(const frsh_resource_id_t resource_id,
                     const fna_vres_id_t vres)
 {
-       return fwp_vres_close(vres);    
+//     return fwp_vres_close(vres);    
 }
 
 fna_operations_t fwp_fna_operations = {