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
33
34
35
36
37
38
39
40
41
42#ifndef __net_sctp_h__
43#define __net_sctp_h__
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58#include <linux/types.h>
59#include <linux/slab.h>
60#include <linux/in.h>
61#include <linux/tty.h>
62#include <linux/proc_fs.h>
63#include <linux/spinlock.h>
64#include <linux/jiffies.h>
65#include <linux/idr.h>
66
67#if IS_ENABLED(CONFIG_IPV6)
68#include <net/ipv6.h>
69#include <net/ip6_route.h>
70#endif
71
72#include <asm/uaccess.h>
73#include <asm/page.h>
74#include <net/sock.h>
75#include <net/snmp.h>
76#include <net/sctp/structs.h>
77#include <net/sctp/constants.h>
78
79#ifdef CONFIG_IP_SCTP_MODULE
80#define SCTP_PROTOSW_FLAG 0
81#else
82#define SCTP_PROTOSW_FLAG INET_PROTOSW_PERMANENT
83#endif
84
85
86#define SCTP_PAD4(s) (((s)+3)&~3)
87
88#define SCTP_TRUNC4(s) ((s)&~3)
89
90
91
92
93
94
95
96
97int sctp_copy_local_addr_list(struct net *, struct sctp_bind_addr *,
98 sctp_scope_t, gfp_t gfp, int flags);
99struct sctp_pf *sctp_get_pf_specific(sa_family_t family);
100int sctp_register_pf(struct sctp_pf *, sa_family_t);
101void sctp_addr_wq_mgmt(struct net *, struct sctp_sockaddr_entry *, int);
102
103
104
105
106int sctp_backlog_rcv(struct sock *sk, struct sk_buff *skb);
107int sctp_inet_listen(struct socket *sock, int backlog);
108void sctp_write_space(struct sock *sk);
109void sctp_data_ready(struct sock *sk);
110unsigned int sctp_poll(struct file *file, struct socket *sock,
111 poll_table *wait);
112void sctp_sock_rfree(struct sk_buff *skb);
113void sctp_copy_sock(struct sock *newsk, struct sock *sk,
114 struct sctp_association *asoc);
115extern struct percpu_counter sctp_sockets_allocated;
116int sctp_asconf_mgmt(struct sctp_sock *, struct sctp_sockaddr_entry *);
117struct sk_buff *sctp_skb_recv_datagram(struct sock *, int, int, int *);
118
119int sctp_transport_walk_start(struct rhashtable_iter *iter);
120void sctp_transport_walk_stop(struct rhashtable_iter *iter);
121struct sctp_transport *sctp_transport_get_next(struct net *net,
122 struct rhashtable_iter *iter);
123struct sctp_transport *sctp_transport_get_idx(struct net *net,
124 struct rhashtable_iter *iter, int pos);
125int sctp_transport_lookup_process(int (*cb)(struct sctp_transport *, void *),
126 struct net *net,
127 const union sctp_addr *laddr,
128 const union sctp_addr *paddr, void *p);
129int sctp_for_each_transport(int (*cb)(struct sctp_transport *, void *),
130 struct net *net, int pos, void *p);
131int sctp_for_each_endpoint(int (*cb)(struct sctp_endpoint *, void *), void *p);
132int sctp_get_sctp_info(struct sock *sk, struct sctp_association *asoc,
133 struct sctp_info *info);
134
135
136
137
138int sctp_primitive_ASSOCIATE(struct net *, struct sctp_association *, void *arg);
139int sctp_primitive_SHUTDOWN(struct net *, struct sctp_association *, void *arg);
140int sctp_primitive_ABORT(struct net *, struct sctp_association *, void *arg);
141int sctp_primitive_SEND(struct net *, struct sctp_association *, void *arg);
142int sctp_primitive_REQUESTHEARTBEAT(struct net *, struct sctp_association *, void *arg);
143int sctp_primitive_ASCONF(struct net *, struct sctp_association *, void *arg);
144
145
146
147
148int sctp_rcv(struct sk_buff *skb);
149void sctp_v4_err(struct sk_buff *skb, u32 info);
150void sctp_hash_endpoint(struct sctp_endpoint *);
151void sctp_unhash_endpoint(struct sctp_endpoint *);
152struct sock *sctp_err_lookup(struct net *net, int family, struct sk_buff *,
153 struct sctphdr *, struct sctp_association **,
154 struct sctp_transport **);
155void sctp_err_finish(struct sock *, struct sctp_transport *);
156void sctp_icmp_frag_needed(struct sock *, struct sctp_association *,
157 struct sctp_transport *t, __u32 pmtu);
158void sctp_icmp_redirect(struct sock *, struct sctp_transport *,
159 struct sk_buff *);
160void sctp_icmp_proto_unreachable(struct sock *sk,
161 struct sctp_association *asoc,
162 struct sctp_transport *t);
163void sctp_backlog_migrate(struct sctp_association *assoc,
164 struct sock *oldsk, struct sock *newsk);
165int sctp_transport_hashtable_init(void);
166void sctp_transport_hashtable_destroy(void);
167void sctp_hash_transport(struct sctp_transport *t);
168void sctp_unhash_transport(struct sctp_transport *t);
169struct sctp_transport *sctp_addrs_lookup_transport(
170 struct net *net,
171 const union sctp_addr *laddr,
172 const union sctp_addr *paddr);
173struct sctp_transport *sctp_epaddr_lookup_transport(
174 const struct sctp_endpoint *ep,
175 const union sctp_addr *paddr);
176
177
178
179
180int sctp_snmp_proc_init(struct net *net);
181void sctp_snmp_proc_exit(struct net *net);
182int sctp_eps_proc_init(struct net *net);
183void sctp_eps_proc_exit(struct net *net);
184int sctp_assocs_proc_init(struct net *net);
185void sctp_assocs_proc_exit(struct net *net);
186int sctp_remaddr_proc_init(struct net *net);
187void sctp_remaddr_proc_exit(struct net *net);
188
189
190
191
192int sctp_offload_init(void);
193
194
195
196
197
198
199
200
201extern struct kmem_cache *sctp_chunk_cachep __read_mostly;
202extern struct kmem_cache *sctp_bucket_cachep __read_mostly;
203extern long sysctl_sctp_mem[3];
204extern int sysctl_sctp_rmem[3];
205extern int sysctl_sctp_wmem[3];
206
207
208
209
210
211
212#define SCTP_INC_STATS(net, field) SNMP_INC_STATS((net)->sctp.sctp_statistics, field)
213#define __SCTP_INC_STATS(net, field) __SNMP_INC_STATS((net)->sctp.sctp_statistics, field)
214#define SCTP_DEC_STATS(net, field) SNMP_DEC_STATS((net)->sctp.sctp_statistics, field)
215
216
217enum {
218 SCTP_MIB_NUM = 0,
219 SCTP_MIB_CURRESTAB,
220 SCTP_MIB_ACTIVEESTABS,
221 SCTP_MIB_PASSIVEESTABS,
222 SCTP_MIB_ABORTEDS,
223 SCTP_MIB_SHUTDOWNS,
224 SCTP_MIB_OUTOFBLUES,
225 SCTP_MIB_CHECKSUMERRORS,
226 SCTP_MIB_OUTCTRLCHUNKS,
227 SCTP_MIB_OUTORDERCHUNKS,
228 SCTP_MIB_OUTUNORDERCHUNKS,
229 SCTP_MIB_INCTRLCHUNKS,
230 SCTP_MIB_INORDERCHUNKS,
231 SCTP_MIB_INUNORDERCHUNKS,
232 SCTP_MIB_FRAGUSRMSGS,
233 SCTP_MIB_REASMUSRMSGS,
234 SCTP_MIB_OUTSCTPPACKS,
235 SCTP_MIB_INSCTPPACKS,
236 SCTP_MIB_T1_INIT_EXPIREDS,
237 SCTP_MIB_T1_COOKIE_EXPIREDS,
238 SCTP_MIB_T2_SHUTDOWN_EXPIREDS,
239 SCTP_MIB_T3_RTX_EXPIREDS,
240 SCTP_MIB_T4_RTO_EXPIREDS,
241 SCTP_MIB_T5_SHUTDOWN_GUARD_EXPIREDS,
242 SCTP_MIB_DELAY_SACK_EXPIREDS,
243 SCTP_MIB_AUTOCLOSE_EXPIREDS,
244 SCTP_MIB_T1_RETRANSMITS,
245 SCTP_MIB_T3_RETRANSMITS,
246 SCTP_MIB_PMTUD_RETRANSMITS,
247 SCTP_MIB_FAST_RETRANSMITS,
248 SCTP_MIB_IN_PKT_SOFTIRQ,
249 SCTP_MIB_IN_PKT_BACKLOG,
250 SCTP_MIB_IN_PKT_DISCARDS,
251 SCTP_MIB_IN_DATA_CHUNK_DISCARDS,
252 __SCTP_MIB_MAX
253};
254
255#define SCTP_MIB_MAX __SCTP_MIB_MAX
256struct sctp_mib {
257 unsigned long mibs[SCTP_MIB_MAX];
258};
259
260
261static inline void sctp_max_rto(struct sctp_association *asoc,
262 struct sctp_transport *trans)
263{
264 if (asoc->stats.max_obs_rto < (__u64)trans->rto) {
265 asoc->stats.max_obs_rto = trans->rto;
266 memset(&asoc->stats.obs_rto_ipaddr, 0,
267 sizeof(struct sockaddr_storage));
268 memcpy(&asoc->stats.obs_rto_ipaddr, &trans->ipaddr,
269 trans->af_specific->sockaddr_len);
270 }
271}
272
273
274
275
276#ifdef CONFIG_SCTP_DBG_OBJCNT
277
278extern atomic_t sctp_dbg_objcnt_sock;
279extern atomic_t sctp_dbg_objcnt_ep;
280extern atomic_t sctp_dbg_objcnt_assoc;
281extern atomic_t sctp_dbg_objcnt_transport;
282extern atomic_t sctp_dbg_objcnt_chunk;
283extern atomic_t sctp_dbg_objcnt_bind_addr;
284extern atomic_t sctp_dbg_objcnt_bind_bucket;
285extern atomic_t sctp_dbg_objcnt_addr;
286extern atomic_t sctp_dbg_objcnt_ssnmap;
287extern atomic_t sctp_dbg_objcnt_datamsg;
288extern atomic_t sctp_dbg_objcnt_keys;
289
290
291#define SCTP_DBG_OBJCNT_INC(name) \
292atomic_inc(&sctp_dbg_objcnt_## name)
293#define SCTP_DBG_OBJCNT_DEC(name) \
294atomic_dec(&sctp_dbg_objcnt_## name)
295#define SCTP_DBG_OBJCNT(name) \
296atomic_t sctp_dbg_objcnt_## name = ATOMIC_INIT(0)
297
298
299
300
301#define SCTP_DBG_OBJCNT_ENTRY(name) \
302{.label= #name, .counter= &sctp_dbg_objcnt_## name}
303
304void sctp_dbg_objcnt_init(struct net *);
305void sctp_dbg_objcnt_exit(struct net *);
306
307#else
308
309#define SCTP_DBG_OBJCNT_INC(name)
310#define SCTP_DBG_OBJCNT_DEC(name)
311
312static inline void sctp_dbg_objcnt_init(struct net *net) { return; }
313static inline void sctp_dbg_objcnt_exit(struct net *net) { return; }
314
315#endif
316
317#if defined CONFIG_SYSCTL
318void sctp_sysctl_register(void);
319void sctp_sysctl_unregister(void);
320int sctp_sysctl_net_register(struct net *net);
321void sctp_sysctl_net_unregister(struct net *net);
322#else
323static inline void sctp_sysctl_register(void) { return; }
324static inline void sctp_sysctl_unregister(void) { return; }
325static inline int sctp_sysctl_net_register(struct net *net) { return 0; }
326static inline void sctp_sysctl_net_unregister(struct net *net) { return; }
327#endif
328
329
330#define SCTP_SAT_LEN(x) (sizeof(struct sctp_paramhdr) + (x) * sizeof(__u16))
331
332#if IS_ENABLED(CONFIG_IPV6)
333
334void sctp_v6_pf_init(void);
335void sctp_v6_pf_exit(void);
336int sctp_v6_protosw_init(void);
337void sctp_v6_protosw_exit(void);
338int sctp_v6_add_protocol(void);
339void sctp_v6_del_protocol(void);
340
341#else
342
343static inline void sctp_v6_pf_init(void) { return; }
344static inline void sctp_v6_pf_exit(void) { return; }
345static inline int sctp_v6_protosw_init(void) { return 0; }
346static inline void sctp_v6_protosw_exit(void) { return; }
347static inline int sctp_v6_add_protocol(void) { return 0; }
348static inline void sctp_v6_del_protocol(void) { return; }
349
350#endif
351
352
353
354static inline sctp_assoc_t sctp_assoc2id(const struct sctp_association *asoc)
355{
356 return asoc ? asoc->assoc_id : 0;
357}
358
359static inline enum sctp_sstat_state
360sctp_assoc_to_state(const struct sctp_association *asoc)
361{
362
363
364
365
366
367
368
369 return asoc->state + 1;
370}
371
372
373struct sctp_association *sctp_id2assoc(struct sock *sk, sctp_assoc_t id);
374
375int sctp_do_peeloff(struct sock *sk, sctp_assoc_t id, struct socket **sockp);
376
377
378#define sctp_skb_for_each(pos, head, tmp) \
379 skb_queue_walk_safe(head, pos, tmp)
380
381
382
383
384
385
386
387
388
389static inline struct list_head *sctp_list_dequeue(struct list_head *list)
390{
391 struct list_head *result = NULL;
392
393 if (!list_empty(list)) {
394 result = list->next;
395 list_del_init(result);
396 }
397 return result;
398}
399
400
401
402
403
404static inline void sctp_skb_set_owner_r(struct sk_buff *skb, struct sock *sk)
405{
406 struct sctp_ulpevent *event = sctp_skb2event(skb);
407
408 skb_orphan(skb);
409 skb->sk = sk;
410 skb->destructor = sctp_sock_rfree;
411 atomic_add(event->rmem_len, &sk->sk_rmem_alloc);
412
413
414
415 sk->sk_forward_alloc -= event->rmem_len;
416}
417
418
419static inline int sctp_list_single_entry(struct list_head *head)
420{
421 return (head->next != head) && (head->next == head->prev);
422}
423
424
425static inline int sctp_frag_point(const struct sctp_association *asoc, int pmtu)
426{
427 struct sctp_sock *sp = sctp_sk(asoc->base.sk);
428 int frag = pmtu;
429
430 frag -= sp->pf->af->net_header_len;
431 frag -= sizeof(struct sctphdr) + sizeof(struct sctp_data_chunk);
432
433 if (asoc->user_frag)
434 frag = min_t(int, frag, asoc->user_frag);
435
436 frag = SCTP_TRUNC4(min_t(int, frag, SCTP_MAX_CHUNK_LEN));
437
438 return frag;
439}
440
441static inline void sctp_assoc_pending_pmtu(struct sock *sk, struct sctp_association *asoc)
442{
443
444 sctp_assoc_sync_pmtu(sk, asoc);
445 asoc->pmtu_pending = 0;
446}
447
448static inline bool sctp_chunk_pending(const struct sctp_chunk *chunk)
449{
450 return !list_empty(&chunk->list);
451}
452
453
454
455
456
457
458#define sctp_walk_params(pos, chunk, member)\
459_sctp_walk_params((pos), (chunk), ntohs((chunk)->chunk_hdr.length), member)
460
461#define _sctp_walk_params(pos, chunk, end, member)\
462for (pos.v = chunk->member;\
463 pos.v <= (void *)chunk + end - ntohs(pos.p->length) &&\
464 ntohs(pos.p->length) >= sizeof(sctp_paramhdr_t);\
465 pos.v += SCTP_PAD4(ntohs(pos.p->length)))
466
467#define sctp_walk_errors(err, chunk_hdr)\
468_sctp_walk_errors((err), (chunk_hdr), ntohs((chunk_hdr)->length))
469
470#define _sctp_walk_errors(err, chunk_hdr, end)\
471for (err = (sctp_errhdr_t *)((void *)chunk_hdr + \
472 sizeof(sctp_chunkhdr_t));\
473 (void *)err <= (void *)chunk_hdr + end - ntohs(err->length) &&\
474 ntohs(err->length) >= sizeof(sctp_errhdr_t); \
475 err = (sctp_errhdr_t *)((void *)err + SCTP_PAD4(ntohs(err->length))))
476
477#define sctp_walk_fwdtsn(pos, chunk)\
478_sctp_walk_fwdtsn((pos), (chunk), ntohs((chunk)->chunk_hdr->length) - sizeof(struct sctp_fwdtsn_chunk))
479
480#define _sctp_walk_fwdtsn(pos, chunk, end)\
481for (pos = chunk->subh.fwdtsn_hdr->skip;\
482 (void *)pos <= (void *)chunk->subh.fwdtsn_hdr->skip + end - sizeof(struct sctp_fwdtsn_skip);\
483 pos++)
484
485
486
487extern struct proto sctp_prot;
488extern struct proto sctpv6_prot;
489void sctp_put_port(struct sock *sk);
490
491extern struct idr sctp_assocs_id;
492extern spinlock_t sctp_assocs_id_lock;
493
494
495
496
497static inline int ipver2af(__u8 ipver)
498{
499 switch (ipver) {
500 case 4:
501 return AF_INET;
502 case 6:
503 return AF_INET6;
504 default:
505 return 0;
506 }
507}
508
509
510static inline int param_type2af(__be16 type)
511{
512 switch (type) {
513 case SCTP_PARAM_IPV4_ADDRESS:
514 return AF_INET;
515 case SCTP_PARAM_IPV6_ADDRESS:
516 return AF_INET6;
517 default:
518 return 0;
519 }
520}
521
522
523
524static inline int sctp_phashfn(struct net *net, __u16 lport)
525{
526 return (net_hash_mix(net) + lport) & (sctp_port_hashsize - 1);
527}
528
529
530static inline int sctp_ep_hashfn(struct net *net, __u16 lport)
531{
532 return (net_hash_mix(net) + lport) & (sctp_ep_hashsize - 1);
533}
534
535#define sctp_for_each_hentry(epb, head) \
536 hlist_for_each_entry(epb, head, node)
537
538
539#define sctp_style(sk, style) __sctp_style((sk), (SCTP_SOCKET_##style))
540static inline int __sctp_style(const struct sock *sk, sctp_socket_type_t style)
541{
542 return sctp_sk(sk)->type == style;
543}
544
545
546#define sctp_state(asoc, state) __sctp_state((asoc), (SCTP_STATE_##state))
547static inline int __sctp_state(const struct sctp_association *asoc,
548 sctp_state_t state)
549{
550 return asoc->state == state;
551}
552
553
554#define sctp_sstate(sk, state) __sctp_sstate((sk), (SCTP_SS_##state))
555static inline int __sctp_sstate(const struct sock *sk, sctp_sock_state_t state)
556{
557 return sk->sk_state == state;
558}
559
560
561static inline void sctp_v6_map_v4(union sctp_addr *addr)
562{
563 addr->v4.sin_family = AF_INET;
564 addr->v4.sin_port = addr->v6.sin6_port;
565 addr->v4.sin_addr.s_addr = addr->v6.sin6_addr.s6_addr32[3];
566}
567
568
569static inline void sctp_v4_map_v6(union sctp_addr *addr)
570{
571 __be16 port;
572
573 port = addr->v4.sin_port;
574 addr->v6.sin6_addr.s6_addr32[3] = addr->v4.sin_addr.s_addr;
575 addr->v6.sin6_port = port;
576 addr->v6.sin6_family = AF_INET6;
577 addr->v6.sin6_flowinfo = 0;
578 addr->v6.sin6_scope_id = 0;
579 addr->v6.sin6_addr.s6_addr32[0] = 0;
580 addr->v6.sin6_addr.s6_addr32[1] = 0;
581 addr->v6.sin6_addr.s6_addr32[2] = htonl(0x0000ffff);
582}
583
584
585
586
587static inline struct dst_entry *sctp_transport_dst_check(struct sctp_transport *t)
588{
589 if (t->dst && !dst_check(t->dst, t->dst_cookie)) {
590 dst_release(t->dst);
591 t->dst = NULL;
592 }
593
594 return t->dst;
595}
596
597#endif
598