The Tor Browser / file comparison

comparison: netwerk/sctp/src/user_recv_thread.c

netwerk/sctp/src/user_recv_thread.c

branch
TOR_BUG_3246
changeset 5
4ab42b5ab56c
equal deleted inserted replaced
-1:000000000000 0:65efbf8caac5
1 /*-
2 * Copyright (c) 2009-2010 Brad Penoff
3 * Copyright (c) 2009-2010 Humaira Kamal
4 * Copyright (c) 2011-2012 Irene Ruengeler
5 * Copyright (c) 2011-2012 Michael Tuexen
6 * All rights reserved.
7 *
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
10 * are met:
11 * 1. Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in the
15 * documentation and/or other materials provided with the distribution.
16 *
17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
18 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
21 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27 * SUCH DAMAGE.
28 *
29 */
30
31 #if defined(INET) || defined(INET6)
32 #include <sys/types.h>
33 #if !defined(__Userspace_os_Windows)
34 #include <sys/socket.h>
35 #include <netinet/in.h>
36 #include <unistd.h>
37 #include <pthread.h>
38 #if !defined(__Userspace_os_DragonFly) && !defined(__Userspace_os_FreeBSD) && !defined(__Userspace_os_NetBSD)
39 #include <sys/uio.h>
40 #else
41 #include <user_ip6_var.h>
42 #endif
43 #endif
44 #include <netinet/sctp_os.h>
45 #include <netinet/sctp_var.h>
46 #include <netinet/sctp_pcb.h>
47 #include <netinet/sctp_input.h>
48 #if 0
49 #if defined(__Userspace_os_Linux)
50 #include <linux/netlink.h>
51 #ifdef HAVE_LINUX_IF_ADDR_H
52 #include <linux/if_addr.h>
53 #endif
54 #ifdef HAVE_LINUX_RTNETLINK_H
55 #include <linux/rtnetlink.h>
56 #endif
57 #endif
58 #endif
59 #if defined(__Userspace_os_Darwin) || defined(__Userspace_os_DragonFly) || defined(__Userspace_os_FreeBSD)
60 #include <net/route.h>
61 #endif
62 /* local macros and datatypes used to get IP addresses system independently */
63 #if !defined(IP_PKTINFO ) && ! defined(IP_RECVDSTADDR)
64 # error "Can't determine socket option to use to get UDP IP"
65 #endif
66
67 void recv_thread_destroy(void);
68 #define MAXLEN_MBUF_CHAIN 32 /* What should this value be? */
69 #define ROUNDUP(a, size) (((a) & ((size)-1)) ? (1 + ((a) | ((size)-1))) : (a))
70 #if defined(__Userspace_os_Darwin) || defined(__Userspace_os_DragonFly) || defined(__Userspace_os_FreeBSD)
71 #define NEXT_SA(ap) ap = (struct sockaddr *) \
72 ((caddr_t) ap + (ap->sa_len ? ROUNDUP(ap->sa_len, sizeof (uint32_t)) : sizeof(uint32_t)))
73 #endif
74
75 #if defined(__Userspace_os_Darwin) || defined(__Userspace_os_DragonFly) || defined(__Userspace_os_FreeBSD)
76 static void
77 sctp_get_rtaddrs(int addrs, struct sockaddr *sa, struct sockaddr **rti_info)
78 {
79 int i;
80
81 for (i = 0; i < RTAX_MAX; i++) {
82 if (addrs & (1 << i)) {
83 rti_info[i] = sa;
84 NEXT_SA(sa);
85 } else {
86 rti_info[i] = NULL;
87 }
88 }
89 }
90
91 static void
92 sctp_handle_ifamsg(unsigned char type, unsigned short index, struct sockaddr *sa)
93 {
94 int rc;
95 struct ifaddrs *ifa, *found_ifa = NULL;
96
97 /* handle only the types we want */
98 if ((type != RTM_NEWADDR) && (type != RTM_DELADDR)) {
99 return;
100 }
101
102 rc = getifaddrs(&g_interfaces);
103 if (rc != 0) {
104 return;
105 }
106 for (ifa = g_interfaces; ifa; ifa = ifa->ifa_next) {
107 if (index == if_nametoindex(ifa->ifa_name)) {
108 found_ifa = ifa;
109 break;
110 }
111 }
112 if (found_ifa == NULL) {
113 return;
114 }
115
116 switch (sa->sa_family) {
117 #ifdef INET
118 case AF_INET:
119 ifa->ifa_addr = (struct sockaddr *)malloc(sizeof(struct sockaddr_in));
120 memcpy(ifa->ifa_addr, sa, sizeof(struct sockaddr_in));
121 break;
122 #endif
123 #ifdef INET6
124 case AF_INET6:
125 ifa->ifa_addr = (struct sockaddr *)malloc(sizeof(struct sockaddr_in6));
126 memcpy(ifa->ifa_addr, sa, sizeof(struct sockaddr_in6));
127 break;
128 #endif
129 default:
130 SCTPDBG(SCTP_DEBUG_USR, "Address family %d not supported.\n", sa->sa_family);
131 }
132
133 /* relay the appropriate address change to the base code */
134 if (type == RTM_NEWADDR) {
135 (void)sctp_add_addr_to_vrf(SCTP_DEFAULT_VRFID, ifa, if_nametoindex(ifa->ifa_name),
136 0,
137 ifa->ifa_name,
138 (void *)ifa,
139 ifa->ifa_addr,
140 0,
141 1);
142 } else {
143 sctp_del_addr_from_vrf(SCTP_DEFAULT_VRFID, ifa->ifa_addr,
144 if_nametoindex(ifa->ifa_name),
145 ifa->ifa_name);
146 }
147 }
148
149 static void *
150 recv_function_route(void *arg)
151 {
152 ssize_t ret;
153 struct ifa_msghdr *ifa;
154 char rt_buffer[1024];
155 struct sockaddr *sa, *rti_info[RTAX_MAX];
156
157 while (1) {
158 bzero(rt_buffer, sizeof(rt_buffer));
159 ret = recv(SCTP_BASE_VAR(userspace_route), rt_buffer, sizeof(rt_buffer), 0);
160
161 if (ret > 0) {
162 ifa = (struct ifa_msghdr *) rt_buffer;
163 if (ifa->ifam_type != RTM_DELADDR && ifa->ifam_type != RTM_NEWADDR) {
164 continue;
165 }
166 sa = (struct sockaddr *) (ifa + 1);
167 sctp_get_rtaddrs(ifa->ifam_addrs, sa, rti_info);
168 switch (ifa->ifam_type) {
169 case RTM_DELADDR:
170 case RTM_NEWADDR:
171 sctp_handle_ifamsg(ifa->ifam_type, ifa->ifam_index, rti_info[RTAX_IFA]);
172 break;
173 default:
174 /* ignore this routing event */
175 break;
176 }
177 }
178 if (ret < 0) {
179 if (errno == EAGAIN) {
180 continue;
181 } else {
182 break;
183 }
184 }
185 }
186 return (NULL);
187 }
188 #endif
189
190 #if 0
191 /* This does not yet work on Linux */
192 static void *
193 recv_function_route(void *arg)
194 {
195 int len;
196 char buf[4096];
197 struct iovec iov = { buf, sizeof(buf) };
198 struct msghdr msg;
199 struct nlmsghdr *nh;
200 struct ifaddrmsg *rtmsg;
201 struct rtattr *rtatp;
202 struct in_addr *inp;
203 struct sockaddr_nl sanl;
204 #ifdef INET
205 struct sockaddr_in *sa;
206 #endif
207 #ifdef INET6
208 struct sockaddr_in6 *sa6;
209 #endif
210
211 for (;;) {
212 memset(&sanl, 0, sizeof(sanl));
213 sanl.nl_family = AF_NETLINK;
214 sanl.nl_groups = RTMGRP_IPV6_IFADDR | RTMGRP_IPV4_IFADDR;
215 memset(&msg, 0, sizeof(struct msghdr));
216 msg.msg_name = (void *)&sanl;
217 msg.msg_namelen = sizeof(sanl);
218 msg.msg_iov = &iov;
219 msg.msg_iovlen = 1;
220 msg.msg_control = NULL;
221 msg.msg_controllen = 0;
222
223 len = recvmsg(SCTP_BASE_VAR(userspace_route), &msg, 0);
224
225 if (len < 0) {
226 if (errno == EAGAIN) {
227 continue;
228 } else {
229 break;
230 }
231 }
232 for (nh = (struct nlmsghdr *) buf; NLMSG_OK (nh, len);
233 nh = NLMSG_NEXT (nh, len)) {
234 if (nh->nlmsg_type == NLMSG_DONE)
235 break;
236
237 if (nh->nlmsg_type == RTM_NEWADDR || nh->nlmsg_type == RTM_DELADDR) {
238 rtmsg = (struct ifaddrmsg *)NLMSG_DATA(nh);
239 rtatp = (struct rtattr *)IFA_RTA(rtmsg);
240 if(rtatp->rta_type == IFA_ADDRESS) {
241 inp = (struct in_addr *)RTA_DATA(rtatp);
242 switch (rtmsg->ifa_family) {
243 #ifdef INET
244 case AF_INET:
245 sa = (struct sockaddr_in *)malloc(sizeof(struct sockaddr_in));
246 sa->sin_family = rtmsg->ifa_family;
247 sa->sin_port = 0;
248 memcpy(&sa->sin_addr, inp, sizeof(struct in_addr));
249 sctp_handle_ifamsg(nh->nlmsg_type, rtmsg->ifa_index, (struct sockaddr *)sa);
250 break;
251 #endif
252 #ifdef INET6
253 case AF_INET6:
254 sa6 = (struct sockaddr_in6 *)malloc(sizeof(struct sockaddr_in6));
255 sa6->sin6_family = rtmsg->ifa_family;
256 sa6->sin6_port = 0;
257 memcpy(&sa6->sin6_addr, inp, sizeof(struct in6_addr));
258 sctp_handle_ifamsg(nh->nlmsg_type, rtmsg->ifa_index, (struct sockaddr *)sa6);
259 break;
260 #endif
261 default:
262 SCTPDBG(SCTP_DEBUG_USR, "Address family %d not supported.\n", rtmsg->ifa_family);
263 break;
264 }
265 }
266 }
267 }
268 }
269 return (NULL);
270 }
271 #endif
272
273 #ifdef INET
274 static void *
275 recv_function_raw(void *arg)
276 {
277 struct mbuf **recvmbuf;
278 struct ip *iphdr;
279 struct sctphdr *sh;
280 uint16_t port;
281 int offset, ecn = 0;
282 #if !defined(SCTP_WITH_NO_CSUM)
283 int compute_crc = 1;
284 #endif
285 struct sctp_chunkhdr *ch;
286 struct sockaddr_in src, dst;
287 #if !defined(__Userspace_os_Windows)
288 struct msghdr msg;
289 struct iovec recv_iovec[MAXLEN_MBUF_CHAIN];
290 #else
291 WSABUF recv_iovec[MAXLEN_MBUF_CHAIN];
292 int nResult, m_ErrorCode;
293 DWORD flags;
294 struct sockaddr_in from;
295 int fromlen;
296 #endif
297
298 /*Initially the entire set of mbufs is to be allocated.
299 to_fill indicates this amount. */
300 int to_fill = MAXLEN_MBUF_CHAIN;
301 /* iovlen is the size of each mbuf in the chain */
302 int i, n, ncounter = 0;
303 int iovlen = MCLBYTES;
304 int want_ext = (iovlen > MLEN)? 1 : 0;
305 int want_header = 0;
306
307 bzero((void *)&src, sizeof(struct sockaddr_in));
308 bzero((void *)&dst, sizeof(struct sockaddr_in));
309
310 recvmbuf = malloc(sizeof(struct mbuf *) * MAXLEN_MBUF_CHAIN);
311
312 while (1) {
313 for (i = 0; i < to_fill; i++) {
314 /* Not getting the packet header. Tests with chain of one run
315 as usual without having the packet header.
316 Have tried both sending and receiving
317 */
318 recvmbuf[i] = sctp_get_mbuf_for_msg(iovlen, want_header, M_NOWAIT, want_ext, MT_DATA);
319 #if !defined(__Userspace_os_Windows)
320 recv_iovec[i].iov_base = (caddr_t)recvmbuf[i]->m_data;
321 recv_iovec[i].iov_len = iovlen;
322 #else
323 recv_iovec[i].buf = (caddr_t)recvmbuf[i]->m_data;
324 recv_iovec[i].len = iovlen;
325 #endif
326 }
327 to_fill = 0;
328 #if defined(__Userspace_os_Windows)
329 flags = 0;
330 ncounter = 0;
331 fromlen = sizeof(struct sockaddr_in);
332 bzero((void *)&from, sizeof(struct sockaddr_in));
333
334 nResult = WSARecvFrom(SCTP_BASE_VAR(userspace_rawsctp), recv_iovec, MAXLEN_MBUF_CHAIN, (LPDWORD)&ncounter, (LPDWORD)&flags, (struct sockaddr*)&from, &fromlen, NULL, NULL);
335 if (nResult != 0) {
336 m_ErrorCode = WSAGetLastError();
337 if (m_ErrorCode == WSAETIMEDOUT) {
338 continue;
339 }
340 if ((m_ErrorCode == WSAENOTSOCK) || (m_ErrorCode == WSAEINTR)) {
341 break;
342 }
343 }
344 n = ncounter;
345 #else
346 bzero((void *)&msg, sizeof(struct msghdr));
347 msg.msg_name = NULL;
348 msg.msg_namelen = 0;
349 msg.msg_iov = recv_iovec;
350 msg.msg_iovlen = MAXLEN_MBUF_CHAIN;
351 msg.msg_control = NULL;
352 msg.msg_controllen = 0;
353 ncounter = n = recvmsg(SCTP_BASE_VAR(userspace_rawsctp), &msg, 0);
354 if (n < 0) {
355 if (errno == EAGAIN) {
356 continue;
357 } else {
358 break;
359 }
360 }
361 #endif
362 SCTP_HEADER_LEN(recvmbuf[0]) = n; /* length of total packet */
363 SCTP_STAT_INCR(sctps_recvpackets);
364 SCTP_STAT_INCR_COUNTER64(sctps_inpackets);
365
366 if (n <= iovlen) {
367 SCTP_BUF_LEN(recvmbuf[0]) = n;
368 (to_fill)++;
369 } else {
370 i = 0;
371 SCTP_BUF_LEN(recvmbuf[0]) = iovlen;
372
373 ncounter -= iovlen;
374 (to_fill)++;
375 do {
376 recvmbuf[i]->m_next = recvmbuf[i+1];
377 SCTP_BUF_LEN(recvmbuf[i]->m_next) = min(ncounter, iovlen);
378 i++;
379 ncounter -= iovlen;
380 (to_fill)++;
381 } while (ncounter > 0);
382 }
383
384 iphdr = mtod(recvmbuf[0], struct ip *);
385 sh = (struct sctphdr *)((caddr_t)iphdr + sizeof(struct ip));
386 ch = (struct sctp_chunkhdr *)((caddr_t)sh + sizeof(struct sctphdr));
387 offset = sizeof(struct ip) + sizeof(struct sctphdr);
388
389 if (iphdr->ip_tos != 0) {
390 ecn = iphdr->ip_tos & 0x02;
391 }
392
393 dst.sin_family = AF_INET;
394 #ifdef HAVE_SIN_LEN
395 dst.sin_len = sizeof(struct sockaddr_in);
396 #endif
397 dst.sin_addr = iphdr->ip_dst;
398 dst.sin_port = sh->dest_port;
399
400 src.sin_family = AF_INET;
401 #ifdef HAVE_SIN_LEN
402 src.sin_len = sizeof(struct sockaddr_in);
403 #endif
404 src.sin_addr = iphdr->ip_src;
405 src.sin_port = sh->src_port;
406
407 /* SCTP does not allow broadcasts or multicasts */
408 if (IN_MULTICAST(ntohl(dst.sin_addr.s_addr))) {
409 return (NULL);
410 }
411 if (SCTP_IS_IT_BROADCAST(dst.sin_addr, recvmbuf[0])) {
412 return (NULL);
413 }
414
415 port = 0;
416
417 #if defined(SCTP_WITH_NO_CSUM)
418 SCTP_STAT_INCR(sctps_recvnocrc);
419 #else
420 if (src.sin_addr.s_addr == dst.sin_addr.s_addr) {
421 compute_crc = 0;
422 SCTP_STAT_INCR(sctps_recvnocrc);
423 } else {
424 SCTP_STAT_INCR(sctps_recvswcrc);
425 }
426 #endif
427 SCTPDBG(SCTP_DEBUG_USR, "%s: Received %d bytes.", __func__, n);
428 SCTPDBG(SCTP_DEBUG_USR, " - calling sctp_common_input_processing with off=%d\n", offset);
429 sctp_common_input_processing(&recvmbuf[0], sizeof(struct ip), offset, n,
430 (struct sockaddr *)&src,
431 (struct sockaddr *)&dst,
432 sh, ch,
433 #if !defined(SCTP_WITH_NO_CSUM)
434 compute_crc,
435 #endif
436 ecn,
437 SCTP_DEFAULT_VRFID, port);
438 if (recvmbuf[0]) {
439 m_freem(recvmbuf[0]);
440 }
441 }
442 for (i = 0; i < MAXLEN_MBUF_CHAIN; i++) {
443 m_free(recvmbuf[i]);
444 }
445 /* free the array itself */
446 free(recvmbuf);
447 return (NULL);
448 }
449 #endif
450
451 #if defined(INET6)
452 static void *
453 recv_function_raw6(void *arg)
454 {
455 struct mbuf **recvmbuf6;
456 #if !defined(__Userspace_os_Windows)
457 struct iovec recv_iovec[MAXLEN_MBUF_CHAIN];
458 struct msghdr msg;
459 struct cmsghdr *cmsgptr;
460 char cmsgbuf[CMSG_SPACE(sizeof (struct in6_pktinfo))];
461 #else
462 WSABUF recv_iovec[MAXLEN_MBUF_CHAIN];
463 int nResult, m_ErrorCode;
464 DWORD flags;
465 struct sockaddr_in6 from;
466 int fromlen;
467 GUID WSARecvMsg_GUID = WSAID_WSARECVMSG;
468 LPFN_WSARECVMSG WSARecvMsg;
469 WSACMSGHDR *cmsgptr;
470 WSAMSG msg;
471 char ControlBuffer[1024];
472 #endif
473 struct sockaddr_in6 src, dst;
474 struct sctphdr *sh;
475 int offset;
476 struct sctp_chunkhdr *ch;
477
478 /*Initially the entire set of mbufs is to be allocated.
479 to_fill indicates this amount. */
480 int to_fill = MAXLEN_MBUF_CHAIN;
481 /* iovlen is the size of each mbuf in the chain */
482 int i, n, ncounter = 0;
483 #if !defined(SCTP_WITH_NO_CSUM)
484 int compute_crc = 1;
485 #endif
486 int iovlen = MCLBYTES;
487 int want_ext = (iovlen > MLEN)? 1 : 0;
488 int want_header = 0;
489
490 recvmbuf6 = malloc(sizeof(struct mbuf *) * MAXLEN_MBUF_CHAIN);
491
492 for (;;) {
493 for (i = 0; i < to_fill; i++) {
494 /* Not getting the packet header. Tests with chain of one run
495 as usual without having the packet header.
496 Have tried both sending and receiving
497 */
498 recvmbuf6[i] = sctp_get_mbuf_for_msg(iovlen, want_header, M_NOWAIT, want_ext, MT_DATA);
499 #if !defined(__Userspace_os_Windows)
500 recv_iovec[i].iov_base = (caddr_t)recvmbuf6[i]->m_data;
501 recv_iovec[i].iov_len = iovlen;
502 #else
503 recv_iovec[i].buf = (caddr_t)recvmbuf6[i]->m_data;
504 recv_iovec[i].len = iovlen;
505 #endif
506 }
507 to_fill = 0;
508 #if defined(__Userspace_os_Windows)
509 flags = 0;
510 ncounter = 0;
511 fromlen = sizeof(struct sockaddr_in6);
512 bzero((void *)&from, sizeof(struct sockaddr_in6));
513 nResult = WSAIoctl(SCTP_BASE_VAR(userspace_rawsctp6), SIO_GET_EXTENSION_FUNCTION_POINTER,
514 &WSARecvMsg_GUID, sizeof WSARecvMsg_GUID,
515 &WSARecvMsg, sizeof WSARecvMsg,
516 &ncounter, NULL, NULL);
517 if (nResult == 0) {
518 msg.name = (void *)&src;
519 msg.namelen = sizeof(struct sockaddr_in6);
520 msg.lpBuffers = recv_iovec;
521 msg.dwBufferCount = MAXLEN_MBUF_CHAIN;
522 msg.Control.len = sizeof ControlBuffer;
523 msg.Control.buf = ControlBuffer;
524 msg.dwFlags = 0;
525 nResult = WSARecvMsg(SCTP_BASE_VAR(userspace_rawsctp6), &msg, &ncounter, NULL, NULL);
526 }
527 if (nResult != 0) {
528 m_ErrorCode = WSAGetLastError();
529 if (m_ErrorCode == WSAETIMEDOUT)
530 continue;
531 if (m_ErrorCode == WSAENOTSOCK || m_ErrorCode == WSAEINTR)
532 break;
533 }
534 n = ncounter;
535 #else
536 bzero((void *)&msg, sizeof(struct msghdr));
537 bzero((void *)&src, sizeof(struct sockaddr_in6));
538 bzero((void *)&dst, sizeof(struct sockaddr_in6));
539 bzero((void *)cmsgbuf, CMSG_SPACE(sizeof (struct in6_pktinfo)));
540 msg.msg_name = (void *)&src;
541 msg.msg_namelen = sizeof(struct sockaddr_in6);
542 msg.msg_iov = recv_iovec;
543 msg.msg_iovlen = MAXLEN_MBUF_CHAIN;
544 msg.msg_control = (void *)cmsgbuf;
545 msg.msg_controllen = (socklen_t)CMSG_LEN(sizeof (struct in6_pktinfo));
546 msg.msg_flags = 0;
547
548 ncounter = n = recvmsg(SCTP_BASE_VAR(userspace_rawsctp6), &msg, 0);
549 if (n < 0) {
550 if (errno == EAGAIN) {
551 continue;
552 } else {
553 break;
554 }
555 }
556 #endif
557 SCTP_HEADER_LEN(recvmbuf6[0]) = n; /* length of total packet */
558 SCTP_STAT_INCR(sctps_recvpackets);
559 SCTP_STAT_INCR_COUNTER64(sctps_inpackets);
560
561 if (n <= iovlen) {
562 SCTP_BUF_LEN(recvmbuf6[0]) = n;
563 (to_fill)++;
564 } else {
565 i = 0;
566 SCTP_BUF_LEN(recvmbuf6[0]) = iovlen;
567
568 ncounter -= iovlen;
569 (to_fill)++;
570 do {
571 recvmbuf6[i]->m_next = recvmbuf6[i+1];
572 SCTP_BUF_LEN(recvmbuf6[i]->m_next) = min(ncounter, iovlen);
573 i++;
574 ncounter -= iovlen;
575 (to_fill)++;
576 } while (ncounter > 0);
577 }
578
579 for (cmsgptr = CMSG_FIRSTHDR(&msg); cmsgptr != NULL; cmsgptr = CMSG_NXTHDR(&msg, cmsgptr)) {
580 if ((cmsgptr->cmsg_level == IPPROTO_IPV6) && (cmsgptr->cmsg_type == IPV6_PKTINFO)) {
581 struct in6_pktinfo * info;
582
583 info = (struct in6_pktinfo *)CMSG_DATA(cmsgptr);
584 memcpy((void *)&dst.sin6_addr, (const void *) &(info->ipi6_addr), sizeof(struct in6_addr));
585 break;
586 }
587 }
588
589 sh = mtod(recvmbuf6[0], struct sctphdr *);
590 ch = (struct sctp_chunkhdr *)((caddr_t)sh + sizeof(struct sctphdr));
591 offset = sizeof(struct sctphdr);
592
593 dst.sin6_family = AF_INET6;
594 #ifdef HAVE_SIN6_LEN
595 dst.sin6_len = sizeof(struct sockaddr_in6);
596 #endif
597 dst.sin6_port = sh->dest_port;
598
599 src.sin6_family = AF_INET6;
600 #ifdef HAVE_SIN6_LEN
601 src.sin6_len = sizeof(struct sockaddr_in6);
602 #endif
603 src.sin6_port = sh->src_port;
604 #if defined(SCTP_WITH_NO_CSUM)
605 SCTP_STAT_INCR(sctps_recvnocrc);
606 #else
607 if (memcmp(&src.sin6_addr, &dst.sin6_addr, sizeof(struct in6_addr)) == 0) {
608 compute_crc = 0;
609 SCTP_STAT_INCR(sctps_recvnocrc);
610 } else {
611 SCTP_STAT_INCR(sctps_recvswcrc);
612 }
613 #endif
614 SCTPDBG(SCTP_DEBUG_USR, "%s: Received %d bytes.", __func__, n);
615 SCTPDBG(SCTP_DEBUG_USR, " - calling sctp_common_input_processing with off=%d\n", offset);
616 sctp_common_input_processing(&recvmbuf6[0], 0, offset, n,
617 (struct sockaddr *)&src,
618 (struct sockaddr *)&dst,
619 sh, ch,
620 #if !defined(SCTP_WITH_NO_CSUM)
621 compute_crc,
622 #endif
623 0,
624 SCTP_DEFAULT_VRFID, 0);
625 if (recvmbuf6[0]) {
626 m_freem(recvmbuf6[0]);
627 }
628 }
629 for (i = 0; i < MAXLEN_MBUF_CHAIN; i++) {
630 m_free(recvmbuf6[i]);
631 }
632 /* free the array itself */
633 free(recvmbuf6);
634 return (NULL);
635 }
636 #endif
637
638 #ifdef INET
639 static void *
640 recv_function_udp(void *arg)
641 {
642 struct mbuf **udprecvmbuf;
643 /*Initially the entire set of mbufs is to be allocated.
644 to_fill indicates this amount. */
645 int to_fill = MAXLEN_MBUF_CHAIN;
646 /* iovlen is the size of each mbuf in the chain */
647 int i, n, ncounter, offset;
648 int iovlen = MCLBYTES;
649 int want_ext = (iovlen > MLEN)? 1 : 0;
650 int want_header = 0;
651 struct sctphdr *sh;
652 uint16_t port;
653 struct sctp_chunkhdr *ch;
654 struct sockaddr_in src, dst;
655 #if defined(IP_PKTINFO)
656 char cmsgbuf[CMSG_SPACE(sizeof(struct in_pktinfo))];
657 #else
658 char cmsgbuf[CMSG_SPACE(sizeof(struct in_addr))];
659 #endif
660 #if !defined(SCTP_WITH_NO_CSUM)
661 int compute_crc = 1;
662 #endif
663 #if !defined(__Userspace_os_Windows)
664 struct iovec iov[MAXLEN_MBUF_CHAIN];
665 struct msghdr msg;
666 struct cmsghdr *cmsgptr;
667 #else
668 GUID WSARecvMsg_GUID = WSAID_WSARECVMSG;
669 LPFN_WSARECVMSG WSARecvMsg;
670 char ControlBuffer[1024];
671 WSABUF iov[MAXLEN_MBUF_CHAIN];
672 WSAMSG msg;
673 int nResult, m_ErrorCode;
674 WSACMSGHDR *cmsgptr;
675 #endif
676
677 udprecvmbuf = malloc(sizeof(struct mbuf *) * MAXLEN_MBUF_CHAIN);
678
679 while (1) {
680 for (i = 0; i < to_fill; i++) {
681 /* Not getting the packet header. Tests with chain of one run
682 as usual without having the packet header.
683 Have tried both sending and receiving
684 */
685 udprecvmbuf[i] = sctp_get_mbuf_for_msg(iovlen, want_header, M_NOWAIT, want_ext, MT_DATA);
686 #if !defined(__Userspace_os_Windows)
687 iov[i].iov_base = (caddr_t)udprecvmbuf[i]->m_data;
688 iov[i].iov_len = iovlen;
689 #else
690 iov[i].buf = (caddr_t)udprecvmbuf[i]->m_data;
691 iov[i].len = iovlen;
692 #endif
693 }
694 to_fill = 0;
695 #if !defined(__Userspace_os_Windows)
696 bzero((void *)&msg, sizeof(struct msghdr));
697 #else
698 bzero((void *)&msg, sizeof(WSAMSG));
699 #endif
700 bzero((void *)&src, sizeof(struct sockaddr_in));
701 bzero((void *)&dst, sizeof(struct sockaddr_in));
702 bzero((void *)cmsgbuf, sizeof(cmsgbuf));
703
704 #if !defined(__Userspace_os_Windows)
705 msg.msg_name = (void *)&src;
706 msg.msg_namelen = sizeof(struct sockaddr_in);
707 msg.msg_iov = iov;
708 msg.msg_iovlen = MAXLEN_MBUF_CHAIN;
709 msg.msg_control = (void *)cmsgbuf;
710 msg.msg_controllen = sizeof(cmsgbuf);
711 msg.msg_flags = 0;
712
713 ncounter = n = recvmsg(SCTP_BASE_VAR(userspace_udpsctp), &msg, 0);
714 if (n < 0) {
715 if (errno == EAGAIN) {
716 continue;
717 } else {
718 break;
719 }
720 }
721 #else
722 nResult = WSAIoctl(SCTP_BASE_VAR(userspace_udpsctp), SIO_GET_EXTENSION_FUNCTION_POINTER,
723 &WSARecvMsg_GUID, sizeof WSARecvMsg_GUID,
724 &WSARecvMsg, sizeof WSARecvMsg,
725 &ncounter, NULL, NULL);
726 if (nResult == 0) {
727 msg.name = (void *)&src;
728 msg.namelen = sizeof(struct sockaddr_in);
729 msg.lpBuffers = iov;
730 msg.dwBufferCount = MAXLEN_MBUF_CHAIN;
731 msg.Control.len = sizeof ControlBuffer;
732 msg.Control.buf = ControlBuffer;
733 msg.dwFlags = 0;
734 nResult = WSARecvMsg(SCTP_BASE_VAR(userspace_udpsctp), &msg, &ncounter, NULL, NULL);
735 }
736 if (nResult != 0) {
737 m_ErrorCode = WSAGetLastError();
738 if (m_ErrorCode == WSAETIMEDOUT) {
739 continue;
740 }
741 if ((m_ErrorCode == WSAENOTSOCK) || (m_ErrorCode == WSAEINTR)) {
742 break;
743 }
744 }
745 n = ncounter;
746 #endif
747 SCTP_HEADER_LEN(udprecvmbuf[0]) = n; /* length of total packet */
748 SCTP_STAT_INCR(sctps_recvpackets);
749 SCTP_STAT_INCR_COUNTER64(sctps_inpackets);
750
751 if (n <= iovlen) {
752 SCTP_BUF_LEN(udprecvmbuf[0]) = n;
753 (to_fill)++;
754 } else {
755 i = 0;
756 SCTP_BUF_LEN(udprecvmbuf[0]) = iovlen;
757
758 ncounter -= iovlen;
759 (to_fill)++;
760 do {
761 udprecvmbuf[i]->m_next = udprecvmbuf[i+1];
762 SCTP_BUF_LEN(udprecvmbuf[i]->m_next) = min(ncounter, iovlen);
763 i++;
764 ncounter -= iovlen;
765 (to_fill)++;
766 } while (ncounter > 0);
767 }
768
769 for (cmsgptr = CMSG_FIRSTHDR(&msg); cmsgptr != NULL; cmsgptr = CMSG_NXTHDR(&msg, cmsgptr)) {
770 #if defined(IP_PKTINFO)
771 if ((cmsgptr->cmsg_level == IPPROTO_IP) && (cmsgptr->cmsg_type == IP_PKTINFO)) {
772 struct in_pktinfo *info;
773
774 dst.sin_family = AF_INET;
775 #ifdef HAVE_SIN_LEN
776 dst.sin_len = sizeof(struct sockaddr_in);
777 #endif
778 info = (struct in_pktinfo *)CMSG_DATA(cmsgptr);
779 memcpy((void *)&dst.sin_addr, (const void *)&(info->ipi_addr), sizeof(struct in_addr));
780 break;
781 }
782 #else
783 if ((cmsgptr->cmsg_level == IPPROTO_IP) && (cmsgptr->cmsg_type == IP_RECVDSTADDR)) {
784 struct in_addr *addr;
785
786 dst.sin_family = AF_INET;
787 #ifdef HAVE_SIN_LEN
788 dst.sin_len = sizeof(struct sockaddr_in);
789 #endif
790 addr = (struct in_addr *)CMSG_DATA(cmsgptr);
791 memcpy((void *)&dst.sin_addr, (const void *)addr, sizeof(struct in_addr));
792 break;
793 }
794 #endif
795 }
796
797 /* SCTP does not allow broadcasts or multicasts */
798 if (IN_MULTICAST(ntohl(dst.sin_addr.s_addr))) {
799 return (NULL);
800 }
801 if (SCTP_IS_IT_BROADCAST(dst.sin_addr, udprecvmbuf[0])) {
802 return (NULL);
803 }
804
805 /*offset = sizeof(struct sctphdr) + sizeof(struct sctp_chunkhdr);*/
806 sh = mtod(udprecvmbuf[0], struct sctphdr *);
807 ch = (struct sctp_chunkhdr *)((caddr_t)sh + sizeof(struct sctphdr));
808 offset = sizeof(struct sctphdr);
809 port = src.sin_port;
810 src.sin_port = sh->src_port;
811 dst.sin_port = sh->dest_port;
812 #if defined(SCTP_WITH_NO_CSUM)
813 SCTP_STAT_INCR(sctps_recvnocrc);
814 #else
815 if (src.sin_addr.s_addr == dst.sin_addr.s_addr) {
816 compute_crc = 0;
817 SCTP_STAT_INCR(sctps_recvnocrc);
818 } else {
819 SCTP_STAT_INCR(sctps_recvswcrc);
820 }
821 #endif
822 SCTPDBG(SCTP_DEBUG_USR, "%s: Received %d bytes.", __func__, n);
823 SCTPDBG(SCTP_DEBUG_USR, " - calling sctp_common_input_processing with off=%d\n", offset);
824 sctp_common_input_processing(&udprecvmbuf[0], 0, offset, n,
825 (struct sockaddr *)&src,
826 (struct sockaddr *)&dst,
827 sh, ch,
828 #if !defined(SCTP_WITH_NO_CSUM)
829 compute_crc,
830 #endif
831 0,
832 SCTP_DEFAULT_VRFID, port);
833 if (udprecvmbuf[0]) {
834 m_freem(udprecvmbuf[0]);
835 }
836 }
837 for (i = 0; i < MAXLEN_MBUF_CHAIN; i++) {
838 m_free(udprecvmbuf[i]);
839 }
840 /* free the array itself */
841 free(udprecvmbuf);
842 return (NULL);
843 }
844 #endif
845
846 #if defined(INET6)
847 static void *
848 recv_function_udp6(void *arg)
849 {
850 struct mbuf **udprecvmbuf6;
851 /*Initially the entire set of mbufs is to be allocated.
852 to_fill indicates this amount. */
853 int to_fill = MAXLEN_MBUF_CHAIN;
854 /* iovlen is the size of each mbuf in the chain */
855 int i, n, ncounter, offset;
856 int iovlen = MCLBYTES;
857 int want_ext = (iovlen > MLEN)? 1 : 0;
858 int want_header = 0;
859 struct sockaddr_in6 src, dst;
860 struct sctphdr *sh;
861 uint16_t port;
862 struct sctp_chunkhdr *ch;
863 char cmsgbuf[CMSG_SPACE(sizeof (struct in6_pktinfo))];
864 #if !defined(SCTP_WITH_NO_CSUM)
865 int compute_crc = 1;
866 #endif
867 #if !defined(__Userspace_os_Windows)
868 struct iovec iov[MAXLEN_MBUF_CHAIN];
869 struct msghdr msg;
870 struct cmsghdr *cmsgptr;
871 #else
872 GUID WSARecvMsg_GUID = WSAID_WSARECVMSG;
873 LPFN_WSARECVMSG WSARecvMsg;
874 char ControlBuffer[1024];
875 WSABUF iov[MAXLEN_MBUF_CHAIN];
876 WSAMSG msg;
877 int nResult, m_ErrorCode;
878 WSACMSGHDR *cmsgptr;
879 #endif
880
881 udprecvmbuf6 = malloc(sizeof(struct mbuf *) * MAXLEN_MBUF_CHAIN);
882 while (1) {
883 for (i = 0; i < to_fill; i++) {
884 /* Not getting the packet header. Tests with chain of one run
885 as usual without having the packet header.
886 Have tried both sending and receiving
887 */
888 udprecvmbuf6[i] = sctp_get_mbuf_for_msg(iovlen, want_header, M_NOWAIT, want_ext, MT_DATA);
889 #if !defined(__Userspace_os_Windows)
890 iov[i].iov_base = (caddr_t)udprecvmbuf6[i]->m_data;
891 iov[i].iov_len = iovlen;
892 #else
893 iov[i].buf = (caddr_t)udprecvmbuf6[i]->m_data;
894 iov[i].len = iovlen;
895 #endif
896 }
897 to_fill = 0;
898
899 #if !defined(__Userspace_os_Windows)
900 bzero((void *)&msg, sizeof(struct msghdr));
901 #else
902 bzero((void *)&msg, sizeof(WSAMSG));
903 #endif
904 bzero((void *)&src, sizeof(struct sockaddr_in6));
905 bzero((void *)&dst, sizeof(struct sockaddr_in6));
906 bzero((void *)cmsgbuf, CMSG_SPACE(sizeof (struct in6_pktinfo)));
907
908 #if !defined(__Userspace_os_Windows)
909 msg.msg_name = (void *)&src;
910 msg.msg_namelen = sizeof(struct sockaddr_in6);
911 msg.msg_iov = iov;
912 msg.msg_iovlen = MAXLEN_MBUF_CHAIN;
913 msg.msg_control = (void *)cmsgbuf;
914 msg.msg_controllen = (socklen_t)CMSG_LEN(sizeof (struct in6_pktinfo));
915 msg.msg_flags = 0;
916
917 ncounter = n = recvmsg(SCTP_BASE_VAR(userspace_udpsctp6), &msg, 0);
918 if (n < 0) {
919 if (errno == EAGAIN) {
920 continue;
921 } else {
922 break;
923 }
924 }
925 #else
926 nResult = WSAIoctl(SCTP_BASE_VAR(userspace_udpsctp6), SIO_GET_EXTENSION_FUNCTION_POINTER,
927 &WSARecvMsg_GUID, sizeof WSARecvMsg_GUID,
928 &WSARecvMsg, sizeof WSARecvMsg,
929 &ncounter, NULL, NULL);
930 if (nResult == SOCKET_ERROR) {
931 m_ErrorCode = WSAGetLastError();
932 WSARecvMsg = NULL;
933 }
934 if (nResult == 0) {
935 msg.name = (void *)&src;
936 msg.namelen = sizeof(struct sockaddr_in6);
937 msg.lpBuffers = iov;
938 msg.dwBufferCount = MAXLEN_MBUF_CHAIN;
939 msg.Control.len = sizeof ControlBuffer;
940 msg.Control.buf = ControlBuffer;
941 msg.dwFlags = 0;
942 nResult = WSARecvMsg(SCTP_BASE_VAR(userspace_udpsctp6), &msg, &ncounter, NULL, NULL);
943 }
944 if (nResult != 0) {
945 m_ErrorCode = WSAGetLastError();
946 if (m_ErrorCode == WSAETIMEDOUT) {
947 continue;
948 }
949 if ((m_ErrorCode == WSAENOTSOCK) || (m_ErrorCode == WSAEINTR)) {
950 break;
951 }
952 }
953 n = ncounter;
954 #endif
955 SCTP_HEADER_LEN(udprecvmbuf6[0]) = n; /* length of total packet */
956 SCTP_STAT_INCR(sctps_recvpackets);
957 SCTP_STAT_INCR_COUNTER64(sctps_inpackets);
958
959 if (n <= iovlen) {
960 SCTP_BUF_LEN(udprecvmbuf6[0]) = n;
961 (to_fill)++;
962 } else {
963 i = 0;
964 SCTP_BUF_LEN(udprecvmbuf6[0]) = iovlen;
965
966 ncounter -= iovlen;
967 (to_fill)++;
968 do {
969 udprecvmbuf6[i]->m_next = udprecvmbuf6[i+1];
970 SCTP_BUF_LEN(udprecvmbuf6[i]->m_next) = min(ncounter, iovlen);
971 i++;
972 ncounter -= iovlen;
973 (to_fill)++;
974 } while (ncounter > 0);
975 }
976
977 for (cmsgptr = CMSG_FIRSTHDR(&msg); cmsgptr != NULL; cmsgptr = CMSG_NXTHDR(&msg, cmsgptr)) {
978 if ((cmsgptr->cmsg_level == IPPROTO_IPV6) && (cmsgptr->cmsg_type == IPV6_PKTINFO)) {
979 struct in6_pktinfo *info;
980
981 dst.sin6_family = AF_INET6;
982 #ifdef HAVE_SIN6_LEN
983 dst.sin6_len = sizeof(struct sockaddr_in6);
984 #endif
985 info = (struct in6_pktinfo *)CMSG_DATA(cmsgptr);
986 /*dst.sin6_port = htons(SCTP_BASE_SYSCTL(sctp_udp_tunneling_port));*/
987 memcpy((void *)&dst.sin6_addr, (const void *)&(info->ipi6_addr), sizeof(struct in6_addr));
988 }
989 }
990
991 /* SCTP does not allow broadcasts or multicasts */
992 if (IN6_IS_ADDR_MULTICAST(&dst.sin6_addr)) {
993 return (NULL);
994 }
995
996 sh = mtod(udprecvmbuf6[0], struct sctphdr *);
997 ch = (struct sctp_chunkhdr *)((caddr_t)sh + sizeof(struct sctphdr));
998 offset = sizeof(struct sctphdr);
999
1000 port = src.sin6_port;
1001 src.sin6_port = sh->src_port;
1002 dst.sin6_port = sh->dest_port;
1003 #if defined(SCTP_WITH_NO_CSUM)
1004 SCTP_STAT_INCR(sctps_recvnocrc);
1005 #else
1006 if ((memcmp(&src.sin6_addr, &dst.sin6_addr, sizeof(struct in6_addr)) == 0)) {
1007 compute_crc = 0;
1008 SCTP_STAT_INCR(sctps_recvnocrc);
1009 } else {
1010 SCTP_STAT_INCR(sctps_recvswcrc);
1011 }
1012 #endif
1013 SCTPDBG(SCTP_DEBUG_USR, "%s: Received %d bytes.", __func__, n);
1014 SCTPDBG(SCTP_DEBUG_USR, " - calling sctp_common_input_processing with off=%d\n", (int)sizeof(struct sctphdr));
1015 sctp_common_input_processing(&udprecvmbuf6[0], 0, offset, n,
1016 (struct sockaddr *)&src,
1017 (struct sockaddr *)&dst,
1018 sh, ch,
1019 #if !defined(SCTP_WITH_NO_CSUM)
1020 compute_crc,
1021 #endif
1022 0,
1023 SCTP_DEFAULT_VRFID, port);
1024 if (udprecvmbuf6[0]) {
1025 m_freem(udprecvmbuf6[0]);
1026 }
1027 }
1028 for (i = 0; i < MAXLEN_MBUF_CHAIN; i++) {
1029 m_free(udprecvmbuf6[i]);
1030 }
1031 /* free the array itself */
1032 free(udprecvmbuf6);
1033 return (NULL);
1034 }
1035 #endif
1036
1037 static void
1038 setReceiveBufferSize(int sfd, int new_size)
1039 {
1040 int ch = new_size;
1041
1042 if (setsockopt (sfd, SOL_SOCKET, SO_RCVBUF, (void*)&ch, sizeof(ch)) < 0) {
1043 #if defined (__Userspace_os_Windows)
1044 SCTPDBG(SCTP_DEBUG_USR, "Can't set recv-buffers size (errno = %d).\n", WSAGetLastError());
1045 #else
1046 SCTPDBG(SCTP_DEBUG_USR, "Can't set recv-buffers size (errno = %d).\n", errno);
1047 #endif
1048 }
1049 return;
1050 }
1051
1052 static void
1053 setSendBufferSize(int sfd, int new_size)
1054 {
1055 int ch = new_size;
1056
1057 if (setsockopt (sfd, SOL_SOCKET, SO_SNDBUF, (void*)&ch, sizeof(ch)) < 0) {
1058 #if defined (__Userspace_os_Windows)
1059 SCTPDBG(SCTP_DEBUG_USR, "Can't set send-buffers size (errno = %d).\n", WSAGetLastError());
1060 #else
1061 SCTPDBG(SCTP_DEBUG_USR, "Can't set send-buffers size (errno = %d).\n", errno);
1062 #endif
1063 }
1064 return;
1065 }
1066
1067 #define SOCKET_TIMEOUT 100 /* in ms */
1068 void
1069 recv_thread_init(void)
1070 {
1071 #if defined(INET)
1072 struct sockaddr_in addr_ipv4;
1073 const int hdrincl = 1;
1074 #endif
1075 #if defined(INET6)
1076 struct sockaddr_in6 addr_ipv6;
1077 #endif
1078 #if defined(INET) || defined(INET6)
1079 const int on = 1;
1080 #endif
1081 #if !defined(__Userspace_os_Windows)
1082 struct timeval timeout;
1083
1084 timeout.tv_sec = (SOCKET_TIMEOUT / 1000);
1085 timeout.tv_usec = (SOCKET_TIMEOUT % 1000) * 1000;
1086 #else
1087 unsigned int timeout = SOCKET_TIMEOUT; /* Timeout in milliseconds */
1088 #endif
1089 #if defined(__Userspace_os_Darwin) || defined(__Userspace_os_DragonFly) || defined(__Userspace_os_FreeBSD)
1090 if (SCTP_BASE_VAR(userspace_route) == -1) {
1091 if ((SCTP_BASE_VAR(userspace_route) = socket(AF_ROUTE, SOCK_RAW, 0)) < 0) {
1092 SCTPDBG(SCTP_DEBUG_USR, "Can't create routing socket (errno = %d).\n", errno);
1093 }
1094 #if 0
1095 struct sockaddr_nl sanl;
1096
1097 if ((SCTP_BASE_VAR(userspace_route) = socket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE)) < 0) {
1098 SCTPDBG(SCTP_DEBUG_USR, "Can't create routing socket (errno = %d.\n", errno);
1099 }
1100 memset(&sanl, 0, sizeof(sanl));
1101 sanl.nl_family = AF_NETLINK;
1102 sanl.nl_groups = 0;
1103 #ifdef INET
1104 sanl.nl_groups |= RTMGRP_IPV4_IFADDR;
1105 #endif
1106 #ifdef INET6
1107 sanl.nl_groups |= RTMGRP_IPV6_IFADDR;
1108 #endif
1109 if (bind(SCTP_BASE_VAR(userspace_route), (struct sockaddr *) &sanl, sizeof(sanl)) < 0) {
1110 SCTPDBG(SCTP_DEBUG_USR, "Can't bind routing socket (errno = %d).\n", errno);
1111 close(SCTP_BASE_VAR(userspace_route));
1112 SCTP_BASE_VAR(userspace_route) = -1;
1113 }
1114 #endif
1115 if (SCTP_BASE_VAR(userspace_route) != -1) {
1116 if (setsockopt(SCTP_BASE_VAR(userspace_route), SOL_SOCKET, SO_RCVTIMEO,(const void*)&timeout, sizeof(struct timeval)) < 0) {
1117 SCTPDBG(SCTP_DEBUG_USR, "Can't set timeout on routing socket (errno = %d).\n", errno);
1118 #if defined(__Userspace_os_Windows)
1119 closesocket(SCTP_BASE_VAR(userspace_route));
1120 #else
1121 close(SCTP_BASE_VAR(userspace_route));
1122 #endif
1123 SCTP_BASE_VAR(userspace_route) = -1;
1124 }
1125 }
1126 }
1127 #endif
1128 #if defined(INET)
1129 if (SCTP_BASE_VAR(userspace_rawsctp) == -1) {
1130 if ((SCTP_BASE_VAR(userspace_rawsctp) = socket(AF_INET, SOCK_RAW, IPPROTO_SCTP)) < 0) {
1131 #if defined(__Userspace_os_Windows)
1132 SCTPDBG(SCTP_DEBUG_USR, "Can't create raw socket for IPv4 (errno = %d).\n", WSAGetLastError());
1133 #else
1134 SCTPDBG(SCTP_DEBUG_USR, "Can't create raw socket for IPv4 (errno = %d).\n", errno);
1135 #endif
1136 } else {
1137 /* complete setting up the raw SCTP socket */
1138 if (setsockopt(SCTP_BASE_VAR(userspace_rawsctp), IPPROTO_IP, IP_HDRINCL,(const void*)&hdrincl, sizeof(int)) < 0) {
1139 #if defined(__Userspace_os_Windows)
1140 SCTPDBG(SCTP_DEBUG_USR, "Can't set IP_HDRINCL (errno = %d).\n", WSAGetLastError());
1141 closesocket(SCTP_BASE_VAR(userspace_rawsctp));
1142 #else
1143 SCTPDBG(SCTP_DEBUG_USR, "Can't set IP_HDRINCL (errno = %d).\n", errno);
1144 close(SCTP_BASE_VAR(userspace_rawsctp));
1145 #endif
1146 SCTP_BASE_VAR(userspace_rawsctp) = -1;
1147 } else if (setsockopt(SCTP_BASE_VAR(userspace_rawsctp), SOL_SOCKET, SO_RCVTIMEO, (const void *)&timeout, sizeof(timeout)) < 0) {
1148 #if defined(__Userspace_os_Windows)
1149 SCTPDBG(SCTP_DEBUG_USR, "Can't set timeout on socket for SCTP/IPv4 (errno = %d).\n", WSAGetLastError());
1150 closesocket(SCTP_BASE_VAR(userspace_rawsctp));
1151 #else
1152 SCTPDBG(SCTP_DEBUG_USR, "Can't set timeout on socket for SCTP/IPv4 (errno = %d).\n", errno);
1153 close(SCTP_BASE_VAR(userspace_rawsctp));
1154 #endif
1155 SCTP_BASE_VAR(userspace_rawsctp) = -1;
1156 } else {
1157 memset((void *)&addr_ipv4, 0, sizeof(struct sockaddr_in));
1158 #ifdef HAVE_SIN_LEN
1159 addr_ipv4.sin_len = sizeof(struct sockaddr_in);
1160 #endif
1161 addr_ipv4.sin_family = AF_INET;
1162 addr_ipv4.sin_port = htons(0);
1163 addr_ipv4.sin_addr.s_addr = htonl(INADDR_ANY);
1164 if (bind(SCTP_BASE_VAR(userspace_rawsctp), (const struct sockaddr *)&addr_ipv4, sizeof(struct sockaddr_in)) < 0) {
1165 #if defined(__Userspace_os_Windows)
1166 SCTPDBG(SCTP_DEBUG_USR, "Can't bind socket for SCTP/IPv4 (errno = %d).\n", WSAGetLastError());
1167 closesocket(SCTP_BASE_VAR(userspace_rawsctp));
1168 #else
1169 SCTPDBG(SCTP_DEBUG_USR, "Can't bind socket for SCTP/IPv4 (errno = %d).\n", errno);
1170 close(SCTP_BASE_VAR(userspace_rawsctp));
1171 #endif
1172 SCTP_BASE_VAR(userspace_rawsctp) = -1;
1173 } else {
1174 setReceiveBufferSize(SCTP_BASE_VAR(userspace_rawsctp), SB_RAW); /* 128K */
1175 setSendBufferSize(SCTP_BASE_VAR(userspace_rawsctp), SB_RAW); /* 128K Is this setting net.inet.raw.maxdgram value? Should it be set to 64K? */
1176 }
1177 }
1178 }
1179 }
1180 if (SCTP_BASE_VAR(userspace_udpsctp) == -1) {
1181 if ((SCTP_BASE_VAR(userspace_udpsctp) = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)) < 0) {
1182 #if defined(__Userspace_os_Windows)
1183 SCTPDBG(SCTP_DEBUG_USR, "Can't create socket for SCTP/UDP/IPv4 (errno = %d).\n", WSAGetLastError());
1184 #else
1185 SCTPDBG(SCTP_DEBUG_USR, "Can't create socket for SCTP/UDP/IPv4 (errno = %d).\n", errno);
1186 #endif
1187 } else {
1188 #if defined(IP_PKTINFO)
1189 if (setsockopt(SCTP_BASE_VAR(userspace_udpsctp), IPPROTO_IP, IP_PKTINFO, (const void *)&on, (int)sizeof(int)) < 0) {
1190 #else
1191 if (setsockopt(SCTP_BASE_VAR(userspace_udpsctp), IPPROTO_IP, IP_RECVDSTADDR, (const void *)&on, (int)sizeof(int)) < 0) {
1192 #endif
1193 #if defined(__Userspace_os_Windows)
1194 #if defined(IP_PKTINFO)
1195 SCTPDBG(SCTP_DEBUG_USR, "Can't set IP_PKTINFO on socket for SCTP/UDP/IPv4 (errno = %d).\n", WSAGetLastError());
1196 #else
1197 SCTPDBG(SCTP_DEBUG_USR, "Can't set IP_RECVDSTADDR on socket for SCTP/UDP/IPv4 (errno = %d).\n", WSAGetLastError());
1198 #endif
1199 closesocket(SCTP_BASE_VAR(userspace_udpsctp));
1200 #else
1201 #if defined(IP_PKTINFO)
1202 SCTPDBG(SCTP_DEBUG_USR, "Can't set IP_PKTINFO on socket for SCTP/UDP/IPv4 (errno = %d).\n", errno);
1203 #else
1204 SCTPDBG(SCTP_DEBUG_USR, "Can't set IP_RECVDSTADDR on socket for SCTP/UDP/IPv4 (errno = %d).\n", errno);
1205 #endif
1206 close(SCTP_BASE_VAR(userspace_udpsctp));
1207 #endif
1208 SCTP_BASE_VAR(userspace_udpsctp) = -1;
1209 } else if (setsockopt(SCTP_BASE_VAR(userspace_udpsctp), SOL_SOCKET, SO_RCVTIMEO, (const void *)&timeout, sizeof(timeout)) < 0) {
1210 #if defined(__Userspace_os_Windows)
1211 SCTPDBG(SCTP_DEBUG_USR, "Can't set timeout on socket for SCTP/UDP/IPv4 (errno = %d).\n", WSAGetLastError());
1212 closesocket(SCTP_BASE_VAR(userspace_udpsctp));
1213 #else
1214 SCTPDBG(SCTP_DEBUG_USR, "Can't set timeout on socket for SCTP/UDP/IPv4 (errno = %d).\n", errno);
1215 close(SCTP_BASE_VAR(userspace_udpsctp));
1216 #endif
1217 SCTP_BASE_VAR(userspace_udpsctp) = -1;
1218 } else {
1219 memset((void *)&addr_ipv4, 0, sizeof(struct sockaddr_in));
1220 #ifdef HAVE_SIN_LEN
1221 addr_ipv4.sin_len = sizeof(struct sockaddr_in);
1222 #endif
1223 addr_ipv4.sin_family = AF_INET;
1224 addr_ipv4.sin_port = htons(SCTP_BASE_SYSCTL(sctp_udp_tunneling_port));
1225 addr_ipv4.sin_addr.s_addr = htonl(INADDR_ANY);
1226 if (bind(SCTP_BASE_VAR(userspace_udpsctp), (const struct sockaddr *)&addr_ipv4, sizeof(struct sockaddr_in)) < 0) {
1227 #if defined(__Userspace_os_Windows)
1228 SCTPDBG(SCTP_DEBUG_USR, "Can't bind socket for SCTP/UDP/IPv4 (errno = %d).\n", WSAGetLastError());
1229 closesocket(SCTP_BASE_VAR(userspace_udpsctp));
1230 #else
1231 SCTPDBG(SCTP_DEBUG_USR, "Can't bind socket for SCTP/UDP/IPv4 (errno = %d).\n", errno);
1232 close(SCTP_BASE_VAR(userspace_udpsctp));
1233 #endif
1234 SCTP_BASE_VAR(userspace_udpsctp) = -1;
1235 } else {
1236 setReceiveBufferSize(SCTP_BASE_VAR(userspace_udpsctp), SB_RAW); /* 128K */
1237 setSendBufferSize(SCTP_BASE_VAR(userspace_udpsctp), SB_RAW); /* 128K Is this setting net.inet.raw.maxdgram value? Should it be set to 64K? */
1238 }
1239 }
1240 }
1241 }
1242 #endif
1243 #if defined(INET6)
1244 if (SCTP_BASE_VAR(userspace_rawsctp6) == -1) {
1245 if ((SCTP_BASE_VAR(userspace_rawsctp6) = socket(AF_INET6, SOCK_RAW, IPPROTO_SCTP)) < 0) {
1246 #if defined(__Userspace_os_Windows)
1247 SCTPDBG(SCTP_DEBUG_USR, "Can't create socket for SCTP/IPv6 (errno = %d).\n", WSAGetLastError());
1248 #else
1249 SCTPDBG(SCTP_DEBUG_USR, "Can't create socket for SCTP/IPv6 (errno = %d).\n", errno);
1250 #endif
1251 } else {
1252 /* complete setting up the raw SCTP socket */
1253 #if defined(IPV6_RECVPKTINFO)
1254 if (setsockopt(SCTP_BASE_VAR(userspace_rawsctp6), IPPROTO_IPV6, IPV6_RECVPKTINFO, (const void *)&on, sizeof(on)) < 0) {
1255 #if defined(__Userspace_os_Windows)
1256 SCTPDBG(SCTP_DEBUG_USR, "Can't set IPV6_RECVPKTINFO on socket for SCTP/IPv6 (errno = %d).\n", WSAGetLastError());
1257 closesocket(SCTP_BASE_VAR(userspace_rawsctp6));
1258 #else
1259 SCTPDBG(SCTP_DEBUG_USR, "Can't set IPV6_RECVPKTINFO on socket for SCTP/IPv6 (errno = %d).\n", errno);
1260 close(SCTP_BASE_VAR(userspace_rawsctp6));
1261 #endif
1262 SCTP_BASE_VAR(userspace_rawsctp6) = -1;
1263 } else {
1264 #else
1265 if (setsockopt(SCTP_BASE_VAR(userspace_rawsctp6), IPPROTO_IPV6, IPV6_PKTINFO,(const void*)&on, sizeof(on)) < 0) {
1266 #if defined(__Userspace_os_Windows)
1267 SCTPDBG(SCTP_DEBUG_USR, "Can't set IPV6_PKTINFO on socket for SCTP/IPv6 (errno = %d).\n", WSAGetLastError());
1268 closesocket(SCTP_BASE_VAR(userspace_rawsctp6));
1269 #else
1270 SCTPDBG(SCTP_DEBUG_USR, "Can't set IPV6_PKTINFO on socket for SCTP/IPv6 (errno = %d).\n", errno);
1271 close(SCTP_BASE_VAR(userspace_rawsctp6));
1272 #endif
1273 SCTP_BASE_VAR(userspace_rawsctp6) = -1;
1274 } else {
1275 #endif
1276 if (setsockopt(SCTP_BASE_VAR(userspace_rawsctp6), IPPROTO_IPV6, IPV6_V6ONLY, (const void*)&on, (socklen_t)sizeof(on)) < 0) {
1277 #if defined(__Userspace_os_Windows)
1278 SCTPDBG(SCTP_DEBUG_USR, "Can't set IPV6_V6ONLY on socket for SCTP/IPv6 (errno = %d).\n", WSAGetLastError());
1279 #else
1280 SCTPDBG(SCTP_DEBUG_USR, "Can't set IPV6_V6ONLY on socket for SCTP/IPv6 (errno = %d).\n", errno);
1281 #endif
1282 }
1283 if (setsockopt(SCTP_BASE_VAR(userspace_rawsctp6), SOL_SOCKET, SO_RCVTIMEO, (const void *)&timeout, sizeof(timeout)) < 0) {
1284 #if defined(__Userspace_os_Windows)
1285 SCTPDBG(SCTP_DEBUG_USR, "Can't set timeout on socket for SCTP/IPv6 (errno = %d).\n", WSAGetLastError());
1286 closesocket(SCTP_BASE_VAR(userspace_rawsctp6));
1287 #else
1288 SCTPDBG(SCTP_DEBUG_USR, "Can't set timeout on socket for SCTP/IPv6 (errno = %d).\n", errno);
1289 close(SCTP_BASE_VAR(userspace_rawsctp6));
1290 #endif
1291 SCTP_BASE_VAR(userspace_rawsctp6) = -1;
1292 } else {
1293 memset((void *)&addr_ipv6, 0, sizeof(struct sockaddr_in6));
1294 #ifdef HAVE_SIN6_LEN
1295 addr_ipv6.sin6_len = sizeof(struct sockaddr_in6);
1296 #endif
1297 addr_ipv6.sin6_family = AF_INET6;
1298 addr_ipv6.sin6_port = htons(0);
1299 addr_ipv6.sin6_addr = in6addr_any;
1300 if (bind(SCTP_BASE_VAR(userspace_rawsctp6), (const struct sockaddr *)&addr_ipv6, sizeof(struct sockaddr_in6)) < 0) {
1301 #if defined(__Userspace_os_Windows)
1302 SCTPDBG(SCTP_DEBUG_USR, "Can't bind socket for SCTP/IPv6 (errno = %d).\n", WSAGetLastError());
1303 closesocket(SCTP_BASE_VAR(userspace_rawsctp6));
1304 #else
1305 SCTPDBG(SCTP_DEBUG_USR, "Can't bind socket for SCTP/IPv6 (errno = %d).\n", errno);
1306 close(SCTP_BASE_VAR(userspace_rawsctp6));
1307 #endif
1308 SCTP_BASE_VAR(userspace_rawsctp6) = -1;
1309 } else {
1310 setReceiveBufferSize(SCTP_BASE_VAR(userspace_rawsctp6), SB_RAW); /* 128K */
1311 setSendBufferSize(SCTP_BASE_VAR(userspace_rawsctp6), SB_RAW); /* 128K Is this setting net.inet.raw.maxdgram value? Should it be set to 64K? */
1312 }
1313 }
1314 }
1315 }
1316 }
1317 if (SCTP_BASE_VAR(userspace_udpsctp6) == -1) {
1318 if ((SCTP_BASE_VAR(userspace_udpsctp6) = socket(AF_INET6, SOCK_DGRAM, IPPROTO_UDP)) < 0) {
1319 #if defined(__Userspace_os_Windows)
1320 SCTPDBG(SCTP_DEBUG_USR, "Can't create socket for SCTP/UDP/IPv6 (errno = %d).\n", WSAGetLastError());
1321 #else
1322 SCTPDBG(SCTP_DEBUG_USR, "Can't create socket for SCTP/UDP/IPv6 (errno = %d).\n", errno);
1323 #endif
1324 }
1325 #if defined(IPV6_RECVPKTINFO)
1326 if (setsockopt(SCTP_BASE_VAR(userspace_udpsctp6), IPPROTO_IPV6, IPV6_RECVPKTINFO, (const void *)&on, (int)sizeof(int)) < 0) {
1327 #if defined(__Userspace_os_Windows)
1328 SCTPDBG(SCTP_DEBUG_USR, "Can't set IPV6_RECVPKTINFO on socket for SCTP/UDP/IPv6 (errno = %d).\n", WSAGetLastError());
1329 closesocket(SCTP_BASE_VAR(userspace_udpsctp6));
1330 #else
1331 SCTPDBG(SCTP_DEBUG_USR, "Can't set IPV6_RECVPKTINFO on socket for SCTP/UDP/IPv6 (errno = %d).\n", errno);
1332 close(SCTP_BASE_VAR(userspace_udpsctp6));
1333 #endif
1334 SCTP_BASE_VAR(userspace_udpsctp6) = -1;
1335 } else {
1336 #else
1337 if (setsockopt(SCTP_BASE_VAR(userspace_udpsctp6), IPPROTO_IPV6, IPV6_PKTINFO, (const void *)&on, (int)sizeof(int)) < 0) {
1338 #if defined(__Userspace_os_Windows)
1339 SCTPDBG(SCTP_DEBUG_USR, "Can't set IPV6_PKTINFO on socket for SCTP/UDP/IPv6 (errno = %d).\n", WSAGetLastError());
1340 closesocket(SCTP_BASE_VAR(userspace_udpsctp6));
1341 #else
1342 SCTPDBG(SCTP_DEBUG_USR, "Can't set IPV6_PKTINFO on socket for SCTP/UDP/IPv6 (errno = %d).\n", errno);
1343 close(SCTP_BASE_VAR(userspace_udpsctp6));
1344 #endif
1345 SCTP_BASE_VAR(userspace_udpsctp6) = -1;
1346 } else {
1347 #endif
1348 if (setsockopt(SCTP_BASE_VAR(userspace_udpsctp6), IPPROTO_IPV6, IPV6_V6ONLY, (const void *)&on, (socklen_t)sizeof(on)) < 0) {
1349 #if defined(__Userspace_os_Windows)
1350 SCTPDBG(SCTP_DEBUG_USR, "Can't set IPV6_V6ONLY on socket for SCTP/UDP/IPv6 (errno = %d).\n", WSAGetLastError());
1351 #else
1352 SCTPDBG(SCTP_DEBUG_USR, "Can't set IPV6_V6ONLY on socket for SCTP/UDP/IPv6 (errno = %d).\n", errno);
1353 #endif
1354 }
1355 if (setsockopt(SCTP_BASE_VAR(userspace_udpsctp6), SOL_SOCKET, SO_RCVTIMEO, (const void *)&timeout, sizeof(timeout)) < 0) {
1356 #if defined(__Userspace_os_Windows)
1357 SCTPDBG(SCTP_DEBUG_USR, "Can't set timeout on socket for SCTP/UDP/IPv6 (errno = %d).\n", WSAGetLastError());
1358 closesocket(SCTP_BASE_VAR(userspace_udpsctp6));
1359 #else
1360 SCTPDBG(SCTP_DEBUG_USR, "Can't set timeout on socket for SCTP/UDP/IPv6 (errno = %d).\n", errno);
1361 close(SCTP_BASE_VAR(userspace_udpsctp6));
1362 #endif
1363 SCTP_BASE_VAR(userspace_udpsctp6) = -1;
1364 } else {
1365 memset((void *)&addr_ipv6, 0, sizeof(struct sockaddr_in6));
1366 #ifdef HAVE_SIN6_LEN
1367 addr_ipv6.sin6_len = sizeof(struct sockaddr_in6);
1368 #endif
1369 addr_ipv6.sin6_family = AF_INET6;
1370 addr_ipv6.sin6_port = htons(SCTP_BASE_SYSCTL(sctp_udp_tunneling_port));
1371 addr_ipv6.sin6_addr = in6addr_any;
1372 if (bind(SCTP_BASE_VAR(userspace_udpsctp6), (const struct sockaddr *)&addr_ipv6, sizeof(struct sockaddr_in6)) < 0) {
1373 #if defined(__Userspace_os_Windows)
1374 SCTPDBG(SCTP_DEBUG_USR, "Can't bind socket for SCTP/UDP/IPv6 (errno = %d).\n", WSAGetLastError());
1375 closesocket(SCTP_BASE_VAR(userspace_udpsctp6));
1376 #else
1377 SCTPDBG(SCTP_DEBUG_USR, "Can't bind socket for SCTP/UDP/IPv6 (errno = %d).\n", errno);
1378 close(SCTP_BASE_VAR(userspace_udpsctp6));
1379 #endif
1380 SCTP_BASE_VAR(userspace_udpsctp6) = -1;
1381 } else {
1382 setReceiveBufferSize(SCTP_BASE_VAR(userspace_udpsctp6), SB_RAW); /* 128K */
1383 setSendBufferSize(SCTP_BASE_VAR(userspace_udpsctp6), SB_RAW); /* 128K Is this setting net.inet.raw.maxdgram value? Should it be set to 64K? */
1384 }
1385 }
1386 }
1387 }
1388 #endif
1389 #if !defined(__Userspace_os_Windows)
1390 #if defined(__Userspace_os_Darwin) || defined(__Userspace_os_DragonFly) || defined(__Userspace_os_FreeBSD)
1391 #if defined(INET) || defined(INET6)
1392 if (SCTP_BASE_VAR(userspace_route) != -1) {
1393 int rc;
1394
1395 if ((rc = pthread_create(&SCTP_BASE_VAR(recvthreadroute), NULL, &recv_function_route, NULL))) {
1396 SCTPDBG(SCTP_DEBUG_USR, "Can't start routing thread (%d).\n", rc);
1397 close(SCTP_BASE_VAR(userspace_route));
1398 SCTP_BASE_VAR(userspace_route) = -1;
1399 }
1400 }
1401 #endif
1402 #endif
1403 #if defined(INET)
1404 if (SCTP_BASE_VAR(userspace_rawsctp) != -1) {
1405 int rc;
1406
1407 if ((rc = pthread_create(&SCTP_BASE_VAR(recvthreadraw), NULL, &recv_function_raw, NULL))) {
1408 SCTPDBG(SCTP_DEBUG_USR, "Can't start SCTP/IPv4 recv thread (%d).\n", rc);
1409 close(SCTP_BASE_VAR(userspace_rawsctp));
1410 SCTP_BASE_VAR(userspace_rawsctp) = -1;
1411 }
1412 }
1413 if (SCTP_BASE_VAR(userspace_udpsctp) != -1) {
1414 int rc;
1415
1416 if ((rc = pthread_create(&SCTP_BASE_VAR(recvthreadudp), NULL, &recv_function_udp, NULL))) {
1417 SCTPDBG(SCTP_DEBUG_USR, "Can't start SCTP/UDP/IPv4 recv thread (%d).\n", rc);
1418 close(SCTP_BASE_VAR(userspace_udpsctp));
1419 SCTP_BASE_VAR(userspace_udpsctp) = -1;
1420 }
1421 }
1422 #endif
1423 #if defined(INET6)
1424 if (SCTP_BASE_VAR(userspace_rawsctp6) != -1) {
1425 int rc;
1426
1427 if ((rc = pthread_create(&SCTP_BASE_VAR(recvthreadraw6), NULL, &recv_function_raw6, NULL))) {
1428 SCTPDBG(SCTP_DEBUG_USR, "Can't start SCTP/IPv6 recv thread (%d).\n", rc);
1429 close(SCTP_BASE_VAR(userspace_rawsctp6));
1430 SCTP_BASE_VAR(userspace_rawsctp6) = -1;
1431 }
1432 }
1433 if (SCTP_BASE_VAR(userspace_udpsctp6) != -1) {
1434 int rc;
1435
1436 if ((rc = pthread_create(&SCTP_BASE_VAR(recvthreadudp6), NULL, &recv_function_udp6, NULL))) {
1437 SCTPDBG(SCTP_DEBUG_USR, "Can't start SCTP/UDP/IPv6 recv thread (%d).\n", rc);
1438 close(SCTP_BASE_VAR(userspace_udpsctp6));
1439 SCTP_BASE_VAR(userspace_udpsctp6) = -1;
1440 }
1441 }
1442 #endif
1443 #else
1444 #if defined(INET)
1445 if (SCTP_BASE_VAR(userspace_rawsctp) != -1) {
1446 if ((SCTP_BASE_VAR(recvthreadraw) = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)&recv_function_raw, NULL, 0, NULL)) == NULL) {
1447 SCTPDBG(SCTP_DEBUG_USR, "Can't start SCTP/IPv4 recv thread.\n");
1448 closesocket(SCTP_BASE_VAR(userspace_rawsctp));
1449 SCTP_BASE_VAR(userspace_rawsctp) = -1;
1450 }
1451 }
1452 if (SCTP_BASE_VAR(userspace_udpsctp) != -1) {
1453 if ((SCTP_BASE_VAR(recvthreadudp) = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)&recv_function_udp, NULL, 0, NULL)) == NULL) {
1454 SCTPDBG(SCTP_DEBUG_USR, "Can't start SCTP/UDP/IPv4 recv thread.\n");
1455 closesocket(SCTP_BASE_VAR(userspace_udpsctp));
1456 SCTP_BASE_VAR(userspace_udpsctp) = -1;
1457 }
1458 }
1459 #endif
1460 #if defined(INET6)
1461 if (SCTP_BASE_VAR(userspace_rawsctp6) != -1) {
1462 if ((SCTP_BASE_VAR(recvthreadraw6) = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)&recv_function_raw6, NULL, 0, NULL)) == NULL) {
1463 SCTPDBG(SCTP_DEBUG_USR, "Can't start SCTP/IPv6 recv thread.\n");
1464 closesocket(SCTP_BASE_VAR(userspace_rawsctp6));
1465 SCTP_BASE_VAR(userspace_rawsctp6) = -1;
1466 }
1467 }
1468 if (SCTP_BASE_VAR(userspace_udpsctp6) != -1) {
1469 if ((SCTP_BASE_VAR(recvthreadudp6) = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)&recv_function_udp6, NULL, 0, NULL)) == NULL) {
1470 SCTPDBG(SCTP_DEBUG_USR, "Can't start SCTP/UDP/IPv6 recv thread.\n");
1471 closesocket(SCTP_BASE_VAR(userspace_udpsctp6));
1472 SCTP_BASE_VAR(userspace_udpsctp6) = -1;
1473 }
1474 }
1475 #endif
1476 #endif
1477 }
1478
1479 void
1480 recv_thread_destroy(void)
1481 {
1482 #if defined(__Userspace_os_Darwin) || defined(__Userspace_os_DragonFly) || defined(__Userspace_os_FreeBSD)
1483 #if defined(INET) || defined(INET6)
1484 if (SCTP_BASE_VAR(userspace_route) != -1) {
1485 close(SCTP_BASE_VAR(userspace_route));
1486 }
1487 #endif
1488 #endif
1489 #if defined(INET)
1490 if (SCTP_BASE_VAR(userspace_rawsctp) != -1) {
1491 #if defined(__Userspace_os_Windows)
1492 closesocket(SCTP_BASE_VAR(userspace_rawsctp));
1493 #else
1494 close(SCTP_BASE_VAR(userspace_rawsctp));
1495 #endif
1496 }
1497 if (SCTP_BASE_VAR(userspace_udpsctp) != -1) {
1498 #if defined(__Userspace_os_Windows)
1499 closesocket(SCTP_BASE_VAR(userspace_udpsctp));
1500 #else
1501 close(SCTP_BASE_VAR(userspace_udpsctp));
1502 #endif
1503 }
1504 #endif
1505 #if defined(INET6)
1506 if (SCTP_BASE_VAR(userspace_rawsctp6) != -1) {
1507 #if defined(__Userspace_os_Windows)
1508 closesocket(SCTP_BASE_VAR(userspace_rawsctp6));
1509 #else
1510 close(SCTP_BASE_VAR(userspace_rawsctp6));
1511 #endif
1512 }
1513 if (SCTP_BASE_VAR(userspace_udpsctp6) != -1) {
1514 #if defined(__Userspace_os_Windows)
1515 closesocket(SCTP_BASE_VAR(userspace_udpsctp6));
1516 #else
1517 close(SCTP_BASE_VAR(userspace_udpsctp6));
1518 #endif
1519 }
1520 #endif
1521 }
1522 #else
1523 int foo;
1524 #endif

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial