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