PageRenderTime 52ms CodeModel.GetById 41ms RepoModel.GetById 1ms app.codeStats 1ms

/netinet/sctputil.c

https://bitbucket.org/brucec/sctpdrv
C | 7726 lines | 6422 code | 376 blank | 928 comment | 1694 complexity | 5b1ab6f6258d7e6de6120e6fe7ae9ca4 MD5 | raw file
    

  1. /*-

    2. 

  2.  * Copyright (c) 2001-2008, by Cisco Systems, Inc. All rights reserved.

    3. 

  3.  * Copyright (c) 2008-2012, by Randall Stewart. All rights reserved.

    4. 

  4.  * Copyright (c) 2008-2012, by Michael Tuexen. All rights reserved.

    5. 

  5.  *

    6. 

  6.  * Redistribution and use in source and binary forms, with or without

    7. 

  7.  * modification, are permitted provided that the following conditions are met:

    8. 

  8.  *

    9. 

  9.  * a) Redistributions of source code must retain the above copyright notice,

    10. 

  10.  *    this list of conditions and the following disclaimer.

    11. 

  11.  *

    12. 

  12.  * b) Redistributions in binary form must reproduce the above copyright

    13. 

  13.  *    notice, this list of conditions and the following disclaimer in

    14. 

  14.  *    the documentation and/or other materials provided with the distribution.

    15. 

  15.  *

    16. 

  16.  * c) Neither the name of Cisco Systems, Inc. nor the names of its

    17. 

  17.  *    contributors may be used to endorse or promote products derived

    18. 

  18.  *    from this software without specific prior written permission.

    19. 

  19.  *

    20. 

  20.  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

    21. 

  21.  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,

    22. 

  22.  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

    23. 

  23.  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE

    24. 

  24.  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR

    25. 

  25.  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF

    26. 

  26.  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS

    27. 

  27.  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN

    28. 

  28.  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)

    29. 

  29.  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF

    30. 

  30.  * THE POSSIBILITY OF SUCH DAMAGE.

    31. 

  31.  */

    32. 

  32. 

    33. 

  33. #ifdef __FreeBSD__

    34. 

  34. #include <sys/cdefs.h>

    35. 

  35. __FBSDID("$FreeBSD: head/sys/netinet/sctputil.c 235828 2012-05-23 11:26:28Z tuexen $");

    36. 

  36. #endif

    37. 

  37. 

    38. 

  38. #include <netinet/sctp_os.h>

    39. 

  39. #include <netinet/sctp_pcb.h>

    40. 

  40. #include <netinet/sctputil.h>

    41. 

  41. #include <netinet/sctp_var.h>

    42. 

  42. #include <netinet/sctp_sysctl.h>

    43. 

  43. #ifdef INET6

    44. 

  44. #if defined(__Userspace__)

    45. 

  45. #include <netinet6/sctp6_var.h>

    46. 

  46. #endif

    47. 

  47. #endif

    48. 

  48. #include <netinet/sctp_header.h>

    49. 

  49. #include <netinet/sctp_output.h>

    50. 

  50. #include <netinet/sctp_uio.h>

    51. 

  51. #include <netinet/sctp_timer.h>

    52. 

  52. #include <netinet/sctp_indata.h>/* for sctp_deliver_data() */

    53. 

  53. #include <netinet/sctp_auth.h>

    54. 

  54. #include <netinet/sctp_asconf.h>

    55. 

  55. #include <netinet/sctp_windows_addr.h>

    56. 

  56. #if defined(__Userspace__)

    57. 

  57. #include <netinet/sctp_constants.h>

    58. 

  58. #endif

    59. 

  59. 

    60. 

  60. #if defined(__APPLE__)

    61. 

  61. #define APPLE_FILE_NO 8

    62. 

  62. #endif

    63. 

  63. 

    64. 

  64. #if defined(__Windows__)

    65. 

  65. #if !defined(SCTP_LOCAL_TRACE_BUF)

    66. 

  66. #include "eventrace_netinet.h"

    67. 

  67. #include "sctputil.tmh" /* this is the file that will be auto generated */

    68. 

  68. #endif

    69. 

  69. #else

    70. 

  70. #ifndef KTR_SCTP

    71. 

  71. #define KTR_SCTP KTR_SUBSYS

    72. 

  72. #endif

    73. 

  73. #endif

    74. 

  74. 

    75. 

  75. extern struct sctp_cc_functions sctp_cc_functions[];

    76. 

  76. extern struct sctp_ss_functions sctp_ss_functions[];

    77. 

  77. 

    78. 

  78. void

    79. 

  79. sctp_sblog(struct sockbuf *sb,

    80. 

  80.     struct sctp_tcb *stcb, int from, int incr)

    81. 

  81. {

    82. 

  82. 	struct sctp_cwnd_log sctp_clog;

    83. 

  83. 

    84. 

  84. 	sctp_clog.x.sb.stcb = stcb;

    85. 

  85. 	sctp_clog.x.sb.so_sbcc = sb->sb_cc;

    86. 

  86. 	if (stcb)

    87. 

  87. 		sctp_clog.x.sb.stcb_sbcc = stcb->asoc.sb_cc;

    88. 

  88. 	else

    89. 

  89. 		sctp_clog.x.sb.stcb_sbcc = 0;

    90. 

  90. 	sctp_clog.x.sb.incr = incr;

    91. 

  91. 	SCTP_CTR6(KTR_SCTP, "SCTP:%d[%d]:%x-%x-%x-%x",

    92. 

  92. 	     SCTP_LOG_EVENT_SB,

    93. 

  93. 	     from,

    94. 

  94. 	     sctp_clog.x.misc.log1,

    95. 

  95. 	     sctp_clog.x.misc.log2,

    96. 

  96. 	     sctp_clog.x.misc.log3,

    97. 

  97. 	     sctp_clog.x.misc.log4);

    98. 

  98. }

    99. 

  99. 

    100. 

  100. void

    101. 

  101. sctp_log_closing(struct sctp_inpcb *inp, struct sctp_tcb *stcb, int16_t loc)

    102. 

  102. {

    103. 

  103. 	struct sctp_cwnd_log sctp_clog;

    104. 

  104. 

    105. 

  105. 	sctp_clog.x.close.inp = (void *)inp;

    106. 

  106. 	sctp_clog.x.close.sctp_flags = inp->sctp_flags;

    107. 

  107. 	if (stcb) {

    108. 

  108. 		sctp_clog.x.close.stcb = (void *)stcb;

    109. 

  109. 		sctp_clog.x.close.state = (uint16_t)stcb->asoc.state;

    110. 

  110. 	} else {

    111. 

  111. 		sctp_clog.x.close.stcb = 0;

    112. 

  112. 		sctp_clog.x.close.state = 0;

    113. 

  113. 	}

    114. 

  114. 	sctp_clog.x.close.loc = loc;

    115. 

  115. 	SCTP_CTR6(KTR_SCTP, "SCTP:%d[%d]:%x-%x-%x-%x",

    116. 

  116. 	     SCTP_LOG_EVENT_CLOSE,

    117. 

  117. 	     0,

    118. 

  118. 	     sctp_clog.x.misc.log1,

    119. 

  119. 	     sctp_clog.x.misc.log2,

    120. 

  120. 	     sctp_clog.x.misc.log3,

    121. 

  121. 	     sctp_clog.x.misc.log4);

    122. 

  122. }

    123. 

  123. 

    124. 

  124. 

    125. 

  125. void

    126. 

  126. rto_logging(struct sctp_nets *net, int from)

    127. 

  127. {

    128. 

  128. 	struct sctp_cwnd_log sctp_clog;

    129. 

  129. 

    130. 

  130. 	memset(&sctp_clog, 0, sizeof(sctp_clog));

    131. 

  131. 	sctp_clog.x.rto.net = (void *) net;

    132. 

  132. 	sctp_clog.x.rto.rtt = net->rtt / 1000;

    133. 

  133. 	SCTP_CTR6(KTR_SCTP, "SCTP:%d[%d]:%x-%x-%x-%x",

    134. 

  134. 	     SCTP_LOG_EVENT_RTT,

    135. 

  135. 	     from,

    136. 

  136. 	     sctp_clog.x.misc.log1,

    137. 

  137. 	     sctp_clog.x.misc.log2,

    138. 

  138. 	     sctp_clog.x.misc.log3,

    139. 

  139. 	     sctp_clog.x.misc.log4);

    140. 

  140. }

    141. 

  141. 

    142. 

  142. void

    143. 

  143. sctp_log_strm_del_alt(struct sctp_tcb *stcb, uint32_t tsn, uint16_t sseq, uint16_t stream, int from)

    144. 

  144. {

    145. 

  145. 	struct sctp_cwnd_log sctp_clog;

    146. 

  146. 

    147. 

  147. 	sctp_clog.x.strlog.stcb = stcb;

    148. 

  148. 	sctp_clog.x.strlog.n_tsn = tsn;

    149. 

  149. 	sctp_clog.x.strlog.n_sseq = sseq;

    150. 

  150. 	sctp_clog.x.strlog.e_tsn = 0;

    151. 

  151. 	sctp_clog.x.strlog.e_sseq = 0;

    152. 

  152. 	sctp_clog.x.strlog.strm = stream;

    153. 

  153. 	SCTP_CTR6(KTR_SCTP, "SCTP:%d[%d]:%x-%x-%x-%x",

    154. 

  154. 	     SCTP_LOG_EVENT_STRM,

    155. 

  155. 	     from,

    156. 

  156. 	     sctp_clog.x.misc.log1,

    157. 

  157. 	     sctp_clog.x.misc.log2,

    158. 

  158. 	     sctp_clog.x.misc.log3,

    159. 

  159. 	     sctp_clog.x.misc.log4);

    160. 

  160. }

    161. 

  161. 

    162. 

  162. void

    163. 

  163. sctp_log_nagle_event(struct sctp_tcb *stcb, int action)

    164. 

  164. {

    165. 

  165. 	struct sctp_cwnd_log sctp_clog;

    166. 

  166. 

    167. 

  167. 	sctp_clog.x.nagle.stcb = (void *)stcb;

    168. 

  168. 	sctp_clog.x.nagle.total_flight = stcb->asoc.total_flight;

    169. 

  169. 	sctp_clog.x.nagle.total_in_queue = stcb->asoc.total_output_queue_size;

    170. 

  170. 	sctp_clog.x.nagle.count_in_queue = stcb->asoc.chunks_on_out_queue;

    171. 

  171. 	sctp_clog.x.nagle.count_in_flight = stcb->asoc.total_flight_count;

    172. 

  172. 	SCTP_CTR6(KTR_SCTP, "SCTP:%d[%d]:%x-%x-%x-%x",

    173. 

  173. 	     SCTP_LOG_EVENT_NAGLE,

    174. 

  174. 	     action,

    175. 

  175. 	     sctp_clog.x.misc.log1,

    176. 

  176. 	     sctp_clog.x.misc.log2,

    177. 

  177. 	     sctp_clog.x.misc.log3,

    178. 

  178. 	     sctp_clog.x.misc.log4);

    179. 

  179. }

    180. 

  180. 

    181. 

  181. void

    182. 

  182. sctp_log_sack(uint32_t old_cumack, uint32_t cumack, uint32_t tsn, uint16_t gaps, uint16_t dups, int from)

    183. 

  183. {

    184. 

  184. 	struct sctp_cwnd_log sctp_clog;

    185. 

  185. 

    186. 

  186. 	sctp_clog.x.sack.cumack = cumack;

    187. 

  187. 	sctp_clog.x.sack.oldcumack = old_cumack;

    188. 

  188. 	sctp_clog.x.sack.tsn = tsn;

    189. 

  189. 	sctp_clog.x.sack.numGaps = gaps;

    190. 

  190. 	sctp_clog.x.sack.numDups = dups;

    191. 

  191. 	SCTP_CTR6(KTR_SCTP, "SCTP:%d[%d]:%x-%x-%x-%x",

    192. 

  192. 	     SCTP_LOG_EVENT_SACK,

    193. 

  193. 	     from,

    194. 

  194. 	     sctp_clog.x.misc.log1,

    195. 

  195. 	     sctp_clog.x.misc.log2,

    196. 

  196. 	     sctp_clog.x.misc.log3,

    197. 

  197. 	     sctp_clog.x.misc.log4);

    198. 

  198. }

    199. 

  199. 

    200. 

  200. void

    201. 

  201. sctp_log_map(uint32_t map, uint32_t cum, uint32_t high, int from)

    202. 

  202. {

    203. 

  203. 	struct sctp_cwnd_log sctp_clog;

    204. 

  204. 

    205. 

  205. 	memset(&sctp_clog, 0, sizeof(sctp_clog));

    206. 

  206. 	sctp_clog.x.map.base = map;

    207. 

  207. 	sctp_clog.x.map.cum = cum;

    208. 

  208. 	sctp_clog.x.map.high = high;

    209. 

  209. 	SCTP_CTR6(KTR_SCTP, "SCTP:%d[%d]:%x-%x-%x-%x",

    210. 

  210. 	     SCTP_LOG_EVENT_MAP,

    211. 

  211. 	     from,

    212. 

  212. 	     sctp_clog.x.misc.log1,

    213. 

  213. 	     sctp_clog.x.misc.log2,

    214. 

  214. 	     sctp_clog.x.misc.log3,

    215. 

  215. 	     sctp_clog.x.misc.log4);

    216. 

  216. }

    217. 

  217. 

    218. 

  218. void

    219. 

  219. sctp_log_fr(uint32_t biggest_tsn, uint32_t biggest_new_tsn, uint32_t tsn,

    220. 

  220.     int from)

    221. 

  221. {

    222. 

  222. 	struct sctp_cwnd_log sctp_clog;

    223. 

  223. 

    224. 

  224. 	memset(&sctp_clog, 0, sizeof(sctp_clog));

    225. 

  225. 	sctp_clog.x.fr.largest_tsn = biggest_tsn;

    226. 

  226. 	sctp_clog.x.fr.largest_new_tsn = biggest_new_tsn;

    227. 

  227. 	sctp_clog.x.fr.tsn = tsn;

    228. 

  228. 	SCTP_CTR6(KTR_SCTP, "SCTP:%d[%d]:%x-%x-%x-%x",

    229. 

  229. 	     SCTP_LOG_EVENT_FR,

    230. 

  230. 	     from,

    231. 

  231. 	     sctp_clog.x.misc.log1,

    232. 

  232. 	     sctp_clog.x.misc.log2,

    233. 

  233. 	     sctp_clog.x.misc.log3,

    234. 

  234. 	     sctp_clog.x.misc.log4);

    235. 

  235. }

    236. 

  236. 

    237. 

  237. void

    238. 

  238. sctp_log_mb(struct mbuf *m, int from)

    239. 

  239. {

    240. 

  240. 	struct sctp_cwnd_log sctp_clog;

    241. 

  241. 

    242. 

  242. 	sctp_clog.x.mb.mp = m;

    243. 

  243. 	sctp_clog.x.mb.mbuf_flags = (uint8_t)(SCTP_BUF_GET_FLAGS(m));

    244. 

  244. 	sctp_clog.x.mb.size = (uint16_t)(SCTP_BUF_LEN(m));

    245. 

  245. 	sctp_clog.x.mb.data = SCTP_BUF_AT(m, 0);

    246. 

  246. 	if (SCTP_BUF_IS_EXTENDED(m)) {

    247. 

  247. 		sctp_clog.x.mb.ext = SCTP_BUF_EXTEND_BASE(m);

    248. 

  248. #if defined(__APPLE__)

    249. 

  249. 		/* APPLE does not use a ref_cnt, but a forward/backward ref queue */

    250. 

  250. #else

    251. 

  251. 		sctp_clog.x.mb.refcnt = (uint8_t)(SCTP_BUF_EXTEND_REFCNT(m));

    252. 

  252. #endif

    253. 

  253. 	} else {

    254. 

  254. 		sctp_clog.x.mb.ext = 0;

    255. 

  255. 		sctp_clog.x.mb.refcnt = 0;

    256. 

  256. 	}

    257. 

  257. 	SCTP_CTR6(KTR_SCTP, "SCTP:%d[%d]:%x-%x-%x-%x",

    258. 

  258. 	     SCTP_LOG_EVENT_MBUF,

    259. 

  259. 	     from,

    260. 

  260. 	     sctp_clog.x.misc.log1,

    261. 

  261. 	     sctp_clog.x.misc.log2,

    262. 

  262. 	     sctp_clog.x.misc.log3,

    263. 

  263. 	     sctp_clog.x.misc.log4);

    264. 

  264. }

    265. 

  265. 

    266. 

  266. void

    267. 

  267. sctp_log_strm_del(struct sctp_queued_to_read *control, struct sctp_queued_to_read *poschk,

    268. 

  268.     int from)

    269. 

  269. {

    270. 

  270. 	struct sctp_cwnd_log sctp_clog;

    271. 

  271. 

    272. 

  272. 	if (control == NULL) {

    273. 

  273. 		SCTP_PRINTF("Gak log of NULL?\n");

    274. 

  274. 		return;

    275. 

  275. 	}

    276. 

  276. 	sctp_clog.x.strlog.stcb = control->stcb;

    277. 

  277. 	sctp_clog.x.strlog.n_tsn = control->sinfo_tsn;

    278. 

  278. 	sctp_clog.x.strlog.n_sseq = control->sinfo_ssn;

    279. 

  279. 	sctp_clog.x.strlog.strm = control->sinfo_stream;

    280. 

  280. 	if (poschk != NULL) {

    281. 

  281. 		sctp_clog.x.strlog.e_tsn = poschk->sinfo_tsn;

    282. 

  282. 		sctp_clog.x.strlog.e_sseq = poschk->sinfo_ssn;

    283. 

  283. 	} else {

    284. 

  284. 		sctp_clog.x.strlog.e_tsn = 0;

    285. 

  285. 		sctp_clog.x.strlog.e_sseq = 0;

    286. 

  286. 	}

    287. 

  287. 	SCTP_CTR6(KTR_SCTP, "SCTP:%d[%d]:%x-%x-%x-%x",

    288. 

  288. 	     SCTP_LOG_EVENT_STRM,

    289. 

  289. 	     from,

    290. 

  290. 	     sctp_clog.x.misc.log1,

    291. 

  291. 	     sctp_clog.x.misc.log2,

    292. 

  292. 	     sctp_clog.x.misc.log3,

    293. 

  293. 	     sctp_clog.x.misc.log4);

    294. 

  294. }

    295. 

  295. 

    296. 

  296. void

    297. 

  297. sctp_log_cwnd(struct sctp_tcb *stcb, struct sctp_nets *net, int augment, uint8_t from)

    298. 

  298. {

    299. 

  299. 	struct sctp_cwnd_log sctp_clog;

    300. 

  300. 

    301. 

  301. 	sctp_clog.x.cwnd.net = net;

    302. 

  302. 	if (stcb->asoc.send_queue_cnt > 255)

    303. 

  303. 		sctp_clog.x.cwnd.cnt_in_send = 255;

    304. 

  304. 	else

    305. 

  305. 		sctp_clog.x.cwnd.cnt_in_send = stcb->asoc.send_queue_cnt;

    306. 

  306. 	if (stcb->asoc.stream_queue_cnt > 255)

    307. 

  307. 		sctp_clog.x.cwnd.cnt_in_str = 255;

    308. 

  308. 	else

    309. 

  309. 		sctp_clog.x.cwnd.cnt_in_str = stcb->asoc.stream_queue_cnt;

    310. 

  310. 

    311. 

  311. 	if (net) {

    312. 

  312. 		sctp_clog.x.cwnd.cwnd_new_value = net->cwnd;

    313. 

  313. 		sctp_clog.x.cwnd.inflight = net->flight_size;

    314. 

  314. 		sctp_clog.x.cwnd.pseudo_cumack = net->pseudo_cumack;

    315. 

  315. 		sctp_clog.x.cwnd.meets_pseudo_cumack = net->new_pseudo_cumack;

    316. 

  316. 		sctp_clog.x.cwnd.need_new_pseudo_cumack = net->find_pseudo_cumack;

    317. 

  317. 	}

    318. 

  318. 	if (SCTP_CWNDLOG_PRESEND == from) {

    319. 

  319. 		sctp_clog.x.cwnd.meets_pseudo_cumack = stcb->asoc.peers_rwnd;

    320. 

  320. 	}

    321. 

  321. 	sctp_clog.x.cwnd.cwnd_augment = augment;

    322. 

  322. 	SCTP_CTR6(KTR_SCTP, "SCTP:%d[%d]:%x-%x-%x-%x",

    323. 

  323. 	     SCTP_LOG_EVENT_CWND,

    324. 

  324. 	     from,

    325. 

  325. 	     sctp_clog.x.misc.log1,

    326. 

  326. 	     sctp_clog.x.misc.log2,

    327. 

  327. 	     sctp_clog.x.misc.log3,

    328. 

  328. 	     sctp_clog.x.misc.log4);

    329. 

  329. }

    330. 

  330. 

    331. 

  331. #ifndef __APPLE__

    332. 

  332. void

    333. 

  333. sctp_log_lock(struct sctp_inpcb *inp, struct sctp_tcb *stcb, uint8_t from)

    334. 

  334. {

    335. 

  335. 	struct sctp_cwnd_log sctp_clog;

    336. 

  336. 

    337. 

  337. 	memset(&sctp_clog, 0, sizeof(sctp_clog));

    338. 

  338. 	if (inp) {

    339. 

  339.  		sctp_clog.x.lock.sock = (void *) inp->sctp_socket;

    340. 

  340. 

    341. 

  341. 	} else {

    342. 

  342.  		sctp_clog.x.lock.sock = (void *) NULL;

    343. 

  343. 	}

    344. 

  344. 	sctp_clog.x.lock.inp = (void *) inp;

    345. 

  345. #if (defined(__FreeBSD__) && __FreeBSD_version >= 503000) || (defined(__APPLE__))

    346. 

  346. 	if (stcb) {

    347. 

  347. 		sctp_clog.x.lock.tcb_lock = mtx_owned(&stcb->tcb_mtx);

    348. 

  348. 	} else {

    349. 

  349. 		sctp_clog.x.lock.tcb_lock = SCTP_LOCK_UNKNOWN;

    350. 

  350. 	}

    351. 

  351. 	if (inp) {

    352. 

  352. 		sctp_clog.x.lock.inp_lock = mtx_owned(&inp->inp_mtx);

    353. 

  353. 		sctp_clog.x.lock.create_lock = mtx_owned(&inp->inp_create_mtx);

    354. 

  354. 	} else {

    355. 

  355. 		sctp_clog.x.lock.inp_lock = SCTP_LOCK_UNKNOWN;

    356. 

  356. 		sctp_clog.x.lock.create_lock = SCTP_LOCK_UNKNOWN;

    357. 

  357. 	}

    358. 

  358. #if (defined(__FreeBSD__) && __FreeBSD_version <= 602000)

    359. 

  359. 	sctp_clog.x.lock.info_lock = mtx_owned(&SCTP_BASE_INFO(ipi_ep_mtx));

    360. 

  360. #else

    361. 

  361. 	sctp_clog.x.lock.info_lock = rw_wowned(&SCTP_BASE_INFO(ipi_ep_mtx));

    362. 

  362. #endif

    363. 

  363. 	if (inp && (inp->sctp_socket)) {

    364. 

  364. 		sctp_clog.x.lock.sock_lock = mtx_owned(&(inp->sctp_socket->so_rcv.sb_mtx));

    365. 

  365. 		sctp_clog.x.lock.sockrcvbuf_lock = mtx_owned(&(inp->sctp_socket->so_rcv.sb_mtx));

    366. 

  366. 		sctp_clog.x.lock.socksndbuf_lock = mtx_owned(&(inp->sctp_socket->so_snd.sb_mtx));

    367. 

  367. 	} else {

    368. 

  368. 		sctp_clog.x.lock.sock_lock = SCTP_LOCK_UNKNOWN;

    369. 

  369. 		sctp_clog.x.lock.sockrcvbuf_lock = SCTP_LOCK_UNKNOWN;

    370. 

  370. 		sctp_clog.x.lock.socksndbuf_lock = SCTP_LOCK_UNKNOWN;

    371. 

  371. 	}

    372. 

  372. #endif

    373. 

  373. 	SCTP_CTR6(KTR_SCTP, "SCTP:%d[%d]:%x-%x-%x-%x",

    374. 

  374. 	     SCTP_LOG_LOCK_EVENT,

    375. 

  375. 	     from,

    376. 

  376. 	     sctp_clog.x.misc.log1,

    377. 

  377. 	     sctp_clog.x.misc.log2,

    378. 

  378. 	     sctp_clog.x.misc.log3,

    379. 

  379. 	     sctp_clog.x.misc.log4);

    380. 

  380. }

    381. 

  381. #endif

    382. 

  382. 

    383. 

  383. void

    384. 

  384. sctp_log_maxburst(struct sctp_tcb *stcb, struct sctp_nets *net, int error, int burst, uint8_t from)

    385. 

  385. {

    386. 

  386. 	struct sctp_cwnd_log sctp_clog;

    387. 

  387. 

    388. 

  388. 	memset(&sctp_clog, 0, sizeof(sctp_clog));

    389. 

  389. 	sctp_clog.x.cwnd.net = net;

    390. 

  390. 	sctp_clog.x.cwnd.cwnd_new_value = error;

    391. 

  391. 	sctp_clog.x.cwnd.inflight = net->flight_size;

    392. 

  392. 	sctp_clog.x.cwnd.cwnd_augment = burst;

    393. 

  393. 	if (stcb->asoc.send_queue_cnt > 255)

    394. 

  394. 		sctp_clog.x.cwnd.cnt_in_send = 255;

    395. 

  395. 	else

    396. 

  396. 		sctp_clog.x.cwnd.cnt_in_send = stcb->asoc.send_queue_cnt;

    397. 

  397. 	if (stcb->asoc.stream_queue_cnt > 255)

    398. 

  398. 		sctp_clog.x.cwnd.cnt_in_str = 255;

    399. 

  399. 	else

    400. 

  400. 		sctp_clog.x.cwnd.cnt_in_str = stcb->asoc.stream_queue_cnt;

    401. 

  401. 	SCTP_CTR6(KTR_SCTP, "SCTP:%d[%d]:%x-%x-%x-%x",

    402. 

  402. 	     SCTP_LOG_EVENT_MAXBURST,

    403. 

  403. 	     from,

    404. 

  404. 	     sctp_clog.x.misc.log1,

    405. 

  405. 	     sctp_clog.x.misc.log2,

    406. 

  406. 	     sctp_clog.x.misc.log3,

    407. 

  407. 	     sctp_clog.x.misc.log4);

    408. 

  408. }

    409. 

  409. 

    410. 

  410. void

    411. 

  411. sctp_log_rwnd(uint8_t from, uint32_t peers_rwnd, uint32_t snd_size, uint32_t overhead)

    412. 

  412. {

    413. 

  413. 	struct sctp_cwnd_log sctp_clog;

    414. 

  414. 

    415. 

  415. 	sctp_clog.x.rwnd.rwnd = peers_rwnd;

    416. 

  416. 	sctp_clog.x.rwnd.send_size = snd_size;

    417. 

  417. 	sctp_clog.x.rwnd.overhead = overhead;

    418. 

  418. 	sctp_clog.x.rwnd.new_rwnd = 0;

    419. 

  419. 	SCTP_CTR6(KTR_SCTP, "SCTP:%d[%d]:%x-%x-%x-%x",

    420. 

  420. 	     SCTP_LOG_EVENT_RWND,

    421. 

  421. 	     from,

    422. 

  422. 	     sctp_clog.x.misc.log1,

    423. 

  423. 	     sctp_clog.x.misc.log2,

    424. 

  424. 	     sctp_clog.x.misc.log3,

    425. 

  425. 	     sctp_clog.x.misc.log4);

    426. 

  426. }

    427. 

  427. 

    428. 

  428. void

    429. 

  429. sctp_log_rwnd_set(uint8_t from, uint32_t peers_rwnd, uint32_t flight_size, uint32_t overhead, uint32_t a_rwndval)

    430. 

  430. {

    431. 

  431. 	struct sctp_cwnd_log sctp_clog;

    432. 

  432. 

    433. 

  433. 	sctp_clog.x.rwnd.rwnd = peers_rwnd;

    434. 

  434. 	sctp_clog.x.rwnd.send_size = flight_size;

    435. 

  435. 	sctp_clog.x.rwnd.overhead = overhead;

    436. 

  436. 	sctp_clog.x.rwnd.new_rwnd = a_rwndval;

    437. 

  437. 	SCTP_CTR6(KTR_SCTP, "SCTP:%d[%d]:%x-%x-%x-%x",

    438. 

  438. 	     SCTP_LOG_EVENT_RWND,

    439. 

  439. 	     from,

    440. 

  440. 	     sctp_clog.x.misc.log1,

    441. 

  441. 	     sctp_clog.x.misc.log2,

    442. 

  442. 	     sctp_clog.x.misc.log3,

    443. 

  443. 	     sctp_clog.x.misc.log4);

    444. 

  444. }

    445. 

  445. 

    446. 

  446. void

    447. 

  447. sctp_log_mbcnt(uint8_t from, uint32_t total_oq, uint32_t book, uint32_t total_mbcnt_q, uint32_t mbcnt)

    448. 

  448. {

    449. 

  449. 	struct sctp_cwnd_log sctp_clog;

    450. 

  450. 

    451. 

  451. 	sctp_clog.x.mbcnt.total_queue_size = total_oq;

    452. 

  452. 	sctp_clog.x.mbcnt.size_change = book;

    453. 

  453. 	sctp_clog.x.mbcnt.total_queue_mb_size = total_mbcnt_q;

    454. 

  454. 	sctp_clog.x.mbcnt.mbcnt_change = mbcnt;

    455. 

  455. 	SCTP_CTR6(KTR_SCTP, "SCTP:%d[%d]:%x-%x-%x-%x",

    456. 

  456. 	     SCTP_LOG_EVENT_MBCNT,

    457. 

  457. 	     from,

    458. 

  458. 	     sctp_clog.x.misc.log1,

    459. 

  459. 	     sctp_clog.x.misc.log2,

    460. 

  460. 	     sctp_clog.x.misc.log3,

    461. 

  461. 	     sctp_clog.x.misc.log4);

    462. 

  462. }

    463. 

  463. 

    464. 

  464. void

    465. 

  465. sctp_misc_ints(uint8_t from, uint32_t a, uint32_t b, uint32_t c, uint32_t d)

    466. 

  466. {

    467. 

  467. 	SCTP_CTR6(KTR_SCTP, "SCTP:%d[%d]:%x-%x-%x-%x",

    468. 

  468. 	     SCTP_LOG_MISC_EVENT,

    469. 

  469. 	     from,

    470. 

  470. 	     a, b, c, d);

    471. 

  471. }

    472. 

  472. 

    473. 

  473. void

    474. 

  474. sctp_wakeup_log(struct sctp_tcb *stcb, uint32_t wake_cnt, int from)

    475. 

  475. {

    476. 

  476. 	struct sctp_cwnd_log sctp_clog;

    477. 

  477. 

    478. 

  478. 	sctp_clog.x.wake.stcb = (void *)stcb;

    479. 

  479. 	sctp_clog.x.wake.wake_cnt = wake_cnt;

    480. 

  480. 	sctp_clog.x.wake.flight = stcb->asoc.total_flight_count;

    481. 

  481. 	sctp_clog.x.wake.send_q = stcb->asoc.send_queue_cnt;

    482. 

  482. 	sctp_clog.x.wake.sent_q = stcb->asoc.sent_queue_cnt;

    483. 

  483. 

    484. 

  484. 	if (stcb->asoc.stream_queue_cnt < 0xff)

    485. 

  485. 		sctp_clog.x.wake.stream_qcnt = (uint8_t) stcb->asoc.stream_queue_cnt;

    486. 

  486. 	else

    487. 

  487. 		sctp_clog.x.wake.stream_qcnt = 0xff;

    488. 

  488. 

    489. 

  489. 	if (stcb->asoc.chunks_on_out_queue < 0xff)

    490. 

  490. 		sctp_clog.x.wake.chunks_on_oque = (uint8_t) stcb->asoc.chunks_on_out_queue;

    491. 

  491. 	else

    492. 

  492. 		sctp_clog.x.wake.chunks_on_oque = 0xff;

    493. 

  493. 

    494. 

  494. 	sctp_clog.x.wake.sctpflags = 0;

    495. 

  495. 	/* set in the defered mode stuff */

    496. 

  496. 	if (stcb->sctp_ep->sctp_flags & SCTP_PCB_FLAGS_DONT_WAKE)

    497. 

  497. 		sctp_clog.x.wake.sctpflags |= 1;

    498. 

  498. 	if (stcb->sctp_ep->sctp_flags & SCTP_PCB_FLAGS_WAKEOUTPUT)

    499. 

  499. 		sctp_clog.x.wake.sctpflags |= 2;

    500. 

  500. 	if (stcb->sctp_ep->sctp_flags & SCTP_PCB_FLAGS_WAKEINPUT)

    501. 

  501. 		sctp_clog.x.wake.sctpflags |= 4;

    502. 

  502.         /* what about the sb */

    503. 

  503. 	if (stcb->sctp_socket) {

    504. 

  504. 		struct socket *so = stcb->sctp_socket;

    505. 

  505. 

    506. 

  506. 		sctp_clog.x.wake.sbflags = (uint8_t)((so->so_snd.sb_flags & 0x00ff));

    507. 

  507. 	} else {

    508. 

  508. 		sctp_clog.x.wake.sbflags = 0xff;

    509. 

  509. 	}

    510. 

  510. 	SCTP_CTR6(KTR_SCTP, "SCTP:%d[%d]:%x-%x-%x-%x",

    511. 

  511. 	     SCTP_LOG_EVENT_WAKE,

    512. 

  512. 	     from,

    513. 

  513. 	     sctp_clog.x.misc.log1,

    514. 

  514. 	     sctp_clog.x.misc.log2,

    515. 

  515. 	     sctp_clog.x.misc.log3,

    516. 

  516. 	     sctp_clog.x.misc.log4);

    517. 

  517. }

    518. 

  518. 

    519. 

  519. void

    520. 

  520. sctp_log_block(uint8_t from, struct sctp_association *asoc, int sendlen)

    521. 

  521. {

    522. 

  522. 	struct sctp_cwnd_log sctp_clog;

    523. 

  523. 

    524. 

  524. 	sctp_clog.x.blk.onsb = asoc->total_output_queue_size;

    525. 

  525. 	sctp_clog.x.blk.send_sent_qcnt = (uint16_t) (asoc->send_queue_cnt + asoc->sent_queue_cnt);

    526. 

  526. 	sctp_clog.x.blk.peer_rwnd = asoc->peers_rwnd;

    527. 

  527. 	sctp_clog.x.blk.stream_qcnt = (uint16_t) asoc->stream_queue_cnt;

    528. 

  528. 	sctp_clog.x.blk.chunks_on_oque = (uint16_t) asoc->chunks_on_out_queue;

    529. 

  529. 	sctp_clog.x.blk.flight_size = (uint16_t) (asoc->total_flight/1024);

    530. 

  530. 	sctp_clog.x.blk.sndlen = sendlen;

    531. 

  531. 	SCTP_CTR6(KTR_SCTP, "SCTP:%d[%d]:%x-%x-%x-%x",

    532. 

  532. 	     SCTP_LOG_EVENT_BLOCK,

    533. 

  533. 	     from,

    534. 

  534. 	     sctp_clog.x.misc.log1,

    535. 

  535. 	     sctp_clog.x.misc.log2,

    536. 

  536. 	     sctp_clog.x.misc.log3,

    537. 

  537. 	     sctp_clog.x.misc.log4);

    538. 

  538. }

    539. 

  539. 

    540. 

  540. int

    541. 

  541. sctp_fill_stat_log(void *optval SCTP_UNUSED, size_t *optsize SCTP_UNUSED)

    542. 

  542. {

    543. 

  543. 	/* May need to fix this if ktrdump does not work */

    544. 

  544. 	return (0);

    545. 

  545. }

    546. 

  546. 

    547. 

  547. #ifdef SCTP_AUDITING_ENABLED

    548. 

  548. uint8_t sctp_audit_data[SCTP_AUDIT_SIZE][2];

    549. 

  549. static int sctp_audit_indx = 0;

    550. 

  550. 

    551. 

  551. static

    552. 

  552. void

    553. 

  553. sctp_print_audit_report(void)

    554. 

  554. {

    555. 

  555. 	int i;

    556. 

  556. 	int cnt;

    557. 

  557. 

    558. 

  558. 	cnt = 0;

    559. 

  559. 	for (i = sctp_audit_indx; i < SCTP_AUDIT_SIZE; i++) {

    560. 

  560. 		if ((sctp_audit_data[i][0] == 0xe0) &&

    561. 

  561. 		    (sctp_audit_data[i][1] == 0x01)) {

    562. 

  562. 			cnt = 0;

    563. 

  563. 			SCTP_PRINTF("\n");

    564. 

  564. 		} else if (sctp_audit_data[i][0] == 0xf0) {

    565. 

  565. 			cnt = 0;

    566. 

  566. 			SCTP_PRINTF("\n");

    567. 

  567. 		} else if ((sctp_audit_data[i][0] == 0xc0) &&

    568. 

  568. 		    (sctp_audit_data[i][1] == 0x01)) {

    569. 

  569. 			SCTP_PRINTF("\n");

    570. 

  570. 			cnt = 0;

    571. 

  571. 		}

    572. 

  572. 		SCTP_PRINTF("%2.2x%2.2x ", (uint32_t) sctp_audit_data[i][0],

    573. 

  573. 			    (uint32_t) sctp_audit_data[i][1]);

    574. 

  574. 		cnt++;

    575. 

  575. 		if ((cnt % 14) == 0)

    576. 

  576. 			SCTP_PRINTF("\n");

    577. 

  577. 	}

    578. 

  578. 	for (i = 0; i < sctp_audit_indx; i++) {

    579. 

  579. 		if ((sctp_audit_data[i][0] == 0xe0) &&

    580. 

  580. 		    (sctp_audit_data[i][1] == 0x01)) {

    581. 

  581. 			cnt = 0;

    582. 

  582. 			SCTP_PRINTF("\n");

    583. 

  583. 		} else if (sctp_audit_data[i][0] == 0xf0) {

    584. 

  584. 			cnt = 0;

    585. 

  585. 			SCTP_PRINTF("\n");

    586. 

  586. 		} else if ((sctp_audit_data[i][0] == 0xc0) &&

    587. 

  587. 		    (sctp_audit_data[i][1] == 0x01)) {

    588. 

  588. 			SCTP_PRINTF("\n");

    589. 

  589. 			cnt = 0;

    590. 

  590. 		}

    591. 

  591. 		SCTP_PRINTF("%2.2x%2.2x ", (uint32_t) sctp_audit_data[i][0],

    592. 

  592. 			    (uint32_t) sctp_audit_data[i][1]);

    593. 

  593. 		cnt++;

    594. 

  594. 		if ((cnt % 14) == 0)

    595. 

  595. 			SCTP_PRINTF("\n");

    596. 

  596. 	}

    597. 

  597. 	SCTP_PRINTF("\n");

    598. 

  598. }

    599. 

  599. 

    600. 

  600. void

    601. 

  601. sctp_auditing(int from, struct sctp_inpcb *inp, struct sctp_tcb *stcb,

    602. 

  602.     struct sctp_nets *net)

    603. 

  603. {

    604. 

  604. 	int resend_cnt, tot_out, rep, tot_book_cnt;

    605. 

  605. 	struct sctp_nets *lnet;

    606. 

  606. 	struct sctp_tmit_chunk *chk;

    607. 

  607. 

    608. 

  608. 	sctp_audit_data[sctp_audit_indx][0] = 0xAA;

    609. 

  609. 	sctp_audit_data[sctp_audit_indx][1] = 0x000000ff & from;

    610. 

  610. 	sctp_audit_indx++;

    611. 

  611. 	if (sctp_audit_indx >= SCTP_AUDIT_SIZE) {

    612. 

  612. 		sctp_audit_indx = 0;

    613. 

  613. 	}

    614. 

  614. 	if (inp == NULL) {

    615. 

  615. 		sctp_audit_data[sctp_audit_indx][0] = 0xAF;

    616. 

  616. 		sctp_audit_data[sctp_audit_indx][1] = 0x01;

    617. 

  617. 		sctp_audit_indx++;

    618. 

  618. 		if (sctp_audit_indx >= SCTP_AUDIT_SIZE) {

    619. 

  619. 			sctp_audit_indx = 0;

    620. 

  620. 		}

    621. 

  621. 		return;

    622. 

  622. 	}

    623. 

  623. 	if (stcb == NULL) {

    624. 

  624. 		sctp_audit_data[sctp_audit_indx][0] = 0xAF;

    625. 

  625. 		sctp_audit_data[sctp_audit_indx][1] = 0x02;

    626. 

  626. 		sctp_audit_indx++;

    627. 

  627. 		if (sctp_audit_indx >= SCTP_AUDIT_SIZE) {

    628. 

  628. 			sctp_audit_indx = 0;

    629. 

  629. 		}

    630. 

  630. 		return;

    631. 

  631. 	}

    632. 

  632. 	sctp_audit_data[sctp_audit_indx][0] = 0xA1;

    633. 

  633. 	sctp_audit_data[sctp_audit_indx][1] =

    634. 

  634. 	    (0x000000ff & stcb->asoc.sent_queue_retran_cnt);

    635. 

  635. 	sctp_audit_indx++;

    636. 

  636. 	if (sctp_audit_indx >= SCTP_AUDIT_SIZE) {

    637. 

  637. 		sctp_audit_indx = 0;

    638. 

  638. 	}

    639. 

  639. 	rep = 0;

    640. 

  640. 	tot_book_cnt = 0;

    641. 

  641. 	resend_cnt = tot_out = 0;

    642. 

  642. 	TAILQ_FOREACH(chk, &stcb->asoc.sent_queue, sctp_next) {

    643. 

  643. 		if (chk->sent == SCTP_DATAGRAM_RESEND) {

    644. 

  644. 			resend_cnt++;

    645. 

  645. 		} else if (chk->sent < SCTP_DATAGRAM_RESEND) {

    646. 

  646. 			tot_out += chk->book_size;

    647. 

  647. 			tot_book_cnt++;

    648. 

  648. 		}

    649. 

  649. 	}

    650. 

  650. 	if (resend_cnt != stcb->asoc.sent_queue_retran_cnt) {

    651. 

  651. 		sctp_audit_data[sctp_audit_indx][0] = 0xAF;

    652. 

  652. 		sctp_audit_data[sctp_audit_indx][1] = 0xA1;

    653. 

  653. 		sctp_audit_indx++;

    654. 

  654. 		if (sctp_audit_indx >= SCTP_AUDIT_SIZE) {

    655. 

  655. 			sctp_audit_indx = 0;

    656. 

  656. 		}

    657. 

  657. 		SCTP_PRINTF("resend_cnt:%d asoc-tot:%d\n",

    658. 

  658. 			    resend_cnt, stcb->asoc.sent_queue_retran_cnt);

    659. 

  659. 		rep = 1;

    660. 

  660. 		stcb->asoc.sent_queue_retran_cnt = resend_cnt;

    661. 

  661. 		sctp_audit_data[sctp_audit_indx][0] = 0xA2;

    662. 

  662. 		sctp_audit_data[sctp_audit_indx][1] =

    663. 

  663. 		    (0x000000ff & stcb->asoc.sent_queue_retran_cnt);

    664. 

  664. 		sctp_audit_indx++;

    665. 

  665. 		if (sctp_audit_indx >= SCTP_AUDIT_SIZE) {

    666. 

  666. 			sctp_audit_indx = 0;

    667. 

  667. 		}

    668. 

  668. 	}

    669. 

  669. 	if (tot_out != stcb->asoc.total_flight) {

    670. 

  670. 		sctp_audit_data[sctp_audit_indx][0] = 0xAF;

    671. 

  671. 		sctp_audit_data[sctp_audit_indx][1] = 0xA2;

    672. 

  672. 		sctp_audit_indx++;

    673. 

  673. 		if (sctp_audit_indx >= SCTP_AUDIT_SIZE) {

    674. 

  674. 			sctp_audit_indx = 0;

    675. 

  675. 		}

    676. 

  676. 		rep = 1;

    677. 

  677. 		SCTP_PRINTF("tot_flt:%d asoc_tot:%d\n", tot_out,

    678. 

  678. 			    (int)stcb->asoc.total_flight);

    679. 

  679. 		stcb->asoc.total_flight = tot_out;

    680. 

  680. 	}

    681. 

  681. 	if (tot_book_cnt != stcb->asoc.total_flight_count) {

    682. 

  682. 		sctp_audit_data[sctp_audit_indx][0] = 0xAF;

    683. 

  683. 		sctp_audit_data[sctp_audit_indx][1] = 0xA5;

    684. 

  684. 		sctp_audit_indx++;

    685. 

  685. 		if (sctp_audit_indx >= SCTP_AUDIT_SIZE) {

    686. 

  686. 			sctp_audit_indx = 0;

    687. 

  687. 		}

    688. 

  688. 		rep = 1;

    689. 

  689. 		SCTP_PRINTF("tot_flt_book:%d\n", tot_book_cnt);

    690. 

  690. 

    691. 

  691. 		stcb->asoc.total_flight_count = tot_book_cnt;

    692. 

  692. 	}

    693. 

  693. 	tot_out = 0;

    694. 

  694. 	TAILQ_FOREACH(lnet, &stcb->asoc.nets, sctp_next) {

    695. 

  695. 		tot_out += lnet->flight_size;

    696. 

  696. 	}

    697. 

  697. 	if (tot_out != stcb->asoc.total_flight) {

    698. 

  698. 		sctp_audit_data[sctp_audit_indx][0] = 0xAF;

    699. 

  699. 		sctp_audit_data[sctp_audit_indx][1] = 0xA3;

    700. 

  700. 		sctp_audit_indx++;

    701. 

  701. 		if (sctp_audit_indx >= SCTP_AUDIT_SIZE) {

    702. 

  702. 			sctp_audit_indx = 0;

    703. 

  703. 		}

    704. 

  704. 		rep = 1;

    705. 

  705. 		SCTP_PRINTF("real flight:%d net total was %d\n",

    706. 

  706. 			    stcb->asoc.total_flight, tot_out);

    707. 

  707. 		/* now corrective action */

    708. 

  708. 		TAILQ_FOREACH(lnet, &stcb->asoc.nets, sctp_next) {

    709. 

  709. 

    710. 

  710. 			tot_out = 0;

    711. 

  711. 			TAILQ_FOREACH(chk, &stcb->asoc.sent_queue, sctp_next) {

    712. 

  712. 				if ((chk->whoTo == lnet) &&

    713. 

  713. 				    (chk->sent < SCTP_DATAGRAM_RESEND)) {

    714. 

  714. 					tot_out += chk->book_size;

    715. 

  715. 				}

    716. 

  716. 			}

    717. 

  717. 			if (lnet->flight_size != tot_out) {

    718. 

  718. 				SCTP_PRINTF("net:%p flight was %d corrected to %d\n",

    719. 

  719. 					    lnet, lnet->flight_size,

    720. 

  720. 					    tot_out);

    721. 

  721. 				lnet->flight_size = tot_out;

    722. 

  722. 			}

    723. 

  723. 		}

    724. 

  724. 	}

    725. 

  725. 	if (rep) {

    726. 

  726. 		sctp_print_audit_report();

    727. 

  727. 	}

    728. 

  728. }

    729. 

  729. 

    730. 

  730. void

    731. 

  731. sctp_audit_log(uint8_t ev, uint8_t fd)

    732. 

  732. {

    733. 

  733. 

    734. 

  734. 	sctp_audit_data[sctp_audit_indx][0] = ev;

    735. 

  735. 	sctp_audit_data[sctp_audit_indx][1] = fd;

    736. 

  736. 	sctp_audit_indx++;

    737. 

  737. 	if (sctp_audit_indx >= SCTP_AUDIT_SIZE) {

    738. 

  738. 		sctp_audit_indx = 0;

    739. 

  739. 	}

    740. 

  740. }

    741. 

  741. 

    742. 

  742. #endif

    743. 

  743. 

    744. 

  744. /*

    745. 

  745.  * sctp_stop_timers_for_shutdown() should be called

    746. 

  746.  * when entering the SHUTDOWN_SENT or SHUTDOWN_ACK_SENT

    747. 

  747.  * state to make sure that all timers are stopped.

    748. 

  748.  */

    749. 

  749. void

    750. 

  750. sctp_stop_timers_for_shutdown(struct sctp_tcb *stcb)

    751. 

  751. {

    752. 

  752. 	struct sctp_association *asoc;

    753. 

  753. 	struct sctp_nets *net;

    754. 

  754. 

    755. 

  755. 	asoc = &stcb->asoc;

    756. 

  756. 

    757. 

  757. 	(void)SCTP_OS_TIMER_STOP(&asoc->dack_timer.timer);

    758. 

  758. 	(void)SCTP_OS_TIMER_STOP(&asoc->strreset_timer.timer);

    759. 

  759. 	(void)SCTP_OS_TIMER_STOP(&asoc->asconf_timer.timer);

    760. 

  760. 	(void)SCTP_OS_TIMER_STOP(&asoc->autoclose_timer.timer);

    761. 

  761. 	(void)SCTP_OS_TIMER_STOP(&asoc->delayed_event_timer.timer);

    762. 

  762. 	TAILQ_FOREACH(net, &asoc->nets, sctp_next) {

    763. 

  763. 		(void)SCTP_OS_TIMER_STOP(&net->pmtu_timer.timer);

    764. 

  764. 		(void)SCTP_OS_TIMER_STOP(&net->hb_timer.timer);

    765. 

  765. 	}

    766. 

  766. }

    767. 

  767. 

    768. 

  768. /*

    769. 

  769.  * a list of sizes based on typical mtu's, used only if next hop size not

    770. 

  770.  * returned.

    771. 

  771.  */

    772. 

  772. static uint32_t sctp_mtu_sizes[] = {

    773. 

  773. 	68,

    774. 

  774. 	296,

    775. 

  775. 	508,

    776. 

  776. 	512,

    777. 

  777. 	544,

    778. 

  778. 	576,

    779. 

  779. 	1006,

    780. 

  780. 	1492,

    781. 

  781. 	1500,

    782. 

  782. 	1536,

    783. 

  783. 	2002,

    784. 

  784. 	2048,

    785. 

  785. 	4352,

    786. 

  786. 	4464,

    787. 

  787. 	8166,

    788. 

  788. 	17914,

    789. 

  789. 	32000,

    790. 

  790. 	65535

    791. 

  791. };

    792. 

  792. 

    793. 

  793. /*

    794. 

  794.  * Return the largest MTU smaller than val. If there is no

    795. 

  795.  * entry, just return val.

    796. 

  796.  */

    797. 

  797. uint32_t

    798. 

  798. sctp_get_prev_mtu(uint32_t val)

    799. 

  799. {

    800. 

  800. 	uint32_t i;

    801. 

  801. 

    802. 

  802. 	if (val <= sctp_mtu_sizes[0]) {

    803. 

  803. 		return (val);

    804. 

  804. 	}

    805. 

  805. 	for (i = 1; i < (sizeof(sctp_mtu_sizes) / sizeof(uint32_t)); i++) {

    806. 

  806. 		if (val <= sctp_mtu_sizes[i]) {

    807. 

  807. 			break;

    808. 

  808. 		}

    809. 

  809. 	}

    810. 

  810. 	return (sctp_mtu_sizes[i - 1]);

    811. 

  811. }

    812. 

  812. 

    813. 

  813. /*

    814. 

  814.  * Return the smallest MTU larger than val. If there is no

    815. 

  815.  * entry, just return val.

    816. 

  816.  */

    817. 

  817. uint32_t

    818. 

  818. sctp_get_next_mtu(uint32_t val)

    819. 

  819. {

    820. 

  820. 	/* select another MTU that is just bigger than this one */

    821. 

  821. 	uint32_t i;

    822. 

  822. 

    823. 

  823. 	for (i = 0; i < (sizeof(sctp_mtu_sizes) / sizeof(uint32_t)); i++) {

    824. 

  824. 		if (val < sctp_mtu_sizes[i]) {

    825. 

  825. 			return (sctp_mtu_sizes[i]);

    826. 

  826. 		}

    827. 

  827. 	}

    828. 

  828. 	return (val);

    829. 

  829. }

    830. 

  830. 

    831. 

  831. void

    832. 

  832. sctp_fill_random_store(struct sctp_pcb *m)

    833. 

  833. {

    834. 

  834. 	/*

    835. 

  835. 	 * Here we use the MD5/SHA-1 to hash with our good randomNumbers and

    836. 

  836. 	 * our counter. The result becomes our good random numbers and we

    837. 

  837. 	 * then setup to give these out. Note that we do no locking to

    838. 

  838. 	 * protect this. This is ok, since if competing folks call this we

    839. 

  839. 	 * will get more gobbled gook in the random store which is what we

    840. 

  840. 	 * want. There is a danger that two guys will use the same random

    841. 

  841. 	 * numbers, but thats ok too since that is random as well :->

    842. 

  842. 	 */

    843. 

  843. 	m->store_at = 0;

    844. 

  844. 	(void)sctp_hmac(SCTP_HMAC, (uint8_t *)m->random_numbers,

    845. 

  845. 	    sizeof(m->random_numbers), (uint8_t *)&m->random_counter,

    846. 

  846. 	    sizeof(m->random_counter), (uint8_t *)m->random_store);

    847. 

  847. 	m->random_counter++;

    848. 

  848. }

    849. 

  849. 

    850. 

  850. uint32_t

    851. 

  851. sctp_select_initial_TSN(struct sctp_pcb *inp)

    852. 

  852. {

    853. 

  853. 	/*

    854. 

  854. 	 * A true implementation should use random selection process to get

    855. 

  855. 	 * the initial stream sequence number, using RFC1750 as a good

    856. 

  856. 	 * guideline

    857. 

  857. 	 */

    858. 

  858. 	uint32_t x, *xp;

    859. 

  859. 	uint8_t *p;

    860. 

  860. 	int store_at, new_store;

    861. 

  861. 

    862. 

  862. 	if (inp->initial_sequence_debug != 0) {

    863. 

  863. 		uint32_t ret;

    864. 

  864. 

    865. 

  865. 		ret = inp->initial_sequence_debug;

    866. 

  866. 		inp->initial_sequence_debug++;

    867. 

  867. 		return (ret);

    868. 

  868. 	}

    869. 

  869.  retry:

    870. 

  870. 	store_at = inp->store_at;

    871. 

  871. 	new_store = store_at + sizeof(uint32_t);

    872. 

  872. 	if (new_store >= (SCTP_SIGNATURE_SIZE-3)) {

    873. 

  873. 		new_store = 0;

    874. 

  874. 	}

    875. 

  875. 	if (!atomic_cmpset_int(&inp->store_at, store_at, new_store)) {

    876. 

  876. 		goto retry;

    877. 

  877. 	}

    878. 

  878. 	if (new_store == 0) {

    879. 

  879. 		/* Refill the random store */

    880. 

  880. 		sctp_fill_random_store(inp);

    881. 

  881. 	}

    882. 

  882. 	p = &inp->random_store[store_at];

    883. 

  883. 	xp = (uint32_t *)p;

    884. 

  884. 	x = *xp;

    885. 

  885. 	return (x);

    886. 

  886. }

    887. 

  887. 

    888. 

  888. uint32_t

    889. 

  889. sctp_select_a_tag(struct sctp_inpcb *inp, uint16_t lport, uint16_t rport, int check)

    890. 

  890. {

    891. 

  891. 	uint32_t x;

    892. 

  892. 	struct timeval now;

    893. 

  893. 

    894. 

  894. 	if (check) {

    895. 

  895. 		(void)SCTP_GETTIME_TIMEVAL(&now);

    896. 

  896. 	}

    897. 

  897. 	for (;;) {

    898. 

  898. 		x = sctp_select_initial_TSN(&inp->sctp_ep);

    899. 

  899. 		if (x == 0) {

    900. 

  900. 			/* we never use 0 */

    901. 

  901. 			continue;

    902. 

  902. 		}

    903. 

  903. 		if (!check || sctp_is_vtag_good(x, lport, rport, &now)) {

    904. 

  904. 			break;

    905. 

  905. 		}

    906. 

  906. 	}

    907. 

  907. 	return (x);

    908. 

  908. }

    909. 

  909. 

    910. 

  910. int

    911. 

  911. sctp_init_asoc(struct sctp_inpcb *m, struct sctp_tcb *stcb,

    912. 

  912.                uint32_t override_tag, uint32_t vrf_id)

    913. 

  913. {

    914. 

  914. 	struct sctp_association *asoc;

    915. 

  915. 	/*

    916. 

  916. 	 * Anything set to zero is taken care of by the allocation routine's

    917. 

  917. 	 * bzero

    918. 

  918. 	 */

    919. 

  919. 

    920. 

  920. 	/*

    921. 

  921. 	 * Up front select what scoping to apply on addresses I tell my peer

    922. 

  922. 	 * Not sure what to do with these right now, we will need to come up

    923. 

  923. 	 * with a way to set them. We may need to pass them through from the

    924. 

  924. 	 * caller in the sctp_aloc_assoc() function.

    925. 

  925. 	 */

    926. 

  926. 	int i;

    927. 

  927. 

    928. 

  928. 	asoc = &stcb->asoc;

    929. 

  929. 	/* init all variables to a known value. */

    930. 

  930. 	SCTP_SET_STATE(&stcb->asoc, SCTP_STATE_INUSE);

    931. 

  931. 	asoc->max_burst = m->sctp_ep.max_burst;

    932. 

  932. 	asoc->fr_max_burst = m->sctp_ep.fr_max_burst;

    933. 

  933. 	asoc->heart_beat_delay = TICKS_TO_MSEC(m->sctp_ep.sctp_timeoutticks[SCTP_TIMER_HEARTBEAT]);

    934. 

  934. 	asoc->cookie_life = m->sctp_ep.def_cookie_life;

    935. 

  935. 	asoc->sctp_cmt_on_off = m->sctp_cmt_on_off;

    936. 

  936. 	asoc->ecn_allowed = m->sctp_ecn_enable;

    937. 

  937. 	asoc->sctp_nr_sack_on_off = (uint8_t)SCTP_BASE_SYSCTL(sctp_nr_sack_on_off);

    938. 

  938. 	asoc->sctp_cmt_pf = (uint8_t)0;

    939. 

  939. 	asoc->sctp_frag_point = m->sctp_frag_point;

    940. 

  940. 	asoc->sctp_features = m->sctp_features;

    941. 

  941. 	asoc->default_dscp = m->sctp_ep.default_dscp;

    942. 

  942. #ifdef INET6

    943. 

  943. 	if (m->sctp_ep.default_flowlabel) {

    944. 

  944. 		asoc->default_flowlabel = m->sctp_ep.default_flowlabel;

    945. 

  945. 	} else {

    946. 

  946. 		if (m->ip_inp.inp.inp_flags & IN6P_AUTOFLOWLABEL) {

    947. 

  947. 			asoc->default_flowlabel = sctp_select_initial_TSN(&m->sctp_ep);

    948. 

  948. 			asoc->default_flowlabel &= 0x000fffff;

    949. 

  949. 			asoc->default_flowlabel |= 0x80000000;

    950. 

  950. 		} else {

    951. 

  951. 			asoc->default_flowlabel = 0;

    952. 

  952. 		}

    953. 

  953. 	}

    954. 

  954. #endif

    955. 

  955. 	asoc->sb_send_resv = 0;

    956. 

  956. 	if (override_tag) {

    957. 

  957. 		asoc->my_vtag = override_tag;

    958. 

  958. 	} else {

    959. 

  959. 		asoc->my_vtag = sctp_select_a_tag(m, stcb->sctp_ep->sctp_lport, stcb->rport,  1);

    960. 

  960. 	}

    961. 

  961. 	/* Get the nonce tags */

    962. 

  962. 	asoc->my_vtag_nonce = sctp_select_a_tag(m, stcb->sctp_ep->sctp_lport, stcb->rport, 0);

    963. 

  963. 	asoc->peer_vtag_nonce = sctp_select_a_tag(m, stcb->sctp_ep->sctp_lport, stcb->rport, 0);

    964. 

  964. 	asoc->vrf_id = vrf_id;

    965. 

  965. 

    966. 

  966. #ifdef SCTP_ASOCLOG_OF_TSNS

    967. 

  967. 	asoc->tsn_in_at = 0;

    968. 

  968.  	asoc->tsn_out_at = 0;

    969. 

  969. 	asoc->tsn_in_wrapped = 0;

    970. 

  970. 	asoc->tsn_out_wrapped = 0;

    971. 

  971. 	asoc->cumack_log_at = 0;

    972. 

  972. 	asoc->cumack_log_atsnt = 0;

    973. 

  973. #endif

    974. 

  974. #ifdef SCTP_FS_SPEC_LOG

    975. 

  975. 	asoc->fs_index = 0;

    976. 

  976. #endif

    977. 

  977. 	asoc->refcnt = 0;

    978. 

  978. 	asoc->assoc_up_sent = 0;

    979. 

  979. 	asoc->asconf_seq_out = asoc->str_reset_seq_out = asoc->init_seq_number = asoc->sending_seq =

    980. 

  980. 	    sctp_select_initial_TSN(&m->sctp_ep);

    981. 

  981. 	asoc->asconf_seq_out_acked = asoc->asconf_seq_out - 1;

    982. 

  982. 	/* we are optimisitic here */

    983. 

  983. 	asoc->peer_supports_pktdrop = 1;

    984. 

  984. 	asoc->peer_supports_nat = 0;

    985. 

  985. 	asoc->sent_queue_retran_cnt = 0;

    986. 

  986. 

    987. 

  987. 	/* for CMT */

    988. 

  988.         asoc->last_net_cmt_send_started = NULL;

    989. 

  989. 

    990. 

  990. 	/* This will need to be adjusted */

    991. 

  991. 	asoc->last_acked_seq = asoc->init_seq_number - 1;

    992. 

  992. 	asoc->advanced_peer_ack_point = asoc->last_acked_seq;

    993. 

  993. 	asoc->asconf_seq_in = asoc->last_acked_seq;

    994. 

  994. 

    995. 

  995. 	/* here we are different, we hold the next one we expect */

    996. 

  996. 	asoc->str_reset_seq_in = asoc->last_acked_seq + 1;

    997. 

  997. 

    998. 

  998. 	asoc->initial_init_rto_max = m->sctp_ep.initial_init_rto_max;

    999. 

  999. 	asoc->initial_rto = m->sctp_ep.initial_rto;

    1000. 

  1000. 

    1001. 

  1001. 	asoc->max_init_times = m->sctp_ep.max_init_times;

    1002. 

  1002. 	asoc->max_send_times = m->sctp_ep.max_send_times;

    1003. 

  1003. 	asoc->def_net_failure = m->sctp_ep.def_net_failure;

    1004. 

  1004. 	asoc->def_net_pf_threshold = m->sctp_ep.def_net_pf_threshold;

    1005. 

  1005. 	asoc->free_chunk_cnt = 0;

    1006. 

  1006. 

    1007. 

  1007. 	asoc->iam_blocking = 0;

    1008. 

  1008. 	asoc->context = m->sctp_context;

    1009. 

  1009. 	asoc->local_strreset_support = m->local_strreset_support;

    1010. 

  1010. 	asoc->def_send = m->def_send;

    1011. 

  1011. 	asoc->delayed_ack = TICKS_TO_MSEC(m->sctp_ep.sctp_timeoutticks[SCTP_TIMER_RECV]);

    1012. 

  1012. 	asoc->sack_freq = m->sctp_ep.sctp_sack_freq;

    1013. 

  1013. 	asoc->pr_sctp_cnt = 0;

    1014. 

  1014. 	asoc->total_output_queue_size = 0;

    1015. 

  1015. 

    1016. 

  1016. 	if (m->sctp_flags & SCTP_PCB_FLAGS_BOUND_V6) {

    1017. 

  1017. 		struct in6pcb *inp6;

    1018. 

  1018. 

    1019. 

  1019. 		/* Its a V6 socket */

    1020. 

  1020. 		inp6 = (struct in6pcb *)m;

    1021. 

  1021. 		asoc->ipv6_addr_legal = 1;

    1022. 

  1022. 		/* Now look at the binding flag to see if V4 will be legal */

    1023. 

  1023. 		if (SCTP_IPV6_V6ONLY(inp6) == 0) {

    1024. 

  1024. 			asoc->ipv4_addr_legal = 1;

    1025. 

  1025. 		} else {

    1026. 

  1026. 			/* V4 addresses are NOT legal on the association */

    1027. 

  1027. 			asoc->ipv4_addr_legal = 0;

    1028. 

  1028. 		}

    1029. 

  1029. 	} else {

    1030. 

  1030. 		/* Its a V4 socket, no - V6 */

    1031. 

  1031. 		asoc->ipv4_addr_legal = 1;

    1032. 

  1032. 		asoc->ipv6_addr_legal = 0;

    1033. 

  1033. 	}

    1034. 

  1034. 

    1035. 

  1035. 	asoc->my_rwnd = max(SCTP_SB_LIMIT_RCV(m->sctp_socket), SCTP_MINIMAL_RWND);

    1036. 

  1036. 	asoc->peers_rwnd = SCTP_SB_LIMIT_RCV(m->sctp_socket);

    1037. 

  1037. 

    1038. 

  1038. 	asoc->smallest_mtu = m->sctp_frag_point;

    1039. 

  1039. 	asoc->minrto = m->sctp_ep.sctp_minrto;

    1040. 

  1040. 	asoc->maxrto = m->sctp_ep.sctp_maxrto;

    1041. 

  1041. 

    1042. 

  1042. 	asoc->locked_on_sending = NULL;

    1043. 

  1043. 	asoc->stream_locked_on = 0;

    1044. 

  1044. 	asoc->ecn_echo_cnt_onq = 0;

    1045. 

  1045. 	asoc->stream_locked = 0;

    1046. 

  1046. 

    1047. 

  1047. 	asoc->send_sack = 1;

    1048. 

  1048. 

    1049. 

  1049. 	LIST_INIT(&asoc->sctp_restricted_addrs);

    1050. 

  1050. 

    1051. 

  1051. 	TAILQ_INIT(&asoc->nets);

    1052. 

  1052. 	TAILQ_INIT(&asoc->pending_reply_queue);

    1053. 

  1053. 	TAILQ_INIT(&asoc->asconf_ack_sent);

    1054. 

  1054. 	/* Setup to fill the hb random cache at first HB */

    1055. 

  1055. 	asoc->hb_random_idx = 4;

    1056. 

  1056. 

    1057. 

  1057. 	asoc->sctp_autoclose_ticks = m->sctp_ep.auto_close_time;

    1058. 

  1058. 

    1059. 

  1059. 	stcb->asoc.congestion_control_module = m->sctp_ep.sctp_default_cc_module;

    1060. 

  1060. 	stcb->asoc.cc_functions = sctp_cc_functions[m->sctp_ep.sctp_default_cc_module];

    1061. 

  1061. 

    1062. 

  1062. 	stcb->asoc.stream_scheduling_module = m->sctp_ep.sctp_default_ss_module;

    1063. 

  1063. 	stcb->asoc.ss_functions = sctp_ss_functions[m->sctp_ep.sctp_default_ss_module];

    1064. 

  1064. 

    1065. 

  1065. 	/*

    1066. 

  1066. 	 * Now the stream parameters, here we allocate space for all streams

    1067. 

  1067. 	 * that we request by default.

    1068. 

  1068. 	 */

    1069. 

  1069. 	asoc->strm_realoutsize = asoc->streamoutcnt = asoc->pre_open_streams =

    1070. 

  1070. 	    m->sctp_ep.pre_open_stream_count;

    1071. 

  1071. 	SCTP_MALLOC(asoc->strmout, struct sctp_stream_out *,

    1072. 

  1072. 		    asoc->streamoutcnt * sizeof(struct sctp_stream_out),

    1073. 

  1073. 		    SCTP_M_STRMO);

    1074. 

  1074. 	if (asoc->strmout == NULL) {

    1075. 

  1075. 		/* big trouble no memory */

    1076. 

  1076. 		SCTP_LTRACE_ERR_RET(NULL, stcb, NULL, SCTP_FROM_SCTPUTIL, ENOMEM);

    1077. 

  1077. 		return (ENOMEM);

    1078. 

  1078. 	}

    1079. 

  1079. 	for (i = 0; i < asoc->streamoutcnt; i++) {

    1080. 

  1080. 		/*

    1081. 

  1081. 		 * inbound side must be set to 0xffff, also NOTE when we get

    1082. 

  1082. 		 * the INIT-ACK back (for INIT sender) we MUST reduce the

    1083. 

  1083. 		 * count (streamoutcnt) but first check if we sent to any of

    1084. 

  1084. 		 * the upper streams that were dropped (if some were). Those

    1085. 

  1085. 		 * that were dropped must be notified to the upper layer as

    1086. 

  1086. 		 * failed to send.

    1087. 

  1087. 		 */

    1088. 

  1088. 		asoc->strmout[i].next_sequence_sent = 0x0;

    1089. 

  1089. 		TAILQ_INIT(&asoc->strmout[i].outqueue);

    1090. 

  1090. 		asoc->strmout[i].stream_no = i;

    1091. 

  1091. 		asoc->strmout[i].last_msg_incomplete = 0;

    1092. 

  1092. 		asoc->ss_functions.sctp_ss_init_stream(&asoc->strmout[i], NULL);

    1093. 

  1093. 	}

    1094. 

  1094. 	asoc->ss_functions.sctp_ss_init(stcb, asoc, 0);

    1095. 

  1095. 

    1096. 

  1096. 	/* Now the mapping array */

    1097. 

  1097. 	asoc->mapping_array_size = SCTP_INITIAL_MAPPING_ARRAY;

    1098. 

  1098. 	SCTP_MALLOC(asoc->mapping_array, uint8_t *, asoc->mapping_array_size,

    1099. 

  1099. 		    SCTP_M_MAP);

    1100. 

  1100. 	if (asoc->mapping_array == NULL) {

    1101. 

  1101. 		SCTP_FREE(asoc->strmout, SCTP_M_STRMO);

    1102. 

  1102. 		SCTP_LTRACE_ERR_RET(NULL, stcb, NULL, SCTP_FROM_SCTPUTIL, ENOMEM);

    1103. 

  1103. 		return (ENOMEM);

    1104. 

  1104. 	}

    1105. 

  1105. 	memset(asoc->mapping_array, 0, asoc->mapping_array_size);

    1106. 

  1106. 	SCTP_MALLOC(asoc->nr_mapping_array, uint8_t *, asoc->mapping_array_size,

    1107. 

  1107. 	    SCTP_M_MAP);

    1108. 

  1108. 	if (asoc->nr_mapping_array == NULL) {

    1109. 

  1109. 		SCTP_FREE(asoc->strmout, SCTP_M_STRMO);

    1110. 

  1110. 		SCTP_FREE(asoc->mapping_array, SCTP_M_MAP);

    1111. 

  1111. 		SCTP_LTRACE_ERR_RET(NULL, stcb, NULL, SCTP_FROM_SCTPUTIL, ENOMEM);

    1112. 

  1112. 		return (ENOMEM);

    1113. 

  1113. 	}

    1114. 

  1114. 	memset(asoc->nr_mapping_array, 0, asoc->mapping_array_size);

    1115. 

  1115. 

    1116. 

  1116. 	/* Now the init of the other outqueues */

    1117. 

  1117. 	TAILQ_INIT(&asoc->free_chunks);

    1118. 

  1118. 	TAILQ_INIT(&asoc->control_send_queue);

    1119. 

  1119. 	TAILQ_INIT(&asoc->asconf_send_queue);

    1120. 

  1120. 	TAILQ_INIT(&asoc->send_queue);

    1121. 

  1121. 	TAILQ_INIT(&asoc->sent_queue);

    1122. 

  1122. 	TAILQ_INIT(&asoc->reasmqueue);

    1123. 

  1123. 	TAILQ_INIT(&asoc->resetHead);

    1124. 

  1124. 	asoc->max_inbound_streams = m->sctp_ep.max_open_streams_intome;

    1125. 

  1125. 	TAILQ_INIT(&asoc->asconf_queue);

    1126. 

  1126. 	/* authentication fields */

    1127. 

  1127. 	asoc->authinfo.random = NULL;

    1128. 

  1128. 	asoc->authinfo.active_keyid = 0;

    1129. 

  1129. 	asoc->authinfo.assoc_key = NULL;

    1130. 

  1130. 	asoc->authinfo.assoc_keyid = 0;

    1131. 

  1131. 	asoc->authinfo.recv_key = NULL;

    1132. 

  1132. 	asoc->authinfo.recv_keyid = 0;

    1133. 

  1133. 	LIST_INIT(&asoc->shared_keys);

    1134. 

  1134. 	asoc->marked_retrans = 0;

    1135. 

  1135. 	asoc->port = m->sctp_ep.port;

    1136. 

  1136. 	asoc->timoinit = 0;

    1137. 

  1137. 	asoc->timodata = 0;

    1138. 

  1138. 	asoc->timosack = 0;

    1139. 

  1139. 	asoc->timoshutdown = 0;

    1140. 

  1140. 	asoc->timoheartbeat = 0;

    1141. 

  1141. 	asoc->timocookie = 0;

    1142. 

  1142. 	asoc->timoshutdownack = 0;

    1143. 

  1143. 	(void)SCTP_GETTIME_TIMEVAL(&asoc->start_time);

    1144. 

  1144. 	asoc->discontinuity_time = asoc->start_time;

    1145. 

  1145. 	/* sa_ignore MEMLEAK {memory is put in the assoc mapping array and freed later when

    1146. 

  1146. 	 * the association is freed.

    1147. 

  1147. 	 */

    1148. 

  1148. 	return (0);

    1149. 

  1149. }

    1150. 

  1150. 

    1151. 

  1151. void

    1152. 

  1152. sctp_print_mapping_array(struct sctp_association *asoc)

    1153. 

  1153. {

    1154. 

  1154. 	unsigned int i, limit;

    1155. 

  1155. 

    1156. 

  1156. 	SCTP_PRINTF("Mapping array size: %d, baseTSN: %8.8x, cumAck: %8.8x, highestTSN: (%8.8x, %8.8x).\n",

    1157. 

  1157. 	            asoc->mapping_array_size,

    1158. 

  1158. 	            asoc->mapping_array_base_tsn,

    1159. 

  1159. 	            asoc->cumulative_tsn,

    1160. 

  1160. 	            asoc->highest_tsn_inside_map,

    1161. 

  1161. 	            asoc->highest_tsn_inside_nr_map);

    1162. 

  1162. 	for (limit = asoc->mapping_array_size; limit > 1; limit--) {

    1163. 

  1163. 		if (asoc->mapping_array[limit - 1] != 0) {

    1164. 

  1164. 			break;

    1165. 

  1165. 		}

    1166. 

  1166. 	}

    1167. 

  1167. 	SCTP_PRINTF("Renegable mapping array (last %d entries are zero):\n", asoc->mapping_array_size - limit);

    1168. 

  1168. 	for (i = 0; i < limit; i++) {

    1169. 

  1169. 		SCTP_PRINTF("%2.2x%c", asoc->mapping_array[i], ((i + 1) % 16) ? ' ' : '\n');

    1170. 

  1170. 	}

    1171. 

  1171. 	if (limit % 16)

    1172. 

  1172. 		SCTP_PRINTF("\n");

    1173. 

  1173. 	for (limit = asoc->mapping_array_size; limit > 1; limit--) {

    1174. 

  1174. 		if (asoc->nr_mapping_array[limit - 1]) {

    1175. 

  1175. 			break;

    1176. 

  1176. 		}

    1177. 

  1177. 	}

    1178. 

  1178. 	SCTP_PRINTF("Non renegable mapping array (last %d entries are zero):\n", asoc->mapping_array_size - limit);

    1179. 

  1179. 	for (i = 0; i < limit; i++) {

    1180. 

  1180. 		SCTP_PRINTF("%2.2x%c", asoc->nr_mapping_array[i], ((i + 1) % 16) ? ' ': '\n');

    1181. 

  1181. 	}

    1182. 

  1182. 	if (limit % 16)

    1183. 

  1183. 		SCTP_PRINTF("\n");

    1184. 

  1184. }

    1185. 

  1185. 

    1186. 

  1186. int

    1187. 

  1187. sctp_expand_mapping_array(struct sctp_association *asoc, uint32_t needed)

    1188. 

  1188. {

    1189. 

  1189. 	/* mapping array needs to grow */

    1190. 

  1190. 	uint8_t *new_array1, *new_array2;

    1191. 

  1191. 	uint32_t new_size;

    1192. 

  1192. 

    1193. 

  1193. 	new_size = asoc->mapping_array_size + ((needed+7)/8 + SCTP_MAPPING_ARRAY_INCR);

    1194. 

  1194. 	SCTP_MALLOC(new_array1, uint8_t *, new_size, SCTP_M_MAP);

    1195. 

  1195. 	SCTP_MALLOC(new_array2, uint8_t *, new_size, SCTP_M_MAP);

    1196. 

  1196. 	if ((new_array1 == NULL) || (new_array2 == NULL)) {

    1197. 

  1197. 		/* can't get more, forget it */

    1198. 

  1198. 		SCTP_PRINTF("No memory for expansion of SCTP mapping array %d\n", new_size);

    1199. 

  1199. 		if (new_array1) {

    1200. 

  1200. 			SCTP_FREE(new_array1, SCTP_M_MAP);

    1201. 

  1201. 		}

    1202. 

  1202. 		if (new_array2) {

    1203. 

  1203. 			SCTP_FREE(new_array2, SCTP_M_MAP);

    1204. 

  1204. 		}

    1205. 

  1205. 		return (-1);

    1206. 

  1206. 	}

    1207. 

  1207. 	memset(new_array1, 0, new_size);

    1208. 

  1208. 	memset(new_array2, 0, new_size);

    1209. 

  1209. 	memcpy(new_array1, asoc->mapping_array, asoc->mapping_array_size);

    1210. 

  1210. 	memcpy(new_array2, asoc->nr_mapping_array, asoc->mapping_array_size);

    1211. 

  1211. 	SCTP_FREE(asoc->mapping_array, SCTP_M_MAP);

    1212. 

  1212. 	SCTP_FREE(asoc->nr_mapping_array, SCTP_M_MAP);

    1213. 

  1213. 	asoc->mapping_array = new_array1;

    1214. 

  1214. 	asoc->nr_mapping_array = new_array2;

    1215. 

  1215. 	asoc->mapping_array_size = new_size;

    1216. 

  1216. 	return (0);

    1217. 

  1217. }

    1218. 

  1218. 

    1219. 

  1219. 

    1220. 

  1220. static void

    1221. 

  1221. sctp_iterator_work(struct sctp_iterator *it)

    1222. 

  1222. {

    1223. 

  1223. 	int iteration_count = 0;

    1224. 

  1224. 	int inp_skip = 0;

    1225. 

  1225. 	int first_in = 1;

    1226. 

  1226. 	struct sctp_inpcb *tinp;

    1227. 

  1227. 

    1228. 

  1228. 	SCTP_INP_INFO_RLOCK();

    1229. 

  1229. 	SCTP_ITERATOR_LOCK();

    1230. 

  1230.  	if (it->inp) {

    1231. 

  1231. 		SCTP_INP_RLOCK(it->inp);

    1232. 

  1232. 		SCTP_INP_DECR_REF(it->inp);

    1233. 

  1233. 	}

    1234. 

  1234. 	if (it->inp == NULL) {

    1235. 

  1235. 		/* iterator is complete */

    1236. 

  1236. done_with_iterator:

    1237. 

  1237. 		SCTP_ITERATOR_UNLOCK();

    1238. 

  1238. 		SCTP_INP_INFO_RUNLOCK();

    1239. 

  1239. 		if (it->function_atend != NULL) {

    1240. 

  1240. 			(*it->function_atend) (it->pointer, it->val);

    1241. 

  1241. 		}

    1242. 

  1242. 		SCTP_FREE(it, SCTP_M_ITER);

    1243. 

  1243. 		return;

    1244. 

  1244. 	}

    1245. 

  1245. select_a_new_ep:

    1246. 

  1246. 	if (first_in) {

    1247. 

  1247. 		first_in = 0;

    1248. 

  1248. 	} else {

    1249. 

  1249. 		SCTP_INP_RLOCK(it->inp);

    1250. 

  1250. 	}

    1251. 

  1251. 	while (((it->pcb_flags) &&

    1252. 

  1252. 		((it->inp->sctp_flags & it->pcb_flags) != it->pcb_flags)) ||

    1253. 

  1253. 	       ((it->pcb_features) &&

    1254. 

  1254. 		((it->inp->sctp_features & it->pcb_features) != it->pcb_features))) {

    1255. 

  1255. 		/* endpoint flags or features don't match, so keep looking */

    1256. 

  1256. 		if (it->iterator_flags & SCTP_ITERATOR_DO_SINGLE_INP) {

    1257. 

  1257. 			SCTP_INP_RUNLOCK(it->inp);

    1258. 

  1258. 			goto done_with_iterator;

    1259. 

  1259. 		}

    1260. 

  1260. 		tinp = it->inp;

    1261. 

  1261. 		it->inp = LIST_NEXT(it->inp, sctp_list);

    1262. 

  1262. 		SCTP_INP_RUNLOCK(tinp);

    1263. 

  1263. 		if (it->inp == NULL) {

    1264. 

  1264. 			goto done_with_iterator;

    1265. 

  1265. 		}

    1266. 

  1266. 		SCTP_INP_RLOCK(it->inp);

    1267. 

  1267. 	}

    1268. 

  1268. 	/* now go through each assoc which is in the desired state */

    1269. 

  1269. 	if (it->done_current_ep == 0) {

    1270. 

  1270. 		if (it->function_inp != NULL)

    1271. 

  1271. 			inp_skip = (*it->function_inp)(it->inp, it->pointer, it->val);

    1272. 

  1272. 		it->done_current_ep = 1;

    1273. 

  1273. 	}

    1274. 

  1274. 	if (it->stcb == NULL) {

    1275. 

  1275. 		/* run the per instance function */

    1276. 

  1276. 		it->stcb = LIST_FIRST(&it->inp->sctp_asoc_list);

    1277. 

  1277. 	}

    1278. 

  1278. 	if ((inp_skip) || it->stcb == NULL) {

    1279. 

  1279. 		if (it->function_inp_end != NULL) {

    1280. 

  1280. 			inp_skip = (*it->function_inp_end)(it->inp,

    1281. 

  1281. 							   it->pointer,

    1282. 

  1282. 							   it->val);

    1283. 

  1283. 		}

    1284. 

  1284. 		SCTP_INP_RUNLOCK(it->inp);

    1285. 

  1285. 		goto no_stcb;

    1286. 

  1286. 	}

    1287. 

  1287. 	while (it->stcb) {

    1288. 

  1288. 		SCTP_TCB_LOCK(it->stcb);

    1289. 

  1289. 		if (it->asoc_state && ((it->stcb->asoc.state & it->asoc_state) != it->asoc_state)) {

    1290. 

  1290. 			/* not in the right state... keep looking */

    1291. 

  1291. 			SCTP_TCB_UNLOCK(it->stcb);

    1292. 

  1292. 			goto next_assoc;

    1293. 

  1293. 		}

    1294. 

  1294. 		/* see if we have limited out the iterator loop */

    1295. 

  1295. 		iteration_count++;

    1296. 

  1296. 		if (iteration_count > SCTP_ITERATOR_MAX_AT_ONCE) {

    1297. 

  1297. 			/* Pause to let others grab the lock */

    1298. 

  1298. 			atomic_add_int(&it->stcb->asoc.refcnt, 1);

    1299. 

  1299. 			SCTP_TCB_UNLOCK(it->stcb);

    1300. 

  1300. 			SCTP_INP_INCR_REF(it->inp);

    1301. 

  1301. 			SCTP_INP_RUNLOCK(it->inp);

    1302. 

  1302. 			SCTP_ITERATOR_UNLOCK();

    1303. 

  1303. 			SCTP_INP_INFO_RUNLOCK();

    1304. 

  1304. 			SCTP_INP_INFO_RLOCK();

    1305. 

  1305. 			SCTP_ITERATOR_LOCK();

    1306. 

  1306. 			if (sctp_it_ctl.iterator_flags) {

    1307. 

  1307. 				/* We won't be staying here */

    1308. 

  1308. 				SCTP_INP_DECR_REF(it->inp);

    1309. 

  1309. 				atomic_add_int(&it->stcb->asoc.refcnt, -1);

    1310. 

  1310. #if !defined(__FreeBSD__)

    1311. 

  1311. 				if (sctp_it_ctl.iterator_flags &

    1312. 

  1312. 				   SCTP_ITERATOR_MUST_EXIT) {

    1313. 

  1313. 					goto done_with_iterator;

    1314. 

  1314. 				}

    1315. 

  1315. #endif

    1316. 

  1316. 				if (sctp_it_ctl.iterator_flags &

    1317. 

  1317. 				   SCTP_ITERATOR_STOP_CUR_IT) {

    1318. 

  1318. 					sctp_it_ctl.iterator_flags &= ~SCTP_ITERATOR_STOP_CUR_IT;

    1319. 

  1319. 					goto done_with_iterator;

    1320. 

  1320. 				}

    1321. 

  1321. 				if (sctp_it_ctl.iterator_flags &

    1322. 

  1322. 				   SCTP_ITERATOR_STOP_CUR_INP) {

    1323. 

  1323. 					sctp_it_ctl.iterator_flags &= ~SCTP_ITERATOR_STOP_CUR_INP;

    1324. 

  1324. 					goto no_stcb;

    1325. 

  1325. 				}

    1326. 

  1326. 				/* If we reach here huh? */

    1327. 

  1327. 				SCTP_PRINTF("Unknown it ctl flag %x\n",

    1328. 

  1328. 					    sctp_it_ctl.iterator_flags);

    1329. 

  1329. 				sctp_it_ctl.iterator_flags = 0;

    1330. 

  1330. 			}

    1331. 

  1331. 			SCTP_INP_RLOCK(it->inp);

    1332. 

  1332. 			SCTP_INP_DECR_REF(it->inp);

    1333. 

  1333. 			SCTP_TCB_LOCK(it->stcb);

    1334. 

  1334. 			atomic_add_int(&it->stcb->asoc.refcnt, -1);

    1335. 

  1335. 			iteration_count = 0;

    1336. 

  1336. 		}

    1337. 

  1337. 

    1338. 

  1338. 		/* run function on this one */

    1339. 

  1339. 		(*it->function_assoc)(it->inp, it->stcb, it->pointer, it->val);

    1340. 

  1340. 

    1341. 

  1341. 		/*

    1342. 

  1342. 		 * we lie here, it really needs to have its own type but

    1343. 

  1343. 		 * first I must verify that this won't effect things :-0

    1344. 

  1344. 		 */

    1345. 

  1345. 		if (it->no_chunk_output == 0)

    1346. 

  1346. 			sctp_chunk_output(it->inp, it->stcb, SCTP_OUTPUT_FROM_T3, SCTP_SO_NOT_LOCKED);

    1347. 

  1347. 

    1348. 

  1348. 		SCTP_TCB_UNLOCK(it->stcb);

    1349. 

  1349. 	next_assoc:

    1350. 

  1350. 		it->stcb = LIST_NEXT(it->stcb, sctp_tcblist);

    1351. 

  1351. 		if (it->stcb == NULL) {

    1352. 

  1352. 			/* Run last function */

    1353. 

  1353. 			if (it->function_inp_end != NULL) {

    1354. 

  1354. 				inp_skip = (*it->function_inp_end)(it->inp,

    1355. 

  1355. 								   it->pointer,

    1356. 

  1356. 								   it->val);

    1357. 

  1357. 			}

    1358. 

  1358. 		}

    1359. 

  1359. 	}

    1360. 

  1360. 	SCTP_INP_RUNLOCK(it->inp);

    1361. 

  1361.  no_stcb:

    1362. 

  1362. 	/* done with all assocs on this endpoint, move on to next endpoint */

    1363. 

  1363. 	it->done_current_ep = 0;

    1364. 

  1364. 	if (it->iterator_flags & SCTP_ITERATOR_DO_SINGLE_INP) {

    1365. 

  1365. 		it->inp = NULL;

    1366. 

  1366. 	} else {

    1367. 

  1367. 		it->inp = LIST_NEXT(it->inp, sctp_list);

    1368. 

  1368. 	}

    1369. 

  1369. 	if (it->inp == NULL) {

    1370. 

  1370. 		goto done_with_iterator;

    1371. 

  1371. 	}

    1372. 

  1372. 	goto select_a_new_ep;

    1373. 

  1373. }

    1374. 

  1374. 

    1375. 

  1375. void

    1376. 

  1376. sctp_iterator_worker(void)

    1377. 

  1377. {

    1378. 

  1378. 	struct sctp_iterator *it, *nit;

    1379. 

  1379. 

    1380. 

  1380. 	/* This function is called with the WQ lock in place */

    1381. 

  1381. 

    1382. 

  1382. 	sctp_it_ctl.iterator_running = 1;

    1383. 

  1383. 	TAILQ_FOREACH_SAFE(it, &sctp_it_ctl.iteratorhead, sctp_nxt_itr, nit) {

    1384. 

  1384. 		sctp_it_ctl.cur_it = it;

    1385. 

  1385. 		/* now lets work on this one */

    1386. 

  1386. 		TAILQ_REMOVE(&sctp_it_ctl.iteratorhead, it, sctp_nxt_itr);

    1387. 

  1387. 		SCTP_IPI_ITERATOR_WQ_UNLOCK();

    1388. 

  1388. #if defined(__FreeBSD__) && __FreeBSD_version >= 801000

    1389. 

  1389. 		CURVNET_SET(it->vn);

    1390. 

  1390. #endif

    1391. 

  1391. 		sctp_iterator_work(it);

    1392. 

  1392. 		sctp_it_ctl.cur_it = NULL;

    1393. 

  1393. #if defined(__FreeBSD__) && __FreeBSD_version >= 801000

    1394. 

  1394. 		CURVNET_RESTORE();

    1395. 

  1395. #endif

    1396. 

  1396. 		SCTP_IPI_ITERATOR_WQ_LOCK();

    1397. 

  1397. #if !defined(__FreeBSD__)

    1398. 

  1398. 		if (sctp_it_ctl.iterator_flags & SCTP_ITERATOR_MUST_EXIT) {

    1399. 

  1399. 			break;

    1400. 

  1400. 		}

    1401. 

  1401. #endif

    1402. 

  1402. 	        /*sa_ignore FREED_MEMORY*/

    1403. 

  1403. 	}

    1404. 

  1404. 	sctp_it_ctl.iterator_running = 0;

    1405. 

  1405. 	return;

    1406. 

  1406. }

    1407. 

  1407. 

    1408. 

  1408. 

    1409. 

  1409. static void

    1410. 

  1410. sctp_handle_addr_wq(void)

    1411. 

  1411. {

    1412. 

  1412. 	/* deal with the ADDR wq from the rtsock calls */

    1413. 

  1413. 	struct sctp_laddr *wi, *nwi;

    1414. 

  1414. 	struct sctp_asconf_iterator *asc;

    1415. 

  1415. 

    1416. 

  1416. 	SCTP_MALLOC(asc, struct sctp_asconf_iterator *,

    1417. 

  1417. 		    sizeof(struct sctp_asconf_iterator), SCTP_M_ASC_IT);

    1418. 

  1418. 	if (asc == NULL) {

    1419. 

  1419. 		/* Try later, no memory */

    1420. 

  1420. 		sctp_timer_start(SCTP_TIMER_TYPE_ADDR_WQ,

    1421. 

  1421. 				 (struct sctp_inpcb *)NULL,

    1422. 

  1422. 				 (struct sctp_tcb *)NULL,

    1423. 

  1423. 				 (struct sctp_nets *)NULL);

    1424. 

  1424. 		return;

    1425. 

  1425. 	}

    1426. 

  1426. 	LIST_INIT(&asc->list_of_work);

    1427. 

  1427. 	asc->cnt = 0;

    1428. 

  1428. 

    1429. 

  1429. 	SCTP_WQ_ADDR_LOCK();

    1430. 

  1430. 	LIST_FOREACH_SAFE(wi, &SCTP_BASE_INFO(addr_wq), sctp_nxt_addr, nwi) {

    1431. 

  1431. 		LIST_REMOVE(wi, sctp_nxt_addr);

    1432. 

  1432. 		LIST_INSERT_HEAD(&asc->list_of_work, wi, sctp_nxt_addr);

    1433. 

  1433. 		asc->cnt++;

    1434. 

  1434. 	}

    1435. 

  1435. 	SCTP_WQ_ADDR_UNLOCK();

    1436. 

  1436. 

    1437. 

  1437. 	if (asc->cnt == 0) {

    1438. 

  1438. 		SCTP_FREE(asc, SCTP_M_ASC_IT);

    1439. 

  1439. 	} else {

    1440. 

  1440. 		(void)sctp_initiate_iterator(sctp_asconf_iterator_ep,

    1441. 

  1441. 					     sctp_asconf_iterator_stcb,

    1442. 

  1442. 					     NULL, /* No ep end for boundall */

    1443. 

  1443. 					     SCTP_PCB_FLAGS_BOUNDALL,

    1444. 

  1444. 					     SCTP_PCB_ANY_FEATURES,

    1445. 

  1445. 					     SCTP_ASOC_ANY_STATE,

    1446. 

  1446. 					     (void *)asc, 0,

    1447. 

  1447. 					     sctp_asconf_iterator_end, NULL, 0);

    1448. 

  1448. 	}

    1449. 

  1449. }

    1450. 

  1450. 

    1451. 

  1451. void

    1452. 

  1452. sctp_timeout_handler(void *t)

    1453. 

  1453. {

    1454. 

  1454. 	struct sctp_inpcb *inp;

    1455. 

  1455. 	struct sctp_tcb *stcb;

    1456. 

  1456. 	struct sctp_nets *net;

    1457. 

  1457. 	struct sctp_timer *tmr;

    1458. 

  1458. #if defined (__APPLE__) || defined(SCTP_SO_LOCK_TESTING)

    1459. 

  1459. 	struct socket *so;

    1460. 

  1460. #endif

    1461. 

  1461. 	int did_output, type;

    1462. 

  1462. 

    1463. 

  1463. 	tmr = (struct sctp_timer *)t;

    1464. 

  1464. 	inp = (struct sctp_inpcb *)tmr->ep;

    1465. 

  1465. 	stcb = (struct sctp_tcb *)tmr->tcb;

    1466. 

  1466. 	net = (struct sctp_nets *)tmr->net;

    1467. 

  1467. #if defined(__FreeBSD__) && __FreeBSD_version >= 801000

    1468. 

  1468. 	CURVNET_SET((struct vnet *)tmr->vnet);

    1469. 

  1469. #endif

    1470. 

  1470. 	did_output = 1;

    1471. 

  1471. 

    1472. 

  1472. #ifdef SCTP_AUDITING_ENABLED

    1473. 

  1473. 	sctp_audit_log(0xF0, (uint8_t) tmr->type);

    1474. 

  1474. 	sctp_auditing(3, inp, stcb, net);

    1475. 

  1475. #endif

    1476. 

  1476. 

    1477. 

  1477. 	/* sanity checks... */

    1478. 

  1478. 	if (tmr->self != (void *)tmr) {

    1479. 

  1479. 		/*

    1480. 

  1480. 		 * SCTP_PRINTF("Stale SCTP timer fired (%p), ignoring...\n",

    1481. 

  1481. 		 * tmr);

    1482. 

  1482. 		 */

    1483. 

  1483. #if defined(__FreeBSD__) && __FreeBSD_version >= 801000

    1484. 

  1484. 		CURVNET_RESTORE();

    1485. 

  1485. #endif

    1486. 

  1486. 		return;

    1487. 

  1487. 	}

    1488. 

  1488. 	tmr->stopped_from = 0xa001;

    1489. 

  1489. 	if (!SCTP_IS_TIMER_TYPE_VALID(tmr->type)) {

    1490. 

  1490. 		/*

    1491. 

  1491. 		 * SCTP_PRINTF("SCTP timer fired with invalid type: 0x%x\n",

    1492. 

  1492. 		 * tmr->type);

    1493. 

  1493. 		 */

    1494. 

  1494. #if defined(__FreeBSD__) && __FreeBSD_version >= 801000

    1495. 

  1495. 		CURVNET_RESTORE();

    1496. 

  1496. #endif

    1497. 

  1497. 		return;

    1498. 

  1498. 	}

    1499. 

  1499. 	tmr->stopped_from = 0xa002;

    1500. 

  1500. 	if ((tmr->type != SCTP_TIMER_TYPE_ADDR_WQ) && (inp == NULL)) {

    1501. 

  1501. #if defined(__FreeBSD__) && __FreeBSD_version >= 801000

    1502. 

  1502. 		CURVNET_RESTORE();

    1503. 

  1503. #endif

    1504. 

  1504. 		return;

    1505. 

  1505. 	}

    1506. 

  1506. 	/* if this is an iterator timeout, get the struct and clear inp */

    1507. 

  1507. 	tmr->stopped_from = 0xa003;

    1508. 

  1508. 	type = tmr->type;

    1509. 

  1509. 	if (inp) {

    1510. 

  1510. 		SCTP_INP_INCR_REF(inp);

    1511. 

  1511. 		if ((inp->sctp_socket == NULL) &&

    1512. 

  1512. 		    ((tmr->type != SCTP_TIMER_TYPE_INPKILL) &&

    1513. 

  1513. 		     (tmr->type != SCTP_TIMER_TYPE_INIT) &&

    1514. 

  1514. 		     (tmr->type != SCTP_TIMER_TYPE_SEND) &&

    1515. 

  1515. 		     (tmr->type != SCTP_TIMER_TYPE_RECV) &&

    1516. 

  1516. 		     (tmr->type != SCTP_TIMER_TYPE_HEARTBEAT) &&

    1517. 

  1517. 		     (tmr->type != SCTP_TIMER_TYPE_SHUTDOWN) &&

    1518. 

  1518. 		     (tmr->type != SCTP_TIMER_TYPE_SHUTDOWNACK) &&

    1519. 

  1519. 		     (tmr->type != SCTP_TIMER_TYPE_SHUTDOWNGUARD) &&

    1520. 

  1520. 		     (tmr->type != SCTP_TIMER_TYPE_ASOCKILL))

    1521. 

  1521. 			) {

    1522. 

  1522. 			SCTP_INP_DECR_REF(inp);

    1523. 

  1523. #if defined(__FreeBSD__) && __FreeBSD_version >= 801000

    1524. 

  1524. 			CURVNET_RESTORE();

    1525. 

  1525. #endif

    1526. 

  1526. 			return;

    1527. 

  1527. 		}

    1528. 

  1528. 	}

    1529. 

  1529. 	tmr->stopped_from = 0xa004;

    1530. 

  1530. 	if (stcb) {

    1531. 

  1531. 		atomic_add_int(&stcb->asoc.refcnt, 1);

    1532. 

  1532. 		if (stcb->asoc.state == 0) {

    1533. 

  1533. 			atomic_add_int(&stcb->asoc.refcnt, -1);

    1534. 

  1534. 			if (inp) {

    1535. 

  1535. 				SCTP_INP_DECR_REF(inp);

    1536. 

  1536. 			}

    1537. 

  1537. #if defined(__FreeBSD__) && __FreeBSD_version >= 801000

    1538. 

  1538. 			CURVNET_RESTORE();

    1539. 

  1539. #endif

    1540. 

  1540. 			return;

    1541. 

  1541. 		}

    1542. 

  1542. 	}

    1543. 

  1543. 	tmr->stopped_from = 0xa005;

    1544. 

  1544. 	SCTPDBG(SCTP_DEBUG_TIMER1, "Timer type %d goes off\n", tmr->type);

    1545. 

  1545. 	if (!SCTP_OS_TIMER_ACTIVE(&tmr->timer)) {

    1546. 

  1546. 		if (inp) {

    1547. 

  1547. 			SCTP_INP_DECR_REF(inp);

    1548. 

  1548. 		}

    1549. 

  1549. 		if (stcb) {

    1550. 

  1550. 			atomic_add_int(&stcb->asoc.refcnt, -1);

    1551. 

  1551. 		}

    1552. 

  1552. #if defined(__FreeBSD__) && __FreeBSD_version >= 801000

    1553. 

  1553. 		CURVNET_RESTORE();

    1554. 

  1554. #endif

    1555. 

  1555. 		return;

    1556. 

  1556. 	}

    1557. 

  1557. 	tmr->stopped_from = 0xa006;

    1558. 

  1558. 

    1559. 

  1559. 	if (stcb) {

    1560. 

  1560. 		SCTP_TCB_LOCK(stcb);

    1561. 

  1561. 		atomic_add_int(&stcb->asoc.refcnt, -1);

    1562. 

  1562. 		if ((tmr->type != SCTP_TIMER_TYPE_ASOCKILL) &&

    1563. 

  1563. 		    ((stcb->asoc.state == 0) ||

    1564. 

  1564. 		     (stcb->asoc.state & SCTP_STATE_ABOUT_TO_BE_FREED))) {

    1565. 

  1565. 			SCTP_TCB_UNLOCK(stcb);

    1566. 

  1566. 			if (inp) {

    1567. 

  1567. 				SCTP_INP_DECR_REF(inp);

    1568. 

  1568. 			}

    1569. 

  1569. #if defined(__FreeBSD__) && __FreeBSD_version >= 801000

    1570. 

  1570. 			CURVNET_RESTORE();

    1571. 

  1571. #endif

    1572. 

  1572. 			return;

    1573. 

  1573. 		}

    1574. 

  1574. 	}

    1575. 

  1575. 	/* record in stopped what t-o occured */

    1576. 

  1576. 	tmr->stopped_from = tmr->type;

    1577. 

  1577. 

    1578. 

  1578. 	/* mark as being serviced now */

    1579. 

  1579. 	if (SCTP_OS_TIMER_PENDING(&tmr->timer)) {

    1580. 

  1580. 		/*

    1581. 

  1581. 		 * Callout has been rescheduled.

    1582. 

  1582. 		 */

    1583. 

  1583. 		goto get_out;

    1584. 

  1584. 	}

    1585. 

  1585. 	if (!SCTP_OS_TIMER_ACTIVE(&tmr->timer)) {

    1586. 

  1586. 		/*

    1587. 

  1587. 		 * Not active, so no action.

    1588. 

  1588. 		 */

    1589. 

  1589. 		goto get_out;

    1590. 

  1590. 	}

    1591. 

  1591. 	SCTP_OS_TIMER_DEACTIVATE(&tmr->timer);

    1592. 

  1592. 

    1593. 

  1593. 	/* call the handler for the appropriate timer type */

    1594. 

  1594. 	switch (tmr->type) {

    1595. 

  1595. 	case SCTP_TIMER_TYPE_ZERO_COPY:

    1596. 

  1596. 		if (inp == NULL) {

    1597. 

  1597. 			break;

    1598. 

  1598. 		}

    1599. 

  1599. 		if (sctp_is_feature_on(inp, SCTP_PCB_FLAGS_ZERO_COPY_ACTIVE)) {

    1600. 

  1600. 			SCTP_ZERO_COPY_EVENT(inp, inp->sctp_socket);

    1601. 

  1601. 		}

    1602. 

  1602. 		break;

    1603. 

  1603. 	case SCTP_TIMER_TYPE_ZCOPY_SENDQ:

    1604. 

  1604. 		if (inp == NULL) {

    1605. 

  1605. 			break;

    1606. 

  1606. 		}

    1607. 

  1607. 		if (sctp_is_feature_on(inp, SCTP_PCB_FLAGS_ZERO_COPY_ACTIVE)) {

    1608. 

  1608. 		    SCTP_ZERO_COPY_SENDQ_EVENT(inp, inp->sctp_socket);

    1609. 

  1609. 		}

    1610. 

  1610.                 break;

    1611. 

  1611. 	case SCTP_TIMER_TYPE_ADDR_WQ:

    1612. 

  1612. 		sctp_handle_addr_wq();

    1613. 

  1613. 		break;

    1614. 

  1614. 	case SCTP_TIMER_TYPE_SEND:

    1615. 

  1615. 		if ((stcb == NULL) || (inp == NULL)) {

    1616. 

  1616. 			break;

    1617. 

  1617. 		}

    1618. 

  1618. 		SCTP_STAT_INCR(sctps_timodata);

    1619. 

  1619. 		stcb->asoc.timodata++;

    1620. 

  1620. 		stcb->asoc.num_send_timers_up--;

    1621. 

  1621. 		if (stcb->asoc.num_send_timers_up < 0) {

    1622. 

  1622. 			stcb->asoc.num_send_timers_up = 0;

    1623. 

  1623. 		}

    1624. 

  1624. 		SCTP_TCB_LOCK_ASSERT(stcb);

    1625. 

  1625. 		if (sctp_t3rxt_timer(inp, stcb, net)) {

    1626. 

  1626. 			/* no need to unlock on tcb its gone */

    1627. 

  1627. 

    1628. 

  1628. 			goto out_decr;

    1629. 

  1629. 		}

    1630. 

  1630. 		SCTP_TCB_LOCK_ASSERT(stcb);

    1631. 

  1631. #ifdef SCTP_AUDITING_ENABLED

    1632. 

  1632. 		sctp_auditing(4, inp, stcb, net);

    1633. 

  1633. #endif

    1634. 

  1634. 		sctp_chunk_output(inp, stcb, SCTP_OUTPUT_FROM_T3, SCTP_SO_NOT_LOCKED);

    1635. 

  1635. 		if ((stcb->asoc.num_send_timers_up == 0) &&

    1636. 

  1636. 		    (stcb->asoc.sent_queue_cnt > 0)) {

    1637. 

  1637. 			struct sctp_tmit_chunk *chk;

    1638. 

  1638. 

    1639. 

  1639. 			/*

    1640. 

  1640. 			 * safeguard. If there on some on the sent queue

    1641. 

  1641. 			 * somewhere but no timers running something is

    1642. 

  1642. 			 * wrong... so we start a timer on the first chunk

    1643. 

  1643. 			 * on the send queue on whatever net it is sent to.

    1644. 

  1644. 			 */

    1645. 

  1645. 			chk = TAILQ_FIRST(&stcb->asoc.sent_queue);

    1646. 

  1646. 			sctp_timer_start(SCTP_TIMER_TYPE_SEND, inp, stcb,

    1647. 

  1647. 			    chk->whoTo);

    1648. 

  1648. 		}

    1649. 

  1649. 		break;

    1650. 

  1650. 	case SCTP_TIMER_TYPE_INIT:

    1651. 

  1651. 		if ((stcb == NULL) || (inp == NULL)) {

    1652. 

  1652. 			break;

    1653. 

  1653. 		}

    1654. 

  1654. 		SCTP_STAT_INCR(sctps_timoinit);

    1655. 

  1655. 		stcb->asoc.timoinit++;

    1656. 

  1656. 		if (sctp_t1init_timer(inp, stcb, net)) {

    1657. 

  1657. 			/* no need to unlock on tcb its gone */

    1658. 

  1658. 			goto out_decr;

    1659. 

  1659. 		}

    1660. 

  1660. 		/* We do output but not here */

    1661. 

  1661. 		did_output = 0;

    1662. 

  1662. 		break;

    1663. 

  1663. 	case SCTP_TIMER_TYPE_RECV:

    1664. 

  1664. 		if ((stcb == NULL) || (inp == NULL)) {

    1665. 

  1665. 			break;

    1666. 

  1666. 		}

    1667. 

  1667. 		SCTP_STAT_INCR(sctps_timosack);

    1668. 

  1668. 		stcb->asoc.timosack++;

    1669. 

  1669. 		sctp_send_sack(stcb, SCTP_SO_NOT_LOCKED);

    1670. 

  1670. #ifdef SCTP_AUDITING_ENABLED

    1671. 

  1671. 		sctp_auditing(4, inp, stcb, net);

    1672. 

  1672. #endif

    1673. 

  1673. 		sctp_chunk_output(inp, stcb, SCTP_OUTPUT_FROM_SACK_TMR, SCTP_SO_NOT_LOCKED);

    1674. 

  1674. 		break;

    1675. 

  1675. 	case SCTP_TIMER_TYPE_SHUTDOWN:

    1676. 

  1676. 		if ((stcb == NULL) || (inp == NULL)) {

    1677. 

  1677. 			break;

    1678. 

  1678. 		}

    1679. 

  1679. 		if (sctp_shutdown_timer(inp, stcb, net)) {

    1680. 

  1680. 			/* no need to unlock on tcb its gone */

    1681. 

  1681. 			goto out_decr;

    1682. 

  1682. 		}

    1683. 

  1683. 		SCTP_STAT_INCR(sctps_timoshutdown);

    1684. 

  1684. 		stcb->asoc.timoshutdown++;

    1685. 

  1685. #ifdef SCTP_AUDITING_ENABLED

    1686. 

  1686. 		sctp_auditing(4, inp, stcb, net);

    1687. 

  1687. #endif

    1688. 

  1688. 		sctp_chunk_output(inp, stcb, SCTP_OUTPUT_FROM_SHUT_TMR, SCTP_SO_NOT_LOCKED);

    1689. 

  1689. 		break;

    1690. 

  1690. 	case SCTP_TIMER_TYPE_HEARTBEAT:

    1691. 

  1691. 		if ((stcb == NULL) || (inp == NULL) || (net == NULL)) {

    1692. 

  1692. 			break;

    1693. 

  1693. 		}

    1694. 

  1694. 		SCTP_STAT_INCR(sctps_timoheartbeat);

    1695. 

  1695. 		stcb->asoc.timoheartbeat++;

    1696. 

  1696. 		if (sctp_heartbeat_timer(inp, stcb, net)) {

    1697. 

  1697. 			/* no need to unlock on tcb its gone */

    1698. 

  1698. 			goto out_decr;

    1699. 

  1699. 		}

    1700. 

  1700. #ifdef SCTP_AUDITING_ENABLED

    1701. 

  1701. 		sctp_auditing(4, inp, stcb, net);

    1702. 

  1702. #endif

    1703. 

  1703. 		if (!(net->dest_state & SCTP_ADDR_NOHB)) {

    1704. 

  1704. 			sctp_timer_start(SCTP_TIMER_TYPE_HEARTBEAT, inp, stcb, net);

    1705. 

  1705. 			sctp_chunk_output(inp, stcb, SCTP_OUTPUT_FROM_HB_TMR, SCTP_SO_NOT_LOCKED);

    1706. 

  1706. 		}

    1707. 

  1707. 		break;

    1708. 

  1708. 	case SCTP_TIMER_TYPE_COOKIE:

    1709. 

  1709. 		if ((stcb == NULL) || (inp == NULL)) {

    1710. 

  1710. 			break;

    1711. 

  1711. 		}

    1712. 

  1712. 

    1713. 

  1713. 		if (sctp_cookie_timer(inp, stcb, net)) {

    1714. 

  1714. 			/* no need to unlock on tcb its gone */

    1715. 

  1715. 			goto out_decr;

    1716. 

  1716. 		}

    1717. 

  1717. 		SCTP_STAT_INCR(sctps_timocookie);

    1718. 

  1718. 		stcb->asoc.timocookie++;

    1719. 

  1719. #ifdef SCTP_AUDITING_ENABLED

    1720. 

  1720. 		sctp_auditing(4, inp, stcb, net);

    1721. 

  1721. #endif

    1722. 

  1722. 		/*

    1723. 

  1723. 		 * We consider T3 and Cookie timer pretty much the same with

    1724. 

  1724. 		 * respect to where from in chunk_output.

    1725. 

  1725. 		 */

    1726. 

  1726. 		sctp_chunk_output(inp, stcb, SCTP_OUTPUT_FROM_T3, SCTP_SO_NOT_LOCKED);

    1727. 

  1727. 		break;

    1728. 

  1728. 	case SCTP_TIMER_TYPE_NEWCOOKIE:

    1729. 

  1729. 		{

    1730. 

  1730. 			struct timeval tv;

    1731. 

  1731. 			int i, secret;

    1732. 

  1732. 			if (inp == NULL) {

    1733. 

  1733. 				break;

    1734. 

  1734. 			}

    1735. 

  1735. 			SCTP_STAT_INCR(sctps_timosecret);

    1736. 

  1736. 			(void)SCTP_GETTIME_TIMEVAL(&tv);

    1737. 

  1737. 			SCTP_INP_WLOCK(inp);

    1738. 

  1738. 			inp->sctp_ep.time_of_secret_change = tv.tv_sec;

    1739. 

  1739. 			inp->sctp_ep.last_secret_number =

    1740. 

  1740. 			    inp->sctp_ep.current_secret_number;

    1741. 

  1741. 			inp->sctp_ep.current_secret_number++;

    1742. 

  1742. 			if (inp->sctp_ep.current_secret_number >=

    1743. 

  1743. 			    SCTP_HOW_MANY_SECRETS) {

    1744. 

  1744. 				inp->sctp_ep.current_secret_number = 0;

    1745. 

  1745. 			}

    1746. 

  1746. 			secret = (int)inp->sctp_ep.current_secret_number;

    1747. 

  1747. 			for (i = 0; i < SCTP_NUMBER_OF_SECRETS; i++) {

    1748. 

  1748. 				inp->sctp_ep.secret_key[secret][i] =

    1749. 

  1749. 				    sctp_select_initial_TSN(&inp->sctp_ep);

    1750. 

  1750. 			}

    1751. 

  1751. 			SCTP_INP_WUNLOCK(inp);

    1752. 

  1752. 			sctp_timer_start(SCTP_TIMER_TYPE_NEWCOOKIE, inp, stcb, net);

    1753. 

  1753. 		}

    1754. 

  1754. 		did_output = 0;

    1755. 

  1755. 		break;

    1756. 

  1756. 	case SCTP_TIMER_TYPE_PATHMTURAISE:

    1757. 

  1757. 		if ((stcb == NULL) || (inp == NULL)) {

    1758. 

  1758. 			break;

    1759. 

  1759. 		}

    1760. 

  1760. 		SCTP_STAT_INCR(sctps_timopathmtu);

    1761. 

  1761. 		sctp_pathmtu_timer(inp, stcb, net);

    1762. 

  1762. 		did_output = 0;

    1763. 

  1763. 		break;

    1764. 

  1764. 	case SCTP_TIMER_TYPE_SHUTDOWNACK:

    1765. 

  1765. 		if ((stcb == NULL) || (inp == NULL)) {

    1766. 

  1766. 			break;

    1767. 

  1767. 		}

    1768. 

  1768. 		if (sctp_shutdownack_timer(inp, stcb, net)) {

    1769. 

  1769. 			/* no need to unlock on tcb its gone */

    1770. 

  1770. 			goto out_decr;

    1771. 

  1771. 		}

    1772. 

  1772. 		SCTP_STAT_INCR(sctps_timoshutdownack);

    1773. 

  1773.  		stcb->asoc.timoshutdownack++;

    1774. 

  1774. #ifdef SCTP_AUDITING_ENABLED

    1775. 

  1775. 		sctp_auditing(4, inp, stcb, net);

    1776. 

  1776. #endif

    1777. 

  1777. 		sctp_chunk_output(inp, stcb, SCTP_OUTPUT_FROM_SHUT_ACK_TMR, SCTP_SO_NOT_LOCKED);

    1778. 

  1778. 		break;

    1779. 

  1779. 	case SCTP_TIMER_TYPE_SHUTDOWNGUARD:

    1780. 

  1780. 		if ((stcb == NULL) || (inp == NULL)) {

    1781. 

  1781. 			break;

    1782. 

  1782. 		}

    1783. 

  1783. 		SCTP_STAT_INCR(sctps_timoshutdownguard);

    1784. 

  1784. 		sctp_abort_an_association(inp, stcb, NULL, SCTP_SO_NOT_LOCKED);

    1785. 

  1785. 		/* no need to unlock on tcb its gone */

    1786. 

  1786. 		goto out_decr;

    1787. 

  1787. 

    1788. 

  1788. 	case SCTP_TIMER_TYPE_STRRESET:

    1789. 

  1789. 		if ((stcb == NULL) || (inp == NULL)) {

    1790. 

  1790. 			break;

    1791. 

  1791. 		}

    1792. 

  1792. 		if (sctp_strreset_timer(inp, stcb, net)) {

    1793. 

  1793. 			/* no need to unlock on tcb its gone */

    1794. 

  1794. 			goto out_decr;

    1795. 

  1795. 		}

    1796. 

  1796. 		SCTP_STAT_INCR(sctps_timostrmrst);

    1797. 

  1797. 		sctp_chunk_output(inp, stcb, SCTP_OUTPUT_FROM_STRRST_TMR, SCTP_SO_NOT_LOCKED);

    1798. 

  1798. 		break;

    1799. 

  1799. 	case SCTP_TIMER_TYPE_ASCONF:

    1800. 

  1800. 		if ((stcb == NULL) || (inp == NULL)) {

    1801. 

  1801. 			break;

    1802. 

  1802. 		}

    1803. 

  1803. 		if (sctp_asconf_timer(inp, stcb, net)) {

    1804. 

  1804. 			/* no need to unlock on tcb its gone */

    1805. 

  1805. 			goto out_decr;

    1806. 

  1806. 		}

    1807. 

  1807. 		SCTP_STAT_INCR(sctps_timoasconf);

    1808. 

  1808. #ifdef SCTP_AUDITING_ENABLED

    1809. 

  1809. 		sctp_auditing(4, inp, stcb, net);

    1810. 

  1810. #endif

    1811. 

  1811. 		sctp_chunk_output(inp, stcb, SCTP_OUTPUT_FROM_ASCONF_TMR, SCTP_SO_NOT_LOCKED);

    1812. 

  1812. 		break;

    1813. 

  1813. 	case SCTP_TIMER_TYPE_PRIM_DELETED:

    1814. 

  1814. 		if ((stcb == NULL) || (inp == NULL)) {

    1815. 

  1815. 			break;

    1816. 

  1816. 		}

    1817. 

  1817. 		sctp_delete_prim_timer(inp, stcb, net);

    1818. 

  1818. 		SCTP_STAT_INCR(sctps_timodelprim);

    1819. 

  1819. 		break;

    1820. 

  1820. 

    1821. 

  1821. 	case SCTP_TIMER_TYPE_AUTOCLOSE:

    1822. 

  1822. 		if ((stcb == NULL) || (inp == NULL)) {

    1823. 

  1823. 			break;

    1824. 

  1824. 		}

    1825. 

  1825. 		SCTP_STAT_INCR(sctps_timoautoclose);

    1826. 

  1826. 		sctp_autoclose_timer(inp, stcb, net);

    1827. 

  1827. 		sctp_chunk_output(inp, stcb, SCTP_OUTPUT_FROM_AUTOCLOSE_TMR, SCTP_SO_NOT_LOCKED);

    1828. 

  1828. 		did_output = 0;

    1829. 

  1829. 		break;

    1830. 

  1830. 	case SCTP_TIMER_TYPE_ASOCKILL:

    1831. 

  1831. 		if ((stcb == NULL) || (inp == NULL)) {

    1832. 

  1832. 			break;

    1833. 

  1833. 		}

    1834. 

  1834. 		SCTP_STAT_INCR(sctps_timoassockill);

    1835. 

  1835. 		/* Can we free it yet? */

    1836. 

  1836. 		SCTP_INP_DECR_REF(inp);

    1837. 

  1837. 		sctp_timer_stop(SCTP_TIMER_TYPE_ASOCKILL, inp, stcb, NULL, SCTP_FROM_SCTPUTIL+SCTP_LOC_1);

    1838. 

  1838. #if defined (__APPLE__) || defined(SCTP_SO_LOCK_TESTING)

    1839. 

  1839. 		so = SCTP_INP_SO(inp);

    1840. 

  1840. 		atomic_add_int(&stcb->asoc.refcnt, 1);

    1841. 

  1841. 		SCTP_TCB_UNLOCK(stcb);

    1842. 

  1842. 		SCTP_SOCKET_LOCK(so, 1);

    1843. 

  1843. 		SCTP_TCB_LOCK(stcb);

    1844. 

  1844. 		atomic_subtract_int(&stcb->asoc.refcnt, 1);

    1845. 

  1845. #endif

    1846. 

  1846. 		(void)sctp_free_assoc(inp, stcb, SCTP_NORMAL_PROC, SCTP_FROM_SCTPUTIL+SCTP_LOC_2);

    1847. 

  1847. #if defined (__APPLE__) || defined(SCTP_SO_LOCK_TESTING)

    1848. 

  1848. 		SCTP_SOCKET_UNLOCK(so, 1);

    1849. 

  1849. #endif

    1850. 

  1850. 		/*

    1851. 

  1851. 		 * free asoc, always unlocks (or destroy's) so prevent

    1852. 

  1852. 		 * duplicate unlock or unlock of a free mtx :-0

    1853. 

  1853. 		 */

    1854. 

  1854. 		stcb = NULL;

    1855. 

  1855. 		goto out_no_decr;

    1856. 

  1856. 	case SCTP_TIMER_TYPE_INPKILL:

    1857. 

  1857. 		SCTP_STAT_INCR(sctps_timoinpkill);

    1858. 

  1858. 		if (inp == NULL) {

    1859. 

  1859. 			break;

    1860. 

  1860. 		}

    1861. 

  1861. 		/*

    1862. 

  1862. 		 * special case, take away our increment since WE are the

    1863. 

  1863. 		 * killer

    1864. 

  1864. 		 */

    1865. 

  1865. 		SCTP_INP_DECR_REF(inp);

    1866. 

  1866. 		sctp_timer_stop(SCTP_TIMER_TYPE_INPKILL, inp, NULL, NULL, SCTP_FROM_SCTPUTIL+SCTP_LOC_3);

    1867. 

  1867. #if defined(__APPLE__)

    1868. 

  1868. 		SCTP_SOCKET_LOCK(SCTP_INP_SO(inp), 1);

    1869. 

  1869. #endif

    1870. 

  1870. 		sctp_inpcb_free(inp, SCTP_FREE_SHOULD_USE_ABORT,

    1871. 

  1871. 				SCTP_CALLED_FROM_INPKILL_TIMER);

    1872. 

  1872. #if defined(__APPLE__)

    1873. 

  1873. 		SCTP_SOCKET_UNLOCK(SCTP_INP_SO(inp), 1);

    1874. 

  1874. #endif

    1875. 

  1875. 		inp = NULL;

    1876. 

  1876. 		goto out_no_decr;

    1877. 

  1877. 	default:

    1878. 

  1878. 		SCTPDBG(SCTP_DEBUG_TIMER1, "sctp_timeout_handler:unknown timer %d\n",

    1879. 

  1879. 			tmr->type);

    1880. 

  1880. 		break;

    1881. 

  1881. 	}

    1882. 

  1882. #ifdef SCTP_AUDITING_ENABLED

    1883. 

  1883. 	sctp_audit_log(0xF1, (uint8_t) tmr->type);

    1884. 

  1884. 	if (inp)

    1885. 

  1885. 		sctp_auditing(5, inp, stcb, net);

    1886. 

  1886. #endif

    1887. 

  1887. 	if ((did_output) && stcb) {

    1888. 

  1888. 		/*

    1889. 

  1889. 		 * Now we need to clean up the control chunk chain if an

    1890. 

  1890. 		 * ECNE is on it. It must be marked as UNSENT again so next

    1891. 

  1891. 		 * call will continue to send it until such time that we get

    1892. 

  1892. 		 * a CWR, to remove it. It is, however, less likely that we

    1893. 

  1893. 		 * will find a ecn echo on the chain though.

    1894. 

  1894. 		 */

    1895. 

  1895. 		sctp_fix_ecn_echo(&stcb->asoc);

    1896. 

  1896. 	}

    1897. 

  1897. get_out:

    1898. 

  1898. 	if (stcb) {

    1899. 

  1899. 		SCTP_TCB_UNLOCK(stcb);

    1900. 

  1900. 	}

    1901. 

  1901. 

    1902. 

  1902. out_decr:

    1903. 

  1903. 	if (inp) {

    1904. 

  1904. 		SCTP_INP_DECR_REF(inp);

    1905. 

  1905. 	}

    1906. 

  1906. 

    1907. 

  1907. out_no_decr:

    1908. 

  1908. 	SCTPDBG(SCTP_DEBUG_TIMER1, "Timer now complete (type %d)\n",

    1909. 

  1909. 			  type);

    1910. 

  1910. #if defined(__FreeBSD__) && __FreeBSD_version >= 801000

    1911. 

  1911. 	CURVNET_RESTORE();

    1912. 

  1912. #endif

    1913. 

  1913. }

    1914. 

  1914. 

    1915. 

  1915. void

    1916. 

  1916. sctp_timer_start(int t_type, struct sctp_inpcb *inp, struct sctp_tcb *stcb,

    1917. 

  1917.     struct sctp_nets *net)

    1918. 

  1918. {

    1919. 

  1919. 	uint32_t to_ticks;

    1920. 

  1920. 	struct sctp_timer *tmr;

    1921. 

  1921. 

    1922. 

  1922. 	if ((t_type != SCTP_TIMER_TYPE_ADDR_WQ) && (inp == NULL))

    1923. 

  1923. 		return;

    1924. 

  1924. 

    1925. 

  1925. 	tmr = NULL;

    1926. 

  1926. 	if (stcb) {

    1927. 

  1927. 		SCTP_TCB_LOCK_ASSERT(stcb);

    1928. 

  1928. 	}

    1929. 

  1929. 	switch (t_type) {

    1930. 

  1930. 	case SCTP_TIMER_TYPE_ZERO_COPY:

    1931. 

  1931. 		tmr = &inp->sctp_ep.zero_copy_timer;

    1932. 

  1932. 		to_ticks = SCTP_ZERO_COPY_TICK_DELAY;

    1933. 

  1933. 		break;

    1934. 

  1934. 	case SCTP_TIMER_TYPE_ZCOPY_SENDQ:

    1935. 

  1935. 		tmr = &inp->sctp_ep.zero_copy_sendq_timer;

    1936. 

  1936. 		to_ticks = SCTP_ZERO_COPY_SENDQ_TICK_DELAY;

    1937. 

  1937. 		break;

    1938. 

  1938. 	case SCTP_TIMER_TYPE_ADDR_WQ:

    1939. 

  1939. 		/* Only 1 tick away :-) */

    1940. 

  1940. 		tmr = &SCTP_BASE_INFO(addr_wq_timer);

    1941. 

  1941. 		to_ticks = SCTP_ADDRESS_TICK_DELAY;

    1942. 

  1942. 		break;

    1943. 

  1943. 	case SCTP_TIMER_TYPE_SEND:

    1944. 

  1944. 		/* Here we use the RTO timer */

    1945. 

  1945. 		{

    1946. 

  1946. 			int rto_val;

    1947. 

  1947. 

    1948. 

  1948. 			if ((stcb == NULL) || (net == NULL)) {

    1949. 

  1949. 				return;

    1950. 

  1950. 			}

    1951. 

  1951. 			tmr = &net->rxt_timer;

    1952. 

  1952. 			if (net->RTO == 0) {

    1953. 

  1953. 				rto_val = stcb->asoc.initial_rto;

    1954. 

  1954. 			} else {

    1955. 

  1955. 				rto_val = net->RTO;

    1956. 

  1956. 			}

    1957. 

  1957. 			to_ticks = MSEC_TO_TICKS(rto_val);

    1958. 

  1958. 		}

    1959. 

  1959. 		break;

    1960. 

  1960. 	case SCTP_TIMER_TYPE_INIT:

    1961. 

  1961. 		/*

    1962. 

  1962. 		 * Here we use the INIT timer default usually about 1

    1963. 

  1963. 		 * minute.

    1964. 

  1964. 		 */

    1965. 

  1965. 		if ((stcb == NULL) || (net == NULL)) {

    1966. 

  1966. 			return;

    1967. 

  1967. 		}

    1968. 

  1968. 		tmr = &net->rxt_timer;

    1969. 

  1969. 		if (net->RTO == 0) {

    1970. 

  1970. 			to_ticks = MSEC_TO_TICKS(stcb->asoc.initial_rto);

    1971. 

  1971. 		} else {

    1972. 

  1972. 			to_ticks = MSEC_TO_TICKS(net->RTO);

    1973. 

  1973. 		}

    1974. 

  1974. 		break;

    1975. 

  1975. 	case SCTP_TIMER_TYPE_RECV:

    1976. 

  1976. 		/*

    1977. 

  1977. 		 * Here we use the Delayed-Ack timer value from the inp

    1978. 

  1978. 		 * ususually about 200ms.

    1979. 

  1979. 		 */

    1980. 

  1980. 		if (stcb == NULL) {

    1981. 

  1981. 			return;

    1982. 

  1982. 		}

    1983. 

  1983. 		tmr = &stcb->asoc.dack_timer;

    1984. 

  1984. 		to_ticks = MSEC_TO_TICKS(stcb->asoc.delayed_ack);

    1985. 

  1985. 		break;

    1986. 

  1986. 	case SCTP_TIMER_TYPE_SHUTDOWN:

    1987. 

  1987. 		/* Here we use the RTO of the destination. */

    1988. 

  1988. 		if ((stcb == NULL) || (net == NULL)) {

    1989. 

  1989. 			return;

    1990. 

  1990. 		}

    1991. 

  1991. 		if (net->RTO == 0) {

    1992. 

  1992. 			to_ticks = MSEC_TO_TICKS(stcb->asoc.initial_rto);

    1993. 

  1993. 		} else {

    1994. 

  1994. 			to_ticks = MSEC_TO_TICKS(net->RTO);

    1995. 

  1995. 		}

    1996. 

  1996. 		tmr = &net->rxt_timer;

    1997. 

  1997. 		break;

    1998. 

  1998. 	case SCTP_TIMER_TYPE_HEARTBEAT:

    1999. 

  1999. 		/*

    2000. 

  2000. 		 * the net is used here so that we can add in the RTO. Even

    2001. 

  2001. 		 * though we use a different timer. We also add the HB timer

    2002. 

  2002. 		 * PLUS a random jitter.

    2003. 

  2003. 		 */

    2004. 

  2004. 		if ((inp == NULL) || (stcb == NULL) || (net == NULL)) {

    2005. 

  2005. 			return;

    2006. 

  2006. 		} else {

    2007. 

  2007. 			uint32_t rndval;

    2008. 

  2008. 			uint32_t jitter;

    2009. 

  2009. 

    2010. 

  2010. 			if ((net->dest_state & SCTP_ADDR_NOHB) &&

    2011. 

  2011. 			    !(net->dest_state & SCTP_ADDR_UNCONFIRMED)) {

    2012. 

  2012. 				return;

    2013. 

  2013. 			}

    2014. 

  2014. 			if (net->RTO == 0) {

    2015. 

  2015. 				to_ticks = stcb->asoc.initial_rto;

    2016. 

  2016. 			} else {

    2017. 

  2017. 				to_ticks = net->RTO;

    2018. 

  2018. 			}

    2019. 

  2019. 			rndval = sctp_select_initial_TSN(&inp->sctp_ep);

    2020. 

  2020. 			jitter = rndval % to_ticks;

    2021. 

  2021. 			if (jitter >= (to_ticks >> 1)) {

    2022. 

  2022. 				to_ticks = to_ticks + (jitter - (to_ticks >> 1));

    2023. 

  2023. 			} else {

    2024. 

  2024. 				to_ticks = to_ticks - jitter;

    2025. 

  2025. 			}

    2026. 

  2026. 			if (!(net->dest_state & SCTP_ADDR_UNCONFIRMED) &&

    2027. 

  2027. 			    !(net->dest_state & SCTP_ADDR_PF)) {

    2028. 

  2028. 				to_ticks += net->heart_beat_delay;

    2029. 

  2029. 			}

    2030. 

  2030. 			/*

    2031. 

  2031. 			 * Now we must convert the to_ticks that are now in

    2032. 

  2032. 			 * ms to ticks.

    2033. 

  2033. 			 */

    2034. 

  2034. 			to_ticks = MSEC_TO_TICKS(to_ticks);

    2035. 

  2035. 			tmr = &net->hb_timer;

    2036. 

  2036. 		}

    2037. 

  2037. 		break;

    2038. 

  2038. 	case SCTP_TIMER_TYPE_COOKIE:

    2039. 

  2039. 		/*

    2040. 

  2040. 		 * Here we can use the RTO timer from the network since one

    2041. 

  2041. 		 * RTT was compelete. If a retran happened then we will be

    2042. 

  2042. 		 * using the RTO initial value.

    2043. 

  2043. 		 */

    2044. 

  2044. 		if ((stcb == NULL) || (net == NULL)) {

    2045. 

  2045. 			return;

    2046. 

  2046. 		}

    2047. 

  2047. 		if (net->RTO == 0) {

    2048. 

  2048. 			to_ticks = MSEC_TO_TICKS(stcb->asoc.initial_rto);

    2049. 

  2049. 		} else {

    2050. 

  2050. 			to_ticks = MSEC_TO_TICKS(net->RTO);

    2051. 

  2051. 		}

    2052. 

  2052. 		tmr = &net->rxt_timer;

    2053. 

  2053. 		break;

    2054. 

  2054. 	case SCTP_TIMER_TYPE_NEWCOOKIE:

    2055. 

  2055. 		/*

    2056. 

  2056. 		 * nothing needed but the endpoint here ususually about 60

    2057. 

  2057. 		 * minutes.

    2058. 

  2058. 		 */

    2059. 

  2059. 		if (inp == NULL) {

    2060. 

  2060. 			return;

    2061. 

  2061. 		}

    2062. 

  2062. 		tmr = &inp->sctp_ep.signature_change;

    2063. 

  2063. 		to_ticks = inp->sctp_ep.sctp_timeoutticks[SCTP_TIMER_SIGNATURE];

    2064. 

  2064. 		break;

    2065. 

  2065. 	case SCTP_TIMER_TYPE_ASOCKILL:

    2066. 

  2066. 		if (stcb == NULL) {

    2067. 

  2067. 			return;

    2068. 

  2068. 		}

    2069. 

  2069. 		tmr = &stcb->asoc.strreset_timer;

    2070. 

  2070. 		to_ticks = MSEC_TO_TICKS(SCTP_ASOC_KILL_TIMEOUT);

    2071. 

  2071. 		break;

    2072. 

  2072. 	case SCTP_TIMER_TYPE_INPKILL:

    2073. 

  2073. 		/*

    2074. 

  2074. 		 * The inp is setup to die. We re-use the signature_chage

    2075. 

  2075. 		 * timer since that has stopped and we are in the GONE

    2076. 

  2076. 		 * state.

    2077. 

  2077. 		 */

    2078. 

  2078. 		if (inp == NULL) {

    2079. 

  2079. 			return;

    2080. 

  2080. 		}

    2081. 

  2081. 		tmr = &inp->sctp_ep.signature_change;

    2082. 

  2082. 		to_ticks = MSEC_TO_TICKS(SCTP_INP_KILL_TIMEOUT);

    2083. 

  2083. 		break;

    2084. 

  2084. 	case SCTP_TIMER_TYPE_PATHMTURAISE:

    2085. 

  2085. 		/*

    2086. 

  2086. 		 * Here we use the value found in the EP for PMTU ususually

    2087. 

  2087. 		 * about 10 minutes.

    2088. 

  2088. 		 */

    2089. 

  2089. 		if ((stcb == NULL) || (inp == NULL)) {

    2090. 

  2090. 			return;

    2091. 

  2091. 		}

    2092. 

  2092. 		if (net == NULL) {

    2093. 

  2093. 			return;

    2094. 

  2094. 		}

    2095. 

  2095. 		if (net->dest_state & SCTP_ADDR_NO_PMTUD) {

    2096. 

  2096. 			return;

    2097. 

  2097. 		}

    2098. 

  2098. 		to_ticks = inp->sctp_ep.sctp_timeoutticks[SCTP_TIMER_PMTU];

    2099. 

  2099. 		tmr = &net->pmtu_timer;

    2100. 

  2100. 		break;

    2101. 

  2101. 	case SCTP_TIMER_TYPE_SHUTDOWNACK:

    2102. 

  2102. 		/* Here we use the RTO of the destination */

    2103. 

  2103. 		if ((stcb == NULL) || (net == NULL)) {

    2104. 

  2104. 			return;

    2105. 

  2105. 		}

    2106. 

  2106. 		if (net->RTO == 0) {

    2107. 

  2107. 			to_ticks = MSEC_TO_TICKS(stcb->asoc.initial_rto);

    2108. 

  2108. 		} else {

    2109. 

  2109. 			to_ticks = MSEC_TO_TICKS(net->RTO);

    2110. 

  2110. 		}

    2111. 

  2111. 		tmr = &net->rxt_timer;

    2112. 

  2112. 		break;

    2113. 

  2113. 	case SCTP_TIMER_TYPE_SHUTDOWNGUARD:

    2114. 

  2114. 		/*

    2115. 

  2115. 		 * Here we use the endpoints shutdown guard timer usually

    2116. 

  2116. 		 * about 3 minutes.

    2117. 

  2117. 		 */

    2118. 

  2118. 		if ((inp == NULL) || (stcb == NULL)) {

    2119. 

  2119. 			return;

    2120. 

  2120. 		}

    2121. 

  2121. 		to_ticks = inp->sctp_ep.sctp_timeoutticks[SCTP_TIMER_MAXSHUTDOWN];

    2122. 

  2122. 		tmr = &stcb->asoc.shut_guard_timer;

    2123. 

  2123. 		break;

    2124. 

  2124. 	case SCTP_TIMER_TYPE_STRRESET:

    2125. 

  2125. 		/*

    2126. 

  2126. 		 * Here the timer comes from the stcb but its value is from

    2127. 

  2127. 		 * the net's RTO.

    2128. 

  2128. 		 */

    2129. 

  2129. 		if ((stcb == NULL) || (net == NULL)) {

    2130. 

  2130. 			return;

    2131. 

  2131. 		}

    2132. 

  2132. 		if (net->RTO == 0) {

    2133. 

  2133. 			to_ticks = MSEC_TO_TICKS(stcb->asoc.initial_rto);

    2134. 

  2134. 		} else {

    2135. 

  2135. 			to_ticks = MSEC_TO_TICKS(net->RTO);

    2136. 

  2136. 		}

    2137. 

  2137. 		tmr = &stcb->asoc.strreset_timer;

    2138. 

  2138. 		break;

    2139. 

  2139. 	case SCTP_TIMER_TYPE_ASCONF:

    2140. 

  2140. 		/*

    2141. 

  2141. 		 * Here the timer comes from the stcb but its value is from

    2142. 

  2142. 		 * the net's RTO.

    2143. 

  2143. 		 */

    2144. 

  2144. 		if ((stcb == NULL) || (net == NULL)) {

    2145. 

  2145. 			return;

    2146. 

  2146. 		}

    2147. 

  2147. 		if (net->RTO == 0) {

    2148. 

  2148. 			to_ticks = MSEC_TO_TICKS(stcb->asoc.initial_rto);

    2149. 

  2149. 		} else {

    2150. 

  2150. 			to_ticks = MSEC_TO_TICKS(net->RTO);

    2151. 

  2151. 		}

    2152. 

  2152. 		tmr = &stcb->asoc.asconf_timer;

    2153. 

  2153. 		break;

    2154. 

  2154. 	case SCTP_TIMER_TYPE_PRIM_DELETED:

    2155. 

  2155. 		if ((stcb == NULL) || (net != NULL)) {

    2156. 

  2156. 			return;

    2157. 

  2157. 		}

    2158. 

  2158. 		to_ticks = MSEC_TO_TICKS(stcb->asoc.initial_rto);

    2159. 

  2159. 		tmr = &stcb->asoc.delete_prim_timer;

    2160. 

  2160. 		break;

    2161. 

  2161. 	case SCTP_TIMER_TYPE_AUTOCLOSE:

    2162. 

  2162. 		if (stcb == NULL) {

    2163. 

  2163. 			return;

    2164. 

  2164. 		}

    2165. 

  2165. 		if (stcb->asoc.sctp_autoclose_ticks == 0) {

    2166. 

  2166. 			/*

    2167. 

  2167. 			 * Really an error since stcb is NOT set to

    2168. 

  2168. 			 * autoclose

    2169. 

  2169. 			 */

    2170. 

  2170. 			return;

    2171. 

  2171. 		}

    2172. 

  2172. 		to_ticks = stcb->asoc.sctp_autoclose_ticks;

    2173. 

  2173. 		tmr = &stcb->asoc.autoclose_timer;

    2174. 

  2174. 		break;

    2175. 

  2175. 	default:

    2176. 

  2176. 		SCTPDBG(SCTP_DEBUG_TIMER1, "%s: Unknown timer type %d\n",

    2177. 

  2177. 			__FUNCTION__, t_type);

    2178. 

  2178. 		return;

    2179. 

  2179. 		break;

    2180. 

  2180. 	}

    2181. 

  2181. 	if ((to_ticks <= 0) || (tmr == NULL)) {

    2182. 

  2182. 		SCTPDBG(SCTP_DEBUG_TIMER1, "%s: %d:software error to_ticks:%d tmr:%p not set ??\n",

    2183. 

  2183. 			__FUNCTION__, t_type, to_ticks, tmr);

    2184. 

  2184. 		return;

    2185. 

  2185. 	}

    2186. 

  2186. 	if (SCTP_OS_TIMER_PENDING(&tmr->timer)) {

    2187. 

  2187. 		/*

    2188. 

  2188. 		 * we do NOT allow you to have it already running. if it is

    2189. 

  2189. 		 * we leave the current one up unchanged

    2190. 

  2190. 		 */

    2191. 

  2191. 		return;

    2192. 

  2192. 	}

    2193. 

  2193. 	/* At this point we can proceed */

    2194. 

  2194. 	if (t_type == SCTP_TIMER_TYPE_SEND) {

    2195. 

  2195. 		stcb->asoc.num_send_timers_up++;

    2196. 

  2196. 	}

    2197. 

  2197. 	tmr->stopped_from = 0;

    2198. 

  2198. 	tmr->type = t_type;

    2199. 

  2199. 	tmr->ep = (void *)inp;

    2200. 

  2200. 	tmr->tcb = (void *)stcb;

    2201. 

  2201. 	tmr->net = (void *)net;

    2202. 

  2202. 	tmr->self = (void *)tmr;

    2203. 

  2203. #if defined(__FreeBSD__) && __FreeBSD_version >= 800000

    2204. 

  2204. 	tmr->vnet = (void *)curvnet;

    2205. 

  2205. #endif

    2206. 

  2206. #ifndef __Panda__

    2207. 

  2207. 	tmr->ticks = sctp_get_tick_count();

    2208. 

  2208. #endif

    2209. 

  2209. 	(void)SCTP_OS_TIMER_START(&tmr->timer, to_ticks, sctp_timeout_handler, tmr);

    2210. 

  2210. 	return;

    2211. 

  2211. }

    2212. 

  2212. 

    2213. 

  2213. void

    2214. 

  2214. sctp_timer_stop(int t_type, struct sctp_inpcb *inp, struct sctp_tcb *stcb,

    2215. 

  2215.     struct sctp_nets *net, uint32_t from)

    2216. 

  2216. {

    2217. 

  2217. 	struct sctp_timer *tmr;

    2218. 

  2218. 

    2219. 

  2219. 	if ((t_type != SCTP_TIMER_TYPE_ADDR_WQ) &&

    2220. 

  2220. 	    (inp == NULL))

    2221. 

  2221. 		return;

    2222. 

  2222. 

    2223. 

  2223. 	tmr = NULL;

    2224. 

  2224. 	if (stcb) {

    2225. 

  2225. 		SCTP_TCB_LOCK_ASSERT(stcb);

    2226. 

  2226. 	}

    2227. 

  2227. 	switch (t_type) {

    2228. 

  2228. 	case SCTP_TIMER_TYPE_ZERO_COPY:

    2229. 

  2229. 		tmr = &inp->sctp_ep.zero_copy_timer;

    2230. 

  2230. 		break;

    2231. 

  2231. 	case SCTP_TIMER_TYPE_ZCOPY_SENDQ:

    2232. 

  2232. 		tmr = &inp->sctp_ep.zero_copy_sendq_timer;

    2233. 

  2233. 		break;

    2234. 

  2234. 	case SCTP_TIMER_TYPE_ADDR_WQ:

    2235. 

  2235. 		tmr = &SCTP_BASE_INFO(addr_wq_timer);

    2236. 

  2236. 		break;

    2237. 

  2237. 	case SCTP_TIMER_TYPE_SEND:

    2238. 

  2238. 		if ((stcb == NULL) || (net == NULL)) {

    2239. 

  2239. 			return;

    2240. 

  2240. 		}

    2241. 

  2241. 		tmr = &net->rxt_timer;

    2242. 

  2242. 		break;

    2243. 

  2243. 	case SCTP_TIMER_TYPE_INIT:

    2244. 

  2244. 		if ((stcb == NULL) || (net == NULL)) {

    2245. 

  2245. 			return;

    2246. 

  2246. 		}

    2247. 

  2247. 		tmr = &net->rxt_timer;

    2248. 

  2248. 		break;

    2249. 

  2249. 	case SCTP_TIMER_TYPE_RECV:

    2250. 

  2250. 		if (stcb == NULL) {

    2251. 

  2251. 			return;

    2252. 

  2252. 		}

    2253. 

  2253. 		tmr = &stcb->asoc.dack_timer;

    2254. 

  2254. 		break;

    2255. 

  2255. 	case SCTP_TIMER_TYPE_SHUTDOWN:

    2256. 

  2256. 		if ((stcb == NULL) || (net == NULL)) {

    2257. 

  2257. 			return;

    2258. 

  2258. 		}

    2259. 

  2259. 		tmr = &net->rxt_timer;

    2260. 

  2260. 		break;

    2261. 

  2261. 	case SCTP_TIMER_TYPE_HEARTBEAT:

    2262. 

  2262. 		if ((stcb == NULL) || (net == NULL)) {

    2263. 

  2263. 			return;

    2264. 

  2264. 		}

    2265. 

  2265. 		tmr = &net->hb_timer;

    2266. 

  2266. 		break;

    2267. 

  2267. 	case SCTP_TIMER_TYPE_COOKIE:

    2268. 

  2268. 		if ((stcb == NULL) || (net == NULL)) {

    2269. 

  2269. 			return;

    2270. 

  2270. 		}

    2271. 

  2271. 		tmr = &net->rxt_timer;

    2272. 

  2272. 		break;

    2273. 

  2273. 	case SCTP_TIMER_TYPE_NEWCOOKIE:

    2274. 

  2274. 		/* nothing needed but the endpoint here */

    2275. 

  2275. 		tmr = &inp->sctp_ep.signature_change;

    2276. 

  2276. 		/*

    2277. 

  2277. 		 * We re-use the newcookie timer for the INP kill timer. We

    2278. 

  2278. 		 * must assure that we do not kill it by accident.

    2279. 

  2279. 		 */

    2280. 

  2280. 		break;

    2281. 

  2281. 	case SCTP_TIMER_TYPE_ASOCKILL:

    2282. 

  2282. 		/*

    2283. 

  2283. 		 * Stop the asoc kill timer.

    2284. 

  2284. 		 */

    2285. 

  2285. 		if (stcb == NULL) {

    2286. 

  2286. 			return;

    2287. 

  2287. 		}

    2288. 

  2288. 		tmr = &stcb->asoc.strreset_timer;

    2289. 

  2289. 		break;

    2290. 

  2290. 

    2291. 

  2291. 	case SCTP_TIMER_TYPE_INPKILL:

    2292. 

  2292. 		/*

    2293. 

  2293. 		 * The inp is setup to die. We re-use the signature_chage

    2294. 

  2294. 		 * timer since that has stopped and we are in the GONE

    2295. 

  2295. 		 * state.

    2296. 

  2296. 		 */

    2297. 

  2297. 		tmr = &inp->sctp_ep.signature_change;

    2298. 

  2298. 		break;

    2299. 

  2299. 	case SCTP_TIMER_TYPE_PATHMTURAISE:

    2300. 

  2300. 		if ((stcb == NULL) || (net == NULL)) {

    2301. 

  2301. 			return;

    2302. 

  2302. 		}

    2303. 

  2303. 		tmr = &net->pmtu_timer;

    2304. 

  2304. 		break;

    2305. 

  2305. 	case SCTP_TIMER_TYPE_SHUTDOWNACK:

    2306. 

  2306. 		if ((stcb == NULL) || (net == NULL)) {

    2307. 

  2307. 			return;

    2308. 

  2308. 		}

    2309. 

  2309. 		tmr = &net->rxt_timer;

    2310. 

  2310. 		break;

    2311. 

  2311. 	case SCTP_TIMER_TYPE_SHUTDOWNGUARD:

    2312. 

  2312. 		if (stcb == NULL) {

    2313. 

  2313. 			return;

    2314. 

  2314. 		}

    2315. 

  2315. 		tmr = &stcb->asoc.shut_guard_timer;

    2316. 

  2316. 		break;

    2317. 

  2317. 	case SCTP_TIMER_TYPE_STRRESET:

    2318. 

  2318. 		if (stcb == NULL) {

    2319. 

  2319. 			return;

    2320. 

  2320. 		}

    2321. 

  2321. 		tmr = &stcb->asoc.strreset_timer;

    2322. 

  2322. 		break;

    2323. 

  2323. 	case SCTP_TIMER_TYPE_ASCONF:

    2324. 

  2324. 		if (stcb == NULL) {

    2325. 

  2325. 			return;

    2326. 

  2326. 		}

    2327. 

  2327. 		tmr = &stcb->asoc.asconf_timer;

    2328. 

  2328. 		break;

    2329. 

  2329. 	case SCTP_TIMER_TYPE_PRIM_DELETED:

    2330. 

  2330. 		if (stcb == NULL) {

    2331. 

  2331. 			return;

    2332. 

  2332. 		}

    2333. 

  2333. 		tmr = &stcb->asoc.delete_prim_timer;

    2334. 

  2334. 		break;

    2335. 

  2335. 	case SCTP_TIMER_TYPE_AUTOCLOSE:

    2336. 

  2336. 		if (stcb == NULL) {

    2337. 

  2337. 			return;

    2338. 

  2338. 		}

    2339. 

  2339. 		tmr = &stcb->asoc.autoclose_timer;

    2340. 

  2340. 		break;

    2341. 

  2341. 	default:

    2342. 

  2342. 		SCTPDBG(SCTP_DEBUG_TIMER1, "%s: Unknown timer type %d\n",

    2343. 

  2343. 			__FUNCTION__, t_type);

    2344. 

  2344. 		break;

    2345. 

  2345. 	}

    2346. 

  2346. 	if (tmr == NULL) {

    2347. 

  2347. 		return;

    2348. 

  2348. 	}

    2349. 

  2349. 	if ((tmr->type != t_type) && tmr->type) {

    2350. 

  2350. 		/*

    2351. 

  2351. 		 * Ok we have a timer that is under joint use. Cookie timer

    2352. 

  2352. 		 * per chance with the SEND timer. We therefore are NOT

    2353. 

  2353. 		 * running the timer that the caller wants stopped.  So just

    2354. 

  2354. 		 * return.

    2355. 

  2355. 		 */

    2356. 

  2356. 		return;

    2357. 

  2357. 	}

    2358. 

  2358. 	if ((t_type == SCTP_TIMER_TYPE_SEND) && (stcb != NULL)) {

    2359. 

  2359. 		stcb->asoc.num_send_timers_up--;

    2360. 

  2360. 		if (stcb->asoc.num_send_timers_up < 0) {

    2361. 

  2361. 			stcb->asoc.num_send_timers_up = 0;

    2362. 

  2362. 		}

    2363. 

  2363. 	}

    2364. 

  2364. 	tmr->self = NULL;

    2365. 

  2365. 	tmr->stopped_from = from;

    2366. 

  2366. 	(void)SCTP_OS_TIMER_STOP(&tmr->timer);

    2367. 

  2367. 	return;

    2368. 

  2368. }

    2369. 

  2369. 

    2370. 

  2370. uint32_t

    2371. 

  2371. sctp_calculate_len(struct mbuf *m)

    2372. 

  2372. {

    2373. 

  2373. 	uint32_t tlen = 0;

    2374. 

  2374. 	struct mbuf *at;

    2375. 

  2375. 

    2376. 

  2376. 	at = m;

    2377. 

  2377. 	while (at) {

    2378. 

  2378. 		tlen += SCTP_BUF_LEN(at);

    2379. 

  2379. 		at = SCTP_BUF_NEXT(at);

    2380. 

  2380. 	}

    2381. 

  2381. 	return (tlen);

    2382. 

  2382. }

    2383. 

  2383. 

    2384. 

  2384. void

    2385. 

  2385. sctp_mtu_size_reset(struct sctp_inpcb *inp,

    2386. 

  2386.     struct sctp_association *asoc, uint32_t mtu)

    2387. 

  2387. {

    2388. 

  2388. 	/*

    2389. 

  2389. 	 * Reset the P-MTU size on this association, this involves changing

    2390. 

  2390. 	 * the asoc MTU, going through ANY chunk+overhead larger than mtu to

    2391. 

  2391. 	 * allow the DF flag to be cleared.

    2392. 

  2392. 	 */

    2393. 

  2393. 	struct sctp_tmit_chunk *chk;

    2394. 

  2394. 	unsigned int eff_mtu, ovh;

    2395. 

  2395. 

    2396. 

  2396. 	asoc->smallest_mtu = mtu;

    2397. 

  2397. 	if (inp->sctp_flags & SCTP_PCB_FLAGS_BOUND_V6) {

    2398. 

  2398. 		ovh = SCTP_MIN_OVERHEAD;

    2399. 

  2399. 	} else {

    2400. 

  2400. 		ovh = SCTP_MIN_V4_OVERHEAD;

    2401. 

  2401. 	}

    2402. 

  2402. 	eff_mtu = mtu - ovh;

    2403. 

  2403. 	TAILQ_FOREACH(chk, &asoc->send_queue, sctp_next) {

    2404. 

  2404. 		if (chk->send_size > eff_mtu) {

    2405. 

  2405. 			chk->flags |= CHUNK_FLAGS_FRAGMENT_OK;

    2406. 

  2406. 		}

    2407. 

  2407. 	}

    2408. 

  2408. 	TAILQ_FOREACH(chk, &asoc->sent_queue, sctp_next) {

    2409. 

  2409. 		if (chk->send_size > eff_mtu) {

    2410. 

  2410. 			chk->flags |= CHUNK_FLAGS_FRAGMENT_OK;

    2411. 

  2411. 		}

    2412. 

  2412. 	}

    2413. 

  2413. }

    2414. 

  2414. 

    2415. 

  2415. 

    2416. 

  2416. /*

    2417. 

  2417.  * given an association and starting time of the current RTT period return

    2418. 

  2418.  * RTO in number of msecs net should point to the current network

    2419. 

  2419.  */

    2420. 

  2420. 

    2421. 

  2421. uint32_t

    2422. 

  2422. sctp_calculate_rto(struct sctp_tcb *stcb,

    2423. 

  2423. 		   struct sctp_association *asoc,

    2424. 

  2424. 		   struct sctp_nets *net,

    2425. 

  2425. 		   struct timeval *told,

    2426. 

  2426. 		   int safe, int rtt_from_sack)

    2427. 

  2427. {

    2428. 

  2428. 	/*-

    2429. 

  2429. 	 * given an association and the starting time of the current RTT

    2430. 

  2430. 	 * period (in value1/value2) return RTO in number of msecs.

    2431. 

  2431. 	 */

    2432. 

  2432. 	int32_t rtt; /* RTT in ms */

    2433. 

  2433. 	uint32_t new_rto;

    2434. 

  2434. 	int first_measure = 0;

    2435. 

  2435. 	struct timeval now, then, *old;

    2436. 

  2436. 

    2437. 

  2437. 	/* Copy it out for sparc64 */

    2438. 

  2438. 	if (safe == sctp_align_unsafe_makecopy) {

    2439. 

  2439. 		old = &then;

    2440. 

  2440. 		memcpy(&then, told, sizeof(struct timeval));

    2441. 

  2441. 	} else if (safe == sctp_align_safe_nocopy) {

    2442. 

  2442. 		old = told;

    2443. 

  2443. 	} else {

    2444. 

  2444. 		/* error */

    2445. 

  2445. 		SCTP_PRINTF("Huh, bad rto calc call\n");

    2446. 

  2446. 		return (0);

    2447. 

  2447. 	}

    2448. 

  2448. 	/************************/

    2449. 

  2449. 	/* 1. calculate new RTT */

    2450. 

  2450. 	/************************/

    2451. 

  2451. 	/* get the current time */

    2452. 

  2452. 	if (stcb->asoc.use_precise_time) {

    2453. 

  2453. 		(void)SCTP_GETPTIME_TIMEVAL(&now);

    2454. 

  2454. 	} else {

    2455. 

  2455. 		(void)SCTP_GETTIME_TIMEVAL(&now);

    2456. 

  2456. 	}

    2457. 

  2457. 	timevalsub(&now, old);

    2458. 

  2458. 	/* store the current RTT in us */

    2459. 

  2459. 	net->rtt = (uint64_t)10000000 * (uint64_t)now.tv_sec +

    2460. 

  2460. 	           (uint64_t)now.tv_usec;

    2461. 

  2461. 	/* computer rtt in ms */

    2462. 

  2462. 	rtt = net->rtt / 1000;

    2463. 

  2463. 	if ((asoc->cc_functions.sctp_rtt_calculated) && (rtt_from_sack == SCTP_RTT_FROM_DATA)) {

    2464. 

  2464. 		/* Tell the CC module that a new update has just occurred from a sack */

    2465. 

  2465. 		(*asoc->cc_functions.sctp_rtt_calculated)(stcb, net, &now);

    2466. 

  2466. 	}

    2467. 

  2467. 	/* Do we need to determine the lan? We do this only

    2468. 

  2468. 	 * on sacks i.e. RTT being determined from data not

    2469. 

  2469. 	 * non-data (HB/INIT->INITACK).

    2470. 

  2470. 	 */

    2471. 

  2471. 	if ((rtt_from_sack == SCTP_RTT_FROM_DATA) &&

    2472. 

  2472. 	    (net->lan_type == SCTP_LAN_UNKNOWN)) {

    2473. 

  2473. 		if (net->rtt > SCTP_LOCAL_LAN_RTT) {

    2474. 

  2474. 			net->lan_type = SCTP_LAN_INTERNET;

    2475. 

  2475. 		} else {

    2476. 

  2476. 			net->lan_type = SCTP_LAN_LOCAL;

    2477. 

  2477. 		}

    2478. 

  2478. 	}

    2479. 

  2479. 

    2480. 

  2480. 	/***************************/

    2481. 

  2481. 	/* 2. update RTTVAR & SRTT */

    2482. 

  2482. 	/***************************/

    2483. 

  2483. 	/*-

    2484. 

  2484. 	 * Compute the scaled average lastsa and the

    2485. 

  2485. 	 * scaled variance lastsv as described in van Jacobson

    2486. 

  2486. 	 * Paper "Congestion Avoidance and Control", Annex A.

    2487. 

  2487. 	 *

    2488. 

  2488. 	 * (net->lastsa >> SCTP_RTT_SHIFT) is the srtt

    2489. 

  2489. 	 * (net->lastsa >> SCTP_RTT_VAR_SHIFT) is the rttvar

    2490. 

  2490. 	 */

    2491. 

  2491. 	if (net->RTO_measured) {

    2492. 

  2492. 		rtt -= (net->lastsa >> SCTP_RTT_SHIFT);

    2493. 

  2493. 		net->lastsa += rtt;

    2494. 

  2494. 		if (rtt < 0) {

    2495. 

  2495. 			rtt = -rtt;

    2496. 

  2496. 		}

    2497. 

  2497. 		rtt -= (net->lastsv >> SCTP_RTT_VAR_SHIFT);

    2498. 

  2498. 		net->lastsv += rtt;

    2499. 

  2499. 		if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_RTTVAR_LOGGING_ENABLE) {

    2500. 

  2500. 			rto_logging(net, SCTP_LOG_RTTVAR);

    2501. 

  2501. 		}

    2502. 

  2502. 	} else {

    2503. 

  2503. 		/* First RTO measurment */

    2504. 

  2504. 		net->RTO_measured = 1;

    2505. 

  2505. 		first_measure = 1;

    2506. 

  2506. 		net->lastsa = rtt << SCTP_RTT_SHIFT;

    2507. 

  2507. 		net->lastsv = (rtt / 2) << SCTP_RTT_VAR_SHIFT;

    2508. 

  2508. 		if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_RTTVAR_LOGGING_ENABLE) {

    2509. 

  2509. 			rto_logging(net, SCTP_LOG_INITIAL_RTT);

    2510. 

  2510. 		}

    2511. 

  2511. 	}

    2512. 

  2512. 	if (net->lastsv == 0) {

    2513. 

  2513. 		net->lastsv = SCTP_CLOCK_GRANULARITY;

    2514. 

  2514. 	}

    2515. 

  2515. 	new_rto = (net->lastsa >> SCTP_RTT_SHIFT) + net->lastsv;

    2516. 

  2516. 	if ((new_rto > SCTP_SAT_NETWORK_MIN) &&

    2517. 

  2517. 	    (stcb->asoc.sat_network_lockout == 0)) {

    2518. 

  2518. 		stcb->asoc.sat_network = 1;

    2519. 

  2519. 	} else if ((!first_measure) && stcb->asoc.sat_network) {

    2520. 

  2520. 		stcb->asoc.sat_network = 0;

    2521. 

  2521. 		stcb->asoc.sat_network_lockout = 1;

    2522. 

  2522. 	}

    2523. 

  2523.  	/* bound it, per C6/C7 in Section 5.3.1 */

    2524. 

  2524.  	if (new_rto < stcb->asoc.minrto) {

    2525. 

  2525. 		new_rto = stcb->asoc.minrto;

    2526. 

  2526. 	}

    2527. 

  2527. 	if (new_rto > stcb->asoc.maxrto) {

    2528. 

  2528. 		new_rto = stcb->asoc.maxrto;

    2529. 

  2529. 	}

    2530. 

  2530. 	/* we are now returning the RTO */

    2531. 

  2531.  	return (new_rto);

    2532. 

  2532. }

    2533. 

  2533. 

    2534. 

  2534. /*

    2535. 

  2535.  * return a pointer to a contiguous piece of data from the given mbuf chain

    2536. 

  2536.  * starting at 'off' for 'len' bytes.  If the desired piece spans more than

    2537. 

  2537.  * one mbuf, a copy is made at 'ptr'. caller must ensure that the buffer size

    2538. 

  2538.  * is >= 'len' returns NULL if there there isn't 'len' bytes in the chain.

    2539. 

  2539.  */

    2540. 

  2540. caddr_t

    2541. 

  2541. sctp_m_getptr(struct mbuf *m, int off, int len, uint8_t * in_ptr)

    2542. 

  2542. {

    2543. 

  2543. 	uint32_t count;

    2544. 

  2544. 	uint8_t *ptr;

    2545. 

  2545. 

    2546. 

  2546. 	ptr = in_ptr;

    2547. 

  2547. 	if ((off < 0) || (len <= 0))

    2548. 

  2548. 		return (NULL);

    2549. 

  2549. 

    2550. 

  2550. 	/* find the desired start location */

    2551. 

  2551. 	while ((m != NULL) && (off > 0)) {

    2552. 

  2552. 		if (off < SCTP_BUF_LEN(m))

    2553. 

  2553. 			break;

    2554. 

  2554. 		off -= SCTP_BUF_LEN(m);

    2555. 

  2555. 		m = SCTP_BUF_NEXT(m);

    2556. 

  2556. 	}

    2557. 

  2557. 	if (m == NULL)

    2558. 

  2558. 		return (NULL);

    2559. 

  2559. 

    2560. 

  2560. 	/* is the current mbuf large enough (eg. contiguous)? */

    2561. 

  2561. 	if ((SCTP_BUF_LEN(m) - off) >= len) {

    2562. 

  2562. 		return (mtod(m, caddr_t) + off);

    2563. 

  2563. 	} else {

    2564. 

  2564. 		/* else, it spans more than one mbuf, so save a temp copy... */

    2565. 

  2565. 		while ((m != NULL) && (len > 0)) {

    2566. 

  2566. 			count = min(SCTP_BUF_LEN(m) - off, len);

    2567. 

  2567. 			bcopy(mtod(m, caddr_t) + off, ptr, count);

    2568. 

  2568. 			len -= count;

    2569. 

  2569. 			ptr += count;

    2570. 

  2570. 			off = 0;

    2571. 

  2571. 			m = SCTP_BUF_NEXT(m);

    2572. 

  2572. 		}

    2573. 

  2573. 		if ((m == NULL) && (len > 0))

    2574. 

  2574. 			return (NULL);

    2575. 

  2575. 		else

    2576. 

  2576. 			return ((caddr_t)in_ptr);

    2577. 

  2577. 	}

    2578. 

  2578. }

    2579. 

  2579. 

    2580. 

  2580. 

    2581. 

  2581. 

    2582. 

  2582. struct sctp_paramhdr *

    2583. 

  2583. sctp_get_next_param(struct mbuf *m,

    2584. 

  2584.     int offset,

    2585. 

  2585.     struct sctp_paramhdr *pull,

    2586. 

  2586.     int pull_limit)

    2587. 

  2587. {

    2588. 

  2588. 	/* This just provides a typed signature to Peter's Pull routine */

    2589. 

  2589. 	return ((struct sctp_paramhdr *)sctp_m_getptr(m, offset, pull_limit,

    2590. 

  2590. 	    (uint8_t *) pull));

    2591. 

  2591. }

    2592. 

  2592. 

    2593. 

  2593. 

    2594. 

  2594. int

    2595. 

  2595. sctp_add_pad_tombuf(struct mbuf *m, int padlen)

    2596. 

  2596. {

    2597. 

  2597. 	/*

    2598. 

  2598. 	 * add padlen bytes of 0 filled padding to the end of the mbuf. If

    2599. 

  2599. 	 * padlen is > 3 this routine will fail.

    2600. 

  2600. 	 */

    2601. 

  2601. 	uint8_t *dp;

    2602. 

  2602. 	int i;

    2603. 

  2603. 

    2604. 

  2604. 	if (padlen > 3) {

    2605. 

  2605. 		SCTP_LTRACE_ERR_RET_PKT(m, NULL, NULL, NULL, SCTP_FROM_SCTPUTIL, ENOBUFS);

    2606. 

  2606. 		return (ENOBUFS);

    2607. 

  2607. 	}

    2608. 

  2608. 	if (padlen <= M_TRAILINGSPACE(m)) {

    2609. 

  2609. 		/*

    2610. 

  2610. 		 * The easy way. We hope the majority of the time we hit

    2611. 

  2611. 		 * here :)

    2612. 

  2612. 		 */

    2613. 

  2613. 		dp = (uint8_t *) (mtod(m, caddr_t) + SCTP_BUF_LEN(m));

    2614. 

  2614. 		SCTP_BUF_LEN(m) += padlen;

    2615. 

  2615. 	} else {

    2616. 

  2616. 		/* Hard way we must grow the mbuf */

    2617. 

  2617. 		struct mbuf *tmp;

    2618. 

  2618. 

    2619. 

  2619. 		tmp = sctp_get_mbuf_for_msg(padlen, 0, M_DONTWAIT, 1, MT_DATA);

    2620. 

  2620. 		if (tmp == NULL) {

    2621. 

  2621. 			/* Out of space GAK! we are in big trouble. */

    2622. 

  2622. 			SCTP_LTRACE_ERR_RET_PKT(m, NULL, NULL, NULL, SCTP_FROM_SCTPUTIL, ENOBUFS);

    2623. 

  2623. 			return (ENOBUFS);

    2624. 

  2624. 		}

    2625. 

  2625. 		/* setup and insert in middle */

    2626. 

  2626. 		SCTP_BUF_LEN(tmp) = padlen;

    2627. 

  2627. 		SCTP_BUF_NEXT(tmp) = NULL;

    2628. 

  2628. 		SCTP_BUF_NEXT(m) = tmp;

    2629. 

  2629. 		dp = mtod(tmp, uint8_t *);

    2630. 

  2630. 	}

    2631. 

  2631. 	/* zero out the pad */

    2632. 

  2632. 	for (i = 0; i < padlen; i++) {

    2633. 

  2633. 		*dp = 0;

    2634. 

  2634. 		dp++;

    2635. 

  2635. 	}

    2636. 

  2636. 	return (0);

    2637. 

  2637. }

    2638. 

  2638. 

    2639. 

  2639. int

    2640. 

  2640. sctp_pad_lastmbuf(struct mbuf *m, int padval, struct mbuf *last_mbuf)

    2641. 

  2641. {

    2642. 

  2642. 	/* find the last mbuf in chain and pad it */

    2643. 

  2643. 	struct mbuf *m_at;

    2644. 

  2644. 

    2645. 

  2645. 	m_at = m;

    2646. 

  2646. 	if (last_mbuf) {

    2647. 

  2647. 		return (sctp_add_pad_tombuf(last_mbuf, padval));

    2648. 

  2648. 	} else {

    2649. 

  2649. 		while (m_at) {

    2650. 

  2650. 			if (SCTP_BUF_NEXT(m_at) == NULL) {

    2651. 

  2651. 				return (sctp_add_pad_tombuf(m_at, padval));

    2652. 

  2652. 			}

    2653. 

  2653. 			m_at = SCTP_BUF_NEXT(m_at);

    2654. 

  2654. 		}

    2655. 

  2655. 	}

    2656. 

  2656. 	SCTP_LTRACE_ERR_RET_PKT(m, NULL, NULL, NULL, SCTP_FROM_SCTPUTIL, EFAULT);

    2657. 

  2657. 	return (EFAULT);

    2658. 

  2658. }

    2659. 

  2659. 

    2660. 

  2660. static void

    2661. 

  2661. sctp_notify_assoc_change(uint16_t state, struct sctp_tcb *stcb,

    2662. 

  2662.     uint16_t error, struct sctp_abort_chunk *abort, uint8_t from_peer, int so_locked

    2663. 

  2663. #if !defined(__APPLE__) && !defined(SCTP_SO_LOCK_TESTING)

    2664. 

  2664.     SCTP_UNUSED

    2665. 

  2665. #endif

    2666. 

  2666.     )

    2667. 

  2667. {

    2668. 

  2668. 	struct mbuf *m_notify;

    2669. 

  2669. 	struct sctp_assoc_change *sac;

    2670. 

  2670. 	struct sctp_queued_to_read *control;

    2671. 

  2671. 	size_t notif_len, abort_len;

    2672. 

  2672. 	unsigned int i;

    2673. 

  2673. #if defined (__APPLE__) || defined(SCTP_SO_LOCK_TESTING)

    2674. 

  2674. 	struct socket *so;

    2675. 

  2675. #endif

    2676. 

  2676. 

    2677. 

  2677. 	if (sctp_stcb_is_feature_on(stcb->sctp_ep, stcb, SCTP_PCB_FLAGS_RECVASSOCEVNT)) {

    2678. 

  2678. 		notif_len = sizeof(struct sctp_assoc_change);

    2679. 

  2679. 		if (abort != NULL) {

    2680. 

  2680. 			abort_len = htons(abort->ch.chunk_length);

    2681. 

  2681. 		} else {

    2682. 

  2682. 			abort_len = 0;

    2683. 

  2683. 		}

    2684. 

  2684. 		if ((state == SCTP_COMM_UP) || (state == SCTP_RESTART)) {

    2685. 

  2685. 			notif_len += SCTP_ASSOC_SUPPORTS_MAX;

    2686. 

  2686. 		} else if ((state == SCTP_COMM_LOST) || (state == SCTP_CANT_STR_ASSOC)) {

    2687. 

  2687. 			notif_len += abort_len;

    2688. 

  2688. 		}

    2689. 

  2689. 		m_notify = sctp_get_mbuf_for_msg(notif_len, 0, M_DONTWAIT, 1, MT_DATA);

    2690. 

  2690. 		if (m_notify == NULL) {

    2691. 

  2691. 			/* Retry with smaller value. */

    2692. 

  2692. 			notif_len = sizeof(struct sctp_assoc_change);

    2693. 

  2693. 			m_notify = sctp_get_mbuf_for_msg(notif_len, 0, M_DONTWAIT, 1, MT_DATA);

    2694. 

  2694. 			if (m_notify == NULL) {

    2695. 

  2695. 				goto set_error;

    2696. 

  2696. 			}

    2697. 

  2697. 		}

    2698. 

  2698. 		SCTP_BUF_NEXT(m_notify) = NULL;

    2699. 

  2699. 		sac = mtod(m_notify, struct sctp_assoc_change *);

    2700. 

  2700. 		sac->sac_type = SCTP_ASSOC_CHANGE;

    2701. 

  2701. 		sac->sac_flags = 0;

    2702. 

  2702. 		sac->sac_length = sizeof(struct sctp_assoc_change);

    2703. 

  2703. 		sac->sac_state = state;

    2704. 

  2704. 		sac->sac_error = error;

    2705. 

  2705. 		/* XXX verify these stream counts */

    2706. 

  2706. 		sac->sac_outbound_streams = stcb->asoc.streamoutcnt;

    2707. 

  2707. 		sac->sac_inbound_streams = stcb->asoc.streamincnt;

    2708. 

  2708. 		sac->sac_assoc_id = sctp_get_associd(stcb);

    2709. 

  2709. 		if (notif_len > sizeof(struct sctp_assoc_change)) {

    2710. 

  2710. 			if ((state == SCTP_COMM_UP) || (state == SCTP_RESTART)) {

    2711. 

  2711. 				i = 0;

    2712. 

  2712. 				if (stcb->asoc.peer_supports_prsctp) {

    2713. 

  2713. 					sac->sac_info[i++] = SCTP_ASSOC_SUPPORTS_PR;

    2714. 

  2714. 				}

    2715. 

  2715. 					if (stcb->asoc.peer_supports_auth) {

    2716. 

  2716. 					sac->sac_info[i++] = SCTP_ASSOC_SUPPORTS_AUTH;

    2717. 

  2717. 				}

    2718. 

  2718. 				if (stcb->asoc.peer_supports_asconf) {

    2719. 

  2719. 					sac->sac_info[i++] = SCTP_ASSOC_SUPPORTS_ASCONF;

    2720. 

  2720. 				}

    2721. 

  2721. 				sac->sac_info[i++] = SCTP_ASSOC_SUPPORTS_MULTIBUF;

    2722. 

  2722. 				if (stcb->asoc.peer_supports_strreset) {

    2723. 

  2723. 					sac->sac_info[i++] = SCTP_ASSOC_SUPPORTS_RE_CONFIG;

    2724. 

  2724. 				}

    2725. 

  2725. 				sac->sac_length += i;

    2726. 

  2726. 			} else if ((state == SCTP_COMM_LOST) || (state == SCTP_CANT_STR_ASSOC)) {

    2727. 

  2727. 				memcpy(sac->sac_info, abort, abort_len);

    2728. 

  2728. 				sac->sac_length += abort_len;

    2729. 

  2729. 			}

    2730. 

  2730. 		}

    2731. 

  2731. 		SCTP_BUF_LEN(m_notify) = sac->sac_length;

    2732. 

  2732. 		control = sctp_build_readq_entry(stcb, stcb->asoc.primary_destination,

    2733. 

  2733. 						 0, 0, stcb->asoc.context, 0, 0, 0,

    2734. 

  2734. 						 m_notify);

    2735. 

  2735. 		if (control != NULL) {

    2736. 

  2736. 			control->length = SCTP_BUF_LEN(m_notify);

    2737. 

  2737. 			/* not that we need this */

    2738. 

  2738. 			control->tail_mbuf = m_notify;

    2739. 

  2739. 			control->spec_flags = M_NOTIFICATION;

    2740. 

  2740. 			sctp_add_to_readq(stcb->sctp_ep, stcb,

    2741. 

  2741. 					  control,

    2742. 

  2742. 					  &stcb->sctp_socket->so_rcv, 1, SCTP_READ_LOCK_NOT_HELD,

    2743. 

  2743. 					  so_locked);

    2744. 

  2744. 		} else {

    2745. 

  2745. 			sctp_m_freem(m_notify);

    2746. 

  2746. 		}

    2747. 

  2747. 	}

    2748. 

  2748. 	/*

    2749. 

  2749. 	 * For 1-to-1 style sockets, we send up and error when an ABORT

    2750. 

  2750. 	 * comes in.

    2751. 

  2751. 	 */

    2752. 

  2752. set_error:

    2753. 

  2753. 	if (((stcb->sctp_ep->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) ||

    2754. 

  2754. 	     (stcb->sctp_ep->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL)) &&

    2755. 

  2755. 	    ((state == SCTP_COMM_LOST) || (state == SCTP_CANT_STR_ASSOC))) {

    2756. 

  2756. 		if (from_peer) {

    2757. 

  2757. 			if (SCTP_GET_STATE(&stcb->asoc) == SCTP_STATE_COOKIE_WAIT) {

    2758. 

  2758. 				SCTP_LTRACE_ERR_RET(NULL, stcb, NULL, SCTP_FROM_SCTPUTIL, ECONNREFUSED);

    2759. 

  2759. 				stcb->sctp_socket->so_error = ECONNREFUSED;

    2760. 

  2760. 			} else {

    2761. 

  2761. 				SCTP_LTRACE_ERR_RET(NULL, stcb, NULL, SCTP_FROM_SCTPUTIL, ECONNRESET);

    2762. 

  2762. 				stcb->sctp_socket->so_error = ECONNRESET;

    2763. 

  2763. 			}

    2764. 

  2764. 		} else {

    2765. 

  2765. 			SCTP_LTRACE_ERR_RET(NULL, stcb, NULL, SCTP_FROM_SCTPUTIL, ECONNABORTED);

    2766. 

  2766. 			stcb->sctp_socket->so_error = ECONNABORTED;

    2767. 

  2767. 		}

    2768. 

  2768. 	}

    2769. 

  2769. 	/* Wake ANY sleepers */

    2770. 

  2770. #if defined (__APPLE__) || defined(SCTP_SO_LOCK_TESTING)

    2771. 

  2771. 	so = SCTP_INP_SO(stcb->sctp_ep);

    2772. 

  2772. 	if (!so_locked) {

    2773. 

  2773. 		atomic_add_int(&stcb->asoc.refcnt, 1);

    2774. 

  2774. 		SCTP_TCB_UNLOCK(stcb);

    2775. 

  2775. 		SCTP_SOCKET_LOCK(so, 1);

    2776. 

  2776. 		SCTP_TCB_LOCK(stcb);

    2777. 

  2777. 		atomic_subtract_int(&stcb->asoc.refcnt, 1);

    2778. 

  2778. 		if (stcb->asoc.state & SCTP_STATE_CLOSED_SOCKET) {

    2779. 

  2779. 			SCTP_SOCKET_UNLOCK(so, 1);

    2780. 

  2780. 			return;

    2781. 

  2781. 		}

    2782. 

  2782. 	}

    2783. 

  2783. #endif

    2784. 

  2784. 	if (((stcb->sctp_ep->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) ||

    2785. 

  2785. 	     (stcb->sctp_ep->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL)) &&

    2786. 

  2786. 	    ((state == SCTP_COMM_LOST) || (state == SCTP_CANT_STR_ASSOC))) {

    2787. 

  2787. 		socantrcvmore(stcb->sctp_socket);

    2788. 

  2788. 	}

    2789. 

  2789. 	sorwakeup(stcb->sctp_socket);

    2790. 

  2790. 	sowwakeup(stcb->sctp_socket);

    2791. 

  2791. #if defined (__APPLE__) || defined(SCTP_SO_LOCK_TESTING)

    2792. 

  2792. 	if (!so_locked) {

    2793. 

  2793. 		SCTP_SOCKET_UNLOCK(so, 1);

    2794. 

  2794. 	}

    2795. 

  2795. #endif

    2796. 

  2796. }

    2797. 

  2797. 

    2798. 

  2798. static void

    2799. 

  2799. sctp_notify_peer_addr_change(struct sctp_tcb *stcb, uint32_t state,

    2800. 

  2800.     struct sockaddr *sa, uint32_t error)

    2801. 

  2801. {

    2802. 

  2802. 	struct mbuf *m_notify;

    2803. 

  2803. 	struct sctp_paddr_change *spc;

    2804. 

  2804. 	struct sctp_queued_to_read *control;

    2805. 

  2805. 

    2806. 

  2806. 	if ((stcb == NULL) ||

    2807. 

  2807. 	    sctp_stcb_is_feature_off(stcb->sctp_ep, stcb, SCTP_PCB_FLAGS_RECVPADDREVNT)) {

    2808. 

  2808. 		/* event not enabled */

    2809. 

  2809. 		return;

    2810. 

  2810. 	}

    2811. 

  2811. 	m_notify = sctp_get_mbuf_for_msg(sizeof(struct sctp_paddr_change), 0, M_DONTWAIT, 1, MT_DATA);

    2812. 

  2812. 	if (m_notify == NULL)

    2813. 

  2813. 		return;

    2814. 

  2814. 	SCTP_BUF_LEN(m_notify) = 0;

    2815. 

  2815. 	spc = mtod(m_notify, struct sctp_paddr_change *);

    2816. 

  2816. 	spc->spc_type = SCTP_PEER_ADDR_CHANGE;

    2817. 

  2817. 	spc->spc_flags = 0;

    2818. 

  2818. 	spc->spc_length = sizeof(struct sctp_paddr_change);

    2819. 

  2819. 	switch (sa->sa_family) {

    2820. 

  2820. #ifdef INET

    2821. 

  2821. 	case AF_INET:

    2822. 

  2822. 		memcpy(&spc->spc_aaddr, sa, sizeof(struct sockaddr_in));

    2823. 

  2823. 		break;

    2824. 

  2824. #endif

    2825. 

  2825. #ifdef INET6

    2826. 

  2826. 	case AF_INET6:

    2827. 

  2827. 	{

    2828. 

  2828. #ifdef SCTP_EMBEDDED_V6_SCOPE

    2829. 

  2829. 		struct sockaddr_in6 *sin6;

    2830. 

  2830. #endif /* SCTP_EMBEDDED_V6_SCOPE */

    2831. 

  2831. 		memcpy(&spc->spc_aaddr, sa, sizeof(struct sockaddr_in6));

    2832. 

  2832. 

    2833. 

  2833. #ifdef SCTP_EMBEDDED_V6_SCOPE

    2834. 

  2834. 		sin6 = (struct sockaddr_in6 *)&spc->spc_aaddr;

    2835. 

  2835. 		if (IN6_IS_SCOPE_LINKLOCAL(&sin6->sin6_addr)) {

    2836. 

  2836. 			if (sin6->sin6_scope_id == 0) {

    2837. 

  2837. 				/* recover scope_id for user */

    2838. 

  2838. #ifdef SCTP_KAME

    2839. 

  2839. 		 		(void)sa6_recoverscope(sin6);

    2840. 

  2840. #else

    2841. 

  2841. 				(void)in6_recoverscope(sin6, &sin6->sin6_addr,

    2842. 

  2842. 						       NULL);

    2843. 

  2843. #endif

    2844. 

  2844. 			} else {

    2845. 

  2845. 				/* clear embedded scope_id for user */

    2846. 

  2846. 				in6_clearscope(&sin6->sin6_addr);

    2847. 

  2847. 			}

    2848. 

  2848. 		}

    2849. 

  2849. #endif /* SCTP_EMBEDDED_V6_SCOPE */

    2850. 

  2850. 		break;

    2851. 

  2851. 	}

    2852. 

  2852. #endif

    2853. 

  2853. 	default:

    2854. 

  2854. 		/* TSNH */

    2855. 

  2855. 		break;

    2856. 

  2856. 	}

    2857. 

  2857. 	spc->spc_state = state;

    2858. 

  2858. 	spc->spc_error = error;

    2859. 

  2859. 	spc->spc_assoc_id = sctp_get_associd(stcb);

    2860. 

  2860. 

    2861. 

  2861. 	SCTP_BUF_LEN(m_notify) = sizeof(struct sctp_paddr_change);

    2862. 

  2862. 	SCTP_BUF_NEXT(m_notify) = NULL;

    2863. 

  2863. 

    2864. 

  2864. 	/* append to socket */

    2865. 

  2865. 	control = sctp_build_readq_entry(stcb, stcb->asoc.primary_destination,

    2866. 

  2866. 	                                 0, 0, stcb->asoc.context, 0, 0, 0,

    2867. 

  2867. 	                                 m_notify);

    2868. 

  2868. 	if (control == NULL) {

    2869. 

  2869. 		/* no memory */

    2870. 

  2870. 		sctp_m_freem(m_notify);

    2871. 

  2871. 		return;

    2872. 

  2872. 	}

    2873. 

  2873. 	control->length = SCTP_BUF_LEN(m_notify);

    2874. 

  2874. 	control->spec_flags = M_NOTIFICATION;

    2875. 

  2875. 	/* not that we need this */

    2876. 

  2876. 	control->tail_mbuf = m_notify;

    2877. 

  2877. 	sctp_add_to_readq(stcb->sctp_ep, stcb,

    2878. 

  2878. 			  control,

    2879. 

  2879. 			  &stcb->sctp_socket->so_rcv, 1,

    2880. 

  2880. 			  SCTP_READ_LOCK_NOT_HELD,

    2881. 

  2881. 			  SCTP_SO_NOT_LOCKED);

    2882. 

  2882. }

    2883. 

  2883. 

    2884. 

  2884. 

    2885. 

  2885. static void

    2886. 

  2886. sctp_notify_send_failed(struct sctp_tcb *stcb, uint8_t sent, uint32_t error,

    2887. 

  2887.     struct sctp_tmit_chunk *chk, int so_locked

    2888. 

  2888. #if !defined(__APPLE__) && !defined(SCTP_SO_LOCK_TESTING)

    2889. 

  2889.     SCTP_UNUSED

    2890. 

  2890. #endif

    2891. 

  2891.     )

    2892. 

  2892. {

    2893. 

  2893. 	struct mbuf *m_notify;

    2894. 

  2894. 	struct sctp_send_failed *ssf;

    2895. 

  2895. 	struct sctp_send_failed_event *ssfe;

    2896. 

  2896. 	struct sctp_queued_to_read *control;

    2897. 

  2897. 	int length;

    2898. 

  2898. 

    2899. 

  2899. 	if ((stcb == NULL) ||

    2900. 

  2900. 	    (sctp_stcb_is_feature_off(stcb->sctp_ep, stcb, SCTP_PCB_FLAGS_RECVSENDFAILEVNT) &&

    2901. 

  2901. 	     sctp_stcb_is_feature_off(stcb->sctp_ep, stcb, SCTP_PCB_FLAGS_RECVNSENDFAILEVNT))) {

    2902. 

  2902. 		/* event not enabled */

    2903. 

  2903. 		return;

    2904. 

  2904. 	}

    2905. 

  2905. 

    2906. 

  2906. 	if (sctp_stcb_is_feature_on(stcb->sctp_ep, stcb, SCTP_PCB_FLAGS_RECVNSENDFAILEVNT)) {

    2907. 

  2907. 		length = sizeof(struct sctp_send_failed_event);

    2908. 

  2908. 	} else {

    2909. 

  2909. 		length = sizeof(struct sctp_send_failed);

    2910. 

  2910. 	}

    2911. 

  2911. 	m_notify = sctp_get_mbuf_for_msg(length, 0, M_DONTWAIT, 1, MT_DATA);

    2912. 

  2912. 	if (m_notify == NULL)

    2913. 

  2913. 		/* no space left */

    2914. 

  2914. 		return;

    2915. 

  2915. 	length += chk->send_size;

    2916. 

  2916. 	length -= sizeof(struct sctp_data_chunk);

    2917. 

  2917. 	SCTP_BUF_LEN(m_notify) = 0;

    2918. 

  2918. 	if (sctp_stcb_is_feature_on(stcb->sctp_ep, stcb, SCTP_PCB_FLAGS_RECVNSENDFAILEVNT)) {

    2919. 

  2919. 		ssfe = mtod(m_notify, struct sctp_send_failed_event *);

    2920. 

  2920. 		ssfe->ssfe_type = SCTP_SEND_FAILED_EVENT;

    2921. 

  2921. 		if (sent) {

    2922. 

  2922. 			ssfe->ssfe_flags = SCTP_DATA_SENT;

    2923. 

  2923. 		} else {

    2924. 

  2924. 			ssfe->ssfe_flags = SCTP_DATA_UNSENT;

    2925. 

  2925. 		}

    2926. 

  2926. 		ssfe->ssfe_length = length;

    2927. 

  2927. 		ssfe->ssfe_error = error;

    2928. 

  2928. 		/* not exactly what the user sent in, but should be close :) */

    2929. 

  2929. 		bzero(&ssfe->ssfe_info, sizeof(ssfe->ssfe_info));

    2930. 

  2930. 		ssfe->ssfe_info.snd_sid = chk->rec.data.stream_number;

    2931. 

  2931. 		ssfe->ssfe_info.snd_flags = chk->rec.data.rcv_flags;

    2932. 

  2932. 		ssfe->ssfe_info.snd_ppid = chk->rec.data.payloadtype;

    2933. 

  2933. 		ssfe->ssfe_info.snd_context = chk->rec.data.context;

    2934. 

  2934. 		ssfe->ssfe_info.snd_assoc_id = sctp_get_associd(stcb);

    2935. 

  2935. 		ssfe->ssfe_assoc_id = sctp_get_associd(stcb);

    2936. 

  2936. 		SCTP_BUF_LEN(m_notify) = sizeof(struct sctp_send_failed_event);

    2937. 

  2937. 	} else {

    2938. 

  2938. 		ssf = mtod(m_notify, struct sctp_send_failed *);

    2939. 

  2939. 		ssf->ssf_type = SCTP_SEND_FAILED;

    2940. 

  2940. 		if (sent) {

    2941. 

  2941. 			ssf->ssf_flags = SCTP_DATA_SENT;

    2942. 

  2942. 		} else {

    2943. 

  2943. 			ssf->ssf_flags = SCTP_DATA_UNSENT;

    2944. 

  2944. 		}

    2945. 

  2945. 		ssf->ssf_length = length;

    2946. 

  2946. 		ssf->ssf_error = error;

    2947. 

  2947. 		/* not exactly what the user sent in, but should be close :) */

    2948. 

  2948. 		bzero(&ssf->ssf_info, sizeof(ssf->ssf_info));

    2949. 

  2949. 		ssf->ssf_info.sinfo_stream = chk->rec.data.stream_number;

    2950. 

  2950. 		ssf->ssf_info.sinfo_ssn = chk->rec.data.stream_seq;

    2951. 

  2951. 		ssf->ssf_info.sinfo_flags = chk->rec.data.rcv_flags;

    2952. 

  2952. 		ssf->ssf_info.sinfo_ppid = chk->rec.data.payloadtype;

    2953. 

  2953. 		ssf->ssf_info.sinfo_context = chk->rec.data.context;

    2954. 

  2954. 		ssf->ssf_info.sinfo_assoc_id = sctp_get_associd(stcb);

    2955. 

  2955. 		ssf->ssf_assoc_id = sctp_get_associd(stcb);

    2956. 

  2956. 		SCTP_BUF_LEN(m_notify) = sizeof(struct sctp_send_failed);

    2957. 

  2957. 	}

    2958. 

  2958. 	if (chk->data) {

    2959. 

  2959. 		/*

    2960. 

  2960. 		 * trim off the sctp chunk header(it should

    2961. 

  2961. 		 * be there)

    2962. 

  2962. 		 */

    2963. 

  2963. 		if (chk->send_size >= sizeof(struct sctp_data_chunk)) {

    2964. 

  2964. 			m_adj(chk->data, sizeof(struct sctp_data_chunk));

    2965. 

  2965. 			sctp_mbuf_crush(chk->data);

    2966. 

  2966. 			chk->send_size -= sizeof(struct sctp_data_chunk);

    2967. 

  2967. 		}

    2968. 

  2968. 	}

    2969. 

  2969. 	SCTP_BUF_NEXT(m_notify) = chk->data;

    2970. 

  2970. 	/* Steal off the mbuf */

    2971. 

  2971. 	chk->data = NULL;

    2972. 

  2972. 	/*

    2973. 

  2973. 	 * For this case, we check the actual socket buffer, since the assoc

    2974. 

  2974. 	 * is going away we don't want to overfill the socket buffer for a

    2975. 

  2975. 	 * non-reader

    2976. 

  2976. 	 */

    2977. 

  2977. 	if (sctp_sbspace_failedmsgs(&stcb->sctp_socket->so_rcv) < SCTP_BUF_LEN(m_notify)) {

    2978. 

  2978. 		sctp_m_freem(m_notify);

    2979. 

  2979. 		return;

    2980. 

  2980. 	}

    2981. 

  2981. 	/* append to socket */

    2982. 

  2982. 	control = sctp_build_readq_entry(stcb, stcb->asoc.primary_destination,

    2983. 

  2983. 	                                 0, 0, stcb->asoc.context, 0, 0, 0,

    2984. 

  2984. 	                                 m_notify);

    2985. 

  2985. 	if (control == NULL) {

    2986. 

  2986. 		/* no memory */

    2987. 

  2987. 		sctp_m_freem(m_notify);

    2988. 

  2988. 		return;

    2989. 

  2989. 	}

    2990. 

  2990. 	control->spec_flags = M_NOTIFICATION;

    2991. 

  2991. 	sctp_add_to_readq(stcb->sctp_ep, stcb,

    2992. 

  2992. 	                  control,

    2993. 

  2993. 	                  &stcb->sctp_socket->so_rcv, 1,

    2994. 

  2994. 	                  SCTP_READ_LOCK_NOT_HELD,

    2995. 

  2995. 	                  so_locked);

    2996. 

  2996. }

    2997. 

  2997. 

    2998. 

  2998. 

    2999. 

  2999. static void

    3000. 

  3000. sctp_notify_send_failed2(struct sctp_tcb *stcb, uint32_t error,

    3001. 

  3001. 			 struct sctp_stream_queue_pending *sp, int so_locked

    3002. 

  3002. #if !defined(__APPLE__) && !defined(SCTP_SO_LOCK_TESTING)

    3003. 

  3003.                          SCTP_UNUSED

    3004. 

  3004. #endif

    3005. 

  3005.                          )

    3006. 

  3006. {

    3007. 

  3007. 	struct mbuf *m_notify;

    3008. 

  3008. 	struct sctp_send_failed *ssf;

    3009. 

  3009. 	struct sctp_send_failed_event *ssfe;

    3010. 

  3010. 	struct sctp_queued_to_read *control;

    3011. 

  3011. 	int length;

    3012. 

  3012. 

    3013. 

  3013. 	if ((stcb == NULL) ||

    3014. 

  3014. 	    (sctp_stcb_is_feature_off(stcb->sctp_ep, stcb, SCTP_PCB_FLAGS_RECVSENDFAILEVNT) &&

    3015. 

  3015. 	     sctp_stcb_is_feature_off(stcb->sctp_ep, stcb, SCTP_PCB_FLAGS_RECVNSENDFAILEVNT))) {

    3016. 

  3016. 		/* event not enabled */

    3017. 

  3017. 		return;

    3018. 

  3018. 	}

    3019. 

  3019. 	if (sctp_stcb_is_feature_on(stcb->sctp_ep, stcb, SCTP_PCB_FLAGS_RECVNSENDFAILEVNT)) {

    3020. 

  3020. 		length = sizeof(struct sctp_send_failed_event);

    3021. 

  3021. 	} else {

    3022. 

  3022. 		length = sizeof(struct sctp_send_failed);

    3023. 

  3023. 	}

    3024. 

  3024. 	m_notify = sctp_get_mbuf_for_msg(length, 0, M_DONTWAIT, 1, MT_DATA);

    3025. 

  3025. 	if (m_notify == NULL) {

    3026. 

  3026. 		/* no space left */

    3027. 

  3027. 		return;

    3028. 

  3028. 	}

    3029. 

  3029. 	length += sp->length;

    3030. 

  3030. 	SCTP_BUF_LEN(m_notify) = 0;

    3031. 

  3031. 	if (sctp_stcb_is_feature_on(stcb->sctp_ep, stcb, SCTP_PCB_FLAGS_RECVNSENDFAILEVNT)) {

    3032. 

  3032. 		ssfe = mtod(m_notify, struct sctp_send_failed_event *);

    3033. 

  3033. 		ssfe->ssfe_type = SCTP_SEND_FAILED;

    3034. 

  3034. 		ssfe->ssfe_flags = SCTP_DATA_UNSENT;

    3035. 

  3035. 		ssfe->ssfe_length = length;

    3036. 

  3036. 		ssfe->ssfe_error = error;

    3037. 

  3037. 		/* not exactly what the user sent in, but should be close :) */

    3038. 

  3038. 		bzero(&ssfe->ssfe_info, sizeof(ssfe->ssfe_info));

    3039. 

  3039. 		ssfe->ssfe_info.snd_sid = sp->stream;

    3040. 

  3040. 		if (sp->some_taken) {

    3041. 

  3041. 			ssfe->ssfe_info.snd_flags = SCTP_DATA_LAST_FRAG;

    3042. 

  3042. 		} else {

    3043. 

  3043. 			ssfe->ssfe_info.snd_flags = SCTP_DATA_NOT_FRAG;

    3044. 

  3044. 		}

    3045. 

  3045. 		ssfe->ssfe_info.snd_ppid = sp->ppid;

    3046. 

  3046. 		ssfe->ssfe_info.snd_context = sp->context;

    3047. 

  3047. 		ssfe->ssfe_info.snd_assoc_id = sctp_get_associd(stcb);

    3048. 

  3048. 		ssfe->ssfe_assoc_id = sctp_get_associd(stcb);

    3049. 

  3049. 		SCTP_BUF_LEN(m_notify) = sizeof(struct sctp_send_failed_event);

    3050. 

  3050. 	} else {

    3051. 

  3051. 		ssf = mtod(m_notify, struct sctp_send_failed *);

    3052. 

  3052. 		ssf->ssf_type = SCTP_SEND_FAILED;

    3053. 

  3053. 		ssf->ssf_flags = SCTP_DATA_UNSENT;

    3054. 

  3054. 		ssf->ssf_length = length;

    3055. 

  3055. 		ssf->ssf_error = error;

    3056. 

  3056. 		/* not exactly what the user sent in, but should be close :) */

    3057. 

  3057. 		bzero(&ssf->ssf_info, sizeof(ssf->ssf_info));

    3058. 

  3058. 		ssf->ssf_info.sinfo_stream = sp->stream;

    3059. 

  3059. 		ssf->ssf_info.sinfo_ssn = sp->strseq;

    3060. 

  3060. 		if (sp->some_taken) {

    3061. 

  3061. 			ssf->ssf_info.sinfo_flags = SCTP_DATA_LAST_FRAG;

    3062. 

  3062. 		} else {

    3063. 

  3063. 			ssf->ssf_info.sinfo_flags = SCTP_DATA_NOT_FRAG;

    3064. 

  3064. 		}

    3065. 

  3065. 		ssf->ssf_info.sinfo_ppid = sp->ppid;

    3066. 

  3066. 		ssf->ssf_info.sinfo_context = sp->context;

    3067. 

  3067. 		ssf->ssf_info.sinfo_assoc_id = sctp_get_associd(stcb);

    3068. 

  3068. 		ssf->ssf_assoc_id = sctp_get_associd(stcb);

    3069. 

  3069. 		SCTP_BUF_LEN(m_notify) = sizeof(struct sctp_send_failed);

    3070. 

  3070. 	}

    3071. 

  3071. 	SCTP_BUF_NEXT(m_notify) = sp->data;

    3072. 

  3072. 

    3073. 

  3073. 	/* Steal off the mbuf */

    3074. 

  3074. 	sp->data = NULL;

    3075. 

  3075. 	/*

    3076. 

  3076. 	 * For this case, we check the actual socket buffer, since the assoc

    3077. 

  3077. 	 * is going away we don't want to overfill the socket buffer for a

    3078. 

  3078. 	 * non-reader

    3079. 

  3079. 	 */

    3080. 

  3080. 	if (sctp_sbspace_failedmsgs(&stcb->sctp_socket->so_rcv) < SCTP_BUF_LEN(m_notify)) {

    3081. 

  3081. 		sctp_m_freem(m_notify);

    3082. 

  3082. 		return;

    3083. 

  3083. 	}

    3084. 

  3084. 	/* append to socket */

    3085. 

  3085. 	control = sctp_build_readq_entry(stcb, stcb->asoc.primary_destination,

    3086. 

  3086. 	                                 0, 0, stcb->asoc.context, 0, 0, 0,

    3087. 

  3087. 	                                 m_notify);

    3088. 

  3088. 	if (control == NULL) {

    3089. 

  3089. 		/* no memory */

    3090. 

  3090. 		sctp_m_freem(m_notify);

    3091. 

  3091. 		return;

    3092. 

  3092. 	}

    3093. 

  3093. 	control->spec_flags = M_NOTIFICATION;

    3094. 

  3094. 	sctp_add_to_readq(stcb->sctp_ep, stcb,

    3095. 

  3095. 	    control,

    3096. 

  3096. 	    &stcb->sctp_socket->so_rcv, 1, SCTP_READ_LOCK_NOT_HELD, so_locked);

    3097. 

  3097. }

    3098. 

  3098. 

    3099. 

  3099. 

    3100. 

  3100. 

    3101. 

  3101. static void

    3102. 

  3102. sctp_notify_adaptation_layer(struct sctp_tcb *stcb)

    3103. 

  3103. {

    3104. 

  3104. 	struct mbuf *m_notify;

    3105. 

  3105. 	struct sctp_adaptation_event *sai;

    3106. 

  3106. 	struct sctp_queued_to_read *control;

    3107. 

  3107. 

    3108. 

  3108. 	if ((stcb == NULL) ||

    3109. 

  3109. 	    sctp_stcb_is_feature_off(stcb->sctp_ep, stcb, SCTP_PCB_FLAGS_ADAPTATIONEVNT)) {

    3110. 

  3110. 		/* event not enabled */

    3111. 

  3111. 		return;

    3112. 

  3112. 	}

    3113. 

  3113. 

    3114. 

  3114. 	m_notify = sctp_get_mbuf_for_msg(sizeof(struct sctp_adaption_event), 0, M_DONTWAIT, 1, MT_DATA);

    3115. 

  3115. 	if (m_notify == NULL)

    3116. 

  3116. 		/* no space left */

    3117. 

  3117. 		return;

    3118. 

  3118. 	SCTP_BUF_LEN(m_notify) = 0;

    3119. 

  3119. 	sai = mtod(m_notify, struct sctp_adaptation_event *);

    3120. 

  3120. 	sai->sai_type = SCTP_ADAPTATION_INDICATION;

    3121. 

  3121. 	sai->sai_flags = 0;

    3122. 

  3122. 	sai->sai_length = sizeof(struct sctp_adaptation_event);

    3123. 

  3123. 	sai->sai_adaptation_ind = stcb->asoc.peers_adaptation;

    3124. 

  3124. 	sai->sai_assoc_id = sctp_get_associd(stcb);

    3125. 

  3125. 

    3126. 

  3126. 	SCTP_BUF_LEN(m_notify) = sizeof(struct sctp_adaptation_event);

    3127. 

  3127. 	SCTP_BUF_NEXT(m_notify) = NULL;

    3128. 

  3128. 

    3129. 

  3129. 	/* append to socket */

    3130. 

  3130. 	control = sctp_build_readq_entry(stcb, stcb->asoc.primary_destination,

    3131. 

  3131. 	                                 0, 0, stcb->asoc.context, 0, 0, 0,

    3132. 

  3132. 	                                 m_notify);

    3133. 

  3133. 	if (control == NULL) {

    3134. 

  3134. 		/* no memory */

    3135. 

  3135. 		sctp_m_freem(m_notify);

    3136. 

  3136. 		return;

    3137. 

  3137. 	}

    3138. 

  3138. 	control->length = SCTP_BUF_LEN(m_notify);

    3139. 

  3139. 	control->spec_flags = M_NOTIFICATION;

    3140. 

  3140. 	/* not that we need this */

    3141. 

  3141. 	control->tail_mbuf = m_notify;

    3142. 

  3142. 	sctp_add_to_readq(stcb->sctp_ep, stcb,

    3143. 

  3143. 	    control,

    3144. 

  3144. 	    &stcb->sctp_socket->so_rcv, 1, SCTP_READ_LOCK_NOT_HELD, SCTP_SO_NOT_LOCKED);

    3145. 

  3145. }

    3146. 

  3146. 

    3147. 

  3147. /* This always must be called with the read-queue LOCKED in the INP */

    3148. 

  3148. static void

    3149. 

  3149. sctp_notify_partial_delivery_indication(struct sctp_tcb *stcb, uint32_t error,

    3150. 

  3150. 					uint32_t val, int so_locked

    3151. 

  3151. #if !defined(__APPLE__) && !defined(SCTP_SO_LOCK_TESTING)

    3152. 

  3152.                              SCTP_UNUSED

    3153. 

  3153. #endif

    3154. 

  3154.                                         )

    3155. 

  3155. {

    3156. 

  3156. 	struct mbuf *m_notify;

    3157. 

  3157. 	struct sctp_pdapi_event *pdapi;

    3158. 

  3158. 	struct sctp_queued_to_read *control;

    3159. 

  3159. 	struct sockbuf *sb;

    3160. 

  3160. 

    3161. 

  3161. 	if ((stcb == NULL) ||

    3162. 

  3162. 	    sctp_stcb_is_feature_off(stcb->sctp_ep, stcb, SCTP_PCB_FLAGS_PDAPIEVNT)) {

    3163. 

  3163. 		/* event not enabled */

    3164. 

  3164. 		return;

    3165. 

  3165. 	}

    3166. 

  3166. 	if (stcb->sctp_ep->sctp_flags & SCTP_PCB_FLAGS_SOCKET_CANT_READ) {

    3167. 

  3167. 		return;

    3168. 

  3168. 	}

    3169. 

  3169. 

    3170. 

  3170. 	m_notify = sctp_get_mbuf_for_msg(sizeof(struct sctp_pdapi_event), 0, M_DONTWAIT, 1, MT_DATA);

    3171. 

  3171. 	if (m_notify == NULL)

    3172. 

  3172. 		/* no space left */

    3173. 

  3173. 		return;

    3174. 

  3174. 	SCTP_BUF_LEN(m_notify) = 0;

    3175. 

  3175. 	pdapi = mtod(m_notify, struct sctp_pdapi_event *);

    3176. 

  3176. 	pdapi->pdapi_type = SCTP_PARTIAL_DELIVERY_EVENT;

    3177. 

  3177. 	pdapi->pdapi_flags = 0;

    3178. 

  3178. 	pdapi->pdapi_length = sizeof(struct sctp_pdapi_event);

    3179. 

  3179. 	pdapi->pdapi_indication = error;

    3180. 

  3180. 	pdapi->pdapi_stream = (val >> 16);

    3181. 

  3181. 	pdapi->pdapi_seq = (val & 0x0000ffff);

    3182. 

  3182. 	pdapi->pdapi_assoc_id = sctp_get_associd(stcb);

    3183. 

  3183. 

    3184. 

  3184. 	SCTP_BUF_LEN(m_notify) = sizeof(struct sctp_pdapi_event);

    3185. 

  3185. 	SCTP_BUF_NEXT(m_notify) = NULL;

    3186. 

  3186. 	control = sctp_build_readq_entry(stcb, stcb->asoc.primary_destination,

    3187. 

  3187. 					 0, 0, stcb->asoc.context, 0, 0, 0,

    3188. 

  3188. 					 m_notify);

    3189. 

  3189. 	if (control == NULL) {

    3190. 

  3190. 		/* no memory */

    3191. 

  3191. 		sctp_m_freem(m_notify);

    3192. 

  3192. 		return;

    3193. 

  3193. 	}

    3194. 

  3194. 	control->spec_flags = M_NOTIFICATION;

    3195. 

  3195. 	control->length = SCTP_BUF_LEN(m_notify);

    3196. 

  3196. 	/* not that we need this */

    3197. 

  3197. 	control->tail_mbuf = m_notify;

    3198. 

  3198. 	control->held_length = 0;

    3199. 

  3199. 	control->length = 0;

    3200. 

  3200. 	sb = &stcb->sctp_socket->so_rcv;

    3201. 

  3201. 	if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_SB_LOGGING_ENABLE) {

    3202. 

  3202. 		sctp_sblog(sb, control->do_not_ref_stcb?NULL:stcb, SCTP_LOG_SBALLOC, SCTP_BUF_LEN(m_notify));

    3203. 

  3203. 	}

    3204. 

  3204. 	sctp_sballoc(stcb, sb, m_notify);

    3205. 

  3205. 	if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_SB_LOGGING_ENABLE) {

    3206. 

  3206. 		sctp_sblog(sb, control->do_not_ref_stcb?NULL:stcb, SCTP_LOG_SBRESULT, 0);

    3207. 

  3207. 	}

    3208. 

  3208. 	atomic_add_int(&control->length, SCTP_BUF_LEN(m_notify));

    3209. 

  3209. 	control->end_added = 1;

    3210. 

  3210. 	if (stcb->asoc.control_pdapi)

    3211. 

  3211. 		TAILQ_INSERT_AFTER(&stcb->sctp_ep->read_queue, stcb->asoc.control_pdapi,  control, next);

    3212. 

  3212. 	else {

    3213. 

  3213. 		/* we really should not see this case */

    3214. 

  3214. 		TAILQ_INSERT_TAIL(&stcb->sctp_ep->read_queue, control, next);

    3215. 

  3215. 	}

    3216. 

  3216. 	if (stcb->sctp_ep && stcb->sctp_socket) {

    3217. 

  3217. 		/* This should always be the case */

    3218. 

  3218. #if defined (__APPLE__) || defined(SCTP_SO_LOCK_TESTING)

    3219. 

  3219. 		struct socket *so;

    3220. 

  3220. 

    3221. 

  3221. 		so = SCTP_INP_SO(stcb->sctp_ep);

    3222. 

  3222. 		if (!so_locked) {

    3223. 

  3223. 			atomic_add_int(&stcb->asoc.refcnt, 1);

    3224. 

  3224. 			SCTP_TCB_UNLOCK(stcb);

    3225. 

  3225. 			SCTP_SOCKET_LOCK(so, 1);

    3226. 

  3226. 			SCTP_TCB_LOCK(stcb);

    3227. 

  3227. 			atomic_subtract_int(&stcb->asoc.refcnt, 1);

    3228. 

  3228. 			if (stcb->sctp_ep->sctp_flags & SCTP_PCB_FLAGS_SOCKET_GONE) {

    3229. 

  3229. 				SCTP_SOCKET_UNLOCK(so, 1);

    3230. 

  3230. 				return;

    3231. 

  3231. 			}

    3232. 

  3232. 		}

    3233. 

  3233. #endif

    3234. 

  3234. 		sctp_sorwakeup(stcb->sctp_ep, stcb->sctp_socket);

    3235. 

  3235. #if defined (__APPLE__) || defined(SCTP_SO_LOCK_TESTING)

    3236. 

  3236. 		if (!so_locked) {

    3237. 

  3237. 			SCTP_SOCKET_UNLOCK(so, 1);

    3238. 

  3238. 		}

    3239. 

  3239. #endif

    3240. 

  3240. 	}

    3241. 

  3241. }

    3242. 

  3242. 

    3243. 

  3243. static void

    3244. 

  3244. sctp_notify_shutdown_event(struct sctp_tcb *stcb)

    3245. 

  3245. {

    3246. 

  3246. 	struct mbuf *m_notify;

    3247. 

  3247. 	struct sctp_shutdown_event *sse;

    3248. 

  3248. 	struct sctp_queued_to_read *control;

    3249. 

  3249. 

    3250. 

  3250. 	/*

    3251. 

  3251. 	 * For TCP model AND UDP connected sockets we will send an error up

    3252. 

  3252. 	 * when an SHUTDOWN completes

    3253. 

  3253. 	 */

    3254. 

  3254. 	if ((stcb->sctp_ep->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) ||

    3255. 

  3255. 	    (stcb->sctp_ep->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL)) {

    3256. 

  3256. 		/* mark socket closed for read/write and wakeup! */

    3257. 

  3257. #if defined (__APPLE__) || defined(SCTP_SO_LOCK_TESTING)

    3258. 

  3258. 		struct socket *so;

    3259. 

  3259. 

    3260. 

  3260. 		so = SCTP_INP_SO(stcb->sctp_ep);

    3261. 

  3261. 		atomic_add_int(&stcb->asoc.refcnt, 1);

    3262. 

  3262. 		SCTP_TCB_UNLOCK(stcb);

    3263. 

  3263. 		SCTP_SOCKET_LOCK(so, 1);

    3264. 

  3264. 		SCTP_TCB_LOCK(stcb);

    3265. 

  3265. 		atomic_subtract_int(&stcb->asoc.refcnt, 1);

    3266. 

  3266. 		if (stcb->asoc.state & SCTP_STATE_CLOSED_SOCKET) {

    3267. 

  3267. 			SCTP_SOCKET_UNLOCK(so, 1);

    3268. 

  3268. 			return;

    3269. 

  3269. 		}

    3270. 

  3270. #endif

    3271. 

  3271. 		socantsendmore(stcb->sctp_socket);

    3272. 

  3272. #if defined (__APPLE__) || defined(SCTP_SO_LOCK_TESTING)

    3273. 

  3273. 		SCTP_SOCKET_UNLOCK(so, 1);

    3274. 

  3274. #endif

    3275. 

  3275. 	}

    3276. 

  3276. 	if (sctp_stcb_is_feature_off(stcb->sctp_ep, stcb, SCTP_PCB_FLAGS_RECVSHUTDOWNEVNT)) {

    3277. 

  3277. 		/* event not enabled */

    3278. 

  3278. 		return;

    3279. 

  3279. 	}

    3280. 

  3280. 

    3281. 

  3281. 	m_notify = sctp_get_mbuf_for_msg(sizeof(struct sctp_shutdown_event), 0, M_DONTWAIT, 1, MT_DATA);

    3282. 

  3282. 	if (m_notify == NULL)

    3283. 

  3283. 		/* no space left */

    3284. 

  3284. 		return;

    3285. 

  3285. 	sse = mtod(m_notify, struct sctp_shutdown_event *);

    3286. 

  3286. 	sse->sse_type = SCTP_SHUTDOWN_EVENT;

    3287. 

  3287. 	sse->sse_flags = 0;

    3288. 

  3288. 	sse->sse_length = sizeof(struct sctp_shutdown_event);

    3289. 

  3289. 	sse->sse_assoc_id = sctp_get_associd(stcb);

    3290. 

  3290. 

    3291. 

  3291. 	SCTP_BUF_LEN(m_notify) = sizeof(struct sctp_shutdown_event);

    3292. 

  3292. 	SCTP_BUF_NEXT(m_notify) = NULL;

    3293. 

  3293. 

    3294. 

  3294. 	/* append to socket */

    3295. 

  3295. 	control = sctp_build_readq_entry(stcb, stcb->asoc.primary_destination,

    3296. 

  3296. 	                                 0, 0, stcb->asoc.context, 0, 0, 0,

    3297. 

  3297. 	                                 m_notify);

    3298. 

  3298. 	if (control == NULL) {

    3299. 

  3299. 		/* no memory */

    3300. 

  3300. 		sctp_m_freem(m_notify);

    3301. 

  3301. 		return;

    3302. 

  3302. 	}

    3303. 

  3303. 	control->spec_flags = M_NOTIFICATION;

    3304. 

  3304. 	control->length = SCTP_BUF_LEN(m_notify);

    3305. 

  3305. 	/* not that we need this */

    3306. 

  3306. 	control->tail_mbuf = m_notify;

    3307. 

  3307. 	sctp_add_to_readq(stcb->sctp_ep, stcb,

    3308. 

  3308. 	    control,

    3309. 

  3309. 	    &stcb->sctp_socket->so_rcv, 1, SCTP_READ_LOCK_NOT_HELD, SCTP_SO_NOT_LOCKED);

    3310. 

  3310. }

    3311. 

  3311. 

    3312. 

  3312. static void

    3313. 

  3313. sctp_notify_sender_dry_event(struct sctp_tcb *stcb,

    3314. 

  3314.                              int so_locked

    3315. 

  3315. #if !defined(__APPLE__) && !defined(SCTP_SO_LOCK_TESTING)

    3316. 

  3316.                              SCTP_UNUSED

    3317. 

  3317. #endif

    3318. 

  3318.                              )

    3319. 

  3319. {

    3320. 

  3320. 	struct mbuf *m_notify;

    3321. 

  3321. 	struct sctp_sender_dry_event *event;

    3322. 

  3322. 	struct sctp_queued_to_read *control;

    3323. 

  3323. 

    3324. 

  3324. 	if ((stcb == NULL) ||

    3325. 

  3325. 	    sctp_stcb_is_feature_off(stcb->sctp_ep, stcb, SCTP_PCB_FLAGS_DRYEVNT)) {

    3326. 

  3326. 		/* event not enabled */

    3327. 

  3327. 		return;

    3328. 

  3328. 	}

    3329. 

  3329. 

    3330. 

  3330. 	m_notify = sctp_get_mbuf_for_msg(sizeof(struct sctp_sender_dry_event), 0, M_DONTWAIT, 1, MT_DATA);

    3331. 

  3331. 	if (m_notify == NULL) {

    3332. 

  3332. 		/* no space left */

    3333. 

  3333. 		return;

    3334. 

  3334. 	}

    3335. 

  3335. 	SCTP_BUF_LEN(m_notify) = 0;

    3336. 

  3336. 	event = mtod(m_notify, struct sctp_sender_dry_event *);

    3337. 

  3337. 	event->sender_dry_type = SCTP_SENDER_DRY_EVENT;

    3338. 

  3338. 	event->sender_dry_flags = 0;

    3339. 

  3339. 	event->sender_dry_length = sizeof(struct sctp_sender_dry_event);

    3340. 

  3340. 	event->sender_dry_assoc_id = sctp_get_associd(stcb);

    3341. 

  3341. 

    3342. 

  3342. 	SCTP_BUF_LEN(m_notify) = sizeof(struct sctp_sender_dry_event);

    3343. 

  3343. 	SCTP_BUF_NEXT(m_notify) = NULL;

    3344. 

  3344. 

    3345. 

  3345. 	/* append to socket */

    3346. 

  3346. 	control = sctp_build_readq_entry(stcb, stcb->asoc.primary_destination,

    3347. 

  3347. 	                                 0, 0, stcb->asoc.context, 0, 0, 0,

    3348. 

  3348. 	                                 m_notify);

    3349. 

  3349. 	if (control == NULL) {

    3350. 

  3350. 		/* no memory */

    3351. 

  3351. 		sctp_m_freem(m_notify);

    3352. 

  3352. 		return;

    3353. 

  3353. 	}

    3354. 

  3354. 	control->length = SCTP_BUF_LEN(m_notify);

    3355. 

  3355. 	control->spec_flags = M_NOTIFICATION;

    3356. 

  3356. 	/* not that we need this */

    3357. 

  3357. 	control->tail_mbuf = m_notify;

    3358. 

  3358. 	sctp_add_to_readq(stcb->sctp_ep, stcb, control,

    3359. 

  3359. 	                  &stcb->sctp_socket->so_rcv, 1, SCTP_READ_LOCK_NOT_HELD, so_locked);

    3360. 

  3360. }

    3361. 

  3361. 

    3362. 

  3362. 

    3363. 

  3363. void

    3364. 

  3364. sctp_notify_stream_reset_add(struct sctp_tcb *stcb, uint16_t numberin, uint16_t numberout, int flag)

    3365. 

  3365. {

    3366. 

  3366. 	struct mbuf *m_notify;

    3367. 

  3367. 	struct sctp_queued_to_read *control;

    3368. 

  3368. 	struct sctp_stream_change_event *stradd;

    3369. 

  3369. 	int len;

    3370. 

  3370. 

    3371. 

  3371. 	if ((stcb == NULL) ||

    3372. 

  3372. 	    (sctp_stcb_is_feature_off(stcb->sctp_ep, stcb, SCTP_PCB_FLAGS_STREAM_CHANGEEVNT))) {

    3373. 

  3373. 		/* event not enabled */

    3374. 

  3374. 		return;

    3375. 

  3375. 	}

    3376. 

  3376. 	if ((stcb->asoc.peer_req_out) && flag) {

    3377. 

  3377. 		/* Peer made the request, don't tell the local user */

    3378. 

  3378. 		stcb->asoc.peer_req_out = 0;

    3379. 

  3379. 		return;

    3380. 

  3380. 	}

    3381. 

  3381. 	stcb->asoc.peer_req_out = 0;

    3382. 

  3382. 	m_notify = sctp_get_mbuf_for_msg(MCLBYTES, 0, M_DONTWAIT, 1, MT_DATA);

    3383. 

  3383. 	if (m_notify == NULL)

    3384. 

  3384. 		/* no space left */

    3385. 

  3385. 		return;

    3386. 

  3386. 	SCTP_BUF_LEN(m_notify) = 0;

    3387. 

  3387. 	len = sizeof(struct sctp_stream_change_event);

    3388. 

  3388. 	if (len > M_TRAILINGSPACE(m_notify)) {

    3389. 

  3389. 		/* never enough room */

    3390. 

  3390. 		sctp_m_freem(m_notify);

    3391. 

  3391. 		return;

    3392. 

  3392. 	}

    3393. 

  3393. 	stradd = mtod(m_notify, struct sctp_stream_change_event *);

    3394. 

  3394. 	stradd->strchange_type = SCTP_STREAM_CHANGE_EVENT;

    3395. 

  3395. 	stradd->strchange_flags = flag;

    3396. 

  3396. 	stradd->strchange_length = len;

    3397. 

  3397. 	stradd->strchange_assoc_id = sctp_get_associd(stcb);

    3398. 

  3398. 	stradd->strchange_instrms = numberin;

    3399. 

  3399. 	stradd->strchange_outstrms = numberout;

    3400. 

  3400. 	SCTP_BUF_LEN(m_notify) = len;

    3401. 

  3401. 	SCTP_BUF_NEXT(m_notify) = NULL;

    3402. 

  3402. 	if (sctp_sbspace(&stcb->asoc, &stcb->sctp_socket->so_rcv) < SCTP_BUF_LEN(m_notify)) {

    3403. 

  3403. 		/* no space */

    3404. 

  3404. 		sctp_m_freem(m_notify);

    3405. 

  3405. 		return;

    3406. 

  3406. 	}

    3407. 

  3407. 	/* append to socket */

    3408. 

  3408. 	control = sctp_build_readq_entry(stcb, stcb->asoc.primary_destination,

    3409. 

  3409. 	                                 0, 0, stcb->asoc.context, 0, 0, 0,

    3410. 

  3410. 	                                 m_notify);

    3411. 

  3411. 	if (control == NULL) {

    3412. 

  3412. 		/* no memory */

    3413. 

  3413. 		sctp_m_freem(m_notify);

    3414. 

  3414. 		return;

    3415. 

  3415. 	}

    3416. 

  3416. 	control->spec_flags = M_NOTIFICATION;

    3417. 

  3417. 	control->length = SCTP_BUF_LEN(m_notify);

    3418. 

  3418. 	/* not that we need this */

    3419. 

  3419. 	control->tail_mbuf = m_notify;

    3420. 

  3420. 	sctp_add_to_readq(stcb->sctp_ep, stcb,

    3421. 

  3421. 	    control,

    3422. 

  3422. 	    &stcb->sctp_socket->so_rcv, 1, SCTP_READ_LOCK_NOT_HELD, SCTP_SO_NOT_LOCKED);

    3423. 

  3423. }

    3424. 

  3424. 

    3425. 

  3425. void

    3426. 

  3426. sctp_notify_stream_reset_tsn(struct sctp_tcb *stcb, uint32_t sending_tsn, uint32_t recv_tsn, int flag)

    3427. 

  3427. {

    3428. 

  3428. 	struct mbuf *m_notify;

    3429. 

  3429. 	struct sctp_queued_to_read *control;

    3430. 

  3430. 	struct sctp_assoc_reset_event *strasoc;

    3431. 

  3431. 	int len;

    3432. 

  3432. 

    3433. 

  3433. 	if ((stcb == NULL) ||

    3434. 

  3434. 	    (sctp_stcb_is_feature_off(stcb->sctp_ep, stcb, SCTP_PCB_FLAGS_ASSOC_RESETEVNT))) {

    3435. 

  3435. 		/* event not enabled */

    3436. 

  3436. 		return;

    3437. 

  3437. 	}

    3438. 

  3438. 	m_notify = sctp_get_mbuf_for_msg(MCLBYTES, 0, M_DONTWAIT, 1, MT_DATA);

    3439. 

  3439. 	if (m_notify == NULL)

    3440. 

  3440. 		/* no space left */

    3441. 

  3441. 		return;

    3442. 

  3442. 	SCTP_BUF_LEN(m_notify) = 0;

    3443. 

  3443. 	len = sizeof(struct sctp_assoc_reset_event);

    3444. 

  3444. 	if (len > M_TRAILINGSPACE(m_notify)) {

    3445. 

  3445. 		/* never enough room */

    3446. 

  3446. 		sctp_m_freem(m_notify);

    3447. 

  3447. 		return;

    3448. 

  3448. 	}

    3449. 

  3449. 	strasoc = mtod(m_notify, struct sctp_assoc_reset_event  *);

    3450. 

  3450. 	strasoc->assocreset_type = SCTP_ASSOC_RESET_EVENT;

    3451. 

  3451. 	strasoc->assocreset_flags = flag;

    3452. 

  3452. 	strasoc->assocreset_length = len;

    3453. 

  3453. 	strasoc->assocreset_assoc_id= sctp_get_associd(stcb);

    3454. 

  3454. 	strasoc->assocreset_local_tsn = sending_tsn;

    3455. 

  3455. 	strasoc->assocreset_remote_tsn = recv_tsn;

    3456. 

  3456. 	SCTP_BUF_LEN(m_notify) = len;

    3457. 

  3457. 	SCTP_BUF_NEXT(m_notify) = NULL;

    3458. 

  3458. 	if (sctp_sbspace(&stcb->asoc, &stcb->sctp_socket->so_rcv) < SCTP_BUF_LEN(m_notify)) {

    3459. 

  3459. 		/* no space */

    3460. 

  3460. 		sctp_m_freem(m_notify);

    3461. 

  3461. 		return;

    3462. 

  3462. 	}

    3463. 

  3463. 	/* append to socket */

    3464. 

  3464. 	control = sctp_build_readq_entry(stcb, stcb->asoc.primary_destination,

    3465. 

  3465. 	                                 0, 0, stcb->asoc.context, 0, 0, 0,

    3466. 

  3466. 	                                 m_notify);

    3467. 

  3467. 	if (control == NULL) {

    3468. 

  3468. 		/* no memory */

    3469. 

  3469. 		sctp_m_freem(m_notify);

    3470. 

  3470. 		return;

    3471. 

  3471. 	}

    3472. 

  3472. 	control->spec_flags = M_NOTIFICATION;

    3473. 

  3473. 	control->length = SCTP_BUF_LEN(m_notify);

    3474. 

  3474. 	/* not that we need this */

    3475. 

  3475. 	control->tail_mbuf = m_notify;

    3476. 

  3476. 	sctp_add_to_readq(stcb->sctp_ep, stcb,

    3477. 

  3477. 	    control,

    3478. 

  3478. 	    &stcb->sctp_socket->so_rcv, 1, SCTP_READ_LOCK_NOT_HELD, SCTP_SO_NOT_LOCKED);

    3479. 

  3479. }

    3480. 

  3480. 

    3481. 

  3481. 

    3482. 

  3482. 

    3483. 

  3483. static void

    3484. 

  3484. sctp_notify_stream_reset(struct sctp_tcb *stcb,

    3485. 

  3485.     int number_entries, uint16_t * list, int flag)

    3486. 

  3486. {

    3487. 

  3487. 	struct mbuf *m_notify;

    3488. 

  3488. 	struct sctp_queued_to_read *control;

    3489. 

  3489. 	struct sctp_stream_reset_event *strreset;

    3490. 

  3490. 	int len;

    3491. 

  3491. 

    3492. 

  3492. 	if ((stcb == NULL) ||

    3493. 

  3493. 	    (sctp_stcb_is_feature_off(stcb->sctp_ep, stcb, SCTP_PCB_FLAGS_STREAM_RESETEVNT))) {

    3494. 

  3494. 		/* event not enabled */

    3495. 

  3495. 		return;

    3496. 

  3496. 	}

    3497. 

  3497. 

    3498. 

  3498. 	m_notify = sctp_get_mbuf_for_msg(MCLBYTES, 0, M_DONTWAIT, 1, MT_DATA);

    3499. 

  3499. 	if (m_notify == NULL)

    3500. 

  3500. 		/* no space left */

    3501. 

  3501. 		return;

    3502. 

  3502. 	SCTP_BUF_LEN(m_notify) = 0;

    3503. 

  3503. 	len = sizeof(struct sctp_stream_reset_event) + (number_entries * sizeof(uint16_t));

    3504. 

  3504. 	if (len > M_TRAILINGSPACE(m_notify)) {

    3505. 

  3505. 		/* never enough room */

    3506. 

  3506. 		sctp_m_freem(m_notify);

    3507. 

  3507. 		return;

    3508. 

  3508. 	}

    3509. 

  3509. 	strreset = mtod(m_notify, struct sctp_stream_reset_event *);

    3510. 

  3510. 	strreset->strreset_type = SCTP_STREAM_RESET_EVENT;

    3511. 

  3511. 	strreset->strreset_flags = flag;

    3512. 

  3512. 	strreset->strreset_length = len;

    3513. 

  3513. 	strreset->strreset_assoc_id = sctp_get_associd(stcb);

    3514. 

  3514. 	if (number_entries) {

    3515. 

  3515. 		int i;

    3516. 

  3516. 

    3517. 

  3517. 		for (i = 0; i < number_entries; i++) {

    3518. 

  3518. 			strreset->strreset_stream_list[i] = ntohs(list[i]);

    3519. 

  3519. 		}

    3520. 

  3520. 	}

    3521. 

  3521. 	SCTP_BUF_LEN(m_notify) = len;

    3522. 

  3522. 	SCTP_BUF_NEXT(m_notify) = NULL;

    3523. 

  3523. 	if (sctp_sbspace(&stcb->asoc, &stcb->sctp_socket->so_rcv) < SCTP_BUF_LEN(m_notify)) {

    3524. 

  3524. 		/* no space */

    3525. 

  3525. 		sctp_m_freem(m_notify);

    3526. 

  3526. 		return;

    3527. 

  3527. 	}

    3528. 

  3528. 	/* append to socket */

    3529. 

  3529. 	control = sctp_build_readq_entry(stcb, stcb->asoc.primary_destination,

    3530. 

  3530. 	                                 0, 0, stcb->asoc.context, 0, 0, 0,

    3531. 

  3531. 	                                 m_notify);

    3532. 

  3532. 	if (control == NULL) {

    3533. 

  3533. 		/* no memory */

    3534. 

  3534. 		sctp_m_freem(m_notify);

    3535. 

  3535. 		return;

    3536. 

  3536. 	}

    3537. 

  3537. 	control->spec_flags = M_NOTIFICATION;

    3538. 

  3538. 	control->length = SCTP_BUF_LEN(m_notify);

    3539. 

  3539. 	/* not that we need this */

    3540. 

  3540. 	control->tail_mbuf = m_notify;

    3541. 

  3541. 	sctp_add_to_readq(stcb->sctp_ep, stcb,

    3542. 

  3542. 	                  control,

    3543. 

  3543. 	                  &stcb->sctp_socket->so_rcv, 1, SCTP_READ_LOCK_NOT_HELD, SCTP_SO_NOT_LOCKED);

    3544. 

  3544. }

    3545. 

  3545. 

    3546. 

  3546. 

    3547. 

  3547. static void

    3548. 

  3548. sctp_notify_remote_error(struct sctp_tcb *stcb, uint16_t error, struct sctp_error_chunk *chunk)

    3549. 

  3549. {

    3550. 

  3550. 	struct mbuf *m_notify;

    3551. 

  3551. 	struct sctp_remote_error *sre;

    3552. 

  3552. 	struct sctp_queued_to_read *control;

    3553. 

  3553. 	size_t notif_len, chunk_len;

    3554. 

  3554. 

    3555. 

  3555. 	if ((stcb == NULL) ||

    3556. 

  3556. 	    sctp_stcb_is_feature_off(stcb->sctp_ep, stcb, SCTP_PCB_FLAGS_RECVPEERERR)) {

    3557. 

  3557. 		return;

    3558. 

  3558. 	}

    3559. 

  3559. 	if (chunk != NULL) {

    3560. 

  3560. 		chunk_len = htons(chunk->ch.chunk_length);

    3561. 

  3561. 	} else {

    3562. 

  3562. 		chunk_len = 0;

    3563. 

  3563. 	}

    3564. 

  3564. 	notif_len = sizeof(struct sctp_remote_error) + chunk_len;

    3565. 

  3565. 	m_notify = sctp_get_mbuf_for_msg(notif_len, 0, M_DONTWAIT, 1, MT_DATA);

    3566. 

  3566. 	if (m_notify == NULL) {

    3567. 

  3567. 		/* Retry with smaller value. */

    3568. 

  3568. 		notif_len = sizeof(struct sctp_remote_error);

    3569. 

  3569. 		m_notify = sctp_get_mbuf_for_msg(notif_len, 0, M_DONTWAIT, 1, MT_DATA);

    3570. 

  3570. 		if (m_notify == NULL) {

    3571. 

  3571. 			return;

    3572. 

  3572. 		}

    3573. 

  3573. 	}

    3574. 

  3574. 	SCTP_BUF_NEXT(m_notify) = NULL;

    3575. 

  3575. 	sre = mtod(m_notify, struct sctp_remote_error *);

    3576. 

  3576. 	sre->sre_type = SCTP_REMOTE_ERROR;

    3577. 

  3577. 	sre->sre_flags = 0;

    3578. 

  3578. 	sre->sre_length = sizeof(struct sctp_remote_error);

    3579. 

  3579. 	sre->sre_error = error;

    3580. 

  3580. 	sre->sre_assoc_id = sctp_get_associd(stcb);

    3581. 

  3581. 	if (notif_len > sizeof(struct sctp_remote_error)) {

    3582. 

  3582. 		memcpy(sre->sre_data, chunk, chunk_len);

    3583. 

  3583. 		sre->sre_length += chunk_len;

    3584. 

  3584. 	}

    3585. 

  3585. 	SCTP_BUF_LEN(m_notify) = sre->sre_length;

    3586. 

  3586. 	control = sctp_build_readq_entry(stcb, stcb->asoc.primary_destination,

    3587. 

  3587. 	                                 0, 0, stcb->asoc.context, 0, 0, 0,

    3588. 

  3588. 	                                 m_notify);

    3589. 

  3589. 	if (control != NULL) {

    3590. 

  3590. 		control->length = SCTP_BUF_LEN(m_notify);

    3591. 

  3591. 		/* not that we need this */

    3592. 

  3592. 		control->tail_mbuf = m_notify;

    3593. 

  3593. 		control->spec_flags = M_NOTIFICATION;

    3594. 

  3594. 		sctp_add_to_readq(stcb->sctp_ep, stcb,

    3595. 

  3595. 		                  control,

    3596. 

  3596. 		                  &stcb->sctp_socket->so_rcv, 1,

    3597. 

  3597. 				  SCTP_READ_LOCK_NOT_HELD, SCTP_SO_NOT_LOCKED);

    3598. 

  3598. 	} else {

    3599. 

  3599. 		sctp_m_freem(m_notify);

    3600. 

  3600. 	}

    3601. 

  3601. }

    3602. 

  3602. 

    3603. 

  3603. 

    3604. 

  3604. void

    3605. 

  3605. sctp_ulp_notify(uint32_t notification, struct sctp_tcb *stcb,

    3606. 

  3606.     uint32_t error, void *data, int so_locked

    3607. 

  3607. #if !defined(__APPLE__) && !defined(SCTP_SO_LOCK_TESTING)

    3608. 

  3608.     SCTP_UNUSED

    3609. 

  3609. #endif

    3610. 

  3610.     )

    3611. 

  3611. {

    3612. 

  3612. 	if ((stcb == NULL) ||

    3613. 

  3613. 	    (stcb->sctp_ep->sctp_flags & SCTP_PCB_FLAGS_SOCKET_GONE) ||

    3614. 

  3614. 	    (stcb->sctp_ep->sctp_flags & SCTP_PCB_FLAGS_SOCKET_ALLGONE) ||

    3615. 

  3615. 	    (stcb->asoc.state & SCTP_STATE_CLOSED_SOCKET)) {

    3616. 

  3616. 		/* If the socket is gone we are out of here */

    3617. 

  3617. 		return;

    3618. 

  3618. 	}

    3619. 

  3619. #if (defined(__FreeBSD__) && __FreeBSD_version > 500000) || defined(__Windows__)

    3620. 

  3620. 	if (stcb->sctp_socket->so_rcv.sb_state & SBS_CANTRCVMORE) {

    3621. 

  3621. #else

    3622. 

  3622. 	if (stcb->sctp_socket->so_state & SS_CANTRCVMORE) {

    3623. 

  3623. #endif

    3624. 

  3624. 		return;

    3625. 

  3625. 	}

    3626. 

  3626. #if defined(__APPLE__)

    3627. 

  3627. 	if (so_locked) {

    3628. 

  3628. 		sctp_lock_assert(SCTP_INP_SO(stcb->sctp_ep));

    3629. 

  3629. 	} else {

    3630. 

  3630. 		sctp_unlock_assert(SCTP_INP_SO(stcb->sctp_ep));

    3631. 

  3631. 	}

    3632. 

  3632. #endif

    3633. 

  3633. 	if (stcb && ((stcb->asoc.state & SCTP_STATE_COOKIE_WAIT) ||

    3634. 

  3634. 	             (stcb->asoc.state &  SCTP_STATE_COOKIE_ECHOED))) {

    3635. 

  3635. 		if ((notification == SCTP_NOTIFY_INTERFACE_DOWN) ||

    3636. 

  3636. 		    (notification == SCTP_NOTIFY_INTERFACE_UP) ||

    3637. 

  3637. 		    (notification == SCTP_NOTIFY_INTERFACE_CONFIRMED)) {

    3638. 

  3638. 			/* Don't report these in front states */

    3639. 

  3639. 			return;

    3640. 

  3640. 		}

    3641. 

  3641. 	}

    3642. 

  3642. 	switch (notification) {

    3643. 

  3643. 	case SCTP_NOTIFY_ASSOC_UP:

    3644. 

  3644. 		if (stcb->asoc.assoc_up_sent == 0) {

    3645. 

  3645. 			sctp_notify_assoc_change(SCTP_COMM_UP, stcb, error, NULL, 0, so_locked);

    3646. 

  3646. 			stcb->asoc.assoc_up_sent = 1;

    3647. 

  3647. 		}

    3648. 

  3648. 		if (stcb->asoc.adaptation_needed && (stcb->asoc.adaptation_sent == 0)) {

    3649. 

  3649. 			sctp_notify_adaptation_layer(stcb);

    3650. 

  3650. 		}

    3651. 

  3651. 		if (stcb->asoc.peer_supports_auth == 0) {

    3652. 

  3652. 			sctp_ulp_notify(SCTP_NOTIFY_NO_PEER_AUTH, stcb, 0,

    3653. 

  3653. 					NULL, so_locked);

    3654. 

  3654. 		}

    3655. 

  3655. 		break;

    3656. 

  3656. 	case SCTP_NOTIFY_ASSOC_DOWN:

    3657. 

  3657. 		sctp_notify_assoc_change(SCTP_SHUTDOWN_COMP, stcb, error, NULL, 0, so_locked);

    3658. 

  3658. #if defined (__Userspace__)

    3659. 

  3659. 		if (stcb->sctp_ep->recv_callback) {

    3660. 

  3660. 			if (stcb->sctp_socket) {

    3661. 

  3661. 				union sctp_sockstore addr;

    3662. 

  3662. 				struct sctp_rcvinfo rcv;

    3663. 

  3663. 

    3664. 

  3664. 				memset(&addr, 0, sizeof(union sctp_sockstore));

    3665. 

  3665. 				memset(&rcv, 0, sizeof(struct sctp_rcvinfo));

    3666. 

  3666. 				atomic_add_int(&stcb->asoc.refcnt, 1);

    3667. 

  3667. 				SCTP_TCB_UNLOCK(stcb);

    3668. 

  3668. 				stcb->sctp_ep->recv_callback(stcb->sctp_socket, addr, NULL, 0, rcv, 0, stcb->sctp_ep->ulp_info);

    3669. 

  3669. 				SCTP_TCB_LOCK(stcb);

    3670. 

  3670. 				atomic_subtract_int(&stcb->asoc.refcnt, 1);

    3671. 

  3671. 			}

    3672. 

  3672. 		}

    3673. 

  3673. #endif

    3674. 

  3674. 		break;

    3675. 

  3675. 	case SCTP_NOTIFY_INTERFACE_DOWN:

    3676. 

  3676. 		{

    3677. 

  3677. 			struct sctp_nets *net;

    3678. 

  3678. 

    3679. 

  3679. 			net = (struct sctp_nets *)data;

    3680. 

  3680. 			sctp_notify_peer_addr_change(stcb, SCTP_ADDR_UNREACHABLE,

    3681. 

  3681. 			    (struct sockaddr *)&net->ro._l_addr, error);

    3682. 

  3682. 			break;

    3683. 

  3683. 		}

    3684. 

  3684. 	case SCTP_NOTIFY_INTERFACE_UP:

    3685. 

  3685. 		{

    3686. 

  3686. 			struct sctp_nets *net;

    3687. 

  3687. 

    3688. 

  3688. 			net = (struct sctp_nets *)data;

    3689. 

  3689. 			sctp_notify_peer_addr_change(stcb, SCTP_ADDR_AVAILABLE,

    3690. 

  3690. 			    (struct sockaddr *)&net->ro._l_addr, error);

    3691. 

  3691. 			break;

    3692. 

  3692. 		}

    3693. 

  3693. 	case SCTP_NOTIFY_INTERFACE_CONFIRMED:

    3694. 

  3694. 		{

    3695. 

  3695. 			struct sctp_nets *net;

    3696. 

  3696. 

    3697. 

  3697. 			net = (struct sctp_nets *)data;

    3698. 

  3698. 			sctp_notify_peer_addr_change(stcb, SCTP_ADDR_CONFIRMED,

    3699. 

  3699. 			    (struct sockaddr *)&net->ro._l_addr, error);

    3700. 

  3700. 			break;

    3701. 

  3701. 		}

    3702. 

  3702. 	case SCTP_NOTIFY_SPECIAL_SP_FAIL:

    3703. 

  3703. 		sctp_notify_send_failed2(stcb, error,

    3704. 

  3704. 					 (struct sctp_stream_queue_pending *)data, so_locked);

    3705. 

  3705. 		break;

    3706. 

  3706. 	case SCTP_NOTIFY_SENT_DG_FAIL:

    3707. 

  3707. 		sctp_notify_send_failed(stcb, 1, error,

    3708. 

  3708. 		    (struct sctp_tmit_chunk *)data, so_locked);

    3709. 

  3709. 		break;

    3710. 

  3710. 	case SCTP_NOTIFY_UNSENT_DG_FAIL:

    3711. 

  3711. 		sctp_notify_send_failed(stcb, 0, error,

    3712. 

  3712. 					(struct sctp_tmit_chunk *)data, so_locked);

    3713. 

  3713. 		break;

    3714. 

  3714. 	case SCTP_NOTIFY_PARTIAL_DELVIERY_INDICATION:

    3715. 

  3715. 		{

    3716. 

  3716. 			uint32_t val;

    3717. 

  3717. 			val = *((uint32_t *)data);

    3718. 

  3718. 

    3719. 

  3719. 			sctp_notify_partial_delivery_indication(stcb, error, val, so_locked);

    3720. 

  3720. 		break;

    3721. 

  3721. 		}

    3722. 

  3722. 	case SCTP_NOTIFY_ASSOC_LOC_ABORTED:

    3723. 

  3723. 		if ((stcb) && (((stcb->asoc.state & SCTP_STATE_MASK) == SCTP_STATE_COOKIE_WAIT) ||

    3724. 

  3724. 			       ((stcb->asoc.state & SCTP_STATE_MASK) == SCTP_STATE_COOKIE_ECHOED))) {

    3725. 

  3725. 			sctp_notify_assoc_change(SCTP_CANT_STR_ASSOC, stcb, error, data, 0, so_locked);

    3726. 

  3726. 		} else {

    3727. 

  3727. 			sctp_notify_assoc_change(SCTP_COMM_LOST, stcb, error, data, 0, so_locked);

    3728. 

  3728. 		}

    3729. 

  3729. 		break;

    3730. 

  3730. 	case SCTP_NOTIFY_ASSOC_REM_ABORTED:

    3731. 

  3731. 		if ((stcb) && (((stcb->asoc.state & SCTP_STATE_MASK) == SCTP_STATE_COOKIE_WAIT) ||

    3732. 

  3732. 				((stcb->asoc.state & SCTP_STATE_MASK) == SCTP_STATE_COOKIE_ECHOED))) {

    3733. 

  3733. 			sctp_notify_assoc_change(SCTP_CANT_STR_ASSOC, stcb, error, data, 1, so_locked);

    3734. 

  3734. 		} else {

    3735. 

  3735. 			sctp_notify_assoc_change(SCTP_COMM_LOST, stcb, error, data, 1, so_locked);

    3736. 

  3736. 		}

    3737. 

  3737. 		break;

    3738. 

  3738. 	case SCTP_NOTIFY_ASSOC_RESTART:

    3739. 

  3739. 		sctp_notify_assoc_change(SCTP_RESTART, stcb, error, NULL, 0, so_locked);

    3740. 

  3740. 		if (stcb->asoc.peer_supports_auth == 0) {

    3741. 

  3741. 			sctp_ulp_notify(SCTP_NOTIFY_NO_PEER_AUTH, stcb, 0,

    3742. 

  3742. 					NULL, so_locked);

    3743. 

  3743. 		}

    3744. 

  3744. 		break;

    3745. 

  3745. 	case SCTP_NOTIFY_STR_RESET_SEND:

    3746. 

  3746. 		sctp_notify_stream_reset(stcb, error, ((uint16_t *) data), SCTP_STREAM_RESET_OUTGOING_SSN);

    3747. 

  3747. 		break;

    3748. 

  3748. 	case SCTP_NOTIFY_STR_RESET_RECV:

    3749. 

  3749. 		sctp_notify_stream_reset(stcb, error, ((uint16_t *) data), SCTP_STREAM_RESET_INCOMING);

    3750. 

  3750. 		break;

    3751. 

  3751. 	case SCTP_NOTIFY_STR_RESET_FAILED_OUT:

    3752. 

  3752. 		sctp_notify_stream_reset(stcb, error, ((uint16_t *) data),

    3753. 

  3753. 					 (SCTP_STREAM_RESET_OUTGOING_SSN|SCTP_STREAM_RESET_FAILED));

    3754. 

  3754. 		break;

    3755. 

  3755. 	case SCTP_NOTIFY_STR_RESET_DENIED_OUT:

    3756. 

  3756. 		sctp_notify_stream_reset(stcb, error, ((uint16_t *) data),

    3757. 

  3757. 		                         (SCTP_STREAM_RESET_OUTGOING_SSN|SCTP_STREAM_RESET_DENIED));

    3758. 

  3758. 		break;

    3759. 

  3759. 	case SCTP_NOTIFY_STR_RESET_FAILED_IN:

    3760. 

  3760. 		sctp_notify_stream_reset(stcb, error, ((uint16_t *) data),

    3761. 

  3761. 					 (SCTP_STREAM_RESET_INCOMING|SCTP_STREAM_RESET_FAILED));

    3762. 

  3762. 		break;

    3763. 

  3763. 	case SCTP_NOTIFY_STR_RESET_DENIED_IN:

    3764. 

  3764. 		sctp_notify_stream_reset(stcb, error, ((uint16_t *) data),

    3765. 

  3765. 		                         (SCTP_STREAM_RESET_INCOMING|SCTP_STREAM_RESET_DENIED));

    3766. 

  3766. 		break;

    3767. 

  3767. 	case SCTP_NOTIFY_ASCONF_ADD_IP:

    3768. 

  3768. 		sctp_notify_peer_addr_change(stcb, SCTP_ADDR_ADDED, data,

    3769. 

  3769. 		    error);

    3770. 

  3770. 		break;

    3771. 

  3771. 	case SCTP_NOTIFY_ASCONF_DELETE_IP:

    3772. 

  3772. 		sctp_notify_peer_addr_change(stcb, SCTP_ADDR_REMOVED, data,

    3773. 

  3773. 		    error);

    3774. 

  3774. 		break;

    3775. 

  3775. 	case SCTP_NOTIFY_ASCONF_SET_PRIMARY:

    3776. 

  3776. 		sctp_notify_peer_addr_change(stcb, SCTP_ADDR_MADE_PRIM, data,

    3777. 

  3777. 		    error);

    3778. 

  3778. 		break;

    3779. 

  3779. 	case SCTP_NOTIFY_PEER_SHUTDOWN:

    3780. 

  3780. 		sctp_notify_shutdown_event(stcb);

    3781. 

  3781. 		break;

    3782. 

  3782. 	case SCTP_NOTIFY_AUTH_NEW_KEY:

    3783. 

  3783. 		sctp_notify_authentication(stcb, SCTP_AUTH_NEW_KEY, error,

    3784. 

  3784. 					   (uint16_t)(uintptr_t)data,

    3785. 

  3785. 					   so_locked);

    3786. 

  3786. 		break;

    3787. 

  3787. 	case SCTP_NOTIFY_AUTH_FREE_KEY:

    3788. 

  3788. 		sctp_notify_authentication(stcb, SCTP_AUTH_FREE_KEY, error,

    3789. 

  3789. 					   (uint16_t)(uintptr_t)data,

    3790. 

  3790. 					   so_locked);

    3791. 

  3791. 		break;

    3792. 

  3792. 	case SCTP_NOTIFY_NO_PEER_AUTH:

    3793. 

  3793. 		sctp_notify_authentication(stcb, SCTP_AUTH_NO_AUTH, error,

    3794. 

  3794. 					   (uint16_t)(uintptr_t)data,

    3795. 

  3795. 					   so_locked);

    3796. 

  3796. 		break;

    3797. 

  3797. 	case SCTP_NOTIFY_SENDER_DRY:

    3798. 

  3798. 		sctp_notify_sender_dry_event(stcb, so_locked);

    3799. 

  3799. 		break;

    3800. 

  3800. 	case SCTP_NOTIFY_REMOTE_ERROR:

    3801. 

  3801. 		sctp_notify_remote_error(stcb, error, data);

    3802. 

  3802. 		break;

    3803. 

  3803. 	default:

    3804. 

  3804. 		SCTPDBG(SCTP_DEBUG_UTIL1, "%s: unknown notification %xh (%u)\n",

    3805. 

  3805. 			__FUNCTION__, notification, notification);

    3806. 

  3806. 		break;

    3807. 

  3807. 	}			/* end switch */

    3808. 

  3808. }

    3809. 

  3809. 

    3810. 

  3810. void

    3811. 

  3811. sctp_report_all_outbound(struct sctp_tcb *stcb, uint16_t error, int holds_lock, int so_locked

    3812. 

  3812. #if !defined(__APPLE__) && !defined(SCTP_SO_LOCK_TESTING)

    3813. 

  3813.     SCTP_UNUSED

    3814. 

  3814. #endif

    3815. 

  3815.     )

    3816. 

  3816. {

    3817. 

  3817. 	struct sctp_association *asoc;

    3818. 

  3818. 	struct sctp_stream_out *outs;

    3819. 

  3819. 	struct sctp_tmit_chunk *chk, *nchk;

    3820. 

  3820. 	struct sctp_stream_queue_pending *sp, *nsp;

    3821. 

  3821. 	int i;

    3822. 

  3822. 

    3823. 

  3823. 	if (stcb == NULL) {

    3824. 

  3824. 		return;

    3825. 

  3825. 	}

    3826. 

  3826. 	asoc = &stcb->asoc;

    3827. 

  3827. 	if (asoc->state & SCTP_STATE_ABOUT_TO_BE_FREED) {

    3828. 

  3828. 		/* already being freed */

    3829. 

  3829. 		return;

    3830. 

  3830. 	}

    3831. 

  3831. #if defined(__APPLE__)

    3832. 

  3832. 	if (so_locked) {

    3833. 

  3833. 		sctp_lock_assert(SCTP_INP_SO(stcb->sctp_ep));

    3834. 

  3834. 	} else {

    3835. 

  3835. 		sctp_unlock_assert(SCTP_INP_SO(stcb->sctp_ep));

    3836. 

  3836. 	}

    3837. 

  3837. #endif

    3838. 

  3838. 	if ((stcb->sctp_ep->sctp_flags & SCTP_PCB_FLAGS_SOCKET_GONE) ||

    3839. 

  3839. 	    (stcb->sctp_ep->sctp_flags & SCTP_PCB_FLAGS_SOCKET_ALLGONE) ||

    3840. 

  3840. 	    (asoc->state & SCTP_STATE_CLOSED_SOCKET)) {

    3841. 

  3841. 		return;

    3842. 

  3842. 	}

    3843. 

  3843. 	/* now through all the gunk freeing chunks */

    3844. 

  3844. 	if (holds_lock == 0) {

    3845. 

  3845. 		SCTP_TCB_SEND_LOCK(stcb);

    3846. 

  3846. 	}

    3847. 

  3847. 	/* sent queue SHOULD be empty */

    3848. 

  3848. 	TAILQ_FOREACH_SAFE(chk, &asoc->sent_queue, sctp_next, nchk) {

    3849. 

  3849. 		TAILQ_REMOVE(&asoc->sent_queue, chk, sctp_next);

    3850. 

  3850. 		asoc->sent_queue_cnt--;

    3851. 

  3851. 		if (chk->data != NULL) {

    3852. 

  3852. 			sctp_free_bufspace(stcb, asoc, chk, 1);

    3853. 

  3853. 			sctp_ulp_notify(SCTP_NOTIFY_SENT_DG_FAIL, stcb,

    3854. 

  3854. 			                error, chk, so_locked);

    3855. 

  3855. 			if (chk->data) {

    3856. 

  3856. 				sctp_m_freem(chk->data);

    3857. 

  3857. 				chk->data = NULL;

    3858. 

  3858. 			}

    3859. 

  3859. 		}

    3860. 

  3860. 		sctp_free_a_chunk(stcb, chk, so_locked);

    3861. 

  3861. 		/*sa_ignore FREED_MEMORY*/

    3862. 

  3862. 	}

    3863. 

  3863. 	/* pending send queue SHOULD be empty */

    3864. 

  3864. 	TAILQ_FOREACH_SAFE(chk, &asoc->send_queue, sctp_next, nchk) {

    3865. 

  3865. 		TAILQ_REMOVE(&asoc->send_queue, chk, sctp_next);

    3866. 

  3866. 		asoc->send_queue_cnt--;

    3867. 

  3867. 		if (chk->data != NULL) {

    3868. 

  3868. 			sctp_free_bufspace(stcb, asoc, chk, 1);

    3869. 

  3869. 			sctp_ulp_notify(SCTP_NOTIFY_UNSENT_DG_FAIL, stcb,

    3870. 

  3870. 			                error, chk, so_locked);

    3871. 

  3871. 			if (chk->data) {

    3872. 

  3872. 				sctp_m_freem(chk->data);

    3873. 

  3873. 				chk->data = NULL;

    3874. 

  3874. 			}

    3875. 

  3875. 		}

    3876. 

  3876. 		sctp_free_a_chunk(stcb, chk, so_locked);

    3877. 

  3877. 		/*sa_ignore FREED_MEMORY*/

    3878. 

  3878. 	}

    3879. 

  3879. 	for (i = 0; i < asoc->streamoutcnt; i++) {

    3880. 

  3880. 		/* For each stream */

    3881. 

  3881. 		outs = &asoc->strmout[i];

    3882. 

  3882. 		/* clean up any sends there */

    3883. 

  3883. 		asoc->locked_on_sending = NULL;

    3884. 

  3884. 		TAILQ_FOREACH_SAFE(sp, &outs->outqueue, next, nsp) {

    3885. 

  3885. 			asoc->stream_queue_cnt--;

    3886. 

  3886. 			TAILQ_REMOVE(&outs->outqueue, sp, next);

    3887. 

  3887. 			sctp_free_spbufspace(stcb, asoc, sp);

    3888. 

  3888. 			if (sp->data) {

    3889. 

  3889. 				sctp_ulp_notify(SCTP_NOTIFY_SPECIAL_SP_FAIL, stcb,

    3890. 

  3890. 						error, (void *)sp, so_locked);

    3891. 

  3891. 				if (sp->data) {

    3892. 

  3892. 					sctp_m_freem(sp->data);

    3893. 

  3893. 					sp->data = NULL;

    3894. 

  3894. 				}

    3895. 

  3895. 			}

    3896. 

  3896. 			if (sp->net) {

    3897. 

  3897. 				sctp_free_remote_addr(sp->net);

    3898. 

  3898. 				sp->net = NULL;

    3899. 

  3899. 			}

    3900. 

  3900. 			/* Free the chunk */

    3901. 

  3901. 			sctp_free_a_strmoq(stcb, sp, so_locked);

    3902. 

  3902. 			/*sa_ignore FREED_MEMORY*/

    3903. 

  3903. 		}

    3904. 

  3904. 	}

    3905. 

  3905. 

    3906. 

  3906. 	if (holds_lock == 0) {

    3907. 

  3907. 		SCTP_TCB_SEND_UNLOCK(stcb);

    3908. 

  3908. 	}

    3909. 

  3909. }

    3910. 

  3910. 

    3911. 

  3911. void

    3912. 

  3912. sctp_abort_notification(struct sctp_tcb *stcb, uint8_t from_peer, uint16_t error,

    3913. 

  3913. 			struct sctp_abort_chunk *abort, int so_locked

    3914. 

  3914. #if !defined(__APPLE__) && !defined(SCTP_SO_LOCK_TESTING)

    3915. 

  3915.     SCTP_UNUSED

    3916. 

  3916. #endif

    3917. 

  3917.     )

    3918. 

  3918. {

    3919. 

  3919. 	if (stcb == NULL) {

    3920. 

  3920. 		return;

    3921. 

  3921. 	}

    3922. 

  3922. #if defined(__APPLE__)

    3923. 

  3923. 	if (so_locked) {

    3924. 

  3924. 		sctp_lock_assert(SCTP_INP_SO(stcb->sctp_ep));

    3925. 

  3925. 	} else {

    3926. 

  3926. 		sctp_unlock_assert(SCTP_INP_SO(stcb->sctp_ep));

    3927. 

  3927. 	}

    3928. 

  3928. #endif

    3929. 

  3929. 	if ((stcb->sctp_ep->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL) ||

    3930. 

  3930. 	    ((stcb->sctp_ep->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) &&

    3931. 

  3931. 	     (stcb->sctp_ep->sctp_flags & SCTP_PCB_FLAGS_CONNECTED))) {

    3932. 

  3932. 		stcb->sctp_ep->sctp_flags |= SCTP_PCB_FLAGS_WAS_ABORTED;

    3933. 

  3933. 	}

    3934. 

  3934. 	if ((stcb->sctp_ep->sctp_flags & SCTP_PCB_FLAGS_SOCKET_GONE) ||

    3935. 

  3935. 	    (stcb->sctp_ep->sctp_flags & SCTP_PCB_FLAGS_SOCKET_ALLGONE) ||

    3936. 

  3936. 	    (stcb->asoc.state & SCTP_STATE_CLOSED_SOCKET)) {

    3937. 

  3937. 		return;

    3938. 

  3938. 	}

    3939. 

  3939. 	/* Tell them we lost the asoc */

    3940. 

  3940. 	sctp_report_all_outbound(stcb, error, 1, so_locked);

    3941. 

  3941. 	if (from_peer) {

    3942. 

  3942. 		sctp_ulp_notify(SCTP_NOTIFY_ASSOC_REM_ABORTED, stcb, error, abort, so_locked);

    3943. 

  3943. 	} else {

    3944. 

  3944. 		sctp_ulp_notify(SCTP_NOTIFY_ASSOC_LOC_ABORTED, stcb, error, abort, so_locked);

    3945. 

  3945. 	}

    3946. 

  3946. }

    3947. 

  3947. 

    3948. 

  3948. void

    3949. 

  3949. sctp_abort_association(struct sctp_inpcb *inp, struct sctp_tcb *stcb,

    3950. 

  3950.     struct mbuf *m, int iphlen, struct sctphdr *sh, struct mbuf *op_err,

    3951. 

  3951.     uint32_t vrf_id, uint16_t port)

    3952. 

  3952. {

    3953. 

  3953. 	uint32_t vtag;

    3954. 

  3954. #if defined (__APPLE__) || defined(SCTP_SO_LOCK_TESTING)

    3955. 

  3955. 	struct socket *so;

    3956. 

  3956. #endif

    3957. 

  3957. 

    3958. 

  3958. 	vtag = 0;

    3959. 

  3959. 	if (stcb != NULL) {

    3960. 

  3960. 		/* We have a TCB to abort, send notification too */

    3961. 

  3961. 		vtag = stcb->asoc.peer_vtag;

    3962. 

  3962. 		sctp_abort_notification(stcb, 0, 0, NULL, SCTP_SO_NOT_LOCKED);

    3963. 

  3963. 		/* get the assoc vrf id and table id */

    3964. 

  3964. 		vrf_id = stcb->asoc.vrf_id;

    3965. 

  3965. 		stcb->asoc.state |= SCTP_STATE_WAS_ABORTED;

    3966. 

  3966. 	}

    3967. 

  3967. 	sctp_send_abort(m, iphlen, sh, vtag, op_err, vrf_id, port);

    3968. 

  3968. 	if (stcb != NULL) {

    3969. 

  3969. 		/* Ok, now lets free it */

    3970. 

  3970. #if defined (__APPLE__) || defined(SCTP_SO_LOCK_TESTING)

    3971. 

  3971. 		so = SCTP_INP_SO(inp);

    3972. 

  3972. 		atomic_add_int(&stcb->asoc.refcnt, 1);

    3973. 

  3973. 		SCTP_TCB_UNLOCK(stcb);

    3974. 

  3974. 		SCTP_SOCKET_LOCK(so, 1);

    3975. 

  3975. 		SCTP_TCB_LOCK(stcb);

    3976. 

  3976. 		atomic_subtract_int(&stcb->asoc.refcnt, 1);

    3977. 

  3977. #endif

    3978. 

  3978. 		SCTP_STAT_INCR_COUNTER32(sctps_aborted);

    3979. 

  3979. 		if ((SCTP_GET_STATE(&stcb->asoc) == SCTP_STATE_OPEN) ||

    3980. 

  3980. 		    (SCTP_GET_STATE(&stcb->asoc) == SCTP_STATE_SHUTDOWN_RECEIVED)) {

    3981. 

  3981. 			SCTP_STAT_DECR_GAUGE32(sctps_currestab);

    3982. 

  3982. 		}

    3983. 

  3983. 		(void)sctp_free_assoc(inp, stcb, SCTP_NORMAL_PROC, SCTP_FROM_SCTPUTIL+SCTP_LOC_4);

    3984. 

  3984. #if defined (__APPLE__) || defined(SCTP_SO_LOCK_TESTING)

    3985. 

  3985. 		SCTP_SOCKET_UNLOCK(so, 1);

    3986. 

  3986. #endif

    3987. 

  3987. 	}

    3988. 

  3988. }

    3989. 

  3989. #ifdef SCTP_ASOCLOG_OF_TSNS

    3990. 

  3990. void

    3991. 

  3991. sctp_print_out_track_log(struct sctp_tcb *stcb)

    3992. 

  3992. {

    3993. 

  3993. #ifdef NOSIY_PRINTS

    3994. 

  3994. 	int i;

    3995. 

  3995. 	SCTP_PRINTF("Last ep reason:%x\n", stcb->sctp_ep->last_abort_code);

    3996. 

  3996. 	SCTP_PRINTF("IN bound TSN log-aaa\n");

    3997. 

  3997. 	if ((stcb->asoc.tsn_in_at == 0) && (stcb->asoc.tsn_in_wrapped == 0)) {

    3998. 

  3998. 		SCTP_PRINTF("None rcvd\n");

    3999. 

  3999. 		goto none_in;

    4000. 

  4000. 	}

    4001. 

  4001. 	if (stcb->asoc.tsn_in_wrapped) {

    4002. 

  4002. 		for (i = stcb->asoc.tsn_in_at; i < SCTP_TSN_LOG_SIZE; i++) {

    4003. 

  4003. 			SCTP_PRINTF("TSN:%x strm:%d seq:%d flags:%x sz:%d\n",

    4004. 

  4004. 				    stcb->asoc.in_tsnlog[i].tsn,

    4005. 

  4005. 				    stcb->asoc.in_tsnlog[i].strm,

    4006. 

  4006. 				    stcb->asoc.in_tsnlog[i].seq,

    4007. 

  4007. 				    stcb->asoc.in_tsnlog[i].flgs,

    4008. 

  4008. 				    stcb->asoc.in_tsnlog[i].sz);

    4009. 

  4009. 		}

    4010. 

  4010. 	}

    4011. 

  4011. 	if (stcb->asoc.tsn_in_at) {

    4012. 

  4012. 		for (i = 0; i < stcb->asoc.tsn_in_at; i++) {

    4013. 

  4013. 			SCTP_PRINTF("TSN:%x strm:%d seq:%d flags:%x sz:%d\n",

    4014. 

  4014. 				    stcb->asoc.in_tsnlog[i].tsn,

    4015. 

  4015. 				    stcb->asoc.in_tsnlog[i].strm,

    4016. 

  4016. 				    stcb->asoc.in_tsnlog[i].seq,

    4017. 

  4017. 				    stcb->asoc.in_tsnlog[i].flgs,

    4018. 

  4018. 				    stcb->asoc.in_tsnlog[i].sz);

    4019. 

  4019. 		}

    4020. 

  4020. 	}

    4021. 

  4021.  none_in:

    4022. 

  4022. 	SCTP_PRINTF("OUT bound TSN log-aaa\n");

    4023. 

  4023. 	if ((stcb->asoc.tsn_out_at == 0) &&

    4024. 

  4024. 	    (stcb->asoc.tsn_out_wrapped == 0)) {

    4025. 

  4025. 		SCTP_PRINTF("None sent\n");

    4026. 

  4026. 	}

    4027. 

  4027. 	if (stcb->asoc.tsn_out_wrapped) {

    4028. 

  4028. 		for (i = stcb->asoc.tsn_out_at; i < SCTP_TSN_LOG_SIZE; i++) {

    4029. 

  4029. 			SCTP_PRINTF("TSN:%x strm:%d seq:%d flags:%x sz:%d\n",

    4030. 

  4030. 				    stcb->asoc.out_tsnlog[i].tsn,

    4031. 

  4031. 				    stcb->asoc.out_tsnlog[i].strm,

    4032. 

  4032. 				    stcb->asoc.out_tsnlog[i].seq,

    4033. 

  4033. 				    stcb->asoc.out_tsnlog[i].flgs,

    4034. 

  4034. 				    stcb->asoc.out_tsnlog[i].sz);

    4035. 

  4035. 		}

    4036. 

  4036. 	}

    4037. 

  4037. 	if (stcb->asoc.tsn_out_at) {

    4038. 

  4038. 		for (i = 0; i < stcb->asoc.tsn_out_at; i++) {

    4039. 

  4039. 			SCTP_PRINTF("TSN:%x strm:%d seq:%d flags:%x sz:%d\n",

    4040. 

  4040. 				    stcb->asoc.out_tsnlog[i].tsn,

    4041. 

  4041. 				    stcb->asoc.out_tsnlog[i].strm,

    4042. 

  4042. 				    stcb->asoc.out_tsnlog[i].seq,

    4043. 

  4043. 				    stcb->asoc.out_tsnlog[i].flgs,

    4044. 

  4044. 				    stcb->asoc.out_tsnlog[i].sz);

    4045. 

  4045. 		}

    4046. 

  4046. 	}

    4047. 

  4047. #endif

    4048. 

  4048. }

    4049. 

  4049. #endif

    4050. 

  4050. 

    4051. 

  4051. void

    4052. 

  4052. sctp_abort_an_association(struct sctp_inpcb *inp, struct sctp_tcb *stcb,

    4053. 

  4053.                           struct mbuf *op_err,

    4054. 

  4054.                           int so_locked

    4055. 

  4055. #if !defined(__APPLE__) && !defined(SCTP_SO_LOCK_TESTING)

    4056. 

  4056.                           SCTP_UNUSED

    4057. 

  4057. #endif

    4058. 

  4058. )

    4059. 

  4059. {

    4060. 

  4060. #if defined (__APPLE__) || defined(SCTP_SO_LOCK_TESTING)

    4061. 

  4061. 	struct socket *so;

    4062. 

  4062. #endif

    4063. 

  4063. 

    4064. 

  4064. #if defined (__APPLE__) || defined(SCTP_SO_LOCK_TESTING)

    4065. 

  4065. 	so = SCTP_INP_SO(inp);

    4066. 

  4066. #endif

    4067. 

  4067. #if defined(__APPLE__)

    4068. 

  4068. 	if (so_locked) {

    4069. 

  4069. 		sctp_lock_assert(SCTP_INP_SO(inp));

    4070. 

  4070. 	} else {

    4071. 

  4071. 		sctp_unlock_assert(SCTP_INP_SO(inp));

    4072. 

  4072. 	}

    4073. 

  4073. #endif

    4074. 

  4074. 	if (stcb == NULL) {

    4075. 

  4075. 		/* Got to have a TCB */

    4076. 

  4076. 		if (inp->sctp_flags & SCTP_PCB_FLAGS_SOCKET_GONE) {

    4077. 

  4077. 			if (LIST_FIRST(&inp->sctp_asoc_list) == NULL) {

    4078. 

  4078. #if defined(__APPLE__)

    4079. 

  4079. 				if (!so_locked) {

    4080. 

  4080. 					SCTP_SOCKET_LOCK(so, 1);

    4081. 

  4081. 				}

    4082. 

  4082. #endif

    4083. 

  4083. 				sctp_inpcb_free(inp, SCTP_FREE_SHOULD_USE_ABORT,

    4084. 

  4084. 						SCTP_CALLED_DIRECTLY_NOCMPSET);

    4085. 

  4085. #if defined(__APPLE__)

    4086. 

  4086. 				if (!so_locked) {

    4087. 

  4087. 					SCTP_SOCKET_UNLOCK(so, 1);

    4088. 

  4088. 				}

    4089. 

  4089. #endif

    4090. 

  4090. 			}

    4091. 

  4091. 		}

    4092. 

  4092. 		return;

    4093. 

  4093. 	} else {

    4094. 

  4094. 		stcb->asoc.state |= SCTP_STATE_WAS_ABORTED;

    4095. 

  4095. 	}

    4096. 

  4096. 	/* notify the ulp */

    4097. 

  4097. 	if ((inp->sctp_flags & SCTP_PCB_FLAGS_SOCKET_GONE) == 0) {

    4098. 

  4098. 		sctp_abort_notification(stcb, 0, 0, NULL, so_locked);

    4099. 

  4099. 	}

    4100. 

  4100. 	/* notify the peer */

    4101. 

  4101. 	sctp_send_abort_tcb(stcb, op_err, so_locked);

    4102. 

  4102. 	SCTP_STAT_INCR_COUNTER32(sctps_aborted);

    4103. 

  4103. 	if ((SCTP_GET_STATE(&stcb->asoc) == SCTP_STATE_OPEN) ||

    4104. 

  4104. 	    (SCTP_GET_STATE(&stcb->asoc) == SCTP_STATE_SHUTDOWN_RECEIVED)) {

    4105. 

  4105. 		SCTP_STAT_DECR_GAUGE32(sctps_currestab);

    4106. 

  4106. 	}

    4107. 

  4107. 	/* now free the asoc */

    4108. 

  4108. #ifdef SCTP_ASOCLOG_OF_TSNS

    4109. 

  4109. 	sctp_print_out_track_log(stcb);

    4110. 

  4110. #endif

    4111. 

  4111. #if defined (__APPLE__) || defined(SCTP_SO_LOCK_TESTING)

    4112. 

  4112. 	if (!so_locked) {

    4113. 

  4113. 		atomic_add_int(&stcb->asoc.refcnt, 1);

    4114. 

  4114. 		SCTP_TCB_UNLOCK(stcb);

    4115. 

  4115. 		SCTP_SOCKET_LOCK(so, 1);

    4116. 

  4116. 		SCTP_TCB_LOCK(stcb);

    4117. 

  4117. 		atomic_subtract_int(&stcb->asoc.refcnt, 1);

    4118. 

  4118. 	}

    4119. 

  4119. #endif

    4120. 

  4120. 	(void)sctp_free_assoc(inp, stcb, SCTP_NORMAL_PROC, SCTP_FROM_SCTPUTIL+SCTP_LOC_5);

    4121. 

  4121. #if defined (__APPLE__) || defined(SCTP_SO_LOCK_TESTING)

    4122. 

  4122. 	if (!so_locked) {

    4123. 

  4123. 		SCTP_SOCKET_UNLOCK(so, 1);

    4124. 

  4124. 	}

    4125. 

  4125. #endif

    4126. 

  4126. }

    4127. 

  4127. 

    4128. 

  4128. void

    4129. 

  4129. sctp_handle_ootb(struct mbuf *m, int iphlen, int offset, struct sctphdr *sh,

    4130. 

  4130.     struct sctp_inpcb *inp, struct mbuf *op_err, uint32_t vrf_id, uint16_t port)

    4131. 

  4131. {

    4132. 

  4132. 	struct sctp_chunkhdr *ch, chunk_buf;

    4133. 

  4133. 	unsigned int chk_length;

    4134. 

  4134. 	int contains_init_chunk;

    4135. 

  4135. 

    4136. 

  4136. 	SCTP_STAT_INCR_COUNTER32(sctps_outoftheblue);

    4137. 

  4137. 	/* Generate a TO address for future reference */

    4138. 

  4138. 	if (inp && (inp->sctp_flags & SCTP_PCB_FLAGS_SOCKET_GONE)) {

    4139. 

  4139. 		if (LIST_FIRST(&inp->sctp_asoc_list) == NULL) {

    4140. 

  4140. #if defined(__APPLE__)

    4141. 

  4141. 			SCTP_SOCKET_LOCK(SCTP_INP_SO(inp), 1);

    4142. 

  4142. #endif

    4143. 

  4143. 			sctp_inpcb_free(inp, SCTP_FREE_SHOULD_USE_ABORT,

    4144. 

  4144. 					SCTP_CALLED_DIRECTLY_NOCMPSET);

    4145. 

  4145. #if defined(__APPLE__)

    4146. 

  4146. 			SCTP_SOCKET_UNLOCK(SCTP_INP_SO(inp), 1);

    4147. 

  4147. #endif

    4148. 

  4148. 		}

    4149. 

  4149. 	}

    4150. 

  4150. 	contains_init_chunk = 0;

    4151. 

  4151. 	ch = (struct sctp_chunkhdr *)sctp_m_getptr(m, offset,

    4152. 

  4152. 	    sizeof(*ch), (uint8_t *) & chunk_buf);

    4153. 

  4153. 	while (ch != NULL) {

    4154. 

  4154. 		chk_length = ntohs(ch->chunk_length);

    4155. 

  4155. 		if (chk_length < sizeof(*ch)) {

    4156. 

  4156. 			/* break to abort land */

    4157. 

  4157. 			break;

    4158. 

  4158. 		}

    4159. 

  4159. 		switch (ch->chunk_type) {

    4160. 

  4160. 		case SCTP_INIT:

    4161. 

  4161. 			contains_init_chunk = 1;

    4162. 

  4162. 			break;

    4163. 

  4163. 		case SCTP_COOKIE_ECHO:

    4164. 

  4164. 			/* We hit here only if the assoc is being freed */

    4165. 

  4165. 			return;

    4166. 

  4166. 		case SCTP_PACKET_DROPPED:

    4167. 

  4167. 			/* we don't respond to pkt-dropped */

    4168. 

  4168. 			return;

    4169. 

  4169. 		case SCTP_ABORT_ASSOCIATION:

    4170. 

  4170. 			/* we don't respond with an ABORT to an ABORT */

    4171. 

  4171. 			return;

    4172. 

  4172. 		case SCTP_SHUTDOWN_COMPLETE:

    4173. 

  4173. 			/*

    4174. 

  4174. 			 * we ignore it since we are not waiting for it and

    4175. 

  4175. 			 * peer is gone

    4176. 

  4176. 			 */

    4177. 

  4177. 			return;

    4178. 

  4178. 		case SCTP_SHUTDOWN_ACK:

    4179. 

  4179. 			sctp_send_shutdown_complete2(m, sh, vrf_id, port);

    4180. 

  4180. 			return;

    4181. 

  4181. 		default:

    4182. 

  4182. 			break;

    4183. 

  4183. 		}

    4184. 

  4184. 		offset += SCTP_SIZE32(chk_length);

    4185. 

  4185. 		ch = (struct sctp_chunkhdr *)sctp_m_getptr(m, offset,

    4186. 

  4186. 		    sizeof(*ch), (uint8_t *) & chunk_buf);

    4187. 

  4187. 	}

    4188. 

  4188. 	if ((SCTP_BASE_SYSCTL(sctp_blackhole) == 0) ||

    4189. 

  4189. 	    ((SCTP_BASE_SYSCTL(sctp_blackhole) == 1) &&

    4190. 

  4190. 	     (contains_init_chunk == 0))) {

    4191. 

  4191. 		sctp_send_abort(m, iphlen, sh, 0, op_err, vrf_id, port);

    4192. 

  4192. 	}

    4193. 

  4193. }

    4194. 

  4194. 

    4195. 

  4195. /*

    4196. 

  4196.  * check the inbound datagram to make sure there is not an abort inside it,

    4197. 

  4197.  * if there is return 1, else return 0.

    4198. 

  4198.  */

    4199. 

  4199. int

    4200. 

  4200. sctp_is_there_an_abort_here(struct mbuf *m, int iphlen, uint32_t * vtagfill)

    4201. 

  4201. {

    4202. 

  4202. 	struct sctp_chunkhdr *ch;

    4203. 

  4203. 	struct sctp_init_chunk *init_chk, chunk_buf;

    4204. 

  4204. 	int offset;

    4205. 

  4205. 	unsigned int chk_length;

    4206. 

  4206. 

    4207. 

  4207. 	offset = iphlen + sizeof(struct sctphdr);

    4208. 

  4208. 	ch = (struct sctp_chunkhdr *)sctp_m_getptr(m, offset, sizeof(*ch),

    4209. 

  4209. 	    (uint8_t *) & chunk_buf);

    4210. 

  4210. 	while (ch != NULL) {

    4211. 

  4211. 		chk_length = ntohs(ch->chunk_length);

    4212. 

  4212. 		if (chk_length < sizeof(*ch)) {

    4213. 

  4213. 			/* packet is probably corrupt */

    4214. 

  4214. 			break;

    4215. 

  4215. 		}

    4216. 

  4216. 		/* we seem to be ok, is it an abort? */

    4217. 

  4217. 		if (ch->chunk_type == SCTP_ABORT_ASSOCIATION) {

    4218. 

  4218. 			/* yep, tell them */

    4219. 

  4219. 			return (1);

    4220. 

  4220. 		}

    4221. 

  4221. 		if (ch->chunk_type == SCTP_INITIATION) {

    4222. 

  4222. 			/* need to update the Vtag */

    4223. 

  4223. 			init_chk = (struct sctp_init_chunk *)sctp_m_getptr(m,

    4224. 

  4224. 			    offset, sizeof(*init_chk), (uint8_t *) & chunk_buf);

    4225. 

  4225. 			if (init_chk != NULL) {

    4226. 

  4226. 				*vtagfill = ntohl(init_chk->init.initiate_tag);

    4227. 

  4227. 			}

    4228. 

  4228. 		}

    4229. 

  4229. 		/* Nope, move to the next chunk */

    4230. 

  4230. 		offset += SCTP_SIZE32(chk_length);

    4231. 

  4231. 		ch = (struct sctp_chunkhdr *)sctp_m_getptr(m, offset,

    4232. 

  4232. 		    sizeof(*ch), (uint8_t *) & chunk_buf);

    4233. 

  4233. 	}

    4234. 

  4234. 	return (0);

    4235. 

  4235. }

    4236. 

  4236. 

    4237. 

  4237. /*

    4238. 

  4238.  * currently (2/02), ifa_addr embeds scope_id's and don't have sin6_scope_id

    4239. 

  4239.  * set (i.e. it's 0) so, create this function to compare link local scopes

    4240. 

  4240.  */

    4241. 

  4241. #ifdef INET6

    4242. 

  4242. uint32_t

    4243. 

  4243. sctp_is_same_scope(struct sockaddr_in6 *addr1, struct sockaddr_in6 *addr2)

    4244. 

  4244. {

    4245. 

  4245. #if defined(__Userspace__)

    4246. 

  4246.     /*__Userspace__ Returning 1 here always */

    4247. 

  4247. #endif

    4248. 

  4248. #if defined(SCTP_EMBEDDED_V6_SCOPE)

    4249. 

  4249. 	struct sockaddr_in6 a, b;

    4250. 

  4250. 

    4251. 

  4251. 	/* save copies */

    4252. 

  4252. 	a = *addr1;

    4253. 

  4253. 	b = *addr2;

    4254. 

  4254. 

    4255. 

  4255. 	if (a.sin6_scope_id == 0)

    4256. 

  4256. #ifdef SCTP_KAME

    4257. 

  4257. 		if (sa6_recoverscope(&a)) {

    4258. 

  4258. #else

    4259. 

  4259. 		if (in6_recoverscope(&a, &a.sin6_addr, NULL)) {

    4260. 

  4260. #endif				/* SCTP_KAME */

    4261. 

  4261. 			/* can't get scope, so can't match */

    4262. 

  4262. 			return (0);

    4263. 

  4263. 		}

    4264. 

  4264. 	if (b.sin6_scope_id == 0)

    4265. 

  4265. #ifdef SCTP_KAME

    4266. 

  4266. 		if (sa6_recoverscope(&b)) {

    4267. 

  4267. #else

    4268. 

  4268. 		if (in6_recoverscope(&b, &b.sin6_addr, NULL)) {

    4269. 

  4269. #endif				/* SCTP_KAME */

    4270. 

  4270. 			/* can't get scope, so can't match */

    4271. 

  4271. 			return (0);

    4272. 

  4272. 		}

    4273. 

  4273. 	if (a.sin6_scope_id != b.sin6_scope_id)

    4274. 

  4274. 		return (0);

    4275. 

  4275. #else

    4276. 

  4276. 	if (addr1->sin6_scope_id != addr2->sin6_scope_id)

    4277. 

  4277. 		return (0);

    4278. 

  4278. #endif /* SCTP_EMBEDDED_V6_SCOPE */

    4279. 

  4279. 

    4280. 

  4280. 	return (1);

    4281. 

  4281. }

    4282. 

  4282. 

    4283. 

  4283. #if defined(SCTP_EMBEDDED_V6_SCOPE)

    4284. 

  4284. /*

    4285. 

  4285.  * returns a sockaddr_in6 with embedded scope recovered and removed

    4286. 

  4286.  */

    4287. 

  4287. struct sockaddr_in6 *

    4288. 

  4288. sctp_recover_scope(struct sockaddr_in6 *addr, struct sockaddr_in6 *store)

    4289. 

  4289. {

    4290. 

  4290. 	/* check and strip embedded scope junk */

    4291. 

  4291. 	if (addr->sin6_family == AF_INET6) {

    4292. 

  4292. 		if (IN6_IS_SCOPE_LINKLOCAL(&addr->sin6_addr)) {

    4293. 

  4293. 			if (addr->sin6_scope_id == 0) {

    4294. 

  4294. 				*store = *addr;

    4295. 

  4295. #ifdef SCTP_KAME

    4296. 

  4296. 				if (!sa6_recoverscope(store)) {

    4297. 

  4297. #else

    4298. 

  4298. 				if (!in6_recoverscope(store, &store->sin6_addr,

    4299. 

  4299. 				    NULL)) {

    4300. 

  4300. #endif /* SCTP_KAME */

    4301. 

  4301. 					/* use the recovered scope */

    4302. 

  4302. 					addr = store;

    4303. 

  4303. 				}

    4304. 

  4304. 			} else {

    4305. 

  4305. 				/* else, return the original "to" addr */

    4306. 

  4306. 				in6_clearscope(&addr->sin6_addr);

    4307. 

  4307. 			}

    4308. 

  4308. 		}

    4309. 

  4309. 	}

    4310. 

  4310. 	return (addr);

    4311. 

  4311. }

    4312. 

  4312. #endif /* SCTP_EMBEDDED_V6_SCOPE */

    4313. 

  4313. #endif

    4314. 

  4314. 

    4315. 

  4315. /*

    4316. 

  4316.  * are the two addresses the same?  currently a "scopeless" check returns: 1

    4317. 

  4317.  * if same, 0 if not

    4318. 

  4318.  */

    4319. 

  4319. int

    4320. 

  4320. sctp_cmpaddr(struct sockaddr *sa1, struct sockaddr *sa2)

    4321. 

  4321. {

    4322. 

  4322. 

    4323. 

  4323. 	/* must be valid */

    4324. 

  4324. 	if (sa1 == NULL || sa2 == NULL)

    4325. 

  4325. 		return (0);

    4326. 

  4326. 

    4327. 

  4327. 	/* must be the same family */

    4328. 

  4328. 	if (sa1->sa_family != sa2->sa_family)

    4329. 

  4329. 		return (0);

    4330. 

  4330. 

    4331. 

  4331. 	switch (sa1->sa_family) {

    4332. 

  4332. #ifdef INET6

    4333. 

  4333. 	case AF_INET6:

    4334. 

  4334. 	{

    4335. 

  4335. 		/* IPv6 addresses */

    4336. 

  4336. 		struct sockaddr_in6 *sin6_1, *sin6_2;

    4337. 

  4337. 

    4338. 

  4338. 		sin6_1 = (struct sockaddr_in6 *)sa1;

    4339. 

  4339. 		sin6_2 = (struct sockaddr_in6 *)sa2;

    4340. 

  4340. 		return (SCTP6_ARE_ADDR_EQUAL(sin6_1,

    4341. 

  4341. 		    sin6_2));

    4342. 

  4342. 	}

    4343. 

  4343. #endif

    4344. 

  4344. #ifdef INET

    4345. 

  4345. 	case AF_INET:

    4346. 

  4346. 	{

    4347. 

  4347. 		/* IPv4 addresses */

    4348. 

  4348. 		struct sockaddr_in *sin_1, *sin_2;

    4349. 

  4349. 

    4350. 

  4350. 		sin_1 = (struct sockaddr_in *)sa1;

    4351. 

  4351. 		sin_2 = (struct sockaddr_in *)sa2;

    4352. 

  4352. 		return (sin_1->sin_addr.s_addr == sin_2->sin_addr.s_addr);

    4353. 

  4353. 	}

    4354. 

  4354. #endif

    4355. 

  4355. 	default:

    4356. 

  4356. 		/* we don't do these... */

    4357. 

  4357. 		return (0);

    4358. 

  4358. 	}

    4359. 

  4359. }

    4360. 

  4360. 

    4361. 

  4361. void

    4362. 

  4362. sctp_print_address(struct sockaddr *sa)

    4363. 

  4363. {

    4364. 

  4364. #ifdef INET6

    4365. 

  4365. 	char ip6buf[INET6_ADDRSTRLEN];

    4366. 

  4366. 	ip6buf[0] = 0;

    4367. 

  4367. #endif

    4368. 

  4368. 

    4369. 

  4369. 	switch (sa->sa_family) {

    4370. 

  4370. #ifdef INET6

    4371. 

  4371. 	case AF_INET6:

    4372. 

  4372. 	{

    4373. 

  4373. 		struct sockaddr_in6 *sin6;

    4374. 

  4374. 

    4375. 

  4375. 		sin6 = (struct sockaddr_in6 *)sa;

    4376. 

  4376. #if defined(__Userspace__)

    4377. 

  4377. 		SCTP_PRINTF("IPv6 address: %x:%x:%x:%x:%x:%x:%x:%x:port:%d scope:%u\n",

    4378. 

  4378. 			    ntohs(sin6->sin6_addr.s6_addr16[0]),

    4379. 

  4379. 			    ntohs(sin6->sin6_addr.s6_addr16[1]),

    4380. 

  4380. 			    ntohs(sin6->sin6_addr.s6_addr16[2]),

    4381. 

  4381. 			    ntohs(sin6->sin6_addr.s6_addr16[3]),

    4382. 

  4382. 			    ntohs(sin6->sin6_addr.s6_addr16[4]),

    4383. 

  4383. 			    ntohs(sin6->sin6_addr.s6_addr16[5]),

    4384. 

  4384. 			    ntohs(sin6->sin6_addr.s6_addr16[6]),

    4385. 

  4385. 			    ntohs(sin6->sin6_addr.s6_addr16[7]),

    4386. 

  4386. 			    ntohs(sin6->sin6_port),

    4387. 

  4387. 			    sin6->sin6_scope_id);

    4388. 

  4388. #else

    4389. 

  4389. 		SCTP_PRINTF("IPv6 address: %s:port:%d scope:%u\n",

    4390. 

  4390. #if defined(__FreeBSD__) && __FreeBSD_version >= 700000

    4391. 

  4391. 			    ip6_sprintf(ip6buf, &sin6->sin6_addr),

    4392. 

  4392. #else

    4393. 

  4393. 			    ip6_sprintf(&sin6->sin6_addr),

    4394. 

  4394. #endif

    4395. 

  4395. 			    ntohs(sin6->sin6_port),

    4396. 

  4396. 			    sin6->sin6_scope_id);

    4397. 

  4397. #endif

    4398. 

  4398. 		break;

    4399. 

  4399. 	}

    4400. 

  4400. #endif

    4401. 

  4401. #ifdef INET

    4402. 

  4402. 	case AF_INET:

    4403. 

  4403. 	{

    4404. 

  4404. 		struct sockaddr_in *sin;

    4405. 

  4405. 		unsigned char *p;

    4406. 

  4406. 

    4407. 

  4407. 		sin = (struct sockaddr_in *)sa;

    4408. 

  4408. 		p = (unsigned char *)&sin->sin_addr;

    4409. 

  4409. 		SCTP_PRINTF("IPv4 address: %u.%u.%u.%u:%d\n",

    4410. 

  4410. 			    p[0], p[1], p[2], p[3], ntohs(sin->sin_port));

    4411. 

  4411. 		break;

    4412. 

  4412. 	}

    4413. 

  4413. #endif

    4414. 

  4414. 	default:

    4415. 

  4415. 		SCTP_PRINTF("?\n");

    4416. 

  4416. 		break;

    4417. 

  4417. 	}

    4418. 

  4418. }

    4419. 

  4419. 

    4420. 

  4420. void

    4421. 

  4421. sctp_print_address_pkt(struct ip *iph, struct sctphdr *sh)

    4422. 

  4422. {

    4423. 

  4423. 	switch (iph->ip_v) {

    4424. 

  4424. #ifdef INET

    4425. 

  4425. 	case IPVERSION:

    4426. 

  4426. 	{

    4427. 

  4427. 		struct sockaddr_in lsa, fsa;

    4428. 

  4428. 

    4429. 

  4429. 		bzero(&lsa, sizeof(lsa));

    4430. 

  4430. #if !defined(__Windows__) && !defined(__Userspace_os_Linux) && !defined(__Userspace_os_Windows)

    4431. 

  4431. 		lsa.sin_len = sizeof(lsa);

    4432. 

  4432. #endif

    4433. 

  4433. 		lsa.sin_family = AF_INET;

    4434. 

  4434. 		lsa.sin_addr = iph->ip_src;

    4435. 

  4435. 		lsa.sin_port = sh->src_port;

    4436. 

  4436. 		bzero(&fsa, sizeof(fsa));

    4437. 

  4437. #if !defined(__Windows__) && !defined(__Userspace_os_Linux) && !defined(__Userspace_os_Windows)

    4438. 

  4438. 		fsa.sin_len = sizeof(fsa);

    4439. 

  4439. #endif

    4440. 

  4440. 		fsa.sin_family = AF_INET;

    4441. 

  4441. 		fsa.sin_addr = iph->ip_dst;

    4442. 

  4442. 		fsa.sin_port = sh->dest_port;

    4443. 

  4443. 		SCTP_PRINTF("src: ");

    4444. 

  4444. 		sctp_print_address((struct sockaddr *)&lsa);

    4445. 

  4445. 		SCTP_PRINTF("dest: ");

    4446. 

  4446. 		sctp_print_address((struct sockaddr *)&fsa);

    4447. 

  4447. 		break;

    4448. 

  4448. 	}

    4449. 

  4449. #endif

    4450. 

  4450. #ifdef INET6

    4451. 

  4451. 	case IPV6_VERSION >> 4:

    4452. 

  4452. 	{

    4453. 

  4453. 		struct ip6_hdr *ip6;

    4454. 

  4454. 		struct sockaddr_in6 lsa6, fsa6;

    4455. 

  4455. 

    4456. 

  4456. 		ip6 = (struct ip6_hdr *)iph;

    4457. 

  4457. 		bzero(&lsa6, sizeof(lsa6));

    4458. 

  4458. #if !defined(__Windows__) && !defined(__Userspace_os_Linux) && !defined(__Userspace_os_Windows)

    4459. 

  4459. 		lsa6.sin6_len = sizeof(lsa6);

    4460. 

  4460. #endif

    4461. 

  4461. 		lsa6.sin6_family = AF_INET6;

    4462. 

  4462. 		lsa6.sin6_addr = ip6->ip6_src;

    4463. 

  4463. 		lsa6.sin6_port = sh->src_port;

    4464. 

  4464. 		bzero(&fsa6, sizeof(fsa6));

    4465. 

  4465. #if !defined(__Windows__) && !defined(__Userspace_os_Linux) && !defined(__Userspace_os_Windows)

    4466. 

  4466. 		fsa6.sin6_len = sizeof(fsa6);

    4467. 

  4467. #endif

    4468. 

  4468. 		fsa6.sin6_family = AF_INET6;

    4469. 

  4469. 		fsa6.sin6_addr = ip6->ip6_dst;

    4470. 

  4470. 		fsa6.sin6_port = sh->dest_port;

    4471. 

  4471. 		SCTP_PRINTF("src: ");

    4472. 

  4472. 		sctp_print_address((struct sockaddr *)&lsa6);

    4473. 

  4473. 		SCTP_PRINTF("dest: ");

    4474. 

  4474. 		sctp_print_address((struct sockaddr *)&fsa6);

    4475. 

  4475. 		break;

    4476. 

  4476. 	}

    4477. 

  4477. #endif

    4478. 

  4478. 	default:

    4479. 

  4479. 		/* TSNH */

    4480. 

  4480. 		break;

    4481. 

  4481. 	}

    4482. 

  4482. }

    4483. 

  4483. 

    4484. 

  4484. void

    4485. 

  4485. sctp_pull_off_control_to_new_inp(struct sctp_inpcb *old_inp,

    4486. 

  4486.     struct sctp_inpcb *new_inp,

    4487. 

  4487.     struct sctp_tcb *stcb,

    4488. 

  4488.     int waitflags)

    4489. 

  4489. {

    4490. 

  4490. 	/*

    4491. 

  4491. 	 * go through our old INP and pull off any control structures that

    4492. 

  4492. 	 * belong to stcb and move then to the new inp.

    4493. 

  4493. 	 */

    4494. 

  4494. 	struct socket *old_so, *new_so;

    4495. 

  4495. 	struct sctp_queued_to_read *control, *nctl;

    4496. 

  4496. 	struct sctp_readhead tmp_queue;

    4497. 

  4497. 	struct mbuf *m;

    4498. 

  4498. 	int error = 0;

    4499. 

  4499. 

    4500. 

  4500. 	old_so = old_inp->sctp_socket;

    4501. 

  4501. 	new_so = new_inp->sctp_socket;

    4502. 

  4502. 	TAILQ_INIT(&tmp_queue);

    4503. 

  4503. #if defined(__FreeBSD__) && __FreeBSD_version < 700000

    4504. 

  4504. 	SOCKBUF_LOCK(&(old_so->so_rcv));

    4505. 

  4505. #endif

    4506. 

  4506. #if defined(__FreeBSD__) || defined(__APPLE__)

    4507. 

  4507. 	error = sblock(&old_so->so_rcv, waitflags);

    4508. 

  4508. #endif

    4509. 

  4509. #if defined(__FreeBSD__) && __FreeBSD_version < 700000

    4510. 

  4510. 	SOCKBUF_UNLOCK(&(old_so->so_rcv));

    4511. 

  4511. #endif

    4512. 

  4512. 	if (error) {

    4513. 

  4513. 		/* Gak, can't get sblock, we have a problem.

    4514. 

  4514. 		 * data will be left stranded.. and we

    4515. 

  4515. 		 * don't dare look at it since the

    4516. 

  4516. 		 * other thread may be reading something.

    4517. 

  4517. 		 * Oh well, its a screwed up app that does

    4518. 

  4518. 		 * a peeloff OR a accept while reading

    4519. 

  4519. 		 * from the main socket... actually its

    4520. 

  4520. 		 * only the peeloff() case, since I think

    4521. 

  4521. 		 * read will fail on a listening socket..

    4522. 

  4522. 		 */

    4523. 

  4523. 		return;

    4524. 

  4524. 	}

    4525. 

  4525. 	/* lock the socket buffers */

    4526. 

  4526. 	SCTP_INP_READ_LOCK(old_inp);

    4527. 

  4527. 	TAILQ_FOREACH_SAFE(control, &old_inp->read_queue, next, nctl) {

    4528. 

  4528. 		/* Pull off all for out target stcb */

    4529. 

  4529. 		if (control->stcb == stcb) {

    4530. 

  4530. 			/* remove it we want it */

    4531. 

  4531. 			TAILQ_REMOVE(&old_inp->read_queue, control, next);

    4532. 

  4532. 			TAILQ_INSERT_TAIL(&tmp_queue, control, next);

    4533. 

  4533. 			m = control->data;

    4534. 

  4534. 			while (m) {

    4535. 

  4535. 				if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_SB_LOGGING_ENABLE) {

    4536. 

  4536. 					sctp_sblog(&old_so->so_rcv, control->do_not_ref_stcb?NULL:stcb, SCTP_LOG_SBFREE,SCTP_BUF_LEN(m));

    4537. 

  4537. 				}

    4538. 

  4538. 				sctp_sbfree(control, stcb, &old_so->so_rcv, m);

    4539. 

  4539. 				if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_SB_LOGGING_ENABLE) {

    4540. 

  4540. 					sctp_sblog(&old_so->so_rcv, control->do_not_ref_stcb?NULL:stcb, SCTP_LOG_SBRESULT, 0);

    4541. 

  4541. 				}

    4542. 

  4542. 				m = SCTP_BUF_NEXT(m);

    4543. 

  4543. 			}

    4544. 

  4544. 		}

    4545. 

  4545. 	}

    4546. 

  4546. 	SCTP_INP_READ_UNLOCK(old_inp);

    4547. 

  4547. 	/* Remove the sb-lock on the old socket */

    4548. 

  4548. #if defined(__FreeBSD__) && __FreeBSD_version < 700000

    4549. 

  4549. 	SOCKBUF_LOCK(&(old_so->so_rcv));

    4550. 

  4550. #endif

    4551. 

  4551. #if defined(__APPLE__)

    4552. 

  4552. 	sbunlock(&old_so->so_rcv, 1);

    4553. 

  4553. #endif

    4554. 

  4554. 

    4555. 

  4555. #if defined(__FreeBSD__)

    4556. 

  4556. 	sbunlock(&old_so->so_rcv);

    4557. 

  4557. #endif

    4558. 

  4558. #if defined(__FreeBSD__) && __FreeBSD_version < 700000

    4559. 

  4559. 	SOCKBUF_UNLOCK(&(old_so->so_rcv));

    4560. 

  4560. #endif

    4561. 

  4561. 	/* Now we move them over to the new socket buffer */

    4562. 

  4562. 	SCTP_INP_READ_LOCK(new_inp);

    4563. 

  4563. 	TAILQ_FOREACH_SAFE(control, &tmp_queue, next, nctl) {

    4564. 

  4564. 		TAILQ_INSERT_TAIL(&new_inp->read_queue, control, next);

    4565. 

  4565. 		m = control->data;

    4566. 

  4566. 		while (m) {

    4567. 

  4567. 			if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_SB_LOGGING_ENABLE) {

    4568. 

  4568. 				sctp_sblog(&new_so->so_rcv, control->do_not_ref_stcb?NULL:stcb, SCTP_LOG_SBALLOC, SCTP_BUF_LEN(m));

    4569. 

  4569. 			}

    4570. 

  4570. 			sctp_sballoc(stcb, &new_so->so_rcv, m);

    4571. 

  4571. 			if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_SB_LOGGING_ENABLE) {

    4572. 

  4572. 				sctp_sblog(&new_so->so_rcv, control->do_not_ref_stcb?NULL:stcb, SCTP_LOG_SBRESULT, 0);

    4573. 

  4573. 			}

    4574. 

  4574. 			m = SCTP_BUF_NEXT(m);

    4575. 

  4575. 		}

    4576. 

  4576. 	}

    4577. 

  4577. 	SCTP_INP_READ_UNLOCK(new_inp);

    4578. 

  4578. }

    4579. 

  4579. 

    4580. 

  4580. void

    4581. 

  4581. sctp_add_to_readq(struct sctp_inpcb *inp,

    4582. 

  4582.     struct sctp_tcb *stcb,

    4583. 

  4583.     struct sctp_queued_to_read *control,

    4584. 

  4584.     struct sockbuf *sb,

    4585. 

  4585.     int end,

    4586. 

  4586.     int inp_read_lock_held,

    4587. 

  4587.     int so_locked

    4588. 

  4588. #if !defined(__APPLE__) && !defined(SCTP_SO_LOCK_TESTING)

    4589. 

  4589.     SCTP_UNUSED

    4590. 

  4590. #endif

    4591. 

  4591.     )

    4592. 

  4592. {

    4593. 

  4593. 	/*

    4594. 

  4594. 	 * Here we must place the control on the end of the socket read

    4595. 

  4595. 	 * queue AND increment sb_cc so that select will work properly on

    4596. 

  4596. 	 * read.

    4597. 

  4597. 	 */

    4598. 

  4598. 	struct mbuf *m, *prev = NULL;

    4599. 

  4599. 

    4600. 

  4600. 	if (inp == NULL) {

    4601. 

  4601. 		/* Gak, TSNH!! */

    4602. 

  4602. #ifdef INVARIANTS

    4603. 

  4603. 		panic("Gak, inp NULL on add_to_readq");

    4604. 

  4604. #endif

    4605. 

  4605. 		return;

    4606. 

  4606. 	}

    4607. 

  4607. #if defined(__APPLE__)

    4608. 

  4608. 	if (so_locked) {

    4609. 

  4609. 		sctp_lock_assert(SCTP_INP_SO(inp));

    4610. 

  4610. 	} else {

    4611. 

  4611. 		sctp_unlock_assert(SCTP_INP_SO(inp));

    4612. 

  4612. 	}

    4613. 

  4613. #endif

    4614. 

  4614. 	if (inp_read_lock_held == 0)

    4615. 

  4615. 		SCTP_INP_READ_LOCK(inp);

    4616. 

  4616. 	if (inp->sctp_flags & SCTP_PCB_FLAGS_SOCKET_CANT_READ) {

    4617. 

  4617. 		sctp_free_remote_addr(control->whoFrom);

    4618. 

  4618. 		if (control->data) {

    4619. 

  4619. 			sctp_m_freem(control->data);

    4620. 

  4620. 			control->data = NULL;

    4621. 

  4621. 		}

    4622. 

  4622. 		SCTP_ZONE_FREE(SCTP_BASE_INFO(ipi_zone_readq), control);

    4623. 

  4623. 		if (inp_read_lock_held == 0)

    4624. 

  4624. 			SCTP_INP_READ_UNLOCK(inp);

    4625. 

  4625. 		return;

    4626. 

  4626. 	}

    4627. 

  4627. 	if (!(control->spec_flags & M_NOTIFICATION)) {

    4628. 

  4628. 		atomic_add_int(&inp->total_recvs, 1);

    4629. 

  4629. 		if (!control->do_not_ref_stcb) {

    4630. 

  4630. 			atomic_add_int(&stcb->total_recvs, 1);

    4631. 

  4631. 		}

    4632. 

  4632. 	}

    4633. 

  4633. 	m = control->data;

    4634. 

  4634. 	control->held_length = 0;

    4635. 

  4635. 	control->length = 0;

    4636. 

  4636. 	while (m) {

    4637. 

  4637. 		if (SCTP_BUF_LEN(m) == 0) {

    4638. 

  4638. 			/* Skip mbufs with NO length */

    4639. 

  4639. 			if (prev == NULL) {

    4640. 

  4640. 				/* First one */

    4641. 

  4641. 				control->data = sctp_m_free(m);

    4642. 

  4642. 				m = control->data;

    4643. 

  4643. 			} else {

    4644. 

  4644. 				SCTP_BUF_NEXT(prev) = sctp_m_free(m);

    4645. 

  4645. 				m = SCTP_BUF_NEXT(prev);

    4646. 

  4646. 			}

    4647. 

  4647. 			if (m == NULL) {

    4648. 

  4648. 				control->tail_mbuf = prev;

    4649. 

  4649. 			}

    4650. 

  4650. 			continue;

    4651. 

  4651. 		}

    4652. 

  4652. 		prev = m;

    4653. 

  4653. 		if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_SB_LOGGING_ENABLE) {

    4654. 

  4654. 			sctp_sblog(sb, control->do_not_ref_stcb?NULL:stcb, SCTP_LOG_SBALLOC, SCTP_BUF_LEN(m));

    4655. 

  4655. 		}

    4656. 

  4656. 		sctp_sballoc(stcb, sb, m);

    4657. 

  4657. 		if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_SB_LOGGING_ENABLE) {

    4658. 

  4658. 			sctp_sblog(sb, control->do_not_ref_stcb?NULL:stcb, SCTP_LOG_SBRESULT, 0);

    4659. 

  4659. 		}

    4660. 

  4660. 		atomic_add_int(&control->length, SCTP_BUF_LEN(m));

    4661. 

  4661. 		m = SCTP_BUF_NEXT(m);

    4662. 

  4662. 	}

    4663. 

  4663. 	if (prev != NULL) {

    4664. 

  4664. 		control->tail_mbuf = prev;

    4665. 

  4665. 	} else {

    4666. 

  4666. 		/* Everything got collapsed out?? */

    4667. 

  4667. 		sctp_free_remote_addr(control->whoFrom);

    4668. 

  4668. 		SCTP_ZONE_FREE(SCTP_BASE_INFO(ipi_zone_readq), control);

    4669. 

  4669. 		if (inp_read_lock_held == 0)

    4670. 

  4670. 			SCTP_INP_READ_UNLOCK(inp);

    4671. 

  4671. 		return;

    4672. 

  4672. 	}

    4673. 

  4673. 	if (end) {

    4674. 

  4674. 		control->end_added = 1;

    4675. 

  4675. 	}

    4676. 

  4676. #if defined(__Userspace__)

    4677. 

  4677. 	if (inp->recv_callback) {

    4678. 

  4678. 		if (inp_read_lock_held == 0)

    4679. 

  4679. 			SCTP_INP_READ_UNLOCK(inp);

    4680. 

  4680. 		if (control->end_added == 1) {

    4681. 

  4681. 			struct socket *so;

    4682. 

  4682. 			struct mbuf *m;

    4683. 

  4683. 			char *buffer;

    4684. 

  4684. 			struct sctp_rcvinfo rcv;

    4685. 

  4685. 			union sctp_sockstore addr;

    4686. 

  4686. 			int flags = 0;

    4687. 

  4687. 

    4688. 

  4688. 			if ((buffer = malloc(control->length)) == NULL) {

    4689. 

  4689. 				return;

    4690. 

  4690. 			}

    4691. 

  4691. 			so = inp->sctp_socket;

    4692. 

  4692. 			for (m = control->data; m; m = SCTP_BUF_NEXT(m)) {

    4693. 

  4693. 				sctp_sbfree(control, control->stcb, &so->so_rcv, m);

    4694. 

  4694. 			}

    4695. 

  4695. 			atomic_add_int(&stcb->asoc.refcnt, 1);

    4696. 

  4696. 			SCTP_TCB_UNLOCK(stcb);

    4697. 

  4697. 			m_copydata(control->data, 0, control->length, buffer);

    4698. 

  4698. 			memset(&rcv, 0, sizeof(struct sctp_rcvinfo));

    4699. 

  4699. 			rcv.rcv_sid = control->sinfo_stream;

    4700. 

  4700. 			rcv.rcv_ssn = control->sinfo_ssn;

    4701. 

  4701. 			rcv.rcv_flags = control->sinfo_flags;

    4702. 

  4702. 			rcv.rcv_ppid = control->sinfo_ppid;

    4703. 

  4703. 			rcv.rcv_tsn = control->sinfo_tsn;

    4704. 

  4704. 			rcv.rcv_cumtsn = control->sinfo_cumtsn;

    4705. 

  4705. 			rcv.rcv_context = control->sinfo_context;

    4706. 

  4706. 			rcv.rcv_assoc_id = control->sinfo_assoc_id;

    4707. 

  4707. 			memset(&addr, 0, sizeof(union sctp_sockstore));

    4708. 

  4708. 			switch (control->whoFrom->ro._l_addr.sa.sa_family) {

    4709. 

  4709. #ifdef INET

    4710. 

  4710. 			case AF_INET:

    4711. 

  4711. 				addr.sin = control->whoFrom->ro._l_addr.sin;

    4712. 

  4712. 				break;

    4713. 

  4713. #endif

    4714. 

  4714. #ifdef INET6

    4715. 

  4715. 			case AF_INET6:

    4716. 

  4716. 				addr.sin6 = control->whoFrom->ro._l_addr.sin6;

    4717. 

  4717. 				break;

    4718. 

  4718. #endif

    4719. 

  4719. 			default:

    4720. 

  4720. 				addr.sa = control->whoFrom->ro._l_addr.sa;

    4721. 

  4721. 				break;

    4722. 

  4722. 			}

    4723. 

  4723. 			if (control->spec_flags & M_NOTIFICATION) {

    4724. 

  4724. 				flags |= MSG_NOTIFICATION;

    4725. 

  4725. 			}

    4726. 

  4726. 			if (control->spec_flags & M_EOR) {

    4727. 

  4727. 				flags |= MSG_EOR;

    4728. 

  4728. 			}

    4729. 

  4729. 			inp->recv_callback(so, addr, buffer, control->length, rcv, flags, inp->ulp_info);

    4730. 

  4730. 			SCTP_TCB_LOCK(stcb);

    4731. 

  4731. 			atomic_subtract_int(&stcb->asoc.refcnt, 1);

    4732. 

  4732. 			sctp_m_freem(control->data);

    4733. 

  4733. 			control->data = NULL;

    4734. 

  4734. 			control->length = 0;

    4735. 

  4735. 			sctp_free_a_readq(stcb, control);

    4736. 

  4736. 		}

    4737. 

  4737. 		return;

    4738. 

  4738. 	}

    4739. 

  4739. #endif

    4740. 

  4740. 	TAILQ_INSERT_TAIL(&inp->read_queue, control, next);

    4741. 

  4741. 	if (inp_read_lock_held == 0)

    4742. 

  4742. 		SCTP_INP_READ_UNLOCK(inp);

    4743. 

  4743. 	if (inp && inp->sctp_socket) {

    4744. 

  4744. 		if (sctp_is_feature_on(inp, SCTP_PCB_FLAGS_ZERO_COPY_ACTIVE)) {

    4745. 

  4745. 			SCTP_ZERO_COPY_EVENT(inp, inp->sctp_socket);

    4746. 

  4746. 		} else {

    4747. 

  4747. #if defined (__APPLE__) || defined(SCTP_SO_LOCK_TESTING)

    4748. 

  4748. 			struct socket *so;

    4749. 

  4749. 

    4750. 

  4750. 			so = SCTP_INP_SO(inp);

    4751. 

  4751. 			if (!so_locked) {

    4752. 

  4752. 				if (stcb) {

    4753. 

  4753. 					atomic_add_int(&stcb->asoc.refcnt, 1);

    4754. 

  4754. 					SCTP_TCB_UNLOCK(stcb);

    4755. 

  4755. 				}

    4756. 

  4756. 				SCTP_SOCKET_LOCK(so, 1);

    4757. 

  4757. 				if (stcb) {

    4758. 

  4758. 					SCTP_TCB_LOCK(stcb);

    4759. 

  4759. 					atomic_subtract_int(&stcb->asoc.refcnt, 1);

    4760. 

  4760. 				}

    4761. 

  4761. 				if (inp->sctp_flags & SCTP_PCB_FLAGS_SOCKET_GONE) {

    4762. 

  4762. 					SCTP_SOCKET_UNLOCK(so, 1);

    4763. 

  4763. 					return;

    4764. 

  4764. 				}

    4765. 

  4765. 			}

    4766. 

  4766. #endif

    4767. 

  4767. 			sctp_sorwakeup(inp, inp->sctp_socket);

    4768. 

  4768. #if defined (__APPLE__) || defined(SCTP_SO_LOCK_TESTING)

    4769. 

  4769. 			if (!so_locked) {

    4770. 

  4770. 				SCTP_SOCKET_UNLOCK(so, 1);

    4771. 

  4771. 			}

    4772. 

  4772. #endif

    4773. 

  4773. 		}

    4774. 

  4774. 	}

    4775. 

  4775. }

    4776. 

  4776. 

    4777. 

  4777. 

    4778. 

  4778. int

    4779. 

  4779. sctp_append_to_readq(struct sctp_inpcb *inp,

    4780. 

  4780.     struct sctp_tcb *stcb,

    4781. 

  4781.     struct sctp_queued_to_read *control,

    4782. 

  4782.     struct mbuf *m,

    4783. 

  4783.     int end,

    4784. 

  4784.     int ctls_cumack,

    4785. 

  4785.     struct sockbuf *sb)

    4786. 

  4786. {

    4787. 

  4787. 	/*

    4788. 

  4788. 	 * A partial delivery API event is underway. OR we are appending on

    4789. 

  4789. 	 * the reassembly queue.

    4790. 

  4790. 	 *

    4791. 

  4791. 	 * If PDAPI this means we need to add m to the end of the data.

    4792. 

  4792. 	 * Increase the length in the control AND increment the sb_cc.

    4793. 

  4793. 	 * Otherwise sb is NULL and all we need to do is put it at the end

    4794. 

  4794. 	 * of the mbuf chain.

    4795. 

  4795. 	 */

    4796. 

  4796. 	int len = 0;

    4797. 

  4797. 	struct mbuf *mm, *tail = NULL, *prev = NULL;

    4798. 

  4798. 

    4799. 

  4799. 	if (inp) {

    4800. 

  4800. 		SCTP_INP_READ_LOCK(inp);

    4801. 

  4801. 	}

    4802. 

  4802. 	if (control == NULL) {

    4803. 

  4803. 	get_out:

    4804. 

  4804. 		if (inp) {

    4805. 

  4805. 			SCTP_INP_READ_UNLOCK(inp);

    4806. 

  4806. 		}

    4807. 

  4807. 		return (-1);

    4808. 

  4808. 	}

    4809. 

  4809. 	if (inp && (inp->sctp_flags & SCTP_PCB_FLAGS_SOCKET_CANT_READ)) {

    4810. 

  4810. 		SCTP_INP_READ_UNLOCK(inp);

    4811. 

  4811. 		return (0);

    4812. 

  4812. 	}

    4813. 

  4813. 	if (control->end_added) {

    4814. 

  4814. 		/* huh this one is complete? */

    4815. 

  4815. 		goto get_out;

    4816. 

  4816. 	}

    4817. 

  4817. 	mm = m;

    4818. 

  4818. 	if (mm == NULL) {

    4819. 

  4819. 		goto get_out;

    4820. 

  4820. 	}

    4821. 

  4821. 

    4822. 

  4822. 	while (mm) {

    4823. 

  4823. 		if (SCTP_BUF_LEN(mm) == 0) {

    4824. 

  4824. 			/* Skip mbufs with NO lenght */

    4825. 

  4825. 			if (prev == NULL) {

    4826. 

  4826. 				/* First one */

    4827. 

  4827. 				m = sctp_m_free(mm);

    4828. 

  4828. 				mm = m;

    4829. 

  4829. 			} else {

    4830. 

  4830. 				SCTP_BUF_NEXT(prev) = sctp_m_free(mm);

    4831. 

  4831. 				mm = SCTP_BUF_NEXT(prev);

    4832. 

  4832. 			}

    4833. 

  4833. 			continue;

    4834. 

  4834. 		}

    4835. 

  4835. 		prev = mm;

    4836. 

  4836. 		len += SCTP_BUF_LEN(mm);

    4837. 

  4837. 		if (sb) {

    4838. 

  4838. 			if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_SB_LOGGING_ENABLE) {

    4839. 

  4839. 				sctp_sblog(sb, control->do_not_ref_stcb?NULL:stcb, SCTP_LOG_SBALLOC, SCTP_BUF_LEN(mm));

    4840. 

  4840. 			}

    4841. 

  4841. 			sctp_sballoc(stcb, sb, mm);

    4842. 

  4842. 			if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_SB_LOGGING_ENABLE) {

    4843. 

  4843. 				sctp_sblog(sb, control->do_not_ref_stcb?NULL:stcb, SCTP_LOG_SBRESULT, 0);

    4844. 

  4844. 			}

    4845. 

  4845. 		}

    4846. 

  4846. 		mm = SCTP_BUF_NEXT(mm);

    4847. 

  4847. 	}

    4848. 

  4848. 	if (prev) {

    4849. 

  4849. 		tail = prev;

    4850. 

  4850. 	} else {

    4851. 

  4851. 		/* Really there should always be a prev */

    4852. 

  4852. 		if (m == NULL) {

    4853. 

  4853. 			/* Huh nothing left? */

    4854. 

  4854. #ifdef INVARIANTS

    4855. 

  4855. 			panic("Nothing left to add?");

    4856. 

  4856. #else

    4857. 

  4857. 			goto get_out;

    4858. 

  4858. #endif

    4859. 

  4859. 		}

    4860. 

  4860. 		tail = m;

    4861. 

  4861. 	}

    4862. 

  4862. 	if (control->tail_mbuf) {

    4863. 

  4863. 		/* append */

    4864. 

  4864. 		SCTP_BUF_NEXT(control->tail_mbuf) = m;

    4865. 

  4865. 		control->tail_mbuf = tail;

    4866. 

  4866. 	} else {

    4867. 

  4867. 		/* nothing there */

    4868. 

  4868. #ifdef INVARIANTS

    4869. 

  4869. 		if (control->data != NULL) {

    4870. 

  4870. 			panic("This should NOT happen");

    4871. 

  4871. 		}

    4872. 

  4872. #endif

    4873. 

  4873. 		control->data = m;

    4874. 

  4874. 		control->tail_mbuf = tail;

    4875. 

  4875. 	}

    4876. 

  4876. 	atomic_add_int(&control->length, len);

    4877. 

  4877. 	if (end) {

    4878. 

  4878. 		/* message is complete */

    4879. 

  4879. 		if (stcb && (control == stcb->asoc.control_pdapi)) {

    4880. 

  4880. 			stcb->asoc.control_pdapi = NULL;

    4881. 

  4881. 		}

    4882. 

  4882. 		control->held_length = 0;

    4883. 

  4883. 		control->end_added = 1;

    4884. 

  4884. 	}

    4885. 

  4885. 	if (stcb == NULL) {

    4886. 

  4886. 		control->do_not_ref_stcb = 1;

    4887. 

  4887. 	}

    4888. 

  4888. 	/*

    4889. 

  4889. 	 * When we are appending in partial delivery, the cum-ack is used

    4890. 

  4890. 	 * for the actual pd-api highest tsn on this mbuf. The true cum-ack

    4891. 

  4891. 	 * is populated in the outbound sinfo structure from the true cumack

    4892. 

  4892. 	 * if the association exists...

    4893. 

  4893. 	 */

    4894. 

  4894. #if defined(__Userspace__)

    4895. 

  4895. 	if (inp->recv_callback) {

    4896. 

  4896. 		if (control->end_added == 1) {

    4897. 

  4897. 			struct socket *so;

    4898. 

  4898. 			char *buffer;

    4899. 

  4899. 			struct sctp_rcvinfo rcv;

    4900. 

  4900. 			union sctp_sockstore addr;

    4901. 

  4901. 			int flags = 0;

    4902. 

  4902. 

    4903. 

  4903. 			if ((buffer = malloc(control->length)) == NULL) {

    4904. 

  4904. 				return (-1);

    4905. 

  4905. 			}

    4906. 

  4906. 			so = inp->sctp_socket;

    4907. 

  4907. 			for (m = control->data; m; m = SCTP_BUF_NEXT(m)) {

    4908. 

  4908. 				sctp_sbfree(control, control->stcb, &so->so_rcv, m);

    4909. 

  4909. 			}

    4910. 

  4910. 			atomic_add_int(&stcb->asoc.refcnt, 1);

    4911. 

  4911. 			SCTP_TCB_UNLOCK(stcb);

    4912. 

  4912. 			m_copydata(control->data, 0, control->length, buffer);

    4913. 

  4913. 			memset(&rcv, 0, sizeof(struct sctp_rcvinfo));

    4914. 

  4914. 			rcv.rcv_sid = control->sinfo_stream;

    4915. 

  4915. 			rcv.rcv_ssn = control->sinfo_ssn;

    4916. 

  4916. 			rcv.rcv_flags = control->sinfo_flags;

    4917. 

  4917. 			rcv.rcv_ppid = control->sinfo_ppid;

    4918. 

  4918. 			rcv.rcv_tsn = control->sinfo_tsn;

    4919. 

  4919. 			rcv.rcv_cumtsn = control->sinfo_cumtsn;

    4920. 

  4920. 			rcv.rcv_context = control->sinfo_context;

    4921. 

  4921. 			rcv.rcv_assoc_id = control->sinfo_assoc_id;

    4922. 

  4922. 			memset(&addr, 0, sizeof(union sctp_sockstore));

    4923. 

  4923. 			switch (control->whoFrom->ro._l_addr.sa.sa_family) {

    4924. 

  4924. #ifdef INET

    4925. 

  4925. 			case AF_INET:

    4926. 

  4926. 				addr.sin = control->whoFrom->ro._l_addr.sin;

    4927. 

  4927. 				break;

    4928. 

  4928. #endif

    4929. 

  4929. #ifdef INET6

    4930. 

  4930. 			case AF_INET6:

    4931. 

  4931. 				addr.sin6 = control->whoFrom->ro._l_addr.sin6;

    4932. 

  4932. 				break;

    4933. 

  4933. #endif

    4934. 

  4934. 			default:

    4935. 

  4935. 				addr.sa = control->whoFrom->ro._l_addr.sa;

    4936. 

  4936. 				break;

    4937. 

  4937. 			}

    4938. 

  4938. 			if (control->spec_flags & M_NOTIFICATION) {

    4939. 

  4939. 				flags |= MSG_NOTIFICATION;

    4940. 

  4940. 			}

    4941. 

  4941. 			if (control->spec_flags & M_EOR) {

    4942. 

  4942. 				flags |= MSG_EOR;

    4943. 

  4943. 			}

    4944. 

  4944. 			inp->recv_callback(so, addr, buffer, control->length, rcv, flags, inp->ulp_info);

    4945. 

  4945. 			SCTP_TCB_LOCK(stcb);

    4946. 

  4946. 			atomic_subtract_int(&stcb->asoc.refcnt, 1);

    4947. 

  4947. 			sctp_m_freem(control->data);

    4948. 

  4948. 			control->data = NULL;

    4949. 

  4949. 			control->length = 0;

    4950. 

  4950. 			sctp_free_a_readq(stcb, control);

    4951. 

  4951. 		}

    4952. 

  4952. 		if (inp)

    4953. 

  4953. 			SCTP_INP_READ_UNLOCK(inp);

    4954. 

  4954. 		return (0);

    4955. 

  4955. 	}

    4956. 

  4956. #endif

    4957. 

  4957. 	control->sinfo_tsn = control->sinfo_cumtsn = ctls_cumack;

    4958. 

  4958. 	if (inp) {

    4959. 

  4959. 		SCTP_INP_READ_UNLOCK(inp);

    4960. 

  4960. 	}

    4961. 

  4961. 	if (inp && inp->sctp_socket) {

    4962. 

  4962. 		if (sctp_is_feature_on(inp, SCTP_PCB_FLAGS_ZERO_COPY_ACTIVE)) {

    4963. 

  4963. 			SCTP_ZERO_COPY_EVENT(inp, inp->sctp_socket);

    4964. 

  4964. 		} else {

    4965. 

  4965. #if defined (__APPLE__) || defined(SCTP_SO_LOCK_TESTING)

    4966. 

  4966. 			struct socket *so;

    4967. 

  4967. 

    4968. 

  4968. 			so = SCTP_INP_SO(inp);

    4969. 

  4969. 			if (stcb) {

    4970. 

  4970. 				atomic_add_int(&stcb->asoc.refcnt, 1);

    4971. 

  4971. 				SCTP_TCB_UNLOCK(stcb);

    4972. 

  4972. 			}

    4973. 

  4973. 			SCTP_SOCKET_LOCK(so, 1);

    4974. 

  4974. 			if (stcb) {

    4975. 

  4975. 				SCTP_TCB_LOCK(stcb);

    4976. 

  4976. 				atomic_subtract_int(&stcb->asoc.refcnt, 1);

    4977. 

  4977. 			}

    4978. 

  4978. 			if (inp->sctp_flags & SCTP_PCB_FLAGS_SOCKET_GONE) {

    4979. 

  4979. 				SCTP_SOCKET_UNLOCK(so, 1);

    4980. 

  4980. 				return (0);

    4981. 

  4981. 			}

    4982. 

  4982. #endif

    4983. 

  4983. 			sctp_sorwakeup(inp, inp->sctp_socket);

    4984. 

  4984. #if defined (__APPLE__) || defined(SCTP_SO_LOCK_TESTING)

    4985. 

  4985. 			SCTP_SOCKET_UNLOCK(so, 1);

    4986. 

  4986. #endif

    4987. 

  4987. 		}

    4988. 

  4988. 	}

    4989. 

  4989. 	return (0);

    4990. 

  4990. }

    4991. 

  4991. 

    4992. 

  4992. 

    4993. 

  4993. 

    4994. 

  4994. /*************HOLD THIS COMMENT FOR PATCH FILE OF

    4995. 

  4995.  *************ALTERNATE ROUTING CODE

    4996. 

  4996.  */

    4997. 

  4997. 

    4998. 

  4998. /*************HOLD THIS COMMENT FOR END OF PATCH FILE OF

    4999. 

  4999.  *************ALTERNATE ROUTING CODE

    5000. 

  5000.  */

    5001. 

  5001. 

    5002. 

  5002. struct mbuf *

    5003. 

  5003. sctp_generate_invmanparam(int err)

    5004. 

  5004. {

    5005. 

  5005. 	/* Return a MBUF with a invalid mandatory parameter */

    5006. 

  5006. 	struct mbuf *m;

    5007. 

  5007. 

    5008. 

  5008. 	m = sctp_get_mbuf_for_msg(sizeof(struct sctp_paramhdr), 0, M_DONTWAIT, 1, MT_DATA);

    5009. 

  5009. 	if (m) {

    5010. 

  5010. 		struct sctp_paramhdr *ph;

    5011. 

  5011. 

    5012. 

  5012. 		SCTP_BUF_LEN(m) = sizeof(struct sctp_paramhdr);

    5013. 

  5013. 		ph = mtod(m, struct sctp_paramhdr *);

    5014. 

  5014. 		ph->param_length = htons(sizeof(struct sctp_paramhdr));

    5015. 

  5015. 		ph->param_type = htons(err);

    5016. 

  5016. 	}

    5017. 

  5017. 	return (m);

    5018. 

  5018. }

    5019. 

  5019. 

    5020. 

  5020. #ifdef SCTP_MBCNT_LOGGING

    5021. 

  5021. void

    5022. 

  5022. sctp_free_bufspace(struct sctp_tcb *stcb, struct sctp_association *asoc,

    5023. 

  5023.     struct sctp_tmit_chunk *tp1, int chk_cnt)

    5024. 

  5024. {

    5025. 

  5025. 	if (tp1->data == NULL) {

    5026. 

  5026. 		return;

    5027. 

  5027. 	}

    5028. 

  5028. 	asoc->chunks_on_out_queue -= chk_cnt;

    5029. 

  5029. 	if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_MBCNT_LOGGING_ENABLE) {

    5030. 

  5030. 		sctp_log_mbcnt(SCTP_LOG_MBCNT_DECREASE,

    5031. 

  5031. 			       asoc->total_output_queue_size,

    5032. 

  5032. 			       tp1->book_size,

    5033. 

  5033. 			       0,

    5034. 

  5034. 			       tp1->mbcnt);

    5035. 

  5035. 	}

    5036. 

  5036. 	if (asoc->total_output_queue_size >= tp1->book_size) {

    5037. 

  5037. 		atomic_add_int(&asoc->total_output_queue_size, -tp1->book_size);

    5038. 

  5038. 	} else {

    5039. 

  5039. 		asoc->total_output_queue_size = 0;

    5040. 

  5040. 	}

    5041. 

  5041. 

    5042. 

  5042. 	if (stcb->sctp_socket && (((stcb->sctp_ep->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL)) ||

    5043. 

  5043. 				  ((stcb->sctp_ep->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE)))) {

    5044. 

  5044. 		if (stcb->sctp_socket->so_snd.sb_cc >= tp1->book_size) {

    5045. 

  5045. 			stcb->sctp_socket->so_snd.sb_cc -= tp1->book_size;

    5046. 

  5046. 		} else {

    5047. 

  5047. 			stcb->sctp_socket->so_snd.sb_cc = 0;

    5048. 

  5048. 

    5049. 

  5049. 		}

    5050. 

  5050. 	}

    5051. 

  5051. }

    5052. 

  5052. 

    5053. 

  5053. #endif

    5054. 

  5054. 

    5055. 

  5055. int

    5056. 

  5056. sctp_release_pr_sctp_chunk(struct sctp_tcb *stcb, struct sctp_tmit_chunk *tp1,

    5057. 

  5057. 			   uint8_t sent, int so_locked

    5058. 

  5058. #if !defined(__APPLE__) && !defined(SCTP_SO_LOCK_TESTING)

    5059. 

  5059. 			   SCTP_UNUSED

    5060. 

  5060. #endif

    5061. 

  5061. 	)

    5062. 

  5062. {

    5063. 

  5063. 	struct sctp_stream_out *strq;

    5064. 

  5064. 	struct sctp_tmit_chunk *chk = NULL, *tp2;

    5065. 

  5065. 	struct sctp_stream_queue_pending *sp;

    5066. 

  5066. 	uint16_t stream = 0, seq = 0;

    5067. 

  5067. 	uint8_t foundeom = 0;

    5068. 

  5068. 	int ret_sz = 0;

    5069. 

  5069. 	int notdone;

    5070. 

  5070. 	int do_wakeup_routine = 0;

    5071. 

  5071. #if defined(__APPLE__)

    5072. 

  5072. 	if (so_locked) {

    5073. 

  5073. 		sctp_lock_assert(SCTP_INP_SO(stcb->sctp_ep));

    5074. 

  5074. 	} else {

    5075. 

  5075. 		sctp_unlock_assert(SCTP_INP_SO(stcb->sctp_ep));

    5076. 

  5076. 	}

    5077. 

  5077. #endif

    5078. 

  5078. 	stream = tp1->rec.data.stream_number;

    5079. 

  5079. 	seq = tp1->rec.data.stream_seq;

    5080. 

  5080. 	do {

    5081. 

  5081. 		ret_sz += tp1->book_size;

    5082. 

  5082. 		if (tp1->data != NULL) {

    5083. 

  5083. 			if (tp1->sent < SCTP_DATAGRAM_RESEND) {

    5084. 

  5084. 				sctp_flight_size_decrease(tp1);

    5085. 

  5085. 				sctp_total_flight_decrease(stcb, tp1);

    5086. 

  5086. 			}

    5087. 

  5087. 			sctp_free_bufspace(stcb, &stcb->asoc, tp1, 1);

    5088. 

  5088. 			stcb->asoc.peers_rwnd += tp1->send_size;

    5089. 

  5089. 			stcb->asoc.peers_rwnd += SCTP_BASE_SYSCTL(sctp_peer_chunk_oh);

    5090. 

  5090. 			if (sent) {

    5091. 

  5091. 				sctp_ulp_notify(SCTP_NOTIFY_SENT_DG_FAIL, stcb, 0, tp1, so_locked);

    5092. 

  5092. 			} else {

    5093. 

  5093. 				sctp_ulp_notify(SCTP_NOTIFY_UNSENT_DG_FAIL, stcb, 0, tp1, so_locked);

    5094. 

  5094. 			}

    5095. 

  5095. 			if (tp1->data) {

    5096. 

  5096. 				sctp_m_freem(tp1->data);

    5097. 

  5097. 				tp1->data = NULL;

    5098. 

  5098. 			}

    5099. 

  5099. 			do_wakeup_routine = 1;

    5100. 

  5100. 			if (PR_SCTP_BUF_ENABLED(tp1->flags)) {

    5101. 

  5101. 				stcb->asoc.sent_queue_cnt_removeable--;

    5102. 

  5102. 			}

    5103. 

  5103. 		}

    5104. 

  5104. 		tp1->sent = SCTP_FORWARD_TSN_SKIP;

    5105. 

  5105. 		if ((tp1->rec.data.rcv_flags & SCTP_DATA_NOT_FRAG) ==

    5106. 

  5106. 		    SCTP_DATA_NOT_FRAG) {

    5107. 

  5107. 			/* not frag'ed we ae done   */

    5108. 

  5108. 			notdone = 0;

    5109. 

  5109. 			foundeom = 1;

    5110. 

  5110. 		} else if (tp1->rec.data.rcv_flags & SCTP_DATA_LAST_FRAG) {

    5111. 

  5111. 			/* end of frag, we are done */

    5112. 

  5112. 			notdone = 0;

    5113. 

  5113. 			foundeom = 1;

    5114. 

  5114. 		} else {

    5115. 

  5115. 			/*

    5116. 

  5116. 			 * Its a begin or middle piece, we must mark all of

    5117. 

  5117. 			 * it

    5118. 

  5118. 			 */

    5119. 

  5119. 			notdone = 1;

    5120. 

  5120. 			tp1 = TAILQ_NEXT(tp1, sctp_next);

    5121. 

  5121. 		}

    5122. 

  5122. 	} while (tp1 && notdone);

    5123. 

  5123. 	if (foundeom == 0) {

    5124. 

  5124. 		/*

    5125. 

  5125. 		 * The multi-part message was scattered across the send and

    5126. 

  5126. 		 * sent queue.

    5127. 

  5127. 		 */

    5128. 

  5128. 		TAILQ_FOREACH_SAFE(tp1, &stcb->asoc.send_queue, sctp_next, tp2) {

    5129. 

  5129. 			if ((tp1->rec.data.stream_number != stream) ||

    5130. 

  5130. 		   	    (tp1->rec.data.stream_seq != seq)) {

    5131. 

  5131. 				break;

    5132. 

  5132. 			}

    5133. 

  5133. 			/* save to chk in case we have some on stream out

    5134. 

  5134. 			 * queue. If so and we have an un-transmitted one

    5135. 

  5135. 			 * we don't have to fudge the TSN.

    5136. 

  5136. 			 */

    5137. 

  5137. 			chk = tp1;

    5138. 

  5138. 			ret_sz += tp1->book_size;

    5139. 

  5139. 			sctp_free_bufspace(stcb, &stcb->asoc, tp1, 1);

    5140. 

  5140. 			if (sent) {

    5141. 

  5141. 				sctp_ulp_notify(SCTP_NOTIFY_SENT_DG_FAIL, stcb, 0, tp1, so_locked);

    5142. 

  5142. 			} else {

    5143. 

  5143. 				sctp_ulp_notify(SCTP_NOTIFY_UNSENT_DG_FAIL, stcb, 0, tp1, so_locked);

    5144. 

  5144. 			}

    5145. 

  5145. 			if (tp1->data) {

    5146. 

  5146. 				sctp_m_freem(tp1->data);

    5147. 

  5147. 				tp1->data = NULL;

    5148. 

  5148. 			}

    5149. 

  5149. 			/* No flight involved here book the size to 0 */

    5150. 

  5150. 			tp1->book_size = 0;

    5151. 

  5151. 			if (tp1->rec.data.rcv_flags & SCTP_DATA_LAST_FRAG) {

    5152. 

  5152. 				foundeom = 1;

    5153. 

  5153. 			}

    5154. 

  5154. 			do_wakeup_routine = 1;

    5155. 

  5155. 			tp1->sent = SCTP_FORWARD_TSN_SKIP;

    5156. 

  5156. 			TAILQ_REMOVE(&stcb->asoc.send_queue, tp1, sctp_next);

    5157. 

  5157. 			/* on to the sent queue so we can wait for it to be passed by. */

    5158. 

  5158. 			TAILQ_INSERT_TAIL(&stcb->asoc.sent_queue, tp1,

    5159. 

  5159. 					  sctp_next);

    5160. 

  5160. 			stcb->asoc.send_queue_cnt--;

    5161. 

  5161. 			stcb->asoc.sent_queue_cnt++;

    5162. 

  5162. 		}

    5163. 

  5163. 	}

    5164. 

  5164. 	if (foundeom == 0) {

    5165. 

  5165. 		/*

    5166. 

  5166. 		 * Still no eom found. That means there

    5167. 

  5167. 		 * is stuff left on the stream out queue.. yuck.

    5168. 

  5168. 		 */

    5169. 

  5169. 		strq = &stcb->asoc.strmout[stream];

    5170. 

  5170. 		SCTP_TCB_SEND_LOCK(stcb);

    5171. 

  5171. 		TAILQ_FOREACH(sp, &strq->outqueue, next) {

    5172. 

  5172. 			/* FIXME: Shouldn't this be a serial number check? */

    5173. 

  5173. 			if (sp->strseq > seq) {

    5174. 

  5174. 				break;

    5175. 

  5175. 			}

    5176. 

  5176. 			/* Check if its our SEQ */

    5177. 

  5177. 			if (sp->strseq == seq) {

    5178. 

  5178. 				sp->discard_rest = 1;

    5179. 

  5179. 				/*

    5180. 

  5180. 				 * We may need to put a chunk on the

    5181. 

  5181. 				 * queue that holds the TSN that

    5182. 

  5182. 				 * would have been sent with the LAST

    5183. 

  5183. 				 * bit.

    5184. 

  5184. 				 */

    5185. 

  5185. 				if (chk == NULL) {

    5186. 

  5186. 					/* Yep, we have to */

    5187. 

  5187. 					sctp_alloc_a_chunk(stcb, chk);

    5188. 

  5188. 					if (chk == NULL) {

    5189. 

  5189. 						/* we are hosed. All we can

    5190. 

  5190. 						 * do is nothing.. which will

    5191. 

  5191. 						 * cause an abort if the peer is

    5192. 

  5192. 						 * paying attention.

    5193. 

  5193. 						 */

    5194. 

  5194. 						goto oh_well;

    5195. 

  5195. 					}

    5196. 

  5196. 					memset(chk, 0, sizeof(*chk));

    5197. 

  5197. 					chk->rec.data.rcv_flags = SCTP_DATA_LAST_FRAG;

    5198. 

  5198. 					chk->sent = SCTP_FORWARD_TSN_SKIP;

    5199. 

  5199. 					chk->asoc = &stcb->asoc;

    5200. 

  5200. 					chk->rec.data.stream_seq = sp->strseq;

    5201. 

  5201. 					chk->rec.data.stream_number = sp->stream;

    5202. 

  5202. 					chk->rec.data.payloadtype = sp->ppid;

    5203. 

  5203. 					chk->rec.data.context = sp->context;

    5204. 

  5204. 					chk->flags = sp->act_flags;

    5205. 

  5205. 					if (sp->net)

    5206. 

  5206. 						chk->whoTo = sp->net;

    5207. 

  5207. 					else

    5208. 

  5208. 						chk->whoTo = stcb->asoc.primary_destination;

    5209. 

  5209. 					atomic_add_int(&chk->whoTo->ref_count, 1);

    5210. 

  5210. #if defined(__FreeBSD__) || defined(__Panda__)

    5211. 

  5211. 					chk->rec.data.TSN_seq = atomic_fetchadd_int(&stcb->asoc.sending_seq, 1);

    5212. 

  5212. #else

    5213. 

  5213. 					chk->rec.data.TSN_seq = stcb->asoc.sending_seq++;

    5214. 

  5214. #endif

    5215. 

  5215. 					stcb->asoc.pr_sctp_cnt++;

    5216. 

  5216. 					chk->pr_sctp_on = 1;

    5217. 

  5217. 					TAILQ_INSERT_TAIL(&stcb->asoc.sent_queue, chk, sctp_next);

    5218. 

  5218. 					stcb->asoc.sent_queue_cnt++;

    5219. 

  5219. 					stcb->asoc.pr_sctp_cnt++;

    5220. 

  5220. 				} else {

    5221. 

  5221. 					chk->rec.data.rcv_flags |= SCTP_DATA_LAST_FRAG;

    5222. 

  5222. 				}

    5223. 

  5223. 			oh_well:

    5224. 

  5224. 				if (sp->data) {

    5225. 

  5225. 					/* Pull any data to free up the SB and

    5226. 

  5226. 					 * allow sender to "add more" whilc we

    5227. 

  5227. 					 * will throw away :-)

    5228. 

  5228. 					 */

    5229. 

  5229. 					sctp_free_spbufspace(stcb, &stcb->asoc,

    5230. 

  5230. 							     sp);

    5231. 

  5231. 					ret_sz += sp->length;

    5232. 

  5232. 					do_wakeup_routine = 1;

    5233. 

  5233. 					sp->some_taken = 1;

    5234. 

  5234. 					sctp_m_freem(sp->data);

    5235. 

  5235. 					sp->length = 0;

    5236. 

  5236. 					sp->data = NULL;

    5237. 

  5237. 					sp->tail_mbuf = NULL;

    5238. 

  5238. 				}

    5239. 

  5239. 				break;

    5240. 

  5240. 			}

    5241. 

  5241. 		} /* End tailq_foreach */

    5242. 

  5242. 		SCTP_TCB_SEND_UNLOCK(stcb);

    5243. 

  5243. 	}

    5244. 

  5244. 	if (do_wakeup_routine) {

    5245. 

  5245. #if defined (__APPLE__) || defined(SCTP_SO_LOCK_TESTING)

    5246. 

  5246. 		struct socket *so;

    5247. 

  5247. 

    5248. 

  5248. 		so = SCTP_INP_SO(stcb->sctp_ep);

    5249. 

  5249. 		if (!so_locked) {

    5250. 

  5250. 			atomic_add_int(&stcb->asoc.refcnt, 1);

    5251. 

  5251. 			SCTP_TCB_UNLOCK(stcb);

    5252. 

  5252. 			SCTP_SOCKET_LOCK(so, 1);

    5253. 

  5253. 			SCTP_TCB_LOCK(stcb);

    5254. 

  5254. 			atomic_subtract_int(&stcb->asoc.refcnt, 1);

    5255. 

  5255. 			if (stcb->asoc.state & SCTP_STATE_CLOSED_SOCKET) {

    5256. 

  5256. 				/* assoc was freed while we were unlocked */

    5257. 

  5257. 				SCTP_SOCKET_UNLOCK(so, 1);

    5258. 

  5258. 				return (ret_sz);

    5259. 

  5259. 			}

    5260. 

  5260. 		}

    5261. 

  5261. #endif

    5262. 

  5262. 		sctp_sowwakeup(stcb->sctp_ep, stcb->sctp_socket);

    5263. 

  5263. #if defined (__APPLE__) || defined(SCTP_SO_LOCK_TESTING)

    5264. 

  5264. 		if (!so_locked) {

    5265. 

  5265. 			SCTP_SOCKET_UNLOCK(so, 1);

    5266. 

  5266. 		}

    5267. 

  5267. #endif

    5268. 

  5268. 	}

    5269. 

  5269. 	return (ret_sz);

    5270. 

  5270. }

    5271. 

  5271. 

    5272. 

  5272. /*

    5273. 

  5273.  * checks to see if the given address, sa, is one that is currently known by

    5274. 

  5274.  * the kernel note: can't distinguish the same address on multiple interfaces

    5275. 

  5275.  * and doesn't handle multiple addresses with different zone/scope id's note:

    5276. 

  5276.  * ifa_ifwithaddr() compares the entire sockaddr struct

    5277. 

  5277.  */

    5278. 

  5278. struct sctp_ifa *

    5279. 

  5279. sctp_find_ifa_in_ep(struct sctp_inpcb *inp, struct sockaddr *addr,

    5280. 

  5280. 		    int holds_lock)

    5281. 

  5281. {

    5282. 

  5282. 	struct sctp_laddr *laddr;

    5283. 

  5283. 

    5284. 

  5284. 	if (holds_lock == 0) {

    5285. 

  5285. 		SCTP_INP_RLOCK(inp);

    5286. 

  5286. 	}

    5287. 

  5287. 

    5288. 

  5288. 	LIST_FOREACH(laddr, &inp->sctp_addr_list, sctp_nxt_addr) {

    5289. 

  5289. 		if (laddr->ifa == NULL)

    5290. 

  5290. 			continue;

    5291. 

  5291. 		if (addr->sa_family != laddr->ifa->address.sa.sa_family)

    5292. 

  5292. 			continue;

    5293. 

  5293. #ifdef INET

    5294. 

  5294. 		if (addr->sa_family == AF_INET) {

    5295. 

  5295. 			if (((struct sockaddr_in *)addr)->sin_addr.s_addr ==

    5296. 

  5296. 			    laddr->ifa->address.sin.sin_addr.s_addr) {

    5297. 

  5297. 				/* found him. */

    5298. 

  5298. 				if (holds_lock == 0) {

    5299. 

  5299. 					SCTP_INP_RUNLOCK(inp);

    5300. 

  5300. 				}

    5301. 

  5301. 				return (laddr->ifa);

    5302. 

  5302. 				break;

    5303. 

  5303. 			}

    5304. 

  5304. 		}

    5305. 

  5305. #endif

    5306. 

  5306. #ifdef INET6

    5307. 

  5307. 		if (addr->sa_family == AF_INET6) {

    5308. 

  5308. 			if (SCTP6_ARE_ADDR_EQUAL((struct sockaddr_in6 *)addr,

    5309. 

  5309. 						 &laddr->ifa->address.sin6)) {

    5310. 

  5310. 				/* found him. */

    5311. 

  5311. 				if (holds_lock == 0) {

    5312. 

  5312. 					SCTP_INP_RUNLOCK(inp);

    5313. 

  5313. 				}

    5314. 

  5314. 				return (laddr->ifa);

    5315. 

  5315. 				break;

    5316. 

  5316. 			}

    5317. 

  5317. 		}

    5318. 

  5318. #endif

    5319. 

  5319. 	}

    5320. 

  5320. 	if (holds_lock == 0) {

    5321. 

  5321. 		SCTP_INP_RUNLOCK(inp);

    5322. 

  5322. 	}

    5323. 

  5323. 	return (NULL);

    5324. 

  5324. }

    5325. 

  5325. 

    5326. 

  5326. uint32_t

    5327. 

  5327. sctp_get_ifa_hash_val(struct sockaddr *addr)

    5328. 

  5328. {

    5329. 

  5329. 	switch (addr->sa_family) {

    5330. 

  5330. #ifdef INET

    5331. 

  5331. 	case AF_INET:

    5332. 

  5332. 	{

    5333. 

  5333. 		struct sockaddr_in *sin;

    5334. 

  5334. 

    5335. 

  5335. 		sin = (struct sockaddr_in *)addr;

    5336. 

  5336. 		return (sin->sin_addr.s_addr ^ (sin->sin_addr.s_addr >> 16));

    5337. 

  5337. 	}

    5338. 

  5338. #endif

    5339. 

  5339. #ifdef INET6

    5340. 

  5340. 	case INET6:

    5341. 

  5341. 	{

    5342. 

  5342. 		struct sockaddr_in6 *sin6;

    5343. 

  5343. 		uint32_t hash_of_addr;

    5344. 

  5344. 

    5345. 

  5345. 		sin6 = (struct sockaddr_in6 *)addr;

    5346. 

  5346. #if !defined(__Windows__) && !defined(__Userspace_os_FreeBSD) && !defined(__Userspace_os_Darwin) && !defined(__Userspace_os_Windows)

    5347. 

  5347. 		hash_of_addr = (sin6->sin6_addr.s6_addr32[0] +

    5348. 

  5348. 				sin6->sin6_addr.s6_addr32[1] +

    5349. 

  5349. 				sin6->sin6_addr.s6_addr32[2] +

    5350. 

  5350. 				sin6->sin6_addr.s6_addr32[3]);

    5351. 

  5351. #else

    5352. 

  5352. 		hash_of_addr = (((uint32_t *)&sin6->sin6_addr)[0] +

    5353. 

  5353. 				((uint32_t *)&sin6->sin6_addr)[1] +

    5354. 

  5354. 				((uint32_t *)&sin6->sin6_addr)[2] +

    5355. 

  5355. 				((uint32_t *)&sin6->sin6_addr)[3]);

    5356. 

  5356. #endif

    5357. 

  5357. 		hash_of_addr = (hash_of_addr ^ (hash_of_addr >> 16));

    5358. 

  5358. 		return (hash_of_addr);

    5359. 

  5359. 	}

    5360. 

  5360. #endif

    5361. 

  5361. 	default:

    5362. 

  5362. 		break;

    5363. 

  5363. 	}

    5364. 

  5364. 	return (0);

    5365. 

  5365. }

    5366. 

  5366. 

    5367. 

  5367. struct sctp_ifa *

    5368. 

  5368. sctp_find_ifa_by_addr(struct sockaddr *addr, uint32_t vrf_id, int holds_lock)

    5369. 

  5369. {

    5370. 

  5370. 	struct sctp_ifa *sctp_ifap;

    5371. 

  5371. 	struct sctp_vrf *vrf;

    5372. 

  5372. 	struct sctp_ifalist *hash_head;

    5373. 

  5373. 	uint32_t hash_of_addr;

    5374. 

  5374. 

    5375. 

  5375. 	if (holds_lock == 0)

    5376. 

  5376. 		SCTP_IPI_ADDR_RLOCK();

    5377. 

  5377. 

    5378. 

  5378. 	vrf = sctp_find_vrf(vrf_id);

    5379. 

  5379. 	if (vrf == NULL) {

    5380. 

  5380. 	stage_right:

    5381. 

  5381. 		if (holds_lock == 0)

    5382. 

  5382. 			SCTP_IPI_ADDR_RUNLOCK();

    5383. 

  5383. 		return (NULL);

    5384. 

  5384. 	}

    5385. 

  5385. 

    5386. 

  5386. 	hash_of_addr = sctp_get_ifa_hash_val(addr);

    5387. 

  5387. 

    5388. 

  5388. 	hash_head = &vrf->vrf_addr_hash[(hash_of_addr & vrf->vrf_addr_hashmark)];

    5389. 

  5389. 	if (hash_head == NULL) {

    5390. 

  5390. 		SCTP_PRINTF("hash_of_addr:%x mask:%x table:%x - ",

    5391. 

  5391. 			    hash_of_addr, (uint32_t)vrf->vrf_addr_hashmark,

    5392. 

  5392. 			    (uint32_t)(hash_of_addr & vrf->vrf_addr_hashmark));

    5393. 

  5393. 		sctp_print_address(addr);

    5394. 

  5394. 		SCTP_PRINTF("No such bucket for address\n");

    5395. 

  5395. 		if (holds_lock == 0)

    5396. 

  5396. 			SCTP_IPI_ADDR_RUNLOCK();

    5397. 

  5397. 

    5398. 

  5398. 		return (NULL);

    5399. 

  5399. 	}

    5400. 

  5400. 	LIST_FOREACH(sctp_ifap, hash_head, next_bucket) {

    5401. 

  5401. 		if (sctp_ifap == NULL) {

    5402. 

  5402. #ifdef INVARIANTS

    5403. 

  5403. 			panic("Huh LIST_FOREACH corrupt");

    5404. 

  5404. 		        goto stage_right;

    5405. 

  5405. #else

    5406. 

  5406. 			SCTP_PRINTF("LIST corrupt of sctp_ifap's?\n");

    5407. 

  5407. 			goto stage_right;

    5408. 

  5408. #endif

    5409. 

  5409. 		}

    5410. 

  5410. 		if (addr->sa_family != sctp_ifap->address.sa.sa_family)

    5411. 

  5411. 			continue;

    5412. 

  5412. #ifdef INET

    5413. 

  5413. 		if (addr->sa_family == AF_INET) {

    5414. 

  5414. 			if (((struct sockaddr_in *)addr)->sin_addr.s_addr ==

    5415. 

  5415. 			    sctp_ifap->address.sin.sin_addr.s_addr) {

    5416. 

  5416. 				/* found him. */

    5417. 

  5417. 				if (holds_lock == 0)

    5418. 

  5418. 					SCTP_IPI_ADDR_RUNLOCK();

    5419. 

  5419. 				return (sctp_ifap);

    5420. 

  5420. 				break;

    5421. 

  5421. 			}

    5422. 

  5422. 		}

    5423. 

  5423. #endif

    5424. 

  5424. #ifdef INET6

    5425. 

  5425. 		if (addr->sa_family == AF_INET6) {

    5426. 

  5426. 			if (SCTP6_ARE_ADDR_EQUAL((struct sockaddr_in6 *)addr,

    5427. 

  5427. 						 &sctp_ifap->address.sin6)) {

    5428. 

  5428. 				/* found him. */

    5429. 

  5429. 				if (holds_lock == 0)

    5430. 

  5430. 					SCTP_IPI_ADDR_RUNLOCK();

    5431. 

  5431. 				return (sctp_ifap);

    5432. 

  5432. 				break;

    5433. 

  5433. 			}

    5434. 

  5434. 		}

    5435. 

  5435. #endif

    5436. 

  5436. 	}

    5437. 

  5437. 	if (holds_lock == 0)

    5438. 

  5438. 		SCTP_IPI_ADDR_RUNLOCK();

    5439. 

  5439. 	return (NULL);

    5440. 

  5440. }

    5441. 

  5441. 

    5442. 

  5442. static void

    5443. 

  5443. sctp_user_rcvd(struct sctp_tcb *stcb, uint32_t *freed_so_far, int hold_rlock,

    5444. 

  5444. 	       uint32_t rwnd_req)

    5445. 

  5445. {

    5446. 

  5446. 	/* User pulled some data, do we need a rwnd update? */

    5447. 

  5447. 	int r_unlocked = 0;

    5448. 

  5448. 	uint32_t dif, rwnd;

    5449. 

  5449. 	struct socket *so = NULL;

    5450. 

  5450. 

    5451. 

  5451. 	if (stcb == NULL)

    5452. 

  5452. 		return;

    5453. 

  5453. 

    5454. 

  5454. 	atomic_add_int(&stcb->asoc.refcnt, 1);

    5455. 

  5455. 

    5456. 

  5456. 	if (stcb->asoc.state & (SCTP_STATE_ABOUT_TO_BE_FREED |

    5457. 

  5457. 				SCTP_STATE_SHUTDOWN_RECEIVED |

    5458. 

  5458. 				SCTP_STATE_SHUTDOWN_ACK_SENT)) {

    5459. 

  5459. 		/* Pre-check If we are freeing no update */

    5460. 

  5460. 		goto no_lock;

    5461. 

  5461. 	}

    5462. 

  5462. 	SCTP_INP_INCR_REF(stcb->sctp_ep);

    5463. 

  5463. 	if ((stcb->sctp_ep->sctp_flags & SCTP_PCB_FLAGS_SOCKET_GONE) ||

    5464. 

  5464. 	    (stcb->sctp_ep->sctp_flags & SCTP_PCB_FLAGS_SOCKET_ALLGONE)) {

    5465. 

  5465. 		goto out;

    5466. 

  5466. 	}

    5467. 

  5467. 	so = stcb->sctp_socket;

    5468. 

  5468. 	if (so == NULL) {

    5469. 

  5469. 		goto out;

    5470. 

  5470. 	}

    5471. 

  5471. 	atomic_add_int(&stcb->freed_by_sorcv_sincelast, *freed_so_far);

    5472. 

  5472. 	/* Have you have freed enough to look */

    5473. 

  5473. 	*freed_so_far = 0;

    5474. 

  5474. 	/* Yep, its worth a look and the lock overhead */

    5475. 

  5475. 

    5476. 

  5476. 	/* Figure out what the rwnd would be */

    5477. 

  5477. 	rwnd = sctp_calc_rwnd(stcb, &stcb->asoc);

    5478. 

  5478. 	if (rwnd >= stcb->asoc.my_last_reported_rwnd) {

    5479. 

  5479. 		dif = rwnd - stcb->asoc.my_last_reported_rwnd;

    5480. 

  5480. 	} else {

    5481. 

  5481. 		dif = 0;

    5482. 

  5482. 	}

    5483. 

  5483. 	if (dif >= rwnd_req) {

    5484. 

  5484. 		if (hold_rlock) {

    5485. 

  5485. 			SCTP_INP_READ_UNLOCK(stcb->sctp_ep);

    5486. 

  5486. 			r_unlocked = 1;

    5487. 

  5487. 		}

    5488. 

  5488. 		if (stcb->asoc.state & SCTP_STATE_ABOUT_TO_BE_FREED) {

    5489. 

  5489. 			/*

    5490. 

  5490. 			 * One last check before we allow the guy possibly

    5491. 

  5491. 			 * to get in. There is a race, where the guy has not

    5492. 

  5492. 			 * reached the gate. In that case

    5493. 

  5493. 			 */

    5494. 

  5494. 			goto out;

    5495. 

  5495. 		}

    5496. 

  5496. 		SCTP_TCB_LOCK(stcb);

    5497. 

  5497. 		if (stcb->asoc.state & SCTP_STATE_ABOUT_TO_BE_FREED) {

    5498. 

  5498. 			/* No reports here */

    5499. 

  5499. 			SCTP_TCB_UNLOCK(stcb);

    5500. 

  5500. 			goto out;

    5501. 

  5501. 		}

    5502. 

  5502. 		SCTP_STAT_INCR(sctps_wu_sacks_sent);

    5503. 

  5503. 		sctp_send_sack(stcb, SCTP_SO_LOCKED);

    5504. 

  5504. 

    5505. 

  5505. 		sctp_chunk_output(stcb->sctp_ep, stcb,

    5506. 

  5506. 				  SCTP_OUTPUT_FROM_USR_RCVD, SCTP_SO_LOCKED);

    5507. 

  5507. 		/* make sure no timer is running */

    5508. 

  5508. 		sctp_timer_stop(SCTP_TIMER_TYPE_RECV, stcb->sctp_ep, stcb, NULL, SCTP_FROM_SCTPUTIL+SCTP_LOC_6);

    5509. 

  5509. 		SCTP_TCB_UNLOCK(stcb);

    5510. 

  5510. 	} else {

    5511. 

  5511. 		/* Update how much we have pending */

    5512. 

  5512. 		stcb->freed_by_sorcv_sincelast = dif;

    5513. 

  5513. 	}

    5514. 

  5514.  out:

    5515. 

  5515. 	if (so && r_unlocked && hold_rlock) {

    5516. 

  5516. 		SCTP_INP_READ_LOCK(stcb->sctp_ep);

    5517. 

  5517. 	}

    5518. 

  5518. 

    5519. 

  5519. 	SCTP_INP_DECR_REF(stcb->sctp_ep);

    5520. 

  5520.  no_lock:

    5521. 

  5521. 	atomic_add_int(&stcb->asoc.refcnt, -1);

    5522. 

  5522. 	return;

    5523. 

  5523. }

    5524. 

  5524. 

    5525. 

  5525. int

    5526. 

  5526. sctp_sorecvmsg(struct socket *so,

    5527. 

  5527.     struct uio *uio,

    5528. 

  5528.     struct mbuf **mp,

    5529. 

  5529.     struct sockaddr *from,

    5530. 

  5530.     int fromlen,

    5531. 

  5531.     int *msg_flags,

    5532. 

  5532.     struct sctp_sndrcvinfo *sinfo,

    5533. 

  5533.     int filling_sinfo)

    5534. 

  5534. {

    5535. 

  5535. 	/*

    5536. 

  5536. 	 * MSG flags we will look at MSG_DONTWAIT - non-blocking IO.

    5537. 

  5537. 	 * MSG_PEEK - Look don't touch :-D (only valid with OUT mbuf copy

    5538. 

  5538. 	 * mp=NULL thus uio is the copy method to userland) MSG_WAITALL - ??

    5539. 

  5539. 	 * On the way out we may send out any combination of:

    5540. 

  5540. 	 * MSG_NOTIFICATION MSG_EOR

    5541. 

  5541. 	 *

    5542. 

  5542. 	 */

    5543. 

  5543. 	struct sctp_inpcb *inp = NULL;

    5544. 

  5544. 	int my_len = 0;

    5545. 

  5545. 	int cp_len = 0, error = 0;

    5546. 

  5546. 	struct sctp_queued_to_read *control = NULL, *ctl = NULL, *nxt = NULL;

    5547. 

  5547. 	struct mbuf *m = NULL;

    5548. 

  5548. 	struct sctp_tcb *stcb = NULL;

    5549. 

  5549. 	int wakeup_read_socket = 0;

    5550. 

  5550. 	int freecnt_applied = 0;

    5551. 

  5551. 	int out_flags = 0, in_flags = 0;

    5552. 

  5552. 	int block_allowed = 1;

    5553. 

  5553. 	uint32_t freed_so_far = 0;

    5554. 

  5554. 	uint32_t copied_so_far = 0;

    5555. 

  5555. 	int in_eeor_mode = 0;

    5556. 

  5556. 	int no_rcv_needed = 0;

    5557. 

  5557. 	uint32_t rwnd_req = 0;

    5558. 

  5558. 	int hold_sblock = 0;

    5559. 

  5559. 	int hold_rlock = 0;

    5560. 

  5560. 	int slen = 0;

    5561. 

  5561. 	uint32_t held_length = 0;

    5562. 

  5562. #if defined(__FreeBSD__) && __FreeBSD_version >= 700000

    5563. 

  5563. 	int sockbuf_lock = 0;

    5564. 

  5564. #endif

    5565. 

  5565. 

    5566. 

  5566. 	if (uio == NULL) {

    5567. 

  5567. 		SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTPUTIL, EINVAL);

    5568. 

  5568. 		return (EINVAL);

    5569. 

  5569. 	}

    5570. 

  5570. 

    5571. 

  5571. 	if (msg_flags) {

    5572. 

  5572. 		in_flags = *msg_flags;

    5573. 

  5573. 		if (in_flags & MSG_PEEK)

    5574. 

  5574. 			SCTP_STAT_INCR(sctps_read_peeks);

    5575. 

  5575. 	} else {

    5576. 

  5576. 		in_flags = 0;

    5577. 

  5577. 	}

    5578. 

  5578. #if defined(__APPLE__)

    5579. 

  5579. #if defined(APPLE_SNOWLEOPARD) || defined(APPLE_LION)

    5580. 

  5580. 	slen = uio_resid(uio);

    5581. 

  5581. #else

    5582. 

  5582. 	slen = uio->uio_resid;

    5583. 

  5583. #endif

    5584. 

  5584. #else

    5585. 

  5585. 	slen = uio->uio_resid;

    5586. 

  5586. #endif

    5587. 

  5587. 

    5588. 

  5588. 	/* Pull in and set up our int flags */

    5589. 

  5589. 	if (in_flags & MSG_OOB) {

    5590. 

  5590. 		/* Out of band's NOT supported */

    5591. 

  5591. 		return (EOPNOTSUPP);

    5592. 

  5592. 	}

    5593. 

  5593. 	if ((in_flags & MSG_PEEK) && (mp != NULL)) {

    5594. 

  5594. 		SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTPUTIL, EINVAL);

    5595. 

  5595. 		return (EINVAL);

    5596. 

  5596. 	}

    5597. 

  5597. 	if ((in_flags & (MSG_DONTWAIT

    5598. 

  5598. #if defined(__FreeBSD__) && __FreeBSD_version > 500000

    5599. 

  5599. 			 | MSG_NBIO

    5600. 

  5600. #endif

    5601. 

  5601. 		     )) ||

    5602. 

  5602. 	    SCTP_SO_IS_NBIO(so)) {

    5603. 

  5603. 		block_allowed = 0;

    5604. 

  5604. 	}

    5605. 

  5605. 	/* setup the endpoint */

    5606. 

  5606. 	inp = (struct sctp_inpcb *)so->so_pcb;

    5607. 

  5607. 	if (inp == NULL) {

    5608. 

  5608. 		SCTP_LTRACE_ERR_RET(NULL, NULL, NULL, SCTP_FROM_SCTPUTIL, EFAULT);

    5609. 

  5609. 		return (EFAULT);

    5610. 

  5610. 	}

    5611. 

  5611. 	rwnd_req = (SCTP_SB_LIMIT_RCV(so) >> SCTP_RWND_HIWAT_SHIFT);

    5612. 

  5612. 	/* Must be at least a MTU's worth */

    5613. 

  5613. 	if (rwnd_req < SCTP_MIN_RWND)

    5614. 

  5614. 		rwnd_req = SCTP_MIN_RWND;

    5615. 

  5615. 	in_eeor_mode = sctp_is_feature_on(inp, SCTP_PCB_FLAGS_EXPLICIT_EOR);

    5616. 

  5616. 	if (SCTP_BASE_SYSCTL(sctp_logging_level) &SCTP_RECV_RWND_LOGGING_ENABLE) {

    5617. 

  5617. #if defined(__APPLE__)

    5618. 

  5618. #if defined(APPLE_SNOWLEOPARD) || defined(APPLE_LION)

    5619. 

  5619. 		sctp_misc_ints(SCTP_SORECV_ENTER,

    5620. 

  5620. 			       rwnd_req, in_eeor_mode, so->so_rcv.sb_cc, uio_resid(uio));

    5621. 

  5621. #else

    5622. 

  5622. 		sctp_misc_ints(SCTP_SORECV_ENTER,

    5623. 

  5623. 			       rwnd_req, in_eeor_mode, so->so_rcv.sb_cc, uio->uio_resid);

    5624. 

  5624. #endif

    5625. 

  5625. #else

    5626. 

  5626. 		sctp_misc_ints(SCTP_SORECV_ENTER,

    5627. 

  5627. 			       rwnd_req, in_eeor_mode, so->so_rcv.sb_cc, uio->uio_resid);

    5628. 

  5628. #endif

    5629. 

  5629. 	}

    5630. 

  5630. #if (defined(__FreeBSD__) && __FreeBSD_version < 700000) || defined(__Userspace__)

    5631. 

  5631. 	SOCKBUF_LOCK(&so->so_rcv);

    5632. 

  5632. 	hold_sblock = 1;

    5633. 

  5633. #endif

    5634. 

  5634. 	if (SCTP_BASE_SYSCTL(sctp_logging_level) &SCTP_RECV_RWND_LOGGING_ENABLE) {

    5635. 

  5635. #if defined(__APPLE__)

    5636. 

  5636. #if defined(APPLE_SNOWLEOPARD) || defined(APPLE_LION)

    5637. 

  5637. 		sctp_misc_ints(SCTP_SORECV_ENTERPL,

    5638. 

  5638. 			       rwnd_req, block_allowed, so->so_rcv.sb_cc, uio_resid(uio));

    5639. 

  5639. #else

    5640. 

  5640. 		sctp_misc_ints(SCTP_SORECV_ENTERPL,

    5641. 

  5641. 			       rwnd_req, block_allowed, so->so_rcv.sb_cc, uio->uio_resid);

    5642. 

  5642. #endif

    5643. 

  5643. #else

    5644. 

  5644. 		sctp_misc_ints(SCTP_SORECV_ENTERPL,

    5645. 

  5645. 			       rwnd_req, block_allowed, so->so_rcv.sb_cc, uio->uio_resid);

    5646. 

  5646. #endif

    5647. 

  5647. 	}

    5648. 

  5648. 

    5649. 

  5649. #if defined(__APPLE__)

    5650. 

  5650. 	error = sblock(&so->so_rcv, SBLOCKWAIT(in_flags));

    5651. 

  5651. #endif

    5652. 

  5652. 

    5653. 

  5653. #if defined(__FreeBSD__)

    5654. 

  5654. 	error = sblock(&so->so_rcv, (block_allowed ? SBL_WAIT : 0));

    5655. 

  5655. #if defined(__FreeBSD__) && __FreeBSD_version >= 700000

    5656. 

  5656. 	sockbuf_lock = 1;

    5657. 

  5657. #endif

    5658. 

  5658. #endif

    5659. 

  5659. 	if (error) {

    5660. 

  5660. 		goto release_unlocked;

    5661. 

  5661. 	}

    5662. 

  5662.  restart:

    5663. 

  5663. #if (defined(__FreeBSD__) && __FreeBSD_version < 700000) || defined(__Userspace__)

    5664. 

  5664. 	if (hold_sblock == 0) {

    5665. 

  5665. 		SOCKBUF_LOCK(&so->so_rcv);

    5666. 

  5666. 		hold_sblock = 1;

    5667. 

  5667. 	}

    5668. 

  5668. #endif

    5669. 

  5669. #if defined(__APPLE__)

    5670. 

  5670. 	sbunlock(&so->so_rcv, 1);

    5671. 

  5671. #endif

    5672. 

  5672. 

    5673. 

  5673. #if defined(__FreeBSD__) && __FreeBSD_version < 700000

    5674. 

  5674. 	sbunlock(&so->so_rcv);

    5675. 

  5675. #endif

    5676. 

  5676. 

    5677. 

  5677.  restart_nosblocks:

    5678. 

  5678. 	if (hold_sblock == 0) {

    5679. 

  5679. 		SOCKBUF_LOCK(&so->so_rcv);

    5680. 

  5680. 		hold_sblock = 1;

    5681. 

  5681. 	}

    5682. 

  5682. 	if ((inp->sctp_flags & SCTP_PCB_FLAGS_SOCKET_GONE) ||

    5683. 

  5683. 	    (inp->sctp_flags & SCTP_PCB_FLAGS_SOCKET_ALLGONE)) {

    5684. 

  5684. 		goto out;

    5685. 

  5685. 	}

    5686. 

  5686. #if (defined(__FreeBSD__) && __FreeBSD_version > 500000) || defined(__Windows__)

    5687. 

  5687. 	if ((so->so_rcv.sb_state & SBS_CANTRCVMORE) && (so->so_rcv.sb_cc == 0)) {

    5688. 

  5688. #else

    5689. 

  5689. 	if ((so->so_state & SS_CANTRCVMORE) && (so->so_rcv.sb_cc == 0)) {

    5690. 

  5690. #endif

    5691. 

  5691. 		if (so->so_error) {

    5692. 

  5692. 			error = so->so_error;

    5693. 

  5693. 			if ((in_flags & MSG_PEEK) == 0)

    5694. 

  5694. 				so->so_error = 0;

    5695. 

  5695. 			goto out;

    5696. 

  5696. 		} else {

    5697. 

  5697. 			if (so->so_rcv.sb_cc == 0) {

    5698. 

  5698. 				/* indicate EOF */

    5699. 

  5699. 				error = 0;

    5700. 

  5700. 				goto out;

    5701. 

  5701. 			}

    5702. 

  5702. 		}

    5703. 

  5703. 	}

    5704. 

  5704. 	if ((so->so_rcv.sb_cc <= held_length) && block_allowed) {

    5705. 

  5705. 		/* we need to wait for data */

    5706. 

  5706. 		if ((so->so_rcv.sb_cc == 0) &&

    5707. 

  5707. 		    ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) ||

    5708. 

  5708. 		     (inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL))) {

    5709. 

  5709. 			if ((inp->sctp_flags & SCTP_PCB_FLAGS_CONNECTED) == 0) {

    5710. 

  5710. 				/* For active open side clear flags for re-use

    5711. 

  5711. 				 * passive open is blocked by connect.

    5712. 

  5712. 				 */

    5713. 

  5713. 				if (inp->sctp_flags & SCTP_PCB_FLAGS_WAS_ABORTED) {

    5714. 

  5714. 					/* You were aborted, passive side always hits here */

    5715. 

  5715. 					SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTPUTIL, ECONNRESET);

    5716. 

  5716. 					error = ECONNRESET;

    5717. 

  5717. 				}

    5718. 

  5718. 				so->so_state &= ~(SS_ISCONNECTING |

    5719. 

  5719. 						  SS_ISDISCONNECTING |

    5720. 

  5720. 						  SS_ISCONFIRMING |

    5721. 

  5721. 						  SS_ISCONNECTED);

    5722. 

  5722. 				if (error == 0) {

    5723. 

  5723. 					if ((inp->sctp_flags & SCTP_PCB_FLAGS_WAS_CONNECTED) == 0) {

    5724. 

  5724. 						SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTPUTIL, ENOTCONN);

    5725. 

  5725. 						error = ENOTCONN;

    5726. 

  5726. 					}

    5727. 

  5727. 				}

    5728. 

  5728. 				goto out;

    5729. 

  5729. 			}

    5730. 

  5730. 		}

    5731. 

  5731. 		error = sbwait(&so->so_rcv);

    5732. 

  5732. 		if (error) {

    5733. 

  5733. 			goto out;

    5734. 

  5734. 		}

    5735. 

  5735. 		held_length = 0;

    5736. 

  5736. 		goto restart_nosblocks;

    5737. 

  5737. 	} else if (so->so_rcv.sb_cc == 0) {

    5738. 

  5738. 		if (so->so_error) {

    5739. 

  5739. 			error = so->so_error;

    5740. 

  5740. 			if ((in_flags & MSG_PEEK) == 0)

    5741. 

  5741. 				so->so_error = 0;

    5742. 

  5742. 		} else {

    5743. 

  5743. 			if ((inp->sctp_flags & SCTP_PCB_FLAGS_TCPTYPE) ||

    5744. 

  5744. 			    (inp->sctp_flags & SCTP_PCB_FLAGS_IN_TCPPOOL)) {

    5745. 

  5745. 				if ((inp->sctp_flags & SCTP_PCB_FLAGS_CONNECTED) == 0) {

    5746. 

  5746. 					/* For active open side clear flags for re-use

    5747. 

  5747. 					 * passive open is blocked by connect.

    5748. 

  5748. 					 */

    5749. 

  5749. 					if (inp->sctp_flags & SCTP_PCB_FLAGS_WAS_ABORTED) {

    5750. 

  5750. 						/* You were aborted, passive side always hits here */

    5751. 

  5751. 						SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTPUTIL, ECONNRESET);

    5752. 

  5752. 						error = ECONNRESET;

    5753. 

  5753. 					}

    5754. 

  5754. 					so->so_state &= ~(SS_ISCONNECTING |

    5755. 

  5755. 							  SS_ISDISCONNECTING |

    5756. 

  5756. 							  SS_ISCONFIRMING |

    5757. 

  5757. 							  SS_ISCONNECTED);

    5758. 

  5758. 					if (error == 0) {

    5759. 

  5759. 						if ((inp->sctp_flags & SCTP_PCB_FLAGS_WAS_CONNECTED) == 0) {

    5760. 

  5760. 							SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTPUTIL, ENOTCONN);

    5761. 

  5761. 							error = ENOTCONN;

    5762. 

  5762. 						}

    5763. 

  5763. 					}

    5764. 

  5764. 					goto out;

    5765. 

  5765. 				}

    5766. 

  5766. 			}

    5767. 

  5767. 			SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTPUTIL, EWOULDBLOCK);

    5768. 

  5768. 			error = EWOULDBLOCK;

    5769. 

  5769. 		}

    5770. 

  5770. 		goto out;

    5771. 

  5771. 	}

    5772. 

  5772. 	if (hold_sblock == 1) {

    5773. 

  5773. 		SOCKBUF_UNLOCK(&so->so_rcv);

    5774. 

  5774. 		hold_sblock = 0;

    5775. 

  5775. 	}

    5776. 

  5776. #if defined(__APPLE__)

    5777. 

  5777. 	error = sblock(&so->so_rcv, SBLOCKWAIT(in_flags));

    5778. 

  5778. #endif

    5779. 

  5779. #if defined(__FreeBSD__) && __FreeBSD_version < 700000

    5780. 

  5780. 	error = sblock(&so->so_rcv, (block_allowed ? M_WAITOK : 0));

    5781. 

  5781. #endif

    5782. 

  5782. 	/* we possibly have data we can read */

    5783. 

  5783. 	/*sa_ignore FREED_MEMORY*/

    5784. 

  5784. 	control = TAILQ_FIRST(&inp->read_queue);

    5785. 

  5785. 	if (control == NULL) {

    5786. 

  5786. 		/* This could be happening since

    5787. 

  5787. 		 * the appender did the increment but as not

    5788. 

  5788. 		 * yet did the tailq insert onto the read_queue

    5789. 

  5789. 		 */

    5790. 

  5790. 		if (hold_rlock == 0) {

    5791. 

  5791. 			SCTP_INP_READ_LOCK(inp);

    5792. 

  5792. 		}

    5793. 

  5793. 		control = TAILQ_FIRST(&inp->read_queue);

    5794. 

  5794. 		if ((control == NULL) && (so->so_rcv.sb_cc != 0)) {

    5795. 

  5795. #ifdef INVARIANTS

    5796. 

  5796. 			panic("Huh, its non zero and nothing on control?");

    5797. 

  5797. #endif

    5798. 

  5798. 			so->so_rcv.sb_cc = 0;

    5799. 

  5799. 		}

    5800. 

  5800. 		SCTP_INP_READ_UNLOCK(inp);

    5801. 

  5801. 		hold_rlock = 0;

    5802. 

  5802. 		goto restart;

    5803. 

  5803. 	}

    5804. 

  5804. 

    5805. 

  5805. 	if ((control->length == 0) &&

    5806. 

  5806. 	    (control->do_not_ref_stcb)) {

    5807. 

  5807. 		/* Clean up code for freeing assoc that left behind a pdapi..

    5808. 

  5808. 		 * maybe a peer in EEOR that just closed after sending and

    5809. 

  5809. 		 * never indicated a EOR.

    5810. 

  5810. 		 */

    5811. 

  5811. 		if (hold_rlock == 0) {

    5812. 

  5812. 			hold_rlock = 1;

    5813. 

  5813. 			SCTP_INP_READ_LOCK(inp);

    5814. 

  5814. 		}

    5815. 

  5815. 		control->held_length = 0;

    5816. 

  5816. 		if (control->data) {

    5817. 

  5817. 			/* Hmm there is data here .. fix */

    5818. 

  5818. 			struct mbuf *m_tmp;

    5819. 

  5819. 			int cnt = 0;

    5820. 

  5820. 			m_tmp = control->data;

    5821. 

  5821. 			while (m_tmp) {

    5822. 

  5822. 				cnt += SCTP_BUF_LEN(m_tmp);

    5823. 

  5823. 				if (SCTP_BUF_NEXT(m_tmp) == NULL) {

    5824. 

  5824. 					control->tail_mbuf = m_tmp;

    5825. 

  5825. 					control->end_added = 1;

    5826. 

  5826. 				}

    5827. 

  5827. 				m_tmp = SCTP_BUF_NEXT(m_tmp);

    5828. 

  5828. 			}

    5829. 

  5829. 			control->length = cnt;

    5830. 

  5830. 		} else {

    5831. 

  5831. 			/* remove it */

    5832. 

  5832. 			TAILQ_REMOVE(&inp->read_queue, control, next);

    5833. 

  5833. 			/* Add back any hiddend data */

    5834. 

  5834. 			sctp_free_remote_addr(control->whoFrom);

    5835. 

  5835. 			sctp_free_a_readq(stcb, control);

    5836. 

  5836. 		}

    5837. 

  5837. 		if (hold_rlock) {

    5838. 

  5838. 			hold_rlock = 0;

    5839. 

  5839. 			SCTP_INP_READ_UNLOCK(inp);

    5840. 

  5840. 		}

    5841. 

  5841. 		goto restart;

    5842. 

  5842. 	}

    5843. 

  5843. 	if ((control->length == 0) &&

    5844. 

  5844. 	    (control->end_added == 1)) {

    5845. 

  5845. 		/* Do we also need to check for (control->pdapi_aborted == 1)? */

    5846. 

  5846. 		if (hold_rlock == 0) {

    5847. 

  5847. 			hold_rlock = 1;

    5848. 

  5848. 			SCTP_INP_READ_LOCK(inp);

    5849. 

  5849. 		}

    5850. 

  5850. 		TAILQ_REMOVE(&inp->read_queue, control, next);

    5851. 

  5851. 		if (control->data) {

    5852. 

  5852. #ifdef INVARIANTS

    5853. 

  5853. 			panic("control->data not null but control->length == 0");

    5854. 

  5854. #else

    5855. 

  5855. 			SCTP_PRINTF("Strange, data left in the control buffer. Cleaning up.\n");

    5856. 

  5856. 			sctp_m_freem(control->data);

    5857. 

  5857. 			control->data = NULL;

    5858. 

  5858. #endif

    5859. 

  5859. 		}

    5860. 

  5860. 		if (control->aux_data) {

    5861. 

  5861. 			sctp_m_free (control->aux_data);

    5862. 

  5862. 			control->aux_data = NULL;

    5863. 

  5863. 		}

    5864. 

  5864. 		sctp_free_remote_addr(control->whoFrom);

    5865. 

  5865. 		sctp_free_a_readq(stcb, control);

    5866. 

  5866. 		if (hold_rlock) {

    5867. 

  5867. 			hold_rlock = 0;

    5868. 

  5868. 			SCTP_INP_READ_UNLOCK(inp);

    5869. 

  5869. 		}

    5870. 

  5870. 		goto restart;

    5871. 

  5871. 	}

    5872. 

  5872. 	if (control->length == 0) {

    5873. 

  5873. 		if ((sctp_is_feature_on(inp, SCTP_PCB_FLAGS_FRAG_INTERLEAVE)) &&

    5874. 

  5874. 		    (filling_sinfo)) {

    5875. 

  5875. 			/* find a more suitable one then this */

    5876. 

  5876. 			ctl = TAILQ_NEXT(control, next);

    5877. 

  5877. 			while (ctl) {

    5878. 

  5878. 				if ((ctl->stcb != control->stcb) && (ctl->length) &&

    5879. 

  5879. 				    (ctl->some_taken ||

    5880. 

  5880. 				     (ctl->spec_flags & M_NOTIFICATION) ||

    5881. 

  5881. 				     ((ctl->do_not_ref_stcb == 0) &&

    5882. 

  5882. 				      (ctl->stcb->asoc.strmin[ctl->sinfo_stream].delivery_started == 0)))

    5883. 

  5883. 					) {

    5884. 

  5884. 					/*-

    5885. 

  5885. 					 * If we have a different TCB next, and there is data

    5886. 

  5886. 					 * present. If we have already taken some (pdapi), OR we can

    5887. 

  5887. 					 * ref the tcb and no delivery as started on this stream, we

    5888. 

  5888. 					 * take it. Note we allow a notification on a different

    5889. 

  5889. 					 * assoc to be delivered..

    5890. 

  5890. 					 */

    5891. 

  5891. 					control = ctl;

    5892. 

  5892. 					goto found_one;

    5893. 

  5893. 				} else if ((sctp_is_feature_on(inp, SCTP_PCB_FLAGS_INTERLEAVE_STRMS)) &&

    5894. 

  5894. 					   (ctl->length) &&

    5895. 

  5895. 					   ((ctl->some_taken) ||

    5896. 

  5896. 					    ((ctl->do_not_ref_stcb == 0) &&

    5897. 

  5897. 					     ((ctl->spec_flags & M_NOTIFICATION) == 0) &&

    5898. 

  5898. 					     (ctl->stcb->asoc.strmin[ctl->sinfo_stream].delivery_started == 0)))) {

    5899. 

  5899. 					/*-

    5900. 

  5900. 					 * If we have the same tcb, and there is data present, and we

    5901. 

  5901. 					 * have the strm interleave feature present. Then if we have

    5902. 

  5902. 					 * taken some (pdapi) or we can refer to tht tcb AND we have

    5903. 

  5903. 					 * not started a delivery for this stream, we can take it.

    5904. 

  5904. 					 * Note we do NOT allow a notificaiton on the same assoc to

    5905. 

  5905. 					 * be delivered.

    5906. 

  5906. 					 */

    5907. 

  5907. 					control = ctl;

    5908. 

  5908. 					goto found_one;

    5909. 

  5909. 				}

    5910. 

  5910. 				ctl = TAILQ_NEXT(ctl, next);

    5911. 

  5911. 			}

    5912. 

  5912. 		}

    5913. 

  5913. 		/*

    5914. 

  5914. 		 * if we reach here, not suitable replacement is available

    5915. 

  5915. 		 * <or> fragment interleave is NOT on. So stuff the sb_cc

    5916. 

  5916. 		 * into the our held count, and its time to sleep again.

    5917. 

  5917. 		 */

    5918. 

  5918. 		held_length = so->so_rcv.sb_cc;

    5919. 

  5919. 		control->held_length = so->so_rcv.sb_cc;

    5920. 

  5920. 		goto restart;

    5921. 

  5921. 	}

    5922. 

  5922. 	/* Clear the held length since there is something to read */

    5923. 

  5923. 	control->held_length = 0;

    5924. 

  5924. 	if (hold_rlock) {

    5925. 

  5925. 		SCTP_INP_READ_UNLOCK(inp);

    5926. 

  5926. 		hold_rlock = 0;

    5927. 

  5927. 	}

    5928. 

  5928.  found_one:

    5929. 

  5929. 	/*

    5930. 

  5930. 	 * If we reach here, control has a some data for us to read off.

    5931. 

  5931. 	 * Note that stcb COULD be NULL.

    5932. 

  5932. 	 */

    5933. 

  5933. 	control->some_taken++;

    5934. 

  5934. 	if (hold_sblock) {

    5935. 

  5935. 		SOCKBUF_UNLOCK(&so->so_rcv);

    5936. 

  5936. 		hold_sblock = 0;

    5937. 

  5937. 	}

    5938. 

  5938. 	stcb = control->stcb;

    5939. 

  5939. 	if (stcb) {

    5940. 

  5940. 		if ((control->do_not_ref_stcb == 0) &&

    5941. 

  5941. 		    (stcb->asoc.state & SCTP_STATE_ABOUT_TO_BE_FREED)) {

    5942. 

  5942. 			if (freecnt_applied == 0)

    5943. 

  5943. 				stcb = NULL;

    5944. 

  5944. 		} else if (control->do_not_ref_stcb == 0) {

    5945. 

  5945. 			/* you can't free it on me please */

    5946. 

  5946. 			/*

    5947. 

  5947. 			 * The lock on the socket buffer protects us so the

    5948. 

  5948. 			 * free code will stop. But since we used the socketbuf

    5949. 

  5949. 			 * lock and the sender uses the tcb_lock to increment,

    5950. 

  5950. 			 * we need to use the atomic add to the refcnt

    5951. 

  5951. 			 */

    5952. 

  5952. 			if (freecnt_applied) {

    5953. 

  5953. #ifdef INVARIANTS

    5954. 

  5954. 				panic("refcnt already incremented");

    5955. 

  5955. #else

    5956. 

  5956. 				SCTP_PRINTF("refcnt already incremented?\n");

    5957. 

  5957. #endif

    5958. 

  5958. 			} else {

    5959. 

  5959. 				atomic_add_int(&stcb->asoc.refcnt, 1);

    5960. 

  5960. 				freecnt_applied = 1;

    5961. 

  5961. 			}

    5962. 

  5962. 			/*

    5963. 

  5963. 			 * Setup to remember how much we have not yet told

    5964. 

  5964. 			 * the peer our rwnd has opened up. Note we grab

    5965. 

  5965. 			 * the value from the tcb from last time.

    5966. 

  5966. 			 * Note too that sack sending clears this when a sack

    5967. 

  5967. 			 * is sent, which is fine. Once we hit the rwnd_req,

    5968. 

  5968. 			 * we then will go to the sctp_user_rcvd() that will

    5969. 

  5969. 			 * not lock until it KNOWs it MUST send a WUP-SACK.

    5970. 

  5970. 			 */

    5971. 

  5971. 			freed_so_far = stcb->freed_by_sorcv_sincelast;

    5972. 

  5972. 			stcb->freed_by_sorcv_sincelast = 0;

    5973. 

  5973. 		}

    5974. 

  5974.         }

    5975. 

  5975. 	if (stcb &&

    5976. 

  5976. 	    ((control->spec_flags & M_NOTIFICATION) == 0) &&

    5977. 

  5977. 	    control->do_not_ref_stcb == 0) {

    5978. 

  5978. 		stcb->asoc.strmin[control->sinfo_stream].delivery_started = 1;

    5979. 

  5979. 	}

    5980. 

  5980. 

    5981. 

  5981. 	/* First lets get off the sinfo and sockaddr info */

    5982. 

  5982. 	if ((sinfo) && filling_sinfo) {

    5983. 

  5983. 		memcpy(sinfo, control, sizeof(struct sctp_nonpad_sndrcvinfo));

    5984. 

  5984. 		nxt = TAILQ_NEXT(control, next);

    5985. 

  5985. 		if (sctp_is_feature_on(inp, SCTP_PCB_FLAGS_EXT_RCVINFO) ||

    5986. 

  5986. 		    sctp_is_feature_on(inp, SCTP_PCB_FLAGS_RECVNXTINFO)) {

    5987. 

  5987. 			struct sctp_extrcvinfo *s_extra;

    5988. 

  5988. 			s_extra = (struct sctp_extrcvinfo *)sinfo;

    5989. 

  5989. 			if ((nxt) &&

    5990. 

  5990. 			    (nxt->length)) {

    5991. 

  5991. 				s_extra->sreinfo_next_flags = SCTP_NEXT_MSG_AVAIL;

    5992. 

  5992. 				if (nxt->sinfo_flags & SCTP_UNORDERED) {

    5993. 

  5993. 					s_extra->sreinfo_next_flags |= SCTP_NEXT_MSG_IS_UNORDERED;

    5994. 

  5994. 				}

    5995. 

  5995. 				if (nxt->spec_flags & M_NOTIFICATION) {

    5996. 

  5996. 					s_extra->sreinfo_next_flags |= SCTP_NEXT_MSG_IS_NOTIFICATION;

    5997. 

  5997. 				}

    5998. 

  5998. 				s_extra->sreinfo_next_aid = nxt->sinfo_assoc_id;

    5999. 

  5999. 				s_extra->sreinfo_next_length = nxt->length;

    6000. 

  6000. 				s_extra->sreinfo_next_ppid = nxt->sinfo_ppid;

    6001. 

  6001. 				s_extra->sreinfo_next_stream = nxt->sinfo_stream;

    6002. 

  6002. 				if (nxt->tail_mbuf != NULL) {

    6003. 

  6003. 					if (nxt->end_added) {

    6004. 

  6004. 						s_extra->sreinfo_next_flags |= SCTP_NEXT_MSG_ISCOMPLETE;

    6005. 

  6005. 					}

    6006. 

  6006. 				}

    6007. 

  6007. 			} else {

    6008. 

  6008. 				/* we explicitly 0 this, since the memcpy got

    6009. 

  6009. 				 * some other things beyond the older sinfo_

    6010. 

  6010. 				 * that is on the control's structure :-D

    6011. 

  6011. 				 */

    6012. 

  6012. 				nxt = NULL;

    6013. 

  6013. 				s_extra->sreinfo_next_flags = SCTP_NO_NEXT_MSG;

    6014. 

  6014. 				s_extra->sreinfo_next_aid = 0;

    6015. 

  6015. 				s_extra->sreinfo_next_length = 0;

    6016. 

  6016. 				s_extra->sreinfo_next_ppid = 0;

    6017. 

  6017. 				s_extra->sreinfo_next_stream = 0;

    6018. 

  6018. 			}

    6019. 

  6019. 		}

    6020. 

  6020. 		/*

    6021. 

  6021. 		 * update off the real current cum-ack, if we have an stcb.

    6022. 

  6022. 		 */

    6023. 

  6023. 		if ((control->do_not_ref_stcb == 0) && stcb)

    6024. 

  6024. 			sinfo->sinfo_cumtsn = stcb->asoc.cumulative_tsn;

    6025. 

  6025. 		/*

    6026. 

  6026. 		 * mask off the high bits, we keep the actual chunk bits in

    6027. 

  6027. 		 * there.

    6028. 

  6028. 		 */

    6029. 

  6029. 		sinfo->sinfo_flags &= 0x00ff;

    6030. 

  6030. 		if ((control->sinfo_flags >> 8) & SCTP_DATA_UNORDERED) {

    6031. 

  6031. 			sinfo->sinfo_flags |= SCTP_UNORDERED;

    6032. 

  6032. 		}

    6033. 

  6033. 	}

    6034. 

  6034. #ifdef SCTP_ASOCLOG_OF_TSNS

    6035. 

  6035. 	{

    6036. 

  6036. 		int index, newindex;

    6037. 

  6037. 		struct sctp_pcbtsn_rlog *entry;

    6038. 

  6038. 		do {

    6039. 

  6039. 			index = inp->readlog_index;

    6040. 

  6040. 			newindex = index + 1;

    6041. 

  6041. 			if (newindex >= SCTP_READ_LOG_SIZE) {

    6042. 

  6042. 				newindex = 0;

    6043. 

  6043. 			}

    6044. 

  6044. 		} while (atomic_cmpset_int(&inp->readlog_index, index, newindex) == 0);

    6045. 

  6045. 		entry = &inp->readlog[index];

    6046. 

  6046. 		entry->vtag = control->sinfo_assoc_id;

    6047. 

  6047. 		entry->strm = control->sinfo_stream;

    6048. 

  6048. 		entry->seq = control->sinfo_ssn;

    6049. 

  6049. 		entry->sz = control->length;

    6050. 

  6050. 		entry->flgs = control->sinfo_flags;

    6051. 

  6051. 	}

    6052. 

  6052. #endif

    6053. 

  6053. 	if (fromlen && from) {

    6054. 

  6054. #if !defined(__Windows__) && !defined(__Userspace_os_Linux) && !defined(__Userspace_os_Windows)

    6055. 

  6055. 		cp_len = min((size_t)fromlen, (size_t)control->whoFrom->ro._l_addr.sa.sa_len);

    6056. 

  6056. #endif

    6057. 

  6057. 		switch (control->whoFrom->ro._l_addr.sa.sa_family) {

    6058. 

  6058. #ifdef INET6

    6059. 

  6059. 			case AF_INET6:

    6060. 

  6060. #if defined(__Windows__) || defined(__Userspace_os_Linux) || defined(__Userspace_os_Windows)

    6061. 

  6061. 				cp_len = min((size_t)fromlen, sizeof(struct sockaddr_in6));

    6062. 

  6062. #endif

    6063. 

  6063. 				((struct sockaddr_in6 *)from)->sin6_port = control->port_from;

    6064. 

  6064. 				break;

    6065. 

  6065. #endif

    6066. 

  6066. #ifdef INET

    6067. 

  6067. 			case AF_INET:

    6068. 

  6068. #if defined(__Windows__) || defined(__Userspace_os_Linux) || defined(__Userspace_os_Windows)

    6069. 

  6069. 				cp_len = min((size_t)fromlen, sizeof(struct sockaddr_in));

    6070. 

  6070. #endif

    6071. 

  6071. 				((struct sockaddr_in *)from)->sin_port = control->port_from;

    6072. 

  6072. 				break;

    6073. 

  6073. #endif

    6074. 

  6074. 			default:

    6075. 

  6075. #if defined(__Windows__) || defined(__Userspace_os_Linux) || defined(__Userspace_os_Windows)

    6076. 

  6076. 				cp_len = min((size_t)fromlen, sizeof(struct sockaddr));

    6077. 

  6077. #endif

    6078. 

  6078. 				break;

    6079. 

  6079. 		}

    6080. 

  6080. 		memcpy(from, &control->whoFrom->ro._l_addr, cp_len);

    6081. 

  6081. 

    6082. 

  6082. #if defined(INET) && defined(INET6)

    6083. 

  6083. 		if ((sctp_is_feature_on(inp,SCTP_PCB_FLAGS_NEEDS_MAPPED_V4)) &&

    6084. 

  6084. 		    (from->sa_family == AF_INET) &&

    6085. 

  6085. 		    ((size_t)fromlen >= sizeof(struct sockaddr_in6))) {

    6086. 

  6086. 			struct sockaddr_in *sin;

    6087. 

  6087. 			struct sockaddr_in6 sin6;

    6088. 

  6088. 

    6089. 

  6089. 			sin = (struct sockaddr_in *)from;

    6090. 

  6090. 			bzero(&sin6, sizeof(sin6));

    6091. 

  6091. 			sin6.sin6_family = AF_INET6;

    6092. 

  6092. #if !defined(__Windows__) && !defined (__Userspace_os_Linux) && !defined(__Userspace_os_Windows)

    6093. 

  6093. 			sin6.sin6_len = sizeof(struct sockaddr_in6);

    6094. 

  6094. #endif

    6095. 

  6095. #if defined(__Userspace_os_FreeBSD) || defined(__Userspace_os_Darwin) || defined(__Userspace_os_Windows)

    6096. 

  6096. 			((uint32_t *)&sin6.sin6_addr)[2] = htonl(0xffff);

    6097. 

  6097. 			bcopy(&sin->sin_addr,

    6098. 

  6098. 			      &(((uint32_t *)&sin6.sin6_addr)[3]),

    6099. 

  6099. 			      sizeof(uint32_t));

    6100. 

  6100. #elif defined(__Windows__)

    6101. 

  6101. 			((uint32_t *)&sin6.sin6_addr)[2] = htonl(0xffff);

    6102. 

  6102. 			bcopy(&sin->sin_addr,

    6103. 

  6103. 			      &((uint32_t *)&sin6.sin6_addr)[3],

    6104. 

  6104. 			      sizeof(uint32_t));

    6105. 

  6105. #else

    6106. 

  6106. 			sin6.sin6_addr.s6_addr32[2] = htonl(0xffff);

    6107. 

  6107. 			bcopy(&sin->sin_addr,

    6108. 

  6108. 			      &sin6.sin6_addr.s6_addr32[3],

    6109. 

  6109. 			      sizeof(sin6.sin6_addr.s6_addr32[3]));

    6110. 

  6110. #endif

    6111. 

  6111. 			sin6.sin6_port = sin->sin_port;

    6112. 

  6112. 			memcpy(from, &sin6, sizeof(struct sockaddr_in6));

    6113. 

  6113. 		}

    6114. 

  6114. #endif

    6115. 

  6115. #if defined(SCTP_EMBEDDED_V6_SCOPE)

    6116. 

  6116. #if defined(INET6)

    6117. 

  6117. 		{

    6118. 

  6118. 			struct sockaddr_in6 lsa6, *from6;

    6119. 

  6119. 

    6120. 

  6120. 			from6 = (struct sockaddr_in6 *)from;

    6121. 

  6121. 			sctp_recover_scope_mac(from6, (&lsa6));

    6122. 

  6122. 		}

    6123. 

  6123. #endif

    6124. 

  6124. #endif

    6125. 

  6125. 	}

    6126. 

  6126. 	/* now copy out what data we can */

    6127. 

  6127. 	if (mp == NULL) {

    6128. 

  6128. 		/* copy out each mbuf in the chain up to length */

    6129. 

  6129. 	get_more_data:

    6130. 

  6130. 		m = control->data;

    6131. 

  6131. 		while (m) {

    6132. 

  6132. 			/* Move out all we can */

    6133. 

  6133. #if defined(__APPLE__)

    6134. 

  6134. #if defined(APPLE_SNOWLEOPARD) || defined(APPLE_LION)

    6135. 

  6135. 			cp_len = (int)uio_resid(uio);

    6136. 

  6136. #else

    6137. 

  6137. 			cp_len = (int)uio->uio_resid;

    6138. 

  6138. #endif

    6139. 

  6139. #else

    6140. 

  6140. 			cp_len = (int)uio->uio_resid;

    6141. 

  6141. #endif

    6142. 

  6142. 			my_len = (int)SCTP_BUF_LEN(m);

    6143. 

  6143. 			if (cp_len > my_len) {

    6144. 

  6144. 				/* not enough in this buf */

    6145. 

  6145. 				cp_len = my_len;

    6146. 

  6146. 			}

    6147. 

  6147. 			if (hold_rlock) {

    6148. 

  6148. 				SCTP_INP_READ_UNLOCK(inp);

    6149. 

  6149. 				hold_rlock = 0;

    6150. 

  6150. 			}

    6151. 

  6151. #if defined(__APPLE__)

    6152. 

  6152. 			SCTP_SOCKET_UNLOCK(so, 0);

    6153. 

  6153. #endif

    6154. 

  6154. 			if (cp_len > 0)

    6155. 

  6155. 				error = uiomove(mtod(m, char *), cp_len, uio);

    6156. 

  6156. #if defined(__APPLE__)

    6157. 

  6157. 			SCTP_SOCKET_LOCK(so, 0);

    6158. 

  6158. #endif

    6159. 

  6159. 			/* re-read */

    6160. 

  6160. 			if (inp->sctp_flags & SCTP_PCB_FLAGS_SOCKET_GONE) {

    6161. 

  6161. 				goto release;

    6162. 

  6162. 			}

    6163. 

  6163. 

    6164. 

  6164. 			if ((control->do_not_ref_stcb == 0) && stcb &&

    6165. 

  6165. 			    stcb->asoc.state & SCTP_STATE_ABOUT_TO_BE_FREED) {

    6166. 

  6166. 				no_rcv_needed = 1;

    6167. 

  6167. 			}

    6168. 

  6168. 			if (error) {

    6169. 

  6169. 				/* error we are out of here */

    6170. 

  6170. 				goto release;

    6171. 

  6171. 			}

    6172. 

  6172. 			if ((SCTP_BUF_NEXT(m) == NULL) &&

    6173. 

  6173. 			    (cp_len >= SCTP_BUF_LEN(m)) &&

    6174. 

  6174. 			    ((control->end_added == 0) ||

    6175. 

  6175. 			     (control->end_added &&

    6176. 

  6176. 			      (TAILQ_NEXT(control, next) == NULL)))

    6177. 

  6177. 				) {

    6178. 

  6178. 				SCTP_INP_READ_LOCK(inp);

    6179. 

  6179. 				hold_rlock = 1;

    6180. 

  6180. 			}

    6181. 

  6181. 			if (cp_len == SCTP_BUF_LEN(m)) {

    6182. 

  6182. 				if ((SCTP_BUF_NEXT(m)== NULL) &&

    6183. 

  6183. 				    (control->end_added)) {

    6184. 

  6184. 					out_flags |= MSG_EOR;

    6185. 

  6185. 					if ((control->do_not_ref_stcb == 0)  &&

    6186. 

  6186. 					    (control->stcb != NULL) &&

    6187. 

  6187. 					    ((control->spec_flags & M_NOTIFICATION) == 0))

    6188. 

  6188. 						control->stcb->asoc.strmin[control->sinfo_stream].delivery_started = 0;

    6189. 

  6189. 				}

    6190. 

  6190. 				if (control->spec_flags & M_NOTIFICATION) {

    6191. 

  6191. 					out_flags |= MSG_NOTIFICATION;

    6192. 

  6192. 				}

    6193. 

  6193. 				/* we ate up the mbuf */

    6194. 

  6194. 				if (in_flags & MSG_PEEK) {

    6195. 

  6195. 					/* just looking */

    6196. 

  6196. 					m = SCTP_BUF_NEXT(m);

    6197. 

  6197. 					copied_so_far += cp_len;

    6198. 

  6198. 				} else {

    6199. 

  6199. 					/* dispose of the mbuf */

    6200. 

  6200. 					if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_SB_LOGGING_ENABLE) {

    6201. 

  6201. 						sctp_sblog(&so->so_rcv,

    6202. 

  6202. 						   control->do_not_ref_stcb?NULL:stcb, SCTP_LOG_SBFREE, SCTP_BUF_LEN(m));

    6203. 

  6203. 					}

    6204. 

  6204. 					sctp_sbfree(control, stcb, &so->so_rcv, m);

    6205. 

  6205. 					if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_SB_LOGGING_ENABLE) {

    6206. 

  6206. 						sctp_sblog(&so->so_rcv,

    6207. 

  6207. 						   control->do_not_ref_stcb?NULL:stcb, SCTP_LOG_SBRESULT, 0);

    6208. 

  6208. 					}

    6209. 

  6209. 					copied_so_far += cp_len;

    6210. 

  6210. 					freed_so_far += cp_len;

    6211. 

  6211. 					freed_so_far += MSIZE;

    6212. 

  6212. 					atomic_subtract_int(&control->length, cp_len);

    6213. 

  6213. 					control->data = sctp_m_free(m);

    6214. 

  6214. 					m = control->data;

    6215. 

  6215. 					/* been through it all, must hold sb lock ok to null tail */

    6216. 

  6216. 					if (control->data == NULL) {

    6217. 

  6217. #ifdef INVARIANTS

    6218. 

  6218. #if !defined(__APPLE__)

    6219. 

  6219. 						if ((control->end_added == 0) ||

    6220. 

  6220. 						    (TAILQ_NEXT(control, next) == NULL)) {

    6221. 

  6221. 							/* If the end is not added, OR the

    6222. 

  6222. 							 * next is NOT null we MUST have the lock.

    6223. 

  6223. 							 */

    6224. 

  6224. 							if (mtx_owned(&inp->inp_rdata_mtx) == 0) {

    6225. 

  6225. 								panic("Hmm we don't own the lock?");

    6226. 

  6226. 							}

    6227. 

  6227. 						}

    6228. 

  6228. #endif

    6229. 

  6229. #endif

    6230. 

  6230. 						control->tail_mbuf = NULL;

    6231. 

  6231. #ifdef INVARIANTS

    6232. 

  6232. 						if ((control->end_added) && ((out_flags & MSG_EOR) == 0)) {

    6233. 

  6233. 							panic("end_added, nothing left and no MSG_EOR");

    6234. 

  6234. 						}

    6235. 

  6235. #endif

    6236. 

  6236. 					}

    6237. 

  6237. 				}

    6238. 

  6238. 			} else {

    6239. 

  6239. 				/* Do we need to trim the mbuf? */

    6240. 

  6240. 				if (control->spec_flags & M_NOTIFICATION) {

    6241. 

  6241. 					out_flags |= MSG_NOTIFICATION;

    6242. 

  6242. 				}

    6243. 

  6243. 				if ((in_flags & MSG_PEEK) == 0) {

    6244. 

  6244. 					SCTP_BUF_RESV_UF(m, cp_len);

    6245. 

  6245. 					SCTP_BUF_LEN(m) -= cp_len;

    6246. 

  6246. 					if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_SB_LOGGING_ENABLE) {

    6247. 

  6247. 						sctp_sblog(&so->so_rcv, control->do_not_ref_stcb?NULL:stcb, SCTP_LOG_SBFREE, cp_len);

    6248. 

  6248. 					}

    6249. 

  6249. 					atomic_subtract_int(&so->so_rcv.sb_cc, cp_len);

    6250. 

  6250. 					if ((control->do_not_ref_stcb == 0) &&

    6251. 

  6251. 					    stcb) {

    6252. 

  6252. 						atomic_subtract_int(&stcb->asoc.sb_cc, cp_len);

    6253. 

  6253. 					}

    6254. 

  6254. 					copied_so_far += cp_len;

    6255. 

  6255. 					freed_so_far += cp_len;

    6256. 

  6256. 					freed_so_far += MSIZE;

    6257. 

  6257. 					if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_SB_LOGGING_ENABLE) {

    6258. 

  6258. 						sctp_sblog(&so->so_rcv, control->do_not_ref_stcb?NULL:stcb,

    6259. 

  6259. 							   SCTP_LOG_SBRESULT, 0);

    6260. 

  6260. 					}

    6261. 

  6261. 					atomic_subtract_int(&control->length, cp_len);

    6262. 

  6262. 				} else {

    6263. 

  6263. 					copied_so_far += cp_len;

    6264. 

  6264. 				}

    6265. 

  6265. 			}

    6266. 

  6266. #if defined(__APPLE__)

    6267. 

  6267. #if defined(APPLE_SNOWLEOPARD) || defined(APPLE_LION)

    6268. 

  6268. 			if ((out_flags & MSG_EOR) || (uio_resid(uio) == 0)) {

    6269. 

  6269. #else

    6270. 

  6270. 			if ((out_flags & MSG_EOR) || (uio->uio_resid == 0)) {

    6271. 

  6271. #endif

    6272. 

  6272. #else

    6273. 

  6273. 			if ((out_flags & MSG_EOR) || (uio->uio_resid == 0)) {

    6274. 

  6274. #endif

    6275. 

  6275. 				break;

    6276. 

  6276. 			}

    6277. 

  6277. 			if (((stcb) && (in_flags & MSG_PEEK) == 0) &&

    6278. 

  6278. 			    (control->do_not_ref_stcb == 0) &&

    6279. 

  6279. 			    (freed_so_far >= rwnd_req)) {

    6280. 

  6280. 				sctp_user_rcvd(stcb, &freed_so_far, hold_rlock, rwnd_req);

    6281. 

  6281. 			}

    6282. 

  6282. 		} /* end while(m) */

    6283. 

  6283. 		/*

    6284. 

  6284. 		 * At this point we have looked at it all and we either have

    6285. 

  6285. 		 * a MSG_EOR/or read all the user wants... <OR>

    6286. 

  6286. 		 * control->length == 0.

    6287. 

  6287. 		 */

    6288. 

  6288. 		if ((out_flags & MSG_EOR) && ((in_flags & MSG_PEEK) == 0)) {

    6289. 

  6289. 			/* we are done with this control */

    6290. 

  6290. 			if (control->length == 0) {

    6291. 

  6291. 				if (control->data) {

    6292. 

  6292. #ifdef INVARIANTS

    6293. 

  6293. 					panic("control->data not null at read eor?");

    6294. 

  6294. #else

    6295. 

  6295. 					SCTP_PRINTF("Strange, data left in the control buffer .. invarients would panic?\n");

    6296. 

  6296. 					sctp_m_freem(control->data);

    6297. 

  6297. 					control->data = NULL;

    6298. 

  6298. #endif

    6299. 

  6299. 				}

    6300. 

  6300. 			done_with_control:

    6301. 

  6301. 				if (TAILQ_NEXT(control, next) == NULL) {

    6302. 

  6302. 					/* If we don't have a next we need a

    6303. 

  6303. 					 * lock, if there is a next interrupt

    6304. 

  6304. 					 * is filling ahead of us and we don't

    6305. 

  6305. 					 * need a lock to remove this guy

    6306. 

  6306. 					 * (which is the head of the queue).

    6307. 

  6307. 					 */

    6308. 

  6308. 					if (hold_rlock == 0) {

    6309. 

  6309. 						SCTP_INP_READ_LOCK(inp);

    6310. 

  6310. 						hold_rlock = 1;

    6311. 

  6311. 					}

    6312. 

  6312. 				}

    6313. 

  6313. 				TAILQ_REMOVE(&inp->read_queue, control, next);

    6314. 

  6314. 				/* Add back any hiddend data */

    6315. 

  6315. 				if (control->held_length) {

    6316. 

  6316. 					held_length = 0;

    6317. 

  6317. 					control->held_length = 0;

    6318. 

  6318. 					wakeup_read_socket = 1;

    6319. 

  6319. 				}

    6320. 

  6320. 				if (control->aux_data) {

    6321. 

  6321. 					sctp_m_free (control->aux_data);

    6322. 

  6322. 					control->aux_data = NULL;

    6323. 

  6323. 				}

    6324. 

  6324. 				no_rcv_needed = control->do_not_ref_stcb;

    6325. 

  6325. 				sctp_free_remote_addr(control->whoFrom);

    6326. 

  6326. 				control->data = NULL;

    6327. 

  6327. 				sctp_free_a_readq(stcb, control);

    6328. 

  6328. 				control = NULL;

    6329. 

  6329. 				if ((freed_so_far >= rwnd_req) &&

    6330. 

  6330. 				    (no_rcv_needed == 0))

    6331. 

  6331. 					sctp_user_rcvd(stcb, &freed_so_far, hold_rlock, rwnd_req);

    6332. 

  6332. 

    6333. 

  6333. 			} else {

    6334. 

  6334. 				/*

    6335. 

  6335. 				 * The user did not read all of this

    6336. 

  6336. 				 * message, turn off the returned MSG_EOR

    6337. 

  6337. 				 * since we are leaving more behind on the

    6338. 

  6338. 				 * control to read.

    6339. 

  6339. 				 */

    6340. 

  6340. #ifdef INVARIANTS

    6341. 

  6341. 				if (control->end_added &&

    6342. 

  6342. 				    (control->data == NULL) &&

    6343. 

  6343. 				    (control->tail_mbuf == NULL)) {

    6344. 

  6344. 					panic("Gak, control->length is corrupt?");

    6345. 

  6345. 				}

    6346. 

  6346. #endif

    6347. 

  6347. 				no_rcv_needed = control->do_not_ref_stcb;

    6348. 

  6348. 				out_flags &= ~MSG_EOR;

    6349. 

  6349. 			}

    6350. 

  6350. 		}

    6351. 

  6351. 		if (out_flags & MSG_EOR) {

    6352. 

  6352. 			goto release;

    6353. 

  6353. 		}

    6354. 

  6354. #if defined(__APPLE__)

    6355. 

  6355. #if defined(APPLE_SNOWLEOPARD) || defined(APPLE_LION)

    6356. 

  6356. 		if ((uio_resid(uio) == 0) ||

    6357. 

  6357. #else

    6358. 

  6358. 		if ((uio->uio_resid == 0) ||

    6359. 

  6359. #endif

    6360. 

  6360. #else

    6361. 

  6361. 		if ((uio->uio_resid == 0) ||

    6362. 

  6362. #endif

    6363. 

  6363. 		    ((in_eeor_mode) && (copied_so_far >= max(so->so_rcv.sb_lowat, 1)))

    6364. 

  6364. 			) {

    6365. 

  6365. 			goto release;

    6366. 

  6366. 		}

    6367. 

  6367. 		/*

    6368. 

  6368. 		 * If I hit here the receiver wants more and this message is

    6369. 

  6369. 		 * NOT done (pd-api). So two questions. Can we block? if not

    6370. 

  6370. 		 * we are done. Did the user NOT set MSG_WAITALL?

    6371. 

  6371. 		 */

    6372. 

  6372. 		if (block_allowed == 0) {

    6373. 

  6373. 			goto release;

    6374. 

  6374. 		}

    6375. 

  6375. 		/*

    6376. 

  6376. 		 * We need to wait for more data a few things: - We don't

    6377. 

  6377. 		 * sbunlock() so we don't get someone else reading. - We

    6378. 

  6378. 		 * must be sure to account for the case where what is added

    6379. 

  6379. 		 * is NOT to our control when we wakeup.

    6380. 

  6380. 		 */

    6381. 

  6381. 

    6382. 

  6382. 		/* Do we need to tell the transport a rwnd update might be

    6383. 

  6383. 		 * needed before we go to sleep?

    6384. 

  6384. 		 */

    6385. 

  6385. 		if (((stcb) && (in_flags & MSG_PEEK) == 0) &&

    6386. 

  6386. 		    ((freed_so_far >= rwnd_req) &&

    6387. 

  6387. 		     (control->do_not_ref_stcb == 0) &&

    6388. 

  6388. 		     (no_rcv_needed == 0))) {

    6389. 

  6389. 			sctp_user_rcvd(stcb, &freed_so_far, hold_rlock, rwnd_req);

    6390. 

  6390. 		}

    6391. 

  6391. 	wait_some_more:

    6392. 

  6392. #if (defined(__FreeBSD__) && __FreeBSD_version > 500000) || defined(__Windows__)

    6393. 

  6393. 		if (so->so_rcv.sb_state & SBS_CANTRCVMORE) {

    6394. 

  6394. 			goto release;

    6395. 

  6395. 		}

    6396. 

  6396. #else

    6397. 

  6397. 		if (so->so_state & SS_CANTRCVMORE) {

    6398. 

  6398. 			goto release;

    6399. 

  6399. 		}

    6400. 

  6400. #endif

    6401. 

  6401. 

    6402. 

  6402. 		if (inp->sctp_flags & SCTP_PCB_FLAGS_SOCKET_GONE)

    6403. 

  6403. 			goto release;

    6404. 

  6404. 

    6405. 

  6405. 		if (hold_rlock == 1) {

    6406. 

  6406. 			SCTP_INP_READ_UNLOCK(inp);

    6407. 

  6407. 			hold_rlock = 0;

    6408. 

  6408. 		}

    6409. 

  6409. 		if (hold_sblock == 0) {

    6410. 

  6410. 			SOCKBUF_LOCK(&so->so_rcv);

    6411. 

  6411. 			hold_sblock = 1;

    6412. 

  6412. 		}

    6413. 

  6413. #if defined(__APPLE__)

    6414. 

  6414. 		sbunlock(&so->so_rcv, 1);

    6415. 

  6415. #endif

    6416. 

  6416. 		if ((copied_so_far) && (control->length == 0) &&

    6417. 

  6417. 		    (sctp_is_feature_on(inp, SCTP_PCB_FLAGS_FRAG_INTERLEAVE))) {

    6418. 

  6418. 			goto release;

    6419. 

  6419. 		}

    6420. 

  6420. 		if (so->so_rcv.sb_cc <= control->held_length) {

    6421. 

  6421. 			error = sbwait(&so->so_rcv);

    6422. 

  6422. 			if (error) {

    6423. 

  6423. #if defined(__FreeBSD__)

    6424. 

  6424. 				goto release;

    6425. 

  6425. #else

    6426. 

  6426. 				goto release_unlocked;

    6427. 

  6427. #endif

    6428. 

  6428. 			}

    6429. 

  6429. 			control->held_length = 0;

    6430. 

  6430. 		}

    6431. 

  6431. #if defined(__APPLE__)

    6432. 

  6432. 		error = sblock(&so->so_rcv, SBLOCKWAIT(in_flags));

    6433. 

  6433. #endif

    6434. 

  6434. 		if (hold_sblock) {

    6435. 

  6435. 			SOCKBUF_UNLOCK(&so->so_rcv);

    6436. 

  6436. 			hold_sblock = 0;

    6437. 

  6437. 		}

    6438. 

  6438. 		if (control->length == 0) {

    6439. 

  6439. 			/* still nothing here */

    6440. 

  6440. 			if (control->end_added == 1) {

    6441. 

  6441. 				/* he aborted, or is done i.e.did a shutdown */

    6442. 

  6442. 				out_flags |= MSG_EOR;

    6443. 

  6443. 				if (control->pdapi_aborted) {

    6444. 

  6444. 					if ((control->do_not_ref_stcb == 0) && ((control->spec_flags & M_NOTIFICATION) == 0))

    6445. 

  6445. 						control->stcb->asoc.strmin[control->sinfo_stream].delivery_started = 0;

    6446. 

  6446. 

    6447. 

  6447. 					out_flags |= MSG_TRUNC;

    6448. 

  6448. 				} else {

    6449. 

  6449. 					if ((control->do_not_ref_stcb == 0) && ((control->spec_flags & M_NOTIFICATION) == 0))

    6450. 

  6450. 						control->stcb->asoc.strmin[control->sinfo_stream].delivery_started = 0;

    6451. 

  6451. 				}

    6452. 

  6452. 				goto done_with_control;

    6453. 

  6453. 			}

    6454. 

  6454. 			if (so->so_rcv.sb_cc > held_length) {

    6455. 

  6455. 				control->held_length = so->so_rcv.sb_cc;

    6456. 

  6456. 				held_length = 0;

    6457. 

  6457. 			}

    6458. 

  6458. 			goto wait_some_more;

    6459. 

  6459. 		} else if (control->data == NULL) {

    6460. 

  6460. 			/* we must re-sync since data

    6461. 

  6461. 			 * is probably being added

    6462. 

  6462. 			 */

    6463. 

  6463. 			SCTP_INP_READ_LOCK(inp);

    6464. 

  6464. 			if ((control->length > 0) && (control->data == NULL)) {

    6465. 

  6465. 				/* big trouble.. we have the lock and its corrupt? */

    6466. 

  6466. #ifdef INVARIANTS

    6467. 

  6467. 				panic ("Impossible data==NULL length !=0");

    6468. 

  6468. #endif

    6469. 

  6469. 				out_flags |= MSG_EOR;

    6470. 

  6470. 				out_flags |= MSG_TRUNC;

    6471. 

  6471. 				control->length = 0;

    6472. 

  6472. 				SCTP_INP_READ_UNLOCK(inp);

    6473. 

  6473. 				goto done_with_control;

    6474. 

  6474. 			}

    6475. 

  6475. 			SCTP_INP_READ_UNLOCK(inp);

    6476. 

  6476. 			/* We will fall around to get more data */

    6477. 

  6477. 		}

    6478. 

  6478. 		goto get_more_data;

    6479. 

  6479. 	} else {

    6480. 

  6480. 		/*-

    6481. 

  6481. 		 * Give caller back the mbuf chain,

    6482. 

  6482. 		 * store in uio_resid the length

    6483. 

  6483. 		 */

    6484. 

  6484. 		wakeup_read_socket = 0;

    6485. 

  6485. 		if ((control->end_added == 0) ||

    6486. 

  6486. 		    (TAILQ_NEXT(control, next) == NULL)) {

    6487. 

  6487. 			/* Need to get rlock */

    6488. 

  6488. 			if (hold_rlock == 0) {

    6489. 

  6489. 				SCTP_INP_READ_LOCK(inp);

    6490. 

  6490. 				hold_rlock = 1;

    6491. 

  6491. 			}

    6492. 

  6492. 		}

    6493. 

  6493. 		if (control->end_added) {

    6494. 

  6494. 			out_flags |= MSG_EOR;

    6495. 

  6495. 			if ((control->do_not_ref_stcb == 0) &&

    6496. 

  6496. 			    (control->stcb != NULL) &&

    6497. 

  6497. 			    ((control->spec_flags & M_NOTIFICATION) == 0))

    6498. 

  6498. 				control->stcb->asoc.strmin[control->sinfo_stream].delivery_started = 0;

    6499. 

  6499. 		}

    6500. 

  6500. 		if (control->spec_flags & M_NOTIFICATION) {

    6501. 

  6501. 			out_flags |= MSG_NOTIFICATION;

    6502. 

  6502. 		}

    6503. 

  6503. #if defined(__APPLE__)

    6504. 

  6504. #if defined(APPLE_SNOWLEOPARD) || defined(APPLE_LION)

    6505. 

  6505. 		uio_setresid(uio, control->length);

    6506. 

  6506. #else

    6507. 

  6507. 		uio->uio_resid = control->length;

    6508. 

  6508. #endif

    6509. 

  6509. #else

    6510. 

  6510. 		uio->uio_resid = control->length;

    6511. 

  6511. #endif

    6512. 

  6512. 		*mp = control->data;

    6513. 

  6513. 		m = control->data;

    6514. 

  6514. 		while (m) {

    6515. 

  6515. 			if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_SB_LOGGING_ENABLE) {

    6516. 

  6516. 				sctp_sblog(&so->so_rcv,

    6517. 

  6517. 				   control->do_not_ref_stcb?NULL:stcb, SCTP_LOG_SBFREE, SCTP_BUF_LEN(m));

    6518. 

  6518. 			}

    6519. 

  6519. 			sctp_sbfree(control, stcb, &so->so_rcv, m);

    6520. 

  6520. 			freed_so_far += SCTP_BUF_LEN(m);

    6521. 

  6521. 			freed_so_far += MSIZE;

    6522. 

  6522. 			if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_SB_LOGGING_ENABLE) {

    6523. 

  6523. 				sctp_sblog(&so->so_rcv,

    6524. 

  6524. 				   control->do_not_ref_stcb?NULL:stcb, SCTP_LOG_SBRESULT, 0);

    6525. 

  6525. 			}

    6526. 

  6526. 			m = SCTP_BUF_NEXT(m);

    6527. 

  6527. 		}

    6528. 

  6528. 		control->data = control->tail_mbuf = NULL;

    6529. 

  6529. 		control->length = 0;

    6530. 

  6530. 		if (out_flags & MSG_EOR) {

    6531. 

  6531. 			/* Done with this control */

    6532. 

  6532. 			goto done_with_control;

    6533. 

  6533. 		}

    6534. 

  6534. 	}

    6535. 

  6535.  release:

    6536. 

  6536. 	if (hold_rlock == 1) {

    6537. 

  6537. 		SCTP_INP_READ_UNLOCK(inp);

    6538. 

  6538. 		hold_rlock = 0;

    6539. 

  6539. 	}

    6540. 

  6540. #if (defined(__FreeBSD__) && __FreeBSD_version < 700000) || defined(__Userspace__)

    6541. 

  6541. 	if (hold_sblock == 0) {

    6542. 

  6542. 		SOCKBUF_LOCK(&so->so_rcv);

    6543. 

  6543. 		hold_sblock = 1;

    6544. 

  6544. 	}

    6545. 

  6545. #else

    6546. 

  6546. 	if (hold_sblock == 1) {

    6547. 

  6547. 		SOCKBUF_UNLOCK(&so->so_rcv);

    6548. 

  6548. 		hold_sblock = 0;

    6549. 

  6549. 	}

    6550. 

  6550. #endif

    6551. 

  6551. #if defined(__APPLE__)

    6552. 

  6552. 	sbunlock(&so->so_rcv, 1);

    6553. 

  6553. #endif

    6554. 

  6554. 

    6555. 

  6555. #if defined(__FreeBSD__)

    6556. 

  6556. 	sbunlock(&so->so_rcv);

    6557. 

  6557. #if defined(__FreeBSD__) && __FreeBSD_version >= 700000

    6558. 

  6558. 	sockbuf_lock = 0;

    6559. 

  6559. #endif

    6560. 

  6560. #endif

    6561. 

  6561. 

    6562. 

  6562.  release_unlocked:

    6563. 

  6563. 	if (hold_sblock) {

    6564. 

  6564. 		SOCKBUF_UNLOCK(&so->so_rcv);

    6565. 

  6565. 		hold_sblock = 0;

    6566. 

  6566. 	}

    6567. 

  6567. 	if ((stcb) && (in_flags & MSG_PEEK) == 0) {

    6568. 

  6568. 		if ((freed_so_far >= rwnd_req) &&

    6569. 

  6569. 		    (control && (control->do_not_ref_stcb == 0)) &&

    6570. 

  6570. 		    (no_rcv_needed == 0))

    6571. 

  6571. 			sctp_user_rcvd(stcb, &freed_so_far, hold_rlock, rwnd_req);

    6572. 

  6572. 	}

    6573. 

  6573.  out:

    6574. 

  6574. 	if (msg_flags) {

    6575. 

  6575. 		*msg_flags = out_flags;

    6576. 

  6576. 	}

    6577. 

  6577. 	if (((out_flags & MSG_EOR) == 0) &&

    6578. 

  6578. 	    ((in_flags & MSG_PEEK) == 0) &&

    6579. 

  6579. 	    (sinfo) &&

    6580. 

  6580. 	    (sctp_is_feature_on(inp, SCTP_PCB_FLAGS_EXT_RCVINFO) ||

    6581. 

  6581. 	     sctp_is_feature_on(inp, SCTP_PCB_FLAGS_RECVNXTINFO))) {

    6582. 

  6582. 		struct sctp_extrcvinfo *s_extra;

    6583. 

  6583. 		s_extra = (struct sctp_extrcvinfo *)sinfo;

    6584. 

  6584. 		s_extra->sreinfo_next_flags = SCTP_NO_NEXT_MSG;

    6585. 

  6585. 	}

    6586. 

  6586. 	if (hold_rlock == 1) {

    6587. 

  6587. 		SCTP_INP_READ_UNLOCK(inp);

    6588. 

  6588. 	}

    6589. 

  6589. 	if (hold_sblock) {

    6590. 

  6590. 		SOCKBUF_UNLOCK(&so->so_rcv);

    6591. 

  6591. 	}

    6592. 

  6592. #if defined(__FreeBSD__) && __FreeBSD_version >= 700000

    6593. 

  6593. 	if (sockbuf_lock) {

    6594. 

  6594. 		sbunlock(&so->so_rcv);

    6595. 

  6595. 	}

    6596. 

  6596. #endif

    6597. 

  6597. 

    6598. 

  6598. 	if (freecnt_applied) {

    6599. 

  6599. 		/*

    6600. 

  6600. 		 * The lock on the socket buffer protects us so the free

    6601. 

  6601. 		 * code will stop. But since we used the socketbuf lock and

    6602. 

  6602. 		 * the sender uses the tcb_lock to increment, we need to use

    6603. 

  6603. 		 * the atomic add to the refcnt.

    6604. 

  6604. 		 */

    6605. 

  6605. 		if (stcb == NULL) {

    6606. 

  6606. #ifdef INVARIANTS

    6607. 

  6607. 			panic("stcb for refcnt has gone NULL?");

    6608. 

  6608. 			goto stage_left;

    6609. 

  6609. #else

    6610. 

  6610. 			goto stage_left;

    6611. 

  6611. #endif

    6612. 

  6612. 		}

    6613. 

  6613. 		atomic_add_int(&stcb->asoc.refcnt, -1);

    6614. 

  6614. 		/* Save the value back for next time */

    6615. 

  6615. 		stcb->freed_by_sorcv_sincelast = freed_so_far;

    6616. 

  6616. 	}

    6617. 

  6617. 	if (SCTP_BASE_SYSCTL(sctp_logging_level) &SCTP_RECV_RWND_LOGGING_ENABLE) {

    6618. 

  6618. 		if (stcb) {

    6619. 

  6619. 			sctp_misc_ints(SCTP_SORECV_DONE,

    6620. 

  6620. 				       freed_so_far,

    6621. 

  6621. #if defined(__APPLE__)

    6622. 

  6622. #if defined(APPLE_SNOWLEOPARD) || defined(APPLE_LION)

    6623. 

  6623. 				       ((uio) ? (slen-uio_resid(uio)) : slen),

    6624. 

  6624. #else

    6625. 

  6625. 				       ((uio) ? (slen-uio->uio_resid) : slen),

    6626. 

  6626. #endif

    6627. 

  6627. #else

    6628. 

  6628. 				       ((uio) ? (slen-uio->uio_resid) : slen),

    6629. 

  6629. #endif

    6630. 

  6630. 				       stcb->asoc.my_rwnd,

    6631. 

  6631. 				       so->so_rcv.sb_cc);

    6632. 

  6632. 		} else {

    6633. 

  6633. 			sctp_misc_ints(SCTP_SORECV_DONE,

    6634. 

  6634. 				       freed_so_far,

    6635. 

  6635. #if defined(__APPLE__)

    6636. 

  6636. #if defined(APPLE_SNOWLEOPARD) || defined(APPLE_LION)

    6637. 

  6637. 				       ((uio) ? (slen-uio_resid(uio)) : slen),

    6638. 

  6638. #else

    6639. 

  6639. 				       ((uio) ? (slen-uio->uio_resid) : slen),

    6640. 

  6640. #endif

    6641. 

  6641. #else

    6642. 

  6642. 				       ((uio) ? (slen-uio->uio_resid) : slen),

    6643. 

  6643. #endif

    6644. 

  6644. 				       0,

    6645. 

  6645. 				       so->so_rcv.sb_cc);

    6646. 

  6646. 		}

    6647. 

  6647. 	}

    6648. 

  6648.  stage_left:

    6649. 

  6649. 	if (wakeup_read_socket) {

    6650. 

  6650. 		sctp_sorwakeup(inp, so);

    6651. 

  6651. 	}

    6652. 

  6652. 	return (error);

    6653. 

  6653. }

    6654. 

  6654. 

    6655. 

  6655. 

    6656. 

  6656. #ifdef SCTP_MBUF_LOGGING

    6657. 

  6657. struct mbuf *

    6658. 

  6658. sctp_m_free(struct mbuf *m)

    6659. 

  6659. {

    6660. 

  6660. 	if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_MBUF_LOGGING_ENABLE) {

    6661. 

  6661. 		if (SCTP_BUF_IS_EXTENDED(m)) {

    6662. 

  6662. 			sctp_log_mb(m, SCTP_MBUF_IFREE);

    6663. 

  6663. 		}

    6664. 

  6664. 	}

    6665. 

  6665. 	return (m_free(m));

    6666. 

  6666. }

    6667. 

  6667. 

    6668. 

  6668. void sctp_m_freem(struct mbuf *mb)

    6669. 

  6669. {

    6670. 

  6670. 	while (mb != NULL)

    6671. 

  6671. 		mb = sctp_m_free(mb);

    6672. 

  6672. }

    6673. 

  6673. 

    6674. 

  6674. #endif

    6675. 

  6675. 

    6676. 

  6676. int

    6677. 

  6677. sctp_dynamic_set_primary(struct sockaddr *sa, uint32_t vrf_id)

    6678. 

  6678. {

    6679. 

  6679. 	/* Given a local address. For all associations

    6680. 

  6680. 	 * that holds the address, request a peer-set-primary.

    6681. 

  6681. 	 */

    6682. 

  6682. 	struct sctp_ifa *ifa;

    6683. 

  6683. 	struct sctp_laddr *wi;

    6684. 

  6684. 

    6685. 

  6685. 	ifa = sctp_find_ifa_by_addr(sa, vrf_id, 0);

    6686. 

  6686. 	if (ifa == NULL) {

    6687. 

  6687. 		SCTP_LTRACE_ERR_RET(NULL, NULL, NULL, SCTP_FROM_SCTPUTIL, EADDRNOTAVAIL);

    6688. 

  6688. 		return (EADDRNOTAVAIL);

    6689. 

  6689. 	}

    6690. 

  6690. 	/* Now that we have the ifa we must awaken the

    6691. 

  6691. 	 * iterator with this message.

    6692. 

  6692. 	 */

    6693. 

  6693. 	wi = SCTP_ZONE_GET(SCTP_BASE_INFO(ipi_zone_laddr), struct sctp_laddr);

    6694. 

  6694. 	if (wi == NULL) {

    6695. 

  6695. 		SCTP_LTRACE_ERR_RET(NULL, NULL, NULL, SCTP_FROM_SCTPUTIL, ENOMEM);

    6696. 

  6696. 		return (ENOMEM);

    6697. 

  6697. 	}

    6698. 

  6698. 	/* Now incr the count and int wi structure */

    6699. 

  6699. 	SCTP_INCR_LADDR_COUNT();

    6700. 

  6700. 	bzero(wi, sizeof(*wi));

    6701. 

  6701. 	(void)SCTP_GETTIME_TIMEVAL(&wi->start_time);

    6702. 

  6702. 	wi->ifa = ifa;

    6703. 

  6703. 	wi->action = SCTP_SET_PRIM_ADDR;

    6704. 

  6704. 	atomic_add_int(&ifa->refcount, 1);

    6705. 

  6705. 

    6706. 

  6706. 	/* Now add it to the work queue */

    6707. 

  6707. 	SCTP_WQ_ADDR_LOCK();

    6708. 

  6708. 	/*

    6709. 

  6709. 	 * Should this really be a tailq? As it is we will process the

    6710. 

  6710. 	 * newest first :-0

    6711. 

  6711. 	 */

    6712. 

  6712. 	LIST_INSERT_HEAD(&SCTP_BASE_INFO(addr_wq), wi, sctp_nxt_addr);

    6713. 

  6713. 	SCTP_WQ_ADDR_UNLOCK();

    6714. 

  6714. 	sctp_timer_start(SCTP_TIMER_TYPE_ADDR_WQ,

    6715. 

  6715. 			 (struct sctp_inpcb *)NULL,

    6716. 

  6716. 			 (struct sctp_tcb *)NULL,

    6717. 

  6717. 			 (struct sctp_nets *)NULL);

    6718. 

  6718. 	return (0);

    6719. 

  6719. }

    6720. 

  6720. 

    6721. 

  6721. #if defined(__Userspace__)

    6722. 

  6722. /* no sctp_soreceive for __Userspace__ now */

    6723. 

  6723. #endif

    6724. 

  6724. 

    6725. 

  6725. #if !defined(__Userspace__)

    6726. 

  6726. int

    6727. 

  6727. sctp_soreceive(	struct socket *so,

    6728. 

  6728. 		struct sockaddr **psa,

    6729. 

  6729. 		struct uio *uio,

    6730. 

  6730. 		struct mbuf **mp0,

    6731. 

  6731. 		struct mbuf **controlp,

    6732. 

  6732. 		int *flagsp)

    6733. 

  6733. {

    6734. 

  6734. 	int error, fromlen;

    6735. 

  6735. 	uint8_t sockbuf[256];

    6736. 

  6736. 	struct sockaddr *from;

    6737. 

  6737. 	struct sctp_extrcvinfo sinfo;

    6738. 

  6738. 	int filling_sinfo = 1;

    6739. 

  6739. 	struct sctp_inpcb *inp;

    6740. 

  6740. 

    6741. 

  6741. 	inp = (struct sctp_inpcb *)so->so_pcb;

    6742. 

  6742. 	/* pickup the assoc we are reading from */

    6743. 

  6743. 	if (inp == NULL) {

    6744. 

  6744. 		SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTPUTIL, EINVAL);

    6745. 

  6745. 		return (EINVAL);

    6746. 

  6746. 	}

    6747. 

  6747. 	if ((sctp_is_feature_off(inp, SCTP_PCB_FLAGS_RECVDATAIOEVNT) &&

    6748. 

  6748. 	     sctp_is_feature_off(inp, SCTP_PCB_FLAGS_RECVRCVINFO) &&

    6749. 

  6749. 	     sctp_is_feature_off(inp, SCTP_PCB_FLAGS_RECVNXTINFO)) ||

    6750. 

  6750. 	    (controlp == NULL)) {

    6751. 

  6751. 		/* user does not want the sndrcv ctl */

    6752. 

  6752. 		filling_sinfo = 0;

    6753. 

  6753. 	}

    6754. 

  6754. 	if (psa) {

    6755. 

  6755. 		from = (struct sockaddr *)sockbuf;

    6756. 

  6756. 		fromlen = sizeof(sockbuf);

    6757. 

  6757. #if !defined(__Windows__)

    6758. 

  6758. 		from->sa_len = 0;

    6759. 

  6759. #endif

    6760. 

  6760. 	} else {

    6761. 

  6761. 		from = NULL;

    6762. 

  6762. 		fromlen = 0;

    6763. 

  6763. 	}

    6764. 

  6764. 

    6765. 

  6765. #if defined(__APPLE__)

    6766. 

  6766. 	SCTP_SOCKET_LOCK(so, 1);

    6767. 

  6767. #endif

    6768. 

  6768. 	error = sctp_sorecvmsg(so, uio, mp0, from, fromlen, flagsp,

    6769. 

  6769. 	    (struct sctp_sndrcvinfo *)&sinfo, filling_sinfo);

    6770. 

  6770. 	if ((controlp) && (filling_sinfo)) {

    6771. 

  6771. 		/* copy back the sinfo in a CMSG format */

    6772. 

  6772. 		if (filling_sinfo)

    6773. 

  6773. 			*controlp = sctp_build_ctl_nchunk(inp,

    6774. 

  6774. 			                                  (struct sctp_sndrcvinfo *)&sinfo);

    6775. 

  6775. 		else

    6776. 

  6776. 			*controlp = NULL;

    6777. 

  6777. 	}

    6778. 

  6778. 	if (psa) {

    6779. 

  6779. 		/* copy back the address info */

    6780. 

  6780. #if !defined(__Windows__)

    6781. 

  6781. 		if (from && from->sa_len) {

    6782. 

  6782. #else

    6783. 

  6783. 		if (from) {

    6784. 

  6784. #endif

    6785. 

  6785. #if (defined(__FreeBSD__) && __FreeBSD_version > 500000) || defined(__Windows__)

    6786. 

  6786. 			*psa = sodupsockaddr(from, M_NOWAIT);

    6787. 

  6787. #else

    6788. 

  6788. 			*psa = dup_sockaddr(from, mp0 == 0);

    6789. 

  6789. #endif

    6790. 

  6790. 		} else {

    6791. 

  6791. 			*psa = NULL;

    6792. 

  6792. 		}

    6793. 

  6793. 	}

    6794. 

  6794. #if defined(__APPLE__)

    6795. 

  6795. 	SCTP_SOCKET_UNLOCK(so, 1);

    6796. 

  6796. #endif

    6797. 

  6797. 	return (error);

    6798. 

  6798. }

    6799. 

  6799. 

    6800. 

  6800. 

    6801. 

  6801. #if (defined(__FreeBSD__) && __FreeBSD_version < 603000) || defined(__Windows__)

    6802. 

  6802. /*

    6803. 

  6803.  * General routine to allocate a hash table with control of memory flags.

    6804. 

  6804.  * is in 7.0 and beyond for sure :-)

    6805. 

  6805.  */

    6806. 

  6806. void *

    6807. 

  6807. sctp_hashinit_flags(int elements, struct malloc_type *type,

    6808. 

  6808.                     u_long *hashmask, int flags)

    6809. 

  6809. {

    6810. 

  6810. 	long hashsize;

    6811. 

  6811. 	LIST_HEAD(generic, generic) *hashtbl;

    6812. 

  6812. 	int i;

    6813. 

  6813. 

    6814. 

  6814. 

    6815. 

  6815. 	if (elements <= 0) {

    6816. 

  6816. #ifdef INVARIANTS

    6817. 

  6817. 		panic("hashinit: bad elements");

    6818. 

  6818. #else

    6819. 

  6819. 		SCTP_PRINTF("hashinit: bad elements?");

    6820. 

  6820. 		elements = 1;

    6821. 

  6821. #endif

    6822. 

  6822. 	}

    6823. 

  6823. 	for (hashsize = 1; hashsize <= elements; hashsize <<= 1)

    6824. 

  6824. 		continue;

    6825. 

  6825. 	hashsize >>= 1;

    6826. 

  6826. 	if (flags & HASH_WAITOK)

    6827. 

  6827. 		hashtbl = malloc((u_long)hashsize * sizeof(*hashtbl), type, M_WAITOK);

    6828. 

  6828. 	else if (flags & HASH_NOWAIT)

    6829. 

  6829. 		hashtbl = malloc((u_long)hashsize * sizeof(*hashtbl), type, M_NOWAIT);

    6830. 

  6830. 	else {

    6831. 

  6831. #ifdef INVARIANTS

    6832. 

  6832. 		panic("flag incorrect in hashinit_flags");

    6833. 

  6833. #else

    6834. 

  6834. 		return (NULL);

    6835. 

  6835. #endif

    6836. 

  6836. 	}

    6837. 

  6837. 

    6838. 

  6838. 	/* no memory? */

    6839. 

  6839. 	if (hashtbl == NULL)

    6840. 

  6840. 		return (NULL);

    6841. 

  6841. 

    6842. 

  6842. 	for (i = 0; i < hashsize; i++)

    6843. 

  6843. 		LIST_INIT(&hashtbl[i]);

    6844. 

  6844. 	*hashmask = hashsize - 1;

    6845. 

  6845. 	return (hashtbl);

    6846. 

  6846. }

    6847. 

  6847. #endif

    6848. 

  6848. 

    6849. 

  6849. #else /*  __Userspace__ ifdef above sctp_soreceive */

    6850. 

  6850. /*

    6851. 

  6851.  * __Userspace__ Defining sctp_hashinit_flags() and sctp_hashdestroy() for userland.

    6852. 

  6852.  * NOTE: We don't want multiple definitions here. So sctp_hashinit_flags() above for

    6853. 

  6853.  *__FreeBSD__ must be excluded.

    6854. 

  6854.  *

    6855. 

  6855.  */

    6856. 

  6856. 

    6857. 

  6857. void *

    6858. 

  6858. sctp_hashinit_flags(int elements, struct malloc_type *type,

    6859. 

  6859.                     u_long *hashmask, int flags)

    6860. 

  6860. {

    6861. 

  6861. 	long hashsize;

    6862. 

  6862. 	LIST_HEAD(generic, generic) *hashtbl;

    6863. 

  6863. 	int i;

    6864. 

  6864. 

    6865. 

  6865. 	if (elements <= 0) {

    6866. 

  6866. 		SCTP_PRINTF("hashinit: bad elements?");

    6867. 

  6867. #ifdef INVARIANTS

    6868. 

  6868. 		return (NULL);

    6869. 

  6869. #else

    6870. 

  6870. 		elements = 1;

    6871. 

  6871. #endif

    6872. 

  6872. 	}

    6873. 

  6873. 	for (hashsize = 1; hashsize <= elements; hashsize <<= 1)

    6874. 

  6874. 		continue;

    6875. 

  6875. 	hashsize >>= 1;

    6876. 

  6876. 	/*cannot use MALLOC here because it has to be declared or defined

    6877. 

  6877. 	  using MALLOC_DECLARE or MALLOC_DEFINE first. */

    6878. 

  6878. 	if (flags & HASH_WAITOK)

    6879. 

  6879. 		hashtbl = malloc((u_long)hashsize * sizeof(*hashtbl));

    6880. 

  6880. 	else if (flags & HASH_NOWAIT)

    6881. 

  6881. 		hashtbl = malloc((u_long)hashsize * sizeof(*hashtbl));

    6882. 

  6882. 	else {

    6883. 

  6883. #ifdef INVARIANTS

    6884. 

  6884. 		SCTP_PRINTF("flag incorrect in hashinit_flags");

    6885. 

  6885. #endif

    6886. 

  6886. 		return (NULL);

    6887. 

  6887. 	}

    6888. 

  6888. 

    6889. 

  6889. 	/* no memory? */

    6890. 

  6890. 	if (hashtbl == NULL)

    6891. 

  6891. 		return (NULL);

    6892. 

  6892. 

    6893. 

  6893. 	for (i = 0; i < hashsize; i++)

    6894. 

  6894. 		LIST_INIT(&hashtbl[i]);

    6895. 

  6895. 	*hashmask = hashsize - 1;

    6896. 

  6896. 	return (hashtbl);

    6897. 

  6897. }

    6898. 

  6898. 

    6899. 

  6899. 

    6900. 

  6900. void

    6901. 

  6901. sctp_hashdestroy(void *vhashtbl, struct malloc_type *type, u_long hashmask)

    6902. 

  6902. {

    6903. 

  6903. 	LIST_HEAD(generic, generic) *hashtbl, *hp;

    6904. 

  6904. 

    6905. 

  6905. 	hashtbl = vhashtbl;

    6906. 

  6906. 	for (hp = hashtbl; hp <= &hashtbl[hashmask]; hp++)

    6907. 

  6907. 		if (!LIST_EMPTY(hp)) {

    6908. 

  6908. 			SCTP_PRINTF("hashdestroy: hash not empty");

    6909. 

  6909. 			return;

    6910. 

  6910. 		}

    6911. 

  6911. 	FREE(hashtbl, type);

    6912. 

  6912. }

    6913. 

  6913. 

    6914. 

  6914. 

    6915. 

  6915. void

    6916. 

  6916. sctp_hashfreedestroy(void *vhashtbl, struct malloc_type *type, u_long hashmask)

    6917. 

  6917. {

    6918. 

  6918. 	LIST_HEAD(generic, generic) *hashtbl/*, *hp*/;

    6919. 

  6919. 	/*

    6920. 

  6920. 	LIST_ENTRY(type) *start, *temp;

    6921. 

  6921. 	 */

    6922. 

  6922. 	hashtbl = vhashtbl;

    6923. 

  6923. 	/* Apparently temp is not dynamically allocated, so attempts to

    6924. 

  6924. 	   free it results in error.

    6925. 

  6925. 	for (hp = hashtbl; hp <= &hashtbl[hashmask]; hp++)

    6926. 

  6926. 		if (!LIST_EMPTY(hp)) {

    6927. 

  6927. 			start = LIST_FIRST(hp);

    6928. 

  6928. 			while (start != NULL) {

    6929. 

  6929. 				temp = start;

    6930. 

  6930. 				start = start->le_next;

    6931. 

  6931. 				SCTP_PRINTF("%s: %p \n", __func__, temp);

    6932. 

  6932. 				FREE(temp, type);

    6933. 

  6933. 			}

    6934. 

  6934. 		}

    6935. 

  6935. 	 */

    6936. 

  6936. 	FREE(hashtbl, type);

    6937. 

  6937. }

    6938. 

  6938. 

    6939. 

  6939. 

    6940. 

  6940. #endif

    6941. 

  6941. 

    6942. 

  6942. 

    6943. 

  6943. int

    6944. 

  6944. sctp_connectx_helper_add(struct sctp_tcb *stcb, struct sockaddr *addr,

    6945. 

  6945. 			 int totaddr, int *error)

    6946. 

  6946. {

    6947. 

  6947. 	int added = 0;

    6948. 

  6948. 	int i;

    6949. 

  6949. 	struct sctp_inpcb *inp;

    6950. 

  6950. 	struct sockaddr *sa;

    6951. 

  6951. 	size_t incr = 0;

    6952. 

  6952. #ifdef INET

    6953. 

  6953. 	struct sockaddr_in *sin;

    6954. 

  6954. #endif

    6955. 

  6955. #ifdef INET6

    6956. 

  6956. 	struct sockaddr_in6 *sin6;

    6957. 

  6957. #endif

    6958. 

  6958. 

    6959. 

  6959. 	sa = addr;

    6960. 

  6960. 	inp = stcb->sctp_ep;

    6961. 

  6961. 	*error = 0;

    6962. 

  6962. 	for (i = 0; i < totaddr; i++) {

    6963. 

  6963. 		switch (sa->sa_family) {

    6964. 

  6964. #ifdef INET

    6965. 

  6965. 		case AF_INET:

    6966. 

  6966. 			incr = sizeof(struct sockaddr_in);

    6967. 

  6967. 			sin = (struct sockaddr_in *)sa;

    6968. 

  6968. 			if ((sin->sin_addr.s_addr == INADDR_ANY) ||

    6969. 

  6969. 			    (sin->sin_addr.s_addr == INADDR_BROADCAST) ||

    6970. 

  6970. 			    IN_MULTICAST(ntohl(sin->sin_addr.s_addr))) {

    6971. 

  6971. 				SCTP_LTRACE_ERR_RET(NULL, stcb, NULL, SCTP_FROM_SCTPUTIL, EINVAL);

    6972. 

  6972. 				(void)sctp_free_assoc(inp, stcb, SCTP_NORMAL_PROC, SCTP_FROM_SCTP_USRREQ+SCTP_LOC_7);

    6973. 

  6973. 				*error = EINVAL;

    6974. 

  6974. 				goto out_now;

    6975. 

  6975. 			}

    6976. 

  6976. 			if (sctp_add_remote_addr(stcb, sa, NULL, SCTP_DONOT_SETSCOPE, SCTP_ADDR_IS_CONFIRMED)) {

    6977. 

  6977. 				/* assoc gone no un-lock */

    6978. 

  6978. 				SCTP_LTRACE_ERR_RET(NULL, stcb, NULL, SCTP_FROM_SCTPUTIL, ENOBUFS);

    6979. 

  6979. 				(void)sctp_free_assoc(inp, stcb, SCTP_NORMAL_PROC, SCTP_FROM_SCTP_USRREQ+SCTP_LOC_7);

    6980. 

  6980. 				*error = ENOBUFS;

    6981. 

  6981. 				goto out_now;

    6982. 

  6982. 			}

    6983. 

  6983. 			added++;

    6984. 

  6984. 			break;

    6985. 

  6985. #endif

    6986. 

  6986. #ifdef INET6

    6987. 

  6987. 		case AF_INET6:

    6988. 

  6988. 			incr = sizeof(struct sockaddr_in6);

    6989. 

  6989. 			sin6 = (struct sockaddr_in6 *)sa;

    6990. 

  6990. 			if (IN6_IS_ADDR_UNSPECIFIED(&sin6->sin6_addr) ||

    6991. 

  6991. 			    IN6_IS_ADDR_MULTICAST(&sin6->sin6_addr)) {

    6992. 

  6992. 				SCTP_LTRACE_ERR_RET(NULL, stcb, NULL, SCTP_FROM_SCTPUTIL, EINVAL);

    6993. 

  6993. 				(void)sctp_free_assoc(inp, stcb, SCTP_NORMAL_PROC, SCTP_FROM_SCTP_USRREQ+SCTP_LOC_8);

    6994. 

  6994. 				*error = EINVAL;

    6995. 

  6995. 				goto out_now;

    6996. 

  6996. 			}

    6997. 

  6997. 			if (sctp_add_remote_addr(stcb, sa, NULL, SCTP_DONOT_SETSCOPE, SCTP_ADDR_IS_CONFIRMED)) {

    6998. 

  6998. 				/* assoc gone no un-lock */

    6999. 

  6999. 				SCTP_LTRACE_ERR_RET(NULL, stcb, NULL, SCTP_FROM_SCTPUTIL, ENOBUFS);

    7000. 

  7000. 				(void)sctp_free_assoc(inp, stcb, SCTP_NORMAL_PROC, SCTP_FROM_SCTP_USRREQ+SCTP_LOC_8);

    7001. 

  7001. 				*error = ENOBUFS;

    7002. 

  7002. 				goto out_now;

    7003. 

  7003. 			}

    7004. 

  7004. 			added++;

    7005. 

  7005. 			break;

    7006. 

  7006. #endif

    7007. 

  7007. 		default:

    7008. 

  7008. 			break;

    7009. 

  7009. 		}

    7010. 

  7010. 		sa = (struct sockaddr *)((caddr_t)sa + incr);

    7011. 

  7011. 	}

    7012. 

  7012.  out_now:

    7013. 

  7013. 	return (added);

    7014. 

  7014. }

    7015. 

  7015. 

    7016. 

  7016. struct sctp_tcb *

    7017. 

  7017. sctp_connectx_helper_find(struct sctp_inpcb *inp, struct sockaddr *addr,

    7018. 

  7018. 			  int *totaddr, int *num_v4, int *num_v6, int *error,

    7019. 

  7019. 			  int limit, int *bad_addr)

    7020. 

  7020. {

    7021. 

  7021. 	struct sockaddr *sa;

    7022. 

  7022. 	struct sctp_tcb *stcb = NULL;

    7023. 

  7023. 	size_t incr, at, i;

    7024. 

  7024. 	at = incr = 0;

    7025. 

  7025. 	sa = addr;

    7026. 

  7026. 

    7027. 

  7027. 	*error = *num_v6 = *num_v4 = 0;

    7028. 

  7028. 	/* account and validate addresses */

    7029. 

  7029. 	for (i = 0; i < (size_t)*totaddr; i++) {

    7030. 

  7030. 		switch (sa->sa_family) {

    7031. 

  7031. #ifdef INET

    7032. 

  7032. 		case AF_INET:

    7033. 

  7033. 			(*num_v4) += 1;

    7034. 

  7034. 			incr = sizeof(struct sockaddr_in);

    7035. 

  7035. #if !defined(__Windows__) && !defined(__Userspace_os_Linux) && !defined(__Userspace_os_Windows)

    7036. 

  7036. 			if (sa->sa_len != incr) {

    7037. 

  7037. 				SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTPUTIL, EINVAL);

    7038. 

  7038. 				*error = EINVAL;

    7039. 

  7039. 				*bad_addr = 1;

    7040. 

  7040. 				return (NULL);

    7041. 

  7041. 			}

    7042. 

  7042. #endif

    7043. 

  7043. 			break;

    7044. 

  7044. #endif

    7045. 

  7045. #ifdef INET6

    7046. 

  7046. 		case AF_INET6:

    7047. 

  7047. 		{

    7048. 

  7048. 			struct sockaddr_in6 *sin6;

    7049. 

  7049. 

    7050. 

  7050. 			sin6 = (struct sockaddr_in6 *)sa;

    7051. 

  7051. 			if (IN6_IS_ADDR_V4MAPPED(&sin6->sin6_addr)) {

    7052. 

  7052. 				/* Must be non-mapped for connectx */

    7053. 

  7053. 				SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTPUTIL, EINVAL);

    7054. 

  7054. 				*error = EINVAL;

    7055. 

  7055. 				*bad_addr = 1;

    7056. 

  7056. 				return (NULL);

    7057. 

  7057. 			}

    7058. 

  7058. 			(*num_v6) += 1;

    7059. 

  7059. 			incr = sizeof(struct sockaddr_in6);

    7060. 

  7060. #if !defined(__Windows__) && !defined(__Userspace_os_Linux) && !defined(__Userspace_os_Windows)

    7061. 

  7061. 			if (sa->sa_len != incr) {

    7062. 

  7062. 				SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTPUTIL, EINVAL);

    7063. 

  7063. 				*error = EINVAL;

    7064. 

  7064. 				*bad_addr = 1;

    7065. 

  7065. 				return (NULL);

    7066. 

  7066. 			}

    7067. 

  7067. #endif

    7068. 

  7068. 			break;

    7069. 

  7069. 		}

    7070. 

  7070. #endif

    7071. 

  7071. 		default:

    7072. 

  7072. 			*totaddr = i;

    7073. 

  7073. 			/* we are done */

    7074. 

  7074. 			break;

    7075. 

  7075. 		}

    7076. 

  7076. 		if (i == (size_t)*totaddr) {

    7077. 

  7077. 			break;

    7078. 

  7078. 		}

    7079. 

  7079. 		SCTP_INP_INCR_REF(inp);

    7080. 

  7080. 		stcb = sctp_findassociation_ep_addr(&inp, sa, NULL, NULL, NULL);

    7081. 

  7081. 		if (stcb != NULL) {

    7082. 

  7082. 			/* Already have or am bring up an association */

    7083. 

  7083. 			return (stcb);

    7084. 

  7084. 		} else {

    7085. 

  7085. 			SCTP_INP_DECR_REF(inp);

    7086. 

  7086. 		}

    7087. 

  7087. 		if ((at + incr) > (size_t)limit) {

    7088. 

  7088. 			*totaddr = i;

    7089. 

  7089. 			break;

    7090. 

  7090. 		}

    7091. 

  7091. 		sa = (struct sockaddr *)((caddr_t)sa + incr);

    7092. 

  7092. 	}

    7093. 

  7093. 	return ((struct sctp_tcb *)NULL);

    7094. 

  7094. }

    7095. 

  7095. 

    7096. 

  7096. /*

    7097. 

  7097.  * sctp_bindx(ADD) for one address.

    7098. 

  7098.  * assumes all arguments are valid/checked by caller.

    7099. 

  7099.  */

    7100. 

  7100. void

    7101. 

  7101. sctp_bindx_add_address(struct socket *so, struct sctp_inpcb *inp,

    7102. 

  7102. 		       struct sockaddr *sa, sctp_assoc_t assoc_id,

    7103. 

  7103. 		       uint32_t vrf_id, int *error, void *p)

    7104. 

  7104. {

    7105. 

  7105. 	struct sockaddr *addr_touse;

    7106. 

  7106. #ifdef INET6

    7107. 

  7107. 	struct sockaddr_in sin;

    7108. 

  7108. #endif

    7109. 

  7109. #ifdef SCTP_MVRF

    7110. 

  7110. 	int i, fnd = 0;

    7111. 

  7111. #endif

    7112. 

  7112. 

    7113. 

  7113. 	/* see if we're bound all already! */

    7114. 

  7114. 	if (inp->sctp_flags & SCTP_PCB_FLAGS_BOUNDALL) {

    7115. 

  7115. 		SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTPUTIL, EINVAL);

    7116. 

  7116. 		*error = EINVAL;

    7117. 

  7117. 		return;

    7118. 

  7118. 	}

    7119. 

  7119. #ifdef SCTP_MVRF

    7120. 

  7120. 	/* Is the VRF one we have */

    7121. 

  7121. 	for (i = 0; i < inp->num_vrfs; i++) {

    7122. 

  7122. 		if (vrf_id == inp->m_vrf_ids[i]) {

    7123. 

  7123. 			fnd = 1;

    7124. 

  7124. 			break;

    7125. 

  7125. 		}

    7126. 

  7126. 	}

    7127. 

  7127. 	if (!fnd) {

    7128. 

  7128. 		SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTPUTIL, EINVAL);

    7129. 

  7129. 		*error = EINVAL;

    7130. 

  7130. 		return;

    7131. 

  7131. 	}

    7132. 

  7132. #endif

    7133. 

  7133. 	addr_touse = sa;

    7134. 

  7134. #ifdef INET6

    7135. 

  7135. 	if (sa->sa_family == AF_INET6) {

    7136. 

  7136. 		struct sockaddr_in6 *sin6;

    7137. 

  7137. #if !defined(__Windows__) && !defined(__Userspace_os_Linux) && !defined(__Userspace_os_Windows)

    7138. 

  7138. 		if (sa->sa_len != sizeof(struct sockaddr_in6)) {

    7139. 

  7139. 			SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTPUTIL, EINVAL);

    7140. 

  7140. 			*error = EINVAL;

    7141. 

  7141. 			return;

    7142. 

  7142. 		}

    7143. 

  7143. #endif

    7144. 

  7144. 		if ((inp->sctp_flags & SCTP_PCB_FLAGS_BOUND_V6) == 0) {

    7145. 

  7145. 			/* can only bind v6 on PF_INET6 sockets */

    7146. 

  7146. 			SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTPUTIL, EINVAL);

    7147. 

  7147. 			*error = EINVAL;

    7148. 

  7148. 			return;

    7149. 

  7149. 		}

    7150. 

  7150. 		sin6 = (struct sockaddr_in6 *)addr_touse;

    7151. 

  7151. 		if (IN6_IS_ADDR_V4MAPPED(&sin6->sin6_addr)) {

    7152. 

  7152. 			if ((inp->sctp_flags & SCTP_PCB_FLAGS_BOUND_V6) &&

    7153. 

  7153. 			    SCTP_IPV6_V6ONLY(inp)) {

    7154. 

  7154. 				/* can't bind v4-mapped on PF_INET sockets */

    7155. 

  7155. 				SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTPUTIL, EINVAL);

    7156. 

  7156. 				*error = EINVAL;

    7157. 

  7157. 				return;

    7158. 

  7158. 			}

    7159. 

  7159. 			in6_sin6_2_sin(&sin, sin6);

    7160. 

  7160. 			addr_touse = (struct sockaddr *)&sin;

    7161. 

  7161. 		}

    7162. 

  7162. 	}

    7163. 

  7163. #endif

    7164. 

  7164. #ifdef INET

    7165. 

  7165. 	if (sa->sa_family == AF_INET) {

    7166. 

  7166. #if !defined(__Windows__) && !defined(__Userspace_os_Linux) && !defined(__Userspace_os_Windows)

    7167. 

  7167. 		if (sa->sa_len != sizeof(struct sockaddr_in)) {

    7168. 

  7168. 			SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTPUTIL, EINVAL);

    7169. 

  7169. 			*error = EINVAL;

    7170. 

  7170. 			return;

    7171. 

  7171. 		}

    7172. 

  7172. #endif

    7173. 

  7173. 		if ((inp->sctp_flags & SCTP_PCB_FLAGS_BOUND_V6) &&

    7174. 

  7174. 		    SCTP_IPV6_V6ONLY(inp)) {

    7175. 

  7175. 			/* can't bind v4 on PF_INET sockets */

    7176. 

  7176. 			SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTPUTIL, EINVAL);

    7177. 

  7177. 			*error = EINVAL;

    7178. 

  7178. 			return;

    7179. 

  7179. 		}

    7180. 

  7180. 	}

    7181. 

  7181. #endif

    7182. 

  7182. 	if (inp->sctp_flags & SCTP_PCB_FLAGS_UNBOUND) {

    7183. 

  7183. #if !(defined(__Panda__) || defined(__Windows__))

    7184. 

  7184. 		if (p == NULL) {

    7185. 

  7185. 			/* Can't get proc for Net/Open BSD */

    7186. 

  7186. 			SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTPUTIL, EINVAL);

    7187. 

  7187. 			*error = EINVAL;

    7188. 

  7188. 			return;

    7189. 

  7189. 		}

    7190. 

  7190. #endif

    7191. 

  7191. 		*error = sctp_inpcb_bind(so, addr_touse, NULL, p);

    7192. 

  7192. 		return;

    7193. 

  7193. 	}

    7194. 

  7194. 	/*

    7195. 

  7195. 	 * No locks required here since bind and mgmt_ep_sa

    7196. 

  7196. 	 * all do their own locking. If we do something for

    7197. 

  7197. 	 * the FIX: below we may need to lock in that case.

    7198. 

  7198. 	 */

    7199. 

  7199. 	if (assoc_id == 0) {

    7200. 

  7200. 		/* add the address */

    7201. 

  7201. 		struct sctp_inpcb *lep;

    7202. 

  7202. 		struct sockaddr_in *lsin = (struct sockaddr_in *)addr_touse;

    7203. 

  7203. 

    7204. 

  7204. 		/* validate the incoming port */

    7205. 

  7205. 		if ((lsin->sin_port != 0) &&

    7206. 

  7206. 		    (lsin->sin_port != inp->sctp_lport)) {

    7207. 

  7207. 			SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTPUTIL, EINVAL);

    7208. 

  7208. 			*error = EINVAL;

    7209. 

  7209. 			return;

    7210. 

  7210. 		} else {

    7211. 

  7211. 			/* user specified 0 port, set it to existing port */

    7212. 

  7212. 			lsin->sin_port = inp->sctp_lport;

    7213. 

  7213. 		}

    7214. 

  7214. 

    7215. 

  7215. 		lep = sctp_pcb_findep(addr_touse, 1, 0, vrf_id);

    7216. 

  7216. 		if (lep != NULL) {

    7217. 

  7217. 			/*

    7218. 

  7218. 			 * We must decrement the refcount

    7219. 

  7219. 			 * since we have the ep already and

    7220. 

  7220. 			 * are binding. No remove going on

    7221. 

  7221. 			 * here.

    7222. 

  7222. 			 */

    7223. 

  7223. 			SCTP_INP_DECR_REF(lep);

    7224. 

  7224. 		}

    7225. 

  7225. 		if (lep == inp) {

    7226. 

  7226. 			/* already bound to it.. ok */

    7227. 

  7227. 			return;

    7228. 

  7228. 		} else if (lep == NULL) {

    7229. 

  7229. 			((struct sockaddr_in *)addr_touse)->sin_port = 0;

    7230. 

  7230. 			*error = sctp_addr_mgmt_ep_sa(inp, addr_touse,

    7231. 

  7231. 						      SCTP_ADD_IP_ADDRESS,

    7232. 

  7232. 						      vrf_id, NULL);

    7233. 

  7233. 		} else {

    7234. 

  7234. 			*error = EADDRINUSE;

    7235. 

  7235. 		}

    7236. 

  7236. 		if (*error)

    7237. 

  7237. 			return;

    7238. 

  7238. 	} else {

    7239. 

  7239. 		/*

    7240. 

  7240. 		 * FIX: decide whether we allow assoc based

    7241. 

  7241. 		 * bindx

    7242. 

  7242. 		 */

    7243. 

  7243. 	}

    7244. 

  7244. }

    7245. 

  7245. 

    7246. 

  7246. /*

    7247. 

  7247.  * sctp_bindx(DELETE) for one address.

    7248. 

  7248.  * assumes all arguments are valid/checked by caller.

    7249. 

  7249.  */

    7250. 

  7250. void

    7251. 

  7251. sctp_bindx_delete_address(struct sctp_inpcb *inp,

    7252. 

  7252. 			  struct sockaddr *sa, sctp_assoc_t assoc_id,

    7253. 

  7253. 			  uint32_t vrf_id, int *error)

    7254. 

  7254. {

    7255. 

  7255. 	struct sockaddr *addr_touse;

    7256. 

  7256. #ifdef INET6

    7257. 

  7257. 	struct sockaddr_in sin;

    7258. 

  7258. #endif

    7259. 

  7259. #ifdef SCTP_MVRF

    7260. 

  7260. 	int i, fnd = 0;

    7261. 

  7261. #endif

    7262. 

  7262. 

    7263. 

  7263. 	/* see if we're bound all already! */

    7264. 

  7264. 	if (inp->sctp_flags & SCTP_PCB_FLAGS_BOUNDALL) {

    7265. 

  7265. 		SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTPUTIL, EINVAL);

    7266. 

  7266. 		*error = EINVAL;

    7267. 

  7267. 		return;

    7268. 

  7268. 	}

    7269. 

  7269. #ifdef SCTP_MVRF

    7270. 

  7270. 	/* Is the VRF one we have */

    7271. 

  7271. 	for (i = 0; i < inp->num_vrfs; i++) {

    7272. 

  7272. 		if (vrf_id == inp->m_vrf_ids[i]) {

    7273. 

  7273. 			fnd = 1;

    7274. 

  7274. 			break;

    7275. 

  7275. 		}

    7276. 

  7276. 	}

    7277. 

  7277. 	if (!fnd) {

    7278. 

  7278. 		SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTPUTIL, EINVAL);

    7279. 

  7279. 		*error = EINVAL;

    7280. 

  7280. 		return;

    7281. 

  7281. 	}

    7282. 

  7282. #endif

    7283. 

  7283. 	addr_touse = sa;

    7284. 

  7284. #if defined(INET6)

    7285. 

  7285. 	if (sa->sa_family == AF_INET6) {

    7286. 

  7286. 		struct sockaddr_in6 *sin6;

    7287. 

  7287. #if !defined(__Windows__) && !defined(__Userspace_os_Linux) && !defined(__Userspace_os_Windows)

    7288. 

  7288. 		if (sa->sa_len != sizeof(struct sockaddr_in6)) {

    7289. 

  7289. 			SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTPUTIL, EINVAL);

    7290. 

  7290. 			*error = EINVAL;

    7291. 

  7291. 			return;

    7292. 

  7292. 		}

    7293. 

  7293. #endif

    7294. 

  7294. 		if ((inp->sctp_flags & SCTP_PCB_FLAGS_BOUND_V6) == 0) {

    7295. 

  7295. 			/* can only bind v6 on PF_INET6 sockets */

    7296. 

  7296. 			SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTPUTIL, EINVAL);

    7297. 

  7297. 			*error = EINVAL;

    7298. 

  7298. 			return;

    7299. 

  7299. 		}

    7300. 

  7300. 		sin6 = (struct sockaddr_in6 *)addr_touse;

    7301. 

  7301. 		if (IN6_IS_ADDR_V4MAPPED(&sin6->sin6_addr)) {

    7302. 

  7302. 			if ((inp->sctp_flags & SCTP_PCB_FLAGS_BOUND_V6) &&

    7303. 

  7303. 			    SCTP_IPV6_V6ONLY(inp)) {

    7304. 

  7304. 				/* can't bind mapped-v4 on PF_INET sockets */

    7305. 

  7305. 				SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTPUTIL, EINVAL);

    7306. 

  7306. 				*error = EINVAL;

    7307. 

  7307. 				return;

    7308. 

  7308. 			}

    7309. 

  7309. 			in6_sin6_2_sin(&sin, sin6);

    7310. 

  7310. 			addr_touse = (struct sockaddr *)&sin;

    7311. 

  7311. 		}

    7312. 

  7312. 	}

    7313. 

  7313. #endif

    7314. 

  7314. #ifdef INET

    7315. 

  7315. 	if (sa->sa_family == AF_INET) {

    7316. 

  7316. #if !defined(__Windows__) && !defined(__Userspace_os_Linux) && !defined(__Userspace_os_Windows)

    7317. 

  7317. 		if (sa->sa_len != sizeof(struct sockaddr_in)) {

    7318. 

  7318. 			SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTPUTIL, EINVAL);

    7319. 

  7319. 			*error = EINVAL;

    7320. 

  7320. 			return;

    7321. 

  7321. 		}

    7322. 

  7322. #endif

    7323. 

  7323. 		if ((inp->sctp_flags & SCTP_PCB_FLAGS_BOUND_V6) &&

    7324. 

  7324. 		    SCTP_IPV6_V6ONLY(inp)) {

    7325. 

  7325. 			/* can't bind v4 on PF_INET sockets */

    7326. 

  7326. 			SCTP_LTRACE_ERR_RET(inp, NULL, NULL, SCTP_FROM_SCTPUTIL, EINVAL);

    7327. 

  7327. 			*error = EINVAL;

    7328. 

  7328. 			return;

    7329. 

  7329. 		}

    7330. 

  7330. 	}

    7331. 

  7331. #endif

    7332. 

  7332. 	/*

    7333. 

  7333. 	 * No lock required mgmt_ep_sa does its own locking.

    7334. 

  7334. 	 * If the FIX: below is ever changed we may need to

    7335. 

  7335. 	 * lock before calling association level binding.

    7336. 

  7336. 	 */

    7337. 

  7337. 	if (assoc_id == 0) {

    7338. 

  7338. 		/* delete the address */

    7339. 

  7339. 		*error = sctp_addr_mgmt_ep_sa(inp, addr_touse,

    7340. 

  7340. 					      SCTP_DEL_IP_ADDRESS,

    7341. 

  7341. 					      vrf_id, NULL);

    7342. 

  7342. 	} else {

    7343. 

  7343. 		/*

    7344. 

  7344. 		 * FIX: decide whether we allow assoc based

    7345. 

  7345. 		 * bindx

    7346. 

  7346. 		 */

    7347. 

  7347. 	}

    7348. 

  7348. }

    7349. 

  7349. 

    7350. 

  7350. /*

    7351. 

  7351.  * returns the valid local address count for an assoc, taking into account

    7352. 

  7352.  * all scoping rules

    7353. 

  7353.  */

    7354. 

  7354. int

    7355. 

  7355. sctp_local_addr_count(struct sctp_tcb *stcb)

    7356. 

  7356. {

    7357. 

  7357. 	int loopback_scope, ipv4_local_scope, local_scope, site_scope;

    7358. 

  7358. 	int ipv4_addr_legal, ipv6_addr_legal;

    7359. 

  7359. 	struct sctp_vrf *vrf;

    7360. 

  7360. 	struct sctp_ifn *sctp_ifn;

    7361. 

  7361. 	struct sctp_ifa *sctp_ifa;

    7362. 

  7362. 	int count = 0;

    7363. 

  7363. 

    7364. 

  7364. 	/* Turn on all the appropriate scopes */

    7365. 

  7365. 	loopback_scope = stcb->asoc.loopback_scope;

    7366. 

  7366. 	ipv4_local_scope = stcb->asoc.ipv4_local_scope;

    7367. 

  7367. 	local_scope = stcb->asoc.local_scope;

    7368. 

  7368. 	site_scope = stcb->asoc.site_scope;

    7369. 

  7369. 	ipv4_addr_legal = ipv6_addr_legal = 0;

    7370. 

  7370. 	if (stcb->sctp_ep->sctp_flags & SCTP_PCB_FLAGS_BOUND_V6) {

    7371. 

  7371. 		ipv6_addr_legal = 1;

    7372. 

  7372. 		if (SCTP_IPV6_V6ONLY(stcb->sctp_ep) == 0) {

    7373. 

  7373. 			ipv4_addr_legal = 1;

    7374. 

  7374. 		}

    7375. 

  7375. 	} else {

    7376. 

  7376. 		ipv4_addr_legal = 1;

    7377. 

  7377. 	}

    7378. 

  7378. 

    7379. 

  7379. 	SCTP_IPI_ADDR_RLOCK();

    7380. 

  7380. 	vrf = sctp_find_vrf(stcb->asoc.vrf_id);

    7381. 

  7381. 	if (vrf == NULL) {

    7382. 

  7382. 		/* no vrf, no addresses */

    7383. 

  7383. 		SCTP_IPI_ADDR_RUNLOCK();

    7384. 

  7384. 		return (0);

    7385. 

  7385. 	}

    7386. 

  7386. 

    7387. 

  7387. 	if (stcb->sctp_ep->sctp_flags & SCTP_PCB_FLAGS_BOUNDALL) {

    7388. 

  7388. 		/*

    7389. 

  7389. 		 * bound all case: go through all ifns on the vrf

    7390. 

  7390. 		 */

    7391. 

  7391. 		LIST_FOREACH(sctp_ifn, &vrf->ifnlist, next_ifn) {

    7392. 

  7392. 			if ((loopback_scope == 0) &&

    7393. 

  7393. 			    SCTP_IFN_IS_IFT_LOOP(sctp_ifn)) {

    7394. 

  7394. 				continue;

    7395. 

  7395. 			}

    7396. 

  7396. 			LIST_FOREACH(sctp_ifa, &sctp_ifn->ifalist, next_ifa) {

    7397. 

  7397. 				if (sctp_is_addr_restricted(stcb, sctp_ifa))

    7398. 

  7398. 					continue;

    7399. 

  7399. 				switch (sctp_ifa->address.sa.sa_family) {

    7400. 

  7400. #ifdef INET

    7401. 

  7401. 				case AF_INET:

    7402. 

  7402. 					if (ipv4_addr_legal) {

    7403. 

  7403. 						struct sockaddr_in *sin;

    7404. 

  7404. 

    7405. 

  7405. 						sin = (struct sockaddr_in *)&sctp_ifa->address.sa;

    7406. 

  7406. 						if (sin->sin_addr.s_addr == 0) {

    7407. 

  7407. 							/* skip unspecified addrs */

    7408. 

  7408. 							continue;

    7409. 

  7409. 						}

    7410. 

  7410. 						if ((ipv4_local_scope == 0) &&

    7411. 

  7411. 						    (IN4_ISPRIVATE_ADDRESS(&sin->sin_addr))) {

    7412. 

  7412. 							continue;

    7413. 

  7413. 						}

    7414. 

  7414. 						/* count this one */

    7415. 

  7415. 						count++;

    7416. 

  7416. 					} else {

    7417. 

  7417. 						continue;

    7418. 

  7418. 					}

    7419. 

  7419. 					break;

    7420. 

  7420. #endif

    7421. 

  7421. #ifdef INET6

    7422. 

  7422. 				case AF_INET6:

    7423. 

  7423. 					if (ipv6_addr_legal) {

    7424. 

  7424. 						struct sockaddr_in6 *sin6;

    7425. 

  7425. 

    7426. 

  7426. #if defined(SCTP_EMBEDDED_V6_SCOPE) && !defined(SCTP_KAME)

    7427. 

  7427. 						struct sockaddr_in6 lsa6;

    7428. 

  7428. #endif

    7429. 

  7429. 						sin6 = (struct sockaddr_in6 *)&sctp_ifa->address.sa;

    7430. 

  7430. 						if (IN6_IS_ADDR_UNSPECIFIED(&sin6->sin6_addr)) {

    7431. 

  7431. 							continue;

    7432. 

  7432. 						}

    7433. 

  7433. 						if (IN6_IS_ADDR_LINKLOCAL(&sin6->sin6_addr)) {

    7434. 

  7434. 							if (local_scope == 0)

    7435. 

  7435. 								continue;

    7436. 

  7436. #if defined(SCTP_EMBEDDED_V6_SCOPE)

    7437. 

  7437. 							if (sin6->sin6_scope_id == 0) {

    7438. 

  7438. #ifdef SCTP_KAME

    7439. 

  7439. 								if (sa6_recoverscope(sin6) != 0)

    7440. 

  7440. 									/*

    7441. 

  7441. 									 * bad link

    7442. 

  7442. 									 * local

    7443. 

  7443. 									 * address

    7444. 

  7444. 									 */

    7445. 

  7445. 									continue;

    7446. 

  7446. #else

    7447. 

  7447. 								lsa6 = *sin6;

    7448. 

  7448. 								if (in6_recoverscope(&lsa6,

    7449. 

  7449. 								                     &lsa6.sin6_addr,

    7450. 

  7450. 								                     NULL))

    7451. 

  7451. 									/*

    7452. 

  7452. 									 * bad link

    7453. 

  7453. 									 * local

    7454. 

  7454. 									 * address

    7455. 

  7455. 									 */

    7456. 

  7456. 									continue;

    7457. 

  7457. 								sin6 = &lsa6;

    7458. 

  7458. #endif /* SCTP_KAME */

    7459. 

  7459. 							}

    7460. 

  7460. #endif /* SCTP_EMBEDDED_V6_SCOPE */

    7461. 

  7461. 						}

    7462. 

  7462. 						if ((site_scope == 0) &&

    7463. 

  7463. 						    (IN6_IS_ADDR_SITELOCAL(&sin6->sin6_addr))) {

    7464. 

  7464. 							continue;

    7465. 

  7465. 						}

    7466. 

  7466. 						/* count this one */

    7467. 

  7467. 						count++;

    7468. 

  7468. 					}

    7469. 

  7469. 					break;

    7470. 

  7470. #endif

    7471. 

  7471. 				default:

    7472. 

  7472. 					/* TSNH */

    7473. 

  7473. 					break;

    7474. 

  7474. 				}

    7475. 

  7475. 			}

    7476. 

  7476. 		}

    7477. 

  7477. 	} else {

    7478. 

  7478. 		/*

    7479. 

  7479. 		 * subset bound case

    7480. 

  7480. 		 */

    7481. 

  7481. 		struct sctp_laddr *laddr;

    7482. 

  7482. 		LIST_FOREACH(laddr, &stcb->sctp_ep->sctp_addr_list,

    7483. 

  7483. 			     sctp_nxt_addr) {

    7484. 

  7484. 			if (sctp_is_addr_restricted(stcb, laddr->ifa)) {

    7485. 

  7485. 				continue;

    7486. 

  7486. 			}

    7487. 

  7487. 			/* count this one */

    7488. 

  7488. 			count++;

    7489. 

  7489. 		}

    7490. 

  7490. 	}

    7491. 

  7491. 	SCTP_IPI_ADDR_RUNLOCK();

    7492. 

  7492. 	return (count);

    7493. 

  7493. }

    7494. 

  7494. 

    7495. 

  7495. #if defined(SCTP_LOCAL_TRACE_BUF)

    7496. 

  7496. 

    7497. 

  7497. void

    7498. 

  7498. sctp_log_trace(uint32_t subsys, const char *str SCTP_UNUSED, uint32_t a, uint32_t b, uint32_t c, uint32_t d, uint32_t e, uint32_t f)

    7499. 

  7499. {

    7500. 

  7500. 	uint32_t saveindex, newindex;

    7501. 

  7501. 

    7502. 

  7502. #if defined(__Windows__)

    7503. 

  7503. 	if (SCTP_BASE_SYSCTL(sctp_log) == NULL) {

    7504. 

  7504. 		return;

    7505. 

  7505. 	}

    7506. 

  7506. 	do {

    7507. 

  7507. 		saveindex = SCTP_BASE_SYSCTL(sctp_log)->index;

    7508. 

  7508. 		if (saveindex >= SCTP_MAX_LOGGING_SIZE) {

    7509. 

  7509. 			newindex = 1;

    7510. 

  7510. 		} else {

    7511. 

  7511. 			newindex = saveindex + 1;

    7512. 

  7512. 		}

    7513. 

  7513. 	} while (atomic_cmpset_int(&SCTP_BASE_SYSCTL(sctp_log)->index, saveindex, newindex) == 0);

    7514. 

  7514. 	if (saveindex >= SCTP_MAX_LOGGING_SIZE) {

    7515. 

  7515. 		saveindex = 0;

    7516. 

  7516. 	}

    7517. 

  7517. 	SCTP_BASE_SYSCTL(sctp_log)->entry[saveindex].timestamp = SCTP_GET_CYCLECOUNT;

    7518. 

  7518. 	SCTP_BASE_SYSCTL(sctp_log)->entry[saveindex].subsys = subsys;

    7519. 

  7519. 	SCTP_BASE_SYSCTL(sctp_log)->entry[saveindex].params[0] = a;

    7520. 

  7520. 	SCTP_BASE_SYSCTL(sctp_log)->entry[saveindex].params[1] = b;

    7521. 

  7521. 	SCTP_BASE_SYSCTL(sctp_log)->entry[saveindex].params[2] = c;

    7522. 

  7522. 	SCTP_BASE_SYSCTL(sctp_log)->entry[saveindex].params[3] = d;

    7523. 

  7523. 	SCTP_BASE_SYSCTL(sctp_log)->entry[saveindex].params[4] = e;

    7524. 

  7524. 	SCTP_BASE_SYSCTL(sctp_log)->entry[saveindex].params[5] = f;

    7525. 

  7525. #else

    7526. 

  7526. 	do {

    7527. 

  7527. 		saveindex = SCTP_BASE_SYSCTL(sctp_log).index;

    7528. 

  7528. 		if (saveindex >= SCTP_MAX_LOGGING_SIZE) {

    7529. 

  7529. 			newindex = 1;

    7530. 

  7530. 		} else {

    7531. 

  7531. 			newindex = saveindex + 1;

    7532. 

  7532. 		}

    7533. 

  7533. 	} while (atomic_cmpset_int(&SCTP_BASE_SYSCTL(sctp_log).index, saveindex, newindex) == 0);

    7534. 

  7534. 	if (saveindex >= SCTP_MAX_LOGGING_SIZE) {

    7535. 

  7535. 		saveindex = 0;

    7536. 

  7536. 	}

    7537. 

  7537. 	SCTP_BASE_SYSCTL(sctp_log).entry[saveindex].timestamp = SCTP_GET_CYCLECOUNT;

    7538. 

  7538. 	SCTP_BASE_SYSCTL(sctp_log).entry[saveindex].subsys = subsys;

    7539. 

  7539. 	SCTP_BASE_SYSCTL(sctp_log).entry[saveindex].params[0] = a;

    7540. 

  7540. 	SCTP_BASE_SYSCTL(sctp_log).entry[saveindex].params[1] = b;

    7541. 

  7541. 	SCTP_BASE_SYSCTL(sctp_log).entry[saveindex].params[2] = c;

    7542. 

  7542. 	SCTP_BASE_SYSCTL(sctp_log).entry[saveindex].params[3] = d;

    7543. 

  7543. 	SCTP_BASE_SYSCTL(sctp_log).entry[saveindex].params[4] = e;

    7544. 

  7544. 	SCTP_BASE_SYSCTL(sctp_log).entry[saveindex].params[5] = f;

    7545. 

  7545. #endif

    7546. 

  7546. }

    7547. 

  7547. 

    7548. 

  7548. #endif

    7549. 

  7549. #if defined(__FreeBSD__)

    7550. 

  7550. /* XXX: Remove the #ifdef after tunneling over IPv6 works also on FreeBSD. */

    7551. 

  7551. #ifdef INET

    7552. 

  7552. /* We will need to add support

    7553. 

  7553.  * to bind the ports and such here

    7554. 

  7554.  * so we can do UDP tunneling. In

    7555. 

  7555.  * the mean-time, we return error

    7556. 

  7556.  */

    7557. 

  7557. #include <netinet/udp.h>

    7558. 

  7558. #include <netinet/udp_var.h>

    7559. 

  7559. #include <sys/proc.h>

    7560. 

  7560. #ifdef INET6

    7561. 

  7561. #include <netinet6/sctp6_var.h>

    7562. 

  7562. #endif

    7563. 

  7563. 

    7564. 

  7564. #if __FreeBSD_version >= 800044

    7565. 

  7565. static void

    7566. 

  7566. sctp_recv_udp_tunneled_packet(struct mbuf *m, int off, struct inpcb *ignored)

    7567. 

  7567. {

    7568. 

  7568. 	struct ip *iph;

    7569. 

  7569. 	struct mbuf *sp, *last;

    7570. 

  7570. 	struct udphdr *uhdr;

    7571. 

  7571. 	uint16_t port = 0;

    7572. 

  7572. 	int header_size = sizeof(struct udphdr) + sizeof(struct sctphdr);

    7573. 

  7573. 

    7574. 

  7574. 	/* Split out the mbuf chain. Leave the

    7575. 

  7575. 	 * IP header in m, place the

    7576. 

  7576. 	 * rest in the sp.

    7577. 

  7577. 	 */

    7578. 

  7578. 	if ((m->m_flags & M_PKTHDR) == 0) {

    7579. 

  7579. 		/* Can't handle one that is not a pkt hdr */

    7580. 

  7580. 		goto out;

    7581. 

  7581. 	}

    7582. 

  7582. 	/* pull the src port */

    7583. 

  7583. 	iph = mtod(m, struct ip *);

    7584. 

  7584. 	uhdr = (struct udphdr *)((caddr_t)iph + off);

    7585. 

  7585. 

    7586. 

  7586. 	port = uhdr->uh_sport;

    7587. 

  7587. 	sp = m_split(m, off, M_DONTWAIT);

    7588. 

  7588. 	if (sp == NULL) {

    7589. 

  7589. 		/* Gak, drop packet, we can't do a split */

    7590. 

  7590. 		goto out;

    7591. 

  7591. 	}

    7592. 

  7592. 	if (sp->m_pkthdr.len < header_size) {

    7593. 

  7593. 		/* Gak, packet can't have an SCTP header in it - to small */

    7594. 

  7594. 		m_freem(sp);

    7595. 

  7595. 		goto out;

    7596. 

  7596. 	}

    7597. 

  7597. 	/* ok now pull up the UDP header and SCTP header together */

    7598. 

  7598. 	sp = m_pullup(sp, header_size);

    7599. 

  7599. 	if (sp == NULL) {

    7600. 

  7600. 		/* Gak pullup failed */

    7601. 

  7601. 		goto out;

    7602. 

  7602. 	}

    7603. 

  7603. 	/* trim out the UDP header */

    7604. 

  7604. 	m_adj(sp, sizeof(struct udphdr));

    7605. 

  7605. 

    7606. 

  7606. 	/* Now reconstruct the mbuf chain */

    7607. 

  7607. 	/* 1) find last one */

    7608. 

  7608. 	last = m;

    7609. 

  7609. 	while (last->m_next != NULL) {

    7610. 

  7610. 		last = last->m_next;

    7611. 

  7611. 	}

    7612. 

  7612. 	last->m_next = sp;

    7613. 

  7613. 	m->m_pkthdr.len += sp->m_pkthdr.len;

    7614. 

  7614. 	last = m;

    7615. 

  7615. 	while (last != NULL) {

    7616. 

  7616. 		last = last->m_next;

    7617. 

  7617. 	}

    7618. 

  7618. 	/* Now its ready for sctp_input or sctp6_input */

    7619. 

  7619. 	iph = mtod(m, struct ip *);

    7620. 

  7620. 	switch (iph->ip_v) {

    7621. 

  7621. #ifdef INET

    7622. 

  7622. 		case IPVERSION:

    7623. 

  7623. 		{

    7624. 

  7624. 			uint16_t len;

    7625. 

  7625. 

    7626. 

  7626. 			/* its IPv4 */

    7627. 

  7627. 			len = SCTP_GET_IPV4_LENGTH(iph);

    7628. 

  7628. 			len -= sizeof(struct udphdr);

    7629. 

  7629. 			SCTP_GET_IPV4_LENGTH(iph) = len;

    7630. 

  7630. 			sctp_input_with_port(m, off, port);

    7631. 

  7631. 			break;

    7632. 

  7632. 		}

    7633. 

  7633. #endif

    7634. 

  7634. #ifdef INET6

    7635. 

  7635. 		case IPV6_VERSION >> 4:

    7636. 

  7636. 		{

    7637. 

  7637. 			/* its IPv6 - NOT supported */

    7638. 

  7638. 			goto out;

    7639. 

  7639. 			break;

    7640. 

  7640. 

    7641. 

  7641. 		}

    7642. 

  7642. #endif

    7643. 

  7643. 		default:

    7644. 

  7644. 		{

    7645. 

  7645. 			m_freem(m);

    7646. 

  7646. 			break;

    7647. 

  7647. 		}

    7648. 

  7648. 	}

    7649. 

  7649. 	return;

    7650. 

  7650.  out:

    7651. 

  7651. 	m_freem(m);

    7652. 

  7652. }

    7653. 

  7653. #endif

    7654. 

  7654. 

    7655. 

  7655. void

    7656. 

  7656. sctp_over_udp_stop(void)

    7657. 

  7657. {

    7658. 

  7658. 	struct socket *sop;

    7659. 

  7659. 	/*

    7660. 

  7660. 	 * This function assumes sysctl caller holds sctp_sysctl_info_lock() for writting!

    7661. 

  7661. 	 */

    7662. 

  7662. 	if (SCTP_BASE_INFO(udp_tun_socket) == NULL) {

    7663. 

  7663. 		/* Nothing to do */

    7664. 

  7664. 		return;

    7665. 

  7665. 	}

    7666. 

  7666. 	sop = SCTP_BASE_INFO(udp_tun_socket);

    7667. 

  7667. 	soclose(sop);

    7668. 

  7668. 	SCTP_BASE_INFO(udp_tun_socket) = NULL;

    7669. 

  7669. }

    7670. 

  7670. 

    7671. 

  7671. int

    7672. 

  7672. sctp_over_udp_start(void)

    7673. 

  7673. {

    7674. 

  7674. #if __FreeBSD_version >= 800044

    7675. 

  7675. 	uint16_t port;

    7676. 

  7676. 	int ret;

    7677. 

  7677. 	struct sockaddr_in sin;

    7678. 

  7678. 	struct socket *sop = NULL;

    7679. 

  7679. 	struct thread *th;

    7680. 

  7680. 	struct ucred *cred;

    7681. 

  7681. 	/*

    7682. 

  7682. 	 * This function assumes sysctl caller holds sctp_sysctl_info_lock() for writting!

    7683. 

  7683. 	 */

    7684. 

  7684. 	port = SCTP_BASE_SYSCTL(sctp_udp_tunneling_port);

    7685. 

  7685. 	if (port == 0) {

    7686. 

  7686. 		/* Must have a port set */

    7687. 

  7687. 		return (EINVAL);

    7688. 

  7688. 	}

    7689. 

  7689. 	if (SCTP_BASE_INFO(udp_tun_socket) != NULL) {

    7690. 

  7690. 		/* Already running -- must stop first */

    7691. 

  7691. 		return (EALREADY);

    7692. 

  7692. 	}

    7693. 

  7693. 	th = curthread;

    7694. 

  7694. 	cred = th->td_ucred;

    7695. 

  7695. 	if ((ret = socreate(PF_INET, &sop,

    7696. 

  7696. 	                    SOCK_DGRAM, IPPROTO_UDP, cred, th))) {

    7697. 

  7697. 		return (ret);

    7698. 

  7698. 	}

    7699. 

  7699. 	SCTP_BASE_INFO(udp_tun_socket) = sop;

    7700. 

  7700. 	/* call the special UDP hook */

    7701. 

  7701. 	ret =  udp_set_kernel_tunneling(sop, sctp_recv_udp_tunneled_packet);

    7702. 

  7702. 	if (ret) {

    7703. 

  7703. 		goto exit_stage_left;

    7704. 

  7704. 	}

    7705. 

  7705. 	/* Ok we have a socket, bind it to the port*/

    7706. 

  7706. 	memset(&sin, 0, sizeof(sin));

    7707. 

  7707. 	sin.sin_len = sizeof(sin);

    7708. 

  7708. 	sin.sin_family = AF_INET;

    7709. 

  7709. 	sin.sin_port = htons(port);

    7710. 

  7710. 	ret = sobind(sop, (struct sockaddr *)&sin, th);

    7711. 

  7711. 	if (ret) {

    7712. 

  7712. 		/* Close up we cant get the port */

    7713. 

  7713. 		exit_stage_left:

    7714. 

  7714. 		sctp_over_udp_stop();

    7715. 

  7715. 		return (ret);

    7716. 

  7716. 	}

    7717. 

  7717. 	/* Ok we should now get UDP packets directly to our input routine

    7718. 

  7718. 	 * sctp_recv_upd_tunneled_packet().

    7719. 

  7719. 	 */

    7720. 

  7720. 	return (0);

    7721. 

  7721. #else

    7722. 

  7722. 	return (1);

    7723. 

  7723. #endif

    7724. 

  7724. }

    7725. 

  7725. #endif

    7726. 

  7726. #endif

    7727. 

  7727.