Changeset 98abd40 in mainline for uspace/lib/c/generic

Timestamp:

2013-07-06T21:57:22Z (12 years ago)

Author:

Vojtech Horky <vojtechhorky@…>

Branches:

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

Children:

c8bb1633, cdc8a391

Parents:

b8e72fd1 (diff), 507c6f3 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge mainline changes

Location:

uspace/lib/c/generic

Files:

• devman.c (modified) (1 diff)
• dnsr.c (modified) (5 diffs)
• inet.c (modified) (3 diffs)
• inet/addr.c (modified) (1 diff)
• inetcfg.c (modified) (6 diffs)
• inetping.c (modified) (2 diffs)
• inetping6.c (added)
• iplink.c (modified) (3 diffs)
• iplink_srv.c (modified) (5 diffs)
• net/inet.c (modified) (4 diffs)
• net/socket_client.c (modified) (4 diffs)
• net/socket_parse.c (modified) (1 diff)
• str.c (modified) (5 diffs)

uspace/lib/c/generic/devman.c

@@ -413 +413 @@
         sysarg_t dretval;
         
-        exch = devman_exchange_begin_blocking(LOC_PORT_CONSUMER);
+        exch = devman_exchange_begin_blocking(DEVMAN_CLIENT);
         
         ipc_call_t answer;

uspace/lib/c/generic/dnsr.c

@@ -44 +44 @@
 static async_exch_t *dnsr_exchange_begin(void)
 {
-        async_sess_t *sess;
-        service_id_t dnsr_svc;
-
         fibril_mutex_lock(&dnsr_sess_mutex);
-
+        
         if (dnsr_sess == NULL) {
+                service_id_t dnsr_svc;
+                
                 (void) loc_service_get_id(SERVICE_NAME_DNSR, &dnsr_svc,
                     IPC_FLAG_BLOCKING);
-
+                
                 dnsr_sess = loc_service_connect(EXCHANGE_SERIALIZE, dnsr_svc,
                     IPC_FLAG_BLOCKING);
         }
-
-        sess = dnsr_sess;
+        
+        async_sess_t *sess = dnsr_sess;
         fibril_mutex_unlock(&dnsr_sess_mutex);
-
+        
         return async_exchange_begin(sess);
 }
@@ -70 +69 @@
 int dnsr_name2host(const char *name, dnsr_hostinfo_t **rinfo)
 {
+        dnsr_hostinfo_t *info = calloc(1, sizeof(dnsr_hostinfo_t));
+        if (info == NULL)
+                return ENOMEM;
+        
         async_exch_t *exch = dnsr_exchange_begin();
-        char cname_buf[DNSR_NAME_MAX_SIZE + 1];
-        ipc_call_t cnreply;
-        size_t act_size;
-        dnsr_hostinfo_t *info;
-
+        
         ipc_call_t answer;
         aid_t req = async_send_0(exch, DNSR_NAME2HOST, &answer);
-        sysarg_t retval = async_data_write_start(exch, name, str_size(name));
-        aid_t cnreq = async_data_read(exch, cname_buf, DNSR_NAME_MAX_SIZE,
-            &cnreply);
-
+        
+        int rc = async_data_write_start(exch, name, str_size(name));
+        if (rc != EOK) {
+                async_exchange_end(exch);
+                async_forget(req);
+                return rc;
+        }
+        
+        ipc_call_t answer_addr;
+        aid_t req_addr = async_data_read(exch, &info->addr,
+            sizeof(inet_addr_t), &answer_addr);
+        
+        sysarg_t retval_addr;
+        async_wait_for(req_addr, &retval_addr);
+        
+        if (retval_addr != EOK) {
+                async_exchange_end(exch);
+                async_forget(req);
+                return (int) retval_addr;
+        }
+        
+        ipc_call_t answer_cname;
+        char cname_buf[DNSR_NAME_MAX_SIZE + 1];
+        aid_t req_cname = async_data_read(exch, cname_buf, DNSR_NAME_MAX_SIZE,
+            &answer_cname);
+        
         dnsr_exchange_end(exch);
-
-        if (retval != EOK) {
+        
+        sysarg_t retval_cname;
+        async_wait_for(req_cname, &retval_cname);
+        
+        if (retval_cname != EOK) {
                 async_forget(req);
-                async_forget(cnreq);
-                return retval;
+                return (int) retval_cname;
         }
-
+        
+        sysarg_t retval;
         async_wait_for(req, &retval);
-        if (retval != EOK) {
-                async_forget(cnreq);
-                return EIO;
-        }
-
-        async_wait_for(cnreq, &retval);
+        
         if (retval != EOK)
-                return EIO;
-
-        info = calloc(1, sizeof(dnsr_hostinfo_t));
-        if (info == NULL)
-                return ENOMEM;
-
-        act_size = IPC_GET_ARG2(cnreply);
+                return (int) retval;
+        
+        size_t act_size = IPC_GET_ARG2(answer_cname);
         assert(act_size <= DNSR_NAME_MAX_SIZE);
+        
         cname_buf[act_size] = '\0';
-
+        
         info->cname = str_dup(cname_buf);
-        info->addr.ipv4 = IPC_GET_ARG1(answer);
-
+        
         *rinfo = info;
         return EOK;
@@ -119 +134 @@
         if (info == NULL)
                 return;
-
+        
         free(info->cname);
         free(info);
@@ -126 +141 @@
 int dnsr_get_srvaddr(inet_addr_t *srvaddr)
 {
-        sysarg_t addr;
         async_exch_t *exch = dnsr_exchange_begin();
-
-        int rc = async_req_0_1(exch, DNSR_GET_SRVADDR, &addr);
-        dnsr_exchange_end(exch);
-
-        if (rc != EOK)
+        
+        ipc_call_t answer;
+        aid_t req = async_send_0(exch, DNSR_GET_SRVADDR, &answer);
+        int rc = async_data_read_start(exch, srvaddr, sizeof(inet_addr_t));
+        
+        loc_exchange_end(exch);
+        
+        if (rc != EOK) {
+                async_forget(req);
                 return rc;
-
-        srvaddr->ipv4 = addr;
-        return EOK;
+        }
+        
+        sysarg_t retval;
+        async_wait_for(req, &retval);
+        
+        return (int) retval;
 }
 
@@ -142 +163 @@
 {
         async_exch_t *exch = dnsr_exchange_begin();
-
-        int rc = async_req_1_0(exch, DNSR_SET_SRVADDR, srvaddr->ipv4);
-        dnsr_exchange_end(exch);
-
-        if (rc != EOK)
+        
+        ipc_call_t answer;
+        aid_t req = async_send_0(exch, DNSR_SET_SRVADDR, &answer);
+        int rc = async_data_write_start(exch, srvaddr, sizeof(inet_addr_t));
+        
+        loc_exchange_end(exch);
+        
+        if (rc != EOK) {
+                async_forget(req);
                 return rc;
-
-        return EOK;
+        }
+        
+        sysarg_t retval;
+        async_wait_for(req, &retval);
+        
+        return (int) retval;
 }
 

uspace/lib/c/generic/inet.c

@@ -30 +30 @@
 #include <assert.h>
 #include <errno.h>
+#include <net/socket_codes.h>
 #include <inet/inet.h>
 #include <ipc/inet.h>
@@ -108 +109 @@
 {
         async_exch_t *exch = async_exchange_begin(inet_sess);
-
+        
         ipc_call_t answer;
-        aid_t req = async_send_5(exch, INET_SEND, dgram->src.ipv4,
-            dgram->dest.ipv4, dgram->tos, ttl, df, &answer);
-        int rc = async_data_write_start(exch, dgram->data, dgram->size);
-        async_exchange_end(exch);
-
-        if (rc != EOK) {
-                async_forget(req);
-                return rc;
-        }
-
+        aid_t req = async_send_3(exch, INET_SEND, dgram->tos, ttl, df,
+            &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;
 }
 
 int inet_get_srcaddr(inet_addr_t *remote, uint8_t tos, inet_addr_t *local)
 {
-        sysarg_t local_addr;
-        async_exch_t *exch = async_exchange_begin(inet_sess);
-
-        int rc = async_req_2_1(exch, INET_GET_SRCADDR, remote->ipv4,
-            tos, &local_addr);
-        async_exchange_end(exch);
-
-        if (rc != EOK)
-                return rc;
-
-        local->ipv4 = local_addr;
-        return EOK;
-}
-
-static void inet_ev_recv(ipc_callid_t callid, ipc_call_t *call)
-{
-        int rc;
+        async_exch_t *exch = async_exchange_begin(inet_sess);
+        
+        ipc_call_t answer;
+        aid_t req = async_send_1(exch, INET_GET_SRCADDR, tos, &answer);
+        
+        int rc = async_data_write_start(exch, remote, sizeof(inet_addr_t));
+        if (rc != EOK) {
+                async_exchange_end(exch);
+                async_forget(req);
+                return rc;
+        }
+        
+        rc = async_data_read_start(exch, local, sizeof(inet_addr_t));
+        
+        async_exchange_end(exch);
+        
+        if (rc != EOK) {
+                async_forget(req);
+                return rc;
+        }
+        
+        sysarg_t retval;
+        async_wait_for(req, &retval);
+        
+        return (int) retval;
+}
+
+static void inet_ev_recv(ipc_callid_t iid, ipc_call_t *icall)
+{
         inet_dgram_t dgram;
-
-        dgram.src.ipv4 = IPC_GET_ARG1(*call);
-        dgram.dest.ipv4 = IPC_GET_ARG2(*call);
-        dgram.tos = IPC_GET_ARG3(*call);
-
+        
+        dgram.tos = 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_addr_t)) {
+                async_answer_0(callid, EINVAL);
+                async_answer_0(iid, EINVAL);
+                return;
+        }
+        
+        int rc = async_data_write_finalize(callid, &dgram.src, 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;
+        }
+        
+        rc = async_data_write_finalize(callid, &dgram.dest, size);
+        if (rc != EOK) {
+                async_answer_0(callid, rc);
+                async_answer_0(iid, rc);
+                return;
+        }
+        
         rc = async_data_write_accept(&dgram.data, false, 0, 0, 0, &dgram.size);
         if (rc != EOK) {
-                async_answer_0(callid, rc);
-                return;
-        }
-
+                async_answer_0(iid, rc);
+                return;
+        }
+        
         rc = inet_ev_ops->recv(&dgram);
-        async_answer_0(callid, rc);
+        async_answer_0(iid, rc);
 }
 
@@ -168 +233 @@
                 ipc_call_t call;
                 ipc_callid_t callid = async_get_call(&call);
-
+                
                 if (!IPC_GET_IMETHOD(call)) {
                         /* TODO: Handle hangup */
                         return;
                 }
-
+                
                 switch (IPC_GET_IMETHOD(call)) {
                 case INET_EV_RECV:

uspace/lib/c/generic/inet/addr.c

@@ -34 +34 @@
 
 #include <errno.h>
+#include <unistd.h>
+#include <net/socket_codes.h>
 #include <inet/addr.h>
+#include <net/inet.h>
 #include <stdio.h>
+#include <malloc.h>
+#include <bitops.h>
+
+#define INET_PREFIXSTRSIZE  5
+
+#if !(defined(__BE__) ^ defined(__LE__))
+        #error The architecture must be either big-endian or little-endian.
+#endif
+
+const addr48_t addr48_broadcast = {
+        0xff, 0xff, 0xff, 0xff, 0xff, 0xff
+};
+
+static const inet_addr_t inet_addr_any_addr = {
+        .family = AF_INET,
+        .addr = 0
+};
+
+static const inet_addr_t inet_addr_any_addr6 = {
+        .family = AF_INET6,
+        .addr6 = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
+};
+
+void addr48(const addr48_t src, addr48_t dst)
+{
+        memcpy(dst, src, 6);
+}
+
+void addr128(const addr128_t src, addr128_t dst)
+{
+        memcpy(dst, src, 16);
+}
+
+void host2addr128_t_be(const addr128_t host, addr128_t be)
+{
+#ifdef __BE__
+        memcpy(be, host, 16);
+#else
+        be[0] = host[15];
+        be[1] = host[14];
+        be[2] = host[13];
+        be[3] = host[12];
+        be[4] = host[11];
+        be[5] = host[10];
+        be[6] = host[9];
+        be[7] = host[8];
+        be[8] = host[7];
+        be[9] = host[6];
+        be[10] = host[5];
+        be[11] = host[4];
+        be[12] = host[3];
+        be[13] = host[2];
+        be[14] = host[1];
+        be[15] = host[0];
+#endif
+}
+
+void addr128_t_be2host(const addr128_t be, addr128_t host)
+{
+#ifdef __BE__
+        memcpy(host, be, 16);
+#else
+        host[0] = be[15];
+        host[1] = be[14];
+        host[2] = be[13];
+        host[3] = be[12];
+        host[4] = be[11];
+        host[5] = be[10];
+        host[6] = be[9];
+        host[7] = be[8];
+        host[8] = be[7];
+        host[9] = be[6];
+        host[10] = be[5];
+        host[11] = be[4];
+        host[12] = be[3];
+        host[13] = be[2];
+        host[14] = be[1];
+        host[15] = be[0];
+#endif
+}
+
+void inet_addr(inet_addr_t *addr, uint8_t a, uint8_t b, uint8_t c, uint8_t d)
+{
+        addr->family = AF_INET;
+        addr->addr = ((addr32_t) a << 24) | ((addr32_t) b << 16) |
+            ((addr32_t) c << 8) | ((addr32_t) d);
+}
+
+void inet_naddr(inet_naddr_t *naddr, uint8_t a, uint8_t b, uint8_t c, uint8_t d,
+    uint8_t prefix)
+{
+        naddr->family = AF_INET;
+        naddr->addr = ((addr32_t) a << 24) | ((addr32_t) b << 16) |
+            ((addr32_t) c << 8) | ((addr32_t) d);
+        naddr->prefix = prefix;
+}
+
+void inet_addr6(inet_addr_t *addr, uint16_t a, uint16_t b, uint16_t c,
+    uint16_t d, uint16_t e, uint16_t f, uint16_t g, uint16_t h)
+{
+        addr->family = AF_INET6;
+        addr->addr6[0] = (a >> 8) & 0xff;
+        addr->addr6[1] = a & 0xff;
+        addr->addr6[2] = (b >> 8) & 0xff;
+        addr->addr6[3] = b & 0xff;
+        addr->addr6[4] = (c >> 8) & 0xff;
+        addr->addr6[5] = c & 0xff;
+        addr->addr6[6] = (d >> 8) & 0xff;
+        addr->addr6[7] = d & 0xff;
+        addr->addr6[8] = (e >> 8) & 0xff;
+        addr->addr6[9] = e & 0xff;
+        addr->addr6[10] = (f >> 8) & 0xff;
+        addr->addr6[11] = f & 0xff;
+        addr->addr6[12] = (g >> 8) & 0xff;
+        addr->addr6[13] = g & 0xff;
+        addr->addr6[14] = (h >> 8) & 0xff;
+        addr->addr6[15] = h & 0xff;
+}
+
+void inet_naddr6(inet_naddr_t *naddr, uint16_t a, uint16_t b, uint16_t c,
+    uint16_t d, uint16_t e, uint16_t f, uint16_t g, uint16_t h, uint8_t prefix)
+{
+        naddr->family = AF_INET6;
+        naddr->addr6[0] = (a >> 8) & 0xff;
+        naddr->addr6[1] = a & 0xff;
+        naddr->addr6[2] = (b >> 8) & 0xff;
+        naddr->addr6[3] = b & 0xff;
+        naddr->addr6[4] = (c >> 8) & 0xff;
+        naddr->addr6[5] = c & 0xff;
+        naddr->addr6[6] = (d >> 8) & 0xff;
+        naddr->addr6[7] = d & 0xff;
+        naddr->addr6[8] = (e >> 8) & 0xff;
+        naddr->addr6[9] = e & 0xff;
+        naddr->addr6[10] = (f >> 8) & 0xff;
+        naddr->addr6[11] = f & 0xff;
+        naddr->addr6[12] = (g >> 8) & 0xff;
+        naddr->addr6[13] = g & 0xff;
+        naddr->addr6[14] = (h >> 8) & 0xff;
+        naddr->addr6[15] = h & 0xff;
+        naddr->prefix = prefix;
+}
+
+/** Parse network address family.
+ *
+ * @param text Network address in common notation.
+ * @param af   Place to store network address family.
+ *
+ * @return EOK on success, EINVAL if input is not in valid format.
+ *
+ */
+int inet_addr_family(const char *text, uint16_t *af)
+{
+        char *dot = str_chr(text, '.');
+        if (dot != NULL) {
+                *af = AF_INET;
+                return EOK;
+        }
+        
+        char *collon = str_chr(text, ':');
+        if (collon != NULL) {
+                *af = AF_INET6;
+                return EOK;
+        }
+        
+        return EINVAL;
+}
+
+void inet_naddr_addr(const inet_naddr_t *naddr, inet_addr_t *addr)
+{
+        addr->family = naddr->family;
+        memcpy(addr->addr6, naddr->addr6, 16);
+}
+
+void inet_addr_any(inet_addr_t *addr)
+{
+        addr->family = AF_NONE;
+        memset(addr->addr6, 0, 16);
+}
+
+void inet_naddr_any(inet_naddr_t *naddr)
+{
+        naddr->family = AF_NONE;
+        memset(naddr->addr6, 0, 16);
+        naddr->prefix = 0;
+}
+
+int inet_addr_compare(const inet_addr_t *a, const inet_addr_t *b)
+{
+        if (a->family != b->family)
+                return 0;
+        
+        switch (a->family) {
+        case AF_INET:
+                return (a->addr == b->addr);
+        case AF_INET6:
+                return memcmp(&a->addr6, &b->addr6, 16);
+        default:
+                return 0;
+        }
+}
+
+int inet_addr_is_any(const inet_addr_t *addr)
+{
+        return ((addr->family == 0) ||
+            (inet_addr_compare(addr, &inet_addr_any_addr)) ||
+            (inet_addr_compare(addr, &inet_addr_any_addr6)));
+}
+
+int inet_naddr_compare_mask(const inet_naddr_t *naddr, const inet_addr_t *addr)
+{
+        if (naddr->family != addr->family)
+                return 0;
+        
+        switch (naddr->family) {
+        case AF_INET:
+                if (naddr->prefix > 32)
+                        return 0;
+                
+                addr32_t mask =
+                    BIT_RANGE(addr32_t, 31, 31 - (naddr->prefix - 1));
+                return ((naddr->addr & mask) == (addr->addr & mask));
+        case AF_INET6:
+                if (naddr->prefix > 128)
+                        return 0;
+                
+                size_t pos = 0;
+                for (size_t i = 0; i < 16; i++) {
+                        /* Further bits do not matter */
+                        if (naddr->prefix < pos)
+                                break;
+                        
+                        if (naddr->prefix - pos > 8) {
+                                /* Comparison without masking */
+                                if (naddr->addr6[i] != addr->addr6[i])
+                                        return 0;
+                        } else {
+                                /* Comparison with masking */
+                                uint8_t mask =
+                                    BIT_RANGE(uint8_t, 8, 8 - (naddr->prefix - pos - 1));
+                                if ((naddr->addr6[i] & mask) != (addr->addr6[i] & mask))
+                                        return 0;
+                        }
+                        
+                        pos += 8;
+                }
+                
+                return 1;
+        default:
+                return 0;
+        }
+}
+
+/** Parse node address.
+ *
+ * @param text Network address in common notation.
+ * @param addr Place to store node address.
+ *
+ * @return EOK on success, EINVAL if input is not in valid format.
+ *
+ */
+int inet_addr_parse(const char *text, inet_addr_t *addr)
+{
+        int rc = inet_addr_family(text, &addr->family);
+        if (rc != EOK)
+                return rc;
+        
+        uint8_t buf[16];
+        rc = inet_pton(addr->family, text, buf);
+        if (rc != EOK)
+                return rc;
+        
+        switch (addr->family) {
+        case AF_INET:
+                addr->addr = (buf[0] << 24) | (buf[1] << 16) | (buf[2] << 8) |
+                    buf[3];
+                break;
+        case AF_INET6:
+                memcpy(addr->addr6, buf, 16);
+                break;
+        default:
+                return EINVAL;
+        }
+        
+        return EOK;
+}
 
 /** Parse network address.
  *
- * @param text  Network address in CIDR notation (a.b.c.d/w)
- * @param naddr Place to store network address
- *
- * @return      EOK on success, EINVAL if input is not in valid format
+ * @param text  Network address in common notation.
+ * @param naddr Place to store network address.
+ *
+ * @return EOK on success, EINVAL if input is not in valid format.
+ *
  */
 int inet_naddr_parse(const char *text, inet_naddr_t *naddr)
 {
-        unsigned long a[4], bits;
-        char *cp = (char *)text;
-        int i;
-
-        for (i = 0; i < 3; i++) {
-                a[i] = strtoul(cp, &cp, 10);
-                if (*cp != '.')
+        char *slash = str_chr(text, '/');
+        if (slash == NULL)
+                return EINVAL;
+        
+        *slash = 0;
+        
+        int rc = inet_addr_family(text, &naddr->family);
+        if (rc != EOK)
+                return rc;
+        
+        uint8_t buf[16];
+        rc = inet_pton(naddr->family, text, buf);
+        *slash = '/';
+        
+        if (rc != EOK)
+                return rc;
+        
+        slash++;
+        uint8_t prefix;
+        
+        switch (naddr->family) {
+        case AF_INET:
+                prefix = strtoul(slash, &slash, 10);
+                if (prefix > 32)
                         return EINVAL;
-                ++cp;
-        }
-
-        a[3] = strtoul(cp, &cp, 10);
-        if (*cp != '/')
-                return EINVAL;
-        ++cp;
-
-        bits = strtoul(cp, &cp, 10);
-        if (*cp != '\0')
-                return EINVAL;
-
-        naddr->ipv4 = 0;
-        for (i = 0; i < 4; i++) {
-                if (a[i] > 255)
+                
+                naddr->addr = (buf[0] << 24) | (buf[1] << 16) | (buf[2] << 8) |
+                    buf[3];
+                naddr->prefix = prefix;
+                
+                break;
+        case AF_INET6:
+                prefix = strtoul(slash, &slash, 10);
+                if (prefix > 128)
                         return EINVAL;
-                naddr->ipv4 = (naddr->ipv4 << 8) | a[i];
-        }
-
-        if (bits > 31)
-                return EINVAL;
-
-        naddr->bits = bits;
+                
+                memcpy(naddr->addr6, buf, 16);
+                naddr->prefix = prefix;
+                
+                break;
+        default:
+                return ENOTSUP;
+        }
+        
         return EOK;
 }
 
-/** Parse node address.
- *
- * @param text  Network address in dot notation (a.b.c.d)
- * @param addr  Place to store node address
- *
- * @return      EOK on success, EINVAL if input is not in valid format
- */
-int inet_addr_parse(const char *text, inet_addr_t *addr)
-{
-        unsigned long a[4];
-        char *cp = (char *)text;
-        int i;
-
-        for (i = 0; i < 3; i++) {
-                a[i] = strtoul(cp, &cp, 10);
-                if (*cp != '.')
-                        return EINVAL;
-                ++cp;
-        }
-
-        a[3] = strtoul(cp, &cp, 10);
-        if (*cp != '\0')
-                return EINVAL;
-
-        addr->ipv4 = 0;
-        for (i = 0; i < 4; i++) {
-                if (a[i] > 255)
-                        return EINVAL;
-                addr->ipv4 = (addr->ipv4 << 8) | a[i];
-        }
-
-        return EOK;
-}
-
-/** Format network address.
- *
- * @param naddr Network address
- * @param bufp  Place to store pointer to formatted string (CIDR notation)
- *
- * @return      EOK on success, ENOMEM if out of memory.
- */
-int inet_naddr_format(inet_naddr_t *naddr, char **bufp)
-{
-        int rc;
-
-        rc = asprintf(bufp, "%d.%d.%d.%d/%d", naddr->ipv4 >> 24,
-            (naddr->ipv4 >> 16) & 0xff, (naddr->ipv4 >> 8) & 0xff,
-            naddr->ipv4 & 0xff, naddr->bits);
-
+/** Format node address.
+ *
+ * @param addr Node address.
+ * @param bufp Place to store pointer to formatted string.
+ *
+ * @return EOK on success.
+ * @return ENOMEM if out of memory.
+ * @return ENOTSUP on unsupported address family.
+ *
+ */
+int inet_addr_format(const inet_addr_t *addr, char **bufp)
+{
+        int rc = 0;
+        
+        switch (addr->family) {
+        case AF_NONE:
+                rc = asprintf(bufp, "none");
+                break;
+        case AF_INET:
+                rc = asprintf(bufp, "%u.%u.%u.%u", (addr->addr >> 24) & 0xff,
+                    (addr->addr >> 16) & 0xff, (addr->addr >> 8) & 0xff,
+                    addr->addr & 0xff);
+                break;
+        case AF_INET6:
+                *bufp = (char *) malloc(INET6_ADDRSTRLEN);
+                if (*bufp == NULL)
+                        return ENOMEM;
+                
+                return inet_ntop(AF_INET6, addr->addr6, *bufp, INET6_ADDRSTRLEN);
+        default:
+                return ENOTSUP;
+        }
+        
         if (rc < 0)
                 return ENOMEM;
-
+        
         return EOK;
 }
 
-/** Format node address.
- *
- * @param addr  Node address
- * @param bufp  Place to store pointer to formatted string (dot notation)
- *
- * @return      EOK on success, ENOMEM if out of memory.
- */
-int inet_addr_format(inet_addr_t *addr, char **bufp)
-{
-        int rc;
-
-        rc = asprintf(bufp, "%d.%d.%d.%d", addr->ipv4 >> 24,
-            (addr->ipv4 >> 16) & 0xff, (addr->ipv4 >> 8) & 0xff,
-            addr->ipv4 & 0xff);
-
+/** Format network address.
+ *
+ * @param naddr Network address.
+ * @param bufp  Place to store pointer to formatted string.
+ *
+ * @return EOK on success.
+ * @return ENOMEM if out of memory.
+ * @return ENOTSUP on unsupported address family.
+ *
+ */
+int inet_naddr_format(const inet_naddr_t *naddr, char **bufp)
+{
+        int rc = 0;
+        char prefix[INET_PREFIXSTRSIZE];
+        
+        switch (naddr->family) {
+        case AF_NONE:
+                rc = asprintf(bufp, "none");
+                break;
+        case AF_INET:
+                rc = asprintf(bufp, "%" PRIu8 ".%" PRIu8 ".%" PRIu8 ".%" PRIu8
+                    "/%" PRIu8, (naddr->addr >> 24) & 0xff,
+                    (naddr->addr >> 16) & 0xff, (naddr->addr >> 8) & 0xff,
+                    naddr->addr & 0xff, naddr->prefix);
+                break;
+        case AF_INET6:
+                *bufp = (char *) malloc(INET6_ADDRSTRLEN + INET_PREFIXSTRSIZE);
+                if (*bufp == NULL)
+                        return ENOMEM;
+                
+                rc = inet_ntop(AF_INET6, naddr->addr6, *bufp,
+                    INET6_ADDRSTRLEN + INET_PREFIXSTRSIZE);
+                if (rc != EOK) {
+                        free(*bufp);
+                        return rc;
+                }
+                
+                rc = snprintf(prefix, INET_PREFIXSTRSIZE, "/%" PRIu8,
+                    naddr->prefix);
+                if (rc < 0) {
+                        free(*bufp);
+                        return ENOMEM;
+                }
+                
+                str_append(*bufp, INET6_ADDRSTRLEN + INET_PREFIXSTRSIZE, prefix);
+                
+                break;
+        default:
+                return ENOTSUP;
+        }
+        
         if (rc < 0)
                 return ENOMEM;
-
+        
         return EOK;
 }
 
+uint16_t inet_addr_get(const inet_addr_t *addr, addr32_t *v4, addr128_t *v6)
+{
+        switch (addr->family) {
+        case AF_INET:
+                if (v4 != NULL)
+                        *v4 = addr->addr;
+                
+                break;
+        case AF_INET6:
+                if (v6 != NULL)
+                        memcpy(*v6, addr->addr6, 16);
+                
+                break;
+        }
+        
+        return addr->family;
+}
+
+uint16_t inet_naddr_get(const inet_naddr_t *naddr, addr32_t *v4, addr128_t *v6,
+    uint8_t *prefix)
+{
+        switch (naddr->family) {
+        case AF_INET:
+                if (v4 != NULL)
+                        *v4 = naddr->addr;
+                
+                if (prefix != NULL)
+                        *prefix = naddr->prefix;
+                
+                break;
+        case AF_INET6:
+                if (v6 != NULL)
+                        memcpy(*v6, naddr->addr6, 16);
+                
+                if (prefix != NULL)
+                        *prefix = naddr->prefix;
+                
+                break;
+        }
+        
+        return naddr->family;
+}
+
+void inet_addr_set(addr32_t v4, inet_addr_t *addr)
+{
+        addr->family = AF_INET;
+        addr->addr = v4;
+}
+
+void inet_naddr_set(addr32_t v4, uint8_t prefix, inet_naddr_t *naddr)
+{
+        naddr->family = AF_INET;
+        naddr->addr = v4;
+        naddr->prefix = prefix;
+}
+
+void inet_sockaddr_in_addr(const sockaddr_in_t *sockaddr_in, inet_addr_t *addr)
+{
+        addr->family = AF_INET;
+        addr->addr = uint32_t_be2host(sockaddr_in->sin_addr.s_addr);
+}
+
+void inet_addr_set6(addr128_t v6, inet_addr_t *addr)
+{
+        addr->family = AF_INET6;
+        memcpy(addr->addr6, v6, 16);
+}
+
+void inet_naddr_set6(addr128_t v6, uint8_t prefix, inet_naddr_t *naddr)
+{
+        naddr->family = AF_INET6;
+        memcpy(naddr->addr6, v6, 16);
+        naddr->prefix = prefix;
+}
+
+void inet_sockaddr_in6_addr(const sockaddr_in6_t *sockaddr_in6,
+    inet_addr_t *addr)
+{
+        addr->family = AF_INET6;
+        addr128_t_be2host(sockaddr_in6->sin6_addr.s6_addr, addr->addr6);
+}
+
+uint16_t inet_addr_sockaddr_in(const inet_addr_t *addr,
+    sockaddr_in_t *sockaddr_in, sockaddr_in6_t *sockaddr_in6)
+{
+        switch (addr->family) {
+        case AF_INET:
+                if (sockaddr_in != NULL) {
+                        sockaddr_in->sin_family = AF_INET;
+                        sockaddr_in->sin_addr.s_addr = host2uint32_t_be(addr->addr);
+                }
+                
+                break;
+        case AF_INET6:
+                if (sockaddr_in6 != NULL) {
+                        sockaddr_in6->sin6_family = AF_INET6;
+                        host2addr128_t_be(addr->addr6, sockaddr_in6->sin6_addr.s6_addr);
+                }
+                
+                break;
+        }
+        
+        return addr->family;
+}
+
 /** @}
  */

uspace/lib/c/generic/inetcfg.c

@@ -137 +137 @@
 {
         async_exch_t *exch = async_exchange_begin(inetcfg_sess);
-
-        ipc_call_t answer;
-        aid_t req = async_send_3(exch, INETCFG_ADDR_CREATE_STATIC, naddr->ipv4,
-            naddr->bits, link_id, &answer);
+        
+        ipc_call_t answer;
+        aid_t req = async_send_1(exch, INETCFG_ADDR_CREATE_STATIC, link_id,
+            &answer);
+        
+        int rc = async_data_write_start(exch, naddr, sizeof(inet_naddr_t));
+        if (rc != EOK) {
+                async_exchange_end(exch);
+                async_forget(req);
+                return rc;
+        }
+        
+        rc = async_data_write_start(exch, name, str_size(name));
+        
+        async_exchange_end(exch);
+        
+        if (rc != EOK) {
+                async_forget(req);
+                return rc;
+        }
+        
+        sysarg_t retval;
+        async_wait_for(req, &retval);
+        
+        *addr_id = IPC_GET_ARG1(answer);
+        
+        return (int) retval;
+}
+
+int inetcfg_addr_delete(sysarg_t addr_id)
+{
+        async_exch_t *exch = async_exchange_begin(inetcfg_sess);
+
+        int rc = async_req_1_0(exch, INETCFG_ADDR_DELETE, addr_id);
+        async_exchange_end(exch);
+
+        return rc;
+}
+
+int inetcfg_addr_get(sysarg_t addr_id, inet_addr_info_t *ainfo)
+{
+        async_exch_t *exch = async_exchange_begin(inetcfg_sess);
+        
+        ipc_call_t answer;
+        aid_t req = async_send_1(exch, INETCFG_ADDR_GET, addr_id, &answer);
+        
+        ipc_call_t answer_naddr;
+        aid_t req_naddr = async_data_read(exch, &ainfo->naddr,
+            sizeof(inet_naddr_t), &answer_naddr);
+        
+        sysarg_t retval_naddr;
+        async_wait_for(req_naddr, &retval_naddr);
+        
+        if (retval_naddr != EOK) {
+                async_exchange_end(exch);
+                async_forget(req);
+                return (int) retval_naddr;
+        }
+        
+        ipc_call_t answer_name;
+        char name_buf[LOC_NAME_MAXLEN + 1];
+        aid_t req_name = async_data_read(exch, name_buf, LOC_NAME_MAXLEN,
+            &answer_name);
+        
+        async_exchange_end(exch);
+        
+        sysarg_t retval_name;
+        async_wait_for(req_name, &retval_name);
+        
+        if (retval_name != EOK) {
+                async_forget(req);
+                return (int) retval_name;
+        }
+        
+        sysarg_t retval;
+        async_wait_for(req, &retval);
+        
+        if (retval != EOK)
+                return (int) retval;
+        
+        size_t act_size = IPC_GET_ARG2(answer_name);
+        assert(act_size <= LOC_NAME_MAXLEN);
+        
+        name_buf[act_size] = '\0';
+        
+        ainfo->ilink = IPC_GET_ARG1(answer);
+        ainfo->name = str_dup(name_buf);
+        
+        return EOK;
+}
+
+int inetcfg_addr_get_id(const char *name, sysarg_t link_id, sysarg_t *addr_id)
+{
+        async_exch_t *exch = async_exchange_begin(inetcfg_sess);
+
+        ipc_call_t answer;
+        aid_t req = async_send_1(exch, INETCFG_ADDR_GET_ID, link_id, &answer);
         sysarg_t retval = async_data_write_start(exch, name, str_size(name));
 
@@ -156 +249 @@
 }
 
-int inetcfg_addr_delete(sysarg_t addr_id)
-{
-        async_exch_t *exch = async_exchange_begin(inetcfg_sess);
-
-        int rc = async_req_1_0(exch, INETCFG_ADDR_DELETE, addr_id);
-        async_exchange_end(exch);
-
-        return rc;
-}
-
-int inetcfg_addr_get(sysarg_t addr_id, inet_addr_info_t *ainfo)
+int inetcfg_get_addr_list(sysarg_t **addrs, size_t *count)
+{
+        return inetcfg_get_ids_internal(INETCFG_GET_ADDR_LIST,
+            0, addrs, count);
+}
+
+int inetcfg_get_link_list(sysarg_t **links, size_t *count)
+{
+        return inetcfg_get_ids_internal(INETCFG_GET_LINK_LIST,
+            0, links, count);
+}
+
+int inetcfg_get_sroute_list(sysarg_t **sroutes, size_t *count)
+{
+        return inetcfg_get_ids_internal(INETCFG_GET_SROUTE_LIST,
+            0, sroutes, count);
+}
+
+int inetcfg_link_get(sysarg_t link_id, inet_link_info_t *linfo)
 {
         ipc_call_t dreply;
@@ -176 +277 @@
 
         ipc_call_t answer;
-        aid_t req = async_send_1(exch, INETCFG_ADDR_GET, addr_id, &answer);
+        aid_t req = async_send_1(exch, INETCFG_LINK_GET, link_id, &answer);
         aid_t dreq = async_data_read(exch, name_buf, LOC_NAME_MAXLEN, &dreply);
         async_wait_for(dreq, &dretval);
@@ -197 +298 @@
         name_buf[act_size] = '\0';
 
-        ainfo->naddr.ipv4 = IPC_GET_ARG1(answer);
-        ainfo->naddr.bits = IPC_GET_ARG2(answer);
-        ainfo->ilink = IPC_GET_ARG3(answer);
-        ainfo->name = str_dup(name_buf);
-
-        return EOK;
-}
-
-int inetcfg_addr_get_id(const char *name, sysarg_t link_id, sysarg_t *addr_id)
-{
-        async_exch_t *exch = async_exchange_begin(inetcfg_sess);
-
-        ipc_call_t answer;
-        aid_t req = async_send_1(exch, INETCFG_ADDR_GET_ID, link_id, &answer);
-        sysarg_t retval = async_data_write_start(exch, name, str_size(name));
-
-        async_exchange_end(exch);
-
-        if (retval != EOK) {
-                async_forget(req);
-                return retval;
-        }
-
-        async_wait_for(req, &retval);
-        *addr_id = IPC_GET_ARG1(answer);
-
-        return retval;
-}
-
-int inetcfg_get_addr_list(sysarg_t **addrs, size_t *count)
-{
-        return inetcfg_get_ids_internal(INETCFG_GET_ADDR_LIST,
-            0, addrs, count);
-}
-
-int inetcfg_get_link_list(sysarg_t **links, size_t *count)
-{
-        return inetcfg_get_ids_internal(INETCFG_GET_LINK_LIST,
-            0, links, count);
-}
-
-int inetcfg_get_sroute_list(sysarg_t **sroutes, size_t *count)
-{
-        return inetcfg_get_ids_internal(INETCFG_GET_SROUTE_LIST,
-            0, sroutes, count);
-}
-
-int inetcfg_link_get(sysarg_t link_id, inet_link_info_t *linfo)
-{
-        ipc_call_t dreply;
-        sysarg_t dretval;
-        size_t act_size;
-        char name_buf[LOC_NAME_MAXLEN + 1];
-
-        async_exch_t *exch = async_exchange_begin(inetcfg_sess);
-
-        ipc_call_t answer;
-        aid_t req = async_send_1(exch, INETCFG_LINK_GET, link_id, &answer);
-        aid_t dreq = async_data_read(exch, name_buf, LOC_NAME_MAXLEN, &dreply);
-        async_wait_for(dreq, &dretval);
-
-        async_exchange_end(exch);
-
-        if (dretval != EOK) {
-                async_forget(req);
-                return dretval;
-        }
-
-        sysarg_t retval;
-        async_wait_for(req, &retval);
-
-        if (retval != EOK)
-                return retval;
-
-        act_size = IPC_GET_ARG2(dreply);
-        assert(act_size <= LOC_NAME_MAXLEN);
-        name_buf[act_size] = '\0';
-
         linfo->name = str_dup(name_buf);
         linfo->def_mtu = IPC_GET_ARG1(answer);
@@ -285 +308 @@
 {
         async_exch_t *exch = async_exchange_begin(inetcfg_sess);
-
-        ipc_call_t answer;
-        aid_t req = async_send_3(exch, INETCFG_SROUTE_CREATE,
-            dest->ipv4, dest->bits, router->ipv4, &answer);
-        sysarg_t retval = async_data_write_start(exch, name, str_size(name));
-
-        async_exchange_end(exch);
-
-        if (retval != EOK) {
-                async_forget(req);
-                return retval;
-        }
-
-        async_wait_for(req, &retval);
+        
+        ipc_call_t answer;
+        aid_t req = async_send_0(exch, INETCFG_SROUTE_CREATE, &answer);
+        
+        int rc = async_data_write_start(exch, dest, sizeof(inet_naddr_t));
+        if (rc != EOK) {
+                async_exchange_end(exch);
+                async_forget(req);
+                return rc;
+        }
+        
+        rc = async_data_write_start(exch, router, sizeof(inet_addr_t));
+        if (rc != EOK) {
+                async_exchange_end(exch);
+                async_forget(req);
+                return rc;
+        }
+        
+        rc = async_data_write_start(exch, name, str_size(name));
+        
+        async_exchange_end(exch);
+        
+        if (rc != EOK) {
+                async_forget(req);
+                return rc;
+        }
+        
+        sysarg_t retval;
+        async_wait_for(req, &retval);
+        
         *sroute_id = IPC_GET_ARG1(answer);
-
-        return retval;
+        
+        return (int) retval;
 }
 
@@ -316 +355 @@
 int inetcfg_sroute_get(sysarg_t sroute_id, inet_sroute_info_t *srinfo)
 {
-        ipc_call_t dreply;
-        sysarg_t dretval;
-        size_t act_size;
+        async_exch_t *exch = async_exchange_begin(inetcfg_sess);
+        
+        ipc_call_t answer;
+        aid_t req = async_send_1(exch, INETCFG_SROUTE_GET, sroute_id, &answer);
+        
+        ipc_call_t answer_dest;
+        aid_t req_dest = async_data_read(exch, &srinfo->dest,
+            sizeof(inet_naddr_t), &answer_dest);
+        
+        sysarg_t retval_dest;
+        async_wait_for(req_dest, &retval_dest);
+        
+        if (retval_dest != EOK) {
+                async_exchange_end(exch);
+                async_forget(req);
+                return (int) retval_dest;
+        }
+        
+        ipc_call_t answer_router;
+        aid_t req_router = async_data_read(exch, &srinfo->router,
+            sizeof(inet_addr_t), &answer_router);
+        
+        sysarg_t retval_router;
+        async_wait_for(req_router, &retval_router);
+        
+        if (retval_router != EOK) {
+                async_exchange_end(exch);
+                async_forget(req);
+                return (int) retval_router;
+        }
+        
+        ipc_call_t answer_name;
         char name_buf[LOC_NAME_MAXLEN + 1];
-
-        async_exch_t *exch = async_exchange_begin(inetcfg_sess);
-
-        ipc_call_t answer;
-        aid_t req = async_send_1(exch, INETCFG_SROUTE_GET, sroute_id, &answer);
-        aid_t dreq = async_data_read(exch, name_buf, LOC_NAME_MAXLEN, &dreply);
-        async_wait_for(dreq, &dretval);
-
-        async_exchange_end(exch);
-
-        if (dretval != EOK) {
-                async_forget(req);
-                return dretval;
-        }
-
-        sysarg_t retval;
-        async_wait_for(req, &retval);
-
+        aid_t req_name = async_data_read(exch, name_buf, LOC_NAME_MAXLEN,
+            &answer_name);
+        
+        async_exchange_end(exch);
+        
+        sysarg_t retval_name;
+        async_wait_for(req_name, &retval_name);
+        
+        if (retval_name != EOK) {
+                async_forget(req);
+                return (int) retval_name;
+        }
+        
+        sysarg_t retval;
+        async_wait_for(req, &retval);
+        
         if (retval != EOK)
-                return retval;
-
-        act_size = IPC_GET_ARG2(dreply);
+                return (int) retval;
+        
+        size_t act_size = IPC_GET_ARG2(answer_name);
         assert(act_size <= LOC_NAME_MAXLEN);
+        
         name_buf[act_size] = '\0';
-
-        srinfo->dest.ipv4 = IPC_GET_ARG1(answer);
-        srinfo->dest.bits = IPC_GET_ARG2(answer);
-        srinfo->router.ipv4 = IPC_GET_ARG3(answer);
+        
         srinfo->name = str_dup(name_buf);
-
+        
         return EOK;
 }

uspace/lib/c/generic/inetping.c

@@ -79 +79 @@
 {
         async_exch_t *exch = async_exchange_begin(inetping_sess);
-
+        
         ipc_call_t answer;
-        aid_t req = async_send_3(exch, INETPING_SEND, sdu->src.ipv4,
-            sdu->dest.ipv4, sdu->seq_no, &answer);
+        aid_t req = async_send_3(exch, INETPING_SEND, (sysarg_t) sdu->src,
+            (sysarg_t) sdu->dest, sdu->seq_no, &answer);
         sysarg_t retval = async_data_write_start(exch, sdu->data, sdu->size);
-
+        
         async_exchange_end(exch);
-
+        
         if (retval != EOK) {
                 async_forget(req);
                 return retval;
         }
-
+        
         async_wait_for(req, &retval);
         return retval;
 }
 
-int inetping_get_srcaddr(inet_addr_t *remote, inet_addr_t *local)
+int inetping_get_srcaddr(uint32_t remote, uint32_t *local)
 {
+        async_exch_t *exch = async_exchange_begin(inetping_sess);
+        
         sysarg_t local_addr;
-        async_exch_t *exch = async_exchange_begin(inetping_sess);
-
-        int rc = async_req_1_1(exch, INETPING_GET_SRCADDR, remote->ipv4,
+        int rc = async_req_1_1(exch, INETPING_GET_SRCADDR, (sysarg_t) remote,
             &local_addr);
+        
         async_exchange_end(exch);
-
+        
         if (rc != EOK)
                 return rc;
-
-        local->ipv4 = local_addr;
+        
+        *local = (uint32_t) local_addr;
         return EOK;
 }
@@ -114 +115 @@
 static void inetping_ev_recv(ipc_callid_t callid, ipc_call_t *call)
 {
-        int rc;
         inetping_sdu_t sdu;
-
-        sdu.src.ipv4 = IPC_GET_ARG1(*call);
-        sdu.dest.ipv4 = IPC_GET_ARG2(*call);
+        
+        sdu.src = IPC_GET_ARG1(*call);
+        sdu.dest = IPC_GET_ARG2(*call);
         sdu.seq_no = IPC_GET_ARG3(*call);
-
-        rc = async_data_write_accept(&sdu.data, false, 0, 0, 0, &sdu.size);
+        
+        int rc = async_data_write_accept(&sdu.data, false, 0, 0, 0, &sdu.size);
         if (rc != EOK) {
                 async_answer_0(callid, rc);
                 return;
         }
-
+        
         rc = inetping_ev_ops->recv(&sdu);
         free(sdu.data);

uspace/lib/c/generic/iplink.c

@@ -39 +39 @@
 #include <errno.h>
 #include <inet/iplink.h>
+#include <inet/addr.h>
 #include <ipc/iplink.h>
 #include <ipc/services.h>
@@ -83 +84 @@
 {
         async_exch_t *exch = async_exchange_begin(iplink->sess);
-
+        
         ipc_call_t answer;
-        aid_t req = async_send_2(exch, IPLINK_SEND, sdu->lsrc.ipv4,
-            sdu->ldest.ipv4, &answer);
-        int rc = async_data_write_start(exch, sdu->data, sdu->size);
-        async_exchange_end(exch);
-
-        if (rc != EOK) {
-                async_forget(req);
-                return rc;
-        }
-
+        aid_t req = async_send_0(exch, IPLINK_SEND, &answer);
+        
+        int rc = async_data_write_start(exch, &sdu->src, sizeof(inet_addr_t));
+        if (rc != EOK) {
+                async_exchange_end(exch);
+                async_forget(req);
+                return rc;
+        }
+        
+        rc = async_data_write_start(exch, &sdu->dest, sizeof(inet_addr_t));
+        if (rc != EOK) {
+                async_exchange_end(exch);
+                async_forget(req);
+                return rc;
+        }
+        
+        rc = async_data_write_start(exch, sdu->data, sdu->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;
 }
 
@@ -118 +132 @@
 }
 
-int iplink_addr_add(iplink_t *iplink, iplink_addr_t *addr)
-{
-        async_exch_t *exch = async_exchange_begin(iplink->sess);
-
-        int rc = async_req_1_0(exch, IPLINK_ADDR_ADD, (sysarg_t)addr->ipv4);
-        async_exchange_end(exch);
-
-        return rc;
-}
-
-int iplink_addr_remove(iplink_t *iplink, iplink_addr_t *addr)
-{
-        async_exch_t *exch = async_exchange_begin(iplink->sess);
-
-        int rc = async_req_1_0(exch, IPLINK_ADDR_REMOVE, (sysarg_t)addr->ipv4);
-        async_exchange_end(exch);
-
-        return rc;
-}
-
-static void iplink_ev_recv(iplink_t *iplink, ipc_callid_t callid,
-    ipc_call_t *call)
-{
-        int rc;
-        iplink_sdu_t sdu;
-
-        sdu.lsrc.ipv4 = IPC_GET_ARG1(*call);
-        sdu.ldest.ipv4 = IPC_GET_ARG2(*call);
-
-        rc = async_data_write_accept(&sdu.data, false, 0, 0, 0, &sdu.size);
-        if (rc != EOK) {
-                async_answer_0(callid, rc);
+int iplink_addr_add(iplink_t *iplink, inet_addr_t *addr)
+{
+        async_exch_t *exch = async_exchange_begin(iplink->sess);
+        
+        ipc_call_t answer;
+        aid_t req = async_send_0(exch, IPLINK_ADDR_ADD, &answer);
+        
+        int rc = async_data_write_start(exch, addr, sizeof(inet_addr_t));
+        async_exchange_end(exch);
+        
+        if (rc != EOK) {
+                async_forget(req);
+                return rc;
+        }
+        
+        sysarg_t retval;
+        async_wait_for(req, &retval);
+        
+        return (int) retval;
+}
+
+int iplink_addr_remove(iplink_t *iplink, inet_addr_t *addr)
+{
+        async_exch_t *exch = async_exchange_begin(iplink->sess);
+        
+        ipc_call_t answer;
+        aid_t req = async_send_0(exch, IPLINK_ADDR_REMOVE, &answer);
+        
+        int rc = async_data_write_start(exch, addr, sizeof(inet_addr_t));
+        async_exchange_end(exch);
+        
+        if (rc != EOK) {
+                async_forget(req);
+                return rc;
+        }
+        
+        sysarg_t retval;
+        async_wait_for(req, &retval);
+        
+        return (int) retval;
+}
+
+static void iplink_ev_recv(iplink_t *iplink, ipc_callid_t iid,
+    ipc_call_t *icall)
+{
+        iplink_recv_sdu_t sdu;
+        
+        uint16_t af = IPC_GET_ARG1(*icall);
+        
+        int rc = async_data_write_accept(&sdu.data, false, 0, 0, 0,
+            &sdu.size);
+        if (rc != EOK) {
+                async_answer_0(iid, rc);
                 return;
         }
-
-        rc = iplink->ev_ops->recv(iplink, &sdu);
+        
+        rc = iplink->ev_ops->recv(iplink, &sdu, af);
         free(sdu.data);
-        async_answer_0(callid, rc);
+        async_answer_0(iid, rc);
 }
 
 static void iplink_cb_conn(ipc_callid_t iid, ipc_call_t *icall, void *arg)
 {
-        iplink_t *iplink = (iplink_t *)arg;
-
+        iplink_t *iplink = (iplink_t *) arg;
+        
         while (true) {
                 ipc_call_t call;
                 ipc_callid_t callid = async_get_call(&call);
-
+                
                 if (!IPC_GET_IMETHOD(call)) {
                         /* TODO: Handle hangup */
                         return;
                 }
-
+                
                 switch (IPC_GET_IMETHOD(call)) {
                 case IPLINK_EV_RECV:

uspace/lib/c/generic/iplink_srv.c

@@ -34 +34 @@
  * @brief IP link server stub
  */
+
 #include <errno.h>
 #include <ipc/iplink.h>
 #include <stdlib.h>
 #include <sys/types.h>
-
+#include <inet/addr.h>
 #include <inet/iplink_srv.h>
 
@@ -44 +45 @@
     ipc_call_t *call)
 {
-        int rc;
         size_t mtu;
-
-        rc = srv->ops->get_mtu(srv, &mtu);
+        int rc = srv->ops->get_mtu(srv, &mtu);
         async_answer_1(callid, rc, mtu);
 }
 
-static void iplink_addr_add_srv(iplink_srv_t *srv, ipc_callid_t callid,
-    ipc_call_t *call)
-{
-        int rc;
-        iplink_srv_addr_t addr;
-
-        addr.ipv4 = IPC_GET_ARG1(*call);
-
+static void iplink_addr_add_srv(iplink_srv_t *srv, ipc_callid_t iid,
+    ipc_call_t *icall)
+{
+        ipc_callid_t callid;
+        size_t size;
+        if (!async_data_write_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;
+        }
+        
+        inet_addr_t addr;
+        int rc = async_data_write_finalize(callid, &addr, size);
+        if (rc != EOK) {
+                async_answer_0(callid, (sysarg_t) rc);
+                async_answer_0(iid, (sysarg_t) rc);
+        }
+        
         rc = srv->ops->addr_add(srv, &addr);
-        async_answer_0(callid, rc);
-}
-
-static void iplink_addr_remove_srv(iplink_srv_t *srv, ipc_callid_t callid,
-    ipc_call_t *call)
-{
-        int rc;
-        iplink_srv_addr_t addr;
-
-        addr.ipv4 = IPC_GET_ARG1(*call);
-
+        async_answer_0(iid, (sysarg_t) rc);
+}
+
+static void iplink_addr_remove_srv(iplink_srv_t *srv, ipc_callid_t iid,
+    ipc_call_t *icall)
+{
+        ipc_callid_t callid;
+        size_t size;
+        if (!async_data_write_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;
+        }
+        
+        inet_addr_t addr;
+        int rc = async_data_write_finalize(callid, &addr, size);
+        if (rc != EOK) {
+                async_answer_0(callid, (sysarg_t) rc);
+                async_answer_0(iid, (sysarg_t) rc);
+        }
+        
         rc = srv->ops->addr_remove(srv, &addr);
-        async_answer_0(callid, rc);
-}
-
-static void iplink_send_srv(iplink_srv_t *srv, ipc_callid_t callid,
-    ipc_call_t *call)
-{
-        iplink_srv_sdu_t sdu;
-        int rc;
-
-        sdu.lsrc.ipv4 = IPC_GET_ARG1(*call);
-        sdu.ldest.ipv4 = IPC_GET_ARG2(*call);
-
-        rc = async_data_write_accept(&sdu.data, false, 0, 0, 0, &sdu.size);
-        if (rc != EOK) {
-                async_answer_0(callid, rc);
-                return;
-        }
-
+        async_answer_0(iid, (sysarg_t) rc);
+}
+
+static void iplink_send_srv(iplink_srv_t *srv, ipc_callid_t iid,
+    ipc_call_t *icall)
+{
+        iplink_sdu_t sdu;
+        
+        ipc_callid_t callid;
+        size_t size;
+        if (!async_data_write_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;
+        }
+        
+        int rc = async_data_write_finalize(callid, &sdu.src, size);
+        if (rc != EOK) {
+                async_answer_0(callid, (sysarg_t) rc);
+                async_answer_0(iid, (sysarg_t) rc);
+        }
+        
+        if (!async_data_write_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_write_finalize(callid, &sdu.dest, size);
+        if (rc != EOK) {
+                async_answer_0(callid, (sysarg_t) rc);
+                async_answer_0(iid, (sysarg_t) rc);
+        }
+        
+        rc = async_data_write_accept(&sdu.data, false, 0, 0, 0,
+            &sdu.size);
+        if (rc != EOK)
+                return;
+        
         rc = srv->ops->send(srv, &sdu);
         free(sdu.data);
-        async_answer_0(callid, rc);
+        async_answer_0(iid, rc);
 }
 
@@ -108 +172 @@
         iplink_srv_t *srv = (iplink_srv_t *)arg;
         int rc;
-
+        
         fibril_mutex_lock(&srv->lock);
         if (srv->connected) {
@@ -115 +179 @@
                 return EBUSY;
         }
-
+        
         srv->connected = true;
         fibril_mutex_unlock(&srv->lock);
-
+        
         /* Accept the connection */
         async_answer_0(iid, EOK);
-
+        
         async_sess_t *sess = async_callback_receive(EXCHANGE_SERIALIZE);
         if (sess == NULL)
                 return ENOMEM;
-
+        
         srv->client_sess = sess;
-
+        
         rc = srv->ops->open(srv);
         if (rc != EOK)
                 return rc;
-
+        
         while (true) {
                 ipc_call_t call;
                 ipc_callid_t callid = async_get_call(&call);
                 sysarg_t method = IPC_GET_IMETHOD(call);
-
+                
                 if (!method) {
                         /* The other side has hung up */
-                        fibril_mutex_lock(&srv->lock);
+                        fibril_mutex_lock(&srv->lock);
                         srv->connected = false;
-                        fibril_mutex_unlock(&srv->lock);
+                        fibril_mutex_unlock(&srv->lock);
                         async_answer_0(callid, EOK);
                         break;
                 }
-
+                
                 switch (method) {
                 case IPLINK_GET_MTU:
@@ -163 +227 @@
                 }
         }
-
+        
         return srv->ops->close(srv);
 }
 
-int iplink_ev_recv(iplink_srv_t *srv, iplink_srv_sdu_t *sdu)
+int iplink_ev_recv(iplink_srv_t *srv, iplink_recv_sdu_t *sdu, uint16_t af)
 {
         if (srv->client_sess == NULL)
                 return EIO;
-
+        
         async_exch_t *exch = async_exchange_begin(srv->client_sess);
-
+        
         ipc_call_t answer;
-        aid_t req = async_send_2(exch, IPLINK_EV_RECV, sdu->lsrc.ipv4,
-            sdu->ldest.ipv4, &answer);
+        aid_t req = async_send_1(exch, IPLINK_EV_RECV, (sysarg_t) af,
+            &answer);
+        
         int rc = async_data_write_start(exch, sdu->data, sdu->size);
         async_exchange_end(exch);
-
+        
         if (rc != EOK) {
                 async_forget(req);
                 return rc;
         }
-
+        
         sysarg_t retval;
         async_wait_for(req, &retval);
         if (retval != EOK)
                 return retval;
-
+        
         return EOK;
 }

uspace/lib/c/generic/net/inet.c

@@ -1 +1 @@
 /*
- * Copyright (c) 2009 Lukas Mejdrech
+ * Copyright (c) 2013 Martin Decky
  * All rights reserved.
  *
@@ -39 +39 @@
 #include <net/in6.h>
 #include <net/inet.h>
-
+#include <inet/addr.h>
 #include <errno.h>
 #include <mem.h>
@@ -45 +45 @@
 #include <str.h>
 
+const in6_addr_t in6addr_any = {
+        { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }
+};
+
+static int inet_ntop4(const uint8_t *data, char *address, size_t length)
+{
+        /* Check output buffer size */
+        if (length < INET_ADDRSTRLEN)
+                return ENOMEM;
+        
+        /* Fill buffer with IPv4 address */
+        snprintf(address, length,
+            "%" PRIu8 ".%" PRIu8 ".%" PRIu8 ".%" PRIu8,
+            data[0], data[1], data[2], data[3]);
+        
+        return EOK;
+}
+
+static int inet_ntop6(const uint8_t *data, char *address, size_t length)
+{
+        /* Check output buffer size */
+        if (length < INET6_ADDRSTRLEN)
+                return ENOMEM;
+        
+        /* Find the longest zero subsequence */
+        
+        uint16_t zeroes[8];
+        uint16_t bioctets[8];
+        
+        for (size_t i = 8; i > 0; i--) {
+                size_t j = i - 1;
+                
+                bioctets[j] = (data[j << 1] << 8) | data[(j << 1) + 1];
+                
+                if (bioctets[j] == 0) {
+                        zeroes[j] = 1;
+                        if (j < 7)
+                                zeroes[j] += zeroes[j + 1];
+                } else
+                        zeroes[j] = 0;
+        }
+        
+        size_t wildcard_pos = (size_t) -1;
+        size_t wildcard_size = 0;
+        
+        for (size_t i = 0; i < 8; i++) {
+                if (zeroes[i] > wildcard_size) {
+                        wildcard_pos = i;
+                        wildcard_size = zeroes[i];
+                }
+        }
+        
+        char *cur = address;
+        size_t rest = length;
+        bool tail_zero = false;
+        int ret;
+        
+        for (size_t i = 0; i < 8; i++) {
+                if ((i == wildcard_pos) && (wildcard_size > 1)) {
+                        ret = snprintf(cur, rest, ":");
+                        i += wildcard_size - 1;
+                        tail_zero = true;
+                } else if (i == 0) {
+                        ret = snprintf(cur, rest, "%" PRIx16, bioctets[i]);
+                        tail_zero = false;
+                } else {
+                        ret = snprintf(cur, rest, ":%" PRIx16, bioctets[i]);
+                        tail_zero = false;
+                }
+                
+                if (ret < 0)
+                        return EINVAL;
+                
+                cur += ret;
+                rest -= ret;
+        }
+        
+        if (tail_zero) {
+                ret = snprintf(cur, rest, ":");
+                if (ret < 0)
+                        return EINVAL;
+        }
+        
+        return EOK;
+}
+
 /** Prints the address into the character buffer.
  *
- *  @param[in] family   The address family.
- *  @param[in] data     The address data.
- *  @param[out] address The character buffer to be filled.
- *  @param[in] length   The buffer length.
- *  @return             EOK on success.
- *  @return             EINVAL if the data or address parameter is NULL.
- *  @return             ENOMEM if the character buffer is not long enough.
- *  @return             ENOTSUP if the address family is not supported.
- */
-int
-inet_ntop(uint16_t family, const uint8_t *data, char *address, size_t length)
-{
-        if ((!data) || (!address))
-                return EINVAL;
-
+ * @param[in]  family  Address family.
+ * @param[in]  data    Address data.
+ * @param[out] address Character buffer to be filled.
+ * @param[in]  length  Buffer length.
+ *
+ * @return EOK on success.
+ * @return EINVAL if the data or address parameter is NULL.
+ * @return ENOMEM if the character buffer is not long enough.
+ * @return ENOTSUP if the address family is not supported.
+ *
+ */
+int inet_ntop(uint16_t family, const uint8_t *data, char *address, size_t length)
+{
         switch (family) {
         case AF_INET:
-                /* Check output buffer size */
-                if (length < INET_ADDRSTRLEN)
-                        return ENOMEM;
-                        
-                /* Fill buffer with IPv4 address */
-                snprintf(address, length, "%hhu.%hhu.%hhu.%hhu",
-                    data[0], data[1], data[2], data[3]);
-
-                return EOK;
-
+                return inet_ntop4(data, address, length);
         case AF_INET6:
-                /* Check output buffer size */
-                if (length < INET6_ADDRSTRLEN)
-                        return ENOMEM;
-                
-                /* Fill buffer with IPv6 address */
-                snprintf(address, length,
-                    "%hhx%hhx:%hhx%hhx:%hhx%hhx:%hhx%hhx:%hhx%hhx:%hhx%hhx:"
-                    "%hhx%hhx:%hhx%hhx",
-                    data[0], data[1], data[2], data[3], data[4], data[5],
-                    data[6], data[7], data[8], data[9], data[10], data[11],
-                    data[12], data[13], data[14], data[15]);
-                
-                return EOK;
-
+                return inet_ntop6(data, address, length);
         default:
                 return ENOTSUP;
@@ -94 +156 @@
 }
 
+static int inet_pton4(const char *address, uint8_t *data)
+{
+        memset(data, 0, 4);
+        
+        const char *cur = address;
+        size_t i = 0;
+        
+        while (i < 4) {
+                int rc = str_uint8_t(cur, &cur, 10, false, &data[i]);
+                if (rc != EOK)
+                        return rc;
+                
+                i++;
+                
+                if (*cur == 0)
+                        break;
+                
+                if (*cur != '.')
+                        return EINVAL;
+                
+                if (i < 4)
+                        cur++;
+        }
+        
+        if ((i == 4) && (*cur != 0))
+                return EINVAL;
+        
+        return EOK;
+}
+
+static int inet_pton6(const char *address, uint8_t *data)
+{
+        memset(data, 0, 16);
+        
+        const char *cur = address;
+        size_t i = 0;
+        size_t wildcard_pos = (size_t) -1;
+        size_t wildcard_size = 0;
+        
+        /* Handle initial wildcard */
+        if ((address[0] == ':') && (address[1] == ':')) {
+                cur = address + 2;
+                wildcard_pos = 0;
+                wildcard_size = 16;
+                
+                /* Handle empty address */
+                if (*cur == 0)
+                        return EOK;
+        }
+        
+        while (i < 16) {
+                uint16_t bioctet;
+                int rc = str_uint16_t(cur, &cur, 16, false, &bioctet);
+                if (rc != EOK)
+                        return rc;
+                
+                data[i] = (bioctet >> 8) & 0xff;
+                data[i + 1] = bioctet & 0xff;
+                
+                if (wildcard_pos != (size_t) -1) {
+                        if (wildcard_size < 2)
+                                return EINVAL;
+                        
+                        wildcard_size -= 2;
+                }
+                
+                i += 2;
+                
+                if (*cur == 0)
+                        break;
+                
+                if (*cur != ':')
+                        return EINVAL;
+                
+                if (i < 16) {
+                        cur++;
+                        
+                        /* Handle wildcard */
+                        if (*cur == ':') {
+                                if (wildcard_pos != (size_t) -1)
+                                        return EINVAL;
+                                
+                                wildcard_pos = i;
+                                wildcard_size = 16 - i;
+                                cur++;
+                                
+                                if (*cur == 0)
+                                        break;
+                        }
+                }
+        }
+        
+        if ((i == 16) && (*cur != 0))
+                return EINVAL;
+        
+        /* Create wildcard positions */
+        if ((wildcard_pos != (size_t) -1) && (wildcard_size > 0)) {
+                size_t wildcard_shift = 16 - wildcard_size;
+                
+                for (i = wildcard_pos + wildcard_shift; i > wildcard_pos; i--) {
+                        size_t j = i - 1;
+                        data[j + wildcard_size] = data[j];
+                        data[j] = 0;
+                }
+        }
+        
+        return EOK;
+}
+
 /** Parses the character string into the address.
  *
- *  If the string is shorter than the full address, zero bytes are added.
- *
- *  @param[in] family   The address family.
- *  @param[in] address  The character buffer to be parsed.
- *  @param[out] data    The address data to be filled.
- *  @return             EOK on success.
- *  @return             EINVAL if the data parameter is NULL.
- *  @return             ENOENT if the address parameter is NULL.
- *  @return             ENOTSUP if the address family is not supported.
+ * @param[in]  family  The address family.
+ * @param[in]  address The character buffer to be parsed.
+ * @param[out] data    The address data to be filled.
+ *
+ * @return EOK on success.
+ * @return EINVAL if the data parameter is NULL.
+ * @return ENOENT if the address parameter is NULL.
+ * @return ENOTSUP if the address family is not supported.
+ *
  */
 int inet_pton(uint16_t family, const char *address, uint8_t *data)
 {
-        /** The base number of the values. */
-        int base;
-        /** The number of bytes per a section. */
-        size_t bytes;
-        /** The number of bytes of the address data. */
-        int count;
-
-        const char *next;
-        char *last;
-        int index;
-        size_t shift;
-        unsigned long value;
-
-        if (!data)
-                return EINVAL;
-
-        /* Set processing parameters */
         switch (family) {
         case AF_INET:
-                count = 4;
-                base = 10;
-                bytes = 1;
-                break;
-
+                return inet_pton4(address, data);
         case AF_INET6:
-                count = 16;
-                base = 16;
-                bytes = 4;
-                break;
-
+                return inet_pton6(address, data);
         default:
+                /** Unknown address family */
                 return ENOTSUP;
         }
-
-        /* Erase if no address */
-        if (!address) {
-                memset(data, 0, count);
-                return ENOENT;
-        }
-
-        /* Process string from the beginning */
-        next = address;
-        index = 0;
-        do {
-                /* If the actual character is set */
-                if (next && *next) {
-
-                        /* If not on the first character */
-                        if (index) {
-                                /* Move to the next character */
-                                ++next;
-                        }
-
-                        /* Parse the actual integral value */
-                        value = strtoul(next, &last, base);
-                        /*
-                         * Remember the last problematic character
-                         * should be either '.' or ':' but is ignored to be
-                         * more generic
-                         */
-                        next = last;
-
-                        /* Fill the address data byte by byte */
-                        shift = bytes - 1;
-                        do {
-                                /* like little endian */
-                                data[index + shift] = value;
-                                value >>= 8;
-                        } while(shift --);
-
-                        index += bytes;
-                } else {
-                        /* Erase the rest of the address */
-                        memset(data + index, 0, count - index);
-                        return EOK;
-                }
-        } while (index < count);
-
-        return EOK;
 }
 

uspace/lib/c/generic/net/socket_client.c

@@ -87 +87 @@
         /** Parent module service. */
         services_t service;
+        /** Socket family */
+        int family;
 
         /**
@@ -395 +397 @@
         switch (domain) {
         case PF_INET:
+        case PF_INET6:
                 switch (type) {
                 case SOCK_STREAM:
@@ -433 +436 @@
                 break;
 
-        case PF_INET6:
         default:
                 return EPFNOSUPPORT;
@@ -447 +449 @@
 
         memset(socket, 0, sizeof(*socket));
+        socket->family = domain;
         fibril_rwlock_write_lock(&socket_globals.lock);
 

uspace/lib/c/generic/net/socket_parse.c

@@ -79 +79 @@
 int socket_parse_protocol_family(const char *name, int *pf)
 {
+        if (str_lcmp(name, "PF_INET6", 8) == 0) {
+                *pf = PF_INET6;
+                return EOK;
+        }
+
         if (str_lcmp(name, "PF_INET", 7) == 0) {
                 *pf = PF_INET;
-                return EOK;
-        }
-        
-        if (str_lcmp(name, "PF_INET6", 8) == 0) {
-                *pf = PF_INET6;
                 return EOK;
         }

uspace/lib/c/generic/str.c

@@ -1524 +1524 @@
  *
  */
-int str_uint8_t(const char *nptr, char **endptr, unsigned int base,
+int str_uint8_t(const char *nptr, const char **endptr, unsigned int base,
     bool strict, uint8_t *result)
 {
@@ -1571 +1571 @@
  *
  */
-int str_uint16_t(const char *nptr, char **endptr, unsigned int base,
+int str_uint16_t(const char *nptr, const char **endptr, unsigned int base,
     bool strict, uint16_t *result)
 {
@@ -1618 +1618 @@
  *
  */
-int str_uint32_t(const char *nptr, char **endptr, unsigned int base,
+int str_uint32_t(const char *nptr, const char **endptr, unsigned int base,
     bool strict, uint32_t *result)
 {
@@ -1665 +1665 @@
  *
  */
-int str_uint64_t(const char *nptr, char **endptr, unsigned int base,
+int str_uint64_t(const char *nptr, const char **endptr, unsigned int base,
     bool strict, uint64_t *result)
 {
@@ -1704 +1704 @@
  *
  */
-int str_size_t(const char *nptr, char **endptr, unsigned int base,
+int str_size_t(const char *nptr, const char **endptr, unsigned int base,
     bool strict, size_t *result)
 {