projects / linux-2.6-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
net: mcs7830: handle usb read errors properly
[linux-2.6-block.git] / drivers / net / amt.c
CommitLineData
b9022b53
TY		 1// SPDX-License-Identifier: GPL-2.0-or-later
2/* Copyright (c) 2021 Taehee Yoo <ap420073@gmail.com> */
3
4#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
5
6#include <linux/module.h>
7#include <linux/skbuff.h>
8#include <linux/udp.h>
9#include <linux/jhash.h>
10#include <linux/if_tunnel.h>
11#include <linux/net.h>
12#include <linux/igmp.h>
13#include <linux/workqueue.h>
14#include <net/net_namespace.h>
b9022b53
TY		 15#include <net/ip.h>
16#include <net/udp.h>
17#include <net/udp_tunnel.h>
18#include <net/icmp.h>
19#include <net/mld.h>
20#include <net/amt.h>
21#include <uapi/linux/amt.h>
22#include <linux/security.h>
23#include <net/gro_cells.h>
24#include <net/ipv6.h>
b9022b53
TY		 25#include <net/if_inet6.h>
26#include <net/ndisc.h>
27#include <net/addrconf.h>
28#include <net/ip6_route.h>
29#include <net/inet_common.h>
b75f7095 30#include <net/ip6_checksum.h>
b9022b53
TY		 31
32static struct workqueue_struct *amt_wq;
33
bc54e49c
TY		 34static HLIST_HEAD(source_gc_list);
35/* Lock for source_gc_list */
36static spinlock_t source_gc_lock;
37static struct delayed_work source_gc_wq;
cbc21dc1
TY		 38static char *status_str[] = {
39 "AMT_STATUS_INIT",
40 "AMT_STATUS_SENT_DISCOVERY",
41 "AMT_STATUS_RECEIVED_DISCOVERY",
42 "AMT_STATUS_SENT_ADVERTISEMENT",
43 "AMT_STATUS_RECEIVED_ADVERTISEMENT",
44 "AMT_STATUS_SENT_REQUEST",
45 "AMT_STATUS_RECEIVED_REQUEST",
46 "AMT_STATUS_SENT_QUERY",
47 "AMT_STATUS_RECEIVED_QUERY",
48 "AMT_STATUS_SENT_UPDATE",
49 "AMT_STATUS_RECEIVED_UPDATE",
50};
51
52static char *type_str[] = {
53 "AMT_MSG_DISCOVERY",
54 "AMT_MSG_ADVERTISEMENT",
55 "AMT_MSG_REQUEST",
56 "AMT_MSG_MEMBERSHIP_QUERY",
57 "AMT_MSG_MEMBERSHIP_UPDATE",
58 "AMT_MSG_MULTICAST_DATA",
59 "AMT_MSG_TEARDOWM",
60};
61
bc54e49c
TY		 62static char *action_str[] = {
63 "AMT_ACT_GMI",
64 "AMT_ACT_GMI_ZERO",
65 "AMT_ACT_GT",
66 "AMT_ACT_STATUS_FWD_NEW",
67 "AMT_ACT_STATUS_D_FWD_NEW",
68 "AMT_ACT_STATUS_NONE_NEW",
69};
70
b75f7095
TY		 71static struct igmpv3_grec igmpv3_zero_grec;
72
73#if IS_ENABLED(CONFIG_IPV6)
74#define MLD2_ALL_NODE_INIT { { { 0xff, 0x02, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x01 } } }
75static struct in6_addr mld2_all_node = MLD2_ALL_NODE_INIT;
76static struct mld2_grec mldv2_zero_grec;
77#endif
78
cbc21dc1
TY		 79static struct amt_skb_cb *amt_skb_cb(struct sk_buff *skb)
80{
81 BUILD_BUG_ON(sizeof(struct amt_skb_cb) + sizeof(struct qdisc_skb_cb) >
82 sizeof_field(struct sk_buff, cb));
83
84 return (struct amt_skb_cb *)((void *)skb->cb +
85 sizeof(struct qdisc_skb_cb));
86}
87
bc54e49c
TY		 88static void __amt_source_gc_work(void)
89{
90 struct amt_source_node *snode;
91 struct hlist_head gc_list;
92 struct hlist_node *t;
93
94 spin_lock_bh(&source_gc_lock);
95 hlist_move_list(&source_gc_list, &gc_list);
96 spin_unlock_bh(&source_gc_lock);
97
98 hlist_for_each_entry_safe(snode, t, &gc_list, node) {
99 hlist_del_rcu(&snode->node);
100 kfree_rcu(snode, rcu);
101 }
102}
103
104static void amt_source_gc_work(struct work_struct *work)
105{
106 __amt_source_gc_work();
107
108 spin_lock_bh(&source_gc_lock);
109 mod_delayed_work(amt_wq, &source_gc_wq,
110 msecs_to_jiffies(AMT_GC_INTERVAL));
111 spin_unlock_bh(&source_gc_lock);
112}
113
114static bool amt_addr_equal(union amt_addr *a, union amt_addr *b)
115{
116 return !memcmp(a, b, sizeof(union amt_addr));
117}
118
119static u32 amt_source_hash(struct amt_tunnel_list *tunnel, union amt_addr *src)
120{
121 u32 hash = jhash(src, sizeof(*src), tunnel->amt->hash_seed);
122
123 return reciprocal_scale(hash, tunnel->amt->hash_buckets);
124}
125
126static bool amt_status_filter(struct amt_source_node *snode,
127 enum amt_filter filter)
128{
129 bool rc = false;
130
131 switch (filter) {
132 case AMT_FILTER_FWD:
133 if (snode->status == AMT_SOURCE_STATUS_FWD &&
134 snode->flags == AMT_SOURCE_OLD)
135 rc = true;
136 break;
137 case AMT_FILTER_D_FWD:
138 if (snode->status == AMT_SOURCE_STATUS_D_FWD &&
139 snode->flags == AMT_SOURCE_OLD)
140 rc = true;
141 break;
142 case AMT_FILTER_FWD_NEW:
143 if (snode->status == AMT_SOURCE_STATUS_FWD &&
144 snode->flags == AMT_SOURCE_NEW)
145 rc = true;
146 break;
147 case AMT_FILTER_D_FWD_NEW:
148 if (snode->status == AMT_SOURCE_STATUS_D_FWD &&
149 snode->flags == AMT_SOURCE_NEW)
150 rc = true;
151 break;
152 case AMT_FILTER_ALL:
153 rc = true;
154 break;
155 case AMT_FILTER_NONE_NEW:
156 if (snode->status == AMT_SOURCE_STATUS_NONE &&
157 snode->flags == AMT_SOURCE_NEW)
158 rc = true;
159 break;
160 case AMT_FILTER_BOTH:
161 if ((snode->status == AMT_SOURCE_STATUS_D_FWD ||
162 snode->status == AMT_SOURCE_STATUS_FWD) &&
163 snode->flags == AMT_SOURCE_OLD)
164 rc = true;
165 break;
166 case AMT_FILTER_BOTH_NEW:
167 if ((snode->status == AMT_SOURCE_STATUS_D_FWD ||
168 snode->status == AMT_SOURCE_STATUS_FWD) &&
169 snode->flags == AMT_SOURCE_NEW)
170 rc = true;
171 break;
172 default:
173 WARN_ON_ONCE(1);
174 break;
175 }
176
177 return rc;
178}
179
180static struct amt_source_node *amt_lookup_src(struct amt_tunnel_list *tunnel,
181 struct amt_group_node *gnode,
182 enum amt_filter filter,
183 union amt_addr *src)
184{
185 u32 hash = amt_source_hash(tunnel, src);
186 struct amt_source_node *snode;
187
188 hlist_for_each_entry_rcu(snode, &gnode->sources[hash], node)
189 if (amt_status_filter(snode, filter) &&
190 amt_addr_equal(&snode->source_addr, src))
191 return snode;
192
193 return NULL;
194}
195
196static u32 amt_group_hash(struct amt_tunnel_list *tunnel, union amt_addr *group)
197{
198 u32 hash = jhash(group, sizeof(*group), tunnel->amt->hash_seed);
199
200 return reciprocal_scale(hash, tunnel->amt->hash_buckets);
201}
202
203static struct amt_group_node *amt_lookup_group(struct amt_tunnel_list *tunnel,
204 union amt_addr *group,
205 union amt_addr *host,
206 bool v6)
207{
208 u32 hash = amt_group_hash(tunnel, group);
209 struct amt_group_node *gnode;
210
211 hlist_for_each_entry_rcu(gnode, &tunnel->groups[hash], node) {
212 if (amt_addr_equal(&gnode->group_addr, group) &&
213 amt_addr_equal(&gnode->host_addr, host) &&
214 gnode->v6 == v6)
215 return gnode;
216 }
217
218 return NULL;
219}
220
221static void amt_destroy_source(struct amt_source_node *snode)
222{
223 struct amt_group_node *gnode = snode->gnode;
224 struct amt_tunnel_list *tunnel;
225
226 tunnel = gnode->tunnel_list;
227
228 if (!gnode->v6) {
229 netdev_dbg(snode->gnode->amt->dev,
230 "Delete source %pI4 from %pI4\n",
231 &snode->source_addr.ip4,
232 &gnode->group_addr.ip4);
b75f7095
TY		 233#if IS_ENABLED(CONFIG_IPV6)
234 } else {
235 netdev_dbg(snode->gnode->amt->dev,
236 "Delete source %pI6 from %pI6\n",
237 &snode->source_addr.ip6,
238 &gnode->group_addr.ip6);
239#endif
bc54e49c
TY		 240 }
241
242 cancel_delayed_work(&snode->source_timer);
243 hlist_del_init_rcu(&snode->node);
244 tunnel->nr_sources--;
245 gnode->nr_sources--;
246 spin_lock_bh(&source_gc_lock);
247 hlist_add_head_rcu(&snode->node, &source_gc_list);
248 spin_unlock_bh(&source_gc_lock);
249}
250
251static void amt_del_group(struct amt_dev *amt, struct amt_group_node *gnode)
252{
253 struct amt_source_node *snode;
254 struct hlist_node *t;
255 int i;
256
257 if (cancel_delayed_work(&gnode->group_timer))
258 dev_put(amt->dev);
259 hlist_del_rcu(&gnode->node);
260 gnode->tunnel_list->nr_groups--;
261
262 if (!gnode->v6)
263 netdev_dbg(amt->dev, "Leave group %pI4\n",
264 &gnode->group_addr.ip4);
b75f7095
TY		 265#if IS_ENABLED(CONFIG_IPV6)
266 else
267 netdev_dbg(amt->dev, "Leave group %pI6\n",
268 &gnode->group_addr.ip6);
269#endif
bc54e49c
TY		 270 for (i = 0; i < amt->hash_buckets; i++)
271 hlist_for_each_entry_safe(snode, t, &gnode->sources[i], node)
272 amt_destroy_source(snode);
273
274 /* tunnel->lock was acquired outside of amt_del_group()
275 * But rcu_read_lock() was acquired too so It's safe.
276 */
277 kfree_rcu(gnode, rcu);
278}
279
280/* If a source timer expires with a router filter-mode for the group of
281 * INCLUDE, the router concludes that traffic from this particular
282 * source is no longer desired on the attached network, and deletes the
283 * associated source record.
284 */
285static void amt_source_work(struct work_struct *work)
286{
287 struct amt_source_node *snode = container_of(to_delayed_work(work),
288 struct amt_source_node,
289 source_timer);
290 struct amt_group_node *gnode = snode->gnode;
291 struct amt_dev *amt = gnode->amt;
292 struct amt_tunnel_list *tunnel;
293
294 tunnel = gnode->tunnel_list;
295 spin_lock_bh(&tunnel->lock);
296 rcu_read_lock();
297 if (gnode->filter_mode == MCAST_INCLUDE) {
298 amt_destroy_source(snode);
299 if (!gnode->nr_sources)
300 amt_del_group(amt, gnode);
301 } else {
302 /* When a router filter-mode for a group is EXCLUDE,
303 * source records are only deleted when the group timer expires
304 */
305 snode->status = AMT_SOURCE_STATUS_D_FWD;
306 }
307 rcu_read_unlock();
308 spin_unlock_bh(&tunnel->lock);
309}
310
311static void amt_act_src(struct amt_tunnel_list *tunnel,
312 struct amt_group_node *gnode,
313 struct amt_source_node *snode,
314 enum amt_act act)
315{
316 struct amt_dev *amt = tunnel->amt;
317
318 switch (act) {
319 case AMT_ACT_GMI:
320 mod_delayed_work(amt_wq, &snode->source_timer,
321 msecs_to_jiffies(amt_gmi(amt)));
322 break;
323 case AMT_ACT_GMI_ZERO:
324 cancel_delayed_work(&snode->source_timer);
325 break;
326 case AMT_ACT_GT:
327 mod_delayed_work(amt_wq, &snode->source_timer,
328 gnode->group_timer.timer.expires);
329 break;
330 case AMT_ACT_STATUS_FWD_NEW:
331 snode->status = AMT_SOURCE_STATUS_FWD;
332 snode->flags = AMT_SOURCE_NEW;
333 break;
334 case AMT_ACT_STATUS_D_FWD_NEW:
335 snode->status = AMT_SOURCE_STATUS_D_FWD;
336 snode->flags = AMT_SOURCE_NEW;
337 break;
338 case AMT_ACT_STATUS_NONE_NEW:
339 cancel_delayed_work(&snode->source_timer);
340 snode->status = AMT_SOURCE_STATUS_NONE;
341 snode->flags = AMT_SOURCE_NEW;
342 break;
343 default:
344 WARN_ON_ONCE(1);
345 return;
346 }
347
348 if (!gnode->v6)
349 netdev_dbg(amt->dev, "Source %pI4 from %pI4 Acted %s\n",
350 &snode->source_addr.ip4,
351 &gnode->group_addr.ip4,
352 action_str[act]);
b75f7095
TY		 353#if IS_ENABLED(CONFIG_IPV6)
354 else
355 netdev_dbg(amt->dev, "Source %pI6 from %pI6 Acted %s\n",
356 &snode->source_addr.ip6,
357 &gnode->group_addr.ip6,
358 action_str[act]);
359#endif
bc54e49c
TY		 360}
361
362static struct amt_source_node *amt_alloc_snode(struct amt_group_node *gnode,
363 union amt_addr *src)
364{
365 struct amt_source_node *snode;
366
367 snode = kzalloc(sizeof(*snode), GFP_ATOMIC);
368 if (!snode)
369 return NULL;
370
371 memcpy(&snode->source_addr, src, sizeof(union amt_addr));
372 snode->gnode = gnode;
373 snode->status = AMT_SOURCE_STATUS_NONE;
374 snode->flags = AMT_SOURCE_NEW;
375 INIT_HLIST_NODE(&snode->node);
376 INIT_DELAYED_WORK(&snode->source_timer, amt_source_work);
377
378 return snode;
379}
380
381/* RFC 3810 - 7.2.2. Definition of Filter Timers
382 *
383 * Router Mode Filter Timer Actions/Comments
384 * ----------- ----------------- ----------------
385 *
386 * INCLUDE Not Used All listeners in
387 * INCLUDE mode.
388 *
389 * EXCLUDE Timer > 0 At least one listener
390 * in EXCLUDE mode.
391 *
392 * EXCLUDE Timer == 0 No more listeners in
393 * EXCLUDE mode for the
394 * multicast address.
395 * If the Requested List
396 * is empty, delete
397 * Multicast Address
398 * Record. If not, switch
399 * to INCLUDE filter mode;
400 * the sources in the
401 * Requested List are
402 * moved to the Include
403 * List, and the Exclude
404 * List is deleted.
405 */
406static void amt_group_work(struct work_struct *work)
407{
408 struct amt_group_node *gnode = container_of(to_delayed_work(work),
409 struct amt_group_node,
410 group_timer);
411 struct amt_tunnel_list *tunnel = gnode->tunnel_list;
412 struct amt_dev *amt = gnode->amt;
413 struct amt_source_node *snode;
414 bool delete_group = true;
415 struct hlist_node *t;
416 int i, buckets;
417
418 buckets = amt->hash_buckets;
419
420 spin_lock_bh(&tunnel->lock);
421 if (gnode->filter_mode == MCAST_INCLUDE) {
422 /* Not Used */
423 spin_unlock_bh(&tunnel->lock);
424 goto out;
425 }
426
427 rcu_read_lock();
428 for (i = 0; i < buckets; i++) {
429 hlist_for_each_entry_safe(snode, t,
430 &gnode->sources[i], node) {
431 if (!delayed_work_pending(&snode->source_timer) ||
432 snode->status == AMT_SOURCE_STATUS_D_FWD) {
433 amt_destroy_source(snode);
434 } else {
435 delete_group = false;
436 snode->status = AMT_SOURCE_STATUS_FWD;
437 }
438 }
439 }
440 if (delete_group)
441 amt_del_group(amt, gnode);
442 else
443 gnode->filter_mode = MCAST_INCLUDE;
444 rcu_read_unlock();
445 spin_unlock_bh(&tunnel->lock);
446out:
447 dev_put(amt->dev);
448}
449
450/* Non-existant group is created as INCLUDE {empty}:
451 *
452 * RFC 3376 - 5.1. Action on Change of Interface State
453 *
454 * If no interface state existed for that multicast address before
455 * the change (i.e., the change consisted of creating a new
456 * per-interface record), or if no state exists after the change
457 * (i.e., the change consisted of deleting a per-interface record),
458 * then the "non-existent" state is considered to have a filter mode
459 * of INCLUDE and an empty source list.
460 */
461static struct amt_group_node *amt_add_group(struct amt_dev *amt,
462 struct amt_tunnel_list *tunnel,
463 union amt_addr *group,
464 union amt_addr *host,
465 bool v6)
466{
467 struct amt_group_node *gnode;
468 u32 hash;
469 int i;
470
471 if (tunnel->nr_groups >= amt->max_groups)
472 return ERR_PTR(-ENOSPC);
473
474 gnode = kzalloc(sizeof(*gnode) +
475 (sizeof(struct hlist_head) * amt->hash_buckets),
476 GFP_ATOMIC);
477 if (unlikely(!gnode))
478 return ERR_PTR(-ENOMEM);
479
480 gnode->amt = amt;
481 gnode->group_addr = *group;
482 gnode->host_addr = *host;
483 gnode->v6 = v6;
484 gnode->tunnel_list = tunnel;
485 gnode->filter_mode = MCAST_INCLUDE;
486 INIT_HLIST_NODE(&gnode->node);
487 INIT_DELAYED_WORK(&gnode->group_timer, amt_group_work);
488 for (i = 0; i < amt->hash_buckets; i++)
489 INIT_HLIST_HEAD(&gnode->sources[i]);
490
491 hash = amt_group_hash(tunnel, group);
492 hlist_add_head_rcu(&gnode->node, &tunnel->groups[hash]);
493 tunnel->nr_groups++;
494
495 if (!gnode->v6)
496 netdev_dbg(amt->dev, "Join group %pI4\n",
497 &gnode->group_addr.ip4);
b75f7095
TY		 498#if IS_ENABLED(CONFIG_IPV6)
499 else
500 netdev_dbg(amt->dev, "Join group %pI6\n",
501 &gnode->group_addr.ip6);
502#endif
503
bc54e49c
TY		 504 return gnode;
505}
506
cbc21dc1
TY		 507static struct sk_buff *amt_build_igmp_gq(struct amt_dev *amt)
508{
509 u8 ra[AMT_IPHDR_OPTS] = { IPOPT_RA, 4, 0, 0 };
510 int hlen = LL_RESERVED_SPACE(amt->dev);
511 int tlen = amt->dev->needed_tailroom;
512 struct igmpv3_query *ihv3;
513 void *csum_start = NULL;
514 __sum16 *csum = NULL;
515 struct sk_buff *skb;
516 struct ethhdr *eth;
517 struct iphdr *iph;
518 unsigned int len;
519 int offset;
520
521 len = hlen + tlen + sizeof(*iph) + AMT_IPHDR_OPTS + sizeof(*ihv3);
522 skb = netdev_alloc_skb_ip_align(amt->dev, len);
523 if (!skb)
524 return NULL;
525
526 skb_reserve(skb, hlen);
527 skb_push(skb, sizeof(*eth));
528 skb->protocol = htons(ETH_P_IP);
529 skb_reset_mac_header(skb);
530 skb->priority = TC_PRIO_CONTROL;
531 skb_put(skb, sizeof(*iph));
532 skb_put_data(skb, ra, sizeof(ra));
533 skb_put(skb, sizeof(*ihv3));
534 skb_pull(skb, sizeof(*eth));
535 skb_reset_network_header(skb);
536
537 iph = ip_hdr(skb);
538 iph->version = 4;
539 iph->ihl = (sizeof(struct iphdr) + AMT_IPHDR_OPTS) >> 2;
540 iph->tos = AMT_TOS;
541 iph->tot_len = htons(sizeof(*iph) + AMT_IPHDR_OPTS + sizeof(*ihv3));
542 iph->frag_off = htons(IP_DF);
543 iph->ttl = 1;
544 iph->id = 0;
545 iph->protocol = IPPROTO_IGMP;
546 iph->daddr = htonl(INADDR_ALLHOSTS_GROUP);
547 iph->saddr = htonl(INADDR_ANY);
548 ip_send_check(iph);
549
550 eth = eth_hdr(skb);
551 ether_addr_copy(eth->h_source, amt->dev->dev_addr);
552 ip_eth_mc_map(htonl(INADDR_ALLHOSTS_GROUP), eth->h_dest);
553 eth->h_proto = htons(ETH_P_IP);
554
555 ihv3 = skb_pull(skb, sizeof(*iph) + AMT_IPHDR_OPTS);
556 skb_reset_transport_header(skb);
557 ihv3->type = IGMP_HOST_MEMBERSHIP_QUERY;
558 ihv3->code = 1;
559 ihv3->group = 0;
560 ihv3->qqic = amt->qi;
561 ihv3->nsrcs = 0;
562 ihv3->resv = 0;
563 ihv3->suppress = false;
564 ihv3->qrv = amt->net->ipv4.sysctl_igmp_qrv;
565 ihv3->csum = 0;
566 csum = &ihv3->csum;
567 csum_start = (void *)ihv3;
568 *csum = ip_compute_csum(csum_start, sizeof(*ihv3));
569 offset = skb_transport_offset(skb);
570 skb->csum = skb_checksum(skb, offset, skb->len - offset, 0);
571 skb->ip_summed = CHECKSUM_NONE;
572
573 skb_push(skb, sizeof(*eth) + sizeof(*iph) + AMT_IPHDR_OPTS);
574
575 return skb;
576}
577
578static void __amt_update_gw_status(struct amt_dev *amt, enum amt_status status,
579 bool validate)
580{
581 if (validate && amt->status >= status)
582 return;
583 netdev_dbg(amt->dev, "Update GW status %s -> %s",
584 status_str[amt->status], status_str[status]);
585 amt->status = status;
586}
587
588static void __amt_update_relay_status(struct amt_tunnel_list *tunnel,
589 enum amt_status status,
590 bool validate)
591{
592 if (validate && tunnel->status >= status)
593 return;
594 netdev_dbg(tunnel->amt->dev,
595 "Update Tunnel(IP = %pI4, PORT = %u) status %s -> %s",
596 &tunnel->ip4, ntohs(tunnel->source_port),
597 status_str[tunnel->status], status_str[status]);
598 tunnel->status = status;
599}
600
601static void amt_update_gw_status(struct amt_dev *amt, enum amt_status status,
602 bool validate)
603{
604 spin_lock_bh(&amt->lock);
605 __amt_update_gw_status(amt, status, validate);
606 spin_unlock_bh(&amt->lock);
607}
608
609static void amt_update_relay_status(struct amt_tunnel_list *tunnel,
610 enum amt_status status, bool validate)
611{
612 spin_lock_bh(&tunnel->lock);
613 __amt_update_relay_status(tunnel, status, validate);
614 spin_unlock_bh(&tunnel->lock);
615}
616
617static void amt_send_discovery(struct amt_dev *amt)
618{
619 struct amt_header_discovery *amtd;
620 int hlen, tlen, offset;
621 struct socket *sock;
622 struct udphdr *udph;
623 struct sk_buff *skb;
624 struct iphdr *iph;
625 struct rtable *rt;
626 struct flowi4 fl4;
627 u32 len;
628 int err;
629
630 rcu_read_lock();
631 sock = rcu_dereference(amt->sock);
632 if (!sock)
633 goto out;
634
635 if (!netif_running(amt->stream_dev) || !netif_running(amt->dev))
636 goto out;
637
638 rt = ip_route_output_ports(amt->net, &fl4, sock->sk,
639 amt->discovery_ip, amt->local_ip,
640 amt->gw_port, amt->relay_port,
641 IPPROTO_UDP, 0,
642 amt->stream_dev->ifindex);
643 if (IS_ERR(rt)) {
644 amt->dev->stats.tx_errors++;
645 goto out;
646 }
647
648 hlen = LL_RESERVED_SPACE(amt->dev);
649 tlen = amt->dev->needed_tailroom;
650 len = hlen + tlen + sizeof(*iph) + sizeof(*udph) + sizeof(*amtd);
651 skb = netdev_alloc_skb_ip_align(amt->dev, len);
652 if (!skb) {
653 ip_rt_put(rt);
654 amt->dev->stats.tx_errors++;
655 goto out;
656 }
657
658 skb->priority = TC_PRIO_CONTROL;
659 skb_dst_set(skb, &rt->dst);
660
661 len = sizeof(*iph) + sizeof(*udph) + sizeof(*amtd);
662 skb_reset_network_header(skb);
663 skb_put(skb, len);
664 amtd = skb_pull(skb, sizeof(*iph) + sizeof(*udph));
665 amtd->version = 0;
666 amtd->type = AMT_MSG_DISCOVERY;
667 amtd->reserved = 0;
668 amtd->nonce = amt->nonce;
669 skb_push(skb, sizeof(*udph));
670 skb_reset_transport_header(skb);
671 udph = udp_hdr(skb);
672 udph->source = amt->gw_port;
673 udph->dest = amt->relay_port;
674 udph->len = htons(sizeof(*udph) + sizeof(*amtd));
675 udph->check = 0;
676 offset = skb_transport_offset(skb);
677 skb->csum = skb_checksum(skb, offset, skb->len - offset, 0);
678 udph->check = csum_tcpudp_magic(amt->local_ip, amt->discovery_ip,
679 sizeof(*udph) + sizeof(*amtd),
680 IPPROTO_UDP, skb->csum);
681
682 skb_push(skb, sizeof(*iph));
683 iph = ip_hdr(skb);
684 iph->version = 4;
685 iph->ihl = (sizeof(struct iphdr)) >> 2;
686 iph->tos = AMT_TOS;
687 iph->frag_off = 0;
688 iph->ttl = ip4_dst_hoplimit(&rt->dst);
689 iph->daddr = amt->discovery_ip;
690 iph->saddr = amt->local_ip;
691 iph->protocol = IPPROTO_UDP;
692 iph->tot_len = htons(len);
693
694 skb->ip_summed = CHECKSUM_NONE;
695 ip_select_ident(amt->net, skb, NULL);
696 ip_send_check(iph);
697 err = ip_local_out(amt->net, sock->sk, skb);
698 if (unlikely(net_xmit_eval(err)))
699 amt->dev->stats.tx_errors++;
700
701 spin_lock_bh(&amt->lock);
702 __amt_update_gw_status(amt, AMT_STATUS_SENT_DISCOVERY, true);
703 spin_unlock_bh(&amt->lock);
704out:
705 rcu_read_unlock();
706}
707
708static void amt_send_request(struct amt_dev *amt, bool v6)
709{
710 struct amt_header_request *amtrh;
711 int hlen, tlen, offset;
712 struct socket *sock;
713 struct udphdr *udph;
714 struct sk_buff *skb;
715 struct iphdr *iph;
716 struct rtable *rt;
717 struct flowi4 fl4;
718 u32 len;
719 int err;
720
721 rcu_read_lock();
722 sock = rcu_dereference(amt->sock);
723 if (!sock)
724 goto out;
725
726 if (!netif_running(amt->stream_dev) || !netif_running(amt->dev))
727 goto out;
728
729 rt = ip_route_output_ports(amt->net, &fl4, sock->sk,
730 amt->remote_ip, amt->local_ip,
731 amt->gw_port, amt->relay_port,
732 IPPROTO_UDP, 0,
733 amt->stream_dev->ifindex);
734 if (IS_ERR(rt)) {
735 amt->dev->stats.tx_errors++;
736 goto out;
737 }
738
739 hlen = LL_RESERVED_SPACE(amt->dev);
740 tlen = amt->dev->needed_tailroom;
741 len = hlen + tlen + sizeof(*iph) + sizeof(*udph) + sizeof(*amtrh);
742 skb = netdev_alloc_skb_ip_align(amt->dev, len);
743 if (!skb) {
744 ip_rt_put(rt);
745 amt->dev->stats.tx_errors++;
746 goto out;
747 }
748
749 skb->priority = TC_PRIO_CONTROL;
750 skb_dst_set(skb, &rt->dst);
751
752 len = sizeof(*iph) + sizeof(*udph) + sizeof(*amtrh);
753 skb_reset_network_header(skb);
754 skb_put(skb, len);
755 amtrh = skb_pull(skb, sizeof(*iph) + sizeof(*udph));
756 amtrh->version = 0;
757 amtrh->type = AMT_MSG_REQUEST;
758 amtrh->reserved1 = 0;
759 amtrh->p = v6;
760 amtrh->reserved2 = 0;
761 amtrh->nonce = amt->nonce;
762 skb_push(skb, sizeof(*udph));
763 skb_reset_transport_header(skb);
764 udph = udp_hdr(skb);
765 udph->source = amt->gw_port;
766 udph->dest = amt->relay_port;
767 udph->len = htons(sizeof(*amtrh) + sizeof(*udph));
768 udph->check = 0;
769 offset = skb_transport_offset(skb);
770 skb->csum = skb_checksum(skb, offset, skb->len - offset, 0);
771 udph->check = csum_tcpudp_magic(amt->local_ip, amt->remote_ip,
772 sizeof(*udph) + sizeof(*amtrh),
773 IPPROTO_UDP, skb->csum);
774
775 skb_push(skb, sizeof(*iph));
776 iph = ip_hdr(skb);
777 iph->version = 4;
778 iph->ihl = (sizeof(struct iphdr)) >> 2;
779 iph->tos = AMT_TOS;
780 iph->frag_off = 0;
781 iph->ttl = ip4_dst_hoplimit(&rt->dst);
782 iph->daddr = amt->remote_ip;
783 iph->saddr = amt->local_ip;
784 iph->protocol = IPPROTO_UDP;
785 iph->tot_len = htons(len);
786
787 skb->ip_summed = CHECKSUM_NONE;
788 ip_select_ident(amt->net, skb, NULL);
789 ip_send_check(iph);
790 err = ip_local_out(amt->net, sock->sk, skb);
791 if (unlikely(net_xmit_eval(err)))
792 amt->dev->stats.tx_errors++;
793
794out:
795 rcu_read_unlock();
796}
797
798static void amt_send_igmp_gq(struct amt_dev *amt,
799 struct amt_tunnel_list *tunnel)
800{
801 struct sk_buff *skb;
802
803 skb = amt_build_igmp_gq(amt);
804 if (!skb)
805 return;
806
807 amt_skb_cb(skb)->tunnel = tunnel;
808 dev_queue_xmit(skb);
809}
810
b75f7095
TY		 811#if IS_ENABLED(CONFIG_IPV6)
812static struct sk_buff *amt_build_mld_gq(struct amt_dev *amt)
813{
814 u8 ra[AMT_IP6HDR_OPTS] = { IPPROTO_ICMPV6, 0, IPV6_TLV_ROUTERALERT,
815 2, 0, 0, IPV6_TLV_PAD1, IPV6_TLV_PAD1 };
816 int hlen = LL_RESERVED_SPACE(amt->dev);
817 int tlen = amt->dev->needed_tailroom;
818 struct mld2_query *mld2q;
819 void *csum_start = NULL;
820 struct ipv6hdr *ip6h;
821 struct sk_buff *skb;
822 struct ethhdr *eth;
823 u32 len;
824
825 len = hlen + tlen + sizeof(*ip6h) + sizeof(ra) + sizeof(*mld2q);
826 skb = netdev_alloc_skb_ip_align(amt->dev, len);
827 if (!skb)
828 return NULL;
829
830 skb_reserve(skb, hlen);
831 skb_push(skb, sizeof(*eth));
832 skb_reset_mac_header(skb);
833 eth = eth_hdr(skb);
834 skb->priority = TC_PRIO_CONTROL;
835 skb->protocol = htons(ETH_P_IPV6);
836 skb_put_zero(skb, sizeof(*ip6h));
837 skb_put_data(skb, ra, sizeof(ra));
838 skb_put_zero(skb, sizeof(*mld2q));
839 skb_pull(skb, sizeof(*eth));
840 skb_reset_network_header(skb);
841 ip6h = ipv6_hdr(skb);
842 ip6h->payload_len = htons(sizeof(ra) + sizeof(*mld2q));
843 ip6h->nexthdr = NEXTHDR_HOP;
844 ip6h->hop_limit = 1;
845 ip6h->daddr = mld2_all_node;
846 ip6_flow_hdr(ip6h, 0, 0);
847
848 if (ipv6_dev_get_saddr(amt->net, amt->dev, &ip6h->daddr, 0,
849 &ip6h->saddr)) {
850 amt->dev->stats.tx_errors++;
851 kfree_skb(skb);
852 return NULL;
853 }
854
855 eth->h_proto = htons(ETH_P_IPV6);
856 ether_addr_copy(eth->h_source, amt->dev->dev_addr);
857 ipv6_eth_mc_map(&mld2_all_node, eth->h_dest);
858
859 skb_pull(skb, sizeof(*ip6h) + sizeof(ra));
860 skb_reset_transport_header(skb);
861 mld2q = (struct mld2_query *)icmp6_hdr(skb);
862 mld2q->mld2q_mrc = htons(1);
863 mld2q->mld2q_type = ICMPV6_MGM_QUERY;
864 mld2q->mld2q_code = 0;
865 mld2q->mld2q_cksum = 0;
866 mld2q->mld2q_resv1 = 0;
867 mld2q->mld2q_resv2 = 0;
868 mld2q->mld2q_suppress = 0;
869 mld2q->mld2q_qrv = amt->qrv;
870 mld2q->mld2q_nsrcs = 0;
871 mld2q->mld2q_qqic = amt->qi;
872 csum_start = (void *)mld2q;
873 mld2q->mld2q_cksum = csum_ipv6_magic(&ip6h->saddr, &ip6h->daddr,
874 sizeof(*mld2q),
875 IPPROTO_ICMPV6,
876 csum_partial(csum_start,
877 sizeof(*mld2q), 0));
878
879 skb->ip_summed = CHECKSUM_NONE;
880 skb_push(skb, sizeof(*eth) + sizeof(*ip6h) + sizeof(ra));
881 return skb;
882}
883
884static void amt_send_mld_gq(struct amt_dev *amt, struct amt_tunnel_list *tunnel)
885{
886 struct sk_buff *skb;
887
888 skb = amt_build_mld_gq(amt);
889 if (!skb)
890 return;
891
892 amt_skb_cb(skb)->tunnel = tunnel;
893 dev_queue_xmit(skb);
894}
895#else
896static void amt_send_mld_gq(struct amt_dev *amt, struct amt_tunnel_list *tunnel)
897{
898}
899#endif
900
cbc21dc1
TY		 901static void amt_secret_work(struct work_struct *work)
902{
903 struct amt_dev *amt = container_of(to_delayed_work(work),
904 struct amt_dev,
905 secret_wq);
906
907 spin_lock_bh(&amt->lock);
908 get_random_bytes(&amt->key, sizeof(siphash_key_t));
909 spin_unlock_bh(&amt->lock);
910 mod_delayed_work(amt_wq, &amt->secret_wq,
911 msecs_to_jiffies(AMT_SECRET_TIMEOUT));
912}
913
914static void amt_discovery_work(struct work_struct *work)
915{
916 struct amt_dev *amt = container_of(to_delayed_work(work),
917 struct amt_dev,
918 discovery_wq);
919
920 spin_lock_bh(&amt->lock);
921 if (amt->status > AMT_STATUS_SENT_DISCOVERY)
922 goto out;
923 get_random_bytes(&amt->nonce, sizeof(__be32));
924 spin_unlock_bh(&amt->lock);
925
926 amt_send_discovery(amt);
927 spin_lock_bh(&amt->lock);
928out:
929 mod_delayed_work(amt_wq, &amt->discovery_wq,
930 msecs_to_jiffies(AMT_DISCOVERY_TIMEOUT));
931 spin_unlock_bh(&amt->lock);
932}
933
934static void amt_req_work(struct work_struct *work)
935{
936 struct amt_dev *amt = container_of(to_delayed_work(work),
937 struct amt_dev,
938 req_wq);
939 u32 exp;
940
941 spin_lock_bh(&amt->lock);
942 if (amt->status < AMT_STATUS_RECEIVED_ADVERTISEMENT)
943 goto out;
944
945 if (amt->req_cnt++ > AMT_MAX_REQ_COUNT) {
946 netdev_dbg(amt->dev, "Gateway is not ready");
947 amt->qi = AMT_INIT_REQ_TIMEOUT;
948 amt->ready4 = false;
949 amt->ready6 = false;
950 amt->remote_ip = 0;
951 __amt_update_gw_status(amt, AMT_STATUS_INIT, false);
952 amt->req_cnt = 0;
953 }
954 spin_unlock_bh(&amt->lock);
955
956 amt_send_request(amt, false);
957 amt_send_request(amt, true);
958 amt_update_gw_status(amt, AMT_STATUS_SENT_REQUEST, true);
959 spin_lock_bh(&amt->lock);
960out:
961 exp = min_t(u32, (1 * (1 << amt->req_cnt)), AMT_MAX_REQ_TIMEOUT);
962 mod_delayed_work(amt_wq, &amt->req_wq, msecs_to_jiffies(exp * 1000));
963 spin_unlock_bh(&amt->lock);
964}
965
966static bool amt_send_membership_update(struct amt_dev *amt,
967 struct sk_buff *skb,
968 bool v6)
969{
970 struct amt_header_membership_update *amtmu;
971 struct socket *sock;
972 struct iphdr *iph;
973 struct flowi4 fl4;
974 struct rtable *rt;
975 int err;
976
977 sock = rcu_dereference_bh(amt->sock);
978 if (!sock)
979 return true;
980
981 err = skb_cow_head(skb, LL_RESERVED_SPACE(amt->dev) + sizeof(*amtmu) +
982 sizeof(*iph) + sizeof(struct udphdr));
983 if (err)
984 return true;
985
986 skb_reset_inner_headers(skb);
987 memset(&fl4, 0, sizeof(struct flowi4));
988 fl4.flowi4_oif = amt->stream_dev->ifindex;
989 fl4.daddr = amt->remote_ip;
990 fl4.saddr = amt->local_ip;
991 fl4.flowi4_tos = AMT_TOS;
992 fl4.flowi4_proto = IPPROTO_UDP;
993 rt = ip_route_output_key(amt->net, &fl4);
994 if (IS_ERR(rt)) {
995 netdev_dbg(amt->dev, "no route to %pI4\n", &amt->remote_ip);
996 return true;
997 }
998
999 amtmu = skb_push(skb, sizeof(*amtmu));
1000 amtmu->version = 0;
1001 amtmu->type = AMT_MSG_MEMBERSHIP_UPDATE;
1002 amtmu->reserved = 0;
1003 amtmu->nonce = amt->nonce;
1004 amtmu->response_mac = amt->mac;
1005
1006 if (!v6)
1007 skb_set_inner_protocol(skb, htons(ETH_P_IP));
1008 else
1009 skb_set_inner_protocol(skb, htons(ETH_P_IPV6));
1010 udp_tunnel_xmit_skb(rt, sock->sk, skb,
1011 fl4.saddr,
1012 fl4.daddr,
1013 AMT_TOS,
1014 ip4_dst_hoplimit(&rt->dst),
1015 0,
1016 amt->gw_port,
1017 amt->relay_port,
1018 false,
1019 false);
1020 amt_update_gw_status(amt, AMT_STATUS_SENT_UPDATE, true);
1021 return false;
1022}
1023
1024static void amt_send_multicast_data(struct amt_dev *amt,
1025 const struct sk_buff *oskb,
1026 struct amt_tunnel_list *tunnel,
1027 bool v6)
1028{
1029 struct amt_header_mcast_data *amtmd;
1030 struct socket *sock;
1031 struct sk_buff *skb;
1032 struct iphdr *iph;
1033 struct flowi4 fl4;
1034 struct rtable *rt;
1035
1036 sock = rcu_dereference_bh(amt->sock);
1037 if (!sock)
1038 return;
1039
1040 skb = skb_copy_expand(oskb, sizeof(*amtmd) + sizeof(*iph) +
1041 sizeof(struct udphdr), 0, GFP_ATOMIC);
1042 if (!skb)
1043 return;
1044
1045 skb_reset_inner_headers(skb);
1046 memset(&fl4, 0, sizeof(struct flowi4));
1047 fl4.flowi4_oif = amt->stream_dev->ifindex;
1048 fl4.daddr = tunnel->ip4;
1049 fl4.saddr = amt->local_ip;
1050 fl4.flowi4_proto = IPPROTO_UDP;
1051 rt = ip_route_output_key(amt->net, &fl4);
1052 if (IS_ERR(rt)) {
1053 netdev_dbg(amt->dev, "no route to %pI4\n", &tunnel->ip4);
1054 kfree_skb(skb);
1055 return;
1056 }
1057
1058 amtmd = skb_push(skb, sizeof(*amtmd));
1059 amtmd->version = 0;
1060 amtmd->reserved = 0;
1061 amtmd->type = AMT_MSG_MULTICAST_DATA;
1062
1063 if (!v6)
1064 skb_set_inner_protocol(skb, htons(ETH_P_IP));
1065 else
1066 skb_set_inner_protocol(skb, htons(ETH_P_IPV6));
1067 udp_tunnel_xmit_skb(rt, sock->sk, skb,
1068 fl4.saddr,
1069 fl4.daddr,
1070 AMT_TOS,
1071 ip4_dst_hoplimit(&rt->dst),
1072 0,
1073 amt->relay_port,
1074 tunnel->source_port,
1075 false,
1076 false);
1077}
1078
1079static bool amt_send_membership_query(struct amt_dev *amt,
1080 struct sk_buff *skb,
1081 struct amt_tunnel_list *tunnel,
1082 bool v6)
1083{
1084 struct amt_header_membership_query *amtmq;
1085 struct socket *sock;
1086 struct rtable *rt;
1087 struct flowi4 fl4;
1088 int err;
1089
1090 sock = rcu_dereference_bh(amt->sock);
1091 if (!sock)
1092 return true;
1093
1094 err = skb_cow_head(skb, LL_RESERVED_SPACE(amt->dev) + sizeof(*amtmq) +
1095 sizeof(struct iphdr) + sizeof(struct udphdr));
1096 if (err)
1097 return true;
1098
1099 skb_reset_inner_headers(skb);
1100 memset(&fl4, 0, sizeof(struct flowi4));
1101 fl4.flowi4_oif = amt->stream_dev->ifindex;
1102 fl4.daddr = tunnel->ip4;
1103 fl4.saddr = amt->local_ip;
1104 fl4.flowi4_tos = AMT_TOS;
1105 fl4.flowi4_proto = IPPROTO_UDP;
1106 rt = ip_route_output_key(amt->net, &fl4);
1107 if (IS_ERR(rt)) {
1108 netdev_dbg(amt->dev, "no route to %pI4\n", &tunnel->ip4);
1109 return -1;
1110 }
1111
1112 amtmq = skb_push(skb, sizeof(*amtmq));
1113 amtmq->version = 0;
1114 amtmq->type = AMT_MSG_MEMBERSHIP_QUERY;
1115 amtmq->reserved = 0;
1116 amtmq->l = 0;
1117 amtmq->g = 0;
1118 amtmq->nonce = tunnel->nonce;
1119 amtmq->response_mac = tunnel->mac;
1120
1121 if (!v6)
1122 skb_set_inner_protocol(skb, htons(ETH_P_IP));
1123 else
1124 skb_set_inner_protocol(skb, htons(ETH_P_IPV6));
1125 udp_tunnel_xmit_skb(rt, sock->sk, skb,
1126 fl4.saddr,
1127 fl4.daddr,
1128 AMT_TOS,
1129 ip4_dst_hoplimit(&rt->dst),
1130 0,
1131 amt->relay_port,
1132 tunnel->source_port,
1133 false,
1134 false);
1135 amt_update_relay_status(tunnel, AMT_STATUS_SENT_QUERY, true);
1136 return false;
1137}
1138
1139static netdev_tx_t amt_dev_xmit(struct sk_buff *skb, struct net_device *dev)
1140{
1141 struct amt_dev *amt = netdev_priv(dev);
1142 struct amt_tunnel_list *tunnel;
bc54e49c
TY		 1143 struct amt_group_node *gnode;
1144 union amt_addr group = {0,};
b75f7095
TY		 1145#if IS_ENABLED(CONFIG_IPV6)
1146 struct ipv6hdr *ip6h;
1147 struct mld_msg *mld;
1148#endif
cbc21dc1
TY		 1149 bool report = false;
1150 struct igmphdr *ih;
1151 bool query = false;
1152 struct iphdr *iph;
1153 bool data = false;
1154 bool v6 = false;
bc54e49c 1155 u32 hash;
cbc21dc1
TY		 1156
1157 iph = ip_hdr(skb);
1158 if (iph->version == 4) {
1159 if (!ipv4_is_multicast(iph->daddr))
1160 goto free;
1161
1162 if (!ip_mc_check_igmp(skb)) {
1163 ih = igmp_hdr(skb);
1164 switch (ih->type) {
1165 case IGMPV3_HOST_MEMBERSHIP_REPORT:
1166 case IGMP_HOST_MEMBERSHIP_REPORT:
1167 report = true;
1168 break;
1169 case IGMP_HOST_MEMBERSHIP_QUERY:
1170 query = true;
1171 break;
1172 default:
1173 goto free;
1174 }
1175 } else {
1176 data = true;
1177 }
1178 v6 = false;
bc54e49c 1179 group.ip4 = iph->daddr;
b75f7095
TY		 1180#if IS_ENABLED(CONFIG_IPV6)
1181 } else if (iph->version == 6) {
1182 ip6h = ipv6_hdr(skb);
1183 if (!ipv6_addr_is_multicast(&ip6h->daddr))
1184 goto free;
1185
1186 if (!ipv6_mc_check_mld(skb)) {
1187 mld = (struct mld_msg *)skb_transport_header(skb);
1188 switch (mld->mld_type) {
1189 case ICMPV6_MGM_REPORT:
1190 case ICMPV6_MLD2_REPORT:
1191 report = true;
1192 break;
1193 case ICMPV6_MGM_QUERY:
1194 query = true;
1195 break;
1196 default:
1197 goto free;
1198 }
1199 } else {
1200 data = true;
1201 }
1202 v6 = true;
1203 group.ip6 = ip6h->daddr;
1204#endif
cbc21dc1
TY		 1205 } else {
1206 dev->stats.tx_errors++;
1207 goto free;
1208 }
1209
1210 if (!pskb_may_pull(skb, sizeof(struct ethhdr)))
1211 goto free;
1212
1213 skb_pull(skb, sizeof(struct ethhdr));
1214
1215 if (amt->mode == AMT_MODE_GATEWAY) {
1216 /* Gateway only passes IGMP/MLD packets */
1217 if (!report)
1218 goto free;
1219 if ((!v6 && !amt->ready4) || (v6 && !amt->ready6))
1220 goto free;
1221 if (amt_send_membership_update(amt, skb, v6))
1222 goto free;
1223 goto unlock;
1224 } else if (amt->mode == AMT_MODE_RELAY) {
1225 if (query) {
1226 tunnel = amt_skb_cb(skb)->tunnel;
1227 if (!tunnel) {
1228 WARN_ON(1);
1229 goto free;
1230 }
1231
1232 /* Do not forward unexpected query */
1233 if (amt_send_membership_query(amt, skb, tunnel, v6))
1234 goto free;
1235 goto unlock;
1236 }
1237
1238 if (!data)
1239 goto free;
bc54e49c
TY		 1240 list_for_each_entry_rcu(tunnel, &amt->tunnel_list, list) {
1241 hash = amt_group_hash(tunnel, &group);
1242 hlist_for_each_entry_rcu(gnode, &tunnel->groups[hash],
1243 node) {
b75f7095 1244 if (!v6) {
bc54e49c
TY		 1245 if (gnode->group_addr.ip4 == iph->daddr)
1246 goto found;
b75f7095
TY		 1247#if IS_ENABLED(CONFIG_IPV6)
1248 } else {
1249 if (ipv6_addr_equal(&gnode->group_addr.ip6,
1250 &ip6h->daddr))
1251 goto found;
1252#endif
1253 }
bc54e49c
TY		 1254 }
1255 continue;
b75f7095 1256found:
cbc21dc1 1257 amt_send_multicast_data(amt, skb, tunnel, v6);
bc54e49c 1258 }
cbc21dc1
TY		 1259 }
1260
1261 dev_kfree_skb(skb);
1262 return NETDEV_TX_OK;
1263free:
1264 dev_kfree_skb(skb);
1265unlock:
1266 dev->stats.tx_dropped++;
1267 return NETDEV_TX_OK;
1268}
1269
1270static int amt_parse_type(struct sk_buff *skb)
1271{
1272 struct amt_header *amth;
1273
1274 if (!pskb_may_pull(skb, sizeof(struct udphdr) +
1275 sizeof(struct amt_header)))
1276 return -1;
1277
1278 amth = (struct amt_header *)(udp_hdr(skb) + 1);
1279
1280 if (amth->version != 0)
1281 return -1;
1282
1283 if (amth->type >= __AMT_MSG_MAX || !amth->type)
1284 return -1;
1285 return amth->type;
1286}
1287
bc54e49c
TY		 1288static void amt_clear_groups(struct amt_tunnel_list *tunnel)
1289{
1290 struct amt_dev *amt = tunnel->amt;
1291 struct amt_group_node *gnode;
1292 struct hlist_node *t;
1293 int i;
1294
1295 spin_lock_bh(&tunnel->lock);
1296 rcu_read_lock();
1297 for (i = 0; i < amt->hash_buckets; i++)
1298 hlist_for_each_entry_safe(gnode, t, &tunnel->groups[i], node)
1299 amt_del_group(amt, gnode);
1300 rcu_read_unlock();
1301 spin_unlock_bh(&tunnel->lock);
1302}
1303
cbc21dc1
TY		 1304static void amt_tunnel_expire(struct work_struct *work)
1305{
1306 struct amt_tunnel_list *tunnel = container_of(to_delayed_work(work),
1307 struct amt_tunnel_list,
1308 gc_wq);
1309 struct amt_dev *amt = tunnel->amt;
1310
1311 spin_lock_bh(&amt->lock);
1312 rcu_read_lock();
1313 list_del_rcu(&tunnel->list);
1314 amt->nr_tunnels--;
bc54e49c 1315 amt_clear_groups(tunnel);
cbc21dc1
TY		 1316 rcu_read_unlock();
1317 spin_unlock_bh(&amt->lock);
1318 kfree_rcu(tunnel, rcu);
1319}
1320
bc54e49c
TY		 1321static void amt_cleanup_srcs(struct amt_dev *amt,
1322 struct amt_tunnel_list *tunnel,
1323 struct amt_group_node *gnode)
1324{
1325 struct amt_source_node *snode;
1326 struct hlist_node *t;
1327 int i;
1328
1329 /* Delete old sources */
1330 for (i = 0; i < amt->hash_buckets; i++) {
1331 hlist_for_each_entry_safe(snode, t, &gnode->sources[i], node) {
1332 if (snode->flags == AMT_SOURCE_OLD)
1333 amt_destroy_source(snode);
1334 }
1335 }
1336
1337 /* switch from new to old */
1338 for (i = 0; i < amt->hash_buckets; i++) {
1339 hlist_for_each_entry_rcu(snode, &gnode->sources[i], node) {
1340 snode->flags = AMT_SOURCE_OLD;
1341 if (!gnode->v6)
1342 netdev_dbg(snode->gnode->amt->dev,
1343 "Add source as OLD %pI4 from %pI4\n",
1344 &snode->source_addr.ip4,
1345 &gnode->group_addr.ip4);
b75f7095
TY		 1346#if IS_ENABLED(CONFIG_IPV6)
1347 else
1348 netdev_dbg(snode->gnode->amt->dev,
1349 "Add source as OLD %pI6 from %pI6\n",
1350 &snode->source_addr.ip6,
1351 &gnode->group_addr.ip6);
1352#endif
bc54e49c
TY		 1353 }
1354 }
1355}
1356
1357static void amt_add_srcs(struct amt_dev *amt, struct amt_tunnel_list *tunnel,
1358 struct amt_group_node *gnode, void *grec,
1359 bool v6)
1360{
1361 struct igmpv3_grec *igmp_grec;
1362 struct amt_source_node *snode;
b75f7095
TY		 1363#if IS_ENABLED(CONFIG_IPV6)
1364 struct mld2_grec *mld_grec;
1365#endif
bc54e49c
TY		 1366 union amt_addr src = {0,};
1367 u16 nsrcs;
1368 u32 hash;
1369 int i;
1370
1371 if (!v6) {
1372 igmp_grec = (struct igmpv3_grec *)grec;
1373 nsrcs = ntohs(igmp_grec->grec_nsrcs);
1374 } else {
b75f7095
TY		 1375#if IS_ENABLED(CONFIG_IPV6)
1376 mld_grec = (struct mld2_grec *)grec;
1377 nsrcs = ntohs(mld_grec->grec_nsrcs);
1378#else
1379 return;
1380#endif
bc54e49c
TY		 1381 }
1382 for (i = 0; i < nsrcs; i++) {
1383 if (tunnel->nr_sources >= amt->max_sources)
1384 return;
1385 if (!v6)
1386 src.ip4 = igmp_grec->grec_src[i];
b75f7095
TY		 1387#if IS_ENABLED(CONFIG_IPV6)
1388 else
1389 memcpy(&src.ip6, &mld_grec->grec_src[i],
1390 sizeof(struct in6_addr));
1391#endif
bc54e49c
TY		 1392 if (amt_lookup_src(tunnel, gnode, AMT_FILTER_ALL, &src))
1393 continue;
1394
1395 snode = amt_alloc_snode(gnode, &src);
1396 if (snode) {
1397 hash = amt_source_hash(tunnel, &snode->source_addr);
1398 hlist_add_head_rcu(&snode->node, &gnode->sources[hash]);
1399 tunnel->nr_sources++;
1400 gnode->nr_sources++;
1401
1402 if (!gnode->v6)
1403 netdev_dbg(snode->gnode->amt->dev,
1404 "Add source as NEW %pI4 from %pI4\n",
1405 &snode->source_addr.ip4,
1406 &gnode->group_addr.ip4);
b75f7095
TY		 1407#if IS_ENABLED(CONFIG_IPV6)
1408 else
1409 netdev_dbg(snode->gnode->amt->dev,
1410 "Add source as NEW %pI6 from %pI6\n",
1411 &snode->source_addr.ip6,
1412 &gnode->group_addr.ip6);
1413#endif
bc54e49c
TY		 1414 }
1415 }
1416}
1417
1418/* Router State Report Rec'd New Router State
1419 * ------------ ------------ ----------------
1420 * EXCLUDE (X,Y) IS_IN (A) EXCLUDE (X+A,Y-A)
1421 *
1422 * -----------+-----------+-----------+
1423 * | OLD | NEW |
1424 * -----------+-----------+-----------+
1425 * FWD | X | X+A |
1426 * -----------+-----------+-----------+
1427 * D_FWD | Y | Y-A |
1428 * -----------+-----------+-----------+
1429 * NONE | | A |
1430 * -----------+-----------+-----------+
1431 *
1432 * a) Received sources are NONE/NEW
1433 * b) All NONE will be deleted by amt_cleanup_srcs().
1434 * c) All OLD will be deleted by amt_cleanup_srcs().
1435 * d) After delete, NEW source will be switched to OLD.
1436 */
1437static void amt_lookup_act_srcs(struct amt_tunnel_list *tunnel,
1438 struct amt_group_node *gnode,
1439 void *grec,
1440 enum amt_ops ops,
1441 enum amt_filter filter,
1442 enum amt_act act,
1443 bool v6)
1444{
1445 struct amt_dev *amt = tunnel->amt;
1446 struct amt_source_node *snode;
1447 struct igmpv3_grec *igmp_grec;
b75f7095
TY		 1448#if IS_ENABLED(CONFIG_IPV6)
1449 struct mld2_grec *mld_grec;
1450#endif
bc54e49c
TY		 1451 union amt_addr src = {0,};
1452 struct hlist_node *t;
1453 u16 nsrcs;
1454 int i, j;
1455
1456 if (!v6) {
1457 igmp_grec = (struct igmpv3_grec *)grec;
1458 nsrcs = ntohs(igmp_grec->grec_nsrcs);
1459 } else {
b75f7095
TY		 1460#if IS_ENABLED(CONFIG_IPV6)
1461 mld_grec = (struct mld2_grec *)grec;
1462 nsrcs = ntohs(mld_grec->grec_nsrcs);
1463#else
1464 return;
1465#endif
bc54e49c
TY		 1466 }
1467
1468 memset(&src, 0, sizeof(union amt_addr));
1469 switch (ops) {
1470 case AMT_OPS_INT:
1471 /* A*B */
1472 for (i = 0; i < nsrcs; i++) {
1473 if (!v6)
1474 src.ip4 = igmp_grec->grec_src[i];
b75f7095
TY		 1475#if IS_ENABLED(CONFIG_IPV6)
1476 else
1477 memcpy(&src.ip6, &mld_grec->grec_src[i],
1478 sizeof(struct in6_addr));
1479#endif
bc54e49c
TY		 1480 snode = amt_lookup_src(tunnel, gnode, filter, &src);
1481 if (!snode)
1482 continue;
1483 amt_act_src(tunnel, gnode, snode, act);
1484 }
1485 break;
1486 case AMT_OPS_UNI:
1487 /* A+B */
1488 for (i = 0; i < amt->hash_buckets; i++) {
1489 hlist_for_each_entry_safe(snode, t, &gnode->sources[i],
1490 node) {
1491 if (amt_status_filter(snode, filter))
1492 amt_act_src(tunnel, gnode, snode, act);
1493 }
1494 }
1495 for (i = 0; i < nsrcs; i++) {
1496 if (!v6)
1497 src.ip4 = igmp_grec->grec_src[i];
b75f7095
TY		 1498#if IS_ENABLED(CONFIG_IPV6)
1499 else
1500 memcpy(&src.ip6, &mld_grec->grec_src[i],
1501 sizeof(struct in6_addr));
1502#endif
bc54e49c
TY		 1503 snode = amt_lookup_src(tunnel, gnode, filter, &src);
1504 if (!snode)
1505 continue;
1506 amt_act_src(tunnel, gnode, snode, act);
1507 }
1508 break;
1509 case AMT_OPS_SUB:
1510 /* A-B */
1511 for (i = 0; i < amt->hash_buckets; i++) {
1512 hlist_for_each_entry_safe(snode, t, &gnode->sources[i],
1513 node) {
1514 if (!amt_status_filter(snode, filter))
1515 continue;
1516 for (j = 0; j < nsrcs; j++) {
1517 if (!v6)
1518 src.ip4 = igmp_grec->grec_src[j];
b75f7095
TY		 1519#if IS_ENABLED(CONFIG_IPV6)
1520 else
1521 memcpy(&src.ip6,
1522 &mld_grec->grec_src[j],
1523 sizeof(struct in6_addr));
1524#endif
bc54e49c
TY		 1525 if (amt_addr_equal(&snode->source_addr,
1526 &src))
1527 goto out_sub;
1528 }
1529 amt_act_src(tunnel, gnode, snode, act);
1530 continue;
1531out_sub:;
1532 }
1533 }
1534 break;
1535 case AMT_OPS_SUB_REV:
1536 /* B-A */
1537 for (i = 0; i < nsrcs; i++) {
1538 if (!v6)
1539 src.ip4 = igmp_grec->grec_src[i];
b75f7095
TY		 1540#if IS_ENABLED(CONFIG_IPV6)
1541 else
1542 memcpy(&src.ip6, &mld_grec->grec_src[i],
1543 sizeof(struct in6_addr));
1544#endif
bc54e49c
TY		 1545 snode = amt_lookup_src(tunnel, gnode, AMT_FILTER_ALL,
1546 &src);
1547 if (!snode) {
1548 snode = amt_lookup_src(tunnel, gnode,
1549 filter, &src);
1550 if (snode)
1551 amt_act_src(tunnel, gnode, snode, act);
1552 }
1553 }
1554 break;
1555 default:
1556 netdev_dbg(amt->dev, "Invalid type\n");
1557 return;
1558 }
1559}
1560
1561static void amt_mcast_is_in_handler(struct amt_dev *amt,
1562 struct amt_tunnel_list *tunnel,
1563 struct amt_group_node *gnode,
1564 void *grec, void *zero_grec, bool v6)
1565{
1566 if (gnode->filter_mode == MCAST_INCLUDE) {
1567/* Router State Report Rec'd New Router State Actions
1568 * ------------ ------------ ---------------- -------
1569 * INCLUDE (A) IS_IN (B) INCLUDE (A+B) (B)=GMI
1570 */
1571 /* Update IS_IN (B) as FWD/NEW */
1572 amt_lookup_act_srcs(tunnel, gnode, grec, AMT_OPS_UNI,
1573 AMT_FILTER_NONE_NEW,
1574 AMT_ACT_STATUS_FWD_NEW,
1575 v6);
1576 /* Update INCLUDE (A) as NEW */
1577 amt_lookup_act_srcs(tunnel, gnode, grec, AMT_OPS_UNI,
1578 AMT_FILTER_FWD,
1579 AMT_ACT_STATUS_FWD_NEW,
1580 v6);
1581 /* (B)=GMI */
1582 amt_lookup_act_srcs(tunnel, gnode, grec, AMT_OPS_INT,
1583 AMT_FILTER_FWD_NEW,
1584 AMT_ACT_GMI,
1585 v6);
1586 } else {
1587/* State Actions
1588 * ------------ ------------ ---------------- -------
1589 * EXCLUDE (X,Y) IS_IN (A) EXCLUDE (X+A,Y-A) (A)=GMI
1590 */
1591 /* Update (A) in (X, Y) as NONE/NEW */
1592 amt_lookup_act_srcs(tunnel, gnode, grec, AMT_OPS_INT,
1593 AMT_FILTER_BOTH,
1594 AMT_ACT_STATUS_NONE_NEW,
1595 v6);
1596 /* Update FWD/OLD as FWD/NEW */
1597 amt_lookup_act_srcs(tunnel, gnode, zero_grec, AMT_OPS_UNI,
1598 AMT_FILTER_FWD,
1599 AMT_ACT_STATUS_FWD_NEW,
1600 v6);
1601 /* Update IS_IN (A) as FWD/NEW */
1602 amt_lookup_act_srcs(tunnel, gnode, grec, AMT_OPS_INT,
1603 AMT_FILTER_NONE_NEW,
1604 AMT_ACT_STATUS_FWD_NEW,
1605 v6);
1606 /* Update EXCLUDE (, Y-A) as D_FWD_NEW */
1607 amt_lookup_act_srcs(tunnel, gnode, grec, AMT_OPS_SUB,
1608 AMT_FILTER_D_FWD,
1609 AMT_ACT_STATUS_D_FWD_NEW,
1610 v6);
1611 }
1612}
1613
1614static void amt_mcast_is_ex_handler(struct amt_dev *amt,
1615 struct amt_tunnel_list *tunnel,
1616 struct amt_group_node *gnode,
1617 void *grec, void *zero_grec, bool v6)
1618{
1619 if (gnode->filter_mode == MCAST_INCLUDE) {
1620/* Router State Report Rec'd New Router State Actions
1621 * ------------ ------------ ---------------- -------
1622 * INCLUDE (A) IS_EX (B) EXCLUDE (A*B,B-A) (B-A)=0
1623 * Delete (A-B)
1624 * Group Timer=GMI
1625 */
1626 /* EXCLUDE(A*B, ) */
1627 amt_lookup_act_srcs(tunnel, gnode, grec, AMT_OPS_INT,
1628 AMT_FILTER_FWD,
1629 AMT_ACT_STATUS_FWD_NEW,
1630 v6);
1631 /* EXCLUDE(, B-A) */
1632 amt_lookup_act_srcs(tunnel, gnode, grec, AMT_OPS_SUB_REV,
1633 AMT_FILTER_FWD,
1634 AMT_ACT_STATUS_D_FWD_NEW,
1635 v6);
1636 /* (B-A)=0 */
1637 amt_lookup_act_srcs(tunnel, gnode, zero_grec, AMT_OPS_UNI,
1638 AMT_FILTER_D_FWD_NEW,
1639 AMT_ACT_GMI_ZERO,
1640 v6);
1641 /* Group Timer=GMI */
1642 if (!mod_delayed_work(amt_wq, &gnode->group_timer,
1643 msecs_to_jiffies(amt_gmi(amt))))
1644 dev_hold(amt->dev);
1645 gnode->filter_mode = MCAST_EXCLUDE;
1646 /* Delete (A-B) will be worked by amt_cleanup_srcs(). */
1647 } else {
1648/* Router State Report Rec'd New Router State Actions
1649 * ------------ ------------ ---------------- -------
1650 * EXCLUDE (X,Y) IS_EX (A) EXCLUDE (A-Y,Y*A) (A-X-Y)=GMI
1651 * Delete (X-A)
1652 * Delete (Y-A)
1653 * Group Timer=GMI
1654 */
1655 /* EXCLUDE (A-Y, ) */
1656 amt_lookup_act_srcs(tunnel, gnode, grec, AMT_OPS_SUB_REV,
1657 AMT_FILTER_D_FWD,
1658 AMT_ACT_STATUS_FWD_NEW,
1659 v6);
1660 /* EXCLUDE (, Y*A ) */
1661 amt_lookup_act_srcs(tunnel, gnode, grec, AMT_OPS_INT,
1662 AMT_FILTER_D_FWD,
1663 AMT_ACT_STATUS_D_FWD_NEW,
1664 v6);
1665 /* (A-X-Y)=GMI */
1666 amt_lookup_act_srcs(tunnel, gnode, grec, AMT_OPS_SUB_REV,
1667 AMT_FILTER_BOTH_NEW,
1668 AMT_ACT_GMI,
1669 v6);
1670 /* Group Timer=GMI */
1671 if (!mod_delayed_work(amt_wq, &gnode->group_timer,
1672 msecs_to_jiffies(amt_gmi(amt))))
1673 dev_hold(amt->dev);
1674 /* Delete (X-A), (Y-A) will be worked by amt_cleanup_srcs(). */
1675 }
1676}
1677
1678static void amt_mcast_to_in_handler(struct amt_dev *amt,
1679 struct amt_tunnel_list *tunnel,
1680 struct amt_group_node *gnode,
1681 void *grec, void *zero_grec, bool v6)
1682{
1683 if (gnode->filter_mode == MCAST_INCLUDE) {
1684/* Router State Report Rec'd New Router State Actions
1685 * ------------ ------------ ---------------- -------
1686 * INCLUDE (A) TO_IN (B) INCLUDE (A+B) (B)=GMI
1687 * Send Q(G,A-B)
1688 */
1689 /* Update TO_IN (B) sources as FWD/NEW */
1690 amt_lookup_act_srcs(tunnel, gnode, grec, AMT_OPS_UNI,
1691 AMT_FILTER_NONE_NEW,
1692 AMT_ACT_STATUS_FWD_NEW,
1693 v6);
1694 /* Update INCLUDE (A) sources as NEW */
1695 amt_lookup_act_srcs(tunnel, gnode, grec, AMT_OPS_UNI,
1696 AMT_FILTER_FWD,
1697 AMT_ACT_STATUS_FWD_NEW,
1698 v6);
1699 /* (B)=GMI */
1700 amt_lookup_act_srcs(tunnel, gnode, grec, AMT_OPS_INT,
1701 AMT_FILTER_FWD_NEW,
1702 AMT_ACT_GMI,
1703 v6);
1704 } else {
1705/* Router State Report Rec'd New Router State Actions
1706 * ------------ ------------ ---------------- -------
1707 * EXCLUDE (X,Y) TO_IN (A) EXCLUDE (X+A,Y-A) (A)=GMI
1708 * Send Q(G,X-A)
1709 * Send Q(G)
1710 */
1711 /* Update TO_IN (A) sources as FWD/NEW */
1712 amt_lookup_act_srcs(tunnel, gnode, grec, AMT_OPS_UNI,
1713 AMT_FILTER_NONE_NEW,
1714 AMT_ACT_STATUS_FWD_NEW,
1715 v6);
1716 /* Update EXCLUDE(X,) sources as FWD/NEW */
1717 amt_lookup_act_srcs(tunnel, gnode, grec, AMT_OPS_UNI,
1718 AMT_FILTER_FWD,
1719 AMT_ACT_STATUS_FWD_NEW,
1720 v6);
1721 /* EXCLUDE (, Y-A)
1722 * (A) are already switched to FWD_NEW.
1723 * So, D_FWD/OLD -> D_FWD/NEW is okay.
1724 */
1725 amt_lookup_act_srcs(tunnel, gnode, zero_grec, AMT_OPS_UNI,
1726 AMT_FILTER_D_FWD,
1727 AMT_ACT_STATUS_D_FWD_NEW,
1728 v6);
1729 /* (A)=GMI
1730 * Only FWD_NEW will have (A) sources.
1731 */
1732 amt_lookup_act_srcs(tunnel, gnode, grec, AMT_OPS_INT,
1733 AMT_FILTER_FWD_NEW,
1734 AMT_ACT_GMI,
1735 v6);
1736 }
1737}
1738
1739static void amt_mcast_to_ex_handler(struct amt_dev *amt,
1740 struct amt_tunnel_list *tunnel,
1741 struct amt_group_node *gnode,
1742 void *grec, void *zero_grec, bool v6)
1743{
1744 if (gnode->filter_mode == MCAST_INCLUDE) {
1745/* Router State Report Rec'd New Router State Actions
1746 * ------------ ------------ ---------------- -------
1747 * INCLUDE (A) TO_EX (B) EXCLUDE (A*B,B-A) (B-A)=0
1748 * Delete (A-B)
1749 * Send Q(G,A*B)
1750 * Group Timer=GMI
1751 */
1752 /* EXCLUDE (A*B, ) */
1753 amt_lookup_act_srcs(tunnel, gnode, grec, AMT_OPS_INT,
1754 AMT_FILTER_FWD,
1755 AMT_ACT_STATUS_FWD_NEW,
1756 v6);
1757 /* EXCLUDE (, B-A) */
1758 amt_lookup_act_srcs(tunnel, gnode, grec, AMT_OPS_SUB_REV,
1759 AMT_FILTER_FWD,
1760 AMT_ACT_STATUS_D_FWD_NEW,
1761 v6);
1762 /* (B-A)=0 */
1763 amt_lookup_act_srcs(tunnel, gnode, zero_grec, AMT_OPS_UNI,
1764 AMT_FILTER_D_FWD_NEW,
1765 AMT_ACT_GMI_ZERO,
1766 v6);
1767 /* Group Timer=GMI */
1768 if (!mod_delayed_work(amt_wq, &gnode->group_timer,
1769 msecs_to_jiffies(amt_gmi(amt))))
1770 dev_hold(amt->dev);
1771 gnode->filter_mode = MCAST_EXCLUDE;
1772 /* Delete (A-B) will be worked by amt_cleanup_srcs(). */
1773 } else {
1774/* Router State Report Rec'd New Router State Actions
1775 * ------------ ------------ ---------------- -------
1776 * EXCLUDE (X,Y) TO_EX (A) EXCLUDE (A-Y,Y*A) (A-X-Y)=Group Timer
1777 * Delete (X-A)
1778 * Delete (Y-A)
1779 * Send Q(G,A-Y)
1780 * Group Timer=GMI
1781 */
1782 /* Update (A-X-Y) as NONE/OLD */
1783 amt_lookup_act_srcs(tunnel, gnode, grec, AMT_OPS_SUB_REV,
1784 AMT_FILTER_BOTH,
1785 AMT_ACT_GT,
1786 v6);
1787 /* EXCLUDE (A-Y, ) */
1788 amt_lookup_act_srcs(tunnel, gnode, grec, AMT_OPS_SUB_REV,
1789 AMT_FILTER_D_FWD,
1790 AMT_ACT_STATUS_FWD_NEW,
1791 v6);
1792 /* EXCLUDE (, Y*A) */
1793 amt_lookup_act_srcs(tunnel, gnode, grec, AMT_OPS_INT,
1794 AMT_FILTER_D_FWD,
1795 AMT_ACT_STATUS_D_FWD_NEW,
1796 v6);
1797 /* Group Timer=GMI */
1798 if (!mod_delayed_work(amt_wq, &gnode->group_timer,
1799 msecs_to_jiffies(amt_gmi(amt))))
1800 dev_hold(amt->dev);
1801 /* Delete (X-A), (Y-A) will be worked by amt_cleanup_srcs(). */
1802 }
1803}
1804
1805static void amt_mcast_allow_handler(struct amt_dev *amt,
1806 struct amt_tunnel_list *tunnel,
1807 struct amt_group_node *gnode,
1808 void *grec, void *zero_grec, bool v6)
1809{
1810 if (gnode->filter_mode == MCAST_INCLUDE) {
1811/* Router State Report Rec'd New Router State Actions
1812 * ------------ ------------ ---------------- -------
1813 * INCLUDE (A) ALLOW (B) INCLUDE (A+B) (B)=GMI
1814 */
1815 /* INCLUDE (A+B) */
1816 amt_lookup_act_srcs(tunnel, gnode, grec, AMT_OPS_UNI,
1817 AMT_FILTER_FWD,
1818 AMT_ACT_STATUS_FWD_NEW,
1819 v6);
1820 /* (B)=GMI */
1821 amt_lookup_act_srcs(tunnel, gnode, grec, AMT_OPS_INT,
1822 AMT_FILTER_FWD_NEW,
1823 AMT_ACT_GMI,
1824 v6);
1825 } else {
1826/* Router State Report Rec'd New Router State Actions
1827 * ------------ ------------ ---------------- -------
1828 * EXCLUDE (X,Y) ALLOW (A) EXCLUDE (X+A,Y-A) (A)=GMI
1829 */
1830 /* EXCLUDE (X+A, ) */
1831 amt_lookup_act_srcs(tunnel, gnode, grec, AMT_OPS_UNI,
1832 AMT_FILTER_FWD,
1833 AMT_ACT_STATUS_FWD_NEW,
1834 v6);
1835 /* EXCLUDE (, Y-A) */
1836 amt_lookup_act_srcs(tunnel, gnode, grec, AMT_OPS_SUB,
1837 AMT_FILTER_D_FWD,
1838 AMT_ACT_STATUS_D_FWD_NEW,
1839 v6);
1840 /* (A)=GMI
1841 * All (A) source are now FWD/NEW status.
1842 */
1843 amt_lookup_act_srcs(tunnel, gnode, grec, AMT_OPS_INT,
1844 AMT_FILTER_FWD_NEW,
1845 AMT_ACT_GMI,
1846 v6);
1847 }
1848}
1849
1850static void amt_mcast_block_handler(struct amt_dev *amt,
1851 struct amt_tunnel_list *tunnel,
1852 struct amt_group_node *gnode,
1853 void *grec, void *zero_grec, bool v6)
1854{
1855 if (gnode->filter_mode == MCAST_INCLUDE) {
1856/* Router State Report Rec'd New Router State Actions
1857 * ------------ ------------ ---------------- -------
1858 * INCLUDE (A) BLOCK (B) INCLUDE (A) Send Q(G,A*B)
1859 */
1860 /* INCLUDE (A) */
1861 amt_lookup_act_srcs(tunnel, gnode, zero_grec, AMT_OPS_UNI,
1862 AMT_FILTER_FWD,
1863 AMT_ACT_STATUS_FWD_NEW,
1864 v6);
1865 } else {
1866/* Router State Report Rec'd New Router State Actions
1867 * ------------ ------------ ---------------- -------
1868 * EXCLUDE (X,Y) BLOCK (A) EXCLUDE (X+(A-Y),Y) (A-X-Y)=Group Timer
1869 * Send Q(G,A-Y)
1870 */
1871 /* (A-X-Y)=Group Timer */
1872 amt_lookup_act_srcs(tunnel, gnode, grec, AMT_OPS_SUB_REV,
1873 AMT_FILTER_BOTH,
1874 AMT_ACT_GT,
1875 v6);
1876 /* EXCLUDE (X, ) */
1877 amt_lookup_act_srcs(tunnel, gnode, grec, AMT_OPS_UNI,
1878 AMT_FILTER_FWD,
1879 AMT_ACT_STATUS_FWD_NEW,
1880 v6);
1881 /* EXCLUDE (X+(A-Y) */
1882 amt_lookup_act_srcs(tunnel, gnode, grec, AMT_OPS_SUB_REV,
1883 AMT_FILTER_D_FWD,
1884 AMT_ACT_STATUS_FWD_NEW,
1885 v6);
1886 /* EXCLUDE (, Y) */
1887 amt_lookup_act_srcs(tunnel, gnode, grec, AMT_OPS_UNI,
1888 AMT_FILTER_D_FWD,
1889 AMT_ACT_STATUS_D_FWD_NEW,
1890 v6);
1891 }
1892}
1893
1894/* RFC 3376
1895 * 7.3.2. In the Presence of Older Version Group Members
1896 *
1897 * When Group Compatibility Mode is IGMPv2, a router internally
1898 * translates the following IGMPv2 messages for that group to their
1899 * IGMPv3 equivalents:
1900 *
1901 * IGMPv2 Message IGMPv3 Equivalent
1902 * -------------- -----------------
1903 * Report IS_EX( {} )
1904 * Leave TO_IN( {} )
1905 */
1906static void amt_igmpv2_report_handler(struct amt_dev *amt, struct sk_buff *skb,
1907 struct amt_tunnel_list *tunnel)
1908{
1909 struct igmphdr *ih = igmp_hdr(skb);
1910 struct iphdr *iph = ip_hdr(skb);
1911 struct amt_group_node *gnode;
1912 union amt_addr group, host;
1913
1914 memset(&group, 0, sizeof(union amt_addr));
1915 group.ip4 = ih->group;
1916 memset(&host, 0, sizeof(union amt_addr));
1917 host.ip4 = iph->saddr;
1918
1919 gnode = amt_lookup_group(tunnel, &group, &host, false);
1920 if (!gnode) {
1921 gnode = amt_add_group(amt, tunnel, &group, &host, false);
1922 if (!IS_ERR(gnode)) {
1923 gnode->filter_mode = MCAST_EXCLUDE;
1924 if (!mod_delayed_work(amt_wq, &gnode->group_timer,
1925 msecs_to_jiffies(amt_gmi(amt))))
1926 dev_hold(amt->dev);
1927 }
1928 }
1929}
1930
1931/* RFC 3376
1932 * 7.3.2. In the Presence of Older Version Group Members
1933 *
1934 * When Group Compatibility Mode is IGMPv2, a router internally
1935 * translates the following IGMPv2 messages for that group to their
1936 * IGMPv3 equivalents:
1937 *
1938 * IGMPv2 Message IGMPv3 Equivalent
1939 * -------------- -----------------
1940 * Report IS_EX( {} )
1941 * Leave TO_IN( {} )
1942 */
1943static void amt_igmpv2_leave_handler(struct amt_dev *amt, struct sk_buff *skb,
1944 struct amt_tunnel_list *tunnel)
1945{
1946 struct igmphdr *ih = igmp_hdr(skb);
1947 struct iphdr *iph = ip_hdr(skb);
1948 struct amt_group_node *gnode;
1949 union amt_addr group, host;
1950
1951 memset(&group, 0, sizeof(union amt_addr));
1952 group.ip4 = ih->group;
1953 memset(&host, 0, sizeof(union amt_addr));
1954 host.ip4 = iph->saddr;
1955
1956 gnode = amt_lookup_group(tunnel, &group, &host, false);
1957 if (gnode)
1958 amt_del_group(amt, gnode);
1959}
1960
1961static void amt_igmpv3_report_handler(struct amt_dev *amt, struct sk_buff *skb,
1962 struct amt_tunnel_list *tunnel)
1963{
1964 struct igmpv3_report *ihrv3 = igmpv3_report_hdr(skb);
1965 int len = skb_transport_offset(skb) + sizeof(*ihrv3);
1966 void *zero_grec = (void *)&igmpv3_zero_grec;
1967 struct iphdr *iph = ip_hdr(skb);
1968 struct amt_group_node *gnode;
1969 union amt_addr group, host;
1970 struct igmpv3_grec *grec;
1971 u16 nsrcs;
1972 int i;
1973
1974 for (i = 0; i < ntohs(ihrv3->ngrec); i++) {
1975 len += sizeof(*grec);
1976 if (!ip_mc_may_pull(skb, len))
1977 break;
1978
1979 grec = (void *)(skb->data + len - sizeof(*grec));
1980 nsrcs = ntohs(grec->grec_nsrcs);
1981
1982 len += nsrcs * sizeof(__be32);
1983 if (!ip_mc_may_pull(skb, len))
1984 break;
1985
1986 memset(&group, 0, sizeof(union amt_addr));
1987 group.ip4 = grec->grec_mca;
1988 memset(&host, 0, sizeof(union amt_addr));
1989 host.ip4 = iph->saddr;
1990 gnode = amt_lookup_group(tunnel, &group, &host, false);
1991 if (!gnode) {
1992 gnode = amt_add_group(amt, tunnel, &group, &host,
1993 false);
1994 if (IS_ERR(gnode))
1995 continue;
1996 }
1997
1998 amt_add_srcs(amt, tunnel, gnode, grec, false);
1999 switch (grec->grec_type) {
2000 case IGMPV3_MODE_IS_INCLUDE:
2001 amt_mcast_is_in_handler(amt, tunnel, gnode, grec,
2002 zero_grec, false);
2003 break;
2004 case IGMPV3_MODE_IS_EXCLUDE:
2005 amt_mcast_is_ex_handler(amt, tunnel, gnode, grec,
2006 zero_grec, false);
2007 break;
2008 case IGMPV3_CHANGE_TO_INCLUDE:
2009 amt_mcast_to_in_handler(amt, tunnel, gnode, grec,
2010 zero_grec, false);
2011 break;
2012 case IGMPV3_CHANGE_TO_EXCLUDE:
2013 amt_mcast_to_ex_handler(amt, tunnel, gnode, grec,
2014 zero_grec, false);
2015 break;
2016 case IGMPV3_ALLOW_NEW_SOURCES:
2017 amt_mcast_allow_handler(amt, tunnel, gnode, grec,
2018 zero_grec, false);
2019 break;
2020 case IGMPV3_BLOCK_OLD_SOURCES:
2021 amt_mcast_block_handler(amt, tunnel, gnode, grec,
2022 zero_grec, false);
2023 break;
2024 default:
2025 break;
2026 }
2027 amt_cleanup_srcs(amt, tunnel, gnode);
2028 }
2029}
2030
2031/* caller held tunnel->lock */
2032static void amt_igmp_report_handler(struct amt_dev *amt, struct sk_buff *skb,
2033 struct amt_tunnel_list *tunnel)
2034{
2035 struct igmphdr *ih = igmp_hdr(skb);
2036
2037 switch (ih->type) {
2038 case IGMPV3_HOST_MEMBERSHIP_REPORT:
2039 amt_igmpv3_report_handler(amt, skb, tunnel);
2040 break;
2041 case IGMPV2_HOST_MEMBERSHIP_REPORT:
2042 amt_igmpv2_report_handler(amt, skb, tunnel);
2043 break;
2044 case IGMP_HOST_LEAVE_MESSAGE:
2045 amt_igmpv2_leave_handler(amt, skb, tunnel);
2046 break;
2047 default:
2048 break;
2049 }
2050}
2051
b75f7095
TY		 2052#if IS_ENABLED(CONFIG_IPV6)
2053/* RFC 3810
2054 * 8.3.2. In the Presence of MLDv1 Multicast Address Listeners
2055 *
2056 * When Multicast Address Compatibility Mode is MLDv2, a router acts
2057 * using the MLDv2 protocol for that multicast address. When Multicast
2058 * Address Compatibility Mode is MLDv1, a router internally translates
2059 * the following MLDv1 messages for that multicast address to their
2060 * MLDv2 equivalents:
2061 *
2062 * MLDv1 Message MLDv2 Equivalent
2063 * -------------- -----------------
2064 * Report IS_EX( {} )
2065 * Done TO_IN( {} )
2066 */
2067static void amt_mldv1_report_handler(struct amt_dev *amt, struct sk_buff *skb,
2068 struct amt_tunnel_list *tunnel)
2069{
2070 struct mld_msg *mld = (struct mld_msg *)icmp6_hdr(skb);
2071 struct ipv6hdr *ip6h = ipv6_hdr(skb);
2072 struct amt_group_node *gnode;
2073 union amt_addr group, host;
2074
2075 memcpy(&group.ip6, &mld->mld_mca, sizeof(struct in6_addr));
2076 memcpy(&host.ip6, &ip6h->saddr, sizeof(struct in6_addr));
2077
2078 gnode = amt_lookup_group(tunnel, &group, &host, true);
2079 if (!gnode) {
2080 gnode = amt_add_group(amt, tunnel, &group, &host, true);
2081 if (!IS_ERR(gnode)) {
2082 gnode->filter_mode = MCAST_EXCLUDE;
2083 if (!mod_delayed_work(amt_wq, &gnode->group_timer,
2084 msecs_to_jiffies(amt_gmi(amt))))
2085 dev_hold(amt->dev);
2086 }
2087 }
2088}
2089
2090/* RFC 3810
2091 * 8.3.2. In the Presence of MLDv1 Multicast Address Listeners
2092 *
2093 * When Multicast Address Compatibility Mode is MLDv2, a router acts
2094 * using the MLDv2 protocol for that multicast address. When Multicast
2095 * Address Compatibility Mode is MLDv1, a router internally translates
2096 * the following MLDv1 messages for that multicast address to their
2097 * MLDv2 equivalents:
2098 *
2099 * MLDv1 Message MLDv2 Equivalent
2100 * -------------- -----------------
2101 * Report IS_EX( {} )
2102 * Done TO_IN( {} )
2103 */
2104static void amt_mldv1_leave_handler(struct amt_dev *amt, struct sk_buff *skb,
2105 struct amt_tunnel_list *tunnel)
2106{
2107 struct mld_msg *mld = (struct mld_msg *)icmp6_hdr(skb);
2108 struct iphdr *iph = ip_hdr(skb);
2109 struct amt_group_node *gnode;
2110 union amt_addr group, host;
2111
2112 memcpy(&group.ip6, &mld->mld_mca, sizeof(struct in6_addr));
2113 memset(&host, 0, sizeof(union amt_addr));
2114 host.ip4 = iph->saddr;
2115
2116 gnode = amt_lookup_group(tunnel, &group, &host, true);
2117 if (gnode) {
2118 amt_del_group(amt, gnode);
2119 return;
2120 }
2121}
2122
2123static void amt_mldv2_report_handler(struct amt_dev *amt, struct sk_buff *skb,
2124 struct amt_tunnel_list *tunnel)
2125{
2126 struct mld2_report *mld2r = (struct mld2_report *)icmp6_hdr(skb);
2127 int len = skb_transport_offset(skb) + sizeof(*mld2r);
2128 void *zero_grec = (void *)&mldv2_zero_grec;
2129 struct ipv6hdr *ip6h = ipv6_hdr(skb);
2130 struct amt_group_node *gnode;
2131 union amt_addr group, host;
2132 struct mld2_grec *grec;
2133 u16 nsrcs;
2134 int i;
2135
2136 for (i = 0; i < ntohs(mld2r->mld2r_ngrec); i++) {
2137 len += sizeof(*grec);
2138 if (!ipv6_mc_may_pull(skb, len))
2139 break;
2140
2141 grec = (void *)(skb->data + len - sizeof(*grec));
2142 nsrcs = ntohs(grec->grec_nsrcs);
2143
2144 len += nsrcs * sizeof(struct in6_addr);
2145 if (!ipv6_mc_may_pull(skb, len))
2146 break;
2147
2148 memset(&group, 0, sizeof(union amt_addr));
2149 group.ip6 = grec->grec_mca;
2150 memset(&host, 0, sizeof(union amt_addr));
2151 host.ip6 = ip6h->saddr;
2152 gnode = amt_lookup_group(tunnel, &group, &host, true);
2153 if (!gnode) {
2154 gnode = amt_add_group(amt, tunnel, &group, &host,
2155 ETH_P_IPV6);
2156 if (IS_ERR(gnode))
2157 continue;
2158 }
2159
2160 amt_add_srcs(amt, tunnel, gnode, grec, true);
2161 switch (grec->grec_type) {
2162 case MLD2_MODE_IS_INCLUDE:
2163 amt_mcast_is_in_handler(amt, tunnel, gnode, grec,
2164 zero_grec, true);
2165 break;
2166 case MLD2_MODE_IS_EXCLUDE:
2167 amt_mcast_is_ex_handler(amt, tunnel, gnode, grec,
2168 zero_grec, true);
2169 break;
2170 case MLD2_CHANGE_TO_INCLUDE:
2171 amt_mcast_to_in_handler(amt, tunnel, gnode, grec,
2172 zero_grec, true);
2173 break;
2174 case MLD2_CHANGE_TO_EXCLUDE:
2175 amt_mcast_to_ex_handler(amt, tunnel, gnode, grec,
2176 zero_grec, true);
2177 break;
2178 case MLD2_ALLOW_NEW_SOURCES:
2179 amt_mcast_allow_handler(amt, tunnel, gnode, grec,
2180 zero_grec, true);
2181 break;
2182 case MLD2_BLOCK_OLD_SOURCES:
2183 amt_mcast_block_handler(amt, tunnel, gnode, grec,
2184 zero_grec, true);
2185 break;
2186 default:
2187 break;
2188 }
2189 amt_cleanup_srcs(amt, tunnel, gnode);
2190 }
2191}
2192
2193/* caller held tunnel->lock */
2194static void amt_mld_report_handler(struct amt_dev *amt, struct sk_buff *skb,
2195 struct amt_tunnel_list *tunnel)
2196{
2197 struct mld_msg *mld = (struct mld_msg *)icmp6_hdr(skb);
2198
2199 switch (mld->mld_type) {
2200 case ICMPV6_MGM_REPORT:
2201 amt_mldv1_report_handler(amt, skb, tunnel);
2202 break;
2203 case ICMPV6_MLD2_REPORT:
2204 amt_mldv2_report_handler(amt, skb, tunnel);
2205 break;
2206 case ICMPV6_MGM_REDUCTION:
2207 amt_mldv1_leave_handler(amt, skb, tunnel);
2208 break;
2209 default:
2210 break;
2211 }
2212}
2213#endif
2214
cbc21dc1
TY		 2215static bool amt_advertisement_handler(struct amt_dev *amt, struct sk_buff *skb)
2216{
2217 struct amt_header_advertisement *amta;
2218 int hdr_size;
2219
2220 hdr_size = sizeof(*amta) - sizeof(struct amt_header);
2221
2222 if (!pskb_may_pull(skb, hdr_size))
2223 return true;
2224
2225 amta = (struct amt_header_advertisement *)(udp_hdr(skb) + 1);
2226 if (!amta->ip4)
2227 return true;
2228
2229 if (amta->reserved || amta->version)
2230 return true;
2231
2232 if (ipv4_is_loopback(amta->ip4) || ipv4_is_multicast(amta->ip4) ||
2233 ipv4_is_zeronet(amta->ip4))
2234 return true;
2235
2236 amt->remote_ip = amta->ip4;
2237 netdev_dbg(amt->dev, "advertised remote ip = %pI4\n", &amt->remote_ip);
2238 mod_delayed_work(amt_wq, &amt->req_wq, 0);
2239
2240 amt_update_gw_status(amt, AMT_STATUS_RECEIVED_ADVERTISEMENT, true);
2241 return false;
2242}
2243
2244static bool amt_multicast_data_handler(struct amt_dev *amt, struct sk_buff *skb)
2245{
2246 struct amt_header_mcast_data *amtmd;
2247 int hdr_size, len, err;
2248 struct ethhdr *eth;
2249 struct iphdr *iph;
2250
2251 amtmd = (struct amt_header_mcast_data *)(udp_hdr(skb) + 1);
2252 if (amtmd->reserved || amtmd->version)
2253 return true;
2254
2255 hdr_size = sizeof(*amtmd) + sizeof(struct udphdr);
2256 if (iptunnel_pull_header(skb, hdr_size, htons(ETH_P_IP), false))
2257 return true;
2258 skb_reset_network_header(skb);
2259 skb_push(skb, sizeof(*eth));
2260 skb_reset_mac_header(skb);
2261 skb_pull(skb, sizeof(*eth));
2262 eth = eth_hdr(skb);
2263 iph = ip_hdr(skb);
2264 if (iph->version == 4) {
2265 if (!ipv4_is_multicast(iph->daddr))
2266 return true;
2267 skb->protocol = htons(ETH_P_IP);
2268 eth->h_proto = htons(ETH_P_IP);
2269 ip_eth_mc_map(iph->daddr, eth->h_dest);
b75f7095
TY		 2270#if IS_ENABLED(CONFIG_IPV6)
2271 } else if (iph->version == 6) {
2272 struct ipv6hdr *ip6h;
2273
2274 ip6h = ipv6_hdr(skb);
2275 if (!ipv6_addr_is_multicast(&ip6h->daddr))
2276 return true;
2277 skb->protocol = htons(ETH_P_IPV6);
2278 eth->h_proto = htons(ETH_P_IPV6);
2279 ipv6_eth_mc_map(&ip6h->daddr, eth->h_dest);
2280#endif
cbc21dc1
TY		 2281 } else {
2282 return true;
2283 }
2284
2285 skb->pkt_type = PACKET_MULTICAST;
2286 skb->ip_summed = CHECKSUM_NONE;
2287 len = skb->len;
2288 err = gro_cells_receive(&amt->gro_cells, skb);
2289 if (likely(err == NET_RX_SUCCESS))
2290 dev_sw_netstats_rx_add(amt->dev, len);
2291 else
2292 amt->dev->stats.rx_dropped++;
2293
2294 return false;
2295}
2296
2297static bool amt_membership_query_handler(struct amt_dev *amt,
2298 struct sk_buff *skb)
2299{
2300 struct amt_header_membership_query *amtmq;
2301 struct igmpv3_query *ihv3;
2302 struct ethhdr *eth, *oeth;
2303 struct iphdr *iph;
2304 int hdr_size, len;
2305
2306 hdr_size = sizeof(*amtmq) - sizeof(struct amt_header);
2307
2308 if (!pskb_may_pull(skb, hdr_size))
2309 return true;
2310
2311 amtmq = (struct amt_header_membership_query *)(udp_hdr(skb) + 1);
2312 if (amtmq->reserved || amtmq->version)
2313 return true;
2314
2315 hdr_size = sizeof(*amtmq) + sizeof(struct udphdr) - sizeof(*eth);
2316 if (iptunnel_pull_header(skb, hdr_size, htons(ETH_P_TEB), false))
2317 return true;
2318 oeth = eth_hdr(skb);
2319 skb_reset_mac_header(skb);
2320 skb_pull(skb, sizeof(*eth));
2321 skb_reset_network_header(skb);
2322 eth = eth_hdr(skb);
2323 iph = ip_hdr(skb);
2324 if (iph->version == 4) {
2325 if (!ipv4_is_multicast(iph->daddr))
2326 return true;
2327 if (!pskb_may_pull(skb, sizeof(*iph) + AMT_IPHDR_OPTS +
2328 sizeof(*ihv3)))
2329 return true;
2330
2331 ihv3 = skb_pull(skb, sizeof(*iph) + AMT_IPHDR_OPTS);
2332 skb_reset_transport_header(skb);
2333 skb_push(skb, sizeof(*iph) + AMT_IPHDR_OPTS);
2334 spin_lock_bh(&amt->lock);
2335 amt->ready4 = true;
2336 amt->mac = amtmq->response_mac;
2337 amt->req_cnt = 0;
2338 amt->qi = ihv3->qqic;
2339 spin_unlock_bh(&amt->lock);
2340 skb->protocol = htons(ETH_P_IP);
2341 eth->h_proto = htons(ETH_P_IP);
2342 ip_eth_mc_map(iph->daddr, eth->h_dest);
b75f7095
TY		 2343#if IS_ENABLED(CONFIG_IPV6)
2344 } else if (iph->version == 6) {
2345 struct ipv6hdr *ip6h = ipv6_hdr(skb);
2346 struct mld2_query *mld2q;
2347
2348 if (!ipv6_addr_is_multicast(&ip6h->daddr))
2349 return true;
2350 if (!pskb_may_pull(skb, sizeof(*ip6h) + AMT_IP6HDR_OPTS +
2351 sizeof(*mld2q)))
2352 return true;
2353
2354 mld2q = skb_pull(skb, sizeof(*ip6h) + AMT_IP6HDR_OPTS);
2355 skb_reset_transport_header(skb);
2356 skb_push(skb, sizeof(*ip6h) + AMT_IP6HDR_OPTS);
2357 spin_lock_bh(&amt->lock);
2358 amt->ready6 = true;
2359 amt->mac = amtmq->response_mac;
2360 amt->req_cnt = 0;
2361 amt->qi = mld2q->mld2q_qqic;
2362 spin_unlock_bh(&amt->lock);
2363 skb->protocol = htons(ETH_P_IPV6);
2364 eth->h_proto = htons(ETH_P_IPV6);
2365 ipv6_eth_mc_map(&ip6h->daddr, eth->h_dest);
2366#endif
cbc21dc1
TY		 2367 } else {
2368 return true;
2369 }
2370
2371 ether_addr_copy(eth->h_source, oeth->h_source);
2372 skb->pkt_type = PACKET_MULTICAST;
2373 skb->ip_summed = CHECKSUM_NONE;
2374 len = skb->len;
2375 if (netif_rx(skb) == NET_RX_SUCCESS) {
2376 amt_update_gw_status(amt, AMT_STATUS_RECEIVED_QUERY, true);
2377 dev_sw_netstats_rx_add(amt->dev, len);
2378 } else {
2379 amt->dev->stats.rx_dropped++;
2380 }
2381
2382 return false;
2383}
2384
2385static bool amt_update_handler(struct amt_dev *amt, struct sk_buff *skb)
2386{
2387 struct amt_header_membership_update *amtmu;
2388 struct amt_tunnel_list *tunnel;
2389 struct udphdr *udph;
2390 struct ethhdr *eth;
2391 struct iphdr *iph;
2392 int len;
2393
2394 iph = ip_hdr(skb);
2395 udph = udp_hdr(skb);
2396
2397 if (__iptunnel_pull_header(skb, sizeof(*udph), skb->protocol,
2398 false, false))
2399 return true;
2400
2401 amtmu = (struct amt_header_membership_update *)skb->data;
2402 if (amtmu->reserved || amtmu->version)
2403 return true;
2404
2405 skb_pull(skb, sizeof(*amtmu));
2406 skb_reset_network_header(skb);
2407
2408 list_for_each_entry_rcu(tunnel, &amt->tunnel_list, list) {
2409 if (tunnel->ip4 == iph->saddr) {
2410 if ((amtmu->nonce == tunnel->nonce &&
2411 amtmu->response_mac == tunnel->mac)) {
2412 mod_delayed_work(amt_wq, &tunnel->gc_wq,
2413 msecs_to_jiffies(amt_gmi(amt))
2414 * 3);
2415 goto report;
2416 } else {
2417 netdev_dbg(amt->dev, "Invalid MAC\n");
2418 return true;
2419 }
2420 }
2421 }
2422
2423 return false;
2424
2425report:
2426 iph = ip_hdr(skb);
2427 if (iph->version == 4) {
2428 if (ip_mc_check_igmp(skb)) {
2429 netdev_dbg(amt->dev, "Invalid IGMP\n");
2430 return true;
2431 }
2432
bc54e49c
TY		 2433 spin_lock_bh(&tunnel->lock);
2434 amt_igmp_report_handler(amt, skb, tunnel);
2435 spin_unlock_bh(&tunnel->lock);
2436
cbc21dc1
TY		 2437 skb_push(skb, sizeof(struct ethhdr));
2438 skb_reset_mac_header(skb);
2439 eth = eth_hdr(skb);
2440 skb->protocol = htons(ETH_P_IP);
2441 eth->h_proto = htons(ETH_P_IP);
2442 ip_eth_mc_map(iph->daddr, eth->h_dest);
b75f7095
TY		 2443#if IS_ENABLED(CONFIG_IPV6)
2444 } else if (iph->version == 6) {
2445 struct ipv6hdr *ip6h = ipv6_hdr(skb);
2446
2447 if (ipv6_mc_check_mld(skb)) {
2448 netdev_dbg(amt->dev, "Invalid MLD\n");
2449 return true;
2450 }
2451
2452 spin_lock_bh(&tunnel->lock);
2453 amt_mld_report_handler(amt, skb, tunnel);
2454 spin_unlock_bh(&tunnel->lock);
2455
2456 skb_push(skb, sizeof(struct ethhdr));
2457 skb_reset_mac_header(skb);
2458 eth = eth_hdr(skb);
2459 skb->protocol = htons(ETH_P_IPV6);
2460 eth->h_proto = htons(ETH_P_IPV6);
2461 ipv6_eth_mc_map(&ip6h->daddr, eth->h_dest);
2462#endif
cbc21dc1
TY		 2463 } else {
2464 netdev_dbg(amt->dev, "Unsupported Protocol\n");
2465 return true;
2466 }
2467
2468 skb_pull(skb, sizeof(struct ethhdr));
2469 skb->pkt_type = PACKET_MULTICAST;
2470 skb->ip_summed = CHECKSUM_NONE;
2471 len = skb->len;
2472 if (netif_rx(skb) == NET_RX_SUCCESS) {
2473 amt_update_relay_status(tunnel, AMT_STATUS_RECEIVED_UPDATE,
2474 true);
2475 dev_sw_netstats_rx_add(amt->dev, len);
2476 } else {
2477 amt->dev->stats.rx_dropped++;
2478 }
2479
2480 return false;
2481}
2482
2483static void amt_send_advertisement(struct amt_dev *amt, __be32 nonce,
2484 __be32 daddr, __be16 dport)
2485{
2486 struct amt_header_advertisement *amta;
2487 int hlen, tlen, offset;
2488 struct socket *sock;
2489 struct udphdr *udph;
2490 struct sk_buff *skb;
2491 struct iphdr *iph;
2492 struct rtable *rt;
2493 struct flowi4 fl4;
2494 u32 len;
2495 int err;
2496
2497 rcu_read_lock();
2498 sock = rcu_dereference(amt->sock);
2499 if (!sock)
2500 goto out;
2501
2502 if (!netif_running(amt->stream_dev) || !netif_running(amt->dev))
2503 goto out;
2504
2505 rt = ip_route_output_ports(amt->net, &fl4, sock->sk,
2506 daddr, amt->local_ip,
2507 dport, amt->relay_port,
2508 IPPROTO_UDP, 0,
2509 amt->stream_dev->ifindex);
2510 if (IS_ERR(rt)) {
2511 amt->dev->stats.tx_errors++;
2512 goto out;
2513 }
2514
2515 hlen = LL_RESERVED_SPACE(amt->dev);
2516 tlen = amt->dev->needed_tailroom;
2517 len = hlen + tlen + sizeof(*iph) + sizeof(*udph) + sizeof(*amta);
2518 skb = netdev_alloc_skb_ip_align(amt->dev, len);
2519 if (!skb) {
2520 ip_rt_put(rt);
2521 amt->dev->stats.tx_errors++;
2522 goto out;
2523 }
2524
2525 skb->priority = TC_PRIO_CONTROL;
2526 skb_dst_set(skb, &rt->dst);
2527
2528 len = sizeof(*iph) + sizeof(*udph) + sizeof(*amta);
2529 skb_reset_network_header(skb);
2530 skb_put(skb, len);
2531 amta = skb_pull(skb, sizeof(*iph) + sizeof(*udph));
2532 amta->version = 0;
2533 amta->type = AMT_MSG_ADVERTISEMENT;
2534 amta->reserved = 0;
2535 amta->nonce = nonce;
2536 amta->ip4 = amt->local_ip;
2537 skb_push(skb, sizeof(*udph));
2538 skb_reset_transport_header(skb);
2539 udph = udp_hdr(skb);
2540 udph->source = amt->relay_port;
2541 udph->dest = dport;
2542 udph->len = htons(sizeof(*amta) + sizeof(*udph));
2543 udph->check = 0;
2544 offset = skb_transport_offset(skb);
2545 skb->csum = skb_checksum(skb, offset, skb->len - offset, 0);
2546 udph->check = csum_tcpudp_magic(amt->local_ip, daddr,
2547 sizeof(*udph) + sizeof(*amta),
2548 IPPROTO_UDP, skb->csum);
2549
2550 skb_push(skb, sizeof(*iph));
2551 iph = ip_hdr(skb);
2552 iph->version = 4;
2553 iph->ihl = (sizeof(struct iphdr)) >> 2;
2554 iph->tos = AMT_TOS;
2555 iph->frag_off = 0;
2556 iph->ttl = ip4_dst_hoplimit(&rt->dst);
2557 iph->daddr = daddr;
2558 iph->saddr = amt->local_ip;
2559 iph->protocol = IPPROTO_UDP;
2560 iph->tot_len = htons(len);
2561
2562 skb->ip_summed = CHECKSUM_NONE;
2563 ip_select_ident(amt->net, skb, NULL);
2564 ip_send_check(iph);
2565 err = ip_local_out(amt->net, sock->sk, skb);
2566 if (unlikely(net_xmit_eval(err)))
2567 amt->dev->stats.tx_errors++;
2568
2569out:
2570 rcu_read_unlock();
2571}
2572
2573static bool amt_discovery_handler(struct amt_dev *amt, struct sk_buff *skb)
2574{
2575 struct amt_header_discovery *amtd;
2576 struct udphdr *udph;
2577 struct iphdr *iph;
2578
2579 if (!pskb_may_pull(skb, sizeof(*udph) + sizeof(*amtd)))
2580 return true;
2581
2582 iph = ip_hdr(skb);
2583 udph = udp_hdr(skb);
2584 amtd = (struct amt_header_discovery *)(udp_hdr(skb) + 1);
2585
2586 if (amtd->reserved || amtd->version)
2587 return true;
2588
2589 amt_send_advertisement(amt, amtd->nonce, iph->saddr, udph->source);
2590
2591 return false;
2592}
2593
2594static bool amt_request_handler(struct amt_dev *amt, struct sk_buff *skb)
2595{
2596 struct amt_header_request *amtrh;
2597 struct amt_tunnel_list *tunnel;
2598 unsigned long long key;
2599 struct udphdr *udph;
2600 struct iphdr *iph;
2601 u64 mac;
2602 int i;
2603
2604 if (!pskb_may_pull(skb, sizeof(*udph) + sizeof(*amtrh)))
2605 return true;
2606
2607 iph = ip_hdr(skb);
2608 udph = udp_hdr(skb);
2609 amtrh = (struct amt_header_request *)(udp_hdr(skb) + 1);
2610
2611 if (amtrh->reserved1 || amtrh->reserved2 || amtrh->version)
2612 return true;
2613
2614 list_for_each_entry_rcu(tunnel, &amt->tunnel_list, list)
2615 if (tunnel->ip4 == iph->saddr)
2616 goto send;
2617
2618 if (amt->nr_tunnels >= amt->max_tunnels) {
2619 icmp_ndo_send(skb, ICMP_DEST_UNREACH, ICMP_HOST_UNREACH, 0);
2620 return true;
2621 }
2622
2623 tunnel = kzalloc(sizeof(*tunnel) +
2624 (sizeof(struct hlist_head) * amt->hash_buckets),
2625 GFP_ATOMIC);
2626 if (!tunnel)
2627 return true;
2628
2629 tunnel->source_port = udph->source;
2630 tunnel->ip4 = iph->saddr;
2631
2632 memcpy(&key, &tunnel->key, sizeof(unsigned long long));
2633 tunnel->amt = amt;
2634 spin_lock_init(&tunnel->lock);
2635 for (i = 0; i < amt->hash_buckets; i++)
2636 INIT_HLIST_HEAD(&tunnel->groups[i]);
2637
2638 INIT_DELAYED_WORK(&tunnel->gc_wq, amt_tunnel_expire);
2639
2640 spin_lock_bh(&amt->lock);
2641 list_add_tail_rcu(&tunnel->list, &amt->tunnel_list);
2642 tunnel->key = amt->key;
2643 amt_update_relay_status(tunnel, AMT_STATUS_RECEIVED_REQUEST, true);
2644 amt->nr_tunnels++;
2645 mod_delayed_work(amt_wq, &tunnel->gc_wq,
2646 msecs_to_jiffies(amt_gmi(amt)));
2647 spin_unlock_bh(&amt->lock);
2648
2649send:
2650 tunnel->nonce = amtrh->nonce;
2651 mac = siphash_3u32((__force u32)tunnel->ip4,
2652 (__force u32)tunnel->source_port,
2653 (__force u32)tunnel->nonce,
2654 &tunnel->key);
2655 tunnel->mac = mac >> 16;
2656
2657 if (!netif_running(amt->dev) || !netif_running(amt->stream_dev))
2658 return true;
2659
2660 if (!amtrh->p)
2661 amt_send_igmp_gq(amt, tunnel);
b75f7095
TY		 2662 else
2663 amt_send_mld_gq(amt, tunnel);
cbc21dc1
TY		 2664
2665 return false;
2666}
2667
2668static int amt_rcv(struct sock *sk, struct sk_buff *skb)
2669{
2670 struct amt_dev *amt;
2671 struct iphdr *iph;
2672 int type;
2673 bool err;
2674
2675 rcu_read_lock_bh();
2676 amt = rcu_dereference_sk_user_data(sk);
2677 if (!amt) {
2678 err = true;
2679 goto out;
2680 }
2681
2682 skb->dev = amt->dev;
2683 iph = ip_hdr(skb);
2684 type = amt_parse_type(skb);
2685 if (type == -1) {
2686 err = true;
2687 goto drop;
2688 }
2689
2690 if (amt->mode == AMT_MODE_GATEWAY) {
2691 switch (type) {
2692 case AMT_MSG_ADVERTISEMENT:
2693 if (iph->saddr != amt->discovery_ip) {
2694 netdev_dbg(amt->dev, "Invalid Relay IP\n");
2695 err = true;
2696 goto drop;
2697 }
2698 if (amt_advertisement_handler(amt, skb))
2699 amt->dev->stats.rx_dropped++;
2700 goto out;
2701 case AMT_MSG_MULTICAST_DATA:
2702 if (iph->saddr != amt->remote_ip) {
2703 netdev_dbg(amt->dev, "Invalid Relay IP\n");
2704 err = true;
2705 goto drop;
2706 }
2707 err = amt_multicast_data_handler(amt, skb);
2708 if (err)
2709 goto drop;
2710 else
2711 goto out;
2712 case AMT_MSG_MEMBERSHIP_QUERY:
2713 if (iph->saddr != amt->remote_ip) {
2714 netdev_dbg(amt->dev, "Invalid Relay IP\n");
2715 err = true;
2716 goto drop;
2717 }
2718 err = amt_membership_query_handler(amt, skb);
2719 if (err)
2720 goto drop;
2721 else
2722 goto out;
2723 default:
2724 err = true;
2725 netdev_dbg(amt->dev, "Invalid type of Gateway\n");
2726 break;
2727 }
2728 } else {
2729 switch (type) {
2730 case AMT_MSG_DISCOVERY:
2731 err = amt_discovery_handler(amt, skb);
2732 break;
2733 case AMT_MSG_REQUEST:
2734 err = amt_request_handler(amt, skb);
2735 break;
2736 case AMT_MSG_MEMBERSHIP_UPDATE:
2737 err = amt_update_handler(amt, skb);
2738 if (err)
2739 goto drop;
2740 else
2741 goto out;
2742 default:
2743 err = true;
2744 netdev_dbg(amt->dev, "Invalid type of relay\n");
2745 break;
2746 }
2747 }
2748drop:
2749 if (err) {
2750 amt->dev->stats.rx_dropped++;
2751 kfree_skb(skb);
2752 } else {
2753 consume_skb(skb);
2754 }
2755out:
2756 rcu_read_unlock_bh();
2757 return 0;
2758}
2759
2760static int amt_err_lookup(struct sock *sk, struct sk_buff *skb)
2761{
2762 struct amt_dev *amt;
2763 int type;
2764
2765 rcu_read_lock_bh();
2766 amt = rcu_dereference_sk_user_data(sk);
2767 if (!amt)
3f81c579 2768 goto out;
cbc21dc1
TY		 2769
2770 if (amt->mode != AMT_MODE_GATEWAY)
2771 goto drop;
2772
2773 type = amt_parse_type(skb);
2774 if (type == -1)
2775 goto drop;
2776
2777 netdev_dbg(amt->dev, "Received IGMP Unreachable of %s\n",
2778 type_str[type]);
2779 switch (type) {
2780 case AMT_MSG_DISCOVERY:
2781 break;
2782 case AMT_MSG_REQUEST:
2783 case AMT_MSG_MEMBERSHIP_UPDATE:
2784 if (amt->status >= AMT_STATUS_RECEIVED_ADVERTISEMENT)
2785 mod_delayed_work(amt_wq, &amt->req_wq, 0);
2786 break;
2787 default:
2788 goto drop;
2789 }
3f81c579 2790out:
cbc21dc1
TY		 2791 rcu_read_unlock_bh();
2792 return 0;
2793drop:
2794 rcu_read_unlock_bh();
2795 amt->dev->stats.rx_dropped++;
2796 return 0;
2797}
2798
b9022b53
TY		 2799static struct socket *amt_create_sock(struct net *net, __be16 port)
2800{
2801 struct udp_port_cfg udp_conf;
2802 struct socket *sock;
2803 int err;
2804
2805 memset(&udp_conf, 0, sizeof(udp_conf));
2806 udp_conf.family = AF_INET;
2807 udp_conf.local_ip.s_addr = htonl(INADDR_ANY);
2808
2809 udp_conf.local_udp_port = port;
2810
2811 err = udp_sock_create(net, &udp_conf, &sock);
2812 if (err < 0)
2813 return ERR_PTR(err);
2814
2815 return sock;
2816}
2817
2818static int amt_socket_create(struct amt_dev *amt)
2819{
2820 struct udp_tunnel_sock_cfg tunnel_cfg;
2821 struct socket *sock;
2822
2823 sock = amt_create_sock(amt->net, amt->relay_port);
2824 if (IS_ERR(sock))
2825 return PTR_ERR(sock);
2826
2827 /* Mark socket as an encapsulation socket */
2828 memset(&tunnel_cfg, 0, sizeof(tunnel_cfg));
2829 tunnel_cfg.sk_user_data = amt;
2830 tunnel_cfg.encap_type = 1;
cbc21dc1
TY		 2831 tunnel_cfg.encap_rcv = amt_rcv;
2832 tunnel_cfg.encap_err_lookup = amt_err_lookup;
b9022b53
TY		 2833 tunnel_cfg.encap_destroy = NULL;
2834 setup_udp_tunnel_sock(amt->net, sock, &tunnel_cfg);
2835
2836 rcu_assign_pointer(amt->sock, sock);
2837 return 0;
2838}
2839
2840static int amt_dev_open(struct net_device *dev)
2841{
2842 struct amt_dev *amt = netdev_priv(dev);
2843 int err;
2844
2845 amt->ready4 = false;
2846 amt->ready6 = false;
2847
2848 err = amt_socket_create(amt);
2849 if (err)
2850 return err;
2851
2852 amt->req_cnt = 0;
2853 amt->remote_ip = 0;
2854 get_random_bytes(&amt->key, sizeof(siphash_key_t));
2855
2856 amt->status = AMT_STATUS_INIT;
cbc21dc1
TY		 2857 if (amt->mode == AMT_MODE_GATEWAY) {
2858 mod_delayed_work(amt_wq, &amt->discovery_wq, 0);
2859 mod_delayed_work(amt_wq, &amt->req_wq, 0);
2860 } else if (amt->mode == AMT_MODE_RELAY) {
2861 mod_delayed_work(amt_wq, &amt->secret_wq,
2862 msecs_to_jiffies(AMT_SECRET_TIMEOUT));
2863 }
b9022b53
TY		 2864 return err;
2865}
2866
2867static int amt_dev_stop(struct net_device *dev)
2868{
2869 struct amt_dev *amt = netdev_priv(dev);
cbc21dc1 2870 struct amt_tunnel_list *tunnel, *tmp;
b9022b53
TY		 2871 struct socket *sock;
2872
cbc21dc1
TY		 2873 cancel_delayed_work_sync(&amt->req_wq);
2874 cancel_delayed_work_sync(&amt->discovery_wq);
2875 cancel_delayed_work_sync(&amt->secret_wq);
2876
b9022b53
TY		 2877 /* shutdown */
2878 sock = rtnl_dereference(amt->sock);
2879 RCU_INIT_POINTER(amt->sock, NULL);
2880 synchronize_net();
2881 if (sock)
2882 udp_tunnel_sock_release(sock);
2883
2884 amt->ready4 = false;
2885 amt->ready6 = false;
2886 amt->req_cnt = 0;
2887 amt->remote_ip = 0;
2888
cbc21dc1
TY		 2889 list_for_each_entry_safe(tunnel, tmp, &amt->tunnel_list, list) {
2890 list_del_rcu(&tunnel->list);
2891 amt->nr_tunnels--;
2892 cancel_delayed_work_sync(&tunnel->gc_wq);
bc54e49c 2893 amt_clear_groups(tunnel);
cbc21dc1
TY		 2894 kfree_rcu(tunnel, rcu);
2895 }
2896
b9022b53
TY		 2897 return 0;
2898}
2899
2900static const struct device_type amt_type = {
2901 .name = "amt",
2902};
2903
2904static int amt_dev_init(struct net_device *dev)
2905{
2906 struct amt_dev *amt = netdev_priv(dev);
2907 int err;
2908
2909 amt->dev = dev;
2910 dev->tstats = netdev_alloc_pcpu_stats(struct pcpu_sw_netstats);
2911 if (!dev->tstats)
2912 return -ENOMEM;
2913
2914 err = gro_cells_init(&amt->gro_cells, dev);
2915 if (err) {
2916 free_percpu(dev->tstats);
2917 return err;
2918 }
2919
2920 return 0;
2921}
2922
2923static void amt_dev_uninit(struct net_device *dev)
2924{
2925 struct amt_dev *amt = netdev_priv(dev);
2926
2927 gro_cells_destroy(&amt->gro_cells);
2928 free_percpu(dev->tstats);
2929}
2930
2931static const struct net_device_ops amt_netdev_ops = {
2932 .ndo_init = amt_dev_init,
2933 .ndo_uninit = amt_dev_uninit,
2934 .ndo_open = amt_dev_open,
2935 .ndo_stop = amt_dev_stop,
cbc21dc1 2936 .ndo_start_xmit = amt_dev_xmit,
b9022b53
TY		 2937 .ndo_get_stats64 = dev_get_tstats64,
2938};
2939
2940static void amt_link_setup(struct net_device *dev)
2941{
2942 dev->netdev_ops = &amt_netdev_ops;
2943 dev->needs_free_netdev = true;
2944 SET_NETDEV_DEVTYPE(dev, &amt_type);
2945 dev->min_mtu = ETH_MIN_MTU;
2946 dev->max_mtu = ETH_MAX_MTU;
2947 dev->type = ARPHRD_NONE;
2948 dev->flags = IFF_POINTOPOINT | IFF_NOARP | IFF_MULTICAST;
2949 dev->hard_header_len = 0;
2950 dev->addr_len = 0;
2951 dev->priv_flags |= IFF_NO_QUEUE;
2952 dev->features |= NETIF_F_LLTX;
2953 dev->features |= NETIF_F_GSO_SOFTWARE;
2954 dev->features |= NETIF_F_NETNS_LOCAL;
2955 dev->hw_features |= NETIF_F_SG | NETIF_F_HW_CSUM;
2956 dev->hw_features |= NETIF_F_FRAGLIST | NETIF_F_RXCSUM;
2957 dev->hw_features |= NETIF_F_GSO_SOFTWARE;
2958 eth_hw_addr_random(dev);
2959 eth_zero_addr(dev->broadcast);
2960 ether_setup(dev);
2961}
2962
2963static const struct nla_policy amt_policy[IFLA_AMT_MAX + 1] = {
2964 [IFLA_AMT_MODE] = { .type = NLA_U32 },
2965 [IFLA_AMT_RELAY_PORT] = { .type = NLA_U16 },
2966 [IFLA_AMT_GATEWAY_PORT] = { .type = NLA_U16 },
2967 [IFLA_AMT_LINK] = { .type = NLA_U32 },
2968 [IFLA_AMT_LOCAL_IP] = { .len = sizeof_field(struct iphdr, daddr) },
2969 [IFLA_AMT_REMOTE_IP] = { .len = sizeof_field(struct iphdr, daddr) },
2970 [IFLA_AMT_DISCOVERY_IP] = { .len = sizeof_field(struct iphdr, daddr) },
2971 [IFLA_AMT_MAX_TUNNELS] = { .type = NLA_U32 },
2972};
2973
2974static int amt_validate(struct nlattr *tb[], struct nlattr *data[],
2975 struct netlink_ext_ack *extack)
2976{
2977 if (!data)
2978 return -EINVAL;
2979
2980 if (!data[IFLA_AMT_LINK]) {
2981 NL_SET_ERR_MSG_ATTR(extack, data[IFLA_AMT_LINK],
2982 "Link attribute is required");
2983 return -EINVAL;
2984 }
2985
2986 if (!data[IFLA_AMT_MODE]) {
2987 NL_SET_ERR_MSG_ATTR(extack, data[IFLA_AMT_MODE],
2988 "Mode attribute is required");
2989 return -EINVAL;
2990 }
2991
2992 if (nla_get_u32(data[IFLA_AMT_MODE]) > AMT_MODE_MAX) {
2993 NL_SET_ERR_MSG_ATTR(extack, data[IFLA_AMT_MODE],
2994 "Mode attribute is not valid");
2995 return -EINVAL;
2996 }
2997
2998 if (!data[IFLA_AMT_LOCAL_IP]) {
2999 NL_SET_ERR_MSG_ATTR(extack, data[IFLA_AMT_DISCOVERY_IP],
3000 "Local attribute is required");
3001 return -EINVAL;
3002 }
3003
3004 if (!data[IFLA_AMT_DISCOVERY_IP] &&
3005 nla_get_u32(data[IFLA_AMT_MODE]) == AMT_MODE_GATEWAY) {
3006 NL_SET_ERR_MSG_ATTR(extack, data[IFLA_AMT_LOCAL_IP],
3007 "Discovery attribute is required");
3008 return -EINVAL;
3009 }
3010
3011 return 0;
3012}
3013
3014static int amt_newlink(struct net *net, struct net_device *dev,
3015 struct nlattr *tb[], struct nlattr *data[],
3016 struct netlink_ext_ack *extack)
3017{
3018 struct amt_dev *amt = netdev_priv(dev);
3019 int err = -EINVAL;
3020
3021 amt->net = net;
3022 amt->mode = nla_get_u32(data[IFLA_AMT_MODE]);
3023
cbc21dc1
TY		 3024 if (data[IFLA_AMT_MAX_TUNNELS] &&
3025 nla_get_u32(data[IFLA_AMT_MAX_TUNNELS]))
b9022b53
TY		 3026 amt->max_tunnels = nla_get_u32(data[IFLA_AMT_MAX_TUNNELS]);
3027 else
3028 amt->max_tunnels = AMT_MAX_TUNNELS;
3029
3030 spin_lock_init(&amt->lock);
3031 amt->max_groups = AMT_MAX_GROUP;
3032 amt->max_sources = AMT_MAX_SOURCE;
3033 amt->hash_buckets = AMT_HSIZE;
3034 amt->nr_tunnels = 0;
3035 get_random_bytes(&amt->hash_seed, sizeof(amt->hash_seed));
3036 amt->stream_dev = dev_get_by_index(net,
3037 nla_get_u32(data[IFLA_AMT_LINK]));
3038 if (!amt->stream_dev) {
3039 NL_SET_ERR_MSG_ATTR(extack, tb[IFLA_AMT_LINK],
3040 "Can't find stream device");
3041 return -ENODEV;
3042 }
3043
3044 if (amt->stream_dev->type != ARPHRD_ETHER) {
3045 NL_SET_ERR_MSG_ATTR(extack, tb[IFLA_AMT_LINK],
3046 "Invalid stream device type");
3047 goto err;
3048 }
3049
3050 amt->local_ip = nla_get_in_addr(data[IFLA_AMT_LOCAL_IP]);
3051 if (ipv4_is_loopback(amt->local_ip) ||
3052 ipv4_is_zeronet(amt->local_ip) ||
3053 ipv4_is_multicast(amt->local_ip)) {
3054 NL_SET_ERR_MSG_ATTR(extack, tb[IFLA_AMT_LOCAL_IP],
3055 "Invalid Local address");
3056 goto err;
3057 }
3058
3059 if (data[IFLA_AMT_RELAY_PORT])
3060 amt->relay_port = nla_get_be16(data[IFLA_AMT_RELAY_PORT]);
3061 else
3062 amt->relay_port = htons(IANA_AMT_UDP_PORT);
3063
3064 if (data[IFLA_AMT_GATEWAY_PORT])
3065 amt->gw_port = nla_get_be16(data[IFLA_AMT_GATEWAY_PORT]);
3066 else
3067 amt->gw_port = htons(IANA_AMT_UDP_PORT);
3068
3069 if (!amt->relay_port) {
3070 NL_SET_ERR_MSG_ATTR(extack, tb[IFLA_AMT_DISCOVERY_IP],
3071 "relay port must not be 0");
3072 goto err;
3073 }
3074 if (amt->mode == AMT_MODE_RELAY) {
3075 amt->qrv = amt->net->ipv4.sysctl_igmp_qrv;
3076 amt->qri = 10;
3077 dev->needed_headroom = amt->stream_dev->needed_headroom +
3078 AMT_RELAY_HLEN;
3079 dev->mtu = amt->stream_dev->mtu - AMT_RELAY_HLEN;
3080 dev->max_mtu = dev->mtu;
3081 dev->min_mtu = ETH_MIN_MTU + AMT_RELAY_HLEN;
3082 } else {
3083 if (!data[IFLA_AMT_DISCOVERY_IP]) {
3084 NL_SET_ERR_MSG_ATTR(extack, tb[IFLA_AMT_DISCOVERY_IP],
3085 "discovery must be set in gateway mode");
3086 goto err;
3087 }
3088 if (!amt->gw_port) {
3089 NL_SET_ERR_MSG_ATTR(extack, tb[IFLA_AMT_DISCOVERY_IP],
3090 "gateway port must not be 0");
3091 goto err;
3092 }
3093 amt->remote_ip = 0;
3094 amt->discovery_ip = nla_get_in_addr(data[IFLA_AMT_DISCOVERY_IP]);
3095 if (ipv4_is_loopback(amt->discovery_ip) ||
3096 ipv4_is_zeronet(amt->discovery_ip) ||
3097 ipv4_is_multicast(amt->discovery_ip)) {
3098 NL_SET_ERR_MSG_ATTR(extack, tb[IFLA_AMT_DISCOVERY_IP],
3099 "discovery must be unicast");
3100 goto err;
3101 }
3102
3103 dev->needed_headroom = amt->stream_dev->needed_headroom +
3104 AMT_GW_HLEN;
3105 dev->mtu = amt->stream_dev->mtu - AMT_GW_HLEN;
3106 dev->max_mtu = dev->mtu;
3107 dev->min_mtu = ETH_MIN_MTU + AMT_GW_HLEN;
3108 }
3109 amt->qi = AMT_INIT_QUERY_INTERVAL;
3110
3111 err = register_netdevice(dev);
3112 if (err < 0) {
3113 netdev_dbg(dev, "failed to register new netdev %d\n", err);
3114 goto err;
3115 }
3116
3117 err = netdev_upper_dev_link(amt->stream_dev, dev, extack);
3118 if (err < 0) {
3119 unregister_netdevice(dev);
3120 goto err;
3121 }
3122
cbc21dc1
TY		 3123 INIT_DELAYED_WORK(&amt->discovery_wq, amt_discovery_work);
3124 INIT_DELAYED_WORK(&amt->req_wq, amt_req_work);
3125 INIT_DELAYED_WORK(&amt->secret_wq, amt_secret_work);
3126 INIT_LIST_HEAD(&amt->tunnel_list);
3127
b9022b53
TY		 3128 return 0;
3129err:
3130 dev_put(amt->stream_dev);
3131 return err;
3132}
3133
3134static void amt_dellink(struct net_device *dev, struct list_head *head)
3135{
3136 struct amt_dev *amt = netdev_priv(dev);
3137
3138 unregister_netdevice_queue(dev, head);
3139 netdev_upper_dev_unlink(amt->stream_dev, dev);
3140 dev_put(amt->stream_dev);
3141}
3142
3143static size_t amt_get_size(const struct net_device *dev)
3144{
3145 return nla_total_size(sizeof(__u32)) + /* IFLA_AMT_MODE */
3146 nla_total_size(sizeof(__u16)) + /* IFLA_AMT_RELAY_PORT */
3147 nla_total_size(sizeof(__u16)) + /* IFLA_AMT_GATEWAY_PORT */
3148 nla_total_size(sizeof(__u32)) + /* IFLA_AMT_LINK */
3149 nla_total_size(sizeof(__u32)) + /* IFLA_MAX_TUNNELS */
3150 nla_total_size(sizeof(struct iphdr)) + /* IFLA_AMT_DISCOVERY_IP */
3151 nla_total_size(sizeof(struct iphdr)) + /* IFLA_AMT_REMOTE_IP */
3152 nla_total_size(sizeof(struct iphdr)); /* IFLA_AMT_LOCAL_IP */
3153}
3154
3155static int amt_fill_info(struct sk_buff *skb, const struct net_device *dev)
3156{
3157 struct amt_dev *amt = netdev_priv(dev);
3158
3159 if (nla_put_u32(skb, IFLA_AMT_MODE, amt->mode))
3160 goto nla_put_failure;
3161 if (nla_put_be16(skb, IFLA_AMT_RELAY_PORT, amt->relay_port))
3162 goto nla_put_failure;
3163 if (nla_put_be16(skb, IFLA_AMT_GATEWAY_PORT, amt->gw_port))
3164 goto nla_put_failure;
3165 if (nla_put_u32(skb, IFLA_AMT_LINK, amt->stream_dev->ifindex))
3166 goto nla_put_failure;
3167 if (nla_put_in_addr(skb, IFLA_AMT_LOCAL_IP, amt->local_ip))
3168 goto nla_put_failure;
3169 if (nla_put_in_addr(skb, IFLA_AMT_DISCOVERY_IP, amt->discovery_ip))
3170 goto nla_put_failure;
3171 if (amt->remote_ip)
3172 if (nla_put_in_addr(skb, IFLA_AMT_REMOTE_IP, amt->remote_ip))
3173 goto nla_put_failure;
3174 if (nla_put_u32(skb, IFLA_AMT_MAX_TUNNELS, amt->max_tunnels))
3175 goto nla_put_failure;
3176
3177 return 0;
3178
3179nla_put_failure:
3180 return -EMSGSIZE;
3181}
3182
3183static struct rtnl_link_ops amt_link_ops __read_mostly = {
3184 .kind = "amt",
3185 .maxtype = IFLA_AMT_MAX,
3186 .policy = amt_policy,
3187 .priv_size = sizeof(struct amt_dev),
3188 .setup = amt_link_setup,
3189 .validate = amt_validate,
3190 .newlink = amt_newlink,
3191 .dellink = amt_dellink,
3192 .get_size = amt_get_size,
3193 .fill_info = amt_fill_info,
3194};
3195
3196static struct net_device *amt_lookup_upper_dev(struct net_device *dev)
3197{
3198 struct net_device *upper_dev;
3199 struct amt_dev *amt;
3200
3201 for_each_netdev(dev_net(dev), upper_dev) {
3202 if (netif_is_amt(upper_dev)) {
3203 amt = netdev_priv(upper_dev);
3204 if (amt->stream_dev == dev)
3205 return upper_dev;
3206 }
3207 }
3208
3209 return NULL;
3210}
3211
3212static int amt_device_event(struct notifier_block *unused,
3213 unsigned long event, void *ptr)
3214{
3215 struct net_device *dev = netdev_notifier_info_to_dev(ptr);
3216 struct net_device *upper_dev;
3217 struct amt_dev *amt;
3218 LIST_HEAD(list);
3219 int new_mtu;
3220
3221 upper_dev = amt_lookup_upper_dev(dev);
3222 if (!upper_dev)
3223 return NOTIFY_DONE;
3224 amt = netdev_priv(upper_dev);
3225
3226 switch (event) {
3227 case NETDEV_UNREGISTER:
3228 amt_dellink(amt->dev, &list);
3229 unregister_netdevice_many(&list);
3230 break;
3231 case NETDEV_CHANGEMTU:
3232 if (amt->mode == AMT_MODE_RELAY)
3233 new_mtu = dev->mtu - AMT_RELAY_HLEN;
3234 else
3235 new_mtu = dev->mtu - AMT_GW_HLEN;
3236
3237 dev_set_mtu(amt->dev, new_mtu);
3238 break;
3239 }
3240
3241 return NOTIFY_DONE;
3242}
3243
3244static struct notifier_block amt_notifier_block __read_mostly = {
3245 .notifier_call = amt_device_event,
3246};
3247
3248static int __init amt_init(void)
3249{
3250 int err;
3251
3252 err = register_netdevice_notifier(&amt_notifier_block);
3253 if (err < 0)
3254 goto err;
3255
3256 err = rtnl_link_register(&amt_link_ops);
3257 if (err < 0)
3258 goto unregister_notifier;
3259
3260 amt_wq = alloc_workqueue("amt", WQ_UNBOUND, 1);
db243434
YY		 3261 if (!amt_wq) {
3262 err = -ENOMEM;
b9022b53 3263 goto rtnl_unregister;
db243434 3264 }
b9022b53 3265
bc54e49c
TY		 3266 spin_lock_init(&source_gc_lock);
3267 spin_lock_bh(&source_gc_lock);
3268 INIT_DELAYED_WORK(&source_gc_wq, amt_source_gc_work);
3269 mod_delayed_work(amt_wq, &source_gc_wq,
3270 msecs_to_jiffies(AMT_GC_INTERVAL));
3271 spin_unlock_bh(&source_gc_lock);
3272
b9022b53
TY		 3273 return 0;
3274
3275rtnl_unregister:
3276 rtnl_link_unregister(&amt_link_ops);
3277unregister_notifier:
3278 unregister_netdevice_notifier(&amt_notifier_block);
3279err:
3280 pr_err("error loading AMT module loaded\n");
3281 return err;
3282}
3283late_initcall(amt_init);
3284
3285static void __exit amt_fini(void)
3286{
3287 rtnl_link_unregister(&amt_link_ops);
3288 unregister_netdevice_notifier(&amt_notifier_block);
b0024a04 3289 cancel_delayed_work_sync(&source_gc_wq);
bc54e49c 3290 __amt_source_gc_work();
b9022b53
TY		 3291 destroy_workqueue(amt_wq);
3292}
3293module_exit(amt_fini);
3294
3295MODULE_LICENSE("GPL");
3296MODULE_AUTHOR("Taehee Yoo <ap420073@gmail.com>");
3297MODULE_ALIAS_RTNL_LINK("amt");
Linux 6.x block layer and io_uring tree(s)