sctp_pcb.h revision 181054
1/*-
2 * Copyright (c) 2001-2007, by Cisco Systems, Inc. All rights reserved.
3 *
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions are met:
6 *
7 * a) Redistributions of source code must retain the above copyright notice,
8 *   this list of conditions and the following disclaimer.
9 *
10 * b) Redistributions in binary form must reproduce the above copyright
11 *    notice, this list of conditions and the following disclaimer in
12 *   the documentation and/or other materials provided with the distribution.
13 *
14 * c) Neither the name of Cisco Systems, Inc. nor the names of its
15 *    contributors may be used to endorse or promote products derived
16 *    from this software without specific prior written permission.
17 *
18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
20 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
21 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
22 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
23 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
24 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
25 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
26 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
27 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
28 * THE POSSIBILITY OF SUCH DAMAGE.
29 */
30
31/* $KAME: sctp_pcb.h,v 1.21 2005/07/16 01:18:47 suz Exp $	 */
32
33#include <sys/cdefs.h>
34__FBSDID("$FreeBSD: head/sys/netinet/sctp_pcb.h 181054 2008-07-31 11:08:30Z rrs $");
35
36#ifndef __sctp_pcb_h__
37#define __sctp_pcb_h__
38
39#include <netinet/sctp_os.h>
40#include <netinet/sctp.h>
41#include <netinet/sctp_constants.h>
42#include <netinet/sctp_sysctl.h>
43
44LIST_HEAD(sctppcbhead, sctp_inpcb);
45LIST_HEAD(sctpasochead, sctp_tcb);
46LIST_HEAD(sctpladdr, sctp_laddr);
47LIST_HEAD(sctpvtaghead, sctp_tagblock);
48LIST_HEAD(sctp_vrflist, sctp_vrf);
49LIST_HEAD(sctp_ifnlist, sctp_ifn);
50LIST_HEAD(sctp_ifalist, sctp_ifa);
51TAILQ_HEAD(sctp_readhead, sctp_queued_to_read);
52TAILQ_HEAD(sctp_streamhead, sctp_stream_queue_pending);
53
54#include <netinet/sctp_structs.h>
55#include <netinet/sctp_auth.h>
56
57#define SCTP_PCBHASH_ALLADDR(port, mask) (port & mask)
58#define SCTP_PCBHASH_ASOC(tag, mask) (tag & mask)
59
60struct sctp_vrf {
61	LIST_ENTRY(sctp_vrf) next_vrf;
62	struct sctp_ifalist *vrf_addr_hash;
63	struct sctp_ifnlist ifnlist;
64	uint32_t vrf_id;
65	uint32_t tbl_id_v4;	/* default v4 table id */
66	uint32_t tbl_id_v6;	/* default v6 table id */
67	uint32_t total_ifa_count;
68	u_long vrf_addr_hashmark;
69	uint32_t refcount;
70};
71
72struct sctp_ifn {
73	struct sctp_ifalist ifalist;
74	struct sctp_vrf *vrf;
75	         LIST_ENTRY(sctp_ifn) next_ifn;
76	         LIST_ENTRY(sctp_ifn) next_bucket;
77	void *ifn_p;		/* never access without appropriate lock */
78	uint32_t ifn_mtu;
79	uint32_t ifn_type;
80	uint32_t ifn_index;	/* shorthand way to look at ifn for reference */
81	uint32_t refcount;	/* number of reference held should be >=
82				 * ifa_count */
83	uint32_t ifa_count;	/* IFA's we hold (in our list - ifalist) */
84	uint32_t num_v6;	/* number of v6 addresses */
85	uint32_t num_v4;	/* number of v4 addresses */
86	uint32_t registered_af;	/* registered address family for i/f events */
87	char ifn_name[SCTP_IFNAMSIZ];
88};
89
90/* SCTP local IFA flags */
91#define SCTP_ADDR_VALID         0x00000001	/* its up and active */
92#define SCTP_BEING_DELETED      0x00000002	/* being deleted, when
93						 * refcount = 0. Note that it
94						 * is pulled from the ifn list
95						 * and ifa_p is nulled right
96						 * away but it cannot be freed
97						 * until the last *net
98						 * pointing to it is deleted. */
99#define SCTP_ADDR_DEFER_USE     0x00000004	/* Hold off using this one */
100#define SCTP_ADDR_IFA_UNUSEABLE 0x00000008
101
102struct sctp_ifa {
103	LIST_ENTRY(sctp_ifa) next_ifa;
104	LIST_ENTRY(sctp_ifa) next_bucket;
105	struct sctp_ifn *ifn_p;	/* back pointer to parent ifn */
106	void *ifa;		/* pointer to ifa, needed for flag update for
107				 * that we MUST lock appropriate locks. This
108				 * is for V6. */
109	union sctp_sockstore address;
110	uint32_t refcount;	/* number of folks refering to this */
111	uint32_t flags;
112	uint32_t localifa_flags;
113	uint32_t vrf_id;	/* vrf_id of this addr (for deleting) */
114	uint8_t src_is_loop;
115	uint8_t src_is_priv;
116	uint8_t src_is_glob;
117	uint8_t resv;
118};
119
120struct sctp_laddr {
121	LIST_ENTRY(sctp_laddr) sctp_nxt_addr;	/* next in list */
122	struct sctp_ifa *ifa;
123	uint32_t action;	/* Used during asconf and adding if no-zero
124				 * src-addr selection will not consider this
125				 * address. */
126	struct timeval start_time;	/* time when this address was created */
127};
128
129struct sctp_block_entry {
130	int error;
131};
132
133struct sctp_timewait {
134	uint32_t tv_sec_at_expire;	/* the seconds from boot to expire */
135	uint32_t v_tag;		/* the vtag that can not be reused */
136};
137
138struct sctp_tagblock {
139	LIST_ENTRY(sctp_tagblock) sctp_nxt_tagblock;
140	struct sctp_timewait vtag_block[SCTP_NUMBER_IN_VTAG_BLOCK];
141};
142
143
144struct sctp_epinfo {
145	struct sctpasochead *sctp_asochash;
146	u_long hashasocmark;
147
148	struct sctppcbhead *sctp_ephash;
149	u_long hashmark;
150
151	struct sctpasochead *sctp_restarthash;
152	u_long hashrestartmark;
153	/*-
154	 * The TCP model represents a substantial overhead in that we get an
155	 * additional hash table to keep explicit connections in. The
156	 * listening TCP endpoint will exist in the usual ephash above and
157	 * accept only INIT's. It will be incapable of sending off an INIT.
158	 * When a dg arrives we must look in the normal ephash. If we find a
159	 * TCP endpoint that will tell us to go to the specific endpoint
160	 * hash and re-hash to find the right assoc/socket. If we find a UDP
161	 * model socket we then must complete the lookup. If this fails,
162	 * i.e. no association can be found then we must continue to see if
163	 * a sctp_peeloff()'d socket is in the tcpephash (a spun off socket
164	 * acts like a TCP model connected socket).
165	 */
166	struct sctppcbhead *sctp_tcpephash;
167	u_long hashtcpmark;
168	uint32_t hashtblsize;
169
170	struct sctp_vrflist *sctp_vrfhash;
171	u_long hashvrfmark;
172
173	struct sctp_ifnlist *vrf_ifn_hash;
174	u_long vrf_ifn_hashmark;
175
176	struct sctppcbhead listhead;
177	struct sctpladdr addr_wq;
178
179	struct sctpiterators iteratorhead;
180	int threads_must_exit;
181	/* ep zone info */
182	sctp_zone_t ipi_zone_ep;
183	sctp_zone_t ipi_zone_asoc;
184	sctp_zone_t ipi_zone_laddr;
185	sctp_zone_t ipi_zone_net;
186	sctp_zone_t ipi_zone_chunk;
187	sctp_zone_t ipi_zone_readq;
188	sctp_zone_t ipi_zone_strmoq;
189	sctp_zone_t ipi_zone_asconf;
190	sctp_zone_t ipi_zone_asconf_ack;
191
192	struct rwlock ipi_ep_mtx;
193	struct mtx it_mtx;
194	struct mtx ipi_iterator_wq_mtx;
195	struct rwlock ipi_addr_mtx;
196	struct mtx ipi_pktlog_mtx;
197	uint32_t ipi_count_ep;
198
199	/* assoc/tcb zone info */
200	uint32_t ipi_count_asoc;
201
202	/* local addrlist zone info */
203	uint32_t ipi_count_laddr;
204
205	/* remote addrlist zone info */
206	uint32_t ipi_count_raddr;
207
208	/* chunk structure list for output */
209	uint32_t ipi_count_chunk;
210
211	/* socket queue zone info */
212	uint32_t ipi_count_readq;
213
214	/* socket queue zone info */
215	uint32_t ipi_count_strmoq;
216
217	/* Number of vrfs */
218	uint32_t ipi_count_vrfs;
219
220	/* Number of ifns */
221	uint32_t ipi_count_ifns;
222
223	/* Number of ifas */
224	uint32_t ipi_count_ifas;
225
226	/* system wide number of free chunks hanging around */
227	uint32_t ipi_free_chunks;
228	uint32_t ipi_free_strmoq;
229
230
231	struct sctpvtaghead vtag_timewait[SCTP_STACK_VTAG_HASH_SIZE_A];
232
233	/* address work queue handling */
234#if defined(SCTP_USE_THREAD_BASED_ITERATOR)
235	uint32_t iterator_running;
236	SCTP_PROCESS_STRUCT thread_proc;
237#endif
238	struct sctp_timer addr_wq_timer;
239
240};
241
242
243struct sctp_base_info {
244	/*
245	 * All static structures that anchor the system must be here.
246	 */
247	struct sctp_epinfo sctppcbinfo;
248	struct sctpstat sctpstat;
249	struct sctp_sysctl sctpsysctl;
250	uint8_t first_time;
251	char sctp_pcb_initialized;
252#if defined(SCTP_PACKET_LOGGING)
253	int packet_log_writers;
254	int packet_log_end;
255	uint8_t packet_log_buffer[SCTP_PACKET_LOG_SIZE];
256#endif
257};
258
259/*-
260 * Here we have all the relevant information for each SCTP entity created. We
261 * will need to modify this as approprate. We also need to figure out how to
262 * access /dev/random.
263 */
264struct sctp_pcb {
265	unsigned int time_of_secret_change;	/* number of seconds from
266						 * timeval.tv_sec */
267	uint32_t secret_key[SCTP_HOW_MANY_SECRETS][SCTP_NUMBER_OF_SECRETS];
268	unsigned int size_of_a_cookie;
269
270	unsigned int sctp_timeoutticks[SCTP_NUM_TMRS];
271	unsigned int sctp_minrto;
272	unsigned int sctp_maxrto;
273	unsigned int initial_rto;
274	int initial_init_rto_max;
275
276	unsigned int sctp_sack_freq;
277	uint32_t sctp_sws_sender;
278	uint32_t sctp_sws_receiver;
279
280	uint32_t sctp_default_cc_module;
281	/* authentication related fields */
282	struct sctp_keyhead shared_keys;
283	sctp_auth_chklist_t *local_auth_chunks;
284	sctp_hmaclist_t *local_hmacs;
285	uint16_t default_keyid;
286
287	/* various thresholds */
288	/* Max times I will init at a guy */
289	uint16_t max_init_times;
290
291	/* Max times I will send before we consider someone dead */
292	uint16_t max_send_times;
293
294	uint16_t def_net_failure;
295
296	/* number of streams to pre-open on a association */
297	uint16_t pre_open_stream_count;
298	uint16_t max_open_streams_intome;
299
300	/* random number generator */
301	uint32_t random_counter;
302	uint8_t random_numbers[SCTP_SIGNATURE_ALOC_SIZE];
303	uint8_t random_store[SCTP_SIGNATURE_ALOC_SIZE];
304
305	/*
306	 * This timer is kept running per endpoint.  When it fires it will
307	 * change the secret key.  The default is once a hour
308	 */
309	struct sctp_timer signature_change;
310
311	/* Zero copy full buffer timer */
312	struct sctp_timer zero_copy_timer;
313	/* Zero copy app to transport (sendq) read repulse timer */
314	struct sctp_timer zero_copy_sendq_timer;
315	uint32_t def_cookie_life;
316	/* defaults to 0 */
317	int auto_close_time;
318	uint32_t initial_sequence_debug;
319	uint32_t adaptation_layer_indicator;
320	uint32_t store_at;
321	uint8_t max_burst;
322	char current_secret_number;
323	char last_secret_number;
324};
325
326#ifndef SCTP_ALIGNMENT
327#define SCTP_ALIGNMENT 32
328#endif
329
330#ifndef SCTP_ALIGNM1
331#define SCTP_ALIGNM1 (SCTP_ALIGNMENT-1)
332#endif
333
334#define sctp_lport ip_inp.inp.inp_lport
335
336struct sctp_pcbtsn_rlog {
337	uint32_t vtag;
338	uint16_t strm;
339	uint16_t seq;
340	uint16_t sz;
341	uint16_t flgs;
342};
343
344#define SCTP_READ_LOG_SIZE 135	/* we choose the number to make a pcb a page */
345
346
347struct sctp_inpcb {
348	/*-
349	 * put an inpcb in front of it all, kind of a waste but we need to
350	 * for compatability with all the other stuff.
351	 */
352	union {
353		struct inpcb inp;
354		char align[(sizeof(struct in6pcb) + SCTP_ALIGNM1) &
355		        ~SCTP_ALIGNM1];
356	}     ip_inp;
357
358
359	/* Socket buffer lock protects read_queue and of course sb_cc */
360	struct sctp_readhead read_queue;
361
362	              LIST_ENTRY(sctp_inpcb) sctp_list;	/* lists all endpoints */
363	/* hash of all endpoints for model */
364	              LIST_ENTRY(sctp_inpcb) sctp_hash;
365	/* count of local addresses bound, 0 if bound all */
366	int laddr_count;
367
368	/* list of addrs in use by the EP, NULL if bound-all */
369	struct sctpladdr sctp_addr_list;
370	/*
371	 * used for source address selection rotation when we are subset
372	 * bound
373	 */
374	struct sctp_laddr *next_addr_touse;
375
376	/* back pointer to our socket */
377	struct socket *sctp_socket;
378	uint32_t sctp_flags;	/* INP state flag set */
379	uint32_t sctp_features;	/* Feature flags */
380	uint32_t sctp_mobility_features;	/* Mobility  Feature flags */
381	struct sctp_pcb sctp_ep;/* SCTP ep data */
382	/* head of the hash of all associations */
383	struct sctpasochead *sctp_tcbhash;
384	u_long sctp_hashmark;
385	/* head of the list of all associations */
386	struct sctpasochead sctp_asoc_list;
387#ifdef SCTP_TRACK_FREED_ASOCS
388	struct sctpasochead sctp_asoc_free_list;
389#endif
390	struct sctp_iterator *inp_starting_point_for_iterator;
391	uint32_t sctp_frag_point;
392	uint32_t partial_delivery_point;
393	uint32_t sctp_context;
394	struct sctp_nonpad_sndrcvinfo def_send;
395	/*-
396	 * These three are here for the sosend_dgram
397	 * (pkt, pkt_last and control).
398	 * routine. However, I don't think anyone in
399	 * the current FreeBSD kernel calls this. So
400	 * they are candidates with sctp_sendm for
401	 * de-supporting.
402	 */
403	struct mbuf *pkt, *pkt_last;
404	struct mbuf *control;
405	struct mtx inp_mtx;
406	struct mtx inp_create_mtx;
407	struct mtx inp_rdata_mtx;
408	int32_t refcount;
409	uint32_t def_vrf_id;
410	uint32_t total_sends;
411	uint32_t total_recvs;
412	uint32_t last_abort_code;
413	uint32_t total_nospaces;
414#ifdef SCTP_ASOCLOG_OF_TSNS
415	struct sctp_pcbtsn_rlog readlog[SCTP_READ_LOG_SIZE];
416	uint32_t readlog_index;
417#endif
418};
419
420struct sctp_tcb {
421	struct socket *sctp_socket;	/* back pointer to socket */
422	struct sctp_inpcb *sctp_ep;	/* back pointer to ep */
423	           LIST_ENTRY(sctp_tcb) sctp_tcbhash;	/* next link in hash
424							 * table */
425	           LIST_ENTRY(sctp_tcb) sctp_tcblist;	/* list of all of the
426							 * TCB's */
427	           LIST_ENTRY(sctp_tcb) sctp_tcbrestarhash;	/* next link in restart
428								 * hash table */
429	           LIST_ENTRY(sctp_tcb) sctp_asocs;	/* vtag hash list */
430	struct sctp_block_entry *block_entry;	/* pointer locked by  socket
431						 * send buffer */
432	struct sctp_association asoc;
433	/*-
434	 * freed_by_sorcv_sincelast is protected by the sockbuf_lock NOT the
435	 * tcb_lock. Its special in this way to help avoid extra mutex calls
436	 * in the reading of data.
437	 */
438	uint32_t freed_by_sorcv_sincelast;
439	uint32_t total_sends;
440	uint32_t total_recvs;
441	int freed_from_where;
442	uint16_t rport;		/* remote port in network format */
443	uint16_t resv;
444	struct mtx tcb_mtx;
445	struct mtx tcb_send_mtx;
446};
447
448
449
450#include <netinet/sctp_lock_bsd.h>
451
452
453/* TODO where to put non-_KERNEL things for __Userspace__? */
454#if defined(_KERNEL) || defined(__Userspace__)
455
456/* Attention Julian, this is the extern that
457 * goes with the base info. sctp_pcb.c has
458 * the real definition.
459 */
460extern struct sctp_base_info system_base_info;
461
462#ifdef INET6
463int SCTP6_ARE_ADDR_EQUAL(struct sockaddr_in6 *a, struct sockaddr_in6 *b);
464
465#endif
466
467void sctp_fill_pcbinfo(struct sctp_pcbinfo *);
468
469struct sctp_ifn *
470         sctp_find_ifn(void *ifn, uint32_t ifn_index);
471
472struct sctp_vrf *sctp_allocate_vrf(int vrfid);
473struct sctp_vrf *sctp_find_vrf(uint32_t vrfid);
474void sctp_free_vrf(struct sctp_vrf *vrf);
475
476/*-
477 * Change address state, can be used if
478 * O/S supports telling transports about
479 * changes to IFA/IFN's (link layer triggers).
480 * If a ifn goes down, we will do src-addr-selection
481 * and NOT use that, as a source address. This does
482 * not stop the routing system from routing out
483 * that interface, but we won't put it as a source.
484 */
485void sctp_mark_ifa_addr_down(uint32_t vrf_id, struct sockaddr *addr, const char *if_name, uint32_t ifn_index);
486void sctp_mark_ifa_addr_up(uint32_t vrf_id, struct sockaddr *addr, const char *if_name, uint32_t ifn_index);
487
488struct sctp_ifa *
489sctp_add_addr_to_vrf(uint32_t vrfid,
490    void *ifn, uint32_t ifn_index, uint32_t ifn_type,
491    const char *if_name,
492    void *ifa, struct sockaddr *addr, uint32_t ifa_flags,
493    int dynamic_add);
494
495void sctp_update_ifn_mtu(uint32_t ifn_index, uint32_t mtu);
496
497void sctp_free_ifn(struct sctp_ifn *sctp_ifnp);
498void sctp_free_ifa(struct sctp_ifa *sctp_ifap);
499
500
501void
502sctp_del_addr_from_vrf(uint32_t vrfid, struct sockaddr *addr,
503    uint32_t ifn_index, const char *if_name);
504
505
506
507struct sctp_nets *sctp_findnet(struct sctp_tcb *, struct sockaddr *);
508
509struct sctp_inpcb *sctp_pcb_findep(struct sockaddr *, int, int, uint32_t);
510
511int
512sctp_inpcb_bind(struct socket *, struct sockaddr *,
513    struct sctp_ifa *, struct thread *);
514
515struct sctp_tcb *
516sctp_findassociation_addr(struct mbuf *, int, int,
517    struct sctphdr *, struct sctp_chunkhdr *, struct sctp_inpcb **,
518    struct sctp_nets **, uint32_t vrf_id);
519
520struct sctp_tcb *
521sctp_findassociation_addr_sa(struct sockaddr *,
522    struct sockaddr *, struct sctp_inpcb **, struct sctp_nets **, int, uint32_t);
523
524void
525sctp_move_pcb_and_assoc(struct sctp_inpcb *, struct sctp_inpcb *,
526    struct sctp_tcb *);
527
528/*-
529 * For this call ep_addr, the to is the destination endpoint address of the
530 * peer (relative to outbound). The from field is only used if the TCP model
531 * is enabled and helps distingush amongst the subset bound (non-boundall).
532 * The TCP model MAY change the actual ep field, this is why it is passed.
533 */
534struct sctp_tcb *
535sctp_findassociation_ep_addr(struct sctp_inpcb **,
536    struct sockaddr *, struct sctp_nets **, struct sockaddr *,
537    struct sctp_tcb *);
538
539struct sctp_tcb *
540sctp_findassociation_ep_asocid(struct sctp_inpcb *,
541    sctp_assoc_t, int);
542
543struct sctp_tcb *
544sctp_findassociation_ep_asconf(struct mbuf *, int, int,
545    struct sctphdr *, struct sctp_inpcb **, struct sctp_nets **);
546
547int sctp_inpcb_alloc(struct socket *so, uint32_t vrf_id);
548
549int sctp_is_address_on_local_host(struct sockaddr *addr, uint32_t vrf_id);
550
551void sctp_inpcb_free(struct sctp_inpcb *, int, int);
552
553struct sctp_tcb *
554sctp_aloc_assoc(struct sctp_inpcb *, struct sockaddr *,
555    int, int *, uint32_t, uint32_t, struct thread *);
556
557int sctp_free_assoc(struct sctp_inpcb *, struct sctp_tcb *, int, int);
558
559
560void sctp_delete_from_timewait(uint32_t);
561
562int sctp_is_in_timewait(uint32_t tag);
563
564void
565     sctp_add_vtag_to_timewait(uint32_t, uint32_t);
566
567void sctp_add_local_addr_ep(struct sctp_inpcb *, struct sctp_ifa *, uint32_t);
568
569int sctp_insert_laddr(struct sctpladdr *, struct sctp_ifa *, uint32_t);
570
571void sctp_remove_laddr(struct sctp_laddr *);
572
573void sctp_del_local_addr_ep(struct sctp_inpcb *, struct sctp_ifa *);
574
575int sctp_add_remote_addr(struct sctp_tcb *, struct sockaddr *, int, int);
576
577void sctp_remove_net(struct sctp_tcb *, struct sctp_nets *);
578
579int sctp_del_remote_addr(struct sctp_tcb *, struct sockaddr *);
580
581void sctp_pcb_init(void);
582
583void sctp_pcb_finish(void);
584
585void sctp_add_local_addr_restricted(struct sctp_tcb *, struct sctp_ifa *);
586void sctp_del_local_addr_restricted(struct sctp_tcb *, struct sctp_ifa *);
587
588int
589sctp_load_addresses_from_init(struct sctp_tcb *, struct mbuf *, int, int,
590    int, struct sctphdr *, struct sockaddr *);
591
592int
593sctp_set_primary_addr(struct sctp_tcb *, struct sockaddr *,
594    struct sctp_nets *);
595
596int sctp_is_vtag_good(struct sctp_inpcb *, uint32_t, struct timeval *, int);
597
598/* void sctp_drain(void); */
599
600int sctp_destination_is_reachable(struct sctp_tcb *, struct sockaddr *);
601
602int sctp_swap_inpcb_for_listen(struct sctp_inpcb *inp);
603
604/*-
605 * Null in last arg inpcb indicate run on ALL ep's. Specific inp in last arg
606 * indicates run on ONLY assoc's of the specified endpoint.
607 */
608int
609sctp_initiate_iterator(inp_func inpf,
610    asoc_func af,
611    inp_func inpe,
612    uint32_t, uint32_t,
613    uint32_t, void *,
614    uint32_t,
615    end_func ef,
616    struct sctp_inpcb *,
617    uint8_t co_off);
618
619#endif				/* _KERNEL */
620#endif				/* !__sctp_pcb_h__ */
621