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;
}
