net/sctp/protocol.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /* SCTP kernel implementation
   3  * (C) Copyright IBM Corp. 2001, 2004
   4  * Copyright (c) 1999-2000 Cisco, Inc.
   5  * Copyright (c) 1999-2001 Motorola, Inc.
   6  * Copyright (c) 2001 Intel Corp.
   7  * Copyright (c) 2001 Nokia, Inc.
   8  * Copyright (c) 2001 La Monte H.P. Yarroll
   9  *
  10  * This file is part of the SCTP kernel implementation
  11  *
  12  * Initialization/cleanup for SCTP protocol support.
  13  *
  14  * Please send any bug reports or fixes you make to the
  15  * email address(es):
  16  *    lksctp developers <[email protected]>
  17  *
  18  * Written or modified by:
  19  *    La Monte H.P. Yarroll <[email protected]>
  20  *    Karl Knutson <[email protected]>
  21  *    Jon Grimm <[email protected]>
  22  *    Sridhar Samudrala <[email protected]>
  23  *    Daisy Chang <[email protected]>
  24  *    Ardelle Fan <[email protected]>
  25  */
  26
  27 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  28
  29 #include <linux/module.h>
  30 #include <linux/init.h>
  31 #include <linux/netdevice.h>
  32 #include <linux/inetdevice.h>
  33 #include <linux/seq_file.h>
  34 #include <linux/memblock.h>
  35 #include <linux/highmem.h>
  36 #include <linux/slab.h>
  37 #include <net/net_namespace.h>
  38 #include <net/protocol.h>
  39 #include <net/ip.h>
  40 #include <net/ipv6.h>
  41 #include <net/route.h>
  42 #include <net/sctp/sctp.h>
  43 #include <net/addrconf.h>
  44 #include <net/inet_common.h>
  45 #include <net/inet_ecn.h>
  46 #include <net/udp_tunnel.h>
  47 #include <net/inet_dscp.h>
  48
  49 #define MAX_SCTP_PORT_HASH_ENTRIES (64 * 1024)
  50
  51 /* Global data structures. */
  52 struct sctp_globals sctp_globals __read_mostly;
  53
  54 struct idr sctp_assocs_id;
  55 DEFINE_SPINLOCK(sctp_assocs_id_lock);
  56
  57 static struct sctp_pf *sctp_pf_inet6_specific;
  58 static struct sctp_pf *sctp_pf_inet_specific;
  59 static struct sctp_af *sctp_af_v4_specific;
  60 static struct sctp_af *sctp_af_v6_specific;
  61
  62 struct kmem_cache *sctp_chunk_cachep __read_mostly;
  63 struct kmem_cache *sctp_bucket_cachep __read_mostly;
  64
  65 long sysctl_sctp_mem[3];
  66 int sysctl_sctp_rmem[3];
  67 int sysctl_sctp_wmem[3];
  68
  69 /* Private helper to extract ipv4 address and stash them in
  70  * the protocol structure.
  71  */
  72 static void sctp_v4_copy_addrlist(struct list_head *addrlist,
  73                                   struct net_device *dev)
  74 {
  75         struct in_device *in_dev;
  76         struct in_ifaddr *ifa;
  77         struct sctp_sockaddr_entry *addr;
  78
  79         rcu_read_lock();
  80         if ((in_dev = __in_dev_get_rcu(dev)) == NULL) {
  81                 rcu_read_unlock();
  82                 return;
  83         }
  84
  85         in_dev_for_each_ifa_rcu(ifa, in_dev) {
  86                 /* Add the address to the local list.  */
  87                 addr = kzalloc(sizeof(*addr), GFP_ATOMIC);
  88                 if (addr) {
  89                         addr->a.v4.sin_family = AF_INET;
  90                         addr->a.v4.sin_addr.s_addr = ifa->ifa_local;
  91                         addr->valid = 1;
  92                         INIT_LIST_HEAD(&addr->list);
  93                         list_add_tail(&addr->list, addrlist);
  94                 }
  95         }
  96
  97         rcu_read_unlock();
  98 }
  99
 100 /* Extract our IP addresses from the system and stash them in the
 101  * protocol structure.
 102  */
 103 static void sctp_get_local_addr_list(struct net *net)
 104 {
 105         struct net_device *dev;
 106         struct list_head *pos;
 107         struct sctp_af *af;
 108
 109         rcu_read_lock();
 110         for_each_netdev_rcu(net, dev) {
 111                 list_for_each(pos, &sctp_address_families) {
 112                         af = list_entry(pos, struct sctp_af, list);
 113                         af->copy_addrlist(&net->sctp.local_addr_list, dev);
 114                 }
 115         }
 116         rcu_read_unlock();
 117 }
 118
 119 /* Free the existing local addresses.  */
 120 static void sctp_free_local_addr_list(struct net *net)
 121 {
 122         struct sctp_sockaddr_entry *addr;
 123         struct list_head *pos, *temp;
 124
 125         list_for_each_safe(pos, temp, &net->sctp.local_addr_list) {
 126                 addr = list_entry(pos, struct sctp_sockaddr_entry, list);
 127                 list_del(pos);
 128                 kfree(addr);
 129         }
 130 }
 131
 132 /* Copy the local addresses which are valid for 'scope' into 'bp'.  */
 133 int sctp_copy_local_addr_list(struct net *net, struct sctp_bind_addr *bp,
 134                               enum sctp_scope scope, gfp_t gfp, int copy_flags)
 135 {
 136         struct sctp_sockaddr_entry *addr;
 137         union sctp_addr laddr;
 138         int error = 0;
 139
 140         rcu_read_lock();
 141         list_for_each_entry_rcu(addr, &net->sctp.local_addr_list, list) {
 142                 if (!addr->valid)
 143                         continue;
 144                 if (!sctp_in_scope(net, &addr->a, scope))
 145                         continue;
 146
 147                 /* Now that the address is in scope, check to see if
 148                  * the address type is really supported by the local
 149                  * sock as well as the remote peer.
 150                  */
 151                 if (addr->a.sa.sa_family == AF_INET &&
 152                     (!(copy_flags & SCTP_ADDR4_ALLOWED) ||
 153                      !(copy_flags & SCTP_ADDR4_PEERSUPP)))
 154                         continue;
 155                 if (addr->a.sa.sa_family == AF_INET6 &&
 156                     (!(copy_flags & SCTP_ADDR6_ALLOWED) ||
 157                      !(copy_flags & SCTP_ADDR6_PEERSUPP)))
 158                         continue;
 159
 160                 laddr = addr->a;
 161                 /* also works for setting ipv6 address port */
 162                 laddr.v4.sin_port = htons(bp->port);
 163                 if (sctp_bind_addr_state(bp, &laddr) != -1)
 164                         continue;
 165
 166                 error = sctp_add_bind_addr(bp, &addr->a, sizeof(addr->a),
 167                                            SCTP_ADDR_SRC, GFP_ATOMIC);
 168                 if (error)
 169                         break;
 170         }
 171
 172         rcu_read_unlock();
 173         return error;
 174 }
 175
 176 /* Copy over any ip options */
 177 static void sctp_v4_copy_ip_options(struct sock *sk, struct sock *newsk)
 178 {
 179         struct inet_sock *newinet, *inet = inet_sk(sk);
 180         struct ip_options_rcu *inet_opt, *newopt = NULL;
 181
 182         newinet = inet_sk(newsk);
 183
 184         rcu_read_lock();
 185         inet_opt = rcu_dereference(inet->inet_opt);
 186         if (inet_opt) {
 187                 newopt = sock_kmalloc(newsk, sizeof(*inet_opt) +
 188                                       inet_opt->opt.optlen, GFP_ATOMIC);
 189                 if (newopt)
 190                         memcpy(newopt, inet_opt, sizeof(*inet_opt) +
 191                                inet_opt->opt.optlen);
 192                 else
 193                         pr_err("%s: Failed to copy ip options\n", __func__);
 194         }
 195         RCU_INIT_POINTER(newinet->inet_opt, newopt);
 196         rcu_read_unlock();
 197 }
 198
 199 /* Account for the IP options */
 200 static int sctp_v4_ip_options_len(struct sock *sk)
 201 {
 202         struct inet_sock *inet = inet_sk(sk);
 203         struct ip_options_rcu *inet_opt;
 204         int len = 0;
 205
 206         rcu_read_lock();
 207         inet_opt = rcu_dereference(inet->inet_opt);
 208         if (inet_opt)
 209                 len = inet_opt->opt.optlen;
 210
 211         rcu_read_unlock();
 212         return len;
 213 }
 214
 215 /* Initialize a sctp_addr from in incoming skb.  */
 216 static void sctp_v4_from_skb(union sctp_addr *addr, struct sk_buff *skb,
 217                              int is_saddr)
 218 {
 219         /* Always called on head skb, so this is safe */
 220         struct sctphdr *sh = sctp_hdr(skb);
 221         struct sockaddr_in *sa = &addr->v4;
 222
 223         addr->v4.sin_family = AF_INET;
 224
 225         if (is_saddr) {
 226                 sa->sin_port = sh->source;
 227                 sa->sin_addr.s_addr = ip_hdr(skb)->saddr;
 228         } else {
 229                 sa->sin_port = sh->dest;
 230                 sa->sin_addr.s_addr = ip_hdr(skb)->daddr;
 231         }
 232         memset(sa->sin_zero, 0, sizeof(sa->sin_zero));
 233 }
 234
 235 /* Initialize an sctp_addr from a socket. */
 236 static void sctp_v4_from_sk(union sctp_addr *addr, struct sock *sk)
 237 {
 238         addr->v4.sin_family = AF_INET;
 239         addr->v4.sin_port = 0;
 240         addr->v4.sin_addr.s_addr = inet_sk(sk)->inet_rcv_saddr;
 241         memset(addr->v4.sin_zero, 0, sizeof(addr->v4.sin_zero));
 242 }
 243
 244 /* Initialize sk->sk_rcv_saddr from sctp_addr. */
 245 static void sctp_v4_to_sk_saddr(union sctp_addr *addr, struct sock *sk)
 246 {
 247         inet_sk(sk)->inet_rcv_saddr = addr->v4.sin_addr.s_addr;
 248 }
 249
 250 /* Initialize sk->sk_daddr from sctp_addr. */
 251 static void sctp_v4_to_sk_daddr(union sctp_addr *addr, struct sock *sk)
 252 {
 253         inet_sk(sk)->inet_daddr = addr->v4.sin_addr.s_addr;
 254 }
 255
 256 /* Initialize a sctp_addr from an address parameter. */
 257 static bool sctp_v4_from_addr_param(union sctp_addr *addr,
 258                                     union sctp_addr_param *param,
 259                                     __be16 port, int iif)
 260 {
 261         if (ntohs(param->v4.param_hdr.length) < sizeof(struct sctp_ipv4addr_param))
 262                 return false;
 263
 264         addr->v4.sin_family = AF_INET;
 265         addr->v4.sin_port = port;
 266         addr->v4.sin_addr.s_addr = param->v4.addr.s_addr;
 267         memset(addr->v4.sin_zero, 0, sizeof(addr->v4.sin_zero));
 268
 269         return true;
 270 }
 271
 272 /* Initialize an address parameter from a sctp_addr and return the length
 273  * of the address parameter.
 274  */
 275 static int sctp_v4_to_addr_param(const union sctp_addr *addr,
 276                                  union sctp_addr_param *param)
 277 {
 278         int length = sizeof(struct sctp_ipv4addr_param);
 279
 280         param->v4.param_hdr.type = SCTP_PARAM_IPV4_ADDRESS;
 281         param->v4.param_hdr.length = htons(length);
 282         param->v4.addr.s_addr = addr->v4.sin_addr.s_addr;
 283
 284         return length;
 285 }
 286
 287 /* Initialize a sctp_addr from a dst_entry. */
 288 static void sctp_v4_dst_saddr(union sctp_addr *saddr, struct flowi4 *fl4,
 289                               __be16 port)
 290 {
 291         saddr->v4.sin_family = AF_INET;
 292         saddr->v4.sin_port = port;
 293         saddr->v4.sin_addr.s_addr = fl4->saddr;
 294         memset(saddr->v4.sin_zero, 0, sizeof(saddr->v4.sin_zero));
 295 }
 296
 297 /* Compare two addresses exactly. */
 298 static int sctp_v4_cmp_addr(const union sctp_addr *addr1,
 299                             const union sctp_addr *addr2)
 300 {
 301         if (addr1->sa.sa_family != addr2->sa.sa_family)
 302                 return 0;
 303         if (addr1->v4.sin_port != addr2->v4.sin_port)
 304                 return 0;
 305         if (addr1->v4.sin_addr.s_addr != addr2->v4.sin_addr.s_addr)
 306                 return 0;
 307
 308         return 1;
 309 }
 310
 311 /* Initialize addr struct to INADDR_ANY. */
 312 static void sctp_v4_inaddr_any(union sctp_addr *addr, __be16 port)
 313 {
 314         addr->v4.sin_family = AF_INET;
 315         addr->v4.sin_addr.s_addr = htonl(INADDR_ANY);
 316         addr->v4.sin_port = port;
 317         memset(addr->v4.sin_zero, 0, sizeof(addr->v4.sin_zero));
 318 }
 319
 320 /* Is this a wildcard address? */
 321 static int sctp_v4_is_any(const union sctp_addr *addr)
 322 {
 323         return htonl(INADDR_ANY) == addr->v4.sin_addr.s_addr;
 324 }
 325
 326 /* This function checks if the address is a valid address to be used for
 327  * SCTP binding.
 328  *
 329  * Output:
 330  * Return 0 - If the address is a non-unicast or an illegal address.
 331  * Return 1 - If the address is a unicast.
 332  */
 333 static int sctp_v4_addr_valid(union sctp_addr *addr,
 334                               struct sctp_sock *sp,
 335                               const struct sk_buff *skb)
 336 {
 337         /* IPv4 addresses not allowed */
 338         if (sp && ipv6_only_sock(sctp_opt2sk(sp)))
 339                 return 0;
 340
 341         /* Is this a non-unicast address or a unusable SCTP address? */
 342         if (IS_IPV4_UNUSABLE_ADDRESS(addr->v4.sin_addr.s_addr))
 343                 return 0;
 344
 345         /* Is this a broadcast address? */
 346         if (skb && skb_rtable(skb)->rt_flags & RTCF_BROADCAST)
 347                 return 0;
 348
 349         return 1;
 350 }
 351
 352 /* Should this be available for binding?   */
 353 static int sctp_v4_available(union sctp_addr *addr, struct sctp_sock *sp)
 354 {
 355         struct sock *sk = &sp->inet.sk;
 356         struct net *net = sock_net(sk);
 357         int tb_id = RT_TABLE_LOCAL;
 358         int ret;
 359
 360         tb_id = l3mdev_fib_table_by_index(net, sk->sk_bound_dev_if) ?: tb_id;
 361         ret = inet_addr_type_table(net, addr->v4.sin_addr.s_addr, tb_id);
 362         if (addr->v4.sin_addr.s_addr != htonl(INADDR_ANY) &&
 363            ret != RTN_LOCAL &&
 364            !inet_test_bit(FREEBIND, sk) &&
 365             !READ_ONCE(net->ipv4.sysctl_ip_nonlocal_bind))
 366                 return 0;
 367
 368         if (ipv6_only_sock(sctp_opt2sk(sp)))
 369                 return 0;
 370
 371         return 1;
 372 }
 373
 374 /* Checking the loopback, private and other address scopes as defined in
 375  * RFC 1918.   The IPv4 scoping is based on the draft for SCTP IPv4
 376  * scoping <draft-stewart-tsvwg-sctp-ipv4-00.txt>.
 377  *
 378  * Level 0 - unusable SCTP addresses
 379  * Level 1 - loopback address
 380  * Level 2 - link-local addresses
 381  * Level 3 - private addresses.
 382  * Level 4 - global addresses
 383  * For INIT and INIT-ACK address list, let L be the level of
 384  * requested destination address, sender and receiver
 385  * SHOULD include all of its addresses with level greater
 386  * than or equal to L.
 387  *
 388  * IPv4 scoping can be controlled through sysctl option
 389  * net.sctp.addr_scope_policy
 390  */
 391 static enum sctp_scope sctp_v4_scope(union sctp_addr *addr)
 392 {
 393         enum sctp_scope retval;
 394
 395         /* Check for unusable SCTP addresses. */
 396         if (IS_IPV4_UNUSABLE_ADDRESS(addr->v4.sin_addr.s_addr)) {
 397                 retval =  SCTP_SCOPE_UNUSABLE;
 398         } else if (ipv4_is_loopback(addr->v4.sin_addr.s_addr)) {
 399                 retval = SCTP_SCOPE_LOOPBACK;
 400         } else if (ipv4_is_linklocal_169(addr->v4.sin_addr.s_addr)) {
 401                 retval = SCTP_SCOPE_LINK;
 402         } else if (ipv4_is_private_10(addr->v4.sin_addr.s_addr) ||
 403                    ipv4_is_private_172(addr->v4.sin_addr.s_addr) ||
 404                    ipv4_is_private_192(addr->v4.sin_addr.s_addr) ||
 405                    ipv4_is_test_198(addr->v4.sin_addr.s_addr)) {
 406                 retval = SCTP_SCOPE_PRIVATE;
 407         } else {
 408                 retval = SCTP_SCOPE_GLOBAL;
 409         }
 410
 411         return retval;
 412 }
 413
 414 /* Returns a valid dst cache entry for the given source and destination ip
 415  * addresses. If an association is passed, trys to get a dst entry with a
 416  * source address that matches an address in the bind address list.
 417  */
 418 static void sctp_v4_get_dst(struct sctp_transport *t, union sctp_addr *saddr,
 419                                 struct flowi *fl, struct sock *sk)
 420 {
 421         struct sctp_association *asoc = t->asoc;
 422         struct rtable *rt;
 423         struct flowi _fl;
 424         struct flowi4 *fl4 = &_fl.u.ip4;
 425         struct sctp_bind_addr *bp;
 426         struct sctp_sockaddr_entry *laddr;
 427         struct dst_entry *dst = NULL;
 428         union sctp_addr *daddr = &t->ipaddr;
 429         union sctp_addr dst_saddr;
 430         u8 tos = READ_ONCE(inet_sk(sk)->tos);
 431
 432         if (t->dscp & SCTP_DSCP_SET_MASK)
 433                 tos = t->dscp & SCTP_DSCP_VAL_MASK;
 434         memset(&_fl, 0x0, sizeof(_fl));
 435         fl4->daddr  = daddr->v4.sin_addr.s_addr;
 436         fl4->fl4_dport = daddr->v4.sin_port;
 437         fl4->flowi4_proto = IPPROTO_SCTP;
 438         if (asoc) {
 439                 fl4->flowi4_tos = tos & INET_DSCP_MASK;
 440                 fl4->flowi4_scope = ip_sock_rt_scope(asoc->base.sk);
 441                 fl4->flowi4_oif = asoc->base.sk->sk_bound_dev_if;
 442                 fl4->fl4_sport = htons(asoc->base.bind_addr.port);
 443         }
 444         if (saddr) {
 445                 fl4->saddr = saddr->v4.sin_addr.s_addr;
 446                 if (!fl4->fl4_sport)
 447                         fl4->fl4_sport = saddr->v4.sin_port;
 448         }
 449
 450         pr_debug("%s: dst:%pI4, src:%pI4 - ", __func__, &fl4->daddr,
 451                  &fl4->saddr);
 452
 453         rt = ip_route_output_key(sock_net(sk), fl4);
 454         if (!IS_ERR(rt)) {
 455                 dst = &rt->dst;
 456                 t->dst = dst;
 457                 memcpy(fl, &_fl, sizeof(_fl));
 458         }
 459
 460         /* If there is no association or if a source address is passed, no
 461          * more validation is required.
 462          */
 463         if (!asoc || saddr)
 464                 goto out;
 465
 466         bp = &asoc->base.bind_addr;
 467
 468         if (dst) {
 469                 /* Walk through the bind address list and look for a bind
 470                  * address that matches the source address of the returned dst.
 471                  */
 472                 sctp_v4_dst_saddr(&dst_saddr, fl4, htons(bp->port));
 473                 rcu_read_lock();
 474                 list_for_each_entry_rcu(laddr, &bp->address_list, list) {
 475                         if (!laddr->valid || (laddr->state == SCTP_ADDR_DEL) ||
 476                             (laddr->state != SCTP_ADDR_SRC &&
 477                             !asoc->src_out_of_asoc_ok))
 478                                 continue;
 479                         if (sctp_v4_cmp_addr(&dst_saddr, &laddr->a))
 480                                 goto out_unlock;
 481                 }
 482                 rcu_read_unlock();
 483
 484                 /* None of the bound addresses match the source address of the
 485                  * dst. So release it.
 486                  */
 487                 dst_release(dst);
 488                 dst = NULL;
 489         }
 490
 491         /* Walk through the bind address list and try to get a dst that
 492          * matches a bind address as the source address.
 493          */
 494         rcu_read_lock();
 495         list_for_each_entry_rcu(laddr, &bp->address_list, list) {
 496                 struct net_device *odev;
 497
 498                 if (!laddr->valid)
 499                         continue;
 500                 if (laddr->state != SCTP_ADDR_SRC ||
 501                     AF_INET != laddr->a.sa.sa_family)
 502                         continue;
 503
 504                 fl4->fl4_sport = laddr->a.v4.sin_port;
 505                 flowi4_update_output(fl4, asoc->base.sk->sk_bound_dev_if,
 506                                      daddr->v4.sin_addr.s_addr,
 507                                      laddr->a.v4.sin_addr.s_addr);
 508
 509                 rt = ip_route_output_key(sock_net(sk), fl4);
 510                 if (IS_ERR(rt))
 511                         continue;
 512
 513                 /* Ensure the src address belongs to the output
 514                  * interface.
 515                  */
 516                 odev = __ip_dev_find(sock_net(sk), laddr->a.v4.sin_addr.s_addr,
 517                                      false);
 518                 if (!odev || odev->ifindex != fl4->flowi4_oif) {
 519                         if (!dst) {
 520                                 dst = &rt->dst;
 521                                 t->dst = dst;
 522                                 memcpy(fl, &_fl, sizeof(_fl));
 523                         } else {
 524                                 dst_release(&rt->dst);
 525                         }
 526                         continue;
 527                 }
 528
 529                 dst_release(dst);
 530                 dst = &rt->dst;
 531                 t->dst = dst;
 532                 memcpy(fl, &_fl, sizeof(_fl));
 533                 break;
 534         }
 535
 536 out_unlock:
 537         rcu_read_unlock();
 538 out:
 539         if (dst) {
 540                 pr_debug("rt_dst:%pI4, rt_src:%pI4\n",
 541                          &fl->u.ip4.daddr, &fl->u.ip4.saddr);
 542         } else {
 543                 t->dst = NULL;
 544                 pr_debug("no route\n");
 545         }
 546 }
 547
 548 /* For v4, the source address is cached in the route entry(dst). So no need
 549  * to cache it separately and hence this is an empty routine.
 550  */
 551 static void sctp_v4_get_saddr(struct sctp_sock *sk,
 552                               struct sctp_transport *t,
 553                               struct flowi *fl)
 554 {
 555         union sctp_addr *saddr = &t->saddr;
 556         struct rtable *rt = dst_rtable(t->dst);
 557
 558         if (rt) {
 559                 saddr->v4.sin_family = AF_INET;
 560                 saddr->v4.sin_addr.s_addr = fl->u.ip4.saddr;
 561         }
 562 }
 563
 564 /* What interface did this skb arrive on? */
 565 static int sctp_v4_skb_iif(const struct sk_buff *skb)
 566 {
 567         return inet_iif(skb);
 568 }
 569
 570 static int sctp_v4_skb_sdif(const struct sk_buff *skb)
 571 {
 572         return inet_sdif(skb);
 573 }
 574
 575 /* Was this packet marked by Explicit Congestion Notification? */
 576 static int sctp_v4_is_ce(const struct sk_buff *skb)
 577 {
 578         return INET_ECN_is_ce(ip_hdr(skb)->tos);
 579 }
 580
 581 /* Create and initialize a new sk for the socket returned by accept(). */
 582 static struct sock *sctp_v4_create_accept_sk(struct sock *sk,
 583                                              struct sctp_association *asoc,
 584                                              bool kern)
 585 {
 586         struct sock *newsk = sk_alloc(sock_net(sk), PF_INET, GFP_KERNEL,
 587                         sk->sk_prot, kern);
 588         struct inet_sock *newinet;
 589
 590         if (!newsk)
 591                 goto out;
 592
 593         sock_init_data(NULL, newsk);
 594
 595         sctp_copy_sock(newsk, sk, asoc);
 596         sock_reset_flag(newsk, SOCK_ZAPPED);
 597
 598         sctp_v4_copy_ip_options(sk, newsk);
 599
 600         newinet = inet_sk(newsk);
 601
 602         newinet->inet_daddr = asoc->peer.primary_addr.v4.sin_addr.s_addr;
 603
 604         if (newsk->sk_prot->init(newsk)) {
 605                 sk_common_release(newsk);
 606                 newsk = NULL;
 607         }
 608
 609 out:
 610         return newsk;
 611 }
 612
 613 static int sctp_v4_addr_to_user(struct sctp_sock *sp, union sctp_addr *addr)
 614 {
 615         /* No address mapping for V4 sockets */
 616         memset(addr->v4.sin_zero, 0, sizeof(addr->v4.sin_zero));
 617         return sizeof(struct sockaddr_in);
 618 }
 619
 620 /* Dump the v4 addr to the seq file. */
 621 static void sctp_v4_seq_dump_addr(struct seq_file *seq, union sctp_addr *addr)
 622 {
 623         seq_printf(seq, "%pI4 ", &addr->v4.sin_addr);
 624 }
 625
 626 static void sctp_v4_ecn_capable(struct sock *sk)
 627 {
 628         INET_ECN_xmit(sk);
 629 }
 630
 631 static void sctp_addr_wq_timeout_handler(struct timer_list *t)
 632 {
 633         struct net *net = from_timer(net, t, sctp.addr_wq_timer);
 634         struct sctp_sockaddr_entry *addrw, *temp;
 635         struct sctp_sock *sp;
 636
 637         spin_lock_bh(&net->sctp.addr_wq_lock);
 638
 639         list_for_each_entry_safe(addrw, temp, &net->sctp.addr_waitq, list) {
 640                 pr_debug("%s: the first ent in wq:%p is addr:%pISc for cmd:%d at "
 641                          "entry:%p\n", __func__, &net->sctp.addr_waitq, &addrw->a.sa,
 642                          addrw->state, addrw);
 643
 644 #if IS_ENABLED(CONFIG_IPV6)
 645                 /* Now we send an ASCONF for each association */
 646                 /* Note. we currently don't handle link local IPv6 addressees */
 647                 if (addrw->a.sa.sa_family == AF_INET6) {
 648                         struct in6_addr *in6;
 649
 650                         if (ipv6_addr_type(&addrw->a.v6.sin6_addr) &
 651                             IPV6_ADDR_LINKLOCAL)
 652                                 goto free_next;
 653
 654                         in6 = (struct in6_addr *)&addrw->a.v6.sin6_addr;
 655                         if (ipv6_chk_addr(net, in6, NULL, 0) == 0 &&
 656                             addrw->state == SCTP_ADDR_NEW) {
 657                                 unsigned long timeo_val;
 658
 659                                 pr_debug("%s: this is on DAD, trying %d sec "
 660                                          "later\n", __func__,
 661                                          SCTP_ADDRESS_TICK_DELAY);
 662
 663                                 timeo_val = jiffies;
 664                                 timeo_val += msecs_to_jiffies(SCTP_ADDRESS_TICK_DELAY);
 665                                 mod_timer(&net->sctp.addr_wq_timer, timeo_val);
 666                                 break;
 667                         }
 668                 }
 669 #endif
 670                 list_for_each_entry(sp, &net->sctp.auto_asconf_splist, auto_asconf_list) {
 671                         struct sock *sk;
 672
 673                         sk = sctp_opt2sk(sp);
 674                         /* ignore bound-specific endpoints */
 675                         if (!sctp_is_ep_boundall(sk))
 676                                 continue;
 677                         bh_lock_sock(sk);
 678                         if (sctp_asconf_mgmt(sp, addrw) < 0)
 679                                 pr_debug("%s: sctp_asconf_mgmt failed\n", __func__);
 680                         bh_unlock_sock(sk);
 681                 }
 682 #if IS_ENABLED(CONFIG_IPV6)
 683 free_next:
 684 #endif
 685                 list_del(&addrw->list);
 686                 kfree(addrw);
 687         }
 688         spin_unlock_bh(&net->sctp.addr_wq_lock);
 689 }
 690
 691 static void sctp_free_addr_wq(struct net *net)
 692 {
 693         struct sctp_sockaddr_entry *addrw;
 694         struct sctp_sockaddr_entry *temp;
 695
 696         spin_lock_bh(&net->sctp.addr_wq_lock);
 697         del_timer(&net->sctp.addr_wq_timer);
 698         list_for_each_entry_safe(addrw, temp, &net->sctp.addr_waitq, list) {
 699                 list_del(&addrw->list);
 700                 kfree(addrw);
 701         }
 702         spin_unlock_bh(&net->sctp.addr_wq_lock);
 703 }
 704
 705 /* lookup the entry for the same address in the addr_waitq
 706  * sctp_addr_wq MUST be locked
 707  */
 708 static struct sctp_sockaddr_entry *sctp_addr_wq_lookup(struct net *net,
 709                                         struct sctp_sockaddr_entry *addr)
 710 {
 711         struct sctp_sockaddr_entry *addrw;
 712
 713         list_for_each_entry(addrw, &net->sctp.addr_waitq, list) {
 714                 if (addrw->a.sa.sa_family != addr->a.sa.sa_family)
 715                         continue;
 716                 if (addrw->a.sa.sa_family == AF_INET) {
 717                         if (addrw->a.v4.sin_addr.s_addr ==
 718                             addr->a.v4.sin_addr.s_addr)
 719                                 return addrw;
 720                 } else if (addrw->a.sa.sa_family == AF_INET6) {
 721                         if (ipv6_addr_equal(&addrw->a.v6.sin6_addr,
 722                             &addr->a.v6.sin6_addr))
 723                                 return addrw;
 724                 }
 725         }
 726         return NULL;
 727 }
 728
 729 void sctp_addr_wq_mgmt(struct net *net, struct sctp_sockaddr_entry *addr, int cmd)
 730 {
 731         struct sctp_sockaddr_entry *addrw;
 732         unsigned long timeo_val;
 733
 734         /* first, we check if an opposite message already exist in the queue.
 735          * If we found such message, it is removed.
 736          * This operation is a bit stupid, but the DHCP client attaches the
 737          * new address after a couple of addition and deletion of that address
 738          */
 739
 740         spin_lock_bh(&net->sctp.addr_wq_lock);
 741
 742         /* Avoid searching the queue or modifying it if there are no consumers,
 743          * as it can lead to performance degradation if addresses are modified
 744          * en-masse.
 745          *
 746          * If the queue already contains some events, update it anyway to avoid
 747          * ugly races between new sessions and new address events.
 748          */
 749         if (list_empty(&net->sctp.auto_asconf_splist) &&
 750             list_empty(&net->sctp.addr_waitq)) {
 751                 spin_unlock_bh(&net->sctp.addr_wq_lock);
 752                 return;
 753         }
 754
 755         /* Offsets existing events in addr_wq */
 756         addrw = sctp_addr_wq_lookup(net, addr);
 757         if (addrw) {
 758                 if (addrw->state != cmd) {
 759                         pr_debug("%s: offsets existing entry for %d, addr:%pISc "
 760                                  "in wq:%p\n", __func__, addrw->state, &addrw->a.sa,
 761                                  &net->sctp.addr_waitq);
 762
 763                         list_del(&addrw->list);
 764                         kfree(addrw);
 765                 }
 766                 spin_unlock_bh(&net->sctp.addr_wq_lock);
 767                 return;
 768         }
 769
 770         /* OK, we have to add the new address to the wait queue */
 771         addrw = kmemdup(addr, sizeof(struct sctp_sockaddr_entry), GFP_ATOMIC);
 772         if (addrw == NULL) {
 773                 spin_unlock_bh(&net->sctp.addr_wq_lock);
 774                 return;
 775         }
 776         addrw->state = cmd;
 777         list_add_tail(&addrw->list, &net->sctp.addr_waitq);
 778
 779         pr_debug("%s: add new entry for cmd:%d, addr:%pISc in wq:%p\n",
 780                  __func__, addrw->state, &addrw->a.sa, &net->sctp.addr_waitq);
 781
 782         if (!timer_pending(&net->sctp.addr_wq_timer)) {
 783                 timeo_val = jiffies;
 784                 timeo_val += msecs_to_jiffies(SCTP_ADDRESS_TICK_DELAY);
 785                 mod_timer(&net->sctp.addr_wq_timer, timeo_val);
 786         }
 787         spin_unlock_bh(&net->sctp.addr_wq_lock);
 788 }
 789
 790 /* Event handler for inet address addition/deletion events.
 791  * The sctp_local_addr_list needs to be protocted by a spin lock since
 792  * multiple notifiers (say IPv4 and IPv6) may be running at the same
 793  * time and thus corrupt the list.
 794  * The reader side is protected with RCU.
 795  */
 796 static int sctp_inetaddr_event(struct notifier_block *this, unsigned long ev,
 797                                void *ptr)
 798 {
 799         struct in_ifaddr *ifa = (struct in_ifaddr *)ptr;
 800         struct sctp_sockaddr_entry *addr = NULL;
 801         struct sctp_sockaddr_entry *temp;
 802         struct net *net = dev_net(ifa->ifa_dev->dev);
 803         int found = 0;
 804
 805         switch (ev) {
 806         case NETDEV_UP:
 807                 addr = kzalloc(sizeof(*addr), GFP_ATOMIC);
 808                 if (addr) {
 809                         addr->a.v4.sin_family = AF_INET;
 810                         addr->a.v4.sin_addr.s_addr = ifa->ifa_local;
 811                         addr->valid = 1;
 812                         spin_lock_bh(&net->sctp.local_addr_lock);
 813                         list_add_tail_rcu(&addr->list, &net->sctp.local_addr_list);
 814                         sctp_addr_wq_mgmt(net, addr, SCTP_ADDR_NEW);
 815                         spin_unlock_bh(&net->sctp.local_addr_lock);
 816                 }
 817                 break;
 818         case NETDEV_DOWN:
 819                 spin_lock_bh(&net->sctp.local_addr_lock);
 820                 list_for_each_entry_safe(addr, temp,
 821                                         &net->sctp.local_addr_list, list) {
 822                         if (addr->a.sa.sa_family == AF_INET &&
 823                                         addr->a.v4.sin_addr.s_addr ==
 824                                         ifa->ifa_local) {
 825                                 found = 1;
 826                                 addr->valid = 0;
 827                                 list_del_rcu(&addr->list);
 828                                 sctp_addr_wq_mgmt(net, addr, SCTP_ADDR_DEL);
 829                                 break;
 830                         }
 831                 }
 832                 spin_unlock_bh(&net->sctp.local_addr_lock);
 833                 if (found)
 834                         kfree_rcu(addr, rcu);
 835                 break;
 836         }
 837
 838         return NOTIFY_DONE;
 839 }
 840
 841 /*
 842  * Initialize the control inode/socket with a control endpoint data
 843  * structure.  This endpoint is reserved exclusively for the OOTB processing.
 844  */
 845 static int sctp_ctl_sock_init(struct net *net)
 846 {
 847         int err;
 848         sa_family_t family = PF_INET;
 849
 850         if (sctp_get_pf_specific(PF_INET6))
 851                 family = PF_INET6;
 852
 853         err = inet_ctl_sock_create(&net->sctp.ctl_sock, family,
 854                                    SOCK_SEQPACKET, IPPROTO_SCTP, net);
 855
 856         /* If IPv6 socket could not be created, try the IPv4 socket */
 857         if (err < 0 && family == PF_INET6)
 858                 err = inet_ctl_sock_create(&net->sctp.ctl_sock, AF_INET,
 859                                            SOCK_SEQPACKET, IPPROTO_SCTP,
 860                                            net);
 861
 862         if (err < 0) {
 863                 pr_err("Failed to create the SCTP control socket\n");
 864                 return err;
 865         }
 866         return 0;
 867 }
 868
 869 static int sctp_udp_rcv(struct sock *sk, struct sk_buff *skb)
 870 {
 871         SCTP_INPUT_CB(skb)->encap_port = udp_hdr(skb)->source;
 872
 873         skb_set_transport_header(skb, sizeof(struct udphdr));
 874         sctp_rcv(skb);
 875         return 0;
 876 }
 877
 878 int sctp_udp_sock_start(struct net *net)
 879 {
 880         struct udp_tunnel_sock_cfg tuncfg = {NULL};
 881         struct udp_port_cfg udp_conf = {0};
 882         struct socket *sock;
 883         int err;
 884
 885         udp_conf.family = AF_INET;
 886         udp_conf.local_ip.s_addr = htonl(INADDR_ANY);
 887         udp_conf.local_udp_port = htons(net->sctp.udp_port);
 888         err = udp_sock_create(net, &udp_conf, &sock);
 889         if (err) {
 890                 pr_err("Failed to create the SCTP UDP tunneling v4 sock\n");
 891                 return err;
 892         }
 893
 894         tuncfg.encap_type = 1;
 895         tuncfg.encap_rcv = sctp_udp_rcv;
 896         tuncfg.encap_err_lookup = sctp_udp_v4_err;
 897         setup_udp_tunnel_sock(net, sock, &tuncfg);
 898         net->sctp.udp4_sock = sock->sk;
 899
 900 #if IS_ENABLED(CONFIG_IPV6)
 901         memset(&udp_conf, 0, sizeof(udp_conf));
 902
 903         udp_conf.family = AF_INET6;
 904         udp_conf.local_ip6 = in6addr_any;
 905         udp_conf.local_udp_port = htons(net->sctp.udp_port);
 906         udp_conf.use_udp6_rx_checksums = true;
 907         udp_conf.ipv6_v6only = true;
 908         err = udp_sock_create(net, &udp_conf, &sock);
 909         if (err) {
 910                 pr_err("Failed to create the SCTP UDP tunneling v6 sock\n");
 911                 udp_tunnel_sock_release(net->sctp.udp4_sock->sk_socket);
 912                 net->sctp.udp4_sock = NULL;
 913                 return err;
 914         }
 915
 916         tuncfg.encap_type = 1;
 917         tuncfg.encap_rcv = sctp_udp_rcv;
 918         tuncfg.encap_err_lookup = sctp_udp_v6_err;
 919         setup_udp_tunnel_sock(net, sock, &tuncfg);
 920         net->sctp.udp6_sock = sock->sk;
 921 #endif
 922
 923         return 0;
 924 }
 925
 926 void sctp_udp_sock_stop(struct net *net)
 927 {
 928         if (net->sctp.udp4_sock) {
 929                 udp_tunnel_sock_release(net->sctp.udp4_sock->sk_socket);
 930                 net->sctp.udp4_sock = NULL;
 931         }
 932         if (net->sctp.udp6_sock) {
 933                 udp_tunnel_sock_release(net->sctp.udp6_sock->sk_socket);
 934                 net->sctp.udp6_sock = NULL;
 935         }
 936 }
 937
 938 /* Register address family specific functions. */
 939 int sctp_register_af(struct sctp_af *af)
 940 {
 941         switch (af->sa_family) {
 942         case AF_INET:
 943                 if (sctp_af_v4_specific)
 944                         return 0;
 945                 sctp_af_v4_specific = af;
 946                 break;
 947         case AF_INET6:
 948                 if (sctp_af_v6_specific)
 949                         return 0;
 950                 sctp_af_v6_specific = af;
 951                 break;
 952         default:
 953                 return 0;
 954         }
 955
 956         INIT_LIST_HEAD(&af->list);
 957         list_add_tail(&af->list, &sctp_address_families);
 958         return 1;
 959 }
 960
 961 /* Get the table of functions for manipulating a particular address
 962  * family.
 963  */
 964 struct sctp_af *sctp_get_af_specific(sa_family_t family)
 965 {
 966         switch (family) {
 967         case AF_INET:
 968                 return sctp_af_v4_specific;
 969         case AF_INET6:
 970                 return sctp_af_v6_specific;
 971         default:
 972                 return NULL;
 973         }
 974 }
 975
 976 /* Common code to initialize a AF_INET msg_name. */
 977 static void sctp_inet_msgname(char *msgname, int *addr_len)
 978 {
 979         struct sockaddr_in *sin;
 980
 981         sin = (struct sockaddr_in *)msgname;
 982         *addr_len = sizeof(struct sockaddr_in);
 983         sin->sin_family = AF_INET;
 984         memset(sin->sin_zero, 0, sizeof(sin->sin_zero));
 985 }
 986
 987 /* Copy the primary address of the peer primary address as the msg_name. */
 988 static void sctp_inet_event_msgname(struct sctp_ulpevent *event, char *msgname,
 989                                     int *addr_len)
 990 {
 991         struct sockaddr_in *sin, *sinfrom;
 992
 993         if (msgname) {
 994                 struct sctp_association *asoc;
 995
 996                 asoc = event->asoc;
 997                 sctp_inet_msgname(msgname, addr_len);
 998                 sin = (struct sockaddr_in *)msgname;
 999                 sinfrom = &asoc->peer.primary_addr.v4;
1000                 sin->sin_port = htons(asoc->peer.port);
1001                 sin->sin_addr.s_addr = sinfrom->sin_addr.s_addr;
1002         }
1003 }
1004
1005 /* Initialize and copy out a msgname from an inbound skb. */
1006 static void sctp_inet_skb_msgname(struct sk_buff *skb, char *msgname, int *len)
1007 {
1008         if (msgname) {
1009                 struct sctphdr *sh = sctp_hdr(skb);
1010                 struct sockaddr_in *sin = (struct sockaddr_in *)msgname;
1011
1012                 sctp_inet_msgname(msgname, len);
1013                 sin->sin_port = sh->source;
1014                 sin->sin_addr.s_addr = ip_hdr(skb)->saddr;
1015         }
1016 }
1017
1018 /* Do we support this AF? */
1019 static int sctp_inet_af_supported(sa_family_t family, struct sctp_sock *sp)
1020 {
1021         /* PF_INET only supports AF_INET addresses. */
1022         return AF_INET == family;
1023 }
1024
1025 /* Address matching with wildcards allowed. */
1026 static int sctp_inet_cmp_addr(const union sctp_addr *addr1,
1027                               const union sctp_addr *addr2,
1028                               struct sctp_sock *opt)
1029 {
1030         /* PF_INET only supports AF_INET addresses. */
1031         if (addr1->sa.sa_family != addr2->sa.sa_family)
1032                 return 0;
1033         if (htonl(INADDR_ANY) == addr1->v4.sin_addr.s_addr ||
1034             htonl(INADDR_ANY) == addr2->v4.sin_addr.s_addr)
1035                 return 1;
1036         if (addr1->v4.sin_addr.s_addr == addr2->v4.sin_addr.s_addr)
1037                 return 1;
1038
1039         return 0;
1040 }
1041
1042 /* Verify that provided sockaddr looks bindable.  Common verification has
1043  * already been taken care of.
1044  */
1045 static int sctp_inet_bind_verify(struct sctp_sock *opt, union sctp_addr *addr)
1046 {
1047         return sctp_v4_available(addr, opt);
1048 }
1049
1050 /* Verify that sockaddr looks sendable.  Common verification has already
1051  * been taken care of.
1052  */
1053 static int sctp_inet_send_verify(struct sctp_sock *opt, union sctp_addr *addr)
1054 {
1055         return 1;
1056 }
1057
1058 /* Fill in Supported Address Type information for INIT and INIT-ACK
1059  * chunks.  Returns number of addresses supported.
1060  */
1061 static int sctp_inet_supported_addrs(const struct sctp_sock *opt,
1062                                      __be16 *types)
1063 {
1064         types[0] = SCTP_PARAM_IPV4_ADDRESS;
1065         return 1;
1066 }
1067
1068 /* Wrapper routine that calls the ip transmit routine. */
1069 static inline int sctp_v4_xmit(struct sk_buff *skb, struct sctp_transport *t)
1070 {
1071         struct dst_entry *dst = dst_clone(t->dst);
1072         struct flowi4 *fl4 = &t->fl.u.ip4;
1073         struct sock *sk = skb->sk;
1074         struct inet_sock *inet = inet_sk(sk);
1075         __u8 dscp = READ_ONCE(inet->tos);
1076         __be16 df = 0;
1077
1078         pr_debug("%s: skb:%p, len:%d, src:%pI4, dst:%pI4\n", __func__, skb,
1079                  skb->len, &fl4->saddr, &fl4->daddr);
1080
1081         if (t->dscp & SCTP_DSCP_SET_MASK)
1082                 dscp = t->dscp & SCTP_DSCP_VAL_MASK;
1083
1084         inet->pmtudisc = t->param_flags & SPP_PMTUD_ENABLE ? IP_PMTUDISC_DO
1085                                                            : IP_PMTUDISC_DONT;
1086         SCTP_INC_STATS(sock_net(sk), SCTP_MIB_OUTSCTPPACKS);
1087
1088         if (!t->encap_port || !sctp_sk(sk)->udp_port) {
1089                 skb_dst_set(skb, dst);
1090                 return __ip_queue_xmit(sk, skb, &t->fl, dscp);
1091         }
1092
1093         if (skb_is_gso(skb))
1094                 skb_shinfo(skb)->gso_type |= SKB_GSO_UDP_TUNNEL_CSUM;
1095
1096         if (ip_dont_fragment(sk, dst) && !skb->ignore_df)
1097                 df = htons(IP_DF);
1098
1099         skb->encapsulation = 1;
1100         skb_reset_inner_mac_header(skb);
1101         skb_reset_inner_transport_header(skb);
1102         skb_set_inner_ipproto(skb, IPPROTO_SCTP);
1103         udp_tunnel_xmit_skb(dst_rtable(dst), sk, skb, fl4->saddr,
1104                             fl4->daddr, dscp, ip4_dst_hoplimit(dst), df,
1105                             sctp_sk(sk)->udp_port, t->encap_port, false, false);
1106         return 0;
1107 }
1108
1109 static struct sctp_af sctp_af_inet;
1110
1111 static struct sctp_pf sctp_pf_inet = {
1112         .event_msgname = sctp_inet_event_msgname,
1113         .skb_msgname   = sctp_inet_skb_msgname,
1114         .af_supported  = sctp_inet_af_supported,
1115         .cmp_addr      = sctp_inet_cmp_addr,
1116         .bind_verify   = sctp_inet_bind_verify,
1117         .send_verify   = sctp_inet_send_verify,
1118         .supported_addrs = sctp_inet_supported_addrs,
1119         .create_accept_sk = sctp_v4_create_accept_sk,
1120         .addr_to_user  = sctp_v4_addr_to_user,
1121         .to_sk_saddr   = sctp_v4_to_sk_saddr,
1122         .to_sk_daddr   = sctp_v4_to_sk_daddr,
1123         .copy_ip_options = sctp_v4_copy_ip_options,
1124         .af            = &sctp_af_inet
1125 };
1126
1127 /* Notifier for inetaddr addition/deletion events.  */
1128 static struct notifier_block sctp_inetaddr_notifier = {
1129         .notifier_call = sctp_inetaddr_event,
1130 };
1131
1132 /* Socket operations.  */
1133 static const struct proto_ops inet_seqpacket_ops = {
1134         .family            = PF_INET,
1135         .owner             = THIS_MODULE,
1136         .release           = inet_release,      /* Needs to be wrapped... */
1137         .bind              = inet_bind,
1138         .connect           = sctp_inet_connect,
1139         .socketpair        = sock_no_socketpair,
1140         .accept            = inet_accept,
1141         .getname           = inet_getname,      /* Semantics are different.  */
1142         .poll              = sctp_poll,
1143         .ioctl             = inet_ioctl,
1144         .gettstamp         = sock_gettstamp,
1145         .listen            = sctp_inet_listen,
1146         .shutdown          = inet_shutdown,     /* Looks harmless.  */
1147         .setsockopt        = sock_common_setsockopt, /* IP_SOL IP_OPTION is a problem */
1148         .getsockopt        = sock_common_getsockopt,
1149         .sendmsg           = inet_sendmsg,
1150         .recvmsg           = inet_recvmsg,
1151         .mmap              = sock_no_mmap,
1152 };
1153
1154 /* Registration with AF_INET family.  */
1155 static struct inet_protosw sctp_seqpacket_protosw = {
1156         .type       = SOCK_SEQPACKET,
1157         .protocol   = IPPROTO_SCTP,
1158         .prot       = &sctp_prot,
1159         .ops        = &inet_seqpacket_ops,
1160         .flags      = SCTP_PROTOSW_FLAG
1161 };
1162 static struct inet_protosw sctp_stream_protosw = {
1163         .type       = SOCK_STREAM,
1164         .protocol   = IPPROTO_SCTP,
1165         .prot       = &sctp_prot,
1166         .ops        = &inet_seqpacket_ops,
1167         .flags      = SCTP_PROTOSW_FLAG
1168 };
1169
1170 static int sctp4_rcv(struct sk_buff *skb)
1171 {
1172         SCTP_INPUT_CB(skb)->encap_port = 0;
1173         return sctp_rcv(skb);
1174 }
1175
1176 /* Register with IP layer.  */
1177 static const struct net_protocol sctp_protocol = {
1178         .handler     = sctp4_rcv,
1179         .err_handler = sctp_v4_err,
1180         .no_policy   = 1,
1181         .icmp_strict_tag_validation = 1,
1182 };
1183
1184 /* IPv4 address related functions.  */
1185 static struct sctp_af sctp_af_inet = {
1186         .sa_family         = AF_INET,
1187         .sctp_xmit         = sctp_v4_xmit,
1188         .setsockopt        = ip_setsockopt,
1189         .getsockopt        = ip_getsockopt,
1190         .get_dst           = sctp_v4_get_dst,
1191         .get_saddr         = sctp_v4_get_saddr,
1192         .copy_addrlist     = sctp_v4_copy_addrlist,
1193         .from_skb          = sctp_v4_from_skb,
1194         .from_sk           = sctp_v4_from_sk,
1195         .from_addr_param   = sctp_v4_from_addr_param,
1196         .to_addr_param     = sctp_v4_to_addr_param,
1197         .cmp_addr          = sctp_v4_cmp_addr,
1198         .addr_valid        = sctp_v4_addr_valid,
1199         .inaddr_any        = sctp_v4_inaddr_any,
1200         .is_any            = sctp_v4_is_any,
1201         .available         = sctp_v4_available,
1202         .scope             = sctp_v4_scope,
1203         .skb_iif           = sctp_v4_skb_iif,
1204         .skb_sdif          = sctp_v4_skb_sdif,
1205         .is_ce             = sctp_v4_is_ce,
1206         .seq_dump_addr     = sctp_v4_seq_dump_addr,
1207         .ecn_capable       = sctp_v4_ecn_capable,
1208         .net_header_len    = sizeof(struct iphdr),
1209         .sockaddr_len      = sizeof(struct sockaddr_in),
1210         .ip_options_len    = sctp_v4_ip_options_len,
1211 };
1212
1213 struct sctp_pf *sctp_get_pf_specific(sa_family_t family)
1214 {
1215         switch (family) {
1216         case PF_INET:
1217                 return sctp_pf_inet_specific;
1218         case PF_INET6:
1219                 return sctp_pf_inet6_specific;
1220         default:
1221                 return NULL;
1222         }
1223 }
1224
1225 /* Register the PF specific function table.  */
1226 int sctp_register_pf(struct sctp_pf *pf, sa_family_t family)
1227 {
1228         switch (family) {
1229         case PF_INET:
1230                 if (sctp_pf_inet_specific)
1231                         return 0;
1232                 sctp_pf_inet_specific = pf;
1233                 break;
1234         case PF_INET6:
1235                 if (sctp_pf_inet6_specific)
1236                         return 0;
1237                 sctp_pf_inet6_specific = pf;
1238                 break;
1239         default:
1240                 return 0;
1241         }
1242         return 1;
1243 }
1244
1245 static inline int init_sctp_mibs(struct net *net)
1246 {
1247         net->sctp.sctp_statistics = alloc_percpu(struct sctp_mib);
1248         if (!net->sctp.sctp_statistics)
1249                 return -ENOMEM;
1250         return 0;
1251 }
1252
1253 static inline void cleanup_sctp_mibs(struct net *net)
1254 {
1255         free_percpu(net->sctp.sctp_statistics);
1256 }
1257
1258 static void sctp_v4_pf_init(void)
1259 {
1260         /* Initialize the SCTP specific PF functions. */
1261         sctp_register_pf(&sctp_pf_inet, PF_INET);
1262         sctp_register_af(&sctp_af_inet);
1263 }
1264
1265 static void sctp_v4_pf_exit(void)
1266 {
1267         list_del(&sctp_af_inet.list);
1268 }
1269
1270 static int sctp_v4_protosw_init(void)
1271 {
1272         int rc;
1273
1274         rc = proto_register(&sctp_prot, 1);
1275         if (rc)
1276                 return rc;
1277
1278         /* Register SCTP(UDP and TCP style) with socket layer.  */
1279         inet_register_protosw(&sctp_seqpacket_protosw);
1280         inet_register_protosw(&sctp_stream_protosw);
1281
1282         return 0;
1283 }
1284
1285 static void sctp_v4_protosw_exit(void)
1286 {
1287         inet_unregister_protosw(&sctp_stream_protosw);
1288         inet_unregister_protosw(&sctp_seqpacket_protosw);
1289         proto_unregister(&sctp_prot);
1290 }
1291
1292 static int sctp_v4_add_protocol(void)
1293 {
1294         /* Register notifier for inet address additions/deletions. */
1295         register_inetaddr_notifier(&sctp_inetaddr_notifier);
1296
1297         /* Register SCTP with inet layer.  */
1298         if (inet_add_protocol(&sctp_protocol, IPPROTO_SCTP) < 0)
1299                 return -EAGAIN;
1300
1301         return 0;
1302 }
1303
1304 static void sctp_v4_del_protocol(void)
1305 {
1306         inet_del_protocol(&sctp_protocol, IPPROTO_SCTP);
1307         unregister_inetaddr_notifier(&sctp_inetaddr_notifier);
1308 }
1309
1310 static int __net_init sctp_defaults_init(struct net *net)
1311 {
1312         int status;
1313
1314         /*
1315          * 14. Suggested SCTP Protocol Parameter Values
1316          */
1317         /* The following protocol parameters are RECOMMENDED:  */
1318         /* RTO.Initial              - 3  seconds */
1319         net->sctp.rto_initial                   = SCTP_RTO_INITIAL;
1320         /* RTO.Min                  - 1  second */
1321         net->sctp.rto_min                       = SCTP_RTO_MIN;
1322         /* RTO.Max                 -  60 seconds */
1323         net->sctp.rto_max                       = SCTP_RTO_MAX;
1324         /* RTO.Alpha                - 1/8 */
1325         net->sctp.rto_alpha                     = SCTP_RTO_ALPHA;
1326         /* RTO.Beta                 - 1/4 */
1327         net->sctp.rto_beta                      = SCTP_RTO_BETA;
1328
1329         /* Valid.Cookie.Life        - 60  seconds */
1330         net->sctp.valid_cookie_life             = SCTP_DEFAULT_COOKIE_LIFE;
1331
1332         /* Whether Cookie Preservative is enabled(1) or not(0) */
1333         net->sctp.cookie_preserve_enable        = 1;
1334
1335         /* Default sctp sockets to use md5 as their hmac alg */
1336 #if defined (CONFIG_SCTP_DEFAULT_COOKIE_HMAC_MD5)
1337         net->sctp.sctp_hmac_alg                 = "md5";
1338 #elif defined (CONFIG_SCTP_DEFAULT_COOKIE_HMAC_SHA1)
1339         net->sctp.sctp_hmac_alg                 = "sha1";
1340 #else
1341         net->sctp.sctp_hmac_alg                 = NULL;
1342 #endif
1343
1344         /* Max.Burst                - 4 */
1345         net->sctp.max_burst                     = SCTP_DEFAULT_MAX_BURST;
1346
1347         /* Disable of Primary Path Switchover by default */
1348         net->sctp.ps_retrans = SCTP_PS_RETRANS_MAX;
1349
1350         /* Enable pf state by default */
1351         net->sctp.pf_enable = 1;
1352
1353         /* Ignore pf exposure feature by default */
1354         net->sctp.pf_expose = SCTP_PF_EXPOSE_UNSET;
1355
1356         /* Association.Max.Retrans  - 10 attempts
1357          * Path.Max.Retrans         - 5  attempts (per destination address)
1358          * Max.Init.Retransmits     - 8  attempts
1359          */
1360         net->sctp.max_retrans_association       = 10;
1361         net->sctp.max_retrans_path              = 5;
1362         net->sctp.max_retrans_init              = 8;
1363
1364         /* Sendbuffer growth        - do per-socket accounting */
1365         net->sctp.sndbuf_policy                 = 0;
1366
1367         /* Rcvbuffer growth         - do per-socket accounting */
1368         net->sctp.rcvbuf_policy                 = 0;
1369
1370         /* HB.interval              - 30 seconds */
1371         net->sctp.hb_interval                   = SCTP_DEFAULT_TIMEOUT_HEARTBEAT;
1372
1373         /* delayed SACK timeout */
1374         net->sctp.sack_timeout                  = SCTP_DEFAULT_TIMEOUT_SACK;
1375
1376         /* Disable ADDIP by default. */
1377         net->sctp.addip_enable = 0;
1378         net->sctp.addip_noauth = 0;
1379         net->sctp.default_auto_asconf = 0;
1380
1381         /* Enable PR-SCTP by default. */
1382         net->sctp.prsctp_enable = 1;
1383
1384         /* Disable RECONF by default. */
1385         net->sctp.reconf_enable = 0;
1386
1387         /* Disable AUTH by default. */
1388         net->sctp.auth_enable = 0;
1389
1390         /* Enable ECN by default. */
1391         net->sctp.ecn_enable = 1;
1392
1393         /* Set UDP tunneling listening port to 0 by default */
1394         net->sctp.udp_port = 0;
1395
1396         /* Set remote encap port to 0 by default */
1397         net->sctp.encap_port = 0;
1398
1399         /* Set SCOPE policy to enabled */
1400         net->sctp.scope_policy = SCTP_SCOPE_POLICY_ENABLE;
1401
1402         /* Set the default rwnd update threshold */
1403         net->sctp.rwnd_upd_shift = SCTP_DEFAULT_RWND_SHIFT;
1404
1405         /* Initialize maximum autoclose timeout. */
1406         net->sctp.max_autoclose         = INT_MAX / HZ;
1407
1408 #ifdef CONFIG_NET_L3_MASTER_DEV
1409         net->sctp.l3mdev_accept = 1;
1410 #endif
1411
1412         status = sctp_sysctl_net_register(net);
1413         if (status)
1414                 goto err_sysctl_register;
1415
1416         /* Allocate and initialise sctp mibs.  */
1417         status = init_sctp_mibs(net);
1418         if (status)
1419                 goto err_init_mibs;
1420
1421 #ifdef CONFIG_PROC_FS
1422         /* Initialize proc fs directory.  */
1423         status = sctp_proc_init(net);
1424         if (status)
1425                 goto err_init_proc;
1426 #endif
1427
1428         sctp_dbg_objcnt_init(net);
1429
1430         /* Initialize the local address list. */
1431         INIT_LIST_HEAD(&net->sctp.local_addr_list);
1432         spin_lock_init(&net->sctp.local_addr_lock);
1433         sctp_get_local_addr_list(net);
1434
1435         /* Initialize the address event list */
1436         INIT_LIST_HEAD(&net->sctp.addr_waitq);
1437         INIT_LIST_HEAD(&net->sctp.auto_asconf_splist);
1438         spin_lock_init(&net->sctp.addr_wq_lock);
1439         net->sctp.addr_wq_timer.expires = 0;
1440         timer_setup(&net->sctp.addr_wq_timer, sctp_addr_wq_timeout_handler, 0);
1441
1442         return 0;
1443
1444 #ifdef CONFIG_PROC_FS
1445 err_init_proc:
1446         cleanup_sctp_mibs(net);
1447 #endif
1448 err_init_mibs:
1449         sctp_sysctl_net_unregister(net);
1450 err_sysctl_register:
1451         return status;
1452 }
1453
1454 static void __net_exit sctp_defaults_exit(struct net *net)
1455 {
1456         /* Free the local address list */
1457         sctp_free_addr_wq(net);
1458         sctp_free_local_addr_list(net);
1459
1460 #ifdef CONFIG_PROC_FS
1461         remove_proc_subtree("sctp", net->proc_net);
1462         net->sctp.proc_net_sctp = NULL;
1463 #endif
1464         cleanup_sctp_mibs(net);
1465         sctp_sysctl_net_unregister(net);
1466 }
1467
1468 static struct pernet_operations sctp_defaults_ops = {
1469         .init = sctp_defaults_init,
1470         .exit = sctp_defaults_exit,
1471 };
1472
1473 static int __net_init sctp_ctrlsock_init(struct net *net)
1474 {
1475         int status;
1476
1477         /* Initialize the control inode/socket for handling OOTB packets.  */
1478         status = sctp_ctl_sock_init(net);
1479         if (status)
1480                 pr_err("Failed to initialize the SCTP control sock\n");
1481
1482         return status;
1483 }
1484
1485 static void __net_exit sctp_ctrlsock_exit(struct net *net)
1486 {
1487         /* Free the control endpoint.  */
1488         inet_ctl_sock_destroy(net->sctp.ctl_sock);
1489 }
1490
1491 static struct pernet_operations sctp_ctrlsock_ops = {
1492         .init = sctp_ctrlsock_init,
1493         .exit = sctp_ctrlsock_exit,
1494 };
1495
1496 /* Initialize the universe into something sensible.  */
1497 static __init int sctp_init(void)
1498 {
1499         unsigned long nr_pages = totalram_pages();
1500         unsigned long limit;
1501         unsigned long goal;
1502         int max_entry_order;
1503         int num_entries;
1504         int max_share;
1505         int status;
1506         int order;
1507         int i;
1508
1509         sock_skb_cb_check_size(sizeof(struct sctp_ulpevent));
1510
1511         /* Allocate bind_bucket and chunk caches. */
1512         status = -ENOBUFS;
1513         sctp_bucket_cachep = KMEM_CACHE(sctp_bind_bucket, SLAB_HWCACHE_ALIGN);
1514         if (!sctp_bucket_cachep)
1515                 goto out;
1516
1517         sctp_chunk_cachep = KMEM_CACHE(sctp_chunk, SLAB_HWCACHE_ALIGN);
1518         if (!sctp_chunk_cachep)
1519                 goto err_chunk_cachep;
1520
1521         status = percpu_counter_init(&sctp_sockets_allocated, 0, GFP_KERNEL);
1522         if (status)
1523                 goto err_percpu_counter_init;
1524
1525         /* Implementation specific variables. */
1526
1527         /* Initialize default stream count setup information. */
1528         sctp_max_instreams              = SCTP_DEFAULT_INSTREAMS;
1529         sctp_max_outstreams             = SCTP_DEFAULT_OUTSTREAMS;
1530
1531         /* Initialize handle used for association ids. */
1532         idr_init(&sctp_assocs_id);
1533
1534         limit = nr_free_buffer_pages() / 8;
1535         limit = max(limit, 128UL);
1536         sysctl_sctp_mem[0] = limit / 4 * 3;
1537         sysctl_sctp_mem[1] = limit;
1538         sysctl_sctp_mem[2] = sysctl_sctp_mem[0] * 2;
1539
1540         /* Set per-socket limits to no more than 1/128 the pressure threshold*/
1541         limit = (sysctl_sctp_mem[1]) << (PAGE_SHIFT - 7);
1542         max_share = min(4UL*1024*1024, limit);
1543
1544         sysctl_sctp_rmem[0] = PAGE_SIZE; /* give each asoc 1 page min */
1545         sysctl_sctp_rmem[1] = 1500 * SKB_TRUESIZE(1);
1546         sysctl_sctp_rmem[2] = max(sysctl_sctp_rmem[1], max_share);
1547
1548         sysctl_sctp_wmem[0] = PAGE_SIZE;
1549         sysctl_sctp_wmem[1] = 16*1024;
1550         sysctl_sctp_wmem[2] = max(64*1024, max_share);
1551
1552         /* Size and allocate the association hash table.
1553          * The methodology is similar to that of the tcp hash tables.
1554          * Though not identical.  Start by getting a goal size
1555          */
1556         if (nr_pages >= (128 * 1024))
1557                 goal = nr_pages >> (22 - PAGE_SHIFT);
1558         else
1559                 goal = nr_pages >> (24 - PAGE_SHIFT);
1560
1561         /* Then compute the page order for said goal */
1562         order = get_order(goal);
1563
1564         /* Now compute the required page order for the maximum sized table we
1565          * want to create
1566          */
1567         max_entry_order = get_order(MAX_SCTP_PORT_HASH_ENTRIES *
1568                                     sizeof(struct sctp_bind_hashbucket));
1569
1570         /* Limit the page order by that maximum hash table size */
1571         order = min(order, max_entry_order);
1572
1573         /* Allocate and initialize the endpoint hash table.  */
1574         sctp_ep_hashsize = 64;
1575         sctp_ep_hashtable =
1576                 kmalloc_array(64, sizeof(struct sctp_hashbucket), GFP_KERNEL);
1577         if (!sctp_ep_hashtable) {
1578                 pr_err("Failed endpoint_hash alloc\n");
1579                 status = -ENOMEM;
1580                 goto err_ehash_alloc;
1581         }
1582         for (i = 0; i < sctp_ep_hashsize; i++) {
1583                 rwlock_init(&sctp_ep_hashtable[i].lock);
1584                 INIT_HLIST_HEAD(&sctp_ep_hashtable[i].chain);
1585         }
1586
1587         /* Allocate and initialize the SCTP port hash table.
1588          * Note that order is initalized to start at the max sized
1589          * table we want to support.  If we can't get that many pages
1590          * reduce the order and try again
1591          */
1592         do {
1593                 sctp_port_hashtable = (struct sctp_bind_hashbucket *)
1594                         __get_free_pages(GFP_KERNEL | __GFP_NOWARN, order);
1595         } while (!sctp_port_hashtable && --order > 0);
1596
1597         if (!sctp_port_hashtable) {
1598                 pr_err("Failed bind hash alloc\n");
1599                 status = -ENOMEM;
1600                 goto err_bhash_alloc;
1601         }
1602
1603         /* Now compute the number of entries that will fit in the
1604          * port hash space we allocated
1605          */
1606         num_entries = (1UL << order) * PAGE_SIZE /
1607                       sizeof(struct sctp_bind_hashbucket);
1608
1609         /* And finish by rounding it down to the nearest power of two.
1610          * This wastes some memory of course, but it's needed because
1611          * the hash function operates based on the assumption that
1612          * the number of entries is a power of two.
1613          */
1614         sctp_port_hashsize = rounddown_pow_of_two(num_entries);
1615
1616         for (i = 0; i < sctp_port_hashsize; i++) {
1617                 spin_lock_init(&sctp_port_hashtable[i].lock);
1618                 INIT_HLIST_HEAD(&sctp_port_hashtable[i].chain);
1619         }
1620
1621         status = sctp_transport_hashtable_init();
1622         if (status)
1623                 goto err_thash_alloc;
1624
1625         pr_info("Hash tables configured (bind %d/%d)\n", sctp_port_hashsize,
1626                 num_entries);
1627
1628         sctp_sysctl_register();
1629
1630         INIT_LIST_HEAD(&sctp_address_families);
1631         sctp_v4_pf_init();
1632         sctp_v6_pf_init();
1633         sctp_sched_ops_init();
1634
1635         status = register_pernet_subsys(&sctp_defaults_ops);
1636         if (status)
1637                 goto err_register_defaults;
1638
1639         status = sctp_v4_protosw_init();
1640         if (status)
1641                 goto err_protosw_init;
1642
1643         status = sctp_v6_protosw_init();
1644         if (status)
1645                 goto err_v6_protosw_init;
1646
1647         status = register_pernet_subsys(&sctp_ctrlsock_ops);
1648         if (status)
1649                 goto err_register_ctrlsock;
1650
1651         status = sctp_v4_add_protocol();
1652         if (status)
1653                 goto err_add_protocol;
1654
1655         /* Register SCTP with inet6 layer.  */
1656         status = sctp_v6_add_protocol();
1657         if (status)
1658                 goto err_v6_add_protocol;
1659
1660         if (sctp_offload_init() < 0)
1661                 pr_crit("%s: Cannot add SCTP protocol offload\n", __func__);
1662
1663 out:
1664         return status;
1665 err_v6_add_protocol:
1666         sctp_v4_del_protocol();
1667 err_add_protocol:
1668         unregister_pernet_subsys(&sctp_ctrlsock_ops);
1669 err_register_ctrlsock:
1670         sctp_v6_protosw_exit();
1671 err_v6_protosw_init:
1672         sctp_v4_protosw_exit();
1673 err_protosw_init:
1674         unregister_pernet_subsys(&sctp_defaults_ops);
1675 err_register_defaults:
1676         sctp_v4_pf_exit();
1677         sctp_v6_pf_exit();
1678         sctp_sysctl_unregister();
1679         free_pages((unsigned long)sctp_port_hashtable,
1680                    get_order(sctp_port_hashsize *
1681                              sizeof(struct sctp_bind_hashbucket)));
1682 err_bhash_alloc:
1683         sctp_transport_hashtable_destroy();
1684 err_thash_alloc:
1685         kfree(sctp_ep_hashtable);
1686 err_ehash_alloc:
1687         percpu_counter_destroy(&sctp_sockets_allocated);
1688 err_percpu_counter_init:
1689         kmem_cache_destroy(sctp_chunk_cachep);
1690 err_chunk_cachep:
1691         kmem_cache_destroy(sctp_bucket_cachep);
1692         goto out;
1693 }
1694
1695 /* Exit handler for the SCTP protocol.  */
1696 static __exit void sctp_exit(void)
1697 {
1698         /* BUG.  This should probably do something useful like clean
1699          * up all the remaining associations and all that memory.
1700          */
1701
1702         /* Unregister with inet6/inet layers. */
1703         sctp_v6_del_protocol();
1704         sctp_v4_del_protocol();
1705
1706         unregister_pernet_subsys(&sctp_ctrlsock_ops);
1707
1708         /* Free protosw registrations */
1709         sctp_v6_protosw_exit();
1710         sctp_v4_protosw_exit();
1711
1712         unregister_pernet_subsys(&sctp_defaults_ops);
1713
1714         /* Unregister with socket layer. */
1715         sctp_v6_pf_exit();
1716         sctp_v4_pf_exit();
1717
1718         sctp_sysctl_unregister();
1719
1720         free_pages((unsigned long)sctp_port_hashtable,
1721                    get_order(sctp_port_hashsize *
1722                              sizeof(struct sctp_bind_hashbucket)));
1723         kfree(sctp_ep_hashtable);
1724         sctp_transport_hashtable_destroy();
1725
1726         percpu_counter_destroy(&sctp_sockets_allocated);
1727
1728         rcu_barrier(); /* Wait for completion of call_rcu()'s */
1729
1730         kmem_cache_destroy(sctp_chunk_cachep);
1731         kmem_cache_destroy(sctp_bucket_cachep);
1732 }
1733
1734 module_init(sctp_init);
1735 module_exit(sctp_exit);
1736
1737 /*
1738  * __stringify doesn't likes enums, so use IPPROTO_SCTP value (132) directly.
1739  */
1740 MODULE_ALIAS("net-pf-" __stringify(PF_INET) "-proto-132");
1741 MODULE_ALIAS("net-pf-" __stringify(PF_INET6) "-proto-132");
1742 MODULE_AUTHOR("Linux Kernel SCTP developers <[email protected]>");
1743 MODULE_DESCRIPTION("Support for the SCTP protocol (RFC2960)");
1744 module_param_named(no_checksums, sctp_checksum_disable, bool, 0644);
1745 MODULE_PARM_DESC(no_checksums, "Disable checksums computing and verification");
1746 MODULE_LICENSE("GPL");