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 auth_enable:1,
1326 intl_enable:1,
1327 prsctp_enable:1,
1328 reconf_enable:1;
1329
1330 __u8 strreset_enable;
1331
1332
1333
1334
1335
1336
1337
1338
1339 u32 secid;
1340 u32 peer_secid;
1341};
1342
1343
1344static inline struct sctp_endpoint *sctp_ep(struct sctp_ep_common *base)
1345{
1346 struct sctp_endpoint *ep;
1347
1348 ep = container_of(base, struct sctp_endpoint, base);
1349 return ep;
1350}
1351
1352
1353struct sctp_endpoint *sctp_endpoint_new(struct sock *, gfp_t);
1354void sctp_endpoint_free(struct sctp_endpoint *);
1355void sctp_endpoint_put(struct sctp_endpoint *);
1356void sctp_endpoint_hold(struct sctp_endpoint *);
1357void sctp_endpoint_add_asoc(struct sctp_endpoint *, struct sctp_association *);
1358struct sctp_association *sctp_endpoint_lookup_assoc(
1359 const struct sctp_endpoint *ep,
1360 const union sctp_addr *paddr,
1361 struct sctp_transport **);
1362bool sctp_endpoint_is_peeled_off(struct sctp_endpoint *ep,
1363 const union sctp_addr *paddr);
1364struct sctp_endpoint *sctp_endpoint_is_match(struct sctp_endpoint *,
1365 struct net *, const union sctp_addr *);
1366bool sctp_has_association(struct net *net, const union sctp_addr *laddr,
1367 const union sctp_addr *paddr);
1368
1369int sctp_verify_init(struct net *net, const struct sctp_endpoint *ep,
1370 const struct sctp_association *asoc,
1371 enum sctp_cid cid, struct sctp_init_chunk *peer_init,
1372 struct sctp_chunk *chunk, struct sctp_chunk **err_chunk);
1373int sctp_process_init(struct sctp_association *, struct sctp_chunk *chunk,
1374 const union sctp_addr *peer,
1375 struct sctp_init_chunk *init, gfp_t gfp);
1376__u32 sctp_generate_tag(const struct sctp_endpoint *);
1377__u32 sctp_generate_tsn(const struct sctp_endpoint *);
1378
1379struct sctp_inithdr_host {
1380 __u32 init_tag;
1381 __u32 a_rwnd;
1382 __u16 num_outbound_streams;
1383 __u16 num_inbound_streams;
1384 __u32 initial_tsn;
1385};
1386
1387struct sctp_stream_priorities {
1388
1389 struct list_head prio_sched;
1390
1391 struct list_head active;
1392
1393 struct sctp_stream_out_ext *next;
1394 __u16 prio;
1395};
1396
1397struct sctp_stream_out_ext {
1398 __u64 abandoned_unsent[SCTP_PR_INDEX(MAX) + 1];
1399 __u64 abandoned_sent[SCTP_PR_INDEX(MAX) + 1];
1400 struct list_head outq;
1401 union {
1402 struct {
1403
1404 struct list_head prio_list;
1405 struct sctp_stream_priorities *prio_head;
1406 };
1407
1408 struct {
1409 struct list_head rr_list;
1410 };
1411 };
1412};
1413
1414struct sctp_stream_out {
1415 union {
1416 __u32 mid;
1417 __u16 ssn;
1418 };
1419 __u32 mid_uo;
1420 struct sctp_stream_out_ext *ext;
1421 __u8 state;
1422};
1423
1424struct sctp_stream_in {
1425 union {
1426 __u32 mid;
1427 __u16 ssn;
1428 };
1429 __u32 mid_uo;
1430 __u32 fsn;
1431 __u32 fsn_uo;
1432 char pd_mode;
1433 char pd_mode_uo;
1434};
1435
1436struct sctp_stream {
1437 GENRADIX(struct sctp_stream_out) out;
1438 GENRADIX(struct sctp_stream_in) in;
1439
1440 __u16 outcnt;
1441 __u16 incnt;
1442
1443 struct sctp_stream_out *out_curr;
1444 union {
1445
1446 struct {
1447
1448 struct list_head prio_list;
1449 };
1450
1451 struct {
1452
1453 struct list_head rr_list;
1454
1455 struct sctp_stream_out_ext *rr_next;
1456 };
1457 };
1458 struct sctp_stream_interleave *si;
1459};
1460
1461static inline struct sctp_stream_out *sctp_stream_out(
1462 struct sctp_stream *stream,
1463 __u16 sid)
1464{
1465 return genradix_ptr(&stream->out, sid);
1466}
1467
1468static inline struct sctp_stream_in *sctp_stream_in(
1469 struct sctp_stream *stream,
1470 __u16 sid)
1471{
1472 return genradix_ptr(&stream->in, sid);
1473}
1474
1475#define SCTP_SO(s, i) sctp_stream_out((s), (i))
1476#define SCTP_SI(s, i) sctp_stream_in((s), (i))
1477
1478#define SCTP_STREAM_CLOSED 0x00
1479#define SCTP_STREAM_OPEN 0x01
1480
1481static inline __u16 sctp_datachk_len(const struct sctp_stream *stream)
1482{
1483 return stream->si->data_chunk_len;
1484}
1485
1486static inline __u16 sctp_datahdr_len(const struct sctp_stream *stream)
1487{
1488 return stream->si->data_chunk_len - sizeof(struct sctp_chunkhdr);
1489}
1490
1491static inline __u16 sctp_ftsnchk_len(const struct sctp_stream *stream)
1492{
1493 return stream->si->ftsn_chunk_len;
1494}
1495
1496static inline __u16 sctp_ftsnhdr_len(const struct sctp_stream *stream)
1497{
1498 return stream->si->ftsn_chunk_len - sizeof(struct sctp_chunkhdr);
1499}
1500
1501
1502struct sctp_priv_assoc_stats {
1503
1504
1505
1506
1507
1508 struct sockaddr_storage obs_rto_ipaddr;
1509 __u64 max_obs_rto;
1510
1511 __u64 isacks;
1512 __u64 osacks;
1513
1514 __u64 opackets;
1515 __u64 ipackets;
1516
1517 __u64 rtxchunks;
1518
1519 __u64 outofseqtsns;
1520
1521 __u64 idupchunks;
1522
1523 __u64 gapcnt;
1524
1525 __u64 ouodchunks;
1526 __u64 iuodchunks;
1527
1528 __u64 oodchunks;
1529 __u64 iodchunks;
1530
1531 __u64 octrlchunks;
1532 __u64 ictrlchunks;
1533};
1534
1535
1536
1537
1538
1539
1540
1541
1542
1543
1544
1545
1546
1547
1548
1549struct sctp_association {
1550
1551
1552
1553
1554
1555 struct sctp_ep_common base;
1556
1557
1558 struct list_head asocs;
1559
1560
1561 sctp_assoc_t assoc_id;
1562
1563
1564 struct sctp_endpoint *ep;
1565
1566
1567 struct sctp_cookie c;
1568
1569
1570 struct {
1571
1572
1573
1574
1575
1576
1577
1578
1579
1580
1581
1582
1583
1584
1585
1586 struct list_head transport_addr_list;
1587
1588
1589
1590
1591
1592 __u32 rwnd;
1593
1594
1595
1596
1597
1598
1599
1600
1601 __u16 transport_count;
1602
1603
1604
1605
1606 __u16 port;
1607
1608
1609
1610
1611
1612
1613
1614
1615
1616
1617
1618
1619
1620
1621
1622
1623 struct sctp_transport *primary_path;
1624
1625
1626
1627
1628 union sctp_addr primary_addr;
1629
1630
1631
1632
1633
1634 struct sctp_transport *active_path;
1635
1636
1637
1638
1639
1640
1641
1642
1643
1644
1645
1646 struct sctp_transport *retran_path;
1647
1648
1649 struct sctp_transport *last_sent_to;
1650
1651
1652 struct sctp_transport *last_data_from;
1653
1654
1655
1656
1657
1658
1659
1660
1661
1662
1663
1664
1665
1666
1667
1668
1669
1670
1671
1672
1673
1674 struct sctp_tsnmap tsn_map;
1675
1676
1677
1678
1679 __be16 addip_disabled_mask;
1680
1681
1682 __u16 ecn_capable:1,
1683 ipv4_address:1,
1684 ipv6_address:1,
1685 hostname_address:1,
1686 asconf_capable:1,
1687 prsctp_capable:1,
1688 reconf_capable:1,
1689 intl_capable:1,
1690 auth_capable:1,
1691
1692
1693
1694
1695
1696
1697
1698
1699
1700
1701
1702 sack_needed:1,
1703 sack_generation:1,
1704 zero_window_announced:1;
1705
1706 __u32 sack_cnt;
1707
1708 __u32 adaptation_ind;
1709
1710 struct sctp_inithdr_host i;
1711 void *cookie;
1712 int cookie_len;
1713
1714
1715
1716
1717
1718 __u32 addip_serial;
1719
1720
1721
1722
1723
1724 struct sctp_random_param *peer_random;
1725 struct sctp_chunks_param *peer_chunks;
1726 struct sctp_hmac_algo_param *peer_hmacs;
1727 } peer;
1728
1729
1730
1731
1732
1733
1734
1735
1736
1737
1738
1739
1740
1741
1742 enum sctp_state state;
1743
1744
1745
1746
1747 int overall_error_count;
1748
1749
1750 ktime_t cookie_life;
1751
1752
1753
1754
1755
1756 unsigned long rto_initial;
1757 unsigned long rto_max;
1758 unsigned long rto_min;
1759
1760
1761 int max_burst;
1762
1763
1764
1765
1766
1767 int max_retrans;
1768
1769
1770
1771
1772
1773 int pf_retrans;
1774
1775
1776 __u16 max_init_attempts;
1777
1778
1779 __u16 init_retries;
1780
1781
1782 unsigned long max_init_timeo;
1783
1784
1785
1786
1787
1788 unsigned long hbinterval;
1789
1790
1791
1792
1793 __u16 pathmaxrxt;
1794
1795 __u32 flowlabel;
1796 __u8 dscp;
1797
1798
1799 __u8 pmtu_pending;
1800
1801
1802
1803
1804 __u32 pathmtu;
1805
1806
1807 __u32 param_flags;
1808
1809 __u32 sackfreq;
1810
1811 unsigned long sackdelay;
1812
1813 unsigned long timeouts[SCTP_NUM_TIMEOUT_TYPES];
1814 struct timer_list timers[SCTP_NUM_TIMEOUT_TYPES];
1815
1816
1817 struct sctp_transport *shutdown_last_sent_to;
1818
1819
1820 struct sctp_transport *init_last_sent_to;
1821
1822
1823 int shutdown_retries;
1824
1825
1826
1827
1828
1829
1830
1831
1832 __u32 next_tsn;
1833
1834
1835
1836
1837
1838
1839
1840
1841
1842
1843 __u32 ctsn_ack_point;
1844
1845
1846 __u32 adv_peer_ack_point;
1847
1848
1849 __u32 highest_sacked;
1850
1851
1852 __u32 fast_recovery_exit;
1853
1854
1855 __u8 fast_recovery;
1856
1857
1858
1859
1860 __u16 unack_data;
1861
1862
1863
1864
1865 __u32 rtx_data_chunks;
1866
1867
1868
1869
1870 __u32 rwnd;
1871
1872
1873 __u32 a_rwnd;
1874
1875
1876
1877
1878 __u32 rwnd_over;
1879
1880
1881
1882
1883
1884 __u32 rwnd_press;
1885
1886
1887
1888
1889
1890 int sndbuf_used;
1891
1892
1893
1894
1895 atomic_t rmem_alloc;
1896
1897
1898
1899
1900 wait_queue_head_t wait;
1901
1902
1903 __u32 frag_point;
1904 __u32 user_frag;
1905
1906
1907 int init_err_counter;
1908
1909
1910 int init_cycle;
1911
1912
1913 __u16 default_stream;
1914 __u16 default_flags;
1915 __u32 default_ppid;
1916 __u32 default_context;
1917 __u32 default_timetolive;
1918
1919
1920 __u32 default_rcv_context;
1921
1922
1923 struct sctp_stream stream;
1924
1925
1926 struct sctp_outq outqueue;
1927
1928
1929
1930
1931 struct sctp_ulpq ulpq;
1932
1933
1934 __u32 last_ecne_tsn;
1935
1936
1937 __u32 last_cwr_tsn;
1938
1939
1940 int numduptsns;
1941
1942
1943
1944
1945
1946
1947
1948
1949
1950
1951
1952
1953
1954
1955
1956
1957
1958
1959
1960
1961
1962
1963
1964
1965 struct sctp_chunk *addip_last_asconf;
1966
1967
1968
1969
1970
1971
1972
1973
1974
1975
1976 struct list_head asconf_ack_list;
1977
1978
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 struct list_head addip_chunk_list;
2007
2008
2009
2010
2011
2012
2013
2014
2015
2016
2017
2018
2019
2020
2021
2022
2023
2024
2025
2026
2027
2028 __u32 addip_serial;
2029 int src_out_of_asoc_ok;
2030 union sctp_addr *asconf_addr_del_pending;
2031 struct sctp_transport *new_transport;
2032
2033
2034
2035
2036
2037 struct list_head endpoint_shared_keys;
2038
2039
2040
2041
2042 struct sctp_auth_bytes *asoc_shared_key;
2043 struct sctp_shared_key *shkey;
2044
2045
2046
2047
2048 __u16 default_hmac_id;
2049
2050 __u16 active_key_id;
2051
2052 __u8 need_ecne:1,
2053 temp:1,
2054 force_delay:1;
2055
2056 __u8 strreset_enable;
2057 __u8 strreset_outstanding;
2058
2059 __u32 strreset_outseq;
2060 __u32 strreset_inseq;
2061 __u32 strreset_result[2];
2062
2063 struct sctp_chunk *strreset_chunk;
2064
2065 struct sctp_priv_assoc_stats stats;
2066
2067 int sent_cnt_removable;
2068
2069 __u16 subscribe;
2070
2071 __u64 abandoned_unsent[SCTP_PR_INDEX(MAX) + 1];
2072 __u64 abandoned_sent[SCTP_PR_INDEX(MAX) + 1];
2073
2074 struct rcu_head rcu;
2075};
2076
2077
2078
2079
2080
2081enum {
2082 SCTP_ASSOC_EYECATCHER = 0xa550c123,
2083};
2084
2085
2086static inline struct sctp_association *sctp_assoc(struct sctp_ep_common *base)
2087{
2088 struct sctp_association *asoc;
2089
2090 asoc = container_of(base, struct sctp_association, base);
2091 return asoc;
2092}
2093
2094
2095
2096
2097struct sctp_association *
2098sctp_association_new(const struct sctp_endpoint *ep, const struct sock *sk,
2099 enum sctp_scope scope, gfp_t gfp);
2100void sctp_association_free(struct sctp_association *);
2101void sctp_association_put(struct sctp_association *);
2102void sctp_association_hold(struct sctp_association *);
2103
2104struct sctp_transport *sctp_assoc_choose_alter_transport(
2105 struct sctp_association *, struct sctp_transport *);
2106void sctp_assoc_update_retran_path(struct sctp_association *);
2107struct sctp_transport *sctp_assoc_lookup_paddr(const struct sctp_association *,
2108 const union sctp_addr *);
2109int sctp_assoc_lookup_laddr(struct sctp_association *asoc,
2110 const union sctp_addr *laddr);
2111struct sctp_transport *sctp_assoc_add_peer(struct sctp_association *,
2112 const union sctp_addr *address,
2113 const gfp_t gfp,
2114 const int peer_state);
2115void sctp_assoc_del_peer(struct sctp_association *asoc,
2116 const union sctp_addr *addr);
2117void sctp_assoc_rm_peer(struct sctp_association *asoc,
2118 struct sctp_transport *peer);
2119void sctp_assoc_control_transport(struct sctp_association *asoc,
2120 struct sctp_transport *transport,
2121 enum sctp_transport_cmd command,
2122 sctp_sn_error_t error);
2123struct sctp_transport *sctp_assoc_lookup_tsn(struct sctp_association *, __u32);
2124void sctp_assoc_migrate(struct sctp_association *, struct sock *);
2125int sctp_assoc_update(struct sctp_association *old,
2126 struct sctp_association *new);
2127
2128__u32 sctp_association_get_next_tsn(struct sctp_association *);
2129
2130void sctp_assoc_update_frag_point(struct sctp_association *asoc);
2131void sctp_assoc_set_pmtu(struct sctp_association *asoc, __u32 pmtu);
2132void sctp_assoc_sync_pmtu(struct sctp_association *asoc);
2133void sctp_assoc_rwnd_increase(struct sctp_association *, unsigned int);
2134void sctp_assoc_rwnd_decrease(struct sctp_association *, unsigned int);
2135void sctp_assoc_set_primary(struct sctp_association *,
2136 struct sctp_transport *);
2137void sctp_assoc_del_nonprimary_peers(struct sctp_association *,
2138 struct sctp_transport *);
2139int sctp_assoc_set_bind_addr_from_ep(struct sctp_association *asoc,
2140 enum sctp_scope scope, gfp_t gfp);
2141int sctp_assoc_set_bind_addr_from_cookie(struct sctp_association *,
2142 struct sctp_cookie*,
2143 gfp_t gfp);
2144int sctp_assoc_set_id(struct sctp_association *, gfp_t);
2145void sctp_assoc_clean_asconf_ack_cache(const struct sctp_association *asoc);
2146struct sctp_chunk *sctp_assoc_lookup_asconf_ack(
2147 const struct sctp_association *asoc,
2148 __be32 serial);
2149void sctp_asconf_queue_teardown(struct sctp_association *asoc);
2150
2151int sctp_cmp_addr_exact(const union sctp_addr *ss1,
2152 const union sctp_addr *ss2);
2153struct sctp_chunk *sctp_get_ecne_prepend(struct sctp_association *asoc);
2154
2155
2156struct sctp_cmsgs {
2157 struct sctp_initmsg *init;
2158 struct sctp_sndrcvinfo *srinfo;
2159 struct sctp_sndinfo *sinfo;
2160 struct sctp_prinfo *prinfo;
2161 struct sctp_authinfo *authinfo;
2162 struct msghdr *addrs_msg;
2163};
2164
2165
2166struct sctp_dbg_objcnt_entry {
2167 char *label;
2168 atomic_t *counter;
2169};
2170
2171#endif
2172