1 /* 2 * hostapd / VLAN initialization - full dynamic VLAN 3 * Copyright 2003, Instant802 Networks, Inc. 4 * Copyright 2005-2006, Devicescape Software, Inc. 5 * Copyright (c) 2009, Jouni Malinen <j (at) w1.fi> 6 * 7 * This software may be distributed under the terms of the BSD license. 8 * See README for more details. 9 */ 10 11 #include "utils/includes.h" 12 #include <net/if.h> 13 /* Avoid conflicts due to NetBSD net/if.h if_type define with driver.h */ 14 #undef if_type 15 #include <sys/ioctl.h> 16 17 #include "utils/common.h" 18 #include "drivers/priv_netlink.h" 19 #include "drivers/linux_ioctl.h" 20 #include "common/linux_bridge.h" 21 #include "common/linux_vlan.h" 22 #include "utils/eloop.h" 23 #include "hostapd.h" 24 #include "ap_config.h" 25 #include "ap_drv_ops.h" 26 #include "wpa_auth.h" 27 #include "vlan_init.h" 28 #include "vlan_util.h" 29 30 31 struct full_dynamic_vlan { 32 int s; /* socket on which to listen for new/removed interfaces. */ 33 }; 34 35 #define DVLAN_CLEAN_BR 0x1 36 #define DVLAN_CLEAN_VLAN 0x2 37 #define DVLAN_CLEAN_VLAN_PORT 0x4 38 39 struct dynamic_iface { 40 char ifname[IFNAMSIZ + 1]; 41 int usage; 42 int clean; 43 struct dynamic_iface *next; 44 }; 45 46 47 /* Increment ref counter for ifname and add clean flag. 48 * If not in list, add it only if some flags are given. 49 */ 50 static void dyn_iface_get(struct hostapd_data *hapd, const char *ifname, 51 int clean) 52 { 53 struct dynamic_iface *next, **dynamic_ifaces; 54 struct hapd_interfaces *interfaces; 55 56 interfaces = hapd->iface->interfaces; 57 dynamic_ifaces = &interfaces->vlan_priv; 58 59 for (next = *dynamic_ifaces; next; next = next->next) { 60 if (os_strcmp(ifname, next->ifname) == 0) 61 break; 62 } 63 64 if (next) { 65 next->usage++; 66 next->clean |= clean; 67 return; 68 } 69 70 if (!clean) 71 return; 72 73 next = os_zalloc(sizeof(*next)); 74 if (!next) 75 return; 76 os_strlcpy(next->ifname, ifname, sizeof(next->ifname)); 77 next->usage = 1; 78 next->clean = clean; 79 next->next = *dynamic_ifaces; 80 *dynamic_ifaces = next; 81 } 82 83 84 /* Decrement reference counter for given ifname. 85 * Return clean flag iff reference counter was decreased to zero, else zero 86 */ 87 static int dyn_iface_put(struct hostapd_data *hapd, const char *ifname) 88 { 89 struct dynamic_iface *next, *prev = NULL, **dynamic_ifaces; 90 struct hapd_interfaces *interfaces; 91 int clean; 92 93 interfaces = hapd->iface->interfaces; 94 dynamic_ifaces = &interfaces->vlan_priv; 95 96 for (next = *dynamic_ifaces; next; next = next->next) { 97 if (os_strcmp(ifname, next->ifname) == 0) 98 break; 99 prev = next; 100 } 101 102 if (!next) 103 return 0; 104 105 next->usage--; 106 if (next->usage) 107 return 0; 108 109 if (prev) 110 prev->next = next->next; 111 else 112 *dynamic_ifaces = next->next; 113 clean = next->clean; 114 os_free(next); 115 116 return clean; 117 } 118 119 120 static int ifconfig_down(const char *if_name) 121 { 122 wpa_printf(MSG_DEBUG, "VLAN: Set interface %s down", if_name); 123 return ifconfig_helper(if_name, 0); 124 } 125 126 127 /* This value should be 256 ONLY. If it is something else, then hostapd 128 * might crash!, as this value has been hard-coded in 2.4.x kernel 129 * bridging code. 130 */ 131 #define MAX_BR_PORTS 256 132 133 static int br_delif(const char *br_name, const char *if_name) 134 { 135 int fd; 136 struct ifreq ifr; 137 unsigned long args[2]; 138 int if_index; 139 140 wpa_printf(MSG_DEBUG, "VLAN: br_delif(%s, %s)", br_name, if_name); 141 if ((fd = socket(AF_INET, SOCK_STREAM, 0)) < 0) { 142 wpa_printf(MSG_ERROR, "VLAN: %s: socket(AF_INET,SOCK_STREAM) " 143 "failed: %s", __func__, strerror(errno)); 144 return -1; 145 } 146 147 if (linux_br_del_if(fd, br_name, if_name) == 0) 148 goto done; 149 150 if_index = if_nametoindex(if_name); 151 152 if (if_index == 0) { 153 wpa_printf(MSG_ERROR, "VLAN: %s: Failure determining " 154 "interface index for '%s'", 155 __func__, if_name); 156 close(fd); 157 return -1; 158 } 159 160 args[0] = BRCTL_DEL_IF; 161 args[1] = if_index; 162 163 os_strlcpy(ifr.ifr_name, br_name, sizeof(ifr.ifr_name)); 164 ifr.ifr_data = (void *) args; 165 166 if (ioctl(fd, SIOCDEVPRIVATE, &ifr) < 0 && errno != EINVAL) { 167 /* No error if interface already removed. */ 168 wpa_printf(MSG_ERROR, "VLAN: %s: ioctl[SIOCDEVPRIVATE," 169 "BRCTL_DEL_IF] failed for br_name=%s if_name=%s: " 170 "%s", __func__, br_name, if_name, strerror(errno)); 171 close(fd); 172 return -1; 173 } 174 175 done: 176 close(fd); 177 return 0; 178 } 179 180 181 /* 182 Add interface 'if_name' to the bridge 'br_name' 183 184 returns -1 on error 185 returns 1 if the interface is already part of the bridge 186 returns 0 otherwise 187 */ 188 static int br_addif(const char *br_name, const char *if_name) 189 { 190 int fd; 191 struct ifreq ifr; 192 unsigned long args[2]; 193 int if_index; 194 195 wpa_printf(MSG_DEBUG, "VLAN: br_addif(%s, %s)", br_name, if_name); 196 if ((fd = socket(AF_INET, SOCK_STREAM, 0)) < 0) { 197 wpa_printf(MSG_ERROR, "VLAN: %s: socket(AF_INET,SOCK_STREAM) " 198 "failed: %s", __func__, strerror(errno)); 199 return -1; 200 } 201 202 if (linux_br_add_if(fd, br_name, if_name) == 0) 203 goto done; 204 if (errno == EBUSY) { 205 /* The interface is already added. */ 206 close(fd); 207 return 1; 208 } 209 210 if_index = if_nametoindex(if_name); 211 212 if (if_index == 0) { 213 wpa_printf(MSG_ERROR, "VLAN: %s: Failure determining " 214 "interface index for '%s'", 215 __func__, if_name); 216 close(fd); 217 return -1; 218 } 219 220 args[0] = BRCTL_ADD_IF; 221 args[1] = if_index; 222 223 os_strlcpy(ifr.ifr_name, br_name, sizeof(ifr.ifr_name)); 224 ifr.ifr_data = (void *) args; 225 226 if (ioctl(fd, SIOCDEVPRIVATE, &ifr) < 0) { 227 if (errno == EBUSY) { 228 /* The interface is already added. */ 229 close(fd); 230 return 1; 231 } 232 233 wpa_printf(MSG_ERROR, "VLAN: %s: ioctl[SIOCDEVPRIVATE," 234 "BRCTL_ADD_IF] failed for br_name=%s if_name=%s: " 235 "%s", __func__, br_name, if_name, strerror(errno)); 236 close(fd); 237 return -1; 238 } 239 240 done: 241 close(fd); 242 return 0; 243 } 244 245 246 static int br_delbr(const char *br_name) 247 { 248 int fd; 249 unsigned long arg[2]; 250 251 wpa_printf(MSG_DEBUG, "VLAN: br_delbr(%s)", br_name); 252 if ((fd = socket(AF_INET, SOCK_STREAM, 0)) < 0) { 253 wpa_printf(MSG_ERROR, "VLAN: %s: socket(AF_INET,SOCK_STREAM) " 254 "failed: %s", __func__, strerror(errno)); 255 return -1; 256 } 257 258 if (linux_br_del(fd, br_name) == 0) 259 goto done; 260 261 arg[0] = BRCTL_DEL_BRIDGE; 262 arg[1] = (unsigned long) br_name; 263 264 if (ioctl(fd, SIOCGIFBR, arg) < 0 && errno != ENXIO) { 265 /* No error if bridge already removed. */ 266 wpa_printf(MSG_ERROR, "VLAN: %s: BRCTL_DEL_BRIDGE failed for " 267 "%s: %s", __func__, br_name, strerror(errno)); 268 close(fd); 269 return -1; 270 } 271 272 done: 273 close(fd); 274 return 0; 275 } 276 277 278 /* 279 Add a bridge with the name 'br_name'. 280 281 returns -1 on error 282 returns 1 if the bridge already exists 283 returns 0 otherwise 284 */ 285 static int br_addbr(const char *br_name) 286 { 287 int fd; 288 unsigned long arg[4]; 289 struct ifreq ifr; 290 291 wpa_printf(MSG_DEBUG, "VLAN: br_addbr(%s)", br_name); 292 if ((fd = socket(AF_INET, SOCK_STREAM, 0)) < 0) { 293 wpa_printf(MSG_ERROR, "VLAN: %s: socket(AF_INET,SOCK_STREAM) " 294 "failed: %s", __func__, strerror(errno)); 295 return -1; 296 } 297 298 if (linux_br_add(fd, br_name) == 0) 299 goto done; 300 if (errno == EEXIST) { 301 /* The bridge is already added. */ 302 close(fd); 303 return 1; 304 } 305 306 arg[0] = BRCTL_ADD_BRIDGE; 307 arg[1] = (unsigned long) br_name; 308 309 if (ioctl(fd, SIOCGIFBR, arg) < 0) { 310 if (errno == EEXIST) { 311 /* The bridge is already added. */ 312 close(fd); 313 return 1; 314 } else { 315 wpa_printf(MSG_ERROR, "VLAN: %s: BRCTL_ADD_BRIDGE " 316 "failed for %s: %s", 317 __func__, br_name, strerror(errno)); 318 close(fd); 319 return -1; 320 } 321 } 322 323 done: 324 /* Decrease forwarding delay to avoid EAPOL timeouts. */ 325 os_memset(&ifr, 0, sizeof(ifr)); 326 os_strlcpy(ifr.ifr_name, br_name, IFNAMSIZ); 327 arg[0] = BRCTL_SET_BRIDGE_FORWARD_DELAY; 328 arg[1] = 1; 329 arg[2] = 0; 330 arg[3] = 0; 331 ifr.ifr_data = (char *) &arg; 332 if (ioctl(fd, SIOCDEVPRIVATE, &ifr) < 0) { 333 wpa_printf(MSG_ERROR, "VLAN: %s: " 334 "BRCTL_SET_BRIDGE_FORWARD_DELAY (1 sec) failed for " 335 "%s: %s", __func__, br_name, strerror(errno)); 336 /* Continue anyway */ 337 } 338 339 close(fd); 340 return 0; 341 } 342 343 344 static int br_getnumports(const char *br_name) 345 { 346 int fd; 347 int i; 348 int port_cnt = 0; 349 unsigned long arg[4]; 350 int ifindices[MAX_BR_PORTS]; 351 struct ifreq ifr; 352 353 if ((fd = socket(AF_INET, SOCK_STREAM, 0)) < 0) { 354 wpa_printf(MSG_ERROR, "VLAN: %s: socket(AF_INET,SOCK_STREAM) " 355 "failed: %s", __func__, strerror(errno)); 356 return -1; 357 } 358 359 arg[0] = BRCTL_GET_PORT_LIST; 360 arg[1] = (unsigned long) ifindices; 361 arg[2] = MAX_BR_PORTS; 362 arg[3] = 0; 363 364 os_memset(ifindices, 0, sizeof(ifindices)); 365 os_strlcpy(ifr.ifr_name, br_name, sizeof(ifr.ifr_name)); 366 ifr.ifr_data = (void *) arg; 367 368 if (ioctl(fd, SIOCDEVPRIVATE, &ifr) < 0) { 369 wpa_printf(MSG_ERROR, "VLAN: %s: BRCTL_GET_PORT_LIST " 370 "failed for %s: %s", 371 __func__, br_name, strerror(errno)); 372 close(fd); 373 return -1; 374 } 375 376 for (i = 1; i < MAX_BR_PORTS; i++) { 377 if (ifindices[i] > 0) { 378 port_cnt++; 379 } 380 } 381 382 close(fd); 383 return port_cnt; 384 } 385 386 387 static void vlan_newlink_tagged(int vlan_naming, const char *tagged_interface, 388 const char *br_name, int vid, 389 struct hostapd_data *hapd) 390 { 391 char vlan_ifname[IFNAMSIZ]; 392 int clean; 393 int ret; 394 395 if (vlan_naming == DYNAMIC_VLAN_NAMING_WITH_DEVICE) 396 ret = os_snprintf(vlan_ifname, sizeof(vlan_ifname), "%s.%d", 397 tagged_interface, vid); 398 else 399 ret = os_snprintf(vlan_ifname, sizeof(vlan_ifname), "vlan%d", 400 vid); 401 if (ret >= (int) sizeof(vlan_ifname)) 402 wpa_printf(MSG_WARNING, 403 "VLAN: Interface name was truncated to %s", 404 vlan_ifname); 405 406 clean = 0; 407 ifconfig_up(tagged_interface); 408 if (!vlan_add(tagged_interface, vid, vlan_ifname)) 409 clean |= DVLAN_CLEAN_VLAN; 410 411 if (!br_addif(br_name, vlan_ifname)) 412 clean |= DVLAN_CLEAN_VLAN_PORT; 413 414 dyn_iface_get(hapd, vlan_ifname, clean); 415 416 ifconfig_up(vlan_ifname); 417 } 418 419 420 static void vlan_bridge_name(char *br_name, struct hostapd_data *hapd, 421 struct hostapd_vlan *vlan, int vid) 422 { 423 char *tagged_interface = hapd->conf->ssid.vlan_tagged_interface; 424 int ret; 425 426 if (vlan->bridge[0]) { 427 os_strlcpy(br_name, vlan->bridge, IFNAMSIZ); 428 ret = 0; 429 } else if (hapd->conf->vlan_bridge[0]) { 430 ret = os_snprintf(br_name, IFNAMSIZ, "%s%d", 431 hapd->conf->vlan_bridge, vid); 432 } else if (tagged_interface) { 433 ret = os_snprintf(br_name, IFNAMSIZ, "br%s.%d", 434 tagged_interface, vid); 435 } else { 436 ret = os_snprintf(br_name, IFNAMSIZ, "brvlan%d", vid); 437 } 438 if (ret >= IFNAMSIZ) 439 wpa_printf(MSG_WARNING, 440 "VLAN: Interface name was truncated to %s", 441 br_name); 442 } 443 444 445 static void vlan_get_bridge(const char *br_name, struct hostapd_data *hapd, 446 int vid) 447 { 448 char *tagged_interface = hapd->conf->ssid.vlan_tagged_interface; 449 int vlan_naming = hapd->conf->ssid.vlan_naming; 450 451 dyn_iface_get(hapd, br_name, br_addbr(br_name) ? 0 : DVLAN_CLEAN_BR); 452 453 ifconfig_up(br_name); 454 455 if (tagged_interface) 456 vlan_newlink_tagged(vlan_naming, tagged_interface, br_name, 457 vid, hapd); 458 } 459 460 461 void vlan_newlink(const char *ifname, struct hostapd_data *hapd) 462 { 463 char br_name[IFNAMSIZ]; 464 struct hostapd_vlan *vlan; 465 int untagged, *tagged, i, notempty; 466 467 wpa_printf(MSG_DEBUG, "VLAN: vlan_newlink(%s)", ifname); 468 469 for (vlan = hapd->conf->vlan; vlan; vlan = vlan->next) { 470 if (vlan->configured || 471 os_strcmp(ifname, vlan->ifname) != 0) 472 continue; 473 break; 474 } 475 if (!vlan) 476 return; 477 478 vlan->configured = 1; 479 480 notempty = vlan->vlan_desc.notempty; 481 untagged = vlan->vlan_desc.untagged; 482 tagged = vlan->vlan_desc.tagged; 483 484 if (!notempty) { 485 /* Non-VLAN STA */ 486 if (hapd->conf->bridge[0] && 487 !br_addif(hapd->conf->bridge, ifname)) 488 vlan->clean |= DVLAN_CLEAN_WLAN_PORT; 489 } else if (untagged > 0 && untagged <= MAX_VLAN_ID) { 490 vlan_bridge_name(br_name, hapd, vlan, untagged); 491 492 vlan_get_bridge(br_name, hapd, untagged); 493 494 if (!br_addif(br_name, ifname)) 495 vlan->clean |= DVLAN_CLEAN_WLAN_PORT; 496 } 497 498 for (i = 0; i < MAX_NUM_TAGGED_VLAN && tagged[i]; i++) { 499 if (tagged[i] == untagged || 500 tagged[i] <= 0 || tagged[i] > MAX_VLAN_ID || 501 (i > 0 && tagged[i] == tagged[i - 1])) 502 continue; 503 vlan_bridge_name(br_name, hapd, vlan, tagged[i]); 504 vlan_get_bridge(br_name, hapd, tagged[i]); 505 vlan_newlink_tagged(DYNAMIC_VLAN_NAMING_WITH_DEVICE, 506 ifname, br_name, tagged[i], hapd); 507 } 508 509 ifconfig_up(ifname); 510 } 511 512 513 static void vlan_dellink_tagged(int vlan_naming, const char *tagged_interface, 514 const char *br_name, int vid, 515 struct hostapd_data *hapd) 516 { 517 char vlan_ifname[IFNAMSIZ]; 518 int clean; 519 int ret; 520 521 if (vlan_naming == DYNAMIC_VLAN_NAMING_WITH_DEVICE) 522 ret = os_snprintf(vlan_ifname, sizeof(vlan_ifname), "%s.%d", 523 tagged_interface, vid); 524 else 525 ret = os_snprintf(vlan_ifname, sizeof(vlan_ifname), "vlan%d", 526 vid); 527 if (ret >= (int) sizeof(vlan_ifname)) 528 wpa_printf(MSG_WARNING, 529 "VLAN: Interface name was truncated to %s", 530 vlan_ifname); 531 532 533 clean = dyn_iface_put(hapd, vlan_ifname); 534 535 if (clean & DVLAN_CLEAN_VLAN_PORT) 536 br_delif(br_name, vlan_ifname); 537 538 if (clean & DVLAN_CLEAN_VLAN) { 539 ifconfig_down(vlan_ifname); 540 vlan_rem(vlan_ifname); 541 } 542 } 543 544 545 static void vlan_put_bridge(const char *br_name, struct hostapd_data *hapd, 546 int vid) 547 { 548 int clean; 549 char *tagged_interface = hapd->conf->ssid.vlan_tagged_interface; 550 int vlan_naming = hapd->conf->ssid.vlan_naming; 551 552 if (tagged_interface) 553 vlan_dellink_tagged(vlan_naming, tagged_interface, br_name, 554 vid, hapd); 555 556 clean = dyn_iface_put(hapd, br_name); 557 if ((clean & DVLAN_CLEAN_BR) && br_getnumports(br_name) == 0) { 558 ifconfig_down(br_name); 559 br_delbr(br_name); 560 } 561 } 562 563 564 void vlan_dellink(const char *ifname, struct hostapd_data *hapd) 565 { 566 struct hostapd_vlan *first, *prev, *vlan = hapd->conf->vlan; 567 568 wpa_printf(MSG_DEBUG, "VLAN: vlan_dellink(%s)", ifname); 569 570 first = prev = vlan; 571 572 while (vlan) { 573 if (os_strcmp(ifname, vlan->ifname) != 0) { 574 prev = vlan; 575 vlan = vlan->next; 576 continue; 577 } 578 break; 579 } 580 if (!vlan) 581 return; 582 583 if (vlan->configured) { 584 int notempty = vlan->vlan_desc.notempty; 585 int untagged = vlan->vlan_desc.untagged; 586 int *tagged = vlan->vlan_desc.tagged; 587 char br_name[IFNAMSIZ]; 588 int i; 589 590 for (i = 0; i < MAX_NUM_TAGGED_VLAN && tagged[i]; i++) { 591 if (tagged[i] == untagged || 592 tagged[i] <= 0 || tagged[i] > MAX_VLAN_ID || 593 (i > 0 && tagged[i] == tagged[i - 1])) 594 continue; 595 vlan_bridge_name(br_name, hapd, vlan, tagged[i]); 596 vlan_dellink_tagged(DYNAMIC_VLAN_NAMING_WITH_DEVICE, 597 ifname, br_name, tagged[i], hapd); 598 vlan_put_bridge(br_name, hapd, tagged[i]); 599 } 600 601 if (!notempty) { 602 /* Non-VLAN STA */ 603 if (hapd->conf->bridge[0] && 604 (vlan->clean & DVLAN_CLEAN_WLAN_PORT)) 605 br_delif(hapd->conf->bridge, ifname); 606 } else if (untagged > 0 && untagged <= MAX_VLAN_ID) { 607 vlan_bridge_name(br_name, hapd, vlan, untagged); 608 609 if (vlan->clean & DVLAN_CLEAN_WLAN_PORT) 610 br_delif(br_name, vlan->ifname); 611 612 vlan_put_bridge(br_name, hapd, untagged); 613 } 614 } 615 616 /* 617 * Ensure this VLAN interface is actually removed even if 618 * NEWLINK message is only received later. 619 */ 620 if (if_nametoindex(vlan->ifname) && vlan_if_remove(hapd, vlan)) 621 wpa_printf(MSG_ERROR, 622 "VLAN: Could not remove VLAN iface: %s: %s", 623 vlan->ifname, strerror(errno)); 624 625 if (vlan == first) 626 hapd->conf->vlan = vlan->next; 627 else 628 prev->next = vlan->next; 629 630 os_free(vlan); 631 } 632 633 634 static void 635 vlan_read_ifnames(struct nlmsghdr *h, size_t len, int del, 636 struct hostapd_data *hapd) 637 { 638 struct ifinfomsg *ifi; 639 int attrlen, nlmsg_len, rta_len; 640 struct rtattr *attr; 641 char ifname[IFNAMSIZ + 1]; 642 643 if (len < sizeof(*ifi)) 644 return; 645 646 ifi = NLMSG_DATA(h); 647 648 nlmsg_len = NLMSG_ALIGN(sizeof(struct ifinfomsg)); 649 650 attrlen = h->nlmsg_len - nlmsg_len; 651 if (attrlen < 0) 652 return; 653 654 attr = (struct rtattr *) (((char *) ifi) + nlmsg_len); 655 656 os_memset(ifname, 0, sizeof(ifname)); 657 rta_len = RTA_ALIGN(sizeof(struct rtattr)); 658 while (RTA_OK(attr, attrlen)) { 659 if (attr->rta_type == IFLA_IFNAME) { 660 int n = attr->rta_len - rta_len; 661 if (n < 0) 662 break; 663 664 if ((size_t) n >= sizeof(ifname)) 665 n = sizeof(ifname) - 1; 666 os_memcpy(ifname, ((char *) attr) + rta_len, n); 667 668 } 669 670 attr = RTA_NEXT(attr, attrlen); 671 } 672 673 if (!ifname[0]) 674 return; 675 if (del && if_nametoindex(ifname)) { 676 /* interface still exists, race condition -> 677 * iface has just been recreated */ 678 return; 679 } 680 681 wpa_printf(MSG_DEBUG, 682 "VLAN: RTM_%sLINK: ifi_index=%d ifname=%s ifi_family=%d ifi_flags=0x%x (%s%s%s%s)", 683 del ? "DEL" : "NEW", 684 ifi->ifi_index, ifname, ifi->ifi_family, ifi->ifi_flags, 685 (ifi->ifi_flags & IFF_UP) ? "[UP]" : "", 686 (ifi->ifi_flags & IFF_RUNNING) ? "[RUNNING]" : "", 687 (ifi->ifi_flags & IFF_LOWER_UP) ? "[LOWER_UP]" : "", 688 (ifi->ifi_flags & IFF_DORMANT) ? "[DORMANT]" : ""); 689 690 if (del) 691 vlan_dellink(ifname, hapd); 692 else 693 vlan_newlink(ifname, hapd); 694 } 695 696 697 static void vlan_event_receive(int sock, void *eloop_ctx, void *sock_ctx) 698 { 699 char buf[8192]; 700 int left; 701 struct sockaddr_nl from; 702 socklen_t fromlen; 703 struct nlmsghdr *h; 704 struct hostapd_data *hapd = eloop_ctx; 705 706 fromlen = sizeof(from); 707 left = recvfrom(sock, buf, sizeof(buf), MSG_DONTWAIT, 708 (struct sockaddr *) &from, &fromlen); 709 if (left < 0) { 710 if (errno != EINTR && errno != EAGAIN) 711 wpa_printf(MSG_ERROR, "VLAN: %s: recvfrom failed: %s", 712 __func__, strerror(errno)); 713 return; 714 } 715 716 h = (struct nlmsghdr *) buf; 717 while (NLMSG_OK(h, left)) { 718 int len, plen; 719 720 len = h->nlmsg_len; 721 plen = len - sizeof(*h); 722 if (len > left || plen < 0) { 723 wpa_printf(MSG_DEBUG, "VLAN: Malformed netlink " 724 "message: len=%d left=%d plen=%d", 725 len, left, plen); 726 break; 727 } 728 729 switch (h->nlmsg_type) { 730 case RTM_NEWLINK: 731 vlan_read_ifnames(h, plen, 0, hapd); 732 break; 733 case RTM_DELLINK: 734 vlan_read_ifnames(h, plen, 1, hapd); 735 break; 736 } 737 738 h = NLMSG_NEXT(h, left); 739 } 740 741 if (left > 0) { 742 wpa_printf(MSG_DEBUG, "VLAN: %s: %d extra bytes in the end of " 743 "netlink message", __func__, left); 744 } 745 } 746 747 748 struct full_dynamic_vlan * 749 full_dynamic_vlan_init(struct hostapd_data *hapd) 750 { 751 struct sockaddr_nl local; 752 struct full_dynamic_vlan *priv; 753 754 priv = os_zalloc(sizeof(*priv)); 755 if (priv == NULL) 756 return NULL; 757 758 vlan_set_name_type(hapd->conf->ssid.vlan_naming == 759 DYNAMIC_VLAN_NAMING_WITH_DEVICE ? 760 VLAN_NAME_TYPE_RAW_PLUS_VID_NO_PAD : 761 VLAN_NAME_TYPE_PLUS_VID_NO_PAD); 762 763 priv->s = socket(PF_NETLINK, SOCK_RAW, NETLINK_ROUTE); 764 if (priv->s < 0) { 765 wpa_printf(MSG_ERROR, "VLAN: %s: socket(PF_NETLINK,SOCK_RAW," 766 "NETLINK_ROUTE) failed: %s", 767 __func__, strerror(errno)); 768 os_free(priv); 769 return NULL; 770 } 771 772 os_memset(&local, 0, sizeof(local)); 773 local.nl_family = AF_NETLINK; 774 local.nl_groups = RTMGRP_LINK; 775 if (bind(priv->s, (struct sockaddr *) &local, sizeof(local)) < 0) { 776 wpa_printf(MSG_ERROR, "VLAN: %s: bind(netlink) failed: %s", 777 __func__, strerror(errno)); 778 close(priv->s); 779 os_free(priv); 780 return NULL; 781 } 782 783 if (eloop_register_read_sock(priv->s, vlan_event_receive, hapd, NULL)) 784 { 785 close(priv->s); 786 os_free(priv); 787 return NULL; 788 } 789 790 return priv; 791 } 792 793 794 void full_dynamic_vlan_deinit(struct full_dynamic_vlan *priv) 795 { 796 if (priv == NULL) 797 return; 798 eloop_unregister_read_sock(priv->s); 799 close(priv->s); 800 os_free(priv); 801 } 802
