1 /* 2 * hostapd / VLAN initialization 3 * Copyright 2003, Instant802 Networks, Inc. 4 * Copyright 2005-2006, Devicescape Software, Inc. 5 * Copyright (c) 2009, Jouni Malinen <j@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 #ifdef CONFIG_FULL_DYNAMIC_VLAN 13 #include <net/if.h> 14 #include <sys/ioctl.h> 15 #include <linux/sockios.h> 16 #include <linux/if_vlan.h> 17 #include <linux/if_bridge.h> 18 #endif /* CONFIG_FULL_DYNAMIC_VLAN */ 19 20 #include "utils/common.h" 21 #include "hostapd.h" 22 #include "ap_config.h" 23 #include "ap_drv_ops.h" 24 #include "vlan_init.h" 25 #include "vlan_util.h" 26 27 28 #ifdef CONFIG_FULL_DYNAMIC_VLAN 29 30 #include "drivers/priv_netlink.h" 31 #include "utils/eloop.h" 32 33 34 struct full_dynamic_vlan { 35 int s; /* socket on which to listen for new/removed interfaces. */ 36 }; 37 38 #define DVLAN_CLEAN_BR 0x1 39 #define DVLAN_CLEAN_VLAN 0x2 40 #define DVLAN_CLEAN_VLAN_PORT 0x4 41 42 struct dynamic_iface { 43 char ifname[IFNAMSIZ + 1]; 44 int usage; 45 int clean; 46 struct dynamic_iface *next; 47 }; 48 49 50 /* Increment ref counter for ifname and add clean flag. 51 * If not in list, add it only if some flags are given. 52 */ 53 static void dyn_iface_get(struct hostapd_data *hapd, const char *ifname, 54 int clean) 55 { 56 struct dynamic_iface *next, **dynamic_ifaces; 57 struct hapd_interfaces *interfaces; 58 59 interfaces = hapd->iface->interfaces; 60 dynamic_ifaces = &interfaces->vlan_priv; 61 62 for (next = *dynamic_ifaces; next; next = next->next) { 63 if (os_strcmp(ifname, next->ifname) == 0) 64 break; 65 } 66 67 if (next) { 68 next->usage++; 69 next->clean |= clean; 70 return; 71 } 72 73 if (!clean) 74 return; 75 76 next = os_zalloc(sizeof(*next)); 77 if (!next) 78 return; 79 os_strlcpy(next->ifname, ifname, sizeof(next->ifname)); 80 next->usage = 1; 81 next->clean = clean; 82 next->next = *dynamic_ifaces; 83 *dynamic_ifaces = next; 84 } 85 86 87 /* Decrement reference counter for given ifname. 88 * Return clean flag iff reference counter was decreased to zero, else zero 89 */ 90 static int dyn_iface_put(struct hostapd_data *hapd, const char *ifname) 91 { 92 struct dynamic_iface *next, *prev = NULL, **dynamic_ifaces; 93 struct hapd_interfaces *interfaces; 94 int clean; 95 96 interfaces = hapd->iface->interfaces; 97 dynamic_ifaces = &interfaces->vlan_priv; 98 99 for (next = *dynamic_ifaces; next; next = next->next) { 100 if (os_strcmp(ifname, next->ifname) == 0) 101 break; 102 prev = next; 103 } 104 105 if (!next) 106 return 0; 107 108 next->usage--; 109 if (next->usage) 110 return 0; 111 112 if (prev) 113 prev->next = next->next; 114 else 115 *dynamic_ifaces = next->next; 116 clean = next->clean; 117 os_free(next); 118 119 return clean; 120 } 121 122 123 static int ifconfig_helper(const char *if_name, int up) 124 { 125 int fd; 126 struct ifreq ifr; 127 128 if ((fd = socket(AF_INET, SOCK_STREAM, 0)) < 0) { 129 wpa_printf(MSG_ERROR, "VLAN: %s: socket(AF_INET,SOCK_STREAM) " 130 "failed: %s", __func__, strerror(errno)); 131 return -1; 132 } 133 134 os_memset(&ifr, 0, sizeof(ifr)); 135 os_strlcpy(ifr.ifr_name, if_name, IFNAMSIZ); 136 137 if (ioctl(fd, SIOCGIFFLAGS, &ifr) != 0) { 138 wpa_printf(MSG_ERROR, "VLAN: %s: ioctl(SIOCGIFFLAGS) failed " 139 "for interface %s: %s", 140 __func__, if_name, strerror(errno)); 141 close(fd); 142 return -1; 143 } 144 145 if (up) 146 ifr.ifr_flags |= IFF_UP; 147 else 148 ifr.ifr_flags &= ~IFF_UP; 149 150 if (ioctl(fd, SIOCSIFFLAGS, &ifr) != 0) { 151 wpa_printf(MSG_ERROR, "VLAN: %s: ioctl(SIOCSIFFLAGS) failed " 152 "for interface %s (up=%d): %s", 153 __func__, if_name, up, strerror(errno)); 154 close(fd); 155 return -1; 156 } 157 158 close(fd); 159 return 0; 160 } 161 162 163 static int ifconfig_up(const char *if_name) 164 { 165 wpa_printf(MSG_DEBUG, "VLAN: Set interface %s up", if_name); 166 return ifconfig_helper(if_name, 1); 167 } 168 169 170 static int ifconfig_down(const char *if_name) 171 { 172 wpa_printf(MSG_DEBUG, "VLAN: Set interface %s down", if_name); 173 return ifconfig_helper(if_name, 0); 174 } 175 176 177 /* 178 * These are only available in recent linux headers (without the leading 179 * underscore). 180 */ 181 #define _GET_VLAN_REALDEV_NAME_CMD 8 182 #define _GET_VLAN_VID_CMD 9 183 184 /* This value should be 256 ONLY. If it is something else, then hostapd 185 * might crash!, as this value has been hard-coded in 2.4.x kernel 186 * bridging code. 187 */ 188 #define MAX_BR_PORTS 256 189 190 static int br_delif(const char *br_name, const char *if_name) 191 { 192 int fd; 193 struct ifreq ifr; 194 unsigned long args[2]; 195 int if_index; 196 197 wpa_printf(MSG_DEBUG, "VLAN: br_delif(%s, %s)", br_name, if_name); 198 if ((fd = socket(AF_INET, SOCK_STREAM, 0)) < 0) { 199 wpa_printf(MSG_ERROR, "VLAN: %s: socket(AF_INET,SOCK_STREAM) " 200 "failed: %s", __func__, strerror(errno)); 201 return -1; 202 } 203 204 if_index = if_nametoindex(if_name); 205 206 if (if_index == 0) { 207 wpa_printf(MSG_ERROR, "VLAN: %s: Failure determining " 208 "interface index for '%s'", 209 __func__, if_name); 210 close(fd); 211 return -1; 212 } 213 214 args[0] = BRCTL_DEL_IF; 215 args[1] = if_index; 216 217 os_strlcpy(ifr.ifr_name, br_name, sizeof(ifr.ifr_name)); 218 ifr.ifr_data = (__caddr_t) args; 219 220 if (ioctl(fd, SIOCDEVPRIVATE, &ifr) < 0 && errno != EINVAL) { 221 /* No error if interface already removed. */ 222 wpa_printf(MSG_ERROR, "VLAN: %s: ioctl[SIOCDEVPRIVATE," 223 "BRCTL_DEL_IF] failed for br_name=%s if_name=%s: " 224 "%s", __func__, br_name, if_name, strerror(errno)); 225 close(fd); 226 return -1; 227 } 228 229 close(fd); 230 return 0; 231 } 232 233 234 /* 235 Add interface 'if_name' to the bridge 'br_name' 236 237 returns -1 on error 238 returns 1 if the interface is already part of the bridge 239 returns 0 otherwise 240 */ 241 static int br_addif(const char *br_name, const char *if_name) 242 { 243 int fd; 244 struct ifreq ifr; 245 unsigned long args[2]; 246 int if_index; 247 248 wpa_printf(MSG_DEBUG, "VLAN: br_addif(%s, %s)", br_name, if_name); 249 if ((fd = socket(AF_INET, SOCK_STREAM, 0)) < 0) { 250 wpa_printf(MSG_ERROR, "VLAN: %s: socket(AF_INET,SOCK_STREAM) " 251 "failed: %s", __func__, strerror(errno)); 252 return -1; 253 } 254 255 if_index = if_nametoindex(if_name); 256 257 if (if_index == 0) { 258 wpa_printf(MSG_ERROR, "VLAN: %s: Failure determining " 259 "interface index for '%s'", 260 __func__, if_name); 261 close(fd); 262 return -1; 263 } 264 265 args[0] = BRCTL_ADD_IF; 266 args[1] = if_index; 267 268 os_strlcpy(ifr.ifr_name, br_name, sizeof(ifr.ifr_name)); 269 ifr.ifr_data = (__caddr_t) args; 270 271 if (ioctl(fd, SIOCDEVPRIVATE, &ifr) < 0) { 272 if (errno == EBUSY) { 273 /* The interface is already added. */ 274 close(fd); 275 return 1; 276 } 277 278 wpa_printf(MSG_ERROR, "VLAN: %s: ioctl[SIOCDEVPRIVATE," 279 "BRCTL_ADD_IF] failed for br_name=%s if_name=%s: " 280 "%s", __func__, br_name, if_name, strerror(errno)); 281 close(fd); 282 return -1; 283 } 284 285 close(fd); 286 return 0; 287 } 288 289 290 static int br_delbr(const char *br_name) 291 { 292 int fd; 293 unsigned long arg[2]; 294 295 wpa_printf(MSG_DEBUG, "VLAN: br_delbr(%s)", br_name); 296 if ((fd = socket(AF_INET, SOCK_STREAM, 0)) < 0) { 297 wpa_printf(MSG_ERROR, "VLAN: %s: socket(AF_INET,SOCK_STREAM) " 298 "failed: %s", __func__, strerror(errno)); 299 return -1; 300 } 301 302 arg[0] = BRCTL_DEL_BRIDGE; 303 arg[1] = (unsigned long) br_name; 304 305 if (ioctl(fd, SIOCGIFBR, arg) < 0 && errno != ENXIO) { 306 /* No error if bridge already removed. */ 307 wpa_printf(MSG_ERROR, "VLAN: %s: BRCTL_DEL_BRIDGE failed for " 308 "%s: %s", __func__, br_name, strerror(errno)); 309 close(fd); 310 return -1; 311 } 312 313 close(fd); 314 return 0; 315 } 316 317 318 /* 319 Add a bridge with the name 'br_name'. 320 321 returns -1 on error 322 returns 1 if the bridge already exists 323 returns 0 otherwise 324 */ 325 static int br_addbr(const char *br_name) 326 { 327 int fd; 328 unsigned long arg[4]; 329 struct ifreq ifr; 330 331 wpa_printf(MSG_DEBUG, "VLAN: br_addbr(%s)", br_name); 332 if ((fd = socket(AF_INET, SOCK_STREAM, 0)) < 0) { 333 wpa_printf(MSG_ERROR, "VLAN: %s: socket(AF_INET,SOCK_STREAM) " 334 "failed: %s", __func__, strerror(errno)); 335 return -1; 336 } 337 338 arg[0] = BRCTL_ADD_BRIDGE; 339 arg[1] = (unsigned long) br_name; 340 341 if (ioctl(fd, SIOCGIFBR, arg) < 0) { 342 if (errno == EEXIST) { 343 /* The bridge is already added. */ 344 close(fd); 345 return 1; 346 } else { 347 wpa_printf(MSG_ERROR, "VLAN: %s: BRCTL_ADD_BRIDGE " 348 "failed for %s: %s", 349 __func__, br_name, strerror(errno)); 350 close(fd); 351 return -1; 352 } 353 } 354 355 /* Decrease forwarding delay to avoid EAPOL timeouts. */ 356 os_memset(&ifr, 0, sizeof(ifr)); 357 os_strlcpy(ifr.ifr_name, br_name, IFNAMSIZ); 358 arg[0] = BRCTL_SET_BRIDGE_FORWARD_DELAY; 359 arg[1] = 1; 360 arg[2] = 0; 361 arg[3] = 0; 362 ifr.ifr_data = (char *) &arg; 363 if (ioctl(fd, SIOCDEVPRIVATE, &ifr) < 0) { 364 wpa_printf(MSG_ERROR, "VLAN: %s: " 365 "BRCTL_SET_BRIDGE_FORWARD_DELAY (1 sec) failed for " 366 "%s: %s", __func__, br_name, strerror(errno)); 367 /* Continue anyway */ 368 } 369 370 close(fd); 371 return 0; 372 } 373 374 375 static int br_getnumports(const char *br_name) 376 { 377 int fd; 378 int i; 379 int port_cnt = 0; 380 unsigned long arg[4]; 381 int ifindices[MAX_BR_PORTS]; 382 struct ifreq ifr; 383 384 if ((fd = socket(AF_INET, SOCK_STREAM, 0)) < 0) { 385 wpa_printf(MSG_ERROR, "VLAN: %s: socket(AF_INET,SOCK_STREAM) " 386 "failed: %s", __func__, strerror(errno)); 387 return -1; 388 } 389 390 arg[0] = BRCTL_GET_PORT_LIST; 391 arg[1] = (unsigned long) ifindices; 392 arg[2] = MAX_BR_PORTS; 393 arg[3] = 0; 394 395 os_memset(ifindices, 0, sizeof(ifindices)); 396 os_strlcpy(ifr.ifr_name, br_name, sizeof(ifr.ifr_name)); 397 ifr.ifr_data = (__caddr_t) arg; 398 399 if (ioctl(fd, SIOCDEVPRIVATE, &ifr) < 0) { 400 wpa_printf(MSG_ERROR, "VLAN: %s: BRCTL_GET_PORT_LIST " 401 "failed for %s: %s", 402 __func__, br_name, strerror(errno)); 403 close(fd); 404 return -1; 405 } 406 407 for (i = 1; i < MAX_BR_PORTS; i++) { 408 if (ifindices[i] > 0) { 409 port_cnt++; 410 } 411 } 412 413 close(fd); 414 return port_cnt; 415 } 416 417 418 #ifndef CONFIG_VLAN_NETLINK 419 420 int vlan_rem(const char *if_name) 421 { 422 int fd; 423 struct vlan_ioctl_args if_request; 424 425 wpa_printf(MSG_DEBUG, "VLAN: vlan_rem(%s)", if_name); 426 if ((os_strlen(if_name) + 1) > sizeof(if_request.device1)) { 427 wpa_printf(MSG_ERROR, "VLAN: Interface name too long: '%s'", 428 if_name); 429 return -1; 430 } 431 432 if ((fd = socket(AF_INET, SOCK_STREAM, 0)) < 0) { 433 wpa_printf(MSG_ERROR, "VLAN: %s: socket(AF_INET,SOCK_STREAM) " 434 "failed: %s", __func__, strerror(errno)); 435 return -1; 436 } 437 438 os_memset(&if_request, 0, sizeof(if_request)); 439 440 os_strlcpy(if_request.device1, if_name, sizeof(if_request.device1)); 441 if_request.cmd = DEL_VLAN_CMD; 442 443 if (ioctl(fd, SIOCSIFVLAN, &if_request) < 0) { 444 wpa_printf(MSG_ERROR, "VLAN: %s: DEL_VLAN_CMD failed for %s: " 445 "%s", __func__, if_name, strerror(errno)); 446 close(fd); 447 return -1; 448 } 449 450 close(fd); 451 return 0; 452 } 453 454 455 /* 456 Add a vlan interface with VLAN ID 'vid' and tagged interface 457 'if_name'. 458 459 returns -1 on error 460 returns 1 if the interface already exists 461 returns 0 otherwise 462 */ 463 int vlan_add(const char *if_name, int vid, const char *vlan_if_name) 464 { 465 int fd; 466 struct vlan_ioctl_args if_request; 467 468 wpa_printf(MSG_DEBUG, "VLAN: vlan_add(if_name=%s, vid=%d)", 469 if_name, vid); 470 ifconfig_up(if_name); 471 472 if ((os_strlen(if_name) + 1) > sizeof(if_request.device1)) { 473 wpa_printf(MSG_ERROR, "VLAN: Interface name too long: '%s'", 474 if_name); 475 return -1; 476 } 477 478 if ((fd = socket(AF_INET, SOCK_STREAM, 0)) < 0) { 479 wpa_printf(MSG_ERROR, "VLAN: %s: socket(AF_INET,SOCK_STREAM) " 480 "failed: %s", __func__, strerror(errno)); 481 return -1; 482 } 483 484 os_memset(&if_request, 0, sizeof(if_request)); 485 486 /* Determine if a suitable vlan device already exists. */ 487 488 os_snprintf(if_request.device1, sizeof(if_request.device1), "vlan%d", 489 vid); 490 491 if_request.cmd = _GET_VLAN_VID_CMD; 492 493 if (ioctl(fd, SIOCSIFVLAN, &if_request) == 0) { 494 495 if (if_request.u.VID == vid) { 496 if_request.cmd = _GET_VLAN_REALDEV_NAME_CMD; 497 498 if (ioctl(fd, SIOCSIFVLAN, &if_request) == 0 && 499 os_strncmp(if_request.u.device2, if_name, 500 sizeof(if_request.u.device2)) == 0) { 501 close(fd); 502 wpa_printf(MSG_DEBUG, "VLAN: vlan_add: " 503 "if_name %s exists already", 504 if_request.device1); 505 return 1; 506 } 507 } 508 } 509 510 /* A suitable vlan device does not already exist, add one. */ 511 512 os_memset(&if_request, 0, sizeof(if_request)); 513 os_strlcpy(if_request.device1, if_name, sizeof(if_request.device1)); 514 if_request.u.VID = vid; 515 if_request.cmd = ADD_VLAN_CMD; 516 517 if (ioctl(fd, SIOCSIFVLAN, &if_request) < 0) { 518 wpa_printf(MSG_ERROR, "VLAN: %s: ADD_VLAN_CMD failed for %s: " 519 "%s", 520 __func__, if_request.device1, strerror(errno)); 521 close(fd); 522 return -1; 523 } 524 525 close(fd); 526 return 0; 527 } 528 529 530 static int vlan_set_name_type(unsigned int name_type) 531 { 532 int fd; 533 struct vlan_ioctl_args if_request; 534 535 wpa_printf(MSG_DEBUG, "VLAN: vlan_set_name_type(name_type=%u)", 536 name_type); 537 if ((fd = socket(AF_INET, SOCK_STREAM, 0)) < 0) { 538 wpa_printf(MSG_ERROR, "VLAN: %s: socket(AF_INET,SOCK_STREAM) " 539 "failed: %s", __func__, strerror(errno)); 540 return -1; 541 } 542 543 os_memset(&if_request, 0, sizeof(if_request)); 544 545 if_request.u.name_type = name_type; 546 if_request.cmd = SET_VLAN_NAME_TYPE_CMD; 547 if (ioctl(fd, SIOCSIFVLAN, &if_request) < 0) { 548 wpa_printf(MSG_ERROR, "VLAN: %s: SET_VLAN_NAME_TYPE_CMD " 549 "name_type=%u failed: %s", 550 __func__, name_type, strerror(errno)); 551 close(fd); 552 return -1; 553 } 554 555 close(fd); 556 return 0; 557 } 558 559 #endif /* CONFIG_VLAN_NETLINK */ 560 561 562 static void vlan_newlink(char *ifname, struct hostapd_data *hapd) 563 { 564 char vlan_ifname[IFNAMSIZ]; 565 char br_name[IFNAMSIZ]; 566 struct hostapd_vlan *vlan = hapd->conf->vlan; 567 char *tagged_interface = hapd->conf->ssid.vlan_tagged_interface; 568 int vlan_naming = hapd->conf->ssid.vlan_naming; 569 int clean; 570 571 wpa_printf(MSG_DEBUG, "VLAN: vlan_newlink(%s)", ifname); 572 573 while (vlan) { 574 if (os_strcmp(ifname, vlan->ifname) == 0 && !vlan->configured) { 575 vlan->configured = 1; 576 577 if (hapd->conf->vlan_bridge[0]) { 578 os_snprintf(br_name, sizeof(br_name), "%s%d", 579 hapd->conf->vlan_bridge, 580 vlan->vlan_id); 581 } else if (tagged_interface) { 582 os_snprintf(br_name, sizeof(br_name), 583 "br%s.%d", tagged_interface, 584 vlan->vlan_id); 585 } else { 586 os_snprintf(br_name, sizeof(br_name), 587 "brvlan%d", vlan->vlan_id); 588 } 589 590 dyn_iface_get(hapd, br_name, 591 br_addbr(br_name) ? 0 : DVLAN_CLEAN_BR); 592 593 ifconfig_up(br_name); 594 595 if (tagged_interface) { 596 if (vlan_naming == 597 DYNAMIC_VLAN_NAMING_WITH_DEVICE) 598 os_snprintf(vlan_ifname, 599 sizeof(vlan_ifname), 600 "%s.%d", tagged_interface, 601 vlan->vlan_id); 602 else 603 os_snprintf(vlan_ifname, 604 sizeof(vlan_ifname), 605 "vlan%d", vlan->vlan_id); 606 607 clean = 0; 608 ifconfig_up(tagged_interface); 609 if (!vlan_add(tagged_interface, vlan->vlan_id, 610 vlan_ifname)) 611 clean |= DVLAN_CLEAN_VLAN; 612 613 if (!br_addif(br_name, vlan_ifname)) 614 clean |= DVLAN_CLEAN_VLAN_PORT; 615 616 dyn_iface_get(hapd, vlan_ifname, clean); 617 618 ifconfig_up(vlan_ifname); 619 } 620 621 if (!br_addif(br_name, ifname)) 622 vlan->clean |= DVLAN_CLEAN_WLAN_PORT; 623 624 ifconfig_up(ifname); 625 626 break; 627 } 628 vlan = vlan->next; 629 } 630 } 631 632 633 static void vlan_dellink(char *ifname, struct hostapd_data *hapd) 634 { 635 char vlan_ifname[IFNAMSIZ]; 636 char br_name[IFNAMSIZ]; 637 struct hostapd_vlan *first, *prev, *vlan = hapd->conf->vlan; 638 char *tagged_interface = hapd->conf->ssid.vlan_tagged_interface; 639 int vlan_naming = hapd->conf->ssid.vlan_naming; 640 int clean; 641 642 wpa_printf(MSG_DEBUG, "VLAN: vlan_dellink(%s)", ifname); 643 644 first = prev = vlan; 645 646 while (vlan) { 647 if (os_strcmp(ifname, vlan->ifname) == 0 && 648 vlan->configured) { 649 if (hapd->conf->vlan_bridge[0]) { 650 os_snprintf(br_name, sizeof(br_name), "%s%d", 651 hapd->conf->vlan_bridge, 652 vlan->vlan_id); 653 } else if (tagged_interface) { 654 os_snprintf(br_name, sizeof(br_name), 655 "br%s.%d", tagged_interface, 656 vlan->vlan_id); 657 } else { 658 os_snprintf(br_name, sizeof(br_name), 659 "brvlan%d", vlan->vlan_id); 660 } 661 662 if (vlan->clean & DVLAN_CLEAN_WLAN_PORT) 663 br_delif(br_name, vlan->ifname); 664 665 if (tagged_interface) { 666 if (vlan_naming == 667 DYNAMIC_VLAN_NAMING_WITH_DEVICE) 668 os_snprintf(vlan_ifname, 669 sizeof(vlan_ifname), 670 "%s.%d", tagged_interface, 671 vlan->vlan_id); 672 else 673 os_snprintf(vlan_ifname, 674 sizeof(vlan_ifname), 675 "vlan%d", vlan->vlan_id); 676 677 clean = dyn_iface_put(hapd, vlan_ifname); 678 679 if (clean & DVLAN_CLEAN_VLAN_PORT) 680 br_delif(br_name, vlan_ifname); 681 682 if (clean & DVLAN_CLEAN_VLAN) { 683 ifconfig_down(vlan_ifname); 684 vlan_rem(vlan_ifname); 685 } 686 } 687 688 clean = dyn_iface_put(hapd, br_name); 689 if ((clean & DVLAN_CLEAN_BR) && 690 br_getnumports(br_name) == 0) { 691 ifconfig_down(br_name); 692 br_delbr(br_name); 693 } 694 } 695 696 if (os_strcmp(ifname, vlan->ifname) == 0) { 697 if (vlan == first) { 698 hapd->conf->vlan = vlan->next; 699 } else { 700 prev->next = vlan->next; 701 } 702 os_free(vlan); 703 704 break; 705 } 706 prev = vlan; 707 vlan = vlan->next; 708 } 709 } 710 711 712 static void 713 vlan_read_ifnames(struct nlmsghdr *h, size_t len, int del, 714 struct hostapd_data *hapd) 715 { 716 struct ifinfomsg *ifi; 717 int attrlen, nlmsg_len, rta_len; 718 struct rtattr *attr; 719 char ifname[IFNAMSIZ + 1]; 720 721 if (len < sizeof(*ifi)) 722 return; 723 724 ifi = NLMSG_DATA(h); 725 726 nlmsg_len = NLMSG_ALIGN(sizeof(struct ifinfomsg)); 727 728 attrlen = h->nlmsg_len - nlmsg_len; 729 if (attrlen < 0) 730 return; 731 732 attr = (struct rtattr *) (((char *) ifi) + nlmsg_len); 733 734 os_memset(ifname, 0, sizeof(ifname)); 735 rta_len = RTA_ALIGN(sizeof(struct rtattr)); 736 while (RTA_OK(attr, attrlen)) { 737 if (attr->rta_type == IFLA_IFNAME) { 738 int n = attr->rta_len - rta_len; 739 if (n < 0) 740 break; 741 742 if ((size_t) n >= sizeof(ifname)) 743 n = sizeof(ifname) - 1; 744 os_memcpy(ifname, ((char *) attr) + rta_len, n); 745 746 } 747 748 attr = RTA_NEXT(attr, attrlen); 749 } 750 751 if (!ifname[0]) 752 return; 753 if (del && if_nametoindex(ifname)) { 754 /* interface still exists, race condition -> 755 * iface has just been recreated */ 756 return; 757 } 758 759 wpa_printf(MSG_DEBUG, 760 "VLAN: RTM_%sLINK: ifi_index=%d ifname=%s ifi_family=%d ifi_flags=0x%x (%s%s%s%s)", 761 del ? "DEL" : "NEW", 762 ifi->ifi_index, ifname, ifi->ifi_family, ifi->ifi_flags, 763 (ifi->ifi_flags & IFF_UP) ? "[UP]" : "", 764 (ifi->ifi_flags & IFF_RUNNING) ? "[RUNNING]" : "", 765 (ifi->ifi_flags & IFF_LOWER_UP) ? "[LOWER_UP]" : "", 766 (ifi->ifi_flags & IFF_DORMANT) ? "[DORMANT]" : ""); 767 768 if (del) 769 vlan_dellink(ifname, hapd); 770 else 771 vlan_newlink(ifname, hapd); 772 } 773 774 775 static void vlan_event_receive(int sock, void *eloop_ctx, void *sock_ctx) 776 { 777 char buf[8192]; 778 int left; 779 struct sockaddr_nl from; 780 socklen_t fromlen; 781 struct nlmsghdr *h; 782 struct hostapd_data *hapd = eloop_ctx; 783 784 fromlen = sizeof(from); 785 left = recvfrom(sock, buf, sizeof(buf), MSG_DONTWAIT, 786 (struct sockaddr *) &from, &fromlen); 787 if (left < 0) { 788 if (errno != EINTR && errno != EAGAIN) 789 wpa_printf(MSG_ERROR, "VLAN: %s: recvfrom failed: %s", 790 __func__, strerror(errno)); 791 return; 792 } 793 794 h = (struct nlmsghdr *) buf; 795 while (NLMSG_OK(h, left)) { 796 int len, plen; 797 798 len = h->nlmsg_len; 799 plen = len - sizeof(*h); 800 if (len > left || plen < 0) { 801 wpa_printf(MSG_DEBUG, "VLAN: Malformed netlink " 802 "message: len=%d left=%d plen=%d", 803 len, left, plen); 804 break; 805 } 806 807 switch (h->nlmsg_type) { 808 case RTM_NEWLINK: 809 vlan_read_ifnames(h, plen, 0, hapd); 810 break; 811 case RTM_DELLINK: 812 vlan_read_ifnames(h, plen, 1, hapd); 813 break; 814 } 815 816 h = NLMSG_NEXT(h, left); 817 } 818 819 if (left > 0) { 820 wpa_printf(MSG_DEBUG, "VLAN: %s: %d extra bytes in the end of " 821 "netlink message", __func__, left); 822 } 823 } 824 825 826 static struct full_dynamic_vlan * 827 full_dynamic_vlan_init(struct hostapd_data *hapd) 828 { 829 struct sockaddr_nl local; 830 struct full_dynamic_vlan *priv; 831 832 priv = os_zalloc(sizeof(*priv)); 833 if (priv == NULL) 834 return NULL; 835 836 #ifndef CONFIG_VLAN_NETLINK 837 vlan_set_name_type(hapd->conf->ssid.vlan_naming == 838 DYNAMIC_VLAN_NAMING_WITH_DEVICE ? 839 VLAN_NAME_TYPE_RAW_PLUS_VID_NO_PAD : 840 VLAN_NAME_TYPE_PLUS_VID_NO_PAD); 841 #endif /* CONFIG_VLAN_NETLINK */ 842 843 priv->s = socket(PF_NETLINK, SOCK_RAW, NETLINK_ROUTE); 844 if (priv->s < 0) { 845 wpa_printf(MSG_ERROR, "VLAN: %s: socket(PF_NETLINK,SOCK_RAW," 846 "NETLINK_ROUTE) failed: %s", 847 __func__, strerror(errno)); 848 os_free(priv); 849 return NULL; 850 } 851 852 os_memset(&local, 0, sizeof(local)); 853 local.nl_family = AF_NETLINK; 854 local.nl_groups = RTMGRP_LINK; 855 if (bind(priv->s, (struct sockaddr *) &local, sizeof(local)) < 0) { 856 wpa_printf(MSG_ERROR, "VLAN: %s: bind(netlink) failed: %s", 857 __func__, strerror(errno)); 858 close(priv->s); 859 os_free(priv); 860 return NULL; 861 } 862 863 if (eloop_register_read_sock(priv->s, vlan_event_receive, hapd, NULL)) 864 { 865 close(priv->s); 866 os_free(priv); 867 return NULL; 868 } 869 870 return priv; 871 } 872 873 874 static void full_dynamic_vlan_deinit(struct full_dynamic_vlan *priv) 875 { 876 if (priv == NULL) 877 return; 878 eloop_unregister_read_sock(priv->s); 879 close(priv->s); 880 os_free(priv); 881 } 882 #endif /* CONFIG_FULL_DYNAMIC_VLAN */ 883 884 885 int vlan_setup_encryption_dyn(struct hostapd_data *hapd, const char *dyn_vlan) 886 { 887 int i; 888 889 if (dyn_vlan == NULL) 890 return 0; 891 892 /* Static WEP keys are set here; IEEE 802.1X and WPA uses their own 893 * functions for setting up dynamic broadcast keys. */ 894 for (i = 0; i < 4; i++) { 895 if (hapd->conf->ssid.wep.key[i] && 896 hostapd_drv_set_key(dyn_vlan, hapd, WPA_ALG_WEP, NULL, i, 897 i == hapd->conf->ssid.wep.idx, NULL, 0, 898 hapd->conf->ssid.wep.key[i], 899 hapd->conf->ssid.wep.len[i])) 900 { 901 wpa_printf(MSG_ERROR, "VLAN: Could not set WEP " 902 "encryption for dynamic VLAN"); 903 return -1; 904 } 905 } 906 907 return 0; 908 } 909 910 911 static int vlan_dynamic_add(struct hostapd_data *hapd, 912 struct hostapd_vlan *vlan) 913 { 914 while (vlan) { 915 if (vlan->vlan_id != VLAN_ID_WILDCARD) { 916 if (hostapd_vlan_if_add(hapd, vlan->ifname)) { 917 if (errno != EEXIST) { 918 wpa_printf(MSG_ERROR, "VLAN: Could " 919 "not add VLAN %s: %s", 920 vlan->ifname, 921 strerror(errno)); 922 return -1; 923 } 924 } 925 #ifdef CONFIG_FULL_DYNAMIC_VLAN 926 ifconfig_up(vlan->ifname); 927 #endif /* CONFIG_FULL_DYNAMIC_VLAN */ 928 } 929 930 vlan = vlan->next; 931 } 932 933 return 0; 934 } 935 936 937 static void vlan_dynamic_remove(struct hostapd_data *hapd, 938 struct hostapd_vlan *vlan) 939 { 940 struct hostapd_vlan *next; 941 942 while (vlan) { 943 next = vlan->next; 944 945 if (vlan->vlan_id != VLAN_ID_WILDCARD && 946 hostapd_vlan_if_remove(hapd, vlan->ifname)) { 947 wpa_printf(MSG_ERROR, "VLAN: Could not remove VLAN " 948 "iface: %s: %s", 949 vlan->ifname, strerror(errno)); 950 } 951 #ifdef CONFIG_FULL_DYNAMIC_VLAN 952 if (vlan->clean) 953 vlan_dellink(vlan->ifname, hapd); 954 #endif /* CONFIG_FULL_DYNAMIC_VLAN */ 955 956 vlan = next; 957 } 958 } 959 960 961 int vlan_init(struct hostapd_data *hapd) 962 { 963 #ifdef CONFIG_FULL_DYNAMIC_VLAN 964 hapd->full_dynamic_vlan = full_dynamic_vlan_init(hapd); 965 #endif /* CONFIG_FULL_DYNAMIC_VLAN */ 966 967 if (hapd->conf->ssid.dynamic_vlan != DYNAMIC_VLAN_DISABLED && 968 !hapd->conf->vlan) { 969 /* dynamic vlans enabled but no (or empty) vlan_file given */ 970 struct hostapd_vlan *vlan; 971 vlan = os_zalloc(sizeof(*vlan)); 972 if (vlan == NULL) { 973 wpa_printf(MSG_ERROR, "Out of memory while assigning " 974 "VLAN interfaces"); 975 return -1; 976 } 977 978 vlan->vlan_id = VLAN_ID_WILDCARD; 979 os_snprintf(vlan->ifname, sizeof(vlan->ifname), "%s.#", 980 hapd->conf->iface); 981 vlan->next = hapd->conf->vlan; 982 hapd->conf->vlan = vlan; 983 } 984 985 if (vlan_dynamic_add(hapd, hapd->conf->vlan)) 986 return -1; 987 988 return 0; 989 } 990 991 992 void vlan_deinit(struct hostapd_data *hapd) 993 { 994 vlan_dynamic_remove(hapd, hapd->conf->vlan); 995 996 #ifdef CONFIG_FULL_DYNAMIC_VLAN 997 full_dynamic_vlan_deinit(hapd->full_dynamic_vlan); 998 hapd->full_dynamic_vlan = NULL; 999 #endif /* CONFIG_FULL_DYNAMIC_VLAN */ 1000 } 1001 1002 1003 struct hostapd_vlan * vlan_add_dynamic(struct hostapd_data *hapd, 1004 struct hostapd_vlan *vlan, 1005 int vlan_id) 1006 { 1007 struct hostapd_vlan *n = NULL; 1008 char *ifname, *pos; 1009 1010 if (vlan == NULL || vlan_id <= 0 || vlan_id > MAX_VLAN_ID || 1011 vlan->vlan_id != VLAN_ID_WILDCARD) 1012 return NULL; 1013 1014 wpa_printf(MSG_DEBUG, "VLAN: %s(vlan_id=%d ifname=%s)", 1015 __func__, vlan_id, vlan->ifname); 1016 ifname = os_strdup(vlan->ifname); 1017 if (ifname == NULL) 1018 return NULL; 1019 pos = os_strchr(ifname, '#'); 1020 if (pos == NULL) 1021 goto free_ifname; 1022 *pos++ = '\0'; 1023 1024 n = os_zalloc(sizeof(*n)); 1025 if (n == NULL) 1026 goto free_ifname; 1027 1028 n->vlan_id = vlan_id; 1029 n->dynamic_vlan = 1; 1030 1031 os_snprintf(n->ifname, sizeof(n->ifname), "%s%d%s", ifname, vlan_id, 1032 pos); 1033 1034 if (hostapd_vlan_if_add(hapd, n->ifname)) { 1035 os_free(n); 1036 n = NULL; 1037 goto free_ifname; 1038 } 1039 1040 n->next = hapd->conf->vlan; 1041 hapd->conf->vlan = n; 1042 1043 #ifdef CONFIG_FULL_DYNAMIC_VLAN 1044 ifconfig_up(n->ifname); 1045 #endif /* CONFIG_FULL_DYNAMIC_VLAN */ 1046 1047 free_ifname: 1048 os_free(ifname); 1049 return n; 1050 } 1051 1052 1053 int vlan_remove_dynamic(struct hostapd_data *hapd, int vlan_id) 1054 { 1055 struct hostapd_vlan *vlan; 1056 1057 if (vlan_id <= 0 || vlan_id > MAX_VLAN_ID) 1058 return 1; 1059 1060 wpa_printf(MSG_DEBUG, "VLAN: %s(ifname=%s vlan_id=%d)", 1061 __func__, hapd->conf->iface, vlan_id); 1062 1063 vlan = hapd->conf->vlan; 1064 while (vlan) { 1065 if (vlan->vlan_id == vlan_id && vlan->dynamic_vlan > 0) { 1066 vlan->dynamic_vlan--; 1067 break; 1068 } 1069 vlan = vlan->next; 1070 } 1071 1072 if (vlan == NULL) 1073 return 1; 1074 1075 if (vlan->dynamic_vlan == 0) { 1076 hostapd_vlan_if_remove(hapd, vlan->ifname); 1077 #ifdef CONFIG_FULL_DYNAMIC_VLAN 1078 vlan_dellink(vlan->ifname, hapd); 1079 #endif /* CONFIG_FULL_DYNAMIC_VLAN */ 1080 } 1081 1082 return 0; 1083 } 1084