net/sctp/input.c

   1 /* SCTP kernel reference Implementation
   2  * Copyright (c) 1999-2000 Cisco, Inc.
   3  * Copyright (c) 1999-2001 Motorola, Inc.
   4  * Copyright (c) 2001-2003 International Business Machines, Corp.
   5  * Copyright (c) 2001 Intel Corp.
   6  * Copyright (c) 2001 Nokia, Inc.
   7  * Copyright (c) 2001 La Monte H.P. Yarroll
   8  *
   9  * This file is part of the SCTP kernel reference Implementation
  10  *
  11  * These functions handle all input from the IP layer into SCTP.
  12  *
  13  * The SCTP reference implementation is free software;
  14  * you can redistribute it and/or modify it under the terms of
  15  * the GNU General Public License as published by
  16  * the Free Software Foundation; either version 2, or (at your option)
  17  * any later version.
  18  *
  19  * The SCTP reference implementation is distributed in the hope that it
  20  * will be useful, but WITHOUT ANY WARRANTY; without even the implied
  21  *                 ************************
  22  * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  23  * See the GNU General Public License for more details.
  24  *
  25  * You should have received a copy of the GNU General Public License
  26  * along with GNU CC; see the file COPYING.  If not, write to
  27  * the Free Software Foundation, 59 Temple Place - Suite 330,
  28  * Boston, MA 02111-1307, USA.
  29  *
  30  * Please send any bug reports or fixes you make to the
  31  * email address(es):
  32  *    lksctp developers <lksctp-developers@lists.sourceforge.net>
  33  *
  34  * Or submit a bug report through the following website:
  35  *    http://www.sf.net/projects/lksctp
  36  *
  37  * Written or modified by:
  38  *    La Monte H.P. Yarroll <piggy@acm.org>
  39  *    Karl Knutson <karl@athena.chicago.il.us>
  40  *    Xingang Guo <xingang.guo@intel.com>
  41  *    Jon Grimm <jgrimm@us.ibm.com>
  42  *    Hui Huang <hui.huang@nokia.com>
  43  *    Daisy Chang <daisyc@us.ibm.com>
  44  *    Sridhar Samudrala <sri@us.ibm.com>
  45  *    Ardelle Fan <ardelle.fan@intel.com>
  46  *
  47  * Any bugs reported given to us we will try to fix... any fixes shared will
  48  * be incorporated into the next SCTP release.
  49  */
  50
  51 #include <linux/types.h>
  52 #include <linux/list.h> /* For struct list_head */
  53 #include <linux/socket.h>
  54 #include <linux/ip.h>
  55 #include <linux/time.h> /* For struct timeval */
  56 #include <net/ip.h>
  57 #include <net/icmp.h>
  58 #include <net/snmp.h>
  59 #include <net/sock.h>
  60 #include <net/xfrm.h>
  61 #include <net/sctp/sctp.h>
  62 #include <net/sctp/sm.h>
  63
  64 /* Forward declarations for internal helpers. */
  65 static int sctp_rcv_ootb(struct sk_buff *);
  66 static struct sctp_association *__sctp_rcv_lookup(struct sk_buff *skb,
  67                                       const union sctp_addr *laddr,
  68                                       const union sctp_addr *paddr,
  69                                       struct sctp_transport **transportp);
  70 static struct sctp_endpoint *__sctp_rcv_lookup_endpoint(const union sctp_addr *laddr);
  71 static struct sctp_association *__sctp_lookup_association(
  72                                         const union sctp_addr *local,
  73                                         const union sctp_addr *peer,
  74                                         struct sctp_transport **pt);
  75
  76 static void sctp_add_backlog(struct sock *sk, struct sk_buff *skb);
  77
  78
  79 /* Calculate the SCTP checksum of an SCTP packet.  */
  80 static inline int sctp_rcv_checksum(struct sk_buff *skb)
  81 {
  82         struct sctphdr *sh;
  83         __u32 cmp, val;
  84         struct sk_buff *list = skb_shinfo(skb)->frag_list;
  85
  86         sh = (struct sctphdr *) skb->h.raw;
  87         cmp = ntohl(sh->checksum);
  88
  89         val = sctp_start_cksum((__u8 *)sh, skb_headlen(skb));
  90
  91         for (; list; list = list->next)
  92                 val = sctp_update_cksum((__u8 *)list->data, skb_headlen(list),
  93                                         val);
  94
  95         val = sctp_end_cksum(val);
  96
  97         if (val != cmp) {
  98                 /* CRC failure, dump it. */
  99                 SCTP_INC_STATS_BH(SCTP_MIB_CHECKSUMERRORS);
 100                 return -1;
 101         }
 102         return 0;
 103 }
 104
 105 struct sctp_input_cb {
 106         union {
 107                 struct inet_skb_parm    h4;
 108 #if defined(CONFIG_IPV6) || defined (CONFIG_IPV6_MODULE)
 109                 struct inet6_skb_parm   h6;
 110 #endif
 111         } header;
 112         struct sctp_chunk *chunk;
 113 };
 114 #define SCTP_INPUT_CB(__skb)    ((struct sctp_input_cb *)&((__skb)->cb[0]))
 115
 116 /*
 117  * This is the routine which IP calls when receiving an SCTP packet.
 118  */
 119 int sctp_rcv(struct sk_buff *skb)
 120 {
 121         struct sock *sk;
 122         struct sctp_association *asoc;
 123         struct sctp_endpoint *ep = NULL;
 124         struct sctp_ep_common *rcvr;
 125         struct sctp_transport *transport = NULL;
 126         struct sctp_chunk *chunk;
 127         struct sctphdr *sh;
 128         union sctp_addr src;
 129         union sctp_addr dest;
 130         int family;
 131         struct sctp_af *af;
 132
 133         if (skb->pkt_type!=PACKET_HOST)
 134                 goto discard_it;
 135
 136         SCTP_INC_STATS_BH(SCTP_MIB_INSCTPPACKS);
 137
 138         sh = (struct sctphdr *) skb->h.raw;
 139
 140         /* Pull up the IP and SCTP headers. */
 141         __skb_pull(skb, skb->h.raw - skb->data);
 142         if (skb->len < sizeof(struct sctphdr))
 143                 goto discard_it;
 144         if (sctp_rcv_checksum(skb) < 0)
 145                 goto discard_it;
 146
 147         skb_pull(skb, sizeof(struct sctphdr));
 148
 149         /* Make sure we at least have chunk headers worth of data left. */
 150         if (skb->len < sizeof(struct sctp_chunkhdr))
 151                 goto discard_it;
 152
 153         family = ipver2af(skb->nh.iph->version);
 154         af = sctp_get_af_specific(family);
 155         if (unlikely(!af))
 156                 goto discard_it;
 157
 158         /* Initialize local addresses for lookups. */
 159         af->from_skb(&src, skb, 1);
 160         af->from_skb(&dest, skb, 0);
 161
 162         /* If the packet is to or from a non-unicast address,
 163          * silently discard the packet.
 164          *
 165          * This is not clearly defined in the RFC except in section
 166          * 8.4 - OOTB handling.  However, based on the book "Stream Control
 167          * Transmission Protocol" 2.1, "It is important to note that the
 168          * IP address of an SCTP transport address must be a routable
 169          * unicast address.  In other words, IP multicast addresses and
 170          * IP broadcast addresses cannot be used in an SCTP transport
 171          * address."
 172          */
 173         if (!af->addr_valid(&src, NULL, skb) ||
 174             !af->addr_valid(&dest, NULL, skb))
 175                 goto discard_it;
 176
 177         asoc = __sctp_rcv_lookup(skb, &src, &dest, &transport);
 178
 179         if (!asoc)
 180                 ep = __sctp_rcv_lookup_endpoint(&dest);
 181
 182         /* Retrieve the common input handling substructure. */
 183         rcvr = asoc ? &asoc->base : &ep->base;
 184         sk = rcvr->sk;
 185
 186         /*
 187          * If a frame arrives on an interface and the receiving socket is
 188          * bound to another interface, via SO_BINDTODEVICE, treat it as OOTB
 189          */
 190         if (sk->sk_bound_dev_if && (sk->sk_bound_dev_if != af->skb_iif(skb)))
 191         {
 192                 if (asoc) {
 193                         sctp_association_put(asoc);
 194                         asoc = NULL;
 195                 } else {
 196                         sctp_endpoint_put(ep);
 197                         ep = NULL;
 198                 }
 199                 sk = sctp_get_ctl_sock();
 200                 ep = sctp_sk(sk)->ep;
 201                 sctp_endpoint_hold(ep);
 202                 rcvr = &ep->base;
 203         }
 204
 205         /*
 206          * RFC 2960, 8.4 - Handle "Out of the blue" Packets.
 207          * An SCTP packet is called an "out of the blue" (OOTB)
 208          * packet if it is correctly formed, i.e., passed the
 209          * receiver's checksum check, but the receiver is not
 210          * able to identify the association to which this
 211          * packet belongs.
 212          */
 213         if (!asoc) {
 214                 if (sctp_rcv_ootb(skb)) {
 215                         SCTP_INC_STATS_BH(SCTP_MIB_OUTOFBLUES);
 216                         goto discard_release;
 217                 }
 218         }
 219
 220         /* SCTP seems to always need a timestamp right now (FIXME) */
 221         if (skb->tstamp.off_sec == 0) {
 222                 __net_timestamp(skb);
 223                 sock_enable_timestamp(sk);
 224         }
 225
 226         if (!xfrm_policy_check(sk, XFRM_POLICY_IN, skb, family))
 227                 goto discard_release;
 228         nf_reset(skb);
 229
 230         if (sk_filter(sk, skb, 1))
 231                 goto discard_release;
 232
 233         /* Create an SCTP packet structure. */
 234         chunk = sctp_chunkify(skb, asoc, sk);
 235         if (!chunk)
 236                 goto discard_release;
 237         SCTP_INPUT_CB(skb)->chunk = chunk;
 238
 239         /* Remember what endpoint is to handle this packet. */
 240         chunk->rcvr = rcvr;
 241
 242         /* Remember the SCTP header. */
 243         chunk->sctp_hdr = sh;
 244
 245         /* Set the source and destination addresses of the incoming chunk.  */
 246         sctp_init_addrs(chunk, &src, &dest);
 247
 248         /* Remember where we came from.  */
 249         chunk->transport = transport;
 250
 251         /* Acquire access to the sock lock. Note: We are safe from other
 252          * bottom halves on this lock, but a user may be in the lock too,
 253          * so check if it is busy.
 254          */
 255         sctp_bh_lock_sock(sk);
 256
 257         if (sock_owned_by_user(sk))
 258                 sctp_add_backlog(sk, skb);
 259         else
 260                 sctp_inq_push(&chunk->rcvr->inqueue, chunk);
 261
 262         sctp_bh_unlock_sock(sk);
 263
 264         /* Release the asoc/ep ref we took in the lookup calls. */
 265         if (asoc)
 266                 sctp_association_put(asoc);
 267         else
 268                 sctp_endpoint_put(ep);
 269
 270         return 0;
 271
 272 discard_it:
 273         kfree_skb(skb);
 274         return 0;
 275
 276 discard_release:
 277         /* Release the asoc/ep ref we took in the lookup calls. */
 278         if (asoc)
 279                 sctp_association_put(asoc);
 280         else
 281                 sctp_endpoint_put(ep);
 282
 283         goto discard_it;
 284 }
 285
 286 /* Process the backlog queue of the socket.  Every skb on
 287  * the backlog holds a ref on an association or endpoint.
 288  * We hold this ref throughout the state machine to make
 289  * sure that the structure we need is still around.
 290  */
 291 int sctp_backlog_rcv(struct sock *sk, struct sk_buff *skb)
 292 {
 293         struct sctp_chunk *chunk = SCTP_INPUT_CB(skb)->chunk;
 294         struct sctp_inq *inqueue = &chunk->rcvr->inqueue;
 295         struct sctp_ep_common *rcvr = NULL;
 296         int backloged = 0;
 297
 298         rcvr = chunk->rcvr;
 299
 300         /* If the rcvr is dead then the association or endpoint
 301          * has been deleted and we can safely drop the chunk
 302          * and refs that we are holding.
 303          */
 304         if (rcvr->dead) {
 305                 sctp_chunk_free(chunk);
 306                 goto done;
 307         }
 308
 309         if (unlikely(rcvr->sk != sk)) {
 310                 /* In this case, the association moved from one socket to
 311                  * another.  We are currently sitting on the backlog of the
 312                  * old socket, so we need to move.
 313                  * However, since we are here in the process context we
 314                  * need to take make sure that the user doesn't own
 315                  * the new socket when we process the packet.
 316                  * If the new socket is user-owned, queue the chunk to the
 317                  * backlog of the new socket without dropping any refs.
 318                  * Otherwise, we can safely push the chunk on the inqueue.
 319                  */
 320
 321                 sk = rcvr->sk;
 322                 sctp_bh_lock_sock(sk);
 323
 324                 if (sock_owned_by_user(sk)) {
 325                         sk_add_backlog(sk, skb);
 326                         backloged = 1;
 327                 } else
 328                         sctp_inq_push(inqueue, chunk);
 329
 330                 sctp_bh_unlock_sock(sk);
 331
 332                 /* If the chunk was backloged again, don't drop refs */
 333                 if (backloged)
 334                         return 0;
 335         } else {
 336                 sctp_inq_push(inqueue, chunk);
 337         }
 338
 339 done:
 340         /* Release the refs we took in sctp_add_backlog */
 341         if (SCTP_EP_TYPE_ASSOCIATION == rcvr->type)
 342                 sctp_association_put(sctp_assoc(rcvr));
 343         else if (SCTP_EP_TYPE_SOCKET == rcvr->type)
 344                 sctp_endpoint_put(sctp_ep(rcvr));
 345         else
 346                 BUG();
 347
 348         return 0;
 349 }
 350
 351 static void sctp_add_backlog(struct sock *sk, struct sk_buff *skb)
 352 {
 353         struct sctp_chunk *chunk = SCTP_INPUT_CB(skb)->chunk;
 354         struct sctp_ep_common *rcvr = chunk->rcvr;
 355
 356         /* Hold the assoc/ep while hanging on the backlog queue.
 357          * This way, we know structures we need will not disappear from us
 358          */
 359         if (SCTP_EP_TYPE_ASSOCIATION == rcvr->type)
 360                 sctp_association_hold(sctp_assoc(rcvr));
 361         else if (SCTP_EP_TYPE_SOCKET == rcvr->type)
 362                 sctp_endpoint_hold(sctp_ep(rcvr));
 363         else
 364                 BUG();
 365
 366         sk_add_backlog(sk, skb);
 367 }
 368
 369 /* Handle icmp frag needed error. */
 370 void sctp_icmp_frag_needed(struct sock *sk, struct sctp_association *asoc,
 371                            struct sctp_transport *t, __u32 pmtu)
 372 {
 373         if (sock_owned_by_user(sk) || !t || (t->pathmtu == pmtu))
 374                 return;
 375
 376         if (t->param_flags & SPP_PMTUD_ENABLE) {
 377                 if (unlikely(pmtu < SCTP_DEFAULT_MINSEGMENT)) {
 378                         printk(KERN_WARNING "%s: Reported pmtu %d too low, "
 379                                "using default minimum of %d\n",
 380                                __FUNCTION__, pmtu,
 381                                SCTP_DEFAULT_MINSEGMENT);
 382                         /* Use default minimum segment size and disable
 383                          * pmtu discovery on this transport.
 384                          */
 385                         t->pathmtu = SCTP_DEFAULT_MINSEGMENT;
 386                         t->param_flags = (t->param_flags & ~SPP_HB) |
 387                                 SPP_PMTUD_DISABLE;
 388                 } else {
 389                         t->pathmtu = pmtu;
 390                 }
 391
 392                 /* Update association pmtu. */
 393                 sctp_assoc_sync_pmtu(asoc);
 394         }
 395
 396         /* Retransmit with the new pmtu setting.
 397          * Normally, if PMTU discovery is disabled, an ICMP Fragmentation
 398          * Needed will never be sent, but if a message was sent before
 399          * PMTU discovery was disabled that was larger than the PMTU, it
 400          * would not be fragmented, so it must be re-transmitted fragmented.
 401          */
 402         sctp_retransmit(&asoc->outqueue, t, SCTP_RTXR_PMTUD);
 403 }
 404
 405 /*
 406  * SCTP Implementer's Guide, 2.37 ICMP handling procedures
 407  *
 408  * ICMP8) If the ICMP code is a "Unrecognized next header type encountered"
 409  *        or a "Protocol Unreachable" treat this message as an abort
 410  *        with the T bit set.
 411  *
 412  * This function sends an event to the state machine, which will abort the
 413  * association.
 414  *
 415  */
 416 void sctp_icmp_proto_unreachable(struct sock *sk,
 417                            struct sctp_association *asoc,
 418                            struct sctp_transport *t)
 419 {
 420         SCTP_DEBUG_PRINTK("%s\n",  __FUNCTION__);
 421
 422         sctp_do_sm(SCTP_EVENT_T_OTHER,
 423                    SCTP_ST_OTHER(SCTP_EVENT_ICMP_PROTO_UNREACH),
 424                    asoc->state, asoc->ep, asoc, t,
 425                    GFP_ATOMIC);
 426
 427 }
 428
 429 /* Common lookup code for icmp/icmpv6 error handler. */
 430 struct sock *sctp_err_lookup(int family, struct sk_buff *skb,
 431                              struct sctphdr *sctphdr,
 432                              struct sctp_association **app,
 433                              struct sctp_transport **tpp)
 434 {
 435         union sctp_addr saddr;
 436         union sctp_addr daddr;
 437         struct sctp_af *af;
 438         struct sock *sk = NULL;
 439         struct sctp_association *asoc;
 440         struct sctp_transport *transport = NULL;
 441
 442         *app = NULL; *tpp = NULL;
 443
 444         af = sctp_get_af_specific(family);
 445         if (unlikely(!af)) {
 446                 return NULL;
 447         }
 448
 449         /* Initialize local addresses for lookups. */
 450         af->from_skb(&saddr, skb, 1);
 451         af->from_skb(&daddr, skb, 0);
 452
 453         /* Look for an association that matches the incoming ICMP error
 454          * packet.
 455          */
 456         asoc = __sctp_lookup_association(&saddr, &daddr, &transport);
 457         if (!asoc)
 458                 return NULL;
 459
 460         sk = asoc->base.sk;
 461
 462         if (ntohl(sctphdr->vtag) != asoc->c.peer_vtag) {
 463                 ICMP_INC_STATS_BH(ICMP_MIB_INERRORS);
 464                 goto out;
 465         }
 466
 467         sctp_bh_lock_sock(sk);
 468
 469         /* If too many ICMPs get dropped on busy
 470          * servers this needs to be solved differently.
 471          */
 472         if (sock_owned_by_user(sk))
 473                 NET_INC_STATS_BH(LINUX_MIB_LOCKDROPPEDICMPS);
 474
 475         *app = asoc;
 476         *tpp = transport;
 477         return sk;
 478
 479 out:
 480         if (asoc)
 481                 sctp_association_put(asoc);
 482         return NULL;
 483 }
 484
 485 /* Common cleanup code for icmp/icmpv6 error handler. */
 486 void sctp_err_finish(struct sock *sk, struct sctp_association *asoc)
 487 {
 488         sctp_bh_unlock_sock(sk);
 489         if (asoc)
 490                 sctp_association_put(asoc);
 491 }
 492
 493 /*
 494  * This routine is called by the ICMP module when it gets some
 495  * sort of error condition.  If err < 0 then the socket should
 496  * be closed and the error returned to the user.  If err > 0
 497  * it's just the icmp type << 8 | icmp code.  After adjustment
 498  * header points to the first 8 bytes of the sctp header.  We need
 499  * to find the appropriate port.
 500  *
 501  * The locking strategy used here is very "optimistic". When
 502  * someone else accesses the socket the ICMP is just dropped
 503  * and for some paths there is no check at all.
 504  * A more general error queue to queue errors for later handling
 505  * is probably better.
 506  *
 507  */
 508 void sctp_v4_err(struct sk_buff *skb, __u32 info)
 509 {
 510         struct iphdr *iph = (struct iphdr *)skb->data;
 511         struct sctphdr *sh = (struct sctphdr *)(skb->data + (iph->ihl <<2));
 512         int type = skb->h.icmph->type;
 513         int code = skb->h.icmph->code;
 514         struct sock *sk;
 515         struct sctp_association *asoc = NULL;
 516         struct sctp_transport *transport;
 517         struct inet_sock *inet;
 518         char *saveip, *savesctp;
 519         int err;
 520
 521         if (skb->len < ((iph->ihl << 2) + 8)) {
 522                 ICMP_INC_STATS_BH(ICMP_MIB_INERRORS);
 523                 return;
 524         }
 525
 526         /* Fix up skb to look at the embedded net header. */
 527         saveip = skb->nh.raw;
 528         savesctp  = skb->h.raw;
 529         skb->nh.iph = iph;
 530         skb->h.raw = (char *)sh;
 531         sk = sctp_err_lookup(AF_INET, skb, sh, &asoc, &transport);
 532         /* Put back, the original pointers. */
 533         skb->nh.raw = saveip;
 534         skb->h.raw = savesctp;
 535         if (!sk) {
 536                 ICMP_INC_STATS_BH(ICMP_MIB_INERRORS);
 537                 return;
 538         }
 539         /* Warning:  The sock lock is held.  Remember to call
 540          * sctp_err_finish!
 541          */
 542
 543         switch (type) {
 544         case ICMP_PARAMETERPROB:
 545                 err = EPROTO;
 546                 break;
 547         case ICMP_DEST_UNREACH:
 548                 if (code > NR_ICMP_UNREACH)
 549                         goto out_unlock;
 550
 551                 /* PMTU discovery (RFC1191) */
 552                 if (ICMP_FRAG_NEEDED == code) {
 553                         sctp_icmp_frag_needed(sk, asoc, transport, info);
 554                         goto out_unlock;
 555                 }
 556                 else {
 557                         if (ICMP_PROT_UNREACH == code) {
 558                                 sctp_icmp_proto_unreachable(sk, asoc,
 559                                                             transport);
 560                                 goto out_unlock;
 561                         }
 562                 }
 563                 err = icmp_err_convert[code].errno;
 564                 break;
 565         case ICMP_TIME_EXCEEDED:
 566                 /* Ignore any time exceeded errors due to fragment reassembly
 567                  * timeouts.
 568                  */
 569                 if (ICMP_EXC_FRAGTIME == code)
 570                         goto out_unlock;
 571
 572                 err = EHOSTUNREACH;
 573                 break;
 574         default:
 575                 goto out_unlock;
 576         }
 577
 578         inet = inet_sk(sk);
 579         if (!sock_owned_by_user(sk) && inet->recverr) {
 580                 sk->sk_err = err;
 581                 sk->sk_error_report(sk);
 582         } else {  /* Only an error on timeout */
 583                 sk->sk_err_soft = err;
 584         }
 585
 586 out_unlock:
 587         sctp_err_finish(sk, asoc);
 588 }
 589
 590 /*
 591  * RFC 2960, 8.4 - Handle "Out of the blue" Packets.
 592  *
 593  * This function scans all the chunks in the OOTB packet to determine if
 594  * the packet should be discarded right away.  If a response might be needed
 595  * for this packet, or, if further processing is possible, the packet will
 596  * be queued to a proper inqueue for the next phase of handling.
 597  *
 598  * Output:
 599  * Return 0 - If further processing is needed.
 600  * Return 1 - If the packet can be discarded right away.
 601  */
 602 int sctp_rcv_ootb(struct sk_buff *skb)
 603 {
 604         sctp_chunkhdr_t *ch;
 605         __u8 *ch_end;
 606         sctp_errhdr_t *err;
 607
 608         ch = (sctp_chunkhdr_t *) skb->data;
 609
 610         /* Scan through all the chunks in the packet.  */
 611         do {
 612                 /* Break out if chunk length is less then minimal. */
 613                 if (ntohs(ch->length) < sizeof(sctp_chunkhdr_t))
 614                         break;
 615
 616                 ch_end = ((__u8 *)ch) + WORD_ROUND(ntohs(ch->length));
 617                 if (ch_end > skb->tail)
 618                         break;
 619
 620                 /* RFC 8.4, 2) If the OOTB packet contains an ABORT chunk, the
 621                  * receiver MUST silently discard the OOTB packet and take no
 622                  * further action.
 623                  */
 624                 if (SCTP_CID_ABORT == ch->type)
 625                         goto discard;
 626
 627                 /* RFC 8.4, 6) If the packet contains a SHUTDOWN COMPLETE
 628                  * chunk, the receiver should silently discard the packet
 629                  * and take no further action.
 630                  */
 631                 if (SCTP_CID_SHUTDOWN_COMPLETE == ch->type)
 632                         goto discard;
 633
 634                 /* RFC 8.4, 7) If the packet contains a "Stale cookie" ERROR
 635                  * or a COOKIE ACK the SCTP Packet should be silently
 636                  * discarded.
 637                  */
 638                 if (SCTP_CID_COOKIE_ACK == ch->type)
 639                         goto discard;
 640
 641                 if (SCTP_CID_ERROR == ch->type) {
 642                         sctp_walk_errors(err, ch) {
 643                                 if (SCTP_ERROR_STALE_COOKIE == err->cause)
 644                                         goto discard;
 645                         }
 646                 }
 647
 648                 ch = (sctp_chunkhdr_t *) ch_end;
 649         } while (ch_end < skb->tail);
 650
 651         return 0;
 652
 653 discard:
 654         return 1;
 655 }
 656
 657 /* Insert endpoint into the hash table.  */
 658 static void __sctp_hash_endpoint(struct sctp_endpoint *ep)
 659 {
 660         struct sctp_ep_common **epp;
 661         struct sctp_ep_common *epb;
 662         struct sctp_hashbucket *head;
 663
 664         epb = &ep->base;
 665
 666         epb->hashent = sctp_ep_hashfn(epb->bind_addr.port);
 667         head = &sctp_ep_hashtable[epb->hashent];
 668
 669         sctp_write_lock(&head->lock);
 670         epp = &head->chain;
 671         epb->next = *epp;
 672         if (epb->next)
 673                 (*epp)->pprev = &epb->next;
 674         *epp = epb;
 675         epb->pprev = epp;
 676         sctp_write_unlock(&head->lock);
 677 }
 678
 679 /* Add an endpoint to the hash. Local BH-safe. */
 680 void sctp_hash_endpoint(struct sctp_endpoint *ep)
 681 {
 682         sctp_local_bh_disable();
 683         __sctp_hash_endpoint(ep);
 684         sctp_local_bh_enable();
 685 }
 686
 687 /* Remove endpoint from the hash table.  */
 688 static void __sctp_unhash_endpoint(struct sctp_endpoint *ep)
 689 {
 690         struct sctp_hashbucket *head;
 691         struct sctp_ep_common *epb;
 692
 693         epb = &ep->base;
 694
 695         epb->hashent = sctp_ep_hashfn(epb->bind_addr.port);
 696
 697         head = &sctp_ep_hashtable[epb->hashent];
 698
 699         sctp_write_lock(&head->lock);
 700
 701         if (epb->pprev) {
 702                 if (epb->next)
 703                         epb->next->pprev = epb->pprev;
 704                 *epb->pprev = epb->next;
 705                 epb->pprev = NULL;
 706         }
 707
 708         sctp_write_unlock(&head->lock);
 709 }
 710
 711 /* Remove endpoint from the hash.  Local BH-safe. */
 712 void sctp_unhash_endpoint(struct sctp_endpoint *ep)
 713 {
 714         sctp_local_bh_disable();
 715         __sctp_unhash_endpoint(ep);
 716         sctp_local_bh_enable();
 717 }
 718
 719 /* Look up an endpoint. */
 720 static struct sctp_endpoint *__sctp_rcv_lookup_endpoint(const union sctp_addr *laddr)
 721 {
 722         struct sctp_hashbucket *head;
 723         struct sctp_ep_common *epb;
 724         struct sctp_endpoint *ep;
 725         int hash;
 726
 727         hash = sctp_ep_hashfn(laddr->v4.sin_port);
 728         head = &sctp_ep_hashtable[hash];
 729         read_lock(&head->lock);
 730         for (epb = head->chain; epb; epb = epb->next) {
 731                 ep = sctp_ep(epb);
 732                 if (sctp_endpoint_is_match(ep, laddr))
 733                         goto hit;
 734         }
 735
 736         ep = sctp_sk((sctp_get_ctl_sock()))->ep;
 737         epb = &ep->base;
 738
 739 hit:
 740         sctp_endpoint_hold(ep);
 741         read_unlock(&head->lock);
 742         return ep;
 743 }
 744
 745 /* Insert association into the hash table.  */
 746 static void __sctp_hash_established(struct sctp_association *asoc)
 747 {
 748         struct sctp_ep_common **epp;
 749         struct sctp_ep_common *epb;
 750         struct sctp_hashbucket *head;
 751
 752         epb = &asoc->base;
 753
 754         /* Calculate which chain this entry will belong to. */
 755         epb->hashent = sctp_assoc_hashfn(epb->bind_addr.port, asoc->peer.port);
 756
 757         head = &sctp_assoc_hashtable[epb->hashent];
 758
 759         sctp_write_lock(&head->lock);
 760         epp = &head->chain;
 761         epb->next = *epp;
 762         if (epb->next)
 763                 (*epp)->pprev = &epb->next;
 764         *epp = epb;
 765         epb->pprev = epp;
 766         sctp_write_unlock(&head->lock);
 767 }
 768
 769 /* Add an association to the hash. Local BH-safe. */
 770 void sctp_hash_established(struct sctp_association *asoc)
 771 {
 772         sctp_local_bh_disable();
 773         __sctp_hash_established(asoc);
 774         sctp_local_bh_enable();
 775 }
 776
 777 /* Remove association from the hash table.  */
 778 static void __sctp_unhash_established(struct sctp_association *asoc)
 779 {
 780         struct sctp_hashbucket *head;
 781         struct sctp_ep_common *epb;
 782
 783         epb = &asoc->base;
 784
 785         epb->hashent = sctp_assoc_hashfn(epb->bind_addr.port,
 786                                          asoc->peer.port);
 787
 788         head = &sctp_assoc_hashtable[epb->hashent];
 789
 790         sctp_write_lock(&head->lock);
 791
 792         if (epb->pprev) {
 793                 if (epb->next)
 794                         epb->next->pprev = epb->pprev;
 795                 *epb->pprev = epb->next;
 796                 epb->pprev = NULL;
 797         }
 798
 799         sctp_write_unlock(&head->lock);
 800 }
 801
 802 /* Remove association from the hash table.  Local BH-safe. */
 803 void sctp_unhash_established(struct sctp_association *asoc)
 804 {
 805         sctp_local_bh_disable();
 806         __sctp_unhash_established(asoc);
 807         sctp_local_bh_enable();
 808 }
 809
 810 /* Look up an association. */
 811 static struct sctp_association *__sctp_lookup_association(
 812                                         const union sctp_addr *local,
 813                                         const union sctp_addr *peer,
 814                                         struct sctp_transport **pt)
 815 {
 816         struct sctp_hashbucket *head;
 817         struct sctp_ep_common *epb;
 818         struct sctp_association *asoc;
 819         struct sctp_transport *transport;
 820         int hash;
 821
 822         /* Optimize here for direct hit, only listening connections can
 823          * have wildcards anyways.
 824          */
 825         hash = sctp_assoc_hashfn(local->v4.sin_port, peer->v4.sin_port);
 826         head = &sctp_assoc_hashtable[hash];
 827         read_lock(&head->lock);
 828         for (epb = head->chain; epb; epb = epb->next) {
 829                 asoc = sctp_assoc(epb);
 830                 transport = sctp_assoc_is_match(asoc, local, peer);
 831                 if (transport)
 832                         goto hit;
 833         }
 834
 835         read_unlock(&head->lock);
 836
 837         return NULL;
 838
 839 hit:
 840         *pt = transport;
 841         sctp_association_hold(asoc);
 842         read_unlock(&head->lock);
 843         return asoc;
 844 }
 845
 846 /* Look up an association. BH-safe. */
 847 SCTP_STATIC
 848 struct sctp_association *sctp_lookup_association(const union sctp_addr *laddr,
 849                                                  const union sctp_addr *paddr,
 850                                             struct sctp_transport **transportp)
 851 {
 852         struct sctp_association *asoc;
 853
 854         sctp_local_bh_disable();
 855         asoc = __sctp_lookup_association(laddr, paddr, transportp);
 856         sctp_local_bh_enable();
 857
 858         return asoc;
 859 }
 860
 861 /* Is there an association matching the given local and peer addresses? */
 862 int sctp_has_association(const union sctp_addr *laddr,
 863                          const union sctp_addr *paddr)
 864 {
 865         struct sctp_association *asoc;
 866         struct sctp_transport *transport;
 867
 868         if ((asoc = sctp_lookup_association(laddr, paddr, &transport))) {
 869                 sctp_association_put(asoc);
 870                 return 1;
 871         }
 872
 873         return 0;
 874 }
 875
 876 /*
 877  * SCTP Implementors Guide, 2.18 Handling of address
 878  * parameters within the INIT or INIT-ACK.
 879  *
 880  * D) When searching for a matching TCB upon reception of an INIT
 881  *    or INIT-ACK chunk the receiver SHOULD use not only the
 882  *    source address of the packet (containing the INIT or
 883  *    INIT-ACK) but the receiver SHOULD also use all valid
 884  *    address parameters contained within the chunk.
 885  *
 886  * 2.18.3 Solution description
 887  *
 888  * This new text clearly specifies to an implementor the need
 889  * to look within the INIT or INIT-ACK. Any implementation that
 890  * does not do this, may not be able to establish associations
 891  * in certain circumstances.
 892  *
 893  */
 894 static struct sctp_association *__sctp_rcv_init_lookup(struct sk_buff *skb,
 895         const union sctp_addr *laddr, struct sctp_transport **transportp)
 896 {
 897         struct sctp_association *asoc;
 898         union sctp_addr addr;
 899         union sctp_addr *paddr = &addr;
 900         struct sctphdr *sh = (struct sctphdr *) skb->h.raw;
 901         sctp_chunkhdr_t *ch;
 902         union sctp_params params;
 903         sctp_init_chunk_t *init;
 904         struct sctp_transport *transport;
 905         struct sctp_af *af;
 906
 907         ch = (sctp_chunkhdr_t *) skb->data;
 908
 909         /* If this is INIT/INIT-ACK look inside the chunk too. */
 910         switch (ch->type) {
 911         case SCTP_CID_INIT:
 912         case SCTP_CID_INIT_ACK:
 913                 break;
 914         default:
 915                 return NULL;
 916         }
 917
 918         /* The code below will attempt to walk the chunk and extract
 919          * parameter information.  Before we do that, we need to verify
 920          * that the chunk length doesn't cause overflow.  Otherwise, we'll
 921          * walk off the end.
 922          */
 923         if (WORD_ROUND(ntohs(ch->length)) > skb->len)
 924                 return NULL;
 925
 926         /*
 927          * This code will NOT touch anything inside the chunk--it is
 928          * strictly READ-ONLY.
 929          *
 930          * RFC 2960 3  SCTP packet Format
 931          *
 932          * Multiple chunks can be bundled into one SCTP packet up to
 933          * the MTU size, except for the INIT, INIT ACK, and SHUTDOWN
 934          * COMPLETE chunks.  These chunks MUST NOT be bundled with any
 935          * other chunk in a packet.  See Section 6.10 for more details
 936          * on chunk bundling.
 937          */
 938
 939         /* Find the start of the TLVs and the end of the chunk.  This is
 940          * the region we search for address parameters.
 941          */
 942         init = (sctp_init_chunk_t *)skb->data;
 943
 944         /* Walk the parameters looking for embedded addresses. */
 945         sctp_walk_params(params, init, init_hdr.params) {
 946
 947                 /* Note: Ignoring hostname addresses. */
 948                 af = sctp_get_af_specific(param_type2af(params.p->type));
 949                 if (!af)
 950                         continue;
 951
 952                 af->from_addr_param(paddr, params.addr, ntohs(sh->source), 0);
 953
 954                 asoc = __sctp_lookup_association(laddr, paddr, &transport);
 955                 if (asoc)
 956                         return asoc;
 957         }
 958
 959         return NULL;
 960 }
 961
 962 /* Lookup an association for an inbound skb. */
 963 static struct sctp_association *__sctp_rcv_lookup(struct sk_buff *skb,
 964                                       const union sctp_addr *paddr,
 965                                       const union sctp_addr *laddr,
 966                                       struct sctp_transport **transportp)
 967 {
 968         struct sctp_association *asoc;
 969
 970         asoc = __sctp_lookup_association(laddr, paddr, transportp);
 971
 972         /* Further lookup for INIT/INIT-ACK packets.
 973          * SCTP Implementors Guide, 2.18 Handling of address
 974          * parameters within the INIT or INIT-ACK.
 975          */
 976         if (!asoc)
 977                 asoc = __sctp_rcv_init_lookup(skb, laddr, transportp);
 978
 979         return asoc;
 980 }