Changes in uspace/srv/net/inetsrv/pdu.c [a1a101d:1d24ad3] in mainline

File:

• uspace/srv/net/inetsrv/pdu.c (modified) (5 diffs)

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)
 {
-        void *data;
-        size_t size;
-        ip_header_t *hdr;
-        size_t hdr_size;
-        size_t data_offs;
-        uint16_t chksum;
-        uint16_t ident;
-        uint16_t flags_foff;
-        uint16_t foff;
-        size_t fragoff_limit;
-        size_t xfer_size;
-        size_t spc_avail;
-        size_t rem_offs;
-
+        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 */
-        fragoff_limit = 1 << (FF_FRAGOFF_h - FF_FRAGOFF_l);
-
+        size_t fragoff_limit = 1 << (FF_FRAGOFF_h - FF_FRAGOFF_l);
+        
         /* Verify that total size of datagram is within reasonable bounds */
         if (offs + packet->size > FRAG_OFFS_UNIT * fragoff_limit)
                 return ELIMIT;
-
-        hdr_size = sizeof(ip_header_t);
-        data_offs = ROUND_UP(hdr_size, 4);
-
+        
+        size_t hdr_size;
+        
+        switch (src_af) {
+        case AF_INET:
+                hdr_size = sizeof(ip_header_t);
+                break;
+        case AF_INET6:
+                hdr_size = sizeof(ip6_header_t);
+                break;
+        default:
+                assert(false);
+        }
+        
+        size_t data_offs = ROUND_UP(hdr_size, 4);
+        
         assert(offs % FRAG_OFFS_UNIT == 0);
         assert(offs / FRAG_OFFS_UNIT < fragoff_limit);
-
+        
         /* Value for the fragment offset field */
-        foff = offs / FRAG_OFFS_UNIT;
-
+        uint16_t foff = offs / FRAG_OFFS_UNIT;
+        
         if (hdr_size >= mtu)
                 return EINVAL;
-
+        
         /* Amount of space in the PDU available for payload */
-        spc_avail = mtu - hdr_size;
+        size_t spc_avail = mtu - hdr_size;
         spc_avail -= (spc_avail % FRAG_OFFS_UNIT);
-
+        
         /* Amount of data (payload) to transfer */
-        xfer_size = min(packet->size - offs, spc_avail);
-
+        size_t xfer_size = min(packet->size - offs, spc_avail);
+        
         /* Total PDU size */
-        size = hdr_size + xfer_size;
-
+        size_t size = hdr_size + xfer_size;
+        
         /* Offset of remaining payload */
-        rem_offs = offs + xfer_size;
-
+        size_t rem_offs = offs + xfer_size;
+        
         /* Flags */
-        flags_foff =
+        uint16_t flags_foff =
             (packet->df ? BIT_V(uint16_t, FF_FLAG_DF) : 0) +
             (rem_offs < packet->size ? BIT_V(uint16_t, FF_FLAG_MF) : 0) +
             (foff << FF_FRAGOFF_l);
-
-        data = calloc(size, 1);
+        
+        void *data = calloc(size, 1);
         if (data == NULL)
                 return ENOMEM;
-
+        
         /* Allocate identifier */
         fibril_mutex_lock(&ip_ident_lock);
-        ident = ++ip_ident;
+        uint16_t ident = ++ip_ident;
         fibril_mutex_unlock(&ip_ident_lock);
-
+        
         /* Encode header fields */
-        hdr = (ip_header_t *)data;
-        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(packet->src.ipv4);
-        hdr->dest_addr = host2uint32_t_be(packet->dest.ipv4);
-
-        /* Compute checksum */
-        chksum = inet_checksum_calc(INET_CHECKSUM_INIT, (void *)hdr, hdr_size);
-        hdr->chksum = host2uint16_t_be(chksum);
-
+        ip_header_t *hdr;
+        ip6_header_t *hdr6;
+        
+        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:
+                // TODO FIXME: fragmentation
+                
+                hdr6 = (ip6_header_t *) data;
+                
+                hdr6->ver_tc = (6 << (VI_VERSION_l));
+                memset(hdr6->tc_fl, 0, 3);
+                hdr6->payload_len = host2uint16_t_be(packet->size);
+                hdr6->next = packet->proto;
+                hdr6->hop_limit = packet->ttl;
+                
+                host2addr128_t_be(src_v6, hdr6->src_addr);
+                host2addr128_t_be(dest_v6, hdr6->dest_addr);
+                
+                break;
+        default:
+                assert(false);
+        }
+        
         /* Copy payload */
-        memcpy((uint8_t *)data + data_offs, packet->data + offs, xfer_size);
-
+        memcpy((uint8_t *) data + data_offs, packet->data + offs, xfer_size);
+        
         *rdata = data;
         *rsize = size;
         *roffs = rem_offs;
-
+        
         return EOK;
 }
@@ -196 +233 @@
 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()");
-
+        
         if (size < sizeof(ip_header_t)) {
                 log_msg(LOG_DEFAULT, LVL_DEBUG, "PDU too short (%zu)", size);
                 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);
                 return EINVAL;
         }
-
+        
         if (tot_len > size) {
                 log_msg(LOG_DEFAULT, LVL_DEBUG, "Total Length = %zu > PDU size = %zu",
@@ -231 +260 @@
                 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 */
-
-        packet->src.ipv4 = uint32_t_be2host(hdr->src_addr);
-        packet->dest.ipv4 = uint32_t_be2host(hdr->dest_addr);
+        
+        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;
         packet->ttl = hdr->ttl;
         packet->ident = ident;
-
+        
         packet->df = (flags_foff & BIT_V(uint16_t, FF_FLAG_DF)) != 0;
         packet->mf = (flags_foff & BIT_V(uint16_t, FF_FLAG_MF)) != 0;
         packet->offs = foff * FRAG_OFFS_UNIT;
-
+        
         /* 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);
@@ -259 +288 @@
                 return ENOMEM;
         }
-
-        memcpy(packet->data, (uint8_t *)data + data_offs, packet->size);
-
+        
+        memcpy(packet->data, (uint8_t *) data + data_offs, packet->size);
+        
         return EOK;
 }
 
+int inet_pdu_decode6(void *data, size_t size, inet_packet_t *packet)
+{
+        // FIXME TODO
+        return ENOTSUP;
+}
+
 /** @}
  */