00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015 #include "includes.h"
00016 #include <sys/ioctl.h>
00017 #include <linux/if.h>
00018 #include <linux/sockios.h>
00019 #include <linux/if_ether.h>
00020 #include <linux/mii.h>
00021
00022 #include "common.h"
00023 #include "driver.h"
00024 #include "l2_packet/l2_packet.h"
00025
00026 #define ROBO_PHY_ADDR 0x1e
00027
00028
00029 #define ROBO_MII_PAGE 0x10
00030 #define ROBO_MII_ADDR 0x11
00031 #define ROBO_MII_DATA_OFFSET 0x18
00032
00033 #define ROBO_MII_PAGE_ENABLE 0x01
00034 #define ROBO_MII_ADDR_WRITE 0x01
00035 #define ROBO_MII_ADDR_READ 0x02
00036 #define ROBO_MII_DATA_MAX 4
00037 #define ROBO_MII_RETRY_MAX 10
00038
00039
00040 #define ROBO_ARLCTRL_PAGE 0x04
00041 #define ROBO_VLAN_PAGE 0x34
00042
00043
00044 #define ROBO_ARLCTRL_CONF 0x00
00045 #define ROBO_ARLCTRL_ADDR_1 0x10
00046 #define ROBO_ARLCTRL_VEC_1 0x16
00047 #define ROBO_ARLCTRL_ADDR_2 0x20
00048 #define ROBO_ARLCTRL_VEC_2 0x26
00049
00050
00051 #define ROBO_VLAN_ACCESS 0x08
00052 #define ROBO_VLAN_ACCESS_5350 0x06
00053 #define ROBO_VLAN_READ 0x0c
00054 #define ROBO_VLAN_MAX 0xff
00055
00056
00057 static const u8 pae_group_addr[ETH_ALEN] =
00058 { 0x01, 0x80, 0xc2, 0x00, 0x00, 0x03 };
00059
00060
00061 struct wpa_driver_roboswitch_data {
00062 void *ctx;
00063 struct l2_packet_data *l2;
00064 char ifname[IFNAMSIZ + 1];
00065 u8 own_addr[ETH_ALEN];
00066 struct ifreq ifr;
00067 int fd, is_5350;
00068 u16 ports;
00069 };
00070
00071
00072
00073 static inline struct mii_ioctl_data *if_mii(struct ifreq *rq)
00074 {
00075 return (struct mii_ioctl_data *) &rq->ifr_ifru;
00076 }
00077
00078
00079
00080
00081
00082
00083 static void wpa_driver_roboswitch_addr_be16(const u8 addr[ETH_ALEN], u16 *be)
00084 {
00085 int i;
00086 for (i = 0; i < ETH_ALEN; i += 2)
00087 be[(ETH_ALEN - i) / 2 - 1] = WPA_GET_BE16(addr + i);
00088 }
00089
00090
00091 static u16 wpa_driver_roboswitch_mdio_read(
00092 struct wpa_driver_roboswitch_data *drv, u8 reg)
00093 {
00094 struct mii_ioctl_data *mii = if_mii(&drv->ifr);
00095
00096 mii->phy_id = ROBO_PHY_ADDR;
00097 mii->reg_num = reg;
00098
00099 if (ioctl(drv->fd, SIOCGMIIREG, &drv->ifr) < 0) {
00100 perror("ioctl[SIOCGMIIREG]");
00101 return 0x00;
00102 }
00103 return mii->val_out;
00104 }
00105
00106
00107 static void wpa_driver_roboswitch_mdio_write(
00108 struct wpa_driver_roboswitch_data *drv, u8 reg, u16 val)
00109 {
00110 struct mii_ioctl_data *mii = if_mii(&drv->ifr);
00111
00112 mii->phy_id = ROBO_PHY_ADDR;
00113 mii->reg_num = reg;
00114 mii->val_in = val;
00115
00116 if (ioctl(drv->fd, SIOCSMIIREG, &drv->ifr) < 0) {
00117 perror("ioctl[SIOCSMIIREG");
00118 }
00119 }
00120
00121
00122 static int wpa_driver_roboswitch_reg(struct wpa_driver_roboswitch_data *drv,
00123 u8 page, u8 reg, u8 op)
00124 {
00125 int i;
00126
00127
00128 wpa_driver_roboswitch_mdio_write(drv, ROBO_MII_PAGE,
00129 (page << 8) | ROBO_MII_PAGE_ENABLE);
00130
00131 wpa_driver_roboswitch_mdio_write(drv, ROBO_MII_ADDR, (reg << 8) | op);
00132
00133
00134 for (i = 0; i < ROBO_MII_RETRY_MAX; ++i) {
00135 if ((wpa_driver_roboswitch_mdio_read(drv, ROBO_MII_ADDR) & 3)
00136 == 0)
00137 return 0;
00138 }
00139
00140 return -1;
00141 }
00142
00143
00144 static int wpa_driver_roboswitch_read(struct wpa_driver_roboswitch_data *drv,
00145 u8 page, u8 reg, u16 *val, int len)
00146 {
00147 int i;
00148
00149 if (len > ROBO_MII_DATA_MAX ||
00150 wpa_driver_roboswitch_reg(drv, page, reg, ROBO_MII_ADDR_READ) < 0)
00151 return -1;
00152
00153 for (i = 0; i < len; ++i) {
00154 val[i] = wpa_driver_roboswitch_mdio_read(
00155 drv, ROBO_MII_DATA_OFFSET + i);
00156 }
00157
00158 return 0;
00159 }
00160
00161
00162 static int wpa_driver_roboswitch_write(struct wpa_driver_roboswitch_data *drv,
00163 u8 page, u8 reg, u16 *val, int len)
00164 {
00165 int i;
00166
00167 if (len > ROBO_MII_DATA_MAX) return -1;
00168 for (i = 0; i < len; ++i) {
00169 wpa_driver_roboswitch_mdio_write(drv, ROBO_MII_DATA_OFFSET + i,
00170 val[i]);
00171 }
00172 return wpa_driver_roboswitch_reg(drv, page, reg, ROBO_MII_ADDR_WRITE);
00173 }
00174
00175
00176 static void wpa_driver_roboswitch_receive(void *priv, const u8 *src_addr,
00177 const u8 *buf, size_t len)
00178 {
00179 struct wpa_driver_roboswitch_data *drv = priv;
00180
00181 if (len > 14 && WPA_GET_BE16(buf + 12) == ETH_P_EAPOL &&
00182 os_memcmp(buf, drv->own_addr, ETH_ALEN) == 0)
00183 drv_event_eapol_rx(drv->ctx, src_addr, buf + 14, len - 14);
00184 }
00185
00186
00187 static int wpa_driver_roboswitch_get_ssid(void *priv, u8 *ssid)
00188 {
00189 ssid[0] = 0;
00190 return 0;
00191 }
00192
00193
00194 static int wpa_driver_roboswitch_get_bssid(void *priv, u8 *bssid)
00195 {
00196
00197 os_memcpy(bssid, pae_group_addr, ETH_ALEN);
00198 return 0;
00199 }
00200
00201
00202 static int wpa_driver_roboswitch_get_capa(void *priv,
00203 struct wpa_driver_capa *capa)
00204 {
00205 os_memset(capa, 0, sizeof(*capa));
00206 capa->flags = WPA_DRIVER_FLAGS_WIRED;
00207 return 0;
00208 }
00209
00210
00211 static int wpa_driver_roboswitch_set_param(void *priv, const char *param)
00212 {
00213 struct wpa_driver_roboswitch_data *drv = priv;
00214 char *sep;
00215
00216 if (param == NULL || os_strstr(param, "multicast_only=1") == NULL) {
00217 sep = drv->ifname + os_strlen(drv->ifname);
00218 *sep = '.';
00219 drv->l2 = l2_packet_init(drv->ifname, NULL, ETH_P_ALL,
00220 wpa_driver_roboswitch_receive, drv,
00221 1);
00222 if (drv->l2 == NULL) {
00223 wpa_printf(MSG_INFO, "%s: Unable to listen on %s",
00224 __func__, drv->ifname);
00225 return -1;
00226 }
00227 *sep = '\0';
00228 l2_packet_get_own_addr(drv->l2, drv->own_addr);
00229 } else {
00230 wpa_printf(MSG_DEBUG, "%s: Ignoring unicast frames", __func__);
00231 drv->l2 = NULL;
00232 }
00233 return 0;
00234 }
00235
00236
00237 static const char * wpa_driver_roboswitch_get_ifname(void *priv)
00238 {
00239 struct wpa_driver_roboswitch_data *drv = priv;
00240 return drv->ifname;
00241 }
00242
00243
00244 static int wpa_driver_roboswitch_join(struct wpa_driver_roboswitch_data *drv,
00245 u16 ports, const u8 *addr)
00246 {
00247 u16 read1[3], read2[3], addr_be16[3];
00248
00249 wpa_driver_roboswitch_addr_be16(addr, addr_be16);
00250
00251 if (wpa_driver_roboswitch_read(drv, ROBO_ARLCTRL_PAGE,
00252 ROBO_ARLCTRL_CONF, read1, 1) < 0)
00253 return -1;
00254 if (!(read1[0] & (1 << 4))) {
00255
00256 read1[0] |= 1 << 4;
00257 wpa_driver_roboswitch_write(drv, ROBO_ARLCTRL_PAGE,
00258 ROBO_ARLCTRL_ADDR_1, addr_be16, 3);
00259 wpa_driver_roboswitch_write(drv, ROBO_ARLCTRL_PAGE,
00260 ROBO_ARLCTRL_VEC_1, &ports, 1);
00261 wpa_driver_roboswitch_write(drv, ROBO_ARLCTRL_PAGE,
00262 ROBO_ARLCTRL_ADDR_2, addr_be16, 3);
00263 wpa_driver_roboswitch_write(drv, ROBO_ARLCTRL_PAGE,
00264 ROBO_ARLCTRL_VEC_2, &ports, 1);
00265 wpa_driver_roboswitch_write(drv, ROBO_ARLCTRL_PAGE,
00266 ROBO_ARLCTRL_CONF, read1, 1);
00267 } else {
00268
00269 wpa_driver_roboswitch_read(drv, ROBO_ARLCTRL_PAGE,
00270 ROBO_ARLCTRL_ADDR_1, read1, 3);
00271 wpa_driver_roboswitch_read(drv, ROBO_ARLCTRL_PAGE,
00272 ROBO_ARLCTRL_ADDR_2, read2, 3);
00273 if (os_memcmp(read1, read2, 6) != 0)
00274 return -1;
00275 wpa_driver_roboswitch_read(drv, ROBO_ARLCTRL_PAGE,
00276 ROBO_ARLCTRL_VEC_1, read1, 1);
00277 wpa_driver_roboswitch_read(drv, ROBO_ARLCTRL_PAGE,
00278 ROBO_ARLCTRL_VEC_2, read2, 1);
00279 if (read1[0] != read2[0])
00280 return -1;
00281 wpa_driver_roboswitch_write(drv, ROBO_ARLCTRL_PAGE,
00282 ROBO_ARLCTRL_ADDR_1, addr_be16, 3);
00283 wpa_driver_roboswitch_write(drv, ROBO_ARLCTRL_PAGE,
00284 ROBO_ARLCTRL_VEC_1, &ports, 1);
00285 }
00286 return 0;
00287 }
00288
00289
00290 static int wpa_driver_roboswitch_leave(struct wpa_driver_roboswitch_data *drv,
00291 u16 ports, const u8 *addr)
00292 {
00293 u16 _read, addr_be16[3], addr_read[3], ports_read;
00294
00295 wpa_driver_roboswitch_addr_be16(addr, addr_be16);
00296
00297 wpa_driver_roboswitch_read(drv, ROBO_ARLCTRL_PAGE, ROBO_ARLCTRL_CONF,
00298 &_read, 1);
00299
00300 if (!(_read & (1 << 4))) return -1;
00301
00302 wpa_driver_roboswitch_read(drv, ROBO_ARLCTRL_PAGE,
00303 ROBO_ARLCTRL_ADDR_1, addr_read, 3);
00304 wpa_driver_roboswitch_read(drv, ROBO_ARLCTRL_PAGE, ROBO_ARLCTRL_VEC_1,
00305 &ports_read, 1);
00306
00307 if (os_memcmp(addr_read, addr_be16, 6) == 0 && ports_read == ports) {
00308 wpa_driver_roboswitch_read(drv, ROBO_ARLCTRL_PAGE,
00309 ROBO_ARLCTRL_ADDR_2, addr_read, 3);
00310 wpa_driver_roboswitch_read(drv, ROBO_ARLCTRL_PAGE,
00311 ROBO_ARLCTRL_VEC_2, &ports_read, 1);
00312
00313 if (os_memcmp(addr_read, addr_be16, 6) == 0 &&
00314 ports_read == ports) {
00315 _read &= ~(1 << 4);
00316 wpa_driver_roboswitch_write(drv, ROBO_ARLCTRL_PAGE,
00317 ROBO_ARLCTRL_CONF, &_read,
00318 1);
00319 } else {
00320 wpa_driver_roboswitch_read(drv, ROBO_ARLCTRL_PAGE,
00321 ROBO_ARLCTRL_ADDR_1,
00322 addr_read, 3);
00323 wpa_driver_roboswitch_read(drv, ROBO_ARLCTRL_PAGE,
00324 ROBO_ARLCTRL_VEC_1,
00325 &ports_read, 1);
00326 wpa_driver_roboswitch_write(drv, ROBO_ARLCTRL_PAGE,
00327 ROBO_ARLCTRL_ADDR_2,
00328 addr_read, 3);
00329 wpa_driver_roboswitch_write(drv, ROBO_ARLCTRL_PAGE,
00330 ROBO_ARLCTRL_VEC_2,
00331 &ports_read, 1);
00332 }
00333 } else {
00334 wpa_driver_roboswitch_read(drv, ROBO_ARLCTRL_PAGE,
00335 ROBO_ARLCTRL_ADDR_2, addr_read, 3);
00336 wpa_driver_roboswitch_read(drv, ROBO_ARLCTRL_PAGE,
00337 ROBO_ARLCTRL_VEC_2, &ports_read, 1);
00338
00339 if (os_memcmp(addr_read, addr_be16, 6) == 0 &&
00340 ports_read == ports) {
00341 wpa_driver_roboswitch_write(drv, ROBO_ARLCTRL_PAGE,
00342 ROBO_ARLCTRL_ADDR_1,
00343 addr_read, 3);
00344 wpa_driver_roboswitch_write(drv, ROBO_ARLCTRL_PAGE,
00345 ROBO_ARLCTRL_VEC_1,
00346 &ports_read, 1);
00347 } else return -1;
00348 }
00349 return 0;
00350 }
00351
00352
00353 static void * wpa_driver_roboswitch_init(void *ctx, const char *ifname)
00354 {
00355 struct wpa_driver_roboswitch_data *drv;
00356 char *sep;
00357 u16 vlan = 0, _read[2];
00358
00359 drv = os_zalloc(sizeof(*drv));
00360 if (drv == NULL) return NULL;
00361 drv->ctx = ctx;
00362 drv->own_addr[0] = '\0';
00363
00364
00365 sep = drv->ifname +
00366 os_strlcpy(drv->ifname, ifname, sizeof(drv->ifname)) - 2;
00367
00368 while (sep > drv->ifname && *sep != '.') sep--;
00369 if (sep <= drv->ifname) {
00370 wpa_printf(MSG_INFO, "%s: No <interface>.<vlan> pair in "
00371 "interface name %s", __func__, drv->ifname);
00372 os_free(drv);
00373 return NULL;
00374 }
00375 *sep = '\0';
00376 while (*++sep) {
00377 if (*sep < '0' || *sep > '9') {
00378 wpa_printf(MSG_INFO, "%s: Invalid vlan specification "
00379 "in interface name %s", __func__, ifname);
00380 os_free(drv);
00381 return NULL;
00382 }
00383 vlan *= 10;
00384 vlan += *sep - '0';
00385 if (vlan > ROBO_VLAN_MAX) {
00386 wpa_printf(MSG_INFO, "%s: VLAN out of range in "
00387 "interface name %s", __func__, ifname);
00388 os_free(drv);
00389 return NULL;
00390 }
00391 }
00392
00393 drv->fd = socket(PF_INET, SOCK_DGRAM, 0);
00394 if (drv->fd < 0) {
00395 wpa_printf(MSG_INFO, "%s: Unable to create socket", __func__);
00396 os_free(drv);
00397 return NULL;
00398 }
00399
00400 os_memset(&drv->ifr, 0, sizeof(drv->ifr));
00401 os_strlcpy(drv->ifr.ifr_name, drv->ifname, IFNAMSIZ);
00402 if (ioctl(drv->fd, SIOCGMIIPHY, &drv->ifr) < 0) {
00403 perror("ioctl[SIOCGMIIPHY]");
00404 os_free(drv);
00405 return NULL;
00406 }
00407 if (if_mii(&drv->ifr)->phy_id != ROBO_PHY_ADDR) {
00408 wpa_printf(MSG_INFO, "%s: Invalid phy address (not a "
00409 "RoboSwitch?)", __func__);
00410 os_free(drv);
00411 return NULL;
00412 }
00413
00414
00415 _read[0] = ROBO_VLAN_MAX;
00416 wpa_driver_roboswitch_write(drv, ROBO_VLAN_PAGE, ROBO_VLAN_ACCESS_5350,
00417 _read, 1);
00418 wpa_driver_roboswitch_read(drv, ROBO_VLAN_PAGE, ROBO_VLAN_ACCESS_5350,
00419 _read + 1, 1);
00420 drv->is_5350 = _read[0] == _read[1];
00421
00422
00423 vlan |= 1 << 13;
00424 wpa_driver_roboswitch_write(drv, ROBO_VLAN_PAGE,
00425 drv->is_5350 ? ROBO_VLAN_ACCESS_5350
00426 : ROBO_VLAN_ACCESS,
00427 &vlan, 1);
00428 wpa_driver_roboswitch_read(drv, ROBO_VLAN_PAGE, ROBO_VLAN_READ, _read,
00429 drv->is_5350 ? 2 : 1);
00430 if (!(drv->is_5350 ? _read[1] & (1 << 4) : _read[0] & (1 << 14))) {
00431 wpa_printf(MSG_INFO, "%s: Could not get port information for "
00432 "VLAN %d", __func__, vlan & ~(1 << 13));
00433 os_free(drv);
00434 return NULL;
00435 }
00436 drv->ports = _read[0] & 0x001F;
00437
00438 drv->ports |= 1 << 8;
00439 if (wpa_driver_roboswitch_join(drv, drv->ports, pae_group_addr) < 0) {
00440 wpa_printf(MSG_INFO, "%s: Unable to join PAE group", __func__);
00441 os_free(drv);
00442 return NULL;
00443 } else {
00444 wpa_printf(MSG_DEBUG, "%s: Added PAE group address to "
00445 "RoboSwitch ARL", __func__);
00446 }
00447
00448 return drv;
00449 }
00450
00451
00452 static void wpa_driver_roboswitch_deinit(void *priv)
00453 {
00454 struct wpa_driver_roboswitch_data *drv = priv;
00455
00456 if (drv->l2) {
00457 l2_packet_deinit(drv->l2);
00458 drv->l2 = NULL;
00459 }
00460 if (wpa_driver_roboswitch_leave(drv, drv->ports, pae_group_addr) < 0) {
00461 wpa_printf(MSG_DEBUG, "%s: Unable to leave PAE group",
00462 __func__);
00463 }
00464
00465 close(drv->fd);
00466 os_free(drv);
00467 }
00468
00469
00470 const struct wpa_driver_ops wpa_driver_roboswitch_ops = {
00471 .name = "roboswitch",
00472 .desc = "wpa_supplicant roboswitch driver",
00473 .get_ssid = wpa_driver_roboswitch_get_ssid,
00474 .get_bssid = wpa_driver_roboswitch_get_bssid,
00475 .get_capa = wpa_driver_roboswitch_get_capa,
00476 .init = wpa_driver_roboswitch_init,
00477 .deinit = wpa_driver_roboswitch_deinit,
00478 .set_param = wpa_driver_roboswitch_set_param,
00479 .get_ifname = wpa_driver_roboswitch_get_ifname,
00480 };