Lines Matching refs:drv
65 static void handle_data(struct hostap_driver_data *drv, u8 *buf, size_t len,
89 wpa_supplicant_event(drv->hapd, EVENT_RX_FROM_UNKNOWN, &event);
116 drv_event_eapol_rx(drv->hapd, sa, pos, left);
126 static void handle_tx_callback(struct hostap_driver_data *drv, u8 *buf,
143 wpa_supplicant_event(drv->hapd, EVENT_TX_STATUS, &event);
147 static void handle_frame(struct hostap_driver_data *drv, u8 *buf, size_t len)
190 handle_tx_callback(drv, buf, data_len, ver == 2 ? 1 : 0);
202 wpa_supplicant_event(drv->hapd, EVENT_RX_MGMT, &event);
209 handle_data(drv, buf, data_len, stype);
220 struct hostap_driver_data *drv = eloop_ctx;
230 handle_frame(drv, buf, len);
234 static int hostap_init_sockets(struct hostap_driver_data *drv, u8 *own_addr)
239 drv->sock = socket(PF_PACKET, SOCK_RAW, htons(ETH_P_ALL));
240 if (drv->sock < 0) {
245 if (eloop_register_read_sock(drv->sock, handle_read, drv, NULL)) {
251 snprintf(ifr.ifr_name, sizeof(ifr.ifr_name), "%sap", drv->iface);
252 if (ioctl(drv->sock, SIOCGIFINDEX, &ifr) != 0) {
257 if (hostap_set_iface_flags(drv, 1)) {
267 if (bind(drv->sock, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
272 return linux_get_ifhwaddr(drv->sock, drv->iface, own_addr);
278 struct hostap_driver_data *drv = priv;
284 res = send(drv->sock, msg, len, 0);
295 struct hostap_driver_data *drv = priv;
325 res = hostap_send_mlme(drv, (u8 *) hdr, len);
340 struct hostap_driver_data *drv = priv;
354 return hostapd_ioctl(drv, ¶m, sizeof(param));
360 struct hostap_driver_data *drv = priv;
364 os_snprintf(ifname, IFNAMSIZ, "%sap", drv->iface);
365 if (linux_set_iface_flags(drv->ioctl_sock, ifname, dev_up) < 0)
372 if (ioctl(drv->ioctl_sock, SIOCSIFMTU, &ifr) != 0) {
386 struct hostap_driver_data *drv = priv;
390 os_strlcpy(iwr.ifr_name, drv->iface, IFNAMSIZ);
394 if (ioctl(drv->ioctl_sock, PRISM2_IOCTL_HOSTAPD, &iwr) < 0) {
409 struct hostap_driver_data *drv = priv;
452 if (hostapd_ioctl(drv, param, blen)) {
465 struct hostap_driver_data *drv = priv;
484 if (hostapd_ioctl(drv, param, blen)) {
498 struct hostap_driver_data *drv = priv;
503 os_strlcpy(iwr.ifr_name, drv->iface, IFNAMSIZ);
508 if (ioctl(drv->ioctl_sock, PRISM2_IOCTL_PRISM2_PARAM, &iwr) < 0) {
519 struct hostap_driver_data *drv = priv;
523 if (hostap_ioctl_prism2param(drv, PRISM2_PARAM_IEEE_802_1X, enabled)) {
534 if (hostap_ioctl_prism2param(drv, PRISM2_PARAM_HOST_DECRYPT, 1) ||
535 hostap_ioctl_prism2param(drv, PRISM2_PARAM_HOST_ENCRYPT, 1)) {
547 struct hostap_drvier_data *drv = priv;
549 return hostap_ioctl_prism2param(drv, PRISM2_PARAM_PRIVACY_INVOKED,
556 struct hostap_driver_data *drv = priv;
560 os_strlcpy(iwr.ifr_name, drv->iface, IFNAMSIZ);
565 if (ioctl(drv->ioctl_sock, SIOCSIWESSID, &iwr) < 0) {
577 struct hostap_driver_data *drv = priv;
582 return hostapd_ioctl(drv, ¶m, sizeof(param));
590 struct hostap_driver_data *drv = priv;
597 drv->iface, MAC2STR(addr));
630 struct hostap_driver_data *drv = priv;
657 return hostapd_ioctl(drv, ¶m, sizeof(param));
663 struct hostap_driver_data *drv = priv;
666 hostap_sta_set_flags(drv, addr, 0, 0, ~WPA_STA_AUTHORIZED);
671 if (hostapd_ioctl(drv, ¶m, sizeof(param))) {
681 struct hostap_driver_data *drv = priv;
687 if (hostapd_ioctl(drv, ¶m, sizeof(param))) {
697 struct hostap_driver_data *drv = priv;
703 if (hostapd_ioctl(drv, ¶m, sizeof(param))) {
711 static int hostapd_ioctl_set_generic_elem(struct hostap_driver_data *drv)
717 elem_len = drv->generic_ie_len + drv->wps_ie_len;
728 if (drv->generic_ie) {
729 os_memcpy(param->u.generic_elem.data, drv->generic_ie,
730 drv->generic_ie_len);
732 if (drv->wps_ie) {
733 os_memcpy(¶m->u.generic_elem.data[drv->generic_ie_len],
734 drv->wps_ie, drv->wps_ie_len);
738 res = hostapd_ioctl(drv, param, blen);
749 struct hostap_driver_data *drv = priv;
751 os_free(drv->generic_ie);
752 drv->generic_ie = NULL;
753 drv->generic_ie_len = 0;
755 drv->generic_ie = os_malloc(elem_len);
756 if (drv->generic_ie == NULL)
758 os_memcpy(drv->generic_ie, elem, elem_len);
759 drv->generic_ie_len = elem_len;
762 return hostapd_ioctl_set_generic_elem(drv);
770 struct hostap_driver_data *drv = priv;
778 os_free(drv->wps_ie);
779 drv->wps_ie = NULL;
780 drv->wps_ie_len = 0;
782 drv->wps_ie = os_malloc(wpabuf_len(proberesp));
783 if (drv->wps_ie == NULL)
785 os_memcpy(drv->wps_ie, wpabuf_head(proberesp),
787 drv->wps_ie_len = wpabuf_len(proberesp);
790 return hostapd_ioctl_set_generic_elem(drv);
795 hostapd_wireless_event_wireless_custom(struct hostap_driver_data *drv,
816 wpa_supplicant_event(drv->hapd,
827 static void hostapd_wireless_event_wireless(struct hostap_driver_data *drv,
846 if (drv->we_version > 18 &&
868 hostapd_wireless_event_wireless_custom(drv, buf);
882 struct hostap_driver_data *drv = ctx;
896 drv, ((char *) attr) + rta_len,
904 static int hostap_get_we_version(struct hostap_driver_data *drv)
911 drv->we_version = 0;
923 os_strlcpy(iwr.ifr_name, drv->iface, IFNAMSIZ);
930 if (ioctl(drv->ioctl_sock, SIOCGIWRANGE, &iwr) < 0) {
941 drv->we_version = range->we_version_compiled;
949 static int hostap_wireless_event_init(struct hostap_driver_data *drv)
953 hostap_get_we_version(drv);
958 cfg->ctx = drv;
960 drv->netlink = netlink_init(cfg);
961 if (drv->netlink == NULL) {
973 struct hostap_driver_data *drv;
975 drv = os_zalloc(sizeof(struct hostap_driver_data));
976 if (drv == NULL) {
981 drv->hapd = hapd;
982 drv->ioctl_sock = drv->sock = -1;
983 memcpy(drv->iface, params->ifname, sizeof(drv->iface));
985 drv->ioctl_sock = socket(PF_INET, SOCK_DGRAM, 0);
986 if (drv->ioctl_sock < 0) {
988 free(drv);
992 if (hostap_ioctl_prism2param(drv, PRISM2_PARAM_HOSTAPD, 1)) {
994 drv->iface);
995 close(drv->ioctl_sock);
996 free(drv);
1000 if (hostap_init_sockets(drv, params->own_addr) ||
1001 hostap_wireless_event_init(drv)) {
1002 close(drv->ioctl_sock);
1003 free(drv);
1007 return drv;
1013 struct hostap_driver_data *drv = priv;
1015 netlink_deinit(drv->netlink);
1016 (void) hostap_set_iface_flags(drv, 0);
1017 (void) hostap_ioctl_prism2param(drv, PRISM2_PARAM_HOSTAPD, 0);
1018 (void) hostap_ioctl_prism2param(drv, PRISM2_PARAM_HOSTAPD_STA, 0);
1020 if (drv->ioctl_sock >= 0)
1021 close(drv->ioctl_sock);
1023 if (drv->sock >= 0)
1024 close(drv->sock);
1026 os_free(drv->generic_ie);
1027 os_free(drv->wps_ie);
1029 free(drv);
1036 struct hostap_driver_data *drv = priv;
1056 return hostap_send_mlme(drv, (u8 *) &mgmt, IEEE80211_HDRLEN +
1064 struct hostap_driver_data *drv = priv;
1074 return hostap_send_mlme(drv, (u8 *) &mgmt, IEEE80211_HDRLEN +
1143 static int hostapd_ioctl(struct wpa_driver_hostap_data *drv,
1150 os_strlcpy(iwr.ifr_name, drv->ifname, IFNAMSIZ);
1154 if (ioctl(drv->sock, PRISM2_IOCTL_HOSTAPD, &iwr) < 0) {
1165 static int wpa_driver_hostap_set_wpa_ie(struct wpa_driver_hostap_data *drv,
1181 res = hostapd_ioctl(drv, param, blen, 1);
1189 static int prism2param(struct wpa_driver_hostap_data *drv, int param,
1196 os_strlcpy(iwr.ifr_name, drv->ifname, IFNAMSIZ);
1201 if (ioctl(drv->sock, PRISM2_IOCTL_PRISM2_PARAM, &iwr) < 0) {
1211 struct wpa_driver_hostap_data *drv = priv;
1216 if (!enabled && wpa_driver_hostap_set_wpa_ie(drv, NULL, 0) < 0)
1218 if (prism2param(drv, PRISM2_PARAM_HOST_ROAMING, enabled ? 2 : 0) < 0)
1220 if (prism2param(drv, PRISM2_PARAM_WPA, enabled) < 0)
1264 struct wpa_driver_hostap_data *drv = priv;
1326 if (hostapd_ioctl(drv, param, blen, 1)) {
1339 struct wpa_driver_hostap_data *drv = priv;
1341 return prism2param(drv, PRISM2_PARAM_TKIP_COUNTERMEASURES, enabled);
1345 static int wpa_driver_hostap_reset(struct wpa_driver_hostap_data *drv,
1354 os_strlcpy(iwr.ifr_name, drv->ifname, IFNAMSIZ);
1358 if (ioctl(drv->sock, PRISM2_IOCTL_RESET, &iwr) < 0) {
1366 static int wpa_driver_hostap_mlme(struct wpa_driver_hostap_data *drv,
1381 ret = hostapd_ioctl(drv, ¶m, sizeof(param), 1);
1384 ret = wpa_driver_hostap_reset(drv, 2);
1393 struct wpa_driver_hostap_data *drv = priv;
1395 return wpa_driver_hostap_mlme(drv, addr, MLME_STA_DEAUTH,
1403 struct wpa_driver_hostap_data *drv = priv;
1405 return wpa_driver_hostap_mlme(drv, addr, MLME_STA_DISASSOC,
1414 struct wpa_driver_hostap_data *drv = priv;
1420 if (prism2param(drv, PRISM2_PARAM_DROP_UNENCRYPTED,
1423 if (wpa_driver_hostap_set_auth_alg(drv, params->auth_alg) < 0)
1425 if (params->mode != drv->current_mode) {
1428 if (prism2param(drv, PRISM2_PARAM_HOST_ROAMING,
1434 drv->current_mode = params->mode;
1437 if (prism2param(drv, PRISM2_PARAM_PRIVACY_INVOKED,
1440 if (wpa_driver_hostap_set_wpa_ie(drv, params->wpa_ie,
1443 if (wpa_driver_wext_set_mode(drv->wext, params->mode) < 0)
1446 wpa_driver_wext_set_freq(drv->wext, params->freq) < 0)
1448 if (wpa_driver_wext_set_ssid(drv->wext, params->ssid, params->ssid_len)
1451 if (wpa_driver_wext_set_bssid(drv->wext, params->bssid) < 0)
1463 if (prism2param(drv, PRISM2_PARAM_IEEE_802_1X,
1478 struct wpa_driver_hostap_data *drv = priv;
1489 return wpa_driver_wext_scan(drv->wext, params);
1499 ret = hostapd_ioctl(drv, ¶m, sizeof(param), 1);
1503 eloop_cancel_timeout(wpa_driver_wext_scan_timeout, drv->wext,
1504 drv->ctx);
1505 eloop_register_timeout(3, 0, wpa_driver_wext_scan_timeout, drv->wext,
1506 drv->ctx);
1514 struct wpa_driver_hostap_data *drv = priv;
1526 return prism2param(drv, PRISM2_PARAM_AP_AUTH_ALGS, algs);
1532 struct wpa_driver_hostap_data *drv = priv;
1533 return wpa_driver_wext_get_bssid(drv->wext, bssid);
1539 struct wpa_driver_hostap_data *drv = priv;
1540 return wpa_driver_wext_get_ssid(drv->wext, ssid);
1546 struct wpa_driver_hostap_data *drv = priv;
1547 return wpa_driver_wext_get_scan_results(drv->wext);
1553 struct wpa_driver_hostap_data *drv = priv;
1554 return wpa_driver_wext_set_operstate(drv->wext, state);
1560 struct wpa_driver_hostap_data *drv;
1562 drv = os_zalloc(sizeof(*drv));
1563 if (drv == NULL)
1565 drv->wext = wpa_driver_wext_init(ctx, ifname);
1566 if (drv->wext == NULL) {
1567 os_free(drv);
1571 drv->ctx = ctx;
1572 os_strlcpy(drv->ifname, ifname, sizeof(drv->ifname));
1573 drv->sock = socket(PF_INET, SOCK_DGRAM, 0);
1574 if (drv->sock < 0) {
1576 wpa_driver_wext_deinit(drv->wext);
1577 os_free(drv);
1589 wpa_driver_wext_alternative_ifindex(drv->wext, ifname2);
1592 wpa_driver_hostap_set_wpa(drv, 1);
1594 return drv;
1600 struct wpa_driver_hostap_data *drv = priv;
1601 wpa_driver_hostap_set_wpa(drv, 0);
1602 wpa_driver_wext_deinit(drv->wext);
1603 close(drv->sock);
1604 os_free(drv);