Changeset bdae198 in mainline for uspace/srv/net/inetsrv/pdu.c

Timestamp:

2013-08-04T12:01:10Z (11 years ago)

Author:

Vojtech Horky <vojtechhorky@…>

Branches:

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

Children:

ea50906

Parents:

b08879c2 (diff), d856110 (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

File:

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

uspace/srv/net/inetsrv/pdu.c

@@ -49 +49 @@
 #include "pdu.h"
 
-static FIBRIL_MUTEX_INITIALIZE(ip_ident_lock);
-static uint16_t ip_ident = 0;
-
 /** One's complement addition.
  *
@@ -88 +85 @@
 }
 
-/** Encode Internet PDU.
+/** Encode IPv4 PDU.
  *
  * Encode internet packet into PDU (serialized form). Will encode a
@@ -96 +93 @@
  * be set in the header, otherwise the offset will equal @a packet->size.
  *
- * @param packet        Packet to encode
- * @param offs          Offset into packet payload (in bytes)
- * @param mtu           MTU (Maximum Transmission Unit) in bytes
- * @param rdata         Place to store pointer to allocated data buffer
- * @param rsize         Place to store size of allocated data buffer
- * @param roffs         Place to store offset of remaning data
- */
-int inet_pdu_encode(inet_packet_t *packet, size_t offs, size_t mtu,
-    void **rdata, size_t *rsize, size_t *roffs)
-{
-        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;
-        
+ * @param packet Packet to encode
+ * @param src    Source address
+ * @param dest   Destination address
+ * @param offs   Offset into packet payload (in bytes)
+ * @param mtu    MTU (Maximum Transmission Unit) in bytes
+ * @param rdata  Place to store pointer to allocated data buffer
+ * @param rsize  Place to store size of allocated data buffer
+ * @param roffs  Place to store offset of remaning data
+ *
+ */
+int inet_pdu_encode(inet_packet_t *packet, addr32_t src, addr32_t dest,
+    size_t offs, size_t mtu, void **rdata, size_t *rsize, size_t *roffs)
+{
         /* Upper bound for fragment offset field */
         size_t fragoff_limit = 1 << (FF_FRAGOFF_h - FF_FRAGOFF_l);
@@ -124 +113 @@
                 return ELIMIT;
         
-        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);
-        
+        size_t hdr_size = sizeof(ip_header_t);
+        if (hdr_size >= mtu)
+                return EINVAL;
+        
+        assert(hdr_size % 4 == 0);
         assert(offs % FRAG_OFFS_UNIT == 0);
         assert(offs / FRAG_OFFS_UNIT < fragoff_limit);
@@ -144 +123 @@
         /* Value for the fragment offset field */
         uint16_t foff = offs / FRAG_OFFS_UNIT;
-        
-        if (hdr_size >= mtu)
-                return EINVAL;
         
         /* Amount of space in the PDU available for payload */
@@ -171 +147 @@
                 return ENOMEM;
         
-        /* Allocate identifier */
-        fibril_mutex_lock(&ip_ident_lock);
-        uint16_t ident = ++ip_ident;
-        fibril_mutex_unlock(&ip_ident_lock);
-        
         /* Encode header fields */
-        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);
-        }
+        ip_header_t *hdr = (ip_header_t *) data;
+        
+        hdr->ver_ihl =
+            (4 << VI_VERSION_l) | (hdr_size / sizeof(uint32_t));
+        hdr->tos = packet->tos;
+        hdr->tot_len = host2uint16_t_be(size);
+        hdr->id = host2uint16_t_be(packet->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);
+        hdr->dest_addr = host2uint32_t_be(dest);
+        
+        /* Compute checksum */
+        uint16_t chksum = inet_checksum_calc(INET_CHECKSUM_INIT,
+            (void *) hdr, hdr_size);
+        hdr->chksum = host2uint16_t_be(chksum);
         
         /* Copy payload */
-        memcpy((uint8_t *) data + data_offs, packet->data + offs, xfer_size);
+        memcpy((uint8_t *) data + hdr_size, packet->data + offs, xfer_size);
         
         *rdata = data;
@@ -231 +177 @@
 }
 
+/** Encode IPv6 PDU.
+ *
+ * Encode internet packet into PDU (serialized form). Will encode a
+ * fragment of the payload starting at offset @a offs. The resulting
+ * PDU will have at most @a mtu bytes. @a *roffs will be set to the offset
+ * of remaining payload. If some data is remaining, the MF flag will
+ * be set in the header, otherwise the offset will equal @a packet->size.
+ *
+ * @param packet Packet to encode
+ * @param src    Source address
+ * @param dest   Destination address
+ * @param offs   Offset into packet payload (in bytes)
+ * @param mtu    MTU (Maximum Transmission Unit) in bytes
+ * @param rdata  Place to store pointer to allocated data buffer
+ * @param rsize  Place to store size of allocated data buffer
+ * @param roffs  Place to store offset of remaning data
+ *
+ */
+int inet_pdu_encode6(inet_packet_t *packet, addr128_t src, addr128_t dest,
+    size_t offs, size_t mtu, void **rdata, size_t *rsize, size_t *roffs)
+{
+        /* IPv6 mandates a minimal MTU of 1280 bytes */
+        if (mtu < 1280)
+                return ELIMIT;
+        
+        /* Upper bound for fragment offset field */
+        size_t fragoff_limit = 1 << (OF_FRAGOFF_h - OF_FRAGOFF_l);
+        
+        /* Verify that total size of datagram is within reasonable bounds */
+        if (offs + packet->size > FRAG_OFFS_UNIT * fragoff_limit)
+                return ELIMIT;
+        
+        /* Determine whether we need the Fragment extension header */
+        bool fragment;
+        if (offs == 0)
+                fragment = (packet->size + sizeof(ip6_header_t) > mtu);
+        else
+                fragment = true;
+        
+        size_t hdr_size;
+        if (fragment)
+                hdr_size = sizeof(ip6_header_t) + sizeof(ip6_header_fragment_t);
+        else
+                hdr_size = sizeof(ip6_header_t);
+        
+        if (hdr_size >= mtu)
+                return EINVAL;
+        
+        assert(sizeof(ip6_header_t) % 8 == 0);
+        assert(hdr_size % 8 == 0);
+        assert(offs % FRAG_OFFS_UNIT == 0);
+        assert(offs / FRAG_OFFS_UNIT < fragoff_limit);
+        
+        /* Value for the fragment offset field */
+        uint16_t foff = offs / FRAG_OFFS_UNIT;
+        
+        /* Amount of space in the PDU available for payload */
+        size_t spc_avail = mtu - hdr_size;
+        spc_avail -= (spc_avail % FRAG_OFFS_UNIT);
+        
+        /* Amount of data (payload) to transfer */
+        size_t xfer_size = min(packet->size - offs, spc_avail);
+        
+        /* Total PDU size */
+        size_t size = hdr_size + xfer_size;
+        
+        /* Offset of remaining payload */
+        size_t rem_offs = offs + xfer_size;
+        
+        /* Flags */
+        uint16_t offsmf =
+            (rem_offs < packet->size ? BIT_V(uint16_t, OF_FLAG_M) : 0) +
+            (foff << OF_FRAGOFF_l);
+        
+        void *data = calloc(size, 1);
+        if (data == NULL)
+                return ENOMEM;
+        
+        /* Encode header fields */
+        ip6_header_t *hdr6 = (ip6_header_t *) data;
+        
+        hdr6->ver_tc = (6 << (VI_VERSION_l));
+        memset(hdr6->tc_fl, 0, 3);
+        hdr6->hop_limit = packet->ttl;
+        
+        host2addr128_t_be(src, hdr6->src_addr);
+        host2addr128_t_be(dest, hdr6->dest_addr);
+        
+        /* Optionally encode Fragment extension header fields */
+        if (fragment) {
+                assert(offsmf != 0);
+                
+                hdr6->payload_len = host2uint16_t_be(packet->size +
+                    sizeof(ip6_header_fragment_t));
+                hdr6->next = IP6_NEXT_FRAGMENT;
+                
+                ip6_header_fragment_t *hdr6f = (ip6_header_fragment_t *)
+                    (hdr6 + 1);
+                
+                hdr6f->next = packet->proto;
+                hdr6f->reserved = 0;
+                hdr6f->offsmf = host2uint16_t_be(offsmf);
+                hdr6f->id = host2uint32_t_be(packet->ident);
+        } else {
+                assert(offsmf == 0);
+                
+                hdr6->payload_len = host2uint16_t_be(packet->size);
+                hdr6->next = packet->proto;
+        }
+        
+        /* Copy payload */
+        memcpy((uint8_t *) data + hdr_size, packet->data + offs, xfer_size);
+        
+        *rdata = data;
+        *rsize = size;
+        *roffs = rem_offs;
+        
+        return EOK;
+}
+
+/** Decode IPv4 datagram
+ *
+ * @param data   Serialized IPv4 datagram
+ * @param size   Length of serialized IPv4 datagram
+ * @param packet IP datagram structure to be filled
+ *
+ * @return EOK on success
+ * @return EINVAL if the datagram is invalid or damaged
+ * @return ENOMEM if not enough memory
+ *
+ */
 int inet_pdu_decode(void *data, size_t size, inet_packet_t *packet)
 {
@@ -257 +334 @@
         if (tot_len > size) {
                 log_msg(LOG_DEFAULT, LVL_DEBUG, "Total Length = %zu > PDU size = %zu",
-                        tot_len, size);
+                    tot_len, size);
                 return EINVAL;
         }
@@ -294 +371 @@
 }
 
+/** Decode IPv6 datagram
+ *
+ * @param data   Serialized IPv6 datagram
+ * @param size   Length of serialized IPv6 datagram
+ * @param packet IP datagram structure to be filled
+ *
+ * @return EOK on success
+ * @return EINVAL if the datagram is invalid or damaged
+ * @return ENOMEM if not enough memory
+ *
+ */
 int inet_pdu_decode6(void *data, size_t size, inet_packet_t *packet)
 {
-        // FIXME TODO
-        return ENOTSUP;
+        log_msg(LOG_DEFAULT, LVL_DEBUG, "inet_pdu_decode6()");
+        
+        if (size < sizeof(ip6_header_t)) {
+                log_msg(LOG_DEFAULT, LVL_DEBUG, "PDU too short (%zu)", size);
+                return EINVAL;
+        }
+        
+        ip6_header_t *hdr6 = (ip6_header_t *) data;
+        
+        uint8_t version = BIT_RANGE_EXTRACT(uint8_t, VI_VERSION_h,
+            VI_VERSION_l, hdr6->ver_tc);
+        if (version != 6) {
+                log_msg(LOG_DEFAULT, LVL_DEBUG, "Version (%d) != 6", version);
+                return EINVAL;
+        }
+        
+        size_t payload_len = uint16_t_be2host(hdr6->payload_len);
+        if (payload_len + sizeof(ip6_header_t) > size) {
+                log_msg(LOG_DEFAULT, LVL_DEBUG, "Payload Length = %zu > PDU size = %zu",
+                    payload_len + sizeof(ip6_header_t), size);
+                return EINVAL;
+        }
+        
+        uint32_t ident;
+        uint16_t offsmf;
+        uint16_t foff;
+        uint16_t next;
+        size_t data_offs = sizeof(ip6_header_t);
+        
+        /* Fragment extension header */
+        if (hdr6->next == IP6_NEXT_FRAGMENT) {
+                ip6_header_fragment_t *hdr6f = (ip6_header_fragment_t *)
+                    (hdr6 + 1);
+                
+                ident = uint32_t_be2host(hdr6f->id);
+                offsmf = uint16_t_be2host(hdr6f->offsmf);
+                foff = BIT_RANGE_EXTRACT(uint16_t, OF_FRAGOFF_h, OF_FRAGOFF_l,
+                    offsmf);
+                next = hdr6f->next;
+                data_offs += sizeof(ip6_header_fragment_t);
+                payload_len -= sizeof(ip6_header_fragment_t);
+        } else {
+                ident = 0;
+                offsmf = 0;
+                foff = 0;
+                next = hdr6->next;
+        }
+        
+        addr128_t src;
+        addr128_t dest;
+        
+        addr128_t_be2host(hdr6->src_addr, src);
+        inet_addr_set6(src, &packet->src);
+        
+        addr128_t_be2host(hdr6->dest_addr, dest);
+        inet_addr_set6(dest, &packet->dest);
+        
+        packet->tos = 0;
+        packet->proto = next;
+        packet->ttl = hdr6->hop_limit;
+        packet->ident = ident;
+        
+        packet->df = 1;
+        packet->mf = (offsmf & BIT_V(uint16_t, OF_FLAG_M)) != 0;
+        packet->offs = foff * FRAG_OFFS_UNIT;
+        
+        packet->size = payload_len;
+        packet->data = calloc(packet->size, 1);
+        if (packet->data == NULL) {
+                log_msg(LOG_DEFAULT, LVL_WARN, "Out of memory.");
+                return ENOMEM;
+        }
+        
+        memcpy(packet->data, (uint8_t *) data + data_offs, packet->size);
+        
+        return EOK;
+}
+
+/** Encode NDP packet
+ *
+ * @param ndp   NDP packet structure to be serialized
+ * @param dgram IPv6 datagram structure to be filled
+ *
+ * @return EOK on success
+ *
+ */
+int ndp_pdu_encode(ndp_packet_t *ndp, inet_dgram_t *dgram)
+{
+        inet_addr_set6(ndp->sender_proto_addr, &dgram->src);
+        inet_addr_set6(ndp->target_proto_addr, &dgram->dest);
+        dgram->tos = 0;
+        dgram->size = sizeof(icmpv6_message_t) + sizeof(ndp_message_t);
+        
+        dgram->data = calloc(1, dgram->size);
+        if (dgram->data == NULL)
+                return ENOMEM;
+        
+        icmpv6_message_t *icmpv6 = (icmpv6_message_t *) dgram->data;
+        
+        icmpv6->type = ndp->opcode;
+        icmpv6->code = 0;
+        memset(icmpv6->un.ndp.reserved, 0, 3);
+        
+        ndp_message_t *message = (ndp_message_t *) (icmpv6 + 1);
+        
+        if (ndp->opcode == ICMPV6_NEIGHBOUR_SOLICITATION) {
+                host2addr128_t_be(ndp->solicited_ip, message->target_address);
+                message->option = 1;
+                icmpv6->un.ndp.flags = 0;
+        } else {
+                host2addr128_t_be(ndp->sender_proto_addr, message->target_address);
+                message->option = 2;
+                icmpv6->un.ndp.flags = NDP_FLAG_OVERRIDE | NDP_FLAG_SOLICITED;
+        }
+        
+        message->length = 1;
+        addr48(ndp->sender_hw_addr, message->mac);
+        
+        icmpv6_phdr_t phdr;
+        
+        host2addr128_t_be(ndp->sender_proto_addr, phdr.src_addr);
+        host2addr128_t_be(ndp->target_proto_addr, phdr.dest_addr);
+        phdr.length = host2uint32_t_be(dgram->size);
+        memset(phdr.zeroes, 0, 3);
+        phdr.next = IP_PROTO_ICMPV6;
+        
+        uint16_t cs_phdr =
+            inet_checksum_calc(INET_CHECKSUM_INIT, &phdr,
+            sizeof(icmpv6_phdr_t));
+        
+        uint16_t cs_all = inet_checksum_calc(cs_phdr, dgram->data,
+            dgram->size);
+        
+        icmpv6->checksum = host2uint16_t_be(cs_all);
+        
+        return EOK;
+}
+
+/** Decode NDP packet
+ *
+ * @param dgram Incoming IPv6 datagram encapsulating NDP packet
+ * @param ndp   NDP packet structure to be filled
+ *
+ * @return EOK on success
+ * @return EINVAL if the Datagram is invalid
+ *
+ */
+int ndp_pdu_decode(inet_dgram_t *dgram, ndp_packet_t *ndp)
+{
+        uint16_t src_af = inet_addr_get(&dgram->src, NULL,
+            &ndp->sender_proto_addr);
+        if (src_af != AF_INET6)
+                return EINVAL;
+        
+        if (dgram->size < sizeof(icmpv6_message_t) + sizeof(ndp_message_t))
+                return EINVAL;
+        
+        icmpv6_message_t *icmpv6 = (icmpv6_message_t *) dgram->data;
+        
+        ndp->opcode = icmpv6->type;
+        
+        ndp_message_t *message = (ndp_message_t *) (icmpv6 + 1);
+        
+        addr128_t_be2host(message->target_address, ndp->target_proto_addr);
+        addr48(message->mac, ndp->sender_hw_addr);
+        
+        return EOK;
 }