drivers/net/amt.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /* Copyright (c) 2021 Taehee Yoo <[email protected]> */
   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>
  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>
  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>
  30 #include <net/ip6_checksum.h>
  31
  32 static struct workqueue_struct *amt_wq;
  33
  34 static HLIST_HEAD(source_gc_list);
  35 /* Lock for source_gc_list */
  36 static spinlock_t source_gc_lock;
  37 static struct delayed_work source_gc_wq;
  38 static 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
  52 static 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
  62 static 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
  71 static 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 } } }
  75 static struct in6_addr mld2_all_node = MLD2_ALL_NODE_INIT;
  76 static struct mld2_grec mldv2_zero_grec;
  77 #endif
  78
  79 static 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
  88 static 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
 104 static 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
 114 static bool amt_addr_equal(union amt_addr *a, union amt_addr *b)
 115 {
 116         return !memcmp(a, b, sizeof(union amt_addr));
 117 }
 118
 119 static 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
 126 static 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
 180 static 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
 196 static 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
 203 static 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
 221 static 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);
 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
 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
 251 static 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);
 265 #if IS_ENABLED(CONFIG_IPV6)
 266         else
 267                 netdev_dbg(amt->dev, "Leave group %pI6\n",
 268                            &gnode->group_addr.ip6);
 269 #endif
 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  */
 285 static 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
 311 static 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]);
 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
 360 }
 361
 362 static 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  */
 406 static 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);
 446 out:
 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  */
 461 static 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);
 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
 504         return gnode;
 505 }
 506
 507 static 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
 578 static 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
 588 static 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
 601 static 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
 609 static 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
 617 static 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);
 704 out:
 705         rcu_read_unlock();
 706 }
 707
 708 static 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
 794 out:
 795         rcu_read_unlock();
 796 }
 797
 798 static 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
 811 #if IS_ENABLED(CONFIG_IPV6)
 812 static 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
 884 static 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
 896 static void amt_send_mld_gq(struct amt_dev *amt, struct amt_tunnel_list *tunnel)
 897 {
 898 }
 899 #endif
 900
 901 static 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
 914 static 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);
 928 out:
 929         mod_delayed_work(amt_wq, &amt->discovery_wq,
 930                          msecs_to_jiffies(AMT_DISCOVERY_TIMEOUT));
 931         spin_unlock_bh(&amt->lock);
 932 }
 933
 934 static 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);
 960 out:
 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
 966 static 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
1024 static 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
1079 static 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
1139 static 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;
1143         struct amt_group_node *gnode;
1144         union amt_addr group = {0,};
1145 #if IS_ENABLED(CONFIG_IPV6)
1146         struct ipv6hdr *ip6h;
1147         struct mld_msg *mld;
1148 #endif
1149         bool report = false;
1150         struct igmphdr *ih;
1151         bool query = false;
1152         struct iphdr *iph;
1153         bool data = false;
1154         bool v6 = false;
1155         u32 hash;
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;
1179                 group.ip4 = iph->daddr;
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
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;
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) {
1244                                 if (!v6) {
1245                                         if (gnode->group_addr.ip4 == iph->daddr)
1246                                                 goto found;
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                                 }
1254                         }
1255                         continue;
1256 found:
1257                         amt_send_multicast_data(amt, skb, tunnel, v6);
1258                 }
1259         }
1260
1261         dev_kfree_skb(skb);
1262         return NETDEV_TX_OK;
1263 free:
1264         dev_kfree_skb(skb);
1265 unlock:
1266         dev->stats.tx_dropped++;
1267         return NETDEV_TX_OK;
1268 }
1269
1270 static 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
1288 static 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
1304 static 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--;
1315         amt_clear_groups(tunnel);
1316         rcu_read_unlock();
1317         spin_unlock_bh(&amt->lock);
1318         kfree_rcu(tunnel, rcu);
1319 }
1320
1321 static 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);
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
1353                 }
1354         }
1355 }
1356
1357 static 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;
1363 #if IS_ENABLED(CONFIG_IPV6)
1364         struct mld2_grec *mld_grec;
1365 #endif
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 {
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
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];
1387 #if IS_ENABLED(CONFIG_IPV6)
1388                 else
1389                         memcpy(&src.ip6, &mld_grec->grec_src[i],
1390                                sizeof(struct in6_addr));
1391 #endif
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);
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
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  */
1437 static 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;
1448 #if IS_ENABLED(CONFIG_IPV6)
1449         struct mld2_grec *mld_grec;
1450 #endif
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 {
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
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];
1475 #if IS_ENABLED(CONFIG_IPV6)
1476                         else
1477                                 memcpy(&src.ip6, &mld_grec->grec_src[i],
1478                                        sizeof(struct in6_addr));
1479 #endif
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];
1498 #if IS_ENABLED(CONFIG_IPV6)
1499                         else
1500                                 memcpy(&src.ip6, &mld_grec->grec_src[i],
1501                                        sizeof(struct in6_addr));
1502 #endif
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];
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
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;
1531 out_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];
1540 #if IS_ENABLED(CONFIG_IPV6)
1541                         else
1542                                 memcpy(&src.ip6, &mld_grec->grec_src[i],
1543                                        sizeof(struct in6_addr));
1544 #endif
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
1561 static 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
1614 static 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
1678 static 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
1739 static 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
1805 static 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
1850 static 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  */
1906 static 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  */
1943 static 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
1961 static 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 */
2032 static 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
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  */
2067 static 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  */
2104 static 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
2123 static 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 */
2194 static 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
2215 static 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
2244 static 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);
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
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
2297 static 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);
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
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
2385 static 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
2425 report:
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
2433                 spin_lock_bh(&tunnel->lock);
2434                 amt_igmp_report_handler(amt, skb, tunnel);
2435                 spin_unlock_bh(&tunnel->lock);
2436
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);
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
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
2483 static 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
2569 out:
2570         rcu_read_unlock();
2571 }
2572
2573 static 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
2594 static 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
2649 send:
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);
2662         else
2663                 amt_send_mld_gq(amt, tunnel);
2664
2665         return false;
2666 }
2667
2668 static 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         }
2748 drop:
2749         if (err) {
2750                 amt->dev->stats.rx_dropped++;
2751                 kfree_skb(skb);
2752         } else {
2753                 consume_skb(skb);
2754         }
2755 out:
2756         rcu_read_unlock_bh();
2757         return 0;
2758 }
2759
2760 static 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)
2768                 goto out;
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         }
2790 out:
2791         rcu_read_unlock_bh();
2792         return 0;
2793 drop:
2794         rcu_read_unlock_bh();
2795         amt->dev->stats.rx_dropped++;
2796         return 0;
2797 }
2798
2799 static 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
2818 static 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;
2831         tunnel_cfg.encap_rcv = amt_rcv;
2832         tunnel_cfg.encap_err_lookup = amt_err_lookup;
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
2840 static 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;
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         }
2864         return err;
2865 }
2866
2867 static int amt_dev_stop(struct net_device *dev)
2868 {
2869         struct amt_dev *amt = netdev_priv(dev);
2870         struct amt_tunnel_list *tunnel, *tmp;
2871         struct socket *sock;
2872
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
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
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);
2893                 amt_clear_groups(tunnel);
2894                 kfree_rcu(tunnel, rcu);
2895         }
2896
2897         return 0;
2898 }
2899
2900 static const struct device_type amt_type = {
2901         .name = "amt",
2902 };
2903
2904 static 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
2923 static 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
2931 static 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,
2936         .ndo_start_xmit         = amt_dev_xmit,
2937         .ndo_get_stats64        = dev_get_tstats64,
2938 };
2939
2940 static 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
2963 static 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
2974 static 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
3014 static 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
3024         if (data[IFLA_AMT_MAX_TUNNELS] &&
3025             nla_get_u32(data[IFLA_AMT_MAX_TUNNELS]))
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
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
3128         return 0;
3129 err:
3130         dev_put(amt->stream_dev);
3131         return err;
3132 }
3133
3134 static 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
3143 static 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
3155 static 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
3179 nla_put_failure:
3180         return -EMSGSIZE;
3181 }
3182
3183 static 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
3196 static 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
3212 static 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
3244 static struct notifier_block amt_notifier_block __read_mostly = {
3245         .notifier_call = amt_device_event,
3246 };
3247
3248 static 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);
3261         if (!amt_wq) {
3262                 err = -ENOMEM;
3263                 goto rtnl_unregister;
3264         }
3265
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
3273         return 0;
3274
3275 rtnl_unregister:
3276         rtnl_link_unregister(&amt_link_ops);
3277 unregister_notifier:
3278         unregister_netdevice_notifier(&amt_notifier_block);
3279 err:
3280         pr_err("error loading AMT module loaded\n");
3281         return err;
3282 }
3283 late_initcall(amt_init);
3284
3285 static void __exit amt_fini(void)
3286 {
3287         rtnl_link_unregister(&amt_link_ops);
3288         unregister_netdevice_notifier(&amt_notifier_block);
3289         cancel_delayed_work_sync(&source_gc_wq);
3290         __amt_source_gc_work();
3291         destroy_workqueue(amt_wq);
3292 }
3293 module_exit(amt_fini);
3294
3295 MODULE_LICENSE("GPL");
3296 MODULE_AUTHOR("Taehee Yoo <[email protected]>");
3297 MODULE_ALIAS_RTNL_LINK("amt");