[GitHub/MotorolaMobilityLLC/hardware-samsung_slsi-scsc_wifibt-wifi_hal.git] / wifi_hal.cpp

#include <errno.h>\r
#include <stdint.h>\r
#include <fcntl.h>\r
#include <sys/socket.h>\r
#include <netlink/genl/genl.h>\r
#include <netlink/genl/family.h>\r
#include <netlink/genl/ctrl.h>\r
#include <linux/rtnetlink.h>\r
#include <netpacket/packet.h>\r
#include <linux/filter.h>\r
#include <linux/errqueue.h>\r
\r
#include <linux/pkt_sched.h>\r
#include <netlink/object-api.h>\r
#include <netlink/netlink.h>\r
#include <netlink/socket.h>\r
#include <netlink/attr.h>\r
#include <netlink/handlers.h>\r
#include <netlink/msg.h>\r
\r
#include <dirent.h>\r
#include <net/if.h>\r
\r
#include "sync.h"\r
\r
#define LOG_TAG  "WifiHAL"\r
\r
#include <utils/Log.h>\r
\r
#include "wifi_hal.h"\r
#include "common.h"\r
#include "cpp_bindings.h"\r
\r
\r
#define WIFI_HAL_CMD_SOCK_PORT       644\r
#define WIFI_HAL_EVENT_SOCK_PORT     645\r
\r
#define FEATURE_SET                  0\r
#define FEATURE_SET_MATRIX           1\r
#define ATTR_NODFS_VALUE             3\r
\r
static void internal_event_handler(wifi_handle handle, int events);\r
static int internal_no_seq_check(nl_msg *msg, void *arg);\r
static int internal_valid_message_handler(nl_msg *msg, void *arg);\r
static int wifi_get_multicast_id(wifi_handle handle, const char *name, const char *group);\r
static int wifi_add_membership(wifi_handle handle, const char *group);\r
static wifi_error wifi_init_interfaces(wifi_handle handle);\r
\r
typedef enum wifi_attr {\r
    ANDR_WIFI_ATTRIBUTE_NUM_FEATURE_SET,\r
    ANDR_WIFI_ATTRIBUTE_FEATURE_SET,\r
    ANDR_WIFI_ATTRIBUTE_PNO_RANDOM_MAC_OUI\r
} wifi_attr_t;\r
\r
/* Initialize/Cleanup */\r
\r
void wifi_socket_set_local_port(struct nl_sock *sock, uint32_t port)\r
{\r
    uint32_t pid = getpid() & 0x3FFFFF;\r
    nl_socket_set_local_port(sock, pid + (port << 22));\r
}\r
\r
static nl_sock * wifi_create_nl_socket(int port)\r
{\r
     ALOGI("Creating socket");\r
    struct nl_sock *sock = nl_socket_alloc();\r
    if (sock == NULL) {\r
        ALOGE("Could not create handle");\r
        return NULL;\r
    }\r
\r
    wifi_socket_set_local_port(sock, port);\r
\r
    struct sockaddr *addr = NULL;\r
    // ALOGI("sizeof(sockaddr) = %d, sizeof(sockaddr_nl) = %d", sizeof(*addr), sizeof(*addr_nl));\r
\r
     ALOGI("Connecting socket");\r
    if (nl_connect(sock, NETLINK_GENERIC)) {\r
        ALOGE("Could not connect handle");\r
        nl_socket_free(sock);\r
        return NULL;\r
    }\r
\r
     ALOGI("Making socket nonblocking");\r
    /*\r
    if (nl_socket_set_nonblocking(sock)) {\r
        ALOGE("Could make socket non-blocking");\r
        nl_socket_free(sock);\r
        return NULL;\r
    }\r
    */\r
\r
    return sock;\r
}\r
\r
/*initialize function pointer table with Broadcom HHAL API*/\r
wifi_error init_wifi_vendor_hal_func_table(wifi_hal_fn *fn)\r
{\r
    if (fn == NULL) {\r
        return WIFI_ERROR_UNKNOWN;\r
    }\r
    fn->wifi_initialize = wifi_initialize;\r
    fn->wifi_cleanup = wifi_cleanup;\r
    fn->wifi_event_loop = wifi_event_loop;\r
    fn->wifi_get_supported_feature_set = wifi_get_supported_feature_set;\r
    fn->wifi_get_concurrency_matrix = wifi_get_concurrency_matrix;\r
    fn->wifi_set_scanning_mac_oui =  wifi_set_scanning_mac_oui;\r
    fn->wifi_get_ifaces = wifi_get_ifaces;\r
    fn->wifi_get_iface_name = wifi_get_iface_name;\r
    fn->wifi_start_gscan = wifi_start_gscan;\r
    fn->wifi_stop_gscan = wifi_stop_gscan;\r
    fn->wifi_get_cached_gscan_results = wifi_get_cached_gscan_results;\r
    fn->wifi_set_bssid_hotlist = wifi_set_bssid_hotlist;\r
    fn->wifi_reset_bssid_hotlist = wifi_reset_bssid_hotlist;\r
    fn->wifi_set_significant_change_handler = wifi_set_significant_change_handler;\r
    fn->wifi_reset_significant_change_handler = wifi_reset_significant_change_handler;\r
    fn->wifi_get_gscan_capabilities = wifi_get_gscan_capabilities;\r
    fn->wifi_get_link_stats = wifi_get_link_stats;\r
    fn->wifi_get_valid_channels = wifi_get_valid_channels;\r
    fn->wifi_rtt_range_request = wifi_rtt_range_request;\r
    fn->wifi_rtt_range_cancel = wifi_rtt_range_cancel;\r
    fn->wifi_get_rtt_capabilities = wifi_get_rtt_capabilities;\r
    fn->wifi_set_nodfs_flag = wifi_set_nodfs_flag;\r
    return WIFI_SUCCESS;\r
}\r
\r
wifi_error wifi_initialize(wifi_handle *handle)\r
{\r
    srand(getpid());\r
\r
    ALOGI("Initializing wifi");\r
    hal_info *info = (hal_info *)malloc(sizeof(hal_info));\r
    if (info == NULL) {\r
        ALOGE("Could not allocate hal_info");\r
        return WIFI_ERROR_UNKNOWN;\r
    }\r
\r
    memset(info, 0, sizeof(*info));\r
\r
    ALOGI("Creating socket");\r
    if (socketpair(AF_UNIX, SOCK_STREAM, 0, info->cleanup_socks) == -1) {\r
        ALOGE("Could not create cleanup sockets");\r
        free(info);\r
        return WIFI_ERROR_UNKNOWN;\r
    }\r
\r
    struct nl_sock *cmd_sock = wifi_create_nl_socket(WIFI_HAL_CMD_SOCK_PORT);\r
    if (cmd_sock == NULL) {\r
        ALOGE("Could not create handle");\r
        free(info);\r
        return WIFI_ERROR_UNKNOWN;\r
    }\r
\r
    struct nl_sock *event_sock = wifi_create_nl_socket(WIFI_HAL_EVENT_SOCK_PORT);\r
    if (event_sock == NULL) {\r
        ALOGE("Could not create handle");\r
        nl_socket_free(cmd_sock);\r
        free(info);\r
        return WIFI_ERROR_UNKNOWN;\r
    }\r
\r
    struct nl_cb *cb = nl_socket_get_cb(event_sock);\r
    if (cb == NULL) {\r
        ALOGE("Could not create handle");\r
        nl_socket_free(cmd_sock);\r
        nl_socket_free(event_sock);\r
        free(info);\r
        return WIFI_ERROR_UNKNOWN;\r
    }\r
\r
//     ALOGI("cb->refcnt = %d", cb->cb_refcnt);\r
    nl_cb_set(cb, NL_CB_SEQ_CHECK, NL_CB_CUSTOM, internal_no_seq_check, info);\r
    nl_cb_set(cb, NL_CB_VALID, NL_CB_CUSTOM, internal_valid_message_handler, info);\r
    nl_cb_put(cb);\r
\r
    info->cmd_sock = cmd_sock;\r
    info->event_sock = event_sock;\r
    info->clean_up = false;\r
    info->in_event_loop = false;\r
\r
    info->event_cb = (cb_info *)malloc(sizeof(cb_info) * DEFAULT_EVENT_CB_SIZE);\r
    info->alloc_event_cb = DEFAULT_EVENT_CB_SIZE;\r
    info->num_event_cb = 0;\r
\r
    info->cmd = (cmd_info *)malloc(sizeof(cmd_info) * DEFAULT_CMD_SIZE);\r
    info->alloc_cmd = DEFAULT_CMD_SIZE;\r
    info->num_cmd = 0;\r
\r
    info->nl80211_family_id = genl_ctrl_resolve(cmd_sock, "nl80211");\r
    if (info->nl80211_family_id < 0) {\r
        ALOGE("Could not resolve nl80211 familty id");\r
        nl_socket_free(cmd_sock);\r
        nl_socket_free(event_sock);\r
        free(info);\r
        return WIFI_ERROR_UNKNOWN;\r
    }\r
\r
    pthread_mutex_init(&info->cb_lock, NULL);\r
\r
    *handle = (wifi_handle) info;\r
	    ALOGD("wifi_initialize, handle = %p\n", handle);\r
	    ALOGD("wifi_initialize, *handle = %p\n", *handle);\r
		ALOGD("wifi_initialize, info = %p\n", info);\r
		ALOGD("wifi_initialize, *info = %pn", *info);\r
    wifi_add_membership(*handle, "scan");\r
    wifi_add_membership(*handle, "mlme");\r
    wifi_add_membership(*handle, "regulatory");\r
    wifi_add_membership(*handle, "vendor");\r
\r
    wifi_init_interfaces(*handle);\r
     ALOGD("Found %d interfaces", info->num_interfaces);\r
\r
\r
    ALOGI("Initialized Wifi HAL Successfully; vendor cmd = %d", NL80211_CMD_VENDOR);\r
    return WIFI_SUCCESS;\r
}\r
\r
static int wifi_add_membership(wifi_handle handle, const char *group)\r
{\r
    hal_info *info = getHalInfo(handle);\r
\r
    int id = wifi_get_multicast_id(handle, "nl80211", group);\r
    if (id < 0) {\r
        ALOGE("Could not find group %s", group);\r
        return id;\r
    }\r
\r
    int ret = nl_socket_add_membership(info->event_sock, id);\r
    if (ret < 0) {\r
        ALOGE("Could not add membership to group %s", group);\r
    }\r
\r
     ALOGI("Successfully added membership for group %s", group);\r
    return ret;\r
}\r
\r
static void internal_cleaned_up_handler(wifi_handle handle)\r
{\r
    hal_info *info = getHalInfo(handle);\r
    wifi_cleaned_up_handler cleaned_up_handler = info->cleaned_up_handler;\r
\r
    if (info->cmd_sock != 0) {\r
        close(info->cleanup_socks[0]);\r
        close(info->cleanup_socks[1]);\r
        nl_socket_free(info->cmd_sock);\r
        nl_socket_free(info->event_sock);\r
        info->cmd_sock = NULL;\r
        info->event_sock = NULL;\r
    }\r
\r
    (*cleaned_up_handler)(handle);\r
    pthread_mutex_destroy(&info->cb_lock);\r
    free(info);\r
\r
    ALOGI("Internal cleanup completed");\r
}\r
\r
void wifi_cleanup(wifi_handle handle, wifi_cleaned_up_handler handler)\r
{\r
    hal_info *info = getHalInfo(handle);\r
    char buf[64];\r
\r
    info->cleaned_up_handler = handler;\r
    if (write(info->cleanup_socks[0], "Exit", 4) < 1) {\r
        ALOGE("could not write to the cleanup socket");\r
    } else {\r
        // Listen to the response\r
        // Hopefully we dont get errors or get hung up\r
        // Not much can be done in that case, but assume that\r
        // it has rx'ed the Exit message to exit the thread.\r
        // As a fallback set the cleanup flag to TRUE\r
        memset(buf, 0, sizeof(buf));\r
        int result = read(info->cleanup_socks[0], buf, sizeof(buf));\r
        ALOGE("%s: Read after POLL returned %d, error no = %d", __FUNCTION__, result, errno);\r
        if (strncmp(buf, "Done", 4) == 0) {\r
            ALOGE("Event processing terminated");\r
        } else {\r
            ALOGD("Rx'ed %s", buf);\r
        }\r
    }\r
    info->clean_up = true;\r
    pthread_mutex_lock(&info->cb_lock);\r
\r
    int bad_commands = 0;\r
\r
    for (int i = 0; i < info->num_event_cb; i++) {\r
        cb_info *cbi = &(info->event_cb[i]);\r
        WifiCommand *cmd = (WifiCommand *)cbi->cb_arg;\r
    }\r
\r
    while (info->num_cmd > bad_commands) {\r
        int num_cmd = info->num_cmd;\r
        cmd_info *cmdi = &(info->cmd[bad_commands]);\r
        WifiCommand *cmd = cmdi->cmd;\r
        if (cmd != NULL) {\r
            pthread_mutex_unlock(&info->cb_lock);\r
            cmd->cancel();\r
            pthread_mutex_lock(&info->cb_lock);\r
            /* release reference added when command is saved */\r
            cmd->releaseRef();\r
            if (num_cmd == info->num_cmd) {\r
                bad_commands++;\r
            }\r
        }\r
    }\r
\r
    for (int i = 0; i < info->num_event_cb; i++) {\r
        cb_info *cbi = &(info->event_cb[i]);\r
        WifiCommand *cmd = (WifiCommand *)cbi->cb_arg;\r
        ALOGE("Leaked command %p", cmd);\r
    }\r
    pthread_mutex_unlock(&info->cb_lock);\r
    internal_cleaned_up_handler(handle);\r
}\r
\r
static int internal_pollin_handler(wifi_handle handle)\r
{\r
    hal_info *info = getHalInfo(handle);\r
		ALOGI("even_loop info = %p", info);\r
    struct nl_cb *cb = nl_socket_get_cb(info->event_sock);\r
    int res = nl_recvmsgs(info->event_sock, cb);\r
     ALOGD("nl_recvmsgs returned %d", res);\r
    nl_cb_put(cb);\r
    return res;\r
}\r
\r
/* Run event handler */\r
void wifi_event_loop(wifi_handle handle)\r
{\r
    hal_info *info = getHalInfo(handle);\r
	ALOGI("even_loop info = %p", info);\r
	ALOGI("even_loop info = %p", handle);\r
    if (info->in_event_loop) {\r
        return;\r
    } else {\r
        info->in_event_loop = true;\r
    }\r
\r
    pollfd pfd[2];\r
    memset(&pfd[0], 0, sizeof(pollfd) * 2);\r
\r
    pfd[0].fd = nl_socket_get_fd(info->event_sock);\r
    pfd[0].events = POLLIN;\r
    pfd[1].fd = info->cleanup_socks[1];\r
    pfd[1].events = POLLIN;\r
\r
    char buf[2048];\r
\r
    do {\r
        int timeout = -1;                   /* Infinite timeout */\r
        pfd[0].revents = 0;\r
        pfd[1].revents = 0;\r
        int result = poll(pfd, 2, timeout);\r
        if (result < 0) {\r
        } else if (pfd[0].revents & POLLERR) {\r
            ALOGE("POLL Error; error no = %d", errno);\r
            int result2 = read(pfd[0].fd, buf, sizeof(buf));\r
            ALOGE("Read after POLL returned %d, error no = %d", result2, errno);\r
        } else if (pfd[0].revents & POLLHUP) {\r
            ALOGE("Remote side hung up");\r
            break;\r
        } else if (pfd[0].revents & POLLIN) {\r
            internal_pollin_handler(handle);\r
        } else if (pfd[1].revents & POLLIN) {\r
            memset(buf, 0, sizeof(buf));\r
            int result2 = read(pfd[1].fd, buf, sizeof(buf));\r
            ALOGE("%s: Read after POLL returned %d, error no = %d", __FUNCTION__, result2, errno);\r
            if (strncmp(buf, "Exit", 4) == 0) {\r
                ALOGD("Got a signal to exit!!!");\r
                if (write(pfd[1].fd, "Done", 4) < 1) {\r
                    ALOGE("could not write to the cleanup socket");\r
                }\r
                break;\r
            } else {\r
                ALOGD("Rx'ed %s on the cleanup socket\n", buf);\r
            }\r
        } else {\r
            ALOGE("Unknown event - %0x, %0x", pfd[0].revents, pfd[1].revents);\r
        }\r
    } while (!info->clean_up);\r
    ALOGI("Exit %s", __FUNCTION__);\r
}\r
\r
///////////////////////////////////////////////////////////////////////////////////////\r
\r
static int internal_no_seq_check(struct nl_msg *msg, void *arg)\r
{\r
    return NL_OK;\r
}\r
\r
static int internal_valid_message_handler(nl_msg *msg, void *arg)\r
{\r
    wifi_handle handle = (wifi_handle)arg;\r
    hal_info *info = getHalInfo(handle);\r
   ALOGI("even_loop info = %p", handle);\r
   ALOGD("internal_valid_message_handler, info = %p", info);\r
\r
    WifiEvent event(msg);\r
    int res = event.parse();\r
    if (res < 0) {\r
        ALOGE("Failed to parse event: %d", res);\r
        return NL_SKIP;\r
    }\r
\r
    int cmd = event.get_cmd();\r
    uint32_t vendor_id = 0;\r
    int subcmd = 0;\r
\r
    if (cmd == NL80211_CMD_VENDOR) {\r
        vendor_id = event.get_u32(NL80211_ATTR_VENDOR_ID);\r
        subcmd = event.get_u32(NL80211_ATTR_VENDOR_SUBCMD);\r
        ALOGI("event received %s, vendor_id = 0x%0x, subcmd = 0x%0x",\r
                event.get_cmdString(), vendor_id, subcmd);\r
    } else {\r
         ALOGI("event received %s", event.get_cmdString());\r
    }\r
\r
     //ALOGI("event received %s, vendor_id = 0x%0x", event.get_cmdString(), vendor_id);\r
     //event.log();\r
\r
    bool dispatched = false;\r
\r
    pthread_mutex_lock(&info->cb_lock);\r
    \r
    ALOGI("Number of events %d", info->num_event_cb);\r
\r
    for (int i = 0; i < info->num_event_cb; i++) {\r
        if (cmd == info->event_cb[i].nl_cmd) {\r
            if (cmd == NL80211_CMD_VENDOR\r
                && ((vendor_id != info->event_cb[i].vendor_id)\r
                || (subcmd != info->event_cb[i].vendor_subcmd)))\r
            {\r
                /* event for a different vendor, ignore it */\r
                continue;\r
            }\r
\r
            cb_info *cbi = &(info->event_cb[i]);\r
            nl_recvmsg_msg_cb_t cb_func = cbi->cb_func;\r
            void *cb_arg = cbi->cb_arg;\r
            WifiCommand *cmd = (WifiCommand *)cbi->cb_arg;\r
            if (cmd != NULL) {\r
                cmd->addRef();\r
            }\r
\r
            pthread_mutex_unlock(&info->cb_lock);\r
            if (cb_func)\r
                (*cb_func)(msg, cb_arg);\r
            if (cmd != NULL) {\r
                cmd->releaseRef();\r
            }\r
\r
            return NL_OK;\r
        }\r
    }\r
\r
    pthread_mutex_unlock(&info->cb_lock);\r
    return NL_OK;\r
}\r
\r
///////////////////////////////////////////////////////////////////////////////////////\r
\r
class GetMulticastIdCommand : public WifiCommand\r
{\r
private:\r
    const char *mName;\r
    const char *mGroup;\r
    int   mId;\r
public:\r
    GetMulticastIdCommand(wifi_handle handle, const char *name, const char *group)\r
        : WifiCommand(handle, 0)\r
    {\r
        mName = name;\r
        mGroup = group;\r
        mId = -1;\r
    }\r
\r
    int getId() {\r
        return mId;\r
    }\r
\r
    virtual int create() {\r
        int nlctrlFamily = genl_ctrl_resolve(mInfo->cmd_sock, "nlctrl");\r
        ALOGI("ctrl family = %d", nlctrlFamily);\r
        int ret = mMsg.create(nlctrlFamily, CTRL_CMD_GETFAMILY, 0, 0);\r
        if (ret < 0) {\r
            return ret;\r
        }\r
        ret = mMsg.put_string(CTRL_ATTR_FAMILY_NAME, mName);\r
        return ret;\r
    }\r
\r
    virtual int handleResponse(WifiEvent& reply) {\r
\r
         ALOGE("handling reponse in %s", __func__);\r
\r
        struct nlattr **tb = reply.attributes();\r
        struct genlmsghdr *gnlh = reply.header();\r
        struct nlattr *mcgrp = NULL;\r
        int i;\r
\r
        if (!tb[CTRL_ATTR_MCAST_GROUPS]) {\r
            ALOGE("No multicast groups found");\r
            return NL_SKIP;\r
        } else {\r
             ALOGE("Multicast groups attr size = %d", nla_len(tb[CTRL_ATTR_MCAST_GROUPS]));\r
        }\r
\r
        for_each_attr(mcgrp, tb[CTRL_ATTR_MCAST_GROUPS], i) {\r
\r
             ALOGE("Processing group");\r
            struct nlattr *tb2[CTRL_ATTR_MCAST_GRP_MAX + 1];\r
            nla_parse(tb2, CTRL_ATTR_MCAST_GRP_MAX, (nlattr *)nla_data(mcgrp),\r
                nla_len(mcgrp), NULL);\r
            if (!tb2[CTRL_ATTR_MCAST_GRP_NAME] || !tb2[CTRL_ATTR_MCAST_GRP_ID]) {\r
                continue;\r
            }\r
\r
            char *grpName = (char *)nla_data(tb2[CTRL_ATTR_MCAST_GRP_NAME]);\r
            int grpNameLen = nla_len(tb2[CTRL_ATTR_MCAST_GRP_NAME]);\r
\r
             ALOGE("Found group name %s", grpName);\r
\r
            if (strncmp(grpName, mGroup, grpNameLen) != 0)\r
                continue;\r
\r
            mId = nla_get_u32(tb2[CTRL_ATTR_MCAST_GRP_ID]);\r
            break;\r
        }\r
\r
        return NL_SKIP;\r
    }\r
\r
};\r
\r
class SetPnoMacAddrOuiCommand : public WifiCommand {\r
\r
private:\r
    byte *mOui;\r
    feature_set *fset;\r
    feature_set *feature_matrix;\r
    int *fm_size;\r
    int set_size_max;\r
public:\r
    SetPnoMacAddrOuiCommand(wifi_interface_handle handle, oui scan_oui)\r
        : WifiCommand(handle, 0)\r
    {\r
        mOui = scan_oui;\r
    }\r
\r
    int createRequest(WifiRequest& request, int subcmd, byte *scan_oui) {\r
        int result = request.create(GOOGLE_OUI, subcmd);\r
        if (result < 0) {\r
            return result;\r
        }\r
\r
        nlattr *data = request.attr_start(NL80211_ATTR_VENDOR_DATA);\r
        result = request.put(ANDR_WIFI_ATTRIBUTE_PNO_RANDOM_MAC_OUI, scan_oui, DOT11_OUI_LEN);\r
        if (result < 0) {\r
            return result;\r
        }\r
\r
        request.attr_end(data);\r
        return WIFI_SUCCESS;\r
\r
    }\r
\r
    int start() {\r
        ALOGD("Sending mac address OUI");\r
        WifiRequest request(familyId(), ifaceId());\r
        int result = createRequest(request, SLSI_NL80211_VENDOR_SUBCMD_SET_GSCAN_OUI, mOui);\r
        if (result != WIFI_SUCCESS) {\r
            ALOGE("failed to create request; result = %d", result);\r
            return result;\r
        }\r
\r
        result = requestResponse(request);\r
        if (result != WIFI_SUCCESS) {\r
            ALOGE("failed to set scanning mac OUI; result = %d", result);\r
        }\r
\r
        return result;\r
    }\r
protected:\r
    virtual int handleResponse(WifiEvent& reply) {\r
         ALOGD("Request complete!");\r
        /* Nothing to do on response! */\r
        return NL_SKIP;\r
    }\r
};\r
\r
class SetNodfsCommand : public WifiCommand {\r
\r
private:\r
    u32 mNoDfs;\r
public:\r
    SetNodfsCommand(wifi_interface_handle handle, u32 nodfs)\r
        : WifiCommand(handle, 0) {\r
        mNoDfs = nodfs;\r
    }\r
    virtual int create() {\r
        int ret;\r
\r
        ret = mMsg.create(GOOGLE_OUI, SLSI_NL80211_VENDOR_SUBCMD_SET_NODFS);\r
        if (ret < 0) {\r
            ALOGE("Can't create message to send to driver - %d", ret);\r
            return ret;\r
        }\r
\r
        nlattr *data = mMsg.attr_start(NL80211_ATTR_VENDOR_DATA);\r
        ret = mMsg.put_u32(ATTR_NODFS_VALUE, mNoDfs);\r
        if (ret < 0) {\r
             return ret;\r
        }\r
\r
        mMsg.attr_end(data);\r
        return WIFI_SUCCESS;\r
    }\r
};\r
\r
static int wifi_get_multicast_id(wifi_handle handle, const char *name, const char *group)\r
{\r
    GetMulticastIdCommand cmd(handle, name, group);\r
    int res = cmd.requestResponse();\r
    if (res < 0)\r
        return res;\r
    else\r
        return cmd.getId();\r
}\r
\r
/////////////////////////////////////////////////////////////////////////\r
\r
static bool is_wifi_interface(const char *name)\r
{\r
    if (strncmp(name, "wlan", 4) != 0 && strncmp(name, "p2p", 3) != 0) {\r
        /* not a wifi interface; ignore it */\r
        return false;\r
    } else {\r
        return true;\r
    }\r
}\r
\r
static int get_interface(const char *name, interface_info *info)\r
{\r
    strcpy(info->name, name);\r
    info->id = if_nametoindex(name);\r
     ALOGI("found an interface : %s, id = %d", name, info->id);\r
    return WIFI_SUCCESS;\r
}\r
\r
wifi_error wifi_init_interfaces(wifi_handle handle)\r
{\r
    hal_info *info = (hal_info *)handle;\r
	ALOGD("wifi_init_interfaces, info = %p", info);\r
\r
    struct dirent *de;\r
\r
    DIR *d = opendir("/sys/class/net");\r
    if (d == 0)\r
        return WIFI_ERROR_UNKNOWN;\r
\r
    int n = 0;\r
    while ((de = readdir(d))) {\r
        if (de->d_name[0] == '.')\r
            continue;\r
        if (is_wifi_interface(de->d_name) ) {\r
            n++;\r
        }\r
    }\r
\r
    closedir(d);\r
\r
    d = opendir("/sys/class/net");\r
    if (d == 0)\r
        return WIFI_ERROR_UNKNOWN;\r
\r
    info->interfaces = (interface_info **)malloc(sizeof(interface_info *) * n);\r
\r
    int i = 0;\r
    while ((de = readdir(d))) {\r
        if (de->d_name[0] == '.')\r
            continue;\r
        if (is_wifi_interface(de->d_name)) {\r
            interface_info *ifinfo = (interface_info *)malloc(sizeof(interface_info));\r
            if (get_interface(de->d_name, ifinfo) != WIFI_SUCCESS) {\r
                free(ifinfo);\r
                continue;\r
            }\r
            ifinfo->handle = handle;\r
            info->interfaces[i] = ifinfo;\r
            i++;\r
        }\r
    }\r
\r
    closedir(d);\r
\r
    info->num_interfaces = n;\r
    return WIFI_SUCCESS;\r
}\r
\r
wifi_error wifi_get_ifaces(wifi_handle handle, int *num, wifi_interface_handle **interfaces)\r
{\r
    hal_info *info = (hal_info *)handle;\r
\r
    *interfaces = (wifi_interface_handle *)info->interfaces;\r
    *num = info->num_interfaces;\r
\r
    return WIFI_SUCCESS;\r
}\r
\r
wifi_error wifi_get_iface_name(wifi_interface_handle handle, char *name, size_t size)\r
{\r
    interface_info *info = (interface_info *)handle;\r
    strcpy(name, info->name);\r
    return WIFI_SUCCESS;\r
}\r
\r
wifi_error wifi_get_supported_feature_set(wifi_interface_handle handle, feature_set *set)\r
{\r
    return WIFI_ERROR_NOT_SUPPORTED;\r
}\r
\r
wifi_error wifi_get_concurrency_matrix(wifi_interface_handle handle, int set_size_max,\r
       feature_set set[], int *set_size)\r
{\r
    return WIFI_ERROR_NOT_SUPPORTED;\r
}\r
\r
wifi_error wifi_set_scanning_mac_oui(wifi_interface_handle handle, oui scan_oui)\r
{\r
    SetPnoMacAddrOuiCommand command(handle, scan_oui);\r
    return (wifi_error)command.start();\r
\r
}\r
\r
wifi_error wifi_set_nodfs_flag(wifi_interface_handle handle, u32 nodfs)\r
{\r
    SetNodfsCommand command(handle, nodfs);\r
    return (wifi_error) command.requestResponse();\r
}\r
\r
/////////////////////////////////////////////////////////////////////////////\r