vlan_init.c 22 KB

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