[3/3]
>From c54a80f4eeb9665992a9eb56191e523384d4e826 Mon Sep 17 00:00:00 2001
From: Alexander Smirnov <[email protected]>
Date: Mon, 27 Jun 2011 13:59:47 +0400
Subject: [PATCH 3/3] Basic support for 6lowpan.
Currently it's possible to send/receive ipv6 data over wpan interface
without acks.
The following features are not implemented yet:
1. Fragmentation;
2. UDP header compress/parse;
3. Next Header compress parse.
NOTE:
This is the first attempt to implement IPv6 support over lowpan.
There are a plenty of comments, debug messages and TODO in code
wich helps to debug/develop and which are to-be-removed in future.
Based on Jon Smirl code.
Signed-off-by: Alexander Smirnov <[email protected]>
---
include/linux/nl802154.h | 1 +
net/mac802154/6lowpan.c | 720 ++++++++++++++++++++++++++++++++++++++++++++++
net/mac802154/6lowpan.h | 170 +++++++++++
net/mac802154/Kconfig | 6 +
net/mac802154/Makefile | 6 +-
net/mac802154/main.c | 5 +
net/mac802154/wpan.c | 2 +-
7 files changed, 908 insertions(+), 2 deletions(-)
create mode 100644 net/mac802154/6lowpan.c
create mode 100644 net/mac802154/6lowpan.h
diff --git a/include/linux/nl802154.h b/include/linux/nl802154.h
index a379fc7..72c686c 100644
--- a/include/linux/nl802154.h
+++ b/include/linux/nl802154.h
@@ -129,6 +129,7 @@ enum {
IEEE802154_DEV_WPAN,
IEEE802154_DEV_MONITOR,
IEEE802154_DEV_SMAC,
+ IEEE802154_DEV_6LOWPAN,
__IEEE802154_DEV_MAX,
};
diff --git a/net/mac802154/6lowpan.c b/net/mac802154/6lowpan.c
new file mode 100644
index 0000000..c286092
--- /dev/null
+++ b/net/mac802154/6lowpan.c
@@ -0,0 +1,720 @@
+#include <linux/if_arp.h>
+#include <linux/netdevice.h>
+#include <linux/nl802154.h>
+#include <net/ipv6.h>
+#include <net/mac802154.h>
+#include <net/ieee802154.h>
+#include <net/ieee802154_netdev.h>
+
+#include "6lowpan.h"
+#include "mac802154.h"
+
+#ifdef DEBUG
+
+#define LOWPAN_DEBUG 1
+#undef pr_debug
+#define pr_debug(fmt, ...) \
+ printk(pr_fmt(fmt), ##__VA_ARGS__)
+
+#endif
+
+/* TTL uncompression values */
+static const u8 ttl_values[] = {0, 1, 64, 255};
+
+/*
+ * Uncompression of linklocal:
+ * 0 -> 16 bytes from packet
+ * 1 -> 2 bytes from prefix - bunch of zeroes and 8 from packet
+ * 2 -> 2 bytes from prefix - zeroes + 2 from packet
+ * 3 -> 2 bytes from prefix - infer 8 bytes from lladdr
+ *
+ * NOTE: => the uncompress function does change 0xf to 0x10
+ * NOTE: 0x00 => no-autoconfig => unspecified
+ */
+const u8 unc_llconf[] = {0x0f,0x28,0x22,0x20};
+
+/*
+ * Uncompression of ctx-based:
+ * 0 -> 0 bits from packet [unspecified / reserved]
+ * 1 -> 8 bytes from prefix - bunch of zeroes and 8 from packet
+ * 2 -> 8 bytes from prefix - zeroes + 2 from packet
+ * 3 -> 8 bytes from prefix - infer 8 bytes from lladdr
+ */
+const u8 unc_ctxconf[] = {0x00,0x88,0x82,0x80};
+
+/*
+ * Uncompression of ctx-base
+ * 0 -> 0 bits from packet
+ * 1 -> 2 bytes from prefix - bunch of zeroes 5 from packet
+ * 2 -> 2 bytes from prefix - zeroes + 3 from packet
+ * 3 -> 2 bytes from prefix - infer 1 bytes from lladdr
+ */
+const u8 unc_mxconf[] = {0x0f, 0x25, 0x23, 0x21};
+
+/* Link local prefix */
+const u8 llprefix[] = {0xfe, 0x80};
+
+/* TODO: lists instead of static allocation? */
+#define LOWPAN_CONF_MAX_ADDR_CONTEXTS 8
+static struct lowpan_addr_context
+ addr_contexts[LOWPAN_CONF_MAX_ADDR_CONTEXTS];
+
+/* Find the context corresponding to prefix ipaddr */
+static struct lowpan_addr_context*
+addr_context_lookup_by_prefix(const struct in6_addr *ipaddr)
+{
+ int i;
+
+ for(i = 0; i < LOWPAN_CONF_MAX_ADDR_CONTEXTS; i++) {
+ if((addr_contexts[i].used == 1) &&
+ ipaddr_prefixcmp(&addr_contexts[i].prefix, ipaddr->s6_addr,
64))
+ return &addr_contexts[i];
+ }
+ return NULL;
+}
+
+/* Find the context with the given number */
+static struct lowpan_addr_context*
+addr_context_lookup_by_number(u8 number)
+{
+ int i;
+
+ for(i = 0; i < LOWPAN_CONF_MAX_ADDR_CONTEXTS; i++) {
+ if((addr_contexts[i].used == 1) &&
+ addr_contexts[i].number == number)
+ return &addr_contexts[i];
+ }
+ return NULL;
+}
+
+static u8
+compress_addr_64(u8 **hc06_ptr, u8 bitpos, const struct in6_addr *ipaddr,
+ const unsigned char lladdr[IEEE802154_ALEN])
+{
+ if (is_addr_mac_addr_based(ipaddr, lladdr))
+ return 3 << bitpos; /* 0-bits */
+
+ else if (lowpan_is_iid_16_bit_compressable(ipaddr)) {
+ /* compress IID to 16 bits xxxx::XXXX */
+ memcpy(*hc06_ptr, &ipaddr->s6_addr16[7], 2);
+ *hc06_ptr += 2;
+ return 2 << bitpos; /* 16-bits */
+ }
+ /* do not compress IID => xxxx::IID */
+ memcpy(*hc06_ptr, &ipaddr->s6_addr16[4], 8);
+ *hc06_ptr += 8;
+ return 1 << bitpos; /* 64-bits */
+}
+
+void
+uip_ds6_set_addr_iid(struct in6_addr *ipaddr, unsigned char *lladdr)
+{
+ memcpy(&ipaddr->s6_addr[8], lladdr, IEEE802154_ALEN);
+ ipaddr->s6_addr[8] ^= 0x02;
+}
+
+/*
+ * Uncompress addresses based on a prefix and a postfix with zeroes in
+ * between. If the postfix is zero in length it will use the link address
+ * to configure the IP address (autoconf style).
+ * pref_post_count takes a byte where the first nibble specify prefix count
+ * and the second postfix count (NOTE: 15/0xf => 16 bytes copy).
+ */
+static void
+uncompress_addr(struct sk_buff *skb, struct in6_addr *ipaddr, u8 const *prefix,
+ u8 pref_post_count, unsigned char *lladdr)
+{
+ int tmp;
+ u8 prefcount = pref_post_count >> 4;
+ u8 postcount = pref_post_count & 0x0f;
+
+ /* full nibble 15 => 16 */
+ prefcount = prefcount == 15 ? 16 : prefcount;
+ postcount = postcount == 15 ? 16 : postcount;
+
+#ifdef LOWPAN_DEBUG
+ if (lladdr) {
+ pr_debug("(%s): link local address: ", __func__);
+ for (tmp = 0; tmp < IEEE802154_ALEN; tmp++)
+ pr_debug("%02x", lladdr[tmp]);
+ pr_debug("\n");
+ }
+ printk("(%s): uncompressing %d + %d => ", __func__, prefcount,
postcount);
+#endif /* LOWPAN_DEBUG */
+
+ if (prefcount > 0)
+ memcpy(ipaddr, prefix, prefcount);
+
+ if (prefcount + postcount < 16)
+ memset(&ipaddr->s6_addr[prefcount], 0, 16 - (prefcount +
postcount));
+
+ if (postcount > 0) {
+ memcpy(&ipaddr->s6_addr[16 - postcount], skb->data, postcount);
+ skb_pull(skb, postcount);
+ } else
+ if (prefcount > 0)
+ /* no IID based configuration if no prefix and no data =>
unspec */
+ uip_ds6_set_addr_iid(ipaddr, lladdr);
+
+#ifdef LOWPAN_DEBUG
+ for (tmp = 0; tmp < 16; tmp++)
+ pr_debug("%02x", ipaddr->s6_addr[tmp]);
+ pr_debug("\n");
+#endif /* LOWPAN_DEBUG */
+}
+
+/*
+ * TODO: this function derived from wpan.c, find better way to share it
+ * instead of copy-past
+ */
+static u8 fetch_skb_u8(struct sk_buff *skb)
+{
+ u8 ret;
+
+ BUG_ON(skb->len < 1);
+
+ ret = skb->data[0];
+ skb_pull(skb, 1);
+
+ return ret;
+}
+
+static int
+lowpan_process_data(struct net_device *dev, struct sk_buff *skb,
+ unsigned char _saddr[IEEE802154_ALEN],
+ unsigned char _daddr[IEEE802154_ALEN])
+{
+ struct ipv6hdr hdr;
+ u8 tmp, iphc0, iphc1, num_context = 0;
+ struct lowpan_addr_context *context = NULL;
+
+ /* at least two byte will be used for the encoding */
+ iphc0 = fetch_skb_u8(skb);
+ iphc1 = fetch_skb_u8(skb);
+
+#ifdef LOWPAN_DEBUG
+ pr_debug("(%s): raw skb data dump:", __func__);
+ for (tmp = 0; tmp < skb->len; tmp++) {
+ if (tmp % 16 == 0)
+ pr_debug("\n\t0x%04x: ", tmp);
+ pr_debug("%02x ", skb->data[tmp]);
+ }
+ pr_debug("\n");
+#endif /* LOWPAN_DEBUG */
+
+ pr_debug("(%s): iphc0 = %02x, iphc1 = %02x\n", __func__, iphc0, iphc1);
+
+ /* another if the CID flag is set */
+ if(iphc1 & LOWPAN_IPHC_CID) {
+ pr_debug("(%s): CID flag is set, increase header with one\n",
__func__);
+ num_context = fetch_skb_u8(skb);
+ }
+
+ hdr.version = 6;
+
+ /* Traffic Class and Flow Label */
+ switch ((iphc0 & LOWPAN_IPHC_TF) >> 3) {
+ /*
+ * Traffic Class and FLow Label carried in-line
+ * ECN + DSCP + 4-bit Pad + Flow Label (4 bytes)
+ */
+ case 0: /* 00b */
+ tmp = fetch_skb_u8(skb);
+ memcpy(&hdr.flow_lbl, &skb->data[0], 3);
+ skb_pull(skb, 3);
+ hdr.priority = ((tmp >> 2) & 0x0f);
+ hdr.flow_lbl[0] = ((tmp >> 2) & 0x30) | (tmp << 6) |
(hdr.flow_lbl[0] & 0x0f);
+ break;
+ /*
+ * Traffic class carried in-line
+ * ECN + DSCP (1 byte), Flow Label is elided
+ */
+ case 1: /* 10b */
+ tmp = fetch_skb_u8(skb);
+ hdr.priority = ((tmp >> 2) & 0x0f);
+ hdr.flow_lbl[0] = ((tmp << 6) & 0xC0) | ((tmp >> 2) & 0x30);
+ hdr.flow_lbl[1] = 0;
+ hdr.flow_lbl[2] = 0;
+ break;
+ /*
+ * Flow Label carried in-line
+ * ECN + 2-bit Pad + Flow Label (3 bytes), DSCP is elided
+ */
+ case 2: /* 01b */
+ tmp = fetch_skb_u8(skb);
+ hdr.flow_lbl[0] = (skb->data[0] & 0x0F) | ((tmp >> 2) & 0x30);
+ memcpy(&hdr.flow_lbl[1], &skb->data[0], 2);
+ skb_pull(skb, 2);
+ break;
+ /* Traffic Class and Flow Label are elided */
+ case 3: /* 11b */
+ hdr.priority = 0;
+ hdr.flow_lbl[0] = 0;
+ hdr.flow_lbl[1] = 0;
+ hdr.flow_lbl[2] = 0;
+ break;
+ default:
+ break;
+ }
+
+ /* Next Header */
+ if ((iphc0 & LOWPAN_IPHC_NH_C) == 0) {
+ /* Next header is carried inline */
+ hdr.nexthdr = fetch_skb_u8(skb);
+ pr_debug("(%s): NH flag is set, next header is carried inline:
%02x\n", __func__, hdr.nexthdr);
+ }
+
+ /* Hop Limit */
+ if ((iphc0 & 0x03) != LOWPAN_IPHC_TTL_I)
+ hdr.hop_limit = ttl_values[iphc0 & 0x03];
+ else
+ hdr.hop_limit = fetch_skb_u8(skb);
+
+ /* Extract SAM to the tmp variable */
+ tmp = ((iphc1 & LOWPAN_IPHC_SAM) >> LOWPAN_IPHC_SAM_BIT) & 0x03;
+
+ /* Source address uncompression */
+ if (iphc1 & LOWPAN_IPHC_SAC) {
+ u8 sci = (iphc1 & LOWPAN_IPHC_CID) ? num_context >> 4 : 0;
+
+ pr_debug("(%s): SAC flag is set, using context-bsed
compression\n", __func__);
+
+ if((iphc1 & LOWPAN_IPHC_SAM) != 0) {
+ context = addr_context_lookup_by_number(sci);
+ pr_debug("(%s): source address context %p, SCI %d\n",
__func__, context, sci);
+
+ if(context == NULL)
+ return pr_debug("(%s): ERROR: context not
found\n", __func__), -ENXIO;
+ else
+ printk("(%s): found compressed source context
for SCI = %d\n", __func__, sci);
+
+ uncompress_addr(skb, &hdr.saddr, context->prefix,
unc_ctxconf[tmp], skb->data);
+ } else {
+ pr_debug("(%s): the full address is carried in-line\n",
__func__);
+ uncompress_addr(skb, &hdr.saddr, (u8 *)llprefix,
unc_ctxconf[tmp], _saddr);
+ }
+ } else {
+ pr_debug("(%s): source address stateless compression\n",
__func__);
+ uncompress_addr(skb, &hdr.saddr, llprefix, unc_llconf[tmp],
skb->data);
+ }
+
+ /* Extract DAM to the tmp variable */
+ tmp = ((iphc1 & LOWPAN_IPHC_DAM_11) >> LOWPAN_IPHC_DAM_BIT) & 0x03;
+
+ /* check for Multicast Compression */
+ if (iphc1 & LOWPAN_IPHC_M) {
+ if (iphc1 & LOWPAN_IPHC_DAC) {
+ pr_debug("(%s): destination address context-based
multicast compression\n", __func__);
+ /* TODO: implement this */
+ } else {
+ u8 prefix[] = {0xff, 0x02};
+
+ pr_debug("(%s): destination address non-context-based
multicast compression\n", __func__);
+ if (0 < tmp && tmp < 3)
+ prefix[1] = fetch_skb_u8(skb);
+
+ uncompress_addr(skb, &hdr.daddr, prefix,
unc_mxconf[tmp], NULL);
+ }
+ } else {
+ if(iphc1 & LOWPAN_IPHC_DAC) {
+ u8 dci = (iphc1 & LOWPAN_IPHC_CID) ? num_context & 0x0f
: 0;
+ context = addr_context_lookup_by_number(dci);
+
+ pr_debug("(%s): destination address context-based
compression\n", __func__);
+
+ if (context == NULL)
+ return pr_debug("(%s): ERROR: context not
found\n", __func__), -ENXIO;
+
+ uncompress_addr(skb, &hdr.daddr, context->prefix,
unc_ctxconf[tmp], skb->data);
+ } else {
+ pr_debug("(%s): destination address stateless
compression\n", __func__);
+ uncompress_addr(skb, &hdr.daddr, llprefix,
unc_llconf[tmp], skb->data);
+ }
+ }
+
+ /* TODO: UDP header parse */
+
+ /* Not fragmented package */
+ hdr.payload_len = htons(skb->len);
+
+ pr_debug("(%s): skb headroom size = %d, data length = %d\n", __func__,
skb_headroom(skb), skb->len);
+
+ skb_push(skb, sizeof(struct ipv6hdr));
+ /* TODO: do we need that?
+ * skb_copy_to_linear_data(skb, &hdr, sizeof(struct ipv6hdr));
+ */
+ skb->protocol = htons(ETH_P_IPV6);
+ skb->pkt_type = PACKET_HOST;
+
+ pr_debug("(%s): IPv6 header dump:\n\tversion = %d\n\tlength =
%d\n\tnexthdr = 0x%02x\n\thop_lim = %d\n",
+ __func__, hdr.version, ntohs(hdr.payload_len), hdr.nexthdr,
hdr.hop_limit);
+
+#ifdef LOWPAN_DEBUG
+ pr_debug("(%s): raw header dump:", __func__);
+ for (tmp = 0; tmp < sizeof(hdr); tmp++) {
+ if (tmp % 8 == 0)
+ pr_debug("\n\t0x%04x: ", tmp);
+ pr_debug("%02x ", ((u8 *)&hdr)[tmp]);
+ }
+ pr_debug("\n");
+#endif /* LOWPAN_DEBUG */
+
+ if (in_interrupt())
+ return netif_rx(skb);
+ else
+ return netif_rx_ni(skb);
+
+ /* TODO: do we need that?
+ * kfree_skb(skb);
+ */
+ return 0;
+}
+
+extern int mac802154_header_parse(const struct sk_buff *skb, u8 *haddr);
+static int lowpan_header_parse(const struct sk_buff *skb,
+ unsigned char *haddr)
+{
+ printk("JDS - %s\n", __func__);
+ return mac802154_header_parse(skb, haddr);
+}
+
+/*
+ * the difference from standard mac802154_header_create is that
+ * 6lowpan uses long addresses only, so we need to set force
+ * long address mode.
+ */
+int lowpan_header_create_finish(struct sk_buff *skb,
+ struct net_device *dev,
+ unsigned short type, const void *_daddr,
+ const void *_saddr, unsigned len)
+{
+ u8 head[24] = {0,};
+ u16 fc;
+ int pos = 2; /* leave room for FC */
+ const u8 *saddr = _saddr;
+ const u8 *daddr = _daddr;
+
+ head[pos++] = mac_cb(skb)->seq; /* DSN/BSN */
+
+ fc = IEEE802154_FC_TYPE_DATA;
+ if (mac_cb_is_ackreq(skb))
+ fc |= IEEE802154_FC_ACK_REQ;
+
+ if (!daddr) return -EINVAL;
+ if (!saddr) saddr = dev->dev_addr;
+
+ /*TODO: default panid, do we need that? */
+ head[pos++] = 0xCD, head[pos++] = 0xAB;
+
+ if (lowpan_is_addr_broadcast(daddr)) {
+ fc |= (IEEE802154_ADDR_SHORT << IEEE802154_FC_DAMODE_SHIFT);
+ head[pos++] = 0xff, head[pos++] = 0xff;
+ } else {
+ /* force long */
+ fc |= (IEEE802154_ADDR_LONG << IEEE802154_FC_DAMODE_SHIFT);
+ data_swap(daddr, head + pos);
+ pos += IEEE802154_ADDR_LEN;
+ }
+
+ fc |= (IEEE802154_ADDR_LONG << IEEE802154_FC_SAMODE_SHIFT);
+ fc |= IEEE802154_FC_INTRA_PAN;
+
+ data_swap(saddr, head + pos);
+ pos += IEEE802154_ADDR_LEN;
+
+ head[0] = fc, head[1] = fc >> 8;
+
+ memcpy(skb_push(skb, pos), head, pos);
+
+ return pos;
+}
+
+static int lowpan_header_create(struct sk_buff *skb,
+ struct net_device *dev,
+ unsigned short type, const void *_daddr,
+ const void *_saddr, unsigned len)
+{
+ u8 tmp, iphc0, iphc1, *hc06_ptr;
+ struct ipv6hdr* hdr;
+ struct lowpan_addr_context *context;
+ const u8 *saddr = _saddr;
+ const u8 *daddr = _daddr;
+ u8 head[100] = {};
+ u8 daddr_buf[IEEE802154_ALEN];
+
+ if (type != ETH_P_IPV6)
+ return lowpan_header_create_finish(skb, dev, type, _daddr,
_saddr, skb->len);
+ /* TODO:
+ * if this package isn't ipv6 one, where should it be routed?
+ * return mac802154_header_create(skb, dev, type, _daddr,
_saddr, skb->len);
+ */
+
+ hdr = ipv6_hdr(skb);
+ hc06_ptr = head + 2;
+
+#ifdef LOWPAN_DEBUG
+ pr_debug("(%s): IPv6 header dump:\n\tversion = %d\n\tlength =
%d\n\tnexthdr = 0x%02x\n\thop_lim = %d\n",
+ __func__, hdr->version, ntohs(hdr->payload_len), hdr->nexthdr,
hdr->hop_limit);
+
+ pr_debug("(%s): raw skb network header dump:", __func__);
+ for (tmp = 0; tmp < sizeof(skb_network_header(skb)); tmp++) {
+ if (tmp % 8 == 0)
+ pr_debug("\n\t0x%04x: ", tmp);
+ pr_debug("%02x ", skb_network_header(skb)[tmp]);
+ }
+ pr_debug("\n");
+#endif /* LOWPAN_DEBUG */
+
+ if (!saddr)
+ saddr = dev->dev_addr;
+
+#ifdef LOWPAN_DEBUG
+ pr_debug("(%s): saddr: ", __func__);
+ for (tmp = 0; tmp < 8; tmp++)
+ pr_debug("%02x ", saddr[tmp]);
+ pr_debug("\n");
+#endif /* LOWPAN_DEBUG */
+
+ /*
+ * As we copy some bit-length fields, in the IPHC encoding bytes,
+ * we sometimes use |=
+ * If the field is 0, and the current bit value in memory is 1,
+ * this does not work. We therefore reset the IPHC encoding here
+ */
+ iphc0 = LOWPAN_DISPATCH_IPHC;
+ iphc1 = 0;
+
+ /* check if dest context exists (for allocating third byte); */
+ if ((context = addr_context_lookup_by_prefix(&hdr->daddr)) != NULL ||
+ addr_context_lookup_by_prefix(&hdr->saddr) != NULL)
+ {
+ pr_debug("(%s): compressing dest or src ipaddr - setting
CID\n", __func__);
+ iphc1 |= LOWPAN_IPHC_CID;
+ hc06_ptr++;
+ }
+
+ if (context && (memcmp(daddr, saddr, IEEE802154_ALEN) == 0)) {
+ memcpy(&daddr_buf, &hdr->daddr.s6_addr[8], IEEE802154_ALEN);
+ daddr_buf[0] &= 0xFD;
+ daddr = &daddr_buf[0];
+ }
+
+#ifdef LOWPAN_DEBUG
+ pr_debug("(%s): daddr: ", __func__);
+ for (tmp = 0; tmp < 8; tmp++)
+ pr_debug("%02x ", daddr[tmp]);
+ pr_debug("\n");
+#endif /* LOWPAN_DEBUG */
+
+ /*
+ * Traffic class, flow label
+ * If flow label is 0, compress it. If traffic class is 0, compress it
+ * We have to process both in the same time as the offset of traffic
class
+ * depends on the presence of version and flow label
+ */
+
+ /* hc06 format of TC is ECN | DSCP , original one is DSCP | ECN */
+ tmp = (hdr->priority << 4) | (hdr->flow_lbl[0] >> 4);
+ tmp = ((tmp & 0x03) << 6) | (tmp >> 2);
+
+ if(((hdr->flow_lbl[0] & 0x0F) == 0) &&
+ (hdr->flow_lbl[1] == 0) && (hdr->flow_lbl[2] == 0)) {
+ /* flow label can be compressed */
+ iphc0 |= LOWPAN_IPHC_FL_C;
+ if((hdr->priority == 0) &&
+ ((hdr->flow_lbl[0] & 0xF0) == 0)) {
+ /* compress (elide) all */
+ iphc0 |= LOWPAN_IPHC_TC_C;
+ } else {
+ /* compress only the flow label */
+ *hc06_ptr = tmp;
+ hc06_ptr += 1;
+ }
+ } else {
+ /* Flow label cannot be compressed */
+ if((hdr->priority == 0) &&
+ ((hdr->flow_lbl[0] & 0xF0) == 0)) {
+ /* compress only traffic class */
+ iphc0 |= LOWPAN_IPHC_TC_C;
+ *hc06_ptr = (tmp & 0xc0) | (hdr->flow_lbl[0] & 0x0F);
+ memcpy(hc06_ptr + 1, &hdr->flow_lbl[1], 2);
+ hc06_ptr += 3;
+ } else {
+ /* compress nothing */
+ memcpy(hc06_ptr, &hdr, 4);
+ /* but replace the top byte with the new ECN | DSCP
format*/
+ *hc06_ptr = tmp;
+ hc06_ptr += 4;
+ }
+ }
+
+ /* NOTE: payload length is always compressed */
+
+ /* Next Header is compress if UDP */
+ if(hdr->nexthdr == UIP_PROTO_UDP)
+ iphc0 |= LOWPAN_IPHC_NH_C;
+
+/* TODO: next header compression */
+#if 0
+ if(LOWPAN_NH_COMPRESSOR.is_compressable(hdr->proto)) {
+ iphc0 |= LOWPAN_IPHC_NH_C;
+ }
+#endif
+
+ if ((iphc0 & LOWPAN_IPHC_NH_C) == 0) {
+ *hc06_ptr = hdr->nexthdr;
+ hc06_ptr += 1;
+ }
+
+ /*
+ * Hop limit
+ * if 1: compress, encoding is 01
+ * if 64: compress, encoding is 10
+ * if 255: compress, encoding is 11
+ * else do not compress
+ */
+ switch(hdr->hop_limit) {
+ case 1:
+ iphc0 |= LOWPAN_IPHC_TTL_1;
+ break;
+ case 64:
+ iphc0 |= LOWPAN_IPHC_TTL_64;
+ break;
+ case 255:
+ iphc0 |= LOWPAN_IPHC_TTL_255;
+ break;
+ default:
+ *hc06_ptr = hdr->hop_limit;
+ break;
+ }
+
+ /* source address compression */
+ if (is_addr_unspecified(&hdr->saddr)) {
+ pr_debug("(%s): source address is unspecified, setting SAC\n",
__func__);
+ iphc1 |= LOWPAN_IPHC_SAC;
+ } else if ((context = addr_context_lookup_by_prefix(&hdr->saddr)) !=
NULL) {
+ /* elide the prefix - indicate by CID and set context + SAC */
+ pr_debug("(%s): compressing source address with context,
setting CID & SAC ctx: %d\n",
+
__func__, context->number);
+ iphc1 |= LOWPAN_IPHC_CID | LOWPAN_IPHC_SAC;
+ head[2] |= context->number << 4;
+
+ /* compession compare with this nodes address (source) */
+ iphc1 |= compress_addr_64(&hc06_ptr, LOWPAN_IPHC_SAM_BIT,
+ &hdr->saddr,
saddr);
+ } else if (is_addr_link_local(&hdr->saddr)) {
+ pr_debug("(%s): source address is link-local\n", __func__);
+ iphc1 |= compress_addr_64(&hc06_ptr, LOWPAN_IPHC_SAM_BIT,
+ &hdr->saddr,
saddr);
+ } else {
+ pr_debug("(%s): send the full source address\n", __func__);
+ memcpy(hc06_ptr, &hdr->saddr.s6_addr16[0], 16);
+ hc06_ptr += 16;
+ }
+
+ /* destination address compression */
+ if (is_addr_mcast(&hdr->daddr)) {
+ pr_debug("(%s): destination address is multicast: ", __func__);
+ iphc1 |= LOWPAN_IPHC_M;
+ if (lowpan_is_mcast_addr_compressable8(&hdr->daddr)) {
+ pr_debug("compressed to 1 octet\n");
+ iphc1 |= LOWPAN_IPHC_DAM_11;
+ /* use last byte */
+ *hc06_ptr = hdr->daddr.s6_addr[15];
+ hc06_ptr += 1;
+ } else
+ if (lowpan_is_mcast_addr_compressable32(&hdr->daddr)) {
+ pr_debug("compressed to 4 octets\n");
+ iphc1 |= LOWPAN_IPHC_DAM_10;
+ /* second byte + the last three */
+ *hc06_ptr = hdr->daddr.s6_addr[1];
+ memcpy(hc06_ptr + 1, &hdr->daddr.s6_addr[13], 3);
+ hc06_ptr += 4;
+ } else
+ if (lowpan_is_mcast_addr_compressable48(&hdr->daddr)) {
+ pr_debug("compressed to 6 octets\n");
+ iphc1 |= LOWPAN_IPHC_DAM_01;
+ /* second byte + the last five */
+ *hc06_ptr = hdr->daddr.s6_addr[1];
+ memcpy(hc06_ptr + 1, &hdr->daddr.s6_addr[11], 5);
+ hc06_ptr += 6;
+ } else {
+ pr_debug("using full address\n");
+ iphc1 |= LOWPAN_IPHC_DAM_00;
+ memcpy(hc06_ptr, &hdr->daddr.s6_addr[0], 16);
+ hc06_ptr += 16;
+ }
+ } else {
+ pr_debug("(%s): destination address is unicast: ", __func__);
+ if((context = addr_context_lookup_by_prefix(&hdr->daddr)) !=
NULL) {
+ pr_debug("compressing with context, setting CID & DAC
ctx: %d\n",
+
context->number);
+ iphc1 |= LOWPAN_IPHC_CID | LOWPAN_IPHC_DAC;
+ head[2] |= context->number;
+ /* compession compare with link adress (destination) */
+ iphc1 |= compress_addr_64(&hc06_ptr,
LOWPAN_IPHC_DAM_BIT,
+
&hdr->daddr, daddr);
+ } else if(is_addr_link_local(&hdr->daddr)) {
+ pr_debug("destination address is link-local\n");
+ iphc1 |= compress_addr_64(&hc06_ptr,
LOWPAN_IPHC_DAM_BIT,
+
&hdr->daddr, daddr);
+ } else {
+ pr_debug("using full address\n");
+ memcpy(hc06_ptr, &hdr->daddr.s6_addr16[0], 16);
+ hc06_ptr += 16;
+ }
+ }
+
+ /* TODO: UDP header compression */
+ /* TODO: Next Header compression */
+
+ head[0] = iphc0;
+ head[1] = iphc1;
+
+ skb_pull(skb, sizeof(struct ipv6hdr));
+ memcpy(skb_push(skb, hc06_ptr - head), head, hc06_ptr - head);
+
+ return lowpan_header_create_finish(skb, dev, type, daddr, saddr,
skb->len);
+}
+
+static struct header_ops lowpan_header_ops = {
+ .create = lowpan_header_create,
+ .parse = lowpan_header_parse,
+};
+
+/*
+ TODO: implement 6lowpan operations separated from wpan
+static const struct net_device_ops lowpan_ops = {
+ .ndo_open = mac802154_slave_open,
+ .ndo_stop = mac802154_slave_close,
+ .ndo_start_xmit = lowpan_xmit,
+ .ndo_do_ioctl = lowpan_ioctl,
+ .ndo_set_mac_address = lowpan_mac_addr,
+};
+*/
+
+void lowpan_setup(struct net_device *dev)
+{
+ struct mac802154_sub_if_data *priv;
+
+ pr_debug("(%s): setting up lowpan interface\n", __func__);
+ mac802154_wpan_setup(dev);
+
+ /* dev->hard_header_len = 2 + 1 + 20 + 14; */
+ dev->header_ops = &lowpan_header_ops;
+ dev->mtu = 1280;
+
+ /* TODO: implement 6lowpan operations, separated from wpan
+ * dev->netdev_ops = &lowpan_ops;
+ */
+
+ priv = netdev_priv(dev);
+ priv->tunnel = lowpan_process_data;
+
+ /* TODO: do we need that? */
+ addr_contexts[0].used = 1;
+ addr_contexts[0].number = 0;
+ addr_contexts[0].prefix[0] = 0xaa;
+ addr_contexts[0].prefix[1] = 0xaa;
+}
+
diff --git a/net/mac802154/6lowpan.h b/net/mac802154/6lowpan.h
new file mode 100644
index 0000000..d87dcde
--- /dev/null
+++ b/net/mac802154/6lowpan.h
@@ -0,0 +1,170 @@
+#ifndef _6LOWPAN_H_
+#define _6LOWPAN_H_
+
+#define UIP_802154_SHORTADDR_LEN 2 /* compressed ipv6 address length */
+#define UIP_IPH_LEN 40 /* ipv6 fixed header size */
+#define UIP_PROTO_UDP 17 /* ipv6 next header value for UDP */
+#define UIP_FRAGH_LEN 8 /* ipv6 fragment header size */
+
+/* ipv6 address based on mac */
+#define is_addr_mac_addr_based(a, m) \
+ ((((a)->s6_addr[8]) == (((m)[0]) ^ 0x02)) && \
+ (((a)->s6_addr[9]) == (m)[1]) && \
+ (((a)->s6_addr[10]) == (m)[2]) && \
+ (((a)->s6_addr[11]) == (m)[3]) && \
+ (((a)->s6_addr[12]) == (m)[4]) && \
+ (((a)->s6_addr[13]) == (m)[5]) && \
+ (((a)->s6_addr[14]) == (m)[6]) && \
+ (((a)->s6_addr[15]) == (m)[7]))
+
+/* ipv6 address is unspecified */
+#define is_addr_unspecified(a) \
+ ((((a)->s6_addr32[0]) == 0) && \
+ (((a)->s6_addr32[1]) == 0) && \
+ (((a)->s6_addr32[2]) == 0) && \
+ (((a)->s6_addr32[3]) == 0))
+
+/* compare ipv6 addresses prefixes */
+#define ipaddr_prefixcmp(addr1, addr2, length) (memcmp(addr1, addr2,
length>>3) == 0)
+
+/* local link, i.e. FE80::/10 */
+#define is_addr_link_local(a) (((a)->s6_addr16[0]) == 0x80FE)
+
+/*
+ * check whether we can compress the IID to 16 bits,
+ * it's possible for unicast adresses with first 49 bits are zero only.
+ */
+#define lowpan_is_iid_16_bit_compressable(a) \
+ ((((a)->s6_addr16[4]) == 0) && \
+ (((a)->s6_addr16[5]) == 0) && \
+ (((a)->s6_addr16[6]) == 0) && \
+ ((((a)->s6_addr[14]) & 0x80) == 0))
+
+/* multicast address */
+#define is_addr_mcast(a) (((a)->s6_addr[0]) == 0xFF)
+
+/* check whether the 112-bit group-id of the multicast address is mappable to:
*/
+
+/* 9 bits, for FF02::1 (all nodes) and FF02::2 (all routers) addresses only. */
+#define lowpan_is_mcast_addr_compressable(a) \
+ ((((a)->s6_addr16[1]) == 0) && \
+ (((a)->s6_addr16[2]) == 0) && \
+ (((a)->s6_addr16[3]) == 0) && \
+ (((a)->s6_addr16[4]) == 0) && \
+ (((a)->s6_addr16[5]) == 0) && \
+ (((a)->s6_addr16[6]) == 0) && \
+ (((a)->s6_addr[14]) == 0) && \
+ ((((a)->s6_addr[15]) == 1) || (((a)->s6_addr[15]) == 2)))
+
+/* 48 bits, FFXX::00XX:XXXX:XXXX */
+#define lowpan_is_mcast_addr_compressable48(a) \
+ ((((a)->s6_addr16[1]) == 0) && \
+ (((a)->s6_addr16[2]) == 0) && \
+ (((a)->s6_addr16[3]) == 0) && \
+ (((a)->s6_addr16[4]) == 0) && \
+ (((a)->s6_addr[10]) == 0))
+
+/* 32 bits, FFXX::00XX:XXXX */
+#define lowpan_is_mcast_addr_compressable32(a) \
+ ((((a)->s6_addr16[1]) == 0) && \
+ (((a)->s6_addr16[2]) == 0) && \
+ (((a)->s6_addr16[3]) == 0) && \
+ (((a)->s6_addr16[4]) == 0) && \
+ (((a)->s6_addr16[5]) == 0) && \
+ (((a)->s6_addr[12]) == 0))
+
+/* 8 bits, FF02::00XX */
+#define lowpan_is_mcast_addr_compressable8(a) \
+ ((((a)->s6_addr[1]) == 2) && \
+ (((a)->s6_addr16[1]) == 0) && \
+ (((a)->s6_addr16[2]) == 0) && \
+ (((a)->s6_addr16[3]) == 0) && \
+ (((a)->s6_addr16[4]) == 0) && \
+ (((a)->s6_addr16[5]) == 0) && \
+ (((a)->s6_addr16[6]) == 0) && \
+ (((a)->s6_addr[14]) == 0))
+
+#define lowpan_is_addr_broadcast(a) \
+ ((((a)[0]) == 0xFF) && \
+ (((a)[1]) == 0xFF) && \
+ (((a)[2]) == 0xFF) && \
+ (((a)[3]) == 0xFF) && \
+ (((a)[4]) == 0xFF) && \
+ (((a)[5]) == 0xFF) && \
+ (((a)[6]) == 0xFF) && \
+ (((a)[7]) == 0xFF))
+
+/*
+ * An address context for IPHC address compression, each context can
+ * have upto 8 bytes
+ */
+struct lowpan_addr_context {
+ u8 used; /* possibly use as prefix-length */
+ u8 number;
+ u8 prefix[8];
+};
+
+#define LOWPAN_DISPATCH_IPV6 0x41 /* 01000001 = 65 */
+#define LOWPAN_DISPATCH_HC1 0x42 /* 01000010 = 66 */
+#define LOWPAN_DISPATCH_IPHC 0x60 /* 011xxxxx = ... */
+#define LOWPAN_DISPATCH_FRAG1 0xc0 /* 11000xxx */
+#define LOWPAN_DISPATCH_FRAGN 0xe0 /* 11100xxx */
+
+/*
+ * Values of fields within the IPHC encoding first byte
+ * (C stands for compressed and I for inline)
+ */
+#define LOWPAN_IPHC_TF 0x18
+
+#define LOWPAN_IPHC_FL_C 0x10
+#define LOWPAN_IPHC_TC_C 0x08
+#define LOWPAN_IPHC_NH_C 0x04
+#define LOWPAN_IPHC_TTL_1 0x01
+#define LOWPAN_IPHC_TTL_64 0x02
+#define LOWPAN_IPHC_TTL_255 0x03
+#define LOWPAN_IPHC_TTL_I 0x00
+
+
+/* Values of fields within the IPHC encoding second byte */
+#define LOWPAN_IPHC_CID 0x80
+
+#define LOWPAN_IPHC_SAC 0x40
+#define LOWPAN_IPHC_SAM_00 0x00
+#define LOWPAN_IPHC_SAM_01 0x10
+#define LOWPAN_IPHC_SAM_10 0x20
+#define LOWPAN_IPHC_SAM 0x30
+
+#define LOWPAN_IPHC_SAM_BIT 4
+
+#define LOWPAN_IPHC_M 0x08
+#define LOWPAN_IPHC_DAC 0x04
+#define LOWPAN_IPHC_DAM_00 0x00
+#define LOWPAN_IPHC_DAM_01 0x01
+#define LOWPAN_IPHC_DAM_10 0x02
+#define LOWPAN_IPHC_DAM_11 0x03
+
+#define LOWPAN_IPHC_DAM_BIT 0
+/*
+ * LOWPAN_UDP encoding (works together with IPHC)
+ */
+#define LOWPAN_NHC_UDP_MASK 0xF8
+#define LOWPAN_NHC_UDP_ID 0xF0
+#define LOWPAN_NHC_UDP_CHECKSUMC 0x04
+#define LOWPAN_NHC_UDP_CHECKSUMI 0x00
+
+/* values for port compression, _with checksum_ ie bit 5 set to 0 */
+#define LOWPAN_NHC_UDP_CS_P_00 0xF0 /* all inline */
+#define LOWPAN_NHC_UDP_CS_P_01 0xF1 /* source 16bit inline, dest =
0xF0 + 8 bit inline */
+#define LOWPAN_NHC_UDP_CS_P_10 0xF2 /* source = 0xF0 + 8bit inline,
dest = 16 bit inline */
+#define LOWPAN_NHC_UDP_CS_P_11 0xF3 /* source & dest = 0xF0B + 4bit
inline */
+
+void lowpan_setup(struct net_device *dev);
+
+#define data_swap(src, dest) \
+{ \
+ int i; \
+ for (i = 0; i < IEEE802154_ADDR_LEN; i++) \
+ (dest)[IEEE802154_ADDR_LEN - i - 1] = (src)[i]; \
+}
+
+#endif /* _6LOWPAN_H_ */
diff --git a/net/mac802154/Kconfig b/net/mac802154/Kconfig
index 61a3287..a5f49f1 100644
--- a/net/mac802154/Kconfig
+++ b/net/mac802154/Kconfig
@@ -15,3 +15,9 @@ config MAC802154
say N here. Alternatievly you can say M to compile it as
module.
+config 6LOWPAN
+ bool "6lowpan support over IEEE 802.15.4"
+ depends on MAC802154
+ ---help---
+ IPv6 compression over IEEE 802.15.4.
+ The support will be added to mac802154 module
diff --git a/net/mac802154/Makefile b/net/mac802154/Makefile
index 790b97f..f9e034b 100644
--- a/net/mac802154/Makefile
+++ b/net/mac802154/Makefile
@@ -1,5 +1,9 @@
obj-$(CONFIG_MAC802154) += mac802154.o
-mac802154-objs := rx.o tx.o main.o monitor.o wpan.o mac_cmd.o scan.o
mib.o \
+mac802154-y := rx.o tx.o main.o monitor.o wpan.o mac_cmd.o scan.o
mib.o \
beacon.o beacon_hash.o smac.o
+mac802154-$(CONFIG_6LOWPAN) += 6lowpan.o
+
+mac802154-objs := $(mac802154-y)
+
EXTRA_CFLAGS += -Wall -DDEBUG
diff --git a/net/mac802154/main.c b/net/mac802154/main.c
index af85fdc..df69f4a 100644
--- a/net/mac802154/main.c
+++ b/net/mac802154/main.c
@@ -25,6 +25,7 @@
#include <net/mac802154.h>
#include <net/wpan-phy.h>
+#include "6lowpan.h"
#include "mac802154.h"
#include "mib.h"
@@ -137,6 +138,10 @@ static struct net_device *mac802154_add_iface(struct
wpan_phy *phy,
dev = alloc_netdev(sizeof(struct mac802154_sub_if_data),
name, mac802154_wpan_setup);
break;
+ case IEEE802154_DEV_6LOWPAN:
+ dev = alloc_netdev(sizeof(struct mac802154_sub_if_data),
+ name, lowpan_setup);
+ break;
case IEEE802154_DEV_MONITOR:
dev = alloc_netdev(sizeof(struct mac802154_sub_if_data),
name, mac802154_monitor_setup);
diff --git a/net/mac802154/wpan.c b/net/mac802154/wpan.c
index f58ea93..11728dd 100644
--- a/net/mac802154/wpan.c
+++ b/net/mac802154/wpan.c
@@ -217,7 +217,7 @@ static int mac802154_header_create(struct sk_buff *skb,
return pos;
}
-static int mac802154_header_parse(const struct sk_buff *skb,
+int mac802154_header_parse(const struct sk_buff *skb,
unsigned char *haddr)
{
const u8 *hdr = skb_mac_header(skb), *tail = skb_tail_pointer(skb);
--
1.7.2.3
------------------------------------------------------------------------------
All of the data generated in your IT infrastructure is seriously valuable.
Why? It contains a definitive record of application performance, security
threats, fraudulent activity, and more. Splunk takes this data and makes
sense of it. IT sense. And common sense.
http://p.sf.net/sfu/splunk-d2d-c2
_______________________________________________
Linux-zigbee-devel mailing list
[email protected]
https://lists.sourceforge.net/lists/listinfo/linux-zigbee-devel
