1// SPDX-License-Identifier: GPL-2.0-only
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/* This callback will be called from AF_PACKET and IPv6 stack, the AF_PACKET
27 * sockets gives an 8 byte array for addresses only!
28 *
29 * TODO I think AF_PACKET DGRAM (sending/receiving) RAW (sending) makes no
30 * sense here. We should disable it, the right use-case would be AF_INET6
31 * RAW/DGRAM sockets.
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	/* TODO:
47	 * if this package isn't ipv6 one, where should it be routed?
48	 */
49	if (type != ETH_P_IPV6)
50		return 0;
51
52	/* intra-pan communication */
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	/* dgram_offset = (saved bytes after compression) + lowpan header len */
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	/* We must take a copy of the skb before we modify/replace the ipv6
261	 * header as the header could be used elsewhere
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