1
2
3#include <net/6lowpan.h>
4#include <net/ndisc.h>
5#include <net/ieee802154_netdev.h>
6#include <net/mac802154.h>
7
8#include "6lowpan_i.h"
9
10#define LOWPAN_FRAG1_HEAD_SIZE 0x4
11#define LOWPAN_FRAGN_HEAD_SIZE 0x5
12
13struct lowpan_addr_info {
14 struct ieee802154_addr daddr;
15 struct ieee802154_addr saddr;
16};
17
18static inline struct
19lowpan_addr_info *lowpan_skb_priv(const struct sk_buff *skb)
20{
21 WARN_ON_ONCE(skb_headroom(skb) < sizeof(struct lowpan_addr_info));
22 return (struct lowpan_addr_info *)(skb->data -
23 sizeof(struct lowpan_addr_info));
24}
25
26
27
28
29
30
31
32
33int lowpan_header_create(struct sk_buff *skb, struct net_device *ldev,
34 unsigned short type, const void *daddr,
35 const void *saddr, unsigned int len)
36{
37 struct wpan_dev *wpan_dev = lowpan_802154_dev(ldev)->wdev->ieee802154_ptr;
38 struct lowpan_addr_info *info = lowpan_skb_priv(skb);
39 struct lowpan_802154_neigh *llneigh = NULL;
40 const struct ipv6hdr *hdr = ipv6_hdr(skb);
41 struct neighbour *n;
42
43 if (!daddr)
44 return -EINVAL;
45
46
47
48
49 if (type != ETH_P_IPV6)
50 return 0;
51
52
53 info->saddr.pan_id = wpan_dev->pan_id;
54 info->daddr.pan_id = info->saddr.pan_id;
55
56 if (!memcmp(daddr, ldev->broadcast, EUI64_ADDR_LEN)) {
57 info->daddr.short_addr = cpu_to_le16(IEEE802154_ADDR_BROADCAST);
58 info->daddr.mode = IEEE802154_ADDR_SHORT;
59 } else {
60 __le16 short_addr = cpu_to_le16(IEEE802154_ADDR_SHORT_UNSPEC);
61
62 n = neigh_lookup(&nd_tbl, &hdr->daddr, ldev);
63 if (n) {
64 llneigh = lowpan_802154_neigh(neighbour_priv(n));
65 read_lock_bh(&n->lock);
66 short_addr = llneigh->short_addr;
67 read_unlock_bh(&n->lock);
68 }
69
70 if (llneigh &&
71 lowpan_802154_is_valid_src_short_addr(short_addr)) {
72 info->daddr.short_addr = short_addr;
73 info->daddr.mode = IEEE802154_ADDR_SHORT;
74 } else {
75 info->daddr.mode = IEEE802154_ADDR_LONG;
76 ieee802154_be64_to_le64(&info->daddr.extended_addr,
77 daddr);
78 }
79
80 if (n)
81 neigh_release(n);
82 }
83
84 if (!saddr) {
85 if (lowpan_802154_is_valid_src_short_addr(wpan_dev->short_addr)) {
86 info->saddr.mode = IEEE802154_ADDR_SHORT;
87 info->saddr.short_addr = wpan_dev->short_addr;
88 } else {
89 info->saddr.mode = IEEE802154_ADDR_LONG;
90 info->saddr.extended_addr = wpan_dev->extended_addr;
91 }
92 } else {
93 info->saddr.mode = IEEE802154_ADDR_LONG;
94 ieee802154_be64_to_le64(&info->saddr.extended_addr, saddr);
95 }
96
97 return 0;
98}
99
100static struct sk_buff*
101lowpan_alloc_frag(struct sk_buff *skb, int size,
102 const struct ieee802154_hdr *master_hdr, bool frag1)
103{
104 struct net_device *wdev = lowpan_802154_dev(skb->dev)->wdev;
105 struct sk_buff *frag;
106 int rc;
107
108 frag = alloc_skb(wdev->needed_headroom + wdev->needed_tailroom + size,
109 GFP_ATOMIC);
110
111 if (likely(frag)) {
112 frag->dev = wdev;
113 frag->priority = skb->priority;
114 skb_reserve(frag, wdev->needed_headroom);
115 skb_reset_network_header(frag);
116 *mac_cb(frag) = *mac_cb(skb);
117
118 if (frag1) {
119 skb_put_data(frag, skb_mac_header(skb), skb->mac_len);
120 } else {
121 rc = wpan_dev_hard_header(frag, wdev,
122 &master_hdr->dest,
123 &master_hdr->source, size);
124 if (rc < 0) {
125 kfree_skb(frag);
126 return ERR_PTR(rc);
127 }
128 }
129 } else {
130 frag = ERR_PTR(-ENOMEM);
131 }
132
133 return frag;
134}
135
136static int
137lowpan_xmit_fragment(struct sk_buff *skb, const struct ieee802154_hdr *wpan_hdr,
138 u8 *frag_hdr, int frag_hdrlen,
139 int offset, int len, bool frag1)
140{
141 struct sk_buff *frag;
142
143 raw_dump_inline(__func__, " fragment header", frag_hdr, frag_hdrlen);
144
145 frag = lowpan_alloc_frag(skb, frag_hdrlen + len, wpan_hdr, frag1);
146 if (IS_ERR(frag))
147 return PTR_ERR(frag);
148
149 skb_put_data(frag, frag_hdr, frag_hdrlen);
150 skb_put_data(frag, skb_network_header(skb) + offset, len);
151
152 raw_dump_table(__func__, " fragment dump", frag->data, frag->len);
153
154 return dev_queue_xmit(frag);
155}
156
157static int
158lowpan_xmit_fragmented(struct sk_buff *skb, struct net_device *ldev,
159 const struct ieee802154_hdr *wpan_hdr, u16 dgram_size,
160 u16 dgram_offset)
161{
162 __be16 frag_tag;
163 u8 frag_hdr[5];
164 int frag_cap, frag_len, payload_cap, rc;
165 int skb_unprocessed, skb_offset;
166
167 frag_tag = htons(lowpan_802154_dev(ldev)->fragment_tag);
168 lowpan_802154_dev(ldev)->fragment_tag++;
169
170 frag_hdr[0] = LOWPAN_DISPATCH_FRAG1 | ((dgram_size >> 8) & 0x07);
171 frag_hdr[1] = dgram_size & 0xff;
172 memcpy(frag_hdr + 2, &frag_tag, sizeof(frag_tag));
173
174 payload_cap = ieee802154_max_payload(wpan_hdr);
175
176 frag_len = round_down(payload_cap - LOWPAN_FRAG1_HEAD_SIZE -
177 skb_network_header_len(skb), 8);
178
179 skb_offset = skb_network_header_len(skb);
180 skb_unprocessed = skb->len - skb->mac_len - skb_offset;
181
182 rc = lowpan_xmit_fragment(skb, wpan_hdr, frag_hdr,
183 LOWPAN_FRAG1_HEAD_SIZE, 0,
184 frag_len + skb_network_header_len(skb),
185 true);
186 if (rc) {
187 pr_debug("%s unable to send FRAG1 packet (tag: %d)",
188 __func__, ntohs(frag_tag));
189 goto err;
190 }
191
192 frag_hdr[0] &= ~LOWPAN_DISPATCH_FRAG1;
193 frag_hdr[0] |= LOWPAN_DISPATCH_FRAGN;
194 frag_cap = round_down(payload_cap - LOWPAN_FRAGN_HEAD_SIZE, 8);
195
196 do {
197 dgram_offset += frag_len;
198 skb_offset += frag_len;
199 skb_unprocessed -= frag_len;
200 frag_len = min(frag_cap, skb_unprocessed);
201
202 frag_hdr[4] = dgram_offset >> 3;
203
204 rc = lowpan_xmit_fragment(skb, wpan_hdr, frag_hdr,
205 LOWPAN_FRAGN_HEAD_SIZE, skb_offset,
206 frag_len, false);
207 if (rc) {
208 pr_debug("%s unable to send a FRAGN packet. (tag: %d, offset: %d)\n",
209 __func__, ntohs(frag_tag), skb_offset);
210 goto err;
211 }
212 } while (skb_unprocessed > frag_cap);
213
214 ldev->stats.tx_packets++;
215 ldev->stats.tx_bytes += dgram_size;
216 consume_skb(skb);
217 return NET_XMIT_SUCCESS;
218
219err:
220 kfree_skb(skb);
221 return rc;
222}
223
224static int lowpan_header(struct sk_buff *skb, struct net_device *ldev,
225 u16 *dgram_size, u16 *dgram_offset)
226{
227 struct wpan_dev *wpan_dev = lowpan_802154_dev(ldev)->wdev->ieee802154_ptr;
228 struct ieee802154_mac_cb *cb = mac_cb_init(skb);
229 struct lowpan_addr_info info;
230
231 memcpy(&info, lowpan_skb_priv(skb), sizeof(info));
232
233 *dgram_size = skb->len;
234 lowpan_header_compress(skb, ldev, &info.daddr, &info.saddr);
235
236 *dgram_offset = (*dgram_size - skb->len) + skb_network_header_len(skb);
237
238 cb->type = IEEE802154_FC_TYPE_DATA;
239
240 if (info.daddr.mode == IEEE802154_ADDR_SHORT &&
241 ieee802154_is_broadcast_short_addr(info.daddr.short_addr))
242 cb->ackreq = false;
243 else
244 cb->ackreq = wpan_dev->ackreq;
245
246 return wpan_dev_hard_header(skb, lowpan_802154_dev(ldev)->wdev,
247 &info.daddr, &info.saddr, 0);
248}
249
250netdev_tx_t lowpan_xmit(struct sk_buff *skb, struct net_device *ldev)
251{
252 struct ieee802154_hdr wpan_hdr;
253 int max_single, ret;
254 u16 dgram_size, dgram_offset;
255
256 pr_debug("package xmit\n");
257
258 WARN_ON_ONCE(skb->len > IPV6_MIN_MTU);
259
260
261
262
263 if (unlikely(skb_headroom(skb) < ldev->needed_headroom ||
264 skb_tailroom(skb) < ldev->needed_tailroom)) {
265 struct sk_buff *nskb;
266
267 nskb = skb_copy_expand(skb, ldev->needed_headroom,
268 ldev->needed_tailroom, GFP_ATOMIC);
269 if (likely(nskb)) {
270 consume_skb(skb);
271 skb = nskb;
272 } else {
273 kfree_skb(skb);
274 return NET_XMIT_DROP;
275 }
276 } else {
277 skb = skb_unshare(skb, GFP_ATOMIC);
278 if (!skb)
279 return NET_XMIT_DROP;
280 }
281
282 ret = lowpan_header(skb, ldev, &dgram_size, &dgram_offset);
283 if (ret < 0) {
284 kfree_skb(skb);
285 return NET_XMIT_DROP;
286 }
287
288 if (ieee802154_hdr_peek(skb, &wpan_hdr) < 0) {
289 kfree_skb(skb);
290 return NET_XMIT_DROP;
291 }
292
293 max_single = ieee802154_max_payload(&wpan_hdr);
294
295 if (skb_tail_pointer(skb) - skb_network_header(skb) <= max_single) {
296 skb->dev = lowpan_802154_dev(ldev)->wdev;
297 ldev->stats.tx_packets++;
298 ldev->stats.tx_bytes += dgram_size;
299 return dev_queue_xmit(skb);
300 } else {
301 netdev_tx_t rc;
302
303 pr_debug("frame is too big, fragmentation is needed\n");
304 rc = lowpan_xmit_fragmented(skb, ldev, &wpan_hdr, dgram_size,
305 dgram_offset);
306
307 return rc < 0 ? NET_XMIT_DROP : rc;
308 }
309}
310
