Changeset a2e3ee6 in mainline for uspace/srv/net/inetsrv

Timestamp:

2013-06-20T16:45:58Z (12 years ago)

Author:

Martin Decky <martin@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

08bb73b

Parents:

19a4f73

Message:

use new network address infrastructure (towards IPv6 support)

Location:

uspace/srv/net/inetsrv

Files:

• addrobj.c (modified) (2 diffs)
• icmp.c (modified) (3 diffs)
• inet_link.c (modified) (6 diffs)
• inetcfg.c (modified) (8 diffs)
• inetping.c (modified) (4 diffs)
• inetping.h (modified) (1 diff)
• inetsrv.c (modified) (5 diffs)
• inetsrv.h (modified) (1 diff)
• pdu.c (modified) (3 diffs)
• reass.c (modified) (1 diff)
• sroute.c (modified) (1 diff)

uspace/srv/net/inetsrv/addrobj.c

@@ -112 +112 @@
 inet_addrobj_t *inet_addrobj_find(inet_addr_t *addr, inet_addrobj_find_t find)
 {
-        uint32_t mask;
-
-        log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_addrobj_find(%x)", (unsigned)addr->ipv4);
-
-        fibril_mutex_lock(&addr_list_lock);
-
+        uint32_t addr_addr;
+        int rc = inet_addr_pack(addr, &addr_addr);
+        if (rc != EOK)
+                return NULL;
+        
+        fibril_mutex_lock(&addr_list_lock);
+        
         list_foreach(addr_list, link) {
                 inet_addrobj_t *naddr = list_get_instance(link,
                     inet_addrobj_t, addr_list);
-
-                mask = inet_netmask(naddr->naddr.bits);
-                if ((naddr->naddr.ipv4 & mask) == (addr->ipv4 & mask)) {
+                
+                uint32_t naddr_addr;
+                uint8_t naddr_bits;
+                rc = inet_naddr_pack(&naddr->naddr, &naddr_addr, &naddr_bits);
+                if (rc != EOK)
+                        continue;
+                
+                uint32_t mask = inet_netmask(naddr_bits);
+                if ((naddr_addr & mask) == (addr_addr & mask)) {
                         fibril_mutex_unlock(&addr_list_lock);
                         log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_addrobj_find: found %p",
@@ -218 +225 @@
 {
         inet_addr_t lsrc_addr;
-        inet_addr_t *ldest_addr;
-
-        lsrc_addr.ipv4 = addr->naddr.ipv4;
-        ldest_addr = ldest;
-
+        inet_naddr_addr(&addr->naddr, &lsrc_addr);
+        
+        inet_addr_t *ldest_addr = ldest;
+        
         return inet_link_send_dgram(addr->ilink, &lsrc_addr, ldest_addr, dgram,
             proto, ttl, df);

uspace/srv/net/inetsrv/icmp.c

@@ -120 +120 @@
 static int icmp_recv_echo_reply(inet_dgram_t *dgram)
 {
-        icmp_echo_t *reply;
-        inetping_sdu_t sdu;
-        uint16_t ident;
-
         log_msg(LOG_DEFAULT, LVL_DEBUG, "icmp_recv_echo_reply()");
-
+        
         if (dgram->size < sizeof(icmp_echo_t))
                 return EINVAL;
-
-        reply = (icmp_echo_t *)dgram->data;
-
-        sdu.src = dgram->src;
-        sdu.dest = dgram->dest;
+        
+        icmp_echo_t *reply = (icmp_echo_t *) dgram->data;
+        
+        inetping_sdu_t sdu;
+        
+        int rc = inet_addr_pack(&dgram->src, &sdu.src);
+        if (rc != EOK)
+                return rc;
+        
+        rc = inet_addr_pack(&dgram->dest, &sdu.dest);
+        if (rc != EOK)
+                return rc;
+        
         sdu.seq_no = uint16_t_be2host(reply->seq_no);
         sdu.data = reply + sizeof(icmp_echo_t);
         sdu.size = dgram->size - sizeof(icmp_echo_t);
-        ident = uint16_t_be2host(reply->ident);
+        
+        uint16_t ident = uint16_t_be2host(reply->ident);
 
         return inetping_recv(ident, &sdu);
@@ -143 +148 @@
 int icmp_ping_send(uint16_t ident, inetping_sdu_t *sdu)
 {
-        inet_dgram_t dgram;
-        icmp_echo_t *request;
-        void *rdata;
-        size_t rsize;
-        uint16_t checksum;
-        int rc;
-
-        rsize = sizeof(icmp_echo_t) + sdu->size;
-        rdata = calloc(rsize, 1);
+        size_t rsize = sizeof(icmp_echo_t) + sdu->size;
+        void *rdata = calloc(rsize, 1);
         if (rdata == NULL)
                 return ENOMEM;
-
-        request = (icmp_echo_t *)rdata;
-
+        
+        icmp_echo_t *request = (icmp_echo_t *)rdata;
+        
         request->type = ICMP_ECHO_REQUEST;
         request->code = 0;
@@ -162 +160 @@
         request->ident = host2uint16_t_be(ident);
         request->seq_no = host2uint16_t_be(sdu->seq_no);
-
+        
         memcpy(rdata + sizeof(icmp_echo_t), sdu->data, sdu->size);
-
-        checksum = inet_checksum_calc(INET_CHECKSUM_INIT, rdata, rsize);
+        
+        uint16_t checksum = inet_checksum_calc(INET_CHECKSUM_INIT, rdata, rsize);
         request->checksum = host2uint16_t_be(checksum);
-
-        dgram.src = sdu->src;
-        dgram.dest = sdu->dest;
+        
+        inet_dgram_t dgram;
+        
+        inet_addr_unpack(sdu->src, &dgram.src);
+        inet_addr_unpack(sdu->dest, &dgram.dest);
+        
         dgram.tos = ICMP_TOS;
         dgram.data = rdata;
         dgram.size = rsize;
-
-        rc = inet_route_packet(&dgram, IP_PROTO_ICMP, INET_TTL_MAX, 0);
-
+        
+        int rc = inet_route_packet(&dgram, IP_PROTO_ICMP, INET_TTL_MAX, 0);
+        
         free(rdata);
         return rc;

uspace/srv/net/inetsrv/inet_link.c

@@ -153 +153 @@
 {
         inet_link_t *ilink;
-        iplink_addr_t iaddr;
+        inet_addr_t iaddr;
         int rc;
 
@@ -196 +196 @@
 
         static int first = 1;
-        /* XXX For testing: set static IP address 10.0.2.15/24 */
+        
         addr = inet_addrobj_new();
+        
         if (first) {
-                addr->naddr.ipv4 = (127 << 24) + (0 << 16) + (0 << 8) + 1;
+                inet_naddr(&addr->naddr, 127, 0, 0, 1, 24);
                 first = 0;
         } else {
-                addr->naddr.ipv4 = (10 << 24) + (0 << 16) + (2 << 8) + 15;
-        }
-        addr->naddr.bits = 24;
+                /* XXX For testing: set static IP address 10.0.2.15/24 */
+                inet_naddr(&addr->naddr, 10, 0, 2, 15, 24);
+        }
+        
         addr->ilink = ilink;
         addr->name = str_dup("v4a");
@@ -215 +217 @@
         }
 
-        iaddr.ipv4 = addr->naddr.ipv4;
+        inet_naddr_addr(&addr->naddr, &iaddr);
         rc = iplink_addr_add(ilink->iplink, &iaddr);
         if (rc != EOK) {
@@ -257 +259 @@
     inet_addr_t *ldest, inet_dgram_t *dgram, uint8_t proto, uint8_t ttl, int df)
 {
-        iplink_sdu_t sdu;
-        inet_packet_t packet;
-        int rc;
-        size_t offs, roffs;
-
         /*
          * Fill packet structure. Fragmentation is performed by
          * inet_pdu_encode().
          */
+        inet_packet_t packet;
+        
         packet.src = dgram->src;
         packet.dest = dgram->dest;
@@ -274 +273 @@
         packet.data = dgram->data;
         packet.size = dgram->size;
-
-        sdu.lsrc.ipv4 = lsrc->ipv4;
-        sdu.ldest.ipv4 = ldest->ipv4;
-
-        offs = 0;
+        
+        iplink_sdu_t sdu;
+        
+        int rc = inet_addr_pack(lsrc, &sdu.lsrc);
+        if (rc != EOK)
+                return rc;
+        
+        rc = inet_addr_pack(ldest, &sdu.ldest);
+        if (rc != EOK)
+                return rc;
+        
+        size_t offs = 0;
         do {
+                size_t roffs;
+                
                 /* Encode one fragment */
                 rc = inet_pdu_encode(&packet, offs, ilink->def_mtu, &sdu.data,
@@ -285 +293 @@
                 if (rc != EOK)
                         return rc;
-
+                
                 /* Send the PDU */
                 rc = iplink_send(ilink->iplink, &sdu);
                 free(sdu.data);
-
+                
                 offs = roffs;
         } while (offs < packet.size);
-
+        
         return rc;
 }

uspace/srv/net/inetsrv/inetcfg.c

@@ -56 +56 @@
         inet_link_t *ilink;
         inet_addrobj_t *addr;
-        iplink_addr_t iaddr;
+        inet_addr_t iaddr;
         int rc;
 
@@ -82 +82 @@
         }
 
-        iaddr.ipv4 = addr->naddr.ipv4;
+        inet_naddr_addr(&addr->naddr, &iaddr);
         rc = iplink_addr_add(ilink->iplink, &iaddr);
         if (rc != EOK) {
@@ -254 +254 @@
         }
 
-        naddr.ipv4 = IPC_GET_ARG1(*call);
-        naddr.bits = IPC_GET_ARG2(*call);
-        link_id    = IPC_GET_ARG3(*call);
+        inet_naddr_unpack(IPC_GET_ARG1(*call), IPC_GET_ARG2(*call), &naddr);
+        link_id = IPC_GET_ARG3(*call);
 
         addr_id = 0;
@@ -279 +278 @@
 static void inetcfg_addr_get_srv(ipc_callid_t callid, ipc_call_t *call)
 {
+        log_msg(LOG_DEFAULT, LVL_DEBUG, "inetcfg_addr_get_srv()");
+        
+        sysarg_t addr_id = IPC_GET_ARG1(*call);
+        
+        inet_addr_info_t ainfo;
+        
+        inet_naddr_any(&ainfo.naddr);
+        ainfo.ilink = 0;
+        ainfo.name = NULL;
+        
         ipc_callid_t rcallid;
         size_t max_size;
-
-        sysarg_t addr_id;
-        inet_addr_info_t ainfo;
-        int rc;
-
-        addr_id = IPC_GET_ARG1(*call);
-        log_msg(LOG_DEFAULT, LVL_DEBUG, "inetcfg_addr_get_srv()");
-
-        ainfo.naddr.ipv4 = 0;
-        ainfo.naddr.bits = 0;
-        ainfo.ilink = 0;
-        ainfo.name = NULL;
-
+        
         if (!async_data_read_receive(&rcallid, &max_size)) {
                 async_answer_0(rcallid, EREFUSED);
@@ -299 +296 @@
                 return;
         }
-
-        rc = inetcfg_addr_get(addr_id, &ainfo);
-        if (rc != EOK) {
-                async_answer_0(callid, rc);
-                return;
-        }
-
+        
+        int rc = inetcfg_addr_get(addr_id, &ainfo);
+        if (rc != EOK) {
+                async_answer_0(callid, rc);
+                return;
+        }
+        
+        uint32_t naddr_addr;
+        uint8_t naddr_bits;
+        rc = inet_naddr_pack(&ainfo.naddr, &naddr_addr, &naddr_bits);
+        if (rc != EOK) {
+                async_answer_0(callid, rc);
+                return;
+        }
+        
         sysarg_t retval = async_data_read_finalize(rcallid, ainfo.name,
             min(max_size, str_size(ainfo.name)));
         free(ainfo.name);
-
-        async_answer_3(callid, retval, ainfo.naddr.ipv4, ainfo.naddr.bits,
-            ainfo.ilink);
+        
+        async_answer_3(callid, retval, (sysarg_t) naddr_addr,
+            (sysarg_t) naddr_bits, ainfo.ilink);
 }
 
@@ -476 +481 @@
     ipc_call_t *call)
 {
+        log_msg(LOG_DEFAULT, LVL_DEBUG, "inetcfg_sroute_create_srv()");
+        
         char *name;
+        int rc = async_data_write_accept((void **) &name, true, 0, LOC_NAME_MAXLEN,
+            0, NULL);
+        if (rc != EOK) {
+                async_answer_0(callid, rc);
+                return;
+        }
+        
         inet_naddr_t dest;
         inet_addr_t router;
-        sysarg_t sroute_id;
-        int rc;
-
-        log_msg(LOG_DEFAULT, LVL_DEBUG, "inetcfg_sroute_create_srv()");
-
-        rc = async_data_write_accept((void **) &name, true, 0, LOC_NAME_MAXLEN,
-            0, NULL);
-        if (rc != EOK) {
-                async_answer_0(callid, rc);
-                return;
-        }
-
-        dest.ipv4   = IPC_GET_ARG1(*call);
-        dest.bits   = IPC_GET_ARG2(*call);
-        router.ipv4 = IPC_GET_ARG3(*call);
-
-        sroute_id = 0;
+        
+        inet_naddr_unpack(IPC_GET_ARG1(*call), IPC_GET_ARG2(*call), &dest);
+        inet_addr_unpack(IPC_GET_ARG3(*call), &router);
+        
+        sysarg_t sroute_id = 0;
         rc = inetcfg_sroute_create(name, &dest, &router, &sroute_id);
         free(name);
@@ -516 +518 @@
 static void inetcfg_sroute_get_srv(ipc_callid_t callid, ipc_call_t *call)
 {
+        log_msg(LOG_DEFAULT, LVL_DEBUG, "inetcfg_sroute_get_srv()");
+        
+        sysarg_t sroute_id = IPC_GET_ARG1(*call);
+        
+        inet_sroute_info_t srinfo;
+        
+        inet_naddr_any(&srinfo.dest);
+        inet_addr_any(&srinfo.router);
+        srinfo.name = NULL;
+        
         ipc_callid_t rcallid;
         size_t max_size;
-
-        sysarg_t sroute_id;
-        inet_sroute_info_t srinfo;
-        int rc;
-
-        sroute_id = IPC_GET_ARG1(*call);
-        log_msg(LOG_DEFAULT, LVL_DEBUG, "inetcfg_sroute_get_srv()");
-
-        srinfo.dest.ipv4 = 0;
-        srinfo.dest.bits = 0;
-        srinfo.router.ipv4 = 0;
-        srinfo.name = NULL;
-
         if (!async_data_read_receive(&rcallid, &max_size)) {
                 async_answer_0(rcallid, EREFUSED);
@@ -536 +535 @@
                 return;
         }
-
-        rc = inetcfg_sroute_get(sroute_id, &srinfo);
-        if (rc != EOK) {
-                async_answer_0(callid, rc);
-                return;
-        }
-
+        
+        int rc = inetcfg_sroute_get(sroute_id, &srinfo);
+        if (rc != EOK) {
+                async_answer_0(callid, rc);
+                return;
+        }
+        
+        uint32_t dest_addr;
+        uint8_t dest_bits;
+        rc = inet_naddr_pack(&srinfo.dest, &dest_addr, &dest_bits);
+        if (rc != EOK) {
+                async_answer_0(callid, rc);
+                return;
+        }
+        
+        uint32_t router_addr;
+        rc = inet_addr_pack(&srinfo.router, &router_addr);
+        if (rc != EOK) {
+                async_answer_0(callid, rc);
+                return;
+        }
+        
         sysarg_t retval = async_data_read_finalize(rcallid, srinfo.name,
             min(max_size, str_size(srinfo.name)));
         free(srinfo.name);
-
-        async_answer_3(callid, retval, srinfo.dest.ipv4, srinfo.dest.bits,
-            srinfo.router.ipv4);
+        
+        async_answer_3(callid, retval, (sysarg_t) dest_addr,
+            (sysarg_t) dest_bits, (sysarg_t) router_addr);
 }
 

uspace/srv/net/inetsrv/inetping.c

@@ -62 +62 @@
 }
 
-static int inetping_get_srcaddr(inetping_client_t *client, inet_addr_t *remote,
-    inet_addr_t *local)
-{
-        return inet_get_srcaddr(remote, ICMP_TOS, local);
+static int inetping_get_srcaddr(inetping_client_t *client, uint32_t remote,
+    uint32_t *local)
+{
+        inet_addr_t remote_addr;
+        inet_addr_unpack(remote, &remote_addr);
+        
+        inet_addr_t local_addr;
+        int rc = inet_get_srcaddr(&remote_addr, ICMP_TOS, &local_addr);
+        if (rc != EOK)
+                return rc;
+        
+        return inet_addr_pack(&local_addr, local);
 }
 
@@ -82 +90 @@
         exch = async_exchange_begin(client->sess);
 
-        aid_t req = async_send_3(exch, INETPING_EV_RECV, sdu->src.ipv4,
-            sdu->dest.ipv4, sdu->seq_no, &answer);
+        aid_t req = async_send_3(exch, INETPING_EV_RECV, (sysarg_t) sdu->src,
+            (sysarg_t) sdu->dest, sdu->seq_no, &answer);
         int rc = async_data_write_start(exch, sdu->data, sdu->size);
         async_exchange_end(exch);
@@ -116 +124 @@
         }
 
-        sdu.src.ipv4 = IPC_GET_ARG1(*call);
-        sdu.dest.ipv4 = IPC_GET_ARG2(*call);
+        sdu.src = IPC_GET_ARG1(*call);
+        sdu.dest = IPC_GET_ARG2(*call);
         sdu.seq_no = IPC_GET_ARG3(*call);
 
@@ -129 +137 @@
     ipc_callid_t callid, ipc_call_t *call)
 {
-        inet_addr_t remote;
-        inet_addr_t local;
-        int rc;
-
         log_msg(LOG_DEFAULT, LVL_DEBUG, "inetping_get_srcaddr_srv()");
-
-        remote.ipv4 = IPC_GET_ARG1(*call);
-        local.ipv4 = 0;
-
-        rc = inetping_get_srcaddr(client, &remote, &local);
-        async_answer_1(callid, rc, local.ipv4);
+        
+        uint32_t remote = IPC_GET_ARG1(*call);
+        uint32_t local = 0;
+        
+        int rc = inetping_get_srcaddr(client, remote, &local);
+        async_answer_1(callid, rc, (sysarg_t) local);
 }
 

uspace/srv/net/inetsrv/inetping.h

@@ -38 +38 @@
 #define INETPING_H_
 
+#include "inetsrv.h"
+
 extern void inetping_conn(ipc_callid_t, ipc_call_t *, void *);
 extern int inetping_recv(uint16_t, inetping_sdu_t *);

uspace/srv/net/inetsrv/inetsrv.c

@@ -104 +104 @@
         }
 
-        sroute->dest.ipv4 = 0;
-        sroute->dest.bits = 0;
-        sroute->router.ipv4 = (10 << 24) | (0 << 16) | (2 << 8) | 2;
+        inet_naddr(&sroute->dest, 0, 0, 0, 0, 0);
+        inet_addr(&sroute->router, 10, 0, 2, 2);
         sroute->name = str_dup("default");
         inet_sroute_add(sroute);
 
-        rc = inet_link_discovery_start();
+        rc = inet_link_discovery_start();
         if (rc != EOK)
                 return EEXIST;
@@ -194 +193 @@
 
         /* Take source address from the address object */
-        local->ipv4 = dir.aobj->naddr.ipv4;
+        inet_naddr_addr(&dir.aobj->naddr, local);
         return EOK;
 }
@@ -201 +200 @@
     ipc_call_t *call)
 {
+        log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_get_srcaddr_srv()");
+        
         inet_addr_t remote;
-        uint8_t tos;
+        inet_addr_unpack(IPC_GET_ARG1(*call), &remote);
+        uint8_t tos = IPC_GET_ARG2(*call);
+        
         inet_addr_t local;
-        int rc;
-
-        log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_get_srcaddr_srv()");
-
-        remote.ipv4 = IPC_GET_ARG1(*call);
-        tos = IPC_GET_ARG2(*call);
-        local.ipv4 = 0;
-
-        rc = inet_get_srcaddr(&remote, tos, &local);
-        async_answer_1(callid, rc, local.ipv4);
+        int rc = inet_get_srcaddr(&remote, tos, &local);
+        if (rc != EOK) {
+                async_answer_0(callid, rc);
+                return;
+        }
+        
+        uint32_t local_addr;
+        rc = inet_addr_pack(&local, &local_addr);
+        if (rc != EOK) {
+                async_answer_0(callid, rc);
+                return;
+        }
+        
+        async_answer_1(callid, rc, (sysarg_t) local_addr);
 }
 
@@ -219 +226 @@
     ipc_call_t *call)
 {
+        log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_send_srv()");
+        
         inet_dgram_t dgram;
-        uint8_t ttl;
-        int df;
-        int rc;
-
-        log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_send_srv()");
-
-        dgram.src.ipv4 = IPC_GET_ARG1(*call);
-        dgram.dest.ipv4 = IPC_GET_ARG2(*call);
+        
+        inet_addr_unpack(IPC_GET_ARG1(*call), &dgram.src);
+        inet_addr_unpack(IPC_GET_ARG2(*call), &dgram.dest);
         dgram.tos = IPC_GET_ARG3(*call);
-        ttl = IPC_GET_ARG4(*call);
-        df = IPC_GET_ARG5(*call);
-
-        rc = async_data_write_accept(&dgram.data, false, 0, 0, 0, &dgram.size);
+        
+        uint8_t ttl = IPC_GET_ARG4(*call);
+        int df = IPC_GET_ARG5(*call);
+        
+        int rc = async_data_write_accept(&dgram.data, false, 0, 0, 0,
+            &dgram.size);
         if (rc != EOK) {
                 async_answer_0(callid, rc);
                 return;
         }
-
+        
         rc = inet_send(client, &dgram, client->protocol, ttl, df);
-
+        
         free(dgram.data);
         async_answer_0(callid, rc);
@@ -365 +371 @@
 int inet_ev_recv(inet_client_t *client, inet_dgram_t *dgram)
 {
+        uint32_t src;
+        int rc = inet_addr_pack(&dgram->src, &src);
+        if (rc != EOK)
+                return rc;
+        
+        uint32_t dest;
+        rc = inet_addr_pack(&dgram->dest, &dest);
+        if (rc != EOK)
+                return rc;
+        
         async_exch_t *exch = async_exchange_begin(client->sess);
-
+        
         ipc_call_t answer;
-        aid_t req = async_send_3(exch, INET_EV_RECV, dgram->src.ipv4,
-            dgram->dest.ipv4, dgram->tos, &answer);
-        int rc = async_data_write_start(exch, dgram->data, dgram->size);
+        aid_t req = async_send_3(exch, INET_EV_RECV, (sysarg_t) src,
+            (sysarg_t) dest, dgram->tos, &answer);
+        rc = async_data_write_start(exch, dgram->data, dgram->size);
         async_exchange_end(exch);
-
+        
         if (rc != EOK) {
                 async_forget(req);
                 return rc;
         }
-
+        
         sysarg_t retval;
         async_wait_for(req, &retval);
         if (retval != EOK)
                 return retval;
-
+        
         return EOK;
 }

uspace/srv/net/inetsrv/inetsrv.h

@@ -172 +172 @@
 
 typedef struct {
-        inet_addr_t src;
-        inet_addr_t dest;
+        uint32_t src;
+        uint32_t dest;
         uint16_t seq_no;
         void *data;

uspace/srv/net/inetsrv/pdu.c

@@ -106 +106 @@
     void **rdata, size_t *rsize, size_t *roffs)
 {
-        void *data;
-        size_t size;
-        ip_header_t *hdr;
-        size_t hdr_size;
-        size_t data_offs;
-        uint16_t chksum;
-        uint16_t ident;
-        uint16_t flags_foff;
-        uint16_t foff;
-        size_t fragoff_limit;
-        size_t xfer_size;
-        size_t spc_avail;
-        size_t rem_offs;
-
+        uint32_t src_addr;
+        int rc = inet_addr_pack(&packet->src, &src_addr);
+        if (rc != EOK)
+                return rc;
+        
+        uint32_t dest_addr;
+        rc = inet_addr_pack(&packet->dest, &dest_addr);
+        if (rc != EOK)
+                return rc;
+        
         /* Upper bound for fragment offset field */
-        fragoff_limit = 1 << (FF_FRAGOFF_h - FF_FRAGOFF_l);
-
+        size_t fragoff_limit = 1 << (FF_FRAGOFF_h - FF_FRAGOFF_l);
+        
         /* Verify that total size of datagram is within reasonable bounds */
         if (offs + packet->size > FRAG_OFFS_UNIT * fragoff_limit)
                 return ELIMIT;
-
-        hdr_size = sizeof(ip_header_t);
-        data_offs = ROUND_UP(hdr_size, 4);
-
+        
+        size_t hdr_size = sizeof(ip_header_t);
+        size_t data_offs = ROUND_UP(hdr_size, 4);
+        
         assert(offs % FRAG_OFFS_UNIT == 0);
         assert(offs / FRAG_OFFS_UNIT < fragoff_limit);
-
+        
         /* Value for the fragment offset field */
-        foff = offs / FRAG_OFFS_UNIT;
-
+        uint16_t foff = offs / FRAG_OFFS_UNIT;
+        
         if (hdr_size >= mtu)
                 return EINVAL;
-
+        
         /* Amount of space in the PDU available for payload */
-        spc_avail = mtu - hdr_size;
+        size_t spc_avail = mtu - hdr_size;
         spc_avail -= (spc_avail % FRAG_OFFS_UNIT);
-
+        
         /* Amount of data (payload) to transfer */
-        xfer_size = min(packet->size - offs, spc_avail);
-
+        size_t xfer_size = min(packet->size - offs, spc_avail);
+        
         /* Total PDU size */
-        size = hdr_size + xfer_size;
-
+        size_t size = hdr_size + xfer_size;
+        
         /* Offset of remaining payload */
-        rem_offs = offs + xfer_size;
-
+        size_t rem_offs = offs + xfer_size;
+        
         /* Flags */
-        flags_foff =
+        uint16_t flags_foff =
             (packet->df ? BIT_V(uint16_t, FF_FLAG_DF) : 0) +
             (rem_offs < packet->size ? BIT_V(uint16_t, FF_FLAG_MF) : 0) +
             (foff << FF_FRAGOFF_l);
-
-        data = calloc(size, 1);
+        
+        void *data = calloc(size, 1);
         if (data == NULL)
                 return ENOMEM;
-
+        
         /* Allocate identifier */
         fibril_mutex_lock(&ip_ident_lock);
-        ident = ++ip_ident;
+        uint16_t ident = ++ip_ident;
         fibril_mutex_unlock(&ip_ident_lock);
-
+        
         /* Encode header fields */
-        hdr = (ip_header_t *)data;
+        ip_header_t *hdr = (ip_header_t *) data;
+        
         hdr->ver_ihl = (4 << VI_VERSION_l) | (hdr_size / sizeof(uint32_t));
         hdr->tos = packet->tos;
@@ -177 +174 @@
         hdr->proto = packet->proto;
         hdr->chksum = 0;
-        hdr->src_addr = host2uint32_t_be(packet->src.ipv4);
-        hdr->dest_addr = host2uint32_t_be(packet->dest.ipv4);
-
+        hdr->src_addr = host2uint32_t_be(src_addr);
+        hdr->dest_addr = host2uint32_t_be(dest_addr);
+        
         /* Compute checksum */
-        chksum = inet_checksum_calc(INET_CHECKSUM_INIT, (void *)hdr, hdr_size);
+        uint16_t chksum = inet_checksum_calc(INET_CHECKSUM_INIT, (void *) hdr,
+            hdr_size);
         hdr->chksum = host2uint16_t_be(chksum);
-
+        
         /* Copy payload */
-        memcpy((uint8_t *)data + data_offs, packet->data + offs, xfer_size);
-
+        memcpy((uint8_t *) data + data_offs, packet->data + offs, xfer_size);
+        
         *rdata = data;
         *rsize = size;
         *roffs = rem_offs;
-
+        
         return EOK;
 }
@@ -238 +236 @@
         /* XXX Checksum */
 
-        packet->src.ipv4 = uint32_t_be2host(hdr->src_addr);
-        packet->dest.ipv4 = uint32_t_be2host(hdr->dest_addr);
+        inet_addr_unpack(uint32_t_be2host(hdr->src_addr), &packet->src);
+        inet_addr_unpack(uint32_t_be2host(hdr->dest_addr), &packet->dest);
         packet->tos = hdr->tos;
         packet->proto = hdr->proto;

uspace/srv/net/inetsrv/reass.c

@@ -139 +139 @@
                     dgram_link);
 
-                if (f1->packet.src.ipv4 == packet->src.ipv4 &&
-                    f1->packet.dest.ipv4 == packet->dest.ipv4 &&
-                    f1->packet.proto == packet->proto &&
-                    f1->packet.ident == packet->ident) {
+                if ((inet_addr_compare(&f1->packet.src, &packet->src)) &&
+                    (inet_addr_compare(&f1->packet.dest, &packet->dest)) &&
+                    (f1->packet.proto == packet->proto) &&
+                    (f1->packet.ident == packet->ident)) {
                         /* Match */
                         return rdg;

uspace/srv/net/inetsrv/sroute.c

@@ -97 +97 @@
 inet_sroute_t *inet_sroute_find(inet_addr_t *addr)
 {
-        uint32_t mask;
-        inet_sroute_t *best;
-
-        log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_sroute_find(%x)", (unsigned)addr->ipv4);
-
-        fibril_mutex_lock(&sroute_list_lock);
-
-        best = NULL;
-
-        list_foreach(sroute_list, link) {
-                inet_sroute_t *sroute = list_get_instance(link,
-                    inet_sroute_t, sroute_list);
-
+        uint32_t addr_addr;
+        int rc = inet_addr_pack(addr, &addr_addr);
+        if (rc != EOK)
+                return NULL;
+        
+        inet_sroute_t *best = NULL;
+        uint8_t best_bits = 0;
+        
+        fibril_mutex_lock(&sroute_list_lock);
+        
+        list_foreach(sroute_list, link) {
+                inet_sroute_t *sroute = list_get_instance(link,
+                    inet_sroute_t, sroute_list);
+                
+                uint32_t dest_addr;
+                uint8_t dest_bits;
+                rc = inet_naddr_pack(&sroute->dest, &dest_addr, &dest_bits);
+                if (rc != EOK)
+                        continue;
+                
                 /* Look for the most specific route */
-                if (best != NULL && best->dest.bits >= sroute->dest.bits)
+                if ((best != NULL) && (best_bits >= dest_bits))
                         continue;
-
-                mask = inet_netmask(sroute->dest.bits);
-                if ((sroute->dest.ipv4 & mask) == (addr->ipv4 & mask)) {
-                        fibril_mutex_unlock(&sroute_list_lock);
-                        log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_sroute_find: found %p",
+                
+                uint32_t mask = inet_netmask(dest_bits);
+                if ((dest_addr & mask) == (addr_addr & mask)) {
+                        log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_sroute_find: found candidate %p",
                             sroute);
-                        return sroute;
+                        
+                        best = sroute;
+                        best_bits = dest_bits;
                 }
         }
-
-        log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_sroute_find: Not found");
-        fibril_mutex_unlock(&sroute_list_lock);
-
-        return NULL;
+        
+        if (best == NULL)
+                log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_sroute_find: Not found");
+        
+        fibril_mutex_unlock(&sroute_list_lock);
+        
+        return best;
 }