Changeset 02a09ed in mainline for uspace/srv

Timestamp:

2013-06-28T20:20:03Z (12 years ago)

Author:

Martin Decky <martin@…>

Branches:

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

Children:

1d24ad3

Parents:

edf0d27

Message:

add basic infrastructure for IPv6 (inactive)
make inet_addr_t a universal address type

Location:

uspace/srv/net

Files:

• dnsrsrv/dnsrsrv.c (modified) (3 diffs)
• dnsrsrv/query.c (modified) (1 diff)
• dnsrsrv/transport.c (modified) (1 diff)
• ethip/arp.c (modified) (3 diffs)
• ethip/arp.h (modified) (1 diff)
• ethip/atrans.c (modified) (3 diffs)
• ethip/atrans.h (modified) (1 diff)
• ethip/ethip.c (modified) (7 diffs)
• ethip/ethip.h (modified) (5 diffs)
• ethip/ethip_nic.c (modified) (8 diffs)
• ethip/ethip_nic.h (modified) (2 diffs)
• ethip/pdu.c (modified) (6 diffs)
• ethip/pdu.h (modified) (1 diff)
• ethip/std.h (modified) (4 diffs)
• inetsrv/Makefile (modified) (1 diff)
• inetsrv/addrobj.c (modified) (4 diffs)
• inetsrv/icmp.c (modified) (3 diffs)
• inetsrv/inet_link.c (modified) (5 diffs)
• inetsrv/inet_util.c (deleted)
• inetsrv/inet_util.h (deleted)
• inetsrv/inetcfg.c (modified) (6 diffs)
• inetsrv/inetping.c (modified) (5 diffs)
• inetsrv/inetsrv.c (modified) (5 diffs)
• inetsrv/pdu.c (modified) (8 diffs)
• inetsrv/sroute.c (modified) (4 diffs)
• loopip/loopip.c (modified) (11 diffs)
• slip/slip.c (modified) (9 diffs)
• tcp/pdu.c (modified) (5 diffs)
• tcp/sock.c (modified) (13 diffs)
• tcp/std.h (modified) (2 diffs)
• tcp/tcp.c (modified) (2 diffs)
• tcp/tcp_type.h (modified) (1 diff)
• udp/pdu.c (modified) (3 diffs)
• udp/sock.c (modified) (13 diffs)

uspace/srv/net/dnsrsrv/dnsrsrv.c

@@ -84 +84 @@
 }
 
-static void dnsr_name2host_srv(dnsr_client_t *client, ipc_callid_t callid,
-    ipc_call_t *call)
-{
+static void dnsr_name2host_srv(dnsr_client_t *client, ipc_callid_t iid,
+    ipc_call_t *icall)
+{
+        log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_get_srvaddr_srv()");
+        
         char *name;
+        int rc = async_data_write_accept((void **) &name, true, 0,
+            DNS_NAME_MAX_SIZE, 0, NULL);
+        if (rc != EOK) {
+                async_answer_0(iid, rc);
+                return;
+        }
+        
         dns_host_info_t *hinfo;
-        ipc_callid_t rcallid;
-        size_t size;
-        sysarg_t retval;
-        size_t act_size;
-        int rc;
-
-        log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_get_srvaddr_srv()");
-
-        rc = async_data_write_accept((void **) &name, true, 0,
-            DNS_NAME_MAX_SIZE, 0, NULL);
-        if (rc != EOK) {
-                async_answer_0(callid, rc);
-                return;
-        }
-
-        if (!async_data_read_receive(&rcallid, &size)) {
-                async_answer_0(rcallid, EREFUSED);
-                async_answer_0(callid, EREFUSED);
-                return;
-        }
-
         rc = dns_name2host(name, &hinfo);
         if (rc != EOK) {
-                async_answer_0(rcallid, rc);
-                async_answer_0(callid, rc);
-                return;
-        }
-        
-        uint32_t addr;
-        rc = inet_addr_pack(&hinfo->addr, &addr);
-        if (rc != EOK) {
-                async_answer_0(rcallid, rc);
-                async_answer_0(callid, rc);
-                return;
-        }
-
-        act_size = str_size(hinfo->cname);
-        if (act_size > size) {
-                async_answer_0(rcallid, EOVERFLOW);
-                async_answer_0(callid, EOVERFLOW);
-                return;
-        }
-
-        retval = async_data_read_finalize(rcallid, hinfo->cname, act_size);
-        async_answer_1(callid, retval, (sysarg_t) addr);
-
-        dns_hostinfo_destroy(hinfo);
-}
-
-static void dnsr_get_srvaddr_srv(dnsr_client_t *client, ipc_callid_t iid,
-    ipc_call_t *icall)
-{
-        log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_get_srvaddr_srv()");
+                async_answer_0(iid, rc);
+                return;
+        }
         
         ipc_callid_t callid;
@@ -157 +118 @@
         }
         
+        rc = async_data_read_finalize(callid, &hinfo->addr, size);
+        if (rc != EOK) {
+                async_answer_0(callid, rc);
+                async_answer_0(iid, rc);
+                return;
+        }
+        
+        if (!async_data_read_receive(&callid, &size)) {
+                async_answer_0(callid, EREFUSED);
+                async_answer_0(iid, EREFUSED);
+                return;
+        }
+        
+        size_t act_size = str_size(hinfo->cname);
+        if (act_size > size) {
+                async_answer_0(callid, EINVAL);
+                async_answer_0(iid, EINVAL);
+                return;
+        }
+        
+        rc = async_data_read_finalize(callid, hinfo->cname, act_size);
+        if (rc != EOK)
+                async_answer_0(callid, rc);
+        
+        async_answer_0(iid, (sysarg_t) rc);
+        
+        dns_hostinfo_destroy(hinfo);
+}
+
+static void dnsr_get_srvaddr_srv(dnsr_client_t *client, ipc_callid_t iid,
+    ipc_call_t *icall)
+{
+        log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_get_srvaddr_srv()");
+        
+        ipc_callid_t callid;
+        size_t size;
+        if (!async_data_read_receive(&callid, &size)) {
+                async_answer_0(callid, EREFUSED);
+                async_answer_0(iid, EREFUSED);
+                return;
+        }
+        
+        if (size != sizeof(inet_addr_t)) {
+                async_answer_0(callid, EINVAL);
+                async_answer_0(iid, EINVAL);
+                return;
+        }
+        
         // FIXME locking
         
-        sysarg_t retval =
-            async_data_read_finalize(callid, &dns_server_addr, size);
-        async_answer_0(iid, retval);
+        int rc = async_data_read_finalize(callid, &dns_server_addr, size);
+        if (rc != EOK)
+                async_answer_0(callid, rc);
+        
+        async_answer_0(iid, rc);
 }
 
@@ -185 +196 @@
         // FIXME locking
         
-        sysarg_t retval =
-            async_data_write_finalize(callid, &dns_server_addr, size);
-        async_answer_0(iid, retval);
+        int rc = async_data_write_finalize(callid, &dns_server_addr, size);
+        if (rc != EOK)
+                async_answer_0(callid, rc);
+        
+        async_answer_0(iid, (sysarg_t) rc);
 }
 

uspace/srv/net/dnsrsrv/query.c

@@ -128 +128 @@
 
                         info->cname = str_dup(rr->name);
-                        inet_addr_unpack(dns_uint32_t_decode(rr->rdata, rr->rdata_size),
+                        inet_addr_set(dns_uint32_t_decode(rr->rdata, rr->rdata_size),
                             &info->addr);
                         

uspace/srv/net/dnsrsrv/transport.c

@@ -183 +183 @@
 int dns_request(dns_message_t *req, dns_message_t **rresp)
 {
-        int rc;
+        trans_req_t *treq = NULL;
+        
         void *req_data;
         size_t req_size;
+        int rc = dns_message_encode(req, &req_data, &req_size);
+        if (rc != EOK)
+                goto error;
+        
         struct sockaddr_in addr;
-        trans_req_t *treq;
-        int ntry;
-
-        req_data = NULL;
-        treq = NULL;
-
-        addr.sin_family = AF_INET;
-        addr.sin_port = htons(DNS_SERVER_PORT);
-        inet_addr_sockaddr_in(&dns_server_addr, &addr);
-
-        rc = dns_message_encode(req, &req_data, &req_size);
-        if (rc != EOK)
-                goto error;
-
-        ntry = 0;
-
+        struct sockaddr_in6 addr6;
+        uint16_t af =
+            inet_addr_sockaddr_in(&dns_server_addr, &addr, &addr6);
+        
+        struct sockaddr *address;
+        socklen_t addrlen;
+        
+        switch (af) {
+        case AF_INET:
+                addr.sin_port = htons(DNS_SERVER_PORT);
+                address = (struct sockaddr *) &addr;
+                addrlen = sizeof(addr);
+                break;
+        case AF_INET6:
+                addr6.sin6_port = htons(DNS_SERVER_PORT);
+                address = (struct sockaddr *) &addr6;
+                addrlen = sizeof(addr6);
+                break;
+        default:
+                rc = EAFNOSUPPORT;
+                goto error;
+        }
+        
+        size_t ntry = 0;
+        
         while (ntry < REQ_RETRY_MAX) {
                 rc = sendto(transport_fd, req_data, req_size, 0,
-                    (struct sockaddr *) &addr, sizeof(addr));
+                    (struct sockaddr *) address, addrlen);
                 if (rc != EOK)
                         goto error;

uspace/srv/net/ethip/arp.c

@@ -38 +38 @@
 #include <io/log.h>
 #include <inet/iplink_srv.h>
+#include <inet/addr.h>
 #include <stdlib.h>
-
+#include <net/socket_codes.h>
 #include "arp.h"
 #include "atrans.h"
@@ -54 +55 @@
 void arp_received(ethip_nic_t *nic, eth_frame_t *frame)
 {
-        int rc;
+        log_msg(LOG_DEFAULT, LVL_DEBUG, "arp_received()");
+        
         arp_eth_packet_t packet;
-        arp_eth_packet_t reply;
-        ethip_link_addr_t *laddr;
-
-        log_msg(LOG_DEFAULT, LVL_DEBUG, "arp_received()");
-
-        rc = arp_pdu_decode(frame->data, frame->size, &packet);
+        int rc = arp_pdu_decode(frame->data, frame->size, &packet);
         if (rc != EOK)
                 return;
-
+        
         log_msg(LOG_DEFAULT, LVL_DEBUG, "ARP PDU decoded, opcode=%d, tpa=%x",
             packet.opcode, packet.target_proto_addr);
-
-        laddr = ethip_nic_addr_find(nic, packet.target_proto_addr);
-        if (laddr != NULL) {
-                log_msg(LOG_DEFAULT, LVL_DEBUG, "Request/reply to my address");
-
-                (void) atrans_add(packet.sender_proto_addr,
-                    &packet.sender_hw_addr);
-
-                if (packet.opcode == aop_request) {
-                        reply.opcode = aop_reply;
-                        reply.sender_hw_addr = nic->mac_addr;
-                        reply.sender_proto_addr = laddr->addr;
-                        reply.target_hw_addr = packet.sender_hw_addr;
-                        reply.target_proto_addr = packet.sender_proto_addr;
-
-                        arp_send_packet(nic, &reply);
-                }
+        
+        inet_addr_t addr;
+        inet_addr_set(packet.target_proto_addr, &addr);
+        
+        ethip_link_addr_t *laddr = ethip_nic_addr_find(nic, &addr);
+        if (laddr == NULL)
+                return;
+        
+        addr32_t laddr_v4;
+        uint16_t laddr_af = inet_addr_get(&laddr->addr, &laddr_v4, NULL);
+        if (laddr_af != AF_INET)
+                return;
+        
+        log_msg(LOG_DEFAULT, LVL_DEBUG, "Request/reply to my address");
+        
+        (void) atrans_add(packet.sender_proto_addr,
+            packet.sender_hw_addr);
+        
+        if (packet.opcode == aop_request) {
+                arp_eth_packet_t reply;
+                
+                reply.opcode = aop_reply;
+                addr48(nic->mac_addr, reply.sender_hw_addr);
+                reply.sender_proto_addr = laddr_v4;
+                addr48(packet.sender_hw_addr, reply.target_hw_addr);
+                reply.target_proto_addr = packet.sender_proto_addr;
+                
+                arp_send_packet(nic, &reply);
         }
 }
 
-int arp_translate(ethip_nic_t *nic, uint32_t src_addr, uint32_t ip_addr,
-    mac48_addr_t *mac_addr)
+int arp_translate(ethip_nic_t *nic, addr32_t src_addr, addr32_t ip_addr,
+    addr48_t mac_addr)
 {
-        int rc;
-        arp_eth_packet_t packet;
-
-        rc = atrans_lookup(ip_addr, mac_addr);
+        int rc = atrans_lookup(ip_addr, mac_addr);
         if (rc == EOK)
                 return EOK;
-
+        
+        arp_eth_packet_t packet;
+        
         packet.opcode = aop_request;
-        packet.sender_hw_addr = nic->mac_addr;
+        addr48(nic->mac_addr, packet.sender_hw_addr);
         packet.sender_proto_addr = src_addr;
-        packet.target_hw_addr.addr = MAC48_BROADCAST;
+        addr48(addr48_broadcast, packet.target_hw_addr);
         packet.target_proto_addr = ip_addr;
-
+        
         rc = arp_send_packet(nic, &packet);
         if (rc != EOK)
@@ -128 +135 @@
                 return rc;
 
-        frame.dest.addr = packet->target_hw_addr.addr;
-        frame.src.addr =  packet->sender_hw_addr.addr;
+        addr48(packet->target_hw_addr, frame.dest);
+        addr48(packet->sender_hw_addr, frame.src);
         frame.etype_len = ETYPE_ARP;
         frame.data = pdata;

uspace/srv/net/ethip/arp.h

@@ -39 +39 @@
 
 #include <inet/iplink_srv.h>
+#include <inet/addr.h>
 #include "ethip.h"
 
 extern void arp_received(ethip_nic_t *, eth_frame_t *);
-extern int arp_translate(ethip_nic_t *, uint32_t, uint32_t, mac48_addr_t *);
+extern int arp_translate(ethip_nic_t *, addr32_t, addr32_t, addr48_t);
 
 #endif

uspace/srv/net/ethip/atrans.c

@@ -62 +62 @@
 }
 
-int atrans_add(uint32_t ip_addr, mac48_addr_t *mac_addr)
+int atrans_add(uint32_t ip_addr, addr48_t mac_addr)
 {
         ethip_atrans_t *atrans;
@@ -72 +72 @@
 
         atrans->ip_addr = ip_addr;
-        atrans->mac_addr = *mac_addr;
+        addr48(mac_addr, atrans->mac_addr);
 
         fibril_mutex_lock(&atrans_list_lock);
@@ -106 +106 @@
 }
 
-int atrans_lookup(uint32_t ip_addr, mac48_addr_t *mac_addr)
+int atrans_lookup(uint32_t ip_addr, addr48_t mac_addr)
 {
-        ethip_atrans_t *atrans;
-
         fibril_mutex_lock(&atrans_list_lock);
-        atrans = atrans_find(ip_addr);
+        ethip_atrans_t *atrans = atrans_find(ip_addr);
         if (atrans == NULL) {
                 fibril_mutex_unlock(&atrans_list_lock);
                 return ENOENT;
         }
-
+        
         fibril_mutex_unlock(&atrans_list_lock);
-        *mac_addr = atrans->mac_addr;
+        addr48(atrans->mac_addr, mac_addr);
         return EOK;
 }

uspace/srv/net/ethip/atrans.h

@@ -39 +39 @@
 
 #include <inet/iplink_srv.h>
+#include <inet/addr.h>
 #include "ethip.h"
 
-extern int atrans_add(uint32_t, mac48_addr_t *);
+extern int atrans_add(uint32_t, addr48_t);
 extern int atrans_remove(uint32_t);
-extern int atrans_lookup(uint32_t, mac48_addr_t *);
+extern int atrans_lookup(uint32_t, addr48_t);
 extern int atrans_wait_timeout(suseconds_t);
 

uspace/srv/net/ethip/ethip.c

@@ -44 +44 @@
 #include <stdio.h>
 #include <stdlib.h>
-
+#include <net/socket_codes.h>
 #include "arp.h"
 #include "ethip.h"
@@ -55 +55 @@
 static int ethip_open(iplink_srv_t *srv);
 static int ethip_close(iplink_srv_t *srv);
-static int ethip_send(iplink_srv_t *srv, iplink_srv_sdu_t *sdu);
+static int ethip_send(iplink_srv_t *srv, iplink_sdu_t *sdu);
 static int ethip_get_mtu(iplink_srv_t *srv, size_t *mtu);
-static int ethip_addr_add(iplink_srv_t *srv, uint32_t addr);
-static int ethip_addr_remove(iplink_srv_t *srv, uint32_t addr);
+static int ethip_addr_add(iplink_srv_t *srv, inet_addr_t *addr);
+static int ethip_addr_remove(iplink_srv_t *srv, inet_addr_t *addr);
 
 static void ethip_client_conn(ipc_callid_t iid, ipc_call_t *icall, void *arg);
@@ -164 +164 @@
 }
 
-static int ethip_send(iplink_srv_t *srv, iplink_srv_sdu_t *sdu)
-{
-        ethip_nic_t *nic = (ethip_nic_t *)srv->arg;
+static int ethip_send(iplink_srv_t *srv, iplink_sdu_t *sdu)
+{
+        log_msg(LOG_DEFAULT, LVL_DEBUG, "ethip_send()");
+        
+        ethip_nic_t *nic = (ethip_nic_t *) srv->arg;
+        
+        addr32_t src_v4;
+        addr128_t src_v6;
+        uint16_t src_af = inet_addr_get(&sdu->src, &src_v4, &src_v6);
+        
+        addr32_t dest_v4;
+        addr128_t dest_v6;
+        uint16_t dest_af = inet_addr_get(&sdu->dest, &dest_v4, &dest_v6);
+        
+        if (src_af != dest_af)
+                return EINVAL;
+        
+        int rc;
         eth_frame_t frame;
+        
+        switch (src_af) {
+        case AF_INET:
+                rc = arp_translate(nic, src_v4, dest_v4, frame.dest);
+                if (rc != EOK) {
+                        log_msg(LOG_DEFAULT, LVL_WARN, "Failed to look up IPv4 address 0x%"
+                            PRIx32, dest_v4);
+                        return rc;
+                }
+                
+                addr48(nic->mac_addr, frame.src);
+                frame.etype_len = ETYPE_IP;
+                frame.data = sdu->data;
+                frame.size = sdu->size;
+                
+                break;
+        case AF_INET6:
+                // FIXME TODO
+                return ENOTSUP;
+        default:
+                return EINVAL;
+        }
+        
         void *data;
         size_t size;
-        mac48_addr_t dest_mac_addr;
-        int rc;
-
-        log_msg(LOG_DEFAULT, LVL_DEBUG, "ethip_send()");
-
-        rc = arp_translate(nic, sdu->lsrc, sdu->ldest, &dest_mac_addr);
-        if (rc != EOK) {
-                log_msg(LOG_DEFAULT, LVL_WARN, "Failed to look up IP address 0x%" PRIx32,
-                    sdu->ldest);
-                return rc;
-        }
-
-        frame.dest      = dest_mac_addr;
-        frame.src       = nic->mac_addr;
-        frame.etype_len = ETYPE_IP;
-        frame.data = sdu->data;
-        frame.size = sdu->size;
-
         rc = eth_pdu_encode(&frame, &data, &size);
         if (rc != EOK)
@@ -201 +221 @@
 {
         log_msg(LOG_DEFAULT, LVL_DEBUG, "ethip_received(): srv=%p", srv);
-        ethip_nic_t *nic = (ethip_nic_t *)srv->arg;
+        ethip_nic_t *nic = (ethip_nic_t *) srv->arg;
+        
+        log_msg(LOG_DEFAULT, LVL_DEBUG, " - eth_pdu_decode");
+        
         eth_frame_t frame;
-        iplink_srv_sdu_t sdu;
-        int rc;
-
-        log_msg(LOG_DEFAULT, LVL_DEBUG, "ethip_received()");
-
-        log_msg(LOG_DEFAULT, LVL_DEBUG, " - eth_pdu_decode");
-        rc = eth_pdu_decode(data, size, &frame);
+        int rc = eth_pdu_decode(data, size, &frame);
         if (rc != EOK) {
                 log_msg(LOG_DEFAULT, LVL_DEBUG, " - eth_pdu_decode failed");
                 return rc;
         }
-
+        
+        iplink_recv_sdu_t sdu;
+        
         switch (frame.etype_len) {
         case ETYPE_ARP:
@@ -221 +240 @@
         case ETYPE_IP:
                 log_msg(LOG_DEFAULT, LVL_DEBUG, " - construct SDU");
-                sdu.lsrc = 0;
-                sdu.ldest = 0;
                 sdu.data = frame.data;
                 sdu.size = frame.size;
                 log_msg(LOG_DEFAULT, LVL_DEBUG, " - call iplink_ev_recv");
-                rc = iplink_ev_recv(&nic->iplink, &sdu);
+                rc = iplink_ev_recv(&nic->iplink, &sdu, AF_INET);
                 break;
         default:
@@ -244 +261 @@
 }
 
-static int ethip_addr_add(iplink_srv_t *srv, uint32_t addr)
-{
-        log_msg(LOG_DEFAULT, LVL_DEBUG, "ethip_addr_add(0x%" PRIx32 ")", addr);
-        
+static int ethip_addr_add(iplink_srv_t *srv, inet_addr_t *addr)
+{
         ethip_nic_t *nic = (ethip_nic_t *) srv->arg;
         
@@ -253 +268 @@
 }
 
-static int ethip_addr_remove(iplink_srv_t *srv, uint32_t addr)
-{
-        log_msg(LOG_DEFAULT, LVL_DEBUG, "ethip_addr_remove(0x%" PRIx32 ")", addr);
-        
-        ethip_nic_t *nic = (ethip_nic_t *)srv->arg;
-        
-        return ethip_nic_addr_add(nic, addr);
+static int ethip_addr_remove(iplink_srv_t *srv, inet_addr_t *addr)
+{
+        ethip_nic_t *nic = (ethip_nic_t *) srv->arg;
+        
+        return ethip_nic_addr_remove(nic, addr);
 }
 

uspace/srv/net/ethip/ethip.h

@@ -41 +41 @@
 #include <async.h>
 #include <inet/iplink_srv.h>
+#include <inet/addr.h>
 #include <loc.h>
 #include <sys/types.h>
 
-#define MAC48_BROADCAST 0xffffffffffff
-
 typedef struct {
         link_t addr_list;
-        uint32_t addr;
+        inet_addr_t addr;
 } ethip_link_addr_t;
-
-/** IEEE MAC-48 identifier */
-typedef struct {
-        /** MAC Address (in lowest 48 bits) */
-        uint64_t addr;
-} mac48_addr_t;
 
 typedef struct ethip_nic {
@@ -67 +60 @@
 
         /** MAC address */
-        mac48_addr_t mac_addr;
+        addr48_t mac_addr;
         /** List of IP addresses configured on this link */
         list_t addr_list; /* of ethip_link_addr_t */
@@ -75 +68 @@
 typedef struct {
         /** Destination Address */
-        mac48_addr_t dest;
+        addr48_t dest;
         /** Source Address */
-        mac48_addr_t src;
+        addr48_t src;
         /** Ethertype or Length */
         uint16_t etype_len;
@@ -102 +95 @@
         arp_opcode_t opcode;
         /** Sender hardware address */
-        mac48_addr_t sender_hw_addr;
+        addr48_t sender_hw_addr;
         /** Sender protocol address */
         uint32_t sender_proto_addr;
         /** Target hardware address */
-        mac48_addr_t target_hw_addr;
+        addr48_t target_hw_addr;
         /** Target protocol address */
         uint32_t target_proto_addr;
@@ -115 +108 @@
         link_t atrans_list;
         uint32_t ip_addr;
-        mac48_addr_t mac_addr;
+        addr48_t mac_addr;
 } ethip_atrans_t;
 

uspace/srv/net/ethip/ethip_nic.c

@@ -121 +121 @@
 }
 
-static ethip_link_addr_t *ethip_nic_addr_new(uint32_t addr)
+static ethip_link_addr_t *ethip_nic_addr_new(inet_addr_t *addr)
 {
         ethip_link_addr_t *laddr = calloc(1, sizeof(ethip_link_addr_t));
@@ -131 +131 @@
         
         link_initialize(&laddr->addr_list);
-        laddr->addr = addr;
+        laddr->addr = *addr;
         
         return laddr;
@@ -193 +193 @@
                 goto error;
         }
-
-        mac48_decode(nic_address.address, &nic->mac_addr);
+        
+        addr48(nic_address.address, nic->mac_addr);
 
         rc = nic_set_state(nic->sess, NIC_STATE_ACTIVE);
@@ -203 +203 @@
         }
 
-        log_msg(LOG_DEFAULT, LVL_DEBUG, "Initialized IP link service, MAC = 0x%" PRIx64,
-            nic->mac_addr.addr);
+        log_msg(LOG_DEFAULT, LVL_DEBUG, "Initialized IP link service,");
 
         return EOK;
@@ -335 +334 @@
 }
 
-int ethip_nic_addr_add(ethip_nic_t *nic, uint32_t addr)
+int ethip_nic_addr_add(ethip_nic_t *nic, inet_addr_t *addr)
 {
         log_msg(LOG_DEFAULT, LVL_DEBUG, "ethip_nic_addr_add()");
@@ -347 +346 @@
 }
 
-int ethip_nic_addr_remove(ethip_nic_t *nic, uint32_t addr)
+int ethip_nic_addr_remove(ethip_nic_t *nic, inet_addr_t *addr)
 {
         log_msg(LOG_DEFAULT, LVL_DEBUG, "ethip_nic_addr_remove()");
@@ -361 +360 @@
 
 ethip_link_addr_t *ethip_nic_addr_find(ethip_nic_t *nic,
-    uint32_t addr)
+    inet_addr_t *addr)
 {
         log_msg(LOG_DEFAULT, LVL_DEBUG, "ethip_nic_addr_find()");
@@ -369 +368 @@
                     ethip_link_addr_t, addr_list);
                 
-                if (addr == laddr->addr)
+                if (inet_addr_compare(addr, &laddr->addr))
                         return laddr;
         }

uspace/srv/net/ethip/ethip_nic.h

@@ -39 +39 @@
 
 #include <ipc/loc.h>
+#include <inet/addr.h>
 #include "ethip.h"
 
@@ -44 +45 @@
 extern ethip_nic_t *ethip_nic_find_by_iplink_sid(service_id_t);
 extern int ethip_nic_send(ethip_nic_t *, void *, size_t);
-extern int ethip_nic_addr_add(ethip_nic_t *, uint32_t);
-extern int ethip_nic_addr_remove(ethip_nic_t *, uint32_t);
-extern ethip_link_addr_t *ethip_nic_addr_find(ethip_nic_t *, uint32_t);
+extern int ethip_nic_addr_add(ethip_nic_t *, inet_addr_t *);
+extern int ethip_nic_addr_remove(ethip_nic_t *, inet_addr_t *);
+extern ethip_link_addr_t *ethip_nic_addr_find(ethip_nic_t *, inet_addr_t *);
 
 #endif

uspace/srv/net/ethip/pdu.c

@@ -62 +62 @@
 
         hdr = (eth_header_t *)data;
-        mac48_encode(&frame->src, hdr->src);
-        mac48_encode(&frame->dest, hdr->dest);
+        addr48(frame->src, hdr->src);
+        addr48(frame->dest, hdr->dest);
         hdr->etype_len = host2uint16_t_be(frame->etype_len);
 
@@ -69 +69 @@
             frame->size);
 
-        log_msg(LOG_DEFAULT, LVL_DEBUG, "Encoding Ethernet frame "
-            "src=%" PRIx64 " dest=%" PRIx64 " etype=%x",
-            frame->src.addr, frame->dest.addr, frame->etype_len);
         log_msg(LOG_DEFAULT, LVL_DEBUG, "Encoded Ethernet frame (%zu bytes)", size);
 
@@ -98 +95 @@
                 return ENOMEM;
 
-        mac48_decode(hdr->src, &frame->src);
-        mac48_decode(hdr->dest, &frame->dest);
+        addr48(hdr->src, frame->src);
+        addr48(hdr->dest, frame->dest);
         frame->etype_len = uint16_t_be2host(hdr->etype_len);
 
@@ -105 +102 @@
             frame->size);
 
-        log_msg(LOG_DEFAULT, LVL_DEBUG, "Decoding Ethernet frame "
-            "src=%" PRIx64 " dest=%" PRIx64 " etype=%x",
-            frame->src.addr, frame->dest.addr, frame->etype_len);
         log_msg(LOG_DEFAULT, LVL_DEBUG, "Decoded Ethernet frame payload (%zu bytes)", frame->size);
 
         return EOK;
-}
-
-void mac48_encode(mac48_addr_t *addr, void *buf)
-{
-        uint64_t val;
-        uint8_t *bbuf = (uint8_t *)buf;
-        int i;
-
-        val = addr->addr;
-        for (i = 0; i < MAC48_BYTES; i++)
-                bbuf[i] = (val >> (8 * (MAC48_BYTES - i - 1))) & 0xff;
-}
-
-void mac48_decode(void *data, mac48_addr_t *addr)
-{
-        uint64_t val;
-        uint8_t *bdata = (uint8_t *)data;
-        int i;
-
-        val = 0;
-        for (i = 0; i < MAC48_BYTES; i++)
-                val |= (uint64_t)bdata[i] << (8 * (MAC48_BYTES - i - 1));
-
-        addr->addr = val;
 }
 
@@ -168 +138 @@
         pfmt->proto_addr_size = IPV4_ADDR_SIZE;
         pfmt->opcode = host2uint16_t_be(fopcode);
-        mac48_encode(&packet->sender_hw_addr, pfmt->sender_hw_addr);
+        addr48(packet->sender_hw_addr, pfmt->sender_hw_addr);
         pfmt->sender_proto_addr =
             host2uint32_t_be(packet->sender_proto_addr);
-        mac48_encode(&packet->target_hw_addr, pfmt->target_hw_addr);
+        addr48(packet->target_hw_addr, pfmt->target_hw_addr);
         pfmt->target_proto_addr =
             host2uint32_t_be(packet->target_proto_addr);
@@ -227 +197 @@
         }
 
-        mac48_decode(pfmt->sender_hw_addr, &packet->sender_hw_addr);
+        addr48(pfmt->sender_hw_addr, packet->sender_hw_addr);
         packet->sender_proto_addr =
             uint32_t_be2host(pfmt->sender_proto_addr);
-        mac48_decode(pfmt->target_hw_addr, &packet->target_hw_addr);
+        addr48(pfmt->target_hw_addr, packet->target_hw_addr);
         packet->target_proto_addr =
             uint32_t_be2host(pfmt->target_proto_addr);

uspace/srv/net/ethip/pdu.h

@@ -42 +42 @@
 extern int eth_pdu_encode(eth_frame_t *, void **, size_t *);
 extern int eth_pdu_decode(void *, size_t, eth_frame_t *);
-extern void mac48_encode(mac48_addr_t *, void *);
-extern void mac48_decode(void *, mac48_addr_t *);
 extern int arp_pdu_encode(arp_eth_packet_t *, void **, size_t *);
 extern int arp_pdu_decode(void *, size_t, arp_eth_packet_t *);

uspace/srv/net/ethip/std.h

@@ -39 +39 @@
 
 #include <sys/types.h>
+#include <inet/addr.h>
 
 #define ETH_ADDR_SIZE       6
@@ -47 +48 @@
 typedef struct {
         /** Destination Address */
-        uint8_t dest[ETH_ADDR_SIZE];
+        addr48_t dest;
         /** Source Address */
-        uint8_t src[ETH_ADDR_SIZE];
+        addr48_t src;
         /** Ethertype or Length */
         uint16_t etype_len;
@@ -67 +68 @@
         uint16_t opcode;
         /** Sender hardware address */
-        uint8_t sender_hw_addr[ETH_ADDR_SIZE];
+        addr48_t sender_hw_addr;
         /** Sender protocol address */
         uint32_t sender_proto_addr;
         /** Target hardware address */
-        uint8_t target_hw_addr[ETH_ADDR_SIZE];
+        addr48_t target_hw_addr;
         /** Target protocol address */
         uint32_t target_proto_addr;
@@ -87 +88 @@
 /** IP Ethertype */
 enum ether_type {
-        ETYPE_ARP = 0x0806,
-        ETYPE_IP  = 0x0800
+        ETYPE_ARP  = 0x0806,
+        ETYPE_IP   = 0x0800,
+        ETYPE_IPV6 = 0x86DD
 };
 

uspace/srv/net/inetsrv/Makefile

@@ -35 +35 @@
         inetsrv.c \
         inet_link.c \
-        inet_util.c \
         inetcfg.c \
         inetping.c \

uspace/srv/net/inetsrv/addrobj.c

@@ -42 +42 @@
 #include <stdlib.h>
 #include <str.h>
-
 #include "addrobj.h"
 #include "inetsrv.h"
 #include "inet_link.h"
-#include "inet_util.h"
 
 static inet_addrobj_t *inet_addrobj_find_by_name_locked(const char *, inet_link_t *);
@@ -106 +104 @@
 /** Find address object matching address @a addr.
  *
- * @param addr  Address
- * @oaram find  iaf_net to find network (using mask),
- *              iaf_addr to find local address (exact match)
+ * @param addr Address
+ * @oaram find iaf_net to find network (using mask),
+ *             iaf_addr to find local address (exact match)
+ *
  */
 inet_addrobj_t *inet_addrobj_find(inet_addr_t *addr, inet_addrobj_find_t find)
 {
-        uint32_t addr_addr;
-        int rc = inet_addr_pack(addr, &addr_addr);
-        if (rc != EOK)
-                return NULL;
-        
         fibril_mutex_lock(&addr_list_lock);
         
@@ -123 +117 @@
                     inet_addrobj_t, addr_list);
                 
-                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)) {
+                if (inet_naddr_compare_mask(&naddr->naddr, addr)) {
                         fibril_mutex_unlock(&addr_list_lock);
                         log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_addrobj_find: found %p",
@@ -227 +214 @@
         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,
+        return inet_link_send_dgram(addr->ilink, &lsrc_addr, ldest, dgram,
             proto, ttl, df);
 }

uspace/srv/net/inetsrv/icmp.c

@@ -40 +40 @@
 #include <mem.h>
 #include <stdlib.h>
-
+#include <net/socket_codes.h>
 #include "icmp.h"
 #include "icmp_std.h"
@@ -129 +129 @@
         inetping_sdu_t sdu;
         
-        int rc = inet_addr_pack(&dgram->src, &sdu.src);
-        if (rc != EOK)
-                return rc;
+        uint16_t family = inet_addr_get(&dgram->src, &sdu.src, NULL);
+        if (family != AF_INET)
+                return EINVAL;
         
-        rc = inet_addr_pack(&dgram->dest, &sdu.dest);
-        if (rc != EOK)
-                return rc;
+        family = inet_addr_get(&dgram->dest, &sdu.dest, NULL);
+        if (family != AF_INET)
+                return EINVAL;
         
         sdu.seq_no = uint16_t_be2host(reply->seq_no);
@@ -168 +168 @@
         inet_dgram_t dgram;
         
-        inet_addr_unpack(sdu->src, &dgram.src);
-        inet_addr_unpack(sdu->dest, &dgram.dest);
+        inet_addr_set(sdu->src, &dgram.src);
+        inet_addr_set(sdu->dest, &dgram.dest);
         
         dgram.tos = ICMP_TOS;

uspace/srv/net/inetsrv/inet_link.c

@@ -43 +43 @@
 #include <stdlib.h>
 #include <str.h>
-
+#include <net/socket_codes.h>
 #include "addrobj.h"
 #include "inetsrv.h"
@@ -49 +49 @@
 #include "pdu.h"
 
-static int inet_link_open(service_id_t sid);
-static int inet_iplink_recv(iplink_t *ilink, iplink_sdu_t *sdu);
+static int inet_link_open(service_id_t);
+static int inet_iplink_recv(iplink_t *, iplink_recv_sdu_t *, uint16_t);
 
 static iplink_ev_ops_t inet_iplink_ev_ops = {
@@ -59 +59 @@
 static FIBRIL_MUTEX_INITIALIZE(inet_discovery_lock);
 
-static int inet_iplink_recv(iplink_t *iplink, iplink_sdu_t *sdu)
-{
+static int inet_iplink_recv(iplink_t *iplink, iplink_recv_sdu_t *sdu, uint16_t af)
+{
+        log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_iplink_recv()");
+        
+        int rc;
         inet_packet_t packet;
-        int rc;
-
-        log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_iplink_recv()");
-        rc = inet_pdu_decode(sdu->data, sdu->size, &packet);
+        
+        switch (af) {
+        case AF_INET:
+                rc = inet_pdu_decode(sdu->data, sdu->size, &packet);
+                break;
+        case AF_INET6:
+                // FIXME TODO
+                return ENOTSUP;
+        default:
+                log_msg(LOG_DEFAULT, LVL_DEBUG, "invalid address family");
+                return EINVAL;
+        }
+        
         if (rc != EOK) {
                 log_msg(LOG_DEFAULT, LVL_DEBUG, "failed decoding PDU");
@@ -228 +240 @@
 
         return EOK;
-
+        
 error:
         if (ilink->iplink != NULL)
@@ -277 +289 @@
         
         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;
+        int rc;
+        
+        sdu.src = *lsrc;
+        sdu.dest = *ldest;
+        
         do {
+                /* Encode one fragment */
                 size_t roffs;
-                
-                /* Encode one fragment */
                 rc = inet_pdu_encode(&packet, offs, ilink->def_mtu, &sdu.data,
                     &sdu.size, &roffs);

uspace/srv/net/inetsrv/inetcfg.c

@@ -236 +236 @@
 }
 
-static void inetcfg_addr_create_static_srv(ipc_callid_t callid,
-    ipc_call_t *call)
-{
+static void inetcfg_addr_create_static_srv(ipc_callid_t iid,
+    ipc_call_t *icall)
+{
+        log_msg(LOG_DEFAULT, LVL_DEBUG, "inetcfg_addr_create_static_srv()");
+        
+        sysarg_t link_id = IPC_GET_ARG1(*icall);
+        
+        ipc_callid_t callid;
+        size_t size;
+        if (!async_data_write_receive(&callid, &size)) {
+                async_answer_0(callid, EINVAL);
+                async_answer_0(iid, EINVAL);
+                return;
+        }
+        
+        if (size != sizeof(inet_naddr_t)) {
+                async_answer_0(callid, EINVAL);
+                async_answer_0(iid, EINVAL);
+                return;
+        }
+        
+        inet_naddr_t naddr;
+        int rc = async_data_write_finalize(callid, &naddr, size);
+        if (rc != EOK) {
+                async_answer_0(callid, rc);
+                async_answer_0(iid, rc);
+                return;
+        }
+        
         char *name;
-        inet_naddr_t naddr;
-        sysarg_t link_id;
-        sysarg_t addr_id;
-        int rc;
-
-        log_msg(LOG_DEFAULT, LVL_DEBUG, "inetcfg_addr_create_static_srv()");
-
         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_unpack(IPC_GET_ARG1(*call), IPC_GET_ARG2(*call), &naddr);
-        link_id = IPC_GET_ARG3(*call);
-
-        addr_id = 0;
+                async_answer_0(iid, rc);
+                return;
+        }
+        
+        sysarg_t addr_id = 0;
         rc = inetcfg_addr_create_static(name, &naddr, link_id, &addr_id);
         free(name);
-        async_answer_1(callid, rc, addr_id);
+        async_answer_1(iid, rc, addr_id);
 }
 
@@ -276 +292 @@
 }
 
-static void inetcfg_addr_get_srv(ipc_callid_t callid, ipc_call_t *call)
+static void inetcfg_addr_get_srv(ipc_callid_t iid, ipc_call_t *icall)
 {
         log_msg(LOG_DEFAULT, LVL_DEBUG, "inetcfg_addr_get_srv()");
         
-        sysarg_t addr_id = IPC_GET_ARG1(*call);
+        sysarg_t addr_id = IPC_GET_ARG1(*icall);
         
         inet_addr_info_t ainfo;
@@ -288 +304 @@
         ainfo.name = NULL;
         
-        ipc_callid_t rcallid;
-        size_t max_size;
-        
-        if (!async_data_read_receive(&rcallid, &max_size)) {
-                async_answer_0(rcallid, EREFUSED);
-                async_answer_0(callid, EREFUSED);
-                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)));
+                async_answer_0(iid, rc);
+                return;
+        }
+        
+        ipc_callid_t callid;
+        size_t size;
+        if (!async_data_read_receive(&callid, &size)) {
+                async_answer_0(callid, EREFUSED);
+                async_answer_0(iid, EREFUSED);
+                return;
+        }
+        
+        if (size != sizeof(inet_naddr_t)) {
+                async_answer_0(callid, EINVAL);
+                async_answer_0(iid, EINVAL);
+                return;
+        }
+        
+        rc = async_data_read_finalize(callid, &ainfo.naddr, size);
+        if (rc != EOK) {
+                async_answer_0(callid, rc);
+                async_answer_0(iid, rc);
+                return;
+        }
+        
+        if (!async_data_read_receive(&callid, &size)) {
+                async_answer_0(callid, EREFUSED);
+                async_answer_0(iid, EREFUSED);
+                return;
+        }
+        
+        rc = async_data_read_finalize(callid, ainfo.name,
+            min(size, str_size(ainfo.name)));
         free(ainfo.name);
         
-        async_answer_3(callid, retval, (sysarg_t) naddr_addr,
-            (sysarg_t) naddr_bits, ainfo.ilink);
+        if (rc != EOK) {
+                async_answer_0(callid, rc);
+                async_answer_0(iid, rc);
+                return;
+        }
+        
+        async_answer_1(iid, (sysarg_t) rc, ainfo.ilink);
 }
 
@@ -477 +508 @@
 }
 
-static void inetcfg_sroute_create_srv(ipc_callid_t callid,
-    ipc_call_t *call)
+static void inetcfg_sroute_create_srv(ipc_callid_t iid,
+    ipc_call_t *icall)
 {
         log_msg(LOG_DEFAULT, LVL_DEBUG, "inetcfg_sroute_create_srv()");
+
+        ipc_callid_t callid;
+        size_t size;
+        if (!async_data_write_receive(&callid, &size)) {
+                async_answer_0(callid, EINVAL);
+                async_answer_0(iid, EINVAL);
+                return;
+        }
+        
+        if (size != sizeof(inet_naddr_t)) {
+                async_answer_0(callid, EINVAL);
+                async_answer_0(iid, EINVAL);
+                return;
+        }
+        
+        inet_naddr_t dest;
+        int rc = async_data_write_finalize(callid, &dest, size);
+        if (rc != EOK) {
+                async_answer_0(callid, rc);
+                async_answer_0(iid, rc);
+                return;
+        }
+        
+        if (!async_data_write_receive(&callid, &size)) {
+                async_answer_0(callid, EINVAL);
+                async_answer_0(iid, EINVAL);
+                return;
+        }
+        
+        if (size != sizeof(inet_addr_t)) {
+                async_answer_0(callid, EINVAL);
+                async_answer_0(iid, EINVAL);
+                return;
+        }
+        
+        inet_addr_t router;
+        rc = async_data_write_finalize(callid, &router, size);
+        if (rc != EOK) {
+                async_answer_0(callid, rc);
+                async_answer_0(iid, rc);
+                return;
+        }
         
         char *name;
-        int rc = async_data_write_accept((void **) &name, true, 0, LOC_NAME_MAXLEN,
+        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;
-        
-        inet_naddr_unpack(IPC_GET_ARG1(*call), IPC_GET_ARG2(*call), &dest);
-        inet_addr_unpack(IPC_GET_ARG3(*call), &router);
+                async_answer_0(iid, rc);
+                return;
+        }
         
         sysarg_t sroute_id = 0;
         rc = inetcfg_sroute_create(name, &dest, &router, &sroute_id);
         free(name);
-        async_answer_1(callid, rc, sroute_id);
+        async_answer_1(iid, rc, sroute_id);
 }
 
@@ -515 +582 @@
 }
 
-static void inetcfg_sroute_get_srv(ipc_callid_t callid, ipc_call_t *call)
+static void inetcfg_sroute_get_srv(ipc_callid_t iid, ipc_call_t *icall)
 {
         log_msg(LOG_DEFAULT, LVL_DEBUG, "inetcfg_sroute_get_srv()");
         
-        sysarg_t sroute_id = IPC_GET_ARG1(*call);
+        sysarg_t sroute_id = IPC_GET_ARG1(*icall);
         
         inet_sroute_info_t srinfo;
@@ -527 +594 @@
         srinfo.name = NULL;
         
-        ipc_callid_t rcallid;
-        size_t max_size;
-        if (!async_data_read_receive(&rcallid, &max_size)) {
-                async_answer_0(rcallid, EREFUSED);
-                async_answer_0(callid, EREFUSED);
-                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)));
+                async_answer_0(iid, rc);
+                return;
+        }
+        
+        ipc_callid_t callid;
+        size_t size;
+        if (!async_data_read_receive(&callid, &size)) {
+                async_answer_0(callid, EREFUSED);
+                async_answer_0(iid, EREFUSED);
+                return;
+        }
+        
+        if (size != sizeof(inet_naddr_t)) {
+                async_answer_0(callid, EINVAL);
+                async_answer_0(iid, EINVAL);
+                return;
+        }
+        
+        rc = async_data_read_finalize(callid, &srinfo.dest, size);
+        if (rc != EOK) {
+                async_answer_0(callid, rc);
+                async_answer_0(iid, rc);
+                return;
+        }
+        
+        if (!async_data_read_receive(&callid, &size)) {
+                async_answer_0(callid, EREFUSED);
+                async_answer_0(iid, EREFUSED);
+                return;
+        }
+        
+        if (size != sizeof(inet_addr_t)) {
+                async_answer_0(callid, EINVAL);
+                async_answer_0(iid, EINVAL);
+                return;
+        }
+        
+        rc = async_data_read_finalize(callid, &srinfo.router, size);
+        if (rc != EOK) {
+                async_answer_0(callid, rc);
+                async_answer_0(iid, rc);
+                return;
+        }
+        
+        if (!async_data_read_receive(&callid, &size)) {
+                async_answer_0(callid, EREFUSED);
+                async_answer_0(iid, EREFUSED);
+                return;
+        }
+        
+        rc = async_data_read_finalize(callid, srinfo.name,
+            min(size, str_size(srinfo.name)));
         free(srinfo.name);
         
-        async_answer_3(callid, retval, (sysarg_t) dest_addr,
-            (sysarg_t) dest_bits, (sysarg_t) router_addr);
+        async_answer_0(iid, (sysarg_t) rc);
 }
 

uspace/srv/net/inetsrv/inetping.c

@@ -43 +43 @@
 #include <stdlib.h>
 #include <sys/types.h>
-
+#include <net/socket_codes.h>
 #include "icmp.h"
 #include "icmp_std.h"
@@ -55 +55 @@
 static uint16_t inetping_ident = 0;
 
-static inetping_client_t *inetping_client_find(uint16_t);
-
 static int inetping_send(inetping_client_t *client, inetping_sdu_t *sdu)
 {
@@ -62 +60 @@
 }
 
-static int inetping_get_srcaddr(inetping_client_t *client, uint32_t remote,
-    uint32_t *local)
+static int inetping_get_srcaddr(inetping_client_t *client, addr32_t remote,
+    addr32_t *local)
 {
         inet_addr_t remote_addr;
-        inet_addr_unpack(remote, &remote_addr);
+        inet_addr_set(remote, &remote_addr);
         
         inet_addr_t local_addr;
@@ -73 +71 @@
                 return rc;
         
-        return inet_addr_pack(&local_addr, local);
+        uint16_t family = inet_addr_get(&local_addr, local, NULL);
+        if (family != AF_INET)
+                return EINVAL;
+        
+        return EOK;
+}
+
+static inetping_client_t *inetping_client_find(uint16_t ident)
+{
+        fibril_mutex_lock(&client_list_lock);
+        
+        list_foreach(client_list, link) {
+                inetping_client_t *client = list_get_instance(link,
+                    inetping_client_t, client_list);
+                
+                if (client->ident == ident) {
+                        fibril_mutex_unlock(&client_list_lock);
+                        return client;
+                }
+        }
+        
+        fibril_mutex_unlock(&client_list_lock);
+        return NULL;
 }
 
 int inetping_recv(uint16_t ident, inetping_sdu_t *sdu)
 {
-        inetping_client_t *client;
-        async_exch_t *exch;
-        ipc_call_t answer;
-
-        client = inetping_client_find(ident);
+        inetping_client_t *client = inetping_client_find(ident);
         if (client == NULL) {
                 log_msg(LOG_DEFAULT, LVL_DEBUG, "Unknown ICMP ident. Dropping.");
                 return ENOENT;
         }
-
-        exch = async_exchange_begin(client->sess);
-
+        
+        async_exch_t *exch = async_exchange_begin(client->sess);
+        
+        ipc_call_t 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);
         
@@ -170 +188 @@
 }
 
-static inetping_client_t *inetping_client_find(uint16_t ident)
-{
-        fibril_mutex_lock(&client_list_lock);
-
-        list_foreach(client_list, link) {
-                inetping_client_t *client = list_get_instance(link,
-                    inetping_client_t, client_list);
-
-                if (client->ident == ident) {
-                        fibril_mutex_unlock(&client_list_lock);
-                        return client;
-                }
-        }
-
-        fibril_mutex_unlock(&client_list_lock);
-        return NULL;
-}
-
 void inetping_conn(ipc_callid_t iid, ipc_call_t *icall, void *arg)
 {
-        inetping_client_t client;
-        int rc;
-
         log_msg(LOG_DEFAULT, LVL_DEBUG, "inetping_conn()");
-
+        
         /* Accept the connection */
         async_answer_0(iid, EOK);
-
-        rc = inetping_client_init(&client);
+        
+        inetping_client_t client;
+        int rc = inetping_client_init(&client);
         if (rc != EOK)
                 return;

uspace/srv/net/inetsrv/inetsrv.c

@@ -46 +46 @@
 #include <stdlib.h>
 #include <sys/types.h>
-
+#include <net/socket_codes.h>
 #include "addrobj.h"
 #include "icmp.h"
@@ -202 +202 @@
         log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_get_srcaddr_srv()");
         
+        addr32_t remote_v4 = IPC_GET_ARG1(*call);
+        uint8_t tos = IPC_GET_ARG2(*call);
+        
         inet_addr_t remote;
-        inet_addr_unpack(IPC_GET_ARG1(*call), &remote);
-        uint8_t tos = IPC_GET_ARG2(*call);
+        inet_addr_set(remote_v4, &remote);
         
         inet_addr_t local;
@@ -213 +215 @@
         }
         
-        uint32_t local_addr;
-        rc = inet_addr_pack(&local, &local_addr);
-        if (rc != EOK) {
-                async_answer_0(callid, rc);
+        addr32_t local_v4;
+        uint16_t family = inet_addr_get(&local, &local_v4, NULL);
+        if (family != AF_INET) {
+                async_answer_0(callid, EINVAL);
                 return;
         }
         
-        async_answer_1(callid, rc, (sysarg_t) local_addr);
+        async_answer_1(callid, rc, (sysarg_t) local_v4);
 }
 
@@ -228 +230 @@
         log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_send_srv()");
         
+        addr32_t src_v4 = IPC_GET_ARG1(*call);
+        addr32_t dest_v4 = IPC_GET_ARG2(*call);
+        
         inet_dgram_t dgram;
         
-        inet_addr_unpack(IPC_GET_ARG1(*call), &dgram.src);
-        inet_addr_unpack(IPC_GET_ARG2(*call), &dgram.dest);
+        inet_addr_set(src_v4, &dgram.src);
+        inet_addr_set(dest_v4, &dgram.dest);
         dgram.tos = IPC_GET_ARG3(*call);
         
@@ -371 +376 @@
 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, (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) {
+        aid_t req = async_send_1(exch, INET_EV_RECV, dgram->tos, &answer);
+        
+        int rc = async_data_write_start(exch, &dgram->src, sizeof(inet_addr_t));
+        if (rc != EOK) {
+                async_exchange_end(exch);
                 async_forget(req);
                 return rc;
         }
         
+        rc = async_data_write_start(exch, &dgram->dest, sizeof(inet_addr_t));
+        if (rc != EOK) {
+                async_exchange_end(exch);
+                async_forget(req);
+                return rc;
+        }
+        
+        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;
+        
+        return (int) retval;
 }
 

uspace/srv/net/inetsrv/pdu.c

@@ -44 +44 @@
 #include <mem.h>
 #include <stdlib.h>
-
+#include <net/socket_codes.h>
 #include "inetsrv.h"
 #include "inet_std.h"
@@ -106 +106 @@
     void **rdata, size_t *rsize, size_t *roffs)
 {
-        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;
+        addr32_t src_v4;
+        addr128_t src_v6;
+        uint16_t src_af = inet_addr_get(&packet->src, &src_v4, &src_v6);
+        
+        addr32_t dest_v4;
+        addr128_t dest_v6;
+        uint16_t dest_af = inet_addr_get(&packet->dest, &dest_v4, &dest_v6);
+        
+        if (src_af != dest_af)
+                return EINVAL;
         
         /* Upper bound for fragment offset field */
@@ -123 +124 @@
                 return ELIMIT;
         
-        size_t hdr_size = sizeof(ip_header_t);
+        size_t hdr_size;
+        
+        switch (src_af) {
+        case AF_INET:
+                hdr_size = sizeof(ip_header_t);
+                break;
+        case AF_INET6:
+                // FIXME TODO
+                assert(false);
+        default:
+                assert(false);
+        }
+        
         size_t data_offs = ROUND_UP(hdr_size, 4);
         
@@ -164 +177 @@
         
         /* Encode header fields */
-        ip_header_t *hdr = (ip_header_t *) data;
-        
-        hdr->ver_ihl = (4 << VI_VERSION_l) | (hdr_size / sizeof(uint32_t));
-        hdr->tos = packet->tos;
-        hdr->tot_len = host2uint16_t_be(size);
-        hdr->id = host2uint16_t_be(ident);
-        hdr->flags_foff = host2uint16_t_be(flags_foff);
-        hdr->ttl = packet->ttl;
-        hdr->proto = packet->proto;
-        hdr->chksum = 0;
-        hdr->src_addr = host2uint32_t_be(src_addr);
-        hdr->dest_addr = host2uint32_t_be(dest_addr);
-        
-        /* Compute checksum */
-        uint16_t chksum = inet_checksum_calc(INET_CHECKSUM_INIT, (void *) hdr,
-            hdr_size);
-        hdr->chksum = host2uint16_t_be(chksum);
+        ip_header_t *hdr;
+        
+        switch (src_af) {
+        case AF_INET:
+                hdr = (ip_header_t *) data;
+                
+                hdr->ver_ihl =
+                    (4 << VI_VERSION_l) | (hdr_size / sizeof(uint32_t));
+                hdr->tos = packet->tos;
+                hdr->tot_len = host2uint16_t_be(size);
+                hdr->id = host2uint16_t_be(ident);
+                hdr->flags_foff = host2uint16_t_be(flags_foff);
+                hdr->ttl = packet->ttl;
+                hdr->proto = packet->proto;
+                hdr->chksum = 0;
+                hdr->src_addr = host2uint32_t_be(src_v4);
+                hdr->dest_addr = host2uint32_t_be(dest_v4);
+                
+                /* Compute checksum */
+                uint16_t chksum = inet_checksum_calc(INET_CHECKSUM_INIT,
+                    (void *) hdr, hdr_size);
+                hdr->chksum = host2uint16_t_be(chksum);
+                
+                break;
+        case AF_INET6:
+                // FIXME TODO
+                return ENOTSUP;
+        default:
+                assert(false);
+        }
         
         /* Copy payload */
@@ -194 +220 @@
 int inet_pdu_decode(void *data, size_t size, inet_packet_t *packet)
 {
-        ip_header_t *hdr;
-        size_t tot_len;
-        size_t data_offs;
-        uint8_t version;
-        uint16_t ident;
-        uint16_t flags_foff;
-        uint16_t foff;
-
         log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_pdu_decode()");
         
@@ -208 +226 @@
                 return EINVAL;
         }
-
-        hdr = (ip_header_t *)data;
-
-        version = BIT_RANGE_EXTRACT(uint8_t, VI_VERSION_h, VI_VERSION_l,
-            hdr->ver_ihl);
+        
+        ip_header_t *hdr = (ip_header_t *) data;
+        
+        uint8_t version = BIT_RANGE_EXTRACT(uint8_t, VI_VERSION_h,
+            VI_VERSION_l, hdr->ver_ihl);
         if (version != 4) {
                 log_msg(LOG_DEFAULT, LVL_DEBUG, "Version (%d) != 4", version);
                 return EINVAL;
         }
-
-        tot_len = uint16_t_be2host(hdr->tot_len);
+        
+        size_t tot_len = uint16_t_be2host(hdr->tot_len);
         if (tot_len < sizeof(ip_header_t)) {
                 log_msg(LOG_DEFAULT, LVL_DEBUG, "Total Length too small (%zu)", tot_len);
@@ -229 +247 @@
                 return EINVAL;
         }
-
-        ident = uint16_t_be2host(hdr->id);
-        flags_foff = uint16_t_be2host(hdr->flags_foff);
-        foff = BIT_RANGE_EXTRACT(uint16_t, FF_FRAGOFF_h, FF_FRAGOFF_l,
+        
+        uint16_t ident = uint16_t_be2host(hdr->id);
+        uint16_t flags_foff = uint16_t_be2host(hdr->flags_foff);
+        uint16_t foff = BIT_RANGE_EXTRACT(uint16_t, FF_FRAGOFF_h, FF_FRAGOFF_l,
             flags_foff);
         /* XXX Checksum */
-
-        inet_addr_unpack(uint32_t_be2host(hdr->src_addr), &packet->src);
-        inet_addr_unpack(uint32_t_be2host(hdr->dest_addr), &packet->dest);
+        
+        inet_addr_set(uint32_t_be2host(hdr->src_addr), &packet->src);
+        inet_addr_set(uint32_t_be2host(hdr->dest_addr), &packet->dest);
         packet->tos = hdr->tos;
         packet->proto = hdr->proto;
@@ -248 +266 @@
         
         /* XXX IP options */
-        data_offs = sizeof(uint32_t) * BIT_RANGE_EXTRACT(uint8_t, VI_IHL_h,
-            VI_IHL_l, hdr->ver_ihl);
-
+        size_t data_offs = sizeof(uint32_t) *
+            BIT_RANGE_EXTRACT(uint8_t, VI_IHL_h, VI_IHL_l, hdr->ver_ihl);
+        
         packet->size = tot_len - data_offs;
         packet->data = calloc(packet->size, 1);

uspace/srv/net/inetsrv/sroute.c

@@ -42 +42 @@
 #include <stdlib.h>
 #include <str.h>
-
 #include "sroute.h"
 #include "inetsrv.h"
 #include "inet_link.h"
-#include "inet_util.h"
 
 static FIBRIL_MUTEX_INITIALIZE(sroute_list_lock);
@@ -97 +95 @@
 inet_sroute_t *inet_sroute_find(inet_addr_t *addr)
 {
-        uint32_t addr_addr;
-        int rc = inet_addr_pack(addr, &addr_addr);
-        if (rc != EOK)
-                return NULL;
+        uint16_t addr_af = inet_addr_get(addr, NULL, NULL);
         
         inet_sroute_t *best = NULL;
@@ -111 +106 @@
                     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)
+                uint16_t dest_af = inet_naddr_get(&sroute->dest, NULL, NULL,
+                    &dest_bits);
+                
+                /* Skip comparison with different address family */
+                if (addr_af != dest_af)
                         continue;
                 
@@ -121 +118 @@
                         continue;
                 
-                uint32_t mask = inet_netmask(dest_bits);
-                if ((dest_addr & mask) == (addr_addr & mask)) {
+                if (inet_naddr_compare_mask(&sroute->dest, addr)) {
                         log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_sroute_find: found candidate %p",
                             sroute);

uspace/srv/net/loopip/loopip.c

@@ -39 +39 @@
 #include <errno.h>
 #include <inet/iplink_srv.h>
+#include <inet/addr.h>
 #include <io/log.h>
 #include <loc.h>
@@ -48 +49 @@
 static int loopip_open(iplink_srv_t *srv);
 static int loopip_close(iplink_srv_t *srv);
-static int loopip_send(iplink_srv_t *srv, iplink_srv_sdu_t *sdu);
+static int loopip_send(iplink_srv_t *srv, iplink_sdu_t *sdu);
 static int loopip_get_mtu(iplink_srv_t *srv, size_t *mtu);
-static int loopip_addr_add(iplink_srv_t *srv, uint32_t addr);
-static int loopip_addr_remove(iplink_srv_t *srv, uint32_t addr);
+static int loopip_addr_add(iplink_srv_t *srv, inet_addr_t *addr);
+static int loopip_addr_remove(iplink_srv_t *srv, inet_addr_t *addr);
 
 static void loopip_client_conn(ipc_callid_t iid, ipc_call_t *icall, void *arg);
@@ -69 +70 @@
 typedef struct {
         link_t link;
-        iplink_srv_sdu_t sdu;
+        
+        uint16_t af;
+        iplink_recv_sdu_t sdu;
 } rqueue_entry_t;
 
@@ -77 +80 @@
                 log_msg(LOG_DEFAULT, LVL_DEBUG, "loopip_recv_fibril(): Wait for one item");
                 link_t *link = prodcons_consume(&loopip_rcv_queue);
-                rqueue_entry_t *rqe = list_get_instance(link, rqueue_entry_t, link);
-
-                (void) iplink_ev_recv(&loopip_iplink, &rqe->sdu);
+                rqueue_entry_t *rqe =
+                    list_get_instance(link, rqueue_entry_t, link);
+                
+                (void) iplink_ev_recv(&loopip_iplink, &rqe->sdu, rqe->af);
+                
+                free(rqe->sdu.data);
+                free(rqe);
         }
         
@@ -87 +94 @@
 static int loopip_init(void)
 {
-        int rc;
-        service_id_t sid;
-        category_id_t iplink_cat;
-        const char *svc_name = "net/loopback";
-        
         async_set_client_connection(loopip_client_conn);
         
-        rc = loc_server_register(NAME);
+        int rc = loc_server_register(NAME);
         if (rc != EOK) {
                 log_msg(LOG_DEFAULT, LVL_ERROR, "Failed registering server.");
@@ -105 +107 @@
         
         prodcons_initialize(&loopip_rcv_queue);
-
+        
+        const char *svc_name = "net/loopback";
+        service_id_t sid;
         rc = loc_service_register(svc_name, &sid);
         if (rc != EOK) {
-                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed registering service %s.", svc_name);
-                return rc;
-        }
-
+                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed registering service %s.",
+                    svc_name);
+                return rc;
+        }
+        
+        category_id_t iplink_cat;
         rc = loc_category_get_id("iplink", &iplink_cat, IPC_FLAG_BLOCKING);
         if (rc != EOK) {
@@ -120 +126 @@
         rc = loc_service_add_to_cat(sid, iplink_cat);
         if (rc != EOK) {
-                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed adding %s to category.", svc_name);
+                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed adding %s to category.",
+                    svc_name);
                 return rc;
         }
@@ -151 +158 @@
 }
 
-static int loopip_send(iplink_srv_t *srv, iplink_srv_sdu_t *sdu)
-{
-        rqueue_entry_t *rqe;
-
+static int loopip_send(iplink_srv_t *srv, iplink_sdu_t *sdu)
+{
         log_msg(LOG_DEFAULT, LVL_DEBUG, "loopip_send()");
-
-        rqe = calloc(1, sizeof(rqueue_entry_t));
+        
+        addr32_t src_v4;
+        addr128_t src_v6;
+        uint16_t src_af = inet_addr_get(&sdu->src, &src_v4, &src_v6);
+        
+        addr32_t dest_v4;
+        addr128_t dest_v6;
+        uint16_t dest_af = inet_addr_get(&sdu->dest, &dest_v4, &dest_v6);
+        
+        if (src_af != dest_af)
+                return EINVAL;
+        
+        rqueue_entry_t *rqe = calloc(1, sizeof(rqueue_entry_t));
         if (rqe == NULL)
                 return ENOMEM;
@@ -164 +180 @@
          * Clone SDU
          */
-        rqe->sdu.lsrc = sdu->ldest;
-        rqe->sdu.ldest = sdu->lsrc;
+        rqe->af = src_af;
         rqe->sdu.data = malloc(sdu->size);
         if (rqe->sdu.data == NULL) {
@@ -190 +205 @@
 }
 
-static int loopip_addr_add(iplink_srv_t *srv, uint32_t addr)
-{
-        log_msg(LOG_DEFAULT, LVL_DEBUG, "loopip_addr_add(0x%" PRIx32 ")", addr);
-        return EOK;
-}
-
-static int loopip_addr_remove(iplink_srv_t *srv, uint32_t addr)
-{
-        log_msg(LOG_DEFAULT, LVL_DEBUG, "loopip_addr_remove(0x%" PRIx32 ")", addr);
+static int loopip_addr_add(iplink_srv_t *srv, inet_addr_t *addr)
+{
+        return EOK;
+}
+
+static int loopip_addr_remove(iplink_srv_t *srv, inet_addr_t *addr)
+{
         return EOK;
 }
@@ -204 +217 @@
 int main(int argc, char *argv[])
 {
-        int rc;
-
-        printf(NAME ": HelenOS loopback IP link provider\n");
-
-        if (log_init(NAME) != EOK) {
-                printf(NAME ": Failed to initialize logging.\n");
-                return 1;
+        printf("%s: HelenOS loopback IP link provider\n", NAME);
+        
+        int rc = log_init(NAME);
+        if (rc != EOK) {
+                printf("%s: Failed to initialize logging.\n", NAME);
+                return rc;
         }
         
         rc = loopip_init();
         if (rc != EOK)
-                return 1;
-
-        printf(NAME ": Accepting connections.\n");
+                return rc;
+        
+        printf("%s: Accepting connections.\n", NAME);
         task_retval(0);
         async_manager();

uspace/srv/net/slip/slip.c

@@ -38 +38 @@
 #include <stdint.h>
 #include <loc.h>
+#include <net/socket_codes.h>
+#include <inet/addr.h>
 #include <inet/iplink_srv.h>
 #include <device/char_dev.h>
@@ -50 +52 @@
 #define SLIP_END        0300
 #define SLIP_ESC        0333
-#define SLIP_ESC_END    0334
+#define SLIP_ESC_END    0334
 #define SLIP_ESC_ESC    0335
 
 static int slip_open(iplink_srv_t *);
 static int slip_close(iplink_srv_t *);
-static int slip_send(iplink_srv_t *, iplink_srv_sdu_t *);
+static int slip_send(iplink_srv_t *, iplink_sdu_t *);
 static int slip_get_mtu(iplink_srv_t *, size_t *);
-static int slip_addr_add(iplink_srv_t *, uint32_t);
-static int slip_addr_remove(iplink_srv_t *, uint32_t);
+static int slip_addr_add(iplink_srv_t *, inet_addr_t *);
+static int slip_addr_remove(iplink_srv_t *, inet_addr_t *);
 
 static iplink_srv_t slip_iplink;
@@ -118 +120 @@
 }
 
-int slip_send(iplink_srv_t *srv, iplink_srv_sdu_t *sdu)
+int slip_send(iplink_srv_t *srv, iplink_sdu_t *sdu)
 {
         async_sess_t *sess = (async_sess_t *) srv->arg;
@@ -137 +139 @@
                 case SLIP_END:
                         write_buffered(sess, SLIP_ESC);
-                        write_buffered(sess, SLIP_ESC_END);     
+                        write_buffered(sess, SLIP_ESC_END);
                         break;
                 case SLIP_ESC:
@@ -161 +163 @@
 }
 
-int slip_addr_add(iplink_srv_t *srv, uint32_t addr)
+int slip_addr_add(iplink_srv_t *srv, inet_addr_t *addr)
 {
         log_msg(LOG_DEFAULT, LVL_DEBUG, "slip_addr_add()");
@@ -167 +169 @@
 }
 
-int slip_addr_remove(iplink_srv_t *srv, uint32_t addr)
+int slip_addr_remove(iplink_srv_t *srv, inet_addr_t *addr)
 {
         log_msg(LOG_DEFAULT, LVL_DEBUG, "slip_addr_remove()");
@@ -207 +209 @@
         async_sess_t *sess = (async_sess_t *) arg;
         static uint8_t recv_final[SLIP_MTU];
-        iplink_srv_sdu_t sdu;
+        iplink_recv_sdu_t sdu;
         uint8_t ch;
         int rc;
 
-        sdu.lsrc = 0;
-        sdu.ldest = 0;
         sdu.data = recv_final;
 
@@ -222 +222 @@
                                 if (sdu.size == 0) {
                                         /*
-                                         * Discard the empty SLIP datagram.
-                                         */
+                                         * Discard the empty SLIP datagram.
+                                         */
                                         break;
                                 }
@@ -260 +260 @@
 
 pass:
-                rc = iplink_ev_recv(&slip_iplink, &sdu);
+                rc = iplink_ev_recv(&slip_iplink, &sdu, AF_INET);
                 if (rc != EOK) {
                         log_msg(LOG_DEFAULT, LVL_ERROR,

uspace/srv/net/tcp/pdu.c

@@ -40 +40 @@
 #include <mem.h>
 #include <stdlib.h>
+#include <net/socket_codes.h>
 #include "pdu.h"
 #include "segment.h"
@@ -144 +145 @@
 }
 
-static void tcp_phdr_setup(tcp_pdu_t *pdu, tcp_phdr_t *phdr)
-{
-        // FIXME: Check for correctness
-        
-        uint32_t src_addr;
-        inet_addr_pack(&pdu->src_addr, &src_addr);
-        
-        uint32_t dest_addr;
-        inet_addr_pack(&pdu->dest_addr, &dest_addr);
-        
-        phdr->src_addr = host2uint32_t_be(src_addr);
-        phdr->dest_addr = host2uint32_t_be(dest_addr);
-        phdr->zero = 0;
-        phdr->protocol = 6; /* XXX Magic number */
-        phdr->tcp_length = host2uint16_t_be(pdu->header_size + pdu->text_size);
+static uint16_t tcp_phdr_setup(tcp_pdu_t *pdu, tcp_phdr_t *phdr)
+{
+        addr32_t src_v4;
+        addr128_t src_v6;
+        uint16_t src_af = inet_addr_get(&pdu->src, &src_v4, &src_v6);
+        
+        addr32_t dest_v4;
+        addr128_t dest_v6;
+        uint16_t dest_af = inet_addr_get(&pdu->dest, &dest_v4, &dest_v6);
+        
+        assert(src_af == dest_af);
+        
+        switch (src_af) {
+        case AF_INET:
+                phdr->src = host2uint32_t_be(src_v4);
+                phdr->dest = host2uint32_t_be(dest_v4);
+                phdr->zero = 0;
+                phdr->protocol = IP_PROTO_TCP;
+                phdr->tcp_length =
+                    host2uint16_t_be(pdu->header_size + pdu->text_size);
+                break;
+        case AF_INET6:
+                // FIXME TODO
+                assert(false);
+        default:
+                assert(false);
+        }
+        
+        return src_af;
 }
 
@@ -243 +258 @@
         uint16_t cs_phdr;
         uint16_t cs_headers;
-        uint16_t cs_all;
         tcp_phdr_t phdr;
-
-        tcp_phdr_setup(pdu, &phdr);
-        cs_phdr = tcp_checksum_calc(TCP_CHECKSUM_INIT, (void *)&phdr,
-            sizeof(tcp_phdr_t));
+        
+        uint16_t af = tcp_phdr_setup(pdu, &phdr);
+        switch (af) {
+        case AF_INET:
+                cs_phdr = tcp_checksum_calc(TCP_CHECKSUM_INIT, (void *) &phdr,
+                    sizeof(tcp_phdr_t));
+                break;
+        case AF_INET6:
+                // FIXME TODO
+                assert(false);
+        default:
+                assert(false);
+        }
+        
         cs_headers = tcp_checksum_calc(cs_phdr, pdu->header, pdu->header_size);
-        cs_all = tcp_checksum_calc(cs_headers, pdu->text, pdu->text_size);
-
-        return cs_all;
+        return tcp_checksum_calc(cs_headers, pdu->text, pdu->text_size);
 }
 
@@ -279 +301 @@
 
         sp->local.port = uint16_t_be2host(hdr->dest_port);
-        sp->local.addr = pdu->dest_addr;
+        sp->local.addr = pdu->dest;
         sp->foreign.port = uint16_t_be2host(hdr->src_port);
-        sp->foreign.addr = pdu->src_addr;
+        sp->foreign.addr = pdu->src;
 
         *seg = nseg;
@@ -298 +320 @@
                 return ENOMEM;
 
-        npdu->src_addr = sp->local.addr;
-        npdu->dest_addr = sp->foreign.addr;
+        npdu->src = sp->local.addr;
+        npdu->dest = sp->foreign.addr;
         tcp_header_encode(sp, seg, &npdu->header, &npdu->header_size);
 

uspace/srv/net/tcp/sock.c

@@ -354 +354 @@
 }
 
-static void tcp_sock_connect(tcp_client_t *client, ipc_callid_t callid, ipc_call_t call)
-{
-        int rc;
-        struct sockaddr_in *addr;
-        int socket_id;
+static void tcp_sock_connect(tcp_client_t *client, ipc_callid_t callid,
+    ipc_call_t call)
+{
+        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_connect()");
+        
+        struct sockaddr_in6 *addr6 = NULL;
         size_t addr_len;
-        socket_core_t *sock_core;
-        tcp_sockdata_t *socket;
-        tcp_error_t trc;
-        tcp_sock_t lsocket;
-        tcp_sock_t fsocket;
-
-        log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_connect()");
-
-        rc = async_data_write_accept((void **) &addr, false, 0, 0, 0, &addr_len);
-        if (rc != EOK || addr_len != sizeof(struct sockaddr_in)) {
+        int rc = async_data_write_accept((void **) &addr6, false, 0, 0, 0, &addr_len);
+        if (rc != EOK) {
                 async_answer_0(callid, rc);
                 return;
         }
-
-        socket_id = SOCKET_GET_SOCKET_ID(call);
-
-        sock_core = socket_cores_find(&client->sockets, socket_id);
+        
+        if ((addr_len != sizeof(struct sockaddr_in)) &&
+            (addr_len != sizeof(struct sockaddr_in6))) {
+                async_answer_0(callid, EINVAL);
+                goto out;
+        }
+        
+        struct sockaddr_in *addr = (struct sockaddr_in *) addr6;
+        
+        int socket_id = SOCKET_GET_SOCKET_ID(call);
+        socket_core_t *sock_core = socket_cores_find(&client->sockets,
+            socket_id);
         if (sock_core == NULL) {
                 async_answer_0(callid, ENOTSOCK);
-                return;
-        }
-
-        socket = (tcp_sockdata_t *)sock_core->specific_data;
+                goto out;
+        }
+        
+        tcp_sockdata_t *socket =
+            (tcp_sockdata_t *) sock_core->specific_data;
+        
         if (sock_core->port <= 0) {
                 rc = socket_bind_free_port(&gsock, sock_core,
@@ -389 +392 @@
                 if (rc != EOK) {
                         async_answer_0(callid, rc);
-                        return;
+                        goto out;
                 }
                 
                 last_used_port = sock_core->port;
         }
-
+        
         fibril_mutex_lock(&socket->lock);
-
+        
         if (inet_addr_is_any(&socket->laddr)) {
                 /* Determine local IP address */
@@ -402 +405 @@
                 inet_addr_t rem_addr;
                 
-                inet_addr_unpack(uint32_t_be2host(addr->sin_addr.s_addr),
-                    &rem_addr);
+                switch (addr->sin_family) {
+                case AF_INET:
+                        inet_sockaddr_in_addr(addr, &rem_addr);
+                        break;
+                case AF_INET6:
+                        inet_sockaddr_in6_addr(addr6, &rem_addr);
+                        break;
+                default:
+                        fibril_mutex_unlock(&socket->lock);
+                        async_answer_0(callid, EINVAL);
+                        goto out;
+                }
+                
                 rc = inet_get_srcaddr(&rem_addr, 0, &loc_addr);
                 if (rc != EOK) {
@@ -410 +424 @@
                         log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_connect: Failed to "
                             "determine local address.");
-                        return;
+                        goto out;
                 }
                 
@@ -416 +430 @@
         }
         
+        tcp_sock_t lsocket;
+        tcp_sock_t fsocket;
+        
         lsocket.addr = socket->laddr;
         lsocket.port = sock_core->port;
         
-        inet_addr_unpack(uint32_t_be2host(addr->sin_addr.s_addr),
-            &fsocket.addr);
+        switch (addr->sin_family) {
+        case AF_INET:
+                inet_sockaddr_in_addr(addr, &fsocket.addr);
+                break;
+        case AF_INET6:
+                inet_sockaddr_in6_addr(addr6, &fsocket.addr);
+                break;
+        default:
+                fibril_mutex_unlock(&socket->lock);
+                async_answer_0(callid, EINVAL);
+                goto out;
+        }
+        
         fsocket.port = uint16_t_be2host(addr->sin_port);
-
-        trc = tcp_uc_open(&lsocket, &fsocket, ap_active, 0, &socket->conn);
-
+        
+        tcp_error_t trc = tcp_uc_open(&lsocket, &fsocket, ap_active, 0,
+            &socket->conn);
+        
         if (socket->conn != NULL)
-                socket->conn->name = (char *)"C";
-
+                socket->conn->name = (char *) "C";
+        
         fibril_mutex_unlock(&socket->lock);
         
@@ -445 +474 @@
         
         async_answer_0(callid, rc);
+        
+out:
+        if (addr6 != NULL)
+                free(addr6);
 }
 
@@ -662 +695 @@
 static void tcp_sock_recvfrom(tcp_client_t *client, ipc_callid_t callid, ipc_call_t call)
 {
-        int socket_id;
-        int flags;
-        size_t addr_length, length;
-        socket_core_t *sock_core;
-        tcp_sockdata_t *socket;
-        ipc_call_t answer;
-        ipc_callid_t rcallid;
-        size_t data_len;
-        struct sockaddr_in addr;
-        tcp_sock_t *rsock;
-        int rc;
-
         log_msg(LOG_DEFAULT, LVL_DEBUG, "%p: tcp_sock_recv[from]()", client);
-
-        socket_id = SOCKET_GET_SOCKET_ID(call);
-        flags = SOCKET_GET_FLAGS(call);
-
-        sock_core = socket_cores_find(&client->sockets, socket_id);
+        
+        int socket_id = SOCKET_GET_SOCKET_ID(call);
+        
+        socket_core_t *sock_core =
+            socket_cores_find(&client->sockets, socket_id);
         if (sock_core == NULL) {
                 async_answer_0(callid, ENOTSOCK);
                 return;
         }
-
-        socket = (tcp_sockdata_t *)sock_core->specific_data;
+        
+        tcp_sockdata_t *socket =
+            (tcp_sockdata_t *) sock_core->specific_data;
+        
         fibril_mutex_lock(&socket->lock);
         
@@ -693 +716 @@
                 return;
         }
-
-        (void)flags;
-
+        
         log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_recvfrom(): lock recv_buffer_lock");
+        
         fibril_mutex_lock(&socket->recv_buffer_lock);
-        while (socket->recv_buffer_used == 0 && socket->recv_error == TCP_EOK) {
+        while ((socket->recv_buffer_used == 0) &&
+            (socket->recv_error == TCP_EOK)) {
                 log_msg(LOG_DEFAULT, LVL_DEBUG, "wait for recv_buffer_cv + recv_buffer_used != 0");
                 fibril_condvar_wait(&socket->recv_buffer_cv,
@@ -705 +728 @@
         
         log_msg(LOG_DEFAULT, LVL_DEBUG, "Got data in sock recv_buffer");
-
-        data_len = socket->recv_buffer_used;
-        rc = socket->recv_error;
-
-        switch (socket->recv_error) {
+        
+        size_t data_len = socket->recv_buffer_used;
+        tcp_error_t trc = socket->recv_error;
+        int rc;
+        
+        switch (trc) {
         case TCP_EOK:
                 rc = EOK;
@@ -732 +756 @@
                 return;
         }
-
+        
+        ipc_callid_t rcallid;
+        
         if (IPC_GET_IMETHOD(call) == NET_SOCKET_RECVFROM) {
                 /* Fill address */
-                rsock = &socket->conn->ident.foreign;
+                tcp_sock_t *rsock = &socket->conn->ident.foreign;
+                struct sockaddr_in addr;
+                struct sockaddr_in6 addr6;
+                size_t addr_length;
                 
-                uint32_t rsock_addr;
-                int rc = inet_addr_pack(&rsock->addr, &rsock_addr);
-                if (rc != EOK) {
-                        fibril_mutex_unlock(&socket->recv_buffer_lock);
-                        fibril_mutex_unlock(&socket->lock);
-                        async_answer_0(callid, rc);
-                        return;
-                }
+                uint16_t addr_af = inet_addr_sockaddr_in(&rsock->addr, &addr,
+                    &addr6);
                 
-                addr.sin_family = AF_INET;
-                addr.sin_addr.s_addr = host2uint32_t_be(rsock_addr);
-                addr.sin_port = host2uint16_t_be(rsock->port);
-
-                log_msg(LOG_DEFAULT, LVL_DEBUG, "addr read receive");
-                if (!async_data_read_receive(&rcallid, &addr_length)) {
+                switch (addr_af) {
+                case AF_INET:
+                        addr.sin_port = host2uint16_t_be(rsock->port);
+                        
+                        log_msg(LOG_DEFAULT, LVL_DEBUG, "addr read receive");
+                        if (!async_data_read_receive(&rcallid, &addr_length)) {
+                                fibril_mutex_unlock(&socket->recv_buffer_lock);
+                                fibril_mutex_unlock(&socket->lock);
+                                async_answer_0(callid, EINVAL);
+                                return;
+                        }
+                        
+                        if (addr_length > sizeof(addr))
+                                addr_length = sizeof(addr);
+                        
+                        log_msg(LOG_DEFAULT, LVL_DEBUG, "addr read finalize");
+                        rc = async_data_read_finalize(rcallid, &addr, addr_length);
+                        if (rc != EOK) {
+                                fibril_mutex_unlock(&socket->recv_buffer_lock);
+                                fibril_mutex_unlock(&socket->lock);
+                                async_answer_0(callid, EINVAL);
+                                return;
+                        }
+                        
+                        break;
+                case AF_INET6:
+                        addr6.sin6_port = host2uint16_t_be(rsock->port);
+                        
+                        log_msg(LOG_DEFAULT, LVL_DEBUG, "addr6 read receive");
+                        if (!async_data_read_receive(&rcallid, &addr_length)) {
+                                fibril_mutex_unlock(&socket->recv_buffer_lock);
+                                fibril_mutex_unlock(&socket->lock);
+                                async_answer_0(callid, EINVAL);
+                                return;
+                        }
+                        
+                        if (addr_length > sizeof(addr6))
+                                addr_length = sizeof(addr6);
+                        
+                        log_msg(LOG_DEFAULT, LVL_DEBUG, "addr6 read finalize");
+                        rc = async_data_read_finalize(rcallid, &addr6, addr_length);
+                        if (rc != EOK) {
+                                fibril_mutex_unlock(&socket->recv_buffer_lock);
+                                fibril_mutex_unlock(&socket->lock);
+                                async_answer_0(callid, EINVAL);
+                                return;
+                        }
+                        
+                        break;
+                default:
                         fibril_mutex_unlock(&socket->recv_buffer_lock);
                         fibril_mutex_unlock(&socket->lock);
@@ -757 +824 @@
                         return;
                 }
-
-                if (addr_length > sizeof(addr))
-                        addr_length = sizeof(addr);
-
-                log_msg(LOG_DEFAULT, LVL_DEBUG, "addr read finalize");
-                rc = async_data_read_finalize(rcallid, &addr, addr_length);
-                if (rc != EOK) {
-                        fibril_mutex_unlock(&socket->recv_buffer_lock);
-                        fibril_mutex_unlock(&socket->lock);
-                        async_answer_0(callid, EINVAL);
-                        return;
-                }
         }
         
         log_msg(LOG_DEFAULT, LVL_DEBUG, "data read receive");
+        
+        size_t length;
         if (!async_data_read_receive(&rcallid, &length)) {
                 fibril_mutex_unlock(&socket->recv_buffer_lock);
@@ -783 +840 @@
         
         log_msg(LOG_DEFAULT, LVL_DEBUG, "data read finalize");
+        
         rc = async_data_read_finalize(rcallid, socket->recv_buffer, length);
         
         socket->recv_buffer_used -= length;
+        
         log_msg(LOG_DEFAULT, LVL_DEBUG, "tcp_sock_recvfrom: %zu left in buffer",
             socket->recv_buffer_used);
+        
         if (socket->recv_buffer_used > 0) {
                 memmove(socket->recv_buffer, socket->recv_buffer + length,
@@ -795 +855 @@
         
         fibril_condvar_broadcast(&socket->recv_buffer_cv);
-
-        if (length < data_len && rc == EOK)
+        
+        if ((length < data_len) && (rc == EOK))
                 rc = EOVERFLOW;
-
+        
+        ipc_call_t answer;
+        
         SOCKET_SET_READ_DATA_LENGTH(answer, length);
         async_answer_1(callid, EOK, IPC_GET_ARG1(answer));

uspace/srv/net/tcp/std.h

@@ -39 +39 @@
 
 #include <sys/types.h>
+#include <inet/addr.h>
+
+#define IP_PROTO_TCP  6
 
 /** TCP Header (fixed part) */
@@ -75 +78 @@
 typedef struct {
         /** Source address */
-        uint32_t src_addr;
+        uint32_t src;
         /** Destination address */
-        uint32_t dest_addr;
+        uint32_t dest;
         /** Zero */
         uint8_t zero;

uspace/srv/net/tcp/tcp.c

@@ -115 +115 @@
         }
 
-        pdu->src_addr = dgram->src;
-        pdu->dest_addr = dgram->dest;
+        pdu->src = dgram->src;
+        pdu->dest = dgram->dest;
 
         tcp_received_pdu(pdu);
@@ -143 +143 @@
             pdu->text_size);
 
-        dgram.src = pdu->src_addr;
-        dgram.dest = pdu->dest_addr;
+        dgram.src = pdu->src;
+        dgram.dest = pdu->dest;
         dgram.tos = 0;
         dgram.data = pdu_raw;

uspace/srv/net/tcp/tcp_type.h

@@ -306 +306 @@
 typedef struct {
         /** Source address */
-        inet_addr_t src_addr;
+        inet_addr_t src;
         /** Destination address */
-        inet_addr_t dest_addr;
-        
+        inet_addr_t dest;
         /** Encoded header */
         void *header;

uspace/srv/net/udp/pdu.c

@@ -40 +40 @@
 #include <mem.h>
 #include <stdlib.h>
-
+#include <inet/addr.h>
+#include <net/socket_codes.h>
 #include "msg.h"
 #include "pdu.h"
@@ -84 +85 @@
 }
 
-static void udp_phdr_setup(udp_pdu_t *pdu, udp_phdr_t *phdr)
-{
-        // FIXME: Check for correctness
-        
-        uint32_t src;
-        inet_addr_pack(&pdu->src, &src);
-        
-        uint32_t dest;
-        inet_addr_pack(&pdu->dest, &dest);
-        
-        phdr->src_addr = host2uint32_t_be(src);
-        phdr->dest_addr = host2uint32_t_be(dest);
-        phdr->zero = 0;
-        phdr->protocol = IP_PROTO_UDP;
-        phdr->udp_length = host2uint16_t_be(pdu->data_size);
+static uint16_t udp_phdr_setup(udp_pdu_t *pdu, udp_phdr_t *phdr)
+{
+        addr32_t src_v4;
+        addr128_t src_v6;
+        uint16_t src_af = inet_addr_get(&pdu->src, &src_v4, &src_v6);
+        
+        addr32_t dest_v4;
+        addr128_t dest_v6;
+        uint16_t dest_af = inet_addr_get(&pdu->dest, &dest_v4, &dest_v6);
+        
+        assert(src_af == dest_af);
+        
+        switch (src_af) {
+        case AF_INET:
+                phdr->src_addr = host2uint32_t_be(src_v4);
+                phdr->dest_addr = host2uint32_t_be(dest_v4);
+                phdr->zero = 0;
+                phdr->protocol = IP_PROTO_UDP;
+                phdr->udp_length = host2uint16_t_be(pdu->data_size);
+                break;
+        case AF_INET6:
+                // FIXME TODO
+                assert(false);
+        default:
+                assert(false);
+        }
+        
+        return src_af;
 }
 
@@ -115 +129 @@
 {
         uint16_t cs_phdr;
-        uint16_t cs_all;
         udp_phdr_t phdr;
-
-        udp_phdr_setup(pdu, &phdr);
-        cs_phdr = udp_checksum_calc(UDP_CHECKSUM_INIT, (void *)&phdr,
-            sizeof(udp_phdr_t));
-        cs_all = udp_checksum_calc(cs_phdr, pdu->data, pdu->data_size);
-
-        return cs_all;
+        
+        uint16_t af = udp_phdr_setup(pdu, &phdr);
+        switch (af) {
+        case AF_INET:
+                cs_phdr = udp_checksum_calc(UDP_CHECKSUM_INIT, (void *) &phdr,
+                    sizeof(udp_phdr_t));
+                break;
+        case AF_INET6:
+                // FIXME TODO
+                assert(false);
+        default:
+                assert(false);
+        }
+        
+        return udp_checksum_calc(cs_phdr, pdu->data, pdu->data_size);
 }
 

uspace/srv/net/udp/sock.c

@@ -159 +159 @@
 static void udp_sock_bind(udp_client_t *client, ipc_callid_t callid, ipc_call_t call)
 {
-        int rc;
-        struct sockaddr_in *addr;
-        size_t addr_size;
-        socket_core_t *sock_core;
-        udp_sockdata_t *socket;
-        udp_sock_t fsock;
-        udp_error_t urc;
-
         log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_sock_bind()");
         log_msg(LOG_DEFAULT, LVL_DEBUG, " - async_data_write_accept");
-
-        addr = NULL;
-
-        rc = async_data_write_accept((void **) &addr, false, 0, 0, 0, &addr_size);
+        
+        struct sockaddr_in6 *addr6 = NULL;
+        size_t addr_len;
+        int rc = async_data_write_accept((void **) &addr6, false, 0, 0, 0, &addr_len);
         if (rc != EOK) {
                 async_answer_0(callid, rc);
-                goto out;
-        }
-        
-        if (addr_size != sizeof(struct sockaddr_in)) {
+                return;
+        }
+        
+        if ((addr_len != sizeof(struct sockaddr_in)) &&
+            (addr_len != sizeof(struct sockaddr_in6))) {
                 async_answer_0(callid, EINVAL);
                 goto out;
         }
         
+        struct sockaddr_in *addr = (struct sockaddr_in *) addr6;
+        
         log_msg(LOG_DEFAULT, LVL_DEBUG, " - call socket_bind");
+        
         rc = socket_bind(&client->sockets, &gsock, SOCKET_GET_SOCKET_ID(call),
-            addr, addr_size, UDP_FREE_PORTS_START, UDP_FREE_PORTS_END,
+            addr6, addr_len, UDP_FREE_PORTS_START, UDP_FREE_PORTS_END,
             last_used_port);
         if (rc != EOK) {
@@ -193 +189 @@
         
         log_msg(LOG_DEFAULT, LVL_DEBUG, " - call socket_cores_find");
-        sock_core = socket_cores_find(&client->sockets, SOCKET_GET_SOCKET_ID(call));
+        
+        socket_core_t *sock_core = socket_cores_find(&client->sockets,
+            SOCKET_GET_SOCKET_ID(call));
         if (sock_core == NULL) {
                 async_answer_0(callid, ENOENT);
                 goto out;
         }
-
-        socket = (udp_sockdata_t *) sock_core->specific_data;
-        
-        inet_addr_unpack(uint32_t_be2host(addr->sin_addr.s_addr),
-            &fsock.addr);
-        fsock.port = sock_core->port;
-        urc = udp_uc_set_local(socket->assoc, &fsock);
-
+        
+        udp_sockdata_t *socket =
+            (udp_sockdata_t *) sock_core->specific_data;
+        
+        udp_sock_t fsocket;
+        
+        fsocket.port = sock_core->port;
+        
+        switch (addr->sin_family) {
+        case AF_INET:
+                inet_sockaddr_in_addr(addr, &fsocket.addr);
+                break;
+        case AF_INET6:
+                inet_sockaddr_in6_addr(addr6, &fsocket.addr);
+                break;
+        default:
+                async_answer_0(callid, EINVAL);
+                goto out;
+        }
+        
+        udp_error_t urc = udp_uc_set_local(socket->assoc, &fsocket);
+        
         switch (urc) {
         case UDP_EOK:
@@ -225 +237 @@
         log_msg(LOG_DEFAULT, LVL_DEBUG, " - success");
         async_answer_0(callid, rc);
+        
 out:
-        if (addr != NULL)
-                free(addr);
+        if (addr6 != NULL)
+                free(addr6);
 }
 
@@ -252 +265 @@
         log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_sock_send()");
         
-        struct sockaddr_in *addr = NULL;
-        udp_sock_t fsock;
-        udp_sock_t *fsock_ptr;
+        struct sockaddr_in6 *addr6 = NULL;
+        struct sockaddr_in *addr;
+        udp_sock_t fsocket;
+        udp_sock_t *fsocket_ptr;
         
         if (IPC_GET_IMETHOD(call) == NET_SOCKET_SENDTO) {
-                size_t addr_size;
-                int rc = async_data_write_accept((void **) &addr, false,
-                    0, 0, 0, &addr_size);
+                size_t addr_len;
+                int rc = async_data_write_accept((void **) &addr6, false,
+                    0, 0, 0, &addr_len);
                 if (rc != EOK) {
                         async_answer_0(callid, rc);
-                        goto out;
-                }
-                
-                if (addr_size != sizeof(struct sockaddr_in)) {
+                        return;
+                }
+                
+                if ((addr_len != sizeof(struct sockaddr_in)) &&
+                    (addr_len != sizeof(struct sockaddr_in6))) {
                         async_answer_0(callid, EINVAL);
                         goto out;
                 }
                 
-                inet_addr_unpack(uint32_t_be2host(addr->sin_addr.s_addr),
-                    &fsock.addr);
-                fsock.port = uint16_t_be2host(addr->sin_port);
-                fsock_ptr = &fsock;
+                addr = (struct sockaddr_in *) addr6;
+                
+                switch (addr->sin_family) {
+                case AF_INET:
+                        inet_sockaddr_in_addr(addr, &fsocket.addr);
+                        break;
+                case AF_INET6:
+                        inet_sockaddr_in6_addr(addr6, &fsocket.addr);
+                        break;
+                default:
+                        async_answer_0(callid, EINVAL);
+                        goto out;
+                }
+                
+                fsocket.port = uint16_t_be2host(addr->sin_port);
+                fsocket_ptr = &fsocket;
         } else
-                fsock_ptr = NULL;
+                fsocket_ptr = NULL;
         
         int socket_id = SOCKET_GET_SOCKET_ID(call);
@@ -321 +348 @@
                 inet_addr_t rem_addr;
                 
-                rem_addr = fsock_ptr ? fsock.addr :
+                rem_addr = fsocket_ptr ? fsocket.addr :
                     socket->assoc->ident.foreign.addr;
                 
@@ -361 +388 @@
                 
                 udp_error_t urc =
-                    udp_uc_send(socket->assoc, fsock_ptr, buffer, length, 0);
+                    udp_uc_send(socket->assoc, fsocket_ptr, buffer, length, 0);
                 
                 switch (urc) {
@@ -396 +423 @@
         
 out:
-        if (addr != NULL)
-                free(addr);
+        if (addr6 != NULL)
+                free(addr6);
 }
 
 static void udp_sock_recvfrom(udp_client_t *client, ipc_callid_t callid, ipc_call_t call)
 {
-        int socket_id;
-        int flags;
-        size_t addr_length, length;
-        socket_core_t *sock_core;
-        udp_sockdata_t *socket;
-        ipc_call_t answer;
-        ipc_callid_t rcallid;
-        size_t data_len;
-        udp_error_t urc;
-        udp_sock_t *rsock;
-        struct sockaddr_in addr;
-        int rc;
-
         log_msg(LOG_DEFAULT, LVL_DEBUG, "%p: udp_sock_recv[from]()", client);
-
-        socket_id = SOCKET_GET_SOCKET_ID(call);
-        flags = SOCKET_GET_FLAGS(call);
-
-        sock_core = socket_cores_find(&client->sockets, socket_id);
+        
+        int socket_id = SOCKET_GET_SOCKET_ID(call);
+        
+        socket_core_t *sock_core =
+            socket_cores_find(&client->sockets, socket_id);
         if (sock_core == NULL) {
                 async_answer_0(callid, ENOTSOCK);
                 return;
         }
-
-        socket = (udp_sockdata_t *)sock_core->specific_data;
+        
+        udp_sockdata_t *socket =
+            (udp_sockdata_t *) sock_core->specific_data;
+        
         fibril_mutex_lock(&socket->lock);
         
@@ -434 +450 @@
                 return;
         }
-
-        (void)flags;
-
+        
         log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_sock_recvfrom(): lock recv_buffer lock");
+        
         fibril_mutex_lock(&socket->recv_buffer_lock);
-        while (socket->recv_buffer_used == 0 && socket->recv_error == UDP_EOK) {
+        
+        while ((socket->recv_buffer_used == 0) &&
+            (socket->recv_error == UDP_EOK)) {
                 log_msg(LOG_DEFAULT, LVL_DEBUG, "udp_sock_recvfrom(): wait for cv");
                 fibril_condvar_wait(&socket->recv_buffer_cv,
@@ -446 +463 @@
         
         log_msg(LOG_DEFAULT, LVL_DEBUG, "Got data in sock recv_buffer");
-
-        rsock = &socket->recv_fsock;
-        data_len = socket->recv_buffer_used;
-        urc = socket->recv_error;
-
+        
+        size_t data_len = socket->recv_buffer_used;
+        udp_error_t urc = socket->recv_error;
+        
         log_msg(LOG_DEFAULT, LVL_DEBUG, "**** recv data_len=%zu", data_len);
-
+        
+        int rc;
+        
         switch (urc) {
         case UDP_EOK:
@@ -476 +494 @@
                 return;
         }
-
+        
+        ipc_callid_t rcallid;
+        size_t addr_size = 0;
+        
         if (IPC_GET_IMETHOD(call) == NET_SOCKET_RECVFROM) {
                 /* Fill address */
-                uint32_t rsock_addr;
-                int rc = inet_addr_pack(&rsock->addr, &rsock_addr);
-                if (rc != EOK) {
-                        fibril_mutex_unlock(&socket->recv_buffer_lock);
-                        fibril_mutex_unlock(&socket->lock);
-                        async_answer_0(callid, rc);
-                        return;
-                }
-                
-                addr.sin_family = AF_INET;
-                addr.sin_addr.s_addr = host2uint32_t_be(rsock_addr);
-                addr.sin_port = host2uint16_t_be(rsock->port);
-
-                log_msg(LOG_DEFAULT, LVL_DEBUG, "addr read receive");
-                if (!async_data_read_receive(&rcallid, &addr_length)) {
+                udp_sock_t *rsock = &socket->recv_fsock;
+                struct sockaddr_in addr;
+                struct sockaddr_in6 addr6;
+                size_t addr_length;
+                
+                uint16_t addr_af = inet_addr_sockaddr_in(&rsock->addr, &addr,
+                    &addr6);
+                
+                switch (addr_af) {
+                case AF_INET:
+                        addr.sin_port = host2uint16_t_be(rsock->port);
+                        
+                        log_msg(LOG_DEFAULT, LVL_DEBUG, "addr read receive");
+                        if (!async_data_read_receive(&rcallid, &addr_length)) {
+                                fibril_mutex_unlock(&socket->recv_buffer_lock);
+                                fibril_mutex_unlock(&socket->lock);
+                                async_answer_0(callid, EINVAL);
+                                return;
+                        }
+                        
+                        if (addr_length > sizeof(addr))
+                                addr_length = sizeof(addr);
+                        
+                        addr_size = sizeof(addr);
+                        
+                        log_msg(LOG_DEFAULT, LVL_DEBUG, "addr read finalize");
+                        rc = async_data_read_finalize(rcallid, &addr, addr_length);
+                        if (rc != EOK) {
+                                fibril_mutex_unlock(&socket->recv_buffer_lock);
+                                fibril_mutex_unlock(&socket->lock);
+                                async_answer_0(callid, EINVAL);
+                                return;
+                        }
+                        
+                        break;
+                case AF_INET6:
+                        addr6.sin6_port = host2uint16_t_be(rsock->port);
+                        
+                        log_msg(LOG_DEFAULT, LVL_DEBUG, "addr6 read receive");
+                        if (!async_data_read_receive(&rcallid, &addr_length)) {
+                                fibril_mutex_unlock(&socket->recv_buffer_lock);
+                                fibril_mutex_unlock(&socket->lock);
+                                async_answer_0(callid, EINVAL);
+                                return;
+                        }
+                        
+                        if (addr_length > sizeof(addr6))
+                                addr_length = sizeof(addr6);
+                        
+                        addr_size = sizeof(addr6);
+                        
+                        log_msg(LOG_DEFAULT, LVL_DEBUG, "addr6 read finalize");
+                        rc = async_data_read_finalize(rcallid, &addr6, addr_length);
+                        if (rc != EOK) {
+                                fibril_mutex_unlock(&socket->recv_buffer_lock);
+                                fibril_mutex_unlock(&socket->lock);
+                                async_answer_0(callid, EINVAL);
+                                return;
+                        }
+                        
+                        break;
+                default:
                         fibril_mutex_unlock(&socket->recv_buffer_lock);
                         fibril_mutex_unlock(&socket->lock);
@@ -499 +567 @@
                         return;
                 }
-
-                if (addr_length > sizeof(addr))
-                        addr_length = sizeof(addr);
-
-                log_msg(LOG_DEFAULT, LVL_DEBUG, "addr read finalize");
-                rc = async_data_read_finalize(rcallid, &addr, addr_length);
-                if (rc != EOK) {
-                        fibril_mutex_unlock(&socket->recv_buffer_lock);
-                        fibril_mutex_unlock(&socket->lock);
-                        async_answer_0(callid, EINVAL);
-                        return;
-                }
-        }
-
+        }
+        
         log_msg(LOG_DEFAULT, LVL_DEBUG, "data read receive");
+        
+        size_t length;
         if (!async_data_read_receive(&rcallid, &length)) {
                 fibril_mutex_unlock(&socket->recv_buffer_lock);
@@ -525 +583 @@
         
         log_msg(LOG_DEFAULT, LVL_DEBUG, "data read finalize");
+        
         rc = async_data_read_finalize(rcallid, socket->recv_buffer, length);
-
-        if (length < data_len && rc == EOK)
+        
+        if ((length < data_len) && (rc == EOK))
                 rc = EOVERFLOW;
         
         log_msg(LOG_DEFAULT, LVL_DEBUG, "read_data_length <- %zu", length);
+        
+        ipc_call_t answer;
+        
         IPC_SET_ARG2(answer, 0);
         SOCKET_SET_READ_DATA_LENGTH(answer, length);
-        SOCKET_SET_ADDRESS_LENGTH(answer, sizeof(addr));
+        SOCKET_SET_ADDRESS_LENGTH(answer, addr_size);
         async_answer_3(callid, EOK, IPC_GET_ARG1(answer),
             IPC_GET_ARG2(answer), IPC_GET_ARG3(answer));
@@ -634 +696 @@
                         log_msg(LOG_DEFAULT, LVL_DEBUG, "[] urc != UDP_EOK, break");
                         fibril_condvar_broadcast(&sock->recv_buffer_cv);
+                        fibril_mutex_unlock(&sock->recv_buffer_lock);
                         break;
                 }