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 1525
