1 /*- 2 * Copyright (c) 2001-2007, by Cisco Systems, Inc. All rights reserved. 3 * Copyright (c) 2008-2012, by Randall Stewart. All rights reserved. 4 * Copyright (c) 2008-2012, by Michael Tuexen. All rights reserved. 5 * 6 * Redistribution and use in source and binary forms, with or without 7 * modification, are permitted provided that the following conditions are met: 8 * 9 * a) Redistributions of source code must retain the above copyright notice, 10 * this list of conditions and the following disclaimer. 11 * 12 * b) Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in 14 * the documentation and/or other materials provided with the distribution. 15 * 16 * c) Neither the name of Cisco Systems, Inc. nor the names of its 17 * contributors may be used to endorse or promote products derived 18 * from this software without specific prior written permission. 19 * 20 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 21 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, 22 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 23 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE 24 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 25 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 26 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 27 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 28 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 29 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF 30 * THE POSSIBILITY OF SUCH DAMAGE. 31 */ 32 33 #ifdef __FreeBSD__ 34 #include <sys/cdefs.h> 35 __FBSDID("$FreeBSD: head/sys/netinet/sctp_bsd_addr.c 258765 2013-11-30 12:51:19Z tuexen $"); 36 #endif 37 38 #include <netinet/sctp_os.h> 39 #include <netinet/sctp_var.h> 40 #include <netinet/sctp_pcb.h> 41 #include <netinet/sctp_header.h> 42 #include <netinet/sctputil.h> 43 #include <netinet/sctp_output.h> 44 #include <netinet/sctp_bsd_addr.h> 45 #include <netinet/sctp_uio.h> 46 #include <netinet/sctputil.h> 47 #include <netinet/sctp_timer.h> 48 #include <netinet/sctp_asconf.h> 49 #include <netinet/sctp_sysctl.h> 50 #include <netinet/sctp_indata.h> 51 #if defined(__FreeBSD__) 52 #include <sys/unistd.h> 53 #endif 54 55 /* Declare all of our malloc named types */ 56 #ifndef __Panda__ 57 MALLOC_DEFINE(SCTP_M_MAP, "sctp_map", "sctp asoc map descriptor"); 58 MALLOC_DEFINE(SCTP_M_STRMI, "sctp_stri", "sctp stream in array"); 59 MALLOC_DEFINE(SCTP_M_STRMO, "sctp_stro", "sctp stream out array"); 60 MALLOC_DEFINE(SCTP_M_ASC_ADDR, "sctp_aadr", "sctp asconf address"); 61 MALLOC_DEFINE(SCTP_M_ASC_IT, "sctp_a_it", "sctp asconf iterator"); 62 MALLOC_DEFINE(SCTP_M_AUTH_CL, "sctp_atcl", "sctp auth chunklist"); 63 MALLOC_DEFINE(SCTP_M_AUTH_KY, "sctp_atky", "sctp auth key"); 64 MALLOC_DEFINE(SCTP_M_AUTH_HL, "sctp_athm", "sctp auth hmac list"); 65 MALLOC_DEFINE(SCTP_M_AUTH_IF, "sctp_athi", "sctp auth info"); 66 MALLOC_DEFINE(SCTP_M_STRESET, "sctp_stre", "sctp stream reset"); 67 MALLOC_DEFINE(SCTP_M_CMSG, "sctp_cmsg", "sctp CMSG buffer"); 68 MALLOC_DEFINE(SCTP_M_COPYAL, "sctp_cpal", "sctp copy all"); 69 MALLOC_DEFINE(SCTP_M_VRF, "sctp_vrf", "sctp vrf struct"); 70 MALLOC_DEFINE(SCTP_M_IFA, "sctp_ifa", "sctp ifa struct"); 71 MALLOC_DEFINE(SCTP_M_IFN, "sctp_ifn", "sctp ifn struct"); 72 MALLOC_DEFINE(SCTP_M_TIMW, "sctp_timw", "sctp time block"); 73 MALLOC_DEFINE(SCTP_M_MVRF, "sctp_mvrf", "sctp mvrf pcb list"); 74 MALLOC_DEFINE(SCTP_M_ITER, "sctp_iter", "sctp iterator control"); 75 MALLOC_DEFINE(SCTP_M_SOCKOPT, "sctp_socko", "sctp socket option"); 76 MALLOC_DEFINE(SCTP_M_MCORE, "sctp_mcore", "sctp mcore queue"); 77 #endif 78 79 /* Global NON-VNET structure that controls the iterator */ 80 struct iterator_control sctp_it_ctl; 81 82 #if !defined(__FreeBSD__) 83 static void 84 sctp_cleanup_itqueue(void) 85 { 86 struct sctp_iterator *it, *nit; 87 88 TAILQ_FOREACH_SAFE(it, &sctp_it_ctl.iteratorhead, sctp_nxt_itr, nit) { 89 if (it->function_atend != NULL) { 90 (*it->function_atend) (it->pointer, it->val); 91 } 92 TAILQ_REMOVE(&sctp_it_ctl.iteratorhead, it, sctp_nxt_itr); 93 SCTP_FREE(it, SCTP_M_ITER); 94 } 95 } 96 #endif 97 #if defined(__Userspace__) 98 /*__Userspace__ TODO if we use thread based iterator 99 * then the implementation of wakeup will need to change. 100 * Currently we are using timeo_cond for ident so_timeo 101 * but that is not sufficient if we need to use another ident 102 * like wakeup(&sctppcbinfo.iterator_running); 103 */ 104 #endif 105 106 void 107 sctp_wakeup_iterator(void) 108 { 109 #if defined(SCTP_PROCESS_LEVEL_LOCKS) 110 #if defined(__Userspace_os_Windows) 111 WakeAllConditionVariable(&sctp_it_ctl.iterator_wakeup); 112 #else 113 pthread_cond_broadcast(&sctp_it_ctl.iterator_wakeup); 114 #endif 115 #else 116 wakeup(&sctp_it_ctl.iterator_running); 117 #endif 118 } 119 120 #if defined(__Userspace__) 121 static void * 122 #else 123 static void 124 #endif 125 sctp_iterator_thread(void *v SCTP_UNUSED) 126 { 127 SCTP_IPI_ITERATOR_WQ_LOCK(); 128 /* In FreeBSD this thread never terminates. */ 129 #if defined(__FreeBSD__) 130 for (;;) { 131 #else 132 while ((sctp_it_ctl.iterator_flags & SCTP_ITERATOR_MUST_EXIT) == 0) { 133 #endif 134 #if !defined(__Userspace__) 135 msleep(&sctp_it_ctl.iterator_running, 136 #if defined(__FreeBSD__) 137 &sctp_it_ctl.ipi_iterator_wq_mtx, 138 #elif defined(__APPLE__) || defined(__Userspace_os_Darwin) 139 sctp_it_ctl.ipi_iterator_wq_mtx, 140 #endif 141 0, "waiting_for_work", 0); 142 #else 143 #if defined(__Userspace_os_Windows) 144 SleepConditionVariableCS(&sctp_it_ctl.iterator_wakeup, &sctp_it_ctl.ipi_iterator_wq_mtx, INFINITE); 145 #else 146 pthread_cond_wait(&sctp_it_ctl.iterator_wakeup, &sctp_it_ctl.ipi_iterator_wq_mtx); 147 #endif 148 #endif 149 #if !defined(__FreeBSD__) 150 if (sctp_it_ctl.iterator_flags & SCTP_ITERATOR_MUST_EXIT) { 151 break; 152 } 153 #endif 154 sctp_iterator_worker(); 155 } 156 #if !defined(__FreeBSD__) 157 /* Now this thread needs to be terminated */ 158 sctp_cleanup_itqueue(); 159 sctp_it_ctl.iterator_flags |= SCTP_ITERATOR_EXITED; 160 SCTP_IPI_ITERATOR_WQ_UNLOCK(); 161 #if defined(__Userspace__) 162 sctp_wakeup_iterator(); 163 return (NULL); 164 #else 165 wakeup(&sctp_it_ctl.iterator_flags); 166 thread_terminate(current_thread()); 167 #ifdef INVARIANTS 168 panic("Hmm. thread_terminate() continues..."); 169 #endif 170 #endif 171 #endif 172 } 173 174 void 175 sctp_startup_iterator(void) 176 { 177 if (sctp_it_ctl.thread_proc) { 178 /* You only get one */ 179 return; 180 } 181 /* Initialize global locks here, thus only once. */ 182 SCTP_ITERATOR_LOCK_INIT(); 183 SCTP_IPI_ITERATOR_WQ_INIT(); 184 TAILQ_INIT(&sctp_it_ctl.iteratorhead); 185 #if defined(__FreeBSD__) 186 #if __FreeBSD_version <= 701000 187 kthread_create(sctp_iterator_thread, 188 #else 189 kproc_create(sctp_iterator_thread, 190 #endif 191 (void *)NULL, 192 &sctp_it_ctl.thread_proc, 193 RFPROC, 194 SCTP_KTHREAD_PAGES, 195 SCTP_KTRHEAD_NAME); 196 #elif defined(__APPLE__) 197 kernel_thread_start((thread_continue_t)sctp_iterator_thread, NULL, &sctp_it_ctl.thread_proc); 198 #elif defined(__Userspace__) 199 #if defined(__Userspace_os_Windows) 200 if ((sctp_it_ctl.thread_proc = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)&sctp_iterator_thread, NULL, 0, NULL)) == NULL) { 201 #else 202 if (pthread_create(&sctp_it_ctl.thread_proc, NULL, &sctp_iterator_thread, NULL)) { 203 #endif 204 SCTP_PRINTF("ERROR: Creating sctp_iterator_thread failed.\n"); 205 } 206 #endif 207 } 208 209 #ifdef INET6 210 211 #if defined(__Userspace__) 212 /* __Userspace__ TODO. struct in6_ifaddr is defined in sys/netinet6/in6_var.h 213 ip6_use_deprecated is defined as int ip6_use_deprecated = 1; in /src/sys/netinet6/in6_proto.c 214 */ 215 void 216 sctp_gather_internal_ifa_flags(struct sctp_ifa *ifa) 217 { 218 return; /* stub */ 219 } 220 #else 221 void 222 sctp_gather_internal_ifa_flags(struct sctp_ifa *ifa) 223 { 224 struct in6_ifaddr *ifa6; 225 226 ifa6 = (struct in6_ifaddr *)ifa->ifa; 227 ifa->flags = ifa6->ia6_flags; 228 if (!MODULE_GLOBAL(ip6_use_deprecated)) { 229 if (ifa->flags & 230 IN6_IFF_DEPRECATED) { 231 ifa->localifa_flags |= SCTP_ADDR_IFA_UNUSEABLE; 232 } else { 233 ifa->localifa_flags &= ~SCTP_ADDR_IFA_UNUSEABLE; 234 } 235 } else { 236 ifa->localifa_flags &= ~SCTP_ADDR_IFA_UNUSEABLE; 237 } 238 if (ifa->flags & 239 (IN6_IFF_DETACHED | 240 IN6_IFF_ANYCAST | 241 IN6_IFF_NOTREADY)) { 242 ifa->localifa_flags |= SCTP_ADDR_IFA_UNUSEABLE; 243 } else { 244 ifa->localifa_flags &= ~SCTP_ADDR_IFA_UNUSEABLE; 245 } 246 } 247 #endif /* __Userspace__ */ 248 #endif /* INET6 */ 249 250 251 #if !defined(__Userspace__) 252 static uint32_t 253 sctp_is_desired_interface_type(struct ifnet *ifn) 254 { 255 int result; 256 257 /* check the interface type to see if it's one we care about */ 258 #if defined(__APPLE__) 259 switch(ifnet_type(ifn)) { 260 #else 261 switch (ifn->if_type) { 262 #endif 263 case IFT_ETHER: 264 case IFT_ISO88023: 265 case IFT_ISO88024: 266 case IFT_ISO88025: 267 case IFT_ISO88026: 268 case IFT_STARLAN: 269 case IFT_P10: 270 case IFT_P80: 271 case IFT_HY: 272 case IFT_FDDI: 273 case IFT_XETHER: 274 case IFT_ISDNBASIC: 275 case IFT_ISDNPRIMARY: 276 case IFT_PTPSERIAL: 277 case IFT_OTHER: 278 case IFT_PPP: 279 case IFT_LOOP: 280 case IFT_SLIP: 281 case IFT_GIF: 282 case IFT_L2VLAN: 283 case IFT_STF: 284 #if !defined(__APPLE__) 285 case IFT_IP: 286 case IFT_IPOVERCDLC: 287 case IFT_IPOVERCLAW: 288 case IFT_PROPVIRTUAL: /* NetGraph Virtual too */ 289 case IFT_VIRTUALIPADDRESS: 290 #endif 291 result = 1; 292 break; 293 default: 294 result = 0; 295 } 296 297 return (result); 298 } 299 #endif 300 301 #if defined(__APPLE__) 302 int 303 sctp_is_vmware_interface(struct ifnet *ifn) 304 { 305 return (strncmp(ifnet_name(ifn), "vmnet", 5) == 0); 306 } 307 #endif 308 309 #if defined(__Userspace_os_Windows) 310 #ifdef MALLOC 311 #undef MALLOC 312 #define MALLOC(x) HeapAlloc(GetProcessHeap(), 0, (x)) 313 #endif 314 #ifdef FREE 315 #undef FREE 316 #define FREE(x) HeapFree(GetProcessHeap(), 0, (x)) 317 #endif 318 static void 319 sctp_init_ifns_for_vrf(int vrfid) 320 { 321 #if defined(INET) || defined(INET6) 322 struct ifaddrs *ifa; 323 struct sctp_ifa *sctp_ifa; 324 DWORD Err, AdapterAddrsSize; 325 PIP_ADAPTER_ADDRESSES pAdapterAddrs, pAdapt; 326 PIP_ADAPTER_UNICAST_ADDRESS pUnicast; 327 #endif 328 329 #ifdef INET 330 AdapterAddrsSize = 0; 331 332 if ((Err = GetAdaptersAddresses(AF_INET, 0, NULL, NULL, &AdapterAddrsSize)) != 0) { 333 if ((Err != ERROR_BUFFER_OVERFLOW) && (Err != ERROR_INSUFFICIENT_BUFFER)) { 334 SCTP_PRINTF("GetAdaptersV4Addresses() sizing failed with error code %d\n", Err); 335 SCTP_PRINTF("err = %d; AdapterAddrsSize = %d\n", Err, AdapterAddrsSize); 336 return; 337 } 338 } 339 340 /* Allocate memory from sizing information */ 341 if ((pAdapterAddrs = (PIP_ADAPTER_ADDRESSES) GlobalAlloc(GPTR, AdapterAddrsSize)) == NULL) { 342 SCTP_PRINTF("Memory allocation error!\n"); 343 return; 344 } 345 /* Get actual adapter information */ 346 if ((Err = GetAdaptersAddresses(AF_INET, 0, NULL, pAdapterAddrs, &AdapterAddrsSize)) != ERROR_SUCCESS) { 347 SCTP_PRINTF("GetAdaptersV4Addresses() failed with error code %d\n", Err); 348 return; 349 } 350 /* Enumerate through each returned adapter and save its information */ 351 for (pAdapt = pAdapterAddrs; pAdapt; pAdapt = pAdapt->Next) { 352 if (pAdapt->IfType == IF_TYPE_IEEE80211 || pAdapt->IfType == IF_TYPE_ETHERNET_CSMACD) { 353 for (pUnicast = pAdapt->FirstUnicastAddress; pUnicast; pUnicast = pUnicast->Next) { 354 if (IN4_ISLINKLOCAL_ADDRESS(&(((struct sockaddr_in *)(pUnicast->Address.lpSockaddr))->sin_addr))) { 355 continue; 356 } 357 ifa = (struct ifaddrs*)malloc(sizeof(struct ifaddrs)); 358 ifa->ifa_name = strdup(pAdapt->AdapterName); 359 ifa->ifa_flags = pAdapt->Flags; 360 ifa->ifa_addr = (struct sockaddr *)malloc(sizeof(struct sockaddr_in)); 361 memcpy(ifa->ifa_addr, pUnicast->Address.lpSockaddr, sizeof(struct sockaddr_in)); 362 363 sctp_ifa = sctp_add_addr_to_vrf(0, 364 ifa, 365 pAdapt->IfIndex, 366 (pAdapt->IfType == IF_TYPE_IEEE80211)?MIB_IF_TYPE_ETHERNET:pAdapt->IfType, 367 ifa->ifa_name, 368 (void *)ifa, 369 ifa->ifa_addr, 370 ifa->ifa_flags, 371 0); 372 if (sctp_ifa) { 373 sctp_ifa->localifa_flags &= ~SCTP_ADDR_DEFER_USE; 374 } 375 } 376 } 377 } 378 if (pAdapterAddrs) 379 FREE(pAdapterAddrs); 380 #endif 381 #ifdef INET6 382 AdapterAddrsSize = 0; 383 384 if ((Err = GetAdaptersAddresses(AF_INET6, 0, NULL, NULL, &AdapterAddrsSize)) != 0) { 385 if ((Err != ERROR_BUFFER_OVERFLOW) && (Err != ERROR_INSUFFICIENT_BUFFER)) { 386 SCTP_PRINTF("GetAdaptersV6Addresses() sizing failed with error code %d\n", Err); 387 SCTP_PRINTF("err = %d; AdapterAddrsSize = %d\n", Err, AdapterAddrsSize); 388 return; 389 } 390 } 391 /* Allocate memory from sizing information */ 392 if ((pAdapterAddrs = (PIP_ADAPTER_ADDRESSES) GlobalAlloc(GPTR, AdapterAddrsSize)) == NULL) { 393 SCTP_PRINTF("Memory allocation error!\n"); 394 return; 395 } 396 /* Get actual adapter information */ 397 if ((Err = GetAdaptersAddresses(AF_INET6, 0, NULL, pAdapterAddrs, &AdapterAddrsSize)) != ERROR_SUCCESS) { 398 SCTP_PRINTF("GetAdaptersV6Addresses() failed with error code %d\n", Err); 399 return; 400 } 401 /* Enumerate through each returned adapter and save its information */ 402 for (pAdapt = pAdapterAddrs; pAdapt; pAdapt = pAdapt->Next) { 403 if (pAdapt->IfType == IF_TYPE_IEEE80211 || pAdapt->IfType == IF_TYPE_ETHERNET_CSMACD) { 404 for (pUnicast = pAdapt->FirstUnicastAddress; pUnicast; pUnicast = pUnicast->Next) { 405 ifa = (struct ifaddrs*)malloc(sizeof(struct ifaddrs)); 406 ifa->ifa_name = strdup(pAdapt->AdapterName); 407 ifa->ifa_flags = pAdapt->Flags; 408 ifa->ifa_addr = (struct sockaddr *)malloc(sizeof(struct sockaddr_in6)); 409 memcpy(ifa->ifa_addr, pUnicast->Address.lpSockaddr, sizeof(struct sockaddr_in6)); 410 sctp_ifa = sctp_add_addr_to_vrf(0, 411 ifa, 412 pAdapt->Ipv6IfIndex, 413 (pAdapt->IfType == IF_TYPE_IEEE80211)?MIB_IF_TYPE_ETHERNET:pAdapt->IfType, 414 ifa->ifa_name, 415 (void *)ifa, 416 ifa->ifa_addr, 417 ifa->ifa_flags, 418 0); 419 if (sctp_ifa) { 420 sctp_ifa->localifa_flags &= ~SCTP_ADDR_DEFER_USE; 421 } 422 } 423 } 424 } 425 if (pAdapterAddrs) 426 FREE(pAdapterAddrs); 427 #endif 428 } 429 #elif defined(__Userspace__) 430 static void 431 sctp_init_ifns_for_vrf(int vrfid) 432 { 433 #if defined(INET) || defined(INET6) 434 int rc; 435 struct ifaddrs *ifa = NULL; 436 struct sctp_ifa *sctp_ifa; 437 uint32_t ifa_flags; 438 439 rc = getifaddrs(&g_interfaces); 440 if (rc != 0) { 441 return; 442 } 443 for (ifa = g_interfaces; ifa; ifa = ifa->ifa_next) { 444 if (ifa->ifa_addr == NULL) { 445 continue; 446 } 447 #if !defined(INET) 448 if (ifa->ifa_addr->sa_family != AF_INET6) { 449 /* non inet6 skip */ 450 continue; 451 } 452 #elif !defined(INET6) 453 if (ifa->ifa_addr->sa_family != AF_INET) { 454 /* non inet skip */ 455 continue; 456 } 457 #else 458 if ((ifa->ifa_addr->sa_family != AF_INET) && (ifa->ifa_addr->sa_family != AF_INET6)) { 459 /* non inet/inet6 skip */ 460 continue; 461 } 462 #endif 463 #if defined(INET6) 464 if ((ifa->ifa_addr->sa_family == AF_INET6) && 465 IN6_IS_ADDR_UNSPECIFIED(&((struct sockaddr_in6 *)ifa->ifa_addr)->sin6_addr)) { 466 /* skip unspecifed addresses */ 467 continue; 468 } 469 #endif 470 #if defined(INET) 471 if (ifa->ifa_addr->sa_family == AF_INET && 472 ((struct sockaddr_in *)ifa->ifa_addr)->sin_addr.s_addr == 0) { 473 continue; 474 } 475 #endif 476 ifa_flags = 0; 477 sctp_ifa = sctp_add_addr_to_vrf(vrfid, 478 ifa, 479 if_nametoindex(ifa->ifa_name), 480 0, 481 ifa->ifa_name, 482 (void *)ifa, 483 ifa->ifa_addr, 484 ifa_flags, 485 0); 486 if (sctp_ifa) { 487 sctp_ifa->localifa_flags &= ~SCTP_ADDR_DEFER_USE; 488 } 489 } 490 #endif 491 } 492 #endif 493 494 #if defined(__APPLE__) 495 static void 496 sctp_init_ifns_for_vrf(int vrfid) 497 { 498 /* Here we must apply ANY locks needed by the 499 * IFN we access and also make sure we lock 500 * any IFA that exists as we float through the 501 * list of IFA's 502 */ 503 struct ifnet **ifnetlist; 504 uint32_t i, j, count; 505 char name[SCTP_IFNAMSIZ]; 506 struct ifnet *ifn; 507 struct ifaddr **ifaddrlist; 508 struct ifaddr *ifa; 509 struct in6_ifaddr *ifa6; 510 struct sctp_ifa *sctp_ifa; 511 uint32_t ifa_flags; 512 513 if (ifnet_list_get(IFNET_FAMILY_ANY, &ifnetlist, &count) != 0) { 514 return; 515 } 516 for (i = 0; i < count; i++) { 517 ifn = ifnetlist[i]; 518 if (SCTP_BASE_SYSCTL(sctp_ignore_vmware_interfaces) && sctp_is_vmware_interface(ifn)) { 519 continue; 520 } 521 if (sctp_is_desired_interface_type(ifn) == 0) { 522 /* non desired type */ 523 continue; 524 } 525 if (ifnet_get_address_list(ifn, &ifaddrlist) != 0) { 526 continue; 527 } 528 for (j = 0; ifaddrlist[j] != NULL; j++) { 529 ifa = ifaddrlist[j]; 530 if (ifa->ifa_addr == NULL) { 531 continue; 532 } 533 if ((ifa->ifa_addr->sa_family != AF_INET) && (ifa->ifa_addr->sa_family != AF_INET6)) { 534 /* non inet/inet6 skip */ 535 continue; 536 } 537 if (ifa->ifa_addr->sa_family == AF_INET6) { 538 if (IN6_IS_ADDR_UNSPECIFIED(&((struct sockaddr_in6 *)ifa->ifa_addr)->sin6_addr)) { 539 /* skip unspecifed addresses */ 540 continue; 541 } 542 } else { 543 if (((struct sockaddr_in *)ifa->ifa_addr)->sin_addr.s_addr == INADDR_ANY) { 544 continue; 545 } 546 } 547 if (ifa->ifa_addr->sa_family == AF_INET6) { 548 ifa6 = (struct in6_ifaddr *)ifa; 549 ifa_flags = ifa6->ia6_flags; 550 } else { 551 ifa_flags = 0; 552 } 553 snprintf(name, SCTP_IFNAMSIZ, "%s%d", ifnet_name(ifn), ifnet_unit(ifn)); 554 sctp_ifa = sctp_add_addr_to_vrf(vrfid, 555 (void *)ifn, 556 ifnet_index(ifn), 557 ifnet_type(ifn), 558 name, 559 (void *)ifa, 560 ifa->ifa_addr, 561 ifa_flags, 562 0); 563 if (sctp_ifa) { 564 sctp_ifa->localifa_flags &= ~SCTP_ADDR_DEFER_USE; 565 } 566 } 567 ifnet_free_address_list(ifaddrlist); 568 } 569 ifnet_list_free(ifnetlist); 570 } 571 #endif 572 573 #if defined(__FreeBSD__) 574 static void 575 sctp_init_ifns_for_vrf(int vrfid) 576 { 577 /* Here we must apply ANY locks needed by the 578 * IFN we access and also make sure we lock 579 * any IFA that exists as we float through the 580 * list of IFA's 581 */ 582 struct ifnet *ifn; 583 struct ifaddr *ifa; 584 struct sctp_ifa *sctp_ifa; 585 uint32_t ifa_flags; 586 #ifdef INET6 587 struct in6_ifaddr *ifa6; 588 #endif 589 590 IFNET_RLOCK(); 591 TAILQ_FOREACH(ifn, &MODULE_GLOBAL(ifnet), if_list) { 592 if (sctp_is_desired_interface_type(ifn) == 0) { 593 /* non desired type */ 594 continue; 595 } 596 #if (__FreeBSD_version >= 803000 && __FreeBSD_version < 900000) || __FreeBSD_version > 900000 597 IF_ADDR_RLOCK(ifn); 598 #else 599 IF_ADDR_LOCK(ifn); 600 #endif 601 TAILQ_FOREACH(ifa, &ifn->if_addrlist, ifa_list) { 602 if (ifa->ifa_addr == NULL) { 603 continue; 604 } 605 switch (ifa->ifa_addr->sa_family) { 606 #ifdef INET 607 case AF_INET: 608 if (((struct sockaddr_in *)ifa->ifa_addr)->sin_addr.s_addr == 0) { 609 continue; 610 } 611 break; 612 #endif 613 #ifdef INET6 614 case AF_INET6: 615 if (IN6_IS_ADDR_UNSPECIFIED(&((struct sockaddr_in6 *)ifa->ifa_addr)->sin6_addr)) { 616 /* skip unspecifed addresses */ 617 continue; 618 } 619 break; 620 #endif 621 default: 622 continue; 623 } 624 switch (ifa->ifa_addr->sa_family) { 625 #ifdef INET 626 case AF_INET: 627 ifa_flags = 0; 628 break; 629 #endif 630 #ifdef INET6 631 case AF_INET6: 632 ifa6 = (struct in6_ifaddr *)ifa; 633 ifa_flags = ifa6->ia6_flags; 634 break; 635 #endif 636 default: 637 ifa_flags = 0; 638 break; 639 } 640 sctp_ifa = sctp_add_addr_to_vrf(vrfid, 641 (void *)ifn, 642 ifn->if_index, 643 ifn->if_type, 644 ifn->if_xname, 645 (void *)ifa, 646 ifa->ifa_addr, 647 ifa_flags, 648 0); 649 if (sctp_ifa) { 650 sctp_ifa->localifa_flags &= ~SCTP_ADDR_DEFER_USE; 651 } 652 } 653 #if (__FreeBSD_version >= 803000 && __FreeBSD_version < 900000) || __FreeBSD_version > 900000 654 IF_ADDR_RUNLOCK(ifn); 655 #else 656 IF_ADDR_UNLOCK(ifn); 657 #endif 658 } 659 IFNET_RUNLOCK(); 660 } 661 #endif 662 663 void 664 sctp_init_vrf_list(int vrfid) 665 { 666 if (vrfid > SCTP_MAX_VRF_ID) 667 /* can't do that */ 668 return; 669 670 /* Don't care about return here */ 671 (void)sctp_allocate_vrf(vrfid); 672 673 /* Now we need to build all the ifn's 674 * for this vrf and there addresses 675 */ 676 sctp_init_ifns_for_vrf(vrfid); 677 } 678 679 void 680 sctp_addr_change(struct ifaddr *ifa, int cmd) 681 { 682 #if defined(__Userspace__) 683 return; 684 #else 685 uint32_t ifa_flags = 0; 686 /* BSD only has one VRF, if this changes 687 * we will need to hook in the right 688 * things here to get the id to pass to 689 * the address managment routine. 690 */ 691 if (SCTP_BASE_VAR(first_time) == 0) { 692 /* Special test to see if my ::1 will showup with this */ 693 SCTP_BASE_VAR(first_time) = 1; 694 sctp_init_ifns_for_vrf(SCTP_DEFAULT_VRFID); 695 } 696 697 if ((cmd != RTM_ADD) && (cmd != RTM_DELETE)) { 698 /* don't know what to do with this */ 699 return; 700 } 701 702 if (ifa->ifa_addr == NULL) { 703 return; 704 } 705 if (sctp_is_desired_interface_type(ifa->ifa_ifp) == 0) { 706 /* non desired type */ 707 return; 708 } 709 switch (ifa->ifa_addr->sa_family) { 710 #ifdef INET 711 case AF_INET: 712 if (((struct sockaddr_in *)ifa->ifa_addr)->sin_addr.s_addr == 0) { 713 return; 714 } 715 break; 716 #endif 717 #ifdef INET6 718 case AF_INET6: 719 ifa_flags = ((struct in6_ifaddr *)ifa)->ia6_flags; 720 if (IN6_IS_ADDR_UNSPECIFIED(&((struct sockaddr_in6 *)ifa->ifa_addr)->sin6_addr)) { 721 /* skip unspecifed addresses */ 722 return; 723 } 724 break; 725 #endif 726 default: 727 /* non inet/inet6 skip */ 728 return; 729 } 730 if (cmd == RTM_ADD) { 731 (void)sctp_add_addr_to_vrf(SCTP_DEFAULT_VRFID, (void *)ifa->ifa_ifp, 732 #if defined(__APPLE__) 733 ifnet_index(ifa->ifa_ifp), ifnet_type(ifa->ifa_ifp), ifnet_name(ifa->ifa_ifp), 734 #else 735 ifa->ifa_ifp->if_index, ifa->ifa_ifp->if_type, ifa->ifa_ifp->if_xname, 736 #endif 737 (void *)ifa, ifa->ifa_addr, ifa_flags, 1); 738 } else { 739 740 sctp_del_addr_from_vrf(SCTP_DEFAULT_VRFID, ifa->ifa_addr, 741 #if defined(__APPLE__) 742 ifnet_index(ifa->ifa_ifp), 743 ifnet_name(ifa->ifa_ifp)); 744 #else 745 ifa->ifa_ifp->if_index, 746 ifa->ifa_ifp->if_xname); 747 #endif 748 749 /* We don't bump refcount here so when it completes 750 * the final delete will happen. 751 */ 752 } 753 #endif 754 } 755 756 #if defined(__FreeBSD__) 757 void 758 sctp_add_or_del_interfaces(int (*pred)(struct ifnet *), int add) 759 { 760 struct ifnet *ifn; 761 struct ifaddr *ifa; 762 763 IFNET_RLOCK(); 764 TAILQ_FOREACH(ifn, &MODULE_GLOBAL(ifnet), if_list) { 765 if (!(*pred)(ifn)) { 766 continue; 767 } 768 TAILQ_FOREACH(ifa, &ifn->if_addrlist, ifa_list) { 769 sctp_addr_change(ifa, add ? RTM_ADD : RTM_DELETE); 770 } 771 } 772 IFNET_RUNLOCK(); 773 } 774 #endif 775 #if defined(__APPLE__) 776 void 777 sctp_add_or_del_interfaces(int (*pred)(struct ifnet *), int add) 778 { 779 struct ifnet **ifnetlist; 780 struct ifaddr **ifaddrlist; 781 uint32_t i, j, count; 782 783 if (ifnet_list_get(IFNET_FAMILY_ANY, &ifnetlist, &count) != 0) { 784 return; 785 } 786 for (i = 0; i < count; i++) { 787 if (!(*pred)(ifnetlist[i])) { 788 continue; 789 } 790 if (ifnet_get_address_list(ifnetlist[i], &ifaddrlist) != 0) { 791 continue; 792 } 793 for (j = 0; ifaddrlist[j] != NULL; j++) { 794 sctp_addr_change(ifaddrlist[j], add ? RTM_ADD : RTM_DELETE); 795 } 796 ifnet_free_address_list(ifaddrlist); 797 } 798 ifnet_list_free(ifnetlist); 799 return; 800 } 801 #endif 802 803 struct mbuf * 804 sctp_get_mbuf_for_msg(unsigned int space_needed, int want_header, 805 int how, int allonebuf, int type) 806 { 807 struct mbuf *m = NULL; 808 #if defined(__Userspace__) 809 810 /* 811 * __Userspace__ 812 * Using m_clget, which creates and mbuf and a cluster and 813 * hooks those together. 814 * TODO: This does not yet have functionality for jumbo packets. 815 * 816 */ 817 818 int mbuf_threshold; 819 if (want_header) { 820 MGETHDR(m, how, type); 821 } else { 822 MGET(m, how, type); 823 } 824 if (m == NULL) { 825 return (NULL); 826 } 827 if (allonebuf == 0) 828 mbuf_threshold = SCTP_BASE_SYSCTL(sctp_mbuf_threshold_count); 829 else 830 mbuf_threshold = 1; 831 832 833 if ((int)space_needed > (((mbuf_threshold - 1) * MLEN) + MHLEN)) { 834 MCLGET(m, how); 835 if (m == NULL) { 836 return (NULL); 837 } 838 839 if (SCTP_BUF_IS_EXTENDED(m) == 0) { 840 sctp_m_freem(m); 841 return (NULL); 842 } 843 } 844 SCTP_BUF_LEN(m) = 0; 845 SCTP_BUF_NEXT(m) = SCTP_BUF_NEXT_PKT(m) = NULL; 846 847 #if defined(__Userspace__) 848 /* __Userspace__ 849 * Check if anything need to be done to ensure logging works 850 */ 851 #endif 852 #ifdef SCTP_MBUF_LOGGING 853 if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_MBUF_LOGGING_ENABLE) { 854 if (SCTP_BUF_IS_EXTENDED(m)) { 855 sctp_log_mb(m, SCTP_MBUF_IALLOC); 856 } 857 } 858 #endif 859 #elif defined(__FreeBSD__) && __FreeBSD_version > 602000 860 m = m_getm2(NULL, space_needed, how, type, want_header ? M_PKTHDR : 0); 861 if (m == NULL) { 862 /* bad, no memory */ 863 return (m); 864 } 865 if (allonebuf) { 866 int siz; 867 if (SCTP_BUF_IS_EXTENDED(m)) { 868 siz = SCTP_BUF_EXTEND_SIZE(m); 869 } else { 870 if (want_header) 871 siz = MHLEN; 872 else 873 siz = MLEN; 874 } 875 if (siz < space_needed) { 876 m_freem(m); 877 return (NULL); 878 } 879 } 880 if (SCTP_BUF_NEXT(m)) { 881 sctp_m_freem( SCTP_BUF_NEXT(m)); 882 SCTP_BUF_NEXT(m) = NULL; 883 } 884 #ifdef SCTP_MBUF_LOGGING 885 if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_MBUF_LOGGING_ENABLE) { 886 if (SCTP_BUF_IS_EXTENDED(m)) { 887 sctp_log_mb(m, SCTP_MBUF_IALLOC); 888 } 889 } 890 #endif 891 #else 892 #if defined(__FreeBSD__) && __FreeBSD_version >= 601000 893 int aloc_size; 894 int index = 0; 895 #endif 896 int mbuf_threshold; 897 if (want_header) { 898 MGETHDR(m, how, type); 899 } else { 900 MGET(m, how, type); 901 } 902 if (m == NULL) { 903 return (NULL); 904 } 905 if (allonebuf == 0) 906 mbuf_threshold = SCTP_BASE_SYSCTL(sctp_mbuf_threshold_count); 907 else 908 mbuf_threshold = 1; 909 910 911 if (space_needed > (((mbuf_threshold - 1) * MLEN) + MHLEN)) { 912 #if defined(__FreeBSD__) && __FreeBSD_version >= 601000 913 try_again: 914 index = 4; 915 if (space_needed <= MCLBYTES) { 916 aloc_size = MCLBYTES; 917 } else { 918 aloc_size = MJUMPAGESIZE; 919 index = 5; 920 } 921 m_cljget(m, how, aloc_size); 922 if (m == NULL) { 923 return (NULL); 924 } 925 if (SCTP_BUF_IS_EXTENDED(m) == 0) { 926 if ((aloc_size != MCLBYTES) && 927 (allonebuf == 0)) { 928 aloc_size -= 10; 929 goto try_again; 930 } 931 sctp_m_freem(m); 932 return (NULL); 933 } 934 #else 935 MCLGET(m, how); 936 if (m == NULL) { 937 return (NULL); 938 } 939 if (SCTP_BUF_IS_EXTENDED(m) == 0) { 940 sctp_m_freem(m); 941 return (NULL); 942 } 943 #endif 944 } 945 SCTP_BUF_LEN(m) = 0; 946 SCTP_BUF_NEXT(m) = SCTP_BUF_NEXT_PKT(m) = NULL; 947 #ifdef SCTP_MBUF_LOGGING 948 if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_MBUF_LOGGING_ENABLE) { 949 if (SCTP_BUF_IS_EXTENDED(m)) { 950 sctp_log_mb(m, SCTP_MBUF_IALLOC); 951 } 952 } 953 #endif 954 #endif 955 return (m); 956 } 957 958 959 #ifdef SCTP_PACKET_LOGGING 960 void 961 sctp_packet_log(struct mbuf *m) 962 { 963 int *lenat, thisone; 964 void *copyto; 965 uint32_t *tick_tock; 966 int length; 967 int total_len; 968 int grabbed_lock = 0; 969 int value, newval, thisend, thisbegin; 970 /* 971 * Buffer layout. 972 * -sizeof this entry (total_len) 973 * -previous end (value) 974 * -ticks of log (ticks) 975 * o -ip packet 976 * o -as logged 977 * - where this started (thisbegin) 978 * x <--end points here 979 */ 980 length = SCTP_HEADER_LEN(m); 981 total_len = SCTP_SIZE32((length + (4 * sizeof(int)))); 982 /* Log a packet to the buffer. */ 983 if (total_len> SCTP_PACKET_LOG_SIZE) { 984 /* Can't log this packet I have not a buffer big enough */ 985 return; 986 } 987 if (length < (int)(SCTP_MIN_V4_OVERHEAD + sizeof(struct sctp_cookie_ack_chunk))) { 988 return; 989 } 990 atomic_add_int(&SCTP_BASE_VAR(packet_log_writers), 1); 991 try_again: 992 if (SCTP_BASE_VAR(packet_log_writers) > SCTP_PKTLOG_WRITERS_NEED_LOCK) { 993 SCTP_IP_PKTLOG_LOCK(); 994 grabbed_lock = 1; 995 again_locked: 996 value = SCTP_BASE_VAR(packet_log_end); 997 newval = SCTP_BASE_VAR(packet_log_end) + total_len; 998 if (newval >= SCTP_PACKET_LOG_SIZE) { 999 /* we wrapped */ 1000 thisbegin = 0; 1001 thisend = total_len; 1002 } else { 1003 thisbegin = SCTP_BASE_VAR(packet_log_end); 1004 thisend = newval; 1005 } 1006 if (!(atomic_cmpset_int(&SCTP_BASE_VAR(packet_log_end), value, thisend))) { 1007 goto again_locked; 1008 } 1009 } else { 1010 value = SCTP_BASE_VAR(packet_log_end); 1011 newval = SCTP_BASE_VAR(packet_log_end) + total_len; 1012 if (newval >= SCTP_PACKET_LOG_SIZE) { 1013 /* we wrapped */ 1014 thisbegin = 0; 1015 thisend = total_len; 1016 } else { 1017 thisbegin = SCTP_BASE_VAR(packet_log_end); 1018 thisend = newval; 1019 } 1020 if (!(atomic_cmpset_int(&SCTP_BASE_VAR(packet_log_end), value, thisend))) { 1021 goto try_again; 1022 } 1023 } 1024 /* Sanity check */ 1025 if (thisend >= SCTP_PACKET_LOG_SIZE) { 1026 SCTP_PRINTF("Insanity stops a log thisbegin:%d thisend:%d writers:%d lock:%d end:%d\n", 1027 thisbegin, 1028 thisend, 1029 SCTP_BASE_VAR(packet_log_writers), 1030 grabbed_lock, 1031 SCTP_BASE_VAR(packet_log_end)); 1032 SCTP_BASE_VAR(packet_log_end) = 0; 1033 goto no_log; 1034 1035 } 1036 lenat = (int *)&SCTP_BASE_VAR(packet_log_buffer)[thisbegin]; 1037 *lenat = total_len; 1038 lenat++; 1039 *lenat = value; 1040 lenat++; 1041 tick_tock = (uint32_t *)lenat; 1042 lenat++; 1043 *tick_tock = sctp_get_tick_count(); 1044 copyto = (void *)lenat; 1045 thisone = thisend - sizeof(int); 1046 lenat = (int *)&SCTP_BASE_VAR(packet_log_buffer)[thisone]; 1047 *lenat = thisbegin; 1048 if (grabbed_lock) { 1049 SCTP_IP_PKTLOG_UNLOCK(); 1050 grabbed_lock = 0; 1051 } 1052 m_copydata(m, 0, length, (caddr_t)copyto); 1053 no_log: 1054 if (grabbed_lock) { 1055 SCTP_IP_PKTLOG_UNLOCK(); 1056 } 1057 atomic_subtract_int(&SCTP_BASE_VAR(packet_log_writers), 1); 1058 } 1059 1060 1061 int 1062 sctp_copy_out_packet_log(uint8_t *target, int length) 1063 { 1064 /* We wind through the packet log starting at 1065 * start copying up to length bytes out. 1066 * We return the number of bytes copied. 1067 */ 1068 int tocopy, this_copy; 1069 int *lenat; 1070 int did_delay = 0; 1071 1072 tocopy = length; 1073 if (length < (int)(2 * sizeof(int))) { 1074 /* not enough room */ 1075 return (0); 1076 } 1077 if (SCTP_PKTLOG_WRITERS_NEED_LOCK) { 1078 atomic_add_int(&SCTP_BASE_VAR(packet_log_writers), SCTP_PKTLOG_WRITERS_NEED_LOCK); 1079 again: 1080 if ((did_delay == 0) && (SCTP_BASE_VAR(packet_log_writers) != SCTP_PKTLOG_WRITERS_NEED_LOCK)) { 1081 /* we delay here for just a moment hoping the writer(s) that were 1082 * present when we entered will have left and we only have 1083 * locking ones that will contend with us for the lock. This 1084 * does not assure 100% access, but its good enough for 1085 * a logging facility like this. 1086 */ 1087 did_delay = 1; 1088 DELAY(10); 1089 goto again; 1090 } 1091 } 1092 SCTP_IP_PKTLOG_LOCK(); 1093 lenat = (int *)target; 1094 *lenat = SCTP_BASE_VAR(packet_log_end); 1095 lenat++; 1096 this_copy = min((length - sizeof(int)), SCTP_PACKET_LOG_SIZE); 1097 memcpy((void *)lenat, (void *)SCTP_BASE_VAR(packet_log_buffer), this_copy); 1098 if (SCTP_PKTLOG_WRITERS_NEED_LOCK) { 1099 atomic_subtract_int(&SCTP_BASE_VAR(packet_log_writers), 1100 SCTP_PKTLOG_WRITERS_NEED_LOCK); 1101 } 1102 SCTP_IP_PKTLOG_UNLOCK(); 1103 return (this_copy + sizeof(int)); 1104 } 1105 1106 #endif 1107
