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