contrib/hostapd/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 software may be distributed under the terms of the BSD license.
   7  * See README for more details.
   8  */
   9
  10 #include "includes.h"
  11 #include <sys/ioctl.h>
  12 #include <net/if.h>
  13 #ifdef __linux__
  14 #include <netpacket/packet.h>
  15 #include <net/if_arp.h>
  16 #include <net/if.h>
  17 #endif /* __linux__ */
  18 #if defined(__FreeBSD__) || defined(__DragonFly__) || defined(__FreeBSD_kernel__)
  19 #include <net/if_dl.h>
  20 #include <net/if_media.h>
  21 #endif /* defined(__FreeBSD__) || defined(__DragonFly__) || defined(__FreeBSD_kernel__) */
  22 #ifdef __sun__
  23 #include <sys/sockio.h>
  24 #endif /* __sun__ */
  25
  26 #include "common.h"
  27 #include "eloop.h"
  28 #include "driver.h"
  29
  30 #ifdef _MSC_VER
  31 #pragma pack(push, 1)
  32 #endif /* _MSC_VER */
  33
  34 struct ieee8023_hdr {
  35         u8 dest[6];
  36         u8 src[6];
  37         u16 ethertype;
  38 } STRUCT_PACKED;
  39
  40 #ifdef _MSC_VER
  41 #pragma pack(pop)
  42 #endif /* _MSC_VER */
  43
  44 static const u8 pae_group_addr[ETH_ALEN] =
  45 { 0x01, 0x80, 0xc2, 0x00, 0x00, 0x03 };
  46
  47
  48 struct wpa_driver_wired_data {
  49         char ifname[IFNAMSIZ + 1];
  50         void *ctx;
  51
  52         int sock; /* raw packet socket for driver access */
  53         int dhcp_sock; /* socket for dhcp packets */
  54         int use_pae_group_addr;
  55
  56         int pf_sock;
  57         int membership, multi, iff_allmulti, iff_up;
  58 };
  59
  60
  61 /* TODO: detecting new devices should eventually be changed from using DHCP
  62  * snooping to trigger on any packet from a new layer 2 MAC address, e.g.,
  63  * based on ebtables, etc. */
  64
  65 struct dhcp_message {
  66         u_int8_t op;
  67         u_int8_t htype;
  68         u_int8_t hlen;
  69         u_int8_t hops;
  70         u_int32_t xid;
  71         u_int16_t secs;
  72         u_int16_t flags;
  73         u_int32_t ciaddr;
  74         u_int32_t yiaddr;
  75         u_int32_t siaddr;
  76         u_int32_t giaddr;
  77         u_int8_t chaddr[16];
  78         u_int8_t sname[64];
  79         u_int8_t file[128];
  80         u_int32_t cookie;
  81         u_int8_t options[308]; /* 312 - cookie */
  82 };
  83
  84
  85 static int wired_multicast_membership(int sock, int ifindex,
  86                                       const u8 *addr, int add)
  87 {
  88 #ifdef __linux__
  89         struct packet_mreq mreq;
  90
  91         if (sock < 0)
  92                 return -1;
  93
  94         os_memset(&mreq, 0, sizeof(mreq));
  95         mreq.mr_ifindex = ifindex;
  96         mreq.mr_type = PACKET_MR_MULTICAST;
  97         mreq.mr_alen = ETH_ALEN;
  98         os_memcpy(mreq.mr_address, addr, ETH_ALEN);
  99
 100         if (setsockopt(sock, SOL_PACKET,
 101                        add ? PACKET_ADD_MEMBERSHIP : PACKET_DROP_MEMBERSHIP,
 102                        &mreq, sizeof(mreq)) < 0) {
 103                 perror("setsockopt");
 104                 return -1;
 105         }
 106         return 0;
 107 #else /* __linux__ */
 108         return -1;
 109 #endif /* __linux__ */
 110 }
 111
 112
 113 #ifdef __linux__
 114 static void handle_data(void *ctx, unsigned char *buf, size_t len)
 115 {
 116 #ifdef HOSTAPD
 117         struct ieee8023_hdr *hdr;
 118         u8 *pos, *sa;
 119         size_t left;
 120         union wpa_event_data event;
 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                         os_memset(&event, 0, sizeof(event));
 137                         event.new_sta.addr = sa;
 138                         wpa_supplicant_event(ctx, EVENT_NEW_STA, &event);
 139
 140                         pos = (u8 *) (hdr + 1);
 141                         left = len - sizeof(*hdr);
 142                         drv_event_eapol_rx(ctx, sa, pos, left);
 143                 break;
 144
 145         default:
 146                 wpa_printf(MSG_DEBUG, "Unknown ethertype 0x%04x in data frame",
 147                            ntohs(hdr->ethertype));
 148                 break;
 149         }
 150 #endif /* HOSTAPD */
 151 }
 152
 153
 154 static void handle_read(int sock, void *eloop_ctx, void *sock_ctx)
 155 {
 156         int len;
 157         unsigned char buf[3000];
 158
 159         len = recv(sock, buf, sizeof(buf), 0);
 160         if (len < 0) {
 161                 perror("recv");
 162                 return;
 163         }
 164
 165         handle_data(eloop_ctx, buf, len);
 166 }
 167
 168
 169 static void handle_dhcp(int sock, void *eloop_ctx, void *sock_ctx)
 170 {
 171         int len;
 172         unsigned char buf[3000];
 173         struct dhcp_message *msg;
 174         u8 *mac_address;
 175         union wpa_event_data event;
 176
 177         len = recv(sock, buf, sizeof(buf), 0);
 178         if (len < 0) {
 179                 perror("recv");
 180                 return;
 181         }
 182
 183         /* must contain at least dhcp_message->chaddr */
 184         if (len < 44) {
 185                 wpa_printf(MSG_MSGDUMP, "handle_dhcp: too short (%d)", len);
 186                 return;
 187         }
 188
 189         msg = (struct dhcp_message *) buf;
 190         mac_address = (u8 *) &(msg->chaddr);
 191
 192         wpa_printf(MSG_MSGDUMP, "Got DHCP broadcast packet from " MACSTR,
 193                    MAC2STR(mac_address));
 194
 195         os_memset(&event, 0, sizeof(event));
 196         event.new_sta.addr = mac_address;
 197         wpa_supplicant_event(eloop_ctx, EVENT_NEW_STA, &event);
 198 }
 199 #endif /* __linux__ */
 200
 201
 202 static int wired_init_sockets(struct wpa_driver_wired_data *drv, u8 *own_addr)
 203 {
 204 #ifdef __linux__
 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 #else /* __linux__ */
 305         return -1;
 306 #endif /* __linux__ */
 307 }
 308
 309
 310 static int wired_send_eapol(void *priv, const u8 *addr,
 311                             const u8 *data, size_t data_len, int encrypt,
 312                             const u8 *own_addr, u32 flags)
 313 {
 314         struct wpa_driver_wired_data *drv = priv;
 315         struct ieee8023_hdr *hdr;
 316         size_t len;
 317         u8 *pos;
 318         int res;
 319
 320         len = sizeof(*hdr) + data_len;
 321         hdr = os_zalloc(len);
 322         if (hdr == NULL) {
 323                 printf("malloc() failed for wired_send_eapol(len=%lu)\n",
 324                        (unsigned long) len);
 325                 return -1;
 326         }
 327
 328         os_memcpy(hdr->dest, drv->use_pae_group_addr ? pae_group_addr : addr,
 329                   ETH_ALEN);
 330         os_memcpy(hdr->src, own_addr, ETH_ALEN);
 331         hdr->ethertype = htons(ETH_P_PAE);
 332
 333         pos = (u8 *) (hdr + 1);
 334         os_memcpy(pos, data, data_len);
 335
 336         res = send(drv->sock, (u8 *) hdr, len, 0);
 337         os_free(hdr);
 338
 339         if (res < 0) {
 340                 perror("wired_send_eapol: send");
 341                 printf("wired_send_eapol - packet len: %lu - failed\n",
 342                        (unsigned long) len);
 343         }
 344
 345         return res;
 346 }
 347
 348
 349 static void * wired_driver_hapd_init(struct hostapd_data *hapd,
 350                                      struct wpa_init_params *params)
 351 {
 352         struct wpa_driver_wired_data *drv;
 353
 354         drv = os_zalloc(sizeof(struct wpa_driver_wired_data));
 355         if (drv == NULL) {
 356                 printf("Could not allocate memory for wired driver data\n");
 357                 return NULL;
 358         }
 359
 360         drv->ctx = hapd;
 361         os_strlcpy(drv->ifname, params->ifname, sizeof(drv->ifname));
 362         drv->use_pae_group_addr = params->use_pae_group_addr;
 363
 364         if (wired_init_sockets(drv, params->own_addr)) {
 365                 os_free(drv);
 366                 return NULL;
 367         }
 368
 369         return drv;
 370 }
 371
 372
 373 static void wired_driver_hapd_deinit(void *priv)
 374 {
 375         struct wpa_driver_wired_data *drv = priv;
 376
 377         if (drv->sock >= 0)
 378                 close(drv->sock);
 379
 380         if (drv->dhcp_sock >= 0)
 381                 close(drv->dhcp_sock);
 382
 383         os_free(drv);
 384 }
 385
 386
 387 static int wpa_driver_wired_get_ssid(void *priv, u8 *ssid)
 388 {
 389         ssid[0] = 0;
 390         return 0;
 391 }
 392
 393
 394 static int wpa_driver_wired_get_bssid(void *priv, u8 *bssid)
 395 {
 396         /* Report PAE group address as the "BSSID" for wired connection. */
 397         os_memcpy(bssid, pae_group_addr, ETH_ALEN);
 398         return 0;
 399 }
 400
 401
 402 static int wpa_driver_wired_get_capa(void *priv, struct wpa_driver_capa *capa)
 403 {
 404         os_memset(capa, 0, sizeof(*capa));
 405         capa->flags = WPA_DRIVER_FLAGS_WIRED;
 406         return 0;
 407 }
 408
 409
 410 static int wpa_driver_wired_get_ifflags(const char *ifname, int *flags)
 411 {
 412         struct ifreq ifr;
 413         int s;
 414
 415         s = socket(PF_INET, SOCK_DGRAM, 0);
 416         if (s < 0) {
 417                 perror("socket");
 418                 return -1;
 419         }
 420
 421         os_memset(&ifr, 0, sizeof(ifr));
 422         os_strlcpy(ifr.ifr_name, ifname, IFNAMSIZ);
 423         if (ioctl(s, SIOCGIFFLAGS, (caddr_t) &ifr) < 0) {
 424                 perror("ioctl[SIOCGIFFLAGS]");
 425                 close(s);
 426                 return -1;
 427         }
 428         close(s);
 429         *flags = ifr.ifr_flags & 0xffff;
 430         return 0;
 431 }
 432
 433
 434 static int wpa_driver_wired_set_ifflags(const char *ifname, int flags)
 435 {
 436         struct ifreq ifr;
 437         int s;
 438
 439         s = socket(PF_INET, SOCK_DGRAM, 0);
 440         if (s < 0) {
 441                 perror("socket");
 442                 return -1;
 443         }
 444
 445         os_memset(&ifr, 0, sizeof(ifr));
 446         os_strlcpy(ifr.ifr_name, ifname, IFNAMSIZ);
 447         ifr.ifr_flags = flags & 0xffff;
 448         if (ioctl(s, SIOCSIFFLAGS, (caddr_t) &ifr) < 0) {
 449                 perror("ioctl[SIOCSIFFLAGS]");
 450                 close(s);
 451                 return -1;
 452         }
 453         close(s);
 454         return 0;
 455 }
 456
 457
 458 #if defined(__FreeBSD__) || defined(__DragonFly__) || defined(__FreeBSD_kernel__)
 459 static int wpa_driver_wired_get_ifstatus(const char *ifname, int *status)
 460 {
 461         struct ifmediareq ifmr;
 462         int s;
 463
 464         s = socket(PF_INET, SOCK_DGRAM, 0);
 465         if (s < 0) {
 466                 perror("socket");
 467                 return -1;
 468         }
 469
 470         os_memset(&ifmr, 0, sizeof(ifmr));
 471         os_strlcpy(ifmr.ifm_name, ifname, IFNAMSIZ);
 472         if (ioctl(s, SIOCGIFMEDIA, (caddr_t) &ifmr) < 0) {
 473                 perror("ioctl[SIOCGIFMEDIA]");
 474                 close(s);
 475                 return -1;
 476         }
 477         close(s);
 478         *status = (ifmr.ifm_status & (IFM_ACTIVE | IFM_AVALID)) ==
 479                 (IFM_ACTIVE | IFM_AVALID);
 480
 481         return 0;
 482 }
 483 #endif /* defined(__FreeBSD__) || defined(__DragonFly__) || defined(FreeBSD_kernel__) */
 484
 485
 486 static int wpa_driver_wired_multi(const char *ifname, const u8 *addr, int add)
 487 {
 488         struct ifreq ifr;
 489         int s;
 490
 491 #ifdef __sun__
 492         return -1;
 493 #endif /* __sun__ */
 494
 495         s = socket(PF_INET, SOCK_DGRAM, 0);
 496         if (s < 0) {
 497                 perror("socket");
 498                 return -1;
 499         }
 500
 501         os_memset(&ifr, 0, sizeof(ifr));
 502         os_strlcpy(ifr.ifr_name, ifname, IFNAMSIZ);
 503 #ifdef __linux__
 504         ifr.ifr_hwaddr.sa_family = AF_UNSPEC;
 505         os_memcpy(ifr.ifr_hwaddr.sa_data, addr, ETH_ALEN);
 506 #endif /* __linux__ */
 507 #if defined(__FreeBSD__) || defined(__DragonFly__) || defined(__FreeBSD_kernel__)
 508         {
 509                 struct sockaddr_dl *dlp;
 510                 dlp = (struct sockaddr_dl *) &ifr.ifr_addr;
 511                 dlp->sdl_len = sizeof(struct sockaddr_dl);
 512                 dlp->sdl_family = AF_LINK;
 513                 dlp->sdl_index = 0;
 514                 dlp->sdl_nlen = 0;
 515                 dlp->sdl_alen = ETH_ALEN;
 516                 dlp->sdl_slen = 0;
 517                 os_memcpy(LLADDR(dlp), addr, ETH_ALEN);
 518         }
 519 #endif /* defined(__FreeBSD__) || defined(__DragonFly__) || defined(FreeBSD_kernel__) */
 520 #if defined(__NetBSD__) || defined(__OpenBSD__) || defined(__APPLE__)
 521         {
 522                 struct sockaddr *sap;
 523                 sap = (struct sockaddr *) &ifr.ifr_addr;
 524                 sap->sa_len = sizeof(struct sockaddr);
 525                 sap->sa_family = AF_UNSPEC;
 526                 os_memcpy(sap->sa_data, addr, ETH_ALEN);
 527         }
 528 #endif /* defined(__NetBSD__) || defined(__OpenBSD__) || defined(__APPLE__) */
 529
 530         if (ioctl(s, add ? SIOCADDMULTI : SIOCDELMULTI, (caddr_t) &ifr) < 0) {
 531                 perror("ioctl[SIOC{ADD/DEL}MULTI]");
 532                 close(s);
 533                 return -1;
 534         }
 535         close(s);
 536         return 0;
 537 }
 538
 539
 540 static void * wpa_driver_wired_init(void *ctx, const char *ifname)
 541 {
 542         struct wpa_driver_wired_data *drv;
 543         int flags;
 544
 545         drv = os_zalloc(sizeof(*drv));
 546         if (drv == NULL)
 547                 return NULL;
 548         os_strlcpy(drv->ifname, ifname, sizeof(drv->ifname));
 549         drv->ctx = ctx;
 550
 551 #ifdef __linux__
 552         drv->pf_sock = socket(PF_PACKET, SOCK_DGRAM, 0);
 553         if (drv->pf_sock < 0)
 554                 perror("socket(PF_PACKET)");
 555 #else /* __linux__ */
 556         drv->pf_sock = -1;
 557 #endif /* __linux__ */
 558
 559         if (wpa_driver_wired_get_ifflags(ifname, &flags) == 0 &&
 560             !(flags & IFF_UP) &&
 561             wpa_driver_wired_set_ifflags(ifname, flags | IFF_UP) == 0) {
 562                 drv->iff_up = 1;
 563         }
 564
 565         if (wired_multicast_membership(drv->pf_sock,
 566                                        if_nametoindex(drv->ifname),
 567                                        pae_group_addr, 1) == 0) {
 568                 wpa_printf(MSG_DEBUG, "%s: Added multicast membership with "
 569                            "packet socket", __func__);
 570                 drv->membership = 1;
 571         } else if (wpa_driver_wired_multi(ifname, pae_group_addr, 1) == 0) {
 572                 wpa_printf(MSG_DEBUG, "%s: Added multicast membership with "
 573                            "SIOCADDMULTI", __func__);
 574                 drv->multi = 1;
 575         } else if (wpa_driver_wired_get_ifflags(ifname, &flags) < 0) {
 576                 wpa_printf(MSG_INFO, "%s: Could not get interface "
 577                            "flags", __func__);
 578                 os_free(drv);
 579                 return NULL;
 580         } else if (flags & IFF_ALLMULTI) {
 581                 wpa_printf(MSG_DEBUG, "%s: Interface is already configured "
 582                            "for multicast", __func__);
 583         } else if (wpa_driver_wired_set_ifflags(ifname,
 584                                                 flags | IFF_ALLMULTI) < 0) {
 585                 wpa_printf(MSG_INFO, "%s: Failed to enable allmulti",
 586                            __func__);
 587                 os_free(drv);
 588                 return NULL;
 589         } else {
 590                 wpa_printf(MSG_DEBUG, "%s: Enabled allmulti mode",
 591                            __func__);
 592                 drv->iff_allmulti = 1;
 593         }
 594 #if defined(__FreeBSD__) || defined(__DragonFly__) || defined(__FreeBSD_kernel__)
 595         {
 596                 int status;
 597                 wpa_printf(MSG_DEBUG, "%s: waiting for link to become active",
 598                            __func__);
 599                 while (wpa_driver_wired_get_ifstatus(ifname, &status) == 0 &&
 600                        status == 0)
 601                         sleep(1);
 602         }
 603 #endif /* defined(__FreeBSD__) || defined(__DragonFly__) || defined(FreeBSD_kernel__) */
 604
 605         return drv;
 606 }
 607
 608
 609 static void wpa_driver_wired_deinit(void *priv)
 610 {
 611         struct wpa_driver_wired_data *drv = priv;
 612         int flags;
 613
 614         if (drv->membership &&
 615             wired_multicast_membership(drv->pf_sock,
 616                                        if_nametoindex(drv->ifname),
 617                                        pae_group_addr, 0) < 0) {
 618                 wpa_printf(MSG_DEBUG, "%s: Failed to remove PAE multicast "
 619                            "group (PACKET)", __func__);
 620         }
 621
 622         if (drv->multi &&
 623             wpa_driver_wired_multi(drv->ifname, pae_group_addr, 0) < 0) {
 624                 wpa_printf(MSG_DEBUG, "%s: Failed to remove PAE multicast "
 625                            "group (SIOCDELMULTI)", __func__);
 626         }
 627
 628         if (drv->iff_allmulti &&
 629             (wpa_driver_wired_get_ifflags(drv->ifname, &flags) < 0 ||
 630              wpa_driver_wired_set_ifflags(drv->ifname,
 631                                           flags & ~IFF_ALLMULTI) < 0)) {
 632                 wpa_printf(MSG_DEBUG, "%s: Failed to disable allmulti mode",
 633                            __func__);
 634         }
 635
 636         if (drv->iff_up &&
 637             wpa_driver_wired_get_ifflags(drv->ifname, &flags) == 0 &&
 638             (flags & IFF_UP) &&
 639             wpa_driver_wired_set_ifflags(drv->ifname, flags & ~IFF_UP) < 0) {
 640                 wpa_printf(MSG_DEBUG, "%s: Failed to set the interface down",
 641                            __func__);
 642         }
 643
 644         if (drv->pf_sock != -1)
 645                 close(drv->pf_sock);
 646
 647         os_free(drv);
 648 }
 649
 650
 651 const struct wpa_driver_ops wpa_driver_wired_ops = {
 652         .name = "wired",
 653         .desc = "Wired Ethernet driver",
 654         .hapd_init = wired_driver_hapd_init,
 655         .hapd_deinit = wired_driver_hapd_deinit,
 656         .hapd_send_eapol = wired_send_eapol,
 657         .get_ssid = wpa_driver_wired_get_ssid,
 658         .get_bssid = wpa_driver_wired_get_bssid,
 659         .get_capa = wpa_driver_wired_get_capa,
 660         .init = wpa_driver_wired_init,
 661         .deinit = wpa_driver_wired_deinit,
 662 };