diff options
Diffstat (limited to 'package/hostapd-rtk/patches')
| -rw-r--r-- | package/hostapd-rtk/patches/001-common-diff.patch | 264 | ||||
| -rw-r--r-- | package/hostapd-rtk/patches/002-common-files.patch | 2948 | ||||
| -rw-r--r-- | package/hostapd-rtk/patches/003-hostapd-diff.patch | 300 | ||||
| -rw-r--r-- | package/hostapd-rtk/patches/004-hostapd-files.patch | 3529 | ||||
| -rw-r--r-- | package/hostapd-rtk/patches/005-supplicant-diff.patch | 207 | ||||
| -rw-r--r-- | package/hostapd-rtk/patches/008-no-inband.patch | 26 |
6 files changed, 7274 insertions, 0 deletions
diff --git a/package/hostapd-rtk/patches/001-common-diff.patch b/package/hostapd-rtk/patches/001-common-diff.patch new file mode 100644 index 000000000..ac942ddcb --- /dev/null +++ b/package/hostapd-rtk/patches/001-common-diff.patch @@ -0,0 +1,264 @@ +Index: hostapd-0.6.10-try/src/drivers/drivers.c +=================================================================== +--- hostapd-0.6.10-try.orig/src/drivers/drivers.c ++++ hostapd-0.6.10-try/src/drivers/drivers.c +@@ -33,6 +33,12 @@ extern struct wpa_driver_ops wpa_driver_ + #ifdef CONFIG_DRIVER_MADWIFI + extern struct wpa_driver_ops wpa_driver_madwifi_ops; /* driver_madwifi.c */ + #endif /* CONFIG_DRIVER_MADWIFI */ ++#ifdef CONFIG_DRIVER_REALTEK ++extern struct wpa_driver_ops wpa_driver_realtek_ops; /* driver_madwifi.c */ ++#endif /* CONFIG_DRIVER_REALTEK */ ++#ifdef CONFIG_DRIVER_REALTEK ++extern struct wpa_driver_ops wpa_driver_realtek_ops; /* driver_realtek.c */ ++#endif /* CONFIG_DRIVER_REALTEK */ + #ifdef CONFIG_DRIVER_ATMEL + extern struct wpa_driver_ops wpa_driver_atmel_ops; /* driver_atmel.c */ + #endif /* CONFIG_DRIVER_ATMEL */ +@@ -96,6 +102,12 @@ struct wpa_driver_ops *wpa_supplicant_dr + #ifdef CONFIG_DRIVER_MADWIFI + &wpa_driver_madwifi_ops, + #endif /* CONFIG_DRIVER_MADWIFI */ ++#ifdef CONFIG_DRIVER_REALTEK ++ &wpa_driver_realtek_ops, ++#endif /* CONFIG_DRIVER_REALTEK */ ++#ifdef CONFIG_DRIVER_REALTEK ++ &wpa_driver_realtek_ops, ++#endif /* CONFIG_DRIVER_REALTEK */ + #ifdef CONFIG_DRIVER_ATMEL + &wpa_driver_atmel_ops, + #endif /* CONFIG_DRIVER_ATMEL */ +Index: hostapd-0.6.10-try/src/rsn_supp/wpa.c +=================================================================== +--- hostapd-0.6.10-try.orig/src/rsn_supp/wpa.c ++++ hostapd-0.6.10-try/src/rsn_supp/wpa.c +@@ -426,9 +426,14 @@ static void wpa_supplicant_process_1_of_ + ptk = &sm->tptk; + wpa_derive_ptk(sm, src_addr, key, ptk); + /* Supplicant: swap tx/rx Mic keys */ ++#ifdef RTK_WPAS ++ printf("NOT SWAP PTK\n"); ++#else ++ printf("SWAP PTK\n"); + os_memcpy(buf, ptk->u.auth.tx_mic_key, 8); + os_memcpy(ptk->u.auth.tx_mic_key, ptk->u.auth.rx_mic_key, 8); + os_memcpy(ptk->u.auth.rx_mic_key, buf, 8); ++#endif + sm->tptk_set = 1; + + if (wpa_supplicant_send_2_of_4(sm, sm->bssid, key, ver, sm->snonce, +@@ -633,10 +638,16 @@ static int wpa_supplicant_install_gtk(st + gd->gtk_len); + wpa_hexdump(MSG_DEBUG, "WPA: RSC", key_rsc, gd->key_rsc_len); + if (sm->group_cipher == WPA_CIPHER_TKIP) { ++#ifdef RTK_WPAS ++ printf("NOT SWAP GTK\n"); ++ os_memcpy(gtk_buf, gd->gtk, gd->gtk_len); ++#else ++ printf("SWAP GTK\n"); + /* Swap Tx/Rx keys for Michael MIC */ + os_memcpy(gtk_buf, gd->gtk, 16); + os_memcpy(gtk_buf + 16, gd->gtk + 24, 8); + os_memcpy(gtk_buf + 24, gd->gtk + 16, 8); ++#endif + _gtk = gtk_buf; + } + if (sm->pairwise_cipher == WPA_CIPHER_NONE) { +@@ -1010,6 +1021,15 @@ static void wpa_supplicant_process_3_of_ + if (key_info & WPA_KEY_INFO_INSTALL) { + if (wpa_supplicant_install_ptk(sm, key)) + goto failed; ++#ifdef RTK_WPAS ++ else if(sm->key_mgmt == WPA_KEY_MGMT_PSK) ++ { ++ wpa_sm_mlme_setprotection( ++ sm, sm->bssid, MLME_SETPROTECTION_PROTECT_TYPE_RX, ++ MLME_SETPROTECTION_KEY_TYPE_PAIRWISE); ++ eapol_sm_notify_portValid(sm->eapol, TRUE); ++ } ++#endif + } + + if (key_info & WPA_KEY_INFO_SECURE) { +Index: hostapd-0.6.10-try/src/utils/common.h +=================================================================== +--- hostapd-0.6.10-try.orig/src/utils/common.h ++++ hostapd-0.6.10-try/src/utils/common.h +@@ -455,4 +455,11 @@ static inline int is_zero_ether_addr(con + void * __hide_aliasing_typecast(void *foo); + #define aliasing_hide_typecast(a,t) (t *) __hide_aliasing_typecast((a)) + ++#define RTK_WPAS ++ ++#ifdef RTK_WPAS ++#define RTK_INBAND ++#define RTK_INBAND_LE ++#endif ++ + #endif /* COMMON_H */ +Index: hostapd-0.6.10-try/src/utils/os_unix.c +=================================================================== +--- hostapd-0.6.10-try.orig/src/utils/os_unix.c ++++ hostapd-0.6.10-try/src/utils/os_unix.c +@@ -116,7 +116,7 @@ int os_daemonize(const char *pid_file) + #ifdef __uClinux__ + return -1; + #else /* __uClinux__ */ +- if (os_daemon(0, 0)) { ++ if (os_daemon(0, 1)) { + perror("daemon"); + return -1; + } +Index: hostapd-0.6.10-try/src/wps/wps.h +=================================================================== +--- hostapd-0.6.10-try.orig/src/wps/wps.h ++++ hostapd-0.6.10-try/src/wps/wps.h +@@ -507,6 +507,10 @@ struct wps_context { + + /* Pending messages from UPnP PutWLANResponse */ + struct upnp_pending_message *upnp_msgs; ++ ++#if defined(RTK_HAPD) || (1) ++ volatile int set_selected_registrar; //add this item to help AP determine to use proxy mode or handle msg by itself. ++#endif + }; + + +Index: hostapd-0.6.10-try/src/wps/wps_registrar.c +=================================================================== +--- hostapd-0.6.10-try.orig/src/wps/wps_registrar.c ++++ hostapd-0.6.10-try/src/wps/wps_registrar.c +@@ -461,6 +461,10 @@ int wps_registrar_add_pin(struct wps_reg + wps_registrar_set_selected_timeout, + reg, NULL); + ++#if defined(RTK_HAPD) || (1) ++ reg->wps->set_selected_registrar = 0; ++#endif ++ + return 0; + } + +@@ -649,6 +653,11 @@ int wps_registrar_button_pushed(struct w + eloop_cancel_timeout(wps_registrar_pbc_timeout, reg, NULL); + eloop_register_timeout(WPS_PBC_WALK_TIME, 0, wps_registrar_pbc_timeout, + reg, NULL); ++ ++#if defined(RTK_HAPD) || (1) ++ reg->wps->set_selected_registrar = 0; ++#endif ++ + return 0; + } + +@@ -1040,10 +1049,32 @@ static int wps_build_cred_encr_type(stru + static int wps_build_cred_network_key(struct wpabuf *msg, + struct wps_credential *cred) + { ++ ++#if defined(RTK_HAPD) || (1) //If authtication is WEP, always tell enrollee use wepkey1. ++ if(cred->encr_type == 0x2) ++ { ++ wpabuf_put_be16(msg, ATTR_NETWORK_KEY_INDEX); ++ wpabuf_put_be16(msg, 1); ++ wpabuf_put_u8(msg, 1); ++ } ++#endif ++ + wpa_printf(MSG_DEBUG, "WPS: * Network Key"); + wpabuf_put_be16(msg, ATTR_NETWORK_KEY); + wpabuf_put_be16(msg, cred->key_len); + wpabuf_put_data(msg, cred->key, cred->key_len); ++ ++#if defined(RTK_HAPD) || (1) ++ if(cred->encr_type == 0x2) ++ { ++ wpabuf_put_be16(msg, ATTR_WEPTRANSMITKEY); ++ wpabuf_put_be16(msg, 1); ++ wpabuf_put_u8(msg, 1); ++ } ++#endif ++ ++ ++ + return 0; + } + +@@ -1446,6 +1477,10 @@ struct wpabuf * wps_registrar_get_msg(st + struct wpabuf *msg; + + #ifdef CONFIG_WPS_UPNP ++ ++#if defined(RTK_HAPD) || (1) ++ if(wps->wps->set_selected_registrar == 1) ++#endif + if (wps->wps->wps_upnp) { + struct upnp_pending_message *p, *prev = NULL; + if (wps->ext_reg > 1) +@@ -2523,6 +2558,19 @@ enum wps_process_res wps_registrar_proce + } + if (wps->ext_reg > 1) + wps_registrar_free_pending_m2(wps->wps); ++ ++#if defined (RTK_HAPD) || (1) ++ wpa_printf(MSG_DEBUG, "WPS: set_selected_registrar = %d", wps->wps->set_selected_registrar); ++ if( wps->wps->wps_upnp && (wps->wps->set_selected_registrar == 1) ++ && upnp_wps_subscribers(wps->wps->wps_upnp)) ++ { ++ if(wps->ext_reg == 0) ++ wps->ext_reg = 1; ++ } ++ else ++ wps->ext_reg = 0; ++#endif ++ + if (wps->wps->wps_upnp && wps->ext_reg && + wps->wps->upnp_msgs == NULL && + (op_code == WSC_MSG || op_code == WSC_Done || op_code == WSC_NACK)) +Index: hostapd-0.6.10-try/src/wps/wps_upnp_event.c +=================================================================== +--- hostapd-0.6.10-try.orig/src/wps/wps_upnp_event.c ++++ hostapd-0.6.10-try/src/wps/wps_upnp_event.c +@@ -485,8 +485,14 @@ void event_send_all_later(struct upnp_wp + if (sm->event_send_all_queued) + return; + sm->event_send_all_queued = 1; ++ ++#if defined(RTK_HAPD) || (1) ++ event_send_all_later_handler(NULL, sm); ++#else + eloop_register_timeout(EVENT_DELAY_SECONDS, EVENT_DELAY_MSEC, + event_send_all_later_handler, NULL, sm); ++#endif ++ + } + + +Index: hostapd-0.6.10-try/src/wps/wps_upnp_web.c +=================================================================== +--- hostapd-0.6.10-try.orig/src/wps/wps_upnp_web.c ++++ hostapd-0.6.10-try/src/wps/wps_upnp_web.c +@@ -1053,6 +1053,11 @@ web_process_set_selected_registrar(struc + enum http_reply_code ret; + + wpa_printf(MSG_DEBUG, "WPS UPnP: SetSelectedRegistrar"); ++ ++#if defined(RTK_HAPD) || (1) ++ sm->wps->set_selected_registrar = 0; ++#endif ++ + msg = web_get_item(data, "NewMessage", &ret); + if (msg == NULL) + return ret; +@@ -1064,6 +1069,11 @@ web_process_set_selected_registrar(struc + wpabuf_free(msg); + *replyname = NULL; + *reply = NULL; ++ ++#if defined(RTK_HAPD) || (1) ++ sm->wps->set_selected_registrar = 1; ++#endif ++ + return HTTP_OK; + } + diff --git a/package/hostapd-rtk/patches/002-common-files.patch b/package/hostapd-rtk/patches/002-common-files.patch new file mode 100644 index 000000000..30641f7b8 --- /dev/null +++ b/package/hostapd-rtk/patches/002-common-files.patch @@ -0,0 +1,2948 @@ +Index: hostapd-rtk-0.6.10/src/drivers/driver_realtek.c +=================================================================== +--- /dev/null ++++ hostapd-rtk-0.6.10/src/drivers/driver_realtek.c +@@ -0,0 +1,876 @@ ++/* ++ * WPA Supplicant - driver interaction with realtek 802.11 driver ++ * Copyright (c) 2004, Sam Leffler <sam@errno.com> ++ * Copyright (c) 2004-2005, Jouni Malinen <j@w1.fi> ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * Alternatively, this software may be distributed under the terms of BSD ++ * license. ++ * ++ * See README and COPYING for more details. ++ * ++ * Please note that realtek supports WPA configuration via Linux wireless ++ * extensions and if the kernel includes support for this, driver_wext.c should ++ * be used instead of this driver wrapper. ++ */ ++ ++#include "includes.h" ++#include <sys/ioctl.h> ++ ++#include "common.h" ++#include "driver.h" ++#include "driver_realtek_wext.h" ++#include "eloop.h" ++#include "ieee802_11_defs.h" ++#include "wireless_copy.h" ++ ++#include "driver_realtek.h" ++ ++#include "../wpa_supplicant/config.h" ++#include "../wpa_supplicant/wpa_supplicant_i.h" ++#include "../wpa_supplicant/wps_supplicant.h" ++ ++ ++/* ++ * Avoid conflicts with wpa_supplicant definitions by undefining a definition. ++ */ ++#undef WME_OUI_TYPE ++ ++//#include <include/compat.h> ++#include <net80211/ieee80211.h> ++#ifdef WME_NUM_AC ++/* Assume this is built against BSD branch of realtek driver. */ ++#define realtek_BSD ++#include <net80211/_ieee80211.h> ++#endif /* WME_NUM_AC */ ++#include <net80211/ieee80211_crypto.h> ++#include <net80211/ieee80211_ioctl.h> ++ ++ ++#ifdef IEEE80211_IOCTL_SETWMMPARAMS ++/* Assume this is built against realtek-ng */ ++#define realtek_NG ++#endif /* IEEE80211_IOCTL_SETWMMPARAMS */ ++ ++struct wpa_driver_realtek_data { ++ void *wext; /* private data for driver_wext */ ++ void *ctx; ++ char ifname[IFNAMSIZ + 1]; ++ int sock; ++}; ++ ++static int ++set80211priv(struct wpa_driver_realtek_data *drv, int op, void *data, int len, ++ int show_err) ++{ ++ struct iwreq iwr; ++ ++ printf("Wpa_supplicant: %s +++\n", __FUNCTION__); ++ ++ os_memset(&iwr, 0, sizeof(iwr)); ++ os_strlcpy(iwr.ifr_name, drv->ifname, IFNAMSIZ); ++ if (len < IFNAMSIZ && ++ op != IEEE80211_IOCTL_SET_APPIEBUF) { ++ /* ++ * Argument data fits inline; put it there. ++ */ ++ os_memcpy(iwr.u.name, data, len); ++ } else { ++ /* ++ * Argument data too big for inline transfer; setup a ++ * parameter block instead; the kernel will transfer ++ * the data for the driver. ++ */ ++ iwr.u.data.pointer = data; ++ iwr.u.data.length = len; ++ } ++ ++ ++#ifdef RTK_INBAND ++ if (inband_ioctl(op, &iwr) < 0) ++#else ++ if (ioctl(drv->sock, op, &iwr) < 0) ++#endif ++ { ++ if (show_err) { ++#ifdef realtek_NG ++ int first = IEEE80211_IOCTL_SETPARAM; ++ int last = IEEE80211_IOCTL_KICKMAC; ++ static const char *opnames[] = { ++ "ioctl[IEEE80211_IOCTL_SETPARAM]", ++ "ioctl[IEEE80211_IOCTL_GETPARAM]", ++ "ioctl[IEEE80211_IOCTL_SETMODE]", ++ "ioctl[IEEE80211_IOCTL_GETMODE]", ++ "ioctl[IEEE80211_IOCTL_SETWMMPARAMS]", ++ "ioctl[IEEE80211_IOCTL_GETWMMPARAMS]", ++ "ioctl[IEEE80211_IOCTL_SETCHANLIST]", ++ "ioctl[IEEE80211_IOCTL_GETCHANLIST]", ++ "ioctl[IEEE80211_IOCTL_CHANSWITCH]", ++ NULL, ++ "ioctl[IEEE80211_IOCTL_SET_APPIEBUF]", ++ "ioctl[IEEE80211_IOCTL_GETSCANRESULTS]", ++ NULL, ++ "ioctl[IEEE80211_IOCTL_GETCHANINFO]", ++ "ioctl[IEEE80211_IOCTL_SETOPTIE]", ++ "ioctl[IEEE80211_IOCTL_GETOPTIE]", ++ "ioctl[IEEE80211_IOCTL_SETMLME]", ++ NULL, ++ "ioctl[IEEE80211_IOCTL_SETKEY]", ++ NULL, ++ "ioctl[IEEE80211_IOCTL_DELKEY]", ++ NULL, ++ "ioctl[IEEE80211_IOCTL_ADDMAC]", ++ NULL, ++ "ioctl[IEEE80211_IOCTL_DELMAC]", ++ NULL, ++ "ioctl[IEEE80211_IOCTL_WDSMAC]", ++ NULL, ++ "ioctl[IEEE80211_IOCTL_WDSDELMAC]", ++ NULL, ++ "ioctl[IEEE80211_IOCTL_KICKMAC]", ++ }; ++#else /* realtek_NG */ ++ int first = IEEE80211_IOCTL_SETPARAM; ++ int last = IEEE80211_IOCTL_CHANLIST; ++ static const char *opnames[] = { ++ "ioctl[IEEE80211_IOCTL_SETPARAM]", ++ "ioctl[IEEE80211_IOCTL_GETPARAM]", ++ "ioctl[IEEE80211_IOCTL_SETKEY]", ++ "ioctl[IEEE80211_IOCTL_GETKEY]", ++ "ioctl[IEEE80211_IOCTL_DELKEY]", ++ NULL, ++ "ioctl[IEEE80211_IOCTL_SETMLME]", ++ NULL, ++ "ioctl[IEEE80211_IOCTL_SETOPTIE]", ++ "ioctl[IEEE80211_IOCTL_GETOPTIE]", ++ "ioctl[IEEE80211_IOCTL_ADDMAC]", ++ NULL, ++ "ioctl[IEEE80211_IOCTL_DELMAC]", ++ NULL, ++ "ioctl[IEEE80211_IOCTL_CHANLIST]", ++ }; ++#endif /* realtek_NG */ ++ int idx = op - first; ++ if (first <= op && op <= last && ++ idx < (int) (sizeof(opnames) / sizeof(opnames[0])) ++ && opnames[idx]) ++ perror(opnames[idx]); ++ else ++ perror("ioctl[unknown???]"); ++ } ++ return -1; ++ } ++ return 0; ++} ++ ++static int ++set80211param(struct wpa_driver_realtek_data *drv, int op, int arg, ++ int show_err) ++{ ++ struct iwreq iwr; ++ ++ printf("Wpa_supplicant: %s +++\n", __FUNCTION__); ++ ++#ifdef RTK_INBAND_LE ++ op = htonl(op); ++ arg = htonl(arg); ++#endif ++ ++ os_memset(&iwr, 0, sizeof(iwr)); ++ os_strlcpy(iwr.ifr_name, drv->ifname, IFNAMSIZ); ++ iwr.u.mode = op; ++ os_memcpy(iwr.u.name+sizeof(u32), &arg, sizeof(arg)); ++ ++ ++#ifdef RTK_INBAND ++ if (inband_ioctl(IEEE80211_IOCTL_SETPARAM, &iwr) < 0) ++#else ++ if (ioctl(drv->sock, IEEE80211_IOCTL_SETPARAM, &iwr) < 0) ++#endif ++ { ++ if (show_err) ++ perror("ioctl[IEEE80211_IOCTL_SETPARAM]"); ++ return -1; ++ } ++ ++ return 0; ++} ++ ++ ++static int ++realtek_configure_wpa(struct wpa_driver_realtek_data *drv, struct wpa_driver_associate_params *params) ++{ ++ int cipher = 0; ++ int wpa = 0; ++ int psk = 0; ++ ++ wpa_printf(MSG_DEBUG, "realtek_configure_wpa +++ pairwise: 0x%x key_mgmt: 0x%x", ++ params->pairwise_suite, params->key_mgmt_suite); ++ ++ //wpa_hexdump(999, "wpa_ie", params->wpa_ie, params->wpa_ie_len); //_Eric ++ ++ if (params->pairwise_suite & CIPHER_CCMP) ++ cipher |= 1<<IEEE80211_CIPHER_AES_CCM; ++ if (params->pairwise_suite & CIPHER_TKIP) ++ cipher |= 1<<IEEE80211_CIPHER_TKIP; ++ if (params->pairwise_suite & CIPHER_NONE) ++ cipher |= 1<<IEEE80211_CIPHER_NONE; ++ ++ if(params->wpa_ie[0] == 0x30) ++ wpa = 2; ++ else if (params->wpa_ie[0] == 0xdd) ++ { ++ if(params->wpa_ie[5] == 0x1) ++ wpa = 1; ++ else if(params->wpa_ie[5] == 0x4) //for WPS ++ return wpa_driver_realtek_set_wpa_ie(drv, params->wpa_ie, params->wpa_ie_len); ++ } ++ ++ wpa_printf(MSG_DEBUG, "wpa:%d, pairwise: 0x%x, cipher:0x%x", wpa, params->pairwise_suite, params->key_mgmt_suite); ++ ++ if(params->key_mgmt_suite & KEY_MGMT_PSK) ++ {//PSK mode, set PSK & cipher ++ ++ if (set80211param(drv, IEEE80211_PARAM_KEYMGTALGS, wpa, 1)) ++ { ++ wpa_printf(MSG_ERROR, "Unable to set key management algorithms"); ++ return -1; ++ } ++ ++ if (set80211param(drv, IEEE80211_PARAM_UCASTCIPHERS, cipher, 1)) ++ { ++ wpa_printf(MSG_ERROR, "Unable to set pairwise key ciphers"); ++ return -1; ++ } ++ ++ } ++ else ++ {//Enterprise mode, Disable PSK & set cipher. ++ if (set80211param(drv, IEEE80211_PARAM_KEYMGTALGS, 0, 1)) ++ { ++ wpa_printf(MSG_ERROR, "Unable to set key management algorithms"); ++ return -1; ++ } ++ if (set80211param(drv, IEEE80211_PARAM_UCASTCIPHERS, cipher, 1)) ++ { ++ wpa_printf(MSG_ERROR, "Unable to set pairwise key ciphers"); ++ return -1; ++ } ++ ++ } ++ ++ if (set80211param(drv, IEEE80211_PARAM_WPA, wpa, 1)) ++ { ++ wpa_printf(MSG_ERROR, "Unable to set WPA"); ++ return -1; ++ } ++ ++ if (set80211param(drv, IEEE80211_PARAM_AUTHMODE, IEEE80211_AUTH_WPA, 1)) ++ { ++ wpa_printf(MSG_ERROR, "Unable to Authmode"); ++ return -1; ++ } ++ ++ return wpa_driver_realtek_set_wpa_ie(drv, params->wpa_ie, params->wpa_ie_len); ++ ++ ++} ++ ++ ++static int ++realtek_config_security(struct wpa_driver_realtek_data *drv, struct wpa_driver_associate_params *params) ++{ ++ int wep_keyidx = params->wep_tx_keyidx; ++ int wep_keylen = params->wep_key_len[wep_keyidx]; ++ ++ printf("Wpa_supplicant: %s +++\n", __FUNCTION__); ++ ++ if(set80211param(drv, IEEE80211_PARAM_UCASTKEYLEN, wep_keylen, 1)) ++ return -1; ++ ++ if(params->wep_key_len[wep_keyidx] > 0) ++ { ++ ++ struct rtk_wpas_config config; ++ ++ wpa_printf(MSG_DEBUG, "wep_key_len %d", params->wep_key_len[wep_keyidx]); ++ ++ memset(&config, 0, sizeof(config)); ++ ++ config.type = WPAS_CONFIG_WEPKEY; ++ ++ config.wep_keyidx = wep_keyidx; ++ config.wep_keylen = wep_keylen; ++ ++ memcpy(config.wep_key, params->wep_key[wep_keyidx], wep_keylen); ++ ++#ifdef RTK_INBAND_LE ++ config.wep_keyidx = htonl(config.wep_keyidx); ++ config.wep_keylen = htonl(config.wep_keylen); ++#endif ++ ++ if(set80211priv(drv, WPAS_IOCTL_CUSTOM, &config, sizeof(config), 1)) ++ { ++ wpa_printf(MSG_ERROR, "%s: Failed to set Configurations", __func__); ++ return -1; ++ } ++ } ++ ++ if (params->wpa_ie_len == 0) ++ { ++ wpa_driver_realtek_set_wpa_ie(drv, params->wpa_ie, params->wpa_ie_len); ++ ++ wpa_printf(MSG_DEBUG, "set WEP: auth_alg %d", params->auth_alg); ++ /* Set interface up flags after setting authentication modes, ++ done atlast in realtek_commit() */ ++ if(params->auth_alg == AUTH_ALG_OPEN_SYSTEM) ++ return set80211param(drv, IEEE80211_PARAM_AUTHMODE, IEEE80211_AUTH_OPEN, 1); ++ else if(params->auth_alg == AUTH_ALG_SHARED_KEY) ++ return set80211param(drv, IEEE80211_PARAM_AUTHMODE, IEEE80211_AUTH_SHARED, 1); ++ else if(params->auth_alg == 0x3) ++ return set80211param(drv, IEEE80211_PARAM_AUTHMODE, IEEE80211_AUTH_AUTO, 1); ++ else if(params->auth_alg == 0x8) //RTK_WPAS, add auth_algs=BIT(3) as value of none authentication. ++ return set80211param(drv, IEEE80211_PARAM_AUTHMODE, IEEE80211_AUTH_NONE, 1); ++ } ++ ++ if (params->key_mgmt_suite & KEY_MGMT_802_1X ) ++ { ++ wpa_printf(MSG_DEBUG, "set 8021X"); ++ if(set80211param(drv, IEEE80211_PARAM_AUTHMODE, IEEE80211_AUTH_8021X, 1)) ++ return -1; ++ } ++ else if (params->wpa_ie_len > 0 ) ++ { ++ return realtek_configure_wpa(drv, params); ++ } ++ else ++ { ++ printf("No 802.1X or WPA enabled!"); ++ return -1; ++ } ++ ++ return 0; ++ ++} ++ ++//_Eric ?? static int error on PC ?? ++int ++wpa_driver_realtek_set_wpa_ie(struct wpa_driver_realtek_data *drv, const u8 *wpa_ie, size_t wpa_ie_len) ++{ ++ struct iwreq iwr; ++ ++ printf("Wpa_supplicant: %s +++\n", __FUNCTION__); ++ ++ os_memset(&iwr, 0, sizeof(iwr)); ++ os_strlcpy(iwr.ifr_name, drv->ifname, IFNAMSIZ); ++ /* NB: SETOPTIE is not fixed-size so must not be inlined */ ++ iwr.u.data.pointer = (void *) wpa_ie; ++ iwr.u.data.length = wpa_ie_len; ++ ++#ifdef RTK_INBAND ++ if (inband_ioctl(IEEE80211_IOCTL_SETOPTIE, &iwr) < 0) ++#else ++ if (ioctl(drv->sock, IEEE80211_IOCTL_SETOPTIE, &iwr) < 0) ++#endif ++ { ++ perror("ioctl[IEEE80211_IOCTL_SETOPTIE]"); ++ return -1; ++ } ++ ++ return 0; ++} ++ ++static int ++wpa_driver_realtek_del_key(struct wpa_driver_realtek_data *drv, int key_idx, ++ const u8 *addr) ++{ ++ struct ieee80211req_del_key wk; ++ ++ printf("Wpa_supplicant: %s +++\n", __FUNCTION__); ++ ++ wpa_printf(MSG_DEBUG, "%s: keyidx=%d", __FUNCTION__, key_idx); ++ os_memset(&wk, 0, sizeof(wk)); ++ ++ wk.idk_keyix = key_idx; ++ ++ if (addr != NULL) ++ os_memcpy(wk.idk_macaddr, addr, IEEE80211_ADDR_LEN); ++ ++ return set80211priv(drv, IEEE80211_IOCTL_DELKEY, &wk, sizeof(wk), 1); ++ ++} ++ ++static int ++wpa_driver_realtek_set_key(void *priv, wpa_alg alg, ++ const u8 *addr, int key_idx, int set_tx, ++ const u8 *seq, size_t seq_len, ++ const u8 *key, size_t key_len) ++{ ++ struct wpa_driver_realtek_data *drv = priv; ++ struct ieee80211req_key wk; ++ char *alg_name; ++ u_int8_t cipher; ++ ++ ++ if (alg == WPA_ALG_NONE) ++ return wpa_driver_realtek_del_key(drv, key_idx, addr); ++ ++ printf("Wpa_supplicant: %s +++\n", __FUNCTION__); ++ ++ switch (alg) { ++ case WPA_ALG_WEP: ++ alg_name = "WEP"; ++ cipher = IEEE80211_CIPHER_WEP; ++ break; ++ case WPA_ALG_TKIP: ++ alg_name = "TKIP"; ++ cipher = IEEE80211_CIPHER_TKIP; ++ break; ++ case WPA_ALG_CCMP: ++ alg_name = "CCMP"; ++ cipher = IEEE80211_CIPHER_AES_CCM; ++ break; ++ default: ++ wpa_printf(MSG_DEBUG, "%s: unknown/unsupported algorithm %d", ++ __FUNCTION__, alg); ++ return -1; ++ } ++ ++ wpa_printf(MSG_DEBUG, "%s: alg=%s key_idx=%d set_tx=%d seq_len=%lu " ++ "key_len=%lu", __FUNCTION__, alg_name, key_idx, set_tx, ++ (unsigned long) seq_len, (unsigned long) key_len); ++ ++ if (seq_len > sizeof(u_int64_t)) { ++ wpa_printf(MSG_DEBUG, "%s: seq_len %lu too big", ++ __FUNCTION__, (unsigned long) seq_len); ++ return -2; ++ } ++ if (key_len > sizeof(wk.ik_keydata)) { ++ wpa_printf(MSG_DEBUG, "%s: key length %lu too big", ++ __FUNCTION__, (unsigned long) key_len); ++ return -3; ++ } ++ ++ os_memset(&wk, 0, sizeof(wk)); ++ wk.ik_type = cipher; ++ wk.ik_flags = IEEE80211_KEY_RECV; ++ if (addr == NULL || ++ os_memcmp(addr, "\xff\xff\xff\xff\xff\xff", ETH_ALEN) == 0) ++ wk.ik_flags |= IEEE80211_KEY_GROUP; ++ if (set_tx) { ++ wk.ik_flags |= IEEE80211_KEY_XMIT | IEEE80211_KEY_DEFAULT; ++ os_memcpy(wk.ik_macaddr, addr, IEEE80211_ADDR_LEN); ++ } else ++ os_memset(wk.ik_macaddr, 0, IEEE80211_ADDR_LEN); ++ wk.ik_keyix = key_idx; ++ wk.ik_keylen = key_len; ++#ifdef WORDS_BIGENDIAN //_Eric ?? Endian problem ? HAPD not identify ? ++#define WPA_KEY_RSC_LEN 8 ++ { ++ size_t i; ++ u8 tmp[WPA_KEY_RSC_LEN]; ++ os_memset(tmp, 0, sizeof(tmp)); ++ for (i = 0; i < seq_len; i++) ++ tmp[WPA_KEY_RSC_LEN - i - 1] = seq[i]; ++ os_memcpy(&wk.ik_keyrsc, tmp, WPA_KEY_RSC_LEN); ++ } ++#else /* WORDS_BIGENDIAN */ ++ os_memcpy(&wk.ik_keyrsc, seq, seq_len); ++#endif /* WORDS_BIGENDIAN */ ++ ++ os_memcpy(wk.ik_keydata, key, key_len); ++ ++#ifdef RTK_INBAND_LE ++ wk.ik_keyix = htons(wk.ik_keyix); ++ wk.ik_keyrsc = htonll(wk.ik_keyrsc); ++#endif ++ ++ return set80211priv(drv, IEEE80211_IOCTL_SETKEY, &wk, sizeof(wk), 1); ++} ++ ++static int ++wpa_driver_realtek_set_countermeasures(void *priv, int enabled) ++{ ++ struct wpa_driver_realtek_data *drv = priv; ++ ++ printf("Wpa_supplicant: %s +++\n", __FUNCTION__); ++ wpa_printf(MSG_DEBUG, "%s: enabled=%d", __FUNCTION__, enabled); ++ return set80211param(drv, IEEE80211_PARAM_COUNTERMEASURES, enabled, 1); ++} ++ ++ ++static int ++wpa_driver_realtek_set_drop_unencrypted(void *priv, int enabled) ++{ ++ struct wpa_driver_realtek_data *drv = priv; ++ ++ printf("Wpa_supplicant: %s +++\n", __FUNCTION__); ++ wpa_printf(MSG_DEBUG, "%s: enabled=%d", __FUNCTION__, enabled); ++ return set80211param(drv, IEEE80211_PARAM_DROPUNENCRYPTED, enabled, 1); ++} ++ ++static int ++wpa_driver_realtek_deauthenticate(void *priv, const u8 *addr, int reason_code) ++{ ++ struct wpa_driver_realtek_data *drv = priv; ++ struct ieee80211req_mlme mlme; ++ ++ printf("Wpa_supplicant: %s +++\n", __FUNCTION__); ++ wpa_printf(MSG_DEBUG, "%s", __FUNCTION__); ++ mlme.im_op = IEEE80211_MLME_DEAUTH; ++ mlme.im_reason = reason_code; ++ os_memcpy(mlme.im_macaddr, addr, IEEE80211_ADDR_LEN); ++ ++#ifdef RTK_INBAND_LE ++ mlme.im_reason = htons(mlme.im_reason); ++#endif ++ return set80211priv(drv, IEEE80211_IOCTL_SETMLME, &mlme, sizeof(mlme), 1); ++} ++ ++static int ++wpa_driver_realtek_disassociate(void *priv, const u8 *addr, int reason_code) ++{ ++ struct wpa_driver_realtek_data *drv = priv; ++ struct ieee80211req_mlme mlme; ++ ++ printf("Wpa_supplicant: %s +++\n", __FUNCTION__); ++ ++ wpa_printf(MSG_DEBUG, "%s", __FUNCTION__); ++ mlme.im_op = IEEE80211_MLME_DISASSOC; ++ mlme.im_reason = reason_code; ++ os_memcpy(mlme.im_macaddr, addr, IEEE80211_ADDR_LEN); ++ ++#ifdef RTK_INBAND_LE ++ mlme.im_reason = htons(mlme.im_reason); ++#endif ++ return set80211priv(drv, IEEE80211_IOCTL_SETMLME, &mlme, sizeof(mlme), 1); ++} ++ ++static int ++wpa_driver_realtek_associate(void *priv, ++ struct wpa_driver_associate_params *params) ++{ ++ struct wpa_driver_realtek_data *drv = priv; ++ struct ieee80211req_mlme mlme; ++ int ret = 0, privacy = 1; ++ ++ printf("Wpa_supplicant: %s +++\n", __FUNCTION__); ++ ++ wpa_printf(MSG_DEBUG, "%s", __FUNCTION__); ++ ++ //_Eric ?? if ret = -1, why still run continuously? ++ ++ if(realtek_config_security(drv, params) < 0) ++ ret = -9; ++ ++ if (params->bssid == NULL) { ++ ++ //_Eric ?? it means no MAC but have SSID(name), driver shall try to find this AP automatically? ++ ++ if (set80211param(drv, IEEE80211_PARAM_ROAMING, 0, 1) < 0) ++ ret = -2; ++ ++ if (wpa_driver_wext_set_ssid(drv->wext, params->ssid, ++ params->ssid_len) < 0) ++ ret = -3; ++ ++ } else { ++ if (set80211param(drv, IEEE80211_PARAM_ROAMING, 2, 1) < 0) ++ ret = -4; ++ if (wpa_driver_wext_set_ssid(drv->wext, params->ssid, ++ params->ssid_len) < 0) ++ ret = -5; ++ os_memset(&mlme, 0, sizeof(mlme)); ++ mlme.im_op = IEEE80211_MLME_ASSOC; ++ os_memcpy(mlme.im_macaddr, params->bssid, IEEE80211_ADDR_LEN); ++ ++ printf("Try to assoc %02x:%02x:%02x:%02x:%02x:%02x \n", ++ params->bssid[0], params->bssid[1], params->bssid[2], ++ params->bssid[3], params->bssid[4], params->bssid[5]); ++ ++ if (set80211priv(drv, IEEE80211_IOCTL_SETMLME, &mlme, ++ sizeof(mlme), 1) < 0) { ++ wpa_printf(MSG_DEBUG, "%s: SETMLME[ASSOC] failed", ++ __func__); ++ ret = -1; ++ } ++ } ++ ++ printf("Wpa_supplicant: %s --- ret = %d\n", __FUNCTION__, ret); ++ ++ return ret; ++ ++} ++ ++static int ++wpa_driver_realtek_set_auth_alg(void *priv, int auth_alg) ++{ ++ struct wpa_driver_realtek_data *drv = priv; ++ int authmode; ++ ++ printf("Wpa_supplicant: %s +++ auth_alg = %d\n", __FUNCTION__, auth_alg); ++ ++ if ((auth_alg & AUTH_ALG_OPEN_SYSTEM) && ++ (auth_alg & AUTH_ALG_SHARED_KEY)) ++ authmode = IEEE80211_AUTH_AUTO; ++ else if (auth_alg & AUTH_ALG_SHARED_KEY) ++ authmode = IEEE80211_AUTH_SHARED; ++ else ++ authmode = IEEE80211_AUTH_OPEN; ++ ++ return set80211param(drv, IEEE80211_PARAM_AUTHMODE, authmode, 1); ++} ++ ++static int ++wpa_driver_realtek_scan(void *priv, const u8 *ssid, size_t ssid_len) ++{ ++ struct wpa_driver_realtek_data *drv = priv; ++ struct iwreq iwr; ++ int ret = 0; ++ ++ printf("Wpa_supplicant: %s +++\n", __FUNCTION__); ++ ++ os_memset(&iwr, 0, sizeof(iwr)); ++ os_strlcpy(iwr.ifr_name, drv->ifname, IFNAMSIZ); ++ ++ if (wpa_driver_wext_set_ssid(drv->wext, ssid, ssid_len) < 0) ++ ret = -1; ++ ++#ifdef RTK_INBAND ++ if (inband_ioctl(SIOCSIWSCAN, &iwr) < 0) ++#else ++ if (ioctl(drv->sock, SIOCSIWSCAN, &iwr) < 0) ++#endif ++ { ++ perror("ioctl[SIOCSIWSCAN]"); ++ ret = -1; ++ } ++ ++ eloop_cancel_timeout(wpa_driver_wext_scan_timeout, drv->wext, ++ drv->ctx); ++ eloop_register_timeout(30, 0, wpa_driver_wext_scan_timeout, drv->wext, ++ drv->ctx); ++ ++ return ret; ++} ++ ++static int wpa_driver_realtek_get_bssid(void *priv, u8 *bssid) ++{ ++ struct wpa_driver_realtek_data *drv = priv; ++ printf("Wpa_supplicant: %s +++\n", __FUNCTION__); ++ return wpa_driver_wext_get_bssid(drv->wext, bssid); ++} ++ ++ ++static int wpa_driver_realtek_get_ssid(void *priv, u8 *ssid) ++{ ++ struct wpa_driver_realtek_data *drv = priv; ++ printf("Wpa_supplicant: %s +++\n", __FUNCTION__); ++ return wpa_driver_wext_get_ssid(drv->wext, ssid); ++} ++ ++ ++static struct wpa_scan_results * ++wpa_driver_realtek_get_scan_results(void *priv) ++{ ++ struct wpa_driver_realtek_data *drv = priv; ++ printf("Wpa_supplicant: %s +++\n", __FUNCTION__); ++ return wpa_driver_wext_get_scan_results(drv->wext); ++} ++ ++ ++static int wpa_driver_realtek_set_operstate(void *priv, int state) ++{ ++ struct wpa_driver_realtek_data *drv = priv; ++ printf("Wpa_supplicant: %s +++\n", __FUNCTION__); ++ return wpa_driver_wext_set_operstate(drv->wext, state); ++} ++ ++ ++static int wpa_driver_realtek_mlme_setprotection(void *priv, const u8 *addr, int protect_type, int key_type) ++{ ++ struct wpa_driver_realtek_data *drv = priv; ++ struct ieee80211req_mlme mlme; ++ ++ printf("Wpa_supplicant: %s +++\n", __FUNCTION__); ++ ++ if(protect_type == MLME_SETPROTECTION_KEY_TYPE_PAIRWISE) ++ { ++ if(protect_type != MLME_SETPROTECTION_PROTECT_TYPE_NONE) ++ mlme.im_op = IEEE80211_MLME_AUTHORIZE; ++ else ++ mlme.im_op = IEEE80211_MLME_UNAUTHORIZE; ++ } ++ else ++ return 0; ++ ++ os_memcpy(mlme.im_macaddr, addr, IEEE80211_ADDR_LEN); ++ ++ return set80211priv(drv, IEEE80211_IOCTL_SETMLME, &mlme, sizeof(mlme), 1); ++ ++} ++ ++ ++static int wpa_driver_realtek_set_probe_req_ie(void *priv, const u8 *ies, ++ size_t ies_len) ++{ ++ struct ieee80211req_getset_appiebuf *probe_req_ie; ++ int ret; ++ ++ printf("Wpa_supplicant: %s +++\n", __FUNCTION__); ++ ++ probe_req_ie = os_malloc(sizeof(*probe_req_ie) + ies_len); ++ if (probe_req_ie == NULL) ++ return -1; ++ ++ probe_req_ie->app_frmtype = IEEE80211_APPIE_FRAME_PROBE_REQ; ++ probe_req_ie->app_buflen = ies_len; ++ os_memcpy(probe_req_ie->app_buf, ies, ies_len); ++ ++#ifdef RTK_INBAND_LE ++ probe_req_ie->app_frmtype = htonl(probe_req_ie->app_frmtype); ++ probe_req_ie->app_buflen = htonl(probe_req_ie->app_buflen); ++#endif ++ ++ ret = set80211priv(priv, IEEE80211_IOCTL_SET_APPIEBUF, probe_req_ie, ++ sizeof(struct ieee80211req_getset_appiebuf) + ++ ies_len, 1); ++ ++ os_free(probe_req_ie); ++ ++ return ret; ++} ++ ++ ++static void * wpa_driver_realtek_init(void *ctx, const char *ifname) ++{ ++ struct wpa_driver_realtek_data *drv; ++ struct iwreq iwr; ++ struct rtk_wpas_config config; ++ struct wpa_supplicant *wpa_s = (struct wpa_supplicant *)ctx; ++ ++ printf("Wpa_supplicant: %s +++\n", __FUNCTION__); ++ ++ drv = os_zalloc(sizeof(*drv)); ++ if (drv == NULL) ++ return NULL; ++ ++ drv->ctx = ctx; ++ os_strlcpy(drv->ifname, ifname, sizeof(drv->ifname)); ++ drv->sock = socket(PF_INET, SOCK_DGRAM, 0); ++ if (drv->sock < 0) ++ goto fail; ++ ++ if (set80211param(drv, IEEE80211_PARAM_ROAMING, 2, 1) < 0) { ++ wpa_printf(MSG_DEBUG, "%s: failed to set wpa_supplicant-based " ++ "roaming", __FUNCTION__); ++ goto fail; ++ } ++ ++ if (set80211param(drv, IEEE80211_PARAM_WPA, 3, 1) < 0) { ++ wpa_printf(MSG_DEBUG, "%s: failed to enable WPA support", ++ __FUNCTION__); ++ goto fail; ++ } ++ ++ ++ memset(&config, 0, sizeof(config)); ++ ++ config.is_hapd = 0; ++ config.type = WPAS_CONFIG_MIB; ++ config.bandmode = wpa_s->conf->macPhyMode; ++ config.phymode = wpa_s->conf->phyBandSelect; ++ ++ if(set80211priv(drv, WPAS_IOCTL_CUSTOM, &config, sizeof(config), 1)) { ++ wpa_printf(MSG_ERROR, "%s: Failed to set Configurations", ++ __FUNCTION__); ++ goto fail; ++ } ++ ++ drv->wext = wpa_driver_wext_init(ctx, ifname); ++ if (drv->wext == NULL) ++ goto fail; ++ ++ printf("Wait 5 seconds for driver init ...\n"); ++ sleep(5); ++ ++ os_memset(&iwr, 0, sizeof(iwr)); ++ os_strlcpy(iwr.ifr_name, drv->ifname, IFNAMSIZ); ++ ++#ifdef RTK_INBAND ++ if (inband_ioctl(SIOCSIWSCAN, &iwr) < 0) ++#else ++ if (ioctl(drv->sock, SIOCSIWSCAN, &iwr) < 0) ++#endif ++ { ++ perror("ioctl[SIOCSIWSCAN] of init"); ++ goto fail; ++ } ++ else{ ++ printf("Wait 5 seconds for scanning ...\n"); ++ sleep(5); ++ } ++ ++ return drv; ++ ++ ++fail: ++ close(drv->sock); ++ os_free(drv); ++ return NULL; ++} ++ ++ ++static void wpa_driver_realtek_deinit(void *priv) ++{ ++ struct wpa_driver_realtek_data *drv = priv; ++ ++ printf("Wpa_supplicant: %s +++\n", __FUNCTION__); ++ ++ if (wpa_driver_realtek_set_wpa_ie(drv, NULL, 0) < 0) { ++ wpa_printf(MSG_DEBUG, "%s: failed to clear WPA IE", ++ __FUNCTION__); ++ } ++ if (set80211param(drv, IEEE80211_PARAM_ROAMING, 0, 1) < 0) { ++ wpa_printf(MSG_DEBUG, "%s: failed to enable driver-based " ++ "roaming", __FUNCTION__); ++ } ++ if (set80211param(drv, IEEE80211_PARAM_PRIVACY, 0, 1) < 0) { ++ wpa_printf(MSG_DEBUG, "%s: failed to disable forced Privacy " ++ "flag", __FUNCTION__); ++ } ++ if (set80211param(drv, IEEE80211_PARAM_WPA, 0, 1) < 0) { ++ wpa_printf(MSG_DEBUG, "%s: failed to disable WPA", ++ __FUNCTION__); ++ } ++ ++ wpa_driver_wext_deinit(drv->wext); ++ ++ close(drv->sock); ++ os_free(drv); ++} ++ ++ ++const struct wpa_driver_ops wpa_driver_realtek_ops = { ++ .name = "realtek", ++ .desc = "realtek 802.11 support (Atheros, etc.)", ++ .get_bssid = wpa_driver_realtek_get_bssid, ++ .get_ssid = wpa_driver_realtek_get_ssid, ++ .set_key = wpa_driver_realtek_set_key, ++ .init = wpa_driver_realtek_init, ++ .deinit = wpa_driver_realtek_deinit, ++ .set_countermeasures = wpa_driver_realtek_set_countermeasures, ++ .set_drop_unencrypted = wpa_driver_realtek_set_drop_unencrypted, ++ .scan = wpa_driver_realtek_scan, ++ .get_scan_results2 = wpa_driver_realtek_get_scan_results, ++ .deauthenticate = wpa_driver_realtek_deauthenticate, ++ .disassociate = wpa_driver_realtek_disassociate, ++ .associate = wpa_driver_realtek_associate, ++ .set_auth_alg = wpa_driver_realtek_set_auth_alg, ++ .set_operstate = wpa_driver_realtek_set_operstate, ++ .mlme_setprotection = wpa_driver_realtek_mlme_setprotection, ++ .set_probe_req_ie = wpa_driver_realtek_set_probe_req_ie, ++}; +Index: hostapd-rtk-0.6.10/src/drivers/driver_realtek.h +=================================================================== +--- /dev/null ++++ hostapd-rtk-0.6.10/src/drivers/driver_realtek.h +@@ -0,0 +1,159 @@ ++ ++ ++#define MACADDRLEN 6 ++#define PROBEIELEN 260 ++ ++#define REQIELEN 123 ++#define RESPIELEN 123 ++ ++#define HAPD_IOCTL_GETWPAIE IEEE80211_IOCTL_GET_APPIEBUF ++#define HAPD_IOCTL_SETCONFIG SIOCIWLASTPRIV ++#define RTL8192CD_IOCTL_DEL_STA 0x89f7 ++#define SIOCGIWIND 0x89ff ++ ++#define HOSTAPD_WPA_VERSION_WPA BIT(0) ++#define HOSTAPD_WPA_VERSION_WPA2 BIT(1) ++ ++#define WPAS_IOCTL_CUSTOM SIOCIWLASTPRIV //0x8BFF ++ ++enum WPAS_EVENT{ ++ WPAS_EXIRED = 10, ++ WPAS_REGISTERED = 11, ++ WPAS_MIC_FAILURE = 12, ++ WPAS_ASSOC_INFO = 13, ++ WPAS_SCAN_DONE = 14 ++}; ++ ++enum WIFI_STATUS_CODE { ++ _STATS_SUCCESSFUL_ = 0, // Success. ++ _STATS_FAILURE_ = 1, // Failure. ++ _STATS_CAP_FAIL_ = 10, // Capability too wide, can't support ++ _STATS_NO_ASOC_ = 11, // Denial reassociate ++ _STATS_OTHER_ = 12, // Denial connect, not 802.11 standard. ++ _STATS_NO_SUPP_ALG_ = 13, // Authenticate algorithm not support . ++ _STATS_OUT_OF_AUTH_SEQ_ = 14, // Out of authenticate sequence number. ++ _STATS_CHALLENGE_FAIL_ = 15, // Denial authenticate, Response message fail. ++ _STATS_AUTH_TIMEOUT_ = 16, // Denial authenticate, timeout. ++ _STATS_UNABLE_HANDLE_STA_ = 17, // Denial authenticate, BS resoruce insufficient. ++ _STATS_RATE_FAIL_ = 18, // Denial authenticate, STA not support BSS request datarate. ++ _STATS_REQ_DECLINED_ = 37, ++/*#if defined(CONFIG_RTL_WAPI_SUPPORT)*/ ++ __STATS_INVALID_IE_ = 40, ++ __STATS_INVALID_AKMP_ = 43, ++ __STATS_CIPER_REJECT_ = 46, ++ __STATS_INVALID_USK_ = 47, ++ __STATS_INVALID_MSK_ = 48, ++ __STATS_INVALID_WAPI_VERSION_ = 49, ++ __STATS_INVALID_WAPI_CAPABILITY_ = 50, ++/*#endif*/ ++ ++#ifdef CONFIG_RTK_MESH // CATUTION: below undefine !! (Refer: Draft 1.06, Page 17, 7.3.1.9, Table 7-23, 2007/08/13 by popen) ++ _STATS_MESH_LINK_ESTABLISHED_ = 55, //The mesh peer link has been successfully ++ _STATS_MESH_LINK_CLOSED_ = 56, // The mesh peer link has been closed completely ++ _STATS_MESH_UNDEFINE1_ = 57, // No listed Key Holder Transport type is supported. ++ _STATS_MESH_UNDEFINE2_ = 58, // The Mesh Key Holder Security Handshake message was malformed. ++#endif ++}; ++ ++typedef enum{ ++ DOT11_EVENT_NO_EVENT = 1, ++ DOT11_EVENT_REQUEST = 2, ++ DOT11_EVENT_ASSOCIATION_IND = 3, ++ DOT11_EVENT_ASSOCIATION_RSP = 4, ++ DOT11_EVENT_AUTHENTICATION_IND = 5, ++ DOT11_EVENT_REAUTHENTICATION_IND = 6, ++ DOT11_EVENT_DEAUTHENTICATION_IND = 7, ++ DOT11_EVENT_DISASSOCIATION_IND = 8, ++ DOT11_EVENT_DISCONNECT_REQ = 9, ++ DOT11_EVENT_SET_802DOT11 = 10, ++ DOT11_EVENT_SET_KEY = 11, ++ DOT11_EVENT_SET_PORT = 12, ++ DOT11_EVENT_DELETE_KEY = 13, ++ DOT11_EVENT_SET_RSNIE = 14, ++ DOT11_EVENT_GKEY_TSC = 15, ++ DOT11_EVENT_MIC_FAILURE = 16, ++ DOT11_EVENT_ASSOCIATION_INFO = 17, ++ DOT11_EVENT_INIT_QUEUE = 18, ++ DOT11_EVENT_EAPOLSTART = 19, ++//2003-07-30 ------------ ++ DOT11_EVENT_ACC_SET_EXPIREDTIME = 31, ++ DOT11_EVENT_ACC_QUERY_STATS = 32, ++ DOT11_EVENT_ACC_QUERY_STATS_ALL = 33, ++//----------------------- ++ ++// --- 2003-08-04 --- ++ DOT11_EVENT_REASSOCIATION_IND = 34, ++ DOT11_EVENT_REASSOCIATION_RSP = 35, ++//----------------------- ++ DOT11_EVENT_STA_QUERY_BSSID = 36, ++ DOT11_EVENT_STA_QUERY_SSID = 37, ++ ++// jimmylin: pass EAP packet by event queue ++ DOT11_EVENT_EAP_PACKET = 41, ++ ++#ifdef RTL_WPA2 ++ DOT11_EVENT_EAPOLSTART_PREAUTH = 45, ++ DOT11_EVENT_EAP_PACKET_PREAUTH = 46, ++#endif ++ ++#ifdef RTL_WPA2_CLIENT ++ DOT11_EVENT_WPA2_MULTICAST_CIPHER = 47, ++#endif ++ ++ DOT11_EVENT_WPA_MULTICAST_CIPHER = 48, ++ ++#ifdef AUTO_CONFIG ++ DOT11_EVENT_AUTOCONF_ASSOCIATION_IND = 50, ++ DOT11_EVENT_AUTOCONF_ASSOCIATION_CONFIRM = 51, ++ DOT11_EVENT_AUTOCONF_PACKET = 52, ++ DOT11_EVENT_AUTOCONF_LINK_IND = 53, ++#endif ++ ++#ifdef WIFI_SIMPLE_CONFIG ++ DOT11_EVENT_WSC_SET_IE = 55, ++ DOT11_EVENT_WSC_PROBE_REQ_IND = 56, ++ DOT11_EVENT_WSC_PIN_IND = 57, ++ DOT11_EVENT_WSC_ASSOC_REQ_IE_IND = 58, ++#ifdef CONFIG_IWPRIV_INTF ++ DOT11_EVENT_WSC_START_IND = 70, ++ //EV_MODE, EV_STATUS, EV_MEHOD, EV_STEP, EV_OOB ++ DOT11_EVENT_WSC_MODE_IND = 71, ++ DOT11_EVENT_WSC_STATUS_IND = 72, ++ DOT11_EVENT_WSC_METHOD_IND = 73, ++ DOT11_EVENT_WSC_STEP_IND = 74, ++ DOT11_EVENT_WSC_OOB_IND = 75, ++#endif //ifdef CONFIG_IWPRIV_INTF ++#endif ++ ++ DOT11_EVENT_MAX = 59, ++} DOT11_EVENT; ++ ++ ++typedef struct _DOT11_PROBE_REQUEST_IND{ ++ unsigned char EventId; ++ unsigned char IsMoreEvent; ++ char MACAddr[MACADDRLEN]; ++ unsigned short ProbeIELen; ++ char ProbeIE[PROBEIELEN]; ++}DOT11_PROBE_REQUEST_IND; ++ ++ ++typedef struct _DOT11_ASSOCIATION_RSP{ ++ unsigned char EventId; ++ unsigned char IsMoreEvent; ++ char MACAddr[MACADDRLEN]; ++ unsigned char Status; ++}DOT11_ASSOCIATION_RSP; ++ ++ ++typedef struct _WPAS_ASSOCIATION_INFO ++{ ++ unsigned short ReqIELen; ++ char ReqIE[REQIELEN]; ++ unsigned short RespIELen; ++ char RespIE[RESPIELEN]; ++} WPAS_ASSOCIATION_INFO; ++ ++ ++//_Eric ?? Put these inot net80211 will be better?? ++ +Index: hostapd-rtk-0.6.10/src/drivers/driver_realtek_wext.c +=================================================================== +--- /dev/null ++++ hostapd-rtk-0.6.10/src/drivers/driver_realtek_wext.c +@@ -0,0 +1,1787 @@ ++/* ++ * WPA Supplicant - driver interaction with generic Linux Wireless Extensions ++ * Copyright (c) 2003-2007, Jouni Malinen <j@w1.fi> ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * Alternatively, this software may be distributed under the terms of BSD ++ * license. ++ * ++ * See README and COPYING for more details. ++ * ++ * This file implements a driver interface for the Linux Wireless Extensions. ++ * When used with WE-18 or newer, this interface can be used as-is with number ++ * of drivers. In addition to this, some of the common functions in this file ++ * can be used by other driver interface implementations that use generic WE ++ * ioctls, but require private ioctls for some of the functionality. ++ */ ++ ++#include "includes.h" ++#include <sys/ioctl.h> ++#include <net/if_arp.h> ++ ++#include "wireless_copy.h" ++#include "common.h" ++#include "driver.h" ++#include "eloop.h" ++#include "priv_netlink.h" ++#include "driver_realtek_wext.h" ++#include "ieee802_11_defs.h" ++#include "wpa_common.h" ++ ++#include "driver_realtek.h" ++ ++ ++#ifdef RTK_INBAND ++#define INBAND_INTF "br0" ++#define INBAND_SLAVE ("001234567899") ++#define INBAND_IOCTL_TYPE 0x8899 ++#define INBAND_NETLINK_TYPE 0x9000 ++#define INBAND_DEBUG 0 ++#define INBAND_IOCTLPKT_DUMP //hex_dump ++#define IWREQ_LEN 32 ++#define INBAND_IOCTLTYPE_LEN 4 ++#define INBAND_IOCTLHDR_LEN 6 ++#define INBAND_PENDING_START(data) data+INBAND_IOCTLHDR_LEN+IWREQ_LEN ++#define INBAND_IOCTLRET_PTR(data) data+INBAND_IOCTLTYPE_LEN ++#define IOH_HDR_LEN sizeof(struct ioh_header) ++#endif ++ ++ ++static int wpa_driver_wext_flush_pmkid(void *priv); ++static int wpa_driver_wext_get_range(void *priv); ++static void wpa_driver_wext_finish_drv_init(struct wpa_driver_wext_data *drv); ++static void wpa_driver_wext_disconnect(struct wpa_driver_wext_data *drv); ++ ++ ++void convert_to_net (const char *name, void *data, int data_size) ++{ ++ //_Eric ?? signed ?? unsigned ?? ++ ++ if(data_size == 16) ++ { ++ u16 *tmp = (u16 *)data; ++ printf("htons +++ %s = 0x%x", name, *tmp); ++ *tmp = htons(*tmp); ++ printf("htons --- %s = 0x%x", name, *tmp); ++ } ++ else if(data_size == 32) ++ { ++ u32 *tmp = (u32 *)data; ++ printf("htonl +++ %s = 0x%x", name, *tmp); ++ *tmp = htonl(*tmp); ++ printf("htonl --- %s = 0x%x", name, *tmp); ++ } ++ else ++ printf("Unknown data type !!!! %s size = %d\n", name, data_size); ++ ++} ++ ++ ++void convert_to_host (const char *name, void *data, int data_size) ++{ ++ //_Eric ?? signed ?? unsigned ?? ++ ++ if(data_size == 16) ++ { ++ u16 *tmp = (u16 *)data; ++ printf("ntohs +++ %s = 0x%x", name, *tmp); ++ *tmp = ntohs(*tmp); ++ printf("ntohs --- %s = 0x%x", name, *tmp); ++ } ++ else if(data_size == 32) ++ { ++ u32 *tmp = (u32 *)data; ++ printf("ntohl +++ %s = 0x%x", name, *tmp); ++ *tmp = ntohl(*tmp); ++ printf("ntohl --- %s = 0x%x", name, *tmp); ++ } ++ else ++ printf("Unknown data type !!!! %s size = %d\n", name, data_size); ++ ++} ++ ++ ++//_Eric ?? ++static int wpa_driver_wext_send_oper_ifla(struct wpa_driver_wext_data *drv, ++ int linkmode, int operstate) ++{ ++ struct { ++ struct nlmsghdr hdr; ++ struct ifinfomsg ifinfo; ++ char opts[16]; ++ } req; ++ struct rtattr *rta; ++ static int nl_seq; ++ ssize_t ret; ++ ++ os_memset(&req, 0, sizeof(req)); ++ ++ req.hdr.nlmsg_len = NLMSG_LENGTH(sizeof(struct ifinfomsg)); ++ req.hdr.nlmsg_type = RTM_SETLINK; ++ req.hdr.nlmsg_flags = NLM_F_REQUEST; ++ req.hdr.nlmsg_seq = ++nl_seq; ++ req.hdr.nlmsg_pid = 0; ++ ++ req.ifinfo.ifi_family = AF_UNSPEC; ++ req.ifinfo.ifi_type = 0; ++ req.ifinfo.ifi_index = drv->ifindex; ++ req.ifinfo.ifi_flags = 0; ++ req.ifinfo.ifi_change = 0; ++ ++ if (linkmode != -1) { ++ rta = aliasing_hide_typecast( ++ ((char *) &req + NLMSG_ALIGN(req.hdr.nlmsg_len)), ++ struct rtattr); ++ rta->rta_type = IFLA_LINKMODE; ++ rta->rta_len = RTA_LENGTH(sizeof(char)); ++ *((char *) RTA_DATA(rta)) = linkmode; ++ req.hdr.nlmsg_len = NLMSG_ALIGN(req.hdr.nlmsg_len) + ++ RTA_LENGTH(sizeof(char)); ++ } ++ if (operstate != -1) { ++ rta = (struct rtattr *) ++ ((char *) &req + NLMSG_ALIGN(req.hdr.nlmsg_len)); ++ rta->rta_type = IFLA_OPERSTATE; ++ rta->rta_len = RTA_LENGTH(sizeof(char)); ++ *((char *) RTA_DATA(rta)) = operstate; ++ req.hdr.nlmsg_len = NLMSG_ALIGN(req.hdr.nlmsg_len) + ++ RTA_LENGTH(sizeof(char)); ++ } ++ ++ wpa_printf(MSG_DEBUG, "WEXT: Operstate: linkmode=%d, operstate=%d", ++ linkmode, operstate); ++ ++ ret = send(drv->event_sock, &req, req.hdr.nlmsg_len, 0); //_Eric ?? "Send" relates to driver or not ? ++ if (ret < 0) { ++ wpa_printf(MSG_DEBUG, "WEXT: Sending operstate IFLA failed: " ++ "%s (assume operstate is not supported)", ++ strerror(errno)); ++ } ++ ++ return ret < 0 ? -1 : 0; ++} ++ ++ ++ ++/** ++ * wpa_driver_wext_get_bssid - Get BSSID, SIOCGIWAP ++ * @priv: Pointer to private wext data from wpa_driver_wext_init() ++ * @bssid: Buffer for BSSID ++ * Returns: 0 on success, -1 on failure ++ */ ++int wpa_driver_wext_get_bssid(void *priv, u8 *bssid) ++{ ++ struct wpa_driver_wext_data *drv = priv; ++ struct iwreq iwr; ++ int ret = 0; ++ ++ os_memset(&iwr, 0, sizeof(iwr)); ++ os_strlcpy(iwr.ifr_name, drv->ifname, IFNAMSIZ); ++ ++#ifdef RTK_INBAND ++ if (inband_ioctl(SIOCGIWAP, &iwr) < 0) ++#else ++ if (ioctl(drv->ioctl_sock, SIOCGIWAP, &iwr) < 0) ++#endif ++ { ++ perror("ioctl[SIOCGIWAP]"); ++ ret = -1; ++ } ++ os_memcpy(bssid, iwr.u.ap_addr.sa_data, ETH_ALEN); ++ ++ return ret; ++} ++ ++ ++ ++/** ++ * wpa_driver_wext_set_bssid - Set BSSID, SIOCSIWAP ++ * @priv: Pointer to private wext data from wpa_driver_wext_init() ++ * @bssid: BSSID ++ * Returns: 0 on success, -1 on failure ++ */ ++int wpa_driver_wext_set_bssid(void *priv, const u8 *bssid) ++{ ++ struct wpa_driver_wext_data *drv = priv; ++ struct iwreq iwr; ++ int ret = 0; ++ ++ os_memset(&iwr, 0, sizeof(iwr)); ++ os_strlcpy(iwr.ifr_name, drv->ifname, IFNAMSIZ); ++ iwr.u.ap_addr.sa_family = ARPHRD_ETHER; ++ if (bssid) ++ os_memcpy(iwr.u.ap_addr.sa_data, bssid, ETH_ALEN); ++ else ++ os_memset(iwr.u.ap_addr.sa_data, 0, ETH_ALEN); ++ ++#ifdef RTK_INBAND ++ if (inband_ioctl(SIOCSIWAP, &iwr) < 0) ++#else ++ if (ioctl(drv->ioctl_sock, SIOCSIWAP, &iwr) < 0) ++#endif ++ { ++ perror("ioctl[SIOCSIWAP]"); ++ ret = -1; ++ } ++ ++ return ret; ++} ++ ++ ++ ++/** ++ * wpa_driver_wext_get_ssid - Get SSID, SIOCGIWESSID ++ * @priv: Pointer to private wext data from wpa_driver_wext_init() ++ * @ssid: Buffer for the SSID; must be at least 32 bytes long ++ * Returns: SSID length on success, -1 on failure ++ */ ++int wpa_driver_wext_get_ssid(void *priv, u8 *ssid) ++{ ++ struct wpa_driver_wext_data *drv = priv; ++ struct iwreq iwr; ++ int ret = 0; ++ ++ os_memset(&iwr, 0, sizeof(iwr)); ++ os_strlcpy(iwr.ifr_name, drv->ifname, IFNAMSIZ); ++ iwr.u.essid.pointer = (caddr_t) ssid; ++ iwr.u.essid.length = 32; ++ ++#ifdef RTK_INBAND ++ if (inband_ioctl(SIOCGIWESSID, &iwr) < 0) ++#else ++ if (ioctl(drv->ioctl_sock, SIOCGIWESSID, &iwr) < 0) ++#endif ++ { ++ perror("ioctl[SIOCGIWESSID]"); ++ ret = -1; ++ } else { ++ ret = iwr.u.essid.length; ++ if (ret > 32) ++ ret = 32; ++ /* Some drivers include nul termination in the SSID, so let's ++ * remove it here before further processing. WE-21 changes this ++ * to explicitly require the length _not_ to include nul ++ * termination. */ ++ if (ret > 0 && ssid[ret - 1] == '\0' && ++ drv->we_version_compiled < 21) ++ ret--; ++ } ++ ++ return ret; ++} ++ ++ ++ ++/** ++ * wpa_driver_wext_set_ssid - Set SSID, SIOCSIWESSID ++ * @priv: Pointer to private wext data from wpa_driver_wext_init() ++ * @ssid: SSID ++ * @ssid_len: Length of SSID (0..32) ++ * Returns: 0 on success, -1 on failure ++ */ ++int wpa_driver_wext_set_ssid(void *priv, const u8 *ssid, size_t ssid_len) ++{ ++ struct wpa_driver_wext_data *drv = priv; ++ struct iwreq iwr; ++ int ret = 0; ++ char buf[33]; ++ ++ printf("wpa_driver_wext_set_ssid ssid_len %d \n ", ssid_len); ++ ++ if (ssid_len > 32) ++ return -1; ++ ++ os_memset(&iwr, 0, sizeof(iwr)); ++ os_strlcpy(iwr.ifr_name, drv->ifname, IFNAMSIZ); ++ /* flags: 1 = ESSID is active, 0 = not (promiscuous) */ ++ iwr.u.essid.flags = (ssid_len != 0); ++ os_memset(buf, 0, sizeof(buf)); ++ os_memcpy(buf, ssid, ssid_len); ++ iwr.u.essid.pointer = (caddr_t) buf; ++ if (drv->we_version_compiled < 21) { ++ /* For historic reasons, set SSID length to include one extra ++ * character, C string nul termination, even though SSID is ++ * really an octet string that should not be presented as a C ++ * string. Some Linux drivers decrement the length by one and ++ * can thus end up missing the last octet of the SSID if the ++ * length is not incremented here. WE-21 changes this to ++ * explicitly require the length _not_ to include nul ++ * termination. */ ++ if (ssid_len) ++ ssid_len++; ++ } ++ iwr.u.essid.length = ssid_len; ++ ++ printf("wpa_driver_wext_set_ssid len %d \n ", iwr.u.essid.length); ++ ++#ifdef RTK_INBAND ++ if (inband_ioctl(SIOCSIWESSID, &iwr) < 0) ++#else ++ if (ioctl(drv->ioctl_sock, SIOCSIWESSID, &iwr) < 0) ++#endif ++ { ++ perror("ioctl[SIOCSIWESSID]"); ++ ret = -1; ++ } ++ ++ return ret; ++} ++ ++ ++ ++static void ++wpa_driver_wext_event_wireless_custom(void *ctx, char *custom, u16 flags, size_t len) ++{ ++ union wpa_event_data data; ++ ++ os_memset(&data, 0, sizeof(data)); ++ ++ wpa_printf(MSG_DEBUG, "custom event =%d, len=%d", flags, len); ++ ++ switch(flags) ++ { ++ case WPAS_MIC_FAILURE: ++ { ++ unsigned char * unicast = (unsigned char *)custom; ++ data.michael_mic_failure.unicast = unicast[0]; ++ wpa_supplicant_event(ctx, EVENT_MICHAEL_MIC_FAILURE, &data); ++ break; ++ } ++ case WPAS_ASSOC_INFO: ++ { ++ struct _WPAS_ASSOCIATION_INFO *assoc_info = (struct _WPAS_ASSOCIATION_INFO *) custom; ++ ++ data.assoc_info.req_ies = NULL; ++ data.assoc_info.resp_ies = NULL; ++ data.assoc_info.beacon_ies = NULL; ++ ++#ifdef RTK_INBAND_LE ++ assoc_info->ReqIELen = ntohs(assoc_info->ReqIELen); ++ assoc_info->RespIELen = ntohs(assoc_info->RespIELen); ++#endif ++ ++ if((assoc_info->ReqIELen == 0) && (assoc_info->RespIELen == 0)) ++ goto done; ++ ++ data.assoc_info.req_ies_len = assoc_info->ReqIELen; ++ data.assoc_info.resp_ies_len = assoc_info->RespIELen; ++ ++ if(data.assoc_info.req_ies_len > 0) ++ { ++ data.assoc_info.req_ies = os_malloc(assoc_info->ReqIELen); ++ ++ if (data.assoc_info.req_ies == NULL) ++ goto done; ++ ++ os_memcpy(data.assoc_info.req_ies, assoc_info->ReqIE, assoc_info->ReqIELen); ++ } ++ ++ ++ if(data.assoc_info.resp_ies_len > 0) ++ { ++ ++ data.assoc_info.resp_ies = os_malloc(assoc_info->RespIELen); ++ if (data.assoc_info.resp_ies == NULL) ++ goto done; ++ ++ os_memcpy(data.assoc_info.resp_ies, assoc_info->RespIE, assoc_info->RespIELen); ++ } ++ ++ wpa_supplicant_event(ctx, EVENT_ASSOCINFO, &data); ++ ++done: ++ ++ if(data.assoc_info.req_ies_len > 0) ++ os_free(data.assoc_info.req_ies); ++ ++ if(data.assoc_info.resp_ies_len > 0) ++ os_free(data.assoc_info.resp_ies); ++ ++ break; ++ } ++ default: ++ break; ++ ++ } ++ ++} ++ ++ ++ ++static int wpa_driver_wext_event_wireless_michaelmicfailure( ++ void *ctx, const char *ev, size_t len) ++{ ++ const struct iw_michaelmicfailure *mic; ++ union wpa_event_data data; ++ ++ if (len < sizeof(*mic)) ++ return -1; ++ ++ mic = (const struct iw_michaelmicfailure *) ev; ++ ++ wpa_printf(MSG_DEBUG, "Michael MIC failure wireless event: " ++ "flags=0x%x src_addr=" MACSTR, mic->flags, ++ MAC2STR(mic->src_addr.sa_data)); ++ ++ os_memset(&data, 0, sizeof(data)); ++ data.michael_mic_failure.unicast = !(mic->flags & IW_MICFAILURE_GROUP); ++ wpa_supplicant_event(ctx, EVENT_MICHAEL_MIC_FAILURE, &data); ++ ++ return 0; ++} ++ ++ ++ ++static void wpa_driver_wext_event_assoc_ies(struct wpa_driver_wext_data *drv) ++{ ++ union wpa_event_data data; ++ ++ if (drv->assoc_req_ies == NULL && drv->assoc_resp_ies == NULL) ++ return; ++ ++ os_memset(&data, 0, sizeof(data)); ++ if (drv->assoc_req_ies) { ++ data.assoc_info.req_ies = drv->assoc_req_ies; ++ drv->assoc_req_ies = NULL; ++ data.assoc_info.req_ies_len = drv->assoc_req_ies_len; ++ } ++ if (drv->assoc_resp_ies) { ++ data.assoc_info.resp_ies = drv->assoc_resp_ies; ++ drv->assoc_resp_ies = NULL; ++ data.assoc_info.resp_ies_len = drv->assoc_resp_ies_len; ++ } ++ ++ wpa_supplicant_event(drv->ctx, EVENT_ASSOCINFO, &data); ++ ++ os_free(data.assoc_info.req_ies); ++ os_free(data.assoc_info.resp_ies); ++} ++ ++ ++ ++static void wpa_driver_wext_event_wireless(struct wpa_driver_wext_data *drv, ++ void *ctx, char *data, int len) ++{ ++ struct iw_event iwe_buf, *iwe = &iwe_buf; ++ char *pos, *end, *custom, *buf; ++ ++ pos = data; ++ end = data + len; ++ ++ while (pos + IW_EV_LCP_LEN <= end) { ++ /* Event data may be unaligned, so make a local, aligned copy ++ * before processing. */ ++ os_memcpy(&iwe_buf, pos, IW_EV_LCP_LEN); ++ ++#ifdef RTK_INBAND_LE ++ iwe->len = ntohs(iwe->len); ++ iwe->cmd = ntohs(iwe->cmd); ++#endif ++ ++ wpa_printf(MSG_DEBUG, "Wireless event: cmd=0x%x len=%d", ++ iwe->cmd, iwe->len); ++ ++ if (iwe->len <= IW_EV_LCP_LEN) ++ return; ++ ++ custom = pos + IW_EV_POINT_LEN; ++ if (drv->we_version_compiled > 18 && ++ (iwe->cmd == IWEVMICHAELMICFAILURE || ++ iwe->cmd == IWEVCUSTOM || ++ iwe->cmd == IWEVASSOCREQIE || ++ iwe->cmd == IWEVASSOCRESPIE || ++ iwe->cmd == IWEVPMKIDCAND)) { ++ /* WE-19 removed the pointer from struct iw_point */ ++ char *dpos = (char *) &iwe_buf.u.data.length; ++ int dlen = dpos - (char *) &iwe_buf; ++ os_memcpy(dpos, pos + IW_EV_LCP_LEN, ++ sizeof(struct iw_event) - dlen); ++ } else { ++ os_memcpy(&iwe_buf, pos, sizeof(struct iw_event)); ++ custom += IW_EV_POINT_OFF; ++ ++#ifdef RTK_INBAND_LE ++ iwe->len = ntohs(iwe->len); ++ iwe->cmd = ntohs(iwe->cmd); ++#endif ++ ++ } ++ ++ switch (iwe->cmd) { ++ case SIOCGIWAP: //_Eric ?? sa_data is get from parsing ?? ++ wpa_printf(MSG_DEBUG, "Wireless event: new AP: " ++ MACSTR, ++ MAC2STR((u8 *) iwe->u.ap_addr.sa_data)); ++ if (is_zero_ether_addr( ++ (const u8 *) iwe->u.ap_addr.sa_data) || ++ os_memcmp(iwe->u.ap_addr.sa_data, ++ "\x44\x44\x44\x44\x44\x44", ETH_ALEN) == ++ 0) { ++ os_free(drv->assoc_req_ies); ++ drv->assoc_req_ies = NULL; ++ os_free(drv->assoc_resp_ies); ++ drv->assoc_resp_ies = NULL; ++ wpa_supplicant_event(ctx, EVENT_DISASSOC, ++ NULL); ++ ++ } else { ++ wpa_driver_wext_event_assoc_ies(drv); ++ wpa_supplicant_event(ctx, EVENT_ASSOC, NULL); ++ } ++ break; ++ case IWEVCUSTOM: ++ ++#ifdef RTK_INBAND_LE ++ iwe->u.data.length = ntohs(iwe->u.data.length); ++ iwe->u.data.flags = ntohs(iwe->u.data.flags); ++#endif ++ ++ if (custom + iwe->u.data.length > end) { ++ wpa_printf(MSG_DEBUG, "WEXT: Invalid " ++ "IWEVCUSTOM length"); ++ return; ++ } ++ buf = os_malloc(iwe->u.data.length + 1); ++ if (buf == NULL) ++ return; ++ os_memcpy(buf, custom, iwe->u.data.length); ++ buf[iwe->u.data.length] = '\0'; ++ wpa_driver_wext_event_wireless_custom(ctx, buf, iwe->u.data.flags, iwe->u.data.length); ++ os_free(buf); ++ break; ++ case SIOCGIWSCAN: ++ drv->scan_complete_events = 1; ++ eloop_cancel_timeout(wpa_driver_wext_scan_timeout, ++ drv, ctx); ++ wpa_supplicant_event(ctx, EVENT_SCAN_RESULTS, NULL); ++ break; ++ } ++ ++ pos += iwe->len; ++ } ++} ++ ++ ++static void wpa_driver_wext_event_rtm_newlink(struct wpa_driver_wext_data *drv, ++ void *ctx, struct nlmsghdr *h, ++ size_t len) ++{ ++ struct ifinfomsg *ifi; ++ int attrlen, nlmsg_len, rta_len; ++ struct rtattr * attr; ++ ++ if (len < sizeof(*ifi)) ++ return; ++ ++ ifi = NLMSG_DATA(h); ++ ++#ifdef RTK_INBAND_LE ++ ifi->ifi_index = ntohl(ifi->ifi_index); ++#endif ++ ++ ++ if (drv->ifindex != ifi->ifi_index) ++ { ++ wpa_printf(MSG_DEBUG, "Ignore event for foreign ifindex %d, drv->ifindex %d", ++ ifi->ifi_index, drv->ifindex); ++ //_Eric ?? return; ++ } ++ ++ wpa_printf(MSG_DEBUG, "RTM_NEWLINK: operstate=%d ifi_flags=0x%x " ++ "(%s%s%s%s)", ++ drv->operstate, ifi->ifi_flags, ++ (ifi->ifi_flags & IFF_UP) ? "[UP]" : "", ++ (ifi->ifi_flags & IFF_RUNNING) ? "[RUNNING]" : "", ++ (ifi->ifi_flags & IFF_LOWER_UP) ? "[LOWER_UP]" : "", ++ (ifi->ifi_flags & IFF_DORMANT) ? "[DORMANT]" : ""); ++ ++ nlmsg_len = NLMSG_ALIGN(sizeof(struct ifinfomsg)); ++ ++ attrlen = h->nlmsg_len - nlmsg_len; ++ if (attrlen < 0) ++ return; ++ ++ attr = (struct rtattr *) (((char *) ifi) + nlmsg_len); ++ ++#ifdef RTK_INBAND_LE ++ attr->rta_len = ntohs(attr->rta_len); ++ attr->rta_type = ntohs(attr->rta_type); ++#endif ++ ++ rta_len = RTA_ALIGN(sizeof(struct rtattr)); ++ while (RTA_OK(attr, attrlen)) ++ { ++ if (attr->rta_type == IFLA_WIRELESS) ++ { ++ wpa_driver_wext_event_wireless( ++ drv, ctx, ((char *) attr) + rta_len, ++ attr->rta_len - rta_len); ++ } ++ ++ attr = RTA_NEXT(attr, attrlen); ++ ++#ifdef RTK_INBAND_LE ++ attr->rta_len = ntohs(attr->rta_len); ++ attr->rta_type = ntohs(attr->rta_type); ++#endif ++ ++ } ++ ++} ++ ++ ++ ++static void wpa_driver_wext_event_receive(int sock, void *eloop_ctx, ++ void *sock_ctx) ++{ ++ char buf[8192]; ++ int left; ++ struct sockaddr_nl from; ++ socklen_t fromlen; ++ struct nlmsghdr *h; ++ int max_events = 10; ++ struct wpa_driver_wext_data *drv = eloop_ctx; ++ ++try_again: ++ ++#ifdef RTK_INBAND ++ left = ioh_recv(&drv->netlink_ioh_obj, 3000); ++ ++ if (left < 0) { ++ perror("recvfrom(rawsock)"); ++ return; ++ } ++ ++ //hex_dump(drv->netlink_ioh_obj.rx_data,left); ++ ++ left -= IOH_HDR_LEN; ++ ++ h = (struct nlmsghdr *)drv->netlink_ioh_obj.rx_data ; ++#else ++ ++ fromlen = sizeof(from); ++ left = recvfrom(sock, buf, sizeof(buf), MSG_DONTWAIT, ++ (struct sockaddr *) &from, &fromlen); ++ if (left < 0) { ++ if (errno != EINTR && errno != EAGAIN) ++ perror("recvfrom(netlink)"); ++ return; ++ } ++ ++ h = (struct nlmsghdr *) buf; ++ ++#endif ++ ++ ++ while (left >= (int) sizeof(*h)) { ++ int len, plen; ++ ++#ifdef RTK_INBAND_LE ++ h->nlmsg_len = ntohl(h->nlmsg_len); ++ h->nlmsg_type = ntohs(h->nlmsg_type); ++ h->nlmsg_flags = ntohs(h->nlmsg_flags); ++ h->nlmsg_seq = ntohl(h->nlmsg_seq); ++ h->nlmsg_pid = ntohl(h->nlmsg_pid); ++#endif ++ ++ ++ len = h->nlmsg_len; ++ plen = len - sizeof(*h); ++ if (len > left || plen < 0) { ++ wpa_printf(MSG_DEBUG, "Malformed netlink message: " ++ "len=%d left=%d plen=%d", ++ len, left, plen); ++ break; ++ } ++ ++ switch (h->nlmsg_type) { ++ case RTM_NEWLINK: ++ wpa_driver_wext_event_rtm_newlink(eloop_ctx, sock_ctx, ++ h, plen); ++ break; ++ } ++ ++ len = NLMSG_ALIGN(len); ++ left -= len; ++ h = (struct nlmsghdr *) ((char *) h + len); ++ } ++ ++ if (left > 0) { ++ wpa_printf(MSG_DEBUG, "%d extra bytes in the end of netlink " ++ "message", left); ++ } ++ ++ if (--max_events > 0) { ++ /* ++ * Try to receive all events in one eloop call in order to ++ * limit race condition on cases where AssocInfo event, Assoc ++ * event, and EAPOL frames are received more or less at the ++ * same time. We want to process the event messages first ++ * before starting EAPOL processing. ++ */ ++ goto try_again; ++ } ++} ++ ++ ++ ++static int wpa_driver_wext_get_ifflags_ifname(struct wpa_driver_wext_data *drv, ++ const char *ifname, int *flags) ++{ ++ struct ifreq ifr; ++ ++ os_memset(&ifr, 0, sizeof(ifr)); ++ os_strlcpy(ifr.ifr_name, ifname, IFNAMSIZ); ++ ++#ifdef RTK_INBAND ++ if (inband_ioctl(SIOCGIFFLAGS, (caddr_t) &ifr) < 0) ++#else ++ if (ioctl(drv->ioctl_sock, SIOCGIFFLAGS, (caddr_t) &ifr) < 0) ++#endif ++ { ++ perror("ioctl[SIOCGIFFLAGS]"); ++ return -1; ++ } ++ *flags = ifr.ifr_flags & 0xffff; ++ return 0; ++} ++ ++ ++ ++/** ++ * wpa_driver_wext_get_ifflags - Get interface flags (SIOCGIFFLAGS) ++ * @drv: driver_wext private data ++ * @flags: Pointer to returned flags value ++ * Returns: 0 on success, -1 on failure ++ */ ++int wpa_driver_wext_get_ifflags(struct wpa_driver_wext_data *drv, int *flags) ++{ ++ return wpa_driver_wext_get_ifflags_ifname(drv, drv->ifname, flags); ++} ++ ++ ++ ++static int wpa_driver_wext_set_ifflags_ifname(struct wpa_driver_wext_data *drv, ++ const char *ifname, int flags) ++{ ++ struct ifreq ifr; ++ ++ os_memset(&ifr, 0, sizeof(ifr)); ++ os_strlcpy(ifr.ifr_name, ifname, IFNAMSIZ); ++ ifr.ifr_flags = flags & 0xffff; ++ ++#ifdef RTK_INBAND ++ if (inband_ioctl(SIOCSIFFLAGS, (caddr_t) &ifr) < 0) ++#else ++ if (ioctl(drv->ioctl_sock, SIOCSIFFLAGS, (caddr_t) &ifr) < 0) ++#endif ++ { ++ perror("SIOCSIFFLAGS"); ++ return -1; ++ } ++ return 0; ++} ++ ++ ++ ++/** ++ * wpa_driver_wext_set_ifflags - Set interface flags (SIOCSIFFLAGS) ++ * @drv: driver_wext private data ++ * @flags: New value for flags ++ * Returns: 0 on success, -1 on failure ++ */ ++int wpa_driver_wext_set_ifflags(struct wpa_driver_wext_data *drv, int flags) ++{ ++ return wpa_driver_wext_set_ifflags_ifname(drv, drv->ifname, flags); ++} ++ ++ ++ ++/** ++ * wpa_driver_wext_init - Initialize WE driver interface ++ * @ctx: context to be used when calling wpa_supplicant functions, ++ * e.g., wpa_supplicant_event() ++ * @ifname: interface name, e.g., wlan0 ++ * Returns: Pointer to private data, %NULL on failure ++ */ ++void * wpa_driver_wext_init(void *ctx, const char *ifname) ++{ ++ int s; ++ struct sockaddr_nl local; ++ struct wpa_driver_wext_data *drv; ++ ++ drv = os_zalloc(sizeof(*drv)); ++ if (drv == NULL) ++ return NULL; ++ drv->ctx = ctx; ++ os_strlcpy(drv->ifname, ifname, sizeof(drv->ifname)); ++ ++ drv->ioctl_sock = socket(PF_INET, SOCK_DGRAM, 0); ++ if (drv->ioctl_sock < 0) { ++ perror("socket(PF_INET,SOCK_DGRAM)"); ++ os_free(drv); ++ return NULL; ++ } ++ ++ ++#ifdef RTK_INBAND ++ s = ioh_open(&drv->netlink_ioh_obj,INBAND_INTF,INBAND_SLAVE,INBAND_NETLINK_TYPE,INBAND_DEBUG); ++ if (s < 0) { ++ perror("socket(PF_PACKET,SOCK_RAW,INBAND_NETLINK_TYPE)"); ++ return -1; ++ } ++#else ++ s = socket(PF_NETLINK, SOCK_RAW, NETLINK_ROUTE); ++ if (s < 0) { ++ perror("socket(PF_NETLINK,SOCK_RAW,NETLINK_ROUTE)"); ++ close(drv->ioctl_sock); ++ os_free(drv); ++ return NULL; ++ } ++ ++ os_memset(&local, 0, sizeof(local)); ++ local.nl_family = AF_NETLINK; ++ local.nl_groups = RTMGRP_LINK; ++ if (bind(s, (struct sockaddr *) &local, sizeof(local)) < 0) { ++ perror("bind(netlink)"); ++ close(s); ++ close(drv->ioctl_sock); ++ os_free(drv); ++ return NULL; ++ } ++#endif ++ ++#ifdef RTK_INBAND ++ eloop_register_read_sock(drv->netlink_ioh_obj.sockfd, wpa_driver_wext_event_receive, drv, ctx); ++ drv->event_sock = drv->netlink_ioh_obj.sockfd; ++#else ++ eloop_register_read_sock(s, wpa_driver_wext_event_receive, drv, ctx); ++ drv->event_sock = s; ++#endif ++ ++ drv->mlme_sock = -1; ++ ++ wpa_driver_wext_finish_drv_init(drv); ++ ++ return drv; ++} ++ ++ ++ ++static void wpa_driver_wext_finish_drv_init(struct wpa_driver_wext_data *drv) ++{ ++ int flags; ++ ++ if (wpa_driver_wext_get_ifflags(drv, &flags) != 0) ++ printf("Could not get interface '%s' flags\n", drv->ifname); ++ ++ if (wpa_driver_wext_set_ifflags(drv, flags &= ~IFF_UP) != 0) ++ printf("Could not set interface '%s' DOWN\n", drv->ifname); ++ ++ if (wpa_driver_wext_set_mode(drv, 0) < 0) ++ printf("Could not configure driver to use managed mode\n"); ++ ++ if (wpa_driver_wext_set_ifflags(drv, flags | IFF_UP) != 0) ++ printf("Could not set interface '%s' UP\n", drv->ifname); ++ ++ wpa_driver_wext_get_range(drv); ++ ++ wpa_driver_wext_disconnect(drv); ++ ++ drv->ifindex = if_nametoindex(drv->ifname); ++ ++} ++ ++ ++ ++/** ++ * wpa_driver_wext_deinit - Deinitialize WE driver interface ++ * @priv: Pointer to private wext data from wpa_driver_wext_init() ++ * ++ * Shut down driver interface and processing of driver events. Free ++ * private data buffer if one was allocated in wpa_driver_wext_init(). ++ */ ++void wpa_driver_wext_deinit(void *priv) ++{ ++ struct wpa_driver_wext_data *drv = priv; ++ int flags; ++ ++ eloop_cancel_timeout(wpa_driver_wext_scan_timeout, drv, drv->ctx); ++ ++ /* ++ * Clear possibly configured driver parameters in order to make it ++ * easier to use the driver after wpa_supplicant has been terminated. ++ */ ++ wpa_driver_wext_disconnect(drv); ++ ++ wpa_driver_wext_send_oper_ifla(priv, 0, IF_OPER_UP); ++ ++ eloop_unregister_read_sock(drv->event_sock); ++ if (drv->mlme_sock >= 0) ++ eloop_unregister_read_sock(drv->mlme_sock); ++ ++ if (wpa_driver_wext_get_ifflags(drv, &flags) == 0) ++ (void) wpa_driver_wext_set_ifflags(drv, flags & ~IFF_UP); ++ ++ close(drv->event_sock); ++ close(drv->ioctl_sock); ++ if (drv->mlme_sock >= 0) ++ close(drv->mlme_sock); ++ os_free(drv->assoc_req_ies); ++ os_free(drv->assoc_resp_ies); ++ os_free(drv); ++} ++ ++ ++ ++/** ++ * wpa_driver_wext_scan_timeout - Scan timeout to report scan completion ++ * @eloop_ctx: Unused ++ * @timeout_ctx: ctx argument given to wpa_driver_wext_init() ++ * ++ * This function can be used as registered timeout when starting a scan to ++ * generate a scan completed event if the driver does not report this. ++ */ ++void wpa_driver_wext_scan_timeout(void *eloop_ctx, void *timeout_ctx) ++{ ++ wpa_printf(MSG_DEBUG, "Scan timeout - try to get results"); ++ wpa_supplicant_event(timeout_ctx, EVENT_SCAN_RESULTS, NULL); ++} ++ ++ ++ ++/** ++ * wpa_driver_wext_scan - Request the driver to initiate scan ++ * @priv: Pointer to private wext data from wpa_driver_wext_init() ++ * @ssid: Specific SSID to scan for (ProbeReq) or %NULL to scan for ++ * all SSIDs (either active scan with broadcast SSID or passive ++ * scan ++ * @ssid_len: Length of the SSID ++ * Returns: 0 on success, -1 on failure ++ */ ++int wpa_driver_wext_scan(void *priv, const u8 *ssid, size_t ssid_len) ++{ ++ struct wpa_driver_wext_data *drv = priv; ++ struct iwreq iwr; ++ int ret = 0, timeout; ++ struct iw_scan_req req; ++ ++ if (ssid_len > IW_ESSID_MAX_SIZE) { ++ wpa_printf(MSG_DEBUG, "%s: too long SSID (%lu)", ++ __FUNCTION__, (unsigned long) ssid_len); ++ return -1; ++ } ++ ++ os_memset(&iwr, 0, sizeof(iwr)); ++ os_strlcpy(iwr.ifr_name, drv->ifname, IFNAMSIZ); ++ ++ if (ssid && ssid_len) { ++ os_memset(&req, 0, sizeof(req)); ++ req.essid_len = ssid_len; ++ req.bssid.sa_family = ARPHRD_ETHER; ++ os_memset(req.bssid.sa_data, 0xff, ETH_ALEN); ++ os_memcpy(req.essid, ssid, ssid_len); ++ iwr.u.data.pointer = (caddr_t) &req; ++ iwr.u.data.length = sizeof(req); ++ iwr.u.data.flags = IW_SCAN_THIS_ESSID; ++ } ++ ++#ifdef RTK_INBAND ++ if (inband_ioctl(SIOCSIWSCAN, &iwr) < 0) ++#else ++ if (ioctl(drv->ioctl_sock, SIOCSIWSCAN, &iwr) < 0) ++#endif ++ { ++ perror("ioctl[SIOCSIWSCAN]"); ++ ret = -1; ++ } ++ ++ /* Not all drivers generate "scan completed" wireless event, so try to ++ * read results after a timeout. */ ++ timeout = 5; ++ if (drv->scan_complete_events) { ++ /* ++ * The driver seems to deliver SIOCGIWSCAN events to notify ++ * when scan is complete, so use longer timeout to avoid race ++ * conditions with scanning and following association request. ++ */ ++ timeout = 30; ++ } ++ wpa_printf(MSG_DEBUG, "Scan requested (ret=%d) - scan timeout %d " ++ "seconds", ret, timeout); ++ eloop_cancel_timeout(wpa_driver_wext_scan_timeout, drv, drv->ctx); ++ eloop_register_timeout(timeout, 0, wpa_driver_wext_scan_timeout, drv, ++ drv->ctx); ++ ++ return ret; ++} ++ ++ ++ ++static u8 * wpa_driver_wext_giwscan(struct wpa_driver_wext_data *drv, ++ size_t *len) ++{ ++ struct iwreq iwr; ++ u8 *res_buf; ++ size_t res_buf_len; ++ ++ res_buf_len = IW_SCAN_MAX_DATA; ++ for (;;) { ++ res_buf = os_malloc(res_buf_len); ++ if (res_buf == NULL) ++ return NULL; ++ os_memset(&iwr, 0, sizeof(iwr)); ++ os_strlcpy(iwr.ifr_name, drv->ifname, IFNAMSIZ); ++ iwr.u.data.pointer = res_buf; ++ iwr.u.data.length = res_buf_len; ++ ++#ifdef RTK_INBAND ++ if (inband_ioctl(SIOCGIWSCAN, &iwr) == 0) ++#else ++ if (ioctl(drv->ioctl_sock, SIOCGIWSCAN, &iwr) == 0) ++#endif ++ break; ++ ++ if (errno == E2BIG && res_buf_len < 65535) { ++ os_free(res_buf); ++ res_buf = NULL; ++ res_buf_len *= 2; ++ if (res_buf_len > 65535) ++ res_buf_len = 65535; /* 16-bit length field */ ++ wpa_printf(MSG_DEBUG, "Scan results did not fit - " ++ "trying larger buffer (%lu bytes)", ++ (unsigned long) res_buf_len); ++ } else { ++ perror("ioctl[SIOCGIWSCAN]"); ++ os_free(res_buf); ++ return NULL; ++ } ++ } ++ ++ if (iwr.u.data.length > res_buf_len) { ++ os_free(res_buf); ++ return NULL; ++ } ++ *len = iwr.u.data.length; ++ ++ return res_buf; ++} ++ ++ ++ ++/* ++ * Data structure for collecting WEXT scan results. This is needed to allow ++ * the various methods of reporting IEs to be combined into a single IE buffer. ++ */ ++struct wext_scan_data { ++ struct wpa_scan_res res; ++ u8 *ie; ++ size_t ie_len; ++ u8 ssid[32]; ++ size_t ssid_len; ++ int maxrate; ++}; ++ ++ ++ ++static void wext_get_scan_mode(struct iw_event *iwe, ++ struct wext_scan_data *res) ++{ ++ if (iwe->u.mode == IW_MODE_ADHOC) ++ res->res.caps |= IEEE80211_CAP_IBSS; ++ else if (iwe->u.mode == IW_MODE_MASTER || iwe->u.mode == IW_MODE_INFRA) ++ res->res.caps |= IEEE80211_CAP_ESS; ++} ++ ++ ++ ++static void wext_get_scan_ssid(struct iw_event *iwe, ++ struct wext_scan_data *res, char *custom, ++ char *end) ++{ ++ int ssid_len = iwe->u.essid.length; ++ if (custom + ssid_len > end) ++ return; ++ if (iwe->u.essid.flags && ++ ssid_len > 0 && ++ ssid_len <= IW_ESSID_MAX_SIZE) { ++ os_memcpy(res->ssid, custom, ssid_len); ++ res->ssid_len = ssid_len; ++ } ++} ++ ++ ++ ++static void wext_get_scan_freq(struct iw_event *iwe, ++ struct wext_scan_data *res) ++{ ++ int divi = 1000000, i; ++ ++ if (iwe->u.freq.e == 0) { ++ /* ++ * Some drivers do not report frequency, but a channel. ++ * Try to map this to frequency by assuming they are using ++ * IEEE 802.11b/g. But don't overwrite a previously parsed ++ * frequency if the driver sends both frequency and channel, ++ * since the driver may be sending an A-band channel that we ++ * don't handle here. ++ */ ++ ++ if (res->res.freq) ++ return; ++ ++ if (iwe->u.freq.m >= 1 && iwe->u.freq.m <= 13) { ++ res->res.freq = 2407 + 5 * iwe->u.freq.m; ++ return; ++ } else if (iwe->u.freq.m == 14) { ++ res->res.freq = 2484; ++ return; ++ } ++ } ++ ++ if (iwe->u.freq.e > 6) { ++ wpa_printf(MSG_DEBUG, "Invalid freq in scan results (BSSID=" ++ MACSTR " m=%d e=%d)", ++ MAC2STR(res->res.bssid), iwe->u.freq.m, ++ iwe->u.freq.e); ++ return; ++ } ++ ++ for (i = 0; i < iwe->u.freq.e; i++) ++ divi /= 10; ++ res->res.freq = iwe->u.freq.m / divi; ++} ++ ++ ++ ++static void wext_get_scan_qual(struct iw_event *iwe, ++ struct wext_scan_data *res) ++{ ++ res->res.qual = iwe->u.qual.qual; ++ res->res.noise = iwe->u.qual.noise; ++ res->res.level = iwe->u.qual.level; ++} ++ ++ ++ ++static void wext_get_scan_encode(struct iw_event *iwe, ++ struct wext_scan_data *res) ++{ ++ if (!(iwe->u.data.flags & IW_ENCODE_DISABLED)) ++ res->res.caps |= IEEE80211_CAP_PRIVACY; ++} ++ ++ ++static void wext_get_scan_rate(struct iw_event *iwe, ++ struct wext_scan_data *res, char *pos, ++ char *end) ++{ ++ int maxrate; ++ char *custom = pos + IW_EV_LCP_LEN; ++ struct iw_param p; ++ size_t clen; ++ ++ clen = iwe->len; ++ if (custom + clen > end) ++ return; ++ maxrate = 0; ++ while (((ssize_t) clen) >= (ssize_t) sizeof(struct iw_param)) { ++ /* Note: may be misaligned, make a local, aligned copy */ ++ os_memcpy(&p, custom, sizeof(struct iw_param)); ++ if (p.value > maxrate) ++ maxrate = p.value; ++ clen -= sizeof(struct iw_param); ++ custom += sizeof(struct iw_param); ++ } ++ ++ /* Convert the maxrate from WE-style (b/s units) to ++ * 802.11 rates (500000 b/s units). ++ */ ++ res->maxrate = maxrate / 500000; ++} ++ ++ ++ ++static void wext_get_scan_iwevgenie(struct iw_event *iwe, ++ struct wext_scan_data *res, char *custom, ++ char *end) ++{ ++ char *genie, *gpos, *gend; ++ u8 *tmp; ++ ++ if (iwe->u.data.length == 0) ++ return; ++ ++ gpos = genie = custom; ++ gend = genie + iwe->u.data.length; ++ if (gend > end) { ++ wpa_printf(MSG_INFO, "IWEVGENIE overflow"); ++ return; ++ } ++ ++ tmp = os_realloc(res->ie, res->ie_len + gend - gpos); ++ if (tmp == NULL) ++ return; ++ os_memcpy(tmp + res->ie_len, gpos, gend - gpos); ++ res->ie = tmp; ++ res->ie_len += gend - gpos; ++} ++ ++ ++ ++static void wext_get_scan_custom(struct iw_event *iwe, ++ struct wext_scan_data *res, char *custom, ++ char *end) ++{ ++ size_t clen; ++ u8 *tmp; ++ ++ clen = iwe->u.data.length; ++ if (custom + clen > end) ++ return; ++ ++ if (clen > 7 && os_strncmp(custom, "wpa_ie=", 7) == 0) { ++ char *spos; ++ int bytes; ++ spos = custom + 7; ++ bytes = custom + clen - spos; ++ if (bytes & 1 || bytes == 0) ++ return; ++ bytes /= 2; ++ tmp = os_realloc(res->ie, res->ie_len + bytes); ++ if (tmp == NULL) ++ return; ++ hexstr2bin(spos, tmp + res->ie_len, bytes); ++ res->ie = tmp; ++ res->ie_len += bytes; ++ } else if (clen > 7 && os_strncmp(custom, "rsn_ie=", 7) == 0) { ++ char *spos; ++ int bytes; ++ spos = custom + 7; ++ bytes = custom + clen - spos; ++ if (bytes & 1 || bytes == 0) ++ return; ++ bytes /= 2; ++ tmp = os_realloc(res->ie, res->ie_len + bytes); ++ if (tmp == NULL) ++ return; ++ hexstr2bin(spos, tmp + res->ie_len, bytes); ++ res->ie = tmp; ++ res->ie_len += bytes; ++ } else if (clen > 4 && os_strncmp(custom, "tsf=", 4) == 0) { ++ char *spos; ++ int bytes; ++ u8 bin[8]; ++ spos = custom + 4; ++ bytes = custom + clen - spos; ++ if (bytes != 16) { ++ wpa_printf(MSG_INFO, "Invalid TSF length (%d)", bytes); ++ return; ++ } ++ bytes /= 2; ++ hexstr2bin(spos, bin, bytes); ++ res->res.tsf += WPA_GET_BE64(bin); ++ } ++} ++ ++ ++ ++static int wext_19_iw_point(struct wpa_driver_wext_data *drv, u16 cmd) ++{ ++ return drv->we_version_compiled > 18 && ++ (cmd == SIOCGIWESSID || cmd == SIOCGIWENCODE || ++ cmd == IWEVGENIE || cmd == IWEVCUSTOM); ++} ++ ++ ++ ++static void wpa_driver_wext_add_scan_entry(struct wpa_scan_results *res, ++ struct wext_scan_data *data) ++{ ++ struct wpa_scan_res **tmp; ++ struct wpa_scan_res *r; ++ size_t extra_len; ++ u8 *pos, *end, *ssid_ie = NULL, *rate_ie = NULL; ++ ++ /* Figure out whether we need to fake any IEs */ ++ pos = data->ie; ++ end = pos + data->ie_len; ++ while (pos && pos + 1 < end) { ++ if (pos + 2 + pos[1] > end) ++ break; ++ if (pos[0] == WLAN_EID_SSID) ++ ssid_ie = pos; ++ else if (pos[0] == WLAN_EID_SUPP_RATES) ++ rate_ie = pos; ++ else if (pos[0] == WLAN_EID_EXT_SUPP_RATES) ++ rate_ie = pos; ++ pos += 2 + pos[1]; ++ } ++ ++ extra_len = 0; ++ if (ssid_ie == NULL) ++ extra_len += 2 + data->ssid_len; ++ if (rate_ie == NULL && data->maxrate) ++ extra_len += 3; ++ ++ r = os_zalloc(sizeof(*r) + extra_len + data->ie_len); ++ if (r == NULL) ++ return; ++ os_memcpy(r, &data->res, sizeof(*r)); ++ r->ie_len = extra_len + data->ie_len; ++ pos = (u8 *) (r + 1); ++ if (ssid_ie == NULL) { ++ /* ++ * Generate a fake SSID IE since the driver did not report ++ * a full IE list. ++ */ ++ *pos++ = WLAN_EID_SSID; ++ *pos++ = data->ssid_len; ++ os_memcpy(pos, data->ssid, data->ssid_len); ++ pos += data->ssid_len; ++ } ++ if (rate_ie == NULL && data->maxrate) { ++ /* ++ * Generate a fake Supported Rates IE since the driver did not ++ * report a full IE list. ++ */ ++ *pos++ = WLAN_EID_SUPP_RATES; ++ *pos++ = 1; ++ *pos++ = data->maxrate; ++ } ++ if (data->ie) ++ os_memcpy(pos, data->ie, data->ie_len); ++ ++ tmp = os_realloc(res->res, ++ (res->num + 1) * sizeof(struct wpa_scan_res *)); ++ if (tmp == NULL) { ++ os_free(r); ++ return; ++ } ++ tmp[res->num++] = r; ++ res->res = tmp; ++} ++ ++ ++ ++/** ++ * wpa_driver_wext_get_scan_results - Fetch the latest scan results ++ * @priv: Pointer to private wext data from wpa_driver_wext_init() ++ * Returns: Scan results on success, -1 on failure ++ */ ++struct wpa_scan_results * wpa_driver_wext_get_scan_results(void *priv) ++{ ++ struct wpa_driver_wext_data *drv = priv; ++ size_t ap_num = 0, len; ++ int first; ++ u8 *res_buf; ++ struct iw_event iwe_buf, *iwe = &iwe_buf; ++ char *pos, *end, *custom; ++ struct wpa_scan_results *res; ++ struct wext_scan_data data; ++#ifdef RTK_INBAND_LE ++ unsigned char cur_ap_num = 0; ++ unsigned char prev_ap_num = 0; ++#endif ++ ++ ++ res_buf = wpa_driver_wext_giwscan(drv, &len); ++ ++ if (res_buf == NULL) ++ return NULL; ++ ++ ap_num = 0; ++ first = 1; ++ ++ res = os_zalloc(sizeof(*res)); ++ if (res == NULL) { ++ os_free(res_buf); ++ return NULL; ++ } ++ ++ pos = (char *) res_buf; ++ end = (char *) res_buf + len; ++ os_memset(&data, 0, sizeof(data)); ++ ++ while (pos + IW_EV_LCP_LEN <= end) { ++ /* Event data may be unaligned, so make a local, aligned copy ++ * before processing. */ ++ os_memcpy(&iwe_buf, pos, IW_EV_LCP_LEN); ++ ++#ifdef RTK_INBAND_LE ++ iwe->len = ntohs(iwe->len); ++ iwe->cmd = ntohs(iwe->cmd); ++#endif ++ ++ if (iwe->len <= IW_EV_LCP_LEN) ++ break; ++ ++ custom = pos + IW_EV_POINT_LEN; ++ if (wext_19_iw_point(drv, iwe->cmd)) { ++ ++#ifdef RTK_INBAND_LE ++ //iwe_buf.u.data.length = ntohs(iwe_buf.u.data.length); ++ //iwe_buf.u.data.flags = ntohs(iwe_buf.u.data.flags); ++#endif ++ ++ /* WE-19 removed the pointer from struct iw_point */ ++ char *dpos = (char *) &iwe_buf.u.data.length; ++ int dlen = dpos - (char *) &iwe_buf; ++ os_memcpy(dpos, pos + IW_EV_LCP_LEN, ++ sizeof(struct iw_event) - dlen); ++ } else { ++ os_memcpy(&iwe_buf, pos, sizeof(struct iw_event)); ++ custom += IW_EV_POINT_OFF; ++ ++#ifdef RTK_INBAND_LE ++ iwe->len = ntohs(iwe->len); ++ iwe->cmd = ntohs(iwe->cmd); ++#endif ++ } ++ ++ ++#ifdef RTK_INBAND_LE ++ ++ if(cur_ap_num > prev_ap_num) ++ { ++ ++ struct wext_scan_data* scan_data = (struct wext_scan_data*)&data; ++ ++ if(first) ++ scan_data->ie_len = ntohl(scan_data->ie_len); ++ ++ scan_data->ssid_len = ntohl(scan_data->ssid_len); ++ scan_data->maxrate = ntohl(scan_data->maxrate); ++ scan_data->res.freq = ntohl(scan_data->res.freq); ++ scan_data->res.beacon_int= ntohs(scan_data->res.beacon_int); ++ scan_data->res.caps = ntohs(scan_data->res.caps); ++ scan_data->res.qual = ntohl(scan_data->res.qual); ++ scan_data->res.noise = ntohl(scan_data->res.noise); ++ scan_data->res.level = ntohl(scan_data->res.level); ++ scan_data->res.tsf = ntohll(scan_data->res.tsf); ++ scan_data->res.ie_len = ntohl(scan_data->res.ie_len); ++ ++ prev_ap_num = cur_ap_num; ++ ++ } ++ ++ iwe_buf.u.data.length = ntohs(iwe_buf.u.data.length); ++ iwe_buf.u.data.flags = ntohs(iwe_buf.u.data.flags); ++ ++#endif ++ ++ switch (iwe->cmd) { ++ case SIOCGIWAP: ++ ++#ifdef RTK_INBAND_LE ++ if (!first) ++ cur_ap_num ++; ++#endif ++ ++ if (!first) ++ wpa_driver_wext_add_scan_entry(res, &data); ++ ++ first = 0; ++ os_free(data.ie); ++ ++ os_memset(&data, 0, sizeof(data)); ++ ++ os_memcpy(data.res.bssid, ++ iwe->u.ap_addr.sa_data, ETH_ALEN); ++ ++#ifdef RTK_INBAND_LE //_Eric ?? ???? ++ data.res.bssid[2] = iwe->u.ap_addr.sa_data[3]; ++ data.res.bssid[3] = iwe->u.ap_addr.sa_data[2]; ++ data.res.bssid[4] = iwe->u.ap_addr.sa_data[5]; ++ data.res.bssid[5] = iwe->u.ap_addr.sa_data[4]; ++#endif ++ ++ break; ++ case SIOCGIWMODE: ++ wext_get_scan_mode(iwe, &data); ++ break; ++ case SIOCGIWESSID: ++ wext_get_scan_ssid(iwe, &data, custom, end); ++ break; ++ case SIOCGIWFREQ: ++ wext_get_scan_freq(iwe, &data); ++ break; ++ case IWEVQUAL: ++ wext_get_scan_qual(iwe, &data); ++ break; ++ case SIOCGIWENCODE: ++ wext_get_scan_encode(iwe, &data); ++ break; ++ case SIOCGIWRATE: //_Eric ?? rate genie custom & NO name ++ wext_get_scan_rate(iwe, &data, pos, end); ++ break; ++ case IWEVGENIE: ++ wext_get_scan_iwevgenie(iwe, &data, custom, end); ++ break; ++ case IWEVCUSTOM: ++ wext_get_scan_custom(iwe, &data, custom, end); ++ break; ++ } ++ ++ pos += iwe->len; ++ } ++ os_free(res_buf); ++ res_buf = NULL; ++ if (!first) ++ wpa_driver_wext_add_scan_entry(res, &data); ++ os_free(data.ie); ++ ++ wpa_printf(MSG_DEBUG, "Received %lu bytes of scan results (%lu BSSes)", ++ (unsigned long) len, (unsigned long) res->num); ++ ++ return res; ++} ++ ++ ++ ++static int wpa_driver_wext_get_range(void *priv) ++{ ++ struct wpa_driver_wext_data *drv = priv; ++ struct iw_range *range; ++ struct iwreq iwr; ++ int minlen; ++ size_t buflen; ++ ++ /* ++ * Use larger buffer than struct iw_range in order to allow the ++ * structure to grow in the future. ++ */ ++ buflen = sizeof(struct iw_range) + 500; ++ range = os_zalloc(buflen); ++ if (range == NULL) ++ return -1; ++ ++ os_memset(&iwr, 0, sizeof(iwr)); ++ os_strlcpy(iwr.ifr_name, drv->ifname, IFNAMSIZ); ++ iwr.u.data.pointer = (caddr_t) range; ++ iwr.u.data.length = buflen; ++ ++ minlen = ((char *) &range->enc_capa) - (char *) range + ++ sizeof(range->enc_capa); ++ ++#ifdef RTK_INBAND ++ if (inband_ioctl(SIOCGIWRANGE, &iwr) < 0) ++#else ++ if (ioctl(drv->ioctl_sock, SIOCGIWRANGE, &iwr) < 0) ++#endif ++ { ++ perror("ioctl[SIOCGIWRANGE]"); ++ os_free(range); ++ return -1; ++ } ++ ++#ifdef RTK_INBAND_LE ++ //_Eric ?? Only convert what used below ++ range->enc_capa = ntohl(range->enc_capa); ++#endif ++ ++ if (iwr.u.data.length >= minlen && ++ range->we_version_compiled >= 18) { ++ wpa_printf(MSG_DEBUG, "SIOCGIWRANGE: WE(compiled)=%d " ++ "WE(source)=%d enc_capa=0x%x", ++ range->we_version_compiled, ++ range->we_version_source, ++ range->enc_capa); ++ drv->has_capability = 1; ++ drv->we_version_compiled = range->we_version_compiled; ++ if (range->enc_capa & IW_ENC_CAPA_WPA) { ++ drv->capa.key_mgmt |= WPA_DRIVER_CAPA_KEY_MGMT_WPA | ++ WPA_DRIVER_CAPA_KEY_MGMT_WPA_PSK; ++ } ++ if (range->enc_capa & IW_ENC_CAPA_WPA2) { ++ drv->capa.key_mgmt |= WPA_DRIVER_CAPA_KEY_MGMT_WPA2 | ++ WPA_DRIVER_CAPA_KEY_MGMT_WPA2_PSK; ++ } ++ drv->capa.enc |= WPA_DRIVER_CAPA_ENC_WEP40 | ++ WPA_DRIVER_CAPA_ENC_WEP104; ++ if (range->enc_capa & IW_ENC_CAPA_CIPHER_TKIP) ++ drv->capa.enc |= WPA_DRIVER_CAPA_ENC_TKIP; ++ if (range->enc_capa & IW_ENC_CAPA_CIPHER_CCMP) ++ drv->capa.enc |= WPA_DRIVER_CAPA_ENC_CCMP; ++ if (range->enc_capa & IW_ENC_CAPA_4WAY_HANDSHAKE) ++ drv->capa.flags |= WPA_DRIVER_FLAGS_4WAY_HANDSHAKE; ++ drv->capa.auth = WPA_DRIVER_AUTH_OPEN | ++ WPA_DRIVER_AUTH_SHARED | ++ WPA_DRIVER_AUTH_LEAP; ++ ++ wpa_printf(MSG_DEBUG, " capabilities: key_mgmt 0x%x enc 0x%x " ++ "flags 0x%x", ++ drv->capa.key_mgmt, drv->capa.enc, drv->capa.flags); ++ } else { ++ wpa_printf(MSG_DEBUG, "SIOCGIWRANGE: too old (short) data - " ++ "assuming WPA is not supported"); ++ } ++ ++ os_free(range); ++ return 0; ++} ++ ++ ++ ++static void wpa_driver_wext_disconnect(struct wpa_driver_wext_data *drv) ++{ ++ struct iwreq iwr; ++ const u8 null_bssid[ETH_ALEN] = { 0, 0, 0, 0, 0, 0 }; ++ u8 ssid[32]; ++ int i; ++ ++ /* ++ * Only force-disconnect when the card is in infrastructure mode, ++ * otherwise the driver might interpret the cleared BSSID and random ++ * SSID as an attempt to create a new ad-hoc network. ++ */ ++ os_memset(&iwr, 0, sizeof(iwr)); ++ os_strlcpy(iwr.ifr_name, drv->ifname, IFNAMSIZ); ++ ++#ifdef RTK_INBAND ++ if (inband_ioctl(SIOCGIWMODE, &iwr) < 0) ++#else ++ if (ioctl(drv->ioctl_sock, SIOCGIWMODE, &iwr) < 0) ++#endif ++ { ++ perror("ioctl[SIOCGIWMODE]"); ++ iwr.u.mode = IW_MODE_INFRA; ++ } ++ ++ if (iwr.u.mode == IW_MODE_INFRA) { ++ /* ++ * Clear the BSSID selection and set a random SSID to make sure ++ * the driver will not be trying to associate with something ++ * even if it does not understand SIOCSIWMLME commands (or ++ * tries to associate automatically after deauth/disassoc). ++ */ ++ wpa_driver_wext_set_bssid(drv, null_bssid); ++ ++ for (i = 0; i < 32; i++) ++ ssid[i] = rand() & 0xFF; ++ wpa_driver_wext_set_ssid(drv, ssid, 32); ++ } ++} ++ ++ ++ ++/** ++ * wpa_driver_wext_set_mode - Set wireless mode (infra/adhoc), SIOCSIWMODE ++ * @priv: Pointer to private wext data from wpa_driver_wext_init() ++ * @mode: 0 = infra/BSS (associate with an AP), 1 = adhoc/IBSS ++ * Returns: 0 on success, -1 on failure ++ */ ++int wpa_driver_wext_set_mode(void *priv, int mode) ++{ ++ struct wpa_driver_wext_data *drv = priv; ++ struct iwreq iwr; ++ int ret = -1, flags; ++ unsigned int new_mode = mode ? IW_MODE_ADHOC : IW_MODE_INFRA; ++ ++ os_memset(&iwr, 0, sizeof(iwr)); ++ os_strlcpy(iwr.ifr_name, drv->ifname, IFNAMSIZ); ++ iwr.u.mode = new_mode; ++ ++#ifdef RTK_INBAND ++ if (inband_ioctl(SIOCSIWMODE, &iwr) == 0) ++#else ++ if (ioctl(drv->ioctl_sock, SIOCSIWMODE, &iwr) == 0) ++#endif ++ { ++ ret = 0; ++ goto done; ++ } ++ ++ if (errno != EBUSY) { ++ perror("ioctl[SIOCSIWMODE]"); ++ goto done; ++ } ++ ++ /* mac80211 doesn't allow mode changes while the device is up, so if ++ * the device isn't in the mode we're about to change to, take device ++ * down, try to set the mode again, and bring it back up. ++ */ ++ ++#ifdef RTK_INBAND ++ if (inband_ioctl(SIOCGIWMODE, &iwr) < 0) ++#else ++ if (ioctl(drv->ioctl_sock, SIOCGIWMODE, &iwr) < 0) ++#endif ++ { ++ perror("ioctl[SIOCGIWMODE]"); ++ goto done; ++ } ++ ++ if (iwr.u.mode == new_mode) { ++ ret = 0; ++ goto done; ++ } ++ ++ if (wpa_driver_wext_get_ifflags(drv, &flags) == 0) { ++ (void) wpa_driver_wext_set_ifflags(drv, flags & ~IFF_UP); ++ ++ /* Try to set the mode again while the interface is down */ ++ iwr.u.mode = new_mode; ++ ++#ifdef RTK_INBAND ++ if (inband_ioctl(SIOCSIWMODE, &iwr) < 0) ++#else ++ if (ioctl(drv->ioctl_sock, SIOCSIWMODE, &iwr) < 0) ++#endif ++ perror("ioctl[SIOCSIWMODE]"); ++ else ++ ret = 0; ++ ++ /* Ignore return value of get_ifflags to ensure that the device ++ * is always up like it was before this function was called. ++ */ ++ (void) wpa_driver_wext_get_ifflags(drv, &flags); ++ (void) wpa_driver_wext_set_ifflags(drv, flags | IFF_UP); ++ } ++ ++done: ++ return ret; ++} ++ ++ ++ ++int wpa_driver_wext_set_operstate(void *priv, int state) ++{ ++ struct wpa_driver_wext_data *drv = priv; ++ ++ wpa_printf(MSG_DEBUG, "%s: operstate %d->%d (%s)", ++ __func__, drv->operstate, state, state ? "UP" : "DORMANT"); ++ drv->operstate = state; ++ return wpa_driver_wext_send_oper_ifla( ++ drv, -1, state ? IF_OPER_UP : IF_OPER_DORMANT); ++} ++ ++ ++ ++const struct wpa_driver_ops wpa_driver_wext_ops = { ++ .name = "wext", ++ .desc = "Linux wireless extensions (generic)", ++ .get_bssid = wpa_driver_wext_get_bssid, ++ .get_ssid = wpa_driver_wext_get_ssid, ++ //.set_wpa = wpa_driver_wext_set_wpa, ++ //.set_key = wpa_driver_wext_set_key, ++ //.set_countermeasures = wpa_driver_wext_set_countermeasures, ++ //.set_drop_unencrypted = wpa_driver_wext_set_drop_unencrypted, ++ .scan = wpa_driver_wext_scan, ++ .get_scan_results2 = wpa_driver_wext_get_scan_results, ++ //.deauthenticate = wpa_driver_wext_deauthenticate, ++ //.disassociate = wpa_driver_wext_disassociate, ++ //.set_mode = wpa_driver_wext_set_mode, ++ //.associate = wpa_driver_wext_associate, ++ //.set_auth_alg = wpa_driver_wext_set_auth_alg, ++ .init = wpa_driver_wext_init, ++ .deinit = wpa_driver_wext_deinit, ++ //.add_pmkid = wpa_driver_wext_add_pmkid, ++ //.remove_pmkid = wpa_driver_wext_remove_pmkid, ++ //.flush_pmkid = wpa_driver_wext_flush_pmkid, ++ //.get_capa = wpa_driver_wext_get_capa, ++ .set_operstate = wpa_driver_wext_set_operstate, ++}; +Index: hostapd-rtk-0.6.10/src/drivers/driver_realtek_wext.h +=================================================================== +--- /dev/null ++++ hostapd-rtk-0.6.10/src/drivers/driver_realtek_wext.h +@@ -0,0 +1,106 @@ ++/* ++ * WPA Supplicant - driver_wext exported functions ++ * Copyright (c) 2003-2005, Jouni Malinen <j@w1.fi> ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * Alternatively, this software may be distributed under the terms of BSD ++ * license. ++ * ++ * See README and COPYING for more details. ++ */ ++ ++#ifndef DRIVER_WEXT_H ++#define DRIVER_WEXT_H ++ ++#include <net/if.h> ++ ++#ifdef RTK_INBAND ++#ifndef __IOH_H ++#include <librtk-inband/ioh.h> ++#endif ++#endif ++ ++#ifndef ntohll ++#define ntohll(x) (((u64)(ntohl((u32)((x << 32) >> 32))) << 32) | (u32)ntohl(((u32)(x >> 32)))) ++#endif ++ ++#ifndef htonll ++#define htonll(x) (((u64)(htonl((u32)((x << 32) >> 32))) << 32) | (u32)htonl(((u32)(x >> 32)))) ++#endif ++ ++ ++ ++struct wpa_driver_wext_data { ++ void *ctx; ++ int event_sock; ++ int ioctl_sock; ++ int mlme_sock; ++ char ifname[IFNAMSIZ + 1]; ++ int ifindex; ++ int ifindex2; ++ int if_removed; ++ u8 *assoc_req_ies; ++ size_t assoc_req_ies_len; ++ u8 *assoc_resp_ies; ++ size_t assoc_resp_ies_len; ++ struct wpa_driver_capa capa; ++ int has_capability; ++ int we_version_compiled; ++ ++ /* for set_auth_alg fallback */ ++ int use_crypt; ++ int auth_alg_fallback; ++ ++ int operstate; ++ ++ char mlmedev[IFNAMSIZ + 1]; ++ ++ int scan_complete_events; ++ ++#ifdef RTK_INBAND ++ struct ioh_class netlink_ioh_obj; ++#endif ++ ++}; ++ ++void convert_to_net (const char *name, void *data, int data_size); ++void convert_to_host (const char *name, void *data, int data_size); ++ ++int wpa_driver_wext_get_ifflags(struct wpa_driver_wext_data *drv, int *flags); ++int wpa_driver_wext_set_ifflags(struct wpa_driver_wext_data *drv, int flags); ++int wpa_driver_wext_get_bssid(void *priv, u8 *bssid); ++int wpa_driver_wext_set_bssid(void *priv, const u8 *bssid); ++int wpa_driver_wext_get_ssid(void *priv, u8 *ssid); ++int wpa_driver_wext_set_ssid(void *priv, const u8 *ssid, size_t ssid_len); ++//int wpa_driver_wext_set_freq(void *priv, int freq); ++int wpa_driver_wext_set_mode(void *priv, int mode); ++//int wpa_driver_wext_set_key(void *priv, wpa_alg alg, ++ //const u8 *addr, int key_idx, ++ //int set_tx, const u8 *seq, size_t seq_len, ++ //const u8 *key, size_t key_len); ++int wpa_driver_wext_scan(void *priv, const u8 *ssid, size_t ssid_len); ++struct wpa_scan_results * wpa_driver_wext_get_scan_results(void *priv); ++ ++void wpa_driver_wext_scan_timeout(void *eloop_ctx, void *timeout_ctx); ++ ++//int wpa_driver_wext_alternative_ifindex(struct wpa_driver_wext_data *drv, ++ //const char *ifname); ++ ++void * wpa_driver_wext_init(void *ctx, const char *ifname); ++void wpa_driver_wext_deinit(void *priv); ++ ++int wpa_driver_wext_set_operstate(void *priv, int state); ++//int wpa_driver_wext_get_version(struct wpa_driver_wext_data *drv); ++ ++//int wpa_driver_wext_associate(void *priv, ++ // struct wpa_driver_associate_params *params); ++//int wpa_driver_wext_get_capa(void *priv, struct wpa_driver_capa *capa); ++//int wpa_driver_wext_set_auth_param(struct wpa_driver_wext_data *drv, ++ //int idx, u32 value); ++//int wpa_driver_wext_cipher2wext(int cipher); ++//int wpa_driver_wext_keymgmt2wext(int keymgmt); ++ ++#endif /* DRIVER_WEXT_H */ diff --git a/package/hostapd-rtk/patches/003-hostapd-diff.patch b/package/hostapd-rtk/patches/003-hostapd-diff.patch new file mode 100644 index 000000000..108bca5d8 --- /dev/null +++ b/package/hostapd-rtk/patches/003-hostapd-diff.patch @@ -0,0 +1,300 @@ +Index: hostapd-0.6.10-try/hostapd/accounting.c +=================================================================== +--- hostapd-0.6.10-try.orig/hostapd/accounting.c ++++ hostapd-0.6.10-try/hostapd/accounting.c +@@ -28,10 +28,6 @@ + * input/output octets and updates Acct-{Input,Output}-Gigawords. */ + #define ACCT_DEFAULT_UPDATE_INTERVAL 300 + +-static void accounting_sta_get_id(struct hostapd_data *hapd, +- struct sta_info *sta); +- +- + static struct radius_msg * accounting_msg(struct hostapd_data *hapd, + struct sta_info *sta, + int status_type) +@@ -400,7 +396,7 @@ void accounting_sta_stop(struct hostapd_ + } + + +-static void accounting_sta_get_id(struct hostapd_data *hapd, ++void accounting_sta_get_id(struct hostapd_data *hapd, + struct sta_info *sta) + { + sta->acct_session_id_lo = hapd->acct_session_id_lo++; +Index: hostapd-0.6.10-try/hostapd/accounting.h +=================================================================== +--- hostapd-0.6.10-try.orig/hostapd/accounting.h ++++ hostapd-0.6.10-try/hostapd/accounting.h +@@ -22,5 +22,7 @@ int accounting_init(struct hostapd_data + void accounting_deinit(struct hostapd_data *hapd); + int accounting_reconfig(struct hostapd_data *hapd, + struct hostapd_config *oldconf); ++void accounting_sta_get_id(struct hostapd_data *hapd, ++ struct sta_info *sta); + + #endif /* ACCOUNTING_H */ +Index: hostapd-0.6.10-try/hostapd/config.c +=================================================================== +--- hostapd-0.6.10-try.orig/hostapd/config.c ++++ hostapd-0.6.10-try/hostapd/config.c +@@ -1461,6 +1461,7 @@ struct hostapd_config * hostapd_config_r + conf->driver = hostapd_drivers[j]; + break; + } ++ wpa_printf(MSG_ERROR, "Index:%d driver name:%s, choice:%s",j,hostapd_drivers[j]->name,pos); + } + if (conf->driver == NULL) { + wpa_printf(MSG_ERROR, "Line %d: invalid/" +@@ -2251,7 +2252,9 @@ struct hostapd_config * hostapd_config_r + } else { + wpa_printf(MSG_ERROR, "Line %d: unknown configuration " + "item '%s'", line, buf); ++#ifndef RTK_HAPD //In order to support realtek private configurations + errors++; ++#endif + } + } + +Index: hostapd-0.6.10-try/hostapd/defconfig +=================================================================== +--- hostapd-0.6.10-try.orig/hostapd/defconfig ++++ hostapd-0.6.10-try/hostapd/defconfig +@@ -10,7 +10,7 @@ + # to override previous values of the variables. + + # Driver interface for Host AP driver +-CONFIG_DRIVER_HOSTAP=y ++#CONFIG_DRIVER_HOSTAP=y + + # Driver interface for wired authenticator + #CONFIG_DRIVER_WIRED=y +@@ -19,6 +19,9 @@ CONFIG_DRIVER_HOSTAP=y + #CONFIG_DRIVER_MADWIFI=y + #CFLAGS += -I../../madwifi # change to the madwifi source directory + ++# Driver interface for realtek driver ++CONFIG_DRIVER_REALTEK=y ++ + # Driver interface for Prism54 driver + #CONFIG_DRIVER_PRISM54=y + +@@ -107,9 +110,9 @@ CONFIG_EAP_TTLS=y + #CONFIG_EAP_FAST=y + + # Wi-Fi Protected Setup (WPS) +-#CONFIG_WPS=y ++CONFIG_WPS=y + # Enable UPnP support for external WPS Registrars +-#CONFIG_WPS_UPNP=y ++CONFIG_WPS_UPNP=y + + # EAP-IKEv2 + #CONFIG_EAP_IKEV2=y +Index: hostapd-0.6.10-try/hostapd/driver.h +=================================================================== +--- hostapd-0.6.10-try.orig/hostapd/driver.h ++++ hostapd-0.6.10-try/hostapd/driver.h +@@ -195,6 +195,10 @@ struct wpa_driver_ops { + const u8 *ie, size_t len); + int (*set_wps_probe_resp_ie)(const char *ifname, void *priv, + const u8 *ie, size_t len); ++ ++#ifdef RTK_HAPD ++ int (*driver_on)(void *priv, int on); ++#endif + }; + + static inline void * +Index: hostapd-0.6.10-try/hostapd/drivers.c +=================================================================== +--- hostapd-0.6.10-try.orig/hostapd/drivers.c ++++ hostapd-0.6.10-try/hostapd/drivers.c +@@ -27,6 +27,9 @@ extern struct wpa_driver_ops wpa_driver_ + #ifdef CONFIG_DRIVER_MADWIFI + extern struct wpa_driver_ops wpa_driver_madwifi_ops; /* driver_madwifi.c */ + #endif /* CONFIG_DRIVER_MADWIFI */ ++#ifdef CONFIG_DRIVER_REALTEK ++extern struct wpa_driver_ops wpa_driver_realtek_ops; /* driver_realtek.c */ ++#endif /* CONFIG_DRIVER_REALTEK */ + #ifdef CONFIG_DRIVER_ATHEROS + extern struct wpa_driver_ops wpa_driver_atheros_ops; /* driver_atheros.c */ + #endif /* CONFIG_DRIVER_ATHEROS */ +@@ -58,6 +61,9 @@ struct wpa_driver_ops *hostapd_drivers[] + #ifdef CONFIG_DRIVER_MADWIFI + &wpa_driver_madwifi_ops, + #endif /* CONFIG_DRIVER_MADWIFI */ ++#ifdef CONFIG_DRIVER_REALTEK ++ &wpa_driver_realtek_ops, ++#endif /* CONFIG_DRIVER_REALTEK */ + #ifdef CONFIG_DRIVER_ATHEROS + &wpa_driver_atheros_ops, + #endif /* CONFIG_DRIVER_ATHEROS */ +Index: hostapd-0.6.10-try/hostapd/hostapd.c +=================================================================== +--- hostapd-0.6.10-try.orig/hostapd/hostapd.c ++++ hostapd-0.6.10-try/hostapd/hostapd.c +@@ -361,6 +361,10 @@ int hostapd_reload_config(struct hostapd + hapd->conf = &newconf->bss[0]; + iface->conf = newconf; + ++#ifdef RTK_HAPD //Configuration works only after driver OFF -> ON ++ hapd->driver->driver_on(hapd->drv_priv, 0); ++#endif ++ + if (hostapd_setup_wpa_psk(hapd->conf)) { + wpa_printf(MSG_ERROR, "Failed to re-configure WPA PSK " + "after reloading configuration"); +@@ -387,11 +391,22 @@ int hostapd_reload_config(struct hostapd + /* try to continue */ + } + ++#ifdef RTK_HAPD ++ hostapd_deinit_wps(hapd); ++ ++ if(hostapd_init_wps(hapd, hapd->conf)) ++ wpa_printf(MSG_ERROR, "Could not init wps when reloading"); ++#endif ++ + if (hapd->conf->ieee802_1x || hapd->conf->wpa) + hostapd_set_ieee8021x(hapd->conf->iface, hapd, 1); + + hostapd_config_free(oldconf); + ++#ifdef RTK_HAPD //Configuration works only after driver OFF -> ON ++ hapd->driver->driver_on(hapd->drv_priv, 1); ++#endif ++ + wpa_printf(MSG_DEBUG, "Reconfigured interface %s", hapd->conf->iface); + + return 0; +@@ -1321,6 +1336,7 @@ static int hostapd_setup_bss(struct host + } + + hostapd_flush_old_stations(hapd); ++ + hostapd_set_privacy(hapd, 0); + + hostapd_broadcast_wep_clear(hapd); +Index: hostapd-0.6.10-try/hostapd/hostapd.h +=================================================================== +--- hostapd-0.6.10-try.orig/hostapd/hostapd.h ++++ hostapd-0.6.10-try/hostapd/hostapd.h +@@ -17,6 +17,8 @@ + #ifndef HOSTAPD_H + #define HOSTAPD_H + ++#define RTK_HAPD //For realtek driver support ++ + #include "common.h" + #include "ap.h" + +Index: hostapd-0.6.10-try/hostapd/iapp.c +=================================================================== +--- hostapd-0.6.10-try.orig/hostapd/iapp.c ++++ hostapd-0.6.10-try/hostapd/iapp.c +@@ -461,6 +461,16 @@ struct iapp_data * iapp_init(struct host + return NULL; + } + ++#ifdef RTK_HAPD //Add these cmd to make IAPP init successful ++ { ++ char cmd[128]; ++ sprintf(cmd, "route delete -net 224.0.0.0 netmask 240.0.0.0 dev %s", iface); ++ system(cmd); ++ sprintf(cmd, "route add -net 224.0.0.0 netmask 240.0.0.0 dev %s", iface); ++ system(cmd); ++ } ++#endif ++ + os_memset(&mreq, 0, sizeof(mreq)); + mreq.imr_multiaddr = iapp->multicast; + mreq.imr_address.s_addr = INADDR_ANY; +Index: hostapd-0.6.10-try/hostapd/wps_hostapd.c +=================================================================== +--- hostapd-0.6.10-try.orig/hostapd/wps_hostapd.c ++++ hostapd-0.6.10-try/hostapd/wps_hostapd.c +@@ -364,6 +364,10 @@ static int hostapd_wps_cred_cb(void *ctx + fprintf(nconf, "%02x", cred->key[i]); + } + fprintf(nconf, "\n"); ++ ++#ifdef RTK_HAPD ++ fprintf(nconf, "wep_key_len_unicast=%d\n", (cred->key_len)/2); ++#endif + } + } + +@@ -382,6 +386,12 @@ static int hostapd_wps_cred_cb(void *ctx + str_starts(buf, "wpa_pairwise=") || + str_starts(buf, "rsn_pairwise=") || + str_starts(buf, "wpa_key_mgmt=") || ++#ifdef RTK_HAPD ++ str_starts(buf, "wep_default_key=") || ++ str_starts(buf, "wep_key0=") || ++ str_starts(buf, "wep_key_len_unicast=") || ++ str_starts(buf, "ieee8021x=") || ++#endif + str_starts(buf, "wpa_passphrase="))) { + fprintf(nconf, "#WPS# %s", buf); + } else +@@ -403,8 +413,11 @@ static int hostapd_wps_cred_cb(void *ctx + /* Schedule configuration reload after short period of time to allow + * EAP-WSC to be finished. + */ +- eloop_register_timeout(0, 100000, wps_reload_config, hapd->iface, +- NULL); ++#ifdef RTK_HAPD ++ eloop_register_timeout(5, 0, wps_reload_config, hapd->iface, NULL); ++#else ++ eloop_register_timeout(0, 100000, wps_reload_config, hapd->iface, NULL); ++#endif + + /* TODO: dualband AP may need to update multiple configuration files */ + +@@ -666,6 +679,10 @@ int hostapd_init_wps(struct hostapd_data + wps->model_url = hapd->conf->model_url; + wps->upc = hapd->conf->upc; + ++#if defined(RTK_HAPD) || (1) ++ wps->set_selected_registrar = 0; ++#endif ++ + if (hostapd_wps_upnp_init(hapd, wps) < 0) { + wpa_printf(MSG_ERROR, "Failed to initialize WPS UPnP"); + wps_registrar_deinit(wps->registrar); +Index: hostapd-0.6.10-try/hostapd/wpa.c +=================================================================== +--- hostapd-0.6.10-try.orig/hostapd/wpa.c ++++ hostapd-0.6.10-try/hostapd/wpa.c +@@ -49,7 +49,11 @@ static int wpa_gtk_update(struct wpa_aut + + static const u32 dot11RSNAConfigGroupUpdateCount = 4; + static const u32 dot11RSNAConfigPairwiseUpdateCount = 4; ++#ifdef INBAND_CTRL ++static const u32 eapol_key_timeout_first = 1000; /* ms */ ++#else + static const u32 eapol_key_timeout_first = 100; /* ms */ ++#endif + static const u32 eapol_key_timeout_subseq = 1000; /* ms */ + + /* TODO: make these configurable */ +Index: hostapd-0.6.10-try/hostapd/Makefile +=================================================================== +--- hostapd-0.6.10-try.orig/hostapd/Makefile ++++ hostapd-0.6.10-try/hostapd/Makefile +@@ -122,6 +122,14 @@ OBJS += driver_atheros.o + CONFIG_L2_PACKET=y + endif + ++ifdef CONFIG_DRIVER_REALTEK ++CFLAGS += -DCONFIG_DRIVER_REALTEK ++CFLAGS += -DINBAND_CTRL ++LIBS += -linband ++OBJS += driver_realtek.o ++CONFIG_L2_PACKET=y ++endif ++ + ifdef CONFIG_DRIVER_PRISM54 + CFLAGS += -DCONFIG_DRIVER_PRISM54 + OBJS += driver_prism54.o diff --git a/package/hostapd-rtk/patches/004-hostapd-files.patch b/package/hostapd-rtk/patches/004-hostapd-files.patch new file mode 100644 index 000000000..a25374ef4 --- /dev/null +++ b/package/hostapd-rtk/patches/004-hostapd-files.patch @@ -0,0 +1,3529 @@ +Index: hostapd-rtk-0.6.10/hostapd/driver_realtek.c +=================================================================== +--- /dev/null ++++ hostapd-rtk-0.6.10/hostapd/driver_realtek.c +@@ -0,0 +1,3251 @@ ++/* ++ * hostapd / Driver interaction with Realtek 802.11 driver ++ * Copyright (c) ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * Alternatively, this software may be distributed under the terms of BSD ++ * license. ++ * ++ * See README and COPYING for more details. ++ */ ++ ++#include "includes.h" ++#include "common.h" ++#include <net/if.h> ++#include <sys/ioctl.h> ++ ++#include <net80211/ieee80211.h> ++#ifdef WME_NUM_AC ++/* Assume this is built against BSD branch of realtek driver. */ ++#define REALTEK_BSD ++#include <net80211/_ieee80211.h> ++#endif /* WME_NUM_AC */ ++#include <net80211/ieee80211_crypto.h> ++#include <net80211/ieee80211_ioctl.h> ++ ++#ifdef IEEE80211_IOCTL_SETWMMPARAMS ++/* Assume this is built against realtek-ng */ ++#define REALTEK_NG ++#endif /* IEEE80211_IOCTL_SETWMMPARAMS */ ++ ++#include <net/if_arp.h> ++#include "wireless_copy.h" ++//#include <linux/wireless.h> ++ ++//#include <netpacket/packet.h> ++ ++#include "hostapd.h" ++#include "driver.h" ++#include "ieee802_1x.h" ++#include "eloop.h" ++#include "priv_netlink.h" ++#include "sta_info.h" ++#include "l2_packet/l2_packet.h" ++ ++#include "eapol_sm.h" ++#include "wpa.h" ++#include "radius/radius.h" ++#include "ieee802_11.h" ++#include "accounting.h" ++#include "common.h" ++#include "wps_hostapd.h" ++ ++#ifndef EAP_WPS ++#define EAP_WPS ++#endif ++ ++#include "./driver_realtek.h" ++ ++#ifdef CONFIG_WPS ++#ifdef IEEE80211_IOCTL_FILTERFRAME ++//#include <netpacket/packet.h> ++#ifndef __LINUX_IF_PACKET_H ++//#ifndef __NETPACKET_PACKET_H ++#include <linux/if_packet.h> ++//#include <netpacket/packet.h> ++#endif ++ ++#ifndef ETH_P_80211_RAW ++#define ETH_P_80211_RAW 0x0019 ++#endif ++#endif /* IEEE80211_IOCTL_FILTERFRAME */ ++#endif /* CONFIG_WPS */ ++ ++/* ++ * Avoid conflicts with hostapd definitions by undefining couple of defines ++ * from madwifi header files. ++ */ ++#undef RSN_VERSION ++#undef WPA_VERSION ++#undef WPA_OUI_TYPE ++#undef WME_OUI_TYPE ++ ++#if defined(INBAND_CTRL) ++#ifndef __IOH_H ++#include <librtk-inband/ioh.h> ++#endif ++#define INBAND_INTF "br0" ++#define INBAND_SLAVE ("001234567899") ++#define INBAND_IOCTL_TYPE 0x8899 ++#define INBAND_NETLINK_TYPE 0x9000 ++#define INBAND_DEBUG 0 ++#define INBAND_IOCTLPKT_DUMP //hex_dump ++#undef STAND_ALONE ++#define IWREQ_LEN 32 ++#define INBAND_IOCTLTYPE_LEN 4 ++#define INBAND_IOCTLHDR_LEN 6 ++#define INBAND_PENDING_START(data) data+INBAND_IOCTLHDR_LEN+IWREQ_LEN ++#define INBAND_IOCTLRET_PTR(data) data+INBAND_IOCTLTYPE_LEN ++#define IOH_HDR_LEN sizeof(struct ioh_header) ++#else ++#define STAND_ALONE ++#endif ++ ++//#define HOST_LITTLE_ENDIAN 1 //mark_endian ++ ++#ifdef RTK_MBSSID ++ ++struct i802_bss { ++ //void *ctx; //back pointer to hapd per bss data ++ struct realtek_driver_data *drv; ++ struct i802_bss *next; ++ int ifindex; ++ char ifname[IFNAMSIZ + 1]; ++ struct l2_packet_data *sock_xmit; /* raw packet xmit socket */ ++ //unsigned int beacon_set:1; ++}; ++ ++#endif ++ ++ ++struct realtek_driver_data { ++ //struct driver_ops ops; /* base class */ ++ struct hostapd_data *hapd; /* back pointer */ ++ ++ char iface[IFNAMSIZ + 1]; ++ int ifindex; ++ struct l2_packet_data *sock_xmit; /* raw packet xmit socket */ ++#ifdef RTK_MBSSID ++ int sock_recv; ++#else ++ struct l2_packet_data *sock_recv; /* raw packet recv socket */ ++#endif ++ int ioctl_sock; /* socket for ioctl() use */ ++ int wext_sock; /* socket for wireless events */ ++ int we_version; ++ u8 acct_mac[ETH_ALEN]; ++ struct hostap_sta_driver_data acct_data; ++#if defined(INBAND_CTRL) ++ struct ioh_class netlink_ioh_obj; ++#endif ++ ++#ifdef RTK_MBSSID ++ struct i802_bss first_bss; ++ int if_indices[RTK_MAX_IF_INDEX]; ++ int num_if_indices; ++#endif ++}; ++ ++struct rtk_hapd_config rtk_config; ++ ++const struct wpa_driver_ops wpa_driver_realtek_ops; ++ ++static void realtek_deinit(void *priv); ++static int realtek_sta_deauth(void *priv, const u8 *addr, int reason_code); ++ ++#ifdef EAP_WPS ++static int realtek_set_wps_beacon_ie(const char *ifname, void *priv, const u8 *iebuf, size_t iebuflen); ++static int realtek_set_wps_probe_resp_ie(const char *ifname, void *priv, const u8 *iebuf, size_t iebuflen); ++static int realtek_set_wps_assoc_resp_ie(const char *ifname, void *priv, const u8 *iebuf, size_t iebuflen); ++static int realtek_start_receive_prob_req(void *priv); ++#endif /* EAP_WPS */ ++ ++#ifdef RTK_HAPD ++static int realtek_driver_on(void *priv, int on); ++static int realtek_hapd_config(void *priv); ++#endif ++ ++static int realtek_read_priv_vap_cfg(const char *ifname,void *priv, struct rtk_hapd_config* config); ++static int realtek_config_rate(int *rate_list, unsigned int *rate_config); ++static int realtek_read_hapd_cfg(struct hostapd_data *hapd,void *priv, struct rtk_hapd_config* config); ++ ++ ++#ifdef MODIFIED_BY_SONY ++static int wext_set_key(void *priv, int alg, ++ const u8 *addr, int key_idx, ++ int set_tx, const u8 *seq, size_t seq_len, ++ const u8 *key, size_t key_len); ++#endif /* MODIFIED_BY_SONY */ ++ ++#ifdef RTK_MBSSID ++static int add_ifidx(struct realtek_driver_data *drv, int ifidx) ++{ ++ int i; ++ wpa_printf(MSG_DEBUG, "nl80211: Add own interface ifindex %d", ++ ifidx); ++ for (i = 0; i < drv->num_if_indices; i++) { ++ if (drv->if_indices[i] == 0) { ++ drv->if_indices[i] = ifidx; ++ return; ++ } ++ } ++ ++ return -1; ++} ++ ++static int have_ifidx(struct realtek_driver_data *drv, int ifidx) ++{ ++ int i; ++ ++ for (i = 0; i < drv->num_if_indices; i++) ++ if (drv->if_indices[i] == ifidx) ++ return 1; ++ return 0; ++} ++ ++ ++static struct hostapd_data *find_hapd_by_ifname(void *priv,const char *ifname) ++{ ++ struct realtek_driver_data *drv = priv; ++ struct hostapd_data *hapd = drv->hapd,*bss_hapd=hapd; ++ struct hostapd_iface *iface = hapd->iface; ++ struct hostapd_bss_config *conf; ++ int j; ++ ++ ++ for (j = 0; j < iface->num_bss; j++) ++ { ++ bss_hapd = iface->bss[j] ; ++ conf = bss_hapd->conf; ++ if(os_strcmp(conf->iface, ifname) == 0) //find the entry ++ break; ++ ++ } ++ ++ return bss_hapd; ++} ++ ++static struct hostapd_data *find_hapd_by_ifindex(void *priv,int ifindex) ++{ ++ struct realtek_driver_data *drv = priv; ++ struct hostapd_data *hapd = drv->hapd; ++ struct i802_bss *tbss = &drv->first_bss,*bss; ++ ++ ++ if( drv->ifindex == ifindex) //if it's for Root AP ++ goto end; ++ ++ while (tbss) { //find the VAP ++ ++ bss = tbss->next; ++ ++ if(bss == NULL) ++ break; ++ ++ if( bss->ifindex == ifindex ) //find the entry ++ { ++ hapd = (struct hostapd_data *)find_hapd_by_ifname(drv,bss->ifname); ++ break; ++ } ++ tbss = tbss->next; ++ } ++end: ++ return hapd; ++} ++ ++static struct hostapd_data *find_hapd_by_sta(void *priv,u8 *sta_addr) ++{ ++ struct realtek_driver_data *drv = priv; ++ struct hostapd_data *hapd = drv->hapd; ++ struct hostapd_iface *iface = hapd->iface; ++ int j; ++ ++ for (j = 0; j < iface->num_bss; j++) { ++ if (ap_get_sta(iface->bss[j], sta_addr)) { ++ hapd = iface->bss[j]; ++ break; ++ } ++ } ++ ++ return hapd; ++} ++ ++static int rtk_free_bss_by_ifname(void *priv, const char *ifname) ++{ ++ struct realtek_driver_data *drv = priv; ++ struct i802_bss *tbss = &drv->first_bss,*bss; ++ ++ while (tbss) { ++ ++ bss = tbss->next; ++ if(bss == NULL) ++ break; ++ if(os_strcmp(bss->ifname, ifname) == 0) //find the entry ++ { ++ if (bss->sock_xmit != NULL) //deinit socket ++ l2_packet_deinit(bss->sock_xmit); ++ ++ tbss->next = bss->next; ++ os_free(bss); ++ break; ++ } ++ tbss = tbss->next ; ++ } ++ return 0; ++} ++ ++static struct l2_packet_data *rtk_find_l2sock_by_ifname(void *priv, const char *ifname) ++{ ++ struct realtek_driver_data *drv = priv; ++ struct i802_bss *tbss = &drv->first_bss,*bss; ++ struct l2_packet_data *eapol_sock=drv->sock_xmit; ++ ++ if(os_strcmp(drv->iface,ifname)==0) //if it's for Root AP ++ goto end; ++ ++ ++ while (tbss) { //find the VAP ++ ++ bss = tbss->next; ++ ++ if(bss == NULL) ++ break; ++ ++ if(os_strcmp(bss->ifname, ifname) == 0) //find the entry ++ { ++ eapol_sock = bss->sock_xmit; ++ break; ++ } ++ tbss = tbss->next; ++ } ++ ++end: ++ return eapol_sock; ++} ++ ++static void handle_eapol(int sock, void *eloop_ctx, void *sock_ctx) ++{ ++ struct realtek_driver_data *drv = eloop_ctx; ++ struct hostapd_data *hapd = drv->hapd; ++ struct sockaddr_ll lladdr; ++ unsigned char buf[3000]; ++ int len,j; ++ socklen_t fromlen = sizeof(lladdr); ++ struct hostapd_iface *iface = hapd->iface; ++ unsigned char *sa; ++ len = recvfrom(sock, buf, sizeof(buf), 0, ++ (struct sockaddr *)&lladdr, &fromlen); ++ ++ if (len < 0) { ++ perror("recv"); ++ return; ++ } ++ sa = (unsigned char *)lladdr.sll_addr; ++ //if (have_ifidx(drv, lladdr.sll_ifindex)) //mark_mbssid , if br0 rcv?? ++ //{ ++ for (j = 0; j < iface->num_bss; j++) { ++ if (ap_get_sta(iface->bss[j], sa)) { ++ hapd = iface->bss[j]; ++ break; ++ } ++ } ++ ++ /*printf("handle_eapol if=%s src_mac=%x:%x:%x:%x:%x:%x\n",hapd->conf->iface, ++ sa[0],sa[1],sa[2],sa[3],sa[4],sa[5]);*/ ++ ieee802_1x_receive(hapd, sa, buf, len); ++ //} ++} ++#endif ++ ++#ifdef INBAND_CTRL // HOST_LITTLE_ENDIAN ++static void rtk_cfg_to_bigEndian(struct rtk_hapd_config *config_ptr) ++{ ++ config_ptr->band = htonl(config_ptr->band); ++ config_ptr->channel = htonl(config_ptr->channel); ++ config_ptr->bcnint = htonl(config_ptr->bcnint); ++ config_ptr->dtimperiod = htonl(config_ptr->dtimperiod); ++ config_ptr->stanum = htonl(config_ptr->stanum); ++ config_ptr->rtsthres = htonl(config_ptr->rtsthres); ++ config_ptr->fragthres = htonl(config_ptr->fragthres); ++ config_ptr->oprates = htonl(config_ptr->oprates); ++ config_ptr->basicrates = htonl(config_ptr->basicrates); ++ config_ptr->preamble = htonl(config_ptr->preamble); ++ config_ptr->aclmode = htonl(config_ptr->aclmode); ++ config_ptr->aclnum = htonl(config_ptr->aclnum); ++ config_ptr->hiddenAP = htonl(config_ptr->hiddenAP); ++ config_ptr->qos_enable = htonl(config_ptr->qos_enable); ++ config_ptr->expired_time = htonl(config_ptr->expired_time); ++ config_ptr->block_relay = htonl(config_ptr->block_relay); ++ config_ptr->shortGI20M = htonl(config_ptr->shortGI20M); ++ config_ptr->shortGI40M = htonl(config_ptr->shortGI40M); ++ //Above are for Hostapd owned configurations //==================================================== ++ config_ptr->phyBandSelect = htonl(config_ptr->phyBandSelect); ++ config_ptr->ther = htonl(config_ptr->ther); ++ config_ptr->swcrypto = htonl(config_ptr->swcrypto); ++ config_ptr->regdomain = htonl(config_ptr->regdomain); ++ config_ptr->autorate = htonl(config_ptr->autorate); ++ config_ptr->fixrate = htonl(config_ptr->fixrate); ++ config_ptr->disable_protection = htonl(config_ptr->disable_protection); ++ config_ptr->disable_olbc = htonl(config_ptr->disable_olbc); ++ config_ptr->deny_legacy = htonl(config_ptr->deny_legacy); ++ config_ptr->opmode = htonl(config_ptr->opmode); ++ config_ptr->vap_enable = htonl(config_ptr->vap_enable); ++ config_ptr->use40M = htonl(config_ptr->use40M); ++ config_ptr->_2ndchoffset = htonl(config_ptr->_2ndchoffset); ++ config_ptr->ampdu = htonl(config_ptr->ampdu); ++ config_ptr->coexist = htonl(config_ptr->coexist); ++ config_ptr->rssi_dump = htonl(config_ptr->rssi_dump); ++ config_ptr->mp_specific = htonl(config_ptr->mp_specific); ++ config_ptr->use_ext_pa = htonl(config_ptr->use_ext_pa); ++ config_ptr->macPhyMode = htonl(config_ptr->macPhyMode); ++ //Below are for RTK private configurations ++ } ++#endif ++ ++ ++static int ++set80211priv(const char *ifname,struct realtek_driver_data *drv, int op, void *data, int len) ++{ ++ struct iwreq iwr; ++ int do_inline = (len < IFNAMSIZ); ++ ++ /* Poorly thought out inteface -- certain ioctls MUST use ++ * the non-inline method: ++ */ ++ if ( ++ #ifdef IEEE80211_IOCTL_SET_APPIEBUF ++ op == IEEE80211_IOCTL_SET_APPIEBUF || ++ #endif ++ #ifdef IEEE80211_IOCTL_FILTERFRAME ++ op == IEEE80211_IOCTL_FILTERFRAME || ++ #endif ++ 0 ++ ) { ++ do_inline = 0; ++ } ++ ++ memset(&iwr, 0, sizeof(iwr)); ++ strncpy(iwr.ifr_name, ifname, IFNAMSIZ); ++ ++ if (do_inline) { ++ memcpy(iwr.u.name, data, len); ++ } else { ++ /* ++ * Argument data MAY BE too big for inline transfer; setup a ++ * parameter block instead; the kernel will transfer ++ * the data for the driver. ++ */ ++ iwr.u.data.pointer = data; ++ iwr.u.data.length = len; ++ } ++ ++#ifdef STAND_ALONE ++ if (ioctl(drv->ioctl_sock, op, &iwr) < 0) { ++ { ++ int err = errno; ++ perror("set80211priv ioctl failed"); ++ wpa_printf(MSG_ERROR, "ioctl 0x%x failed errno=%d", ++ op, err); ++ } ++ return -1; ++ } ++#endif ++#if defined(INBAND_CTRL) ++ INBAND_IOCTLPKT_DUMP(&iwr,sizeof(iwr)); ++ ++ if ( inband_ioctl(op, &iwr) < 0) { ++ perror("set80211priv ioctl failed"); ++ wpa_printf(MSG_ERROR, "ioctl 0x%x failed", op); ++ return -1; ++ } ++#endif ++ ++ ++ return 0; ++} ++ ++static int ++set80211param(const char *ifname,struct realtek_driver_data *drv, int op, int arg) ++{ ++ struct iwreq iwr; ++ ++ memset(&iwr, 0, sizeof(iwr)); ++ strncpy(iwr.ifr_name, ifname, IFNAMSIZ); ++#ifdef INBAND_CTRL //HOST_LITTLE_ENDIAN ++// int need endian swap ++ op = htonl(op); ++ arg = htonl(arg); ++#endif ++ iwr.u.mode = op; ++ memcpy(iwr.u.name+sizeof(__u32), &arg, sizeof(arg)); ++ ++#ifdef STAND_ALONE ++ if (ioctl(drv->ioctl_sock, IEEE80211_IOCTL_SETPARAM, &iwr) < 0) { ++ perror("ioctl[IEEE80211_IOCTL_SETPARAM]"); ++ wpa_printf(MSG_DEBUG, "%s: Failed to set parameter (op %d " ++ "arg %d)", __func__, op, arg); ++ return -1; ++ } ++#endif ++#if defined(INBAND_CTRL) ++ INBAND_IOCTLPKT_DUMP(&iwr,sizeof(iwr)); ++ if (inband_ioctl(IEEE80211_IOCTL_SETPARAM, &iwr) < 0) { ++ perror("ioctl[IEEE80211_IOCTL_SETPARAM]"); ++ wpa_printf(MSG_DEBUG, "%s: Failed to set parameter (op %d " ++ "arg %d)", __func__, op, arg); ++ return -1; ++ } ++#endif ++ ++ return 0; ++} ++ ++static const char * ++ether_sprintf(const u8 *addr) ++{ ++ static char buf[sizeof(MACSTR)]; ++ ++ if (addr != NULL) ++ snprintf(buf, sizeof(buf), MACSTR, MAC2STR(addr)); ++ else ++ snprintf(buf, sizeof(buf), MACSTR, 0,0,0,0,0,0); ++ return buf; ++} ++ ++ ++static int ++realtek_set_wpa(char *ifname,struct realtek_driver_data *drv, int wpa, int psk, int cipher) ++{ ++ ++ if(psk & WPA_KEY_MGMT_PSK) ++ {//PSK mode, set PSK & cipher ++ if (set80211param(ifname,drv, IEEE80211_PARAM_KEYMGTALGS, wpa)) ++ { ++ wpa_printf(MSG_ERROR, "Unable to set key management algorithms"); ++ return -1; ++ } ++ if (set80211param(ifname,drv, IEEE80211_PARAM_UCASTCIPHERS, cipher)) ++ { ++ wpa_printf(MSG_ERROR, "Unable to set pairwise key ciphers"); ++ return -1; ++ } ++ ++ } ++ else ++ {//Enterprise mode, Disable PSK & set cipher. ++ if (set80211param(ifname,drv, IEEE80211_PARAM_KEYMGTALGS, 0)) ++ { ++ wpa_printf(MSG_ERROR, "Unable to set key management algorithms"); ++ return -1; ++ } ++ if (set80211param(ifname,drv, IEEE80211_PARAM_UCASTCIPHERS, cipher)) ++ { ++ wpa_printf(MSG_ERROR, "Unable to set pairwise key ciphers"); ++ return -1; ++ } ++ ++ } ++ ++ if (set80211param(ifname,drv, IEEE80211_PARAM_WPA, wpa)) ++ { ++ wpa_printf(MSG_ERROR, "Unable to set WPA"); ++ return -1; ++ } ++ ++ return set80211param(ifname,drv, IEEE80211_PARAM_AUTHMODE, IEEE80211_AUTH_WPA); ++ ++} ++ ++/* ++ * Configure WPA parameters. ++ */ ++static int ++realtek_configure_wpa(struct hostapd_data *hapd,struct realtek_driver_data *drv) ++{ ++ struct hostapd_bss_config *conf = hapd->conf; ++ int v; ++ ++ //delete conf->wpa_group & conf->rsn_preauth related parts (like ralink) ++ ++ wpa_printf(MSG_DEBUG, "realtek_configure_wpa +++ wpa=0x%x, psk=0x%x, cipher=0x%x", ++ conf->wpa, conf->wpa_key_mgmt, conf->wpa_pairwise); ++ ++ v = 0; ++ if (conf->wpa_pairwise & WPA_CIPHER_CCMP) ++ v |= 1<<IEEE80211_CIPHER_AES_CCM; ++ if (conf->wpa_pairwise & WPA_CIPHER_TKIP) ++ v |= 1<<IEEE80211_CIPHER_TKIP; ++ if (conf->wpa_pairwise & WPA_CIPHER_NONE) ++ v |= 1<<IEEE80211_CIPHER_NONE; ++ ++ if((conf->wpa == 0) || (conf->wpa > (HOSTAPD_WPA_VERSION_WPA|HOSTAPD_WPA_VERSION_WPA2))) ++ return -1; ++ else ++ return realtek_set_wpa(conf->iface,drv, conf->wpa , conf->wpa_key_mgmt, v); ++ ++} ++ ++static int ++realtek_set_iface_hwMac(const char *ifname,void *priv, char *addr) ++{ ++ struct realtek_driver_data *drv = priv; ++ struct ifreq ifreq; ++ ++ if (drv->ioctl_sock < 0) ++ return -1; ++ ++ os_memset(&ifreq, 0, sizeof(ifreq)); ++ os_strlcpy(ifreq.ifr_name, ifname, IFNAMSIZ); ++ ++ memcpy(ifreq.ifr_hwaddr.sa_data, addr, ETH_ALEN); ++ ifreq.ifr_hwaddr.sa_family = ARPHRD_ETHER; ++ ++#if defined(INBAND_CTRL) ++ INBAND_IOCTLPKT_DUMP(&ifreq,sizeof(ifreq)); ++ if (inband_ioctl(SIOCSIFHWADDR, &ifreq) < 0) { ++ perror("inband_ioctl[SIOCSIFHWADDR]"); ++ return -1; ++ } ++#else ++ if (ioctl(drv->ioctl_sock, SIOCSIFHWADDR, &ifreq) != 0) { ++ perror("ioctl[SIOCSIFHWADDR]"); ++ return -1; ++ } ++#endif ++ ++ ++ return 0; ++} ++ ++static int ++realtek_set_iface_flags(const char *ifname,void *priv, int dev_up) ++{ ++ struct realtek_driver_data *drv = priv; ++ struct ifreq ifr; ++ ++ wpa_printf(MSG_DEBUG, "realtek_set_iface_flags +++ dev_up = %d", dev_up); ++ ++ if (drv->ioctl_sock < 0) ++ return -1; ++ ++ if (dev_up) { ++ memset(&ifr, 0, sizeof(ifr)); ++ snprintf(ifr.ifr_name, IFNAMSIZ, "%s", ifname); ++ ifr.ifr_mtu = HOSTAPD_MTU; ++#ifdef STAND_ALONE ++ if (ioctl(drv->ioctl_sock, SIOCSIFMTU, &ifr) != 0) { ++ perror("ioctl[SIOCSIFMTU]"); ++ printf("Setting MTU failed - trying to survive with " ++ "current value\n"); ++ } ++#endif ++#if defined(INBAND_CTRL) ++ INBAND_IOCTLPKT_DUMP(&ifr,sizeof(ifr)); ++ if (inband_ioctl(SIOCSIFMTU, &ifr) < 0) { ++ perror("inband_ioctl[SIOCSIFMTU]"); ++ printf("Setting MTU failed - trying to survive with " ++ "current value\n"); ++ } ++#endif ++ } ++ ++ memset(&ifr, 0, sizeof(ifr)); ++ snprintf(ifr.ifr_name, IFNAMSIZ, "%s", ifname); ++#ifdef STAND_ALONE ++ if (ioctl(drv->ioctl_sock, SIOCGIFFLAGS, &ifr) != 0) { ++ perror("ioctl[SIOCGIFFLAGS]"); ++ return -1; ++ } ++#endif ++#if defined(INBAND_CTRL) ++ INBAND_IOCTLPKT_DUMP(&ifr,sizeof(ifr)); ++ if (inband_ioctl(SIOCGIFFLAGS, &ifr) < 0) { ++ perror("inband_ioctl[SIOCGIFFLAGS]"); ++ printf("inband_ioctl[SIOCGIFFLAGS] fail"); ++ return -1; ++ } ++#endif ++ ++ if (dev_up) ++ ifr.ifr_flags |= IFF_UP; ++ else ++ ifr.ifr_flags &= ~IFF_UP; ++#ifdef STAND_ALONE ++ if (ioctl(drv->ioctl_sock, SIOCSIFFLAGS, &ifr) != 0) { ++ perror("ioctl[SIOCSIFFLAGS]"); ++ return -1; ++ } ++#endif ++#if defined(INBAND_CTRL) ++ INBAND_IOCTLPKT_DUMP(&ifr,sizeof(ifr)); ++ if (inband_ioctl(SIOCSIFFLAGS, &ifr) < 0) { ++ perror("inband_ioctl[SIOCSIFFLAGS]"); ++ printf("inband_ioctl[SIOCGIFFLAGS] fail"); ++ return -1; ++ } ++#endif ++ ++ wpa_printf(MSG_DEBUG, "realtek_set_iface_flags ---"); ++ return 0; ++} ++ ++static int realtek_set_ieee8021x(const char *ifname, void *priv, int enabled) ++{ ++ struct realtek_driver_data *drv = priv; ++ struct hostapd_data *hapd = drv->hapd; ++ struct hostapd_bss_config *conf = hapd->conf; ++ struct hostapd_wep_keys wep = conf->ssid.wep; ++ ++#ifdef RTK_MBSSID //find the real VAP ++ hapd =(struct hostapd_data *) find_hapd_by_ifname(priv,ifname); ++ conf = hapd->conf; ++ wep = conf->ssid.wep; ++#endif ++ ++ wpa_printf(MSG_DEBUG, "realtek_set_ieee8021x+++ \n" ++ "enabled=%d, conf->auth_algs=%d, wep.keys_set=%d, conf->ieee802_1x=%d" ++ ,enabled, conf->auth_algs, wep.keys_set, conf->ieee802_1x); ++ ++ if(set80211param(ifname,priv, IEEE80211_PARAM_UCASTKEYLEN, conf->individual_wep_key_len)) ++ return -1; ++ ++ if (!enabled) { ++ wpa_printf(MSG_DEBUG, "set WEP"); ++ /* Set interface up flags after setting authentication modes, ++ done atlast in realtek_commit() */ ++ if(conf->auth_algs==1 && wep.keys_set==0) ++ return set80211param(ifname,priv, IEEE80211_PARAM_AUTHMODE, IEEE80211_AUTH_OPEN); ++ else if(conf->auth_algs==1 && wep.keys_set==1){ ++ return set80211param(ifname,priv, IEEE80211_PARAM_AUTHMODE, IEEE80211_AUTH_OPEN); ++ /*Fix for open wep when run using hostapd*/ ++ //return set80211param(priv, IEEE80211_PARAM_PRIVACY, 1); ++ } ++ else if(conf->auth_algs==2) ++ return set80211param(ifname,priv, IEEE80211_PARAM_AUTHMODE, IEEE80211_AUTH_SHARED); ++ else if(conf->auth_algs==3) ++ return set80211param(ifname,priv, IEEE80211_PARAM_AUTHMODE, IEEE80211_AUTH_AUTO); ++ else if(conf->auth_algs==8) //RTK_HAPD, add auth_algs=BIT(3) as value of none authentication. ++ return set80211param(ifname,priv, IEEE80211_PARAM_AUTHMODE, IEEE80211_AUTH_NONE); ++ } ++ ++ if (!conf->wpa && !conf->ieee802_1x) { ++ hostapd_logger(hapd, NULL, HOSTAPD_MODULE_DRIVER, ++ HOSTAPD_LEVEL_WARNING, "No 802.1X or WPA enabled!"); ++ return -1; ++ } ++ ++ if((conf->wpa == 0) && (conf->ieee802_1x)) ++ { ++ if(set80211param(ifname,priv, IEEE80211_PARAM_AUTHMODE, IEEE80211_AUTH_8021X)) ++ return -1; ++ } ++ ++ if (conf->wpa) ++ { ++ return realtek_configure_wpa(hapd,drv); ++ } ++ ++ return 0; ++} ++ ++static int ++realtek_set_privacy(const char *ifname, void *priv, int enabled) ++{ ++ struct realtek_driver_data *drv = priv; ++ struct hostapd_data *hapd = drv->hapd; ++ ++ wpa_printf(MSG_DEBUG, "realtek_set_privacy +++"); ++ ++ return set80211param(ifname,priv, IEEE80211_PARAM_PRIVACY, enabled); ++} ++ ++static int ++realtek_set_sta_authorized(void *priv, const u8 *addr, int authorized) ++{ ++ struct realtek_driver_data *drv = priv; ++ struct hostapd_data *hapd = drv->hapd; ++ struct hostapd_bss_config *conf = hapd->conf; ++ struct ieee80211req_mlme mlme; ++ int ret; ++ ++#ifdef RTK_MBSSID ++ hapd = (struct hostapd_data *)find_hapd_by_sta(priv,addr); ++ conf = hapd->conf; ++#endif ++ ++ if (authorized) ++ mlme.im_op = IEEE80211_MLME_AUTHORIZE; ++ else ++ mlme.im_op = IEEE80211_MLME_UNAUTHORIZE; ++ mlme.im_reason = 0; ++ memcpy(mlme.im_macaddr, addr, IEEE80211_ADDR_LEN); ++ ret = set80211priv(conf->iface,priv, IEEE80211_IOCTL_SETMLME, &mlme, ++ sizeof(mlme)); ++ if (ret < 0) { ++ wpa_printf(MSG_DEBUG, "%s: Failed to %sauthorize STA " MACSTR, ++ __func__, authorized ? "" : "un", MAC2STR(addr)); ++ } ++ ++ return ret; ++} ++ ++static int ++realtek_sta_set_flags(void *priv, const u8 *addr, int flags_or, int flags_and) ++{ ++ ++ wpa_printf(MSG_DEBUG, "realtek_sta_set_flags +++"); ++ ++ /* For now, only support setting Authorized flag */ ++ if (flags_or & WLAN_STA_AUTHORIZED) ++ return realtek_set_sta_authorized(priv, addr, 1); ++ if (!(flags_and & WLAN_STA_AUTHORIZED)) ++ return realtek_set_sta_authorized(priv, addr, 0); ++ return 0; ++} ++ ++static int ++realtek_del_key(const char *ifname,void *priv, const u8 *addr, int key_idx) ++{ ++ struct realtek_driver_data *drv = priv; ++ struct hostapd_data *hapd = drv->hapd; ++ struct ieee80211req_del_key wk; ++ int ret; ++ ++ wpa_printf(MSG_DEBUG, "realtek_del_key +++"); ++ ++ memset(&wk, 0, sizeof(wk)); ++ if (addr != NULL) { ++ memcpy(wk.idk_macaddr, addr, IEEE80211_ADDR_LEN); ++ wk.idk_keyix = (u8) IEEE80211_KEYIX_NONE; ++ } else { ++ wk.idk_keyix = key_idx; ++ } ++ ++ ret = set80211priv(ifname ,priv, IEEE80211_IOCTL_DELKEY, &wk, sizeof(wk)); ++ if (ret < 0) { ++ wpa_printf(MSG_DEBUG, "%s: Failed to delete key (addr %s" ++ " key_idx %d)", __func__, ether_sprintf(addr), ++ key_idx); ++ } ++ ++ wpa_printf(MSG_DEBUG, "realtek_del_key ---"); ++ return ret; ++} ++ ++static int ++realtek_set_key(const char *ifname, void *priv, const char *alg, ++ const u8 *addr, int key_idx, ++ const u8 *key, size_t key_len, int txkey) ++{ ++ struct realtek_driver_data *drv = priv; ++ struct hostapd_data *hapd = drv->hapd; ++ struct hostapd_bss_config *conf = hapd->conf; ++ struct hostapd_wep_keys wep = conf->ssid.wep; ++ struct ieee80211req_key wk; ++ u_int8_t cipher; ++ int ret; ++ ++#ifdef RTK_MBSSID //find the real VAP ++ hapd = (struct hostapd_data *)find_hapd_by_ifname(priv,ifname); ++ conf = hapd->conf; ++ wep = conf->ssid.wep; ++#endif ++ ++ wpa_printf(MSG_DEBUG, "realtek_set_key +++"); ++ wpa_printf(MSG_DEBUG, "alg = %s\n, addr = %s\n, key_index = %d", alg, ether_sprintf(addr), key_idx); ++ ++ if (strcmp(alg, "none") == 0) ++ return realtek_del_key(ifname,priv, addr, key_idx); ++ ++ if ((strcmp(alg, "WEP") == 0) && ((wep.keys_set >= 1) && (wep.keys_set <= 4))) ++ cipher = IEEE80211_CIPHER_WEP; ++ else if (strcmp(alg, "TKIP") == 0) ++ cipher = IEEE80211_CIPHER_TKIP; ++ else if (strcmp(alg, "CCMP") == 0) ++ cipher = IEEE80211_CIPHER_AES_CCM; ++ else { ++ printf("%s: unknown/unsupported algorithm %s\n", ++ __func__, alg); ++ return -1; ++ } ++ ++ if (key_len > sizeof(wk.ik_keydata)) { ++ printf("%s: key length %lu too big\n", __func__, ++ (unsigned long) key_len); ++ return -3; ++ } ++ ++ memset(&wk, 0, sizeof(wk)); ++ wk.ik_type = cipher; ++ wk.ik_flags = IEEE80211_KEY_RECV | IEEE80211_KEY_XMIT; ++ if (addr == NULL) { ++ memset(wk.ik_macaddr, 0xff, IEEE80211_ADDR_LEN); ++ wk.ik_keyix = key_idx; ++ wk.ik_flags |= IEEE80211_KEY_DEFAULT; ++ } else { ++ memcpy(wk.ik_macaddr, addr, IEEE80211_ADDR_LEN); ++ wk.ik_keyix = key_idx; ++ //wk.ik_keyix = IEEE80211_KEYIX_NONE; ++ } ++ wk.ik_keylen = key_len; ++ memcpy(wk.ik_keydata, key, key_len); ++ ++#ifdef INBAND_CTRL //HOST_LITTLE_ENDIAN ++ // ik_keyix int16 need endian-swap ++ wk.ik_keyix = htons(wk.ik_keyix); ++ wk.ik_keylen = htonl(key_len); ++#endif ++ ret = set80211priv(ifname,priv, IEEE80211_IOCTL_SETKEY, &wk, sizeof(wk)); ++ if (ret < 0) { ++ wpa_printf(MSG_DEBUG, "%s: Failed to set key (addr %s" ++ " key_idx %d alg '%s' key_len %lu txkey %d)", ++ __func__, ether_sprintf(wk.ik_macaddr), key_idx, ++ alg, (unsigned long) key_len, txkey); ++ } ++ ++ wpa_printf(MSG_DEBUG, "realtek_set_key ---"); ++ return ret; ++} ++ ++ ++static int ++realtek_get_seqnum(const char *ifname, void *priv, const u8 *addr, int idx, ++ u8 *seq) ++{ ++//do nothing like broadcom & ralink, even madwifi did not call back for hosapd. ++ ++ wpa_printf(MSG_DEBUG, "realtek_get_seqnum +++"); ++ wpa_printf(MSG_DEBUG, "realtek_get_seqnum ---"); ++ ++ return 0; ++} ++ ++ ++static int ++realtek_flush(void *priv) ++{ ++//do nothing like broadcom & ralink ++ wpa_printf(MSG_DEBUG, "realtek_flush +++"); ++ wpa_printf(MSG_DEBUG, "realtek_flush ---"); ++ return 0; ++} ++ ++ ++static int ++realtek_read_sta_driver_data(void *priv, struct hostap_sta_driver_data *data, ++ const u8 *addr) ++{ ++#if 0 //not use now ++ struct realtek_driver_data *drv = priv; ++ wpa_printf(MSG_DEBUG, "realtek_read_sta_driver_data +++"); ++ ++#ifdef REALTEK_BSD ++ struct ieee80211req_sta_stats stats; ++ ++ memset(data, 0, sizeof(*data)); ++ ++ /* ++ * Fetch statistics for station from the system. ++ */ ++ memset(&stats, 0, sizeof(stats)); ++ memcpy(stats.is_u.macaddr, addr, IEEE80211_ADDR_LEN); ++ if (set80211priv(drv, ++#ifdef REALTEK_NG ++ IEEE80211_IOCTL_STA_STATS, ++#else /* REALTEK_NG */ ++ IEEE80211_IOCTL_GETSTASTATS, ++#endif /* REALTEK_NG */ ++ &stats, sizeof(stats))) { ++ wpa_printf(MSG_DEBUG, "%s: Failed to fetch STA stats (addr " ++ MACSTR ")", __func__, MAC2STR(addr)); ++ if (memcmp(addr, drv->acct_mac, ETH_ALEN) == 0) { ++ memcpy(data, &drv->acct_data, sizeof(*data)); ++ return 0; ++ } ++ ++ printf("Failed to get station stats information element.\n"); ++ return -1; ++ } ++#ifdef INBAND_CTRL //HOST_LITTLE_ENDIAN ++ stats.is_stats.ns_rx_data = ntohl(stats.is_stats.ns_rx_data); ++ stats.is_stats.ns_rx_bytes = ntohl(stats.is_stats.ns_rx_bytes); ++ stats.is_stats.ns_tx_data = ntohl(stats.is_stats.ns_tx_data); ++ stats.is_stats.ns_tx_bytes = ntohl(stats.is_stats.ns_tx_bytes); ++#endif ++ data->rx_packets = stats.is_stats.ns_rx_data; ++ data->rx_bytes = stats.is_stats.ns_rx_bytes; ++ data->tx_packets = stats.is_stats.ns_tx_data; ++ data->tx_bytes = stats.is_stats.ns_tx_bytes; ++ return 0; ++ ++#else /* REALTEK_BSD */ ++ ++ char buf[1024], line[128], *pos; ++ FILE *f; ++ unsigned long val; ++ ++ memset(data, 0, sizeof(*data)); ++ snprintf(buf, sizeof(buf), "/proc/net/realtek/%s/" MACSTR, ++ drv->iface, MAC2STR(addr)); ++ ++ f = fopen(buf, "r"); ++ if (!f) { ++ if (memcmp(addr, drv->acct_mac, ETH_ALEN) != 0) ++ return -1; ++ memcpy(data, &drv->acct_data, sizeof(*data)); ++ return 0; ++ } ++ /* Need to read proc file with in one piece, so use large enough ++ * buffer. */ ++ setbuffer(f, buf, sizeof(buf)); ++ ++ while (fgets(line, sizeof(line), f)) { ++ pos = strchr(line, '='); ++ if (!pos) ++ continue; ++ *pos++ = '\0'; ++ val = strtoul(pos, NULL, 10); ++ if (strcmp(line, "rx_packets") == 0) ++ data->rx_packets = val; ++ else if (strcmp(line, "tx_packets") == 0) ++ data->tx_packets = val; ++ else if (strcmp(line, "rx_bytes") == 0) ++ data->rx_bytes = val; ++ else if (strcmp(line, "tx_bytes") == 0) ++ data->tx_bytes = val; ++ } ++ ++ fclose(f); ++ ++ return 0; ++#endif /* REALTEK_BSD */ ++#endif ++return 0; ++} ++ ++ ++static int ++realtek_sta_clear_stats(void *priv, const u8 *addr) ++{ ++#if 0 //not support now ++#if defined(REALTEK_BSD) && defined(IEEE80211_MLME_CLEAR_STATS) ++ struct realtek_driver_data *drv = priv; ++ struct hostapd_data *hapd = drv->hapd; ++ struct ieee80211req_mlme mlme; ++ int ret; ++ ++ wpa_printf(MSG_DEBUG, "realtek_sta_clear_stats (BSD) +++"); ++ ++ mlme.im_op = IEEE80211_MLME_CLEAR_STATS; ++ memcpy(mlme.im_macaddr, addr, IEEE80211_ADDR_LEN); ++ ret = set80211priv(priv, IEEE80211_IOCTL_SETMLME, &mlme, ++ sizeof(mlme)); ++ if (ret < 0) { ++ wpa_printf(MSG_DEBUG, "%s: Failed to clear STA stats (addr " ++ MACSTR ")", __func__, MAC2STR(addr)); ++ } ++ ++ return ret; ++#else /* REALTEK_BSD && IEEE80211_MLME_CLEAR_STATS */ ++ wpa_printf(MSG_DEBUG, "realtek_sta_clear_stats +++"); ++ return 0; /* FIX */ ++#endif /* REALTEK_BSD && IEEE80211_MLME_CLEAR_STATS */ ++#endif ++return 0; ++} ++ ++ ++static int ++realtek_set_opt_ie(const char *ifname, void *priv, const u8 *ie, size_t ie_len) ++{ ++//do nothing like broadcom & ralink & madwifi ++ ++ wpa_printf(MSG_DEBUG, "realtek_set_opt_ie +++"); ++ wpa_printf(MSG_DEBUG, "realtek_set_opt_ie ---"); ++ return 0; ++} ++ ++static int ++realtek_is_ifup(const char *ifname,struct realtek_driver_data *drv) ++{ ++ struct ifreq ifr; ++ ++ if (drv->ioctl_sock < 0) ++ return 0; ++ ++ memset(&ifr, 0, sizeof(ifr)); ++ snprintf(ifr.ifr_name, IFNAMSIZ, "%s", ifname); ++#ifdef STAND_ALONE ++ if (ioctl(drv->ioctl_sock, SIOCGIFFLAGS, &ifr) != 0) { ++ perror("ioctl[SIOCGIFFLAGS]"); ++ return 0; ++ } ++#endif ++#if defined(INBAND_CTRL) ++ INBAND_IOCTLPKT_DUMP(&ifr,sizeof(ifr)); ++ if (inband_ioctl(SIOCGIFFLAGS, &ifr) < 0) { ++ perror("ioctl[SIOCGIFFLAGS]"); ++ return 0; ++ } ++#endif ++ ++ return ((ifr.ifr_flags & IFF_UP) == IFF_UP); ++} ++ ++static int ++realtek_sta_deauth(void *priv, const u8 *addr, int reason_code) ++{ ++ struct realtek_driver_data *drv = priv; ++ struct hostapd_data *hapd = drv->hapd; ++ struct hostapd_bss_config *conf = hapd->conf; ++ struct ieee80211req_mlme mlme; ++ int ret; ++ ++#ifdef RTK_MBSSID //find the sta belong to which MBSSID ++ hapd = (struct hostapd_data *)find_hapd_by_sta(priv,addr); ++ conf = hapd->conf; ++#endif ++ ++ wpa_printf(MSG_DEBUG, "realtek_sta_deauth +++"); ++ ++ mlme.im_op = IEEE80211_MLME_DEAUTH; ++ mlme.im_reason = reason_code; ++ memcpy(mlme.im_macaddr, addr, IEEE80211_ADDR_LEN); ++ if (!realtek_is_ifup(conf->iface,drv)) { ++ return EINVAL; ++ } ++#ifdef INBAND_CTRL //HOST_LITTLE_ENDIAN ++ //im_reason need swap ++ mlme.im_reason = htons(mlme.im_reason); ++#endif ++ ret = set80211priv(conf->iface,priv, IEEE80211_IOCTL_SETMLME, &mlme, sizeof(mlme)); ++ if (ret < 0) { ++ wpa_printf(MSG_DEBUG, "%s: Failed to deauth STA (addr " MACSTR ++ " reason %d)", ++ __func__, MAC2STR(addr), reason_code); ++ } ++ ++ return ret; ++} ++ ++static int ++realtek_sta_disassoc(void *priv, const u8 *addr, int reason_code) ++{ ++ struct realtek_driver_data *drv = priv; ++ struct hostapd_data *hapd = drv->hapd; ++ struct hostapd_bss_config *conf = hapd->conf; ++ struct ieee80211req_mlme mlme; ++ int ret; ++ ++#ifdef RTK_MBSSID //find the sta belong to which MBSSID ++ hapd = (struct hostapd_data *)find_hapd_by_sta(priv,addr); ++ conf = hapd->conf; ++#endif ++ ++ wpa_printf(MSG_DEBUG, "realtek_sta_disassoc +++"); ++ ++ mlme.im_op = IEEE80211_MLME_DISASSOC; ++ mlme.im_reason = reason_code; ++ memcpy(mlme.im_macaddr, addr, IEEE80211_ADDR_LEN); ++#ifdef INBAND_CTRL //HOST_LITTLE_ENDIAN ++ //im_reason need swap ++ mlme.im_reason = htons(mlme.im_reason); ++#endif ++ ret = set80211priv(conf->iface,priv, IEEE80211_IOCTL_SETMLME, &mlme, sizeof(mlme)); ++ if (ret < 0) { ++ wpa_printf(MSG_DEBUG, "%s: Failed to disassoc STA (addr " ++ MACSTR " reason %d)", ++ __func__, MAC2STR(addr), reason_code); ++ } ++ ++ return ret; ++} ++ ++#ifdef RTK_HAPD ++//Announce driver to remove sta list for IAPP function ++static int ++realtek_sta_remove(void *priv, const u8 *addr) ++{ ++ struct realtek_driver_data *drv = priv; ++ struct hostapd_data *hapd = drv->hapd; ++ struct hostapd_bss_config *conf = hapd->conf; ++ unsigned char para[32]; ++ struct iwreq wrq; ++ ++#ifdef RTK_MBSSID //find the sta belong to which MBSSID ++ hapd = (struct hostapd_data *)find_hapd_by_sta(priv,addr); ++ conf = hapd->conf; ++#endif ++ wpa_printf(MSG_DEBUG, "realtek_sta_remove +++"); ++ memset(para, 0, 32); ++ sprintf(para, "%02x%02x%02x%02x%02x%02x", addr[0], addr[1], ++ addr[2], addr[3], addr[4], addr[5]); ++ wrq.u.data.pointer = para; ++ wrq.u.data.length = strlen(para); ++ strncpy(wrq.ifr_name, conf->iface, IFNAMSIZ); ++#ifdef STAND_ALONE ++ ioctl(drv->ioctl_sock, RTL8192CD_IOCTL_DEL_STA, &wrq); ++#endif ++#ifdef INBAND_CTRL ++ inband_ioctl(RTL8192CD_IOCTL_DEL_STA, &wrq); ++#endif ++ ++ wpa_printf(MSG_DEBUG, "realtek_sta_remove ---"); ++ ++ return 0; ++} ++#endif ++ ++static int ++realtek_del_sta(struct hostapd_data *hapd,struct realtek_driver_data *drv, u8 addr[IEEE80211_ADDR_LEN]) ++{ ++ struct sta_info *sta; ++ ++ hostapd_logger(hapd, addr, HOSTAPD_MODULE_IEEE80211, ++ HOSTAPD_LEVEL_INFO, "disassociated"); ++ ++ sta = ap_get_sta(hapd, addr); ++ if (sta != NULL) { ++ sta->flags &= ~(WLAN_STA_AUTH | WLAN_STA_ASSOC); ++ wpa_auth_sm_event(sta->wpa_sm, WPA_DISASSOC); ++ sta->acct_terminate_cause = RADIUS_ACCT_TERMINATE_CAUSE_USER_REQUEST; ++ ieee802_1x_notify_port_enabled(sta->eapol_sm, 0); ++ ap_free_sta(hapd, sta); ++ } ++ return 0; ++} ++ ++static int ++realtek_process_wpa_ie(struct hostapd_data *hapd,struct realtek_driver_data *drv, struct sta_info *sta) ++{ ++ struct ieee80211req_wpaie ie; ++ int ielen, res; ++ u8 *iebuf = NULL; ++ struct hostapd_bss_config *conf = hapd->conf; ++ ++ wpa_printf(MSG_DEBUG, "realtek_process_wpa_ie +++"); ++ ++ /* ++ * Fetch negotiated WPA/RSN parameters from the system. ++ */ ++ memset(&ie, 0, sizeof(ie)); ++ memcpy(ie.wpa_macaddr, sta->addr, IEEE80211_ADDR_LEN); ++ ++ if (set80211priv(conf->iface,drv, HAPD_IOCTL_GETWPAIE, &ie, sizeof(ie))) ++ { ++ wpa_printf(MSG_ERROR, "%s: Failed to get WPA/RSN IE", __func__); ++ printf("Failed to get WPA/RSN information element.\n"); ++ return -1; ++ } ++ ++ //wpa_printf(MSG_DEBUG, "get wpa_ie = 0x%02x, 0x%02x, 0x%02x", ie.wpa_ie[0], ie.wpa_ie[1], ie.wpa_ie[2]); ++ //wpa_printf(MSG_DEBUG, "get wps_ie = 0x%02x, 0x%02x, 0x%02x", ie.wps_ie[0], ie.wps_ie[1], ie.wps_ie[2]); ++ ++ do { ++ iebuf = 0; ielen = 0; ++ if (conf->wpa & HOSTAPD_WPA_VERSION_WPA) { ++ iebuf = ie.wpa_ie; ielen = 0; ++ if ((iebuf[0] == WLAN_EID_VENDOR_SPECIFIC) && iebuf[1]) { ++ wpa_printf(MSG_DEBUG, "get wpa_ie"); ++ ielen = iebuf[1]; ++ break; ++ } ++ } ++ if (conf->wpa & HOSTAPD_WPA_VERSION_WPA2) { ++ iebuf = ie.rsn_ie; ielen = 0; ++ if ((iebuf[0] == WLAN_EID_RSN) && iebuf[1]) { ++ wpa_printf(MSG_DEBUG, "get rsn_ie"); ++ ielen = iebuf[1]; ++ break; ++ } ++ } ++ } while (0); ++ ++ wpabuf_free(sta->wps_ie); ++ if ((ie.wps_ie[0] == WLAN_EID_VENDOR_SPECIFIC) && ie.wps_ie[1]) ++ { ++ //Test rtl8192su usb-dongle wps_pbc/wps_pin ok via here. ++ wpa_printf(MSG_DEBUG, "get wps_ie"); ++ ielen = ie.wps_ie[1] + 2; ++ ++ sta->wps_ie = wpabuf_alloc(0); ++ sta->wps_ie->size = ielen; ++ sta->wps_ie->used = ielen; ++ sta->wps_ie->ext_data = os_malloc(ielen); ++ memcpy(sta->wps_ie->ext_data, ie.wps_ie, ielen); ++ ++ sta->flags |= WLAN_STA_WPS; ++ return 0; ++ } ++ else ++ { ++ sta->wps_ie = wpabuf_alloc(0); ++ sta->wps_ie->used = 0; ++ sta->wps_ie->ext_data = NULL; ++ ++ sta->flags &= ~WLAN_STA_WPS; ++ ++ ++ if((ielen == 0) && (conf->wps_state)){ ++ wpa_printf(MSG_DEBUG, "STA did not include WPA/RSN/WPS IE in (Re)Association Request " ++ "but WPS enabled at hostapd conf file - possible WPS use"); ++ sta->flags |= WLAN_STA_MAYBE_WPS; // Test dwa140 and wn111 wps_pbc/wps_pin ok because of here!!!! --zj ++ } ++ else{ ++ sta->flags &= ~WLAN_STA_MAYBE_WPS; ++ } ++ } ++ ++ if(ielen != 0) //_For WPS, neglect wpa_ie?? ++ { ++ if (sta->wpa_sm == NULL) ++ sta->wpa_sm = wpa_auth_sta_init(hapd->wpa_auth, sta->addr); ++ ++ if (sta->wpa_sm == NULL) ++ { ++ wpa_printf(MSG_ERROR, "Failed to initialize WPA state machine"); ++ return -1; ++ } ++ ++ ielen += 2; ++ res = wpa_validate_wpa_ie(hapd->wpa_auth, sta->wpa_sm, iebuf, ielen, NULL, 0); ++ ++ if (res != WPA_IE_OK) ++ { ++ wpa_printf(MSG_ERROR, "WPA/RSN information element rejected? (res %u)", res); ++ return -1; ++ } ++ else ++ wpa_printf(MSG_DEBUG, "WPA_IE_OK"); ++ } ++ ++ ++ return 0; ++} ++ ++static int ++realtek_issue_asocrsp(char *ifname,struct realtek_driver_data *drv, struct sta_info *sta) ++{ ++ int retVal = 0; ++ struct iwreq iwr; ++ DOT11_ASSOCIATION_RSP Association_Rsp; ++ ++ wpa_printf(MSG_DEBUG, "realtek_issue_asocrsp +++"); ++ ++ strncpy(iwr.ifr_name, ifname, IFNAMSIZ); ++ ++ iwr.u.data.pointer = (caddr_t)&Association_Rsp; ++ iwr.u.data.length = sizeof(DOT11_ASSOCIATION_RSP); ++ ++ Association_Rsp.EventId = DOT11_EVENT_ASSOCIATION_RSP; ++ ++ //?? Re-Association case?? ++ //Association_Rsp.EventId = DOT11_EVENT_REASSOCIATION_RSP; ++ ++ Association_Rsp.IsMoreEvent = FALSE; ++ Association_Rsp.Status = _STATS_SUCCESSFUL_; ++ memcpy(&Association_Rsp.MACAddr, sta->addr, IEEE80211_ADDR_LEN); ++ ++#ifdef STAND_ALONE ++ if(ioctl(drv->ioctl_sock, SIOCGIWIND, &iwr) < 0) ++ retVal = -1; ++ else ++ retVal = 0; ++#endif ++#if defined(INBAND_CTRL) ++ INBAND_IOCTLPKT_DUMP(&iwr,sizeof(iwr)); ++ if (inband_ioctl(SIOCGIWIND, &iwr) < 0) ++ retVal = -1; ++ else ++ retVal = 0; ++#endif ++ return retVal; ++ ++} ++ ++ ++static int ++realtek_new_sta(struct hostapd_data *hapd,struct realtek_driver_data *drv, u8 addr[IEEE80211_ADDR_LEN]) ++{ ++ struct hostapd_bss_config *conf = hapd->conf; ++ struct sta_info *sta; ++ int new_assoc; ++ ++ hostapd_logger(hapd, addr, HOSTAPD_MODULE_IEEE80211, ++ HOSTAPD_LEVEL_INFO, "associated"); ++ ++ sta = ap_get_sta(hapd, addr); ++ if (sta) { ++ accounting_sta_stop(hapd, sta); ++ } else { ++ //printf("realtek_new_sta hapd=%s \n",conf->iface); ++ sta = ap_sta_add(hapd, addr); ++ if (sta == NULL) ++ return -1; ++ } ++ //mark_mbssid , acct_mac ? per VAP? ++ if (memcmp(addr, drv->acct_mac, ETH_ALEN) == 0) { ++ /* Cached accounting data is not valid anymore. */ ++ memset(drv->acct_mac, 0, ETH_ALEN); ++ memset(&drv->acct_data, 0, sizeof(drv->acct_data)); ++ } ++ accounting_sta_get_id(hapd, sta); ++ ++ if (hapd->conf->wpa || hapd->conf->wps_state) { ++ if (realtek_process_wpa_ie(hapd,drv, sta)) ++ return -1; ++ if((sta->wps_ie->used == 0) && ((conf->wpa_key_mgmt & WPA_KEY_MGMT_PSK) == 0) && (conf->ieee802_1x != 0)) ++ {//do issue Association response just for RADIUS authentication. ++ if(realtek_issue_asocrsp(hapd->conf->iface,drv, sta)) ++ return -1; ++ } ++ } ++ else ++ { ++ if(conf->ieee802_1x != 0) ++ if(realtek_issue_asocrsp(hapd->conf->iface,drv, sta)) ++ return -1; ++ } ++ ++ /* ++ * Now that the internal station state is setup ++ * kick the authenticator into action. ++ */ ++ ++ wpa_printf(MSG_DEBUG, "Try to kick the authenticator into action"); ++ ++ new_assoc = (sta->flags & WLAN_STA_ASSOC) == 0; ++ sta->flags |= WLAN_STA_AUTH | WLAN_STA_ASSOC; ++ wpa_auth_sm_event(sta->wpa_sm, WPA_ASSOC); ++ hostapd_new_assoc_sta(hapd, sta, !new_assoc); ++ ieee802_1x_notify_port_enabled(sta->eapol_sm, 1); ++ return 0; ++} ++ ++ ++ ++int realtek_set_wds(void *priv, struct rtk_wds_config wds) ++{ ++ struct realtek_driver_data *drv = priv; ++ struct hostapd_data *hapd = drv->hapd; ++ struct hostapd_bss_config *conf = hapd->conf; ++ struct iwreq iwr; ++ int op = 0; ++ ++ wpa_printf(MSG_DEBUG, "realtek_set_wds +++"); ++ ++ memset(&iwr, 0, sizeof(iwr)); ++ strncpy(iwr.ifr_name, drv->iface, IFNAMSIZ); ++ ++ iwr.u.data.pointer = &wds; ++ iwr.u.data.length = sizeof(struct rtk_wds_config); ++ ++ if(wds.wdsEnabled) ++ op = IEEE80211_IOCTL_WDSADDMAC; ++ else ++ op = IEEE80211_IOCTL_WDSDELMAC; ++#ifdef STAND_ALONE ++ if (ioctl(drv->ioctl_sock, op, &iwr) < 0) ++ { ++ { ++ int err = errno; ++ perror("set WDS ioctl failed"); ++ wpa_printf(MSG_ERROR, "ioctl 0x%x failed errno=%d", ++ op, err); ++ } ++ return -1; ++ } ++#endif ++#if defined(INBAND_CTRL) ++ INBAND_IOCTLPKT_DUMP(&iwr,sizeof(iwr)); ++ if (inband_ioctl(op, &iwr) < 0) ++ { ++ { ++ perror("set80211priv ioctl failed"); ++ wpa_printf(MSG_ERROR, "ioctl 0x%x failed", op); ++ } ++ return -1; ++ } ++#endif ++ ++ ++ return 0; ++} ++ ++ ++static void ++realtek_wireless_event_wireless_custom(struct hostapd_data *hapd,struct realtek_driver_data *drv, u16 flags, char * custom, size_t len) ++{ ++ wpa_printf(MSG_DEBUG, "custom event =%d, len=%d", flags, len); ++ ++ switch(flags) ++ { ++ case HAPD_MIC_FAILURE: ++ { ++ unsigned char * mac = (unsigned char *)custom; ++ wpa_printf(MSG_DEBUG, "MIC failed sta: %02x %02x %02x %02x %02x %02x" ++ , mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]); ++ ieee80211_michael_mic_failure(hapd, mac, 1); ++ break; ++ } ++ case HAPD_WPS_PROBEREQ: ++ { ++ struct _DOT11_PROBE_REQUEST_IND *wps_ie = (struct _DOT11_PROBE_REQUEST_IND *) custom; ++ wpa_printf(MSG_DEBUG, "IsMoreEvent =%d, ProbeIELen =%d", wps_ie->IsMoreEvent, wps_ie->ProbeIELen); ++ hostapd_wps_probe_req_rx(hapd, wps_ie->MACAddr, wps_ie->ProbeIE, wps_ie->ProbeIELen); ++ break; ++ } ++ } ++ ++} ++ ++ ++static void ++realtek_wireless_event_wireless(struct hostapd_data *hapd,struct realtek_driver_data *drv, ++ u8 *data, int len) ++{ ++ struct iw_event iwe_buf, *iwe = &iwe_buf; ++ u8 *pos, *end, *custom, *buf; ++ u8 macaddr[ETH_ALEN] = {}; ++ ++ pos = data; ++ end = data + len; ++ ++ wpa_printf(MSG_DEBUG, "realtek_wireless_event_wireless +++"); ++ ++ while (pos + IW_EV_LCP_LEN <= end) { ++ /* Event data may be unaligned, so make a local, aligned copy ++ * before processing. */ ++ memcpy(&iwe_buf, pos, IW_EV_LCP_LEN); ++ ++#ifdef INBAND_CTRL //HOST_LITTLE_ENDIAN ++ iwe->len = ntohs(iwe->len); ++ iwe->cmd = ntohs(iwe->cmd); ++#endif ++ if (iwe->len <= IW_EV_LCP_LEN) ++ return; ++ ++ custom = pos + IW_EV_POINT_LEN; ++ if (drv->we_version > 18 && ++ (iwe->cmd == IWEVMICHAELMICFAILURE || ++ iwe->cmd == SIOCGIWESSID || ++ iwe->cmd == SIOCGIWENCODE || ++ iwe->cmd == IWEVGENIE || ++ iwe->cmd == IWEVASSOCREQIE || ++ iwe->cmd == IWEVASSOCRESPIE || ++ iwe->cmd == IWEVCUSTOM)) { ++ /* WE-19 removed the pointer from struct iw_point */ ++ char *dpos = (char *) &iwe_buf.u.data.length; ++ int dlen = dpos - (char *) &iwe_buf; ++ memcpy(dpos, pos + IW_EV_LCP_LEN, ++ sizeof(struct iw_event) - dlen); ++ } else { ++ memcpy(&iwe_buf, pos, sizeof(struct iw_event)); ++ custom += IW_EV_POINT_OFF; ++#ifdef INBAND_CTRL //HOST_LITTLE_ENDIAN ++ iwe->len = ntohs(iwe->len); ++ iwe->cmd = ntohs(iwe->cmd); ++#endif ++ } ++ ++ switch (iwe->cmd) { ++ case IWEVEXPIRED: ++ wpa_printf(MSG_DEBUG, "case IWEVEXPIRED"); ++ realtek_del_sta(hapd,drv, (u8 *) iwe->u.addr.sa_data); ++ break; ++ case IWEVREGISTERED: ++ wpa_printf(MSG_DEBUG, "case IWEVREGISTERED"); ++ realtek_new_sta(hapd,drv, (u8 *) iwe->u.addr.sa_data); ++ break; ++ case IWEVCUSTOM: ++ case IWEVGENIE: ++ wpa_printf(MSG_DEBUG, "case IWEVCUSTOM|IWEVGENIE"); ++#ifdef INBAND_CTRL //HOST_LITTLE_ENDIAN ++ iwe->u.data.length = ntohs(iwe->u.data.length); ++ iwe->u.data.flags = ntohs(iwe->u.data.flags); ++#endif ++ if (custom + iwe->u.data.length > end) ++ return; ++ buf = malloc(iwe->u.data.length + 1); ++ if (buf == NULL) ++ return; /* XXX */ ++ memcpy(buf, custom, iwe->u.data.length); ++ buf[iwe->u.data.length] = '\0'; ++ realtek_wireless_event_wireless_custom(hapd,drv, iwe->u.data.flags, buf, iwe->u.data.length); ++ free(buf); ++ break; ++ } ++ pos += iwe->len; ++ } ++} ++ ++ ++static void ++realtek_wireless_event_rtm_newlink(struct realtek_driver_data *drv, ++ struct nlmsghdr *h, int len) ++{ ++ struct ifinfomsg *ifi; ++ int attrlen, nlmsg_len, rta_len; ++ struct rtattr * attr; ++ struct hostapd_data *hapd = drv->hapd; ++ ++ wpa_printf(MSG_DEBUG, "realtek_wireless_event_rtm_newlink +++"); ++ ++ if (len < (int) sizeof(*ifi)) ++ return; ++ ++ ifi = NLMSG_DATA(h); ++#ifdef INBAND_CTRL //HOST_LITTLE_ENDIAN ++ ifi->ifi_index = ntohl(ifi->ifi_index); ++#endif ++#ifdef RTK_MBSSID ++ if(!have_ifidx(drv, ifi->ifi_index)) ++ return; ++ hapd = find_hapd_by_ifindex(drv,ifi->ifi_index); ++#else ++ if (ifi->ifi_index != drv->ifindex) ++ return; ++#endif ++ nlmsg_len = NLMSG_ALIGN(sizeof(struct ifinfomsg)); ++ ++ attrlen = h->nlmsg_len - nlmsg_len; ++ if (attrlen < 0) ++ return; ++ ++ attr = (struct rtattr *) (((char *) ifi) + nlmsg_len); ++ ++#ifdef INBAND_CTRL //HOST_LITTLE_ENDIAN ++ attr->rta_len = ntohs(attr->rta_len); ++ attr->rta_type = ntohs(attr->rta_type); ++#endif ++ rta_len = RTA_ALIGN(sizeof(struct rtattr)); ++ while (RTA_OK(attr, attrlen)) { ++ if (attr->rta_type == IFLA_WIRELESS) { ++ realtek_wireless_event_wireless(hapd, ++ drv, ((u8 *) attr) + rta_len, ++ attr->rta_len - rta_len); ++ } ++ attr = RTA_NEXT(attr, attrlen); ++#ifdef INBAND_CTRL //HOST_LITTLE_ENDIAN ++ attr->rta_len = ntohs(attr->rta_len); ++ attr->rta_type = ntohs(attr->rta_type); ++#endif ++ } ++} ++ ++ ++static void ++realtek_wireless_event_receive(int sock, void *eloop_ctx, void *sock_ctx) ++{ ++ //char buf[256]; ++ char buf[1024], cmd_type=0x01; //increse size for IWEVGENIE event ++ int left; ++ struct sockaddr_nl from; ++ socklen_t fromlen; ++ struct nlmsghdr *h; ++ struct realtek_driver_data *drv = eloop_ctx; ++#ifdef INBAND_CTRL ++ left = ioh_recv(&drv->netlink_ioh_obj, 3000); ++ if (left < 0) { ++ perror("recvfrom(rawsock)"); ++ return; ++ } ++ INBAND_IOCTLPKT_DUMP(drv->netlink_ioh_obj.rx_data,left); ++ left -= IOH_HDR_LEN; ++ ++ h = (struct nlmsghdr *)drv->netlink_ioh_obj.rx_data ; ++#else ++ fromlen = sizeof(from); ++ left = recvfrom(sock, buf, sizeof(buf), MSG_DONTWAIT, ++ (struct sockaddr *) &from, &fromlen); ++ if (left < 0) { ++ if (errno != EINTR && errno != EAGAIN) ++ perror("recvfrom(netlink)"); ++ return; ++ } ++ ++ h = (struct nlmsghdr *) buf; ++#endif ++ while (left >= (int) sizeof(*h)) { ++ int len, plen; ++#ifdef INBAND_CTRL //HOST_LITTLE_ENDIAN //mark_x86 ++ h->nlmsg_len = ntohl(h->nlmsg_len); ++ h->nlmsg_type = ntohs(h->nlmsg_type); ++ h->nlmsg_flags = ntohs(h->nlmsg_flags); ++ h->nlmsg_seq = ntohl(h->nlmsg_seq); ++ h->nlmsg_pid = ntohl(h->nlmsg_pid); ++#endif ++ len = h->nlmsg_len; ++ plen = len - sizeof(*h); ++ if (len > left || plen < 0) { ++ printf("Malformed netlink message: " ++ "len=%d left=%d plen=%d\n", ++ len, left, plen); ++ break; ++ } ++ ++ switch (h->nlmsg_type) { ++ case RTM_NEWLINK: ++ realtek_wireless_event_rtm_newlink(drv, h, plen); ++ break; ++ } ++ ++ len = NLMSG_ALIGN(len); ++ left -= len; ++ h = (struct nlmsghdr *) ((char *) h + len); ++ } ++ ++ if (left > 0) { ++ printf("%d extra bytes in the end of netlink message\n", left); ++ } ++} ++ ++ ++static int ++realtek_get_we_version(struct realtek_driver_data *drv) ++{ ++ struct iw_range *range; ++ struct iwreq iwr; ++ int minlen; ++ size_t buflen; ++ ++ drv->we_version = 0; ++ ++ /* ++ * Use larger buffer than struct iw_range in order to allow the ++ * structure to grow in the future. ++ */ ++ buflen = sizeof(struct iw_range) + 500; ++ range = os_zalloc(buflen); ++ if (range == NULL) ++ return -1; ++ ++ memset(&iwr, 0, sizeof(iwr)); ++ strncpy(iwr.ifr_name, drv->iface, IFNAMSIZ); ++ iwr.u.data.pointer = (caddr_t) range; ++ iwr.u.data.length = buflen; ++ ++ minlen = ((char *) &range->enc_capa) - (char *) range + ++ sizeof(range->enc_capa); ++#ifdef STAND_ALONE ++ if (ioctl(drv->ioctl_sock, SIOCGIWRANGE, &iwr) < 0) { ++ perror("ioctl[SIOCGIWRANGE]"); ++ free(range); ++ return -1; ++ } ++ else if (iwr.u.data.length >= minlen && ++ range->we_version_compiled >= 18) { ++ wpa_printf(MSG_DEBUG, "SIOCGIWRANGE: WE(compiled)=%d " ++ "WE(source)=%d enc_capa=0x%x", ++ range->we_version_compiled, ++ range->we_version_source, ++ range->enc_capa); ++ drv->we_version = range->we_version_compiled; ++ } ++#endif ++#if defined(INBAND_CTRL) ++ INBAND_IOCTLPKT_DUMP(&iwr,sizeof(iwr)); ++ if (inband_ioctl(SIOCGIWRANGE, &iwr) < 0) { ++ perror("inband_ioctl[SIOCGIWRANGE]"); ++ free(range); ++ return -1; ++ } else if (iwr.u.data.length >= minlen && ++ range->we_version_compiled >= 18) { ++ wpa_printf(MSG_DEBUG, "SIOCGIWRANGE: WE(compiled)=%d " ++ "WE(source)=%d enc_capa=0x%x", ++ range->we_version_compiled, ++ range->we_version_source, ++ range->enc_capa); ++ drv->we_version = range->we_version_compiled; ++ } ++#endif ++ ++ ++ free(range); ++ return 0; ++} ++ ++ ++static int ++realtek_wireless_event_init(void *priv) ++{ ++ struct realtek_driver_data *drv = priv; ++ int s; ++ struct sockaddr_nl local; ++ ++ realtek_get_we_version(drv); ++ ++ drv->wext_sock = -1; ++#ifdef INBAND_CTRL ++ s = ioh_open(&drv->netlink_ioh_obj,INBAND_INTF,INBAND_SLAVE,INBAND_NETLINK_TYPE,INBAND_DEBUG); ++ if (s < 0) { ++ perror("socket(PF_PACKET,SOCK_RAW,INBAND_NETLINK_TYPE)"); ++ return -1; ++ } ++#else ++ s = socket(PF_NETLINK, SOCK_RAW, NETLINK_ROUTE); ++ if (s < 0) { ++ perror("socket(PF_NETLINK,SOCK_RAW,NETLINK_ROUTE)"); ++ return -1; ++ } ++ ++ memset(&local, 0, sizeof(local)); ++ local.nl_family = AF_NETLINK; ++ local.nl_groups = RTMGRP_LINK; ++ if (bind(s, (struct sockaddr *) &local, sizeof(local)) < 0) { ++ perror("bind(netlink)"); ++ close(s); ++ return -1; ++ } ++#endif ++ ++#ifdef INBAND_CTRL ++ eloop_register_read_sock(drv->netlink_ioh_obj.sockfd, realtek_wireless_event_receive, drv, NULL); ++#else ++ eloop_register_read_sock(s, realtek_wireless_event_receive, drv, NULL); ++#endif ++#ifdef INBAND_CTRL ++ drv->wext_sock = drv->netlink_ioh_obj.sockfd; ++#else ++ drv->wext_sock = 0; ++#endif ++ ++ return 0; ++} ++ ++ ++static void ++realtek_wireless_event_deinit(void *priv) ++{ ++ struct realtek_driver_data *drv = priv; ++ ++ wpa_printf(MSG_DEBUG, "realtek_wireless_event_deinit +++"); ++ ++ if (drv != NULL) { ++ if (drv->wext_sock < 0) ++ return; ++ eloop_unregister_read_sock(drv->wext_sock); ++ close(drv->wext_sock); ++ } ++} ++ ++ ++static int ++realtek_send_eapol(void *priv, const u8 *addr, const u8 *data, size_t data_len, ++ int encrypt, const u8 *own_addr) ++{ ++ struct realtek_driver_data *drv = priv; ++ unsigned char buf[3000]; ++ unsigned char *bp = buf; ++ struct l2_ethhdr *eth; ++ size_t len; ++ int status; ++ struct l2_packet_data *eapol_sock=drv->sock_xmit; ++#ifdef RTK_MBSSID ++#ifndef INBAND_CTRL ++ struct hostapd_data *hapd = drv->hapd; ++ ++ hapd = (struct hostapd_data *)find_hapd_by_sta(priv,addr); ++ eapol_sock = (struct l2_packet_data *)rtk_find_l2sock_by_ifname(priv,hapd->conf->iface); ++#endif ++#endif ++ wpa_printf(MSG_DEBUG, "realtek_send_eapol +++"); ++ ++ /* ++ * Prepend the Ethernet header. If the caller left us ++ * space at the front we could just insert it but since ++ * we don't know we copy to a local buffer. Given the frequency ++ * and size of frames this probably doesn't matter. ++ */ ++ len = data_len + sizeof(struct l2_ethhdr); ++ if (len > sizeof(buf)) { ++ bp = malloc(len); ++ if (bp == NULL) { ++ printf("EAPOL frame discarded, cannot malloc temp " ++ "buffer of size %lu!\n", (unsigned long) len); ++ return -1; ++ } ++ } ++ eth = (struct l2_ethhdr *) bp; ++ memcpy(eth->h_dest, addr, ETH_ALEN); ++ memcpy(eth->h_source, drv->hapd->own_addr, ETH_ALEN); ++ eth->h_proto = htons(ETH_P_EAPOL); ++ memcpy(eth+1, data, data_len); ++ ++ //mark wpa_hexdump because both ralink & broadcom NOT call this function ++ //wpa_hexdump(MSG_MSGDUMP, "TX EAPOL", bp, len); ++ ++ status = l2_packet_send(eapol_sock, addr, ETH_P_EAPOL, bp, len); ++ if (bp != buf) ++ free(bp); ++ return status; ++} ++ ++static void ++handle_read(void *ctx, const u8 *src_addr, const u8 *buf, size_t len) ++{ ++ struct realtek_driver_data *drv = ctx; ++ struct hostapd_data *hapd = drv->hapd; ++ struct sta_info *sta; ++ ++ //printf("handle_read +++"); ++#ifndef RTK_MBSSID ++ sta = ap_get_sta(hapd, src_addr); ++ if (!sta || !(sta->flags & WLAN_STA_ASSOC)) { ++ printf("Data frame from not associated STA %s\n", ++ ether_sprintf(src_addr)); ++ /* XXX cannot happen */ ++ return; ++ } ++ ++ ieee802_1x_receive(hapd, src_addr, buf + sizeof(struct l2_ethhdr), ++ len - sizeof(struct l2_ethhdr)); ++#else ++ return; // do nothing here , all handle in handle_eapol ++#endif ++} ++ ++#ifdef INBAND_CTRL ++static int rtk_l2_packet_get_own_addr(struct realtek_driver_data *drv, u8 *addr) ++{ ++ unsigned char cmd[100]; ++ struct ifreq ifr; ++ ++ os_memset(&ifr, 0, sizeof(ifr)); ++ os_strlcpy(ifr.ifr_name, INBAND_INTF, sizeof(INBAND_INTF)); ++ ++ if(ioctl(drv->ioctl_sock,SIOCGIFHWADDR, &ifr ) < 0){ ++ return -1; ++ } ++ ++ sprintf(cmd,"echo %d:%d:%d:%d:%d:%d > /proc/br_hostmac",ifr.ifr_hwaddr.sa_data[0], ++ ifr.ifr_hwaddr.sa_data[1],ifr.ifr_hwaddr.sa_data[2],ifr.ifr_hwaddr.sa_data[3], ++ ifr.ifr_hwaddr.sa_data[4],ifr.ifr_hwaddr.sa_data[5]); ++ ++ if (inband_remote_cmd(cmd) < 0) ++ return -1; ++ ++ os_strlcpy(ifr.ifr_name, drv->iface, sizeof(ifr.ifr_name)); ++ if (inband_ioctl(SIOCGIFHWADDR,&ifr) < 0) ++ return -1; ++ else ++ os_memcpy(addr, ifr.ifr_hwaddr.sa_data, ETH_ALEN); ++ return 0; ++} ++#endif ++ ++#ifdef RTK_MBSSID ++static int realtek_bss_add(void *priv, const char *ifname, const u8 *bssid) ++{ ++ struct realtek_driver_data *drv = priv; ++ struct i802_bss *new_bss = NULL; ++ struct ifreq ifr; ++ struct rtk_hapd_config config; ++ struct hostapd_data *hapd = drv->hapd; ++ ++ //printf("realtek_bss_add : ifname = %s\n",ifname); ++ ++ new_bss = os_zalloc(sizeof(*new_bss)); ++ if (new_bss == NULL) ++ return -1; ++ ++ ++ memset(&ifr, 0, sizeof(ifr)); ++ snprintf(ifr.ifr_name, sizeof(ifr.ifr_name), "%s", ifname); ++#ifdef STAND_ALONE ++ if (ioctl(drv->ioctl_sock, SIOCGIFINDEX, &ifr) != 0) { ++ perror("ioctl(SIOCGIFINDEX)"); ++ goto bad; ++ } ++#endif ++#if defined(INBAND_CTRL) ++ INBAND_IOCTLPKT_DUMP(&ifr,sizeof(ifr)); ++ if (inband_ioctl(SIOCGIFINDEX, &ifr) < 0) { ++ perror("inband_ioctl(SIOCGIFINDEX)"); ++ goto bad; ++ } ++#endif ++ os_strlcpy(new_bss->ifname, ifname, IFNAMSIZ); ++ ++#ifdef INBAND_CTRL ++ new_bss->sock_xmit = drv->sock_xmit; ++#else ++ new_bss->sock_xmit = l2_packet_init(new_bss->ifname, NULL, ETH_P_EAPOL, handle_read, drv, 1); ++#endif ++ if (new_bss->sock_xmit == NULL) ++ goto bad; ++ ++ //do we nee to set HW addr to VAP?? ++ realtek_set_iface_flags(new_bss->ifname,drv, 0); //down the interface ...... , bring up in realtek_commit!! ++ ++ if (bssid[0] | bssid[1] | bssid[2] | bssid[3] | bssid[4] | bssid[5]) ++ realtek_set_iface_hwMac(new_bss->ifname,drv, bssid); ++ else ++ printf("Warning !!! VAP no HW addr setting \n"); ++ ++ //memset(&config, 0, sizeof(struct rtk_hapd_config)); ++ os_memcpy(&config, &rtk_config, sizeof(struct rtk_hapd_config)); //get some val from root ++ hapd =(struct hostapd_data *) find_hapd_by_ifname(priv,ifname); ++ ++ realtek_set_privacy(ifname, drv, 0); /* default to no privacy */ ++ ++ if(realtek_read_hapd_cfg(hapd,priv, &config)) ++ goto bad; ++ ++ //if(realtek_read_priv_cfg(priv, &config)) //already read in init ++ // goto bad; ++ if(realtek_read_priv_vap_cfg(ifname,priv, &config)) //already read in init ++ goto bad; ++ ++ ++#ifdef INBAND_CTRL //HOST_LITTLE_ENDIAN ++ // rtk_hapd_config need to swap , write a function to do it ++ rtk_cfg_to_bigEndian(&config); ++#endif ++ ++ if(set80211priv(ifname,drv, HAPD_IOCTL_SETCONFIG, &config, sizeof(config))) ++ { ++ wpa_printf(MSG_ERROR, "%s: Failed to set Configurations", __func__); ++ goto bad; ++ } ++ ++ /*if(realtek_read_wds_cfg(priv, &wds)) //mark_mbssid , wds for vap ?? ++ return -1;*/ ++ ++ if((hapd->conf->wpa == 0) && (hapd->conf->ieee802_1x == 0 )) ++ realtek_set_ieee8021x(ifname, drv, 0); ++ ++ new_bss->ifindex = ifr.ifr_ifindex; ++ new_bss->drv = drv; ++ new_bss->next = drv->first_bss.next; ++ drv->first_bss.next = new_bss; ++ add_ifidx(drv, new_bss->ifindex); ++ ++ return 0; ++ ++bad : ++ os_free(new_bss); ++ return -1; ++} ++ ++static int realtek_bss_remove(void *priv, const char *ifname) ++{ ++ ++ //printf("realtek_bss_remove : ifname = %s\n",ifname); ++ ++ rtk_free_bss_by_ifname(priv,ifname); ++ ++ realtek_set_iface_flags(ifname,priv, 0); //down VAP ++ ++ return 0; ++} ++ ++static void * ++realtek_driver_init(struct hostapd_data *hapd) ++{ ++ struct realtek_driver_data *drv; ++ struct ifreq ifr; ++ struct iwreq iwr; ++ struct i802_bss *bss; ++ ++ wpa_printf(MSG_DEBUG, "realtek_init +++"); ++ ++ drv = os_zalloc(sizeof(struct realtek_driver_data)); ++ if (drv == NULL) { ++ printf("Could not allocate memory for realtek driver data\n"); ++ goto bad; ++ } ++ ++ drv->hapd = hapd; ++ bss = &drv->first_bss; ++ bss->drv = drv; ++ os_strlcpy(bss->ifname, hapd->conf->iface, sizeof(bss->ifname)); ++ ++ 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)); ++ snprintf(ifr.ifr_name, sizeof(ifr.ifr_name), "%s", drv->iface); ++#ifdef STAND_ALONE ++ if (ioctl(drv->ioctl_sock, SIOCGIFINDEX, &ifr) != 0) { ++ perror("ioctl(SIOCGIFINDEX)"); ++ goto bad; ++ } ++#endif ++#if defined(INBAND_CTRL) ++ INBAND_IOCTLPKT_DUMP(&ifr,sizeof(ifr)); ++ if (inband_ioctl(SIOCGIFINDEX, &ifr) < 0) { ++ perror("inband_ioctl(SIOCGIFINDEX)"); ++ goto bad; ++ } ++#endif ++ drv->ifindex = ifr.ifr_ifindex; ++ bss->ifindex = drv->ifindex; ++#ifdef INBAND_CTRL ++ drv->sock_xmit = l2_packet_init(INBAND_INTF, NULL, ETH_P_EAPOL, handle_read, drv, 1); ++#else ++ drv->sock_xmit = l2_packet_init(drv->iface, NULL, ETH_P_EAPOL, handle_read, drv, 1); ++#endif ++ if (drv->sock_xmit == NULL) ++ goto bad; ++#ifdef INBAND_CTRL ++ if( rtk_l2_packet_get_own_addr(drv,hapd->own_addr) ) ++#else ++ if (l2_packet_get_own_addr(drv->sock_xmit, hapd->own_addr)) ++#endif ++ goto bad; ++ ++ //mark_mbssid , now recv all EAPOL from one socket ++ drv->sock_recv = socket(PF_PACKET, SOCK_DGRAM, htons(ETH_P_EAPOL)); ++ if (drv->sock_recv < 0) { ++ perror("socket(PF_PACKET, SOCK_DGRAM, ETH_P_EAPOL)"); ++ goto bad; ++ } ++ if (eloop_register_read_sock(drv->sock_recv, handle_eapol, drv, NULL)) ++ { ++ printf("Could not register read socket for eapol\n"); ++ goto bad; ++ } ++ ++ memset(&iwr, 0, sizeof(iwr)); ++ strncpy(iwr.ifr_name, drv->iface, IFNAMSIZ); ++ ++ realtek_set_iface_flags(drv->iface,drv, 0); /* mark down during setup */ ++ realtek_set_privacy(drv->iface, drv, 0); /* default to no privacy */ ++ ++ if(realtek_hapd_config(drv)) ++ goto bad; ++ ++ if((hapd->conf->wpa == 0) && (hapd->conf->ieee802_1x == 0 )) ++ realtek_set_ieee8021x(drv->iface, drv, 0); ++ ++ wpa_printf(MSG_DEBUG, "realtek_init ---"); ++ return bss; ++bad: ++ wpa_printf(MSG_ERROR, "realtek_init failed!"); ++ ++ if (drv != NULL) ++ realtek_deinit(drv); ++ ++ return NULL; ++} ++ ++static void * ++realtek_init(struct hostapd_data *hapd) ++{ ++ struct realtek_driver_data *drv; ++ struct i802_bss *bss; ++ int i; ++ ++ bss = realtek_driver_init(hapd); ++ ++ if (bss == NULL) ++ return NULL; ++ ++ drv = bss->drv; ++ ++ drv->num_if_indices = RTK_MAX_IF_INDEX; ++ for(i=0;i<drv->num_if_indices;i++) ++ drv->if_indices[i]=0; ++ ++ add_ifidx(drv, drv->ifindex); ++ ++ //below maybe add bridge control in the future ++ //return bss; ++ return drv; ++ ++} ++ ++#else //mark_mbssid , remove below in future ++ ++static void * ++realtek_init(struct hostapd_data *hapd) ++{ ++ struct realtek_driver_data *drv; ++ struct ifreq ifr; ++ struct iwreq iwr; ++ ++ wpa_printf(MSG_DEBUG, "realtek_init +++"); ++ ++ drv = os_zalloc(sizeof(struct realtek_driver_data)); ++ if (drv == NULL) { ++ printf("Could not allocate memory for realtek driver data\n"); ++ goto bad; ++ } ++ ++ 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)); ++ snprintf(ifr.ifr_name, sizeof(ifr.ifr_name), "%s", drv->iface); ++#ifdef STAND_ALONE ++ if (ioctl(drv->ioctl_sock, SIOCGIFINDEX, &ifr) != 0) { ++ perror("ioctl(SIOCGIFINDEX)"); ++ goto bad; ++ } ++#endif ++#if defined(INBAND_CTRL) ++ INBAND_IOCTLPKT_DUMP(&ifr,sizeof(ifr)); ++ if (inband_ioctl(SIOCGIFINDEX, &ifr) < 0) { ++ perror("inband_ioctl(SIOCGIFINDEX)"); ++ goto bad; ++ } ++#endif ++ drv->ifindex = ifr.ifr_ifindex; ++#ifdef INBAND_CTRL ++ drv->sock_xmit = l2_packet_init(INBAND_INTF, NULL, ETH_P_EAPOL, handle_read, drv, 1); ++#else ++ drv->sock_xmit = l2_packet_init(drv->iface, NULL, ETH_P_EAPOL, handle_read, drv, 1); ++#endif ++ if (drv->sock_xmit == NULL) ++ goto bad; ++#ifdef INBAND_CTRL ++ if( rtk_l2_packet_get_own_addr(drv,hapd->own_addr) ) ++#else ++ if (l2_packet_get_own_addr(drv->sock_xmit, hapd->own_addr)) ++#endif ++ goto bad; ++ if (hapd->conf->bridge[0] != '\0') { ++ drv->sock_recv = l2_packet_init(hapd->conf->bridge, NULL, ++ ETH_P_EAPOL, handle_read, drv, ++ 1); //fix receive sock?? ++ if (drv->sock_recv == NULL) ++ goto bad; ++ } else ++ drv->sock_recv = drv->sock_xmit; ++ ++ memset(&iwr, 0, sizeof(iwr)); ++ strncpy(iwr.ifr_name, drv->iface, IFNAMSIZ); ++ ++ realtek_set_iface_flags(drv->iface,drv, 0); /* mark down during setup */ ++ realtek_set_privacy(drv->iface, drv, 0); /* default to no privacy */ ++ ++ if(realtek_hapd_config(drv)) ++ goto bad; ++ ++ if((hapd->conf->wpa == 0) && (hapd->conf->ieee802_1x == 0 )) ++ realtek_set_ieee8021x(drv->iface, drv, 0); ++ ++ wpa_printf(MSG_DEBUG, "realtek_init ---"); ++ return drv; ++bad: ++ wpa_printf(MSG_ERROR, "realtek_init failed!"); ++ ++ if (drv != NULL) ++ realtek_deinit(drv); ++ ++ return -1; ++} ++#endif ++ ++static void ++realtek_deinit(void *priv) ++{ ++ struct realtek_driver_data *drv = priv; ++ ++ wpa_printf(MSG_DEBUG, "realtek_deinit +++"); ++ ++ drv->hapd->driver = NULL; ++ ++ realtek_set_iface_flags(drv->iface,drv, 0); ++ #if 0 /* OLD */ ++ if (drv->probe_recv != NULL) ++ l2_packet_deinit(drv->probe_recv); ++ #endif ++ if (drv->ioctl_sock >= 0) ++ close(drv->ioctl_sock); ++#ifdef RTK_MBSSID ++ if (drv->sock_recv >= 0) { ++ eloop_unregister_read_sock(drv->sock_recv); ++ close(drv->sock_recv); ++ } ++#else ++ if (drv->sock_recv != NULL && drv->sock_recv != drv->sock_xmit) ++ l2_packet_deinit(drv->sock_recv); ++#endif ++ if (drv->sock_xmit != NULL) ++ l2_packet_deinit(drv->sock_xmit); ++ free(drv); ++ ++ wpa_printf(MSG_DEBUG, "realtek_deinit ---"); ++} ++ ++static int ++realtek_set_ssid(const char *ifname, void *priv, const u8 *buf, int len) ++{ ++ struct realtek_driver_data *drv = priv; ++ struct iwreq iwr; ++ ++ wpa_printf(MSG_DEBUG, "realtek_set_ssid +++"); ++ ++ memset(&iwr, 0, sizeof(iwr)); ++ strncpy(iwr.ifr_name, ifname, IFNAMSIZ); ++ iwr.u.essid.flags = 1; /* SSID active */ ++ iwr.u.essid.pointer = (caddr_t) buf; ++ iwr.u.essid.length = len + 1; ++#ifdef STAND_ALONE ++ if (ioctl(drv->ioctl_sock, SIOCSIWESSID, &iwr) < 0) { ++ perror("ioctl[SIOCSIWESSID]"); ++ printf("len=%d\n", len); ++ return -1; ++ } ++#endif ++#if defined(INBAND_CTRL) ++ INBAND_IOCTLPKT_DUMP(&iwr,sizeof(iwr)); ++ if (inband_ioctl(SIOCSIWESSID, &iwr) < 0) { ++ perror("inband_ioctl[SIOCSIWESSID]"); ++ printf("len=%d\n", len); ++ return -1; ++ } ++#endif ++ return 0; ++} ++ ++static int ++realtek_get_ssid(const char *ifname, void *priv, u8 *buf, int len) ++{ ++ struct realtek_driver_data *drv = priv; ++ struct iwreq iwr; ++ int ret = 0; ++ ++ wpa_printf(MSG_DEBUG, "realtek_get_ssid +++"); ++ ++ memset(&iwr, 0, sizeof(iwr)); ++ strncpy(iwr.ifr_name, ifname, IFNAMSIZ); ++ iwr.u.essid.pointer = (caddr_t) buf; ++ iwr.u.essid.length = len; ++#ifdef STAND_ALONE ++ if (ioctl(drv->ioctl_sock, SIOCGIWESSID, &iwr) < 0) { ++ perror("ioctl[SIOCGIWESSID]"); ++ ret = -1; ++ } else ++ ret = iwr.u.essid.length; ++#endif ++#if defined(INBAND_CTRL) ++ INBAND_IOCTLPKT_DUMP(&iwr,sizeof(iwr)); ++ if (inband_ioctl(SIOCGIWESSID, &iwr) < 0) { ++ perror("ioctl[SIOCGIWESSID]"); ++ ret = -1; ++ } ++#endif ++ return ret; ++} ++ ++static int ++realtek_set_countermeasures(void *priv, int enabled) ++{ ++ struct realtek_driver_data *drv = priv; ++ wpa_printf(MSG_DEBUG, "realtek_set_countermeasures +++"); ++ wpa_printf(MSG_DEBUG, "%s: enabled=%d", __FUNCTION__, enabled); ++ return set80211param(drv->iface,drv, IEEE80211_PARAM_COUNTERMEASURES, enabled); ++} ++ ++#ifdef INBAND_CTRL ++/* inband ioctl start */ ++inline void realtek_priviwr(struct iwreq *iwr, unsigned char *param, void *value) ++{ ++ unsigned char buf[1024] = {0}; ++ ++ sprintf(buf,"%s=%d",param,*(unsigned int *)value); ++ iwr->u.data.length = os_strlen(buf); ++ iwr->u.data.pointer = os_malloc(iwr->u.data.length+1); ++ if( iwr->u.data.pointer ) ++ os_memcpy(iwr->u.data.pointer,buf,iwr->u.data.length+1); ++ else ++ printf("Err: Alloc memory failed while %s\n",__FUNCTION__); ++} ++#endif ++ ++ ++static int ++realtek_commit(void *priv) ++{ ++ struct realtek_driver_data *drv = priv; ++#ifdef RTK_MBSSID ++ struct i802_bss *tbss = &drv->first_bss,*bss; ++ wpa_printf(MSG_DEBUG, "realtek_commit +++"); ++ ++ //up root interface here ++ if(realtek_set_iface_flags(drv->iface,priv, 1) < 0) ++ return -1; ++ //up other VAP ++ while (tbss) { ++ ++ bss = tbss->next; ++ if(bss == NULL) ++ break; ++ ++ if(realtek_set_iface_flags(bss->ifname,priv, 1)<0) ++ return -1; ++ tbss = tbss->next ; ++ } ++ return 0; ++#else ++ return realtek_set_iface_flags(drv->iface,priv, 1); ++#endif ++} ++ ++#ifdef EAP_WPS ++static int ++realtek_set_wps_ie(const char *ifname,void *priv, u8 *iebuf, int iebuflen, u32 frametype) ++{ ++ struct realtek_driver_data *drv = priv; ++ u8 buf[256]; ++ struct ieee80211req_getset_appiebuf * ie; ++ // int i; ++ ++ ie = (struct ieee80211req_getset_appiebuf *) buf; ++ ie->app_frmtype = frametype; ++ ie->app_buflen = iebuflen; ++ if (iebuflen > 0) ++ os_memcpy(&(ie->app_buf[0]), iebuf, iebuflen); ++ ++#ifdef INBAND_CTRL //HOST_LITTLE_ENDIAN ++ // int32 need to swap ++ ie->app_frmtype = htonl(ie->app_frmtype); ++ ie->app_buflen = htonl(ie->app_buflen); ++#endif ++ return set80211priv(ifname,priv, IEEE80211_IOCTL_SET_APPIEBUF, ie, ++ sizeof(struct ieee80211req_getset_appiebuf) + iebuflen); ++} ++ ++ ++static int ++realtek_set_wps_beacon_ie(const char *ifname, void *priv, const u8 *iebuf, size_t iebuflen) ++{ ++ wpa_printf(MSG_DEBUG, "realtek_set_wps_beacon_ie +++"); ++ return realtek_set_wps_ie(ifname,priv, iebuf, iebuflen, ++ IEEE80211_APPIE_FRAME_BEACON); ++} ++ ++ ++static int ++realtek_set_wps_probe_resp_ie(const char *ifname, void *priv, const u8 *iebuf, size_t iebuflen) ++{ ++ wpa_printf(MSG_DEBUG, "realtek_set_wps_probe_resp_ie +++"); ++ return realtek_set_wps_ie(ifname,priv, iebuf, iebuflen, ++ IEEE80211_APPIE_FRAME_PROBE_RESP); ++} ++ ++ ++static int ++realtek_set_wps_assoc_resp_ie(const char *ifname, void *priv, const u8 *iebuf, size_t iebuflen) ++{ ++ wpa_printf(MSG_DEBUG, "realtek_set_wps_assoc_resp_ie +++"); ++ return realtek_set_wps_ie(ifname,priv, iebuf, iebuflen, ++ IEEE80211_APPIE_FRAME_ASSOC_RESP); ++} ++ ++ ++/* Ask to receive copies of all probe requests received. ++ */ ++static int ++realtek_start_receive_prob_req(void *priv) ++{ ++#if 0 //this function is not used now!! ++ struct ieee80211req_set_filter filt; ++ ++ wpa_printf(MSG_DEBUG, "%s Enter\n", __FUNCTION__); ++ filt.app_filterype = IEEE80211_FILTER_TYPE_PROBE_REQ; ++#ifdef INBAND_CTRL //HOST_LITTLE_ENDIAN ++ // int32 need to swap ++ filt.app_filterype = htonl(filt.app_filterype); ++#endif ++ return set80211priv(priv, IEEE80211_IOCTL_FILTERFRAME, &filt, ++ sizeof(struct ieee80211req_set_filter)); ++#endif ++ return 0; ++} ++ ++#endif /* EAP_WPS */ ++ ++#ifdef RTK_HAPD ++//Turn ON|OFF driver for hostapd reload. ++//mark_mbssid , realtek_driver_on , it's only for WPS in root hapd reload ++static int realtek_driver_on(void *priv, int on) ++{ ++ struct realtek_driver_data *drv = priv; ++ struct hostapd_data *hapd = drv->hapd; ++ ++ wpa_printf(MSG_DEBUG, "realtek_driver_on = %d +++", on); ++ ++ if((hapd->conf->wpa == 0) && (hapd->conf->ieee802_1x ==0 ) && (on == 1)) ++ realtek_set_ieee8021x(drv->iface, drv, 0); ++ ++ return realtek_set_iface_flags(drv->iface,priv, on); ++} ++ ++static int realtek_config_rate(int *rate_list, unsigned int *rate_config) ++{ ++ // bit mask value. bit0-bit11 as 1,2,5.5,11,6,9,12,18,24,36,48,54 ++ int temp = 0; ++ ++ while(1) ++ { ++ int rate; ++ rate = rate_list[temp]; ++ if((rate == -1) || (rate == 0)) ++ break; ++ ++ if(rate == 10) ++ *rate_config |= BIT(0); ++ else if(rate == 20) ++ *rate_config |= BIT(1); ++ else if(rate == 55) ++ *rate_config |= BIT(2); ++ else if(rate == 110) ++ *rate_config |= BIT(3); ++ else if(rate == 60) ++ *rate_config |= BIT(4); ++ else if(rate == 90) ++ *rate_config |= BIT(5); ++ else if(rate == 120) ++ *rate_config |= BIT(6); ++ else if(rate == 180) ++ *rate_config |= BIT(7); ++ else if(rate == 240) ++ *rate_config |= BIT(8); ++ else if(rate == 360) ++ *rate_config |= BIT(9); ++ else if(rate == 480) ++ *rate_config |= BIT(10); ++ else if(rate == 540) ++ *rate_config |= BIT(11); ++ ++ temp++; ++ ++ if(temp > 12) ++ { ++ wpa_printf(MSG_ERROR, "Config Rates NUM > 12!!!"); ++ return -1; ++ } ++ ++ } ++ ++ return 0; ++ ++} ++ ++static int realtek_parse_pwrlevel(unsigned char* pwr_list, char *val) ++{ ++ int count; ++ char *pos, *end; ++ ++ pos = val; ++ count = 0; ++ while (*pos != '\0') { ++ if (*pos == ' ') ++ count++; ++ pos++; ++ } ++ ++ pos = val; ++ count = 0; ++ ++ while (*pos != '\0') { ++ end = os_strchr(pos, ' '); ++ if (end) ++ *end = '\0'; ++ ++ pwr_list[count] = atoi(pos); ++ ++ if (!end) ++ break; ++ ++ count ++; ++ if(count >=MAX_2G_CHANNEL_NUM) ++ break; ++ ++ pos = end + 1; ++ } ++ ++ return 0; ++} ++ ++ ++static int realtek_read_hapd_cfg(struct hostapd_data *hapd,void *priv, struct rtk_hapd_config* config) ++{ ++ struct realtek_driver_data *drv = priv; ++ struct hostapd_config *iconf = hapd->iconf; ++ struct hostapd_bss_config *conf = hapd->conf; ++ ++ int temp = 0; ++ ++ wpa_printf(MSG_DEBUG, "realtek_read_hapd_cfg +++"); ++ ++ config->band |= BIT(iconf->hw_mode); ++ if(iconf->ieee80211n) ++ config->band |= BIT(3); ++ ++ config->channel = iconf->channel; ++ ++ config->bcnint = iconf->beacon_int; ++ ++ config->dtimperiod = conf->dtim_period; ++ ++ //if(conf->max_num_sta > RTK_MAX_STA)//mark_mbssid ,issue how to sync conf and rtk real support ++ config->stanum = conf->max_num_sta; ++ ++ config->rtsthres = iconf->rts_threshold; ++ ++ config->fragthres = iconf->fragm_threshold; ++ ++ if(realtek_config_rate(iconf->supported_rates, &(config->oprates))) ++ return -1; ++ ++ if(realtek_config_rate(iconf->basic_rates, &(config->basicrates))) ++ return -1; ++ ++ config->preamble = iconf->preamble; ++ ++ config->aclmode = conf->macaddr_acl; ++ ++ if(config->aclmode == ACCEPT_UNLESS_DENIED) ++ { ++ int x = 0, y =0; ++ config->aclnum = conf->num_deny_mac; ++ ++ if(config->aclnum > 0) ++ { ++ for(x=0; x < config->aclnum; x++) ++ { ++ struct mac_acl_entry *deny_mac = &conf->deny_mac[x]; ++ for(y=0; y<MACADDRLEN; y++) ++ { ++ config->acladdr[x][y] = deny_mac->addr[y]; ++ } ++ wpa_printf(MSG_DEBUG, "DENY ACL# %d = %s", x, ether_sprintf(config->acladdr[x])); ++ } ++ } ++ } ++ else if(config->aclmode == DENY_UNLESS_ACCEPTED) ++ { ++ int x = 0, y = 0; ++ config->aclnum = conf->num_accept_mac; ++ ++ if(config->aclnum > 0) ++ { ++ for(x=0; x<config->aclnum; x++) ++ { ++ struct mac_acl_entry *accept_mac = &conf->accept_mac[x]; ++ for(y=0; y<MACADDRLEN; y++) ++ { ++ config->acladdr[x][y] = accept_mac->addr[y]; ++ } ++ wpa_printf(MSG_DEBUG, "ACCEPT ACL# %d = %s", x, ether_sprintf(config->acladdr[x])); ++ } ++ } ++ } ++ ++ config->hiddenAP = conf->ignore_broadcast_ssid; ++ ++ config->qos_enable = conf->wmm_enabled; ++ ++ config->expired_time = conf->ap_max_inactivity; ++ ++ config->block_relay = iconf->bridge_packets; ++ ++ if(iconf->ht_capab &= HT_CAP_INFO_SHORT_GI20MHZ) ++ config->shortGI20M = 1; ++ ++ if(iconf->ht_capab &= HT_CAP_INFO_SHORT_GI40MHZ) ++ config->shortGI40M = 1; ++ ++ wpa_printf(MSG_DEBUG, "realtek_read_hapd_cfg ---"); ++ ++ return 0; ++ ++} ++ ++static int realtek_read_priv_vap_cfg(const char *ifname,void *priv, struct rtk_hapd_config* config) ++{ ++ ++ struct realtek_driver_data *drv = priv; ++ FILE *f; ++ char buf[256], *pos; ++ int errors = 0; ++ int line = 0; ++ int in_bss_section=0; ++ ++ f = fopen(drv->hapd->iface->config_fname, "r"); ++ if (f == NULL) ++ { ++ wpa_printf(MSG_ERROR, "Could not open configuration file '%s' " ++ "for reading.", drv->hapd->iface->config_fname); ++ return -1; ++ } ++ ++ while (fgets(buf, sizeof(buf), f)) ++ { ++ line++; ++ if (buf[0] == '#') ++ continue; ++ pos = buf; ++ while (*pos != '\0') ++ { ++ if (*pos == '\n') ++ { ++ *pos = '\0'; ++ break; ++ } ++ pos++; ++ } ++ ++ if (buf[0] == '\0') ++ continue; ++ ++ pos = os_strchr(buf, '='); ++ if (pos == NULL) ++ { ++ wpa_printf(MSG_ERROR, "Line %d: invalid line '%s'", line, buf); ++ errors++; ++ continue; ++ } ++ *pos = '\0'; ++ pos++; ++ if (os_strcmp(buf, "bss") == 0) { ++ ++ if(in_bss_section) //already in section , then scan finished; ++ break; ++ if(os_strcmp(pos, ifname) == 0) ++ { ++ in_bss_section = 1; ++ } ++ continue; ++ } ++ //below is the rtk parameter for per VAP ++ if(in_bss_section){ ++ /*else if (os_strcmp(buf, "autorate") == 0) { //mark_issue ++ config->autorate = atoi(pos); ++ }*/ ++ if (os_strcmp(buf, "fixrate") == 0) { ++ unsigned int select=0; ++ select = atoi(pos); ++ if(select == 0) ++ { ++ config->autorate = 1; ++ config->fixrate = 0; ++ } ++ else ++ { ++ config->autorate = 0; ++ config->fixrate = (1 << (select-1)); ++ } ++ //mark_issue , need to validate the rate with hw_mode(G? , N?) ++ }else if (os_strcmp(buf, "guest_access") == 0) { ++ config->guest_access= atoi(pos); ++ } ++ } ++ } ++ ++ fclose(f); ++ ++ if (errors) ++ wpa_printf(MSG_ERROR, "%d errors found in configuration file " ++ "'%s'", errors, drv->hapd->iface->config_fname); ++ ++ return errors; ++ ++} ++ ++ ++static int realtek_read_priv_cfg(void *priv, struct rtk_hapd_config* config) ++{ ++ ++ struct realtek_driver_data *drv = priv; ++ FILE *f; ++ char buf[256], *pos; ++ int errors = 0; ++ int line = 0; ++ ++ wpa_printf(MSG_DEBUG, "realtek_read_priv_cfg +++"); ++ ++ f = fopen(drv->hapd->iface->config_fname, "r"); ++ if (f == NULL) ++ { ++ wpa_printf(MSG_ERROR, "Could not open configuration file '%s' " ++ "for reading.", drv->hapd->iface->config_fname); ++ return -1; ++ } ++ ++ while (fgets(buf, sizeof(buf), f)) ++ { ++ line++; ++ if (buf[0] == '#') ++ continue; ++ pos = buf; ++ while (*pos != '\0') ++ { ++ if (*pos == '\n') ++ { ++ *pos = '\0'; ++ break; ++ } ++ pos++; ++ } ++ ++ if (buf[0] == '\0') ++ continue; ++ ++ pos = os_strchr(buf, '='); ++ if (pos == NULL) ++ { ++ wpa_printf(MSG_ERROR, "Line %d: invalid line '%s'", line, buf); ++ errors++; ++ continue; ++ } ++ *pos = '\0'; ++ pos++; ++ if (os_strcmp(buf, "bss") == 0) { ++ break; //only read interface section ++ } ++ if (os_strcmp(buf, "pwrlevelCCK_A") == 0) { ++ realtek_parse_pwrlevel(config->pwrlevelCCK_A, pos); ++ } ++ else if (os_strcmp(buf, "pwrlevelCCK_B") == 0) { ++ realtek_parse_pwrlevel(config->pwrlevelCCK_B, pos); ++ } ++ else if (os_strcmp(buf, "pwrlevelHT40_1S_A") == 0) { ++ realtek_parse_pwrlevel(config->pwrlevelHT40_1S_A, pos); ++ } ++ else if (os_strcmp(buf, "pwrlevelHT40_1S_B") == 0) { ++ realtek_parse_pwrlevel(config->pwrlevelHT40_1S_B, pos); ++ } ++ else if (os_strcmp(buf, "pwrdiffHT40_2S") == 0) { ++ realtek_parse_pwrlevel(config->pwrdiffHT40_2S, pos); ++ } ++ else if (os_strcmp(buf, "pwrdiffHT20") == 0) { ++ realtek_parse_pwrlevel(config->pwrdiffHT20, pos); ++ } ++ else if (os_strcmp(buf, "pwrdiffOFDM") == 0) { ++ realtek_parse_pwrlevel(config->pwrdiffOFDM, pos); ++ } ++ else if (os_strcmp(buf, "phyBandSelect") == 0) { ++ config->phyBandSelect = atoi(pos); ++ } ++ else if (os_strcmp(buf, "macPhyMode") == 0) { ++ config->macPhyMode = atoi(pos); ++ } ++ else if (os_strcmp(buf, "ther") == 0) { ++ config->ther = atoi(pos); ++ } ++ else if (os_strcmp(buf, "swcrypto") == 0) { ++ config->swcrypto = atoi(pos); ++ } ++ else if (os_strcmp(buf, "regdomain") == 0) { ++ config->regdomain = atoi(pos); ++ } ++ /*else if (os_strcmp(buf, "autorate") == 0) { //mark_issue ++ config->autorate = atoi(pos); ++ }*/ ++ else if (os_strcmp(buf, "fixrate") == 0) { ++ unsigned int select=0; ++ select = atoi(pos); ++ if(select == 0) ++ { ++ config->autorate = 1; ++ config->fixrate = 0; ++ } ++ else ++ { ++ config->autorate = 0; ++ config->fixrate = (1 << (select-1)); ++ } ++ //mark_issue , need to validate the rate with hw_mode(G? , N?) ++ } ++ else if (os_strcmp(buf, "disable_protection") == 0) { ++ config->disable_protection = atoi(pos); ++ } ++ else if (os_strcmp(buf, "disable_olbc") == 0) { ++ config->disable_olbc = atoi(pos); ++ } ++ else if (os_strcmp(buf, "deny_legacy") == 0) { ++ config->deny_legacy = atoi(pos); ++ } ++ else if (os_strcmp(buf, "opmode") == 0) { ++ config->opmode = atoi(pos); ++ } ++ else if (os_strcmp(buf, "vap_enable") == 0) { ++ config->vap_enable = atoi(pos); ++ } ++ else if (os_strcmp(buf, "use40M") == 0) { ++ config->use40M = atoi(pos); ++ } ++ else if (os_strcmp(buf, "2ndchoffset") == 0) { ++ config->_2ndchoffset = atoi(pos); ++ } ++ else if (os_strcmp(buf, "ampdu") == 0) { ++ config->ampdu = atoi(pos); ++ } ++ else if (os_strcmp(buf, "coexist") == 0) { ++ config->coexist = atoi(pos); ++ } ++ else if (os_strcmp(buf, "rssi_dump") == 0) { ++ config->rssi_dump = atoi(pos); ++ } ++ else if (os_strcmp(buf, "mp_specific") == 0) { ++ config->mp_specific = atoi(pos); ++ } ++ else if (os_strcmp(buf, "use_ext_pa") == 0) { ++ config->use_ext_pa = atoi(pos); ++ } ++ else if (os_strcmp(buf, "guest_access") == 0) { ++ config->guest_access= atoi(pos); ++ } ++ ++ } ++ ++ fclose(f); ++ ++ if (errors) ++ wpa_printf(MSG_ERROR, "%d errors found in configuration file " ++ "'%s'", errors, drv->hapd->iface->config_fname); ++ ++ wpa_printf(MSG_DEBUG, "realtek_read_priv_cfg ---"); ++ ++ return errors; ++ ++} ++ ++ ++ ++static int realtek_read_wds_cfg(void *priv, struct rtk_wds_config* wds) ++{ ++ ++ struct realtek_driver_data *drv = priv; ++ FILE *f; ++ char buf[256], *pos; ++ int errors = 0; ++ int line = 0; ++ ++ wpa_printf(MSG_DEBUG, "realtek_read_wds_cfg +++"); ++ ++ f = fopen(drv->hapd->iface->config_fname, "r"); ++ if (f == NULL) ++ { ++ wpa_printf(MSG_ERROR, "Could not open configuration file '%s' " ++ "for reading.", drv->hapd->iface->config_fname); ++ return -1; ++ } ++ ++ while (fgets(buf, sizeof(buf), f)) ++ { ++ line++; ++ if (buf[0] == '#') ++ continue; ++ pos = buf; ++ while (*pos != '\0') ++ { ++ if (*pos == '\n') ++ { ++ *pos = '\0'; ++ break; ++ } ++ pos++; ++ } ++ ++ if (buf[0] == '\0') ++ continue; ++ ++ pos = os_strchr(buf, '='); ++ if (pos == NULL) ++ { ++ wpa_printf(MSG_ERROR, "Line %d: invalid line '%s'", line, buf); ++ errors++; ++ continue; ++ } ++ *pos = '\0'; ++ pos++; ++ ++ if (strcmp(buf, "wds_enable") == 0) { ++ wds->wdsEnabled = atoi(pos); ++ } ++ else if (strcmp(buf, "wds_num") == 0) { ++ wds->wdsNum = atoi(pos); ++ } ++ else if (strcmp(buf, "wds_mac1") == 0) { ++ if (hwaddr_aton(pos, wds->macAddr[0])) { ++ wpa_printf(MSG_ERROR, "Line %d: invalid MAC address '%s'\n", line, pos); ++ errors++; ++ } ++ } ++ else if (strcmp(buf, "wds_mac2") == 0) { ++ if (hwaddr_aton(pos, wds->macAddr[1])) { ++ wpa_printf(MSG_ERROR, "Line %d: invalid MAC address '%s'\n", line, pos); ++ errors++; ++ } ++ } ++ else if (strcmp(buf, "wds_mac3") == 0) { ++ if (hwaddr_aton(pos, wds->macAddr[2])) { ++ wpa_printf(MSG_ERROR, "Line %d: invalid MAC address '%s'\n", line, pos); ++ errors++; ++ } ++ } ++ else if (strcmp(buf, "wds_mac4") == 0) { ++ if (hwaddr_aton(pos, wds->macAddr[3])) { ++ wpa_printf(MSG_ERROR, "Line %d: invalid MAC address '%s'\n", line, pos); ++ errors++; ++ } ++ } ++ else if (strcmp(buf, "wds_ssid") == 0) { ++ int ssid_len = strlen(pos); ++ if (ssid_len > HOSTAPD_MAX_SSID_LEN || ssid_len < 1) { ++ wpa_printf(MSG_ERROR, "Line %d: invalid SSID '%s'\n", line, pos); ++ errors++; ++ } else { ++ memcpy(wds->ssid, pos, ssid_len); ++ wds->ssid[ssid_len] = '\0'; ++ } ++ } ++ else if (strcmp(buf, "wds_enc_type") == 0) { ++ wds->wdsPrivacy = atoi(pos); ++ } ++ else if (strcmp(buf, "wds_wepkey") == 0) { ++ int len = strlen(pos); ++ int tmp_error = 0; ++ ++ //free(wds->wdsWepKey); ++ wds->wdsWepKey = NULL; ++ wds->wdsWepKeyLen = 0; ++ ++ if (pos[0] == '"') { ++ if (len < 2 || pos[len - 1] != '"') ++ tmp_error++; ++ else{ ++ len -= 2; ++ if (len > 0) { ++ wds->wdsWepKey = malloc(len); ++ if (wds->wdsWepKey == NULL) ++ tmp_error++; ++ else ++ memcpy(wds->wdsWepKey, pos + 1, len); ++ } ++ } ++ } ++ else ++ { ++ if (len & 1) ++ tmp_error++; ++ ++ len /= 2; ++ if (len > 0) ++ { ++ wds->wdsWepKey = malloc(len); ++ if (wds->wdsWepKey == NULL) ++ tmp_error++; ++ ++ if (hexstr2bin(pos, wds->wdsWepKey, len) < 0) ++ tmp_error++; ++ } ++ } ++ ++ wds->wdsWepKeyLen = len; ++ ++ if(tmp_error) ++ { ++ wpa_printf(MSG_ERROR, "Line %d: invalid wds_wepkey '%s'\n", line, pos); ++ errors++; ++ } ++ } ++ else if (strcmp(buf, "wds_passphrase") == 0) { ++ int len = strlen(pos); ++ //free(wds->wdsPskPassPhrase); ++ wds->wdsPskPassPhrase = NULL; ++ if (len < 8 || len > 63) { ++ wpa_printf(MSG_ERROR, "Line %d: invalid WPA passphrase length" ++ " %d (expected 8..63)\n", line, len); ++ errors++; ++ } else { ++ if ((wds->wdsPskPassPhrase = strdup(pos)) == NULL) ++ errors++; ++ } ++ } ++ ++ } ++ ++ fclose(f); ++ ++ if (errors) ++ wpa_printf(MSG_ERROR, "%d errors found in configuration file " ++ "'%s'", errors, drv->hapd->iface->config_fname); ++ ++ wpa_printf(MSG_DEBUG, "realtek_read_wds_cfg ---"); ++ ++ return errors; ++ ++} ++ ++static int realtek_hapd_config(void *priv) ++{ ++ struct realtek_driver_data *drv = priv; ++ struct hostapd_data *hapd = drv->hapd; ++ struct rtk_hapd_config *config=&rtk_config; ++ struct rtk_wds_config wds; ++ ++ wpa_printf(MSG_DEBUG, "realtek_hapd_config +++"); ++ ++ memset(config, 0, sizeof(struct rtk_hapd_config)); ++ ++ config->is_hapd = 1; //RTK_WPAS ++ ++ if(realtek_read_hapd_cfg(hapd,priv, config)) ++ return -1; ++ ++ if(realtek_read_priv_cfg(priv, config)) ++ return -1; ++ ++#ifdef INBAND_CTRL //HOST_LITTLE_ENDIAN ++ // rtk_hapd_config need to swap , write a function to do it ++ rtk_cfg_to_bigEndian(config); ++#endif ++ ++ if(set80211priv(drv->iface,drv, HAPD_IOCTL_SETCONFIG, config, sizeof(struct rtk_hapd_config))) ++ { ++ wpa_printf(MSG_ERROR, "%s: Failed to set Configurations", __func__); ++ return -1; ++ } ++ ++ if(realtek_read_wds_cfg(priv, &wds)) //mark_mbssid , wds for vap ?? ++ return -1; ++ ++ /* ++ if(realtek_set_wds(priv, wds)) ++ return -1; ++ */ ++ ++ wpa_printf(MSG_DEBUG, "realtek_hapd_config ---"); ++ ++ return 0; ++ ++} ++ ++ ++#endif ++ ++ ++const struct wpa_driver_ops wpa_driver_realtek_ops = { ++ .name = "realtek", ++ .init = realtek_init, ++ .deinit = realtek_deinit, ++ .set_ieee8021x = realtek_set_ieee8021x, ++ .set_privacy = realtek_set_privacy, ++ .set_encryption = realtek_set_key, ++ .get_seqnum = realtek_get_seqnum, ++ .flush = realtek_flush, ++ .set_generic_elem = realtek_set_opt_ie, ++ .wireless_event_init = realtek_wireless_event_init, ++ .wireless_event_deinit = realtek_wireless_event_deinit, ++ .sta_set_flags = realtek_sta_set_flags, ++ //mark read_sta_data because both ralink & broadcom NOT support ++ //.read_sta_data = realtek_read_sta_driver_data, ++ .send_eapol = realtek_send_eapol, ++ .sta_disassoc = realtek_sta_disassoc, ++ .sta_deauth = realtek_sta_deauth, ++#ifdef RTK_MBSSID ++ .bss_add = realtek_bss_add, ++ .bss_remove = realtek_bss_remove, ++#endif ++#ifdef RTK_HAPD ++ .sta_remove = realtek_sta_remove, ++#endif ++ .set_ssid = realtek_set_ssid, ++ .get_ssid = realtek_get_ssid, ++ .set_countermeasures = realtek_set_countermeasures, ++ //mark sta_clear_stats because both ralink & broadcom NOT support ++ //.sta_clear_stats = realtek_sta_clear_stats, ++ .commit = realtek_commit, ++#ifdef EAP_WPS ++ .set_wps_beacon_ie = realtek_set_wps_beacon_ie, ++ .set_wps_probe_resp_ie = realtek_set_wps_probe_resp_ie, ++ //.set_wps_assoc_resp_ie = realtek_set_wps_assoc_resp_ie, ++#endif /* EAP_WPS */ ++#ifdef RTK_HAPD ++ .driver_on = realtek_driver_on, ++#endif ++}; ++ ++#ifdef MODIFIED_BY_SONY ++int wext_set_key(void *priv, int alg, ++ const u8 *addr, int key_idx, ++ int set_tx, const u8 *seq, size_t seq_len, ++ const u8 *key, size_t key_len) ++{ ++ struct realtek_driver_data *drv = priv; ++ struct hostapd_data *hapd = drv->hapd; ++ struct hostapd_bss_config *conf = hapd->conf; ++ struct iwreq iwr; ++ int ret = 0; ++ int ioctl_sock; ++ ++ wpa_printf(MSG_DEBUG,"%s: alg=%d key_idx=%d set_tx=%d seq_len=%lu " ++ "key_len=%lu", __FUNCTION__, alg, key_idx, set_tx, ++ (unsigned long) seq_len, (unsigned long) key_len); ++ ++ ioctl_sock = socket(PF_INET, SOCK_DGRAM, 0); ++ if (ioctl_sock < 0) { ++ perror("socket(PF_INET,SOCK_DGRAM)"); ++ return -1; ++ } ++ ++ os_memset(&iwr, 0, sizeof(iwr)); ++ os_strncpy(iwr.ifr_name, drv->iface, IFNAMSIZ); ++ iwr.u.encoding.flags = key_idx + 1; ++ if (alg == WPA_ALG_NONE) ++ iwr.u.encoding.flags |= IW_ENCODE_DISABLED; ++ if (conf->auth_algs & HOSTAPD_AUTH_OPEN) ++ iwr.u.encoding.flags |= IW_ENCODE_OPEN; ++ if (conf->auth_algs & HOSTAPD_AUTH_SHARED_KEY) ++ iwr.u.encoding.flags |= IW_ENCODE_RESTRICTED; ++ iwr.u.encoding.pointer = (caddr_t) key; ++ iwr.u.encoding.length = key_len; ++#ifdef STAND_ALONE ++ if (ioctl(ioctl_sock, SIOCSIWENCODE, &iwr) < 0) { ++ perror("ioctl[SIOCSIWENCODE]"); ++ ret = -1; ++ } ++#endif ++#if defined(INBAND_CTRL) ++ INBAND_IOCTLPKT_DUMP(&iwr,sizeof(iwr)); ++ if (inband_ioctl(&drv->ioctl_ioh_obj,SIOCSIWENCODE, &iwr) < 0) { ++ perror("inband_ioctl[SIOCSIWENCODE]"); ++ ret = -1; ++ } ++#endif ++ ++ if (set_tx && alg != WPA_ALG_NONE) { ++ os_memset(&iwr, 0, sizeof(iwr)); ++ os_strncpy(iwr.ifr_name, drv->iface, IFNAMSIZ); ++ iwr.u.encoding.flags = key_idx + 1; ++ iwr.u.encoding.pointer = (caddr_t) key; ++ iwr.u.encoding.length = 0; ++#ifdef STAND_ALONE ++ if (ioctl(ioctl_sock, SIOCSIWENCODE, &iwr) < 0) { ++ perror("ioctl[SIOCSIWENCODE] (set_tx)"); ++ ret = -1; ++ } ++#endif ++#if defined(INBAND_CTRL) ++ INBAND_IOCTLPKT_DUMP(&iwr,sizeof(iwr)); ++ if (inband_ioctl(&drv->ioctl_ioh_obj,SIOCSIWENCODE, &iwr) < 0) { ++ perror("inband_ioctl[SIOCSIWENCODE] (set_tx)"); ++ ret = -1; ++ } ++#endif ++ ++ } ++ close(ioctl_sock); ++ return ret; ++} ++#endif /* MODIFIED_BY_SONY */ +Index: hostapd-rtk-0.6.10/hostapd/driver_realtek.h +=================================================================== +--- /dev/null ++++ hostapd-rtk-0.6.10/hostapd/driver_realtek.h +@@ -0,0 +1,147 @@ ++ ++#define MACADDRLEN 6 ++#define PROBEIELEN 260 ++ ++#define HAPD_IOCTL_GETWPAIE IEEE80211_IOCTL_GET_APPIEBUF ++#define HAPD_IOCTL_SETCONFIG SIOCIWLASTPRIV ++#define RTL8192CD_IOCTL_DEL_STA 0x89f7 ++#define SIOCGIWIND 0x89ff ++ ++#define HOSTAPD_WPA_VERSION_WPA BIT(0) ++#define HOSTAPD_WPA_VERSION_WPA2 BIT(1) ++ ++#define RTK_MBSSID 1 ++#define RTK_MAX_STA 32 ++#define RTK_MAX_IF_INDEX 16 ++ ++enum HAPD_EVENT{ ++ HAPD_EXIRED = 0, ++ HAPD_REGISTERED = 1, ++ HAPD_MIC_FAILURE = 2, ++ HAPD_TRAFFIC_STAT = 3, ++ HAPD_PUSH_BUTTON = 4, ++ HAPD_WPS_PROBEREQ = 5, ++ HAPD_WDS_SETWPA = 6 ++}; ++ ++enum WIFI_STATUS_CODE { ++ _STATS_SUCCESSFUL_ = 0, // Success. ++ _STATS_FAILURE_ = 1, // Failure. ++ _STATS_CAP_FAIL_ = 10, // Capability too wide, can't support ++ _STATS_NO_ASOC_ = 11, // Denial reassociate ++ _STATS_OTHER_ = 12, // Denial connect, not 802.11 standard. ++ _STATS_NO_SUPP_ALG_ = 13, // Authenticate algorithm not support . ++ _STATS_OUT_OF_AUTH_SEQ_ = 14, // Out of authenticate sequence number. ++ _STATS_CHALLENGE_FAIL_ = 15, // Denial authenticate, Response message fail. ++ _STATS_AUTH_TIMEOUT_ = 16, // Denial authenticate, timeout. ++ _STATS_UNABLE_HANDLE_STA_ = 17, // Denial authenticate, BS resoruce insufficient. ++ _STATS_RATE_FAIL_ = 18, // Denial authenticate, STA not support BSS request datarate. ++ _STATS_REQ_DECLINED_ = 37, ++/*#if defined(CONFIG_RTL_WAPI_SUPPORT)*/ ++ __STATS_INVALID_IE_ = 40, ++ __STATS_INVALID_AKMP_ = 43, ++ __STATS_CIPER_REJECT_ = 46, ++ __STATS_INVALID_USK_ = 47, ++ __STATS_INVALID_MSK_ = 48, ++ __STATS_INVALID_WAPI_VERSION_ = 49, ++ __STATS_INVALID_WAPI_CAPABILITY_ = 50, ++/*#endif*/ ++ ++#ifdef CONFIG_RTK_MESH // CATUTION: below undefine !! (Refer: Draft 1.06, Page 17, 7.3.1.9, Table 7-23, 2007/08/13 by popen) ++ _STATS_MESH_LINK_ESTABLISHED_ = 55, //The mesh peer link has been successfully ++ _STATS_MESH_LINK_CLOSED_ = 56, // The mesh peer link has been closed completely ++ _STATS_MESH_UNDEFINE1_ = 57, // No listed Key Holder Transport type is supported. ++ _STATS_MESH_UNDEFINE2_ = 58, // The Mesh Key Holder Security Handshake message was malformed. ++#endif ++}; ++ ++typedef enum{ ++ DOT11_EVENT_NO_EVENT = 1, ++ DOT11_EVENT_REQUEST = 2, ++ DOT11_EVENT_ASSOCIATION_IND = 3, ++ DOT11_EVENT_ASSOCIATION_RSP = 4, ++ DOT11_EVENT_AUTHENTICATION_IND = 5, ++ DOT11_EVENT_REAUTHENTICATION_IND = 6, ++ DOT11_EVENT_DEAUTHENTICATION_IND = 7, ++ DOT11_EVENT_DISASSOCIATION_IND = 8, ++ DOT11_EVENT_DISCONNECT_REQ = 9, ++ DOT11_EVENT_SET_802DOT11 = 10, ++ DOT11_EVENT_SET_KEY = 11, ++ DOT11_EVENT_SET_PORT = 12, ++ DOT11_EVENT_DELETE_KEY = 13, ++ DOT11_EVENT_SET_RSNIE = 14, ++ DOT11_EVENT_GKEY_TSC = 15, ++ DOT11_EVENT_MIC_FAILURE = 16, ++ DOT11_EVENT_ASSOCIATION_INFO = 17, ++ DOT11_EVENT_INIT_QUEUE = 18, ++ DOT11_EVENT_EAPOLSTART = 19, ++//2003-07-30 ------------ ++ DOT11_EVENT_ACC_SET_EXPIREDTIME = 31, ++ DOT11_EVENT_ACC_QUERY_STATS = 32, ++ DOT11_EVENT_ACC_QUERY_STATS_ALL = 33, ++//----------------------- ++ ++// --- 2003-08-04 --- ++ DOT11_EVENT_REASSOCIATION_IND = 34, ++ DOT11_EVENT_REASSOCIATION_RSP = 35, ++//----------------------- ++ DOT11_EVENT_STA_QUERY_BSSID = 36, ++ DOT11_EVENT_STA_QUERY_SSID = 37, ++ ++// jimmylin: pass EAP packet by event queue ++ DOT11_EVENT_EAP_PACKET = 41, ++ ++#ifdef RTL_WPA2 ++ DOT11_EVENT_EAPOLSTART_PREAUTH = 45, ++ DOT11_EVENT_EAP_PACKET_PREAUTH = 46, ++#endif ++ ++#ifdef RTL_WPA2_CLIENT ++ DOT11_EVENT_WPA2_MULTICAST_CIPHER = 47, ++#endif ++ ++ DOT11_EVENT_WPA_MULTICAST_CIPHER = 48, ++ ++#ifdef AUTO_CONFIG ++ DOT11_EVENT_AUTOCONF_ASSOCIATION_IND = 50, ++ DOT11_EVENT_AUTOCONF_ASSOCIATION_CONFIRM = 51, ++ DOT11_EVENT_AUTOCONF_PACKET = 52, ++ DOT11_EVENT_AUTOCONF_LINK_IND = 53, ++#endif ++ ++#ifdef WIFI_SIMPLE_CONFIG ++ DOT11_EVENT_WSC_SET_IE = 55, ++ DOT11_EVENT_WSC_PROBE_REQ_IND = 56, ++ DOT11_EVENT_WSC_PIN_IND = 57, ++ DOT11_EVENT_WSC_ASSOC_REQ_IE_IND = 58, ++#ifdef CONFIG_IWPRIV_INTF ++ DOT11_EVENT_WSC_START_IND = 70, ++ //EV_MODE, EV_STATUS, EV_MEHOD, EV_STEP, EV_OOB ++ DOT11_EVENT_WSC_MODE_IND = 71, ++ DOT11_EVENT_WSC_STATUS_IND = 72, ++ DOT11_EVENT_WSC_METHOD_IND = 73, ++ DOT11_EVENT_WSC_STEP_IND = 74, ++ DOT11_EVENT_WSC_OOB_IND = 75, ++#endif //ifdef CONFIG_IWPRIV_INTF ++#endif ++ ++ DOT11_EVENT_MAX = 59, ++} DOT11_EVENT; ++ ++ ++typedef struct _DOT11_PROBE_REQUEST_IND{ ++ unsigned char EventId; ++ unsigned char IsMoreEvent; ++ char MACAddr[MACADDRLEN]; ++ unsigned short ProbeIELen; ++ char ProbeIE[PROBEIELEN]; ++}DOT11_PROBE_REQUEST_IND; ++ ++ ++typedef struct _DOT11_ASSOCIATION_RSP{ ++ unsigned char EventId; ++ unsigned char IsMoreEvent; ++ char MACAddr[MACADDRLEN]; ++ unsigned char Status; ++}DOT11_ASSOCIATION_RSP; ++ +Index: hostapd-rtk-0.6.10/hostapd/README-REALTEK_WIFI +=================================================================== +--- /dev/null ++++ hostapd-rtk-0.6.10/hostapd/README-REALTEK_WIFI +@@ -0,0 +1,116 @@ ++================================================================================== ++Introduction ++ This document is the guideline for building/using/porting the Hostapd ++application to support Realtek's Wifi device. ++ ++================================================================================== ++ ++1.Build the hostapd daemon ++----------------------------- ++ If the Wifi device is connected to your platform using GMII/MII interface ++then the inband libary must be built and enabled in hostapd.control. Please follow ++the steps below to build the hostapd daemon.() ++ ++ a. Build the inband libary (#This step can be skipped,if you dont need inband-cotrol) ++ ++ - Enter the inband_dir directory.(default:../../inband_dir) ++ ++ - Modify the definition of CC and LD in /inband_lib/Makefile to fit your ++ toolchain setting. ++ ++ - type make and the inband.a libray will be built on your platform. ++ ++ b. Enable/Disable the inband-control support in Hostapd. ++ ++ - Enable the lines below in hostapd-0.6.10/hostapd/Makefile to enable the ++ inband-support.In the other hand,disable these lines to disable the inband-control. ++ ++ CFLAGS += -DINBAND_CTRL ++ CFLAGS += -I../../inband_lib ++ LIBS += ../../inband_lib/inband.a ++ ++ c. Make the Hostapd ++ ++ - enter the directory : hostapd-0.6.10/hostapd/ ++ ++ - Modify hostapd-0.6.10/hostapd/Makefile to include your openssl libary.Below ++ lines are the default setting in Realtek's WIFI-AP SDK. ++ ++ LIBS += -ldl ../../openssl-0.9.8b/libssl.a ../../openssl-0.9.8b/libcrypto.a ++ LIBS_p += ../../openssl-0.9.8b/libcrypto.a ++ LIBS_h += ../../openssl-0.9.8b/libcrypto.a ++ ++ - Modify the definition of CC and LD in hostapd-0.6.10/hostapd/Makefile to ++ fit your toolchain setting. ++ ++ - type 'make' under hostapd-0.6.10/hostapd ,then the hostapd daemon will be built. ++ ++NOTEs: ++ - Because of the ethernet type 0x8899 and 0x9000 is used for inband control ++ please do not use them in other applications. ++ ++ - The default local interface for inband control is "br0', you can change the definition ++ in drv_realtek.c(the line list below) to fit your MII interface setting. ++ ++ #define INBAND_INTF "br0" ++ ++ - The default MAC address for inband-control is "00:12:34:56:78:99", it ++ can be changed in drv_realtek.c. ++ ++================================================================================== ++ ++2.Realtek proprietary configuration options ++---------------------------- ++ ++ - Please refer to file hostapd.test_conf(under hostapd-0.6.10/hostapd/conf) ++ for detail descriptions about the new added realtek private configurations. All these ++ configurations are directly mapped to realtek WiFi mibs. ++ ++ - Other inherently hostapd configurations are same as before. ++ ++ - 'auth_algs' has new values for supporting Open Networking & WEP+802.1x ++ ## ======== Modify auth_algs support========== ++ ## bit 0 = Open System Authentication ++ ## bit 1 = Shared Key Authentication (requires WEP) ++ ## bit 0 + bit 1 = Auto WEP mode ++ ## bit 2 = WEP + 802.1x ++ ## bit 3 = Open Networking(no security) ++ ++ - These hostapd configuration files(under /hostapd-0.6.10/hostapd/conf) can be examples for testing ++ - hostapd.none_security :WPS configured, Open Networking. ++ - hostapd.wpa_psk :WPS configured, WPA-PSK CCMP. ++ - NOT Supported yet: ++ - Some IEEE 802.11 related configurations ++ - IEEE 802.11r configuration ++ - Passive scanning ++ - Multiple BSSID support ++ ++ ++================================================================================== ++ ++3.Porting notes ++----------------------------- ++ The Hostapd for Realtek WiFi device is based on hostapd 0.6.10 and patch the realtek's implementation. ++Some notes are listed below to help you to port this package to your platform(for example , ++you are using hostapd 0.6.9 on your platform not 0.6.10). ++ ++ - Driver_realtek.c & Driver_realtek.h under /hostapd-0.6.10/hostapd are the main added files ++ for supporting realtek WiFi device. ++ ++ - Other modifications about Hostapd-0.6.10 were labeled with compile tag 'RTK_HAPD'. ++ You can check these patches by searching the keyword 'RTK_HAPD'. ++ ++ - List of modified source files in hostapd v0.6.10: ++ - Config.c ++ - Driver.h ++ - Hostapd.c ++ - Hostapd.h ++ - Iapp.c ++ - Os_unix.c ++ - Wps.h ++ - Wps_hostapd.c ++ - Wps_registrar.c ++ - Wps_upnp_event.c ++ - Wps_upnp_web.c ++ ++================================================================================= diff --git a/package/hostapd-rtk/patches/005-supplicant-diff.patch b/package/hostapd-rtk/patches/005-supplicant-diff.patch new file mode 100644 index 000000000..329194bb5 --- /dev/null +++ b/package/hostapd-rtk/patches/005-supplicant-diff.patch @@ -0,0 +1,207 @@ +Index: hostapd-rtk-0.6.10/wpa_supplicant/config_file.c +=================================================================== +--- hostapd-rtk-0.6.10.orig/wpa_supplicant/config_file.c ++++ hostapd-rtk-0.6.10/wpa_supplicant/config_file.c +@@ -458,6 +458,10 @@ static const struct global_parse_data gl + { FUNC(os_version) }, + { INT_RANGE(wps_cred_processing, 0, 2) }, + #endif /* CONFIG_WPS */ ++#ifdef RTK_WPAS ++ { INT(macPhyMode) }, ++ { INT(phyBandSelect) }, ++#endif + { FUNC(country) } + }; + +@@ -886,6 +890,10 @@ static void wpa_config_write_global(FILE + fprintf(f, "wps_cred_processing=%d\n", + config->wps_cred_processing); + #endif /* CONFIG_WPS */ ++#ifdef RTK_WPAS ++ fprintf(f, "macPhyMode=%d\n", config->macPhyMode); ++ fprintf(f, "phyBandSelect=%d\n", config->phyBandSelect); ++#endif + if (config->country[0] && config->country[1]) { + fprintf(f, "country=%c%c\n", + config->country[0], config->country[1]); +Index: hostapd-rtk-0.6.10/wpa_supplicant/config.h +=================================================================== +--- hostapd-rtk-0.6.10.orig/wpa_supplicant/config.h ++++ hostapd-rtk-0.6.10/wpa_supplicant/config.h +@@ -323,6 +323,11 @@ struct wpa_config { + * ctrl_iface to external program(s) + */ + int wps_cred_processing; ++ ++#if (1)//RTK_HAPD ++ int macPhyMode; ++ int phyBandSelect; ++#endif + }; + + +Index: hostapd-rtk-0.6.10/wpa_supplicant/defconfig +=================================================================== +--- hostapd-rtk-0.6.10.orig/wpa_supplicant/defconfig ++++ hostapd-rtk-0.6.10/wpa_supplicant/defconfig +@@ -41,7 +41,7 @@ + + + # Driver interface for Host AP driver +-CONFIG_DRIVER_HOSTAP=y ++#CONFIG_DRIVER_HOSTAP=y + + # Driver interface for Agere driver + #CONFIG_DRIVER_HERMES=y +@@ -55,6 +55,9 @@ CONFIG_DRIVER_HOSTAP=y + # Set include directory to the madwifi source tree + #CFLAGS += -I../../madwifi + ++# Driver interface for Realtek driver ++CONFIG_DRIVER_REALTEK=y ++ + # Driver interface for Prism54 driver + # (Note: Prism54 is not yet supported, i.e., this will not work as-is and is + # for developers only) +@@ -65,7 +68,7 @@ CONFIG_DRIVER_HOSTAP=y + #CONFIG_DRIVER_NDISWRAPPER=y + + # Driver interface for Atmel driver +-CONFIG_DRIVER_ATMEL=y ++#CONFIG_DRIVER_ATMEL=y + + # Driver interface for old Broadcom driver + # Please note that the newer Broadcom driver ("hybrid Linux driver") supports +@@ -83,7 +86,7 @@ CONFIG_DRIVER_ATMEL=y + #CONFIG_DRIVER_RALINK=y + + # Driver interface for generic Linux wireless extensions +-CONFIG_DRIVER_WEXT=y ++#CONFIG_DRIVER_WEXT=y + + # Driver interface for Linux drivers using the nl80211 kernel interface + #CONFIG_DRIVER_NL80211=y +@@ -113,7 +116,7 @@ CONFIG_DRIVER_WEXT=y + #CONFIG_DRIVER_TEST=y + + # Driver interface for wired Ethernet drivers +-CONFIG_DRIVER_WIRED=y ++#CONFIG_DRIVER_WIRED=y + + # Driver interface for the Broadcom RoboSwitch family + #CONFIG_DRIVER_ROBOSWITCH=y +Index: hostapd-rtk-0.6.10/wpa_supplicant/events.c +=================================================================== +--- hostapd-rtk-0.6.10.orig/wpa_supplicant/events.c ++++ hostapd-rtk-0.6.10/wpa_supplicant/events.c +@@ -259,6 +259,9 @@ static int wpa_supplicant_match_privacy( + for (i = 0; i < NUM_WEP_KEYS; i++) { + if (ssid->wep_key_len[i]) { + privacy = 1; ++#ifdef RTK_WPAS ++ bss->caps |= IEEE80211_CAP_PRIVACY; ++#endif + break; + } + } +Index: hostapd-rtk-0.6.10/wpa_supplicant/wpa_supplicant.c +=================================================================== +--- hostapd-rtk-0.6.10.orig/wpa_supplicant/wpa_supplicant.c ++++ hostapd-rtk-0.6.10/wpa_supplicant/wpa_supplicant.c +@@ -40,6 +40,11 @@ + #include "wpas_glue.h" + #include "wps_supplicant.h" + ++#ifdef RTK_INBAND ++#include <net/if.h> ++#include <sys/ioctl.h> ++#endif ++ + const char *wpa_supplicant_version = + "wpa_supplicant v" VERSION_STR "\n" + "Copyright (c) 2003-2009, Jouni Malinen <j@w1.fi> and contributors"; +@@ -1603,25 +1608,52 @@ void wpa_supplicant_sta_rx(void *ctx, co + int wpa_supplicant_driver_init(struct wpa_supplicant *wpa_s) + { + static int interface_count = 0; ++#ifdef RTK_INBAND ++ struct ifreq ifr; ++#endif ++ + + if (wpa_s->driver->send_eapol) { + const u8 *addr = wpa_drv_get_mac_addr(wpa_s); + if (addr) + os_memcpy(wpa_s->own_addr, addr, ETH_ALEN); + } else { ++ ++#ifdef RTK_INBAND ++ wpa_s->l2 = l2_packet_init("eth0", ++ wpa_drv_get_mac_addr(wpa_s), ++ ETH_P_EAPOL, ++ wpa_supplicant_rx_eapol, wpa_s, 0); ++#else + wpa_s->l2 = l2_packet_init(wpa_s->ifname, + wpa_drv_get_mac_addr(wpa_s), + ETH_P_EAPOL, + wpa_supplicant_rx_eapol, wpa_s, 0); ++#endif + if (wpa_s->l2 == NULL) + return -1; + } + ++#ifdef RTK_INBAND ++ ++ os_memset(&ifr, 0, sizeof(ifr)); ++ ++ os_strlcpy(ifr.ifr_name, wpa_s->ifname, sizeof(ifr.ifr_name)); ++ ++ if (inband_ioctl(SIOCGIFHWADDR,&ifr) < 0) ++ printf("SIOCGIFHWADDR error !! Failed to get own address\n"); ++ else ++ os_memcpy(wpa_s->own_addr, ifr.ifr_hwaddr.sa_data, ETH_ALEN); ++ ++#else ++ + if (wpa_s->l2 && l2_packet_get_own_addr(wpa_s->l2, wpa_s->own_addr)) { + wpa_printf(MSG_ERROR, "Failed to get own L2 address"); + return -1; + } + ++#endif ++ + wpa_printf(MSG_DEBUG, "Own MAC address: " MACSTR, + MAC2STR(wpa_s->own_addr)); + +Index: hostapd-rtk-0.6.10/wpa_supplicant/Makefile +=================================================================== +--- hostapd-rtk-0.6.10.orig/wpa_supplicant/Makefile ++++ hostapd-rtk-0.6.10/wpa_supplicant/Makefile +@@ -157,6 +157,14 @@ OBJS_d += ../src/drivers/driver_madwifi. + CONFIG_WIRELESS_EXTENSION=y + endif + ++ifdef CONFIG_DRIVER_REALTEK ++CFLAGS += -DCONFIG_DRIVER_REALTEK ++CFLAGS += -DINBAND_CTRL ++LIBS += -linband ++OBJS_d += ../src/drivers/driver_realtek.o ++CONFIG_WIRELESS_EXTENSION=y ++endif ++ + ifdef CONFIG_DRIVER_ATMEL + CFLAGS += -DCONFIG_DRIVER_ATMEL + OBJS_d += ../src/drivers/driver_atmel.o +@@ -859,8 +867,12 @@ CFLAGS += -DNEED_SHA256 + endif + + ifdef CONFIG_WIRELESS_EXTENSION ++ifdef CONFIG_DRIVER_REALTEK ++OBJS_d += ../src/drivers/driver_realtek_wext.o ++else + OBJS_d += ../src/drivers/driver_wext.o + endif ++endif + + ifdef CONFIG_CTRL_IFACE + ifeq ($(CONFIG_CTRL_IFACE), y) diff --git a/package/hostapd-rtk/patches/008-no-inband.patch b/package/hostapd-rtk/patches/008-no-inband.patch new file mode 100644 index 000000000..ef71b897b --- /dev/null +++ b/package/hostapd-rtk/patches/008-no-inband.patch @@ -0,0 +1,26 @@ +Index: hostapd-rtk-0.6.10/hostapd/Makefile +=================================================================== +--- hostapd-rtk-0.6.10.orig/hostapd/Makefile ++++ hostapd-rtk-0.6.10/hostapd/Makefile +@@ -124,7 +124,7 @@ endif + + ifdef CONFIG_DRIVER_REALTEK + CFLAGS += -DCONFIG_DRIVER_REALTEK +-CFLAGS += -DINBAND_CTRL ++#CFLAGS += -DINBAND_CTRL + LIBS += -linband + OBJS += driver_realtek.o + CONFIG_L2_PACKET=y +Index: hostapd-rtk-0.6.10/wpa_supplicant/Makefile +=================================================================== +--- hostapd-rtk-0.6.10.orig/wpa_supplicant/Makefile ++++ hostapd-rtk-0.6.10/wpa_supplicant/Makefile +@@ -159,7 +159,7 @@ endif + + ifdef CONFIG_DRIVER_REALTEK + CFLAGS += -DCONFIG_DRIVER_REALTEK +-CFLAGS += -DINBAND_CTRL ++#CFLAGS += -DINBAND_CTRL + LIBS += -linband + OBJS_d += ../src/drivers/driver_realtek.o + CONFIG_WIRELESS_EXTENSION=y |