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 <linux/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);
144int sctp_primitive_RECONF(struct net *net, struct sctp_association *asoc,
145 void *arg);
146
147
148
149
150int sctp_rcv(struct sk_buff *skb);
151void sctp_v4_err(struct sk_buff *skb, u32 info);
152void sctp_hash_endpoint(struct sctp_endpoint *);
153void sctp_unhash_endpoint(struct sctp_endpoint *);
154struct sock *sctp_err_lookup(struct net *net, int family, struct sk_buff *,
155 struct sctphdr *, struct sctp_association **,
156 struct sctp_transport **);
157void sctp_err_finish(struct sock *, struct sctp_transport *);
158void sctp_icmp_frag_needed(struct sock *, struct sctp_association *,
159 struct sctp_transport *t, __u32 pmtu);
160void sctp_icmp_redirect(struct sock *, struct sctp_transport *,
161 struct sk_buff *);
162void sctp_icmp_proto_unreachable(struct sock *sk,
163 struct sctp_association *asoc,
164 struct sctp_transport *t);
165void sctp_backlog_migrate(struct sctp_association *assoc,
166 struct sock *oldsk, struct sock *newsk);
167int sctp_transport_hashtable_init(void);
168void sctp_transport_hashtable_destroy(void);
169int sctp_hash_transport(struct sctp_transport *t);
170void sctp_unhash_transport(struct sctp_transport *t);
171struct sctp_transport *sctp_addrs_lookup_transport(
172 struct net *net,
173 const union sctp_addr *laddr,
174 const union sctp_addr *paddr);
175struct sctp_transport *sctp_epaddr_lookup_transport(
176 const struct sctp_endpoint *ep,
177 const union sctp_addr *paddr);
178
179
180
181
182int sctp_snmp_proc_init(struct net *net);
183void sctp_snmp_proc_exit(struct net *net);
184int sctp_eps_proc_init(struct net *net);
185void sctp_eps_proc_exit(struct net *net);
186int sctp_assocs_proc_init(struct net *net);
187void sctp_assocs_proc_exit(struct net *net);
188int sctp_remaddr_proc_init(struct net *net);
189void sctp_remaddr_proc_exit(struct net *net);
190
191
192
193
194int sctp_offload_init(void);
195
196
197
198
199int sctp_send_reset_streams(struct sctp_association *asoc,
200 struct sctp_reset_streams *params);
201int sctp_send_reset_assoc(struct sctp_association *asoc);
202int sctp_send_add_streams(struct sctp_association *asoc,
203 struct sctp_add_streams *params);
204
205
206
207
208
209
210
211
212extern struct kmem_cache *sctp_chunk_cachep __read_mostly;
213extern struct kmem_cache *sctp_bucket_cachep __read_mostly;
214extern long sysctl_sctp_mem[3];
215extern int sysctl_sctp_rmem[3];
216extern int sysctl_sctp_wmem[3];
217
218
219
220
221
222
223#define SCTP_INC_STATS(net, field) SNMP_INC_STATS((net)->sctp.sctp_statistics, field)
224#define __SCTP_INC_STATS(net, field) __SNMP_INC_STATS((net)->sctp.sctp_statistics, field)
225#define SCTP_DEC_STATS(net, field) SNMP_DEC_STATS((net)->sctp.sctp_statistics, field)
226
227
228enum {
229 SCTP_MIB_NUM = 0,
230 SCTP_MIB_CURRESTAB,
231 SCTP_MIB_ACTIVEESTABS,
232 SCTP_MIB_PASSIVEESTABS,
233 SCTP_MIB_ABORTEDS,
234 SCTP_MIB_SHUTDOWNS,
235 SCTP_MIB_OUTOFBLUES,
236 SCTP_MIB_CHECKSUMERRORS,
237 SCTP_MIB_OUTCTRLCHUNKS,
238 SCTP_MIB_OUTORDERCHUNKS,
239 SCTP_MIB_OUTUNORDERCHUNKS,
240 SCTP_MIB_INCTRLCHUNKS,
241 SCTP_MIB_INORDERCHUNKS,
242 SCTP_MIB_INUNORDERCHUNKS,
243 SCTP_MIB_FRAGUSRMSGS,
244 SCTP_MIB_REASMUSRMSGS,
245 SCTP_MIB_OUTSCTPPACKS,
246 SCTP_MIB_INSCTPPACKS,
247 SCTP_MIB_T1_INIT_EXPIREDS,
248 SCTP_MIB_T1_COOKIE_EXPIREDS,
249 SCTP_MIB_T2_SHUTDOWN_EXPIREDS,
250 SCTP_MIB_T3_RTX_EXPIREDS,
251 SCTP_MIB_T4_RTO_EXPIREDS,
252 SCTP_MIB_T5_SHUTDOWN_GUARD_EXPIREDS,
253 SCTP_MIB_DELAY_SACK_EXPIREDS,
254 SCTP_MIB_AUTOCLOSE_EXPIREDS,
255 SCTP_MIB_T1_RETRANSMITS,
256 SCTP_MIB_T3_RETRANSMITS,
257 SCTP_MIB_PMTUD_RETRANSMITS,
258 SCTP_MIB_FAST_RETRANSMITS,
259 SCTP_MIB_IN_PKT_SOFTIRQ,
260 SCTP_MIB_IN_PKT_BACKLOG,
261 SCTP_MIB_IN_PKT_DISCARDS,
262 SCTP_MIB_IN_DATA_CHUNK_DISCARDS,
263 __SCTP_MIB_MAX
264};
265
266#define SCTP_MIB_MAX __SCTP_MIB_MAX
267struct sctp_mib {
268 unsigned long mibs[SCTP_MIB_MAX];
269};
270
271
272static inline void sctp_max_rto(struct sctp_association *asoc,
273 struct sctp_transport *trans)
274{
275 if (asoc->stats.max_obs_rto < (__u64)trans->rto) {
276 asoc->stats.max_obs_rto = trans->rto;
277 memset(&asoc->stats.obs_rto_ipaddr, 0,
278 sizeof(struct sockaddr_storage));
279 memcpy(&asoc->stats.obs_rto_ipaddr, &trans->ipaddr,
280 trans->af_specific->sockaddr_len);
281 }
282}
283
284
285
286
287#ifdef CONFIG_SCTP_DBG_OBJCNT
288
289extern atomic_t sctp_dbg_objcnt_sock;
290extern atomic_t sctp_dbg_objcnt_ep;
291extern atomic_t sctp_dbg_objcnt_assoc;
292extern atomic_t sctp_dbg_objcnt_transport;
293extern atomic_t sctp_dbg_objcnt_chunk;
294extern atomic_t sctp_dbg_objcnt_bind_addr;
295extern atomic_t sctp_dbg_objcnt_bind_bucket;
296extern atomic_t sctp_dbg_objcnt_addr;
297extern atomic_t sctp_dbg_objcnt_datamsg;
298extern atomic_t sctp_dbg_objcnt_keys;
299
300
301#define SCTP_DBG_OBJCNT_INC(name) \
302atomic_inc(&sctp_dbg_objcnt_## name)
303#define SCTP_DBG_OBJCNT_DEC(name) \
304atomic_dec(&sctp_dbg_objcnt_## name)
305#define SCTP_DBG_OBJCNT(name) \
306atomic_t sctp_dbg_objcnt_## name = ATOMIC_INIT(0)
307
308
309
310
311#define SCTP_DBG_OBJCNT_ENTRY(name) \
312{.label= #name, .counter= &sctp_dbg_objcnt_## name}
313
314void sctp_dbg_objcnt_init(struct net *);
315void sctp_dbg_objcnt_exit(struct net *);
316
317#else
318
319#define SCTP_DBG_OBJCNT_INC(name)
320#define SCTP_DBG_OBJCNT_DEC(name)
321
322static inline void sctp_dbg_objcnt_init(struct net *net) { return; }
323static inline void sctp_dbg_objcnt_exit(struct net *net) { return; }
324
325#endif
326
327#if defined CONFIG_SYSCTL
328void sctp_sysctl_register(void);
329void sctp_sysctl_unregister(void);
330int sctp_sysctl_net_register(struct net *net);
331void sctp_sysctl_net_unregister(struct net *net);
332#else
333static inline void sctp_sysctl_register(void) { return; }
334static inline void sctp_sysctl_unregister(void) { return; }
335static inline int sctp_sysctl_net_register(struct net *net) { return 0; }
336static inline void sctp_sysctl_net_unregister(struct net *net) { return; }
337#endif
338
339
340#define SCTP_SAT_LEN(x) (sizeof(struct sctp_paramhdr) + (x) * sizeof(__u16))
341
342#if IS_ENABLED(CONFIG_IPV6)
343
344void sctp_v6_pf_init(void);
345void sctp_v6_pf_exit(void);
346int sctp_v6_protosw_init(void);
347void sctp_v6_protosw_exit(void);
348int sctp_v6_add_protocol(void);
349void sctp_v6_del_protocol(void);
350
351#else
352
353static inline void sctp_v6_pf_init(void) { return; }
354static inline void sctp_v6_pf_exit(void) { return; }
355static inline int sctp_v6_protosw_init(void) { return 0; }
356static inline void sctp_v6_protosw_exit(void) { return; }
357static inline int sctp_v6_add_protocol(void) { return 0; }
358static inline void sctp_v6_del_protocol(void) { return; }
359
360#endif
361
362
363
364static inline sctp_assoc_t sctp_assoc2id(const struct sctp_association *asoc)
365{
366 return asoc ? asoc->assoc_id : 0;
367}
368
369static inline enum sctp_sstat_state
370sctp_assoc_to_state(const struct sctp_association *asoc)
371{
372
373
374
375
376
377
378
379 return asoc->state + 1;
380}
381
382
383struct sctp_association *sctp_id2assoc(struct sock *sk, sctp_assoc_t id);
384
385int sctp_do_peeloff(struct sock *sk, sctp_assoc_t id, struct socket **sockp);
386
387
388#define sctp_skb_for_each(pos, head, tmp) \
389 skb_queue_walk_safe(head, pos, tmp)
390
391
392
393
394
395
396
397
398
399static inline struct list_head *sctp_list_dequeue(struct list_head *list)
400{
401 struct list_head *result = NULL;
402
403 if (!list_empty(list)) {
404 result = list->next;
405 list_del_init(result);
406 }
407 return result;
408}
409
410
411
412
413
414static inline void sctp_skb_set_owner_r(struct sk_buff *skb, struct sock *sk)
415{
416 struct sctp_ulpevent *event = sctp_skb2event(skb);
417
418 skb_orphan(skb);
419 skb->sk = sk;
420 skb->destructor = sctp_sock_rfree;
421 atomic_add(event->rmem_len, &sk->sk_rmem_alloc);
422
423
424
425 sk->sk_forward_alloc -= event->rmem_len;
426}
427
428
429static inline int sctp_list_single_entry(struct list_head *head)
430{
431 return (head->next != head) && (head->next == head->prev);
432}
433
434
435static inline int sctp_frag_point(const struct sctp_association *asoc, int pmtu)
436{
437 struct sctp_sock *sp = sctp_sk(asoc->base.sk);
438 int frag = pmtu;
439
440 frag -= sp->pf->af->net_header_len;
441 frag -= sizeof(struct sctphdr) + sizeof(struct sctp_data_chunk);
442
443 if (asoc->user_frag)
444 frag = min_t(int, frag, asoc->user_frag);
445
446 frag = SCTP_TRUNC4(min_t(int, frag, SCTP_MAX_CHUNK_LEN));
447
448 return frag;
449}
450
451static inline void sctp_assoc_pending_pmtu(struct sctp_association *asoc)
452{
453 sctp_assoc_sync_pmtu(asoc);
454 asoc->pmtu_pending = 0;
455}
456
457static inline bool sctp_chunk_pending(const struct sctp_chunk *chunk)
458{
459 return !list_empty(&chunk->list);
460}
461
462
463
464
465
466
467#define sctp_walk_params(pos, chunk, member)\
468_sctp_walk_params((pos), (chunk), ntohs((chunk)->chunk_hdr.length), member)
469
470#define _sctp_walk_params(pos, chunk, end, member)\
471for (pos.v = chunk->member;\
472 (pos.v + offsetof(struct sctp_paramhdr, length) + sizeof(pos.p->length) <=\
473 (void *)chunk + end) &&\
474 pos.v <= (void *)chunk + end - ntohs(pos.p->length) &&\
475 ntohs(pos.p->length) >= sizeof(struct sctp_paramhdr);\
476 pos.v += SCTP_PAD4(ntohs(pos.p->length)))
477
478#define sctp_walk_errors(err, chunk_hdr)\
479_sctp_walk_errors((err), (chunk_hdr), ntohs((chunk_hdr)->length))
480
481#define _sctp_walk_errors(err, chunk_hdr, end)\
482for (err = (sctp_errhdr_t *)((void *)chunk_hdr + \
483 sizeof(struct sctp_chunkhdr));\
484 ((void *)err + offsetof(sctp_errhdr_t, length) + sizeof(err->length) <=\
485 (void *)chunk_hdr + end) &&\
486 (void *)err <= (void *)chunk_hdr + end - ntohs(err->length) &&\
487 ntohs(err->length) >= sizeof(sctp_errhdr_t); \
488 err = (sctp_errhdr_t *)((void *)err + SCTP_PAD4(ntohs(err->length))))
489
490#define sctp_walk_fwdtsn(pos, chunk)\
491_sctp_walk_fwdtsn((pos), (chunk), ntohs((chunk)->chunk_hdr->length) - sizeof(struct sctp_fwdtsn_chunk))
492
493#define _sctp_walk_fwdtsn(pos, chunk, end)\
494for (pos = chunk->subh.fwdtsn_hdr->skip;\
495 (void *)pos <= (void *)chunk->subh.fwdtsn_hdr->skip + end - sizeof(struct sctp_fwdtsn_skip);\
496 pos++)
497
498
499
500extern struct proto sctp_prot;
501extern struct proto sctpv6_prot;
502void sctp_put_port(struct sock *sk);
503
504extern struct idr sctp_assocs_id;
505extern spinlock_t sctp_assocs_id_lock;
506
507
508
509
510static inline int ipver2af(__u8 ipver)
511{
512 switch (ipver) {
513 case 4:
514 return AF_INET;
515 case 6:
516 return AF_INET6;
517 default:
518 return 0;
519 }
520}
521
522
523static inline int param_type2af(__be16 type)
524{
525 switch (type) {
526 case SCTP_PARAM_IPV4_ADDRESS:
527 return AF_INET;
528 case SCTP_PARAM_IPV6_ADDRESS:
529 return AF_INET6;
530 default:
531 return 0;
532 }
533}
534
535
536
537static inline int sctp_phashfn(struct net *net, __u16 lport)
538{
539 return (net_hash_mix(net) + lport) & (sctp_port_hashsize - 1);
540}
541
542
543static inline int sctp_ep_hashfn(struct net *net, __u16 lport)
544{
545 return (net_hash_mix(net) + lport) & (sctp_ep_hashsize - 1);
546}
547
548#define sctp_for_each_hentry(epb, head) \
549 hlist_for_each_entry(epb, head, node)
550
551
552#define sctp_style(sk, style) __sctp_style((sk), (SCTP_SOCKET_##style))
553static inline int __sctp_style(const struct sock *sk, sctp_socket_type_t style)
554{
555 return sctp_sk(sk)->type == style;
556}
557
558
559#define sctp_state(asoc, state) __sctp_state((asoc), (SCTP_STATE_##state))
560static inline int __sctp_state(const struct sctp_association *asoc,
561 sctp_state_t state)
562{
563 return asoc->state == state;
564}
565
566
567#define sctp_sstate(sk, state) __sctp_sstate((sk), (SCTP_SS_##state))
568static inline int __sctp_sstate(const struct sock *sk, sctp_sock_state_t state)
569{
570 return sk->sk_state == state;
571}
572
573
574static inline void sctp_v6_map_v4(union sctp_addr *addr)
575{
576 addr->v4.sin_family = AF_INET;
577 addr->v4.sin_port = addr->v6.sin6_port;
578 addr->v4.sin_addr.s_addr = addr->v6.sin6_addr.s6_addr32[3];
579}
580
581
582static inline void sctp_v4_map_v6(union sctp_addr *addr)
583{
584 __be16 port;
585
586 port = addr->v4.sin_port;
587 addr->v6.sin6_addr.s6_addr32[3] = addr->v4.sin_addr.s_addr;
588 addr->v6.sin6_port = port;
589 addr->v6.sin6_family = AF_INET6;
590 addr->v6.sin6_flowinfo = 0;
591 addr->v6.sin6_scope_id = 0;
592 addr->v6.sin6_addr.s6_addr32[0] = 0;
593 addr->v6.sin6_addr.s6_addr32[1] = 0;
594 addr->v6.sin6_addr.s6_addr32[2] = htonl(0x0000ffff);
595}
596
597
598
599
600static inline struct dst_entry *sctp_transport_dst_check(struct sctp_transport *t)
601{
602 if (t->dst && !dst_check(t->dst, t->dst_cookie))
603 sctp_transport_dst_release(t);
604
605 return t->dst;
606}
607
608static inline bool sctp_transport_pmtu_check(struct sctp_transport *t)
609{
610 __u32 pmtu = max_t(size_t, SCTP_TRUNC4(dst_mtu(t->dst)),
611 SCTP_DEFAULT_MINSEGMENT);
612
613 if (t->pathmtu == pmtu)
614 return true;
615
616 t->pathmtu = pmtu;
617
618 return false;
619}
620
621#endif
622