-\r
-#include <stdlib.h>\r
-#include <netlink/object-api.h>\r
-#include <netlink/handlers.h>\r
-\r
-#include "wifi_hal.h"\r
-#include "common.h"\r
-\r
-interface_info *getIfaceInfo(wifi_interface_handle handle)\r
-{\r
- return (interface_info *)handle;\r
-}\r
-\r
-wifi_handle getWifiHandle(wifi_interface_handle handle)\r
-{\r
- return getIfaceInfo(handle)->handle;\r
-}\r
-\r
-hal_info *getHalInfo(wifi_handle handle)\r
-{\r
- return (hal_info *)handle;\r
-}\r
-\r
-hal_info *getHalInfo(wifi_interface_handle handle)\r
-{\r
- return getHalInfo(getWifiHandle(handle));\r
-}\r
-\r
-wifi_handle getWifiHandle(hal_info *info)\r
-{\r
- return (wifi_handle)info;\r
-}\r
-\r
-wifi_interface_handle getIfaceHandle(interface_info *info)\r
-{\r
- return (wifi_interface_handle)info;\r
-}\r
-\r
-wifi_error wifi_register_handler(wifi_handle handle, int cmd, nl_recvmsg_msg_cb_t func, void *arg)\r
-{\r
- hal_info *info = (hal_info *)handle;\r
-\r
- /* TODO: check for multiple handlers? */\r
- pthread_mutex_lock(&info->cb_lock);\r
-\r
- wifi_error result = WIFI_ERROR_OUT_OF_MEMORY;\r
-\r
- if (info->num_event_cb < info->alloc_event_cb) {\r
- info->event_cb[info->num_event_cb].nl_cmd = cmd;\r
- info->event_cb[info->num_event_cb].vendor_id = 0;\r
- info->event_cb[info->num_event_cb].vendor_subcmd = 0;\r
- info->event_cb[info->num_event_cb].cb_func = func;\r
- info->event_cb[info->num_event_cb].cb_arg = arg;\r
- ALOGI("Successfully added event handler %p:%p for command %d at %d",\r
- arg, func, cmd, info->num_event_cb);\r
- info->num_event_cb++;\r
- result = WIFI_SUCCESS;\r
- }\r
-\r
- pthread_mutex_unlock(&info->cb_lock);\r
- return result;\r
-}\r
-\r
-wifi_error wifi_register_vendor_handler(wifi_handle handle,\r
- uint32_t id, int subcmd, nl_recvmsg_msg_cb_t func, void *arg)\r
-{\r
- hal_info *info = (hal_info *)handle;\r
-\r
-//ALOGD("GSCAN register handle wifi_register_vendor_handler %p", handle);\r
- /* TODO: check for multiple handlers? */\r
- pthread_mutex_lock(&info->cb_lock);\r
- ALOGI("Added event handler %p", info);\r
-\r
- wifi_error result = WIFI_ERROR_OUT_OF_MEMORY;\r
-\r
- // ALOGD("register_vendor_handler: handle = %p", handle);\r
- if (info->num_event_cb < info->alloc_event_cb) {\r
- info->event_cb[info->num_event_cb].nl_cmd = NL80211_CMD_VENDOR;\r
- info->event_cb[info->num_event_cb].vendor_id = id;\r
- info->event_cb[info->num_event_cb].vendor_subcmd = subcmd;\r
- info->event_cb[info->num_event_cb].cb_func = func;\r
- info->event_cb[info->num_event_cb].cb_arg = arg;\r
- ALOGI("Added event handler %p:%p for vendor 0x%0x and subcmd 0x%0x at %d",\r
- arg, func, id, subcmd, info->num_event_cb);\r
- info->num_event_cb++;\r
- result = WIFI_SUCCESS;\r
- }\r
-\r
- pthread_mutex_unlock(&info->cb_lock);\r
- return result;\r
-}\r
-\r
-void wifi_unregister_handler(wifi_handle handle, int cmd)\r
-{\r
- hal_info *info = (hal_info *)handle;\r
-\r
- if (cmd == NL80211_CMD_VENDOR) {\r
- ALOGE("Must use wifi_unregister_vendor_handler to remove vendor handlers");\r
- return;\r
- }\r
-\r
- pthread_mutex_lock(&info->cb_lock);\r
-\r
- for (int i = 0; i < info->num_event_cb; i++) {\r
- if (info->event_cb[i].nl_cmd == cmd) {\r
- ALOGI("Successfully removed event handler %p:%p for cmd = 0x%0x from %d",\r
- info->event_cb[i].cb_arg, info->event_cb[i].cb_func, cmd, i);\r
-\r
- memmove(&info->event_cb[i], &info->event_cb[i+1],\r
- (info->num_event_cb - i - 1) * sizeof(cb_info));\r
- info->num_event_cb--;\r
- break;\r
- }\r
- }\r
-\r
- pthread_mutex_unlock(&info->cb_lock);\r
-}\r
-\r
-void wifi_unregister_vendor_handler(wifi_handle handle, uint32_t id, int subcmd)\r
-{\r
- hal_info *info = (hal_info *)handle;\r
-\r
- pthread_mutex_lock(&info->cb_lock);\r
-\r
- for (int i = 0; i < info->num_event_cb; i++) {\r
-\r
- if (info->event_cb[i].nl_cmd == NL80211_CMD_VENDOR\r
- && info->event_cb[i].vendor_id == id\r
- && info->event_cb[i].vendor_subcmd == subcmd) {\r
- ALOGI("Successfully removed event handler %p:%p for vendor 0x%0x, subcmd 0x%0x from %d",\r
- info->event_cb[i].cb_arg, info->event_cb[i].cb_func, id, subcmd, i);\r
- memmove(&info->event_cb[i], &info->event_cb[i+1],\r
- (info->num_event_cb - i - 1) * sizeof(cb_info));\r
- info->num_event_cb--;\r
- break;\r
- }\r
- }\r
-\r
- pthread_mutex_unlock(&info->cb_lock);\r
-}\r
-\r
-\r
-wifi_error wifi_register_cmd(wifi_handle handle, int id, WifiCommand *cmd)\r
-{\r
- hal_info *info = (hal_info *)handle;\r
-\r
- ALOGD("registering command %d", id);\r
-\r
- wifi_error result = WIFI_ERROR_OUT_OF_MEMORY;\r
-\r
- if (info->num_cmd < info->alloc_cmd) {\r
- info->cmd[info->num_cmd].id = id;\r
- info->cmd[info->num_cmd].cmd = cmd;\r
- ALOGI("Successfully added command %d: %p at %d", id, cmd, info->num_cmd);\r
- info->num_cmd++;\r
- result = WIFI_SUCCESS;\r
- }\r
-\r
- return result;\r
-}\r
-\r
-WifiCommand *wifi_unregister_cmd(wifi_handle handle, int id)\r
-{\r
- hal_info *info = (hal_info *)handle;\r
-\r
- ALOGD("un-registering command %d", id);\r
-\r
- WifiCommand *cmd = NULL;\r
-\r
- for (int i = 0; i < info->num_cmd; i++) {\r
- if (info->cmd[i].id == id) {\r
- cmd = info->cmd[i].cmd;\r
- memmove(&info->cmd[i], &info->cmd[i+1], (info->num_cmd - i) * sizeof(cmd_info));\r
- info->num_cmd--;\r
- ALOGI("Successfully removed command %d: %p from %d", id, cmd, i);\r
- break;\r
- }\r
- }\r
-\r
- return cmd;\r
-}\r
-\r
-WifiCommand *wifi_get_cmd(wifi_handle handle, int id)\r
-{\r
- hal_info *info = (hal_info *)handle;\r
-\r
- WifiCommand *cmd = NULL;\r
-\r
- for (int i = 0; i < info->num_cmd; i++) {\r
- if (info->cmd[i].id == id) {\r
- cmd = info->cmd[i].cmd;\r
- break;\r
- }\r
- }\r
-\r
- return cmd;\r
-}\r
-\r
-void wifi_unregister_cmd(wifi_handle handle, WifiCommand *cmd)\r
-{\r
- hal_info *info = (hal_info *)handle;\r
-\r
- for (int i = 0; i < info->num_cmd; i++) {\r
- if (info->cmd[i].cmd == cmd) {\r
- int id = info->cmd[i].id;\r
- memmove(&info->cmd[i], &info->cmd[i+1], (info->num_cmd - i) * sizeof(cmd_info));\r
- info->num_cmd--;\r
- ALOGI("Successfully removed command %d: %p from %d", id, cmd, i);\r
- break;\r
- }\r
- }\r
-}\r
+
+#include <stdlib.h>
+#include <netlink/object-api.h>
+#include <netlink/handlers.h>
+
+#include "wifi_hal.h"
+#include "common.h"
+
+interface_info *getIfaceInfo(wifi_interface_handle handle)
+{
+ return (interface_info *)handle;
+}
+
+wifi_handle getWifiHandle(wifi_interface_handle handle)
+{
+ return getIfaceInfo(handle)->handle;
+}
+
+hal_info *getHalInfo(wifi_handle handle)
+{
+ return (hal_info *)handle;
+}
+
+hal_info *getHalInfo(wifi_interface_handle handle)
+{
+ return getHalInfo(getWifiHandle(handle));
+}
+
+wifi_handle getWifiHandle(hal_info *info)
+{
+ return (wifi_handle)info;
+}
+
+wifi_interface_handle getIfaceHandle(interface_info *info)
+{
+ return (wifi_interface_handle)info;
+}
+
+wifi_error wifi_register_handler(wifi_handle handle, int cmd, nl_recvmsg_msg_cb_t func, void *arg)
+{
+ hal_info *info = (hal_info *)handle;
+
+ /* TODO: check for multiple handlers? */
+ pthread_mutex_lock(&info->cb_lock);
+
+ wifi_error result = WIFI_ERROR_OUT_OF_MEMORY;
+
+ if (info->num_event_cb < info->alloc_event_cb) {
+ info->event_cb[info->num_event_cb].nl_cmd = cmd;
+ info->event_cb[info->num_event_cb].vendor_id = 0;
+ info->event_cb[info->num_event_cb].vendor_subcmd = 0;
+ info->event_cb[info->num_event_cb].cb_func = func;
+ info->event_cb[info->num_event_cb].cb_arg = arg;
+ ALOGI("Successfully added event handler %p:%p for command %d at %d",
+ arg, func, cmd, info->num_event_cb);
+ info->num_event_cb++;
+ result = WIFI_SUCCESS;
+ }
+
+ pthread_mutex_unlock(&info->cb_lock);
+ return result;
+}
+
+wifi_error wifi_register_vendor_handler(wifi_handle handle,
+ uint32_t id, int subcmd, nl_recvmsg_msg_cb_t func, void *arg)
+{
+ hal_info *info = (hal_info *)handle;
+
+//ALOGD("GSCAN register handle wifi_register_vendor_handler %p", handle);
+ /* TODO: check for multiple handlers? */
+ pthread_mutex_lock(&info->cb_lock);
+ ALOGI("Added event handler %p", info);
+
+ wifi_error result = WIFI_ERROR_OUT_OF_MEMORY;
+
+ // ALOGD("register_vendor_handler: handle = %p", handle);
+ if (info->num_event_cb < info->alloc_event_cb) {
+ info->event_cb[info->num_event_cb].nl_cmd = NL80211_CMD_VENDOR;
+ info->event_cb[info->num_event_cb].vendor_id = id;
+ info->event_cb[info->num_event_cb].vendor_subcmd = subcmd;
+ info->event_cb[info->num_event_cb].cb_func = func;
+ info->event_cb[info->num_event_cb].cb_arg = arg;
+ ALOGI("Added event handler %p:%p for vendor 0x%0x and subcmd 0x%0x at %d",
+ arg, func, id, subcmd, info->num_event_cb);
+ info->num_event_cb++;
+ result = WIFI_SUCCESS;
+ }
+
+ pthread_mutex_unlock(&info->cb_lock);
+ return result;
+}
+
+void wifi_unregister_handler(wifi_handle handle, int cmd)
+{
+ hal_info *info = (hal_info *)handle;
+
+ if (cmd == NL80211_CMD_VENDOR) {
+ ALOGE("Must use wifi_unregister_vendor_handler to remove vendor handlers");
+ return;
+ }
+
+ pthread_mutex_lock(&info->cb_lock);
+
+ for (int i = 0; i < info->num_event_cb; i++) {
+ if (info->event_cb[i].nl_cmd == cmd) {
+ ALOGI("Successfully removed event handler %p:%p for cmd = 0x%0x from %d",
+ info->event_cb[i].cb_arg, info->event_cb[i].cb_func, cmd, i);
+
+ memmove(&info->event_cb[i], &info->event_cb[i+1],
+ (info->num_event_cb - i - 1) * sizeof(cb_info));
+ info->num_event_cb--;
+ break;
+ }
+ }
+
+ pthread_mutex_unlock(&info->cb_lock);
+}
+
+void wifi_unregister_vendor_handler(wifi_handle handle, uint32_t id, int subcmd)
+{
+ hal_info *info = (hal_info *)handle;
+
+ pthread_mutex_lock(&info->cb_lock);
+
+ for (int i = 0; i < info->num_event_cb; i++) {
+
+ if (info->event_cb[i].nl_cmd == NL80211_CMD_VENDOR
+ && info->event_cb[i].vendor_id == id
+ && info->event_cb[i].vendor_subcmd == subcmd) {
+ ALOGI("Successfully removed event handler %p:%p for vendor 0x%0x, subcmd 0x%0x from %d",
+ info->event_cb[i].cb_arg, info->event_cb[i].cb_func, id, subcmd, i);
+ memmove(&info->event_cb[i], &info->event_cb[i+1],
+ (info->num_event_cb - i - 1) * sizeof(cb_info));
+ info->num_event_cb--;
+ break;
+ }
+ }
+
+ pthread_mutex_unlock(&info->cb_lock);
+}
+
+
+wifi_error wifi_register_cmd(wifi_handle handle, int id, WifiCommand *cmd)
+{
+ hal_info *info = (hal_info *)handle;
+
+ ALOGD("registering command %d", id);
+
+ wifi_error result = WIFI_ERROR_OUT_OF_MEMORY;
+
+ if (info->num_cmd < info->alloc_cmd) {
+ info->cmd[info->num_cmd].id = id;
+ info->cmd[info->num_cmd].cmd = cmd;
+ ALOGI("Successfully added command %d: %p at %d", id, cmd, info->num_cmd);
+ info->num_cmd++;
+ result = WIFI_SUCCESS;
+ }
+
+ return result;
+}
+
+WifiCommand *wifi_unregister_cmd(wifi_handle handle, int id)
+{
+ hal_info *info = (hal_info *)handle;
+
+ ALOGD("un-registering command %d", id);
+
+ WifiCommand *cmd = NULL;
+
+ for (int i = 0; i < info->num_cmd; i++) {
+ if (info->cmd[i].id == id) {
+ cmd = info->cmd[i].cmd;
+ memmove(&info->cmd[i], &info->cmd[i+1], (info->num_cmd - i) * sizeof(cmd_info));
+ info->num_cmd--;
+ ALOGI("Successfully removed command %d: %p from %d", id, cmd, i);
+ break;
+ }
+ }
+
+ return cmd;
+}
+
+WifiCommand *wifi_get_cmd(wifi_handle handle, int id)
+{
+ hal_info *info = (hal_info *)handle;
+
+ WifiCommand *cmd = NULL;
+
+ for (int i = 0; i < info->num_cmd; i++) {
+ if (info->cmd[i].id == id) {
+ cmd = info->cmd[i].cmd;
+ break;
+ }
+ }
+
+ return cmd;
+}
+
+void wifi_unregister_cmd(wifi_handle handle, WifiCommand *cmd)
+{
+ hal_info *info = (hal_info *)handle;
+
+ for (int i = 0; i < info->num_cmd; i++) {
+ if (info->cmd[i].cmd == cmd) {
+ int id = info->cmd[i].id;
+ memmove(&info->cmd[i], &info->cmd[i+1], (info->num_cmd - i) * sizeof(cmd_info));
+ info->num_cmd--;
+ ALOGI("Successfully removed command %d: %p from %d", id, cmd, i);
+ break;
+ }
+ }
+}
-\r
-#include "wifi_hal.h"\r
-\r
-#ifndef __WIFI_HAL_COMMON_H__\r
-#define __WIFI_HAL_COMMON_H__\r
-\r
-#define LOG_TAG "WifiHAL"\r
-\r
-#include <utils/Log.h>\r
-#include "nl80211_copy.h"\r
-#include "sync.h"\r
-\r
-#define SOCKET_BUFFER_SIZE (32768U)\r
-#define RECV_BUF_SIZE (4096)\r
-#define DEFAULT_EVENT_CB_SIZE (64)\r
-#define DEFAULT_CMD_SIZE (64)\r
-#define DOT11_OUI_LEN 3\r
-\r
-/*\r
- Vendor OUI - This is a unique identifier that identifies organization. Lets\r
- code Android specific functions with Google OUI; although vendors can do more\r
- with their own OUI's as well.\r
- */\r
-\r
-const uint32_t GOOGLE_OUI = 0x001A11;\r
-/* TODO: define vendor OUI here */\r
-\r
-\r
-/*\r
- This enum defines ranges for various commands; commands themselves\r
- can be defined in respective feature headers; i.e. find gscan command\r
- definitions in gscan.cpp\r
- */\r
-\r
-typedef enum {\r
- /* don't use 0 as a valid subcommand */\r
- VENDOR_NL80211_SUBCMD_UNSPECIFIED,\r
-\r
- /* define all vendor startup commands between 0x0 and 0x0FFF */\r
- VENDOR_NL80211_SUBCMD_RANGE_START = 0x0001,\r
- VENDOR_NL80211_SUBCMD_RANGE_END = 0x0FFF,\r
-\r
- /* define all GScan related commands between 0x1000 and 0x10FF */\r
- ANDROID_NL80211_SUBCMD_GSCAN_RANGE_START = 0x1000,\r
- ANDROID_NL80211_SUBCMD_GSCAN_RANGE_END = 0x10FF,\r
-\r
- /* define all NearbyDiscovery related commands between 0x1100 and 0x11FF */\r
- ANDROID_NL80211_SUBCMD_NBD_RANGE_START = 0x1100,\r
- ANDROID_NL80211_SUBCMD_NBD_RANGE_END = 0x11FF,\r
-\r
- /* define all RTT related commands between 0x1100 and 0x11FF */\r
- ANDROID_NL80211_SUBCMD_RTT_RANGE_START = 0x1100,\r
- ANDROID_NL80211_SUBCMD_RTT_RANGE_END = 0x11FF,\r
-\r
- ANDROID_NL80211_SUBCMD_LSTATS_RANGE_START = 0x1200,\r
- ANDROID_NL80211_SUBCMD_LSTATS_RANGE_END = 0x12FF,\r
-\r
- /* This is reserved for future usage */\r
-\r
-} ANDROID_VENDOR_SUB_COMMAND;\r
-\r
-typedef enum {\r
- SLSI_NL80211_VENDOR_SUBCMD_GET_CAPABILITIES = ANDROID_NL80211_SUBCMD_GSCAN_RANGE_START,\r
- SLSI_NL80211_VENDOR_SUBCMD_GET_VALID_CHANNELS,\r
- SLSI_NL80211_VENDOR_SUBCMD_ADD_GSCAN,\r
- SLSI_NL80211_VENDOR_SUBCMD_DEL_GSCAN,\r
- SLSI_NL80211_VENDOR_SUBCMD_GET_SCAN_RESULTS,\r
- SLSI_NL80211_VENDOR_SUBCMD_SET_BSSID_HOTLIST,\r
- SLSI_NL80211_VENDOR_SUBCMD_RESET_BSSID_HOTLIST,\r
- SLSI_NL80211_VENDOR_SUBCMD_GET_HOTLIST_RESULTS,\r
- SLSI_NL80211_VENDOR_SUBCMD_SET_SIGNIFICANT_CHANGE,\r
- SLSI_NL80211_VENDOR_SUBCMD_RESET_SIGNIFICANT_CHANGE,\r
- SLSI_NL80211_VENDOR_SUBCMD_SET_GSCAN_OUI,\r
- SLSI_NL80211_VENDOR_SUBCMD_SET_NODFS\r
-} WIFI_SUB_COMMAND;\r
-\r
-typedef enum {\r
- GSCAN_EVENT_SIGNIFICANT_CHANGE_RESULTS ,\r
- GSCAN_EVENT_HOTLIST_RESULTS_FOUND,\r
- GSCAN_EVENT_SCAN_RESULTS_AVAILABLE,\r
- GSCAN_EVENT_FULL_SCAN_RESULTS,\r
- GSCAN_EVENT_COMPLETE_SCAN,\r
- GSCAN_EVENT_HOTLIST_RESULTS_LOST\r
-} WIFI_EVENT;\r
-\r
-typedef void (*wifi_internal_event_handler) (wifi_handle handle, int events);\r
-\r
-class WifiCommand;\r
-\r
-typedef struct {\r
- int nl_cmd;\r
- uint32_t vendor_id;\r
- int vendor_subcmd;\r
- nl_recvmsg_msg_cb_t cb_func;\r
- void *cb_arg;\r
-} cb_info;\r
-\r
-typedef struct {\r
- wifi_request_id id;\r
- WifiCommand *cmd;\r
-} cmd_info;\r
-\r
-typedef struct {\r
- wifi_handle handle; // handle to wifi data\r
- char name[8+1]; // interface name + trailing null\r
- int id; // id to use when talking to driver\r
-} interface_info;\r
-\r
-typedef struct {\r
-\r
- struct nl_sock *cmd_sock; // command socket object\r
- struct nl_sock *event_sock; // event socket object\r
- int nl80211_family_id; // family id for 80211 driver\r
- int cleanup_socks[2]; // sockets used to implement wifi_cleanup\r
-\r
- bool in_event_loop; // Indicates that event loop is active\r
- bool clean_up; // Indication to clean up the socket\r
-\r
- wifi_internal_event_handler event_handler; // default event handler\r
- wifi_cleaned_up_handler cleaned_up_handler; // socket cleaned up handler\r
-\r
- cb_info *event_cb; // event callbacks\r
- int num_event_cb; // number of event callbacks\r
- int alloc_event_cb; // number of allocated callback objects\r
- pthread_mutex_t cb_lock; // mutex for the event_cb access\r
-\r
- cmd_info *cmd; // Outstanding commands\r
- int num_cmd; // number of commands\r
- int alloc_cmd; // number of commands allocated\r
-\r
- interface_info **interfaces; // array of interfaces\r
- int num_interfaces; // number of interfaces\r
-\r
-\r
- // add other details\r
-} hal_info;\r
-\r
-wifi_error wifi_register_handler(wifi_handle handle, int cmd, nl_recvmsg_msg_cb_t func, void *arg);\r
-wifi_error wifi_register_vendor_handler(wifi_handle handle,\r
- uint32_t id, int subcmd, nl_recvmsg_msg_cb_t func, void *arg);\r
-\r
-void wifi_unregister_handler(wifi_handle handle, int cmd);\r
-void wifi_unregister_vendor_handler(wifi_handle handle, uint32_t id, int subcmd);\r
-\r
-wifi_error wifi_register_cmd(wifi_handle handle, int id, WifiCommand *cmd);\r
-WifiCommand *wifi_unregister_cmd(wifi_handle handle, int id);\r
-WifiCommand *wifi_get_cmd(wifi_handle handle, int id);\r
-void wifi_unregister_cmd(wifi_handle handle, WifiCommand *cmd);\r
-\r
-interface_info *getIfaceInfo(wifi_interface_handle);\r
-wifi_handle getWifiHandle(wifi_interface_handle handle);\r
-hal_info *getHalInfo(wifi_handle handle);\r
-hal_info *getHalInfo(wifi_interface_handle handle);\r
-wifi_handle getWifiHandle(hal_info *info);\r
-wifi_interface_handle getIfaceHandle(interface_info *info);\r
-\r
-\r
-// some common macros\r
-\r
-#define min(x, y) ((x) < (y) ? (x) : (y))\r
-#define max(x, y) ((x) > (y) ? (x) : (y))\r
-\r
-#endif\r
-\r
+
+#include "wifi_hal.h"
+
+#ifndef __WIFI_HAL_COMMON_H__
+#define __WIFI_HAL_COMMON_H__
+
+#define LOG_TAG "WifiHAL"
+
+#include <utils/Log.h>
+#include "nl80211_copy.h"
+#include "sync.h"
+
+#define SOCKET_BUFFER_SIZE (32768U)
+#define RECV_BUF_SIZE (4096)
+#define DEFAULT_EVENT_CB_SIZE (64)
+#define DEFAULT_CMD_SIZE (64)
+#define DOT11_OUI_LEN 3
+
+/*
+ Vendor OUI - This is a unique identifier that identifies organization. Lets
+ code Android specific functions with Google OUI; although vendors can do more
+ with their own OUI's as well.
+ */
+
+const uint32_t GOOGLE_OUI = 0x001A11;
+/* TODO: define vendor OUI here */
+
+
+/*
+ This enum defines ranges for various commands; commands themselves
+ can be defined in respective feature headers; i.e. find gscan command
+ definitions in gscan.cpp
+ */
+
+typedef enum {
+ /* don't use 0 as a valid subcommand */
+ VENDOR_NL80211_SUBCMD_UNSPECIFIED,
+
+ /* define all vendor startup commands between 0x0 and 0x0FFF */
+ VENDOR_NL80211_SUBCMD_RANGE_START = 0x0001,
+ VENDOR_NL80211_SUBCMD_RANGE_END = 0x0FFF,
+
+ /* define all GScan related commands between 0x1000 and 0x10FF */
+ ANDROID_NL80211_SUBCMD_GSCAN_RANGE_START = 0x1000,
+ ANDROID_NL80211_SUBCMD_GSCAN_RANGE_END = 0x10FF,
+
+ /* define all NearbyDiscovery related commands between 0x1100 and 0x11FF */
+ ANDROID_NL80211_SUBCMD_NBD_RANGE_START = 0x1100,
+ ANDROID_NL80211_SUBCMD_NBD_RANGE_END = 0x11FF,
+
+ /* define all RTT related commands between 0x1100 and 0x11FF */
+ ANDROID_NL80211_SUBCMD_RTT_RANGE_START = 0x1100,
+ ANDROID_NL80211_SUBCMD_RTT_RANGE_END = 0x11FF,
+
+ ANDROID_NL80211_SUBCMD_LSTATS_RANGE_START = 0x1200,
+ ANDROID_NL80211_SUBCMD_LSTATS_RANGE_END = 0x12FF,
+
+ /* This is reserved for future usage */
+
+} ANDROID_VENDOR_SUB_COMMAND;
+
+typedef enum {
+ SLSI_NL80211_VENDOR_SUBCMD_GET_CAPABILITIES = ANDROID_NL80211_SUBCMD_GSCAN_RANGE_START,
+ SLSI_NL80211_VENDOR_SUBCMD_GET_VALID_CHANNELS,
+ SLSI_NL80211_VENDOR_SUBCMD_ADD_GSCAN,
+ SLSI_NL80211_VENDOR_SUBCMD_DEL_GSCAN,
+ SLSI_NL80211_VENDOR_SUBCMD_GET_SCAN_RESULTS,
+ SLSI_NL80211_VENDOR_SUBCMD_SET_BSSID_HOTLIST,
+ SLSI_NL80211_VENDOR_SUBCMD_RESET_BSSID_HOTLIST,
+ SLSI_NL80211_VENDOR_SUBCMD_GET_HOTLIST_RESULTS,
+ SLSI_NL80211_VENDOR_SUBCMD_SET_SIGNIFICANT_CHANGE,
+ SLSI_NL80211_VENDOR_SUBCMD_RESET_SIGNIFICANT_CHANGE,
+ SLSI_NL80211_VENDOR_SUBCMD_SET_GSCAN_OUI,
+ SLSI_NL80211_VENDOR_SUBCMD_SET_NODFS
+} WIFI_SUB_COMMAND;
+
+typedef enum {
+ GSCAN_EVENT_SIGNIFICANT_CHANGE_RESULTS ,
+ GSCAN_EVENT_HOTLIST_RESULTS_FOUND,
+ GSCAN_EVENT_SCAN_RESULTS_AVAILABLE,
+ GSCAN_EVENT_FULL_SCAN_RESULTS,
+ GSCAN_EVENT_COMPLETE_SCAN,
+ GSCAN_EVENT_HOTLIST_RESULTS_LOST
+} WIFI_EVENT;
+
+typedef void (*wifi_internal_event_handler) (wifi_handle handle, int events);
+
+class WifiCommand;
+
+typedef struct {
+ int nl_cmd;
+ uint32_t vendor_id;
+ int vendor_subcmd;
+ nl_recvmsg_msg_cb_t cb_func;
+ void *cb_arg;
+} cb_info;
+
+typedef struct {
+ wifi_request_id id;
+ WifiCommand *cmd;
+} cmd_info;
+
+typedef struct {
+ wifi_handle handle; // handle to wifi data
+ char name[8+1]; // interface name + trailing null
+ int id; // id to use when talking to driver
+} interface_info;
+
+typedef struct {
+
+ struct nl_sock *cmd_sock; // command socket object
+ struct nl_sock *event_sock; // event socket object
+ int nl80211_family_id; // family id for 80211 driver
+ int cleanup_socks[2]; // sockets used to implement wifi_cleanup
+
+ bool in_event_loop; // Indicates that event loop is active
+ bool clean_up; // Indication to clean up the socket
+
+ wifi_internal_event_handler event_handler; // default event handler
+ wifi_cleaned_up_handler cleaned_up_handler; // socket cleaned up handler
+
+ cb_info *event_cb; // event callbacks
+ int num_event_cb; // number of event callbacks
+ int alloc_event_cb; // number of allocated callback objects
+ pthread_mutex_t cb_lock; // mutex for the event_cb access
+
+ cmd_info *cmd; // Outstanding commands
+ int num_cmd; // number of commands
+ int alloc_cmd; // number of commands allocated
+
+ interface_info **interfaces; // array of interfaces
+ int num_interfaces; // number of interfaces
+
+
+ // add other details
+} hal_info;
+
+wifi_error wifi_register_handler(wifi_handle handle, int cmd, nl_recvmsg_msg_cb_t func, void *arg);
+wifi_error wifi_register_vendor_handler(wifi_handle handle,
+ uint32_t id, int subcmd, nl_recvmsg_msg_cb_t func, void *arg);
+
+void wifi_unregister_handler(wifi_handle handle, int cmd);
+void wifi_unregister_vendor_handler(wifi_handle handle, uint32_t id, int subcmd);
+
+wifi_error wifi_register_cmd(wifi_handle handle, int id, WifiCommand *cmd);
+WifiCommand *wifi_unregister_cmd(wifi_handle handle, int id);
+WifiCommand *wifi_get_cmd(wifi_handle handle, int id);
+void wifi_unregister_cmd(wifi_handle handle, WifiCommand *cmd);
+
+interface_info *getIfaceInfo(wifi_interface_handle);
+wifi_handle getWifiHandle(wifi_interface_handle handle);
+hal_info *getHalInfo(wifi_handle handle);
+hal_info *getHalInfo(wifi_interface_handle handle);
+wifi_handle getWifiHandle(hal_info *info);
+wifi_interface_handle getIfaceHandle(interface_info *info);
+
+
+// some common macros
+
+#define min(x, y) ((x) < (y) ? (x) : (y))
+#define max(x, y) ((x) > (y) ? (x) : (y))
+
+#endif
+
-\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/handlers.h>\r
-#include <stdarg.h>\r
-\r
-#include <ctype.h>\r
-\r
-#include "wifi_hal.h"\r
-#include "common.h"\r
-#include "cpp_bindings.h"\r
-\r
-void appendFmt(char *buf, int &offset, const char *fmt, ...)\r
-{\r
- va_list params;\r
- va_start(params, fmt);\r
- offset += vsprintf(buf + offset, fmt, params);\r
- va_end(params);\r
-}\r
-\r
-#define C2S(x) case x: return #x;\r
-\r
-static const char *cmdToString(int cmd)\r
-{\r
- switch (cmd) {\r
- C2S(NL80211_CMD_UNSPEC)\r
- C2S(NL80211_CMD_GET_WIPHY)\r
- C2S(NL80211_CMD_SET_WIPHY)\r
- C2S(NL80211_CMD_NEW_WIPHY)\r
- C2S(NL80211_CMD_DEL_WIPHY)\r
- C2S(NL80211_CMD_GET_INTERFACE)\r
- C2S(NL80211_CMD_SET_INTERFACE)\r
- C2S(NL80211_CMD_NEW_INTERFACE)\r
- C2S(NL80211_CMD_DEL_INTERFACE)\r
- C2S(NL80211_CMD_GET_KEY)\r
- C2S(NL80211_CMD_SET_KEY)\r
- C2S(NL80211_CMD_NEW_KEY)\r
- C2S(NL80211_CMD_DEL_KEY)\r
- C2S(NL80211_CMD_GET_BEACON)\r
- C2S(NL80211_CMD_SET_BEACON)\r
- C2S(NL80211_CMD_START_AP)\r
- C2S(NL80211_CMD_STOP_AP)\r
- C2S(NL80211_CMD_GET_STATION)\r
- C2S(NL80211_CMD_SET_STATION)\r
- C2S(NL80211_CMD_NEW_STATION)\r
- C2S(NL80211_CMD_DEL_STATION)\r
- C2S(NL80211_CMD_GET_MPATH)\r
- C2S(NL80211_CMD_SET_MPATH)\r
- C2S(NL80211_CMD_NEW_MPATH)\r
- C2S(NL80211_CMD_DEL_MPATH)\r
- C2S(NL80211_CMD_SET_BSS)\r
- C2S(NL80211_CMD_SET_REG)\r
- C2S(NL80211_CMD_REQ_SET_REG)\r
- C2S(NL80211_CMD_GET_MESH_CONFIG)\r
- C2S(NL80211_CMD_SET_MESH_CONFIG)\r
- C2S(NL80211_CMD_SET_MGMT_EXTRA_IE)\r
- C2S(NL80211_CMD_GET_REG)\r
- C2S(NL80211_CMD_GET_SCAN)\r
- C2S(NL80211_CMD_TRIGGER_SCAN)\r
- C2S(NL80211_CMD_NEW_SCAN_RESULTS)\r
- C2S(NL80211_CMD_SCAN_ABORTED)\r
- C2S(NL80211_CMD_REG_CHANGE)\r
- C2S(NL80211_CMD_AUTHENTICATE)\r
- C2S(NL80211_CMD_ASSOCIATE)\r
- C2S(NL80211_CMD_DEAUTHENTICATE)\r
- C2S(NL80211_CMD_DISASSOCIATE)\r
- C2S(NL80211_CMD_MICHAEL_MIC_FAILURE)\r
- C2S(NL80211_CMD_REG_BEACON_HINT)\r
- C2S(NL80211_CMD_JOIN_IBSS)\r
- C2S(NL80211_CMD_LEAVE_IBSS)\r
- C2S(NL80211_CMD_TESTMODE)\r
- C2S(NL80211_CMD_CONNECT)\r
- C2S(NL80211_CMD_ROAM)\r
- C2S(NL80211_CMD_DISCONNECT)\r
- C2S(NL80211_CMD_SET_WIPHY_NETNS)\r
- C2S(NL80211_CMD_GET_SURVEY)\r
- C2S(NL80211_CMD_NEW_SURVEY_RESULTS)\r
- C2S(NL80211_CMD_SET_PMKSA)\r
- C2S(NL80211_CMD_DEL_PMKSA)\r
- C2S(NL80211_CMD_FLUSH_PMKSA)\r
- C2S(NL80211_CMD_REMAIN_ON_CHANNEL)\r
- C2S(NL80211_CMD_CANCEL_REMAIN_ON_CHANNEL)\r
- C2S(NL80211_CMD_SET_TX_BITRATE_MASK)\r
- C2S(NL80211_CMD_REGISTER_FRAME)\r
- C2S(NL80211_CMD_FRAME)\r
- C2S(NL80211_CMD_FRAME_TX_STATUS)\r
- C2S(NL80211_CMD_SET_POWER_SAVE)\r
- C2S(NL80211_CMD_GET_POWER_SAVE)\r
- C2S(NL80211_CMD_SET_CQM)\r
- C2S(NL80211_CMD_NOTIFY_CQM)\r
- C2S(NL80211_CMD_SET_CHANNEL)\r
- C2S(NL80211_CMD_SET_WDS_PEER)\r
- C2S(NL80211_CMD_FRAME_WAIT_CANCEL)\r
- C2S(NL80211_CMD_JOIN_MESH)\r
- C2S(NL80211_CMD_LEAVE_MESH)\r
- C2S(NL80211_CMD_UNPROT_DEAUTHENTICATE)\r
- C2S(NL80211_CMD_UNPROT_DISASSOCIATE)\r
- C2S(NL80211_CMD_NEW_PEER_CANDIDATE)\r
- C2S(NL80211_CMD_GET_WOWLAN)\r
- C2S(NL80211_CMD_SET_WOWLAN)\r
- C2S(NL80211_CMD_START_SCHED_SCAN)\r
- C2S(NL80211_CMD_STOP_SCHED_SCAN)\r
- C2S(NL80211_CMD_SCHED_SCAN_RESULTS)\r
- C2S(NL80211_CMD_SCHED_SCAN_STOPPED)\r
- C2S(NL80211_CMD_SET_REKEY_OFFLOAD)\r
- C2S(NL80211_CMD_PMKSA_CANDIDATE)\r
- C2S(NL80211_CMD_TDLS_OPER)\r
- C2S(NL80211_CMD_TDLS_MGMT)\r
- C2S(NL80211_CMD_UNEXPECTED_FRAME)\r
- C2S(NL80211_CMD_PROBE_CLIENT)\r
- C2S(NL80211_CMD_REGISTER_BEACONS)\r
- C2S(NL80211_CMD_UNEXPECTED_4ADDR_FRAME)\r
- C2S(NL80211_CMD_SET_NOACK_MAP)\r
- C2S(NL80211_CMD_CH_SWITCH_NOTIFY)\r
- C2S(NL80211_CMD_START_P2P_DEVICE)\r
- C2S(NL80211_CMD_STOP_P2P_DEVICE)\r
- C2S(NL80211_CMD_CONN_FAILED)\r
- C2S(NL80211_CMD_SET_MCAST_RATE)\r
- C2S(NL80211_CMD_SET_MAC_ACL)\r
- C2S(NL80211_CMD_RADAR_DETECT)\r
- C2S(NL80211_CMD_GET_PROTOCOL_FEATURES)\r
- C2S(NL80211_CMD_UPDATE_FT_IES)\r
- C2S(NL80211_CMD_FT_EVENT)\r
- C2S(NL80211_CMD_CRIT_PROTOCOL_START)\r
- C2S(NL80211_CMD_CRIT_PROTOCOL_STOP)\r
- C2S(NL80211_CMD_VENDOR)\r
- default:\r
- return "NL80211_CMD_UNKNOWN";\r
- }\r
-}\r
-\r
-const char *attributeToString(int attribute)\r
-{\r
- switch (attribute) {\r
- C2S(NL80211_ATTR_UNSPEC)\r
-\r
- C2S(NL80211_ATTR_WIPHY)\r
- C2S(NL80211_ATTR_WIPHY_NAME)\r
-\r
- C2S(NL80211_ATTR_IFINDEX)\r
- C2S(NL80211_ATTR_IFNAME)\r
- C2S(NL80211_ATTR_IFTYPE)\r
-\r
- C2S(NL80211_ATTR_MAC)\r
-\r
- C2S(NL80211_ATTR_KEY_DATA)\r
- C2S(NL80211_ATTR_KEY_IDX)\r
- C2S(NL80211_ATTR_KEY_CIPHER)\r
- C2S(NL80211_ATTR_KEY_SEQ)\r
- C2S(NL80211_ATTR_KEY_DEFAULT)\r
-\r
- C2S(NL80211_ATTR_BEACON_INTERVAL)\r
- C2S(NL80211_ATTR_DTIM_PERIOD)\r
- C2S(NL80211_ATTR_BEACON_HEAD)\r
- C2S(NL80211_ATTR_BEACON_TAIL)\r
-\r
- C2S(NL80211_ATTR_STA_AID)\r
- C2S(NL80211_ATTR_STA_FLAGS)\r
- C2S(NL80211_ATTR_STA_LISTEN_INTERVAL)\r
- C2S(NL80211_ATTR_STA_SUPPORTED_RATES)\r
- C2S(NL80211_ATTR_STA_VLAN)\r
- C2S(NL80211_ATTR_STA_INFO)\r
-\r
- C2S(NL80211_ATTR_WIPHY_BANDS)\r
-\r
- C2S(NL80211_ATTR_MNTR_FLAGS)\r
-\r
- C2S(NL80211_ATTR_MESH_ID)\r
- C2S(NL80211_ATTR_STA_PLINK_ACTION)\r
- C2S(NL80211_ATTR_MPATH_NEXT_HOP)\r
- C2S(NL80211_ATTR_MPATH_INFO)\r
-\r
- C2S(NL80211_ATTR_BSS_CTS_PROT)\r
- C2S(NL80211_ATTR_BSS_SHORT_PREAMBLE)\r
- C2S(NL80211_ATTR_BSS_SHORT_SLOT_TIME)\r
-\r
- C2S(NL80211_ATTR_HT_CAPABILITY)\r
-\r
- C2S(NL80211_ATTR_SUPPORTED_IFTYPES)\r
-\r
- C2S(NL80211_ATTR_REG_ALPHA2)\r
- C2S(NL80211_ATTR_REG_RULES)\r
-\r
- C2S(NL80211_ATTR_MESH_CONFIG)\r
-\r
- C2S(NL80211_ATTR_BSS_BASIC_RATES)\r
-\r
- C2S(NL80211_ATTR_WIPHY_TXQ_PARAMS)\r
- C2S(NL80211_ATTR_WIPHY_FREQ)\r
- C2S(NL80211_ATTR_WIPHY_CHANNEL_TYPE)\r
-\r
- C2S(NL80211_ATTR_KEY_DEFAULT_MGMT)\r
-\r
- C2S(NL80211_ATTR_MGMT_SUBTYPE)\r
- C2S(NL80211_ATTR_IE)\r
-\r
- C2S(NL80211_ATTR_MAX_NUM_SCAN_SSIDS)\r
-\r
- C2S(NL80211_ATTR_SCAN_FREQUENCIES)\r
- C2S(NL80211_ATTR_SCAN_SSIDS)\r
- C2S(NL80211_ATTR_GENERATION) /* replaces old SCAN_GENERATION */\r
- C2S(NL80211_ATTR_BSS)\r
-\r
- C2S(NL80211_ATTR_REG_INITIATOR)\r
- C2S(NL80211_ATTR_REG_TYPE)\r
-\r
- C2S(NL80211_ATTR_SUPPORTED_COMMANDS)\r
-\r
- C2S(NL80211_ATTR_FRAME)\r
- C2S(NL80211_ATTR_SSID)\r
- C2S(NL80211_ATTR_AUTH_TYPE)\r
- C2S(NL80211_ATTR_REASON_CODE)\r
-\r
- C2S(NL80211_ATTR_KEY_TYPE)\r
-\r
- C2S(NL80211_ATTR_MAX_SCAN_IE_LEN)\r
- C2S(NL80211_ATTR_CIPHER_SUITES)\r
-\r
- C2S(NL80211_ATTR_FREQ_BEFORE)\r
- C2S(NL80211_ATTR_FREQ_AFTER)\r
-\r
- C2S(NL80211_ATTR_FREQ_FIXED)\r
-\r
-\r
- C2S(NL80211_ATTR_WIPHY_RETRY_SHORT)\r
- C2S(NL80211_ATTR_WIPHY_RETRY_LONG)\r
- C2S(NL80211_ATTR_WIPHY_FRAG_THRESHOLD)\r
- C2S(NL80211_ATTR_WIPHY_RTS_THRESHOLD)\r
-\r
- C2S(NL80211_ATTR_TIMED_OUT)\r
-\r
- C2S(NL80211_ATTR_USE_MFP)\r
-\r
- C2S(NL80211_ATTR_STA_FLAGS2)\r
-\r
- C2S(NL80211_ATTR_CONTROL_PORT)\r
-\r
- C2S(NL80211_ATTR_TESTDATA)\r
-\r
- C2S(NL80211_ATTR_PRIVACY)\r
-\r
- C2S(NL80211_ATTR_DISCONNECTED_BY_AP)\r
- C2S(NL80211_ATTR_STATUS_CODE)\r
-\r
- C2S(NL80211_ATTR_CIPHER_SUITES_PAIRWISE)\r
- C2S(NL80211_ATTR_CIPHER_SUITE_GROUP)\r
- C2S(NL80211_ATTR_WPA_VERSIONS)\r
- C2S(NL80211_ATTR_AKM_SUITES)\r
-\r
- C2S(NL80211_ATTR_REQ_IE)\r
- C2S(NL80211_ATTR_RESP_IE)\r
-\r
- C2S(NL80211_ATTR_PREV_BSSID)\r
-\r
- C2S(NL80211_ATTR_KEY)\r
- C2S(NL80211_ATTR_KEYS)\r
-\r
- C2S(NL80211_ATTR_PID)\r
-\r
- C2S(NL80211_ATTR_4ADDR)\r
-\r
- C2S(NL80211_ATTR_SURVEY_INFO)\r
-\r
- C2S(NL80211_ATTR_PMKID)\r
- C2S(NL80211_ATTR_MAX_NUM_PMKIDS)\r
-\r
- C2S(NL80211_ATTR_DURATION)\r
-\r
- C2S(NL80211_ATTR_COOKIE)\r
-\r
- C2S(NL80211_ATTR_WIPHY_COVERAGE_CLASS)\r
-\r
- C2S(NL80211_ATTR_TX_RATES)\r
-\r
- C2S(NL80211_ATTR_FRAME_MATCH)\r
-\r
- C2S(NL80211_ATTR_ACK)\r
-\r
- C2S(NL80211_ATTR_PS_STATE)\r
-\r
- C2S(NL80211_ATTR_CQM)\r
-\r
- C2S(NL80211_ATTR_LOCAL_STATE_CHANGE)\r
-\r
- C2S(NL80211_ATTR_AP_ISOLATE)\r
-\r
- C2S(NL80211_ATTR_WIPHY_TX_POWER_SETTING)\r
- C2S(NL80211_ATTR_WIPHY_TX_POWER_LEVEL)\r
-\r
- C2S(NL80211_ATTR_TX_FRAME_TYPES)\r
- C2S(NL80211_ATTR_RX_FRAME_TYPES)\r
- C2S(NL80211_ATTR_FRAME_TYPE)\r
-\r
- C2S(NL80211_ATTR_CONTROL_PORT_ETHERTYPE)\r
- C2S(NL80211_ATTR_CONTROL_PORT_NO_ENCRYPT)\r
-\r
- C2S(NL80211_ATTR_SUPPORT_IBSS_RSN)\r
-\r
- C2S(NL80211_ATTR_WIPHY_ANTENNA_TX)\r
- C2S(NL80211_ATTR_WIPHY_ANTENNA_RX)\r
-\r
- C2S(NL80211_ATTR_MCAST_RATE)\r
-\r
- C2S(NL80211_ATTR_OFFCHANNEL_TX_OK)\r
-\r
- C2S(NL80211_ATTR_BSS_HT_OPMODE)\r
-\r
- C2S(NL80211_ATTR_KEY_DEFAULT_TYPES)\r
-\r
- C2S(NL80211_ATTR_MAX_REMAIN_ON_CHANNEL_DURATION)\r
-\r
- C2S(NL80211_ATTR_MESH_SETUP)\r
-\r
- C2S(NL80211_ATTR_WIPHY_ANTENNA_AVAIL_TX)\r
- C2S(NL80211_ATTR_WIPHY_ANTENNA_AVAIL_RX)\r
-\r
- C2S(NL80211_ATTR_SUPPORT_MESH_AUTH)\r
- C2S(NL80211_ATTR_STA_PLINK_STATE)\r
-\r
- C2S(NL80211_ATTR_WOWLAN_TRIGGERS)\r
- C2S(NL80211_ATTR_WOWLAN_TRIGGERS_SUPPORTED)\r
-\r
- C2S(NL80211_ATTR_SCHED_SCAN_INTERVAL)\r
-\r
- C2S(NL80211_ATTR_INTERFACE_COMBINATIONS)\r
- C2S(NL80211_ATTR_SOFTWARE_IFTYPES)\r
-\r
- C2S(NL80211_ATTR_REKEY_DATA)\r
-\r
- C2S(NL80211_ATTR_MAX_NUM_SCHED_SCAN_SSIDS)\r
- C2S(NL80211_ATTR_MAX_SCHED_SCAN_IE_LEN)\r
-\r
- C2S(NL80211_ATTR_SCAN_SUPP_RATES)\r
-\r
- C2S(NL80211_ATTR_HIDDEN_SSID)\r
-\r
- C2S(NL80211_ATTR_IE_PROBE_RESP)\r
- C2S(NL80211_ATTR_IE_ASSOC_RESP)\r
-\r
- C2S(NL80211_ATTR_STA_WME)\r
- C2S(NL80211_ATTR_SUPPORT_AP_UAPSD)\r
-\r
- C2S(NL80211_ATTR_ROAM_SUPPORT)\r
-\r
- C2S(NL80211_ATTR_SCHED_SCAN_MATCH)\r
- C2S(NL80211_ATTR_MAX_MATCH_SETS)\r
-\r
- C2S(NL80211_ATTR_PMKSA_CANDIDATE)\r
-\r
- C2S(NL80211_ATTR_TX_NO_CCK_RATE)\r
-\r
- C2S(NL80211_ATTR_TDLS_ACTION)\r
- C2S(NL80211_ATTR_TDLS_DIALOG_TOKEN)\r
- C2S(NL80211_ATTR_TDLS_OPERATION)\r
- C2S(NL80211_ATTR_TDLS_SUPPORT)\r
- C2S(NL80211_ATTR_TDLS_EXTERNAL_SETUP)\r
-\r
- C2S(NL80211_ATTR_DEVICE_AP_SME)\r
-\r
- C2S(NL80211_ATTR_DONT_WAIT_FOR_ACK)\r
-\r
- C2S(NL80211_ATTR_FEATURE_FLAGS)\r
-\r
- C2S(NL80211_ATTR_PROBE_RESP_OFFLOAD)\r
-\r
- C2S(NL80211_ATTR_PROBE_RESP)\r
-\r
- C2S(NL80211_ATTR_DFS_REGION)\r
-\r
- C2S(NL80211_ATTR_DISABLE_HT)\r
- C2S(NL80211_ATTR_HT_CAPABILITY_MASK)\r
-\r
- C2S(NL80211_ATTR_NOACK_MAP)\r
-\r
- C2S(NL80211_ATTR_INACTIVITY_TIMEOUT)\r
-\r
- C2S(NL80211_ATTR_RX_SIGNAL_DBM)\r
-\r
- C2S(NL80211_ATTR_BG_SCAN_PERIOD)\r
-\r
- C2S(NL80211_ATTR_WDEV)\r
-\r
- C2S(NL80211_ATTR_USER_REG_HINT_TYPE)\r
-\r
- C2S(NL80211_ATTR_CONN_FAILED_REASON)\r
-\r
- C2S(NL80211_ATTR_SAE_DATA)\r
-\r
- C2S(NL80211_ATTR_VHT_CAPABILITY)\r
-\r
- C2S(NL80211_ATTR_SCAN_FLAGS)\r
-\r
- C2S(NL80211_ATTR_CHANNEL_WIDTH)\r
- C2S(NL80211_ATTR_CENTER_FREQ1)\r
- C2S(NL80211_ATTR_CENTER_FREQ2)\r
-\r
- C2S(NL80211_ATTR_P2P_CTWINDOW)\r
- C2S(NL80211_ATTR_P2P_OPPPS)\r
-\r
- C2S(NL80211_ATTR_LOCAL_MESH_POWER_MODE)\r
-\r
- C2S(NL80211_ATTR_ACL_POLICY)\r
-\r
- C2S(NL80211_ATTR_MAC_ADDRS)\r
-\r
- C2S(NL80211_ATTR_MAC_ACL_MAX)\r
-\r
- C2S(NL80211_ATTR_RADAR_EVENT)\r
-\r
- C2S(NL80211_ATTR_EXT_CAPA)\r
- C2S(NL80211_ATTR_EXT_CAPA_MASK)\r
-\r
- C2S(NL80211_ATTR_STA_CAPABILITY)\r
- C2S(NL80211_ATTR_STA_EXT_CAPABILITY)\r
-\r
- C2S(NL80211_ATTR_PROTOCOL_FEATURES)\r
- C2S(NL80211_ATTR_SPLIT_WIPHY_DUMP)\r
-\r
- C2S(NL80211_ATTR_DISABLE_VHT)\r
- C2S(NL80211_ATTR_VHT_CAPABILITY_MASK)\r
-\r
- C2S(NL80211_ATTR_MDID)\r
- C2S(NL80211_ATTR_IE_RIC)\r
-\r
- C2S(NL80211_ATTR_CRIT_PROT_ID)\r
- C2S(NL80211_ATTR_MAX_CRIT_PROT_DURATION)\r
-\r
- C2S(NL80211_ATTR_PEER_AID)\r
-\r
-\r
- //S(NL80211_ATTR_VENDOR_ID)\r
- C2S(NL80211_ATTR_VENDOR_SUBCMD)\r
- C2S(NL80211_ATTR_VENDOR_DATA)\r
- C2S(NL80211_ATTR_VENDOR_EVENTS)\r
-\r
- default:\r
- return "NL80211_ATTR_UNKNOWN";\r
- }\r
-}\r
-\r
-void WifiEvent::log() {\r
- parse();\r
-\r
- byte *data = (byte *)genlmsg_attrdata(mHeader, 0);\r
- int len = genlmsg_attrlen(mHeader, 0);\r
- ALOGD("cmd = %s, len = %d", get_cmdString(), len);\r
- ALOGD("vendor_id = %04x, vendor_subcmd = %d", get_vendor_id(), get_vendor_subcmd());\r
-\r
- for (int i = 0; i < len; i += 16) {\r
- char line[81];\r
- int linelen = min(16, len - i);\r
- int offset = 0;\r
- appendFmt(line, offset, "%02x", data[i]);\r
- for (int j = 1; j < linelen; j++) {\r
- appendFmt(line, offset, " %02x", data[i+j]);\r
- }\r
-\r
- for (int j = linelen; j < 16; j++) {\r
- appendFmt(line, offset, " ");\r
- }\r
-\r
- line[23] = '-';\r
-\r
- appendFmt(line, offset, " ");\r
-\r
- for (int j = 0; j < linelen; j++) {\r
- if (isprint(data[i+j])) {\r
- appendFmt(line, offset, "%c", data[i+j]);\r
- } else {\r
- appendFmt(line, offset, "-");\r
- }\r
- }\r
-\r
- ALOGD("%s", line);\r
- }\r
-\r
- for (unsigned i = 0; i < NL80211_ATTR_MAX_INTERNAL; i++) {\r
- if (mAttributes[i] != NULL) {\r
- ALOGD("found attribute %s", attributeToString(i));\r
- }\r
- }\r
-\r
- ALOGD("-- End of message --");\r
-}\r
-\r
-const char *WifiEvent::get_cmdString() {\r
- return cmdToString(get_cmd());\r
-}\r
-\r
-\r
-int WifiEvent::parse() {\r
- if (mHeader != NULL) {\r
- return WIFI_SUCCESS;\r
- }\r
- mHeader = (genlmsghdr *)nlmsg_data(nlmsg_hdr(mMsg));\r
- int result = nla_parse(mAttributes, NL80211_ATTR_MAX_INTERNAL, genlmsg_attrdata(mHeader, 0),\r
- genlmsg_attrlen(mHeader, 0), NULL);\r
-\r
- ALOGD("event len = %d", nlmsg_hdr(mMsg)->nlmsg_len);\r
- return result;\r
-}\r
-\r
-int WifiRequest::create(int family, uint8_t cmd, int flags, int hdrlen) {\r
- mMsg = nlmsg_alloc();\r
- if (mMsg != NULL) {\r
- genlmsg_put(mMsg, /* pid = */ 0, /* seq = */ 0, family,\r
- hdrlen, flags, cmd, /* version = */ 0);\r
- return WIFI_SUCCESS;\r
- } else {\r
- return WIFI_ERROR_OUT_OF_MEMORY;\r
- }\r
-}\r
-\r
-int WifiRequest::create(uint32_t id, int subcmd) {\r
- int res = create(NL80211_CMD_VENDOR);\r
- if (res < 0) {\r
- return res;\r
- }\r
-\r
- res = put_u32(NL80211_ATTR_VENDOR_ID, id);\r
- if (res < 0) {\r
- return res;\r
- }\r
-\r
- res = put_u32(NL80211_ATTR_VENDOR_SUBCMD, subcmd);\r
- if (res < 0) {\r
- return res;\r
- }\r
-\r
- if (mIface != -1) {\r
- res = set_iface_id(mIface);\r
- }\r
-\r
- return res;\r
-}\r
-\r
-\r
-static int no_seq_check(struct nl_msg *msg, void *arg)\r
-{\r
- return NL_OK;\r
-}\r
-\r
-int WifiCommand::requestResponse() {\r
- int err = create(); /* create the message */\r
- if (err < 0) {\r
- return err;\r
- }\r
-\r
- return requestResponse(mMsg);\r
-}\r
-\r
-int WifiCommand::requestResponse(WifiRequest& request) {\r
- int err = 0;\r
-\r
- struct nl_cb *cb = nl_cb_alloc(NL_CB_DEFAULT);\r
- if (!cb)\r
- goto out;\r
-\r
- err = nl_send_auto_complete(mInfo->cmd_sock, request.getMessage()); /* send message */\r
- if (err < 0)\r
- goto out;\r
-\r
- err = 1;\r
-\r
- nl_cb_set(cb, NL_CB_SEQ_CHECK, NL_CB_CUSTOM, no_seq_check, NULL);\r
- nl_cb_err(cb, NL_CB_CUSTOM, error_handler, &err);\r
- nl_cb_set(cb, NL_CB_FINISH, NL_CB_CUSTOM, finish_handler, &err);\r
- nl_cb_set(cb, NL_CB_ACK, NL_CB_CUSTOM, ack_handler, &err);\r
- nl_cb_set(cb, NL_CB_VALID, NL_CB_CUSTOM, response_handler, this);\r
-\r
- while (err > 0) { /* wait for reply */\r
- int res = nl_recvmsgs(mInfo->cmd_sock, cb);\r
- if (res) {\r
- ALOGE("nl80211: %s->nl_recvmsgs failed: %d", __func__, res);\r
- }\r
- }\r
-out:\r
- nl_cb_put(cb);\r
- return err;\r
-}\r
-\r
-int WifiCommand::requestEvent(int cmd) {\r
-\r
- ALOGD("requesting event %d", cmd);\r
-\r
- int res = wifi_register_handler(wifiHandle(), cmd, event_handler, this);\r
- if (res < 0) {\r
- return res;\r
- }\r
-\r
- res = create(); /* create the message */\r
- if (res < 0)\r
- goto out;\r
-\r
- ALOGD("waiting for response %d", cmd);\r
-\r
- res = nl_send_auto_complete(mInfo->cmd_sock, mMsg.getMessage()); /* send message */\r
- if (res < 0)\r
- goto out;\r
-\r
- ALOGD("waiting for event %d", cmd);\r
- res = mCondition.wait();\r
- if (res < 0)\r
- goto out;\r
-\r
-out:\r
- wifi_unregister_handler(wifiHandle(), cmd);\r
- return res;\r
-}\r
-\r
-int WifiCommand::requestVendorEvent(uint32_t id, int subcmd) {\r
-\r
- int res = wifi_register_vendor_handler(wifiHandle(), id, subcmd, event_handler, this);\r
- if (res < 0) {\r
- return res;\r
- }\r
-\r
- res = create(); /* create the message */\r
- if (res < 0)\r
- goto out;\r
-\r
- res = nl_send_auto_complete(mInfo->cmd_sock, mMsg.getMessage()); /* send message */\r
- if (res < 0)\r
- goto out;\r
-\r
- res = mCondition.wait();\r
- if (res < 0)\r
- goto out;\r
-\r
-out:\r
- wifi_unregister_vendor_handler(wifiHandle(), id, subcmd);\r
- return res;\r
-}\r
-\r
-/* Event handlers */\r
-int WifiCommand::response_handler(struct nl_msg *msg, void *arg) {\r
- ALOGD("response_handler called");\r
- WifiCommand *cmd = (WifiCommand *)arg;\r
- WifiEvent reply(msg);\r
- int res = reply.parse();\r
- if (res < 0) {\r
- ALOGE("Failed to parse reply message = %d", res);\r
- return NL_SKIP;\r
- } else {\r
- // reply.log();\r
- return cmd->handleResponse(reply);\r
- }\r
-}\r
-\r
-int WifiCommand::event_handler(struct nl_msg *msg, void *arg) {\r
- WifiCommand *cmd = (WifiCommand *)arg;\r
- WifiEvent event(msg);\r
- int res = event.parse();\r
- if (res < 0) {\r
- ALOGE("Failed to parse event = %d", res);\r
- res = NL_SKIP;\r
- } else {\r
- res = cmd->handleEvent(event);\r
- }\r
-\r
- cmd->mCondition.signal();\r
- return res;\r
-}\r
-\r
-/* Other event handlers */\r
-int WifiCommand::valid_handler(struct nl_msg *msg, void *arg) {\r
- ALOGD("valid_handler called");\r
- int *err = (int *)arg;\r
- *err = 0;\r
- return NL_SKIP;\r
-}\r
-\r
-int WifiCommand::ack_handler(struct nl_msg *msg, void *arg) {\r
- ALOGD("ack_handler called");\r
- int *err = (int *)arg;\r
- *err = 0;\r
- return NL_STOP;\r
-}\r
-\r
-int WifiCommand::finish_handler(struct nl_msg *msg, void *arg) {\r
- ALOGD("finish_handler called");\r
- int *ret = (int *)arg;\r
- *ret = 0;\r
- return NL_SKIP;\r
-}\r
-\r
-int WifiCommand::error_handler(struct sockaddr_nl *nla, struct nlmsgerr *err, void *arg) {\r
- int *ret = (int *)arg;\r
- *ret = err->error;\r
-\r
- ALOGD("error_handler received : %d", err->error);\r
- return NL_SKIP;\r
-}\r
+
+#include <stdint.h>
+#include <fcntl.h>
+#include <sys/socket.h>
+#include <netlink/genl/genl.h>
+#include <netlink/genl/family.h>
+#include <netlink/genl/ctrl.h>
+#include <linux/rtnetlink.h>
+#include <netpacket/packet.h>
+#include <linux/filter.h>
+#include <linux/errqueue.h>
+
+#include <linux/pkt_sched.h>
+#include <netlink/object-api.h>
+#include <netlink/netlink.h>
+#include <netlink/socket.h>
+#include <netlink/handlers.h>
+#include <stdarg.h>
+
+#include <ctype.h>
+
+#include "wifi_hal.h"
+#include "common.h"
+#include "cpp_bindings.h"
+
+void appendFmt(char *buf, int &offset, const char *fmt, ...)
+{
+ va_list params;
+ va_start(params, fmt);
+ offset += vsprintf(buf + offset, fmt, params);
+ va_end(params);
+}
+
+#define C2S(x) case x: return #x;
+
+static const char *cmdToString(int cmd)
+{
+ switch (cmd) {
+ C2S(NL80211_CMD_UNSPEC)
+ C2S(NL80211_CMD_GET_WIPHY)
+ C2S(NL80211_CMD_SET_WIPHY)
+ C2S(NL80211_CMD_NEW_WIPHY)
+ C2S(NL80211_CMD_DEL_WIPHY)
+ C2S(NL80211_CMD_GET_INTERFACE)
+ C2S(NL80211_CMD_SET_INTERFACE)
+ C2S(NL80211_CMD_NEW_INTERFACE)
+ C2S(NL80211_CMD_DEL_INTERFACE)
+ C2S(NL80211_CMD_GET_KEY)
+ C2S(NL80211_CMD_SET_KEY)
+ C2S(NL80211_CMD_NEW_KEY)
+ C2S(NL80211_CMD_DEL_KEY)
+ C2S(NL80211_CMD_GET_BEACON)
+ C2S(NL80211_CMD_SET_BEACON)
+ C2S(NL80211_CMD_START_AP)
+ C2S(NL80211_CMD_STOP_AP)
+ C2S(NL80211_CMD_GET_STATION)
+ C2S(NL80211_CMD_SET_STATION)
+ C2S(NL80211_CMD_NEW_STATION)
+ C2S(NL80211_CMD_DEL_STATION)
+ C2S(NL80211_CMD_GET_MPATH)
+ C2S(NL80211_CMD_SET_MPATH)
+ C2S(NL80211_CMD_NEW_MPATH)
+ C2S(NL80211_CMD_DEL_MPATH)
+ C2S(NL80211_CMD_SET_BSS)
+ C2S(NL80211_CMD_SET_REG)
+ C2S(NL80211_CMD_REQ_SET_REG)
+ C2S(NL80211_CMD_GET_MESH_CONFIG)
+ C2S(NL80211_CMD_SET_MESH_CONFIG)
+ C2S(NL80211_CMD_SET_MGMT_EXTRA_IE)
+ C2S(NL80211_CMD_GET_REG)
+ C2S(NL80211_CMD_GET_SCAN)
+ C2S(NL80211_CMD_TRIGGER_SCAN)
+ C2S(NL80211_CMD_NEW_SCAN_RESULTS)
+ C2S(NL80211_CMD_SCAN_ABORTED)
+ C2S(NL80211_CMD_REG_CHANGE)
+ C2S(NL80211_CMD_AUTHENTICATE)
+ C2S(NL80211_CMD_ASSOCIATE)
+ C2S(NL80211_CMD_DEAUTHENTICATE)
+ C2S(NL80211_CMD_DISASSOCIATE)
+ C2S(NL80211_CMD_MICHAEL_MIC_FAILURE)
+ C2S(NL80211_CMD_REG_BEACON_HINT)
+ C2S(NL80211_CMD_JOIN_IBSS)
+ C2S(NL80211_CMD_LEAVE_IBSS)
+ C2S(NL80211_CMD_TESTMODE)
+ C2S(NL80211_CMD_CONNECT)
+ C2S(NL80211_CMD_ROAM)
+ C2S(NL80211_CMD_DISCONNECT)
+ C2S(NL80211_CMD_SET_WIPHY_NETNS)
+ C2S(NL80211_CMD_GET_SURVEY)
+ C2S(NL80211_CMD_NEW_SURVEY_RESULTS)
+ C2S(NL80211_CMD_SET_PMKSA)
+ C2S(NL80211_CMD_DEL_PMKSA)
+ C2S(NL80211_CMD_FLUSH_PMKSA)
+ C2S(NL80211_CMD_REMAIN_ON_CHANNEL)
+ C2S(NL80211_CMD_CANCEL_REMAIN_ON_CHANNEL)
+ C2S(NL80211_CMD_SET_TX_BITRATE_MASK)
+ C2S(NL80211_CMD_REGISTER_FRAME)
+ C2S(NL80211_CMD_FRAME)
+ C2S(NL80211_CMD_FRAME_TX_STATUS)
+ C2S(NL80211_CMD_SET_POWER_SAVE)
+ C2S(NL80211_CMD_GET_POWER_SAVE)
+ C2S(NL80211_CMD_SET_CQM)
+ C2S(NL80211_CMD_NOTIFY_CQM)
+ C2S(NL80211_CMD_SET_CHANNEL)
+ C2S(NL80211_CMD_SET_WDS_PEER)
+ C2S(NL80211_CMD_FRAME_WAIT_CANCEL)
+ C2S(NL80211_CMD_JOIN_MESH)
+ C2S(NL80211_CMD_LEAVE_MESH)
+ C2S(NL80211_CMD_UNPROT_DEAUTHENTICATE)
+ C2S(NL80211_CMD_UNPROT_DISASSOCIATE)
+ C2S(NL80211_CMD_NEW_PEER_CANDIDATE)
+ C2S(NL80211_CMD_GET_WOWLAN)
+ C2S(NL80211_CMD_SET_WOWLAN)
+ C2S(NL80211_CMD_START_SCHED_SCAN)
+ C2S(NL80211_CMD_STOP_SCHED_SCAN)
+ C2S(NL80211_CMD_SCHED_SCAN_RESULTS)
+ C2S(NL80211_CMD_SCHED_SCAN_STOPPED)
+ C2S(NL80211_CMD_SET_REKEY_OFFLOAD)
+ C2S(NL80211_CMD_PMKSA_CANDIDATE)
+ C2S(NL80211_CMD_TDLS_OPER)
+ C2S(NL80211_CMD_TDLS_MGMT)
+ C2S(NL80211_CMD_UNEXPECTED_FRAME)
+ C2S(NL80211_CMD_PROBE_CLIENT)
+ C2S(NL80211_CMD_REGISTER_BEACONS)
+ C2S(NL80211_CMD_UNEXPECTED_4ADDR_FRAME)
+ C2S(NL80211_CMD_SET_NOACK_MAP)
+ C2S(NL80211_CMD_CH_SWITCH_NOTIFY)
+ C2S(NL80211_CMD_START_P2P_DEVICE)
+ C2S(NL80211_CMD_STOP_P2P_DEVICE)
+ C2S(NL80211_CMD_CONN_FAILED)
+ C2S(NL80211_CMD_SET_MCAST_RATE)
+ C2S(NL80211_CMD_SET_MAC_ACL)
+ C2S(NL80211_CMD_RADAR_DETECT)
+ C2S(NL80211_CMD_GET_PROTOCOL_FEATURES)
+ C2S(NL80211_CMD_UPDATE_FT_IES)
+ C2S(NL80211_CMD_FT_EVENT)
+ C2S(NL80211_CMD_CRIT_PROTOCOL_START)
+ C2S(NL80211_CMD_CRIT_PROTOCOL_STOP)
+ C2S(NL80211_CMD_VENDOR)
+ default:
+ return "NL80211_CMD_UNKNOWN";
+ }
+}
+
+const char *attributeToString(int attribute)
+{
+ switch (attribute) {
+ C2S(NL80211_ATTR_UNSPEC)
+
+ C2S(NL80211_ATTR_WIPHY)
+ C2S(NL80211_ATTR_WIPHY_NAME)
+
+ C2S(NL80211_ATTR_IFINDEX)
+ C2S(NL80211_ATTR_IFNAME)
+ C2S(NL80211_ATTR_IFTYPE)
+
+ C2S(NL80211_ATTR_MAC)
+
+ C2S(NL80211_ATTR_KEY_DATA)
+ C2S(NL80211_ATTR_KEY_IDX)
+ C2S(NL80211_ATTR_KEY_CIPHER)
+ C2S(NL80211_ATTR_KEY_SEQ)
+ C2S(NL80211_ATTR_KEY_DEFAULT)
+
+ C2S(NL80211_ATTR_BEACON_INTERVAL)
+ C2S(NL80211_ATTR_DTIM_PERIOD)
+ C2S(NL80211_ATTR_BEACON_HEAD)
+ C2S(NL80211_ATTR_BEACON_TAIL)
+
+ C2S(NL80211_ATTR_STA_AID)
+ C2S(NL80211_ATTR_STA_FLAGS)
+ C2S(NL80211_ATTR_STA_LISTEN_INTERVAL)
+ C2S(NL80211_ATTR_STA_SUPPORTED_RATES)
+ C2S(NL80211_ATTR_STA_VLAN)
+ C2S(NL80211_ATTR_STA_INFO)
+
+ C2S(NL80211_ATTR_WIPHY_BANDS)
+
+ C2S(NL80211_ATTR_MNTR_FLAGS)
+
+ C2S(NL80211_ATTR_MESH_ID)
+ C2S(NL80211_ATTR_STA_PLINK_ACTION)
+ C2S(NL80211_ATTR_MPATH_NEXT_HOP)
+ C2S(NL80211_ATTR_MPATH_INFO)
+
+ C2S(NL80211_ATTR_BSS_CTS_PROT)
+ C2S(NL80211_ATTR_BSS_SHORT_PREAMBLE)
+ C2S(NL80211_ATTR_BSS_SHORT_SLOT_TIME)
+
+ C2S(NL80211_ATTR_HT_CAPABILITY)
+
+ C2S(NL80211_ATTR_SUPPORTED_IFTYPES)
+
+ C2S(NL80211_ATTR_REG_ALPHA2)
+ C2S(NL80211_ATTR_REG_RULES)
+
+ C2S(NL80211_ATTR_MESH_CONFIG)
+
+ C2S(NL80211_ATTR_BSS_BASIC_RATES)
+
+ C2S(NL80211_ATTR_WIPHY_TXQ_PARAMS)
+ C2S(NL80211_ATTR_WIPHY_FREQ)
+ C2S(NL80211_ATTR_WIPHY_CHANNEL_TYPE)
+
+ C2S(NL80211_ATTR_KEY_DEFAULT_MGMT)
+
+ C2S(NL80211_ATTR_MGMT_SUBTYPE)
+ C2S(NL80211_ATTR_IE)
+
+ C2S(NL80211_ATTR_MAX_NUM_SCAN_SSIDS)
+
+ C2S(NL80211_ATTR_SCAN_FREQUENCIES)
+ C2S(NL80211_ATTR_SCAN_SSIDS)
+ C2S(NL80211_ATTR_GENERATION) /* replaces old SCAN_GENERATION */
+ C2S(NL80211_ATTR_BSS)
+
+ C2S(NL80211_ATTR_REG_INITIATOR)
+ C2S(NL80211_ATTR_REG_TYPE)
+
+ C2S(NL80211_ATTR_SUPPORTED_COMMANDS)
+
+ C2S(NL80211_ATTR_FRAME)
+ C2S(NL80211_ATTR_SSID)
+ C2S(NL80211_ATTR_AUTH_TYPE)
+ C2S(NL80211_ATTR_REASON_CODE)
+
+ C2S(NL80211_ATTR_KEY_TYPE)
+
+ C2S(NL80211_ATTR_MAX_SCAN_IE_LEN)
+ C2S(NL80211_ATTR_CIPHER_SUITES)
+
+ C2S(NL80211_ATTR_FREQ_BEFORE)
+ C2S(NL80211_ATTR_FREQ_AFTER)
+
+ C2S(NL80211_ATTR_FREQ_FIXED)
+
+
+ C2S(NL80211_ATTR_WIPHY_RETRY_SHORT)
+ C2S(NL80211_ATTR_WIPHY_RETRY_LONG)
+ C2S(NL80211_ATTR_WIPHY_FRAG_THRESHOLD)
+ C2S(NL80211_ATTR_WIPHY_RTS_THRESHOLD)
+
+ C2S(NL80211_ATTR_TIMED_OUT)
+
+ C2S(NL80211_ATTR_USE_MFP)
+
+ C2S(NL80211_ATTR_STA_FLAGS2)
+
+ C2S(NL80211_ATTR_CONTROL_PORT)
+
+ C2S(NL80211_ATTR_TESTDATA)
+
+ C2S(NL80211_ATTR_PRIVACY)
+
+ C2S(NL80211_ATTR_DISCONNECTED_BY_AP)
+ C2S(NL80211_ATTR_STATUS_CODE)
+
+ C2S(NL80211_ATTR_CIPHER_SUITES_PAIRWISE)
+ C2S(NL80211_ATTR_CIPHER_SUITE_GROUP)
+ C2S(NL80211_ATTR_WPA_VERSIONS)
+ C2S(NL80211_ATTR_AKM_SUITES)
+
+ C2S(NL80211_ATTR_REQ_IE)
+ C2S(NL80211_ATTR_RESP_IE)
+
+ C2S(NL80211_ATTR_PREV_BSSID)
+
+ C2S(NL80211_ATTR_KEY)
+ C2S(NL80211_ATTR_KEYS)
+
+ C2S(NL80211_ATTR_PID)
+
+ C2S(NL80211_ATTR_4ADDR)
+
+ C2S(NL80211_ATTR_SURVEY_INFO)
+
+ C2S(NL80211_ATTR_PMKID)
+ C2S(NL80211_ATTR_MAX_NUM_PMKIDS)
+
+ C2S(NL80211_ATTR_DURATION)
+
+ C2S(NL80211_ATTR_COOKIE)
+
+ C2S(NL80211_ATTR_WIPHY_COVERAGE_CLASS)
+
+ C2S(NL80211_ATTR_TX_RATES)
+
+ C2S(NL80211_ATTR_FRAME_MATCH)
+
+ C2S(NL80211_ATTR_ACK)
+
+ C2S(NL80211_ATTR_PS_STATE)
+
+ C2S(NL80211_ATTR_CQM)
+
+ C2S(NL80211_ATTR_LOCAL_STATE_CHANGE)
+
+ C2S(NL80211_ATTR_AP_ISOLATE)
+
+ C2S(NL80211_ATTR_WIPHY_TX_POWER_SETTING)
+ C2S(NL80211_ATTR_WIPHY_TX_POWER_LEVEL)
+
+ C2S(NL80211_ATTR_TX_FRAME_TYPES)
+ C2S(NL80211_ATTR_RX_FRAME_TYPES)
+ C2S(NL80211_ATTR_FRAME_TYPE)
+
+ C2S(NL80211_ATTR_CONTROL_PORT_ETHERTYPE)
+ C2S(NL80211_ATTR_CONTROL_PORT_NO_ENCRYPT)
+
+ C2S(NL80211_ATTR_SUPPORT_IBSS_RSN)
+
+ C2S(NL80211_ATTR_WIPHY_ANTENNA_TX)
+ C2S(NL80211_ATTR_WIPHY_ANTENNA_RX)
+
+ C2S(NL80211_ATTR_MCAST_RATE)
+
+ C2S(NL80211_ATTR_OFFCHANNEL_TX_OK)
+
+ C2S(NL80211_ATTR_BSS_HT_OPMODE)
+
+ C2S(NL80211_ATTR_KEY_DEFAULT_TYPES)
+
+ C2S(NL80211_ATTR_MAX_REMAIN_ON_CHANNEL_DURATION)
+
+ C2S(NL80211_ATTR_MESH_SETUP)
+
+ C2S(NL80211_ATTR_WIPHY_ANTENNA_AVAIL_TX)
+ C2S(NL80211_ATTR_WIPHY_ANTENNA_AVAIL_RX)
+
+ C2S(NL80211_ATTR_SUPPORT_MESH_AUTH)
+ C2S(NL80211_ATTR_STA_PLINK_STATE)
+
+ C2S(NL80211_ATTR_WOWLAN_TRIGGERS)
+ C2S(NL80211_ATTR_WOWLAN_TRIGGERS_SUPPORTED)
+
+ C2S(NL80211_ATTR_SCHED_SCAN_INTERVAL)
+
+ C2S(NL80211_ATTR_INTERFACE_COMBINATIONS)
+ C2S(NL80211_ATTR_SOFTWARE_IFTYPES)
+
+ C2S(NL80211_ATTR_REKEY_DATA)
+
+ C2S(NL80211_ATTR_MAX_NUM_SCHED_SCAN_SSIDS)
+ C2S(NL80211_ATTR_MAX_SCHED_SCAN_IE_LEN)
+
+ C2S(NL80211_ATTR_SCAN_SUPP_RATES)
+
+ C2S(NL80211_ATTR_HIDDEN_SSID)
+
+ C2S(NL80211_ATTR_IE_PROBE_RESP)
+ C2S(NL80211_ATTR_IE_ASSOC_RESP)
+
+ C2S(NL80211_ATTR_STA_WME)
+ C2S(NL80211_ATTR_SUPPORT_AP_UAPSD)
+
+ C2S(NL80211_ATTR_ROAM_SUPPORT)
+
+ C2S(NL80211_ATTR_SCHED_SCAN_MATCH)
+ C2S(NL80211_ATTR_MAX_MATCH_SETS)
+
+ C2S(NL80211_ATTR_PMKSA_CANDIDATE)
+
+ C2S(NL80211_ATTR_TX_NO_CCK_RATE)
+
+ C2S(NL80211_ATTR_TDLS_ACTION)
+ C2S(NL80211_ATTR_TDLS_DIALOG_TOKEN)
+ C2S(NL80211_ATTR_TDLS_OPERATION)
+ C2S(NL80211_ATTR_TDLS_SUPPORT)
+ C2S(NL80211_ATTR_TDLS_EXTERNAL_SETUP)
+
+ C2S(NL80211_ATTR_DEVICE_AP_SME)
+
+ C2S(NL80211_ATTR_DONT_WAIT_FOR_ACK)
+
+ C2S(NL80211_ATTR_FEATURE_FLAGS)
+
+ C2S(NL80211_ATTR_PROBE_RESP_OFFLOAD)
+
+ C2S(NL80211_ATTR_PROBE_RESP)
+
+ C2S(NL80211_ATTR_DFS_REGION)
+
+ C2S(NL80211_ATTR_DISABLE_HT)
+ C2S(NL80211_ATTR_HT_CAPABILITY_MASK)
+
+ C2S(NL80211_ATTR_NOACK_MAP)
+
+ C2S(NL80211_ATTR_INACTIVITY_TIMEOUT)
+
+ C2S(NL80211_ATTR_RX_SIGNAL_DBM)
+
+ C2S(NL80211_ATTR_BG_SCAN_PERIOD)
+
+ C2S(NL80211_ATTR_WDEV)
+
+ C2S(NL80211_ATTR_USER_REG_HINT_TYPE)
+
+ C2S(NL80211_ATTR_CONN_FAILED_REASON)
+
+ C2S(NL80211_ATTR_SAE_DATA)
+
+ C2S(NL80211_ATTR_VHT_CAPABILITY)
+
+ C2S(NL80211_ATTR_SCAN_FLAGS)
+
+ C2S(NL80211_ATTR_CHANNEL_WIDTH)
+ C2S(NL80211_ATTR_CENTER_FREQ1)
+ C2S(NL80211_ATTR_CENTER_FREQ2)
+
+ C2S(NL80211_ATTR_P2P_CTWINDOW)
+ C2S(NL80211_ATTR_P2P_OPPPS)
+
+ C2S(NL80211_ATTR_LOCAL_MESH_POWER_MODE)
+
+ C2S(NL80211_ATTR_ACL_POLICY)
+
+ C2S(NL80211_ATTR_MAC_ADDRS)
+
+ C2S(NL80211_ATTR_MAC_ACL_MAX)
+
+ C2S(NL80211_ATTR_RADAR_EVENT)
+
+ C2S(NL80211_ATTR_EXT_CAPA)
+ C2S(NL80211_ATTR_EXT_CAPA_MASK)
+
+ C2S(NL80211_ATTR_STA_CAPABILITY)
+ C2S(NL80211_ATTR_STA_EXT_CAPABILITY)
+
+ C2S(NL80211_ATTR_PROTOCOL_FEATURES)
+ C2S(NL80211_ATTR_SPLIT_WIPHY_DUMP)
+
+ C2S(NL80211_ATTR_DISABLE_VHT)
+ C2S(NL80211_ATTR_VHT_CAPABILITY_MASK)
+
+ C2S(NL80211_ATTR_MDID)
+ C2S(NL80211_ATTR_IE_RIC)
+
+ C2S(NL80211_ATTR_CRIT_PROT_ID)
+ C2S(NL80211_ATTR_MAX_CRIT_PROT_DURATION)
+
+ C2S(NL80211_ATTR_PEER_AID)
+
+
+ //S(NL80211_ATTR_VENDOR_ID)
+ C2S(NL80211_ATTR_VENDOR_SUBCMD)
+ C2S(NL80211_ATTR_VENDOR_DATA)
+ C2S(NL80211_ATTR_VENDOR_EVENTS)
+
+ default:
+ return "NL80211_ATTR_UNKNOWN";
+ }
+}
+
+void WifiEvent::log() {
+ parse();
+
+ byte *data = (byte *)genlmsg_attrdata(mHeader, 0);
+ int len = genlmsg_attrlen(mHeader, 0);
+ ALOGD("cmd = %s, len = %d", get_cmdString(), len);
+ ALOGD("vendor_id = %04x, vendor_subcmd = %d", get_vendor_id(), get_vendor_subcmd());
+
+ for (int i = 0; i < len; i += 16) {
+ char line[81];
+ int linelen = min(16, len - i);
+ int offset = 0;
+ appendFmt(line, offset, "%02x", data[i]);
+ for (int j = 1; j < linelen; j++) {
+ appendFmt(line, offset, " %02x", data[i+j]);
+ }
+
+ for (int j = linelen; j < 16; j++) {
+ appendFmt(line, offset, " ");
+ }
+
+ line[23] = '-';
+
+ appendFmt(line, offset, " ");
+
+ for (int j = 0; j < linelen; j++) {
+ if (isprint(data[i+j])) {
+ appendFmt(line, offset, "%c", data[i+j]);
+ } else {
+ appendFmt(line, offset, "-");
+ }
+ }
+
+ ALOGD("%s", line);
+ }
+
+ for (unsigned i = 0; i < NL80211_ATTR_MAX_INTERNAL; i++) {
+ if (mAttributes[i] != NULL) {
+ ALOGD("found attribute %s", attributeToString(i));
+ }
+ }
+
+ ALOGD("-- End of message --");
+}
+
+const char *WifiEvent::get_cmdString() {
+ return cmdToString(get_cmd());
+}
+
+
+int WifiEvent::parse() {
+ if (mHeader != NULL) {
+ return WIFI_SUCCESS;
+ }
+ mHeader = (genlmsghdr *)nlmsg_data(nlmsg_hdr(mMsg));
+ int result = nla_parse(mAttributes, NL80211_ATTR_MAX_INTERNAL, genlmsg_attrdata(mHeader, 0),
+ genlmsg_attrlen(mHeader, 0), NULL);
+
+ ALOGD("event len = %d", nlmsg_hdr(mMsg)->nlmsg_len);
+ return result;
+}
+
+int WifiRequest::create(int family, uint8_t cmd, int flags, int hdrlen) {
+ mMsg = nlmsg_alloc();
+ if (mMsg != NULL) {
+ genlmsg_put(mMsg, /* pid = */ 0, /* seq = */ 0, family,
+ hdrlen, flags, cmd, /* version = */ 0);
+ return WIFI_SUCCESS;
+ } else {
+ return WIFI_ERROR_OUT_OF_MEMORY;
+ }
+}
+
+int WifiRequest::create(uint32_t id, int subcmd) {
+ int res = create(NL80211_CMD_VENDOR);
+ if (res < 0) {
+ return res;
+ }
+
+ res = put_u32(NL80211_ATTR_VENDOR_ID, id);
+ if (res < 0) {
+ return res;
+ }
+
+ res = put_u32(NL80211_ATTR_VENDOR_SUBCMD, subcmd);
+ if (res < 0) {
+ return res;
+ }
+
+ if (mIface != -1) {
+ res = set_iface_id(mIface);
+ }
+
+ return res;
+}
+
+
+static int no_seq_check(struct nl_msg *msg, void *arg)
+{
+ return NL_OK;
+}
+
+int WifiCommand::requestResponse() {
+ int err = create(); /* create the message */
+ if (err < 0) {
+ return err;
+ }
+
+ return requestResponse(mMsg);
+}
+
+int WifiCommand::requestResponse(WifiRequest& request) {
+ int err = 0;
+
+ struct nl_cb *cb = nl_cb_alloc(NL_CB_DEFAULT);
+ if (!cb)
+ goto out;
+
+ err = nl_send_auto_complete(mInfo->cmd_sock, request.getMessage()); /* send message */
+ if (err < 0)
+ goto out;
+
+ err = 1;
+
+ nl_cb_set(cb, NL_CB_SEQ_CHECK, NL_CB_CUSTOM, no_seq_check, NULL);
+ nl_cb_err(cb, NL_CB_CUSTOM, error_handler, &err);
+ nl_cb_set(cb, NL_CB_FINISH, NL_CB_CUSTOM, finish_handler, &err);
+ nl_cb_set(cb, NL_CB_ACK, NL_CB_CUSTOM, ack_handler, &err);
+ nl_cb_set(cb, NL_CB_VALID, NL_CB_CUSTOM, response_handler, this);
+
+ while (err > 0) { /* wait for reply */
+ int res = nl_recvmsgs(mInfo->cmd_sock, cb);
+ if (res) {
+ ALOGE("nl80211: %s->nl_recvmsgs failed: %d", __func__, res);
+ }
+ }
+out:
+ nl_cb_put(cb);
+ return err;
+}
+
+int WifiCommand::requestEvent(int cmd) {
+
+ ALOGD("requesting event %d", cmd);
+
+ int res = wifi_register_handler(wifiHandle(), cmd, event_handler, this);
+ if (res < 0) {
+ return res;
+ }
+
+ res = create(); /* create the message */
+ if (res < 0)
+ goto out;
+
+ ALOGD("waiting for response %d", cmd);
+
+ res = nl_send_auto_complete(mInfo->cmd_sock, mMsg.getMessage()); /* send message */
+ if (res < 0)
+ goto out;
+
+ ALOGD("waiting for event %d", cmd);
+ res = mCondition.wait();
+ if (res < 0)
+ goto out;
+
+out:
+ wifi_unregister_handler(wifiHandle(), cmd);
+ return res;
+}
+
+int WifiCommand::requestVendorEvent(uint32_t id, int subcmd) {
+
+ int res = wifi_register_vendor_handler(wifiHandle(), id, subcmd, event_handler, this);
+ if (res < 0) {
+ return res;
+ }
+
+ res = create(); /* create the message */
+ if (res < 0)
+ goto out;
+
+ res = nl_send_auto_complete(mInfo->cmd_sock, mMsg.getMessage()); /* send message */
+ if (res < 0)
+ goto out;
+
+ res = mCondition.wait();
+ if (res < 0)
+ goto out;
+
+out:
+ wifi_unregister_vendor_handler(wifiHandle(), id, subcmd);
+ return res;
+}
+
+/* Event handlers */
+int WifiCommand::response_handler(struct nl_msg *msg, void *arg) {
+ ALOGD("response_handler called");
+ WifiCommand *cmd = (WifiCommand *)arg;
+ WifiEvent reply(msg);
+ int res = reply.parse();
+ if (res < 0) {
+ ALOGE("Failed to parse reply message = %d", res);
+ return NL_SKIP;
+ } else {
+ // reply.log();
+ return cmd->handleResponse(reply);
+ }
+}
+
+int WifiCommand::event_handler(struct nl_msg *msg, void *arg) {
+ WifiCommand *cmd = (WifiCommand *)arg;
+ WifiEvent event(msg);
+ int res = event.parse();
+ if (res < 0) {
+ ALOGE("Failed to parse event = %d", res);
+ res = NL_SKIP;
+ } else {
+ res = cmd->handleEvent(event);
+ }
+
+ cmd->mCondition.signal();
+ return res;
+}
+
+/* Other event handlers */
+int WifiCommand::valid_handler(struct nl_msg *msg, void *arg) {
+ ALOGD("valid_handler called");
+ int *err = (int *)arg;
+ *err = 0;
+ return NL_SKIP;
+}
+
+int WifiCommand::ack_handler(struct nl_msg *msg, void *arg) {
+ ALOGD("ack_handler called");
+ int *err = (int *)arg;
+ *err = 0;
+ return NL_STOP;
+}
+
+int WifiCommand::finish_handler(struct nl_msg *msg, void *arg) {
+ ALOGD("finish_handler called");
+ int *ret = (int *)arg;
+ *ret = 0;
+ return NL_SKIP;
+}
+
+int WifiCommand::error_handler(struct sockaddr_nl *nla, struct nlmsgerr *err, void *arg) {
+ int *ret = (int *)arg;
+ *ret = err->error;
+
+ ALOGD("error_handler received : %d", err->error);
+ return NL_SKIP;
+}
-\r
-#include "wifi_hal.h"\r
-#include "common.h"\r
-#include "sync.h"\r
-\r
-class WifiEvent\r
-{\r
- /* TODO: remove this when nl headers are updated */\r
- static const unsigned NL80211_ATTR_MAX_INTERNAL = 256;\r
-private:\r
- struct nl_msg *mMsg;\r
- struct genlmsghdr *mHeader;\r
- struct nlattr *mAttributes[NL80211_ATTR_MAX_INTERNAL + 1];\r
-\r
-public:\r
- WifiEvent(nl_msg *msg) {\r
- mMsg = msg;\r
- mHeader = NULL;\r
- memset(mAttributes, 0, sizeof(mAttributes));\r
- }\r
- ~WifiEvent() {\r
- /* don't destroy mMsg; it doesn't belong to us */\r
- }\r
-\r
- void log();\r
-\r
- int parse();\r
-\r
- genlmsghdr *header() {\r
- return mHeader;\r
- }\r
-\r
- int get_cmd() {\r
- return mHeader->cmd;\r
- }\r
-\r
- int get_vendor_id() {\r
- return get_u32(NL80211_ATTR_VENDOR_ID);\r
- }\r
-\r
- int get_vendor_subcmd() {\r
- return get_u32(NL80211_ATTR_VENDOR_SUBCMD);\r
- }\r
-\r
- void *get_vendor_data() {\r
- return get_data(NL80211_ATTR_VENDOR_DATA);\r
- }\r
-\r
- int get_vendor_data_len() {\r
- return get_len(NL80211_ATTR_VENDOR_DATA);\r
- }\r
-\r
- const char *get_cmdString();\r
-\r
- nlattr ** attributes() {\r
- return mAttributes;\r
- }\r
-\r
- nlattr *get_attribute(int attribute) {\r
- return mAttributes[attribute];\r
- }\r
-\r
- uint8_t get_u8(int attribute) {\r
- return mAttributes[attribute] ? nla_get_u8(mAttributes[attribute]) : 0;\r
- }\r
-\r
- uint16_t get_u16(int attribute) {\r
- return mAttributes[attribute] ? nla_get_u16(mAttributes[attribute]) : 0;\r
- }\r
-\r
- uint32_t get_u32(int attribute) {\r
- return mAttributes[attribute] ? nla_get_u32(mAttributes[attribute]) : 0;\r
- }\r
-\r
- uint64_t get_u64(int attribute) {\r
- return mAttributes[attribute] ? nla_get_u64(mAttributes[attribute]) : 0;\r
- }\r
-\r
- int get_len(int attribute) {\r
- return mAttributes[attribute] ? nla_len(mAttributes[attribute]) : 0;\r
- }\r
-\r
- void *get_data(int attribute) {\r
- return mAttributes[attribute] ? nla_data(mAttributes[attribute]) : NULL;\r
- }\r
-\r
-private:\r
- WifiEvent(const WifiEvent&); // hide copy constructor to prevent copies\r
-};\r
-\r
-class nl_iterator {\r
- struct nlattr *pos;\r
- int rem;\r
-public:\r
- nl_iterator(struct nlattr *attr) {\r
- pos = (struct nlattr *)nla_data(attr);\r
- rem = nla_len(attr);\r
- }\r
- bool has_next() {\r
- return nla_ok(pos, rem);\r
- }\r
- void next() {\r
- pos = (struct nlattr *)nla_next(pos, &(rem));\r
- }\r
- struct nlattr *get() {\r
- return pos;\r
- }\r
- uint16_t get_type() {\r
- return pos->nla_type;\r
- }\r
- uint8_t get_u8() {\r
- return nla_get_u8(pos);\r
- }\r
- uint16_t get_u16() {\r
- return nla_get_u16(pos);\r
- }\r
- uint32_t get_u32() {\r
- return nla_get_u32(pos);\r
- }\r
- uint64_t get_u64() {\r
- return nla_get_u64(pos);\r
- }\r
- void* get_data() {\r
- return nla_data(pos);\r
- }\r
- int get_len() {\r
- return nla_len(pos);\r
- }\r
-private:\r
- nl_iterator(const nl_iterator&); // hide copy constructor to prevent copies\r
-};\r
-\r
-class WifiRequest\r
-{\r
-private:\r
- int mFamily;\r
- int mIface;\r
- struct nl_msg *mMsg;\r
-\r
-public:\r
- WifiRequest(int family) {\r
- mMsg = NULL;\r
- mFamily = family;\r
- mIface = -1;\r
- }\r
-\r
- WifiRequest(int family, int iface) {\r
- mMsg = NULL;\r
- mFamily = family;\r
- mIface = iface;\r
- }\r
-\r
- ~WifiRequest() {\r
- destroy();\r
- }\r
-\r
- void destroy() {\r
- if (mMsg) {\r
- nlmsg_free(mMsg);\r
- mMsg = NULL;\r
- }\r
- }\r
-\r
- nl_msg *getMessage() {\r
- return mMsg;\r
- }\r
-\r
- /* Command assembly helpers */\r
- int create(int family, uint8_t cmd, int flags, int hdrlen);\r
- int create(uint8_t cmd) {\r
- return create(mFamily, cmd, 0, 0);\r
- }\r
-\r
- int create(uint32_t id, int subcmd);\r
-\r
- int put(int attribute, void *ptr, unsigned len) {\r
- return nla_put(mMsg, attribute, len, ptr);\r
- }\r
- int put_u8(int attribute, uint8_t value) {\r
- return nla_put(mMsg, attribute, sizeof(value), &value);\r
- }\r
- int put_u16(int attribute, uint16_t value) {\r
- return nla_put(mMsg, attribute, sizeof(value), &value);\r
- }\r
- int put_u32(int attribute, uint32_t value) {\r
- return nla_put(mMsg, attribute, sizeof(value), &value);\r
- }\r
- int put_u64(int attribute, uint64_t value) {\r
- return nla_put(mMsg, attribute, sizeof(value), &value);\r
- }\r
- int put_string(int attribute, const char *value) {\r
- return nla_put(mMsg, attribute, strlen(value) + 1, value);\r
- }\r
- int put_addr(int attribute, mac_addr value) {\r
- return nla_put(mMsg, attribute, sizeof(mac_addr), value);\r
- }\r
-\r
- struct nlattr * attr_start(int attribute) {\r
- return nla_nest_start(mMsg, attribute);\r
- }\r
- void attr_end(struct nlattr *attr) {\r
- nla_nest_end(mMsg, attr);\r
- }\r
-\r
- int set_iface_id(int ifindex) {\r
- return put_u32(NL80211_ATTR_IFINDEX, ifindex);\r
- }\r
-private:\r
- WifiRequest(const WifiRequest&); // hide copy constructor to prevent copies\r
-\r
-};\r
-\r
-class WifiCommand\r
-{\r
-protected:\r
- hal_info *mInfo;\r
- WifiRequest mMsg;\r
- Condition mCondition;\r
- wifi_request_id mId;\r
- interface_info *mIfaceInfo;\r
- int mRefs;\r
-public:\r
- WifiCommand(wifi_handle handle, wifi_request_id id)\r
- : mMsg(getHalInfo(handle)->nl80211_family_id), mId(id), mRefs(1)\r
- {\r
- mIfaceInfo = NULL;\r
- mInfo = getHalInfo(handle);\r
- // ALOGD("WifiCommand %p created, mInfo = %p, mIfaceInfo = %p", this, mInfo, mIfaceInfo);\r
- }\r
-\r
- WifiCommand(wifi_interface_handle iface, wifi_request_id id)\r
- : mMsg(getHalInfo(iface)->nl80211_family_id, getIfaceInfo(iface)->id), mId(id), mRefs(1)\r
- {\r
- mIfaceInfo = getIfaceInfo(iface);\r
- mInfo = getHalInfo(iface);\r
- // ALOGD("WifiCommand %p created, mInfo = %p, mIfaceInfo = %p", this, mInfo, mIfaceInfo);\r
- }\r
-\r
- virtual ~WifiCommand() {\r
- // ALOGD("WifiCommand %p destroyed", this);\r
- }\r
-\r
- wifi_request_id id() {\r
- return mId;\r
- }\r
-\r
- virtual void addRef() {\r
- int refs = __sync_add_and_fetch(&mRefs, 1);\r
- // ALOGD("addRef: WifiCommand %p has %d references", this, refs);\r
- }\r
-\r
- virtual void releaseRef() {\r
- int refs = __sync_sub_and_fetch(&mRefs, 1);\r
- if (refs == 0) {\r
- delete this;\r
- } else {\r
- // ALOGD("releaseRef: WifiCommand %p has %d references", this, refs);\r
- }\r
- }\r
-\r
- virtual int create() {\r
- /* by default there is no way to cancel */\r
- ALOGD("WifiCommand %p can't be created", this);\r
- return WIFI_ERROR_NOT_SUPPORTED;\r
- }\r
-\r
- virtual int cancel() {\r
- /* by default there is no way to cancel */\r
- return WIFI_ERROR_NOT_SUPPORTED;\r
- }\r
-\r
- int requestResponse();\r
- int requestEvent(int cmd);\r
- int requestVendorEvent(uint32_t id, int subcmd);\r
- int requestResponse(WifiRequest& request);\r
-\r
-protected:\r
- wifi_handle wifiHandle() {\r
- return getWifiHandle(mInfo);\r
- }\r
-\r
- wifi_interface_handle ifaceHandle() {\r
- return getIfaceHandle(mIfaceInfo);\r
- }\r
-\r
- int familyId() {\r
- return mInfo->nl80211_family_id;\r
- }\r
-\r
- int ifaceId() {\r
- return mIfaceInfo->id;\r
- }\r
-\r
- /* Override this method to parse reply and dig out data; save it in the object */\r
- virtual int handleResponse(WifiEvent& reply) {\r
- ALOGI("skipping a response");\r
- return NL_SKIP;\r
- }\r
-\r
- /* Override this method to parse event and dig out data; save it in the object */\r
- virtual int handleEvent(WifiEvent& event) {\r
- ALOGI("skipping an event");\r
- return NL_SKIP;\r
- }\r
-\r
- int registerHandler(int cmd) {\r
- return wifi_register_handler(wifiHandle(), cmd, &event_handler, this);\r
- }\r
-\r
- void unregisterHandler(int cmd) {\r
- wifi_unregister_handler(wifiHandle(), cmd);\r
- }\r
-\r
- int registerVendorHandler(uint32_t id, int subcmd) {\r
- return wifi_register_vendor_handler(wifiHandle(), id, subcmd, &event_handler, this);\r
- }\r
-\r
- void unregisterVendorHandler(uint32_t id, int subcmd) {\r
- wifi_unregister_vendor_handler(wifiHandle(), id, subcmd);\r
- }\r
-\r
-private:\r
- WifiCommand(const WifiCommand& ); // hide copy constructor to prevent copies\r
-\r
- /* Event handling */\r
- static int response_handler(struct nl_msg *msg, void *arg);\r
-\r
- static int event_handler(struct nl_msg *msg, void *arg);\r
-\r
- /* Other event handlers */\r
- static int valid_handler(struct nl_msg *msg, void *arg);\r
-\r
- static int ack_handler(struct nl_msg *msg, void *arg);\r
-\r
- static int finish_handler(struct nl_msg *msg, void *arg);\r
-\r
- static int error_handler(struct sockaddr_nl *nla, struct nlmsgerr *err, void *arg);\r
-};\r
-\r
-/* nl message processing macros (required to pass C++ type checks) */\r
-\r
-#define for_each_attr(pos, nla, rem) \\r
- for (pos = (nlattr *)nla_data(nla), rem = nla_len(nla); \\r
- nla_ok(pos, rem); \\r
- pos = (nlattr *)nla_next(pos, &(rem)))\r
-\r
+
+#include "wifi_hal.h"
+#include "common.h"
+#include "sync.h"
+
+class WifiEvent
+{
+ /* TODO: remove this when nl headers are updated */
+ static const unsigned NL80211_ATTR_MAX_INTERNAL = 256;
+private:
+ struct nl_msg *mMsg;
+ struct genlmsghdr *mHeader;
+ struct nlattr *mAttributes[NL80211_ATTR_MAX_INTERNAL + 1];
+
+public:
+ WifiEvent(nl_msg *msg) {
+ mMsg = msg;
+ mHeader = NULL;
+ memset(mAttributes, 0, sizeof(mAttributes));
+ }
+ ~WifiEvent() {
+ /* don't destroy mMsg; it doesn't belong to us */
+ }
+
+ void log();
+
+ int parse();
+
+ genlmsghdr *header() {
+ return mHeader;
+ }
+
+ int get_cmd() {
+ return mHeader->cmd;
+ }
+
+ int get_vendor_id() {
+ return get_u32(NL80211_ATTR_VENDOR_ID);
+ }
+
+ int get_vendor_subcmd() {
+ return get_u32(NL80211_ATTR_VENDOR_SUBCMD);
+ }
+
+ void *get_vendor_data() {
+ return get_data(NL80211_ATTR_VENDOR_DATA);
+ }
+
+ int get_vendor_data_len() {
+ return get_len(NL80211_ATTR_VENDOR_DATA);
+ }
+
+ const char *get_cmdString();
+
+ nlattr ** attributes() {
+ return mAttributes;
+ }
+
+ nlattr *get_attribute(int attribute) {
+ return mAttributes[attribute];
+ }
+
+ uint8_t get_u8(int attribute) {
+ return mAttributes[attribute] ? nla_get_u8(mAttributes[attribute]) : 0;
+ }
+
+ uint16_t get_u16(int attribute) {
+ return mAttributes[attribute] ? nla_get_u16(mAttributes[attribute]) : 0;
+ }
+
+ uint32_t get_u32(int attribute) {
+ return mAttributes[attribute] ? nla_get_u32(mAttributes[attribute]) : 0;
+ }
+
+ uint64_t get_u64(int attribute) {
+ return mAttributes[attribute] ? nla_get_u64(mAttributes[attribute]) : 0;
+ }
+
+ int get_len(int attribute) {
+ return mAttributes[attribute] ? nla_len(mAttributes[attribute]) : 0;
+ }
+
+ void *get_data(int attribute) {
+ return mAttributes[attribute] ? nla_data(mAttributes[attribute]) : NULL;
+ }
+
+private:
+ WifiEvent(const WifiEvent&); // hide copy constructor to prevent copies
+};
+
+class nl_iterator {
+ struct nlattr *pos;
+ int rem;
+public:
+ nl_iterator(struct nlattr *attr) {
+ pos = (struct nlattr *)nla_data(attr);
+ rem = nla_len(attr);
+ }
+ bool has_next() {
+ return nla_ok(pos, rem);
+ }
+ void next() {
+ pos = (struct nlattr *)nla_next(pos, &(rem));
+ }
+ struct nlattr *get() {
+ return pos;
+ }
+ uint16_t get_type() {
+ return pos->nla_type;
+ }
+ uint8_t get_u8() {
+ return nla_get_u8(pos);
+ }
+ uint16_t get_u16() {
+ return nla_get_u16(pos);
+ }
+ uint32_t get_u32() {
+ return nla_get_u32(pos);
+ }
+ uint64_t get_u64() {
+ return nla_get_u64(pos);
+ }
+ void* get_data() {
+ return nla_data(pos);
+ }
+ int get_len() {
+ return nla_len(pos);
+ }
+private:
+ nl_iterator(const nl_iterator&); // hide copy constructor to prevent copies
+};
+
+class WifiRequest
+{
+private:
+ int mFamily;
+ int mIface;
+ struct nl_msg *mMsg;
+
+public:
+ WifiRequest(int family) {
+ mMsg = NULL;
+ mFamily = family;
+ mIface = -1;
+ }
+
+ WifiRequest(int family, int iface) {
+ mMsg = NULL;
+ mFamily = family;
+ mIface = iface;
+ }
+
+ ~WifiRequest() {
+ destroy();
+ }
+
+ void destroy() {
+ if (mMsg) {
+ nlmsg_free(mMsg);
+ mMsg = NULL;
+ }
+ }
+
+ nl_msg *getMessage() {
+ return mMsg;
+ }
+
+ /* Command assembly helpers */
+ int create(int family, uint8_t cmd, int flags, int hdrlen);
+ int create(uint8_t cmd) {
+ return create(mFamily, cmd, 0, 0);
+ }
+
+ int create(uint32_t id, int subcmd);
+
+ int put(int attribute, void *ptr, unsigned len) {
+ return nla_put(mMsg, attribute, len, ptr);
+ }
+ int put_u8(int attribute, uint8_t value) {
+ return nla_put(mMsg, attribute, sizeof(value), &value);
+ }
+ int put_u16(int attribute, uint16_t value) {
+ return nla_put(mMsg, attribute, sizeof(value), &value);
+ }
+ int put_u32(int attribute, uint32_t value) {
+ return nla_put(mMsg, attribute, sizeof(value), &value);
+ }
+ int put_u64(int attribute, uint64_t value) {
+ return nla_put(mMsg, attribute, sizeof(value), &value);
+ }
+ int put_string(int attribute, const char *value) {
+ return nla_put(mMsg, attribute, strlen(value) + 1, value);
+ }
+ int put_addr(int attribute, mac_addr value) {
+ return nla_put(mMsg, attribute, sizeof(mac_addr), value);
+ }
+
+ struct nlattr * attr_start(int attribute) {
+ return nla_nest_start(mMsg, attribute);
+ }
+ void attr_end(struct nlattr *attr) {
+ nla_nest_end(mMsg, attr);
+ }
+
+ int set_iface_id(int ifindex) {
+ return put_u32(NL80211_ATTR_IFINDEX, ifindex);
+ }
+private:
+ WifiRequest(const WifiRequest&); // hide copy constructor to prevent copies
+
+};
+
+class WifiCommand
+{
+protected:
+ hal_info *mInfo;
+ WifiRequest mMsg;
+ Condition mCondition;
+ wifi_request_id mId;
+ interface_info *mIfaceInfo;
+ int mRefs;
+public:
+ WifiCommand(wifi_handle handle, wifi_request_id id)
+ : mMsg(getHalInfo(handle)->nl80211_family_id), mId(id), mRefs(1)
+ {
+ mIfaceInfo = NULL;
+ mInfo = getHalInfo(handle);
+ // ALOGD("WifiCommand %p created, mInfo = %p, mIfaceInfo = %p", this, mInfo, mIfaceInfo);
+ }
+
+ WifiCommand(wifi_interface_handle iface, wifi_request_id id)
+ : mMsg(getHalInfo(iface)->nl80211_family_id, getIfaceInfo(iface)->id), mId(id), mRefs(1)
+ {
+ mIfaceInfo = getIfaceInfo(iface);
+ mInfo = getHalInfo(iface);
+ // ALOGD("WifiCommand %p created, mInfo = %p, mIfaceInfo = %p", this, mInfo, mIfaceInfo);
+ }
+
+ virtual ~WifiCommand() {
+ // ALOGD("WifiCommand %p destroyed", this);
+ }
+
+ wifi_request_id id() {
+ return mId;
+ }
+
+ virtual void addRef() {
+ int refs = __sync_add_and_fetch(&mRefs, 1);
+ // ALOGD("addRef: WifiCommand %p has %d references", this, refs);
+ }
+
+ virtual void releaseRef() {
+ int refs = __sync_sub_and_fetch(&mRefs, 1);
+ if (refs == 0) {
+ delete this;
+ } else {
+ // ALOGD("releaseRef: WifiCommand %p has %d references", this, refs);
+ }
+ }
+
+ virtual int create() {
+ /* by default there is no way to cancel */
+ ALOGD("WifiCommand %p can't be created", this);
+ return WIFI_ERROR_NOT_SUPPORTED;
+ }
+
+ virtual int cancel() {
+ /* by default there is no way to cancel */
+ return WIFI_ERROR_NOT_SUPPORTED;
+ }
+
+ int requestResponse();
+ int requestEvent(int cmd);
+ int requestVendorEvent(uint32_t id, int subcmd);
+ int requestResponse(WifiRequest& request);
+
+protected:
+ wifi_handle wifiHandle() {
+ return getWifiHandle(mInfo);
+ }
+
+ wifi_interface_handle ifaceHandle() {
+ return getIfaceHandle(mIfaceInfo);
+ }
+
+ int familyId() {
+ return mInfo->nl80211_family_id;
+ }
+
+ int ifaceId() {
+ return mIfaceInfo->id;
+ }
+
+ /* Override this method to parse reply and dig out data; save it in the object */
+ virtual int handleResponse(WifiEvent& reply) {
+ ALOGI("skipping a response");
+ return NL_SKIP;
+ }
+
+ /* Override this method to parse event and dig out data; save it in the object */
+ virtual int handleEvent(WifiEvent& event) {
+ ALOGI("skipping an event");
+ return NL_SKIP;
+ }
+
+ int registerHandler(int cmd) {
+ return wifi_register_handler(wifiHandle(), cmd, &event_handler, this);
+ }
+
+ void unregisterHandler(int cmd) {
+ wifi_unregister_handler(wifiHandle(), cmd);
+ }
+
+ int registerVendorHandler(uint32_t id, int subcmd) {
+ return wifi_register_vendor_handler(wifiHandle(), id, subcmd, &event_handler, this);
+ }
+
+ void unregisterVendorHandler(uint32_t id, int subcmd) {
+ wifi_unregister_vendor_handler(wifiHandle(), id, subcmd);
+ }
+
+private:
+ WifiCommand(const WifiCommand& ); // hide copy constructor to prevent copies
+
+ /* Event handling */
+ static int response_handler(struct nl_msg *msg, void *arg);
+
+ static int event_handler(struct nl_msg *msg, void *arg);
+
+ /* Other event handlers */
+ static int valid_handler(struct nl_msg *msg, void *arg);
+
+ static int ack_handler(struct nl_msg *msg, void *arg);
+
+ static int finish_handler(struct nl_msg *msg, void *arg);
+
+ static int error_handler(struct sockaddr_nl *nla, struct nlmsgerr *err, void *arg);
+};
+
+/* nl message processing macros (required to pass C++ type checks) */
+
+#define for_each_attr(pos, nla, rem) \
+ for (pos = (nlattr *)nla_data(nla), rem = nla_len(nla); \
+ nla_ok(pos, rem); \
+ pos = (nlattr *)nla_next(pos, &(rem)))
+
-\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/handlers.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
-typedef enum {\r
-\r
- GSCAN_ATTRIBUTE_NUM_BUCKETS = 10,\r
- GSCAN_ATTRIBUTE_BASE_PERIOD,\r
- GSCAN_ATTRIBUTE_BUCKETS_BAND,\r
- GSCAN_ATTRIBUTE_BUCKET_ID,\r
- GSCAN_ATTRIBUTE_BUCKET_PERIOD,\r
- GSCAN_ATTRIBUTE_BUCKET_NUM_CHANNELS,\r
- GSCAN_ATTRIBUTE_BUCKET_CHANNELS,\r
- GSCAN_ATTRIBUTE_NUM_AP_PER_SCAN,\r
- GSCAN_ATTRIBUTE_REPORT_THRESHOLD,\r
- GSCAN_ATTRIBUTE_NUM_SCANS_TO_CACHE,\r
- GSCAN_ATTRIBUTE_REPORT_THRESHOLD_NUM_SCANS,\r
- GSCAN_ATTRIBUTE_BAND = GSCAN_ATTRIBUTE_BUCKETS_BAND,\r
-\r
- GSCAN_ATTRIBUTE_ENABLE_FEATURE = 20,\r
- GSCAN_ATTRIBUTE_SCAN_RESULTS_COMPLETE, /* indicates no more results */\r
- GSCAN_ATTRIBUTE_REPORT_EVENTS,\r
-\r
- /* remaining reserved for additional attributes */\r
- GSCAN_ATTRIBUTE_NUM_OF_RESULTS = 30,\r
- GSCAN_ATTRIBUTE_SCAN_RESULTS, /* flat array of wifi_scan_result */\r
- GSCAN_ATTRIBUTE_NUM_CHANNELS,\r
- GSCAN_ATTRIBUTE_CHANNEL_LIST,\r
- GSCAN_ATTRIBUTE_SCAN_ID,\r
- GSCAN_ATTRIBUTE_SCAN_FLAGS,\r
-\r
- /* remaining reserved for additional attributes */\r
-\r
- GSCAN_ATTRIBUTE_SSID = 40,\r
- GSCAN_ATTRIBUTE_BSSID,\r
- GSCAN_ATTRIBUTE_CHANNEL,\r
- GSCAN_ATTRIBUTE_RSSI,\r
- GSCAN_ATTRIBUTE_TIMESTAMP,\r
- GSCAN_ATTRIBUTE_RTT,\r
- GSCAN_ATTRIBUTE_RTTSD,\r
-\r
- /* remaining reserved for additional attributes */\r
-\r
- GSCAN_ATTRIBUTE_HOTLIST_BSSIDS = 50,\r
- GSCAN_ATTRIBUTE_RSSI_LOW,\r
- GSCAN_ATTRIBUTE_RSSI_HIGH,\r
- GSCAN_ATTRIBUTE_HOTLIST_ELEM,\r
- GSCAN_ATTRIBUTE_HOTLIST_FLUSH,\r
- GSCAN_ATTRIBUTE_CHANNEL_NUMBER,\r
-\r
- /* remaining reserved for additional attributes */\r
- GSCAN_ATTRIBUTE_RSSI_SAMPLE_SIZE = 60,\r
- GSCAN_ATTRIBUTE_LOST_AP_SAMPLE_SIZE,\r
- GSCAN_ATTRIBUTE_MIN_BREACHING,\r
- GSCAN_ATTRIBUTE_SIGNIFICANT_CHANGE_BSSIDS,\r
-\r
- GSCAN_ATTRIBUTE_MAX\r
-\r
-} GSCAN_ATTRIBUTE;\r
-\r
-\r
-class GetCapabilitiesCommand : public WifiCommand\r
-{\r
- wifi_gscan_capabilities *mCapabilities;\r
-public:\r
- GetCapabilitiesCommand(wifi_interface_handle iface, wifi_gscan_capabilities *capabitlites)\r
- : WifiCommand(iface, 0), mCapabilities(capabitlites)\r
- {\r
- memset(mCapabilities, 0, sizeof(*mCapabilities));\r
- }\r
-\r
- virtual int create() {\r
- ALOGD("Creating message to get scan capablities; iface = %d", mIfaceInfo->id);\r
-\r
- int ret = mMsg.create(GOOGLE_OUI, SLSI_NL80211_VENDOR_SUBCMD_GET_CAPABILITIES);\r
- if (ret < 0) {\r
- ALOGD("NL message creation failed");\r
- return ret;\r
- }\r
-\r
- return ret;\r
- }\r
-\r
-protected:\r
- virtual int handleResponse(WifiEvent& reply) {\r
-\r
- ALOGD("In GetCapabilities::handleResponse");\r
-\r
- if (reply.get_cmd() != NL80211_CMD_VENDOR) {\r
- ALOGD("Ignoring reply with cmd = %d", reply.get_cmd());\r
- return NL_SKIP;\r
- }\r
-\r
- int id = reply.get_vendor_id();\r
- int subcmd = reply.get_vendor_subcmd();\r
-\r
- void *data = reply.get_vendor_data();\r
- int len = reply.get_vendor_data_len();\r
-\r
- ALOGD("Id = %0x, subcmd = %d, len = %d, expected len = %d", id, subcmd, len,\r
- sizeof(*mCapabilities));\r
-\r
- memcpy(mCapabilities, data, min(len, (int) sizeof(*mCapabilities)));\r
-\r
- return NL_OK;\r
- }\r
-};\r
-\r
-\r
-wifi_error wifi_get_gscan_capabilities(wifi_interface_handle handle,\r
- wifi_gscan_capabilities *capabilities)\r
-{\r
- GetCapabilitiesCommand command(handle, capabilities);\r
- return (wifi_error) command.requestResponse();\r
-}\r
-\r
-class GetChannelListCommand : public WifiCommand\r
-{\r
- wifi_channel *channels;\r
- int max_channels;\r
- int *num_channels;\r
- int band;\r
-public:\r
- GetChannelListCommand(wifi_interface_handle iface, wifi_channel *channel_buf, int *ch_num,\r
- int num_max_ch, int band)\r
- : WifiCommand(iface, 0), channels(channel_buf), max_channels(num_max_ch), num_channels(ch_num),\r
- band(band)\r
- {\r
- memset(channels, 0, sizeof(wifi_channel) * max_channels);\r
- }\r
- virtual int create() {\r
- ALOGD("Creating message to get channel list; iface = %d", mIfaceInfo->id);\r
-\r
- int ret = mMsg.create(GOOGLE_OUI, SLSI_NL80211_VENDOR_SUBCMD_GET_VALID_CHANNELS);\r
- if (ret < 0) {\r
- return ret;\r
- }\r
-\r
- nlattr *data = mMsg.attr_start(NL80211_ATTR_VENDOR_DATA);\r
- ret = mMsg.put_u32(GSCAN_ATTRIBUTE_BAND, band);\r
- if (ret < 0) {\r
- return ret;\r
- }\r
-\r
- mMsg.attr_end(data);\r
-\r
- return ret;\r
- }\r
-\r
-protected:\r
- virtual int handleResponse(WifiEvent& reply) {\r
-\r
- ALOGD("In GetChannelList::handleResponse");\r
-\r
- if (reply.get_cmd() != NL80211_CMD_VENDOR) {\r
- ALOGD("Ignoring reply with cmd = %d", reply.get_cmd());\r
- return NL_SKIP;\r
- }\r
-\r
- int id = reply.get_vendor_id();\r
- int subcmd = reply.get_vendor_subcmd();\r
- int num_channels_to_copy = 0;\r
-\r
- nlattr *vendor_data = reply.get_attribute(NL80211_ATTR_VENDOR_DATA);\r
- int len = reply.get_vendor_data_len();\r
-\r
- ALOGD("Id = %0x, subcmd = %d, len = %d", id, subcmd, len);\r
- if (vendor_data == NULL || len == 0) {\r
- ALOGE("no vendor data in GetChannelList response; ignoring it");\r
- return NL_SKIP;\r
- }\r
-\r
- for (nl_iterator it(vendor_data); it.has_next(); it.next()) {\r
- if (it.get_type() == GSCAN_ATTRIBUTE_NUM_CHANNELS) {\r
- num_channels_to_copy = it.get_u32();\r
- ALOGD("Got channel list with %d channels", num_channels_to_copy);\r
- if(num_channels_to_copy > max_channels)\r
- num_channels_to_copy = max_channels;\r
- *num_channels = num_channels_to_copy;\r
- } else if (it.get_type() == GSCAN_ATTRIBUTE_CHANNEL_LIST && num_channels_to_copy) {\r
- memcpy(channels, it.get_data(), sizeof(int) * num_channels_to_copy);\r
- } else {\r
- ALOGW("Ignoring invalid attribute type = %d, size = %d",\r
- it.get_type(), it.get_len());\r
- }\r
- }\r
-\r
- return NL_OK;\r
- }\r
-};\r
-\r
-wifi_error wifi_get_valid_channels(wifi_interface_handle handle,\r
- int band, int max_channels, wifi_channel *channels, int *num_channels)\r
-{\r
- GetChannelListCommand command(handle, channels, num_channels,\r
- max_channels, band);\r
- return (wifi_error) command.requestResponse();\r
-}\r
-/////////////////////////////////////////////////////////////////////////////\r
-\r
-/* helper functions */\r
-\r
-static int parseScanResults(wifi_scan_result *results, int num, nlattr *attr)\r
-{\r
- memset(results, 0, sizeof(wifi_scan_result) * num);\r
-\r
- int i = 0;\r
- for (nl_iterator it(attr); it.has_next() && i < num; it.next(), i++) {\r
-\r
- int index = it.get_type();\r
- ALOGD("retrieved scan result %d", index);\r
- nlattr *sc_data = (nlattr *) it.get_data();\r
- wifi_scan_result *result = results + i;\r
-\r
- for (nl_iterator it2(sc_data); it2.has_next(); it2.next()) {\r
- int type = it2.get_type();\r
- if (type == GSCAN_ATTRIBUTE_SSID) {\r
- strncpy(result->ssid, (char *) it2.get_data(), it2.get_len());\r
- result->ssid[it2.get_len()] = 0;\r
- } else if (type == GSCAN_ATTRIBUTE_BSSID) {\r
- memcpy(result->bssid, (byte *) it2.get_data(), sizeof(mac_addr));\r
- } else if (type == GSCAN_ATTRIBUTE_TIMESTAMP) {\r
- result->ts = it2.get_u64();\r
- } else if (type == GSCAN_ATTRIBUTE_CHANNEL) {\r
- result->ts = it2.get_u16();\r
- } else if (type == GSCAN_ATTRIBUTE_RSSI) {\r
- result->rssi = it2.get_u8();\r
- } else if (type == GSCAN_ATTRIBUTE_RTT) {\r
- result->rtt = it2.get_u64();\r
- } else if (type == GSCAN_ATTRIBUTE_RTTSD) {\r
- result->rtt_sd = it2.get_u64();\r
- }\r
- }\r
-\r
- }\r
-\r
- if (i >= num) {\r
- ALOGE("Got too many results; skipping some");\r
- }\r
-\r
- return i;\r
-}\r
-\r
-int createFeatureRequest(WifiRequest& request, int subcmd) {\r
-\r
- int result = request.create(GOOGLE_OUI, subcmd);\r
- if (result < 0) {\r
- return result;\r
- }\r
-\r
- return WIFI_SUCCESS;\r
-}\r
-\r
-class ScanCommand : public WifiCommand\r
-{\r
- wifi_scan_cmd_params *mParams;\r
- wifi_scan_result_handler mHandler;\r
- static unsigned mGlobalFullScanBuckets;\r
- bool mLocalFullScanBuckets;\r
-public:\r
- ScanCommand(wifi_interface_handle iface, int id, wifi_scan_cmd_params *params,\r
- wifi_scan_result_handler handler)\r
- : WifiCommand(iface, id), mParams(params), mHandler(handler),\r
- mLocalFullScanBuckets(0)\r
- { }\r
-\r
- int createSetupRequest(WifiRequest& request) {\r
- int result = request.create(GOOGLE_OUI, SLSI_NL80211_VENDOR_SUBCMD_ADD_GSCAN);\r
- if (result < 0) {\r
- return result;\r
- }\r
-\r
- nlattr *data = request.attr_start(NL80211_ATTR_VENDOR_DATA);\r
- result = request.put_u32(GSCAN_ATTRIBUTE_BASE_PERIOD, mParams->base_period);\r
- if (result < 0) {\r
- return result;\r
- }\r
-\r
- result = request.put_u32(GSCAN_ATTRIBUTE_NUM_AP_PER_SCAN, mParams->max_ap_per_scan);\r
- if (result < 0) {\r
- return result;\r
- }\r
-\r
- result = request.put_u32(GSCAN_ATTRIBUTE_REPORT_THRESHOLD, mParams->report_threshold_percent);\r
- if (result < 0) {\r
- return result;\r
- }\r
-\r
- result = request.put_u32(GSCAN_ATTRIBUTE_REPORT_THRESHOLD_NUM_SCANS, mParams->report_threshold_num_scans);\r
- if (result < 0) {\r
- return result;\r
- }\r
-\r
- result = request.put_u32(GSCAN_ATTRIBUTE_NUM_BUCKETS, mParams->num_buckets);\r
- if (result < 0) {\r
- return result;\r
- }\r
-\r
- for (int i = 0; i < mParams->num_buckets; i++) {\r
- nlattr * bucket = request.attr_start(i); // next bucket\r
- result = request.put_u32(GSCAN_ATTRIBUTE_BUCKET_ID, mParams->buckets[i].bucket);\r
- if (result < 0) {\r
- return result;\r
- }\r
- result = request.put_u32(GSCAN_ATTRIBUTE_BUCKET_PERIOD, mParams->buckets[i].period);\r
- if (result < 0) {\r
- return result;\r
- }\r
- result = request.put_u32(GSCAN_ATTRIBUTE_BUCKETS_BAND,\r
- mParams->buckets[i].band);\r
- if (result < 0) {\r
- return result;\r
- }\r
-\r
- result = request.put_u32(GSCAN_ATTRIBUTE_REPORT_EVENTS,\r
- mParams->buckets[i].report_events);\r
- if (result < 0) {\r
- return result;\r
- }\r
-\r
- result = request.put_u32(GSCAN_ATTRIBUTE_BUCKET_NUM_CHANNELS,\r
- mParams->buckets[i].num_channels);\r
- if (result < 0) {\r
- return result;\r
- }\r
-\r
- if (mParams->buckets[i].num_channels) {\r
- nlattr *channels = request.attr_start(GSCAN_ATTRIBUTE_BUCKET_CHANNELS);\r
- for (int j = 0; j < mParams->buckets[i].num_channels; j++) {\r
- result = request.put_u32(j, mParams->buckets[i].channels[j].channel);\r
- if (result < 0) {\r
- return result;\r
- }\r
- }\r
- request.attr_end(channels);\r
- }\r
-\r
- request.attr_end(bucket);\r
- }\r
-\r
- request.attr_end(data);\r
- return WIFI_SUCCESS;\r
- }\r
-\r
- int createStartRequest(WifiRequest& request) {\r
- return createFeatureRequest(request, SLSI_NL80211_VENDOR_SUBCMD_ADD_GSCAN);\r
- }\r
-\r
- int createStopRequest(WifiRequest& request) {\r
- return createFeatureRequest(request, SLSI_NL80211_VENDOR_SUBCMD_DEL_GSCAN);\r
- }\r
-\r
- int start() {\r
- ALOGD(" sending scan req to driver");\r
- WifiRequest request(familyId(), ifaceId());\r
- int result = createSetupRequest(request);\r
- if (result != WIFI_SUCCESS) {\r
- ALOGE("failed to create setup request; result = %d", result);\r
- return result;\r
- }\r
- ALOGD("Starting scan");\r
-\r
- registerVendorHandler(GOOGLE_OUI, GSCAN_EVENT_SCAN_RESULTS_AVAILABLE);\r
- registerVendorHandler(GOOGLE_OUI, GSCAN_EVENT_COMPLETE_SCAN);\r
-\r
- int nBuckets = 0;\r
- for (int i = 0; i < mParams->num_buckets; i++) {\r
- if (mParams->buckets[i].report_events == 2) {\r
- nBuckets++;\r
- }\r
- }\r
-\r
- if (nBuckets != 0) {\r
- ALOGI("Full scan requested with nBuckets = %d", nBuckets);\r
- registerVendorHandler(GOOGLE_OUI, GSCAN_EVENT_FULL_SCAN_RESULTS);\r
- }\r
- result = requestResponse(request);\r
- if (result != WIFI_SUCCESS) {\r
- ALOGE("failed to start scan; result = %d", result);\r
- unregisterVendorHandler(GOOGLE_OUI, GSCAN_EVENT_COMPLETE_SCAN);\r
- unregisterVendorHandler(GOOGLE_OUI, GSCAN_EVENT_SCAN_RESULTS_AVAILABLE);\r
- return result;\r
- }\r
-\r
- \r
- return result;\r
- }\r
-\r
- virtual int cancel() {\r
- ALOGD("Stopping scan");\r
-\r
- WifiRequest request(familyId(), ifaceId());\r
- int result = createStopRequest(request);\r
- if (result != WIFI_SUCCESS) {\r
- ALOGE("failed to create stop request; result = %d", result);\r
- } else {\r
- result = requestResponse(request);\r
- if (result != WIFI_SUCCESS) {\r
- ALOGE("failed to stop scan; result = %d", result);\r
- }\r
- }\r
-\r
- unregisterVendorHandler(GOOGLE_OUI, GSCAN_EVENT_COMPLETE_SCAN);\r
- unregisterVendorHandler(GOOGLE_OUI, GSCAN_EVENT_SCAN_RESULTS_AVAILABLE);\r
- unregisterVendorHandler(GOOGLE_OUI, GSCAN_EVENT_FULL_SCAN_RESULTS);\r
-\r
- return WIFI_SUCCESS;\r
- }\r
-\r
- virtual int handleResponse(WifiEvent& reply) {\r
- /* Nothing to do on response! */\r
- return NL_SKIP;\r
- }\r
-\r
- virtual int handleEvent(WifiEvent& event) {\r
- ALOGD("Got a scan results event");\r
-\r
- event.log();\r
-\r
- nlattr *vendor_data = event.get_attribute(NL80211_ATTR_VENDOR_DATA);\r
- unsigned int len = event.get_vendor_data_len();\r
- int event_id = event.get_vendor_subcmd();\r
- ALOGD("handleEvent, event_id = %d", event_id);\r
-\r
- if(event_id == GSCAN_EVENT_COMPLETE_SCAN) {\r
- if (vendor_data == NULL || len != 4) {\r
- ALOGD("Scan complete type not mentioned!");\r
- return NL_SKIP;\r
- }\r
- wifi_scan_event evt_type;\r
-\r
- evt_type = (wifi_scan_event) event.get_u32(NL80211_ATTR_VENDOR_DATA);\r
- ALOGD("Scan complete: Received event type %d", evt_type);\r
- if(*mHandler.on_scan_event)\r
- (*mHandler.on_scan_event)(evt_type, evt_type);\r
- } else if(event_id == GSCAN_EVENT_FULL_SCAN_RESULTS) {\r
- if (vendor_data == NULL || len < sizeof(wifi_scan_result)) {\r
- ALOGD("No scan results found");\r
- return NL_SKIP;\r
- }\r
- wifi_scan_result *result = (wifi_scan_result *)event.get_vendor_data();\r
-\r
- if(*mHandler.on_full_scan_result)\r
- (*mHandler.on_full_scan_result)(id(), result);\r
-\r
- ALOGD("%-32s\t", result->ssid);\r
-\r
- ALOGD("%02x:%02x:%02x:%02x:%02x:%02x ", result->bssid[0], result->bssid[1],\r
- result->bssid[2], result->bssid[3], result->bssid[4], result->bssid[5]);\r
-\r
- ALOGD("%d\t", result->rssi);\r
- ALOGD("%d\t", result->channel);\r
- ALOGD("%lld\t", result->ts);\r
- ALOGD("%lld\t", result->rtt);\r
- ALOGD("%lld\n", result->rtt_sd);\r
- } else {\r
-\r
- if (vendor_data == NULL || len != 4) {\r
- ALOGD("No scan results found");\r
- return NL_SKIP;\r
- }\r
-\r
- int num = event.get_u32(NL80211_ATTR_VENDOR_DATA);\r
- ALOGD("Found %d scan results", num);\r
- if(*mHandler.on_scan_results_available)\r
- (*mHandler.on_scan_results_available)(id(), num);\r
- }\r
- return NL_SKIP;\r
- }\r
-};\r
-\r
-unsigned ScanCommand::mGlobalFullScanBuckets = 0;\r
-\r
-wifi_error wifi_start_gscan(\r
- wifi_request_id id,\r
- wifi_interface_handle iface,\r
- wifi_scan_cmd_params params,\r
- wifi_scan_result_handler handler)\r
-{\r
- wifi_handle handle = getWifiHandle(iface);\r
-\r
- ALOGD("Starting GScan, halHandle = %p", handle);\r
-\r
- ScanCommand *cmd = new ScanCommand(iface, id, ¶ms, handler);\r
- wifi_register_cmd(handle, id, cmd);\r
- return (wifi_error)cmd->start();\r
-}\r
-\r
-wifi_error wifi_stop_gscan(wifi_request_id id, wifi_interface_handle iface)\r
-{\r
- ALOGD("Stopping GScan");\r
- wifi_handle handle = getWifiHandle(iface);\r
-\r
- if(id == -1) {\r
- wifi_scan_result_handler handler;\r
- wifi_scan_cmd_params dummy_params;\r
- wifi_handle handle = getWifiHandle(iface);\r
- memset(&handler, 0, sizeof(handler));\r
-\r
- ScanCommand *cmd = new ScanCommand(iface, id, &dummy_params, handler);\r
- cmd->cancel();\r
- cmd->releaseRef();\r
- return WIFI_SUCCESS;\r
- }\r
-\r
-\r
- WifiCommand *cmd = wifi_unregister_cmd(handle, id);\r
- if (cmd) {\r
- cmd->cancel();\r
- cmd->releaseRef();\r
- return WIFI_SUCCESS;\r
- }\r
-\r
- return WIFI_ERROR_INVALID_ARGS;\r
-}\r
-\r
-class GetScanResultsCommand : public WifiCommand {\r
- wifi_cached_scan_results *mScans;\r
- int mMax;\r
- int *mNum;\r
- int mRetrieved;\r
- byte mFlush;\r
- int mCompleted;\r
- static const int MAX_RESULTS = 320;\r
- wifi_scan_result mScanResults[MAX_RESULTS];\r
- int mNextScanResult;\r
-public:\r
- GetScanResultsCommand(wifi_interface_handle iface, byte flush,\r
- wifi_cached_scan_results *results, int max, int *num)\r
- : WifiCommand(iface, -1), mScans(results), mMax(max), mNum(num),\r
- mRetrieved(0), mFlush(flush), mCompleted(0)\r
- { }\r
-\r
- int createRequest(WifiRequest& request, int num, byte flush) {\r
- int result = request.create(GOOGLE_OUI, SLSI_NL80211_VENDOR_SUBCMD_GET_SCAN_RESULTS);\r
- if (result < 0) {\r
- return result;\r
- }\r
-\r
- nlattr *data = request.attr_start(NL80211_ATTR_VENDOR_DATA);\r
- result = request.put_u32(GSCAN_ATTRIBUTE_NUM_OF_RESULTS, num);\r
- if (result < 0) {\r
- return result;\r
- }\r
-\r
- request.attr_end(data);\r
- return WIFI_SUCCESS;\r
- }\r
-\r
- int execute() {\r
- WifiRequest request(familyId(), ifaceId());\r
- ALOGD("retrieving %d scan results", mMax);\r
-\r
- for (int i = 0; i < 10 && mRetrieved < mMax; i++) {\r
- int result = createRequest(request, (mMax - mRetrieved), mFlush);\r
- if (result < 0) {\r
- ALOGE("failed to create request");\r
- return result;\r
- }\r
-\r
- int prev_retrieved = mRetrieved;\r
-\r
- result = requestResponse(request);\r
-\r
- if (result != WIFI_SUCCESS) {\r
- ALOGE("failed to retrieve scan results; result = %d", result);\r
- return result;\r
- }\r
-\r
- if (mRetrieved == prev_retrieved || mCompleted) {\r
- /* no more items left to retrieve */\r
- break;\r
- }\r
-\r
- request.destroy();\r
- }\r
-\r
- ALOGE("GetScanResults read %d results", mRetrieved);\r
- *mNum = mRetrieved;\r
- return WIFI_SUCCESS;\r
- }\r
-\r
- virtual int handleResponse(WifiEvent& reply) {\r
- ALOGD("In GetScanResultsCommand::handleResponse");\r
-\r
- if (reply.get_cmd() != NL80211_CMD_VENDOR) {\r
- ALOGD("Ignoring reply with cmd = %d", reply.get_cmd());\r
- return NL_SKIP;\r
- }\r
-\r
- int id = reply.get_vendor_id();\r
- int subcmd = reply.get_vendor_subcmd();\r
-\r
- ALOGD("Id = %0x, subcmd = %d", id, subcmd);\r
-\r
- nlattr *vendor_data = reply.get_attribute(NL80211_ATTR_VENDOR_DATA);\r
- int len = reply.get_vendor_data_len();\r
-\r
- if (vendor_data == NULL || len == 0) {\r
- ALOGE("no vendor data in GetScanResults response; ignoring it");\r
- return NL_SKIP;\r
- }\r
-\r
- for (nl_iterator it(vendor_data); it.has_next(); it.next()) {\r
- if (it.get_type() == GSCAN_ATTRIBUTE_SCAN_RESULTS_COMPLETE) {\r
- mCompleted = it.get_u8();\r
- ALOGD("retrieved mCompleted flag : %d", mCompleted);\r
- } else if (it.get_type() == GSCAN_ATTRIBUTE_SCAN_RESULTS || it.get_type() == 0) {\r
- int scan_id = 0, flags = 0, num = 0;\r
- for (nl_iterator it2(it.get()); it2.has_next(); it2.next()) {\r
- if (it2.get_type() == GSCAN_ATTRIBUTE_SCAN_ID) {\r
- scan_id = it2.get_u32();\r
- ALOGD("retrieved scan_id : 0x%0x", scan_id);\r
- } else if (it2.get_type() == GSCAN_ATTRIBUTE_SCAN_FLAGS) {\r
- flags = it2.get_u8();\r
- ALOGD("retrieved scan_flags : 0x%0x", flags);\r
- } else if (it2.get_type() == GSCAN_ATTRIBUTE_NUM_OF_RESULTS) {\r
- num = it2.get_u32();\r
- ALOGD("retrieved num_results: %d", num);\r
- } else if (it2.get_type() == GSCAN_ATTRIBUTE_SCAN_RESULTS) {\r
- if (mRetrieved >= mMax) {\r
- ALOGW("Stored %d scans, ignoring excess results", mRetrieved);\r
- break;\r
- }\r
- num = it2.get_len() / sizeof(wifi_scan_result);\r
- num = min(MAX_RESULTS - mNextScanResult, num);\r
- num = min((int)MAX_AP_CACHE_PER_SCAN, num);\r
- memcpy(mScanResults + mNextScanResult, it2.get_data(),\r
- sizeof(wifi_scan_result) * num);\r
- ALOGD("Retrieved %d scan results", num);\r
- wifi_scan_result *results = (wifi_scan_result *)it2.get_data();\r
- for (int i = 0; i < num; i++) {\r
- wifi_scan_result *result = results + i;\r
- ALOGD("%02d %-32s %02x:%02x:%02x:%02x:%02x:%02x %04d", i,\r
- result->ssid, result->bssid[0], result->bssid[1], result->bssid[2],\r
- result->bssid[3], result->bssid[4], result->bssid[5],\r
- result->rssi);\r
- }\r
- mScans[mRetrieved].scan_id = scan_id;\r
- mScans[mRetrieved].flags = flags;\r
- mScans[mRetrieved].num_results = num;\r
- ALOGD("Setting result of scan_id : 0x%0x", mScans[mRetrieved].scan_id);\r
- memcpy(mScans[mRetrieved].results,\r
- &(mScanResults[mNextScanResult]), num * sizeof(wifi_scan_result));\r
- mNextScanResult += num;\r
- mRetrieved++;\r
- } else {\r
- ALOGW("Ignoring invalid attribute type = %d, size = %d",\r
- it.get_type(), it.get_len());\r
- }\r
- }\r
- } else {\r
- ALOGW("Ignoring invalid attribute type = %d, size = %d",\r
- it.get_type(), it.get_len());\r
- }\r
- }\r
-\r
- return NL_OK;\r
- }\r
-};\r
-\r
-wifi_error wifi_get_cached_gscan_results(wifi_interface_handle iface, byte flush,\r
- int max, wifi_cached_scan_results *results, int *num) {\r
- ALOGD("Getting cached scan results, iface handle = %p, num = %d", iface, *num);\r
-\r
- GetScanResultsCommand *cmd = new GetScanResultsCommand(iface, flush, results, max, num);\r
- return (wifi_error)cmd->execute();\r
-}\r
-\r
-/////////////////////////////////////////////////////////////////////////////\r
-\r
-class BssidHotlistCommand : public WifiCommand\r
-{\r
-private:\r
- wifi_bssid_hotlist_params mParams;\r
- wifi_hotlist_ap_found_handler mHandler;\r
- static const int MAX_RESULTS = 64;\r
- wifi_scan_result mResults[MAX_RESULTS];\r
-public:\r
- BssidHotlistCommand(wifi_interface_handle handle, int id,\r
- wifi_bssid_hotlist_params params, wifi_hotlist_ap_found_handler handler)\r
- : WifiCommand(handle, id), mParams(params), mHandler(handler)\r
- { }\r
-\r
- int createSetupRequest(WifiRequest& request) {\r
- int result = request.create(GOOGLE_OUI, SLSI_NL80211_VENDOR_SUBCMD_SET_BSSID_HOTLIST);\r
- if (result < 0) {\r
- return result;\r
- }\r
-\r
- nlattr *data = request.attr_start(NL80211_ATTR_VENDOR_DATA);\r
-\r
- result = request.put_u32(GSCAN_ATTRIBUTE_LOST_AP_SAMPLE_SIZE, mParams.lost_ap_sample_size);\r
- if (result < 0) {\r
- return result;\r
- }\r
-\r
- struct nlattr * attr = request.attr_start(GSCAN_ATTRIBUTE_HOTLIST_BSSIDS);\r
- for (int i = 0; i < mParams.num_bssid; i++) {\r
- nlattr *attr2 = request.attr_start(GSCAN_ATTRIBUTE_HOTLIST_ELEM);\r
- if (attr2 == NULL) {\r
- return WIFI_ERROR_OUT_OF_MEMORY;\r
- }\r
- result = request.put_addr(GSCAN_ATTRIBUTE_BSSID, mParams.ap[i].bssid);\r
- if (result < 0) {\r
- return result;\r
- }\r
- result = request.put_u8(GSCAN_ATTRIBUTE_RSSI_HIGH, mParams.ap[i].high);\r
- if (result < 0) {\r
- return result;\r
- }\r
- result = request.put_u8(GSCAN_ATTRIBUTE_RSSI_LOW, mParams.ap[i].low);\r
- if (result < 0) {\r
- return result;\r
- }\r
- request.attr_end(attr2);\r
- }\r
-\r
- request.attr_end(attr);\r
- request.attr_end(data);\r
- return result;\r
- }\r
-\r
- int createTeardownRequest(WifiRequest& request) {\r
- int result = request.create(GOOGLE_OUI, SLSI_NL80211_VENDOR_SUBCMD_RESET_BSSID_HOTLIST);\r
- if (result < 0) {\r
- return result;\r
- }\r
-\r
- return result;\r
- }\r
-\r
- int start() {\r
- ALOGD("Executing hotlist setup request, num = %d", mParams.num_bssid);\r
- WifiRequest request(familyId(), ifaceId());\r
- int result = createSetupRequest(request);\r
- if (result < 0) {\r
- return result;\r
- }\r
-\r
- result = requestResponse(request);\r
- if (result < 0) {\r
- ALOGD("Failed to execute hotlist setup request, result = %d", result);\r
- unregisterVendorHandler(GOOGLE_OUI, GSCAN_EVENT_HOTLIST_RESULTS_FOUND);\r
- unregisterVendorHandler(GOOGLE_OUI, GSCAN_EVENT_HOTLIST_RESULTS_LOST);\r
- return result;\r
- }\r
-\r
- ALOGD("Successfully set %d APs in the hotlist", mParams.num_bssid);\r
-\r
- registerVendorHandler(GOOGLE_OUI, GSCAN_EVENT_HOTLIST_RESULTS_FOUND);\r
- registerVendorHandler(GOOGLE_OUI, GSCAN_EVENT_HOTLIST_RESULTS_LOST);\r
-\r
- return result;\r
- }\r
-\r
- virtual int cancel() {\r
- /* unregister event handler */\r
- unregisterVendorHandler(GOOGLE_OUI, GSCAN_EVENT_HOTLIST_RESULTS_FOUND);\r
- unregisterVendorHandler(GOOGLE_OUI, GSCAN_EVENT_HOTLIST_RESULTS_LOST);\r
- /* create set hotlist message with empty hotlist */\r
- WifiRequest request(familyId(), ifaceId());\r
- int result = createTeardownRequest(request);\r
- if (result < 0) {\r
- return result;\r
- }\r
-\r
- result = requestResponse(request);\r
- if (result < 0) {\r
- return result;\r
- }\r
-\r
- ALOGD("Successfully reset APs in current hotlist");\r
- return result;\r
- }\r
-\r
- virtual int handleResponse(WifiEvent& reply) {\r
- /* Nothing to do on response! */\r
- return NL_SKIP;\r
- }\r
-\r
- virtual int handleEvent(WifiEvent& event) {\r
- ALOGD("Hotlist AP event");\r
- int event_id = event.get_vendor_subcmd();\r
- event.log();\r
-\r
- nlattr *vendor_data = event.get_attribute(NL80211_ATTR_VENDOR_DATA);\r
- int len = event.get_vendor_data_len();\r
-\r
- if (vendor_data == NULL || len == 0) {\r
- ALOGD("No scan results found");\r
- return NL_SKIP;\r
- }\r
-\r
- memset(mResults, 0, sizeof(wifi_scan_result) * MAX_RESULTS);\r
-\r
- int num = len / sizeof(wifi_scan_result);\r
- num = min(MAX_RESULTS, num);\r
- memcpy(mResults, event.get_vendor_data(), num * sizeof(wifi_scan_result));\r
-\r
- if (event_id == GSCAN_EVENT_HOTLIST_RESULTS_FOUND) {\r
- ALOGD("FOUND %d hotlist APs", num);\r
- if (*mHandler.on_hotlist_ap_found)\r
- (*mHandler.on_hotlist_ap_found)(id(), num, mResults);\r
- } else if (event_id == GSCAN_EVENT_HOTLIST_RESULTS_LOST) {\r
- ALOGD("LOST %d hotlist APs", num);\r
- if (*mHandler.on_hotlist_ap_lost)\r
- (*mHandler.on_hotlist_ap_lost)(id(), num, mResults);\r
- }\r
- return NL_SKIP;\r
- }\r
-};\r
-\r
-wifi_error wifi_set_bssid_hotlist(wifi_request_id id, wifi_interface_handle iface,\r
- wifi_bssid_hotlist_params params, wifi_hotlist_ap_found_handler handler)\r
-{\r
- wifi_handle handle = getWifiHandle(iface);\r
-\r
- BssidHotlistCommand *cmd = new BssidHotlistCommand(iface, id, params, handler);\r
- wifi_register_cmd(handle, id, cmd);\r
- return (wifi_error)cmd->start();\r
-}\r
-\r
-wifi_error wifi_reset_bssid_hotlist(wifi_request_id id, wifi_interface_handle iface)\r
-{\r
- wifi_handle handle = getWifiHandle(iface);\r
-\r
- WifiCommand *cmd = wifi_unregister_cmd(handle, id);\r
- if (cmd) {\r
- cmd->cancel();\r
- cmd->releaseRef();\r
- return WIFI_SUCCESS;\r
- }\r
-\r
- return WIFI_ERROR_INVALID_ARGS;\r
-}\r
-\r
-\r
-/////////////////////////////////////////////////////////////////////////////\r
-\r
-class SignificantWifiChangeCommand : public WifiCommand\r
-{\r
- typedef struct {\r
- mac_addr bssid; // BSSID\r
- wifi_channel channel; // channel frequency in MHz\r
- int num_rssi; // number of rssi samples\r
- wifi_rssi rssi[8]; // RSSI history in db\r
- } wifi_significant_change_result_internal;\r
-\r
-private:\r
- wifi_significant_change_params mParams;\r
- wifi_significant_change_handler mHandler;\r
- static const int MAX_RESULTS = 64;\r
- wifi_significant_change_result_internal mResultsBuffer[MAX_RESULTS];\r
- wifi_significant_change_result *mResults[MAX_RESULTS];\r
-public:\r
- SignificantWifiChangeCommand(wifi_interface_handle handle, int id,\r
- wifi_significant_change_params params, wifi_significant_change_handler handler)\r
- : WifiCommand(handle, id), mParams(params), mHandler(handler)\r
- { }\r
-\r
- int createSetupRequest(WifiRequest& request) {\r
- int result = request.create(GOOGLE_OUI, SLSI_NL80211_VENDOR_SUBCMD_SET_SIGNIFICANT_CHANGE);\r
- if (result < 0) {\r
- return result;\r
- }\r
-\r
- nlattr *data = request.attr_start(NL80211_ATTR_VENDOR_DATA);\r
-\r
- result = request.put_u16(GSCAN_ATTRIBUTE_RSSI_SAMPLE_SIZE, mParams.rssi_sample_size);\r
- if (result < 0) {\r
- return result;\r
- }\r
- result = request.put_u16(GSCAN_ATTRIBUTE_LOST_AP_SAMPLE_SIZE, mParams.lost_ap_sample_size);\r
- if (result < 0) {\r
- return result;\r
- }\r
- result = request.put_u16(GSCAN_ATTRIBUTE_MIN_BREACHING, mParams.min_breaching);\r
- if (result < 0) {\r
- return result;\r
- }\r
-\r
- struct nlattr * attr = request.attr_start(GSCAN_ATTRIBUTE_SIGNIFICANT_CHANGE_BSSIDS);\r
-\r
- for (int i = 0; i < mParams.num_bssid; i++) {\r
-\r
- nlattr *attr2 = request.attr_start(i);\r
- if (attr2 == NULL) {\r
- return WIFI_ERROR_OUT_OF_MEMORY;\r
- }\r
- result = request.put_addr(GSCAN_ATTRIBUTE_BSSID, mParams.ap[i].bssid);\r
- if (result < 0) {\r
- return result;\r
- }\r
- result = request.put_u8(GSCAN_ATTRIBUTE_RSSI_HIGH, mParams.ap[i].high);\r
- if (result < 0) {\r
- return result;\r
- }\r
- result = request.put_u8(GSCAN_ATTRIBUTE_RSSI_LOW, mParams.ap[i].low);\r
- if (result < 0) {\r
- return result;\r
- }\r
- request.attr_end(attr2);\r
- }\r
-\r
- request.attr_end(attr);\r
- request.attr_end(data);\r
-\r
- return result;\r
- }\r
-\r
- int createTeardownRequest(WifiRequest& request) {\r
- int result = request.create(GOOGLE_OUI, SLSI_NL80211_VENDOR_SUBCMD_RESET_SIGNIFICANT_CHANGE);\r
- if (result < 0) {\r
- return result;\r
- }\r
-\r
- return result;\r
- }\r
-\r
- int start() {\r
- ALOGD("Set significant wifi change");\r
- WifiRequest request(familyId(), ifaceId());\r
-\r
- int result = createSetupRequest(request);\r
- if (result < 0) {\r
- return result;\r
- }\r
-\r
- result = requestResponse(request);\r
- if (result < 0) {\r
- ALOGD("failed to set significant wifi change %d", result);\r
- return result;\r
- }\r
- registerVendorHandler(GOOGLE_OUI, GSCAN_EVENT_SIGNIFICANT_CHANGE_RESULTS);\r
-\r
- return result;\r
- }\r
-\r
- virtual int cancel() {\r
- /* unregister event handler */\r
- unregisterVendorHandler(GOOGLE_OUI, GSCAN_EVENT_SIGNIFICANT_CHANGE_RESULTS);\r
-\r
- /* create set significant change monitor message with empty hotlist */\r
- WifiRequest request(familyId(), ifaceId());\r
-\r
- int result = createTeardownRequest(request);\r
- if (result < 0) {\r
- return result;\r
- }\r
-\r
- result = requestResponse(request);\r
- if (result < 0) {\r
- return result;\r
- }\r
-\r
- ALOGD("successfully reset significant wifi change");\r
- return result;\r
- }\r
-\r
- virtual int handleResponse(WifiEvent& reply) {\r
- /* Nothing to do on response! */\r
- return NL_SKIP;\r
- }\r
-\r
- virtual int handleEvent(WifiEvent& event) {\r
- ALOGD("Got a significant wifi change event");\r
-\r
- nlattr *vendor_data = event.get_attribute(NL80211_ATTR_VENDOR_DATA);\r
- int len = event.get_vendor_data_len();\r
-\r
- if (vendor_data == NULL || len == 0) {\r
- ALOGD("No scan results found");\r
- return NL_SKIP;\r
- }\r
-\r
- typedef struct {\r
- uint16_t channel;\r
- mac_addr bssid;\r
- int16_t rssi_history[8];\r
- } ChangeInfo;\r
-\r
- int num = min(len / sizeof(ChangeInfo), MAX_RESULTS);\r
- ChangeInfo *ci = (ChangeInfo *)event.get_vendor_data();\r
-\r
- for (int i = 0; i < num; i++) {\r
- memcpy(mResultsBuffer[i].bssid, ci[i].bssid, sizeof(mac_addr));\r
- mResultsBuffer[i].channel = ci[i].channel;\r
- /* Driver sends N samples and the rest 8-N are filled 0x7FFF\r
- * N = no of rssi samples to average sent in significant change request. */\r
- int num_rssi = 0;\r
- for (int j = 0; j < 8; j++) {\r
- if (ci[i].rssi_history[j] == 0x7FFF) {\r
- num_rssi = j;\r
- break;\r
- }\r
- mResultsBuffer[i].rssi[j] = (int) ci[i].rssi_history[j];\r
- }\r
- mResultsBuffer[i].num_rssi = num_rssi;\r
- mResults[i] = reinterpret_cast<wifi_significant_change_result *>(&(mResultsBuffer[i]));\r
- }\r
-\r
- ALOGD("Retrieved %d scan results", num);\r
-\r
- if (num != 0) {\r
- (*mHandler.on_significant_change)(id(), num, mResults);\r
- } else {\r
- ALOGW("No significant change reported");\r
- }\r
-\r
- return NL_SKIP;\r
- }\r
-};\r
-\r
-wifi_error wifi_set_significant_change_handler(wifi_request_id id, wifi_interface_handle iface,\r
- wifi_significant_change_params params, wifi_significant_change_handler handler)\r
-{\r
- wifi_handle handle = getWifiHandle(iface);\r
-\r
- SignificantWifiChangeCommand *cmd = new SignificantWifiChangeCommand(\r
- iface, id, params, handler);\r
- wifi_register_cmd(handle, id, cmd);\r
- return (wifi_error)cmd->start();\r
-}\r
-\r
-wifi_error wifi_reset_significant_change_handler(wifi_request_id id, wifi_interface_handle iface)\r
-{\r
- wifi_handle handle = getWifiHandle(iface);\r
-\r
- WifiCommand *cmd = wifi_unregister_cmd(handle, id);\r
- if (cmd) {\r
- cmd->cancel();\r
- cmd->releaseRef();\r
- return WIFI_SUCCESS;\r
- }\r
-\r
- return WIFI_ERROR_INVALID_ARGS;\r
-}\r
+
+#include <stdint.h>
+#include <fcntl.h>
+#include <sys/socket.h>
+#include <netlink/genl/genl.h>
+#include <netlink/genl/family.h>
+#include <netlink/genl/ctrl.h>
+#include <linux/rtnetlink.h>
+#include <netpacket/packet.h>
+#include <linux/filter.h>
+#include <linux/errqueue.h>
+
+#include <linux/pkt_sched.h>
+#include <netlink/object-api.h>
+#include <netlink/netlink.h>
+#include <netlink/socket.h>
+#include <netlink/handlers.h>
+
+#include "sync.h"
+
+#define LOG_TAG "WifiHAL"
+
+#include <utils/Log.h>
+
+#include "wifi_hal.h"
+#include "common.h"
+#include "cpp_bindings.h"
+
+typedef enum {
+
+ GSCAN_ATTRIBUTE_NUM_BUCKETS = 10,
+ GSCAN_ATTRIBUTE_BASE_PERIOD,
+ GSCAN_ATTRIBUTE_BUCKETS_BAND,
+ GSCAN_ATTRIBUTE_BUCKET_ID,
+ GSCAN_ATTRIBUTE_BUCKET_PERIOD,
+ GSCAN_ATTRIBUTE_BUCKET_NUM_CHANNELS,
+ GSCAN_ATTRIBUTE_BUCKET_CHANNELS,
+ GSCAN_ATTRIBUTE_NUM_AP_PER_SCAN,
+ GSCAN_ATTRIBUTE_REPORT_THRESHOLD,
+ GSCAN_ATTRIBUTE_NUM_SCANS_TO_CACHE,
+ GSCAN_ATTRIBUTE_REPORT_THRESHOLD_NUM_SCANS,
+ GSCAN_ATTRIBUTE_BAND = GSCAN_ATTRIBUTE_BUCKETS_BAND,
+
+ GSCAN_ATTRIBUTE_ENABLE_FEATURE = 20,
+ GSCAN_ATTRIBUTE_SCAN_RESULTS_COMPLETE, /* indicates no more results */
+ GSCAN_ATTRIBUTE_REPORT_EVENTS,
+
+ /* remaining reserved for additional attributes */
+ GSCAN_ATTRIBUTE_NUM_OF_RESULTS = 30,
+ GSCAN_ATTRIBUTE_SCAN_RESULTS, /* flat array of wifi_scan_result */
+ GSCAN_ATTRIBUTE_NUM_CHANNELS,
+ GSCAN_ATTRIBUTE_CHANNEL_LIST,
+ GSCAN_ATTRIBUTE_SCAN_ID,
+ GSCAN_ATTRIBUTE_SCAN_FLAGS,
+
+ /* remaining reserved for additional attributes */
+
+ GSCAN_ATTRIBUTE_SSID = 40,
+ GSCAN_ATTRIBUTE_BSSID,
+ GSCAN_ATTRIBUTE_CHANNEL,
+ GSCAN_ATTRIBUTE_RSSI,
+ GSCAN_ATTRIBUTE_TIMESTAMP,
+ GSCAN_ATTRIBUTE_RTT,
+ GSCAN_ATTRIBUTE_RTTSD,
+
+ /* remaining reserved for additional attributes */
+
+ GSCAN_ATTRIBUTE_HOTLIST_BSSIDS = 50,
+ GSCAN_ATTRIBUTE_RSSI_LOW,
+ GSCAN_ATTRIBUTE_RSSI_HIGH,
+ GSCAN_ATTRIBUTE_HOTLIST_ELEM,
+ GSCAN_ATTRIBUTE_HOTLIST_FLUSH,
+ GSCAN_ATTRIBUTE_CHANNEL_NUMBER,
+
+ /* remaining reserved for additional attributes */
+ GSCAN_ATTRIBUTE_RSSI_SAMPLE_SIZE = 60,
+ GSCAN_ATTRIBUTE_LOST_AP_SAMPLE_SIZE,
+ GSCAN_ATTRIBUTE_MIN_BREACHING,
+ GSCAN_ATTRIBUTE_SIGNIFICANT_CHANGE_BSSIDS,
+
+ GSCAN_ATTRIBUTE_MAX
+
+} GSCAN_ATTRIBUTE;
+
+
+class GetCapabilitiesCommand : public WifiCommand
+{
+ wifi_gscan_capabilities *mCapabilities;
+public:
+ GetCapabilitiesCommand(wifi_interface_handle iface, wifi_gscan_capabilities *capabitlites)
+ : WifiCommand(iface, 0), mCapabilities(capabitlites)
+ {
+ memset(mCapabilities, 0, sizeof(*mCapabilities));
+ }
+
+ virtual int create() {
+ ALOGD("Creating message to get scan capablities; iface = %d", mIfaceInfo->id);
+
+ int ret = mMsg.create(GOOGLE_OUI, SLSI_NL80211_VENDOR_SUBCMD_GET_CAPABILITIES);
+ if (ret < 0) {
+ ALOGD("NL message creation failed");
+ return ret;
+ }
+
+ return ret;
+ }
+
+protected:
+ virtual int handleResponse(WifiEvent& reply) {
+
+ ALOGD("In GetCapabilities::handleResponse");
+
+ if (reply.get_cmd() != NL80211_CMD_VENDOR) {
+ ALOGD("Ignoring reply with cmd = %d", reply.get_cmd());
+ return NL_SKIP;
+ }
+
+ int id = reply.get_vendor_id();
+ int subcmd = reply.get_vendor_subcmd();
+
+ void *data = reply.get_vendor_data();
+ int len = reply.get_vendor_data_len();
+
+ ALOGD("Id = %0x, subcmd = %d, len = %d, expected len = %d", id, subcmd, len,
+ sizeof(*mCapabilities));
+
+ memcpy(mCapabilities, data, min(len, (int) sizeof(*mCapabilities)));
+
+ return NL_OK;
+ }
+};
+
+
+wifi_error wifi_get_gscan_capabilities(wifi_interface_handle handle,
+ wifi_gscan_capabilities *capabilities)
+{
+ GetCapabilitiesCommand command(handle, capabilities);
+ return (wifi_error) command.requestResponse();
+}
+
+class GetChannelListCommand : public WifiCommand
+{
+ wifi_channel *channels;
+ int max_channels;
+ int *num_channels;
+ int band;
+public:
+ GetChannelListCommand(wifi_interface_handle iface, wifi_channel *channel_buf, int *ch_num,
+ int num_max_ch, int band)
+ : WifiCommand(iface, 0), channels(channel_buf), max_channels(num_max_ch), num_channels(ch_num),
+ band(band)
+ {
+ memset(channels, 0, sizeof(wifi_channel) * max_channels);
+ }
+ virtual int create() {
+ ALOGD("Creating message to get channel list; iface = %d", mIfaceInfo->id);
+
+ int ret = mMsg.create(GOOGLE_OUI, SLSI_NL80211_VENDOR_SUBCMD_GET_VALID_CHANNELS);
+ if (ret < 0) {
+ return ret;
+ }
+
+ nlattr *data = mMsg.attr_start(NL80211_ATTR_VENDOR_DATA);
+ ret = mMsg.put_u32(GSCAN_ATTRIBUTE_BAND, band);
+ if (ret < 0) {
+ return ret;
+ }
+
+ mMsg.attr_end(data);
+
+ return ret;
+ }
+
+protected:
+ virtual int handleResponse(WifiEvent& reply) {
+
+ ALOGD("In GetChannelList::handleResponse");
+
+ if (reply.get_cmd() != NL80211_CMD_VENDOR) {
+ ALOGD("Ignoring reply with cmd = %d", reply.get_cmd());
+ return NL_SKIP;
+ }
+
+ int id = reply.get_vendor_id();
+ int subcmd = reply.get_vendor_subcmd();
+ int num_channels_to_copy = 0;
+
+ nlattr *vendor_data = reply.get_attribute(NL80211_ATTR_VENDOR_DATA);
+ int len = reply.get_vendor_data_len();
+
+ ALOGD("Id = %0x, subcmd = %d, len = %d", id, subcmd, len);
+ if (vendor_data == NULL || len == 0) {
+ ALOGE("no vendor data in GetChannelList response; ignoring it");
+ return NL_SKIP;
+ }
+
+ for (nl_iterator it(vendor_data); it.has_next(); it.next()) {
+ if (it.get_type() == GSCAN_ATTRIBUTE_NUM_CHANNELS) {
+ num_channels_to_copy = it.get_u32();
+ ALOGD("Got channel list with %d channels", num_channels_to_copy);
+ if(num_channels_to_copy > max_channels)
+ num_channels_to_copy = max_channels;
+ *num_channels = num_channels_to_copy;
+ } else if (it.get_type() == GSCAN_ATTRIBUTE_CHANNEL_LIST && num_channels_to_copy) {
+ memcpy(channels, it.get_data(), sizeof(int) * num_channels_to_copy);
+ } else {
+ ALOGW("Ignoring invalid attribute type = %d, size = %d",
+ it.get_type(), it.get_len());
+ }
+ }
+
+ return NL_OK;
+ }
+};
+
+wifi_error wifi_get_valid_channels(wifi_interface_handle handle,
+ int band, int max_channels, wifi_channel *channels, int *num_channels)
+{
+ GetChannelListCommand command(handle, channels, num_channels,
+ max_channels, band);
+ return (wifi_error) command.requestResponse();
+}
+/////////////////////////////////////////////////////////////////////////////
+
+/* helper functions */
+
+static int parseScanResults(wifi_scan_result *results, int num, nlattr *attr)
+{
+ memset(results, 0, sizeof(wifi_scan_result) * num);
+
+ int i = 0;
+ for (nl_iterator it(attr); it.has_next() && i < num; it.next(), i++) {
+
+ int index = it.get_type();
+ ALOGD("retrieved scan result %d", index);
+ nlattr *sc_data = (nlattr *) it.get_data();
+ wifi_scan_result *result = results + i;
+
+ for (nl_iterator it2(sc_data); it2.has_next(); it2.next()) {
+ int type = it2.get_type();
+ if (type == GSCAN_ATTRIBUTE_SSID) {
+ strncpy(result->ssid, (char *) it2.get_data(), it2.get_len());
+ result->ssid[it2.get_len()] = 0;
+ } else if (type == GSCAN_ATTRIBUTE_BSSID) {
+ memcpy(result->bssid, (byte *) it2.get_data(), sizeof(mac_addr));
+ } else if (type == GSCAN_ATTRIBUTE_TIMESTAMP) {
+ result->ts = it2.get_u64();
+ } else if (type == GSCAN_ATTRIBUTE_CHANNEL) {
+ result->ts = it2.get_u16();
+ } else if (type == GSCAN_ATTRIBUTE_RSSI) {
+ result->rssi = it2.get_u8();
+ } else if (type == GSCAN_ATTRIBUTE_RTT) {
+ result->rtt = it2.get_u64();
+ } else if (type == GSCAN_ATTRIBUTE_RTTSD) {
+ result->rtt_sd = it2.get_u64();
+ }
+ }
+
+ }
+
+ if (i >= num) {
+ ALOGE("Got too many results; skipping some");
+ }
+
+ return i;
+}
+
+int createFeatureRequest(WifiRequest& request, int subcmd) {
+
+ int result = request.create(GOOGLE_OUI, subcmd);
+ if (result < 0) {
+ return result;
+ }
+
+ return WIFI_SUCCESS;
+}
+
+class ScanCommand : public WifiCommand
+{
+ wifi_scan_cmd_params *mParams;
+ wifi_scan_result_handler mHandler;
+ static unsigned mGlobalFullScanBuckets;
+ bool mLocalFullScanBuckets;
+public:
+ ScanCommand(wifi_interface_handle iface, int id, wifi_scan_cmd_params *params,
+ wifi_scan_result_handler handler)
+ : WifiCommand(iface, id), mParams(params), mHandler(handler),
+ mLocalFullScanBuckets(0)
+ { }
+
+ int createSetupRequest(WifiRequest& request) {
+ int result = request.create(GOOGLE_OUI, SLSI_NL80211_VENDOR_SUBCMD_ADD_GSCAN);
+ if (result < 0) {
+ return result;
+ }
+
+ nlattr *data = request.attr_start(NL80211_ATTR_VENDOR_DATA);
+ result = request.put_u32(GSCAN_ATTRIBUTE_BASE_PERIOD, mParams->base_period);
+ if (result < 0) {
+ return result;
+ }
+
+ result = request.put_u32(GSCAN_ATTRIBUTE_NUM_AP_PER_SCAN, mParams->max_ap_per_scan);
+ if (result < 0) {
+ return result;
+ }
+
+ result = request.put_u32(GSCAN_ATTRIBUTE_REPORT_THRESHOLD, mParams->report_threshold_percent);
+ if (result < 0) {
+ return result;
+ }
+
+ result = request.put_u32(GSCAN_ATTRIBUTE_REPORT_THRESHOLD_NUM_SCANS, mParams->report_threshold_num_scans);
+ if (result < 0) {
+ return result;
+ }
+
+ result = request.put_u32(GSCAN_ATTRIBUTE_NUM_BUCKETS, mParams->num_buckets);
+ if (result < 0) {
+ return result;
+ }
+
+ for (int i = 0; i < mParams->num_buckets; i++) {
+ nlattr * bucket = request.attr_start(i); // next bucket
+ result = request.put_u32(GSCAN_ATTRIBUTE_BUCKET_ID, mParams->buckets[i].bucket);
+ if (result < 0) {
+ return result;
+ }
+ result = request.put_u32(GSCAN_ATTRIBUTE_BUCKET_PERIOD, mParams->buckets[i].period);
+ if (result < 0) {
+ return result;
+ }
+ result = request.put_u32(GSCAN_ATTRIBUTE_BUCKETS_BAND,
+ mParams->buckets[i].band);
+ if (result < 0) {
+ return result;
+ }
+
+ result = request.put_u32(GSCAN_ATTRIBUTE_REPORT_EVENTS,
+ mParams->buckets[i].report_events);
+ if (result < 0) {
+ return result;
+ }
+
+ result = request.put_u32(GSCAN_ATTRIBUTE_BUCKET_NUM_CHANNELS,
+ mParams->buckets[i].num_channels);
+ if (result < 0) {
+ return result;
+ }
+
+ if (mParams->buckets[i].num_channels) {
+ nlattr *channels = request.attr_start(GSCAN_ATTRIBUTE_BUCKET_CHANNELS);
+ for (int j = 0; j < mParams->buckets[i].num_channels; j++) {
+ result = request.put_u32(j, mParams->buckets[i].channels[j].channel);
+ if (result < 0) {
+ return result;
+ }
+ }
+ request.attr_end(channels);
+ }
+
+ request.attr_end(bucket);
+ }
+
+ request.attr_end(data);
+ return WIFI_SUCCESS;
+ }
+
+ int createStartRequest(WifiRequest& request) {
+ return createFeatureRequest(request, SLSI_NL80211_VENDOR_SUBCMD_ADD_GSCAN);
+ }
+
+ int createStopRequest(WifiRequest& request) {
+ return createFeatureRequest(request, SLSI_NL80211_VENDOR_SUBCMD_DEL_GSCAN);
+ }
+
+ int start() {
+ ALOGD(" sending scan req to driver");
+ WifiRequest request(familyId(), ifaceId());
+ int result = createSetupRequest(request);
+ if (result != WIFI_SUCCESS) {
+ ALOGE("failed to create setup request; result = %d", result);
+ return result;
+ }
+ ALOGD("Starting scan");
+
+ registerVendorHandler(GOOGLE_OUI, GSCAN_EVENT_SCAN_RESULTS_AVAILABLE);
+ registerVendorHandler(GOOGLE_OUI, GSCAN_EVENT_COMPLETE_SCAN);
+
+ int nBuckets = 0;
+ for (int i = 0; i < mParams->num_buckets; i++) {
+ if (mParams->buckets[i].report_events == 2) {
+ nBuckets++;
+ }
+ }
+
+ if (nBuckets != 0) {
+ ALOGI("Full scan requested with nBuckets = %d", nBuckets);
+ registerVendorHandler(GOOGLE_OUI, GSCAN_EVENT_FULL_SCAN_RESULTS);
+ }
+ result = requestResponse(request);
+ if (result != WIFI_SUCCESS) {
+ ALOGE("failed to start scan; result = %d", result);
+ unregisterVendorHandler(GOOGLE_OUI, GSCAN_EVENT_COMPLETE_SCAN);
+ unregisterVendorHandler(GOOGLE_OUI, GSCAN_EVENT_SCAN_RESULTS_AVAILABLE);
+ return result;
+ }
+
+
+ return result;
+ }
+
+ virtual int cancel() {
+ ALOGD("Stopping scan");
+
+ WifiRequest request(familyId(), ifaceId());
+ int result = createStopRequest(request);
+ if (result != WIFI_SUCCESS) {
+ ALOGE("failed to create stop request; result = %d", result);
+ } else {
+ result = requestResponse(request);
+ if (result != WIFI_SUCCESS) {
+ ALOGE("failed to stop scan; result = %d", result);
+ }
+ }
+
+ unregisterVendorHandler(GOOGLE_OUI, GSCAN_EVENT_COMPLETE_SCAN);
+ unregisterVendorHandler(GOOGLE_OUI, GSCAN_EVENT_SCAN_RESULTS_AVAILABLE);
+ unregisterVendorHandler(GOOGLE_OUI, GSCAN_EVENT_FULL_SCAN_RESULTS);
+
+ return WIFI_SUCCESS;
+ }
+
+ virtual int handleResponse(WifiEvent& reply) {
+ /* Nothing to do on response! */
+ return NL_SKIP;
+ }
+
+ virtual int handleEvent(WifiEvent& event) {
+ ALOGD("Got a scan results event");
+
+ event.log();
+
+ nlattr *vendor_data = event.get_attribute(NL80211_ATTR_VENDOR_DATA);
+ unsigned int len = event.get_vendor_data_len();
+ int event_id = event.get_vendor_subcmd();
+ ALOGD("handleEvent, event_id = %d", event_id);
+
+ if(event_id == GSCAN_EVENT_COMPLETE_SCAN) {
+ if (vendor_data == NULL || len != 4) {
+ ALOGD("Scan complete type not mentioned!");
+ return NL_SKIP;
+ }
+ wifi_scan_event evt_type;
+
+ evt_type = (wifi_scan_event) event.get_u32(NL80211_ATTR_VENDOR_DATA);
+ ALOGD("Scan complete: Received event type %d", evt_type);
+ if(*mHandler.on_scan_event)
+ (*mHandler.on_scan_event)(evt_type, evt_type);
+ } else if(event_id == GSCAN_EVENT_FULL_SCAN_RESULTS) {
+ if (vendor_data == NULL || len < sizeof(wifi_scan_result)) {
+ ALOGD("No scan results found");
+ return NL_SKIP;
+ }
+ wifi_scan_result *result = (wifi_scan_result *)event.get_vendor_data();
+
+ if(*mHandler.on_full_scan_result)
+ (*mHandler.on_full_scan_result)(id(), result);
+
+ ALOGD("%-32s\t", result->ssid);
+
+ ALOGD("%02x:%02x:%02x:%02x:%02x:%02x ", result->bssid[0], result->bssid[1],
+ result->bssid[2], result->bssid[3], result->bssid[4], result->bssid[5]);
+
+ ALOGD("%d\t", result->rssi);
+ ALOGD("%d\t", result->channel);
+ ALOGD("%lld\t", result->ts);
+ ALOGD("%lld\t", result->rtt);
+ ALOGD("%lld\n", result->rtt_sd);
+ } else {
+
+ if (vendor_data == NULL || len != 4) {
+ ALOGD("No scan results found");
+ return NL_SKIP;
+ }
+
+ int num = event.get_u32(NL80211_ATTR_VENDOR_DATA);
+ ALOGD("Found %d scan results", num);
+ if(*mHandler.on_scan_results_available)
+ (*mHandler.on_scan_results_available)(id(), num);
+ }
+ return NL_SKIP;
+ }
+};
+
+unsigned ScanCommand::mGlobalFullScanBuckets = 0;
+
+wifi_error wifi_start_gscan(
+ wifi_request_id id,
+ wifi_interface_handle iface,
+ wifi_scan_cmd_params params,
+ wifi_scan_result_handler handler)
+{
+ wifi_handle handle = getWifiHandle(iface);
+
+ ALOGD("Starting GScan, halHandle = %p", handle);
+
+ ScanCommand *cmd = new ScanCommand(iface, id, ¶ms, handler);
+ wifi_register_cmd(handle, id, cmd);
+ return (wifi_error)cmd->start();
+}
+
+wifi_error wifi_stop_gscan(wifi_request_id id, wifi_interface_handle iface)
+{
+ ALOGD("Stopping GScan");
+ wifi_handle handle = getWifiHandle(iface);
+
+ if(id == -1) {
+ wifi_scan_result_handler handler;
+ wifi_scan_cmd_params dummy_params;
+ wifi_handle handle = getWifiHandle(iface);
+ memset(&handler, 0, sizeof(handler));
+
+ ScanCommand *cmd = new ScanCommand(iface, id, &dummy_params, handler);
+ cmd->cancel();
+ cmd->releaseRef();
+ return WIFI_SUCCESS;
+ }
+
+
+ WifiCommand *cmd = wifi_unregister_cmd(handle, id);
+ if (cmd) {
+ cmd->cancel();
+ cmd->releaseRef();
+ return WIFI_SUCCESS;
+ }
+
+ return WIFI_ERROR_INVALID_ARGS;
+}
+
+class GetScanResultsCommand : public WifiCommand {
+ wifi_cached_scan_results *mScans;
+ int mMax;
+ int *mNum;
+ int mRetrieved;
+ byte mFlush;
+ int mCompleted;
+ static const int MAX_RESULTS = 320;
+ wifi_scan_result mScanResults[MAX_RESULTS];
+ int mNextScanResult;
+public:
+ GetScanResultsCommand(wifi_interface_handle iface, byte flush,
+ wifi_cached_scan_results *results, int max, int *num)
+ : WifiCommand(iface, -1), mScans(results), mMax(max), mNum(num),
+ mRetrieved(0), mFlush(flush), mCompleted(0)
+ { }
+
+ int createRequest(WifiRequest& request, int num, byte flush) {
+ int result = request.create(GOOGLE_OUI, SLSI_NL80211_VENDOR_SUBCMD_GET_SCAN_RESULTS);
+ if (result < 0) {
+ return result;
+ }
+
+ nlattr *data = request.attr_start(NL80211_ATTR_VENDOR_DATA);
+ result = request.put_u32(GSCAN_ATTRIBUTE_NUM_OF_RESULTS, num);
+ if (result < 0) {
+ return result;
+ }
+
+ request.attr_end(data);
+ return WIFI_SUCCESS;
+ }
+
+ int execute() {
+ WifiRequest request(familyId(), ifaceId());
+ ALOGD("retrieving %d scan results", mMax);
+
+ for (int i = 0; i < 10 && mRetrieved < mMax; i++) {
+ int result = createRequest(request, (mMax - mRetrieved), mFlush);
+ if (result < 0) {
+ ALOGE("failed to create request");
+ return result;
+ }
+
+ int prev_retrieved = mRetrieved;
+
+ result = requestResponse(request);
+
+ if (result != WIFI_SUCCESS) {
+ ALOGE("failed to retrieve scan results; result = %d", result);
+ return result;
+ }
+
+ if (mRetrieved == prev_retrieved || mCompleted) {
+ /* no more items left to retrieve */
+ break;
+ }
+
+ request.destroy();
+ }
+
+ ALOGE("GetScanResults read %d results", mRetrieved);
+ *mNum = mRetrieved;
+ return WIFI_SUCCESS;
+ }
+
+ virtual int handleResponse(WifiEvent& reply) {
+ ALOGD("In GetScanResultsCommand::handleResponse");
+
+ if (reply.get_cmd() != NL80211_CMD_VENDOR) {
+ ALOGD("Ignoring reply with cmd = %d", reply.get_cmd());
+ return NL_SKIP;
+ }
+
+ int id = reply.get_vendor_id();
+ int subcmd = reply.get_vendor_subcmd();
+
+ ALOGD("Id = %0x, subcmd = %d", id, subcmd);
+
+ nlattr *vendor_data = reply.get_attribute(NL80211_ATTR_VENDOR_DATA);
+ int len = reply.get_vendor_data_len();
+
+ if (vendor_data == NULL || len == 0) {
+ ALOGE("no vendor data in GetScanResults response; ignoring it");
+ return NL_SKIP;
+ }
+
+ for (nl_iterator it(vendor_data); it.has_next(); it.next()) {
+ if (it.get_type() == GSCAN_ATTRIBUTE_SCAN_RESULTS_COMPLETE) {
+ mCompleted = it.get_u8();
+ ALOGD("retrieved mCompleted flag : %d", mCompleted);
+ } else if (it.get_type() == GSCAN_ATTRIBUTE_SCAN_RESULTS || it.get_type() == 0) {
+ int scan_id = 0, flags = 0, num = 0;
+ for (nl_iterator it2(it.get()); it2.has_next(); it2.next()) {
+ if (it2.get_type() == GSCAN_ATTRIBUTE_SCAN_ID) {
+ scan_id = it2.get_u32();
+ ALOGD("retrieved scan_id : 0x%0x", scan_id);
+ } else if (it2.get_type() == GSCAN_ATTRIBUTE_SCAN_FLAGS) {
+ flags = it2.get_u8();
+ ALOGD("retrieved scan_flags : 0x%0x", flags);
+ } else if (it2.get_type() == GSCAN_ATTRIBUTE_NUM_OF_RESULTS) {
+ num = it2.get_u32();
+ ALOGD("retrieved num_results: %d", num);
+ } else if (it2.get_type() == GSCAN_ATTRIBUTE_SCAN_RESULTS) {
+ if (mRetrieved >= mMax) {
+ ALOGW("Stored %d scans, ignoring excess results", mRetrieved);
+ break;
+ }
+ num = it2.get_len() / sizeof(wifi_scan_result);
+ num = min(MAX_RESULTS - mNextScanResult, num);
+ num = min((int)MAX_AP_CACHE_PER_SCAN, num);
+ memcpy(mScanResults + mNextScanResult, it2.get_data(),
+ sizeof(wifi_scan_result) * num);
+ ALOGD("Retrieved %d scan results", num);
+ wifi_scan_result *results = (wifi_scan_result *)it2.get_data();
+ for (int i = 0; i < num; i++) {
+ wifi_scan_result *result = results + i;
+ ALOGD("%02d %-32s %02x:%02x:%02x:%02x:%02x:%02x %04d", i,
+ result->ssid, result->bssid[0], result->bssid[1], result->bssid[2],
+ result->bssid[3], result->bssid[4], result->bssid[5],
+ result->rssi);
+ }
+ mScans[mRetrieved].scan_id = scan_id;
+ mScans[mRetrieved].flags = flags;
+ mScans[mRetrieved].num_results = num;
+ ALOGD("Setting result of scan_id : 0x%0x", mScans[mRetrieved].scan_id);
+ memcpy(mScans[mRetrieved].results,
+ &(mScanResults[mNextScanResult]), num * sizeof(wifi_scan_result));
+ mNextScanResult += num;
+ mRetrieved++;
+ } else {
+ ALOGW("Ignoring invalid attribute type = %d, size = %d",
+ it.get_type(), it.get_len());
+ }
+ }
+ } else {
+ ALOGW("Ignoring invalid attribute type = %d, size = %d",
+ it.get_type(), it.get_len());
+ }
+ }
+
+ return NL_OK;
+ }
+};
+
+wifi_error wifi_get_cached_gscan_results(wifi_interface_handle iface, byte flush,
+ int max, wifi_cached_scan_results *results, int *num) {
+ ALOGD("Getting cached scan results, iface handle = %p, num = %d", iface, *num);
+
+ GetScanResultsCommand *cmd = new GetScanResultsCommand(iface, flush, results, max, num);
+ return (wifi_error)cmd->execute();
+}
+
+/////////////////////////////////////////////////////////////////////////////
+
+class BssidHotlistCommand : public WifiCommand
+{
+private:
+ wifi_bssid_hotlist_params mParams;
+ wifi_hotlist_ap_found_handler mHandler;
+ static const int MAX_RESULTS = 64;
+ wifi_scan_result mResults[MAX_RESULTS];
+public:
+ BssidHotlistCommand(wifi_interface_handle handle, int id,
+ wifi_bssid_hotlist_params params, wifi_hotlist_ap_found_handler handler)
+ : WifiCommand(handle, id), mParams(params), mHandler(handler)
+ { }
+
+ int createSetupRequest(WifiRequest& request) {
+ int result = request.create(GOOGLE_OUI, SLSI_NL80211_VENDOR_SUBCMD_SET_BSSID_HOTLIST);
+ if (result < 0) {
+ return result;
+ }
+
+ nlattr *data = request.attr_start(NL80211_ATTR_VENDOR_DATA);
+
+ result = request.put_u32(GSCAN_ATTRIBUTE_LOST_AP_SAMPLE_SIZE, mParams.lost_ap_sample_size);
+ if (result < 0) {
+ return result;
+ }
+
+ struct nlattr * attr = request.attr_start(GSCAN_ATTRIBUTE_HOTLIST_BSSIDS);
+ for (int i = 0; i < mParams.num_bssid; i++) {
+ nlattr *attr2 = request.attr_start(GSCAN_ATTRIBUTE_HOTLIST_ELEM);
+ if (attr2 == NULL) {
+ return WIFI_ERROR_OUT_OF_MEMORY;
+ }
+ result = request.put_addr(GSCAN_ATTRIBUTE_BSSID, mParams.ap[i].bssid);
+ if (result < 0) {
+ return result;
+ }
+ result = request.put_u8(GSCAN_ATTRIBUTE_RSSI_HIGH, mParams.ap[i].high);
+ if (result < 0) {
+ return result;
+ }
+ result = request.put_u8(GSCAN_ATTRIBUTE_RSSI_LOW, mParams.ap[i].low);
+ if (result < 0) {
+ return result;
+ }
+ request.attr_end(attr2);
+ }
+
+ request.attr_end(attr);
+ request.attr_end(data);
+ return result;
+ }
+
+ int createTeardownRequest(WifiRequest& request) {
+ int result = request.create(GOOGLE_OUI, SLSI_NL80211_VENDOR_SUBCMD_RESET_BSSID_HOTLIST);
+ if (result < 0) {
+ return result;
+ }
+
+ return result;
+ }
+
+ int start() {
+ ALOGD("Executing hotlist setup request, num = %d", mParams.num_bssid);
+ WifiRequest request(familyId(), ifaceId());
+ int result = createSetupRequest(request);
+ if (result < 0) {
+ return result;
+ }
+
+ result = requestResponse(request);
+ if (result < 0) {
+ ALOGD("Failed to execute hotlist setup request, result = %d", result);
+ unregisterVendorHandler(GOOGLE_OUI, GSCAN_EVENT_HOTLIST_RESULTS_FOUND);
+ unregisterVendorHandler(GOOGLE_OUI, GSCAN_EVENT_HOTLIST_RESULTS_LOST);
+ return result;
+ }
+
+ ALOGD("Successfully set %d APs in the hotlist", mParams.num_bssid);
+
+ registerVendorHandler(GOOGLE_OUI, GSCAN_EVENT_HOTLIST_RESULTS_FOUND);
+ registerVendorHandler(GOOGLE_OUI, GSCAN_EVENT_HOTLIST_RESULTS_LOST);
+
+ return result;
+ }
+
+ virtual int cancel() {
+ /* unregister event handler */
+ unregisterVendorHandler(GOOGLE_OUI, GSCAN_EVENT_HOTLIST_RESULTS_FOUND);
+ unregisterVendorHandler(GOOGLE_OUI, GSCAN_EVENT_HOTLIST_RESULTS_LOST);
+ /* create set hotlist message with empty hotlist */
+ WifiRequest request(familyId(), ifaceId());
+ int result = createTeardownRequest(request);
+ if (result < 0) {
+ return result;
+ }
+
+ result = requestResponse(request);
+ if (result < 0) {
+ return result;
+ }
+
+ ALOGD("Successfully reset APs in current hotlist");
+ return result;
+ }
+
+ virtual int handleResponse(WifiEvent& reply) {
+ /* Nothing to do on response! */
+ return NL_SKIP;
+ }
+
+ virtual int handleEvent(WifiEvent& event) {
+ ALOGD("Hotlist AP event");
+ int event_id = event.get_vendor_subcmd();
+ event.log();
+
+ nlattr *vendor_data = event.get_attribute(NL80211_ATTR_VENDOR_DATA);
+ int len = event.get_vendor_data_len();
+
+ if (vendor_data == NULL || len == 0) {
+ ALOGD("No scan results found");
+ return NL_SKIP;
+ }
+
+ memset(mResults, 0, sizeof(wifi_scan_result) * MAX_RESULTS);
+
+ int num = len / sizeof(wifi_scan_result);
+ num = min(MAX_RESULTS, num);
+ memcpy(mResults, event.get_vendor_data(), num * sizeof(wifi_scan_result));
+
+ if (event_id == GSCAN_EVENT_HOTLIST_RESULTS_FOUND) {
+ ALOGD("FOUND %d hotlist APs", num);
+ if (*mHandler.on_hotlist_ap_found)
+ (*mHandler.on_hotlist_ap_found)(id(), num, mResults);
+ } else if (event_id == GSCAN_EVENT_HOTLIST_RESULTS_LOST) {
+ ALOGD("LOST %d hotlist APs", num);
+ if (*mHandler.on_hotlist_ap_lost)
+ (*mHandler.on_hotlist_ap_lost)(id(), num, mResults);
+ }
+ return NL_SKIP;
+ }
+};
+
+wifi_error wifi_set_bssid_hotlist(wifi_request_id id, wifi_interface_handle iface,
+ wifi_bssid_hotlist_params params, wifi_hotlist_ap_found_handler handler)
+{
+ wifi_handle handle = getWifiHandle(iface);
+
+ BssidHotlistCommand *cmd = new BssidHotlistCommand(iface, id, params, handler);
+ wifi_register_cmd(handle, id, cmd);
+ return (wifi_error)cmd->start();
+}
+
+wifi_error wifi_reset_bssid_hotlist(wifi_request_id id, wifi_interface_handle iface)
+{
+ wifi_handle handle = getWifiHandle(iface);
+
+ WifiCommand *cmd = wifi_unregister_cmd(handle, id);
+ if (cmd) {
+ cmd->cancel();
+ cmd->releaseRef();
+ return WIFI_SUCCESS;
+ }
+
+ return WIFI_ERROR_INVALID_ARGS;
+}
+
+
+/////////////////////////////////////////////////////////////////////////////
+
+class SignificantWifiChangeCommand : public WifiCommand
+{
+ typedef struct {
+ mac_addr bssid; // BSSID
+ wifi_channel channel; // channel frequency in MHz
+ int num_rssi; // number of rssi samples
+ wifi_rssi rssi[8]; // RSSI history in db
+ } wifi_significant_change_result_internal;
+
+private:
+ wifi_significant_change_params mParams;
+ wifi_significant_change_handler mHandler;
+ static const int MAX_RESULTS = 64;
+ wifi_significant_change_result_internal mResultsBuffer[MAX_RESULTS];
+ wifi_significant_change_result *mResults[MAX_RESULTS];
+public:
+ SignificantWifiChangeCommand(wifi_interface_handle handle, int id,
+ wifi_significant_change_params params, wifi_significant_change_handler handler)
+ : WifiCommand(handle, id), mParams(params), mHandler(handler)
+ { }
+
+ int createSetupRequest(WifiRequest& request) {
+ int result = request.create(GOOGLE_OUI, SLSI_NL80211_VENDOR_SUBCMD_SET_SIGNIFICANT_CHANGE);
+ if (result < 0) {
+ return result;
+ }
+
+ nlattr *data = request.attr_start(NL80211_ATTR_VENDOR_DATA);
+
+ result = request.put_u16(GSCAN_ATTRIBUTE_RSSI_SAMPLE_SIZE, mParams.rssi_sample_size);
+ if (result < 0) {
+ return result;
+ }
+ result = request.put_u16(GSCAN_ATTRIBUTE_LOST_AP_SAMPLE_SIZE, mParams.lost_ap_sample_size);
+ if (result < 0) {
+ return result;
+ }
+ result = request.put_u16(GSCAN_ATTRIBUTE_MIN_BREACHING, mParams.min_breaching);
+ if (result < 0) {
+ return result;
+ }
+
+ struct nlattr * attr = request.attr_start(GSCAN_ATTRIBUTE_SIGNIFICANT_CHANGE_BSSIDS);
+
+ for (int i = 0; i < mParams.num_bssid; i++) {
+
+ nlattr *attr2 = request.attr_start(i);
+ if (attr2 == NULL) {
+ return WIFI_ERROR_OUT_OF_MEMORY;
+ }
+ result = request.put_addr(GSCAN_ATTRIBUTE_BSSID, mParams.ap[i].bssid);
+ if (result < 0) {
+ return result;
+ }
+ result = request.put_u8(GSCAN_ATTRIBUTE_RSSI_HIGH, mParams.ap[i].high);
+ if (result < 0) {
+ return result;
+ }
+ result = request.put_u8(GSCAN_ATTRIBUTE_RSSI_LOW, mParams.ap[i].low);
+ if (result < 0) {
+ return result;
+ }
+ request.attr_end(attr2);
+ }
+
+ request.attr_end(attr);
+ request.attr_end(data);
+
+ return result;
+ }
+
+ int createTeardownRequest(WifiRequest& request) {
+ int result = request.create(GOOGLE_OUI, SLSI_NL80211_VENDOR_SUBCMD_RESET_SIGNIFICANT_CHANGE);
+ if (result < 0) {
+ return result;
+ }
+
+ return result;
+ }
+
+ int start() {
+ ALOGD("Set significant wifi change");
+ WifiRequest request(familyId(), ifaceId());
+
+ int result = createSetupRequest(request);
+ if (result < 0) {
+ return result;
+ }
+
+ result = requestResponse(request);
+ if (result < 0) {
+ ALOGD("failed to set significant wifi change %d", result);
+ return result;
+ }
+ registerVendorHandler(GOOGLE_OUI, GSCAN_EVENT_SIGNIFICANT_CHANGE_RESULTS);
+
+ return result;
+ }
+
+ virtual int cancel() {
+ /* unregister event handler */
+ unregisterVendorHandler(GOOGLE_OUI, GSCAN_EVENT_SIGNIFICANT_CHANGE_RESULTS);
+
+ /* create set significant change monitor message with empty hotlist */
+ WifiRequest request(familyId(), ifaceId());
+
+ int result = createTeardownRequest(request);
+ if (result < 0) {
+ return result;
+ }
+
+ result = requestResponse(request);
+ if (result < 0) {
+ return result;
+ }
+
+ ALOGD("successfully reset significant wifi change");
+ return result;
+ }
+
+ virtual int handleResponse(WifiEvent& reply) {
+ /* Nothing to do on response! */
+ return NL_SKIP;
+ }
+
+ virtual int handleEvent(WifiEvent& event) {
+ ALOGD("Got a significant wifi change event");
+
+ nlattr *vendor_data = event.get_attribute(NL80211_ATTR_VENDOR_DATA);
+ int len = event.get_vendor_data_len();
+
+ if (vendor_data == NULL || len == 0) {
+ ALOGD("No scan results found");
+ return NL_SKIP;
+ }
+
+ typedef struct {
+ uint16_t channel;
+ mac_addr bssid;
+ int16_t rssi_history[8];
+ } ChangeInfo;
+
+ int num = min(len / sizeof(ChangeInfo), MAX_RESULTS);
+ ChangeInfo *ci = (ChangeInfo *)event.get_vendor_data();
+
+ for (int i = 0; i < num; i++) {
+ memcpy(mResultsBuffer[i].bssid, ci[i].bssid, sizeof(mac_addr));
+ mResultsBuffer[i].channel = ci[i].channel;
+ /* Driver sends N samples and the rest 8-N are filled 0x7FFF
+ * N = no of rssi samples to average sent in significant change request. */
+ int num_rssi = 0;
+ for (int j = 0; j < 8; j++) {
+ if (ci[i].rssi_history[j] == 0x7FFF) {
+ num_rssi = j;
+ break;
+ }
+ mResultsBuffer[i].rssi[j] = (int) ci[i].rssi_history[j];
+ }
+ mResultsBuffer[i].num_rssi = num_rssi;
+ mResults[i] = reinterpret_cast<wifi_significant_change_result *>(&(mResultsBuffer[i]));
+ }
+
+ ALOGD("Retrieved %d scan results", num);
+
+ if (num != 0) {
+ (*mHandler.on_significant_change)(id(), num, mResults);
+ } else {
+ ALOGW("No significant change reported");
+ }
+
+ return NL_SKIP;
+ }
+};
+
+wifi_error wifi_set_significant_change_handler(wifi_request_id id, wifi_interface_handle iface,
+ wifi_significant_change_params params, wifi_significant_change_handler handler)
+{
+ wifi_handle handle = getWifiHandle(iface);
+
+ SignificantWifiChangeCommand *cmd = new SignificantWifiChangeCommand(
+ iface, id, params, handler);
+ wifi_register_cmd(handle, id, cmd);
+ return (wifi_error)cmd->start();
+}
+
+wifi_error wifi_reset_significant_change_handler(wifi_request_id id, wifi_interface_handle iface)
+{
+ wifi_handle handle = getWifiHandle(iface);
+
+ WifiCommand *cmd = wifi_unregister_cmd(handle, id);
+ if (cmd) {
+ cmd->cancel();
+ cmd->releaseRef();
+ return WIFI_SUCCESS;
+ }
+
+ return WIFI_ERROR_INVALID_ARGS;
+}
-#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/handlers.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
-wifi_error wifi_get_link_stats(wifi_request_id id,\r
- wifi_interface_handle iface, wifi_stats_result_handler handler)\r
-{\r
- return WIFI_ERROR_NOT_SUPPORTED;\r
-}\r
+#include <stdint.h>
+#include <fcntl.h>
+#include <sys/socket.h>
+#include <netlink/genl/genl.h>
+#include <netlink/genl/family.h>
+#include <netlink/genl/ctrl.h>
+#include <linux/rtnetlink.h>
+#include <netpacket/packet.h>
+#include <linux/filter.h>
+#include <linux/errqueue.h>
+
+#include <linux/pkt_sched.h>
+#include <netlink/object-api.h>
+#include <netlink/netlink.h>
+#include <netlink/socket.h>
+#include <netlink/handlers.h>
+
+#include "sync.h"
+
+#define LOG_TAG "WifiHAL"
+
+#include <utils/Log.h>
+
+#include "wifi_hal.h"
+#include "common.h"
+#include "cpp_bindings.h"
+wifi_error wifi_get_link_stats(wifi_request_id id,
+ wifi_interface_handle iface, wifi_stats_result_handler handler)
+{
+ return WIFI_ERROR_NOT_SUPPORTED;
+}
-#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-types.h>\r
-\r
-#include "nl80211_copy.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
-/* API to request RTT measurement */\r
-wifi_error wifi_rtt_range_request(wifi_request_id id, wifi_interface_handle iface,\r
- unsigned num_rtt_config, wifi_rtt_config rtt_config[], wifi_rtt_event_handler handler)\r
-{\r
- \r
- return WIFI_ERROR_NOT_SUPPORTED;\r
-}\r
-\r
-/* API to cancel RTT measurements */\r
-wifi_error wifi_rtt_range_cancel(wifi_request_id id, wifi_interface_handle iface,\r
- unsigned num_devices, mac_addr addr[])\r
-{\r
-\r
-\r
- return WIFI_ERROR_NOT_SUPPORTED;\r
-}\r
-\r
-/* API to get RTT capability */\r
-wifi_error wifi_get_rtt_capabilities(wifi_interface_handle iface,\r
- wifi_rtt_capabilities *capabilities)\r
-{\r
-\r
- return WIFI_ERROR_NOT_SUPPORTED;\r
-}\r
+#include <stdint.h>
+#include <fcntl.h>
+#include <sys/socket.h>
+#include <netlink/genl/genl.h>
+#include <netlink/genl/family.h>
+#include <netlink/genl/ctrl.h>
+#include <linux/rtnetlink.h>
+#include <netpacket/packet.h>
+#include <linux/filter.h>
+#include <linux/errqueue.h>
+
+#include <linux/pkt_sched.h>
+#include <netlink/object-api.h>
+#include <netlink/netlink.h>
+#include <netlink/socket.h>
+#include <netlink-types.h>
+
+#include "nl80211_copy.h"
+
+#include "sync.h"
+
+#define LOG_TAG "WifiHAL"
+
+#include <utils/Log.h>
+
+#include "wifi_hal.h"
+#include "common.h"
+#include "cpp_bindings.h"
+/* API to request RTT measurement */
+wifi_error wifi_rtt_range_request(wifi_request_id id, wifi_interface_handle iface,
+ unsigned num_rtt_config, wifi_rtt_config rtt_config[], wifi_rtt_event_handler handler)
+{
+
+ return WIFI_ERROR_NOT_SUPPORTED;
+}
+
+/* API to cancel RTT measurements */
+wifi_error wifi_rtt_range_cancel(wifi_request_id id, wifi_interface_handle iface,
+ unsigned num_devices, mac_addr addr[])
+{
+
+
+ return WIFI_ERROR_NOT_SUPPORTED;
+}
+
+/* API to get RTT capability */
+wifi_error wifi_get_rtt_capabilities(wifi_interface_handle iface,
+ wifi_rtt_capabilities *capabilities)
+{
+
+ return WIFI_ERROR_NOT_SUPPORTED;
+}
-\r
-#include <pthread.h>\r
-\r
-#ifndef __WIFI_HAL_SYNC_H__\r
-#define __WIFI_HAL_SYNC_H__\r
-\r
-class Mutex\r
-{\r
-private:\r
- pthread_mutex_t mMutex;\r
-public:\r
- Mutex() {\r
- pthread_mutex_init(&mMutex, NULL);\r
- }\r
- ~Mutex() {\r
- pthread_mutex_destroy(&mMutex);\r
- }\r
- int tryLock() {\r
- return pthread_mutex_trylock(&mMutex);\r
- }\r
- int lock() {\r
- return pthread_mutex_lock(&mMutex);\r
- }\r
- void unlock() {\r
- pthread_mutex_unlock(&mMutex);\r
- }\r
-};\r
-\r
-class Condition\r
-{\r
-private:\r
- pthread_cond_t mCondition;\r
- pthread_mutex_t mMutex;\r
-\r
-public:\r
- Condition() {\r
- pthread_mutex_init(&mMutex, NULL);\r
- pthread_cond_init(&mCondition, NULL);\r
- }\r
- ~Condition() {\r
- pthread_cond_destroy(&mCondition);\r
- pthread_mutex_destroy(&mMutex);\r
- }\r
-\r
- int wait() {\r
- return pthread_cond_wait(&mCondition, &mMutex);\r
- }\r
-\r
- void signal() {\r
- pthread_cond_signal(&mCondition);\r
- }\r
-};\r
-\r
+
+#include <pthread.h>
+
+#ifndef __WIFI_HAL_SYNC_H__
+#define __WIFI_HAL_SYNC_H__
+
+class Mutex
+{
+private:
+ pthread_mutex_t mMutex;
+public:
+ Mutex() {
+ pthread_mutex_init(&mMutex, NULL);
+ }
+ ~Mutex() {
+ pthread_mutex_destroy(&mMutex);
+ }
+ int tryLock() {
+ return pthread_mutex_trylock(&mMutex);
+ }
+ int lock() {
+ return pthread_mutex_lock(&mMutex);
+ }
+ void unlock() {
+ pthread_mutex_unlock(&mMutex);
+ }
+};
+
+class Condition
+{
+private:
+ pthread_cond_t mCondition;
+ pthread_mutex_t mMutex;
+
+public:
+ Condition() {
+ pthread_mutex_init(&mMutex, NULL);
+ pthread_cond_init(&mCondition, NULL);
+ }
+ ~Condition() {
+ pthread_cond_destroy(&mCondition);
+ pthread_mutex_destroy(&mMutex);
+ }
+
+ int wait() {
+ return pthread_cond_wait(&mCondition, &mMutex);
+ }
+
+ void signal() {
+ pthread_cond_signal(&mCondition);
+ }
+};
+
#endif
\ No newline at end of file
-#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
+#include <errno.h>
+#include <stdint.h>
+#include <fcntl.h>
+#include <sys/socket.h>
+#include <netlink/genl/genl.h>
+#include <netlink/genl/family.h>
+#include <netlink/genl/ctrl.h>
+#include <linux/rtnetlink.h>
+#include <netpacket/packet.h>
+#include <linux/filter.h>
+#include <linux/errqueue.h>
+
+#include <linux/pkt_sched.h>
+#include <netlink/object-api.h>
+#include <netlink/netlink.h>
+#include <netlink/socket.h>
+#include <netlink/attr.h>
+#include <netlink/handlers.h>
+#include <netlink/msg.h>
+
+#include <dirent.h>
+#include <net/if.h>
+
+#include "sync.h"
+
+#define LOG_TAG "WifiHAL"
+
+#include <utils/Log.h>
+
+#include "wifi_hal.h"
+#include "common.h"
+#include "cpp_bindings.h"
+
+
+#define WIFI_HAL_CMD_SOCK_PORT 644
+#define WIFI_HAL_EVENT_SOCK_PORT 645
+
+#define FEATURE_SET 0
+#define FEATURE_SET_MATRIX 1
+#define ATTR_NODFS_VALUE 3
+
+static void internal_event_handler(wifi_handle handle, int events);
+static int internal_no_seq_check(nl_msg *msg, void *arg);
+static int internal_valid_message_handler(nl_msg *msg, void *arg);
+static int wifi_get_multicast_id(wifi_handle handle, const char *name, const char *group);
+static int wifi_add_membership(wifi_handle handle, const char *group);
+static wifi_error wifi_init_interfaces(wifi_handle handle);
+
+typedef enum wifi_attr {
+ ANDR_WIFI_ATTRIBUTE_NUM_FEATURE_SET,
+ ANDR_WIFI_ATTRIBUTE_FEATURE_SET,
+ ANDR_WIFI_ATTRIBUTE_PNO_RANDOM_MAC_OUI
+} wifi_attr_t;
+
+/* Initialize/Cleanup */
+
+void wifi_socket_set_local_port(struct nl_sock *sock, uint32_t port)
+{
+ uint32_t pid = getpid() & 0x3FFFFF;
+ nl_socket_set_local_port(sock, pid + (port << 22));
+}
+
+static nl_sock * wifi_create_nl_socket(int port)
+{
+ ALOGI("Creating socket");
+ struct nl_sock *sock = nl_socket_alloc();
+ if (sock == NULL) {
+ ALOGE("Could not create handle");
+ return NULL;
+ }
+
+ wifi_socket_set_local_port(sock, port);
+
+ struct sockaddr *addr = NULL;
+ // ALOGI("sizeof(sockaddr) = %d, sizeof(sockaddr_nl) = %d", sizeof(*addr), sizeof(*addr_nl));
+
+ ALOGI("Connecting socket");
+ if (nl_connect(sock, NETLINK_GENERIC)) {
+ ALOGE("Could not connect handle");
+ nl_socket_free(sock);
+ return NULL;
+ }
+
+ ALOGI("Making socket nonblocking");
+ /*
+ if (nl_socket_set_nonblocking(sock)) {
+ ALOGE("Could make socket non-blocking");
+ nl_socket_free(sock);
+ return NULL;
+ }
+ */
+
+ return sock;
+}
+
+/*initialize function pointer table with Broadcom HHAL API*/
+wifi_error init_wifi_vendor_hal_func_table(wifi_hal_fn *fn)
+{
+ if (fn == NULL) {
+ return WIFI_ERROR_UNKNOWN;
+ }
+ fn->wifi_initialize = wifi_initialize;
+ fn->wifi_cleanup = wifi_cleanup;
+ fn->wifi_event_loop = wifi_event_loop;
+ fn->wifi_get_supported_feature_set = wifi_get_supported_feature_set;
+ fn->wifi_get_concurrency_matrix = wifi_get_concurrency_matrix;
+ fn->wifi_set_scanning_mac_oui = wifi_set_scanning_mac_oui;
+ fn->wifi_get_ifaces = wifi_get_ifaces;
+ fn->wifi_get_iface_name = wifi_get_iface_name;
+ fn->wifi_start_gscan = wifi_start_gscan;
+ fn->wifi_stop_gscan = wifi_stop_gscan;
+ fn->wifi_get_cached_gscan_results = wifi_get_cached_gscan_results;
+ fn->wifi_set_bssid_hotlist = wifi_set_bssid_hotlist;
+ fn->wifi_reset_bssid_hotlist = wifi_reset_bssid_hotlist;
+ fn->wifi_set_significant_change_handler = wifi_set_significant_change_handler;
+ fn->wifi_reset_significant_change_handler = wifi_reset_significant_change_handler;
+ fn->wifi_get_gscan_capabilities = wifi_get_gscan_capabilities;
+ fn->wifi_get_link_stats = wifi_get_link_stats;
+ fn->wifi_get_valid_channels = wifi_get_valid_channels;
+ fn->wifi_rtt_range_request = wifi_rtt_range_request;
+ fn->wifi_rtt_range_cancel = wifi_rtt_range_cancel;
+ fn->wifi_get_rtt_capabilities = wifi_get_rtt_capabilities;
+ fn->wifi_set_nodfs_flag = wifi_set_nodfs_flag;
+ return WIFI_SUCCESS;
+}
+
+wifi_error wifi_initialize(wifi_handle *handle)
+{
+ srand(getpid());
+
+ ALOGI("Initializing wifi");
+ hal_info *info = (hal_info *)malloc(sizeof(hal_info));
+ if (info == NULL) {
+ ALOGE("Could not allocate hal_info");
+ return WIFI_ERROR_UNKNOWN;
+ }
+
+ memset(info, 0, sizeof(*info));
+
+ ALOGI("Creating socket");
+ if (socketpair(AF_UNIX, SOCK_STREAM, 0, info->cleanup_socks) == -1) {
+ ALOGE("Could not create cleanup sockets");
+ free(info);
+ return WIFI_ERROR_UNKNOWN;
+ }
+
+ struct nl_sock *cmd_sock = wifi_create_nl_socket(WIFI_HAL_CMD_SOCK_PORT);
+ if (cmd_sock == NULL) {
+ ALOGE("Could not create handle");
+ free(info);
+ return WIFI_ERROR_UNKNOWN;
+ }
+
+ struct nl_sock *event_sock = wifi_create_nl_socket(WIFI_HAL_EVENT_SOCK_PORT);
+ if (event_sock == NULL) {
+ ALOGE("Could not create handle");
+ nl_socket_free(cmd_sock);
+ free(info);
+ return WIFI_ERROR_UNKNOWN;
+ }
+
+ struct nl_cb *cb = nl_socket_get_cb(event_sock);
+ if (cb == NULL) {
+ ALOGE("Could not create handle");
+ nl_socket_free(cmd_sock);
+ nl_socket_free(event_sock);
+ free(info);
+ return WIFI_ERROR_UNKNOWN;
+ }
+
+// ALOGI("cb->refcnt = %d", cb->cb_refcnt);
+ nl_cb_set(cb, NL_CB_SEQ_CHECK, NL_CB_CUSTOM, internal_no_seq_check, info);
+ nl_cb_set(cb, NL_CB_VALID, NL_CB_CUSTOM, internal_valid_message_handler, info);
+ nl_cb_put(cb);
+
+ info->cmd_sock = cmd_sock;
+ info->event_sock = event_sock;
+ info->clean_up = false;
+ info->in_event_loop = false;
+
+ info->event_cb = (cb_info *)malloc(sizeof(cb_info) * DEFAULT_EVENT_CB_SIZE);
+ info->alloc_event_cb = DEFAULT_EVENT_CB_SIZE;
+ info->num_event_cb = 0;
+
+ info->cmd = (cmd_info *)malloc(sizeof(cmd_info) * DEFAULT_CMD_SIZE);
+ info->alloc_cmd = DEFAULT_CMD_SIZE;
+ info->num_cmd = 0;
+
+ info->nl80211_family_id = genl_ctrl_resolve(cmd_sock, "nl80211");
+ if (info->nl80211_family_id < 0) {
+ ALOGE("Could not resolve nl80211 familty id");
+ nl_socket_free(cmd_sock);
+ nl_socket_free(event_sock);
+ free(info);
+ return WIFI_ERROR_UNKNOWN;
+ }
+
+ pthread_mutex_init(&info->cb_lock, NULL);
+
+ *handle = (wifi_handle) info;
+ ALOGD("wifi_initialize, handle = %p\n", handle);
+ ALOGD("wifi_initialize, *handle = %p\n", *handle);
+ ALOGD("wifi_initialize, info = %p\n", info);
+ ALOGD("wifi_initialize, *info = %pn", *info);
+ wifi_add_membership(*handle, "scan");
+ wifi_add_membership(*handle, "mlme");
+ wifi_add_membership(*handle, "regulatory");
+ wifi_add_membership(*handle, "vendor");
+
+ wifi_init_interfaces(*handle);
+ ALOGD("Found %d interfaces", info->num_interfaces);
+
+
+ ALOGI("Initialized Wifi HAL Successfully; vendor cmd = %d", NL80211_CMD_VENDOR);
+ return WIFI_SUCCESS;
+}
+
+static int wifi_add_membership(wifi_handle handle, const char *group)
+{
+ hal_info *info = getHalInfo(handle);
+
+ int id = wifi_get_multicast_id(handle, "nl80211", group);
+ if (id < 0) {
+ ALOGE("Could not find group %s", group);
+ return id;
+ }
+
+ int ret = nl_socket_add_membership(info->event_sock, id);
+ if (ret < 0) {
+ ALOGE("Could not add membership to group %s", group);
+ }
+
+ ALOGI("Successfully added membership for group %s", group);
+ return ret;
+}
+
+static void internal_cleaned_up_handler(wifi_handle handle)
+{
+ hal_info *info = getHalInfo(handle);
+ wifi_cleaned_up_handler cleaned_up_handler = info->cleaned_up_handler;
+
+ if (info->cmd_sock != 0) {
+ close(info->cleanup_socks[0]);
+ close(info->cleanup_socks[1]);
+ nl_socket_free(info->cmd_sock);
+ nl_socket_free(info->event_sock);
+ info->cmd_sock = NULL;
+ info->event_sock = NULL;
+ }
+
+ (*cleaned_up_handler)(handle);
+ pthread_mutex_destroy(&info->cb_lock);
+ free(info);
+
+ ALOGI("Internal cleanup completed");
+}
+
+void wifi_cleanup(wifi_handle handle, wifi_cleaned_up_handler handler)
+{
+ hal_info *info = getHalInfo(handle);
+ char buf[64];
+
+ info->cleaned_up_handler = handler;
+ if (write(info->cleanup_socks[0], "Exit", 4) < 1) {
+ ALOGE("could not write to the cleanup socket");
+ } else {
+ // Listen to the response
+ // Hopefully we dont get errors or get hung up
+ // Not much can be done in that case, but assume that
+ // it has rx'ed the Exit message to exit the thread.
+ // As a fallback set the cleanup flag to TRUE
+ memset(buf, 0, sizeof(buf));
+ int result = read(info->cleanup_socks[0], buf, sizeof(buf));
+ ALOGE("%s: Read after POLL returned %d, error no = %d", __FUNCTION__, result, errno);
+ if (strncmp(buf, "Done", 4) == 0) {
+ ALOGE("Event processing terminated");
+ } else {
+ ALOGD("Rx'ed %s", buf);
+ }
+ }
+ info->clean_up = true;
+ pthread_mutex_lock(&info->cb_lock);
+
+ int bad_commands = 0;
+
+ for (int i = 0; i < info->num_event_cb; i++) {
+ cb_info *cbi = &(info->event_cb[i]);
+ WifiCommand *cmd = (WifiCommand *)cbi->cb_arg;
+ }
+
+ while (info->num_cmd > bad_commands) {
+ int num_cmd = info->num_cmd;
+ cmd_info *cmdi = &(info->cmd[bad_commands]);
+ WifiCommand *cmd = cmdi->cmd;
+ if (cmd != NULL) {
+ pthread_mutex_unlock(&info->cb_lock);
+ cmd->cancel();
+ pthread_mutex_lock(&info->cb_lock);
+ /* release reference added when command is saved */
+ cmd->releaseRef();
+ if (num_cmd == info->num_cmd) {
+ bad_commands++;
+ }
+ }
+ }
+
+ for (int i = 0; i < info->num_event_cb; i++) {
+ cb_info *cbi = &(info->event_cb[i]);
+ WifiCommand *cmd = (WifiCommand *)cbi->cb_arg;
+ ALOGE("Leaked command %p", cmd);
+ }
+ pthread_mutex_unlock(&info->cb_lock);
+ internal_cleaned_up_handler(handle);
+}
+
+static int internal_pollin_handler(wifi_handle handle)
+{
+ hal_info *info = getHalInfo(handle);
+ ALOGI("even_loop info = %p", info);
+ struct nl_cb *cb = nl_socket_get_cb(info->event_sock);
+ int res = nl_recvmsgs(info->event_sock, cb);
+ ALOGD("nl_recvmsgs returned %d", res);
+ nl_cb_put(cb);
+ return res;
+}
+
+/* Run event handler */
+void wifi_event_loop(wifi_handle handle)
+{
+ hal_info *info = getHalInfo(handle);
+ ALOGI("even_loop info = %p", info);
+ ALOGI("even_loop info = %p", handle);
+ if (info->in_event_loop) {
+ return;
+ } else {
+ info->in_event_loop = true;
+ }
+
+ pollfd pfd[2];
+ memset(&pfd[0], 0, sizeof(pollfd) * 2);
+
+ pfd[0].fd = nl_socket_get_fd(info->event_sock);
+ pfd[0].events = POLLIN;
+ pfd[1].fd = info->cleanup_socks[1];
+ pfd[1].events = POLLIN;
+
+ char buf[2048];
+
+ do {
+ int timeout = -1; /* Infinite timeout */
+ pfd[0].revents = 0;
+ pfd[1].revents = 0;
+ int result = poll(pfd, 2, timeout);
+ if (result < 0) {
+ } else if (pfd[0].revents & POLLERR) {
+ ALOGE("POLL Error; error no = %d", errno);
+ int result2 = read(pfd[0].fd, buf, sizeof(buf));
+ ALOGE("Read after POLL returned %d, error no = %d", result2, errno);
+ } else if (pfd[0].revents & POLLHUP) {
+ ALOGE("Remote side hung up");
+ break;
+ } else if (pfd[0].revents & POLLIN) {
+ internal_pollin_handler(handle);
+ } else if (pfd[1].revents & POLLIN) {
+ memset(buf, 0, sizeof(buf));
+ int result2 = read(pfd[1].fd, buf, sizeof(buf));
+ ALOGE("%s: Read after POLL returned %d, error no = %d", __FUNCTION__, result2, errno);
+ if (strncmp(buf, "Exit", 4) == 0) {
+ ALOGD("Got a signal to exit!!!");
+ if (write(pfd[1].fd, "Done", 4) < 1) {
+ ALOGE("could not write to the cleanup socket");
+ }
+ break;
+ } else {
+ ALOGD("Rx'ed %s on the cleanup socket\n", buf);
+ }
+ } else {
+ ALOGE("Unknown event - %0x, %0x", pfd[0].revents, pfd[1].revents);
+ }
+ } while (!info->clean_up);
+ ALOGI("Exit %s", __FUNCTION__);
+}
+
+///////////////////////////////////////////////////////////////////////////////////////
+
+static int internal_no_seq_check(struct nl_msg *msg, void *arg)
+{
+ return NL_OK;
+}
+
+static int internal_valid_message_handler(nl_msg *msg, void *arg)
+{
+ wifi_handle handle = (wifi_handle)arg;
+ hal_info *info = getHalInfo(handle);
+ ALOGI("even_loop info = %p", handle);
+ ALOGD("internal_valid_message_handler, info = %p", info);
+
+ WifiEvent event(msg);
+ int res = event.parse();
+ if (res < 0) {
+ ALOGE("Failed to parse event: %d", res);
+ return NL_SKIP;
+ }
+
+ int cmd = event.get_cmd();
+ uint32_t vendor_id = 0;
+ int subcmd = 0;
+
+ if (cmd == NL80211_CMD_VENDOR) {
+ vendor_id = event.get_u32(NL80211_ATTR_VENDOR_ID);
+ subcmd = event.get_u32(NL80211_ATTR_VENDOR_SUBCMD);
+ ALOGI("event received %s, vendor_id = 0x%0x, subcmd = 0x%0x",
+ event.get_cmdString(), vendor_id, subcmd);
+ } else {
+ ALOGI("event received %s", event.get_cmdString());
+ }
+
+ //ALOGI("event received %s, vendor_id = 0x%0x", event.get_cmdString(), vendor_id);
+ //event.log();
+
+ bool dispatched = false;
+
+ pthread_mutex_lock(&info->cb_lock);
+
+ ALOGI("Number of events %d", info->num_event_cb);
+
+ for (int i = 0; i < info->num_event_cb; i++) {
+ if (cmd == info->event_cb[i].nl_cmd) {
+ if (cmd == NL80211_CMD_VENDOR
+ && ((vendor_id != info->event_cb[i].vendor_id)
+ || (subcmd != info->event_cb[i].vendor_subcmd)))
+ {
+ /* event for a different vendor, ignore it */
+ continue;
+ }
+
+ cb_info *cbi = &(info->event_cb[i]);
+ nl_recvmsg_msg_cb_t cb_func = cbi->cb_func;
+ void *cb_arg = cbi->cb_arg;
+ WifiCommand *cmd = (WifiCommand *)cbi->cb_arg;
+ if (cmd != NULL) {
+ cmd->addRef();
+ }
+
+ pthread_mutex_unlock(&info->cb_lock);
+ if (cb_func)
+ (*cb_func)(msg, cb_arg);
+ if (cmd != NULL) {
+ cmd->releaseRef();
+ }
+
+ return NL_OK;
+ }
+ }
+
+ pthread_mutex_unlock(&info->cb_lock);
+ return NL_OK;
+}
+
+///////////////////////////////////////////////////////////////////////////////////////
+
+class GetMulticastIdCommand : public WifiCommand
+{
+private:
+ const char *mName;
+ const char *mGroup;
+ int mId;
+public:
+ GetMulticastIdCommand(wifi_handle handle, const char *name, const char *group)
+ : WifiCommand(handle, 0)
+ {
+ mName = name;
+ mGroup = group;
+ mId = -1;
+ }
+
+ int getId() {
+ return mId;
+ }
+
+ virtual int create() {
+ int nlctrlFamily = genl_ctrl_resolve(mInfo->cmd_sock, "nlctrl");
+ ALOGI("ctrl family = %d", nlctrlFamily);
+ int ret = mMsg.create(nlctrlFamily, CTRL_CMD_GETFAMILY, 0, 0);
+ if (ret < 0) {
+ return ret;
+ }
+ ret = mMsg.put_string(CTRL_ATTR_FAMILY_NAME, mName);
+ return ret;
+ }
+
+ virtual int handleResponse(WifiEvent& reply) {
+
+ ALOGE("handling reponse in %s", __func__);
+
+ struct nlattr **tb = reply.attributes();
+ struct genlmsghdr *gnlh = reply.header();
+ struct nlattr *mcgrp = NULL;
+ int i;
+
+ if (!tb[CTRL_ATTR_MCAST_GROUPS]) {
+ ALOGE("No multicast groups found");
+ return NL_SKIP;
+ } else {
+ ALOGE("Multicast groups attr size = %d", nla_len(tb[CTRL_ATTR_MCAST_GROUPS]));
+ }
+
+ for_each_attr(mcgrp, tb[CTRL_ATTR_MCAST_GROUPS], i) {
+
+ ALOGE("Processing group");
+ struct nlattr *tb2[CTRL_ATTR_MCAST_GRP_MAX + 1];
+ nla_parse(tb2, CTRL_ATTR_MCAST_GRP_MAX, (nlattr *)nla_data(mcgrp),
+ nla_len(mcgrp), NULL);
+ if (!tb2[CTRL_ATTR_MCAST_GRP_NAME] || !tb2[CTRL_ATTR_MCAST_GRP_ID]) {
+ continue;
+ }
+
+ char *grpName = (char *)nla_data(tb2[CTRL_ATTR_MCAST_GRP_NAME]);
+ int grpNameLen = nla_len(tb2[CTRL_ATTR_MCAST_GRP_NAME]);
+
+ ALOGE("Found group name %s", grpName);
+
+ if (strncmp(grpName, mGroup, grpNameLen) != 0)
+ continue;
+
+ mId = nla_get_u32(tb2[CTRL_ATTR_MCAST_GRP_ID]);
+ break;
+ }
+
+ return NL_SKIP;
+ }
+
+};
+
+class SetPnoMacAddrOuiCommand : public WifiCommand {
+
+private:
+ byte *mOui;
+ feature_set *fset;
+ feature_set *feature_matrix;
+ int *fm_size;
+ int set_size_max;
+public:
+ SetPnoMacAddrOuiCommand(wifi_interface_handle handle, oui scan_oui)
+ : WifiCommand(handle, 0)
+ {
+ mOui = scan_oui;
+ }
+
+ int createRequest(WifiRequest& request, int subcmd, byte *scan_oui) {
+ int result = request.create(GOOGLE_OUI, subcmd);
+ if (result < 0) {
+ return result;
+ }
+
+ nlattr *data = request.attr_start(NL80211_ATTR_VENDOR_DATA);
+ result = request.put(ANDR_WIFI_ATTRIBUTE_PNO_RANDOM_MAC_OUI, scan_oui, DOT11_OUI_LEN);
+ if (result < 0) {
+ return result;
+ }
+
+ request.attr_end(data);
+ return WIFI_SUCCESS;
+
+ }
+
+ int start() {
+ ALOGD("Sending mac address OUI");
+ WifiRequest request(familyId(), ifaceId());
+ int result = createRequest(request, SLSI_NL80211_VENDOR_SUBCMD_SET_GSCAN_OUI, mOui);
+ if (result != WIFI_SUCCESS) {
+ ALOGE("failed to create request; result = %d", result);
+ return result;
+ }
+
+ result = requestResponse(request);
+ if (result != WIFI_SUCCESS) {
+ ALOGE("failed to set scanning mac OUI; result = %d", result);
+ }
+
+ return result;
+ }
+protected:
+ virtual int handleResponse(WifiEvent& reply) {
+ ALOGD("Request complete!");
+ /* Nothing to do on response! */
+ return NL_SKIP;
+ }
+};
+
+class SetNodfsCommand : public WifiCommand {
+
+private:
+ u32 mNoDfs;
+public:
+ SetNodfsCommand(wifi_interface_handle handle, u32 nodfs)
+ : WifiCommand(handle, 0) {
+ mNoDfs = nodfs;
+ }
+ virtual int create() {
+ int ret;
+
+ ret = mMsg.create(GOOGLE_OUI, SLSI_NL80211_VENDOR_SUBCMD_SET_NODFS);
+ if (ret < 0) {
+ ALOGE("Can't create message to send to driver - %d", ret);
+ return ret;
+ }
+
+ nlattr *data = mMsg.attr_start(NL80211_ATTR_VENDOR_DATA);
+ ret = mMsg.put_u32(ATTR_NODFS_VALUE, mNoDfs);
+ if (ret < 0) {
+ return ret;
+ }
+
+ mMsg.attr_end(data);
+ return WIFI_SUCCESS;
+ }
+};
+
+static int wifi_get_multicast_id(wifi_handle handle, const char *name, const char *group)
+{
+ GetMulticastIdCommand cmd(handle, name, group);
+ int res = cmd.requestResponse();
+ if (res < 0)
+ return res;
+ else
+ return cmd.getId();
+}
+
+/////////////////////////////////////////////////////////////////////////
+
+static bool is_wifi_interface(const char *name)
+{
+ if (strncmp(name, "wlan", 4) != 0 && strncmp(name, "p2p", 3) != 0) {
+ /* not a wifi interface; ignore it */
+ return false;
+ } else {
+ return true;
+ }
+}
+
+static int get_interface(const char *name, interface_info *info)
+{
+ strcpy(info->name, name);
+ info->id = if_nametoindex(name);
+ ALOGI("found an interface : %s, id = %d", name, info->id);
+ return WIFI_SUCCESS;
+}
+
+wifi_error wifi_init_interfaces(wifi_handle handle)
+{
+ hal_info *info = (hal_info *)handle;
+ ALOGD("wifi_init_interfaces, info = %p", info);
+
+ struct dirent *de;
+
+ DIR *d = opendir("/sys/class/net");
+ if (d == 0)
+ return WIFI_ERROR_UNKNOWN;
+
+ int n = 0;
+ while ((de = readdir(d))) {
+ if (de->d_name[0] == '.')
+ continue;
+ if (is_wifi_interface(de->d_name) ) {
+ n++;
+ }
+ }
+
+ closedir(d);
+
+ d = opendir("/sys/class/net");
+ if (d == 0)
+ return WIFI_ERROR_UNKNOWN;
+
+ info->interfaces = (interface_info **)malloc(sizeof(interface_info *) * n);
+
+ int i = 0;
+ while ((de = readdir(d))) {
+ if (de->d_name[0] == '.')
+ continue;
+ if (is_wifi_interface(de->d_name)) {
+ interface_info *ifinfo = (interface_info *)malloc(sizeof(interface_info));
+ if (get_interface(de->d_name, ifinfo) != WIFI_SUCCESS) {
+ free(ifinfo);
+ continue;
+ }
+ ifinfo->handle = handle;
+ info->interfaces[i] = ifinfo;
+ i++;
+ }
+ }
+
+ closedir(d);
+
+ info->num_interfaces = n;
+ return WIFI_SUCCESS;
+}
+
+wifi_error wifi_get_ifaces(wifi_handle handle, int *num, wifi_interface_handle **interfaces)
+{
+ hal_info *info = (hal_info *)handle;
+
+ *interfaces = (wifi_interface_handle *)info->interfaces;
+ *num = info->num_interfaces;
+
+ return WIFI_SUCCESS;
+}
+
+wifi_error wifi_get_iface_name(wifi_interface_handle handle, char *name, size_t size)
+{
+ interface_info *info = (interface_info *)handle;
+ strcpy(name, info->name);
+ return WIFI_SUCCESS;
+}
+
+wifi_error wifi_get_supported_feature_set(wifi_interface_handle handle, feature_set *set)
+{
+ return WIFI_ERROR_NOT_SUPPORTED;
+}
+
+wifi_error wifi_get_concurrency_matrix(wifi_interface_handle handle, int set_size_max,
+ feature_set set[], int *set_size)
+{
+ return WIFI_ERROR_NOT_SUPPORTED;
+}
+
+wifi_error wifi_set_scanning_mac_oui(wifi_interface_handle handle, oui scan_oui)
+{
+ SetPnoMacAddrOuiCommand command(handle, scan_oui);
+ return (wifi_error)command.start();
+
+}
+
+wifi_error wifi_set_nodfs_flag(wifi_interface_handle handle, u32 nodfs)
+{
+ SetNodfsCommand command(handle, nodfs);
+ return (wifi_error) command.requestResponse();
+}
+
+/////////////////////////////////////////////////////////////////////////////
projects / GitHub / MotorolaMobilityLLC / hardware-samsung_slsi-scsc_wifibt-wifi_hal.git / commitdiff