diff options
| author | Roman Yeryomin <roman@advem.lv> | 2012-09-22 19:44:27 +0300 |
|---|---|---|
| committer | Roman Yeryomin <roman@advem.lv> | 2013-05-26 00:44:46 +0300 |
| commit | 77ae7d375b727f757bf60c93a21d7360524e2e39 (patch) | |
| tree | be625058667a786c7846d87f18eef076e0305da9 /package/hostapd-rtk/patches/004-hostapd-files.patch | |
| parent | 57a39662357063732a967214f29415020221186c (diff) | |
Add hostapd-rtk and librtk-inband packages
Signed-off-by: Roman Yeryomin <roman@advem.lv>
Diffstat (limited to 'package/hostapd-rtk/patches/004-hostapd-files.patch')
| -rw-r--r-- | package/hostapd-rtk/patches/004-hostapd-files.patch | 3529 |
1 files changed, 3529 insertions, 0 deletions
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 ++ ++================================================================================= |