1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32#ifndef __sctp_structs_h__
33#define __sctp_structs_h__
34
35#include <linux/ktime.h>
36#include <linux/generic-radix-tree.h>
37#include <linux/rhashtable-types.h>
38#include <linux/socket.h>
39#include <linux/in.h>
40#include <linux/in6.h>
41#include <linux/ipv6.h>
42#include <asm/param.h>
43#include <linux/atomic.h>
44#include <linux/skbuff.h>
45#include <linux/workqueue.h>
46#include <linux/sctp.h>
47#include <net/sctp/auth.h>
48#include <net/ip.h>
49
50
51
52
53union sctp_addr {
54 struct sockaddr_in v4;
55 struct sockaddr_in6 v6;
56 struct sockaddr sa;
57};
58
59
60struct sctp_globals;
61struct sctp_endpoint;
62struct sctp_association;
63struct sctp_transport;
64struct sctp_packet;
65struct sctp_chunk;
66struct sctp_inq;
67struct sctp_outq;
68struct sctp_bind_addr;
69struct sctp_ulpq;
70struct sctp_ep_common;
71struct crypto_shash;
72struct sctp_stream;
73
74
75#include <net/sctp/tsnmap.h>
76#include <net/sctp/ulpevent.h>
77#include <net/sctp/ulpqueue.h>
78#include <net/sctp/stream_interleave.h>
79
80
81
82struct sctp_bind_bucket {
83 unsigned short port;
84 signed char fastreuse;
85 signed char fastreuseport;
86 kuid_t fastuid;
87 struct hlist_node node;
88 struct hlist_head owner;
89 struct net *net;
90};
91
92struct sctp_bind_hashbucket {
93 spinlock_t lock;
94 struct hlist_head chain;
95};
96
97
98struct sctp_hashbucket {
99 rwlock_t lock;
100 struct hlist_head chain;
101} __attribute__((__aligned__(8)));
102
103
104
105extern struct sctp_globals {
106
107
108
109 struct list_head address_families;
110
111
112 struct sctp_hashbucket *ep_hashtable;
113
114 struct sctp_bind_hashbucket *port_hashtable;
115
116 struct rhltable transport_hashtable;
117
118
119 int ep_hashsize;
120 int port_hashsize;
121
122
123 __u16 max_instreams;
124 __u16 max_outstreams;
125
126
127
128 bool checksum_disable;
129} sctp_globals;
130
131#define sctp_max_instreams (sctp_globals.max_instreams)
132#define sctp_max_outstreams (sctp_globals.max_outstreams)
133#define sctp_address_families (sctp_globals.address_families)
134#define sctp_ep_hashsize (sctp_globals.ep_hashsize)
135#define sctp_ep_hashtable (sctp_globals.ep_hashtable)
136#define sctp_port_hashsize (sctp_globals.port_hashsize)
137#define sctp_port_hashtable (sctp_globals.port_hashtable)
138#define sctp_transport_hashtable (sctp_globals.transport_hashtable)
139#define sctp_checksum_disable (sctp_globals.checksum_disable)
140
141
142enum sctp_socket_type {
143 SCTP_SOCKET_UDP = 0,
144 SCTP_SOCKET_UDP_HIGH_BANDWIDTH,
145 SCTP_SOCKET_TCP
146};
147
148
149struct sctp_sock {
150
151 struct inet_sock inet;
152
153 enum sctp_socket_type type;
154
155
156 struct sctp_pf *pf;
157
158
159 struct crypto_shash *hmac;
160 char *sctp_hmac_alg;
161
162
163 struct sctp_endpoint *ep;
164
165 struct sctp_bind_bucket *bind_hash;
166
167 __u16 default_stream;
168 __u32 default_ppid;
169 __u16 default_flags;
170 __u32 default_context;
171 __u32 default_timetolive;
172 __u32 default_rcv_context;
173 int max_burst;
174
175
176
177
178
179 __u32 hbinterval;
180 __u32 probe_interval;
181
182 __be16 udp_port;
183 __be16 encap_port;
184
185
186 __u16 pathmaxrxt;
187
188 __u32 flowlabel;
189 __u8 dscp;
190
191 __u16 pf_retrans;
192 __u16 ps_retrans;
193
194
195 __u32 pathmtu;
196
197
198 __u32 sackdelay;
199 __u32 sackfreq;
200
201
202 __u32 param_flags;
203
204 __u32 default_ss;
205
206 struct sctp_rtoinfo rtoinfo;
207 struct sctp_paddrparams paddrparam;
208 struct sctp_assocparams assocparams;
209
210
211
212
213
214 __u16 subscribe;
215 struct sctp_initmsg initmsg;
216
217 int user_frag;
218
219 __u32 autoclose;
220 __u32 adaptation_ind;
221 __u32 pd_point;
222 __u16 nodelay:1,
223 pf_expose:2,
224 reuse:1,
225 disable_fragments:1,
226 v4mapped:1,
227 frag_interleave:1,
228 recvrcvinfo:1,
229 recvnxtinfo:1,
230 data_ready_signalled:1;
231
232 atomic_t pd_mode;
233
234
235
236
237
238
239 struct sk_buff_head pd_lobby;
240
241 struct list_head auto_asconf_list;
242 int do_auto_asconf;
243};
244
245static inline struct sctp_sock *sctp_sk(const struct sock *sk)
246{
247 return (struct sctp_sock *)sk;
248}
249
250static inline struct sock *sctp_opt2sk(const struct sctp_sock *sp)
251{
252 return (struct sock *)sp;
253}
254
255#if IS_ENABLED(CONFIG_IPV6)
256struct sctp6_sock {
257 struct sctp_sock sctp;
258 struct ipv6_pinfo inet6;
259};
260#endif
261
262
263
264
265
266
267
268
269
270
271
272struct sctp_cookie {
273
274
275
276
277
278 __u32 my_vtag;
279
280
281
282
283
284 __u32 peer_vtag;
285
286
287
288
289
290
291 __u32 my_ttag;
292
293
294 __u32 peer_ttag;
295
296
297 ktime_t expiration;
298
299
300
301
302 __u16 sinit_num_ostreams;
303 __u16 sinit_max_instreams;
304
305
306 __u32 initial_tsn;
307
308
309 union sctp_addr peer_addr;
310
311
312
313
314 __u16 my_port;
315
316 __u8 prsctp_capable;
317
318
319 __u8 padding;
320
321 __u32 adaptation_ind;
322
323 __u8 auth_random[sizeof(struct sctp_paramhdr) +
324 SCTP_AUTH_RANDOM_LENGTH];
325 __u8 auth_hmacs[SCTP_AUTH_NUM_HMACS * sizeof(__u16) + 2];
326 __u8 auth_chunks[sizeof(struct sctp_paramhdr) + SCTP_AUTH_MAX_CHUNKS];
327
328
329
330
331
332
333
334 __u32 raw_addr_list_len;
335 struct sctp_init_chunk peer_init[];
336};
337
338
339
340struct sctp_signed_cookie {
341 __u8 signature[SCTP_SECRET_SIZE];
342 __u32 __pad;
343 struct sctp_cookie c;
344} __packed;
345
346
347
348
349
350union sctp_addr_param {
351 struct sctp_paramhdr p;
352 struct sctp_ipv4addr_param v4;
353 struct sctp_ipv6addr_param v6;
354};
355
356
357
358
359union sctp_params {
360 void *v;
361 struct sctp_paramhdr *p;
362 struct sctp_cookie_preserve_param *life;
363 struct sctp_hostname_param *dns;
364 struct sctp_cookie_param *cookie;
365 struct sctp_supported_addrs_param *sat;
366 struct sctp_ipv4addr_param *v4;
367 struct sctp_ipv6addr_param *v6;
368 union sctp_addr_param *addr;
369 struct sctp_adaptation_ind_param *aind;
370 struct sctp_supported_ext_param *ext;
371 struct sctp_random_param *random;
372 struct sctp_chunks_param *chunks;
373 struct sctp_hmac_algo_param *hmac_algo;
374 struct sctp_addip_param *addip;
375};
376
377
378
379
380
381
382
383
384struct sctp_sender_hb_info {
385 struct sctp_paramhdr param_hdr;
386 union sctp_addr daddr;
387 unsigned long sent_at;
388 __u64 hb_nonce;
389 __u32 probe_size;
390};
391
392int sctp_stream_init(struct sctp_stream *stream, __u16 outcnt, __u16 incnt,
393 gfp_t gfp);
394int sctp_stream_init_ext(struct sctp_stream *stream, __u16 sid);
395void sctp_stream_free(struct sctp_stream *stream);
396void sctp_stream_clear(struct sctp_stream *stream);
397void sctp_stream_update(struct sctp_stream *stream, struct sctp_stream *new);
398
399
400#define sctp_ssn_peek(stream, type, sid) \
401 (sctp_stream_##type((stream), (sid))->ssn)
402
403
404#define sctp_ssn_next(stream, type, sid) \
405 (sctp_stream_##type((stream), (sid))->ssn++)
406
407
408#define sctp_ssn_skip(stream, type, sid, ssn) \
409 (sctp_stream_##type((stream), (sid))->ssn = ssn + 1)
410
411
412#define sctp_mid_peek(stream, type, sid) \
413 (sctp_stream_##type((stream), (sid))->mid)
414
415
416#define sctp_mid_next(stream, type, sid) \
417 (sctp_stream_##type((stream), (sid))->mid++)
418
419
420#define sctp_mid_skip(stream, type, sid, mid) \
421 (sctp_stream_##type((stream), (sid))->mid = mid + 1)
422
423
424#define sctp_mid_uo_peek(stream, type, sid) \
425 (sctp_stream_##type((stream), (sid))->mid_uo)
426
427
428#define sctp_mid_uo_next(stream, type, sid) \
429 (sctp_stream_##type((stream), (sid))->mid_uo++)
430
431
432
433
434
435struct sctp_af {
436 int (*sctp_xmit) (struct sk_buff *skb,
437 struct sctp_transport *);
438 int (*setsockopt) (struct sock *sk,
439 int level,
440 int optname,
441 sockptr_t optval,
442 unsigned int optlen);
443 int (*getsockopt) (struct sock *sk,
444 int level,
445 int optname,
446 char __user *optval,
447 int __user *optlen);
448 void (*get_dst) (struct sctp_transport *t,
449 union sctp_addr *saddr,
450 struct flowi *fl,
451 struct sock *sk);
452 void (*get_saddr) (struct sctp_sock *sk,
453 struct sctp_transport *t,
454 struct flowi *fl);
455 void (*copy_addrlist) (struct list_head *,
456 struct net_device *);
457 int (*cmp_addr) (const union sctp_addr *addr1,
458 const union sctp_addr *addr2);
459 void (*addr_copy) (union sctp_addr *dst,
460 union sctp_addr *src);
461 void (*from_skb) (union sctp_addr *,
462 struct sk_buff *skb,
463 int saddr);
464 void (*from_sk) (union sctp_addr *,
465 struct sock *sk);
466 bool (*from_addr_param) (union sctp_addr *,
467 union sctp_addr_param *,
468 __be16 port, int iif);
469 int (*to_addr_param) (const union sctp_addr *,
470 union sctp_addr_param *);
471 int (*addr_valid) (union sctp_addr *,
472 struct sctp_sock *,
473 const struct sk_buff *);
474 enum sctp_scope (*scope)(union sctp_addr *);
475 void (*inaddr_any) (union sctp_addr *, __be16);
476 int (*is_any) (const union sctp_addr *);
477 int (*available) (union sctp_addr *,
478 struct sctp_sock *);
479 int (*skb_iif) (const struct sk_buff *sk);
480 int (*is_ce) (const struct sk_buff *sk);
481 void (*seq_dump_addr)(struct seq_file *seq,
482 union sctp_addr *addr);
483 void (*ecn_capable)(struct sock *sk);
484 __u16 net_header_len;
485 int sockaddr_len;
486 int (*ip_options_len)(struct sock *sk);
487 sa_family_t sa_family;
488 struct list_head list;
489};
490
491struct sctp_af *sctp_get_af_specific(sa_family_t);
492int sctp_register_af(struct sctp_af *);
493
494
495struct sctp_pf {
496 void (*event_msgname)(struct sctp_ulpevent *, char *, int *);
497 void (*skb_msgname) (struct sk_buff *, char *, int *);
498 int (*af_supported) (sa_family_t, struct sctp_sock *);
499 int (*cmp_addr) (const union sctp_addr *,
500 const union sctp_addr *,
501 struct sctp_sock *);
502 int (*bind_verify) (struct sctp_sock *, union sctp_addr *);
503 int (*send_verify) (struct sctp_sock *, union sctp_addr *);
504 int (*supported_addrs)(const struct sctp_sock *, __be16 *);
505 struct sock *(*create_accept_sk) (struct sock *sk,
506 struct sctp_association *asoc,
507 bool kern);
508 int (*addr_to_user)(struct sctp_sock *sk, union sctp_addr *addr);
509 void (*to_sk_saddr)(union sctp_addr *, struct sock *sk);
510 void (*to_sk_daddr)(union sctp_addr *, struct sock *sk);
511 void (*copy_ip_options)(struct sock *sk, struct sock *newsk);
512 struct sctp_af *af;
513};
514
515
516
517
518
519struct sctp_datamsg {
520
521 struct list_head chunks;
522
523 refcount_t refcnt;
524
525 unsigned long expires_at;
526
527 int send_error;
528 u8 send_failed:1,
529 can_delay:1,
530 abandoned:1;
531};
532
533struct sctp_datamsg *sctp_datamsg_from_user(struct sctp_association *,
534 struct sctp_sndrcvinfo *,
535 struct iov_iter *);
536void sctp_datamsg_free(struct sctp_datamsg *);
537void sctp_datamsg_put(struct sctp_datamsg *);
538void sctp_chunk_fail(struct sctp_chunk *, int error);
539int sctp_chunk_abandoned(struct sctp_chunk *);
540
541
542
543
544
545
546
547
548
549struct sctp_chunk {
550 struct list_head list;
551
552 refcount_t refcnt;
553
554
555 int sent_count;
556
557 union {
558
559 struct list_head transmitted_list;
560
561 struct list_head stream_list;
562 };
563
564
565
566
567
568
569 struct list_head frag_list;
570
571
572 struct sk_buff *skb;
573
574 union {
575
576 struct sk_buff *head_skb;
577
578 struct sctp_shared_key *shkey;
579 };
580
581
582
583
584
585
586
587
588 union sctp_params param_hdr;
589 union {
590 __u8 *v;
591 struct sctp_datahdr *data_hdr;
592 struct sctp_inithdr *init_hdr;
593 struct sctp_sackhdr *sack_hdr;
594 struct sctp_heartbeathdr *hb_hdr;
595 struct sctp_sender_hb_info *hbs_hdr;
596 struct sctp_shutdownhdr *shutdown_hdr;
597 struct sctp_signed_cookie *cookie_hdr;
598 struct sctp_ecnehdr *ecne_hdr;
599 struct sctp_cwrhdr *ecn_cwr_hdr;
600 struct sctp_errhdr *err_hdr;
601 struct sctp_addiphdr *addip_hdr;
602 struct sctp_fwdtsn_hdr *fwdtsn_hdr;
603 struct sctp_authhdr *auth_hdr;
604 struct sctp_idatahdr *idata_hdr;
605 struct sctp_ifwdtsn_hdr *ifwdtsn_hdr;
606 } subh;
607
608 __u8 *chunk_end;
609
610 struct sctp_chunkhdr *chunk_hdr;
611 struct sctphdr *sctp_hdr;
612
613
614 struct sctp_sndrcvinfo sinfo;
615
616
617 struct sctp_association *asoc;
618
619
620 struct sctp_ep_common *rcvr;
621
622
623 unsigned long sent_at;
624
625
626 union sctp_addr source;
627
628 union sctp_addr dest;
629
630
631 struct sctp_datamsg *msg;
632
633
634
635
636
637 struct sctp_transport *transport;
638
639
640
641
642
643
644 struct sk_buff *auth_chunk;
645
646#define SCTP_CAN_FRTX 0x0
647#define SCTP_NEED_FRTX 0x1
648#define SCTP_DONT_FRTX 0x2
649 __u16 rtt_in_progress:1,
650 has_tsn:1,
651 has_ssn:1,
652#define has_mid has_ssn
653 singleton:1,
654 end_of_packet:1,
655 ecn_ce_done:1,
656 pdiscard:1,
657 tsn_gap_acked:1,
658 data_accepted:1,
659 auth:1,
660 has_asconf:1,
661 pmtu_probe:1,
662 tsn_missing_report:2,
663 fast_retransmit:2;
664};
665
666#define sctp_chunk_retransmitted(chunk) (chunk->sent_count > 1)
667void sctp_chunk_hold(struct sctp_chunk *);
668void sctp_chunk_put(struct sctp_chunk *);
669int sctp_user_addto_chunk(struct sctp_chunk *chunk, int len,
670 struct iov_iter *from);
671void sctp_chunk_free(struct sctp_chunk *);
672void *sctp_addto_chunk(struct sctp_chunk *, int len, const void *data);
673struct sctp_chunk *sctp_chunkify(struct sk_buff *,
674 const struct sctp_association *,
675 struct sock *, gfp_t gfp);
676void sctp_init_addrs(struct sctp_chunk *, union sctp_addr *,
677 union sctp_addr *);
678const union sctp_addr *sctp_source(const struct sctp_chunk *chunk);
679
680static inline __u16 sctp_chunk_stream_no(struct sctp_chunk *ch)
681{
682 return ntohs(ch->subh.data_hdr->stream);
683}
684
685enum {
686 SCTP_ADDR_NEW,
687 SCTP_ADDR_SRC,
688 SCTP_ADDR_DEL,
689};
690
691
692struct sctp_sockaddr_entry {
693 struct list_head list;
694 struct rcu_head rcu;
695 union sctp_addr a;
696 __u8 state;
697 __u8 valid;
698};
699
700#define SCTP_ADDRESS_TICK_DELAY 500
701
702
703
704
705struct sctp_packet {
706
707 __u16 source_port;
708 __u16 destination_port;
709 __u32 vtag;
710
711
712 struct list_head chunk_list;
713
714
715 size_t overhead;
716
717 size_t size;
718
719 size_t max_size;
720
721
722
723
724
725 struct sctp_transport *transport;
726
727
728 struct sctp_chunk *auth;
729
730 u8 has_cookie_echo:1,
731 has_sack:1,
732 has_auth:1,
733 has_data:1,
734 ipfragok:1;
735};
736
737void sctp_packet_init(struct sctp_packet *, struct sctp_transport *,
738 __u16 sport, __u16 dport);
739void sctp_packet_config(struct sctp_packet *, __u32 vtag, int);
740enum sctp_xmit sctp_packet_transmit_chunk(struct sctp_packet *packet,
741 struct sctp_chunk *chunk,
742 int one_packet, gfp_t gfp);
743enum sctp_xmit sctp_packet_append_chunk(struct sctp_packet *packet,
744 struct sctp_chunk *chunk);
745int sctp_packet_transmit(struct sctp_packet *, gfp_t);
746void sctp_packet_free(struct sctp_packet *);
747
748static inline int sctp_packet_empty(struct sctp_packet *packet)
749{
750 return packet->size == packet->overhead;
751}
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773struct sctp_transport {
774
775 struct list_head transports;
776 struct rhlist_head node;
777
778
779 refcount_t refcnt;
780
781
782
783
784
785
786
787
788
789 __u32 rto_pending:1,
790
791
792
793
794
795 hb_sent:1,
796
797
798 pmtu_pending:1,
799
800 dst_pending_confirm:1,
801
802
803 sack_generation:1;
804 u32 dst_cookie;
805
806 struct flowi fl;
807
808
809 union sctp_addr ipaddr;
810
811
812 struct sctp_af *af_specific;
813
814
815 struct sctp_association *asoc;
816
817
818
819
820
821
822
823
824
825
826 unsigned long rto;
827
828 __u32 rtt;
829
830
831 __u32 rttvar;
832
833
834 __u32 srtt;
835
836
837
838
839
840 __u32 cwnd;
841
842
843 __u32 ssthresh;
844
845
846
847
848 __u32 partial_bytes_acked;
849
850
851 __u32 flight_size;
852
853 __u32 burst_limited;
854
855
856 struct dst_entry *dst;
857
858 union sctp_addr saddr;
859
860
861
862
863 unsigned long hbinterval;
864 unsigned long probe_interval;
865
866
867 unsigned long sackdelay;
868 __u32 sackfreq;
869
870 atomic_t mtu_info;
871
872
873
874
875 ktime_t last_time_heard;
876
877
878
879
880 unsigned long last_time_sent;
881
882
883
884
885 unsigned long last_time_ecne_reduced;
886
887 __be16 encap_port;
888
889
890
891
892
893 __u16 pathmaxrxt;
894
895 __u32 flowlabel;
896 __u8 dscp;
897
898
899
900
901
902 __u16 pf_retrans;
903
904 __u16 ps_retrans;
905
906 __u32 pathmtu;
907
908
909 __u32 param_flags;
910
911
912 int init_sent_count;
913
914
915
916
917 int state;
918
919
920
921
922 unsigned short error_count;
923
924
925
926
927
928
929
930 struct timer_list T3_rtx_timer;
931
932
933 struct timer_list hb_timer;
934
935
936 struct timer_list proto_unreach_timer;
937
938
939 struct timer_list reconf_timer;
940
941
942 struct timer_list probe_timer;
943
944
945
946
947
948
949 struct list_head transmitted;
950
951
952 struct sctp_packet packet;
953
954
955 struct list_head send_ready;
956
957
958
959
960
961
962
963
964
965 struct {
966
967
968
969 __u32 next_tsn_at_change;
970
971
972 char changeover_active;
973
974
975
976
977
978 char cycling_changeover;
979
980
981
982
983 char cacc_saw_newack;
984 } cacc;
985
986 struct {
987 __u32 last_rtx_chunks;
988 __u16 pmtu;
989 __u16 probe_size;
990 __u16 probe_high;
991 __u8 probe_count:3;
992 __u8 raise_count:5;
993 __u8 state;
994 } pl;
995
996
997 __u64 hb_nonce;
998
999 struct rcu_head rcu;
1000};
1001
1002struct sctp_transport *sctp_transport_new(struct net *, const union sctp_addr *,
1003 gfp_t);
1004void sctp_transport_set_owner(struct sctp_transport *,
1005 struct sctp_association *);
1006void sctp_transport_route(struct sctp_transport *, union sctp_addr *,
1007 struct sctp_sock *);
1008void sctp_transport_pmtu(struct sctp_transport *, struct sock *sk);
1009void sctp_transport_free(struct sctp_transport *);
1010void sctp_transport_reset_t3_rtx(struct sctp_transport *);
1011void sctp_transport_reset_hb_timer(struct sctp_transport *);
1012void sctp_transport_reset_reconf_timer(struct sctp_transport *transport);
1013void sctp_transport_reset_probe_timer(struct sctp_transport *transport);
1014int sctp_transport_hold(struct sctp_transport *);
1015void sctp_transport_put(struct sctp_transport *);
1016void sctp_transport_update_rto(struct sctp_transport *, __u32);
1017void sctp_transport_raise_cwnd(struct sctp_transport *, __u32, __u32);
1018void sctp_transport_lower_cwnd(struct sctp_transport *t,
1019 enum sctp_lower_cwnd reason);
1020void sctp_transport_burst_limited(struct sctp_transport *);
1021void sctp_transport_burst_reset(struct sctp_transport *);
1022unsigned long sctp_transport_timeout(struct sctp_transport *);
1023void sctp_transport_reset(struct sctp_transport *t);
1024bool sctp_transport_update_pmtu(struct sctp_transport *t, u32 pmtu);
1025void sctp_transport_immediate_rtx(struct sctp_transport *);
1026void sctp_transport_dst_release(struct sctp_transport *t);
1027void sctp_transport_dst_confirm(struct sctp_transport *t);
1028bool sctp_transport_pl_send(struct sctp_transport *t);
1029bool sctp_transport_pl_recv(struct sctp_transport *t);
1030
1031
1032
1033
1034
1035struct sctp_inq {
1036
1037
1038
1039 struct list_head in_chunk_list;
1040
1041
1042
1043 struct sctp_chunk *in_progress;
1044
1045
1046
1047
1048 struct work_struct immediate;
1049};
1050
1051void sctp_inq_init(struct sctp_inq *);
1052void sctp_inq_free(struct sctp_inq *);
1053void sctp_inq_push(struct sctp_inq *, struct sctp_chunk *packet);
1054struct sctp_chunk *sctp_inq_pop(struct sctp_inq *);
1055struct sctp_chunkhdr *sctp_inq_peek(struct sctp_inq *);
1056void sctp_inq_set_th_handler(struct sctp_inq *, work_func_t);
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077struct sctp_outq {
1078 struct sctp_association *asoc;
1079
1080
1081 struct list_head out_chunk_list;
1082
1083
1084 struct sctp_sched_ops *sched;
1085
1086 unsigned int out_qlen;
1087
1088
1089 unsigned int error;
1090
1091
1092 struct list_head control_chunk_list;
1093
1094
1095
1096
1097 struct list_head sacked;
1098
1099
1100
1101
1102 struct list_head retransmit;
1103
1104
1105
1106
1107 struct list_head abandoned;
1108
1109
1110 __u32 outstanding_bytes;
1111
1112
1113 char fast_rtx;
1114
1115
1116 char cork;
1117};
1118
1119void sctp_outq_init(struct sctp_association *, struct sctp_outq *);
1120void sctp_outq_teardown(struct sctp_outq *);
1121void sctp_outq_free(struct sctp_outq*);
1122void sctp_outq_tail(struct sctp_outq *, struct sctp_chunk *chunk, gfp_t);
1123int sctp_outq_sack(struct sctp_outq *, struct sctp_chunk *);
1124int sctp_outq_is_empty(const struct sctp_outq *);
1125void sctp_outq_restart(struct sctp_outq *);
1126
1127void sctp_retransmit(struct sctp_outq *q, struct sctp_transport *transport,
1128 enum sctp_retransmit_reason reason);
1129void sctp_retransmit_mark(struct sctp_outq *, struct sctp_transport *, __u8);
1130void sctp_outq_uncork(struct sctp_outq *, gfp_t gfp);
1131void sctp_prsctp_prune(struct sctp_association *asoc,
1132 struct sctp_sndrcvinfo *sinfo, int msg_len);
1133void sctp_generate_fwdtsn(struct sctp_outq *q, __u32 sack_ctsn);
1134
1135static inline void sctp_outq_cork(struct sctp_outq *q)
1136{
1137 q->cork = 1;
1138}
1139
1140
1141
1142
1143struct sctp_input_cb {
1144 union {
1145 struct inet_skb_parm h4;
1146#if IS_ENABLED(CONFIG_IPV6)
1147 struct inet6_skb_parm h6;
1148#endif
1149 } header;
1150 struct sctp_chunk *chunk;
1151 struct sctp_af *af;
1152 __be16 encap_port;
1153};
1154#define SCTP_INPUT_CB(__skb) ((struct sctp_input_cb *)&((__skb)->cb[0]))
1155
1156struct sctp_output_cb {
1157 struct sk_buff *last;
1158};
1159#define SCTP_OUTPUT_CB(__skb) ((struct sctp_output_cb *)&((__skb)->cb[0]))
1160
1161static inline const struct sk_buff *sctp_gso_headskb(const struct sk_buff *skb)
1162{
1163 const struct sctp_chunk *chunk = SCTP_INPUT_CB(skb)->chunk;
1164
1165 return chunk->head_skb ? : skb;
1166}
1167
1168
1169struct sctp_bind_addr {
1170
1171
1172
1173
1174
1175
1176 __u16 port;
1177
1178
1179
1180
1181
1182
1183
1184 struct list_head address_list;
1185};
1186
1187void sctp_bind_addr_init(struct sctp_bind_addr *, __u16 port);
1188void sctp_bind_addr_free(struct sctp_bind_addr *);
1189int sctp_bind_addr_copy(struct net *net, struct sctp_bind_addr *dest,
1190 const struct sctp_bind_addr *src,
1191 enum sctp_scope scope, gfp_t gfp,
1192 int flags);
1193int sctp_bind_addr_dup(struct sctp_bind_addr *dest,
1194 const struct sctp_bind_addr *src,
1195 gfp_t gfp);
1196int sctp_add_bind_addr(struct sctp_bind_addr *, union sctp_addr *,
1197 int new_size, __u8 addr_state, gfp_t gfp);
1198int sctp_del_bind_addr(struct sctp_bind_addr *, union sctp_addr *);
1199int sctp_bind_addr_match(struct sctp_bind_addr *, const union sctp_addr *,
1200 struct sctp_sock *);
1201int sctp_bind_addr_conflict(struct sctp_bind_addr *, const union sctp_addr *,
1202 struct sctp_sock *, struct sctp_sock *);
1203int sctp_bind_addr_state(const struct sctp_bind_addr *bp,
1204 const union sctp_addr *addr);
1205int sctp_bind_addrs_check(struct sctp_sock *sp,
1206 struct sctp_sock *sp2, int cnt2);
1207union sctp_addr *sctp_find_unmatch_addr(struct sctp_bind_addr *bp,
1208 const union sctp_addr *addrs,
1209 int addrcnt,
1210 struct sctp_sock *opt);
1211union sctp_params sctp_bind_addrs_to_raw(const struct sctp_bind_addr *bp,
1212 int *addrs_len,
1213 gfp_t gfp);
1214int sctp_raw_to_bind_addrs(struct sctp_bind_addr *bp, __u8 *raw, int len,
1215 __u16 port, gfp_t gfp);
1216
1217enum sctp_scope sctp_scope(const union sctp_addr *addr);
1218int sctp_in_scope(struct net *net, const union sctp_addr *addr,
1219 const enum sctp_scope scope);
1220int sctp_is_any(struct sock *sk, const union sctp_addr *addr);
1221int sctp_is_ep_boundall(struct sock *sk);
1222
1223
1224
1225enum sctp_endpoint_type {
1226 SCTP_EP_TYPE_SOCKET,
1227 SCTP_EP_TYPE_ASSOCIATION,
1228};
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246struct sctp_ep_common {
1247
1248 struct hlist_node node;
1249 int hashent;
1250
1251
1252 enum sctp_endpoint_type type;
1253
1254
1255
1256
1257
1258 refcount_t refcnt;
1259 bool dead;
1260
1261
1262 struct sock *sk;
1263
1264
1265 struct net *net;
1266
1267
1268 struct sctp_inq inqueue;
1269
1270
1271
1272
1273
1274
1275 struct sctp_bind_addr bind_addr;
1276};
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289
1290
1291
1292
1293
1294
1295
1296
1297
1298struct sctp_endpoint {
1299
1300 struct sctp_ep_common base;
1301
1302
1303
1304
1305
1306
1307
1308
1309
1310
1311
1312 struct list_head asocs;
1313
1314
1315
1316
1317
1318
1319
1320 __u8 secret_key[SCTP_SECRET_SIZE];
1321
1322
1323
1324
1325
1326
1327
1328 __u8 *digest;
1329
1330
1331 __u32 sndbuf_policy;
1332
1333
1334 __u32 rcvbuf_policy;
1335
1336
1337
1338
1339 struct crypto_shash **auth_hmacs;
1340
1341
1342 struct sctp_hmac_algo_param *auth_hmacs_list;
1343
1344
1345 struct sctp_chunks_param *auth_chunk_list;
1346
1347
1348 struct list_head endpoint_shared_keys;
1349 __u16 active_key_id;
1350 __u8 ecn_enable:1,
1351 auth_enable:1,
1352 intl_enable:1,
1353 prsctp_enable:1,
1354 asconf_enable:1,
1355 reconf_enable:1;
1356
1357 __u8 strreset_enable;
1358
1359
1360
1361
1362
1363
1364
1365
1366 u32 secid;
1367 u32 peer_secid;
1368};
1369
1370
1371static inline struct sctp_endpoint *sctp_ep(struct sctp_ep_common *base)
1372{
1373 struct sctp_endpoint *ep;
1374
1375 ep = container_of(base, struct sctp_endpoint, base);
1376 return ep;
1377}
1378
1379
1380struct sctp_endpoint *sctp_endpoint_new(struct sock *, gfp_t);
1381void sctp_endpoint_free(struct sctp_endpoint *);
1382void sctp_endpoint_put(struct sctp_endpoint *);
1383void sctp_endpoint_hold(struct sctp_endpoint *);
1384void sctp_endpoint_add_asoc(struct sctp_endpoint *, struct sctp_association *);
1385struct sctp_association *sctp_endpoint_lookup_assoc(
1386 const struct sctp_endpoint *ep,
1387 const union sctp_addr *paddr,
1388 struct sctp_transport **);
1389bool sctp_endpoint_is_peeled_off(struct sctp_endpoint *ep,
1390 const union sctp_addr *paddr);
1391struct sctp_endpoint *sctp_endpoint_is_match(struct sctp_endpoint *,
1392 struct net *, const union sctp_addr *);
1393bool sctp_has_association(struct net *net, const union sctp_addr *laddr,
1394 const union sctp_addr *paddr);
1395
1396int sctp_verify_init(struct net *net, const struct sctp_endpoint *ep,
1397 const struct sctp_association *asoc,
1398 enum sctp_cid cid, struct sctp_init_chunk *peer_init,
1399 struct sctp_chunk *chunk, struct sctp_chunk **err_chunk);
1400int sctp_process_init(struct sctp_association *, struct sctp_chunk *chunk,
1401 const union sctp_addr *peer,
1402 struct sctp_init_chunk *init, gfp_t gfp);
1403__u32 sctp_generate_tag(const struct sctp_endpoint *);
1404__u32 sctp_generate_tsn(const struct sctp_endpoint *);
1405
1406struct sctp_inithdr_host {
1407 __u32 init_tag;
1408 __u32 a_rwnd;
1409 __u16 num_outbound_streams;
1410 __u16 num_inbound_streams;
1411 __u32 initial_tsn;
1412};
1413
1414struct sctp_stream_priorities {
1415
1416 struct list_head prio_sched;
1417
1418 struct list_head active;
1419
1420 struct sctp_stream_out_ext *next;
1421 __u16 prio;
1422};
1423
1424struct sctp_stream_out_ext {
1425 __u64 abandoned_unsent[SCTP_PR_INDEX(MAX) + 1];
1426 __u64 abandoned_sent[SCTP_PR_INDEX(MAX) + 1];
1427 struct list_head outq;
1428 union {
1429 struct {
1430
1431 struct list_head prio_list;
1432 struct sctp_stream_priorities *prio_head;
1433 };
1434
1435 struct {
1436 struct list_head rr_list;
1437 };
1438 };
1439};
1440
1441struct sctp_stream_out {
1442 union {
1443 __u32 mid;
1444 __u16 ssn;
1445 };
1446 __u32 mid_uo;
1447 struct sctp_stream_out_ext *ext;
1448 __u8 state;
1449};
1450
1451struct sctp_stream_in {
1452 union {
1453 __u32 mid;
1454 __u16 ssn;
1455 };
1456 __u32 mid_uo;
1457 __u32 fsn;
1458 __u32 fsn_uo;
1459 char pd_mode;
1460 char pd_mode_uo;
1461};
1462
1463struct sctp_stream {
1464 GENRADIX(struct sctp_stream_out) out;
1465 GENRADIX(struct sctp_stream_in) in;
1466
1467 __u16 outcnt;
1468 __u16 incnt;
1469
1470 struct sctp_stream_out *out_curr;
1471 union {
1472
1473 struct {
1474
1475 struct list_head prio_list;
1476 };
1477
1478 struct {
1479
1480 struct list_head rr_list;
1481
1482 struct sctp_stream_out_ext *rr_next;
1483 };
1484 };
1485 struct sctp_stream_interleave *si;
1486};
1487
1488static inline struct sctp_stream_out *sctp_stream_out(
1489 struct sctp_stream *stream,
1490 __u16 sid)
1491{
1492 return genradix_ptr(&stream->out, sid);
1493}
1494
1495static inline struct sctp_stream_in *sctp_stream_in(
1496 struct sctp_stream *stream,
1497 __u16 sid)
1498{
1499 return genradix_ptr(&stream->in, sid);
1500}
1501
1502#define SCTP_SO(s, i) sctp_stream_out((s), (i))
1503#define SCTP_SI(s, i) sctp_stream_in((s), (i))
1504
1505#define SCTP_STREAM_CLOSED 0x00
1506#define SCTP_STREAM_OPEN 0x01
1507
1508static inline __u16 sctp_datachk_len(const struct sctp_stream *stream)
1509{
1510 return stream->si->data_chunk_len;
1511}
1512
1513static inline __u16 sctp_datahdr_len(const struct sctp_stream *stream)
1514{
1515 return stream->si->data_chunk_len - sizeof(struct sctp_chunkhdr);
1516}
1517
1518static inline __u16 sctp_ftsnchk_len(const struct sctp_stream *stream)
1519{
1520 return stream->si->ftsn_chunk_len;
1521}
1522
1523static inline __u16 sctp_ftsnhdr_len(const struct sctp_stream *stream)
1524{
1525 return stream->si->ftsn_chunk_len - sizeof(struct sctp_chunkhdr);
1526}
1527
1528
1529struct sctp_priv_assoc_stats {
1530
1531
1532
1533
1534
1535 struct sockaddr_storage obs_rto_ipaddr;
1536 __u64 max_obs_rto;
1537
1538 __u64 isacks;
1539 __u64 osacks;
1540
1541 __u64 opackets;
1542 __u64 ipackets;
1543
1544 __u64 rtxchunks;
1545
1546 __u64 outofseqtsns;
1547
1548 __u64 idupchunks;
1549
1550 __u64 gapcnt;
1551
1552 __u64 ouodchunks;
1553 __u64 iuodchunks;
1554
1555 __u64 oodchunks;
1556 __u64 iodchunks;
1557
1558 __u64 octrlchunks;
1559 __u64 ictrlchunks;
1560};
1561
1562
1563
1564
1565
1566
1567
1568
1569
1570
1571
1572
1573
1574
1575
1576struct sctp_association {
1577
1578
1579
1580
1581
1582 struct sctp_ep_common base;
1583
1584
1585 struct list_head asocs;
1586
1587
1588 sctp_assoc_t assoc_id;
1589
1590
1591 struct sctp_endpoint *ep;
1592
1593
1594 struct sctp_cookie c;
1595
1596
1597 struct {
1598
1599
1600
1601
1602
1603
1604
1605
1606
1607
1608
1609
1610
1611
1612
1613 struct list_head transport_addr_list;
1614
1615
1616
1617
1618
1619 __u32 rwnd;
1620
1621
1622
1623
1624
1625
1626
1627
1628 __u16 transport_count;
1629
1630
1631
1632
1633 __u16 port;
1634
1635
1636
1637
1638
1639
1640
1641
1642
1643
1644
1645
1646
1647
1648
1649
1650 struct sctp_transport *primary_path;
1651
1652
1653
1654
1655 union sctp_addr primary_addr;
1656
1657
1658
1659
1660
1661 struct sctp_transport *active_path;
1662
1663
1664
1665
1666
1667
1668
1669
1670
1671
1672
1673 struct sctp_transport *retran_path;
1674
1675
1676 struct sctp_transport *last_sent_to;
1677
1678
1679 struct sctp_transport *last_data_from;
1680
1681
1682
1683
1684
1685
1686
1687
1688
1689
1690
1691
1692
1693
1694
1695
1696
1697
1698
1699
1700
1701 struct sctp_tsnmap tsn_map;
1702
1703
1704
1705
1706 __be16 addip_disabled_mask;
1707
1708
1709 __u16 ecn_capable:1,
1710 ipv4_address:1,
1711 ipv6_address:1,
1712 hostname_address:1,
1713 asconf_capable:1,
1714 prsctp_capable:1,
1715 reconf_capable:1,
1716 intl_capable:1,
1717 auth_capable:1,
1718
1719
1720
1721
1722
1723
1724
1725
1726
1727
1728
1729 sack_needed:1,
1730 sack_generation:1,
1731 zero_window_announced:1;
1732
1733 __u32 sack_cnt;
1734
1735 __u32 adaptation_ind;
1736
1737 struct sctp_inithdr_host i;
1738 void *cookie;
1739 int cookie_len;
1740
1741
1742
1743
1744
1745 __u32 addip_serial;
1746
1747
1748
1749
1750
1751 struct sctp_random_param *peer_random;
1752 struct sctp_chunks_param *peer_chunks;
1753 struct sctp_hmac_algo_param *peer_hmacs;
1754 } peer;
1755
1756
1757
1758
1759
1760
1761
1762
1763
1764
1765
1766
1767
1768
1769 enum sctp_state state;
1770
1771
1772
1773
1774 int overall_error_count;
1775
1776
1777 ktime_t cookie_life;
1778
1779
1780
1781
1782
1783 unsigned long rto_initial;
1784 unsigned long rto_max;
1785 unsigned long rto_min;
1786
1787
1788 int max_burst;
1789
1790
1791
1792
1793
1794 int max_retrans;
1795
1796
1797
1798
1799
1800 __u16 pf_retrans;
1801
1802 __u16 ps_retrans;
1803
1804
1805 __u16 max_init_attempts;
1806
1807
1808 __u16 init_retries;
1809
1810
1811 unsigned long max_init_timeo;
1812
1813
1814
1815
1816
1817 unsigned long hbinterval;
1818 unsigned long probe_interval;
1819
1820 __be16 encap_port;
1821
1822
1823
1824
1825 __u16 pathmaxrxt;
1826
1827 __u32 flowlabel;
1828 __u8 dscp;
1829
1830
1831 __u8 pmtu_pending;
1832
1833
1834
1835
1836 __u32 pathmtu;
1837
1838
1839 __u32 param_flags;
1840
1841 __u32 sackfreq;
1842
1843 unsigned long sackdelay;
1844
1845 unsigned long timeouts[SCTP_NUM_TIMEOUT_TYPES];
1846 struct timer_list timers[SCTP_NUM_TIMEOUT_TYPES];
1847
1848
1849 struct sctp_transport *shutdown_last_sent_to;
1850
1851
1852 struct sctp_transport *init_last_sent_to;
1853
1854
1855 int shutdown_retries;
1856
1857
1858
1859
1860
1861
1862
1863
1864 __u32 next_tsn;
1865
1866
1867
1868
1869
1870
1871
1872
1873
1874
1875 __u32 ctsn_ack_point;
1876
1877
1878 __u32 adv_peer_ack_point;
1879
1880
1881 __u32 highest_sacked;
1882
1883
1884 __u32 fast_recovery_exit;
1885
1886
1887 __u8 fast_recovery;
1888
1889
1890
1891
1892 __u16 unack_data;
1893
1894
1895
1896
1897 __u32 rtx_data_chunks;
1898
1899
1900
1901
1902 __u32 rwnd;
1903
1904
1905 __u32 a_rwnd;
1906
1907
1908
1909
1910 __u32 rwnd_over;
1911
1912
1913
1914
1915
1916 __u32 rwnd_press;
1917
1918
1919
1920
1921
1922 int sndbuf_used;
1923
1924
1925
1926
1927 atomic_t rmem_alloc;
1928
1929
1930
1931
1932 wait_queue_head_t wait;
1933
1934
1935 __u32 frag_point;
1936 __u32 user_frag;
1937
1938
1939 int init_err_counter;
1940
1941
1942 int init_cycle;
1943
1944
1945 __u16 default_stream;
1946 __u16 default_flags;
1947 __u32 default_ppid;
1948 __u32 default_context;
1949 __u32 default_timetolive;
1950
1951
1952 __u32 default_rcv_context;
1953
1954
1955 struct sctp_stream stream;
1956
1957
1958 struct sctp_outq outqueue;
1959
1960
1961
1962
1963 struct sctp_ulpq ulpq;
1964
1965
1966 __u32 last_ecne_tsn;
1967
1968
1969 __u32 last_cwr_tsn;
1970
1971
1972 int numduptsns;
1973
1974
1975
1976
1977
1978
1979
1980
1981
1982
1983
1984
1985
1986
1987
1988
1989
1990
1991
1992
1993
1994
1995
1996
1997 struct sctp_chunk *addip_last_asconf;
1998
1999
2000
2001
2002
2003
2004
2005
2006
2007
2008 struct list_head asconf_ack_list;
2009
2010
2011
2012
2013
2014
2015
2016
2017
2018
2019
2020
2021
2022
2023
2024
2025
2026
2027
2028
2029
2030
2031
2032
2033
2034
2035
2036
2037
2038 struct list_head addip_chunk_list;
2039
2040
2041
2042
2043
2044
2045
2046
2047
2048
2049
2050
2051
2052
2053
2054
2055
2056
2057
2058
2059
2060 __u32 addip_serial;
2061 int src_out_of_asoc_ok;
2062 union sctp_addr *asconf_addr_del_pending;
2063 struct sctp_transport *new_transport;
2064
2065
2066
2067
2068
2069 struct list_head endpoint_shared_keys;
2070
2071
2072
2073
2074 struct sctp_auth_bytes *asoc_shared_key;
2075 struct sctp_shared_key *shkey;
2076
2077
2078
2079
2080 __u16 default_hmac_id;
2081
2082 __u16 active_key_id;
2083
2084 __u8 need_ecne:1,
2085 temp:1,
2086 pf_expose:2,
2087 force_delay:1;
2088
2089 __u8 strreset_enable;
2090 __u8 strreset_outstanding;
2091
2092 __u32 strreset_outseq;
2093 __u32 strreset_inseq;
2094 __u32 strreset_result[2];
2095
2096 struct sctp_chunk *strreset_chunk;
2097
2098 struct sctp_priv_assoc_stats stats;
2099
2100 int sent_cnt_removable;
2101
2102 __u16 subscribe;
2103
2104 __u64 abandoned_unsent[SCTP_PR_INDEX(MAX) + 1];
2105 __u64 abandoned_sent[SCTP_PR_INDEX(MAX) + 1];
2106
2107 struct rcu_head rcu;
2108};
2109
2110
2111
2112
2113
2114enum {
2115 SCTP_ASSOC_EYECATCHER = 0xa550c123,
2116};
2117
2118
2119static inline struct sctp_association *sctp_assoc(struct sctp_ep_common *base)
2120{
2121 struct sctp_association *asoc;
2122
2123 asoc = container_of(base, struct sctp_association, base);
2124 return asoc;
2125}
2126
2127
2128
2129
2130struct sctp_association *
2131sctp_association_new(const struct sctp_endpoint *ep, const struct sock *sk,
2132 enum sctp_scope scope, gfp_t gfp);
2133void sctp_association_free(struct sctp_association *);
2134void sctp_association_put(struct sctp_association *);
2135void sctp_association_hold(struct sctp_association *);
2136
2137struct sctp_transport *sctp_assoc_choose_alter_transport(
2138 struct sctp_association *, struct sctp_transport *);
2139void sctp_assoc_update_retran_path(struct sctp_association *);
2140struct sctp_transport *sctp_assoc_lookup_paddr(const struct sctp_association *,
2141 const union sctp_addr *);
2142int sctp_assoc_lookup_laddr(struct sctp_association *asoc,
2143 const union sctp_addr *laddr);
2144struct sctp_transport *sctp_assoc_add_peer(struct sctp_association *,
2145 const union sctp_addr *address,
2146 const gfp_t gfp,
2147 const int peer_state);
2148void sctp_assoc_del_peer(struct sctp_association *asoc,
2149 const union sctp_addr *addr);
2150void sctp_assoc_rm_peer(struct sctp_association *asoc,
2151 struct sctp_transport *peer);
2152void sctp_assoc_control_transport(struct sctp_association *asoc,
2153 struct sctp_transport *transport,
2154 enum sctp_transport_cmd command,
2155 sctp_sn_error_t error);
2156struct sctp_transport *sctp_assoc_lookup_tsn(struct sctp_association *, __u32);
2157void sctp_assoc_migrate(struct sctp_association *, struct sock *);
2158int sctp_assoc_update(struct sctp_association *old,
2159 struct sctp_association *new);
2160
2161__u32 sctp_association_get_next_tsn(struct sctp_association *);
2162
2163void sctp_assoc_update_frag_point(struct sctp_association *asoc);
2164void sctp_assoc_set_pmtu(struct sctp_association *asoc, __u32 pmtu);
2165void sctp_assoc_sync_pmtu(struct sctp_association *asoc);
2166void sctp_assoc_rwnd_increase(struct sctp_association *, unsigned int);
2167void sctp_assoc_rwnd_decrease(struct sctp_association *, unsigned int);
2168void sctp_assoc_set_primary(struct sctp_association *,
2169 struct sctp_transport *);
2170void sctp_assoc_del_nonprimary_peers(struct sctp_association *,
2171 struct sctp_transport *);
2172int sctp_assoc_set_bind_addr_from_ep(struct sctp_association *asoc,
2173 enum sctp_scope scope, gfp_t gfp);
2174int sctp_assoc_set_bind_addr_from_cookie(struct sctp_association *,
2175 struct sctp_cookie*,
2176 gfp_t gfp);
2177int sctp_assoc_set_id(struct sctp_association *, gfp_t);
2178void sctp_assoc_clean_asconf_ack_cache(const struct sctp_association *asoc);
2179struct sctp_chunk *sctp_assoc_lookup_asconf_ack(
2180 const struct sctp_association *asoc,
2181 __be32 serial);
2182void sctp_asconf_queue_teardown(struct sctp_association *asoc);
2183
2184int sctp_cmp_addr_exact(const union sctp_addr *ss1,
2185 const union sctp_addr *ss2);
2186struct sctp_chunk *sctp_get_ecne_prepend(struct sctp_association *asoc);
2187
2188
2189struct sctp_cmsgs {
2190 struct sctp_initmsg *init;
2191 struct sctp_sndrcvinfo *srinfo;
2192 struct sctp_sndinfo *sinfo;
2193 struct sctp_prinfo *prinfo;
2194 struct sctp_authinfo *authinfo;
2195 struct msghdr *addrs_msg;
2196};
2197
2198
2199struct sctp_dbg_objcnt_entry {
2200 char *label;
2201 atomic_t *counter;
2202};
2203
2204#endif
2205