src/drivers/driver_wired.c

   1 /*
   2  * Wired Ethernet driver interface
   3  * Copyright (c) 2005-2009, Jouni Malinen <j@w1.fi>
   4  * Copyright (c) 2004, Gunter Burchardt <tira@isx.de>
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License version 2 as
   8  * published by the Free Software Foundation.
   9  *
  10  * Alternatively, this software may be distributed under the terms of BSD
  11  * license.
  12  *
  13  * See README and COPYING for more details.
  14  */
  15
  16 #include "includes.h"
  17 #include <sys/ioctl.h>
  18 #include <net/if.h>
  19 #ifdef __linux__
  20 #include <netpacket/packet.h>
  21 #include <net/if_arp.h>
  22 #include <net/if.h>
  23 #endif /* __linux__ */
  24 #if defined(__FreeBSD__) || defined(__DragonFly__)
  25 #include <net/if_dl.h>
  26 #endif /* defined(__FreeBSD__) || defined(__DragonFly__) */
  27
  28 #include "common.h"
  29 #include "eloop.h"
  30 #include "driver.h"
  31
  32 #ifdef _MSC_VER
  33 #pragma pack(push, 1)
  34 #endif /* _MSC_VER */
  35
  36 struct ieee8023_hdr {
  37         u8 dest[6];
  38         u8 src[6];
  39         u16 ethertype;
  40 } STRUCT_PACKED;
  41
  42 #ifdef _MSC_VER
  43 #pragma pack(pop)
  44 #endif /* _MSC_VER */
  45
  46 static const u8 pae_group_addr[ETH_ALEN] =
  47 { 0x01, 0x80, 0xc2, 0x00, 0x00, 0x03 };
  48
  49
  50 struct wpa_driver_wired_data {
  51         char ifname[IFNAMSIZ + 1];
  52         void *ctx;
  53
  54         int sock; /* raw packet socket for driver access */
  55         int dhcp_sock; /* socket for dhcp packets */
  56         int use_pae_group_addr;
  57
  58         int pf_sock;
  59         int membership, multi, iff_allmulti, iff_up;
  60 };
  61
  62
  63 /* TODO: detecting new devices should eventually be changed from using DHCP
  64  * snooping to trigger on any packet from a new layer 2 MAC address, e.g.,
  65  * based on ebtables, etc. */
  66
  67 struct dhcp_message {
  68         u_int8_t op;
  69         u_int8_t htype;
  70         u_int8_t hlen;
  71         u_int8_t hops;
  72         u_int32_t xid;
  73         u_int16_t secs;
  74         u_int16_t flags;
  75         u_int32_t ciaddr;
  76         u_int32_t yiaddr;
  77         u_int32_t siaddr;
  78         u_int32_t giaddr;
  79         u_int8_t chaddr[16];
  80         u_int8_t sname[64];
  81         u_int8_t file[128];
  82         u_int32_t cookie;
  83         u_int8_t options[308]; /* 312 - cookie */
  84 };
  85
  86
  87 static int wired_multicast_membership(int sock, int ifindex,
  88                                       const u8 *addr, int add)
  89 {
  90 #ifdef __linux__
  91         struct packet_mreq mreq;
  92
  93         if (sock < 0)
  94                 return -1;
  95
  96         os_memset(&mreq, 0, sizeof(mreq));
  97         mreq.mr_ifindex = ifindex;
  98         mreq.mr_type = PACKET_MR_MULTICAST;
  99         mreq.mr_alen = ETH_ALEN;
 100         os_memcpy(mreq.mr_address, addr, ETH_ALEN);
 101
 102         if (setsockopt(sock, SOL_PACKET,
 103                        add ? PACKET_ADD_MEMBERSHIP : PACKET_DROP_MEMBERSHIP,
 104                        &mreq, sizeof(mreq)) < 0) {
 105                 perror("setsockopt");
 106                 return -1;
 107         }
 108         return 0;
 109 #else /* __linux__ */
 110         return -1;
 111 #endif /* __linux__ */
 112 }
 113
 114
 115 static void handle_data(void *ctx, unsigned char *buf, size_t len)
 116 {
 117 #ifdef HOSTAPD
 118         struct ieee8023_hdr *hdr;
 119         u8 *pos, *sa;
 120         size_t left;
 121         union wpa_event_data event;
 122
 123         /* must contain at least ieee8023_hdr 6 byte source, 6 byte dest,
 124          * 2 byte ethertype */
 125         if (len < 14) {
 126                 wpa_printf(MSG_MSGDUMP, "handle_data: too short (%lu)",
 127                            (unsigned long) len);
 128                 return;
 129         }
 130
 131         hdr = (struct ieee8023_hdr *) buf;
 132
 133         switch (ntohs(hdr->ethertype)) {
 134                 case ETH_P_PAE:
 135                         wpa_printf(MSG_MSGDUMP, "Received EAPOL packet");
 136                         sa = hdr->src;
 137                         os_memset(&event, 0, sizeof(event));
 138                         event.new_sta.addr = sa;
 139                         wpa_supplicant_event(ctx, EVENT_NEW_STA, &event);
 140
 141                         pos = (u8 *) (hdr + 1);
 142                         left = len - sizeof(*hdr);
 143
 144                         hostapd_eapol_receive(ctx, sa, pos, left);
 145                 break;
 146
 147         default:
 148                 wpa_printf(MSG_DEBUG, "Unknown ethertype 0x%04x in data frame",
 149                            ntohs(hdr->ethertype));
 150                 break;
 151         }
 152 #endif /* HOSTAPD */
 153 }
 154
 155
 156 static void handle_read(int sock, void *eloop_ctx, void *sock_ctx)
 157 {
 158         int len;
 159         unsigned char buf[3000];
 160
 161         len = recv(sock, buf, sizeof(buf), 0);
 162         if (len < 0) {
 163                 perror("recv");
 164                 return;
 165         }
 166
 167         handle_data(eloop_ctx, buf, len);
 168 }
 169
 170
 171 static void handle_dhcp(int sock, void *eloop_ctx, void *sock_ctx)
 172 {
 173         int len;
 174         unsigned char buf[3000];
 175         struct dhcp_message *msg;
 176         u8 *mac_address;
 177         union wpa_event_data event;
 178
 179         len = recv(sock, buf, sizeof(buf), 0);
 180         if (len < 0) {
 181                 perror("recv");
 182                 return;
 183         }
 184
 185         /* must contain at least dhcp_message->chaddr */
 186         if (len < 44) {
 187                 wpa_printf(MSG_MSGDUMP, "handle_dhcp: too short (%d)", len);
 188                 return;
 189         }
 190
 191         msg = (struct dhcp_message *) buf;
 192         mac_address = (u8 *) &(msg->chaddr);
 193
 194         wpa_printf(MSG_MSGDUMP, "Got DHCP broadcast packet from " MACSTR,
 195                    MAC2STR(mac_address));
 196
 197         os_memset(&event, 0, sizeof(event));
 198         event.new_sta.addr = mac_address;
 199         wpa_supplicant_event(eloop_ctx, EVENT_NEW_STA, &event);
 200 }
 201
 202
 203 static int wired_init_sockets(struct wpa_driver_wired_data *drv, u8 *own_addr)
 204 {
 205         struct ifreq ifr;
 206         struct sockaddr_ll addr;
 207         struct sockaddr_in addr2;
 208         int n = 1;
 209
 210         drv->sock = socket(PF_PACKET, SOCK_RAW, htons(ETH_P_PAE));
 211         if (drv->sock < 0) {
 212                 perror("socket[PF_PACKET,SOCK_RAW]");
 213                 return -1;
 214         }
 215
 216         if (eloop_register_read_sock(drv->sock, handle_read, drv->ctx, NULL)) {
 217                 printf("Could not register read socket\n");
 218                 return -1;
 219         }
 220
 221         os_memset(&ifr, 0, sizeof(ifr));
 222         os_strlcpy(ifr.ifr_name, drv->ifname, sizeof(ifr.ifr_name));
 223         if (ioctl(drv->sock, SIOCGIFINDEX, &ifr) != 0) {
 224                 perror("ioctl(SIOCGIFINDEX)");
 225                 return -1;
 226         }
 227
 228         os_memset(&addr, 0, sizeof(addr));
 229         addr.sll_family = AF_PACKET;
 230         addr.sll_ifindex = ifr.ifr_ifindex;
 231         wpa_printf(MSG_DEBUG, "Opening raw packet socket for ifindex %d",
 232                    addr.sll_ifindex);
 233
 234         if (bind(drv->sock, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
 235                 perror("bind");
 236                 return -1;
 237         }
 238
 239         /* filter multicast address */
 240         if (wired_multicast_membership(drv->sock, ifr.ifr_ifindex,
 241                                        pae_group_addr, 1) < 0) {
 242                 wpa_printf(MSG_ERROR, "wired: Failed to add multicast group "
 243                            "membership");
 244                 return -1;
 245         }
 246
 247         os_memset(&ifr, 0, sizeof(ifr));
 248         os_strlcpy(ifr.ifr_name, drv->ifname, sizeof(ifr.ifr_name));
 249         if (ioctl(drv->sock, SIOCGIFHWADDR, &ifr) != 0) {
 250                 perror("ioctl(SIOCGIFHWADDR)");
 251                 return -1;
 252         }
 253
 254         if (ifr.ifr_hwaddr.sa_family != ARPHRD_ETHER) {
 255                 printf("Invalid HW-addr family 0x%04x\n",
 256                        ifr.ifr_hwaddr.sa_family);
 257                 return -1;
 258         }
 259         os_memcpy(own_addr, ifr.ifr_hwaddr.sa_data, ETH_ALEN);
 260
 261         /* setup dhcp listen socket for sta detection */
 262         if ((drv->dhcp_sock = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP)) < 0) {
 263                 perror("socket call failed for dhcp");
 264                 return -1;
 265         }
 266
 267         if (eloop_register_read_sock(drv->dhcp_sock, handle_dhcp, drv->ctx,
 268                                      NULL)) {
 269                 printf("Could not register read socket\n");
 270                 return -1;
 271         }
 272
 273         os_memset(&addr2, 0, sizeof(addr2));
 274         addr2.sin_family = AF_INET;
 275         addr2.sin_port = htons(67);
 276         addr2.sin_addr.s_addr = INADDR_ANY;
 277
 278         if (setsockopt(drv->dhcp_sock, SOL_SOCKET, SO_REUSEADDR, (char *) &n,
 279                        sizeof(n)) == -1) {
 280                 perror("setsockopt[SOL_SOCKET,SO_REUSEADDR]");
 281                 return -1;
 282         }
 283         if (setsockopt(drv->dhcp_sock, SOL_SOCKET, SO_BROADCAST, (char *) &n,
 284                        sizeof(n)) == -1) {
 285                 perror("setsockopt[SOL_SOCKET,SO_BROADCAST]");
 286                 return -1;
 287         }
 288
 289         os_memset(&ifr, 0, sizeof(ifr));
 290         os_strlcpy(ifr.ifr_ifrn.ifrn_name, drv->ifname, IFNAMSIZ);
 291         if (setsockopt(drv->dhcp_sock, SOL_SOCKET, SO_BINDTODEVICE,
 292                        (char *) &ifr, sizeof(ifr)) < 0) {
 293                 perror("setsockopt[SOL_SOCKET,SO_BINDTODEVICE]");
 294                 return -1;
 295         }
 296
 297         if (bind(drv->dhcp_sock, (struct sockaddr *) &addr2,
 298                  sizeof(struct sockaddr)) == -1) {
 299                 perror("bind");
 300                 return -1;
 301         }
 302
 303         return 0;
 304 }
 305
 306
 307 static int wired_send_eapol(void *priv, const u8 *addr,
 308                             const u8 *data, size_t data_len, int encrypt,
 309                             const u8 *own_addr)
 310 {
 311         struct wpa_driver_wired_data *drv = priv;
 312         struct ieee8023_hdr *hdr;
 313         size_t len;
 314         u8 *pos;
 315         int res;
 316
 317         len = sizeof(*hdr) + data_len;
 318         hdr = os_zalloc(len);
 319         if (hdr == NULL) {
 320                 printf("malloc() failed for wired_send_eapol(len=%lu)\n",
 321                        (unsigned long) len);
 322                 return -1;
 323         }
 324
 325         os_memcpy(hdr->dest, drv->use_pae_group_addr ? pae_group_addr : addr,
 326                   ETH_ALEN);
 327         os_memcpy(hdr->src, own_addr, ETH_ALEN);
 328         hdr->ethertype = htons(ETH_P_PAE);
 329
 330         pos = (u8 *) (hdr + 1);
 331         os_memcpy(pos, data, data_len);
 332
 333         res = send(drv->sock, (u8 *) hdr, len, 0);
 334         os_free(hdr);
 335
 336         if (res < 0) {
 337                 perror("wired_send_eapol: send");
 338                 printf("wired_send_eapol - packet len: %lu - failed\n",
 339                        (unsigned long) len);
 340         }
 341
 342         return res;
 343 }
 344
 345
 346 static void * wired_driver_hapd_init(struct hostapd_data *hapd,
 347                                      struct wpa_init_params *params)
 348 {
 349         struct wpa_driver_wired_data *drv;
 350
 351         drv = os_zalloc(sizeof(struct wpa_driver_wired_data));
 352         if (drv == NULL) {
 353                 printf("Could not allocate memory for wired driver data\n");
 354                 return NULL;
 355         }
 356
 357         drv->ctx = hapd;
 358         os_strlcpy(drv->ifname, params->ifname, sizeof(drv->ifname));
 359         drv->use_pae_group_addr = params->use_pae_group_addr;
 360
 361         if (wired_init_sockets(drv, params->own_addr)) {
 362                 os_free(drv);
 363                 return NULL;
 364         }
 365
 366         return drv;
 367 }
 368
 369
 370 static void wired_driver_hapd_deinit(void *priv)
 371 {
 372         struct wpa_driver_wired_data *drv = priv;
 373
 374         if (drv->sock >= 0)
 375                 close(drv->sock);
 376
 377         if (drv->dhcp_sock >= 0)
 378                 close(drv->dhcp_sock);
 379
 380         os_free(drv);
 381 }
 382
 383
 384 static int wpa_driver_wired_get_ssid(void *priv, u8 *ssid)
 385 {
 386         ssid[0] = 0;
 387         return 0;
 388 }
 389
 390
 391 static int wpa_driver_wired_get_bssid(void *priv, u8 *bssid)
 392 {
 393         /* Report PAE group address as the "BSSID" for wired connection. */
 394         os_memcpy(bssid, pae_group_addr, ETH_ALEN);
 395         return 0;
 396 }
 397
 398
 399 static int wpa_driver_wired_get_capa(void *priv, struct wpa_driver_capa *capa)
 400 {
 401         os_memset(capa, 0, sizeof(*capa));
 402         capa->flags = WPA_DRIVER_FLAGS_WIRED;
 403         return 0;
 404 }
 405
 406
 407 static int wpa_driver_wired_get_ifflags(const char *ifname, int *flags)
 408 {
 409         struct ifreq ifr;
 410         int s;
 411
 412         s = socket(PF_INET, SOCK_DGRAM, 0);
 413         if (s < 0) {
 414                 perror("socket");
 415                 return -1;
 416         }
 417
 418         os_memset(&ifr, 0, sizeof(ifr));
 419         os_strlcpy(ifr.ifr_name, ifname, IFNAMSIZ);
 420         if (ioctl(s, SIOCGIFFLAGS, (caddr_t) &ifr) < 0) {
 421                 perror("ioctl[SIOCGIFFLAGS]");
 422                 close(s);
 423                 return -1;
 424         }
 425         close(s);
 426         *flags = ifr.ifr_flags & 0xffff;
 427         return 0;
 428 }
 429
 430
 431 static int wpa_driver_wired_set_ifflags(const char *ifname, int flags)
 432 {
 433         struct ifreq ifr;
 434         int s;
 435
 436         s = socket(PF_INET, SOCK_DGRAM, 0);
 437         if (s < 0) {
 438                 perror("socket");
 439                 return -1;
 440         }
 441
 442         os_memset(&ifr, 0, sizeof(ifr));
 443         os_strlcpy(ifr.ifr_name, ifname, IFNAMSIZ);
 444         ifr.ifr_flags = flags & 0xffff;
 445         if (ioctl(s, SIOCSIFFLAGS, (caddr_t) &ifr) < 0) {
 446                 perror("ioctl[SIOCSIFFLAGS]");
 447                 close(s);
 448                 return -1;
 449         }
 450         close(s);
 451         return 0;
 452 }
 453
 454
 455 static int wpa_driver_wired_multi(const char *ifname, const u8 *addr, int add)
 456 {
 457         struct ifreq ifr;
 458         int s;
 459
 460         s = socket(PF_INET, SOCK_DGRAM, 0);
 461         if (s < 0) {
 462                 perror("socket");
 463                 return -1;
 464         }
 465
 466         os_memset(&ifr, 0, sizeof(ifr));
 467         os_strlcpy(ifr.ifr_name, ifname, IFNAMSIZ);
 468 #ifdef __linux__
 469         ifr.ifr_hwaddr.sa_family = AF_UNSPEC;
 470         os_memcpy(ifr.ifr_hwaddr.sa_data, addr, ETH_ALEN);
 471 #endif /* __linux__ */
 472 #if defined(__FreeBSD__) || defined(__DragonFly__)
 473         {
 474                 struct sockaddr_dl *dlp;
 475                 dlp = (struct sockaddr_dl *) &ifr.ifr_addr;
 476                 dlp->sdl_len = sizeof(struct sockaddr_dl);
 477                 dlp->sdl_family = AF_LINK;
 478                 dlp->sdl_index = 0;
 479                 dlp->sdl_nlen = 0;
 480                 dlp->sdl_alen = ETH_ALEN;
 481                 dlp->sdl_slen = 0;
 482                 os_memcpy(LLADDR(dlp), addr, ETH_ALEN);
 483         }
 484 #endif /* defined(__FreeBSD__) || defined(__DragonFly__) */
 485 #if defined(__NetBSD__) || defined(__OpenBSD__) || defined(__APPLE__)
 486         {
 487                 struct sockaddr *sap;
 488                 sap = (struct sockaddr *) &ifr.ifr_addr;
 489                 sap->sa_len = sizeof(struct sockaddr);
 490                 sap->sa_family = AF_UNSPEC;
 491                 os_memcpy(sap->sa_data, addr, ETH_ALEN);
 492         }
 493 #endif /* defined(__NetBSD__) || defined(__OpenBSD__) || defined(__APPLE__) */
 494
 495         if (ioctl(s, add ? SIOCADDMULTI : SIOCDELMULTI, (caddr_t) &ifr) < 0) {
 496                 perror("ioctl[SIOC{ADD/DEL}MULTI]");
 497                 close(s);
 498                 return -1;
 499         }
 500         close(s);
 501         return 0;
 502 }
 503
 504
 505 static void * wpa_driver_wired_init(void *ctx, const char *ifname)
 506 {
 507         struct wpa_driver_wired_data *drv;
 508         int flags;
 509
 510         drv = os_zalloc(sizeof(*drv));
 511         if (drv == NULL)
 512                 return NULL;
 513         os_strlcpy(drv->ifname, ifname, sizeof(drv->ifname));
 514         drv->ctx = ctx;
 515
 516 #ifdef __linux__
 517         drv->pf_sock = socket(PF_PACKET, SOCK_DGRAM, 0);
 518         if (drv->pf_sock < 0)
 519                 perror("socket(PF_PACKET)");
 520 #else /* __linux__ */
 521         drv->pf_sock = -1;
 522 #endif /* __linux__ */
 523
 524         if (wpa_driver_wired_get_ifflags(ifname, &flags) == 0 &&
 525             !(flags & IFF_UP) &&
 526             wpa_driver_wired_set_ifflags(ifname, flags | IFF_UP) == 0) {
 527                 drv->iff_up = 1;
 528         }
 529
 530         if (wired_multicast_membership(drv->pf_sock,
 531                                        if_nametoindex(drv->ifname),
 532                                        pae_group_addr, 1) == 0) {
 533                 wpa_printf(MSG_DEBUG, "%s: Added multicast membership with "
 534                            "packet socket", __func__);
 535                 drv->membership = 1;
 536         } else if (wpa_driver_wired_multi(ifname, pae_group_addr, 1) == 0) {
 537                 wpa_printf(MSG_DEBUG, "%s: Added multicast membership with "
 538                            "SIOCADDMULTI", __func__);
 539                 drv->multi = 1;
 540         } else if (wpa_driver_wired_get_ifflags(ifname, &flags) < 0) {
 541                 wpa_printf(MSG_INFO, "%s: Could not get interface "
 542                            "flags", __func__);
 543                 os_free(drv);
 544                 return NULL;
 545         } else if (flags & IFF_ALLMULTI) {
 546                 wpa_printf(MSG_DEBUG, "%s: Interface is already configured "
 547                            "for multicast", __func__);
 548         } else if (wpa_driver_wired_set_ifflags(ifname,
 549                                                 flags | IFF_ALLMULTI) < 0) {
 550                 wpa_printf(MSG_INFO, "%s: Failed to enable allmulti",
 551                            __func__);
 552                 os_free(drv);
 553                 return NULL;
 554         } else {
 555                 wpa_printf(MSG_DEBUG, "%s: Enabled allmulti mode",
 556                            __func__);
 557                 drv->iff_allmulti = 1;
 558         }
 559
 560         return drv;
 561 }
 562
 563
 564 static void wpa_driver_wired_deinit(void *priv)
 565 {
 566         struct wpa_driver_wired_data *drv = priv;
 567         int flags;
 568
 569         if (drv->membership &&
 570             wired_multicast_membership(drv->pf_sock,
 571                                        if_nametoindex(drv->ifname),
 572                                        pae_group_addr, 0) < 0) {
 573                 wpa_printf(MSG_DEBUG, "%s: Failed to remove PAE multicast "
 574                            "group (PACKET)", __func__);
 575         }
 576
 577         if (drv->multi &&
 578             wpa_driver_wired_multi(drv->ifname, pae_group_addr, 0) < 0) {
 579                 wpa_printf(MSG_DEBUG, "%s: Failed to remove PAE multicast "
 580                            "group (SIOCDELMULTI)", __func__);
 581         }
 582
 583         if (drv->iff_allmulti &&
 584             (wpa_driver_wired_get_ifflags(drv->ifname, &flags) < 0 ||
 585              wpa_driver_wired_set_ifflags(drv->ifname,
 586                                           flags & ~IFF_ALLMULTI) < 0)) {
 587                 wpa_printf(MSG_DEBUG, "%s: Failed to disable allmulti mode",
 588                            __func__);
 589         }
 590
 591         if (drv->iff_up &&
 592             wpa_driver_wired_get_ifflags(drv->ifname, &flags) == 0 &&
 593             (flags & IFF_UP) &&
 594             wpa_driver_wired_set_ifflags(drv->ifname, flags & ~IFF_UP) < 0) {
 595                 wpa_printf(MSG_DEBUG, "%s: Failed to set the interface down",
 596                            __func__);
 597         }
 598
 599         if (drv->pf_sock != -1)
 600                 close(drv->pf_sock);
 601
 602         os_free(drv);
 603 }
 604
 605
 606 const struct wpa_driver_ops wpa_driver_wired_ops = {
 607         .name = "wired",
 608         .desc = "Wired Ethernet driver",
 609         .hapd_init = wired_driver_hapd_init,
 610         .hapd_deinit = wired_driver_hapd_deinit,
 611         .hapd_send_eapol = wired_send_eapol,
 612         .get_ssid = wpa_driver_wired_get_ssid,
 613         .get_bssid = wpa_driver_wired_get_bssid,
 614         .get_capa = wpa_driver_wired_get_capa,
 615         .init = wpa_driver_wired_init,
 616         .deinit = wpa_driver_wired_deinit,
 617 };