12c6bed7cSAlexander Aring /*
22c6bed7cSAlexander Aring * Copyright 2011, Siemens AG
32c6bed7cSAlexander Aring * written by Alexander Smirnov <alex.bluesman.smirnov@gmail.com>
42c6bed7cSAlexander Aring */
52c6bed7cSAlexander Aring
63fd0202aSDavid S. Miller /* Based on patches from Jon Smirl <jonsmirl@gmail.com>
72c6bed7cSAlexander Aring * Copyright (c) 2011 Jon Smirl <jonsmirl@gmail.com>
82c6bed7cSAlexander Aring *
92c6bed7cSAlexander Aring * This program is free software; you can redistribute it and/or modify
102c6bed7cSAlexander Aring * it under the terms of the GNU General Public License version 2
112c6bed7cSAlexander Aring * as published by the Free Software Foundation.
122c6bed7cSAlexander Aring *
132c6bed7cSAlexander Aring * This program is distributed in the hope that it will be useful,
142c6bed7cSAlexander Aring * but WITHOUT ANY WARRANTY; without even the implied warranty of
152c6bed7cSAlexander Aring * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
162c6bed7cSAlexander Aring * GNU General Public License for more details.
172c6bed7cSAlexander Aring *
182c6bed7cSAlexander Aring */
192c6bed7cSAlexander Aring
202c6bed7cSAlexander Aring /* Jon's code is based on 6lowpan implementation for Contiki which is:
212c6bed7cSAlexander Aring * Copyright (c) 2008, Swedish Institute of Computer Science.
222c6bed7cSAlexander Aring * All rights reserved.
232c6bed7cSAlexander Aring *
242c6bed7cSAlexander Aring * Redistribution and use in source and binary forms, with or without
252c6bed7cSAlexander Aring * modification, are permitted provided that the following conditions
262c6bed7cSAlexander Aring * are met:
272c6bed7cSAlexander Aring * 1. Redistributions of source code must retain the above copyright
282c6bed7cSAlexander Aring * notice, this list of conditions and the following disclaimer.
292c6bed7cSAlexander Aring * 2. Redistributions in binary form must reproduce the above copyright
302c6bed7cSAlexander Aring * notice, this list of conditions and the following disclaimer in the
312c6bed7cSAlexander Aring * documentation and/or other materials provided with the distribution.
322c6bed7cSAlexander Aring * 3. Neither the name of the Institute nor the names of its contributors
332c6bed7cSAlexander Aring * may be used to endorse or promote products derived from this software
342c6bed7cSAlexander Aring * without specific prior written permission.
352c6bed7cSAlexander Aring *
362c6bed7cSAlexander Aring * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
372c6bed7cSAlexander Aring * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
382c6bed7cSAlexander Aring * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
392c6bed7cSAlexander Aring * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
402c6bed7cSAlexander Aring * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
412c6bed7cSAlexander Aring * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
422c6bed7cSAlexander Aring * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
432c6bed7cSAlexander Aring * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
442c6bed7cSAlexander Aring * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
452c6bed7cSAlexander Aring * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
462c6bed7cSAlexander Aring * SUCH DAMAGE.
472c6bed7cSAlexander Aring */
482c6bed7cSAlexander Aring
492c6bed7cSAlexander Aring #include <linux/bitops.h>
502c6bed7cSAlexander Aring #include <linux/if_arp.h>
512c6bed7cSAlexander Aring #include <linux/netdevice.h>
528911d774SAlexander Aring
532c6bed7cSAlexander Aring #include <net/6lowpan.h>
542c6bed7cSAlexander Aring #include <net/ipv6.h>
558911d774SAlexander Aring
565609c185SAlexander Aring #include "6lowpan_i.h"
57cc6ed268SAlexander Aring #include "nhc.h"
58cc6ed268SAlexander Aring
59c8a3e7ebSAlexander Aring /* Values of fields within the IPHC encoding first byte */
60c8a3e7ebSAlexander Aring #define LOWPAN_IPHC_TF_MASK 0x18
61c8a3e7ebSAlexander Aring #define LOWPAN_IPHC_TF_00 0x00
62c8a3e7ebSAlexander Aring #define LOWPAN_IPHC_TF_01 0x08
63c8a3e7ebSAlexander Aring #define LOWPAN_IPHC_TF_10 0x10
64c8a3e7ebSAlexander Aring #define LOWPAN_IPHC_TF_11 0x18
656350047eSAlexander Aring
66c8a3e7ebSAlexander Aring #define LOWPAN_IPHC_NH 0x04
67c8a3e7ebSAlexander Aring
68c8a3e7ebSAlexander Aring #define LOWPAN_IPHC_HLIM_MASK 0x03
69c8a3e7ebSAlexander Aring #define LOWPAN_IPHC_HLIM_00 0x00
70c8a3e7ebSAlexander Aring #define LOWPAN_IPHC_HLIM_01 0x01
71c8a3e7ebSAlexander Aring #define LOWPAN_IPHC_HLIM_10 0x02
72c8a3e7ebSAlexander Aring #define LOWPAN_IPHC_HLIM_11 0x03
736350047eSAlexander Aring
746350047eSAlexander Aring /* Values of fields within the IPHC encoding second byte */
756350047eSAlexander Aring #define LOWPAN_IPHC_CID 0x80
766350047eSAlexander Aring
776350047eSAlexander Aring #define LOWPAN_IPHC_SAC 0x40
786350047eSAlexander Aring
79c8a3e7ebSAlexander Aring #define LOWPAN_IPHC_SAM_MASK 0x30
80c8a3e7ebSAlexander Aring #define LOWPAN_IPHC_SAM_00 0x00
81c8a3e7ebSAlexander Aring #define LOWPAN_IPHC_SAM_01 0x10
82c8a3e7ebSAlexander Aring #define LOWPAN_IPHC_SAM_10 0x20
83c8a3e7ebSAlexander Aring #define LOWPAN_IPHC_SAM_11 0x30
846350047eSAlexander Aring
856350047eSAlexander Aring #define LOWPAN_IPHC_M 0x08
86c8a3e7ebSAlexander Aring
876350047eSAlexander Aring #define LOWPAN_IPHC_DAC 0x04
88c8a3e7ebSAlexander Aring
89c8a3e7ebSAlexander Aring #define LOWPAN_IPHC_DAM_MASK 0x03
906350047eSAlexander Aring #define LOWPAN_IPHC_DAM_00 0x00
916350047eSAlexander Aring #define LOWPAN_IPHC_DAM_01 0x01
926350047eSAlexander Aring #define LOWPAN_IPHC_DAM_10 0x02
936350047eSAlexander Aring #define LOWPAN_IPHC_DAM_11 0x03
946350047eSAlexander Aring
956350047eSAlexander Aring /* ipv6 address based on mac
966350047eSAlexander Aring * second bit-flip (Universe/Local) is done according RFC2464
976350047eSAlexander Aring */
986350047eSAlexander Aring #define is_addr_mac_addr_based(a, m) \
996350047eSAlexander Aring ((((a)->s6_addr[8]) == (((m)[0]) ^ 0x02)) && \
1006350047eSAlexander Aring (((a)->s6_addr[9]) == (m)[1]) && \
1016350047eSAlexander Aring (((a)->s6_addr[10]) == (m)[2]) && \
1026350047eSAlexander Aring (((a)->s6_addr[11]) == (m)[3]) && \
1036350047eSAlexander Aring (((a)->s6_addr[12]) == (m)[4]) && \
1046350047eSAlexander Aring (((a)->s6_addr[13]) == (m)[5]) && \
1056350047eSAlexander Aring (((a)->s6_addr[14]) == (m)[6]) && \
1066350047eSAlexander Aring (((a)->s6_addr[15]) == (m)[7]))
1076350047eSAlexander Aring
1086350047eSAlexander Aring /* check whether we can compress the IID to 16 bits,
1096350047eSAlexander Aring * it's possible for unicast addresses with first 49 bits are zero only.
1106350047eSAlexander Aring */
1116350047eSAlexander Aring #define lowpan_is_iid_16_bit_compressable(a) \
1126350047eSAlexander Aring ((((a)->s6_addr16[4]) == 0) && \
1136350047eSAlexander Aring (((a)->s6_addr[10]) == 0) && \
1146350047eSAlexander Aring (((a)->s6_addr[11]) == 0xff) && \
1156350047eSAlexander Aring (((a)->s6_addr[12]) == 0xfe) && \
1166350047eSAlexander Aring (((a)->s6_addr[13]) == 0))
1176350047eSAlexander Aring
1186350047eSAlexander Aring /* check whether the 112-bit gid of the multicast address is mappable to: */
1196350047eSAlexander Aring
1206350047eSAlexander Aring /* 48 bits, FFXX::00XX:XXXX:XXXX */
1216350047eSAlexander Aring #define lowpan_is_mcast_addr_compressable48(a) \
1226350047eSAlexander Aring ((((a)->s6_addr16[1]) == 0) && \
1236350047eSAlexander Aring (((a)->s6_addr16[2]) == 0) && \
1246350047eSAlexander Aring (((a)->s6_addr16[3]) == 0) && \
1256350047eSAlexander Aring (((a)->s6_addr16[4]) == 0) && \
1266350047eSAlexander Aring (((a)->s6_addr[10]) == 0))
1276350047eSAlexander Aring
1286350047eSAlexander Aring /* 32 bits, FFXX::00XX:XXXX */
1296350047eSAlexander Aring #define lowpan_is_mcast_addr_compressable32(a) \
1306350047eSAlexander Aring ((((a)->s6_addr16[1]) == 0) && \
1316350047eSAlexander Aring (((a)->s6_addr16[2]) == 0) && \
1326350047eSAlexander Aring (((a)->s6_addr16[3]) == 0) && \
1336350047eSAlexander Aring (((a)->s6_addr16[4]) == 0) && \
1346350047eSAlexander Aring (((a)->s6_addr16[5]) == 0) && \
1356350047eSAlexander Aring (((a)->s6_addr[12]) == 0))
1366350047eSAlexander Aring
1376350047eSAlexander Aring /* 8 bits, FF02::00XX */
1386350047eSAlexander Aring #define lowpan_is_mcast_addr_compressable8(a) \
1396350047eSAlexander Aring ((((a)->s6_addr[1]) == 2) && \
1406350047eSAlexander Aring (((a)->s6_addr16[1]) == 0) && \
1416350047eSAlexander Aring (((a)->s6_addr16[2]) == 0) && \
1426350047eSAlexander Aring (((a)->s6_addr16[3]) == 0) && \
1436350047eSAlexander Aring (((a)->s6_addr16[4]) == 0) && \
1446350047eSAlexander Aring (((a)->s6_addr16[5]) == 0) && \
1456350047eSAlexander Aring (((a)->s6_addr16[6]) == 0) && \
1466350047eSAlexander Aring (((a)->s6_addr[14]) == 0))
1476350047eSAlexander Aring
148feb2add3SAlexander Aring #define lowpan_is_linklocal_zero_padded(a) \
149feb2add3SAlexander Aring (!(hdr->saddr.s6_addr[1] & 0x3f) && \
150feb2add3SAlexander Aring !hdr->saddr.s6_addr16[1] && \
151feb2add3SAlexander Aring !hdr->saddr.s6_addr32[1])
152feb2add3SAlexander Aring
1535609c185SAlexander Aring #define LOWPAN_IPHC_CID_DCI(cid) (cid & 0x0f)
1545609c185SAlexander Aring #define LOWPAN_IPHC_CID_SCI(cid) ((cid & 0xf0) >> 4)
1555609c185SAlexander Aring
1567115a968SAlexander Aring static inline void
lowpan_iphc_uncompress_802154_lladdr(struct in6_addr * ipaddr,const void * lladdr)1577115a968SAlexander Aring lowpan_iphc_uncompress_802154_lladdr(struct in6_addr *ipaddr,
1588911d774SAlexander Aring const void *lladdr)
1598911d774SAlexander Aring {
1608911d774SAlexander Aring const struct ieee802154_addr *addr = lladdr;
1612bc068c3SAlexander Aring u8 eui64[EUI64_ADDR_LEN];
1628911d774SAlexander Aring
1638911d774SAlexander Aring switch (addr->mode) {
1648911d774SAlexander Aring case IEEE802154_ADDR_LONG:
1658911d774SAlexander Aring ieee802154_le64_to_be64(eui64, &addr->extended_addr);
1667115a968SAlexander Aring lowpan_iphc_uncompress_eui64_lladdr(ipaddr, eui64);
1678911d774SAlexander Aring break;
1688911d774SAlexander Aring case IEEE802154_ADDR_SHORT:
1698911d774SAlexander Aring /* fe:80::ff:fe00:XXXX
1708911d774SAlexander Aring * \__/
1718911d774SAlexander Aring * short_addr
1728911d774SAlexander Aring *
1738911d774SAlexander Aring * Universe/Local bit is zero.
1748911d774SAlexander Aring */
1758911d774SAlexander Aring ipaddr->s6_addr[0] = 0xFE;
1768911d774SAlexander Aring ipaddr->s6_addr[1] = 0x80;
1778911d774SAlexander Aring ipaddr->s6_addr[11] = 0xFF;
1788911d774SAlexander Aring ipaddr->s6_addr[12] = 0xFE;
1798911d774SAlexander Aring ieee802154_le16_to_be16(&ipaddr->s6_addr16[7],
1808911d774SAlexander Aring &addr->short_addr);
1818911d774SAlexander Aring break;
1828911d774SAlexander Aring default:
1838911d774SAlexander Aring /* should never handled and filtered by 802154 6lowpan */
1848911d774SAlexander Aring WARN_ON_ONCE(1);
1858911d774SAlexander Aring break;
1868911d774SAlexander Aring }
1878911d774SAlexander Aring }
1888911d774SAlexander Aring
1895609c185SAlexander Aring static struct lowpan_iphc_ctx *
lowpan_iphc_ctx_get_by_id(const struct net_device * dev,u8 id)1905609c185SAlexander Aring lowpan_iphc_ctx_get_by_id(const struct net_device *dev, u8 id)
1915609c185SAlexander Aring {
1922e4d60cbSAlexander Aring struct lowpan_iphc_ctx *ret = &lowpan_dev(dev)->ctx.table[id];
1935609c185SAlexander Aring
1945609c185SAlexander Aring if (!lowpan_iphc_ctx_is_active(ret))
1955609c185SAlexander Aring return NULL;
1965609c185SAlexander Aring
1975609c185SAlexander Aring return ret;
1985609c185SAlexander Aring }
1995609c185SAlexander Aring
2005609c185SAlexander Aring static struct lowpan_iphc_ctx *
lowpan_iphc_ctx_get_by_addr(const struct net_device * dev,const struct in6_addr * addr)2015609c185SAlexander Aring lowpan_iphc_ctx_get_by_addr(const struct net_device *dev,
2025609c185SAlexander Aring const struct in6_addr *addr)
2035609c185SAlexander Aring {
2042e4d60cbSAlexander Aring struct lowpan_iphc_ctx *table = lowpan_dev(dev)->ctx.table;
2055609c185SAlexander Aring struct lowpan_iphc_ctx *ret = NULL;
2065609c185SAlexander Aring struct in6_addr addr_pfx;
2075609c185SAlexander Aring u8 addr_plen;
2085609c185SAlexander Aring int i;
2095609c185SAlexander Aring
2105609c185SAlexander Aring for (i = 0; i < LOWPAN_IPHC_CTX_TABLE_SIZE; i++) {
2115609c185SAlexander Aring /* Check if context is valid. A context that is not valid
2125609c185SAlexander Aring * MUST NOT be used for compression.
2135609c185SAlexander Aring */
2145609c185SAlexander Aring if (!lowpan_iphc_ctx_is_active(&table[i]) ||
2155609c185SAlexander Aring !lowpan_iphc_ctx_is_compression(&table[i]))
2165609c185SAlexander Aring continue;
2175609c185SAlexander Aring
2185609c185SAlexander Aring ipv6_addr_prefix(&addr_pfx, addr, table[i].plen);
2195609c185SAlexander Aring
2205609c185SAlexander Aring /* if prefix len < 64, the remaining bits until 64th bit is
2215609c185SAlexander Aring * zero. Otherwise we use table[i]->plen.
2225609c185SAlexander Aring */
2235609c185SAlexander Aring if (table[i].plen < 64)
2245609c185SAlexander Aring addr_plen = 64;
2255609c185SAlexander Aring else
2265609c185SAlexander Aring addr_plen = table[i].plen;
2275609c185SAlexander Aring
2285609c185SAlexander Aring if (ipv6_prefix_equal(&addr_pfx, &table[i].pfx, addr_plen)) {
2295609c185SAlexander Aring /* remember first match */
2305609c185SAlexander Aring if (!ret) {
2315609c185SAlexander Aring ret = &table[i];
2325609c185SAlexander Aring continue;
2335609c185SAlexander Aring }
2345609c185SAlexander Aring
2355609c185SAlexander Aring /* get the context with longest prefix len */
2365609c185SAlexander Aring if (table[i].plen > ret->plen)
2375609c185SAlexander Aring ret = &table[i];
2385609c185SAlexander Aring }
2395609c185SAlexander Aring }
2405609c185SAlexander Aring
2415609c185SAlexander Aring return ret;
2425609c185SAlexander Aring }
2435609c185SAlexander Aring
2445609c185SAlexander Aring static struct lowpan_iphc_ctx *
lowpan_iphc_ctx_get_by_mcast_addr(const struct net_device * dev,const struct in6_addr * addr)2455609c185SAlexander Aring lowpan_iphc_ctx_get_by_mcast_addr(const struct net_device *dev,
2465609c185SAlexander Aring const struct in6_addr *addr)
2475609c185SAlexander Aring {
2482e4d60cbSAlexander Aring struct lowpan_iphc_ctx *table = lowpan_dev(dev)->ctx.table;
2495609c185SAlexander Aring struct lowpan_iphc_ctx *ret = NULL;
2505609c185SAlexander Aring struct in6_addr addr_mcast, network_pfx = {};
2515609c185SAlexander Aring int i;
2525609c185SAlexander Aring
2535609c185SAlexander Aring /* init mcast address with */
2545609c185SAlexander Aring memcpy(&addr_mcast, addr, sizeof(*addr));
2555609c185SAlexander Aring
2565609c185SAlexander Aring for (i = 0; i < LOWPAN_IPHC_CTX_TABLE_SIZE; i++) {
2575609c185SAlexander Aring /* Check if context is valid. A context that is not valid
2585609c185SAlexander Aring * MUST NOT be used for compression.
2595609c185SAlexander Aring */
2605609c185SAlexander Aring if (!lowpan_iphc_ctx_is_active(&table[i]) ||
2615609c185SAlexander Aring !lowpan_iphc_ctx_is_compression(&table[i]))
2625609c185SAlexander Aring continue;
2635609c185SAlexander Aring
2645609c185SAlexander Aring /* setting plen */
2655609c185SAlexander Aring addr_mcast.s6_addr[3] = table[i].plen;
2665609c185SAlexander Aring /* get network prefix to copy into multicast address */
2675609c185SAlexander Aring ipv6_addr_prefix(&network_pfx, &table[i].pfx,
2685609c185SAlexander Aring table[i].plen);
2695609c185SAlexander Aring /* setting network prefix */
2705609c185SAlexander Aring memcpy(&addr_mcast.s6_addr[4], &network_pfx, 8);
2715609c185SAlexander Aring
2725609c185SAlexander Aring if (ipv6_addr_equal(addr, &addr_mcast)) {
2735609c185SAlexander Aring ret = &table[i];
2745609c185SAlexander Aring break;
2755609c185SAlexander Aring }
2765609c185SAlexander Aring }
2775609c185SAlexander Aring
2785609c185SAlexander Aring return ret;
2795609c185SAlexander Aring }
2805609c185SAlexander Aring
lowpan_iphc_uncompress_lladdr(const struct net_device * dev,struct in6_addr * ipaddr,const void * lladdr)281fa09ae66SLuiz Augusto von Dentz static void lowpan_iphc_uncompress_lladdr(const struct net_device *dev,
282fa09ae66SLuiz Augusto von Dentz struct in6_addr *ipaddr,
283fa09ae66SLuiz Augusto von Dentz const void *lladdr)
284fa09ae66SLuiz Augusto von Dentz {
285fa09ae66SLuiz Augusto von Dentz switch (dev->addr_len) {
286fa09ae66SLuiz Augusto von Dentz case ETH_ALEN:
287fa09ae66SLuiz Augusto von Dentz lowpan_iphc_uncompress_eui48_lladdr(ipaddr, lladdr);
288fa09ae66SLuiz Augusto von Dentz break;
289fa09ae66SLuiz Augusto von Dentz case EUI64_ADDR_LEN:
290fa09ae66SLuiz Augusto von Dentz lowpan_iphc_uncompress_eui64_lladdr(ipaddr, lladdr);
291fa09ae66SLuiz Augusto von Dentz break;
292fa09ae66SLuiz Augusto von Dentz default:
293fa09ae66SLuiz Augusto von Dentz WARN_ON_ONCE(1);
294fa09ae66SLuiz Augusto von Dentz break;
295fa09ae66SLuiz Augusto von Dentz }
296fa09ae66SLuiz Augusto von Dentz }
297fa09ae66SLuiz Augusto von Dentz
2983fd0202aSDavid S. Miller /* Uncompress address function for source and
2992c6bed7cSAlexander Aring * destination address(non-multicast).
3002c6bed7cSAlexander Aring *
301c8a3e7ebSAlexander Aring * address_mode is the masked value for sam or dam value
3022c6bed7cSAlexander Aring */
lowpan_iphc_uncompress_addr(struct sk_buff * skb,const struct net_device * dev,struct in6_addr * ipaddr,u8 address_mode,const void * lladdr)3037115a968SAlexander Aring static int lowpan_iphc_uncompress_addr(struct sk_buff *skb,
3047115a968SAlexander Aring const struct net_device *dev,
3057115a968SAlexander Aring struct in6_addr *ipaddr,
3067115a968SAlexander Aring u8 address_mode, const void *lladdr)
3072c6bed7cSAlexander Aring {
3082c6bed7cSAlexander Aring bool fail;
3092c6bed7cSAlexander Aring
3102c6bed7cSAlexander Aring switch (address_mode) {
311c8a3e7ebSAlexander Aring /* SAM and DAM are the same here */
312c8a3e7ebSAlexander Aring case LOWPAN_IPHC_DAM_00:
3132c6bed7cSAlexander Aring /* for global link addresses */
3142c6bed7cSAlexander Aring fail = lowpan_fetch_skb(skb, ipaddr->s6_addr, 16);
3152c6bed7cSAlexander Aring break;
316c8a3e7ebSAlexander Aring case LOWPAN_IPHC_SAM_01:
317c8a3e7ebSAlexander Aring case LOWPAN_IPHC_DAM_01:
3182c6bed7cSAlexander Aring /* fe:80::XXXX:XXXX:XXXX:XXXX */
3192c6bed7cSAlexander Aring ipaddr->s6_addr[0] = 0xFE;
3202c6bed7cSAlexander Aring ipaddr->s6_addr[1] = 0x80;
3212c6bed7cSAlexander Aring fail = lowpan_fetch_skb(skb, &ipaddr->s6_addr[8], 8);
3222c6bed7cSAlexander Aring break;
323c8a3e7ebSAlexander Aring case LOWPAN_IPHC_SAM_10:
324c8a3e7ebSAlexander Aring case LOWPAN_IPHC_DAM_10:
3252c6bed7cSAlexander Aring /* fe:80::ff:fe00:XXXX */
3262c6bed7cSAlexander Aring ipaddr->s6_addr[0] = 0xFE;
3272c6bed7cSAlexander Aring ipaddr->s6_addr[1] = 0x80;
3282c6bed7cSAlexander Aring ipaddr->s6_addr[11] = 0xFF;
3292c6bed7cSAlexander Aring ipaddr->s6_addr[12] = 0xFE;
3302c6bed7cSAlexander Aring fail = lowpan_fetch_skb(skb, &ipaddr->s6_addr[14], 2);
3312c6bed7cSAlexander Aring break;
332c8a3e7ebSAlexander Aring case LOWPAN_IPHC_SAM_11:
333c8a3e7ebSAlexander Aring case LOWPAN_IPHC_DAM_11:
3342c6bed7cSAlexander Aring fail = false;
3352e4d60cbSAlexander Aring switch (lowpan_dev(dev)->lltype) {
3368911d774SAlexander Aring case LOWPAN_LLTYPE_IEEE802154:
3377115a968SAlexander Aring lowpan_iphc_uncompress_802154_lladdr(ipaddr, lladdr);
3382c6bed7cSAlexander Aring break;
3392c6bed7cSAlexander Aring default:
340fa09ae66SLuiz Augusto von Dentz lowpan_iphc_uncompress_lladdr(dev, ipaddr, lladdr);
3418911d774SAlexander Aring break;
3422c6bed7cSAlexander Aring }
3432c6bed7cSAlexander Aring break;
3442c6bed7cSAlexander Aring default:
3452c6bed7cSAlexander Aring pr_debug("Invalid address mode value: 0x%x\n", address_mode);
3462c6bed7cSAlexander Aring return -EINVAL;
3472c6bed7cSAlexander Aring }
3482c6bed7cSAlexander Aring
3492c6bed7cSAlexander Aring if (fail) {
3502c6bed7cSAlexander Aring pr_debug("Failed to fetch skb data\n");
3512c6bed7cSAlexander Aring return -EIO;
3522c6bed7cSAlexander Aring }
3532c6bed7cSAlexander Aring
3542c6bed7cSAlexander Aring raw_dump_inline(NULL, "Reconstructed ipv6 addr is",
3552c6bed7cSAlexander Aring ipaddr->s6_addr, 16);
3562c6bed7cSAlexander Aring
3572c6bed7cSAlexander Aring return 0;
3582c6bed7cSAlexander Aring }
3592c6bed7cSAlexander Aring
3603fd0202aSDavid S. Miller /* Uncompress address function for source context
3612c6bed7cSAlexander Aring * based address(non-multicast).
3622c6bed7cSAlexander Aring */
lowpan_iphc_uncompress_ctx_addr(struct sk_buff * skb,const struct net_device * dev,const struct lowpan_iphc_ctx * ctx,struct in6_addr * ipaddr,u8 address_mode,const void * lladdr)3637115a968SAlexander Aring static int lowpan_iphc_uncompress_ctx_addr(struct sk_buff *skb,
3645609c185SAlexander Aring const struct net_device *dev,
3655609c185SAlexander Aring const struct lowpan_iphc_ctx *ctx,
3667115a968SAlexander Aring struct in6_addr *ipaddr,
3677115a968SAlexander Aring u8 address_mode, const void *lladdr)
3682c6bed7cSAlexander Aring {
3695609c185SAlexander Aring bool fail;
3705609c185SAlexander Aring
371c8a3e7ebSAlexander Aring switch (address_mode) {
3725609c185SAlexander Aring /* SAM and DAM are the same here */
3735609c185SAlexander Aring case LOWPAN_IPHC_DAM_00:
3745609c185SAlexander Aring fail = false;
3755609c185SAlexander Aring /* SAM_00 -> unspec address ::
3762c6bed7cSAlexander Aring * Do nothing, address is already ::
3775609c185SAlexander Aring *
3785609c185SAlexander Aring * DAM 00 -> reserved should never occur.
3792c6bed7cSAlexander Aring */
3802c6bed7cSAlexander Aring break;
381c8a3e7ebSAlexander Aring case LOWPAN_IPHC_SAM_01:
3825609c185SAlexander Aring case LOWPAN_IPHC_DAM_01:
3835609c185SAlexander Aring fail = lowpan_fetch_skb(skb, &ipaddr->s6_addr[8], 8);
3845609c185SAlexander Aring ipv6_addr_prefix_copy(ipaddr, &ctx->pfx, ctx->plen);
3855609c185SAlexander Aring break;
386c8a3e7ebSAlexander Aring case LOWPAN_IPHC_SAM_10:
3875609c185SAlexander Aring case LOWPAN_IPHC_DAM_10:
3885609c185SAlexander Aring ipaddr->s6_addr[11] = 0xFF;
3895609c185SAlexander Aring ipaddr->s6_addr[12] = 0xFE;
3905609c185SAlexander Aring fail = lowpan_fetch_skb(skb, &ipaddr->s6_addr[14], 2);
3915609c185SAlexander Aring ipv6_addr_prefix_copy(ipaddr, &ctx->pfx, ctx->plen);
3925609c185SAlexander Aring break;
393c8a3e7ebSAlexander Aring case LOWPAN_IPHC_SAM_11:
3945609c185SAlexander Aring case LOWPAN_IPHC_DAM_11:
3955609c185SAlexander Aring fail = false;
3962e4d60cbSAlexander Aring switch (lowpan_dev(dev)->lltype) {
3975609c185SAlexander Aring case LOWPAN_LLTYPE_IEEE802154:
3987115a968SAlexander Aring lowpan_iphc_uncompress_802154_lladdr(ipaddr, lladdr);
3995609c185SAlexander Aring break;
4005609c185SAlexander Aring default:
401fa09ae66SLuiz Augusto von Dentz lowpan_iphc_uncompress_lladdr(dev, ipaddr, lladdr);
4025609c185SAlexander Aring break;
4035609c185SAlexander Aring }
4045609c185SAlexander Aring ipv6_addr_prefix_copy(ipaddr, &ctx->pfx, ctx->plen);
4055609c185SAlexander Aring break;
4062c6bed7cSAlexander Aring default:
407c8a3e7ebSAlexander Aring pr_debug("Invalid sam value: 0x%x\n", address_mode);
4082c6bed7cSAlexander Aring return -EINVAL;
4092c6bed7cSAlexander Aring }
4102c6bed7cSAlexander Aring
4115609c185SAlexander Aring if (fail) {
4125609c185SAlexander Aring pr_debug("Failed to fetch skb data\n");
4135609c185SAlexander Aring return -EIO;
4145609c185SAlexander Aring }
4155609c185SAlexander Aring
4162c6bed7cSAlexander Aring raw_dump_inline(NULL,
4172c6bed7cSAlexander Aring "Reconstructed context based ipv6 src addr is",
4182c6bed7cSAlexander Aring ipaddr->s6_addr, 16);
4192c6bed7cSAlexander Aring
4202c6bed7cSAlexander Aring return 0;
4212c6bed7cSAlexander Aring }
4222c6bed7cSAlexander Aring
4232c6bed7cSAlexander Aring /* Uncompress function for multicast destination address,
4242c6bed7cSAlexander Aring * when M bit is set.
4252c6bed7cSAlexander Aring */
lowpan_uncompress_multicast_daddr(struct sk_buff * skb,struct in6_addr * ipaddr,u8 address_mode)4267fc4cfdaSMarcel Holtmann static int lowpan_uncompress_multicast_daddr(struct sk_buff *skb,
4272c6bed7cSAlexander Aring struct in6_addr *ipaddr,
428c8a3e7ebSAlexander Aring u8 address_mode)
4292c6bed7cSAlexander Aring {
4302c6bed7cSAlexander Aring bool fail;
4312c6bed7cSAlexander Aring
432c8a3e7ebSAlexander Aring switch (address_mode) {
4332c6bed7cSAlexander Aring case LOWPAN_IPHC_DAM_00:
4342c6bed7cSAlexander Aring /* 00: 128 bits. The full address
4352c6bed7cSAlexander Aring * is carried in-line.
4362c6bed7cSAlexander Aring */
4372c6bed7cSAlexander Aring fail = lowpan_fetch_skb(skb, ipaddr->s6_addr, 16);
4382c6bed7cSAlexander Aring break;
4392c6bed7cSAlexander Aring case LOWPAN_IPHC_DAM_01:
4402c6bed7cSAlexander Aring /* 01: 48 bits. The address takes
4412c6bed7cSAlexander Aring * the form ffXX::00XX:XXXX:XXXX.
4422c6bed7cSAlexander Aring */
4432c6bed7cSAlexander Aring ipaddr->s6_addr[0] = 0xFF;
4442c6bed7cSAlexander Aring fail = lowpan_fetch_skb(skb, &ipaddr->s6_addr[1], 1);
4452c6bed7cSAlexander Aring fail |= lowpan_fetch_skb(skb, &ipaddr->s6_addr[11], 5);
4462c6bed7cSAlexander Aring break;
4472c6bed7cSAlexander Aring case LOWPAN_IPHC_DAM_10:
4482c6bed7cSAlexander Aring /* 10: 32 bits. The address takes
4492c6bed7cSAlexander Aring * the form ffXX::00XX:XXXX.
4502c6bed7cSAlexander Aring */
4512c6bed7cSAlexander Aring ipaddr->s6_addr[0] = 0xFF;
4522c6bed7cSAlexander Aring fail = lowpan_fetch_skb(skb, &ipaddr->s6_addr[1], 1);
4532c6bed7cSAlexander Aring fail |= lowpan_fetch_skb(skb, &ipaddr->s6_addr[13], 3);
4542c6bed7cSAlexander Aring break;
4552c6bed7cSAlexander Aring case LOWPAN_IPHC_DAM_11:
4562c6bed7cSAlexander Aring /* 11: 8 bits. The address takes
4572c6bed7cSAlexander Aring * the form ff02::00XX.
4582c6bed7cSAlexander Aring */
4592c6bed7cSAlexander Aring ipaddr->s6_addr[0] = 0xFF;
4602c6bed7cSAlexander Aring ipaddr->s6_addr[1] = 0x02;
4612c6bed7cSAlexander Aring fail = lowpan_fetch_skb(skb, &ipaddr->s6_addr[15], 1);
4622c6bed7cSAlexander Aring break;
4632c6bed7cSAlexander Aring default:
464c8a3e7ebSAlexander Aring pr_debug("DAM value has a wrong value: 0x%x\n", address_mode);
4652c6bed7cSAlexander Aring return -EINVAL;
4662c6bed7cSAlexander Aring }
4672c6bed7cSAlexander Aring
4682c6bed7cSAlexander Aring if (fail) {
4692c6bed7cSAlexander Aring pr_debug("Failed to fetch skb data\n");
4702c6bed7cSAlexander Aring return -EIO;
4712c6bed7cSAlexander Aring }
4722c6bed7cSAlexander Aring
4732c6bed7cSAlexander Aring raw_dump_inline(NULL, "Reconstructed ipv6 multicast addr is",
4742c6bed7cSAlexander Aring ipaddr->s6_addr, 16);
4752c6bed7cSAlexander Aring
4762c6bed7cSAlexander Aring return 0;
4772c6bed7cSAlexander Aring }
4782c6bed7cSAlexander Aring
lowpan_uncompress_multicast_ctx_daddr(struct sk_buff * skb,struct lowpan_iphc_ctx * ctx,struct in6_addr * ipaddr,u8 address_mode)4795609c185SAlexander Aring static int lowpan_uncompress_multicast_ctx_daddr(struct sk_buff *skb,
4805609c185SAlexander Aring struct lowpan_iphc_ctx *ctx,
4815609c185SAlexander Aring struct in6_addr *ipaddr,
4825609c185SAlexander Aring u8 address_mode)
4835609c185SAlexander Aring {
4845609c185SAlexander Aring struct in6_addr network_pfx = {};
4855609c185SAlexander Aring bool fail;
4865609c185SAlexander Aring
4875609c185SAlexander Aring ipaddr->s6_addr[0] = 0xFF;
4885609c185SAlexander Aring fail = lowpan_fetch_skb(skb, &ipaddr->s6_addr[1], 2);
4895609c185SAlexander Aring fail |= lowpan_fetch_skb(skb, &ipaddr->s6_addr[12], 4);
4904c23d874SAndrzej Hajda if (fail)
4915609c185SAlexander Aring return -EIO;
4925609c185SAlexander Aring
4935609c185SAlexander Aring /* take prefix_len and network prefix from the context */
4945609c185SAlexander Aring ipaddr->s6_addr[3] = ctx->plen;
4955609c185SAlexander Aring /* get network prefix to copy into multicast address */
4965609c185SAlexander Aring ipv6_addr_prefix(&network_pfx, &ctx->pfx, ctx->plen);
4975609c185SAlexander Aring /* setting network prefix */
4985609c185SAlexander Aring memcpy(&ipaddr->s6_addr[4], &network_pfx, 8);
4995609c185SAlexander Aring
5005609c185SAlexander Aring return 0;
5015609c185SAlexander Aring }
5025609c185SAlexander Aring
503b5af9bdbSAlexander Aring /* get the ecn values from iphc tf format and set it to ipv6hdr */
lowpan_iphc_tf_set_ecn(struct ipv6hdr * hdr,const u8 * tf)504b5af9bdbSAlexander Aring static inline void lowpan_iphc_tf_set_ecn(struct ipv6hdr *hdr, const u8 *tf)
505b5af9bdbSAlexander Aring {
506b5af9bdbSAlexander Aring /* get the two higher bits which is ecn */
507b5af9bdbSAlexander Aring u8 ecn = tf[0] & 0xc0;
508b5af9bdbSAlexander Aring
509b5af9bdbSAlexander Aring /* ECN takes 0x30 in hdr->flow_lbl[0] */
510b5af9bdbSAlexander Aring hdr->flow_lbl[0] |= (ecn >> 2);
511b5af9bdbSAlexander Aring }
512b5af9bdbSAlexander Aring
513b5af9bdbSAlexander Aring /* get the dscp values from iphc tf format and set it to ipv6hdr */
lowpan_iphc_tf_set_dscp(struct ipv6hdr * hdr,const u8 * tf)514b5af9bdbSAlexander Aring static inline void lowpan_iphc_tf_set_dscp(struct ipv6hdr *hdr, const u8 *tf)
515b5af9bdbSAlexander Aring {
516b5af9bdbSAlexander Aring /* DSCP is at place after ECN */
517b5af9bdbSAlexander Aring u8 dscp = tf[0] & 0x3f;
518b5af9bdbSAlexander Aring
519b5af9bdbSAlexander Aring /* The four highest bits need to be set at hdr->priority */
520b5af9bdbSAlexander Aring hdr->priority |= ((dscp & 0x3c) >> 2);
521b5af9bdbSAlexander Aring /* The two lower bits is part of hdr->flow_lbl[0] */
522b5af9bdbSAlexander Aring hdr->flow_lbl[0] |= ((dscp & 0x03) << 6);
523b5af9bdbSAlexander Aring }
524b5af9bdbSAlexander Aring
525b5af9bdbSAlexander Aring /* get the flow label values from iphc tf format and set it to ipv6hdr */
lowpan_iphc_tf_set_lbl(struct ipv6hdr * hdr,const u8 * lbl)526b5af9bdbSAlexander Aring static inline void lowpan_iphc_tf_set_lbl(struct ipv6hdr *hdr, const u8 *lbl)
527b5af9bdbSAlexander Aring {
528b5af9bdbSAlexander Aring /* flow label is always some array started with lower nibble of
529b5af9bdbSAlexander Aring * flow_lbl[0] and followed with two bytes afterwards. Inside inline
530b5af9bdbSAlexander Aring * data the flow_lbl position can be different, which will be handled
531b5af9bdbSAlexander Aring * by lbl pointer. E.g. case "01" vs "00" the traffic class is 8 bit
532b5af9bdbSAlexander Aring * shifted, the different lbl pointer will handle that.
533b5af9bdbSAlexander Aring *
534b5af9bdbSAlexander Aring * The flow label will started at lower nibble of flow_lbl[0], the
535b5af9bdbSAlexander Aring * higher nibbles are part of DSCP + ECN.
536b5af9bdbSAlexander Aring */
537b5af9bdbSAlexander Aring hdr->flow_lbl[0] |= lbl[0] & 0x0f;
538b5af9bdbSAlexander Aring memcpy(&hdr->flow_lbl[1], &lbl[1], 2);
539b5af9bdbSAlexander Aring }
540b5af9bdbSAlexander Aring
541b5af9bdbSAlexander Aring /* lowpan_iphc_tf_decompress - decompress the traffic class.
542b5af9bdbSAlexander Aring * This function will return zero on success, a value lower than zero if
543b5af9bdbSAlexander Aring * failed.
544b5af9bdbSAlexander Aring */
lowpan_iphc_tf_decompress(struct sk_buff * skb,struct ipv6hdr * hdr,u8 val)545b5af9bdbSAlexander Aring static int lowpan_iphc_tf_decompress(struct sk_buff *skb, struct ipv6hdr *hdr,
546b5af9bdbSAlexander Aring u8 val)
547b5af9bdbSAlexander Aring {
548b5af9bdbSAlexander Aring u8 tf[4];
549b5af9bdbSAlexander Aring
550b5af9bdbSAlexander Aring /* Traffic Class and Flow Label */
551b5af9bdbSAlexander Aring switch (val) {
552b5af9bdbSAlexander Aring case LOWPAN_IPHC_TF_00:
553b5af9bdbSAlexander Aring /* ECN + DSCP + 4-bit Pad + Flow Label (4 bytes) */
554b5af9bdbSAlexander Aring if (lowpan_fetch_skb(skb, tf, 4))
555b5af9bdbSAlexander Aring return -EINVAL;
556b5af9bdbSAlexander Aring
557b5af9bdbSAlexander Aring /* 1 2 3
558b5af9bdbSAlexander Aring * 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
559b5af9bdbSAlexander Aring * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
560b5af9bdbSAlexander Aring * |ECN| DSCP | rsv | Flow Label |
561b5af9bdbSAlexander Aring * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
562b5af9bdbSAlexander Aring */
563b5af9bdbSAlexander Aring lowpan_iphc_tf_set_ecn(hdr, tf);
564b5af9bdbSAlexander Aring lowpan_iphc_tf_set_dscp(hdr, tf);
565b5af9bdbSAlexander Aring lowpan_iphc_tf_set_lbl(hdr, &tf[1]);
566b5af9bdbSAlexander Aring break;
567b5af9bdbSAlexander Aring case LOWPAN_IPHC_TF_01:
568b5af9bdbSAlexander Aring /* ECN + 2-bit Pad + Flow Label (3 bytes), DSCP is elided. */
569b5af9bdbSAlexander Aring if (lowpan_fetch_skb(skb, tf, 3))
570b5af9bdbSAlexander Aring return -EINVAL;
571b5af9bdbSAlexander Aring
572b5af9bdbSAlexander Aring /* 1 2
573b5af9bdbSAlexander Aring * 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3
574b5af9bdbSAlexander Aring * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
575b5af9bdbSAlexander Aring * |ECN|rsv| Flow Label |
576b5af9bdbSAlexander Aring * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
577b5af9bdbSAlexander Aring */
578b5af9bdbSAlexander Aring lowpan_iphc_tf_set_ecn(hdr, tf);
579b5af9bdbSAlexander Aring lowpan_iphc_tf_set_lbl(hdr, &tf[0]);
580b5af9bdbSAlexander Aring break;
581b5af9bdbSAlexander Aring case LOWPAN_IPHC_TF_10:
582b5af9bdbSAlexander Aring /* ECN + DSCP (1 byte), Flow Label is elided. */
583b5af9bdbSAlexander Aring if (lowpan_fetch_skb(skb, tf, 1))
584b5af9bdbSAlexander Aring return -EINVAL;
585b5af9bdbSAlexander Aring
586b5af9bdbSAlexander Aring /* 0 1 2 3 4 5 6 7
587b5af9bdbSAlexander Aring * +-+-+-+-+-+-+-+-+
588b5af9bdbSAlexander Aring * |ECN| DSCP |
589b5af9bdbSAlexander Aring * +-+-+-+-+-+-+-+-+
590b5af9bdbSAlexander Aring */
591b5af9bdbSAlexander Aring lowpan_iphc_tf_set_ecn(hdr, tf);
592b5af9bdbSAlexander Aring lowpan_iphc_tf_set_dscp(hdr, tf);
593b5af9bdbSAlexander Aring break;
594b5af9bdbSAlexander Aring case LOWPAN_IPHC_TF_11:
595b5af9bdbSAlexander Aring /* Traffic Class and Flow Label are elided */
596b5af9bdbSAlexander Aring break;
597b5af9bdbSAlexander Aring default:
598b5af9bdbSAlexander Aring WARN_ON_ONCE(1);
599b5af9bdbSAlexander Aring return -EINVAL;
600b5af9bdbSAlexander Aring }
601b5af9bdbSAlexander Aring
602b5af9bdbSAlexander Aring return 0;
603b5af9bdbSAlexander Aring }
604b5af9bdbSAlexander Aring
6052c6bed7cSAlexander Aring /* TTL uncompression values */
606c8a3e7ebSAlexander Aring static const u8 lowpan_ttl_values[] = {
607c8a3e7ebSAlexander Aring [LOWPAN_IPHC_HLIM_01] = 1,
608c8a3e7ebSAlexander Aring [LOWPAN_IPHC_HLIM_10] = 64,
609c8a3e7ebSAlexander Aring [LOWPAN_IPHC_HLIM_11] = 255,
610c8a3e7ebSAlexander Aring };
6112c6bed7cSAlexander Aring
lowpan_header_decompress(struct sk_buff * skb,const struct net_device * dev,const void * daddr,const void * saddr)6128911d774SAlexander Aring int lowpan_header_decompress(struct sk_buff *skb, const struct net_device *dev,
6138911d774SAlexander Aring const void *daddr, const void *saddr)
6142c6bed7cSAlexander Aring {
6152c6bed7cSAlexander Aring struct ipv6hdr hdr = {};
6165609c185SAlexander Aring struct lowpan_iphc_ctx *ci;
6175609c185SAlexander Aring u8 iphc0, iphc1, cid = 0;
6182c6bed7cSAlexander Aring int err;
6192c6bed7cSAlexander Aring
6202c6bed7cSAlexander Aring raw_dump_table(__func__, "raw skb data dump uncompressed",
6212c6bed7cSAlexander Aring skb->data, skb->len);
6222c6bed7cSAlexander Aring
623478208e3SAlexander Aring if (lowpan_fetch_skb(skb, &iphc0, sizeof(iphc0)) ||
624478208e3SAlexander Aring lowpan_fetch_skb(skb, &iphc1, sizeof(iphc1)))
6258911d774SAlexander Aring return -EINVAL;
6268911d774SAlexander Aring
6272c6bed7cSAlexander Aring hdr.version = 6;
6282c6bed7cSAlexander Aring
6295609c185SAlexander Aring /* default CID = 0, another if the CID flag is set */
6305609c185SAlexander Aring if (iphc1 & LOWPAN_IPHC_CID) {
6315609c185SAlexander Aring if (lowpan_fetch_skb(skb, &cid, sizeof(cid)))
6325609c185SAlexander Aring return -EINVAL;
6335609c185SAlexander Aring }
6345609c185SAlexander Aring
635b5af9bdbSAlexander Aring err = lowpan_iphc_tf_decompress(skb, &hdr,
636b5af9bdbSAlexander Aring iphc0 & LOWPAN_IPHC_TF_MASK);
637b5af9bdbSAlexander Aring if (err < 0)
638b5af9bdbSAlexander Aring return err;
6392c6bed7cSAlexander Aring
6402c6bed7cSAlexander Aring /* Next Header */
641c8a3e7ebSAlexander Aring if (!(iphc0 & LOWPAN_IPHC_NH)) {
6422c6bed7cSAlexander Aring /* Next header is carried inline */
6434ebc960fSAlexander Aring if (lowpan_fetch_skb(skb, &hdr.nexthdr, sizeof(hdr.nexthdr)))
64456b2c3eeSMartin Townsend return -EINVAL;
6452c6bed7cSAlexander Aring
6462c6bed7cSAlexander Aring pr_debug("NH flag is set, next header carried inline: %02x\n",
6472c6bed7cSAlexander Aring hdr.nexthdr);
6482c6bed7cSAlexander Aring }
6492c6bed7cSAlexander Aring
6502c6bed7cSAlexander Aring /* Hop Limit */
651c8a3e7ebSAlexander Aring if ((iphc0 & LOWPAN_IPHC_HLIM_MASK) != LOWPAN_IPHC_HLIM_00) {
652c8a3e7ebSAlexander Aring hdr.hop_limit = lowpan_ttl_values[iphc0 & LOWPAN_IPHC_HLIM_MASK];
6533fd0202aSDavid S. Miller } else {
6544ebc960fSAlexander Aring if (lowpan_fetch_skb(skb, &hdr.hop_limit,
6554ebc960fSAlexander Aring sizeof(hdr.hop_limit)))
65656b2c3eeSMartin Townsend return -EINVAL;
6572c6bed7cSAlexander Aring }
6582c6bed7cSAlexander Aring
6592c6bed7cSAlexander Aring if (iphc1 & LOWPAN_IPHC_SAC) {
6602e4d60cbSAlexander Aring spin_lock_bh(&lowpan_dev(dev)->ctx.lock);
6615609c185SAlexander Aring ci = lowpan_iphc_ctx_get_by_id(dev, LOWPAN_IPHC_CID_SCI(cid));
6625609c185SAlexander Aring if (!ci) {
6632e4d60cbSAlexander Aring spin_unlock_bh(&lowpan_dev(dev)->ctx.lock);
6645609c185SAlexander Aring return -EINVAL;
6655609c185SAlexander Aring }
6665609c185SAlexander Aring
6672c6bed7cSAlexander Aring pr_debug("SAC bit is set. Handle context based source address.\n");
6687115a968SAlexander Aring err = lowpan_iphc_uncompress_ctx_addr(skb, dev, ci, &hdr.saddr,
6697115a968SAlexander Aring iphc1 & LOWPAN_IPHC_SAM_MASK,
6707115a968SAlexander Aring saddr);
6712e4d60cbSAlexander Aring spin_unlock_bh(&lowpan_dev(dev)->ctx.lock);
6722c6bed7cSAlexander Aring } else {
6732c6bed7cSAlexander Aring /* Source address uncompression */
6742c6bed7cSAlexander Aring pr_debug("source address stateless compression\n");
6757115a968SAlexander Aring err = lowpan_iphc_uncompress_addr(skb, dev, &hdr.saddr,
6767115a968SAlexander Aring iphc1 & LOWPAN_IPHC_SAM_MASK,
6777115a968SAlexander Aring saddr);
6782c6bed7cSAlexander Aring }
6792c6bed7cSAlexander Aring
6802c6bed7cSAlexander Aring /* Check on error of previous branch */
6812c6bed7cSAlexander Aring if (err)
68256b2c3eeSMartin Townsend return -EINVAL;
6832c6bed7cSAlexander Aring
6845609c185SAlexander Aring switch (iphc1 & (LOWPAN_IPHC_M | LOWPAN_IPHC_DAC)) {
6855609c185SAlexander Aring case LOWPAN_IPHC_M | LOWPAN_IPHC_DAC:
68694e4a680SAlexander Aring skb->pkt_type = PACKET_BROADCAST;
68794e4a680SAlexander Aring
6882e4d60cbSAlexander Aring spin_lock_bh(&lowpan_dev(dev)->ctx.lock);
6895609c185SAlexander Aring ci = lowpan_iphc_ctx_get_by_id(dev, LOWPAN_IPHC_CID_DCI(cid));
6905609c185SAlexander Aring if (!ci) {
6912e4d60cbSAlexander Aring spin_unlock_bh(&lowpan_dev(dev)->ctx.lock);
69256b2c3eeSMartin Townsend return -EINVAL;
6932c6bed7cSAlexander Aring }
6945609c185SAlexander Aring
6955609c185SAlexander Aring /* multicast with context */
6965609c185SAlexander Aring pr_debug("dest: context-based mcast compression\n");
6975609c185SAlexander Aring err = lowpan_uncompress_multicast_ctx_daddr(skb, ci,
6985609c185SAlexander Aring &hdr.daddr,
6995609c185SAlexander Aring iphc1 & LOWPAN_IPHC_DAM_MASK);
7002e4d60cbSAlexander Aring spin_unlock_bh(&lowpan_dev(dev)->ctx.lock);
7015609c185SAlexander Aring break;
7025609c185SAlexander Aring case LOWPAN_IPHC_M:
70394e4a680SAlexander Aring skb->pkt_type = PACKET_BROADCAST;
70494e4a680SAlexander Aring
7055609c185SAlexander Aring /* multicast */
7065609c185SAlexander Aring err = lowpan_uncompress_multicast_daddr(skb, &hdr.daddr,
7075609c185SAlexander Aring iphc1 & LOWPAN_IPHC_DAM_MASK);
7085609c185SAlexander Aring break;
7095609c185SAlexander Aring case LOWPAN_IPHC_DAC:
71094e4a680SAlexander Aring skb->pkt_type = PACKET_HOST;
71194e4a680SAlexander Aring
7122e4d60cbSAlexander Aring spin_lock_bh(&lowpan_dev(dev)->ctx.lock);
7135609c185SAlexander Aring ci = lowpan_iphc_ctx_get_by_id(dev, LOWPAN_IPHC_CID_DCI(cid));
7145609c185SAlexander Aring if (!ci) {
7152e4d60cbSAlexander Aring spin_unlock_bh(&lowpan_dev(dev)->ctx.lock);
7165609c185SAlexander Aring return -EINVAL;
7175609c185SAlexander Aring }
7185609c185SAlexander Aring
7195609c185SAlexander Aring /* Destination address context based uncompression */
7205609c185SAlexander Aring pr_debug("DAC bit is set. Handle context based destination address.\n");
7217115a968SAlexander Aring err = lowpan_iphc_uncompress_ctx_addr(skb, dev, ci, &hdr.daddr,
7227115a968SAlexander Aring iphc1 & LOWPAN_IPHC_DAM_MASK,
7237115a968SAlexander Aring daddr);
7242e4d60cbSAlexander Aring spin_unlock_bh(&lowpan_dev(dev)->ctx.lock);
7255609c185SAlexander Aring break;
7265609c185SAlexander Aring default:
72794e4a680SAlexander Aring skb->pkt_type = PACKET_HOST;
72894e4a680SAlexander Aring
7297115a968SAlexander Aring err = lowpan_iphc_uncompress_addr(skb, dev, &hdr.daddr,
7307115a968SAlexander Aring iphc1 & LOWPAN_IPHC_DAM_MASK,
7317115a968SAlexander Aring daddr);
7322c6bed7cSAlexander Aring pr_debug("dest: stateless compression mode %d dest %pI6c\n",
733c8a3e7ebSAlexander Aring iphc1 & LOWPAN_IPHC_DAM_MASK, &hdr.daddr);
7345609c185SAlexander Aring break;
7355609c185SAlexander Aring }
7365609c185SAlexander Aring
7372c6bed7cSAlexander Aring if (err)
73856b2c3eeSMartin Townsend return -EINVAL;
7392c6bed7cSAlexander Aring
740cc6ed268SAlexander Aring /* Next header data uncompression */
741c8a3e7ebSAlexander Aring if (iphc0 & LOWPAN_IPHC_NH) {
742cc6ed268SAlexander Aring err = lowpan_nhc_do_uncompression(skb, dev, &hdr);
743cc6ed268SAlexander Aring if (err < 0)
74411e3ff70SMartin Townsend return err;
74511e3ff70SMartin Townsend } else {
74611e3ff70SMartin Townsend err = skb_cow(skb, sizeof(hdr));
74756b2c3eeSMartin Townsend if (unlikely(err))
74811e3ff70SMartin Townsend return err;
74911e3ff70SMartin Townsend }
7502c6bed7cSAlexander Aring
7512e4d60cbSAlexander Aring switch (lowpan_dev(dev)->lltype) {
75272a5e6bbSAlexander Aring case LOWPAN_LLTYPE_IEEE802154:
75372a5e6bbSAlexander Aring if (lowpan_802154_cb(skb)->d_size)
75472a5e6bbSAlexander Aring hdr.payload_len = htons(lowpan_802154_cb(skb)->d_size -
75572a5e6bbSAlexander Aring sizeof(struct ipv6hdr));
75672a5e6bbSAlexander Aring else
7572c6bed7cSAlexander Aring hdr.payload_len = htons(skb->len);
75872a5e6bbSAlexander Aring break;
75972a5e6bbSAlexander Aring default:
76072a5e6bbSAlexander Aring hdr.payload_len = htons(skb->len);
76172a5e6bbSAlexander Aring break;
76272a5e6bbSAlexander Aring }
7632c6bed7cSAlexander Aring
7642c6bed7cSAlexander Aring pr_debug("skb headroom size = %d, data length = %d\n",
7652c6bed7cSAlexander Aring skb_headroom(skb), skb->len);
7662c6bed7cSAlexander Aring
7672c6bed7cSAlexander Aring pr_debug("IPv6 header dump:\n\tversion = %d\n\tlength = %d\n\t"
7682c6bed7cSAlexander Aring "nexthdr = 0x%02x\n\thop_lim = %d\n\tdest = %pI6c\n",
7692c6bed7cSAlexander Aring hdr.version, ntohs(hdr.payload_len), hdr.nexthdr,
7702c6bed7cSAlexander Aring hdr.hop_limit, &hdr.daddr);
7712c6bed7cSAlexander Aring
772f8b36176SMartin Townsend skb_push(skb, sizeof(hdr));
77303bc05e1SMichael Scott skb_reset_mac_header(skb);
774f8b36176SMartin Townsend skb_reset_network_header(skb);
775f8b36176SMartin Townsend skb_copy_to_linear_data(skb, &hdr, sizeof(hdr));
776f8b36176SMartin Townsend
7777fc4cfdaSMarcel Holtmann raw_dump_table(__func__, "raw header dump", (u8 *)&hdr, sizeof(hdr));
7782c6bed7cSAlexander Aring
779f8b36176SMartin Townsend return 0;
7802c6bed7cSAlexander Aring }
78101141234SMartin Townsend EXPORT_SYMBOL_GPL(lowpan_header_decompress);
7822c6bed7cSAlexander Aring
783c8a3e7ebSAlexander Aring static const u8 lowpan_iphc_dam_to_sam_value[] = {
784c8a3e7ebSAlexander Aring [LOWPAN_IPHC_DAM_00] = LOWPAN_IPHC_SAM_00,
785c8a3e7ebSAlexander Aring [LOWPAN_IPHC_DAM_01] = LOWPAN_IPHC_SAM_01,
786c8a3e7ebSAlexander Aring [LOWPAN_IPHC_DAM_10] = LOWPAN_IPHC_SAM_10,
787c8a3e7ebSAlexander Aring [LOWPAN_IPHC_DAM_11] = LOWPAN_IPHC_SAM_11,
788c8a3e7ebSAlexander Aring };
789c8a3e7ebSAlexander Aring
790eab560e5SAlexander Aring static inline bool
lowpan_iphc_compress_ctx_802154_lladdr(const struct in6_addr * ipaddr,const struct lowpan_iphc_ctx * ctx,const void * lladdr)791eab560e5SAlexander Aring lowpan_iphc_compress_ctx_802154_lladdr(const struct in6_addr *ipaddr,
792eab560e5SAlexander Aring const struct lowpan_iphc_ctx *ctx,
793eab560e5SAlexander Aring const void *lladdr)
794eab560e5SAlexander Aring {
795eab560e5SAlexander Aring const struct ieee802154_addr *addr = lladdr;
796eab560e5SAlexander Aring unsigned char extended_addr[EUI64_ADDR_LEN];
797eab560e5SAlexander Aring bool lladdr_compress = false;
798eab560e5SAlexander Aring struct in6_addr tmp = {};
799eab560e5SAlexander Aring
800eab560e5SAlexander Aring switch (addr->mode) {
801eab560e5SAlexander Aring case IEEE802154_ADDR_LONG:
802eab560e5SAlexander Aring ieee802154_le64_to_be64(&extended_addr, &addr->extended_addr);
803eab560e5SAlexander Aring /* check for SAM/DAM = 11 */
804eab560e5SAlexander Aring memcpy(&tmp.s6_addr[8], &extended_addr, EUI64_ADDR_LEN);
805eab560e5SAlexander Aring /* second bit-flip (Universe/Local) is done according RFC2464 */
806eab560e5SAlexander Aring tmp.s6_addr[8] ^= 0x02;
807eab560e5SAlexander Aring /* context information are always used */
808eab560e5SAlexander Aring ipv6_addr_prefix_copy(&tmp, &ctx->pfx, ctx->plen);
809eab560e5SAlexander Aring if (ipv6_addr_equal(&tmp, ipaddr))
810eab560e5SAlexander Aring lladdr_compress = true;
811eab560e5SAlexander Aring break;
812eab560e5SAlexander Aring case IEEE802154_ADDR_SHORT:
813eab560e5SAlexander Aring tmp.s6_addr[11] = 0xFF;
814eab560e5SAlexander Aring tmp.s6_addr[12] = 0xFE;
815eab560e5SAlexander Aring ieee802154_le16_to_be16(&tmp.s6_addr16[7],
816eab560e5SAlexander Aring &addr->short_addr);
817eab560e5SAlexander Aring /* context information are always used */
818eab560e5SAlexander Aring ipv6_addr_prefix_copy(&tmp, &ctx->pfx, ctx->plen);
819eab560e5SAlexander Aring if (ipv6_addr_equal(&tmp, ipaddr))
820eab560e5SAlexander Aring lladdr_compress = true;
821eab560e5SAlexander Aring break;
822eab560e5SAlexander Aring default:
823eab560e5SAlexander Aring /* should never handled and filtered by 802154 6lowpan */
824eab560e5SAlexander Aring WARN_ON_ONCE(1);
825eab560e5SAlexander Aring break;
826eab560e5SAlexander Aring }
827eab560e5SAlexander Aring
828eab560e5SAlexander Aring return lladdr_compress;
829eab560e5SAlexander Aring }
830eab560e5SAlexander Aring
lowpan_iphc_addr_equal(const struct net_device * dev,const struct lowpan_iphc_ctx * ctx,const struct in6_addr * ipaddr,const void * lladdr)831fa09ae66SLuiz Augusto von Dentz static bool lowpan_iphc_addr_equal(const struct net_device *dev,
832fa09ae66SLuiz Augusto von Dentz const struct lowpan_iphc_ctx *ctx,
833fa09ae66SLuiz Augusto von Dentz const struct in6_addr *ipaddr,
834fa09ae66SLuiz Augusto von Dentz const void *lladdr)
835fa09ae66SLuiz Augusto von Dentz {
836fa09ae66SLuiz Augusto von Dentz struct in6_addr tmp = {};
837fa09ae66SLuiz Augusto von Dentz
838fa09ae66SLuiz Augusto von Dentz lowpan_iphc_uncompress_lladdr(dev, &tmp, lladdr);
839fa09ae66SLuiz Augusto von Dentz
840fa09ae66SLuiz Augusto von Dentz if (ctx)
841fa09ae66SLuiz Augusto von Dentz ipv6_addr_prefix_copy(&tmp, &ctx->pfx, ctx->plen);
842fa09ae66SLuiz Augusto von Dentz
843fa09ae66SLuiz Augusto von Dentz return ipv6_addr_equal(&tmp, ipaddr);
844fa09ae66SLuiz Augusto von Dentz }
845fa09ae66SLuiz Augusto von Dentz
lowpan_compress_ctx_addr(u8 ** hc_ptr,const struct net_device * dev,const struct in6_addr * ipaddr,const struct lowpan_iphc_ctx * ctx,const unsigned char * lladdr,bool sam)846eab560e5SAlexander Aring static u8 lowpan_compress_ctx_addr(u8 **hc_ptr, const struct net_device *dev,
847eab560e5SAlexander Aring const struct in6_addr *ipaddr,
8485609c185SAlexander Aring const struct lowpan_iphc_ctx *ctx,
8495609c185SAlexander Aring const unsigned char *lladdr, bool sam)
8505609c185SAlexander Aring {
851*be689c71SKuniyuki Iwashima struct in6_addr tmp;
8525609c185SAlexander Aring u8 dam;
8535609c185SAlexander Aring
854eab560e5SAlexander Aring switch (lowpan_dev(dev)->lltype) {
855eab560e5SAlexander Aring case LOWPAN_LLTYPE_IEEE802154:
856eab560e5SAlexander Aring if (lowpan_iphc_compress_ctx_802154_lladdr(ipaddr, ctx,
857eab560e5SAlexander Aring lladdr)) {
858eab560e5SAlexander Aring dam = LOWPAN_IPHC_DAM_11;
859eab560e5SAlexander Aring goto out;
860eab560e5SAlexander Aring }
861eab560e5SAlexander Aring break;
862eab560e5SAlexander Aring default:
863fa09ae66SLuiz Augusto von Dentz if (lowpan_iphc_addr_equal(dev, ctx, ipaddr, lladdr)) {
8645609c185SAlexander Aring dam = LOWPAN_IPHC_DAM_11;
8655609c185SAlexander Aring goto out;
8665609c185SAlexander Aring }
867eab560e5SAlexander Aring break;
868eab560e5SAlexander Aring }
8695609c185SAlexander Aring
8705609c185SAlexander Aring memset(&tmp, 0, sizeof(tmp));
87124c4a81dSAlexander Aring /* check for SAM/DAM = 10 */
8725609c185SAlexander Aring tmp.s6_addr[11] = 0xFF;
8735609c185SAlexander Aring tmp.s6_addr[12] = 0xFE;
8745609c185SAlexander Aring memcpy(&tmp.s6_addr[14], &ipaddr->s6_addr[14], 2);
8755609c185SAlexander Aring /* context information are always used */
8765609c185SAlexander Aring ipv6_addr_prefix_copy(&tmp, &ctx->pfx, ctx->plen);
8775609c185SAlexander Aring if (ipv6_addr_equal(&tmp, ipaddr)) {
8785609c185SAlexander Aring lowpan_push_hc_data(hc_ptr, &ipaddr->s6_addr[14], 2);
8795609c185SAlexander Aring dam = LOWPAN_IPHC_DAM_10;
8805609c185SAlexander Aring goto out;
8815609c185SAlexander Aring }
8825609c185SAlexander Aring
8835609c185SAlexander Aring memset(&tmp, 0, sizeof(tmp));
88424c4a81dSAlexander Aring /* check for SAM/DAM = 01, should always match */
8855609c185SAlexander Aring memcpy(&tmp.s6_addr[8], &ipaddr->s6_addr[8], 8);
8865609c185SAlexander Aring /* context information are always used */
8875609c185SAlexander Aring ipv6_addr_prefix_copy(&tmp, &ctx->pfx, ctx->plen);
8885609c185SAlexander Aring if (ipv6_addr_equal(&tmp, ipaddr)) {
8895609c185SAlexander Aring lowpan_push_hc_data(hc_ptr, &ipaddr->s6_addr[8], 8);
8905609c185SAlexander Aring dam = LOWPAN_IPHC_DAM_01;
8915609c185SAlexander Aring goto out;
8925609c185SAlexander Aring }
8935609c185SAlexander Aring
8942306f656SAlexander Aring WARN_ONCE(1, "context found but no address mode matched\n");
8952306f656SAlexander Aring return LOWPAN_IPHC_DAM_00;
8965609c185SAlexander Aring out:
8975609c185SAlexander Aring
8985609c185SAlexander Aring if (sam)
8995609c185SAlexander Aring return lowpan_iphc_dam_to_sam_value[dam];
9005609c185SAlexander Aring else
9015609c185SAlexander Aring return dam;
9025609c185SAlexander Aring }
9035609c185SAlexander Aring
904eab560e5SAlexander Aring static inline bool
lowpan_iphc_compress_802154_lladdr(const struct in6_addr * ipaddr,const void * lladdr)905eab560e5SAlexander Aring lowpan_iphc_compress_802154_lladdr(const struct in6_addr *ipaddr,
906eab560e5SAlexander Aring const void *lladdr)
907eab560e5SAlexander Aring {
908eab560e5SAlexander Aring const struct ieee802154_addr *addr = lladdr;
909eab560e5SAlexander Aring unsigned char extended_addr[EUI64_ADDR_LEN];
910eab560e5SAlexander Aring bool lladdr_compress = false;
911eab560e5SAlexander Aring struct in6_addr tmp = {};
912eab560e5SAlexander Aring
913eab560e5SAlexander Aring switch (addr->mode) {
914eab560e5SAlexander Aring case IEEE802154_ADDR_LONG:
915eab560e5SAlexander Aring ieee802154_le64_to_be64(&extended_addr, &addr->extended_addr);
916eab560e5SAlexander Aring if (is_addr_mac_addr_based(ipaddr, extended_addr))
917eab560e5SAlexander Aring lladdr_compress = true;
918eab560e5SAlexander Aring break;
919eab560e5SAlexander Aring case IEEE802154_ADDR_SHORT:
920eab560e5SAlexander Aring /* fe:80::ff:fe00:XXXX
921eab560e5SAlexander Aring * \__/
922eab560e5SAlexander Aring * short_addr
923eab560e5SAlexander Aring *
924eab560e5SAlexander Aring * Universe/Local bit is zero.
925eab560e5SAlexander Aring */
926eab560e5SAlexander Aring tmp.s6_addr[0] = 0xFE;
927eab560e5SAlexander Aring tmp.s6_addr[1] = 0x80;
928eab560e5SAlexander Aring tmp.s6_addr[11] = 0xFF;
929eab560e5SAlexander Aring tmp.s6_addr[12] = 0xFE;
930eab560e5SAlexander Aring ieee802154_le16_to_be16(&tmp.s6_addr16[7],
931eab560e5SAlexander Aring &addr->short_addr);
932eab560e5SAlexander Aring if (ipv6_addr_equal(&tmp, ipaddr))
933eab560e5SAlexander Aring lladdr_compress = true;
934eab560e5SAlexander Aring break;
935eab560e5SAlexander Aring default:
936eab560e5SAlexander Aring /* should never handled and filtered by 802154 6lowpan */
937eab560e5SAlexander Aring WARN_ON_ONCE(1);
938eab560e5SAlexander Aring break;
939eab560e5SAlexander Aring }
940eab560e5SAlexander Aring
941eab560e5SAlexander Aring return lladdr_compress;
942eab560e5SAlexander Aring }
943eab560e5SAlexander Aring
lowpan_compress_addr_64(u8 ** hc_ptr,const struct net_device * dev,const struct in6_addr * ipaddr,const unsigned char * lladdr,bool sam)944eab560e5SAlexander Aring static u8 lowpan_compress_addr_64(u8 **hc_ptr, const struct net_device *dev,
945eab560e5SAlexander Aring const struct in6_addr *ipaddr,
946c8a3e7ebSAlexander Aring const unsigned char *lladdr, bool sam)
9472c6bed7cSAlexander Aring {
948eab560e5SAlexander Aring u8 dam = LOWPAN_IPHC_DAM_01;
9492c6bed7cSAlexander Aring
950eab560e5SAlexander Aring switch (lowpan_dev(dev)->lltype) {
951eab560e5SAlexander Aring case LOWPAN_LLTYPE_IEEE802154:
952eab560e5SAlexander Aring if (lowpan_iphc_compress_802154_lladdr(ipaddr, lladdr)) {
953eab560e5SAlexander Aring dam = LOWPAN_IPHC_DAM_11; /* 0-bits */
954eab560e5SAlexander Aring pr_debug("address compression 0 bits\n");
955eab560e5SAlexander Aring goto out;
956eab560e5SAlexander Aring }
957eab560e5SAlexander Aring break;
958eab560e5SAlexander Aring default:
959fa09ae66SLuiz Augusto von Dentz if (lowpan_iphc_addr_equal(dev, NULL, ipaddr, lladdr)) {
960fa09ae66SLuiz Augusto von Dentz dam = LOWPAN_IPHC_DAM_11;
9612c6bed7cSAlexander Aring pr_debug("address compression 0 bits\n");
962eab560e5SAlexander Aring goto out;
963eab560e5SAlexander Aring }
964fa09ae66SLuiz Augusto von Dentz
965eab560e5SAlexander Aring break;
966eab560e5SAlexander Aring }
967eab560e5SAlexander Aring
968eab560e5SAlexander Aring if (lowpan_is_iid_16_bit_compressable(ipaddr)) {
9692c6bed7cSAlexander Aring /* compress IID to 16 bits xxxx::XXXX */
97085c71240SAlexander Aring lowpan_push_hc_data(hc_ptr, &ipaddr->s6_addr16[7], 2);
971c8a3e7ebSAlexander Aring dam = LOWPAN_IPHC_DAM_10; /* 16-bits */
9722c6bed7cSAlexander Aring raw_dump_inline(NULL, "Compressed ipv6 addr is (16 bits)",
97384ca5e03SAlexander Aring *hc_ptr - 2, 2);
974eab560e5SAlexander Aring goto out;
975eab560e5SAlexander Aring }
976eab560e5SAlexander Aring
9772c6bed7cSAlexander Aring /* do not compress IID => xxxx::IID */
97885c71240SAlexander Aring lowpan_push_hc_data(hc_ptr, &ipaddr->s6_addr16[4], 8);
9792c6bed7cSAlexander Aring raw_dump_inline(NULL, "Compressed ipv6 addr is (64 bits)",
98084ca5e03SAlexander Aring *hc_ptr - 8, 8);
981eab560e5SAlexander Aring
982eab560e5SAlexander Aring out:
9832c6bed7cSAlexander Aring
984c8a3e7ebSAlexander Aring if (sam)
985c8a3e7ebSAlexander Aring return lowpan_iphc_dam_to_sam_value[dam];
986c8a3e7ebSAlexander Aring else
987c8a3e7ebSAlexander Aring return dam;
9882c6bed7cSAlexander Aring }
9892c6bed7cSAlexander Aring
990b5af9bdbSAlexander Aring /* lowpan_iphc_get_tc - get the ECN + DCSP fields in hc format */
lowpan_iphc_get_tc(const struct ipv6hdr * hdr)991b5af9bdbSAlexander Aring static inline u8 lowpan_iphc_get_tc(const struct ipv6hdr *hdr)
992b5af9bdbSAlexander Aring {
993b5af9bdbSAlexander Aring u8 dscp, ecn;
994b5af9bdbSAlexander Aring
995b5af9bdbSAlexander Aring /* hdr->priority contains the higher bits of dscp, lower are part of
996b5af9bdbSAlexander Aring * flow_lbl[0]. Note ECN, DCSP is swapped in ipv6 hdr.
997b5af9bdbSAlexander Aring */
998b5af9bdbSAlexander Aring dscp = (hdr->priority << 2) | ((hdr->flow_lbl[0] & 0xc0) >> 6);
999b5af9bdbSAlexander Aring /* ECN is at the two lower bits from first nibble of flow_lbl[0] */
1000b5af9bdbSAlexander Aring ecn = (hdr->flow_lbl[0] & 0x30);
1001b5af9bdbSAlexander Aring /* for pretty debug output, also shift ecn to get the ecn value */
1002b5af9bdbSAlexander Aring pr_debug("ecn 0x%02x dscp 0x%02x\n", ecn >> 4, dscp);
1003b5af9bdbSAlexander Aring /* ECN is at 0x30 now, shift it to have ECN + DCSP */
1004b5af9bdbSAlexander Aring return (ecn << 2) | dscp;
1005b5af9bdbSAlexander Aring }
1006b5af9bdbSAlexander Aring
1007b5af9bdbSAlexander Aring /* lowpan_iphc_is_flow_lbl_zero - check if flow label is zero */
lowpan_iphc_is_flow_lbl_zero(const struct ipv6hdr * hdr)1008b5af9bdbSAlexander Aring static inline bool lowpan_iphc_is_flow_lbl_zero(const struct ipv6hdr *hdr)
1009b5af9bdbSAlexander Aring {
1010b5af9bdbSAlexander Aring return ((!(hdr->flow_lbl[0] & 0x0f)) &&
1011b5af9bdbSAlexander Aring !hdr->flow_lbl[1] && !hdr->flow_lbl[2]);
1012b5af9bdbSAlexander Aring }
1013b5af9bdbSAlexander Aring
1014b5af9bdbSAlexander Aring /* lowpan_iphc_tf_compress - compress the traffic class which is set by
1015b5af9bdbSAlexander Aring * ipv6hdr. Return the corresponding format identifier which is used.
1016b5af9bdbSAlexander Aring */
lowpan_iphc_tf_compress(u8 ** hc_ptr,const struct ipv6hdr * hdr)1017b5af9bdbSAlexander Aring static u8 lowpan_iphc_tf_compress(u8 **hc_ptr, const struct ipv6hdr *hdr)
1018b5af9bdbSAlexander Aring {
1019b5af9bdbSAlexander Aring /* get ecn dscp data in a byteformat as: ECN(hi) + DSCP(lo) */
1020b5af9bdbSAlexander Aring u8 tc = lowpan_iphc_get_tc(hdr), tf[4], val;
1021b5af9bdbSAlexander Aring
1022b5af9bdbSAlexander Aring /* printout the traffic class in hc format */
1023b5af9bdbSAlexander Aring pr_debug("tc 0x%02x\n", tc);
1024b5af9bdbSAlexander Aring
1025b5af9bdbSAlexander Aring if (lowpan_iphc_is_flow_lbl_zero(hdr)) {
1026b5af9bdbSAlexander Aring if (!tc) {
1027b5af9bdbSAlexander Aring /* 11: Traffic Class and Flow Label are elided. */
1028b5af9bdbSAlexander Aring val = LOWPAN_IPHC_TF_11;
1029b5af9bdbSAlexander Aring } else {
1030b5af9bdbSAlexander Aring /* 10: ECN + DSCP (1 byte), Flow Label is elided.
1031b5af9bdbSAlexander Aring *
1032b5af9bdbSAlexander Aring * 0 1 2 3 4 5 6 7
1033b5af9bdbSAlexander Aring * +-+-+-+-+-+-+-+-+
1034b5af9bdbSAlexander Aring * |ECN| DSCP |
1035b5af9bdbSAlexander Aring * +-+-+-+-+-+-+-+-+
1036b5af9bdbSAlexander Aring */
1037b5af9bdbSAlexander Aring lowpan_push_hc_data(hc_ptr, &tc, sizeof(tc));
1038b5af9bdbSAlexander Aring val = LOWPAN_IPHC_TF_10;
1039b5af9bdbSAlexander Aring }
1040b5af9bdbSAlexander Aring } else {
1041b5af9bdbSAlexander Aring /* check if dscp is zero, it's after the first two bit */
1042b5af9bdbSAlexander Aring if (!(tc & 0x3f)) {
1043b5af9bdbSAlexander Aring /* 01: ECN + 2-bit Pad + Flow Label (3 bytes), DSCP is elided
1044b5af9bdbSAlexander Aring *
1045b5af9bdbSAlexander Aring * 1 2
1046b5af9bdbSAlexander Aring * 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3
1047b5af9bdbSAlexander Aring * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1048b5af9bdbSAlexander Aring * |ECN|rsv| Flow Label |
1049b5af9bdbSAlexander Aring * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1050b5af9bdbSAlexander Aring */
1051b5af9bdbSAlexander Aring memcpy(&tf[0], &hdr->flow_lbl[0], 3);
1052b5af9bdbSAlexander Aring /* zero the highest 4-bits, contains DCSP + ECN */
1053b5af9bdbSAlexander Aring tf[0] &= ~0xf0;
1054b5af9bdbSAlexander Aring /* set ECN */
1055b5af9bdbSAlexander Aring tf[0] |= (tc & 0xc0);
1056b5af9bdbSAlexander Aring
1057b5af9bdbSAlexander Aring lowpan_push_hc_data(hc_ptr, tf, 3);
1058b5af9bdbSAlexander Aring val = LOWPAN_IPHC_TF_01;
1059b5af9bdbSAlexander Aring } else {
1060b5af9bdbSAlexander Aring /* 00: ECN + DSCP + 4-bit Pad + Flow Label (4 bytes)
1061b5af9bdbSAlexander Aring *
1062b5af9bdbSAlexander Aring * 1 2 3
1063b5af9bdbSAlexander Aring * 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
1064b5af9bdbSAlexander Aring * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1065b5af9bdbSAlexander Aring * |ECN| DSCP | rsv | Flow Label |
1066b5af9bdbSAlexander Aring * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1067b5af9bdbSAlexander Aring */
1068b5af9bdbSAlexander Aring memcpy(&tf[0], &tc, sizeof(tc));
1069b5af9bdbSAlexander Aring /* highest nibble of flow_lbl[0] is part of DSCP + ECN
1070b5af9bdbSAlexander Aring * which will be the 4-bit pad and will be filled with
1071b5af9bdbSAlexander Aring * zeros afterwards.
1072b5af9bdbSAlexander Aring */
1073b5af9bdbSAlexander Aring memcpy(&tf[1], &hdr->flow_lbl[0], 3);
1074b5af9bdbSAlexander Aring /* zero the 4-bit pad, which is reserved */
1075b5af9bdbSAlexander Aring tf[1] &= ~0xf0;
1076b5af9bdbSAlexander Aring
1077b5af9bdbSAlexander Aring lowpan_push_hc_data(hc_ptr, tf, 4);
1078b5af9bdbSAlexander Aring val = LOWPAN_IPHC_TF_00;
1079b5af9bdbSAlexander Aring }
1080b5af9bdbSAlexander Aring }
1081b5af9bdbSAlexander Aring
1082b5af9bdbSAlexander Aring return val;
1083b5af9bdbSAlexander Aring }
1084b5af9bdbSAlexander Aring
lowpan_iphc_mcast_ctx_addr_compress(u8 ** hc_ptr,const struct lowpan_iphc_ctx * ctx,const struct in6_addr * ipaddr)10855609c185SAlexander Aring static u8 lowpan_iphc_mcast_ctx_addr_compress(u8 **hc_ptr,
10865609c185SAlexander Aring const struct lowpan_iphc_ctx *ctx,
10875609c185SAlexander Aring const struct in6_addr *ipaddr)
10885609c185SAlexander Aring {
10895609c185SAlexander Aring u8 data[6];
10905609c185SAlexander Aring
10915609c185SAlexander Aring /* flags/scope, reserved (RIID) */
10925609c185SAlexander Aring memcpy(data, &ipaddr->s6_addr[1], 2);
10935609c185SAlexander Aring /* group ID */
10945609c185SAlexander Aring memcpy(&data[1], &ipaddr->s6_addr[11], 4);
10955609c185SAlexander Aring lowpan_push_hc_data(hc_ptr, data, 6);
10965609c185SAlexander Aring
10975609c185SAlexander Aring return LOWPAN_IPHC_DAM_00;
10985609c185SAlexander Aring }
10995609c185SAlexander Aring
lowpan_iphc_mcast_addr_compress(u8 ** hc_ptr,const struct in6_addr * ipaddr)110009bf420fSAlexander Aring static u8 lowpan_iphc_mcast_addr_compress(u8 **hc_ptr,
110109bf420fSAlexander Aring const struct in6_addr *ipaddr)
110209bf420fSAlexander Aring {
110309bf420fSAlexander Aring u8 val;
110409bf420fSAlexander Aring
110509bf420fSAlexander Aring if (lowpan_is_mcast_addr_compressable8(ipaddr)) {
110609bf420fSAlexander Aring pr_debug("compressed to 1 octet\n");
110709bf420fSAlexander Aring /* use last byte */
110809bf420fSAlexander Aring lowpan_push_hc_data(hc_ptr, &ipaddr->s6_addr[15], 1);
110909bf420fSAlexander Aring val = LOWPAN_IPHC_DAM_11;
111009bf420fSAlexander Aring } else if (lowpan_is_mcast_addr_compressable32(ipaddr)) {
111109bf420fSAlexander Aring pr_debug("compressed to 4 octets\n");
111209bf420fSAlexander Aring /* second byte + the last three */
111309bf420fSAlexander Aring lowpan_push_hc_data(hc_ptr, &ipaddr->s6_addr[1], 1);
111409bf420fSAlexander Aring lowpan_push_hc_data(hc_ptr, &ipaddr->s6_addr[13], 3);
111509bf420fSAlexander Aring val = LOWPAN_IPHC_DAM_10;
111609bf420fSAlexander Aring } else if (lowpan_is_mcast_addr_compressable48(ipaddr)) {
111709bf420fSAlexander Aring pr_debug("compressed to 6 octets\n");
111809bf420fSAlexander Aring /* second byte + the last five */
111909bf420fSAlexander Aring lowpan_push_hc_data(hc_ptr, &ipaddr->s6_addr[1], 1);
112009bf420fSAlexander Aring lowpan_push_hc_data(hc_ptr, &ipaddr->s6_addr[11], 5);
112109bf420fSAlexander Aring val = LOWPAN_IPHC_DAM_01;
112209bf420fSAlexander Aring } else {
112309bf420fSAlexander Aring pr_debug("using full address\n");
112409bf420fSAlexander Aring lowpan_push_hc_data(hc_ptr, ipaddr->s6_addr, 16);
112509bf420fSAlexander Aring val = LOWPAN_IPHC_DAM_00;
112609bf420fSAlexander Aring }
112709bf420fSAlexander Aring
112809bf420fSAlexander Aring return val;
112909bf420fSAlexander Aring }
113009bf420fSAlexander Aring
lowpan_header_compress(struct sk_buff * skb,const struct net_device * dev,const void * daddr,const void * saddr)1131a6f77389SAlexander Aring int lowpan_header_compress(struct sk_buff *skb, const struct net_device *dev,
1132a6f77389SAlexander Aring const void *daddr, const void *saddr)
11332c6bed7cSAlexander Aring {
11345609c185SAlexander Aring u8 iphc0, iphc1, *hc_ptr, cid = 0;
11352c6bed7cSAlexander Aring struct ipv6hdr *hdr;
1136bf513fd6SAlexander Aring u8 head[LOWPAN_IPHC_MAX_HC_BUF_LEN] = {};
11375609c185SAlexander Aring struct lowpan_iphc_ctx *dci, *sci, dci_entry, sci_entry;
11385609c185SAlexander Aring int ret, ipv6_daddr_type, ipv6_saddr_type;
11392c6bed7cSAlexander Aring
1140a6f77389SAlexander Aring if (skb->protocol != htons(ETH_P_IPV6))
11412c6bed7cSAlexander Aring return -EINVAL;
11422c6bed7cSAlexander Aring
11432c6bed7cSAlexander Aring hdr = ipv6_hdr(skb);
114484ca5e03SAlexander Aring hc_ptr = head + 2;
11452c6bed7cSAlexander Aring
11462c6bed7cSAlexander Aring pr_debug("IPv6 header dump:\n\tversion = %d\n\tlength = %d\n"
11472c6bed7cSAlexander Aring "\tnexthdr = 0x%02x\n\thop_lim = %d\n\tdest = %pI6c\n",
11482c6bed7cSAlexander Aring hdr->version, ntohs(hdr->payload_len), hdr->nexthdr,
11492c6bed7cSAlexander Aring hdr->hop_limit, &hdr->daddr);
11502c6bed7cSAlexander Aring
11512c6bed7cSAlexander Aring raw_dump_table(__func__, "raw skb network header dump",
11522c6bed7cSAlexander Aring skb_network_header(skb), sizeof(struct ipv6hdr));
11532c6bed7cSAlexander Aring
11543fd0202aSDavid S. Miller /* As we copy some bit-length fields, in the IPHC encoding bytes,
11552c6bed7cSAlexander Aring * we sometimes use |=
11562c6bed7cSAlexander Aring * If the field is 0, and the current bit value in memory is 1,
11572c6bed7cSAlexander Aring * this does not work. We therefore reset the IPHC encoding here
11582c6bed7cSAlexander Aring */
11592c6bed7cSAlexander Aring iphc0 = LOWPAN_DISPATCH_IPHC;
11602c6bed7cSAlexander Aring iphc1 = 0;
11612c6bed7cSAlexander Aring
11627fc4cfdaSMarcel Holtmann raw_dump_table(__func__, "sending raw skb network uncompressed packet",
11632c6bed7cSAlexander Aring skb->data, skb->len);
11642c6bed7cSAlexander Aring
11655609c185SAlexander Aring ipv6_daddr_type = ipv6_addr_type(&hdr->daddr);
11662e4d60cbSAlexander Aring spin_lock_bh(&lowpan_dev(dev)->ctx.lock);
11675609c185SAlexander Aring if (ipv6_daddr_type & IPV6_ADDR_MULTICAST)
11685609c185SAlexander Aring dci = lowpan_iphc_ctx_get_by_mcast_addr(dev, &hdr->daddr);
11695609c185SAlexander Aring else
11705609c185SAlexander Aring dci = lowpan_iphc_ctx_get_by_addr(dev, &hdr->daddr);
11715609c185SAlexander Aring if (dci) {
11725609c185SAlexander Aring memcpy(&dci_entry, dci, sizeof(*dci));
11735609c185SAlexander Aring cid |= dci->id;
11745609c185SAlexander Aring }
11752e4d60cbSAlexander Aring spin_unlock_bh(&lowpan_dev(dev)->ctx.lock);
11765609c185SAlexander Aring
11772e4d60cbSAlexander Aring spin_lock_bh(&lowpan_dev(dev)->ctx.lock);
11785609c185SAlexander Aring sci = lowpan_iphc_ctx_get_by_addr(dev, &hdr->saddr);
11795609c185SAlexander Aring if (sci) {
11805609c185SAlexander Aring memcpy(&sci_entry, sci, sizeof(*sci));
11815609c185SAlexander Aring cid |= (sci->id << 4);
11825609c185SAlexander Aring }
11832e4d60cbSAlexander Aring spin_unlock_bh(&lowpan_dev(dev)->ctx.lock);
11845609c185SAlexander Aring
11855609c185SAlexander Aring /* if cid is zero it will be compressed */
11865609c185SAlexander Aring if (cid) {
11875609c185SAlexander Aring iphc1 |= LOWPAN_IPHC_CID;
11885609c185SAlexander Aring lowpan_push_hc_data(&hc_ptr, &cid, sizeof(cid));
11895609c185SAlexander Aring }
11905609c185SAlexander Aring
1191b5af9bdbSAlexander Aring /* Traffic Class, Flow Label compression */
1192b5af9bdbSAlexander Aring iphc0 |= lowpan_iphc_tf_compress(&hc_ptr, hdr);
11932c6bed7cSAlexander Aring
11942c6bed7cSAlexander Aring /* NOTE: payload length is always compressed */
11952c6bed7cSAlexander Aring
1196cc6ed268SAlexander Aring /* Check if we provide the nhc format for nexthdr and compression
1197cc6ed268SAlexander Aring * functionality. If not nexthdr is handled inline and not compressed.
1198cc6ed268SAlexander Aring */
1199607b0bd3SAlexander Aring ret = lowpan_nhc_check_compression(skb, hdr, &hc_ptr);
1200607b0bd3SAlexander Aring if (ret == -ENOENT)
1201607b0bd3SAlexander Aring lowpan_push_hc_data(&hc_ptr, &hdr->nexthdr,
1202607b0bd3SAlexander Aring sizeof(hdr->nexthdr));
1203607b0bd3SAlexander Aring else
1204c8a3e7ebSAlexander Aring iphc0 |= LOWPAN_IPHC_NH;
12052c6bed7cSAlexander Aring
12063fd0202aSDavid S. Miller /* Hop limit
12072c6bed7cSAlexander Aring * if 1: compress, encoding is 01
12082c6bed7cSAlexander Aring * if 64: compress, encoding is 10
12092c6bed7cSAlexander Aring * if 255: compress, encoding is 11
12102c6bed7cSAlexander Aring * else do not compress
12112c6bed7cSAlexander Aring */
12122c6bed7cSAlexander Aring switch (hdr->hop_limit) {
12132c6bed7cSAlexander Aring case 1:
1214c8a3e7ebSAlexander Aring iphc0 |= LOWPAN_IPHC_HLIM_01;
12152c6bed7cSAlexander Aring break;
12162c6bed7cSAlexander Aring case 64:
1217c8a3e7ebSAlexander Aring iphc0 |= LOWPAN_IPHC_HLIM_10;
12182c6bed7cSAlexander Aring break;
12192c6bed7cSAlexander Aring case 255:
1220c8a3e7ebSAlexander Aring iphc0 |= LOWPAN_IPHC_HLIM_11;
12212c6bed7cSAlexander Aring break;
12222c6bed7cSAlexander Aring default:
122385c71240SAlexander Aring lowpan_push_hc_data(&hc_ptr, &hdr->hop_limit,
122485c71240SAlexander Aring sizeof(hdr->hop_limit));
12252c6bed7cSAlexander Aring }
12262c6bed7cSAlexander Aring
12275609c185SAlexander Aring ipv6_saddr_type = ipv6_addr_type(&hdr->saddr);
12282c6bed7cSAlexander Aring /* source address compression */
12295609c185SAlexander Aring if (ipv6_saddr_type == IPV6_ADDR_ANY) {
12302c6bed7cSAlexander Aring pr_debug("source address is unspecified, setting SAC\n");
12312c6bed7cSAlexander Aring iphc1 |= LOWPAN_IPHC_SAC;
1232556a5bfcSAlexander Aring } else {
12335609c185SAlexander Aring if (sci) {
1234eab560e5SAlexander Aring iphc1 |= lowpan_compress_ctx_addr(&hc_ptr, dev,
1235eab560e5SAlexander Aring &hdr->saddr,
12365609c185SAlexander Aring &sci_entry, saddr,
12375609c185SAlexander Aring true);
12385609c185SAlexander Aring iphc1 |= LOWPAN_IPHC_SAC;
12395609c185SAlexander Aring } else {
1240feb2add3SAlexander Aring if (ipv6_saddr_type & IPV6_ADDR_LINKLOCAL &&
1241feb2add3SAlexander Aring lowpan_is_linklocal_zero_padded(hdr->saddr)) {
1242eab560e5SAlexander Aring iphc1 |= lowpan_compress_addr_64(&hc_ptr, dev,
12435609c185SAlexander Aring &hdr->saddr,
1244c8a3e7ebSAlexander Aring saddr, true);
1245556a5bfcSAlexander Aring pr_debug("source address unicast link-local %pI6c iphc1 0x%02x\n",
1246556a5bfcSAlexander Aring &hdr->saddr, iphc1);
12472c6bed7cSAlexander Aring } else {
12482c6bed7cSAlexander Aring pr_debug("send the full source address\n");
12495609c185SAlexander Aring lowpan_push_hc_data(&hc_ptr,
12505609c185SAlexander Aring hdr->saddr.s6_addr, 16);
12515609c185SAlexander Aring }
1252556a5bfcSAlexander Aring }
12532c6bed7cSAlexander Aring }
12542c6bed7cSAlexander Aring
12552c6bed7cSAlexander Aring /* destination address compression */
12565609c185SAlexander Aring if (ipv6_daddr_type & IPV6_ADDR_MULTICAST) {
12572c6bed7cSAlexander Aring pr_debug("destination address is multicast: ");
12588790404dSAlexander Aring iphc1 |= LOWPAN_IPHC_M;
12595609c185SAlexander Aring if (dci) {
12605609c185SAlexander Aring iphc1 |= lowpan_iphc_mcast_ctx_addr_compress(&hc_ptr,
12615609c185SAlexander Aring &dci_entry,
12625609c185SAlexander Aring &hdr->daddr);
12638790404dSAlexander Aring iphc1 |= LOWPAN_IPHC_DAC;
12645609c185SAlexander Aring } else {
12655609c185SAlexander Aring iphc1 |= lowpan_iphc_mcast_addr_compress(&hc_ptr,
12665609c185SAlexander Aring &hdr->daddr);
12675609c185SAlexander Aring }
12682c6bed7cSAlexander Aring } else {
12695609c185SAlexander Aring if (dci) {
1270eab560e5SAlexander Aring iphc1 |= lowpan_compress_ctx_addr(&hc_ptr, dev,
1271eab560e5SAlexander Aring &hdr->daddr,
12725609c185SAlexander Aring &dci_entry, daddr,
12735609c185SAlexander Aring false);
12745609c185SAlexander Aring iphc1 |= LOWPAN_IPHC_DAC;
12755609c185SAlexander Aring } else {
1276feb2add3SAlexander Aring if (ipv6_daddr_type & IPV6_ADDR_LINKLOCAL &&
1277feb2add3SAlexander Aring lowpan_is_linklocal_zero_padded(hdr->daddr)) {
1278eab560e5SAlexander Aring iphc1 |= lowpan_compress_addr_64(&hc_ptr, dev,
12795609c185SAlexander Aring &hdr->daddr,
1280c8a3e7ebSAlexander Aring daddr, false);
12815609c185SAlexander Aring pr_debug("dest address unicast link-local %pI6c iphc1 0x%02x\n",
12825609c185SAlexander Aring &hdr->daddr, iphc1);
12832c6bed7cSAlexander Aring } else {
12845609c185SAlexander Aring pr_debug("dest address unicast %pI6c\n",
12855609c185SAlexander Aring &hdr->daddr);
12865609c185SAlexander Aring lowpan_push_hc_data(&hc_ptr,
12875609c185SAlexander Aring hdr->daddr.s6_addr, 16);
12885609c185SAlexander Aring }
12892c6bed7cSAlexander Aring }
12902c6bed7cSAlexander Aring }
12912c6bed7cSAlexander Aring
1292cc6ed268SAlexander Aring /* next header compression */
1293c8a3e7ebSAlexander Aring if (iphc0 & LOWPAN_IPHC_NH) {
1294cc6ed268SAlexander Aring ret = lowpan_nhc_do_compression(skb, hdr, &hc_ptr);
1295cc6ed268SAlexander Aring if (ret < 0)
1296cc6ed268SAlexander Aring return ret;
1297cc6ed268SAlexander Aring }
12982c6bed7cSAlexander Aring
12992c6bed7cSAlexander Aring head[0] = iphc0;
13002c6bed7cSAlexander Aring head[1] = iphc1;
13012c6bed7cSAlexander Aring
13022c6bed7cSAlexander Aring skb_pull(skb, sizeof(struct ipv6hdr));
13032c6bed7cSAlexander Aring skb_reset_transport_header(skb);
130484ca5e03SAlexander Aring memcpy(skb_push(skb, hc_ptr - head), head, hc_ptr - head);
13052c6bed7cSAlexander Aring skb_reset_network_header(skb);
13062c6bed7cSAlexander Aring
130784ca5e03SAlexander Aring pr_debug("header len %d skb %u\n", (int)(hc_ptr - head), skb->len);
13082c6bed7cSAlexander Aring
13092c6bed7cSAlexander Aring raw_dump_table(__func__, "raw skb data dump compressed",
13102c6bed7cSAlexander Aring skb->data, skb->len);
13112c6bed7cSAlexander Aring return 0;
13122c6bed7cSAlexander Aring }
13132c6bed7cSAlexander Aring EXPORT_SYMBOL_GPL(lowpan_header_compress);
1314