1 /* SCTP kernel implementation
2  * (C) Copyright IBM Corp. 2001, 2004
3  * Copyright (c) 1999-2000 Cisco, Inc.
4  * Copyright (c) 1999-2001 Motorola, Inc.
5  * Copyright (c) 2001 Intel Corp.
6  *
7  * This file is part of the SCTP kernel implementation
8  *
9  * This SCTP implementation is free software;
10  * you can redistribute it and/or modify it under the terms of
11  * the GNU General Public License as published by
12  * the Free Software Foundation; either version 2, or (at your option)
13  * any later version.
14  *
15  * This SCTP implementation is distributed in the hope that it
16  * will be useful, but WITHOUT ANY WARRANTY; without even the implied
17  *		   ************************
18  * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
19  * See the GNU General Public License for more details.
20  *
21  * You should have received a copy of the GNU General Public License
22  * along with GNU CC; see the file COPYING.  If not, write to
23  * the Free Software Foundation, 59 Temple Place - Suite 330,
24  * Boston, MA 02111-1307, USA.
25  *
26  * Please send any bug reports or fixes you make to the
27  * email addresses:
28  *    lksctp developers <lksctp-developers@lists.sourceforge.net>
29  *
30  * Or submit a bug report through the following website:
31  *    http://www.sf.net/projects/lksctp
32  *
33  * Written or modified by:
34  *    Randall Stewart	    <randall@sctp.chicago.il.us>
35  *    Ken Morneau	    <kmorneau@cisco.com>
36  *    Qiaobing Xie	    <qxie1@email.mot.com>
37  *    La Monte H.P. Yarroll <piggy@acm.org>
38  *    Karl Knutson	    <karl@athena.chicago.il.us>
39  *    Jon Grimm		    <jgrimm@us.ibm.com>
40  *    Xingang Guo	    <xingang.guo@intel.com>
41  *    Hui Huang		    <hui.huang@nokia.com>
42  *    Sridhar Samudrala	    <sri@us.ibm.com>
43  *    Daisy Chang	    <daisyc@us.ibm.com>
44  *    Dajiang Zhang	    <dajiang.zhang@nokia.com>
45  *    Ardelle Fan	    <ardelle.fan@intel.com>
46  *    Ryan Layer	    <rmlayer@us.ibm.com>
47  *    Anup Pemmaiah	    <pemmaiah@cc.usu.edu>
48  *    Kevin Gao             <kevin.gao@intel.com>
49  *
50  * Any bugs reported given to us we will try to fix... any fixes shared will
51  * be incorporated into the next SCTP release.
52  */
53 
54 #ifndef __sctp_structs_h__
55 #define __sctp_structs_h__
56 
57 #include <linux/time.h>		/* We get struct timespec.    */
58 #include <linux/socket.h>	/* linux/in.h needs this!!    */
59 #include <linux/in.h>		/* We get struct sockaddr_in. */
60 #include <linux/in6.h>		/* We get struct in6_addr     */
61 #include <linux/ipv6.h>
62 #include <asm/param.h>		/* We get MAXHOSTNAMELEN.     */
63 #include <linux/atomic.h>		/* This gets us atomic counters.  */
64 #include <linux/skbuff.h>	/* We need sk_buff_head. */
65 #include <linux/workqueue.h>	/* We need tq_struct.	 */
66 #include <linux/sctp.h>		/* We need sctp* header structs.  */
67 #include <net/sctp/auth.h>	/* We need auth specific structs */
68 
69 /* A convenience structure for handling sockaddr structures.
70  * We should wean ourselves off this.
71  */
72 union sctp_addr {
73 	struct sockaddr_in v4;
74 	struct sockaddr_in6 v6;
75 	struct sockaddr sa;
76 };
77 
78 /* Forward declarations for data structures. */
79 struct sctp_globals;
80 struct sctp_endpoint;
81 struct sctp_association;
82 struct sctp_transport;
83 struct sctp_packet;
84 struct sctp_chunk;
85 struct sctp_inq;
86 struct sctp_outq;
87 struct sctp_bind_addr;
88 struct sctp_ulpq;
89 struct sctp_ep_common;
90 struct sctp_ssnmap;
91 struct crypto_hash;
92 
93 
94 #include <net/sctp/tsnmap.h>
95 #include <net/sctp/ulpevent.h>
96 #include <net/sctp/ulpqueue.h>
97 
98 /* Structures useful for managing bind/connect. */
99 
100 struct sctp_bind_bucket {
101 	unsigned short	port;
102 	unsigned short	fastreuse;
103 	struct hlist_node	node;
104 	struct hlist_head	owner;
105 };
106 
107 struct sctp_bind_hashbucket {
108 	spinlock_t	lock;
109 	struct hlist_head	chain;
110 };
111 
112 /* Used for hashing all associations.  */
113 struct sctp_hashbucket {
114 	rwlock_t	lock;
115 	struct hlist_head	chain;
116 } __attribute__((__aligned__(8)));
117 
118 
119 /* The SCTP globals structure. */
120 extern struct sctp_globals {
121 	/* RFC2960 Section 14. Suggested SCTP Protocol Parameter Values
122 	 *
123 	 * The following protocol parameters are RECOMMENDED:
124 	 *
125 	 * RTO.Initial		    - 3	 seconds
126 	 * RTO.Min		    - 1	 second
127 	 * RTO.Max		   -  60 seconds
128 	 * RTO.Alpha		    - 1/8  (3 when converted to right shifts.)
129 	 * RTO.Beta		    - 1/4  (2 when converted to right shifts.)
130 	 */
131 	unsigned int rto_initial;
132 	unsigned int rto_min;
133 	unsigned int rto_max;
134 
135 	/* Note: rto_alpha and rto_beta are really defined as inverse
136 	 * powers of two to facilitate integer operations.
137 	 */
138 	int rto_alpha;
139 	int rto_beta;
140 
141 	/* Max.Burst		    - 4 */
142 	int max_burst;
143 
144 	/* Whether Cookie Preservative is enabled(1) or not(0) */
145 	int cookie_preserve_enable;
146 
147 	/* Valid.Cookie.Life	    - 60  seconds  */
148 	unsigned int valid_cookie_life;
149 
150 	/* Delayed SACK timeout  200ms default*/
151 	unsigned int sack_timeout;
152 
153 	/* HB.interval		    - 30 seconds  */
154 	unsigned int hb_interval;
155 
156 	/* Association.Max.Retrans  - 10 attempts
157 	 * Path.Max.Retrans	    - 5	 attempts (per destination address)
158 	 * Max.Init.Retransmits	    - 8	 attempts
159 	 */
160 	int max_retrans_association;
161 	int max_retrans_path;
162 	int max_retrans_init;
163 
164 	/*
165 	 * Policy for preforming sctp/socket accounting
166 	 * 0   - do socket level accounting, all assocs share sk_sndbuf
167 	 * 1   - do sctp accounting, each asoc may use sk_sndbuf bytes
168 	 */
169 	int sndbuf_policy;
170 
171 	/*
172 	 * Policy for preforming sctp/socket accounting
173 	 * 0   - do socket level accounting, all assocs share sk_rcvbuf
174 	 * 1   - do sctp accounting, each asoc may use sk_rcvbuf bytes
175 	 */
176 	int rcvbuf_policy;
177 
178 	/* The following variables are implementation specific.	 */
179 
180 	/* Default initialization values to be applied to new associations. */
181 	__u16 max_instreams;
182 	__u16 max_outstreams;
183 
184 	/* This is a list of groups of functions for each address
185 	 * family that we support.
186 	 */
187 	struct list_head address_families;
188 
189 	/* This is the hash of all endpoints. */
190 	int ep_hashsize;
191 	struct sctp_hashbucket *ep_hashtable;
192 
193 	/* This is the hash of all associations. */
194 	int assoc_hashsize;
195 	struct sctp_hashbucket *assoc_hashtable;
196 
197 	/* This is the sctp port control hash.	*/
198 	int port_hashsize;
199 	struct sctp_bind_hashbucket *port_hashtable;
200 
201 	/* This is the global local address list.
202 	 * We actively maintain this complete list of addresses on
203 	 * the system by catching address add/delete events.
204 	 *
205 	 * It is a list of sctp_sockaddr_entry.
206 	 */
207 	struct list_head local_addr_list;
208 	int default_auto_asconf;
209 	struct list_head addr_waitq;
210 	struct timer_list addr_wq_timer;
211 	struct list_head auto_asconf_splist;
212 	spinlock_t addr_wq_lock;
213 
214 	/* Lock that protects the local_addr_list writers */
215 	spinlock_t addr_list_lock;
216 
217 	/* Flag to indicate if addip is enabled. */
218 	int addip_enable;
219 	int addip_noauth_enable;
220 
221 	/* Flag to indicate if PR-SCTP is enabled. */
222 	int prsctp_enable;
223 
224 	/* Flag to idicate if SCTP-AUTH is enabled */
225 	int auth_enable;
226 
227 	/*
228 	 * Policy to control SCTP IPv4 address scoping
229 	 * 0   - Disable IPv4 address scoping
230 	 * 1   - Enable IPv4 address scoping
231 	 * 2   - Selectively allow only IPv4 private addresses
232 	 * 3   - Selectively allow only IPv4 link local address
233 	 */
234 	int ipv4_scope_policy;
235 
236 	/* Flag to indicate whether computing and verifying checksum
237 	 * is disabled. */
238         bool checksum_disable;
239 
240 	/* Threshold for rwnd update SACKS.  Receive buffer shifted this many
241 	 * bits is an indicator of when to send and window update SACK.
242 	 */
243 	int rwnd_update_shift;
244 
245 	/* Threshold for autoclose timeout, in seconds. */
246 	unsigned long max_autoclose;
247 } sctp_globals;
248 
249 #define sctp_rto_initial		(sctp_globals.rto_initial)
250 #define sctp_rto_min			(sctp_globals.rto_min)
251 #define sctp_rto_max			(sctp_globals.rto_max)
252 #define sctp_rto_alpha			(sctp_globals.rto_alpha)
253 #define sctp_rto_beta			(sctp_globals.rto_beta)
254 #define sctp_max_burst			(sctp_globals.max_burst)
255 #define sctp_valid_cookie_life		(sctp_globals.valid_cookie_life)
256 #define sctp_cookie_preserve_enable	(sctp_globals.cookie_preserve_enable)
257 #define sctp_max_retrans_association	(sctp_globals.max_retrans_association)
258 #define sctp_sndbuf_policy	 	(sctp_globals.sndbuf_policy)
259 #define sctp_rcvbuf_policy	 	(sctp_globals.rcvbuf_policy)
260 #define sctp_max_retrans_path		(sctp_globals.max_retrans_path)
261 #define sctp_max_retrans_init		(sctp_globals.max_retrans_init)
262 #define sctp_sack_timeout		(sctp_globals.sack_timeout)
263 #define sctp_hb_interval		(sctp_globals.hb_interval)
264 #define sctp_max_instreams		(sctp_globals.max_instreams)
265 #define sctp_max_outstreams		(sctp_globals.max_outstreams)
266 #define sctp_address_families		(sctp_globals.address_families)
267 #define sctp_ep_hashsize		(sctp_globals.ep_hashsize)
268 #define sctp_ep_hashtable		(sctp_globals.ep_hashtable)
269 #define sctp_assoc_hashsize		(sctp_globals.assoc_hashsize)
270 #define sctp_assoc_hashtable		(sctp_globals.assoc_hashtable)
271 #define sctp_port_hashsize		(sctp_globals.port_hashsize)
272 #define sctp_port_hashtable		(sctp_globals.port_hashtable)
273 #define sctp_local_addr_list		(sctp_globals.local_addr_list)
274 #define sctp_local_addr_lock		(sctp_globals.addr_list_lock)
275 #define sctp_auto_asconf_splist		(sctp_globals.auto_asconf_splist)
276 #define sctp_addr_waitq			(sctp_globals.addr_waitq)
277 #define sctp_addr_wq_timer		(sctp_globals.addr_wq_timer)
278 #define sctp_addr_wq_lock		(sctp_globals.addr_wq_lock)
279 #define sctp_default_auto_asconf	(sctp_globals.default_auto_asconf)
280 #define sctp_scope_policy		(sctp_globals.ipv4_scope_policy)
281 #define sctp_addip_enable		(sctp_globals.addip_enable)
282 #define sctp_addip_noauth		(sctp_globals.addip_noauth_enable)
283 #define sctp_prsctp_enable		(sctp_globals.prsctp_enable)
284 #define sctp_auth_enable		(sctp_globals.auth_enable)
285 #define sctp_checksum_disable		(sctp_globals.checksum_disable)
286 #define sctp_rwnd_upd_shift		(sctp_globals.rwnd_update_shift)
287 #define sctp_max_autoclose		(sctp_globals.max_autoclose)
288 
289 /* SCTP Socket type: UDP or TCP style. */
290 typedef enum {
291 	SCTP_SOCKET_UDP = 0,
292 	SCTP_SOCKET_UDP_HIGH_BANDWIDTH,
293 	SCTP_SOCKET_TCP
294 } sctp_socket_type_t;
295 
296 /* Per socket SCTP information. */
297 struct sctp_sock {
298 	/* inet_sock has to be the first member of sctp_sock */
299 	struct inet_sock inet;
300 	/* What kind of a socket is this? */
301 	sctp_socket_type_t type;
302 
303 	/* PF_ family specific functions.  */
304 	struct sctp_pf *pf;
305 
306 	/* Access to HMAC transform. */
307 	struct crypto_hash *hmac;
308 
309 	/* What is our base endpointer? */
310 	struct sctp_endpoint *ep;
311 
312 	struct sctp_bind_bucket *bind_hash;
313 	/* Various Socket Options.  */
314 	__u16 default_stream;
315 	__u32 default_ppid;
316 	__u16 default_flags;
317 	__u32 default_context;
318 	__u32 default_timetolive;
319 	__u32 default_rcv_context;
320 	int max_burst;
321 
322 	/* Heartbeat interval: The endpoint sends out a Heartbeat chunk to
323 	 * the destination address every heartbeat interval. This value
324 	 * will be inherited by all new associations.
325 	 */
326 	__u32 hbinterval;
327 
328 	/* This is the max_retrans value for new associations. */
329 	__u16 pathmaxrxt;
330 
331 	/* The initial Path MTU to use for new associations. */
332 	__u32 pathmtu;
333 
334 	/* The default SACK delay timeout for new associations. */
335 	__u32 sackdelay;
336 	__u32 sackfreq;
337 
338 	/* Flags controlling Heartbeat, SACK delay, and Path MTU Discovery. */
339 	__u32 param_flags;
340 
341 	struct sctp_initmsg initmsg;
342 	struct sctp_rtoinfo rtoinfo;
343 	struct sctp_paddrparams paddrparam;
344 	struct sctp_event_subscribe subscribe;
345 	struct sctp_assocparams assocparams;
346 	int user_frag;
347 	__u32 autoclose;
348 	__u8 nodelay;
349 	__u8 disable_fragments;
350 	__u8 v4mapped;
351 	__u8 frag_interleave;
352 	__u32 adaptation_ind;
353 	__u32 pd_point;
354 
355 	atomic_t pd_mode;
356 	/* Receive to here while partial delivery is in effect. */
357 	struct sk_buff_head pd_lobby;
358 	struct list_head auto_asconf_list;
359 	int do_auto_asconf;
360 };
361 
sctp_sk(const struct sock * sk)362 static inline struct sctp_sock *sctp_sk(const struct sock *sk)
363 {
364        return (struct sctp_sock *)sk;
365 }
366 
sctp_opt2sk(const struct sctp_sock * sp)367 static inline struct sock *sctp_opt2sk(const struct sctp_sock *sp)
368 {
369        return (struct sock *)sp;
370 }
371 
372 #if IS_ENABLED(CONFIG_IPV6)
373 struct sctp6_sock {
374        struct sctp_sock  sctp;
375        struct ipv6_pinfo inet6;
376 };
377 #endif /* CONFIG_IPV6 */
378 
379 
380 /* This is our APPLICATION-SPECIFIC state cookie.
381  * THIS IS NOT DICTATED BY THE SPECIFICATION.
382  */
383 /* These are the parts of an association which we send in the cookie.
384  * Most of these are straight out of:
385  * RFC2960 12.2 Parameters necessary per association (i.e. the TCB)
386  *
387  */
388 
389 struct sctp_cookie {
390 
391 	/* My	       : Tag expected in every inbound packet and sent
392 	 * Verification: in the INIT or INIT ACK chunk.
393 	 * Tag	       :
394 	 */
395 	__u32 my_vtag;
396 
397 	/* Peer's      : Tag expected in every outbound packet except
398 	 * Verification: in the INIT chunk.
399 	 * Tag	       :
400 	 */
401 	__u32 peer_vtag;
402 
403 	/* The rest of these are not from the spec, but really need to
404 	 * be in the cookie.
405 	 */
406 
407 	/* My Tie Tag  : Assist in discovering a restarting association. */
408 	__u32 my_ttag;
409 
410 	/* Peer's Tie Tag: Assist in discovering a restarting association. */
411 	__u32 peer_ttag;
412 
413 	/* When does this cookie expire? */
414 	struct timeval expiration;
415 
416 	/* Number of inbound/outbound streams which are set
417 	 * and negotiated during the INIT process.
418 	 */
419 	__u16 sinit_num_ostreams;
420 	__u16 sinit_max_instreams;
421 
422 	/* This is the first sequence number I used.  */
423 	__u32 initial_tsn;
424 
425 	/* This holds the originating address of the INIT packet.  */
426 	union sctp_addr peer_addr;
427 
428 	/* IG Section 2.35.3
429 	 * Include the source port of the INIT-ACK
430 	 */
431 	__u16		my_port;
432 
433 	__u8 prsctp_capable;
434 
435 	/* Padding for future use */
436 	__u8 padding;
437 
438 	__u32 adaptation_ind;
439 
440 	__u8 auth_random[sizeof(sctp_paramhdr_t) + SCTP_AUTH_RANDOM_LENGTH];
441 	__u8 auth_hmacs[SCTP_AUTH_NUM_HMACS * sizeof(__u16) + 2];
442 	__u8 auth_chunks[sizeof(sctp_paramhdr_t) + SCTP_AUTH_MAX_CHUNKS];
443 
444 	/* This is a shim for my peer's INIT packet, followed by
445 	 * a copy of the raw address list of the association.
446 	 * The length of the raw address list is saved in the
447 	 * raw_addr_list_len field, which will be used at the time when
448 	 * the association TCB is re-constructed from the cookie.
449 	 */
450 	__u32 raw_addr_list_len;
451 	struct sctp_init_chunk peer_init[0];
452 };
453 
454 
455 /* The format of our cookie that we send to our peer. */
456 struct sctp_signed_cookie {
457 	__u8 signature[SCTP_SECRET_SIZE];
458 	__u32 __pad;		/* force sctp_cookie alignment to 64 bits */
459 	struct sctp_cookie c;
460 } __packed;
461 
462 /* This is another convenience type to allocate memory for address
463  * params for the maximum size and pass such structures around
464  * internally.
465  */
466 union sctp_addr_param {
467 	struct sctp_paramhdr p;
468 	struct sctp_ipv4addr_param v4;
469 	struct sctp_ipv6addr_param v6;
470 };
471 
472 /* A convenience type to allow walking through the various
473  * parameters and avoid casting all over the place.
474  */
475 union sctp_params {
476 	void *v;
477 	struct sctp_paramhdr *p;
478 	struct sctp_cookie_preserve_param *life;
479 	struct sctp_hostname_param *dns;
480 	struct sctp_cookie_param *cookie;
481 	struct sctp_supported_addrs_param *sat;
482 	struct sctp_ipv4addr_param *v4;
483 	struct sctp_ipv6addr_param *v6;
484 	union sctp_addr_param *addr;
485 	struct sctp_adaptation_ind_param *aind;
486 	struct sctp_supported_ext_param *ext;
487 	struct sctp_random_param *random;
488 	struct sctp_chunks_param *chunks;
489 	struct sctp_hmac_algo_param *hmac_algo;
490 	struct sctp_addip_param *addip;
491 };
492 
493 /* RFC 2960.  Section 3.3.5 Heartbeat.
494  *    Heartbeat Information: variable length
495  *    The Sender-specific Heartbeat Info field should normally include
496  *    information about the sender's current time when this HEARTBEAT
497  *    chunk is sent and the destination transport address to which this
498  *    HEARTBEAT is sent (see Section 8.3).
499  */
500 typedef struct sctp_sender_hb_info {
501 	struct sctp_paramhdr param_hdr;
502 	union sctp_addr daddr;
503 	unsigned long sent_at;
504 	__u64 hb_nonce;
505 } __packed sctp_sender_hb_info_t;
506 
507 /*
508  *  RFC 2960 1.3.2 Sequenced Delivery within Streams
509  *
510  *  The term "stream" is used in SCTP to refer to a sequence of user
511  *  messages that are to be delivered to the upper-layer protocol in
512  *  order with respect to other messages within the same stream.  This is
513  *  in contrast to its usage in TCP, where it refers to a sequence of
514  *  bytes (in this document a byte is assumed to be eight bits).
515  *  ...
516  *
517  *  This is the structure we use to track both our outbound and inbound
518  *  SSN, or Stream Sequence Numbers.
519  */
520 
521 struct sctp_stream {
522 	__u16 *ssn;
523 	unsigned int len;
524 };
525 
526 struct sctp_ssnmap {
527 	struct sctp_stream in;
528 	struct sctp_stream out;
529 	int malloced;
530 };
531 
532 struct sctp_ssnmap *sctp_ssnmap_new(__u16 in, __u16 out,
533 				    gfp_t gfp);
534 void sctp_ssnmap_free(struct sctp_ssnmap *map);
535 void sctp_ssnmap_clear(struct sctp_ssnmap *map);
536 
537 /* What is the current SSN number for this stream? */
sctp_ssn_peek(struct sctp_stream * stream,__u16 id)538 static inline __u16 sctp_ssn_peek(struct sctp_stream *stream, __u16 id)
539 {
540 	return stream->ssn[id];
541 }
542 
543 /* Return the next SSN number for this stream.	*/
sctp_ssn_next(struct sctp_stream * stream,__u16 id)544 static inline __u16 sctp_ssn_next(struct sctp_stream *stream, __u16 id)
545 {
546 	return stream->ssn[id]++;
547 }
548 
549 /* Skip over this ssn and all below. */
sctp_ssn_skip(struct sctp_stream * stream,__u16 id,__u16 ssn)550 static inline void sctp_ssn_skip(struct sctp_stream *stream, __u16 id,
551 				 __u16 ssn)
552 {
553 	stream->ssn[id] = ssn+1;
554 }
555 
556 /*
557  * Pointers to address related SCTP functions.
558  * (i.e. things that depend on the address family.)
559  */
560 struct sctp_af {
561 	int		(*sctp_xmit)	(struct sk_buff *skb,
562 					 struct sctp_transport *);
563 	int		(*setsockopt)	(struct sock *sk,
564 					 int level,
565 					 int optname,
566 					 char __user *optval,
567 					 unsigned int optlen);
568 	int		(*getsockopt)	(struct sock *sk,
569 					 int level,
570 					 int optname,
571 					 char __user *optval,
572 					 int __user *optlen);
573 	int		(*compat_setsockopt)	(struct sock *sk,
574 					 int level,
575 					 int optname,
576 					 char __user *optval,
577 					 unsigned int optlen);
578 	int		(*compat_getsockopt)	(struct sock *sk,
579 					 int level,
580 					 int optname,
581 					 char __user *optval,
582 					 int __user *optlen);
583 	void		(*get_dst)	(struct sctp_transport *t,
584 					 union sctp_addr *saddr,
585 					 struct flowi *fl,
586 					 struct sock *sk);
587 	void		(*get_saddr)	(struct sctp_sock *sk,
588 					 struct sctp_transport *t,
589 					 struct flowi *fl);
590 	void		(*copy_addrlist) (struct list_head *,
591 					  struct net_device *);
592 	int		(*cmp_addr)	(const union sctp_addr *addr1,
593 					 const union sctp_addr *addr2);
594 	void		(*addr_copy)	(union sctp_addr *dst,
595 					 union sctp_addr *src);
596 	void		(*from_skb)	(union sctp_addr *,
597 					 struct sk_buff *skb,
598 					 int saddr);
599 	void		(*from_sk)	(union sctp_addr *,
600 					 struct sock *sk);
601 	void		(*to_sk_saddr)	(union sctp_addr *,
602 					 struct sock *sk);
603 	void		(*to_sk_daddr)	(union sctp_addr *,
604 					 struct sock *sk);
605 	void		(*from_addr_param) (union sctp_addr *,
606 					    union sctp_addr_param *,
607 					    __be16 port, int iif);
608 	int		(*to_addr_param) (const union sctp_addr *,
609 					  union sctp_addr_param *);
610 	int		(*addr_valid)	(union sctp_addr *,
611 					 struct sctp_sock *,
612 					 const struct sk_buff *);
613 	sctp_scope_t	(*scope) (union sctp_addr *);
614 	void		(*inaddr_any)	(union sctp_addr *, __be16);
615 	int		(*is_any)	(const union sctp_addr *);
616 	int		(*available)	(union sctp_addr *,
617 					 struct sctp_sock *);
618 	int		(*skb_iif)	(const struct sk_buff *sk);
619 	int		(*is_ce)	(const struct sk_buff *sk);
620 	void		(*seq_dump_addr)(struct seq_file *seq,
621 					 union sctp_addr *addr);
622 	void		(*ecn_capable)(struct sock *sk);
623 	__u16		net_header_len;
624 	int		sockaddr_len;
625 	sa_family_t	sa_family;
626 	struct list_head list;
627 };
628 
629 struct sctp_af *sctp_get_af_specific(sa_family_t);
630 int sctp_register_af(struct sctp_af *);
631 
632 /* Protocol family functions. */
633 struct sctp_pf {
634 	void (*event_msgname)(struct sctp_ulpevent *, char *, int *);
635 	void (*skb_msgname)  (struct sk_buff *, char *, int *);
636 	int  (*af_supported) (sa_family_t, struct sctp_sock *);
637 	int  (*cmp_addr) (const union sctp_addr *,
638 			  const union sctp_addr *,
639 			  struct sctp_sock *);
640 	int  (*bind_verify) (struct sctp_sock *, union sctp_addr *);
641 	int  (*send_verify) (struct sctp_sock *, union sctp_addr *);
642 	int  (*supported_addrs)(const struct sctp_sock *, __be16 *);
643 	struct sock *(*create_accept_sk) (struct sock *sk,
644 					  struct sctp_association *asoc);
645 	void (*addr_v4map) (struct sctp_sock *, union sctp_addr *);
646 	struct sctp_af *af;
647 };
648 
649 
650 /* Structure to track chunk fragments that have been acked, but peer
651  * fragments of the same message have not.
652  */
653 struct sctp_datamsg {
654 	/* Chunks waiting to be submitted to lower layer. */
655 	struct list_head chunks;
656 	/* Reference counting. */
657 	atomic_t refcnt;
658 	/* When is this message no longer interesting to the peer? */
659 	unsigned long expires_at;
660 	/* Did the messenge fail to send? */
661 	int send_error;
662 	u8 send_failed:1,
663 	   can_abandon:1,   /* can chunks from this message can be abandoned. */
664 	   can_delay;	    /* should this message be Nagle delayed */
665 };
666 
667 struct sctp_datamsg *sctp_datamsg_from_user(struct sctp_association *,
668 					    struct sctp_sndrcvinfo *,
669 					    struct msghdr *, int len);
670 void sctp_datamsg_free(struct sctp_datamsg *);
671 void sctp_datamsg_put(struct sctp_datamsg *);
672 void sctp_chunk_fail(struct sctp_chunk *, int error);
673 int sctp_chunk_abandoned(struct sctp_chunk *);
674 
675 /* RFC2960 1.4 Key Terms
676  *
677  * o Chunk: A unit of information within an SCTP packet, consisting of
678  * a chunk header and chunk-specific content.
679  *
680  * As a matter of convenience, we remember the SCTP common header for
681  * each chunk as well as a few other header pointers...
682  */
683 struct sctp_chunk {
684 	struct list_head list;
685 
686 	atomic_t refcnt;
687 
688 	/* This is our link to the per-transport transmitted list.  */
689 	struct list_head transmitted_list;
690 
691 	/* This field is used by chunks that hold fragmented data.
692 	 * For the first fragment this is the list that holds the rest of
693 	 * fragments. For the remaining fragments, this is the link to the
694 	 * frag_list maintained in the first fragment.
695 	 */
696 	struct list_head frag_list;
697 
698 	/* This points to the sk_buff containing the actual data.  */
699 	struct sk_buff *skb;
700 
701 	/* These are the SCTP headers by reverse order in a packet.
702 	 * Note that some of these may happen more than once.  In that
703 	 * case, we point at the "current" one, whatever that means
704 	 * for that level of header.
705 	 */
706 
707 	/* We point this at the FIRST TLV parameter to chunk_hdr.  */
708 	union sctp_params param_hdr;
709 	union {
710 		__u8 *v;
711 		struct sctp_datahdr *data_hdr;
712 		struct sctp_inithdr *init_hdr;
713 		struct sctp_sackhdr *sack_hdr;
714 		struct sctp_heartbeathdr *hb_hdr;
715 		struct sctp_sender_hb_info *hbs_hdr;
716 		struct sctp_shutdownhdr *shutdown_hdr;
717 		struct sctp_signed_cookie *cookie_hdr;
718 		struct sctp_ecnehdr *ecne_hdr;
719 		struct sctp_cwrhdr *ecn_cwr_hdr;
720 		struct sctp_errhdr *err_hdr;
721 		struct sctp_addiphdr *addip_hdr;
722 		struct sctp_fwdtsn_hdr *fwdtsn_hdr;
723 		struct sctp_authhdr *auth_hdr;
724 	} subh;
725 
726 	__u8 *chunk_end;
727 
728 	struct sctp_chunkhdr *chunk_hdr;
729 	struct sctphdr *sctp_hdr;
730 
731 	/* This needs to be recoverable for SCTP_SEND_FAILED events. */
732 	struct sctp_sndrcvinfo sinfo;
733 
734 	/* Which association does this belong to?  */
735 	struct sctp_association *asoc;
736 
737 	/* What endpoint received this chunk? */
738 	struct sctp_ep_common *rcvr;
739 
740 	/* We fill this in if we are calculating RTT. */
741 	unsigned long sent_at;
742 
743 	/* What is the origin IP address for this chunk?  */
744 	union sctp_addr source;
745 	/* Destination address for this chunk. */
746 	union sctp_addr dest;
747 
748 	/* For outbound message, track all fragments for SEND_FAILED. */
749 	struct sctp_datamsg *msg;
750 
751 	/* For an inbound chunk, this tells us where it came from.
752 	 * For an outbound chunk, it tells us where we'd like it to
753 	 * go.	It is NULL if we have no preference.
754 	 */
755 	struct sctp_transport *transport;
756 
757 	/* SCTP-AUTH:  For the special case inbound processing of COOKIE-ECHO
758 	 * we need save a pointer to the AUTH chunk, since the SCTP-AUTH
759 	 * spec violates the principle premis that all chunks are processed
760 	 * in order.
761 	 */
762 	struct sk_buff *auth_chunk;
763 
764 #define SCTP_CAN_FRTX 0x0
765 #define SCTP_NEED_FRTX 0x1
766 #define SCTP_DONT_FRTX 0x2
767 	__u16	rtt_in_progress:1,	/* This chunk used for RTT calc? */
768 		has_tsn:1,		/* Does this chunk have a TSN yet? */
769 		has_ssn:1,		/* Does this chunk have a SSN yet? */
770 		singleton:1,		/* Only chunk in the packet? */
771 		end_of_packet:1,	/* Last chunk in the packet? */
772 		ecn_ce_done:1,		/* Have we processed the ECN CE bit? */
773 		pdiscard:1,		/* Discard the whole packet now? */
774 		tsn_gap_acked:1,	/* Is this chunk acked by a GAP ACK? */
775 		data_accepted:1,	/* At least 1 chunk accepted */
776 		auth:1,			/* IN: was auth'ed | OUT: needs auth */
777 		has_asconf:1,		/* IN: have seen an asconf before */
778 		tsn_missing_report:2,	/* Data chunk missing counter. */
779 		fast_retransmit:2;	/* Is this chunk fast retransmitted? */
780 };
781 
782 void sctp_chunk_hold(struct sctp_chunk *);
783 void sctp_chunk_put(struct sctp_chunk *);
784 int sctp_user_addto_chunk(struct sctp_chunk *chunk, int off, int len,
785 			  struct iovec *data);
786 void sctp_chunk_free(struct sctp_chunk *);
787 void  *sctp_addto_chunk(struct sctp_chunk *, int len, const void *data);
788 void  *sctp_addto_chunk_fixed(struct sctp_chunk *, int len, const void *data);
789 struct sctp_chunk *sctp_chunkify(struct sk_buff *,
790 				 const struct sctp_association *,
791 				 struct sock *);
792 void sctp_init_addrs(struct sctp_chunk *, union sctp_addr *,
793 		     union sctp_addr *);
794 const union sctp_addr *sctp_source(const struct sctp_chunk *chunk);
795 
796 enum {
797 	SCTP_ADDR_NEW,		/* new address added to assoc/ep */
798 	SCTP_ADDR_SRC,		/* address can be used as source */
799 	SCTP_ADDR_DEL,		/* address about to be deleted */
800 };
801 
802 /* This is a structure for holding either an IPv6 or an IPv4 address.  */
803 struct sctp_sockaddr_entry {
804 	struct list_head list;
805 	struct rcu_head	rcu;
806 	union sctp_addr a;
807 	__u8 state;
808 	__u8 valid;
809 };
810 
811 #define SCTP_ADDRESS_TICK_DELAY	500
812 
813 typedef struct sctp_chunk *(sctp_packet_phandler_t)(struct sctp_association *);
814 
815 /* This structure holds lists of chunks as we are assembling for
816  * transmission.
817  */
818 struct sctp_packet {
819 	/* These are the SCTP header values (host order) for the packet. */
820 	__u16 source_port;
821 	__u16 destination_port;
822 	__u32 vtag;
823 
824 	/* This contains the payload chunks.  */
825 	struct list_head chunk_list;
826 
827 	/* This is the overhead of the sctp and ip headers. */
828 	size_t overhead;
829 	/* This is the total size of all chunks INCLUDING padding.  */
830 	size_t size;
831 
832 	/* The packet is destined for this transport address.
833 	 * The function we finally use to pass down to the next lower
834 	 * layer lives in the transport structure.
835 	 */
836 	struct sctp_transport *transport;
837 
838 	/* pointer to the auth chunk for this packet */
839 	struct sctp_chunk *auth;
840 
841 	u8  has_cookie_echo:1,	/* This packet contains a COOKIE-ECHO chunk. */
842 	    has_sack:1,		/* This packet contains a SACK chunk. */
843 	    has_auth:1,		/* This packet contains an AUTH chunk */
844 	    has_data:1,		/* This packet contains at least 1 DATA chunk */
845 	    ipfragok:1,		/* So let ip fragment this packet */
846 	    malloced:1;		/* Is it malloced? */
847 };
848 
849 struct sctp_packet *sctp_packet_init(struct sctp_packet *,
850 				     struct sctp_transport *,
851 				     __u16 sport, __u16 dport);
852 struct sctp_packet *sctp_packet_config(struct sctp_packet *, __u32 vtag, int);
853 sctp_xmit_t sctp_packet_transmit_chunk(struct sctp_packet *,
854                                        struct sctp_chunk *, int);
855 sctp_xmit_t sctp_packet_append_chunk(struct sctp_packet *,
856                                      struct sctp_chunk *);
857 int sctp_packet_transmit(struct sctp_packet *);
858 void sctp_packet_free(struct sctp_packet *);
859 
sctp_packet_empty(struct sctp_packet * packet)860 static inline int sctp_packet_empty(struct sctp_packet *packet)
861 {
862 	return packet->size == packet->overhead;
863 }
864 
865 /* This represents a remote transport address.
866  * For local transport addresses, we just use union sctp_addr.
867  *
868  * RFC2960 Section 1.4 Key Terms
869  *
870  *   o	Transport address:  A Transport Address is traditionally defined
871  *	by Network Layer address, Transport Layer protocol and Transport
872  *	Layer port number.  In the case of SCTP running over IP, a
873  *	transport address is defined by the combination of an IP address
874  *	and an SCTP port number (where SCTP is the Transport protocol).
875  *
876  * RFC2960 Section 7.1 SCTP Differences from TCP Congestion control
877  *
878  *   o	The sender keeps a separate congestion control parameter set for
879  *	each of the destination addresses it can send to (not each
880  *	source-destination pair but for each destination).  The parameters
881  *	should decay if the address is not used for a long enough time
882  *	period.
883  *
884  */
885 struct sctp_transport {
886 	/* A list of transports. */
887 	struct list_head transports;
888 
889 	/* Reference counting. */
890 	atomic_t refcnt;
891 	__u32	 dead:1,
892 		/* RTO-Pending : A flag used to track if one of the DATA
893 		 *		chunks sent to this address is currently being
894 		 *		used to compute a RTT. If this flag is 0,
895 		 *		the next DATA chunk sent to this destination
896 		 *		should be used to compute a RTT and this flag
897 		 *		should be set. Every time the RTT
898 		 *		calculation completes (i.e. the DATA chunk
899 		 *		is SACK'd) clear this flag.
900 		 */
901 		 rto_pending:1,
902 
903 		/*
904 		 * hb_sent : a flag that signals that we have a pending
905 		 * heartbeat.
906 		 */
907 		hb_sent:1,
908 
909 		/* Is the Path MTU update pending on this tranport */
910 		pmtu_pending:1,
911 
912 		/* Is this structure kfree()able? */
913 		malloced:1;
914 
915 	struct flowi fl;
916 
917 	/* This is the peer's IP address and port. */
918 	union sctp_addr ipaddr;
919 
920 	/* These are the functions we call to handle LLP stuff.	 */
921 	struct sctp_af *af_specific;
922 
923 	/* Which association do we belong to?  */
924 	struct sctp_association *asoc;
925 
926 	/* RFC2960
927 	 *
928 	 * 12.3 Per Transport Address Data
929 	 *
930 	 * For each destination transport address in the peer's
931 	 * address list derived from the INIT or INIT ACK chunk, a
932 	 * number of data elements needs to be maintained including:
933 	 */
934 	/* RTO	       : The current retransmission timeout value.  */
935 	unsigned long rto;
936 
937 	__u32 rtt;		/* This is the most recent RTT.	 */
938 
939 	/* RTTVAR      : The current RTT variation.  */
940 	__u32 rttvar;
941 
942 	/* SRTT	       : The current smoothed round trip time.	*/
943 	__u32 srtt;
944 
945 	/*
946 	 * These are the congestion stats.
947 	 */
948 	/* cwnd	       : The current congestion window.	 */
949 	__u32 cwnd;		  /* This is the actual cwnd.  */
950 
951 	/* ssthresh    : The current slow start threshold value.  */
952 	__u32 ssthresh;
953 
954 	/* partial     : The tracking method for increase of cwnd when in
955 	 * bytes acked : congestion avoidance mode (see Section 6.2.2)
956 	 */
957 	__u32 partial_bytes_acked;
958 
959 	/* Data that has been sent, but not acknowledged. */
960 	__u32 flight_size;
961 
962 	__u32 burst_limited;	/* Holds old cwnd when max.burst is applied */
963 
964 	/* Destination */
965 	struct dst_entry *dst;
966 	/* Source address. */
967 	union sctp_addr saddr;
968 
969 	/* Heartbeat interval: The endpoint sends out a Heartbeat chunk to
970 	 * the destination address every heartbeat interval.
971 	 */
972 	unsigned long hbinterval;
973 
974 	/* SACK delay timeout */
975 	unsigned long sackdelay;
976 	__u32 sackfreq;
977 
978 	/* When was the last time (in jiffies) that we heard from this
979 	 * transport?  We use this to pick new active and retran paths.
980 	 */
981 	unsigned long last_time_heard;
982 
983 	/* Last time(in jiffies) when cwnd is reduced due to the congestion
984 	 * indication based on ECNE chunk.
985 	 */
986 	unsigned long last_time_ecne_reduced;
987 
988 	/* This is the max_retrans value for the transport and will
989 	 * be initialized from the assocs value.  This can be changed
990 	 * using SCTP_SET_PEER_ADDR_PARAMS socket option.
991 	 */
992 	__u16 pathmaxrxt;
993 
994 	/* PMTU	      : The current known path MTU.  */
995 	__u32 pathmtu;
996 
997 	/* Flags controlling Heartbeat, SACK delay, and Path MTU Discovery. */
998 	__u32 param_flags;
999 
1000 	/* The number of times INIT has been sent on this transport. */
1001 	int init_sent_count;
1002 
1003 	/* state       : The current state of this destination,
1004 	 *             : i.e. SCTP_ACTIVE, SCTP_INACTIVE, SCTP_UNKNOWN.
1005 	 */
1006 	int state;
1007 
1008 	/* These are the error stats for this destination.  */
1009 
1010 	/* Error count : The current error count for this destination.	*/
1011 	unsigned short error_count;
1012 
1013 	/* Per	       : A timer used by each destination.
1014 	 * Destination :
1015 	 * Timer       :
1016 	 *
1017 	 * [Everywhere else in the text this is called T3-rtx. -ed]
1018 	 */
1019 	struct timer_list T3_rtx_timer;
1020 
1021 	/* Heartbeat timer is per destination. */
1022 	struct timer_list hb_timer;
1023 
1024 	/* Timer to handle ICMP proto unreachable envets */
1025 	struct timer_list proto_unreach_timer;
1026 
1027 	/* Since we're using per-destination retransmission timers
1028 	 * (see above), we're also using per-destination "transmitted"
1029 	 * queues.  This probably ought to be a private struct
1030 	 * accessible only within the outqueue, but it's not, yet.
1031 	 */
1032 	struct list_head transmitted;
1033 
1034 	/* We build bundle-able packets for this transport here.  */
1035 	struct sctp_packet packet;
1036 
1037 	/* This is the list of transports that have chunks to send.  */
1038 	struct list_head send_ready;
1039 
1040 	/* State information saved for SFR_CACC algorithm. The key
1041 	 * idea in SFR_CACC is to maintain state at the sender on a
1042 	 * per-destination basis when a changeover happens.
1043 	 *	char changeover_active;
1044 	 *	char cycling_changeover;
1045 	 *	__u32 next_tsn_at_change;
1046 	 *	char cacc_saw_newack;
1047 	 */
1048 	struct {
1049 		/* An unsigned integer, which stores the next TSN to be
1050 		 * used by the sender, at the moment of changeover.
1051 		 */
1052 		__u32 next_tsn_at_change;
1053 
1054 		/* A flag which indicates the occurrence of a changeover */
1055 		char changeover_active;
1056 
1057 		/* A flag which indicates whether the change of primary is
1058 		 * the first switch to this destination address during an
1059 		 * active switch.
1060 		 */
1061 		char cycling_changeover;
1062 
1063 		/* A temporary flag, which is used during the processing of
1064 		 * a SACK to estimate the causative TSN(s)'s group.
1065 		 */
1066 		char cacc_saw_newack;
1067 	} cacc;
1068 
1069 	/* 64-bit random number sent with heartbeat. */
1070 	__u64 hb_nonce;
1071 };
1072 
1073 struct sctp_transport *sctp_transport_new(const union sctp_addr *,
1074 					  gfp_t);
1075 void sctp_transport_set_owner(struct sctp_transport *,
1076 			      struct sctp_association *);
1077 void sctp_transport_route(struct sctp_transport *, union sctp_addr *,
1078 			  struct sctp_sock *);
1079 void sctp_transport_pmtu(struct sctp_transport *, struct sock *sk);
1080 void sctp_transport_free(struct sctp_transport *);
1081 void sctp_transport_reset_timers(struct sctp_transport *);
1082 void sctp_transport_hold(struct sctp_transport *);
1083 void sctp_transport_put(struct sctp_transport *);
1084 void sctp_transport_update_rto(struct sctp_transport *, __u32);
1085 void sctp_transport_raise_cwnd(struct sctp_transport *, __u32, __u32);
1086 void sctp_transport_lower_cwnd(struct sctp_transport *, sctp_lower_cwnd_t);
1087 void sctp_transport_burst_limited(struct sctp_transport *);
1088 void sctp_transport_burst_reset(struct sctp_transport *);
1089 unsigned long sctp_transport_timeout(struct sctp_transport *);
1090 void sctp_transport_reset(struct sctp_transport *);
1091 void sctp_transport_update_pmtu(struct sctp_transport *, u32);
1092 void sctp_transport_immediate_rtx(struct sctp_transport *);
1093 
1094 
1095 /* This is the structure we use to queue packets as they come into
1096  * SCTP.  We write packets to it and read chunks from it.
1097  */
1098 struct sctp_inq {
1099 	/* This is actually a queue of sctp_chunk each
1100 	 * containing a partially decoded packet.
1101 	 */
1102 	struct list_head in_chunk_list;
1103 	/* This is the packet which is currently off the in queue and is
1104 	 * being worked on through the inbound chunk processing.
1105 	 */
1106 	struct sctp_chunk *in_progress;
1107 
1108 	/* This is the delayed task to finish delivering inbound
1109 	 * messages.
1110 	 */
1111 	struct work_struct immediate;
1112 
1113 	int malloced;	     /* Is this structure kfree()able?	*/
1114 };
1115 
1116 void sctp_inq_init(struct sctp_inq *);
1117 void sctp_inq_free(struct sctp_inq *);
1118 void sctp_inq_push(struct sctp_inq *, struct sctp_chunk *packet);
1119 struct sctp_chunk *sctp_inq_pop(struct sctp_inq *);
1120 struct sctp_chunkhdr *sctp_inq_peek(struct sctp_inq *);
1121 void sctp_inq_set_th_handler(struct sctp_inq *, work_func_t);
1122 
1123 /* This is the structure we use to hold outbound chunks.  You push
1124  * chunks in and they automatically pop out the other end as bundled
1125  * packets (it calls (*output_handler)()).
1126  *
1127  * This structure covers sections 6.3, 6.4, 6.7, 6.8, 6.10, 7., 8.1,
1128  * and 8.2 of the v13 draft.
1129  *
1130  * It handles retransmissions.	The connection to the timeout portion
1131  * of the state machine is through sctp_..._timeout() and timeout_handler.
1132  *
1133  * If you feed it SACKs, it will eat them.
1134  *
1135  * If you give it big chunks, it will fragment them.
1136  *
1137  * It assigns TSN's to data chunks.  This happens at the last possible
1138  * instant before transmission.
1139  *
1140  * When free()'d, it empties itself out via output_handler().
1141  */
1142 struct sctp_outq {
1143 	struct sctp_association *asoc;
1144 
1145 	/* Data pending that has never been transmitted.  */
1146 	struct list_head out_chunk_list;
1147 
1148 	unsigned out_qlen;	/* Total length of queued data chunks. */
1149 
1150 	/* Error of send failed, may used in SCTP_SEND_FAILED event. */
1151 	unsigned error;
1152 
1153 	/* These are control chunks we want to send.  */
1154 	struct list_head control_chunk_list;
1155 
1156 	/* These are chunks that have been sacked but are above the
1157 	 * CTSN, or cumulative tsn ack point.
1158 	 */
1159 	struct list_head sacked;
1160 
1161 	/* Put chunks on this list to schedule them for
1162 	 * retransmission.
1163 	 */
1164 	struct list_head retransmit;
1165 
1166 	/* Put chunks on this list to save them for FWD TSN processing as
1167 	 * they were abandoned.
1168 	 */
1169 	struct list_head abandoned;
1170 
1171 	/* How many unackd bytes do we have in-flight?	*/
1172 	__u32 outstanding_bytes;
1173 
1174 	/* Are we doing fast-rtx on this queue */
1175 	char fast_rtx;
1176 
1177 	/* Corked? */
1178 	char cork;
1179 
1180 	/* Is this structure empty?  */
1181 	char empty;
1182 
1183 	/* Are we kfree()able? */
1184 	char malloced;
1185 };
1186 
1187 void sctp_outq_init(struct sctp_association *, struct sctp_outq *);
1188 void sctp_outq_teardown(struct sctp_outq *);
1189 void sctp_outq_free(struct sctp_outq*);
1190 int sctp_outq_tail(struct sctp_outq *, struct sctp_chunk *chunk);
1191 int sctp_outq_sack(struct sctp_outq *, struct sctp_sackhdr *);
1192 int sctp_outq_is_empty(const struct sctp_outq *);
1193 void sctp_outq_restart(struct sctp_outq *);
1194 
1195 void sctp_retransmit(struct sctp_outq *, struct sctp_transport *,
1196 		     sctp_retransmit_reason_t);
1197 void sctp_retransmit_mark(struct sctp_outq *, struct sctp_transport *, __u8);
1198 int sctp_outq_uncork(struct sctp_outq *);
1199 /* Uncork and flush an outqueue.  */
sctp_outq_cork(struct sctp_outq * q)1200 static inline void sctp_outq_cork(struct sctp_outq *q)
1201 {
1202 	q->cork = 1;
1203 }
1204 
1205 /* These bind address data fields common between endpoints and associations */
1206 struct sctp_bind_addr {
1207 
1208 	/* RFC 2960 12.1 Parameters necessary for the SCTP instance
1209 	 *
1210 	 * SCTP Port:	The local SCTP port number the endpoint is
1211 	 *		bound to.
1212 	 */
1213 	__u16 port;
1214 
1215 	/* RFC 2960 12.1 Parameters necessary for the SCTP instance
1216 	 *
1217 	 * Address List: The list of IP addresses that this instance
1218 	 *	has bound.  This information is passed to one's
1219 	 *	peer(s) in INIT and INIT ACK chunks.
1220 	 */
1221 	struct list_head address_list;
1222 
1223 	int malloced;	     /* Are we kfree()able?  */
1224 };
1225 
1226 void sctp_bind_addr_init(struct sctp_bind_addr *, __u16 port);
1227 void sctp_bind_addr_free(struct sctp_bind_addr *);
1228 int sctp_bind_addr_copy(struct sctp_bind_addr *dest,
1229 			const struct sctp_bind_addr *src,
1230 			sctp_scope_t scope, gfp_t gfp,
1231 			int flags);
1232 int sctp_bind_addr_dup(struct sctp_bind_addr *dest,
1233 			const struct sctp_bind_addr *src,
1234 			gfp_t gfp);
1235 int sctp_add_bind_addr(struct sctp_bind_addr *, union sctp_addr *,
1236 		       __u8 addr_state, gfp_t gfp);
1237 int sctp_del_bind_addr(struct sctp_bind_addr *, union sctp_addr *);
1238 int sctp_bind_addr_match(struct sctp_bind_addr *, const union sctp_addr *,
1239 			 struct sctp_sock *);
1240 int sctp_bind_addr_conflict(struct sctp_bind_addr *, const union sctp_addr *,
1241 			 struct sctp_sock *, struct sctp_sock *);
1242 int sctp_bind_addr_state(const struct sctp_bind_addr *bp,
1243 			 const union sctp_addr *addr);
1244 union sctp_addr *sctp_find_unmatch_addr(struct sctp_bind_addr	*bp,
1245 					const union sctp_addr	*addrs,
1246 					int			addrcnt,
1247 					struct sctp_sock	*opt);
1248 union sctp_params sctp_bind_addrs_to_raw(const struct sctp_bind_addr *bp,
1249 					 int *addrs_len,
1250 					 gfp_t gfp);
1251 int sctp_raw_to_bind_addrs(struct sctp_bind_addr *bp, __u8 *raw, int len,
1252 			   __u16 port, gfp_t gfp);
1253 
1254 sctp_scope_t sctp_scope(const union sctp_addr *);
1255 int sctp_in_scope(const union sctp_addr *addr, const sctp_scope_t scope);
1256 int sctp_is_any(struct sock *sk, const union sctp_addr *addr);
1257 int sctp_addr_is_valid(const union sctp_addr *addr);
1258 int sctp_is_ep_boundall(struct sock *sk);
1259 
1260 
1261 /* What type of endpoint?  */
1262 typedef enum {
1263 	SCTP_EP_TYPE_SOCKET,
1264 	SCTP_EP_TYPE_ASSOCIATION,
1265 } sctp_endpoint_type_t;
1266 
1267 /*
1268  * A common base class to bridge the implmentation view of a
1269  * socket (usually listening) endpoint versus an association's
1270  * local endpoint.
1271  * This common structure is useful for several purposes:
1272  *   1) Common interface for lookup routines.
1273  *	a) Subfunctions work for either endpoint or association
1274  *	b) Single interface to lookup allows hiding the lookup lock rather
1275  *	   than acquiring it externally.
1276  *   2) Common interface for the inbound chunk handling/state machine.
1277  *   3) Common object handling routines for reference counting, etc.
1278  *   4) Disentangle association lookup from endpoint lookup, where we
1279  *	do not have to find our endpoint to find our association.
1280  *
1281  */
1282 
1283 struct sctp_ep_common {
1284 	/* Fields to help us manage our entries in the hash tables. */
1285 	struct hlist_node node;
1286 	int hashent;
1287 
1288 	/* Runtime type information.  What kind of endpoint is this? */
1289 	sctp_endpoint_type_t type;
1290 
1291 	/* Some fields to help us manage this object.
1292 	 *   refcnt   - Reference count access to this object.
1293 	 *   dead     - Do not attempt to use this object.
1294 	 *   malloced - Do we need to kfree this object?
1295 	 */
1296 	atomic_t    refcnt;
1297 	char	    dead;
1298 	char	    malloced;
1299 
1300 	/* What socket does this endpoint belong to?  */
1301 	struct sock *sk;
1302 
1303 	/* This is where we receive inbound chunks.  */
1304 	struct sctp_inq	  inqueue;
1305 
1306 	/* This substructure includes the defining parameters of the
1307 	 * endpoint:
1308 	 * bind_addr.port is our shared port number.
1309 	 * bind_addr.address_list is our set of local IP addresses.
1310 	 */
1311 	struct sctp_bind_addr bind_addr;
1312 };
1313 
1314 
1315 /* RFC Section 1.4 Key Terms
1316  *
1317  * o SCTP endpoint: The logical sender/receiver of SCTP packets. On a
1318  *   multi-homed host, an SCTP endpoint is represented to its peers as a
1319  *   combination of a set of eligible destination transport addresses to
1320  *   which SCTP packets can be sent and a set of eligible source
1321  *   transport addresses from which SCTP packets can be received.
1322  *   All transport addresses used by an SCTP endpoint must use the
1323  *   same port number, but can use multiple IP addresses. A transport
1324  *   address used by an SCTP endpoint must not be used by another
1325  *   SCTP endpoint. In other words, a transport address is unique
1326  *   to an SCTP endpoint.
1327  *
1328  * From an implementation perspective, each socket has one of these.
1329  * A TCP-style socket will have exactly one association on one of
1330  * these.  An UDP-style socket will have multiple associations hanging
1331  * off one of these.
1332  */
1333 
1334 struct sctp_endpoint {
1335 	/* Common substructure for endpoint and association. */
1336 	struct sctp_ep_common base;
1337 
1338 	/* Associations: A list of current associations and mappings
1339 	 *	      to the data consumers for each association. This
1340 	 *	      may be in the form of a hash table or other
1341 	 *	      implementation dependent structure. The data
1342 	 *	      consumers may be process identification
1343 	 *	      information such as file descriptors, named pipe
1344 	 *	      pointer, or table pointers dependent on how SCTP
1345 	 *	      is implemented.
1346 	 */
1347 	/* This is really a list of struct sctp_association entries. */
1348 	struct list_head asocs;
1349 
1350 	/* Secret Key: A secret key used by this endpoint to compute
1351 	 *	      the MAC.	This SHOULD be a cryptographic quality
1352 	 *	      random number with a sufficient length.
1353 	 *	      Discussion in [RFC1750] can be helpful in
1354 	 *	      selection of the key.
1355 	 */
1356 	__u8 secret_key[SCTP_HOW_MANY_SECRETS][SCTP_SECRET_SIZE];
1357 	int current_key;
1358 	int last_key;
1359 	int key_changed_at;
1360 
1361  	/* digest:  This is a digest of the sctp cookie.  This field is
1362  	 * 	    only used on the receive path when we try to validate
1363  	 * 	    that the cookie has not been tampered with.  We put
1364  	 * 	    this here so we pre-allocate this once and can re-use
1365  	 * 	    on every receive.
1366  	 */
1367  	__u8 *digest;
1368 
1369 	/* sendbuf acct. policy.	*/
1370 	__u32 sndbuf_policy;
1371 
1372 	/* rcvbuf acct. policy.	*/
1373 	__u32 rcvbuf_policy;
1374 
1375 	/* SCTP AUTH: array of the HMACs that will be allocated
1376 	 * we need this per association so that we don't serialize
1377 	 */
1378 	struct crypto_hash **auth_hmacs;
1379 
1380 	/* SCTP-AUTH: hmacs for the endpoint encoded into parameter */
1381 	 struct sctp_hmac_algo_param *auth_hmacs_list;
1382 
1383 	/* SCTP-AUTH: chunks to authenticate encoded into parameter */
1384 	struct sctp_chunks_param *auth_chunk_list;
1385 
1386 	/* SCTP-AUTH: endpoint shared keys */
1387 	struct list_head endpoint_shared_keys;
1388 	__u16 active_key_id;
1389 };
1390 
1391 /* Recover the outter endpoint structure. */
sctp_ep(struct sctp_ep_common * base)1392 static inline struct sctp_endpoint *sctp_ep(struct sctp_ep_common *base)
1393 {
1394 	struct sctp_endpoint *ep;
1395 
1396 	ep = container_of(base, struct sctp_endpoint, base);
1397 	return ep;
1398 }
1399 
1400 /* These are function signatures for manipulating endpoints.  */
1401 struct sctp_endpoint *sctp_endpoint_new(struct sock *, gfp_t);
1402 void sctp_endpoint_free(struct sctp_endpoint *);
1403 void sctp_endpoint_put(struct sctp_endpoint *);
1404 void sctp_endpoint_hold(struct sctp_endpoint *);
1405 void sctp_endpoint_add_asoc(struct sctp_endpoint *, struct sctp_association *);
1406 struct sctp_association *sctp_endpoint_lookup_assoc(
1407 	const struct sctp_endpoint *ep,
1408 	const union sctp_addr *paddr,
1409 	struct sctp_transport **);
1410 int sctp_endpoint_is_peeled_off(struct sctp_endpoint *,
1411 				const union sctp_addr *);
1412 struct sctp_endpoint *sctp_endpoint_is_match(struct sctp_endpoint *,
1413 					const union sctp_addr *);
1414 int sctp_has_association(const union sctp_addr *laddr,
1415 			 const union sctp_addr *paddr);
1416 
1417 int sctp_verify_init(const struct sctp_association *asoc, sctp_cid_t,
1418 		     sctp_init_chunk_t *peer_init, struct sctp_chunk *chunk,
1419 		     struct sctp_chunk **err_chunk);
1420 int sctp_process_init(struct sctp_association *, struct sctp_chunk *chunk,
1421 		      const union sctp_addr *peer,
1422 		      sctp_init_chunk_t *init, gfp_t gfp);
1423 __u32 sctp_generate_tag(const struct sctp_endpoint *);
1424 __u32 sctp_generate_tsn(const struct sctp_endpoint *);
1425 
1426 struct sctp_inithdr_host {
1427 	__u32 init_tag;
1428 	__u32 a_rwnd;
1429 	__u16 num_outbound_streams;
1430 	__u16 num_inbound_streams;
1431 	__u32 initial_tsn;
1432 };
1433 
1434 /* RFC2960
1435  *
1436  * 12. Recommended Transmission Control Block (TCB) Parameters
1437  *
1438  * This section details a recommended set of parameters that should
1439  * be contained within the TCB for an implementation. This section is
1440  * for illustrative purposes and should not be deemed as requirements
1441  * on an implementation or as an exhaustive list of all parameters
1442  * inside an SCTP TCB. Each implementation may need its own additional
1443  * parameters for optimization.
1444  */
1445 
1446 
1447 /* Here we have information about each individual association. */
1448 struct sctp_association {
1449 
1450 	/* A base structure common to endpoint and association.
1451 	 * In this context, it represents the associations's view
1452 	 * of the local endpoint of the association.
1453 	 */
1454 	struct sctp_ep_common base;
1455 
1456 	/* Associations on the same socket. */
1457 	struct list_head asocs;
1458 
1459 	/* association id. */
1460 	sctp_assoc_t assoc_id;
1461 
1462 	/* This is our parent endpoint.	 */
1463 	struct sctp_endpoint *ep;
1464 
1465 	/* These are those association elements needed in the cookie.  */
1466 	struct sctp_cookie c;
1467 
1468 	/* This is all information about our peer.  */
1469 	struct {
1470 		/* rwnd
1471 		 *
1472 		 * Peer Rwnd   : Current calculated value of the peer's rwnd.
1473 		 */
1474 		__u32 rwnd;
1475 
1476 		/* transport_addr_list
1477 		 *
1478 		 * Peer	       : A list of SCTP transport addresses that the
1479 		 * Transport   : peer is bound to. This information is derived
1480 		 * Address     : from the INIT or INIT ACK and is used to
1481 		 * List	       : associate an inbound packet with a given
1482 		 *	       : association. Normally this information is
1483 		 *	       : hashed or keyed for quick lookup and access
1484 		 *	       : of the TCB.
1485 		 *	       : The list is also initialized with the list
1486 		 *	       : of addresses passed with the sctp_connectx()
1487 		 *	       : call.
1488 		 *
1489 		 * It is a list of SCTP_transport's.
1490 		 */
1491 		struct list_head transport_addr_list;
1492 
1493 		/* transport_count
1494 		 *
1495 		 * Peer        : A count of the number of peer addresses
1496 		 * Transport   : in the Peer Transport Address List.
1497 		 * Address     :
1498 		 * Count       :
1499 		 */
1500 		__u16 transport_count;
1501 
1502 		/* port
1503 		 *   The transport layer port number.
1504 		 */
1505 		__u16 port;
1506 
1507 		/* primary_path
1508 		 *
1509 		 * Primary     : This is the current primary destination
1510 		 * Path	       : transport address of the peer endpoint.  It
1511 		 *	       : may also specify a source transport address
1512 		 *	       : on this endpoint.
1513 		 *
1514 		 * All of these paths live on transport_addr_list.
1515 		 *
1516 		 * At the bakeoffs, we discovered that the intent of
1517 		 * primaryPath is that it only changes when the ULP
1518 		 * asks to have it changed.  We add the activePath to
1519 		 * designate the connection we are currently using to
1520 		 * transmit new data and most control chunks.
1521 		 */
1522 		struct sctp_transport *primary_path;
1523 
1524 		/* Cache the primary path address here, when we
1525 		 * need a an address for msg_name.
1526 		 */
1527 		union sctp_addr primary_addr;
1528 
1529 		/* active_path
1530 		 *   The path that we are currently using to
1531 		 *   transmit new data and most control chunks.
1532 		 */
1533 		struct sctp_transport *active_path;
1534 
1535 		/* retran_path
1536 		 *
1537 		 * RFC2960 6.4 Multi-homed SCTP Endpoints
1538 		 * ...
1539 		 * Furthermore, when its peer is multi-homed, an
1540 		 * endpoint SHOULD try to retransmit a chunk to an
1541 		 * active destination transport address that is
1542 		 * different from the last destination address to
1543 		 * which the DATA chunk was sent.
1544 		 */
1545 		struct sctp_transport *retran_path;
1546 
1547 		/* Pointer to last transport I have sent on.  */
1548 		struct sctp_transport *last_sent_to;
1549 
1550 		/* This is the last transport I have received DATA on.	*/
1551 		struct sctp_transport *last_data_from;
1552 
1553 		/*
1554 		 * Mapping  An array of bits or bytes indicating which out of
1555 		 * Array    order TSN's have been received (relative to the
1556 		 *	    Last Rcvd TSN). If no gaps exist, i.e. no out of
1557 		 *	    order packets have been received, this array
1558 		 *	    will be set to all zero. This structure may be
1559 		 *	    in the form of a circular buffer or bit array.
1560 		 *
1561 		 * Last Rcvd   : This is the last TSN received in
1562 		 * TSN	       : sequence. This value is set initially by
1563 		 *	       : taking the peer's Initial TSN, received in
1564 		 *	       : the INIT or INIT ACK chunk, and subtracting
1565 		 *	       : one from it.
1566 		 *
1567 		 * Throughout most of the specification this is called the
1568 		 * "Cumulative TSN ACK Point".	In this case, we
1569 		 * ignore the advice in 12.2 in favour of the term
1570 		 * used in the bulk of the text.  This value is hidden
1571 		 * in tsn_map--we get it by calling sctp_tsnmap_get_ctsn().
1572 		 */
1573 		struct sctp_tsnmap tsn_map;
1574 
1575 		/* Ack State   : This flag indicates if the next received
1576 		 *             : packet is to be responded to with a
1577 		 *             : SACK. This is initializedto 0.  When a packet
1578 		 *             : is received it is incremented. If this value
1579 		 *             : reaches 2 or more, a SACK is sent and the
1580 		 *             : value is reset to 0. Note: This is used only
1581 		 *             : when no DATA chunks are received out of
1582 		 *             : order.  When DATA chunks are out of order,
1583 		 *             : SACK's are not delayed (see Section 6).
1584 		 */
1585 		__u8    sack_needed;     /* Do we need to sack the peer? */
1586 		__u32	sack_cnt;
1587 
1588 		/* These are capabilities which our peer advertised.  */
1589 		__u8	ecn_capable:1,	    /* Can peer do ECN? */
1590 			ipv4_address:1,	    /* Peer understands IPv4 addresses? */
1591 			ipv6_address:1,	    /* Peer understands IPv6 addresses? */
1592 			hostname_address:1, /* Peer understands DNS addresses? */
1593 			asconf_capable:1,   /* Does peer support ADDIP? */
1594 			prsctp_capable:1,   /* Can peer do PR-SCTP? */
1595 			auth_capable:1;	    /* Is peer doing SCTP-AUTH? */
1596 
1597 		__u32   adaptation_ind;	 /* Adaptation Code point. */
1598 
1599 		/* This mask is used to disable sending the ASCONF chunk
1600 		 * with specified parameter to peer.
1601 		 */
1602 		__be16 addip_disabled_mask;
1603 
1604 		struct sctp_inithdr_host i;
1605 		int cookie_len;
1606 		void *cookie;
1607 
1608 		/* ADDIP Section 4.2 Upon reception of an ASCONF Chunk.
1609 		 * C1) ... "Peer-Serial-Number'. This value MUST be initialized to the
1610 		 * Initial TSN Value minus 1
1611 		 */
1612 		__u32 addip_serial;
1613 
1614 		/* SCTP-AUTH: We need to know pears random number, hmac list
1615 		 * and authenticated chunk list.  All that is part of the
1616 		 * cookie and these are just pointers to those locations
1617 		 */
1618 		sctp_random_param_t *peer_random;
1619 		sctp_chunks_param_t *peer_chunks;
1620 		sctp_hmac_algo_param_t *peer_hmacs;
1621 	} peer;
1622 
1623 	/* State       : A state variable indicating what state the
1624 	 *	       : association is in, i.e. COOKIE-WAIT,
1625 	 *	       : COOKIE-ECHOED, ESTABLISHED, SHUTDOWN-PENDING,
1626 	 *	       : SHUTDOWN-SENT, SHUTDOWN-RECEIVED, SHUTDOWN-ACK-SENT.
1627 	 *
1628 	 *		Note: No "CLOSED" state is illustrated since if a
1629 	 *		association is "CLOSED" its TCB SHOULD be removed.
1630 	 *
1631 	 *		In this implementation we DO have a CLOSED
1632 	 *		state which is used during initiation and shutdown.
1633 	 *
1634 	 *		State takes values from SCTP_STATE_*.
1635 	 */
1636 	sctp_state_t state;
1637 
1638 	/* The cookie life I award for any cookie.  */
1639 	struct timeval cookie_life;
1640 
1641 	/* Overall     : The overall association error count.
1642 	 * Error Count : [Clear this any time I get something.]
1643 	 */
1644 	int overall_error_count;
1645 
1646 	/* These are the association's initial, max, and min RTO values.
1647 	 * These values will be initialized by system defaults, but can
1648 	 * be modified via the SCTP_RTOINFO socket option.
1649 	 */
1650 	unsigned long rto_initial;
1651 	unsigned long rto_max;
1652 	unsigned long rto_min;
1653 
1654 	/* Maximum number of new data packets that can be sent in a burst.  */
1655 	int max_burst;
1656 
1657 	/* This is the max_retrans value for the association.  This value will
1658 	 * be initialized initialized from system defaults, but can be
1659 	 * modified by the SCTP_ASSOCINFO socket option.
1660 	 */
1661 	int max_retrans;
1662 
1663 	/* Maximum number of times the endpoint will retransmit INIT  */
1664 	__u16 max_init_attempts;
1665 
1666 	/* How many times have we resent an INIT? */
1667 	__u16 init_retries;
1668 
1669 	/* The largest timeout or RTO value to use in attempting an INIT */
1670 	unsigned long max_init_timeo;
1671 
1672 	/* Heartbeat interval: The endpoint sends out a Heartbeat chunk to
1673 	 * the destination address every heartbeat interval. This value
1674 	 * will be inherited by all new transports.
1675 	 */
1676 	unsigned long hbinterval;
1677 
1678 	/* This is the max_retrans value for new transports in the
1679 	 * association.
1680 	 */
1681 	__u16 pathmaxrxt;
1682 
1683 	/* Flag that path mtu update is pending */
1684 	__u8   pmtu_pending;
1685 
1686 	/* Association : The smallest PMTU discovered for all of the
1687 	 * PMTU	       : peer's transport addresses.
1688 	 */
1689 	__u32 pathmtu;
1690 
1691 	/* Flags controlling Heartbeat, SACK delay, and Path MTU Discovery. */
1692 	__u32 param_flags;
1693 
1694 	/* SACK delay timeout */
1695 	unsigned long sackdelay;
1696 	__u32 sackfreq;
1697 
1698 
1699 	unsigned long timeouts[SCTP_NUM_TIMEOUT_TYPES];
1700 	struct timer_list timers[SCTP_NUM_TIMEOUT_TYPES];
1701 
1702 	/* Transport to which SHUTDOWN chunk was last sent.  */
1703 	struct sctp_transport *shutdown_last_sent_to;
1704 
1705 	/* How many times have we resent a SHUTDOWN */
1706 	int shutdown_retries;
1707 
1708 	/* Transport to which INIT chunk was last sent.  */
1709 	struct sctp_transport *init_last_sent_to;
1710 
1711 	/* Next TSN    : The next TSN number to be assigned to a new
1712 	 *	       : DATA chunk.  This is sent in the INIT or INIT
1713 	 *	       : ACK chunk to the peer and incremented each
1714 	 *	       : time a DATA chunk is assigned a TSN
1715 	 *	       : (normally just prior to transmit or during
1716 	 *	       : fragmentation).
1717 	 */
1718 	__u32 next_tsn;
1719 
1720 	/*
1721 	 * Last Rcvd   : This is the last TSN received in sequence.  This value
1722 	 * TSN	       : is set initially by taking the peer's Initial TSN,
1723 	 *	       : received in the INIT or INIT ACK chunk, and
1724 	 *	       : subtracting one from it.
1725 	 *
1726 	 * Most of RFC 2960 refers to this as the Cumulative TSN Ack Point.
1727 	 */
1728 
1729 	__u32 ctsn_ack_point;
1730 
1731 	/* PR-SCTP Advanced.Peer.Ack.Point */
1732 	__u32 adv_peer_ack_point;
1733 
1734 	/* Highest TSN that is acknowledged by incoming SACKs. */
1735 	__u32 highest_sacked;
1736 
1737 	/* TSN marking the fast recovery exit point */
1738 	__u32 fast_recovery_exit;
1739 
1740 	/* Flag to track the current fast recovery state */
1741 	__u8 fast_recovery;
1742 
1743 	/* The number of unacknowledged data chunks.  Reported through
1744 	 * the SCTP_STATUS sockopt.
1745 	 */
1746 	__u16 unack_data;
1747 
1748 	/* The total number of data chunks that we've had to retransmit
1749 	 * as the result of a T3 timer expiration
1750 	 */
1751 	__u32 rtx_data_chunks;
1752 
1753 	/* This is the association's receive buffer space.  This value is used
1754 	 * to set a_rwnd field in an INIT or a SACK chunk.
1755 	 */
1756 	__u32 rwnd;
1757 
1758 	/* This is the last advertised value of rwnd over a SACK chunk. */
1759 	__u32 a_rwnd;
1760 
1761 	/* Number of bytes by which the rwnd has slopped.  The rwnd is allowed
1762 	 * to slop over a maximum of the association's frag_point.
1763 	 */
1764 	__u32 rwnd_over;
1765 
1766 	/* Keeps treack of rwnd pressure.  This happens when we have
1767 	 * a window, but not recevie buffer (i.e small packets).  This one
1768 	 * is releases slowly (1 PMTU at a time ).
1769 	 */
1770 	__u32 rwnd_press;
1771 
1772 	/* This is the sndbuf size in use for the association.
1773 	 * This corresponds to the sndbuf size for the association,
1774 	 * as specified in the sk->sndbuf.
1775 	 */
1776 	int sndbuf_used;
1777 
1778 	/* This is the amount of memory that this association has allocated
1779 	 * in the receive path at any given time.
1780 	 */
1781 	atomic_t rmem_alloc;
1782 
1783 	/* This is the wait queue head for send requests waiting on
1784 	 * the association sndbuf space.
1785 	 */
1786 	wait_queue_head_t	wait;
1787 
1788 	/* The message size at which SCTP fragmentation will occur. */
1789 	__u32 frag_point;
1790 	__u32 user_frag;
1791 
1792 	/* Counter used to count INIT errors. */
1793 	int init_err_counter;
1794 
1795 	/* Count the number of INIT cycles (for doubling timeout). */
1796 	int init_cycle;
1797 
1798 	/* Default send parameters. */
1799 	__u16 default_stream;
1800 	__u16 default_flags;
1801 	__u32 default_ppid;
1802 	__u32 default_context;
1803 	__u32 default_timetolive;
1804 
1805 	/* Default receive parameters */
1806 	__u32 default_rcv_context;
1807 
1808 	/* This tracks outbound ssn for a given stream.	 */
1809 	struct sctp_ssnmap *ssnmap;
1810 
1811 	/* All outbound chunks go through this structure.  */
1812 	struct sctp_outq outqueue;
1813 
1814 	/* A smart pipe that will handle reordering and fragmentation,
1815 	 * as well as handle passing events up to the ULP.
1816 	 */
1817 	struct sctp_ulpq ulpq;
1818 
1819 	/* Last TSN that caused an ECNE Chunk to be sent.  */
1820 	__u32 last_ecne_tsn;
1821 
1822 	/* Last TSN that caused a CWR Chunk to be sent.	 */
1823 	__u32 last_cwr_tsn;
1824 
1825 	/* How many duplicated TSNs have we seen?  */
1826 	int numduptsns;
1827 
1828 	/* Number of seconds of idle time before an association is closed.
1829 	 * In the association context, this is really used as a boolean
1830 	 * since the real timeout is stored in the timeouts array
1831 	 */
1832 	__u32 autoclose;
1833 
1834 	/* These are to support
1835 	 * "SCTP Extensions for Dynamic Reconfiguration of IP Addresses
1836 	 *  and Enforcement of Flow and Message Limits"
1837 	 * <draft-ietf-tsvwg-addip-sctp-02.txt>
1838 	 * or "ADDIP" for short.
1839 	 */
1840 
1841 
1842 
1843 	/* ADDIP Section 4.1.1 Congestion Control of ASCONF Chunks
1844 	 *
1845 	 * R1) One and only one ASCONF Chunk MAY be in transit and
1846 	 * unacknowledged at any one time.  If a sender, after sending
1847 	 * an ASCONF chunk, decides it needs to transfer another
1848 	 * ASCONF Chunk, it MUST wait until the ASCONF-ACK Chunk
1849 	 * returns from the previous ASCONF Chunk before sending a
1850 	 * subsequent ASCONF. Note this restriction binds each side,
1851 	 * so at any time two ASCONF may be in-transit on any given
1852 	 * association (one sent from each endpoint).
1853 	 *
1854 	 * [This is our one-and-only-one ASCONF in flight.  If we do
1855 	 * not have an ASCONF in flight, this is NULL.]
1856 	 */
1857 	struct sctp_chunk *addip_last_asconf;
1858 
1859 	/* ADDIP Section 5.2 Upon reception of an ASCONF Chunk.
1860 	 *
1861 	 * This is needed to implement itmes E1 - E4 of the updated
1862 	 * spec.  Here is the justification:
1863 	 *
1864 	 * Since the peer may bundle multiple ASCONF chunks toward us,
1865 	 * we now need the ability to cache multiple ACKs.  The section
1866 	 * describes in detail how they are cached and cleaned up.
1867 	 */
1868 	struct list_head asconf_ack_list;
1869 
1870 	/* These ASCONF chunks are waiting to be sent.
1871 	 *
1872 	 * These chunaks can't be pushed to outqueue until receiving
1873 	 * ASCONF_ACK for the previous ASCONF indicated by
1874 	 * addip_last_asconf, so as to guarantee that only one ASCONF
1875 	 * is in flight at any time.
1876 	 *
1877 	 * ADDIP Section 4.1.1 Congestion Control of ASCONF Chunks
1878 	 *
1879 	 * In defining the ASCONF Chunk transfer procedures, it is
1880 	 * essential that these transfers MUST NOT cause congestion
1881 	 * within the network.	To achieve this, we place these
1882 	 * restrictions on the transfer of ASCONF Chunks:
1883 	 *
1884 	 * R1) One and only one ASCONF Chunk MAY be in transit and
1885 	 * unacknowledged at any one time.  If a sender, after sending
1886 	 * an ASCONF chunk, decides it needs to transfer another
1887 	 * ASCONF Chunk, it MUST wait until the ASCONF-ACK Chunk
1888 	 * returns from the previous ASCONF Chunk before sending a
1889 	 * subsequent ASCONF. Note this restriction binds each side,
1890 	 * so at any time two ASCONF may be in-transit on any given
1891 	 * association (one sent from each endpoint).
1892 	 *
1893 	 *
1894 	 * [I really think this is EXACTLY the sort of intelligence
1895 	 *  which already resides in sctp_outq.	 Please move this
1896 	 *  queue and its supporting logic down there.	--piggy]
1897 	 */
1898 	struct list_head addip_chunk_list;
1899 
1900 	/* ADDIP Section 4.1 ASCONF Chunk Procedures
1901 	 *
1902 	 * A2) A serial number should be assigned to the Chunk. The
1903 	 * serial number SHOULD be a monotonically increasing
1904 	 * number. The serial number SHOULD be initialized at
1905 	 * the start of the association to the same value as the
1906 	 * Initial TSN and every time a new ASCONF chunk is created
1907 	 * it is incremented by one after assigning the serial number
1908 	 * to the newly created chunk.
1909 	 *
1910 	 * ADDIP
1911 	 * 3.1.1  Address/Stream Configuration Change Chunk (ASCONF)
1912 	 *
1913 	 * Serial Number : 32 bits (unsigned integer)
1914 	 *
1915 	 * This value represents a Serial Number for the ASCONF
1916 	 * Chunk. The valid range of Serial Number is from 0 to
1917 	 * 4294967295 (2^32 - 1).  Serial Numbers wrap back to 0
1918 	 * after reaching 4294967295.
1919 	 */
1920 	__u32 addip_serial;
1921 	union sctp_addr *asconf_addr_del_pending;
1922 	int src_out_of_asoc_ok;
1923 	struct sctp_transport *new_transport;
1924 
1925 	/* SCTP AUTH: list of the endpoint shared keys.  These
1926 	 * keys are provided out of band by the user applicaton
1927 	 * and can't change during the lifetime of the association
1928 	 */
1929 	struct list_head endpoint_shared_keys;
1930 
1931 	/* SCTP AUTH:
1932 	 * The current generated assocaition shared key (secret)
1933 	 */
1934 	struct sctp_auth_bytes *asoc_shared_key;
1935 
1936 	/* SCTP AUTH: hmac id of the first peer requested algorithm
1937 	 * that we support.
1938 	 */
1939 	__u16 default_hmac_id;
1940 
1941 	__u16 active_key_id;
1942 
1943 	__u8 need_ecne:1,	/* Need to send an ECNE Chunk? */
1944 	     temp:1;		/* Is it a temporary association? */
1945 };
1946 
1947 
1948 /* An eyecatcher for determining if we are really looking at an
1949  * association data structure.
1950  */
1951 enum {
1952 	SCTP_ASSOC_EYECATCHER = 0xa550c123,
1953 };
1954 
1955 /* Recover the outter association structure. */
sctp_assoc(struct sctp_ep_common * base)1956 static inline struct sctp_association *sctp_assoc(struct sctp_ep_common *base)
1957 {
1958 	struct sctp_association *asoc;
1959 
1960 	asoc = container_of(base, struct sctp_association, base);
1961 	return asoc;
1962 }
1963 
1964 /* These are function signatures for manipulating associations.	 */
1965 
1966 
1967 struct sctp_association *
1968 sctp_association_new(const struct sctp_endpoint *, const struct sock *,
1969 		     sctp_scope_t scope, gfp_t gfp);
1970 void sctp_association_free(struct sctp_association *);
1971 void sctp_association_put(struct sctp_association *);
1972 void sctp_association_hold(struct sctp_association *);
1973 
1974 struct sctp_transport *sctp_assoc_choose_alter_transport(
1975 	struct sctp_association *, struct sctp_transport *);
1976 void sctp_assoc_update_retran_path(struct sctp_association *);
1977 struct sctp_transport *sctp_assoc_lookup_paddr(const struct sctp_association *,
1978 					  const union sctp_addr *);
1979 int sctp_assoc_lookup_laddr(struct sctp_association *asoc,
1980 			    const union sctp_addr *laddr);
1981 struct sctp_transport *sctp_assoc_add_peer(struct sctp_association *,
1982 				     const union sctp_addr *address,
1983 				     const gfp_t gfp,
1984 				     const int peer_state);
1985 void sctp_assoc_del_peer(struct sctp_association *asoc,
1986 			 const union sctp_addr *addr);
1987 void sctp_assoc_rm_peer(struct sctp_association *asoc,
1988 			 struct sctp_transport *peer);
1989 void sctp_assoc_control_transport(struct sctp_association *,
1990 				  struct sctp_transport *,
1991 				  sctp_transport_cmd_t, sctp_sn_error_t);
1992 struct sctp_transport *sctp_assoc_lookup_tsn(struct sctp_association *, __u32);
1993 struct sctp_transport *sctp_assoc_is_match(struct sctp_association *,
1994 					   const union sctp_addr *,
1995 					   const union sctp_addr *);
1996 void sctp_assoc_migrate(struct sctp_association *, struct sock *);
1997 void sctp_assoc_update(struct sctp_association *old,
1998 		       struct sctp_association *new);
1999 
2000 __u32 sctp_association_get_next_tsn(struct sctp_association *);
2001 
2002 void sctp_assoc_sync_pmtu(struct sctp_association *);
2003 void sctp_assoc_rwnd_increase(struct sctp_association *, unsigned);
2004 void sctp_assoc_rwnd_decrease(struct sctp_association *, unsigned);
2005 void sctp_assoc_set_primary(struct sctp_association *,
2006 			    struct sctp_transport *);
2007 void sctp_assoc_del_nonprimary_peers(struct sctp_association *,
2008 				    struct sctp_transport *);
2009 int sctp_assoc_set_bind_addr_from_ep(struct sctp_association *,
2010 				     sctp_scope_t, gfp_t);
2011 int sctp_assoc_set_bind_addr_from_cookie(struct sctp_association *,
2012 					 struct sctp_cookie*,
2013 					 gfp_t gfp);
2014 int sctp_assoc_set_id(struct sctp_association *, gfp_t);
2015 void sctp_assoc_clean_asconf_ack_cache(const struct sctp_association *asoc);
2016 struct sctp_chunk *sctp_assoc_lookup_asconf_ack(
2017 					const struct sctp_association *asoc,
2018 					__be32 serial);
2019 void sctp_asconf_queue_teardown(struct sctp_association *asoc);
2020 
2021 int sctp_cmp_addr_exact(const union sctp_addr *ss1,
2022 			const union sctp_addr *ss2);
2023 struct sctp_chunk *sctp_get_ecne_prepend(struct sctp_association *asoc);
2024 
2025 /* A convenience structure to parse out SCTP specific CMSGs. */
2026 typedef struct sctp_cmsgs {
2027 	struct sctp_initmsg *init;
2028 	struct sctp_sndrcvinfo *info;
2029 } sctp_cmsgs_t;
2030 
2031 /* Structure for tracking memory objects */
2032 typedef struct {
2033 	char *label;
2034 	atomic_t *counter;
2035 } sctp_dbg_objcnt_entry_t;
2036 
2037 #endif /* __sctp_structs_h__ */
2038