contrib/hostapd/src/ap/vlan_init.c

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