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
 122         /* must contain at least ieee8023_hdr 6 byte source, 6 byte dest,
 123          * 2 byte ethertype */
 124         if (len < 14) {
 125                 wpa_printf(MSG_MSGDUMP, "handle_data: too short (%lu)",
 126                            (unsigned long) len);
 127                 return;
 128         }
 129
 130         hdr = (struct ieee8023_hdr *) buf;
 131
 132         switch (ntohs(hdr->ethertype)) {
 133                 case ETH_P_PAE:
 134                         wpa_printf(MSG_MSGDUMP, "Received EAPOL packet");
 135                         sa = hdr->src;
 136                         hostapd_notif_new_sta(ctx, sa);
 137
 138                         pos = (u8 *) (hdr + 1);
 139                         left = len - sizeof(*hdr);
 140
 141                         hostapd_eapol_receive(ctx, sa, pos, left);
 142                 break;
 143
 144         default:
 145                 wpa_printf(MSG_DEBUG, "Unknown ethertype 0x%04x in data frame",
 146                            ntohs(hdr->ethertype));
 147                 break;
 148         }
 149 #endif /* HOSTAPD */
 150 }
 151
 152
 153 static void handle_read(int sock, void *eloop_ctx, void *sock_ctx)
 154 {
 155         int len;
 156         unsigned char buf[3000];
 157
 158         len = recv(sock, buf, sizeof(buf), 0);
 159         if (len < 0) {
 160                 perror("recv");
 161                 return;
 162         }
 163
 164         handle_data(eloop_ctx, buf, len);
 165 }
 166
 167
 168 static void handle_dhcp(int sock, void *eloop_ctx, void *sock_ctx)
 169 {
 170 #ifdef HOSTAPD
 171         int len;
 172         unsigned char buf[3000];
 173         struct dhcp_message *msg;
 174         u8 *mac_address;
 175
 176         len = recv(sock, buf, sizeof(buf), 0);
 177         if (len < 0) {
 178                 perror("recv");
 179                 return;
 180         }
 181
 182         /* must contain at least dhcp_message->chaddr */
 183         if (len < 44) {
 184                 wpa_printf(MSG_MSGDUMP, "handle_dhcp: too short (%d)", len);
 185                 return;
 186         }
 187
 188         msg = (struct dhcp_message *) buf;
 189         mac_address = (u8 *) &(msg->chaddr);
 190
 191         wpa_printf(MSG_MSGDUMP, "Got DHCP broadcast packet from " MACSTR,
 192                    MAC2STR(mac_address));
 193
 194         hostapd_notif_new_sta(eloop_ctx, mac_address);
 195 #endif /* HOSTAPD */
 196 }
 197
 198
 199 static int wired_init_sockets(struct wpa_driver_wired_data *drv, u8 *own_addr)
 200 {
 201         struct ifreq ifr;
 202         struct sockaddr_ll addr;
 203         struct sockaddr_in addr2;
 204         int n = 1;
 205
 206         drv->sock = socket(PF_PACKET, SOCK_RAW, htons(ETH_P_PAE));
 207         if (drv->sock < 0) {
 208                 perror("socket[PF_PACKET,SOCK_RAW]");
 209                 return -1;
 210         }
 211
 212         if (eloop_register_read_sock(drv->sock, handle_read, drv->ctx, NULL)) {
 213                 printf("Could not register read socket\n");
 214                 return -1;
 215         }
 216
 217         os_memset(&ifr, 0, sizeof(ifr));
 218         os_strlcpy(ifr.ifr_name, drv->ifname, sizeof(ifr.ifr_name));
 219         if (ioctl(drv->sock, SIOCGIFINDEX, &ifr) != 0) {
 220                 perror("ioctl(SIOCGIFINDEX)");
 221                 return -1;
 222         }
 223
 224         os_memset(&addr, 0, sizeof(addr));
 225         addr.sll_family = AF_PACKET;
 226         addr.sll_ifindex = ifr.ifr_ifindex;
 227         wpa_printf(MSG_DEBUG, "Opening raw packet socket for ifindex %d",
 228                    addr.sll_ifindex);
 229
 230         if (bind(drv->sock, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
 231                 perror("bind");
 232                 return -1;
 233         }
 234
 235         /* filter multicast address */
 236         if (wired_multicast_membership(drv->sock, ifr.ifr_ifindex,
 237                                        pae_group_addr, 1) < 0) {
 238                 wpa_printf(MSG_ERROR, "wired: Failed to add multicast group "
 239                            "membership");
 240                 return -1;
 241         }
 242
 243         os_memset(&ifr, 0, sizeof(ifr));
 244         os_strlcpy(ifr.ifr_name, drv->ifname, sizeof(ifr.ifr_name));
 245         if (ioctl(drv->sock, SIOCGIFHWADDR, &ifr) != 0) {
 246                 perror("ioctl(SIOCGIFHWADDR)");
 247                 return -1;
 248         }
 249
 250         if (ifr.ifr_hwaddr.sa_family != ARPHRD_ETHER) {
 251                 printf("Invalid HW-addr family 0x%04x\n",
 252                        ifr.ifr_hwaddr.sa_family);
 253                 return -1;
 254         }
 255         os_memcpy(own_addr, ifr.ifr_hwaddr.sa_data, ETH_ALEN);
 256
 257         /* setup dhcp listen socket for sta detection */
 258         if ((drv->dhcp_sock = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP)) < 0) {
 259                 perror("socket call failed for dhcp");
 260                 return -1;
 261         }
 262
 263         if (eloop_register_read_sock(drv->dhcp_sock, handle_dhcp, drv->ctx,
 264                                      NULL)) {
 265                 printf("Could not register read socket\n");
 266                 return -1;
 267         }
 268
 269         os_memset(&addr2, 0, sizeof(addr2));
 270         addr2.sin_family = AF_INET;
 271         addr2.sin_port = htons(67);
 272         addr2.sin_addr.s_addr = INADDR_ANY;
 273
 274         if (setsockopt(drv->dhcp_sock, SOL_SOCKET, SO_REUSEADDR, (char *) &n,
 275                        sizeof(n)) == -1) {
 276                 perror("setsockopt[SOL_SOCKET,SO_REUSEADDR]");
 277                 return -1;
 278         }
 279         if (setsockopt(drv->dhcp_sock, SOL_SOCKET, SO_BROADCAST, (char *) &n,
 280                        sizeof(n)) == -1) {
 281                 perror("setsockopt[SOL_SOCKET,SO_BROADCAST]");
 282                 return -1;
 283         }
 284
 285         os_memset(&ifr, 0, sizeof(ifr));
 286         os_strlcpy(ifr.ifr_ifrn.ifrn_name, drv->ifname, IFNAMSIZ);
 287         if (setsockopt(drv->dhcp_sock, SOL_SOCKET, SO_BINDTODEVICE,
 288                        (char *) &ifr, sizeof(ifr)) < 0) {
 289                 perror("setsockopt[SOL_SOCKET,SO_BINDTODEVICE]");
 290                 return -1;
 291         }
 292
 293         if (bind(drv->dhcp_sock, (struct sockaddr *) &addr2,
 294                  sizeof(struct sockaddr)) == -1) {
 295                 perror("bind");
 296                 return -1;
 297         }
 298
 299         return 0;
 300 }
 301
 302
 303 static int wired_send_eapol(void *priv, const u8 *addr,
 304                             const u8 *data, size_t data_len, int encrypt,
 305                             const u8 *own_addr)
 306 {
 307         struct wpa_driver_wired_data *drv = priv;
 308         struct ieee8023_hdr *hdr;
 309         size_t len;
 310         u8 *pos;
 311         int res;
 312
 313         len = sizeof(*hdr) + data_len;
 314         hdr = os_zalloc(len);
 315         if (hdr == NULL) {
 316                 printf("malloc() failed for wired_send_eapol(len=%lu)\n",
 317                        (unsigned long) len);
 318                 return -1;
 319         }
 320
 321         os_memcpy(hdr->dest, drv->use_pae_group_addr ? pae_group_addr : addr,
 322                   ETH_ALEN);
 323         os_memcpy(hdr->src, own_addr, ETH_ALEN);
 324         hdr->ethertype = htons(ETH_P_PAE);
 325
 326         pos = (u8 *) (hdr + 1);
 327         os_memcpy(pos, data, data_len);
 328
 329         res = send(drv->sock, (u8 *) hdr, len, 0);
 330         os_free(hdr);
 331
 332         if (res < 0) {
 333                 perror("wired_send_eapol: send");
 334                 printf("wired_send_eapol - packet len: %lu - failed\n",
 335                        (unsigned long) len);
 336         }
 337
 338         return res;
 339 }
 340
 341
 342 static void * wired_driver_hapd_init(struct hostapd_data *hapd,
 343                                      struct wpa_init_params *params)
 344 {
 345         struct wpa_driver_wired_data *drv;
 346
 347         drv = os_zalloc(sizeof(struct wpa_driver_wired_data));
 348         if (drv == NULL) {
 349                 printf("Could not allocate memory for wired driver data\n");
 350                 return NULL;
 351         }
 352
 353         drv->ctx = hapd;
 354         os_strlcpy(drv->ifname, params->ifname, sizeof(drv->ifname));
 355         drv->use_pae_group_addr = params->use_pae_group_addr;
 356
 357         if (wired_init_sockets(drv, params->own_addr)) {
 358                 os_free(drv);
 359                 return NULL;
 360         }
 361
 362         return drv;
 363 }
 364
 365
 366 static void wired_driver_hapd_deinit(void *priv)
 367 {
 368         struct wpa_driver_wired_data *drv = priv;
 369
 370         if (drv->sock >= 0)
 371                 close(drv->sock);
 372
 373         if (drv->dhcp_sock >= 0)
 374                 close(drv->dhcp_sock);
 375
 376         os_free(drv);
 377 }
 378
 379
 380 static int wpa_driver_wired_get_ssid(void *priv, u8 *ssid)
 381 {
 382         ssid[0] = 0;
 383         return 0;
 384 }
 385
 386
 387 static int wpa_driver_wired_get_bssid(void *priv, u8 *bssid)
 388 {
 389         /* Report PAE group address as the "BSSID" for wired connection. */
 390         os_memcpy(bssid, pae_group_addr, ETH_ALEN);
 391         return 0;
 392 }
 393
 394
 395 static int wpa_driver_wired_get_capa(void *priv, struct wpa_driver_capa *capa)
 396 {
 397         os_memset(capa, 0, sizeof(*capa));
 398         capa->flags = WPA_DRIVER_FLAGS_WIRED;
 399         return 0;
 400 }
 401
 402
 403 static int wpa_driver_wired_get_ifflags(const char *ifname, int *flags)
 404 {
 405         struct ifreq ifr;
 406         int s;
 407
 408         s = socket(PF_INET, SOCK_DGRAM, 0);
 409         if (s < 0) {
 410                 perror("socket");
 411                 return -1;
 412         }
 413
 414         os_memset(&ifr, 0, sizeof(ifr));
 415         os_strlcpy(ifr.ifr_name, ifname, IFNAMSIZ);
 416         if (ioctl(s, SIOCGIFFLAGS, (caddr_t) &ifr) < 0) {
 417                 perror("ioctl[SIOCGIFFLAGS]");
 418                 close(s);
 419                 return -1;
 420         }
 421         close(s);
 422         *flags = ifr.ifr_flags & 0xffff;
 423         return 0;
 424 }
 425
 426
 427 static int wpa_driver_wired_set_ifflags(const char *ifname, int flags)
 428 {
 429         struct ifreq ifr;
 430         int s;
 431
 432         s = socket(PF_INET, SOCK_DGRAM, 0);
 433         if (s < 0) {
 434                 perror("socket");
 435                 return -1;
 436         }
 437
 438         os_memset(&ifr, 0, sizeof(ifr));
 439         os_strlcpy(ifr.ifr_name, ifname, IFNAMSIZ);
 440         ifr.ifr_flags = flags & 0xffff;
 441         if (ioctl(s, SIOCSIFFLAGS, (caddr_t) &ifr) < 0) {
 442                 perror("ioctl[SIOCSIFFLAGS]");
 443                 close(s);
 444                 return -1;
 445         }
 446         close(s);
 447         return 0;
 448 }
 449
 450
 451 static int wpa_driver_wired_multi(const char *ifname, const u8 *addr, int add)
 452 {
 453         struct ifreq ifr;
 454         int s;
 455
 456         s = socket(PF_INET, SOCK_DGRAM, 0);
 457         if (s < 0) {
 458                 perror("socket");
 459                 return -1;
 460         }
 461
 462         os_memset(&ifr, 0, sizeof(ifr));
 463         os_strlcpy(ifr.ifr_name, ifname, IFNAMSIZ);
 464 #ifdef __linux__
 465         ifr.ifr_hwaddr.sa_family = AF_UNSPEC;
 466         os_memcpy(ifr.ifr_hwaddr.sa_data, addr, ETH_ALEN);
 467 #endif /* __linux__ */
 468 #if defined(__FreeBSD__) || defined(__DragonFly__)
 469         {
 470                 struct sockaddr_dl *dlp;
 471                 dlp = (struct sockaddr_dl *) &ifr.ifr_addr;
 472                 dlp->sdl_len = sizeof(struct sockaddr_dl);
 473                 dlp->sdl_family = AF_LINK;
 474                 dlp->sdl_index = 0;
 475                 dlp->sdl_nlen = 0;
 476                 dlp->sdl_alen = ETH_ALEN;
 477                 dlp->sdl_slen = 0;
 478                 os_memcpy(LLADDR(dlp), addr, ETH_ALEN);
 479         }
 480 #endif /* defined(__FreeBSD__) || defined(__DragonFly__) */
 481 #if defined(__NetBSD__) || defined(__OpenBSD__) || defined(__APPLE__)
 482         {
 483                 struct sockaddr *sap;
 484                 sap = (struct sockaddr *) &ifr.ifr_addr;
 485                 sap->sa_len = sizeof(struct sockaddr);
 486                 sap->sa_family = AF_UNSPEC;
 487                 os_memcpy(sap->sa_data, addr, ETH_ALEN);
 488         }
 489 #endif /* defined(__NetBSD__) || defined(__OpenBSD__) || defined(__APPLE__) */
 490
 491         if (ioctl(s, add ? SIOCADDMULTI : SIOCDELMULTI, (caddr_t) &ifr) < 0) {
 492                 perror("ioctl[SIOC{ADD/DEL}MULTI]");
 493                 close(s);
 494                 return -1;
 495         }
 496         close(s);
 497         return 0;
 498 }
 499
 500
 501 static void * wpa_driver_wired_init(void *ctx, const char *ifname)
 502 {
 503         struct wpa_driver_wired_data *drv;
 504         int flags;
 505
 506         drv = os_zalloc(sizeof(*drv));
 507         if (drv == NULL)
 508                 return NULL;
 509         os_strlcpy(drv->ifname, ifname, sizeof(drv->ifname));
 510         drv->ctx = ctx;
 511
 512 #ifdef __linux__
 513         drv->pf_sock = socket(PF_PACKET, SOCK_DGRAM, 0);
 514         if (drv->pf_sock < 0)
 515                 perror("socket(PF_PACKET)");
 516 #else /* __linux__ */
 517         drv->pf_sock = -1;
 518 #endif /* __linux__ */
 519
 520         if (wpa_driver_wired_get_ifflags(ifname, &flags) == 0 &&
 521             !(flags & IFF_UP) &&
 522             wpa_driver_wired_set_ifflags(ifname, flags | IFF_UP) == 0) {
 523                 drv->iff_up = 1;
 524         }
 525
 526         if (wired_multicast_membership(drv->pf_sock,
 527                                        if_nametoindex(drv->ifname),
 528                                        pae_group_addr, 1) == 0) {
 529                 wpa_printf(MSG_DEBUG, "%s: Added multicast membership with "
 530                            "packet socket", __func__);
 531                 drv->membership = 1;
 532         } else if (wpa_driver_wired_multi(ifname, pae_group_addr, 1) == 0) {
 533                 wpa_printf(MSG_DEBUG, "%s: Added multicast membership with "
 534                            "SIOCADDMULTI", __func__);
 535                 drv->multi = 1;
 536         } else if (wpa_driver_wired_get_ifflags(ifname, &flags) < 0) {
 537                 wpa_printf(MSG_INFO, "%s: Could not get interface "
 538                            "flags", __func__);
 539                 os_free(drv);
 540                 return NULL;
 541         } else if (flags & IFF_ALLMULTI) {
 542                 wpa_printf(MSG_DEBUG, "%s: Interface is already configured "
 543                            "for multicast", __func__);
 544         } else if (wpa_driver_wired_set_ifflags(ifname,
 545                                                 flags | IFF_ALLMULTI) < 0) {
 546                 wpa_printf(MSG_INFO, "%s: Failed to enable allmulti",
 547                            __func__);
 548                 os_free(drv);
 549                 return NULL;
 550         } else {
 551                 wpa_printf(MSG_DEBUG, "%s: Enabled allmulti mode",
 552                            __func__);
 553                 drv->iff_allmulti = 1;
 554         }
 555
 556         return drv;
 557 }
 558
 559
 560 static void wpa_driver_wired_deinit(void *priv)
 561 {
 562         struct wpa_driver_wired_data *drv = priv;
 563         int flags;
 564
 565         if (drv->membership &&
 566             wired_multicast_membership(drv->pf_sock,
 567                                        if_nametoindex(drv->ifname),
 568                                        pae_group_addr, 0) < 0) {
 569                 wpa_printf(MSG_DEBUG, "%s: Failed to remove PAE multicast "
 570                            "group (PACKET)", __func__);
 571         }
 572
 573         if (drv->multi &&
 574             wpa_driver_wired_multi(drv->ifname, pae_group_addr, 0) < 0) {
 575                 wpa_printf(MSG_DEBUG, "%s: Failed to remove PAE multicast "
 576                            "group (SIOCDELMULTI)", __func__);
 577         }
 578
 579         if (drv->iff_allmulti &&
 580             (wpa_driver_wired_get_ifflags(drv->ifname, &flags) < 0 ||
 581              wpa_driver_wired_set_ifflags(drv->ifname,
 582                                           flags & ~IFF_ALLMULTI) < 0)) {
 583                 wpa_printf(MSG_DEBUG, "%s: Failed to disable allmulti mode",
 584                            __func__);
 585         }
 586
 587         if (drv->iff_up &&
 588             wpa_driver_wired_get_ifflags(drv->ifname, &flags) == 0 &&
 589             (flags & IFF_UP) &&
 590             wpa_driver_wired_set_ifflags(drv->ifname, flags & ~IFF_UP) < 0) {
 591                 wpa_printf(MSG_DEBUG, "%s: Failed to set the interface down",
 592                            __func__);
 593         }
 594
 595         if (drv->pf_sock != -1)
 596                 close(drv->pf_sock);
 597
 598         os_free(drv);
 599 }
 600
 601
 602 const struct wpa_driver_ops wpa_driver_wired_ops = {
 603         .name = "wired",
 604         .desc = "Wired Ethernet driver",
 605         .hapd_init = wired_driver_hapd_init,
 606         .hapd_deinit = wired_driver_hapd_deinit,
 607         .hapd_send_eapol = wired_send_eapol,
 608         .get_ssid = wpa_driver_wired_get_ssid,
 609         .get_bssid = wpa_driver_wired_get_bssid,
 610         .get_capa = wpa_driver_wired_get_capa,
 611         .init = wpa_driver_wired_init,
 612         .deinit = wpa_driver_wired_deinit,
 613 };