static void wpa_priv_cmd_l2_register(struct wpa_priv_interface *iface, struct sockaddr_un *from, void *buf, size_t len) { int *reg_cmd = buf; u8 own_addr[ETH_ALEN]; int res; u16 proto; if (len != 2 * sizeof(int)) { wpa_printf(MSG_DEBUG, "Invalid l2_register length %lu", (unsigned long) len); return; } proto = reg_cmd[0]; if (proto != ETH_P_EAPOL && proto != ETH_P_RSN_PREAUTH) { wpa_printf(MSG_DEBUG, "Refused l2_packet connection for " "ethertype 0x%x", proto); return; } if (iface->l2) { wpa_printf(MSG_DEBUG, "Cleaning up forgotten l2_packet " "instance"); l2_packet_deinit(iface->l2); iface->l2 = NULL; } os_memcpy(&iface->l2_addr, from, sizeof(iface->l2_addr)); iface->l2 = l2_packet_init(iface->ifname, NULL, proto, wpa_priv_l2_rx, iface, reg_cmd[1]); if (iface->l2 == NULL) { wpa_printf(MSG_DEBUG, "Failed to initialize l2_packet " "instance for protocol %d", proto); return; } if (l2_packet_get_own_addr(iface->l2, own_addr) < 0) { wpa_printf(MSG_DEBUG, "Failed to get own address from " "l2_packet"); l2_packet_deinit(iface->l2); iface->l2 = NULL; return; } res = sendto(iface->fd, own_addr, ETH_ALEN, 0, (struct sockaddr *) from, sizeof(*from)); wpa_printf(MSG_DEBUG, "L2 registration: res=%d", res); }
static void wext_deinit(void *priv) { struct wext_driver_data *drv = priv; (void) wext_set_iface_flags(drv, 0); if (drv->ioctl_sock >= 0) close(drv->ioctl_sock); if (drv->sock_recv != NULL && drv->sock_recv != drv->sock_xmit) l2_packet_deinit(drv->sock_recv); if (drv->sock_xmit != NULL) l2_packet_deinit(drv->sock_xmit); free(drv); }
void hostapd_deinit_wpa(struct hostapd_data *hapd) { rsn_preauth_iface_deinit(hapd); if (hapd->wpa_auth) { wpa_deinit(hapd->wpa_auth); hapd->wpa_auth = NULL; if (hostapd_set_privacy(hapd, 0)) { wpa_printf(MSG_DEBUG, "Could not disable " "PrivacyInvoked for interface %s", hapd->conf->iface); } if (hostapd_set_generic_elem(hapd, (u8 *) "", 0)) { wpa_printf(MSG_DEBUG, "Could not remove generic " "information element from interface %s", hapd->conf->iface); } } ieee802_1x_deinit(hapd); #ifdef CONFIG_IEEE80211R l2_packet_deinit(hapd->l2); #endif /* CONFIG_IEEE80211R */ }
static void wpa_supplicant_event_interface_status(struct wpa_supplicant *wpa_s, union wpa_event_data *data) { if (os_strcmp(wpa_s->ifname, data->interface_status.ifname) != 0) return; switch (data->interface_status.ievent) { case EVENT_INTERFACE_ADDED: if (!wpa_s->interface_removed) break; wpa_s->interface_removed = 0; wpa_printf(MSG_DEBUG, "Configured interface was added."); if (wpa_supplicant_driver_init(wpa_s) < 0) { wpa_printf(MSG_INFO, "Failed to initialize the driver " "after interface was added."); } break; case EVENT_INTERFACE_REMOVED: wpa_printf(MSG_DEBUG, "Configured interface was removed."); wpa_s->interface_removed = 1; wpa_supplicant_mark_disassoc(wpa_s); l2_packet_deinit(wpa_s->l2); wpa_s->l2 = NULL; break; } }
static void wpa_supplicant_event_interface_status(struct wpa_supplicant *wpa_s, union wpa_event_data *data) { if (os_strcmp(wpa_s->ifname, data->interface_status.ifname) != 0) return; switch (data->interface_status.ievent) { case EVENT_INTERFACE_ADDED: if (!wpa_s->interface_removed) break; wpa_s->interface_removed = 0; wpa_printf(MSG_DEBUG, "Configured interface was added."); if (wpa_supplicant_driver_init(wpa_s) < 0) { wpa_printf(MSG_INFO, "Failed to initialize the driver " "after interface was added."); } break; case EVENT_INTERFACE_REMOVED: wpa_printf(MSG_DEBUG, "Configured interface was removed."); wpa_s->interface_removed = 1; wpa_supplicant_mark_disassoc(wpa_s); l2_packet_deinit(wpa_s->l2); wpa_s->l2 = NULL; #ifdef CONFIG_TERMINATE_ONLASTIF /* check if last interface */ if (!any_interfaces(wpa_s->global->ifaces)) eloop_terminate(); #endif /* CONFIG_TERMINATE_ONLASTIF */ break; } }
static void atheros_deinit(void *priv) { struct atheros_driver_data *drv = priv; netlink_deinit(drv->netlink); (void) linux_set_iface_flags(drv->ioctl_sock, drv->iface, 0); if (drv->ioctl_sock >= 0) close(drv->ioctl_sock); if (drv->sock_recv != NULL && drv->sock_recv != drv->sock_xmit) l2_packet_deinit(drv->sock_recv); if (drv->sock_xmit != NULL) l2_packet_deinit(drv->sock_xmit); if (drv->sock_raw) l2_packet_deinit(drv->sock_raw); free(drv); }
/** * rsn_preauth_deinit - Abort RSN pre-authentication * @sm: Pointer to WPA state machine data from wpa_sm_init() * * This function aborts the current RSN pre-authentication (if one is started) * and frees resources allocated for it. */ void rsn_preauth_deinit(struct wpa_sm *sm) { if (sm == NULL || !sm->preauth_eapol) return; eloop_cancel_timeout(rsn_preauth_timeout, sm, NULL); eapol_sm_deinit(sm->preauth_eapol); sm->preauth_eapol = NULL; os_memset(sm->preauth_bssid, 0, ETH_ALEN); l2_packet_deinit(sm->l2_preauth); sm->l2_preauth = NULL; if (sm->l2_preauth_br) { l2_packet_deinit(sm->l2_preauth_br); sm->l2_preauth_br = NULL; } }
static void wpa_priv_cmd_l2_unregister(struct wpa_priv_interface *iface, struct sockaddr_un *from) { if (iface->l2) { l2_packet_deinit(iface->l2); iface->l2 = NULL; } }
static void wpa_priv_cmd_register(struct wpa_priv_interface *iface, struct sockaddr_un *from) { if (iface->drv_priv) { wpa_printf(MSG_DEBUG, "Cleaning up forgotten driver instance"); if (iface->driver->deinit) iface->driver->deinit(iface->drv_priv); iface->drv_priv = NULL; if (iface->drv_global_priv) { iface->driver->global_deinit(iface->drv_global_priv); iface->drv_global_priv = NULL; } iface->wpas_registered = 0; } if (iface->l2) { wpa_printf(MSG_DEBUG, "Cleaning up forgotten l2_packet " "instance"); l2_packet_deinit(iface->l2); iface->l2 = NULL; } if (iface->driver->init2) { if (iface->driver->global_init) { iface->drv_global_priv = iface->driver->global_init(); if (!iface->drv_global_priv) { wpa_printf(MSG_INFO, "Failed to initialize driver global context"); return; } } else { iface->drv_global_priv = NULL; } iface->drv_priv = iface->driver->init2(iface, iface->ifname, iface->drv_global_priv); } else if (iface->driver->init) { iface->drv_priv = iface->driver->init(iface, iface->ifname); } else { return; } if (iface->drv_priv == NULL) { wpa_printf(MSG_DEBUG, "Failed to initialize driver wrapper"); return; } wpa_printf(MSG_DEBUG, "Driver wrapper '%s' initialized for interface " "'%s'", iface->driver_name, iface->ifname); os_memcpy(&iface->drv_addr, from, sizeof(iface->drv_addr)); iface->wpas_registered = 1; if (iface->driver->set_param && iface->driver->set_param(iface->drv_priv, NULL) < 0) { wpa_printf(MSG_ERROR, "Driver interface rejected param"); } }
static void ar6000_deinit(void *priv) { struct ar6000_driver_data *drv = priv; netlink_deinit(drv->netlink); (void) linux_set_iface_flags(drv->ioctl_sock, drv->iface, 0); if (drv->ioctl_sock >= 0) close(drv->ioctl_sock); if (drv->sock_recv != NULL && drv->sock_recv != drv->sock_xmit) l2_packet_deinit(drv->sock_recv); if (drv->sock_xmit != NULL) l2_packet_deinit(drv->sock_xmit); if (drv->sock_raw) l2_packet_deinit(drv->sock_raw); wpabuf_free(drv->wpa_ie); wpabuf_free(drv->wps_beacon_ie); wpabuf_free(drv->wps_probe_resp_ie); free(drv); }
static void * bsd_init(struct hostapd_data *hapd, struct wpa_init_params *params) { struct bsd_driver_data *drv; drv = os_zalloc(sizeof(struct bsd_driver_data)); if (drv == NULL) { printf("Could not allocate memory for bsd driver data\n"); goto bad; } drv->hapd = hapd; drv->sock = socket(PF_INET, SOCK_DGRAM, 0); if (drv->sock < 0) { perror("socket[PF_INET,SOCK_DGRAM]"); goto bad; } os_strlcpy(drv->ifname, params->ifname, sizeof(drv->ifname)); drv->sock_xmit = l2_packet_init(drv->ifname, NULL, ETH_P_EAPOL, handle_read, drv, 0); if (drv->sock_xmit == NULL) goto bad; if (l2_packet_get_own_addr(drv->sock_xmit, params->own_addr)) goto bad; /* mark down during setup */ if (bsd_ctrl_iface(drv, 0) < 0) goto bad; drv->route = socket(PF_ROUTE, SOCK_RAW, 0); if (drv->route < 0) { perror("socket(PF_ROUTE,SOCK_RAW)"); goto bad; } eloop_register_read_sock(drv->route, bsd_wireless_event_receive, drv, NULL); if (bsd_set_mediaopt(drv, IFM_OMASK, IFM_IEEE80211_HOSTAP) < 0) { wpa_printf(MSG_ERROR, "%s: failed to set operation mode", __func__); goto bad; } return drv; bad: if (drv->sock_xmit != NULL) l2_packet_deinit(drv->sock_xmit); if (drv->sock >= 0) close(drv->sock); if (drv != NULL) os_free(drv); return NULL; }
static void rtl871x_driver_deinit_ops(void *priv) { //struct iwreq iwr; struct rtl871x_driver_data *drv = priv; //back to INFRA MODE when exit. /* memset(&iwr, 0, sizeof(iwr)); os_strlcpy(iwr.ifr_name, drv->iface, IFNAMSIZ); iwr.u.mode = IW_MODE_INFRA; if (ioctl(drv->ioctl_sock, SIOCSIWMODE, &iwr) < 0) { perror("ioctl[SIOCSIWMODE]"); } */ rtl871x_set_mode(drv, IW_MODE_INFRA); if (drv->ioctl_sock >= 0) close(drv->ioctl_sock); if (drv->l2_sock_recv != NULL && drv->l2_sock_recv != drv->l2_sock) l2_packet_deinit(drv->l2_sock_recv); if(drv->l2_sock) l2_packet_deinit(drv->l2_sock); //if (drv->sock_xmit != NULL) // l2_packet_deinit(drv->sock_xmit); #ifdef CONFIG_MGNT_L2SOCK if (drv->mgnt_l2_sock) l2_packet_deinit(drv->mgnt_l2_sock); #else if (drv->mgnt_sock >= 0) close(drv->mgnt_sock); #endif os_free(drv); }
static void bsd_deinit(void *priv) { struct bsd_driver_data *drv = priv; (void) bsd_set_iface_flags(drv, 0); if (drv->ioctl_sock >= 0) close(drv->ioctl_sock); if (drv->sock_xmit != NULL) l2_packet_deinit(drv->sock_xmit); free(drv); }
void rsn_preauth_deinit(struct wpa_supplicant *wpa_s) { if (!wpa_s->preauth_eapol) return; eloop_cancel_timeout(rsn_preauth_timeout, wpa_s, NULL); eapol_sm_deinit(wpa_s->preauth_eapol); wpa_s->preauth_eapol = NULL; memset(wpa_s->preauth_bssid, 0, ETH_ALEN); l2_packet_deinit(wpa_s->l2_preauth); wpa_s->l2_preauth = NULL; }
void rsn_preauth_iface_deinit(struct asd_data *wasd) { struct rsn_preauth_interface *piface, *prev; piface = wasd->preauth_iface; wasd->preauth_iface = NULL; while (piface) { prev = piface; piface = piface->next; l2_packet_deinit(prev->l2); os_free(prev->ifname); os_free(prev); } }
void rsn_preauth_iface_deinit(struct hostapd_data *hapd) { struct rsn_preauth_interface *piface, *prev; piface = hapd->preauth_iface; hapd->preauth_iface = NULL; while (piface) { prev = piface; piface = piface->next; l2_packet_deinit(prev->l2); free(prev->ifname); free(prev); } }
static void wpa_supplicant_cleanup(struct wpa_supplicant *wpa_s) { l2_packet_deinit(wpa_s->l2); wpa_s->l2 = NULL; if (wpa_s->conf != NULL) { wpa_config_free(wpa_s->conf); wpa_s->conf = NULL; } free(wpa_s->ap_wpa_ie); pmksa_candidate_free(wpa_s); pmksa_cache_free(wpa_s); }
static void wpa_init_conf(struct wpa_supplicant *wpa_s, const char *ifname) { struct l2_packet_data *l2; struct wpa_sm_ctx *ctx; os_memset(&dummy_driver, 0, sizeof(dummy_driver)); wpa_s->driver = &dummy_driver; ctx = os_zalloc(sizeof(*ctx)); assert(ctx != NULL); ctx->ctx = wpa_s; ctx->set_state = _wpa_supplicant_set_state; ctx->get_state = _wpa_supplicant_get_state; ctx->req_scan = _wpa_supplicant_req_scan; ctx->deauthenticate = _wpa_supplicant_deauthenticate; ctx->disassociate = _wpa_supplicant_disassociate; ctx->set_key = wpa_supplicant_set_key; ctx->scan = wpa_supplicant_scan; ctx->get_ssid = _wpa_supplicant_get_ssid; ctx->get_bssid = wpa_supplicant_get_bssid; ctx->ether_send = wpa_ether_send; ctx->get_beacon_ie = wpa_supplicant_get_beacon_ie; ctx->alloc_eapol = _wpa_alloc_eapol; ctx->cancel_auth_timeout = _wpa_supplicant_cancel_auth_timeout; ctx->add_pmkid = wpa_supplicant_add_pmkid; ctx->remove_pmkid = wpa_supplicant_remove_pmkid; ctx->set_config_blob = wpa_supplicant_set_config_blob; ctx->get_config_blob = wpa_supplicant_get_config_blob; ctx->mlme_setprotection = wpa_supplicant_mlme_setprotection; wpa_s->wpa = wpa_sm_init(ctx); assert(wpa_s->wpa != NULL); wpa_sm_set_param(wpa_s->wpa, WPA_PARAM_PROTO, WPA_PROTO_RSN); os_strncpy(wpa_s->ifname, ifname, sizeof(wpa_s->ifname)); wpa_sm_set_ifname(wpa_s->wpa, wpa_s->ifname, NULL); l2 = l2_packet_init(wpa_s->ifname, NULL, ETH_P_RSN_PREAUTH, NULL, NULL, 0); assert(l2 != NULL); if (l2_packet_get_own_addr(l2, wpa_s->own_addr)) { wpa_printf(MSG_WARNING, "Failed to get own L2 address\n"); exit(-1); } l2_packet_deinit(l2); wpa_sm_set_own_addr(wpa_s->wpa, wpa_s->own_addr); }
static void wpa_driver_roboswitch_deinit(void *priv) { struct wpa_driver_roboswitch_data *drv = priv; if (drv->l2) { l2_packet_deinit(drv->l2); drv->l2 = NULL; } if (wpa_driver_roboswitch_leave(drv, drv->ports, pae_group_addr) < 0) { wpa_printf(MSG_DEBUG, "%s: Unable to leave PAE group", __func__); } close(drv->fd); os_free(drv); }
static void bsd_deinit(void *priv) { struct bsd_driver_data *drv = priv; if (drv->route >= 0) { eloop_unregister_read_sock(drv->route); close(drv->route); } bsd_ctrl_iface(drv, 0); if (drv->sock >= 0) close(drv->sock); if (drv->sock_xmit != NULL) l2_packet_deinit(drv->sock_xmit); os_free(drv); }
static void wpa_priv_interface_deinit(struct wpa_priv_interface *iface) { if (iface->drv_priv && iface->driver->deinit) iface->driver->deinit(iface->drv_priv); if (iface->fd >= 0) { eloop_unregister_read_sock(iface->fd); close(iface->fd); unlink(iface->sock_name); } if (iface->l2) l2_packet_deinit(iface->l2); os_free(iface->ifname); os_free(iface->driver_name); os_free(iface->sock_name); os_free(iface); }
static int bsd_init(struct hostapd_data *hapd) { struct bsd_driver_data *drv; drv = malloc(sizeof(struct bsd_driver_data)); if (drv == NULL) { printf("Could not allocate memory for bsd driver data\n"); goto bad; } memset(drv, 0, sizeof(*drv)); drv->ops = bsd_driver_ops; drv->hapd = hapd; drv->ioctl_sock = socket(PF_INET, SOCK_DGRAM, 0); if (drv->ioctl_sock < 0) { perror("socket[PF_INET,SOCK_DGRAM]"); goto bad; } memcpy(drv->iface, hapd->conf->iface, sizeof(drv->iface)); drv->sock_xmit = l2_packet_init(drv->iface, NULL, ETH_P_EAPOL, handle_read, drv); if (drv->sock_xmit == NULL) goto bad; if (l2_packet_get_own_addr(drv->sock_xmit, hapd->own_addr)) goto bad; bsd_set_iface_flags(drv, 0); /* mark down during setup */ hapd->driver = &drv->ops; return 0; bad: if (drv->sock_xmit != NULL) l2_packet_deinit(drv->sock_xmit); if (drv->ioctl_sock >= 0) close(drv->ioctl_sock); if (drv != NULL) free(drv); return -1; }
static void wpa_driver_bsd_deinit(void *priv) { struct bsd_driver_data *drv = priv; wpa_driver_bsd_set_wpa(drv, 0); eloop_unregister_read_sock(drv->route); /* NB: mark interface down */ bsd_ctrl_iface(drv, 0); wpa_driver_bsd_set_wpa_internal(drv, drv->prev_wpa, drv->prev_privacy); if (set80211param(drv, IEEE80211_IOC_ROAMING, drv->prev_roaming) < 0) wpa_printf(MSG_DEBUG, "%s: failed to restore roaming state", __func__); if (drv->sock_xmit != NULL) l2_packet_deinit(drv->sock_xmit); (void) close(drv->route); /* ioctl socket */ (void) close(drv->sock); /* event socket */ os_free(drv); }
void dhcp_snoop_deinit(struct hostapd_data *hapd) { l2_packet_deinit(hapd->sock_dhcp); }
void ndisc_snoop_deinit(struct hostapd_data *hapd) { l2_packet_deinit(hapd->sock_ndisc); hapd->sock_ndisc = NULL; }
static void *rtl871x_driver_init_ops(struct hostapd_data *hapd, struct wpa_init_params *params) { struct rtl871x_driver_data *drv; struct ifreq ifr; char ifrn_name[IFNAMSIZ + 1]; // for mgnt_l2_sock/mgnt_sock char brname[IFNAMSIZ]; drv = os_zalloc(sizeof(struct rtl871x_driver_data)); if (drv == NULL) { printf("Could not allocate memory for rtl871x driver data\n"); return NULL; } drv->hapd = hapd; drv->ioctl_sock = socket(PF_INET, SOCK_DGRAM, 0); if (drv->ioctl_sock < 0) { perror("socket[PF_INET,SOCK_DGRAM]"); goto bad; } os_memcpy(drv->iface, params->ifname, sizeof(drv->iface)); linux_set_iface_flags(drv->ioctl_sock, drv->iface, 1); // set interface up os_memset(&ifr, 0, sizeof(ifr)); os_strlcpy(ifr.ifr_name, drv->iface, sizeof(ifr.ifr_name)); if (ioctl(drv->ioctl_sock, SIOCGIFINDEX, &ifr) != 0) { perror("ioctl(SIOCGIFINDEX)"); goto bad; } drv->ifindex = ifr.ifr_ifindex; printf("drv->ifindex=%d\n", drv->ifindex); drv->l2_sock = l2_packet_init(drv->iface, NULL, ETH_P_EAPOL, rtl871x_handle_read, drv, 1); if (drv->l2_sock == NULL) goto bad; if (l2_packet_get_own_addr(drv->l2_sock, params->own_addr)) goto bad; if (params->bridge[0]) { wpa_printf(MSG_DEBUG, "Configure bridge %s for EAPOL traffic.", params->bridge[0]); drv->l2_sock_recv = l2_packet_init(params->bridge[0], NULL, ETH_P_EAPOL, rtl871x_handle_read, drv, 1); if (drv->l2_sock_recv == NULL) { drv->l2_sock_recv = drv->l2_sock; printf("no br0 interface , let l2_sock_recv==l2_sock_xmit=0x%p\n", drv->l2_sock); } } else if (linux_br_get(brname, drv->iface) == 0) { wpa_printf(MSG_DEBUG, "Interface in bridge %s; configure for " "EAPOL receive", brname); drv->l2_sock_recv = l2_packet_init(brname, NULL, ETH_P_EAPOL, rtl871x_handle_read, drv, 1); if (drv->l2_sock_recv == NULL) goto bad; } else { drv->l2_sock_recv = drv->l2_sock; printf("l2_sock_recv==l2_sock_xmit=0x%p\n", drv->l2_sock); } os_memset(ifrn_name, 0, sizeof(ifrn_name)); snprintf(ifrn_name, sizeof(ifrn_name), "mgnt.%s", "wlan0"); #ifdef CONFIG_MGNT_L2SOCK drv->mgnt_l2_sock = NULL; drv->mgnt_l2_sock = l2_packet_init(ifrn_name, NULL, ETH_P_80211_RAW, rtl871x_recvive_mgmt_frame, drv, 1); if (drv->mgnt_l2_sock == NULL) goto bad; #else #ifdef CONFIG_MLME_OFFLOAD drv->mgnt_sock = -1; #else drv->mgnt_sock = rtl871x_mgnt_sock_init(drv, ifrn_name); if (drv->mgnt_sock < 0) { goto bad; } #endif #endif if (rtl871x_set_mode(drv, IW_MODE_MASTER)<0) { printf("Could not set interface to master mode!\n"); goto bad; } #ifndef CONFIG_MLME_OFFLOAD rtl871x_set_iface_flags(drv, 1); // set mgnt interface up #endif if (rtl871x_wireless_event_init(drv)) goto bad; os_memcpy(drv->hw_mac, params->own_addr, ETH_ALEN); return drv; bad: if (drv->l2_sock_recv != NULL && drv->l2_sock_recv != drv->l2_sock) l2_packet_deinit(drv->l2_sock_recv); if (drv->l2_sock != NULL) l2_packet_deinit(drv->l2_sock); if (drv->ioctl_sock >= 0) close(drv->ioctl_sock); #ifdef CONFIG_MGNT_L2SOCK if ( drv->mgnt_l2_sock != NULL) l2_packet_deinit(drv->mgnt_l2_sock); #else if (drv->mgnt_sock >= 0) close(drv->mgnt_sock); #endif if (drv != NULL) free(drv); return NULL; }
static void * atheros_init(struct hostapd_data *hapd, struct wpa_init_params *params) { struct atheros_driver_data *drv; struct ifreq ifr; struct iwreq iwr; char brname[IFNAMSIZ]; drv = os_zalloc(sizeof(struct atheros_driver_data)); if (drv == NULL) { printf("Could not allocate memory for atheros driver data\n"); return NULL; } drv->hapd = hapd; drv->ioctl_sock = socket(PF_INET, SOCK_DGRAM, 0); if (drv->ioctl_sock < 0) { perror("socket[PF_INET,SOCK_DGRAM]"); goto bad; } memcpy(drv->iface, params->ifname, sizeof(drv->iface)); memset(&ifr, 0, sizeof(ifr)); os_strlcpy(ifr.ifr_name, drv->iface, sizeof(ifr.ifr_name)); if (ioctl(drv->ioctl_sock, SIOCGIFINDEX, &ifr) != 0) { perror("ioctl(SIOCGIFINDEX)"); goto bad; } drv->ifindex = ifr.ifr_ifindex; drv->sock_xmit = l2_packet_init(drv->iface, NULL, ETH_P_EAPOL, handle_read, drv, 1); if (drv->sock_xmit == NULL) goto bad; if (l2_packet_get_own_addr(drv->sock_xmit, params->own_addr)) goto bad; if (params->bridge[0]) { wpa_printf(MSG_DEBUG, "Configure bridge %s for EAPOL traffic.", params->bridge[0]); drv->sock_recv = l2_packet_init(params->bridge[0], NULL, ETH_P_EAPOL, handle_read, drv, 1); if (drv->sock_recv == NULL) goto bad; } else if (linux_br_get(brname, drv->iface) == 0) { wpa_printf(MSG_DEBUG, "Interface in bridge %s; configure for " "EAPOL receive", brname); drv->sock_recv = l2_packet_init(brname, NULL, ETH_P_EAPOL, handle_read, drv, 1); if (drv->sock_recv == NULL) goto bad; } else drv->sock_recv = drv->sock_xmit; memset(&iwr, 0, sizeof(iwr)); os_strlcpy(iwr.ifr_name, drv->iface, IFNAMSIZ); iwr.u.mode = IW_MODE_MASTER; if (ioctl(drv->ioctl_sock, SIOCSIWMODE, &iwr) < 0) { perror("ioctl[SIOCSIWMODE]"); printf("Could not set interface to master mode!\n"); goto bad; } /* mark down during setup */ linux_set_iface_flags(drv->ioctl_sock, drv->iface, 0); atheros_set_privacy(drv, 0); /* default to no privacy */ atheros_receive_probe_req(drv); if (atheros_wireless_event_init(drv)) goto bad; return drv; bad: if (drv->sock_recv != NULL && drv->sock_recv != drv->sock_xmit) l2_packet_deinit(drv->sock_recv); if (drv->sock_xmit != NULL) l2_packet_deinit(drv->sock_xmit); if (drv->ioctl_sock >= 0) close(drv->ioctl_sock); if (drv != NULL) free(drv); return NULL; }
static void * madwifi_init(struct hostapd_data *hapd) { struct madwifi_driver_data *drv; struct ifreq ifr; struct iwreq iwr; drv = os_zalloc(sizeof(struct madwifi_driver_data)); if (drv == NULL) { printf("Could not allocate memory for madwifi driver data\n"); return NULL; } drv->hapd = hapd; drv->ioctl_sock = socket(PF_INET, SOCK_DGRAM, 0); if (drv->ioctl_sock < 0) { perror("socket[PF_INET,SOCK_DGRAM]"); goto bad; } memcpy(drv->iface, hapd->conf->iface, sizeof(drv->iface)); memset(&ifr, 0, sizeof(ifr)); os_strlcpy(ifr.ifr_name, drv->iface, sizeof(ifr.ifr_name)); if (ioctl(drv->ioctl_sock, SIOCGIFINDEX, &ifr) != 0) { perror("ioctl(SIOCGIFINDEX)"); goto bad; } drv->ifindex = ifr.ifr_ifindex; drv->sock_xmit = l2_packet_init(drv->iface, NULL, ETH_P_EAPOL, handle_read, drv, 1); if (drv->sock_xmit == NULL) goto bad; if (l2_packet_get_own_addr(drv->sock_xmit, hapd->own_addr)) goto bad; if (hapd->conf->bridge[0] != '\0') { wpa_printf(MSG_DEBUG, "Configure bridge %s for EAPOL traffic.", hapd->conf->bridge); drv->sock_recv = l2_packet_init(hapd->conf->bridge, NULL, ETH_P_EAPOL, handle_read, drv, 1); if (drv->sock_recv == NULL) goto bad; } else drv->sock_recv = drv->sock_xmit; memset(&iwr, 0, sizeof(iwr)); os_strlcpy(iwr.ifr_name, drv->iface, IFNAMSIZ); iwr.u.mode = IW_MODE_MASTER; if (ioctl(drv->ioctl_sock, SIOCSIWMODE, &iwr) < 0) { perror("ioctl[SIOCSIWMODE]"); printf("Could not set interface to master mode!\n"); goto bad; } madwifi_set_iface_flags(drv, 0); /* mark down during setup */ madwifi_set_privacy(drv->iface, drv, 0); /* default to no privacy */ madwifi_receive_probe_req(drv); return drv; bad: if (drv->sock_xmit != NULL) l2_packet_deinit(drv->sock_xmit); if (drv->ioctl_sock >= 0) close(drv->ioctl_sock); if (drv != NULL) free(drv); return NULL; }
static void * bsd_init(struct hostapd_data *hapd, struct wpa_init_params *params) { struct bsd_driver_data *drv; drv = os_zalloc(sizeof(struct bsd_driver_data)); if (drv == NULL) { printf("Could not allocate memory for bsd driver data\n"); goto bad; } drv->hapd = hapd; drv->sock = socket(PF_INET, SOCK_DGRAM, 0); if (drv->sock < 0) { perror("socket[PF_INET,SOCK_DGRAM]"); goto bad; } os_strlcpy(drv->ifname, params->ifname, sizeof(drv->ifname)); /* * NB: We require the interface name be mappable to an index. * This implies we do not support having wpa_supplicant * wait for an interface to appear. This seems ok; that * doesn't belong here; it's really the job of devd. * XXXSCW: devd is FreeBSD-specific. */ drv->ifindex = if_nametoindex(drv->ifname); if (drv->ifindex == 0) { printf("%s: interface %s does not exist", __func__, drv->ifname); goto bad; } drv->sock_xmit = l2_packet_init(drv->ifname, NULL, ETH_P_EAPOL, handle_read, drv, 0); if (drv->sock_xmit == NULL) goto bad; if (l2_packet_get_own_addr(drv->sock_xmit, params->own_addr)) goto bad; /* mark down during setup */ if (bsd_ctrl_iface(drv, 0) < 0) goto bad; drv->route = socket(PF_ROUTE, SOCK_RAW, 0); if (drv->route < 0) { perror("socket(PF_ROUTE,SOCK_RAW)"); goto bad; } eloop_register_read_sock(drv->route, bsd_wireless_event_receive, drv, NULL); return drv; bad: if (drv == NULL) return NULL; if (drv->sock_xmit != NULL) l2_packet_deinit(drv->sock_xmit); if (drv->sock >= 0) close(drv->sock); os_free(drv); return NULL; }