Changes in uspace/srv/net/inetsrv/inet_link.c [a1a101d:c3b25985] in mainline

File:

• uspace/srv/net/inetsrv/inet_link.c (modified) (6 diffs)

uspace/srv/net/inetsrv/inet_link.c

@@ -35 +35 @@
  */
 
-#include <bool.h>
+#include <stdbool.h>
 #include <errno.h>
 #include <fibril_synch.h>
@@ -43 +43 @@
 #include <stdlib.h>
 #include <str.h>
-
 #include "addrobj.h"
 #include "inetsrv.h"
@@ -49 +48 @@
 #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 bool first_link = true;
+static bool first_link6 = true;
+
+static FIBRIL_MUTEX_INITIALIZE(ip_ident_lock);
+static uint16_t ip_ident = 0;
+
+static int inet_iplink_recv(iplink_t *, iplink_recv_sdu_t *, ip_ver_t);
+static int inet_iplink_change_addr(iplink_t *, addr48_t);
+static inet_link_t *inet_link_get_by_id_locked(sysarg_t);
 
 static iplink_ev_ops_t inet_iplink_ev_ops = {
-        .recv = inet_iplink_recv
+        .recv = inet_iplink_recv,
+        .change_addr = inet_iplink_change_addr,
 };
 
-static LIST_INITIALIZE(inet_link_list);
-static FIBRIL_MUTEX_INITIALIZE(inet_discovery_lock);
-
-static int inet_iplink_recv(iplink_t *iplink, iplink_sdu_t *sdu)
-{
+static LIST_INITIALIZE(inet_links);
+static FIBRIL_MUTEX_INITIALIZE(inet_links_lock);
+
+static addr128_t link_local_node_ip =
+    {0xfe, 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xff, 0xfe, 0, 0, 0};
+
+static void inet_link_local_node_ip(addr48_t mac_addr,
+    addr128_t ip_addr)
+{
+        memcpy(ip_addr, link_local_node_ip, 16);
+        
+        ip_addr[8] = mac_addr[0] ^ 0x02;
+        ip_addr[9] = mac_addr[1];
+        ip_addr[10] = mac_addr[2];
+        ip_addr[13] = mac_addr[3];
+        ip_addr[14] = mac_addr[4];
+        ip_addr[15] = mac_addr[5];
+}
+
+static int inet_iplink_recv(iplink_t *iplink, iplink_recv_sdu_t *sdu, ip_ver_t ver)
+{
+        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 (ver) {
+        case ip_v4:
+                rc = inet_pdu_decode(sdu->data, sdu->size, &packet);
+                break;
+        case ip_v6:
+                rc = inet_pdu_decode6(sdu->data, sdu->size, &packet);
+                break;
+        default:
+                log_msg(LOG_DEFAULT, LVL_DEBUG, "invalid IP version");
+                return EINVAL;
+        }
+        
         if (rc != EOK) {
                 log_msg(LOG_DEFAULT, LVL_DEBUG, "failed decoding PDU");
                 return rc;
         }
-
+        
         log_msg(LOG_DEFAULT, LVL_DEBUG, "call inet_recv_packet()");
         rc = inet_recv_packet(&packet);
         log_msg(LOG_DEFAULT, LVL_DEBUG, "call inet_recv_packet -> %d", rc);
         free(packet.data);
-
+        
         return rc;
 }
 
-static int inet_link_check_new(void)
-{
-        bool already_known;
-        category_id_t iplink_cat;
-        service_id_t *svcs;
-        size_t count, i;
-        int rc;
-
-        fibril_mutex_lock(&inet_discovery_lock);
-
-        rc = loc_category_get_id("iplink", &iplink_cat, IPC_FLAG_BLOCKING);
-        if (rc != EOK) {
-                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed resolving category 'iplink'.");
-                fibril_mutex_unlock(&inet_discovery_lock);
-                return ENOENT;
-        }
-
-        rc = loc_category_get_svcs(iplink_cat, &svcs, &count);
-        if (rc != EOK) {
-                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed getting list of IP links.");
-                fibril_mutex_unlock(&inet_discovery_lock);
-                return EIO;
-        }
-
-        for (i = 0; i < count; i++) {
-                already_known = false;
-
-                list_foreach(inet_link_list, ilink_link) {
-                        inet_link_t *ilink = list_get_instance(ilink_link,
-                            inet_link_t, link_list);
-                        if (ilink->svc_id == svcs[i]) {
-                                already_known = true;
-                                break;
-                        }
-                }
-
-                if (!already_known) {
-                        log_msg(LOG_DEFAULT, LVL_DEBUG, "Found IP link '%lu'",
-                            (unsigned long) svcs[i]);
-                        rc = inet_link_open(svcs[i]);
-                        if (rc != EOK)
-                                log_msg(LOG_DEFAULT, LVL_ERROR, "Could not open IP link.");
-                }
-        }
-
-        fibril_mutex_unlock(&inet_discovery_lock);
+static int inet_iplink_change_addr(iplink_t *iplink, addr48_t mac)
+{
+        log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_iplink_change_addr(): "
+            "new addr=%02x:%02x:%02x:%02x:%02x:%02x",
+            mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
+
+        list_foreach(inet_links, link_list, inet_link_t, ilink) {
+                if (ilink->sess == iplink->sess)
+                        memcpy(&ilink->mac, mac, sizeof(addr48_t));
+        }
+
         return EOK;
 }
@@ -147 +147 @@
         if (ilink->svc_name != NULL)
                 free(ilink->svc_name);
+        
         free(ilink);
 }
 
-static int inet_link_open(service_id_t sid)
+int inet_link_open(service_id_t sid)
 {
         inet_link_t *ilink;
-        iplink_addr_t iaddr;
+        inet_addr_t iaddr;
         int rc;
 
@@ -189 +190 @@
                 goto error;
         }
+        
+        /*
+         * Get the MAC address of the link. If the link has a MAC
+         * address, we assume that it supports NDP.
+         */
+        rc = iplink_get_mac48(ilink->iplink, &ilink->mac);
+        ilink->mac_valid = (rc == EOK);
 
         log_msg(LOG_DEFAULT, LVL_DEBUG, "Opened IP link '%s'", ilink->svc_name);
-        list_append(&ilink->link_list, &inet_link_list);
-
-        inet_addrobj_t *addr;
-
-        static int first = 1;
-        /* XXX For testing: set static IP address 192.168.0.4/24 */
-        addr = inet_addrobj_new();
-        if (first) {
-                addr->naddr.ipv4 = (127 << 24) + (0 << 16) + (0 << 8) + 1;
-                first = 0;
-        } else {
-                addr->naddr.ipv4 = (192 << 24) + (168 << 16) + (0 << 8) + 4;
-        }
-        addr->naddr.bits = 24;
-        addr->ilink = ilink;
-        addr->name = str_dup("v4a");
-        rc = inet_addrobj_add(addr);
-        if (rc != EOK) {
-                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed setting IP address on internet link.");
-                inet_addrobj_delete(addr);
-                /* XXX Roll back */
-                return rc;
-        }
-
-        iaddr.ipv4 = addr->naddr.ipv4;
-        rc = iplink_addr_add(ilink->iplink, &iaddr);
-        if (rc != EOK) {
-                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed setting IP address on internet link.");
-                inet_addrobj_remove(addr);
-                inet_addrobj_delete(addr);
-                /* XXX Roll back */
-                return rc;
-        }
-
+
+        fibril_mutex_lock(&inet_links_lock);
+
+        if (inet_link_get_by_id_locked(sid) != NULL) {
+                fibril_mutex_unlock(&inet_links_lock);
+                log_msg(LOG_DEFAULT, LVL_DEBUG, "Link %zu already open",
+                    sid);
+                rc = EEXIST;
+                goto error;
+        }
+
+        list_append(&ilink->link_list, &inet_links);
+        fibril_mutex_unlock(&inet_links_lock);
+
+        inet_addrobj_t *addr = NULL;
+        
+        /* XXX FIXME Cannot rely on loopback being the first IP link service!! */
+        if (first_link) {
+                addr = inet_addrobj_new();
+                
+                inet_naddr(&addr->naddr, 127, 0, 0, 1, 24);
+                first_link = false;
+        }
+        
+        if (addr != NULL) {
+                addr->ilink = ilink;
+                addr->name = str_dup("v4a");
+                
+                rc = inet_addrobj_add(addr);
+                if (rc == EOK) {
+                        inet_naddr_addr(&addr->naddr, &iaddr);
+                        rc = iplink_addr_add(ilink->iplink, &iaddr);
+                        if (rc != EOK) {
+                                log_msg(LOG_DEFAULT, LVL_ERROR,
+                                    "Failed setting IPv4 address on internet link.");
+                                inet_addrobj_remove(addr);
+                                inet_addrobj_delete(addr);
+                        }
+                } else {
+                        log_msg(LOG_DEFAULT, LVL_ERROR, "Failed adding IPv4 address.");
+                        inet_addrobj_delete(addr);
+                }
+        }
+        
+        inet_addrobj_t *addr6 = NULL;
+        
+        if (first_link6) {
+                addr6 = inet_addrobj_new();
+                
+                inet_naddr6(&addr6->naddr, 0, 0, 0, 0, 0, 0, 0, 1, 128);
+                first_link6 = false;
+        } else if (ilink->mac_valid) {
+                addr6 = inet_addrobj_new();
+                
+                addr128_t link_local;
+                inet_link_local_node_ip(ilink->mac, link_local);
+                
+                inet_naddr_set6(link_local, 64, &addr6->naddr);
+        }
+        
+        if (addr6 != NULL) {
+                addr6->ilink = ilink;
+                addr6->name = str_dup("v6a");
+                
+                rc = inet_addrobj_add(addr6);
+                if (rc == EOK) {
+                        inet_naddr_addr(&addr6->naddr, &iaddr);
+                        rc = iplink_addr_add(ilink->iplink, &iaddr);
+                        if (rc != EOK) {
+                                log_msg(LOG_DEFAULT, LVL_ERROR,
+                                    "Failed setting IPv6 address on internet link.");
+                                inet_addrobj_remove(addr6);
+                                inet_addrobj_delete(addr6);
+                        }
+                } else {
+                        log_msg(LOG_DEFAULT, LVL_ERROR, "Failed adding IPv6 address.");
+                        inet_addrobj_delete(addr6);
+                }
+        }
+        
+        log_msg(LOG_DEFAULT, LVL_DEBUG, "Configured link '%s'.", ilink->svc_name);
         return EOK;
-
+        
 error:
         if (ilink->iplink != NULL)
                 iplink_close(ilink->iplink);
+        
         inet_link_delete(ilink);
         return rc;
 }
 
-static void inet_link_cat_change_cb(void)
-{
-        (void) inet_link_check_new();
-}
-
-int inet_link_discovery_start(void)
-{
-        int rc;
-
-        rc = loc_register_cat_change_cb(inet_link_cat_change_cb);
-        if (rc != EOK) {
-                log_msg(LOG_DEFAULT, LVL_ERROR, "Failed registering callback for IP link "
-                    "discovery (%d).", rc);
-                return rc;
-        }
-
-        return inet_link_check_new();
-}
-
-/** Send datagram over Internet link */
-int inet_link_send_dgram(inet_link_t *ilink, inet_addr_t *lsrc,
-    inet_addr_t *ldest, inet_dgram_t *dgram, uint8_t proto, uint8_t ttl, int df)
-{
-        iplink_sdu_t sdu;
-        inet_packet_t packet;
-        int rc;
-        size_t offs, roffs;
-
+/** Send IPv4 datagram over Internet link
+ *
+ * @param ilink Internet link
+ * @param lsrc  Source IPv4 address
+ * @param ldest Destination IPv4 address
+ * @param dgram IPv4 datagram body
+ * @param proto Protocol
+ * @param ttl   Time-to-live
+ * @param df    Do-not-Fragment flag
+ *
+ * @return EOK on success
+ * @return ENOMEM when not enough memory to create the datagram
+ * @return ENOTSUP if networking mode is not supported
+ *
+ */
+int inet_link_send_dgram(inet_link_t *ilink, addr32_t lsrc, addr32_t ldest,
+    inet_dgram_t *dgram, uint8_t proto, uint8_t ttl, int df)
+{
+        addr32_t src_v4;
+        ip_ver_t src_ver = inet_addr_get(&dgram->src, &src_v4, NULL);
+        if (src_ver != ip_v4)
+                return EINVAL;
+        
+        addr32_t dest_v4;
+        ip_ver_t dest_ver = inet_addr_get(&dgram->dest, &dest_v4, NULL);
+        if (dest_ver != ip_v4)
+                return EINVAL;
+        
         /*
          * Fill packet structure. Fragmentation is performed by
          * inet_pdu_encode().
          */
+        
+        iplink_sdu_t sdu;
+        
+        sdu.src = lsrc;
+        sdu.dest = ldest;
+        
+        inet_packet_t packet;
+        
         packet.src = dgram->src;
         packet.dest = dgram->dest;
@@ -271 +335 @@
         packet.proto = proto;
         packet.ttl = ttl;
+        
+        /* Allocate identifier */
+        fibril_mutex_lock(&ip_ident_lock);
+        packet.ident = ++ip_ident;
+        fibril_mutex_unlock(&ip_ident_lock);
+        
         packet.df = df;
         packet.data = dgram->data;
         packet.size = dgram->size;
-
-        sdu.lsrc.ipv4 = lsrc->ipv4;
-        sdu.ldest.ipv4 = ldest->ipv4;
-
-        offs = 0;
+        
+        int rc;
+        size_t offs = 0;
+        
         do {
                 /* Encode one fragment */
-                rc = inet_pdu_encode(&packet, offs, ilink->def_mtu, &sdu.data,
-                    &sdu.size, &roffs);
+                
+                size_t roffs;
+                rc = inet_pdu_encode(&packet, src_v4, dest_v4, offs, ilink->def_mtu,
+                    &sdu.data, &sdu.size, &roffs);
                 if (rc != EOK)
                         return rc;
-
+                
                 /* Send the PDU */
                 rc = iplink_send(ilink->iplink, &sdu);
+                
                 free(sdu.data);
-
                 offs = roffs;
         } while (offs < packet.size);
-
+        
         return rc;
 }
 
+/** Send IPv6 datagram over Internet link
+ *
+ * @param ilink Internet link
+ * @param ldest Destination MAC address
+ * @param dgram IPv6 datagram body
+ * @param proto Next header
+ * @param ttl   Hop limit
+ * @param df    Do-not-Fragment flag (unused)
+ *
+ * @return EOK on success
+ * @return ENOMEM when not enough memory to create the datagram
+ *
+ */
+int inet_link_send_dgram6(inet_link_t *ilink, addr48_t ldest,
+    inet_dgram_t *dgram, uint8_t proto, uint8_t ttl, int df)
+{
+        addr128_t src_v6;
+        ip_ver_t src_ver = inet_addr_get(&dgram->src, NULL, &src_v6);
+        if (src_ver != ip_v6)
+                return EINVAL;
+        
+        addr128_t dest_v6;
+        ip_ver_t dest_ver = inet_addr_get(&dgram->dest, NULL, &dest_v6);
+        if (dest_ver != ip_v6)
+                return EINVAL;
+        
+        iplink_sdu6_t sdu6;
+        addr48(ldest, sdu6.dest);
+        
+        /*
+         * Fill packet structure. Fragmentation is performed by
+         * inet_pdu_encode6().
+         */
+        
+        inet_packet_t packet;
+        
+        packet.src = dgram->src;
+        packet.dest = dgram->dest;
+        packet.tos = dgram->tos;
+        packet.proto = proto;
+        packet.ttl = ttl;
+        
+        /* Allocate identifier */
+        fibril_mutex_lock(&ip_ident_lock);
+        packet.ident = ++ip_ident;
+        fibril_mutex_unlock(&ip_ident_lock);
+        
+        packet.df = df;
+        packet.data = dgram->data;
+        packet.size = dgram->size;
+        
+        int rc;
+        size_t offs = 0;
+        
+        do {
+                /* Encode one fragment */
+                
+                size_t roffs;
+                rc = inet_pdu_encode6(&packet, src_v6, dest_v6, offs, ilink->def_mtu,
+                    &sdu6.data, &sdu6.size, &roffs);
+                if (rc != EOK)
+                        return rc;
+                
+                /* Send the PDU */
+                rc = iplink_send6(ilink->iplink, &sdu6);
+                
+                free(sdu6.data);
+                offs = roffs;
+        } while (offs < packet.size);
+        
+        return rc;
+}
+
+static inet_link_t *inet_link_get_by_id_locked(sysarg_t link_id)
+{
+        assert(fibril_mutex_is_locked(&inet_links_lock));
+
+        list_foreach(inet_links, link_list, inet_link_t, ilink) {
+                if (ilink->svc_id == link_id)
+                        return ilink;
+        }
+
+        return NULL;
+}
+
 inet_link_t *inet_link_get_by_id(sysarg_t link_id)
 {
-        fibril_mutex_lock(&inet_discovery_lock);
-
-        list_foreach(inet_link_list, elem) {
-                inet_link_t *ilink = list_get_instance(elem, inet_link_t,
-                    link_list);
-
-                if (ilink->svc_id == link_id) {
-                        fibril_mutex_unlock(&inet_discovery_lock);
-                        return ilink;
-                }
-        }
-
-        fibril_mutex_unlock(&inet_discovery_lock);
-        return NULL;
+        inet_link_t *ilink;
+
+        fibril_mutex_lock(&inet_links_lock);
+        ilink = inet_link_get_by_id_locked(link_id);
+        fibril_mutex_unlock(&inet_links_lock);
+
+        return ilink;
+}
+
+/** Get IDs of all links. */
+int inet_link_get_id_list(sysarg_t **rid_list, size_t *rcount)
+{
+        sysarg_t *id_list;
+        size_t count, i;
+
+        fibril_mutex_lock(&inet_links_lock);
+        count = list_count(&inet_links);
+
+        id_list = calloc(count, sizeof(sysarg_t));
+        if (id_list == NULL) {
+                fibril_mutex_unlock(&inet_links_lock);
+                return ENOMEM;
+        }
+
+        i = 0;
+        list_foreach(inet_links, link_list, inet_link_t, ilink) {
+                id_list[i++] = ilink->svc_id;
+        }
+
+        fibril_mutex_unlock(&inet_links_lock);
+
+        *rid_list = id_list;
+        *rcount = count;
+
+        return EOK;
 }