sctp: Validate Initiate Tag when handling ICMP message
[pandora-kernel.git] / net / sctp / input.c
1 /* SCTP kernel 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 implementation
10  *
11  * These functions handle all input from the IP layer into SCTP.
12  *
13  * This SCTP 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  * This SCTP 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 #include <net/sctp/checksum.h>
64
65 /* Forward declarations for internal helpers. */
66 static int sctp_rcv_ootb(struct sk_buff *);
67 static struct sctp_association *__sctp_rcv_lookup(struct sk_buff *skb,
68                                       const union sctp_addr *laddr,
69                                       const union sctp_addr *paddr,
70                                       struct sctp_transport **transportp);
71 static struct sctp_endpoint *__sctp_rcv_lookup_endpoint(const union sctp_addr *laddr);
72 static struct sctp_association *__sctp_lookup_association(
73                                         const union sctp_addr *local,
74                                         const union sctp_addr *peer,
75                                         struct sctp_transport **pt);
76
77 static void sctp_add_backlog(struct sock *sk, struct sk_buff *skb);
78
79
80 /* Calculate the SCTP checksum of an SCTP packet.  */
81 static inline int sctp_rcv_checksum(struct sk_buff *skb)
82 {
83         struct sk_buff *list = skb_shinfo(skb)->frag_list;
84         struct sctphdr *sh = sctp_hdr(skb);
85         __u32 cmp = ntohl(sh->checksum);
86         __u32 val = sctp_start_cksum((__u8 *)sh, skb_headlen(skb));
87
88         for (; list; list = list->next)
89                 val = sctp_update_cksum((__u8 *)list->data, skb_headlen(list),
90                                         val);
91
92         val = sctp_end_cksum(val);
93
94         if (val != cmp) {
95                 /* CRC failure, dump it. */
96                 SCTP_INC_STATS_BH(SCTP_MIB_CHECKSUMERRORS);
97                 return -1;
98         }
99         return 0;
100 }
101
102 struct sctp_input_cb {
103         union {
104                 struct inet_skb_parm    h4;
105 #if defined(CONFIG_IPV6) || defined (CONFIG_IPV6_MODULE)
106                 struct inet6_skb_parm   h6;
107 #endif
108         } header;
109         struct sctp_chunk *chunk;
110 };
111 #define SCTP_INPUT_CB(__skb)    ((struct sctp_input_cb *)&((__skb)->cb[0]))
112
113 /*
114  * This is the routine which IP calls when receiving an SCTP packet.
115  */
116 int sctp_rcv(struct sk_buff *skb)
117 {
118         struct sock *sk;
119         struct sctp_association *asoc;
120         struct sctp_endpoint *ep = NULL;
121         struct sctp_ep_common *rcvr;
122         struct sctp_transport *transport = NULL;
123         struct sctp_chunk *chunk;
124         struct sctphdr *sh;
125         union sctp_addr src;
126         union sctp_addr dest;
127         int family;
128         struct sctp_af *af;
129
130         if (skb->pkt_type!=PACKET_HOST)
131                 goto discard_it;
132
133         SCTP_INC_STATS_BH(SCTP_MIB_INSCTPPACKS);
134
135         if (skb_linearize(skb))
136                 goto discard_it;
137
138         sh = sctp_hdr(skb);
139
140         /* Pull up the IP and SCTP headers. */
141         __skb_pull(skb, skb_transport_offset(skb));
142         if (skb->len < sizeof(struct sctphdr))
143                 goto discard_it;
144         if (!skb_csum_unnecessary(skb) && 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(ip_hdr(skb)->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         if (!xfrm_policy_check(sk, XFRM_POLICY_IN, skb, family))
221                 goto discard_release;
222         nf_reset(skb);
223
224         if (sk_filter(sk, skb))
225                 goto discard_release;
226
227         /* Create an SCTP packet structure. */
228         chunk = sctp_chunkify(skb, asoc, sk);
229         if (!chunk)
230                 goto discard_release;
231         SCTP_INPUT_CB(skb)->chunk = chunk;
232
233         /* Remember what endpoint is to handle this packet. */
234         chunk->rcvr = rcvr;
235
236         /* Remember the SCTP header. */
237         chunk->sctp_hdr = sh;
238
239         /* Set the source and destination addresses of the incoming chunk.  */
240         sctp_init_addrs(chunk, &src, &dest);
241
242         /* Remember where we came from.  */
243         chunk->transport = transport;
244
245         /* Acquire access to the sock lock. Note: We are safe from other
246          * bottom halves on this lock, but a user may be in the lock too,
247          * so check if it is busy.
248          */
249         sctp_bh_lock_sock(sk);
250
251         if (sock_owned_by_user(sk)) {
252                 SCTP_INC_STATS_BH(SCTP_MIB_IN_PKT_BACKLOG);
253                 sctp_add_backlog(sk, skb);
254         } else {
255                 SCTP_INC_STATS_BH(SCTP_MIB_IN_PKT_SOFTIRQ);
256                 sctp_inq_push(&chunk->rcvr->inqueue, chunk);
257         }
258
259         sctp_bh_unlock_sock(sk);
260
261         /* Release the asoc/ep ref we took in the lookup calls. */
262         if (asoc)
263                 sctp_association_put(asoc);
264         else
265                 sctp_endpoint_put(ep);
266
267         return 0;
268
269 discard_it:
270         SCTP_INC_STATS_BH(SCTP_MIB_IN_PKT_DISCARDS);
271         kfree_skb(skb);
272         return 0;
273
274 discard_release:
275         /* Release the asoc/ep ref we took in the lookup calls. */
276         if (asoc)
277                 sctp_association_put(asoc);
278         else
279                 sctp_endpoint_put(ep);
280
281         goto discard_it;
282 }
283
284 /* Process the backlog queue of the socket.  Every skb on
285  * the backlog holds a ref on an association or endpoint.
286  * We hold this ref throughout the state machine to make
287  * sure that the structure we need is still around.
288  */
289 int sctp_backlog_rcv(struct sock *sk, struct sk_buff *skb)
290 {
291         struct sctp_chunk *chunk = SCTP_INPUT_CB(skb)->chunk;
292         struct sctp_inq *inqueue = &chunk->rcvr->inqueue;
293         struct sctp_ep_common *rcvr = NULL;
294         int backloged = 0;
295
296         rcvr = chunk->rcvr;
297
298         /* If the rcvr is dead then the association or endpoint
299          * has been deleted and we can safely drop the chunk
300          * and refs that we are holding.
301          */
302         if (rcvr->dead) {
303                 sctp_chunk_free(chunk);
304                 goto done;
305         }
306
307         if (unlikely(rcvr->sk != sk)) {
308                 /* In this case, the association moved from one socket to
309                  * another.  We are currently sitting on the backlog of the
310                  * old socket, so we need to move.
311                  * However, since we are here in the process context we
312                  * need to take make sure that the user doesn't own
313                  * the new socket when we process the packet.
314                  * If the new socket is user-owned, queue the chunk to the
315                  * backlog of the new socket without dropping any refs.
316                  * Otherwise, we can safely push the chunk on the inqueue.
317                  */
318
319                 sk = rcvr->sk;
320                 sctp_bh_lock_sock(sk);
321
322                 if (sock_owned_by_user(sk)) {
323                         sk_add_backlog(sk, skb);
324                         backloged = 1;
325                 } else
326                         sctp_inq_push(inqueue, chunk);
327
328                 sctp_bh_unlock_sock(sk);
329
330                 /* If the chunk was backloged again, don't drop refs */
331                 if (backloged)
332                         return 0;
333         } else {
334                 sctp_inq_push(inqueue, chunk);
335         }
336
337 done:
338         /* Release the refs we took in sctp_add_backlog */
339         if (SCTP_EP_TYPE_ASSOCIATION == rcvr->type)
340                 sctp_association_put(sctp_assoc(rcvr));
341         else if (SCTP_EP_TYPE_SOCKET == rcvr->type)
342                 sctp_endpoint_put(sctp_ep(rcvr));
343         else
344                 BUG();
345
346         return 0;
347 }
348
349 static void sctp_add_backlog(struct sock *sk, struct sk_buff *skb)
350 {
351         struct sctp_chunk *chunk = SCTP_INPUT_CB(skb)->chunk;
352         struct sctp_ep_common *rcvr = chunk->rcvr;
353
354         /* Hold the assoc/ep while hanging on the backlog queue.
355          * This way, we know structures we need will not disappear from us
356          */
357         if (SCTP_EP_TYPE_ASSOCIATION == rcvr->type)
358                 sctp_association_hold(sctp_assoc(rcvr));
359         else if (SCTP_EP_TYPE_SOCKET == rcvr->type)
360                 sctp_endpoint_hold(sctp_ep(rcvr));
361         else
362                 BUG();
363
364         sk_add_backlog(sk, skb);
365 }
366
367 /* Handle icmp frag needed error. */
368 void sctp_icmp_frag_needed(struct sock *sk, struct sctp_association *asoc,
369                            struct sctp_transport *t, __u32 pmtu)
370 {
371         if (!t || (t->pathmtu == pmtu))
372                 return;
373
374         if (sock_owned_by_user(sk)) {
375                 asoc->pmtu_pending = 1;
376                 t->pmtu_pending = 1;
377                 return;
378         }
379
380         if (t->param_flags & SPP_PMTUD_ENABLE) {
381                 /* Update transports view of the MTU */
382                 sctp_transport_update_pmtu(t, pmtu);
383
384                 /* Update association pmtu. */
385                 sctp_assoc_sync_pmtu(asoc);
386         }
387
388         /* Retransmit with the new pmtu setting.
389          * Normally, if PMTU discovery is disabled, an ICMP Fragmentation
390          * Needed will never be sent, but if a message was sent before
391          * PMTU discovery was disabled that was larger than the PMTU, it
392          * would not be fragmented, so it must be re-transmitted fragmented.
393          */
394         sctp_retransmit(&asoc->outqueue, t, SCTP_RTXR_PMTUD);
395 }
396
397 /*
398  * SCTP Implementer's Guide, 2.37 ICMP handling procedures
399  *
400  * ICMP8) If the ICMP code is a "Unrecognized next header type encountered"
401  *        or a "Protocol Unreachable" treat this message as an abort
402  *        with the T bit set.
403  *
404  * This function sends an event to the state machine, which will abort the
405  * association.
406  *
407  */
408 void sctp_icmp_proto_unreachable(struct sock *sk,
409                            struct sctp_association *asoc,
410                            struct sctp_transport *t)
411 {
412         SCTP_DEBUG_PRINTK("%s\n",  __func__);
413
414         sctp_do_sm(SCTP_EVENT_T_OTHER,
415                    SCTP_ST_OTHER(SCTP_EVENT_ICMP_PROTO_UNREACH),
416                    asoc->state, asoc->ep, asoc, t,
417                    GFP_ATOMIC);
418
419 }
420
421 /* Common lookup code for icmp/icmpv6 error handler. */
422 struct sock *sctp_err_lookup(int family, struct sk_buff *skb,
423                              struct sctphdr *sctphdr,
424                              struct sctp_association **app,
425                              struct sctp_transport **tpp)
426 {
427         union sctp_addr saddr;
428         union sctp_addr daddr;
429         struct sctp_af *af;
430         struct sock *sk = NULL;
431         struct sctp_association *asoc;
432         struct sctp_transport *transport = NULL;
433         struct sctp_init_chunk *chunkhdr;
434         __u32 vtag = ntohl(sctphdr->vtag);
435         int len = skb->len - ((void *)sctphdr - (void *)skb->data);
436
437         *app = NULL; *tpp = NULL;
438
439         af = sctp_get_af_specific(family);
440         if (unlikely(!af)) {
441                 return NULL;
442         }
443
444         /* Initialize local addresses for lookups. */
445         af->from_skb(&saddr, skb, 1);
446         af->from_skb(&daddr, skb, 0);
447
448         /* Look for an association that matches the incoming ICMP error
449          * packet.
450          */
451         asoc = __sctp_lookup_association(&saddr, &daddr, &transport);
452         if (!asoc)
453                 return NULL;
454
455         sk = asoc->base.sk;
456
457         /* RFC 4960, Appendix C. ICMP Handling
458          *
459          * ICMP6) An implementation MUST validate that the Verification Tag
460          * contained in the ICMP message matches the Verification Tag of
461          * the peer.  If the Verification Tag is not 0 and does NOT
462          * match, discard the ICMP message.  If it is 0 and the ICMP
463          * message contains enough bytes to verify that the chunk type is
464          * an INIT chunk and that the Initiate Tag matches the tag of the
465          * peer, continue with ICMP7.  If the ICMP message is too short
466          * or the chunk type or the Initiate Tag does not match, silently
467          * discard the packet.
468          */
469         if (vtag == 0) {
470                 chunkhdr = (struct sctp_init_chunk *)((void *)sctphdr
471                                 + sizeof(struct sctphdr));
472                 if (len < sizeof(struct sctphdr) + sizeof(sctp_chunkhdr_t)
473                           + sizeof(__be32) ||
474                     chunkhdr->chunk_hdr.type != SCTP_CID_INIT ||
475                     ntohl(chunkhdr->init_hdr.init_tag) != asoc->c.my_vtag) {
476                         goto out;
477                 }
478         } else if (vtag != asoc->c.peer_vtag) {
479                 goto out;
480         }
481
482         sctp_bh_lock_sock(sk);
483
484         /* If too many ICMPs get dropped on busy
485          * servers this needs to be solved differently.
486          */
487         if (sock_owned_by_user(sk))
488                 NET_INC_STATS_BH(LINUX_MIB_LOCKDROPPEDICMPS);
489
490         *app = asoc;
491         *tpp = transport;
492         return sk;
493
494 out:
495         if (asoc)
496                 sctp_association_put(asoc);
497         return NULL;
498 }
499
500 /* Common cleanup code for icmp/icmpv6 error handler. */
501 void sctp_err_finish(struct sock *sk, struct sctp_association *asoc)
502 {
503         sctp_bh_unlock_sock(sk);
504         if (asoc)
505                 sctp_association_put(asoc);
506 }
507
508 /*
509  * This routine is called by the ICMP module when it gets some
510  * sort of error condition.  If err < 0 then the socket should
511  * be closed and the error returned to the user.  If err > 0
512  * it's just the icmp type << 8 | icmp code.  After adjustment
513  * header points to the first 8 bytes of the sctp header.  We need
514  * to find the appropriate port.
515  *
516  * The locking strategy used here is very "optimistic". When
517  * someone else accesses the socket the ICMP is just dropped
518  * and for some paths there is no check at all.
519  * A more general error queue to queue errors for later handling
520  * is probably better.
521  *
522  */
523 void sctp_v4_err(struct sk_buff *skb, __u32 info)
524 {
525         struct iphdr *iph = (struct iphdr *)skb->data;
526         const int ihlen = iph->ihl * 4;
527         const int type = icmp_hdr(skb)->type;
528         const int code = icmp_hdr(skb)->code;
529         struct sock *sk;
530         struct sctp_association *asoc = NULL;
531         struct sctp_transport *transport;
532         struct inet_sock *inet;
533         sk_buff_data_t saveip, savesctp;
534         int err;
535
536         if (skb->len < ihlen + 8) {
537                 ICMP_INC_STATS_BH(ICMP_MIB_INERRORS);
538                 return;
539         }
540
541         /* Fix up skb to look at the embedded net header. */
542         saveip = skb->network_header;
543         savesctp = skb->transport_header;
544         skb_reset_network_header(skb);
545         skb_set_transport_header(skb, ihlen);
546         sk = sctp_err_lookup(AF_INET, skb, sctp_hdr(skb), &asoc, &transport);
547         /* Put back, the original values. */
548         skb->network_header = saveip;
549         skb->transport_header = savesctp;
550         if (!sk) {
551                 ICMP_INC_STATS_BH(ICMP_MIB_INERRORS);
552                 return;
553         }
554         /* Warning:  The sock lock is held.  Remember to call
555          * sctp_err_finish!
556          */
557
558         switch (type) {
559         case ICMP_PARAMETERPROB:
560                 err = EPROTO;
561                 break;
562         case ICMP_DEST_UNREACH:
563                 if (code > NR_ICMP_UNREACH)
564                         goto out_unlock;
565
566                 /* PMTU discovery (RFC1191) */
567                 if (ICMP_FRAG_NEEDED == code) {
568                         sctp_icmp_frag_needed(sk, asoc, transport, info);
569                         goto out_unlock;
570                 }
571                 else {
572                         if (ICMP_PROT_UNREACH == code) {
573                                 sctp_icmp_proto_unreachable(sk, asoc,
574                                                             transport);
575                                 goto out_unlock;
576                         }
577                 }
578                 err = icmp_err_convert[code].errno;
579                 break;
580         case ICMP_TIME_EXCEEDED:
581                 /* Ignore any time exceeded errors due to fragment reassembly
582                  * timeouts.
583                  */
584                 if (ICMP_EXC_FRAGTIME == code)
585                         goto out_unlock;
586
587                 err = EHOSTUNREACH;
588                 break;
589         default:
590                 goto out_unlock;
591         }
592
593         inet = inet_sk(sk);
594         if (!sock_owned_by_user(sk) && inet->recverr) {
595                 sk->sk_err = err;
596                 sk->sk_error_report(sk);
597         } else {  /* Only an error on timeout */
598                 sk->sk_err_soft = err;
599         }
600
601 out_unlock:
602         sctp_err_finish(sk, asoc);
603 }
604
605 /*
606  * RFC 2960, 8.4 - Handle "Out of the blue" Packets.
607  *
608  * This function scans all the chunks in the OOTB packet to determine if
609  * the packet should be discarded right away.  If a response might be needed
610  * for this packet, or, if further processing is possible, the packet will
611  * be queued to a proper inqueue for the next phase of handling.
612  *
613  * Output:
614  * Return 0 - If further processing is needed.
615  * Return 1 - If the packet can be discarded right away.
616  */
617 static int sctp_rcv_ootb(struct sk_buff *skb)
618 {
619         sctp_chunkhdr_t *ch;
620         __u8 *ch_end;
621         sctp_errhdr_t *err;
622
623         ch = (sctp_chunkhdr_t *) skb->data;
624
625         /* Scan through all the chunks in the packet.  */
626         do {
627                 /* Break out if chunk length is less then minimal. */
628                 if (ntohs(ch->length) < sizeof(sctp_chunkhdr_t))
629                         break;
630
631                 ch_end = ((__u8 *)ch) + WORD_ROUND(ntohs(ch->length));
632                 if (ch_end > skb_tail_pointer(skb))
633                         break;
634
635                 /* RFC 8.4, 2) If the OOTB packet contains an ABORT chunk, the
636                  * receiver MUST silently discard the OOTB packet and take no
637                  * further action.
638                  */
639                 if (SCTP_CID_ABORT == ch->type)
640                         goto discard;
641
642                 /* RFC 8.4, 6) If the packet contains a SHUTDOWN COMPLETE
643                  * chunk, the receiver should silently discard the packet
644                  * and take no further action.
645                  */
646                 if (SCTP_CID_SHUTDOWN_COMPLETE == ch->type)
647                         goto discard;
648
649                 /* RFC 4460, 2.11.2
650                  * This will discard packets with INIT chunk bundled as
651                  * subsequent chunks in the packet.  When INIT is first,
652                  * the normal INIT processing will discard the chunk.
653                  */
654                 if (SCTP_CID_INIT == ch->type && (void *)ch != skb->data)
655                         goto discard;
656
657                 /* RFC 8.4, 7) If the packet contains a "Stale cookie" ERROR
658                  * or a COOKIE ACK the SCTP Packet should be silently
659                  * discarded.
660                  */
661                 if (SCTP_CID_COOKIE_ACK == ch->type)
662                         goto discard;
663
664                 if (SCTP_CID_ERROR == ch->type) {
665                         sctp_walk_errors(err, ch) {
666                                 if (SCTP_ERROR_STALE_COOKIE == err->cause)
667                                         goto discard;
668                         }
669                 }
670
671                 ch = (sctp_chunkhdr_t *) ch_end;
672         } while (ch_end < skb_tail_pointer(skb));
673
674         return 0;
675
676 discard:
677         return 1;
678 }
679
680 /* Insert endpoint into the hash table.  */
681 static void __sctp_hash_endpoint(struct sctp_endpoint *ep)
682 {
683         struct sctp_ep_common *epb;
684         struct sctp_hashbucket *head;
685
686         epb = &ep->base;
687
688         epb->hashent = sctp_ep_hashfn(epb->bind_addr.port);
689         head = &sctp_ep_hashtable[epb->hashent];
690
691         sctp_write_lock(&head->lock);
692         hlist_add_head(&epb->node, &head->chain);
693         sctp_write_unlock(&head->lock);
694 }
695
696 /* Add an endpoint to the hash. Local BH-safe. */
697 void sctp_hash_endpoint(struct sctp_endpoint *ep)
698 {
699         sctp_local_bh_disable();
700         __sctp_hash_endpoint(ep);
701         sctp_local_bh_enable();
702 }
703
704 /* Remove endpoint from the hash table.  */
705 static void __sctp_unhash_endpoint(struct sctp_endpoint *ep)
706 {
707         struct sctp_hashbucket *head;
708         struct sctp_ep_common *epb;
709
710         epb = &ep->base;
711
712         if (hlist_unhashed(&epb->node))
713                 return;
714
715         epb->hashent = sctp_ep_hashfn(epb->bind_addr.port);
716
717         head = &sctp_ep_hashtable[epb->hashent];
718
719         sctp_write_lock(&head->lock);
720         __hlist_del(&epb->node);
721         sctp_write_unlock(&head->lock);
722 }
723
724 /* Remove endpoint from the hash.  Local BH-safe. */
725 void sctp_unhash_endpoint(struct sctp_endpoint *ep)
726 {
727         sctp_local_bh_disable();
728         __sctp_unhash_endpoint(ep);
729         sctp_local_bh_enable();
730 }
731
732 /* Look up an endpoint. */
733 static struct sctp_endpoint *__sctp_rcv_lookup_endpoint(const union sctp_addr *laddr)
734 {
735         struct sctp_hashbucket *head;
736         struct sctp_ep_common *epb;
737         struct sctp_endpoint *ep;
738         struct hlist_node *node;
739         int hash;
740
741         hash = sctp_ep_hashfn(ntohs(laddr->v4.sin_port));
742         head = &sctp_ep_hashtable[hash];
743         read_lock(&head->lock);
744         sctp_for_each_hentry(epb, node, &head->chain) {
745                 ep = sctp_ep(epb);
746                 if (sctp_endpoint_is_match(ep, laddr))
747                         goto hit;
748         }
749
750         ep = sctp_sk((sctp_get_ctl_sock()))->ep;
751
752 hit:
753         sctp_endpoint_hold(ep);
754         read_unlock(&head->lock);
755         return ep;
756 }
757
758 /* Insert association into the hash table.  */
759 static void __sctp_hash_established(struct sctp_association *asoc)
760 {
761         struct sctp_ep_common *epb;
762         struct sctp_hashbucket *head;
763
764         epb = &asoc->base;
765
766         /* Calculate which chain this entry will belong to. */
767         epb->hashent = sctp_assoc_hashfn(epb->bind_addr.port, asoc->peer.port);
768
769         head = &sctp_assoc_hashtable[epb->hashent];
770
771         sctp_write_lock(&head->lock);
772         hlist_add_head(&epb->node, &head->chain);
773         sctp_write_unlock(&head->lock);
774 }
775
776 /* Add an association to the hash. Local BH-safe. */
777 void sctp_hash_established(struct sctp_association *asoc)
778 {
779         if (asoc->temp)
780                 return;
781
782         sctp_local_bh_disable();
783         __sctp_hash_established(asoc);
784         sctp_local_bh_enable();
785 }
786
787 /* Remove association from the hash table.  */
788 static void __sctp_unhash_established(struct sctp_association *asoc)
789 {
790         struct sctp_hashbucket *head;
791         struct sctp_ep_common *epb;
792
793         epb = &asoc->base;
794
795         epb->hashent = sctp_assoc_hashfn(epb->bind_addr.port,
796                                          asoc->peer.port);
797
798         head = &sctp_assoc_hashtable[epb->hashent];
799
800         sctp_write_lock(&head->lock);
801         __hlist_del(&epb->node);
802         sctp_write_unlock(&head->lock);
803 }
804
805 /* Remove association from the hash table.  Local BH-safe. */
806 void sctp_unhash_established(struct sctp_association *asoc)
807 {
808         if (asoc->temp)
809                 return;
810
811         sctp_local_bh_disable();
812         __sctp_unhash_established(asoc);
813         sctp_local_bh_enable();
814 }
815
816 /* Look up an association. */
817 static struct sctp_association *__sctp_lookup_association(
818                                         const union sctp_addr *local,
819                                         const union sctp_addr *peer,
820                                         struct sctp_transport **pt)
821 {
822         struct sctp_hashbucket *head;
823         struct sctp_ep_common *epb;
824         struct sctp_association *asoc;
825         struct sctp_transport *transport;
826         struct hlist_node *node;
827         int hash;
828
829         /* Optimize here for direct hit, only listening connections can
830          * have wildcards anyways.
831          */
832         hash = sctp_assoc_hashfn(ntohs(local->v4.sin_port), ntohs(peer->v4.sin_port));
833         head = &sctp_assoc_hashtable[hash];
834         read_lock(&head->lock);
835         sctp_for_each_hentry(epb, node, &head->chain) {
836                 asoc = sctp_assoc(epb);
837                 transport = sctp_assoc_is_match(asoc, local, peer);
838                 if (transport)
839                         goto hit;
840         }
841
842         read_unlock(&head->lock);
843
844         return NULL;
845
846 hit:
847         *pt = transport;
848         sctp_association_hold(asoc);
849         read_unlock(&head->lock);
850         return asoc;
851 }
852
853 /* Look up an association. BH-safe. */
854 SCTP_STATIC
855 struct sctp_association *sctp_lookup_association(const union sctp_addr *laddr,
856                                                  const union sctp_addr *paddr,
857                                             struct sctp_transport **transportp)
858 {
859         struct sctp_association *asoc;
860
861         sctp_local_bh_disable();
862         asoc = __sctp_lookup_association(laddr, paddr, transportp);
863         sctp_local_bh_enable();
864
865         return asoc;
866 }
867
868 /* Is there an association matching the given local and peer addresses? */
869 int sctp_has_association(const union sctp_addr *laddr,
870                          const union sctp_addr *paddr)
871 {
872         struct sctp_association *asoc;
873         struct sctp_transport *transport;
874
875         if ((asoc = sctp_lookup_association(laddr, paddr, &transport))) {
876                 sctp_association_put(asoc);
877                 return 1;
878         }
879
880         return 0;
881 }
882
883 /*
884  * SCTP Implementors Guide, 2.18 Handling of address
885  * parameters within the INIT or INIT-ACK.
886  *
887  * D) When searching for a matching TCB upon reception of an INIT
888  *    or INIT-ACK chunk the receiver SHOULD use not only the
889  *    source address of the packet (containing the INIT or
890  *    INIT-ACK) but the receiver SHOULD also use all valid
891  *    address parameters contained within the chunk.
892  *
893  * 2.18.3 Solution description
894  *
895  * This new text clearly specifies to an implementor the need
896  * to look within the INIT or INIT-ACK. Any implementation that
897  * does not do this, may not be able to establish associations
898  * in certain circumstances.
899  *
900  */
901 static struct sctp_association *__sctp_rcv_init_lookup(struct sk_buff *skb,
902         const union sctp_addr *laddr, struct sctp_transport **transportp)
903 {
904         struct sctp_association *asoc;
905         union sctp_addr addr;
906         union sctp_addr *paddr = &addr;
907         struct sctphdr *sh = sctp_hdr(skb);
908         sctp_chunkhdr_t *ch;
909         union sctp_params params;
910         sctp_init_chunk_t *init;
911         struct sctp_transport *transport;
912         struct sctp_af *af;
913
914         ch = (sctp_chunkhdr_t *) skb->data;
915
916         /*
917          * This code will NOT touch anything inside the chunk--it is
918          * strictly READ-ONLY.
919          *
920          * RFC 2960 3  SCTP packet Format
921          *
922          * Multiple chunks can be bundled into one SCTP packet up to
923          * the MTU size, except for the INIT, INIT ACK, and SHUTDOWN
924          * COMPLETE chunks.  These chunks MUST NOT be bundled with any
925          * other chunk in a packet.  See Section 6.10 for more details
926          * on chunk bundling.
927          */
928
929         /* Find the start of the TLVs and the end of the chunk.  This is
930          * the region we search for address parameters.
931          */
932         init = (sctp_init_chunk_t *)skb->data;
933
934         /* Walk the parameters looking for embedded addresses. */
935         sctp_walk_params(params, init, init_hdr.params) {
936
937                 /* Note: Ignoring hostname addresses. */
938                 af = sctp_get_af_specific(param_type2af(params.p->type));
939                 if (!af)
940                         continue;
941
942                 af->from_addr_param(paddr, params.addr, sh->source, 0);
943
944                 asoc = __sctp_lookup_association(laddr, paddr, &transport);
945                 if (asoc)
946                         return asoc;
947         }
948
949         return NULL;
950 }
951
952 /* ADD-IP, Section 5.2
953  * When an endpoint receives an ASCONF Chunk from the remote peer
954  * special procedures may be needed to identify the association the
955  * ASCONF Chunk is associated with. To properly find the association
956  * the following procedures SHOULD be followed:
957  *
958  * D2) If the association is not found, use the address found in the
959  * Address Parameter TLV combined with the port number found in the
960  * SCTP common header. If found proceed to rule D4.
961  *
962  * D2-ext) If more than one ASCONF Chunks are packed together, use the
963  * address found in the ASCONF Address Parameter TLV of each of the
964  * subsequent ASCONF Chunks. If found, proceed to rule D4.
965  */
966 static struct sctp_association *__sctp_rcv_asconf_lookup(
967                                         sctp_chunkhdr_t *ch,
968                                         const union sctp_addr *laddr,
969                                         __be16 peer_port,
970                                         struct sctp_transport **transportp)
971 {
972         sctp_addip_chunk_t *asconf = (struct sctp_addip_chunk *)ch;
973         struct sctp_af *af;
974         union sctp_addr_param *param;
975         union sctp_addr paddr;
976
977         /* Skip over the ADDIP header and find the Address parameter */
978         param = (union sctp_addr_param *)(asconf + 1);
979
980         af = sctp_get_af_specific(param_type2af(param->v4.param_hdr.type));
981         if (unlikely(!af))
982                 return NULL;
983
984         af->from_addr_param(&paddr, param, peer_port, 0);
985
986         return __sctp_lookup_association(laddr, &paddr, transportp);
987 }
988
989
990 /* SCTP-AUTH, Section 6.3:
991 *    If the receiver does not find a STCB for a packet containing an AUTH
992 *    chunk as the first chunk and not a COOKIE-ECHO chunk as the second
993 *    chunk, it MUST use the chunks after the AUTH chunk to look up an existing
994 *    association.
995 *
996 * This means that any chunks that can help us identify the association need
997 * to be looked at to find this assocation.
998 */
999 static struct sctp_association *__sctp_rcv_walk_lookup(struct sk_buff *skb,
1000                                       const union sctp_addr *laddr,
1001                                       struct sctp_transport **transportp)
1002 {
1003         struct sctp_association *asoc = NULL;
1004         sctp_chunkhdr_t *ch;
1005         int have_auth = 0;
1006         unsigned int chunk_num = 1;
1007         __u8 *ch_end;
1008
1009         /* Walk through the chunks looking for AUTH or ASCONF chunks
1010          * to help us find the association.
1011          */
1012         ch = (sctp_chunkhdr_t *) skb->data;
1013         do {
1014                 /* Break out if chunk length is less then minimal. */
1015                 if (ntohs(ch->length) < sizeof(sctp_chunkhdr_t))
1016                         break;
1017
1018                 ch_end = ((__u8 *)ch) + WORD_ROUND(ntohs(ch->length));
1019                 if (ch_end > skb_tail_pointer(skb))
1020                         break;
1021
1022                 switch(ch->type) {
1023                     case SCTP_CID_AUTH:
1024                             have_auth = chunk_num;
1025                             break;
1026
1027                     case SCTP_CID_COOKIE_ECHO:
1028                             /* If a packet arrives containing an AUTH chunk as
1029                              * a first chunk, a COOKIE-ECHO chunk as the second
1030                              * chunk, and possibly more chunks after them, and
1031                              * the receiver does not have an STCB for that
1032                              * packet, then authentication is based on
1033                              * the contents of the COOKIE- ECHO chunk.
1034                              */
1035                             if (have_auth == 1 && chunk_num == 2)
1036                                     return NULL;
1037                             break;
1038
1039                     case SCTP_CID_ASCONF:
1040                             if (have_auth || sctp_addip_noauth)
1041                                     asoc = __sctp_rcv_asconf_lookup(ch, laddr,
1042                                                         sctp_hdr(skb)->source,
1043                                                         transportp);
1044                     default:
1045                             break;
1046                 }
1047
1048                 if (asoc)
1049                         break;
1050
1051                 ch = (sctp_chunkhdr_t *) ch_end;
1052                 chunk_num++;
1053         } while (ch_end < skb_tail_pointer(skb));
1054
1055         return asoc;
1056 }
1057
1058 /*
1059  * There are circumstances when we need to look inside the SCTP packet
1060  * for information to help us find the association.   Examples
1061  * include looking inside of INIT/INIT-ACK chunks or after the AUTH
1062  * chunks.
1063  */
1064 static struct sctp_association *__sctp_rcv_lookup_harder(struct sk_buff *skb,
1065                                       const union sctp_addr *laddr,
1066                                       struct sctp_transport **transportp)
1067 {
1068         sctp_chunkhdr_t *ch;
1069
1070         ch = (sctp_chunkhdr_t *) skb->data;
1071
1072         /* The code below will attempt to walk the chunk and extract
1073          * parameter information.  Before we do that, we need to verify
1074          * that the chunk length doesn't cause overflow.  Otherwise, we'll
1075          * walk off the end.
1076          */
1077         if (WORD_ROUND(ntohs(ch->length)) > skb->len)
1078                 return NULL;
1079
1080         /* If this is INIT/INIT-ACK look inside the chunk too. */
1081         switch (ch->type) {
1082         case SCTP_CID_INIT:
1083         case SCTP_CID_INIT_ACK:
1084                 return __sctp_rcv_init_lookup(skb, laddr, transportp);
1085                 break;
1086
1087         default:
1088                 return __sctp_rcv_walk_lookup(skb, laddr, transportp);
1089                 break;
1090         }
1091
1092
1093         return NULL;
1094 }
1095
1096 /* Lookup an association for an inbound skb. */
1097 static struct sctp_association *__sctp_rcv_lookup(struct sk_buff *skb,
1098                                       const union sctp_addr *paddr,
1099                                       const union sctp_addr *laddr,
1100                                       struct sctp_transport **transportp)
1101 {
1102         struct sctp_association *asoc;
1103
1104         asoc = __sctp_lookup_association(laddr, paddr, transportp);
1105
1106         /* Further lookup for INIT/INIT-ACK packets.
1107          * SCTP Implementors Guide, 2.18 Handling of address
1108          * parameters within the INIT or INIT-ACK.
1109          */
1110         if (!asoc)
1111                 asoc = __sctp_rcv_lookup_harder(skb, laddr, transportp);
1112
1113         return asoc;
1114 }