--- /dev/null
+
+#include <stdint.h>
+#include <stddef.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"
+
+#include <utils/Log.h>
+
+#include "wifi_hal.h"
+#include "common.h"
+#include "cpp_bindings.h"
+
+#define SLSI_WIFI_HAL_NAN_VERSION 1
+
+#define CHECK_WIFI_STATUS_RETURN_FAIL(result, LOGSTR) \
+ if (result != WIFI_SUCCESS) {\
+ ALOGE(LOGSTR" [result:%d]", result);\
+ return result;\
+ }
+
+#define CHECK_CONFIG_PUT_8_RETURN_FAIL(config, val, nan_attribute, request, result, FAIL_STR) \
+ if (config) {\
+ result = request.put_u8(nan_attribute, val); \
+ if (result != WIFI_SUCCESS) {\
+ ALOGE(FAIL_STR" [result:%d]", result);\
+ return result;\
+ }\
+ }
+
+#define CHECK_CONFIG_PUT_16_RETURN_FAIL(config, val, nan_attribute, request, result, FAIL_STR) \
+ if (config) {\
+ result = request.put_u16(nan_attribute, val); \
+ if (result != WIFI_SUCCESS) {\
+ ALOGE(FAIL_STR" [result:%d]", result);\
+ return result;\
+ }\
+ }
+
+
+#define CHECK_CONFIG_PUT_32_RETURN_FAIL(config, val, nan_attribute, request, result, FAIL_STR) \
+ if (config) {\
+ result = request.put_u32(nan_attribute, val); \
+ if (result != WIFI_SUCCESS) {\
+ ALOGE(FAIL_STR" [result:%d]", result);\
+ return result;\
+ }\
+ }
+
+#define CHECK_CONFIG_PUT_RETURN_FAIL(config, valptr, len, nan_attribute, request, result, FAIL_STR) \
+ if (config) {\
+ result = request.put(nan_attribute, valptr, len); \
+ if (result != WIFI_SUCCESS) {\
+ ALOGE(FAIL_STR" [result:%d]", result);\
+ return result;\
+ }\
+ }
+
+typedef enum {
+ NAN_REQ_ATTR_MASTER_PREF,
+ NAN_REQ_ATTR_CLUSTER_LOW,
+ NAN_REQ_ATTR_CLUSTER_HIGH,
+ NAN_REQ_ATTR_HOP_COUNT_LIMIT_VAL,
+ NAN_REQ_ATTR_SID_BEACON_VAL,
+
+ NAN_REQ_ATTR_SUPPORT_2G4_VAL,
+ NAN_REQ_ATTR_SUPPORT_5G_VAL,
+
+ NAN_REQ_ATTR_RSSI_CLOSE_2G4_VAL,
+ NAN_REQ_ATTR_RSSI_MIDDLE_2G4_VAL,
+ NAN_REQ_ATTR_RSSI_PROXIMITY_2G4_VAL,
+ NAN_REQ_ATTR_BEACONS_2G4_VAL,
+ NAN_REQ_ATTR_SDF_2G4_VAL,
+ NAN_REQ_ATTR_CHANNEL_2G4_MHZ_VAL,
+ NAN_REQ_ATTR_RSSI_PROXIMITY_VAL,
+
+
+ NAN_REQ_ATTR_RSSI_CLOSE_5G_VAL,
+ NAN_REQ_ATTR_RSSI_CLOSE_PROXIMITY_5G_VAL,
+ NAN_REQ_ATTR_RSSI_MIDDLE_5G_VAL,
+ NAN_REQ_ATTR_RSSI_PROXIMITY_5G_VAL,
+ NAN_REQ_ATTR_BEACON_5G_VAL,
+ NAN_REQ_ATTR_SDF_5G_VAL,
+ NAN_REQ_ATTR_CHANNEL_5G_MHZ_VAL,
+
+ NAN_REQ_ATTR_RSSI_WINDOW_SIZE_VAL,
+ NAN_REQ_ATTR_OUI_VAL,
+ NAN_REQ_ATTR_MAC_ADDR_VAL,
+ NAN_REQ_ATTR_CLUSTER_VAL,
+ NAN_REQ_ATTR_SOCIAL_CH_SCAN_DWELL_TIME,
+ NAN_REQ_ATTR_SOCIAL_CH_SCAN_PERIOD,
+ NAN_REQ_ATTR_RANDOM_FACTOR_FORCE_VAL,
+ NAN_REQ_ATTR_HOP_COUNT_FORCE_VAL,
+ NAN_REQ_ATTR_CONN_CAPABILITY_PAYLOAD_TX,
+ NAN_REQ_ATTR_CONN_CAPABILITY_IBSS,
+ NAN_REQ_ATTR_CONN_CAPABILITY_WFD,
+ NAN_REQ_ATTR_CONN_CAPABILITY_WFDS,
+ NAN_REQ_ATTR_CONN_CAPABILITY_TDLS,
+ NAN_REQ_ATTR_CONN_CAPABILITY_MESH,
+ NAN_REQ_ATTR_CONN_CAPABILITY_WLAN_INFRA,
+ NAN_REQ_ATTR_DISCOVERY_ATTR_NUM_ENTRIES,
+ NAN_REQ_ATTR_DISCOVERY_ATTR_VAL,
+ NAN_REQ_ATTR_CONN_TYPE,
+ NAN_REQ_ATTR_NAN_ROLE,
+ NAN_REQ_ATTR_TRANSMIT_FREQ,
+ NAN_REQ_ATTR_AVAILABILITY_DURATION,
+ NAN_REQ_ATTR_AVAILABILITY_INTERVAL,
+ NAN_REQ_ATTR_MESH_ID_LEN,
+ NAN_REQ_ATTR_MESH_ID,
+ NAN_REQ_ATTR_INFRASTRUCTURE_SSID_LEN,
+ NAN_REQ_ATTR_INFRASTRUCTURE_SSID,
+ NAN_REQ_ATTR_FURTHER_AVAIL_NUM_ENTRIES,
+ NAN_REQ_ATTR_FURTHER_AVAIL_VAL,
+ NAN_REQ_ATTR_FURTHER_AVAIL_ENTRY_CTRL,
+ NAN_REQ_ATTR_FURTHER_AVAIL_CHAN_CLASS,
+ NAN_REQ_ATTR_FURTHER_AVAIL_CHAN,
+ NAN_REQ_ATTR_FURTHER_AVAIL_CHAN_MAPID,
+ NAN_REQ_ATTR_FURTHER_AVAIL_INTERVAL_BITMAP,
+ NAN_REQ_ATTR_PUBLISH_ID,
+ NAN_REQ_ATTR_PUBLISH_TTL,
+ NAN_REQ_ATTR_PUBLISH_PERIOD,
+ NAN_REQ_ATTR_PUBLISH_TYPE,
+ NAN_REQ_ATTR_PUBLISH_TX_TYPE,
+ NAN_REQ_ATTR_PUBLISH_COUNT,
+ NAN_REQ_ATTR_PUBLISH_SERVICE_NAME_LEN,
+ NAN_REQ_ATTR_PUBLISH_SERVICE_NAME,
+ NAN_REQ_ATTR_PUBLISH_MATCH_ALGO,
+ NAN_REQ_ATTR_PUBLISH_SERVICE_INFO_LEN,
+ NAN_REQ_ATTR_PUBLISH_SERVICE_INFO,
+ NAN_REQ_ATTR_PUBLISH_RX_MATCH_FILTER_LEN,
+ NAN_REQ_ATTR_PUBLISH_RX_MATCH_FILTER,
+ NAN_REQ_ATTR_PUBLISH_TX_MATCH_FILTER_LEN,
+ NAN_REQ_ATTR_PUBLISH_TX_MATCH_FILTER,
+ NAN_REQ_ATTR_PUBLISH_RSSI_THRESHOLD_FLAG,
+ NAN_REQ_ATTR_PUBLISH_CONN_MAP,
+ NAN_REQ_ATTR_PUBLISH_RECV_IND_CFG,
+ NAN_REQ_ATTR_SUBSCRIBE_ID,
+ NAN_REQ_ATTR_SUBSCRIBE_TTL,
+ NAN_REQ_ATTR_SUBSCRIBE_PERIOD,
+ NAN_REQ_ATTR_SUBSCRIBE_TYPE,
+ NAN_REQ_ATTR_SUBSCRIBE_RESP_FILTER_TYPE,
+ NAN_REQ_ATTR_SUBSCRIBE_RESP_INCLUDE,
+ NAN_REQ_ATTR_SUBSCRIBE_USE_RESP_FILTER,
+ NAN_REQ_ATTR_SUBSCRIBE_SSI_REQUIRED,
+ NAN_REQ_ATTR_SUBSCRIBE_MATCH_INDICATOR,
+ NAN_REQ_ATTR_SUBSCRIBE_COUNT,
+ NAN_REQ_ATTR_SUBSCRIBE_SERVICE_NAME_LEN,
+ NAN_REQ_ATTR_SUBSCRIBE_SERVICE_NAME,
+ NAN_REQ_ATTR_SUBSCRIBE_SERVICE_INFO_LEN,
+ NAN_REQ_ATTR_SUBSCRIBE_SERVICE_INFO,
+ NAN_REQ_ATTR_SUBSCRIBE_RX_MATCH_FILTER_LEN,
+ NAN_REQ_ATTR_SUBSCRIBE_RX_MATCH_FILTER,
+ NAN_REQ_ATTR_SUBSCRIBE_TX_MATCH_FILTER_LEN,
+ NAN_REQ_ATTR_SUBSCRIBE_TX_MATCH_FILTER,
+ NAN_REQ_ATTR_SUBSCRIBE_RSSI_THRESHOLD_FLAG,
+ NAN_REQ_ATTR_SUBSCRIBE_CONN_MAP,
+ NAN_REQ_ATTR_SUBSCRIBE_NUM_INTF_ADDR_PRESENT,
+ NAN_REQ_ATTR_SUBSCRIBE_INTF_ADDR,
+ NAN_REQ_ATTR_SUBSCRIBE_RECV_IND_CFG,
+ NAN_REQ_ATTR_FOLLOWUP_ID,
+ NAN_REQ_ATTR_FOLLOWUP_REQUESTOR_ID,
+ NAN_REQ_ATTR_FOLLOWUP_ADDR,
+ NAN_REQ_ATTR_FOLLOWUP_PRIORITY,
+ NAN_REQ_ATTR_FOLLOWUP_SERVICE_NAME_LEN,
+ NAN_REQ_ATTR_FOLLOWUP_SERVICE_NAME,
+ NAN_REQ_ATTR_FOLLOWUP_TX_WINDOW,
+ NAN_REQ_ATTR_FOLLOWUP_RECV_IND_CFG,
+} NAN_REQ_ATTRIBUTES;
+
+typedef enum {
+ NAN_REPLY_ATTR_STATUS_TYPE,
+ NAN_REPLY_ATTR_VALUE,
+ NAN_REPLY_ATTR_RESPONSE_TYPE,
+ NAN_REPLY_ATTR_PUBLISH_SUBSCRIBE_TYPE,
+ NAN_REPLY_ATTR_CAP_MAX_CONCURRENT_CLUSTER,
+ NAN_REPLY_ATTR_CAP_MAX_PUBLISHES,
+ NAN_REPLY_ATTR_CAP_MAX_SUBSCRIBES,
+ NAN_REPLY_ATTR_CAP_MAX_SERVICE_NAME_LEN,
+ NAN_REPLY_ATTR_CAP_MAX_MATCH_FILTER_LEN,
+ NAN_REPLY_ATTR_CAP_MAX_TOTAL_MATCH_FILTER_LEN,
+ NAN_REPLY_ATTR_CAP_MAX_SERVICE_SPECIFIC_INFO_LEN,
+ NAN_REPLY_ATTR_CAP_MAX_VSA_DATA_LEN,
+ NAN_REPLY_ATTR_CAP_MAX_MESH_DATA_LEN,
+ NAN_REPLY_ATTR_CAP_MAX_NDI_INTERFACES,
+ NAN_REPLY_ATTR_CAP_MAX_NDP_SESSIONS,
+ NAN_REPLY_ATTR_CAP_MAX_APP_INFO_LEN,
+} NAN_RESP_ATTRIBUTES;
+
+typedef enum {
+ NAN_EVT_ATTR_MATCH_PUBLISH_SUBSCRIBE_ID,
+ NAN_EVT_ATTR_MATCH_REQUESTOR_INSTANCE_ID,
+ NAN_EVT_ATTR_MATCH_ADDR,
+ NAN_EVT_ATTR_MATCH_SERVICE_SPECIFIC_INFO_LEN,
+ NAN_EVT_ATTR_MATCH_SERVICE_SPECIFIC_INFO,
+ NAN_EVT_ATTR_MATCH_SDF_MATCH_FILTER_LEN,
+ NAN_EVT_ATTR_MATCH_SDF_MATCH_FILTER,
+ NAN_EVT_ATTR_MATCH_MATCH_OCCURED_FLAG,
+ NAN_EVT_ATTR_MATCH_OUT_OF_RESOURCE_FLAG,
+ NAN_EVT_ATTR_MATCH_RSSI_VALUE,
+/*CONN_CAPABILITY*/
+ NAN_EVT_ATTR_MATCH_CONN_CAPABILITY_IS_WFD_SUPPORTED,
+ NAN_EVT_ATTR_MATCH_CONN_CAPABILITY_IS_WFDS_SUPPORTED,
+ NAN_EVT_ATTR_MATCH_CONN_CAPABILITY_IS_TDLS_SUPPORTED,
+ NAN_EVT_ATTR_MATCH_CONN_CAPABILITY_IS_IBSS_SUPPORTED,
+ NAN_EVT_ATTR_MATCH_CONN_CAPABILITY_IS_MESH_SUPPORTED,
+ NAN_EVT_ATTR_MATCH_CONN_CAPABILITY_WLAN_INFRA_FIELD,
+ NAN_EVT_ATTR_MATCH_NUM_RX_DISCOVERY_ATTR,
+ NAN_EVT_ATTR_MATCH_RX_DISCOVERY_ATTR,
+/*NANRECEIVEPOSTDISCOVERY DISCOVERY_ATTR,*/
+ NAN_EVT_ATTR_MATCH_DISC_ATTR_TYPE,
+ NAN_EVT_ATTR_MATCH_DISC_ATTR_ROLE,
+ NAN_EVT_ATTR_MATCH_DISC_ATTR_DURATION,
+ NAN_EVT_ATTR_MATCH_DISC_ATTR_AVAIL_INTERVAL_BITMAP,
+ NAN_EVT_ATTR_MATCH_DISC_ATTR_MAPID,
+ NAN_EVT_ATTR_MATCH_DISC_ATTR_ADDR,
+ NAN_EVT_ATTR_MATCH_DISC_ATTR_MESH_ID_LEN,
+ NAN_EVT_ATTR_MATCH_DISC_ATTR_MESH_ID,
+ NAN_EVT_ATTR_MATCH_DISC_ATTR_INFRASTRUCTURE_SSID_LEN,
+ NAN_EVT_ATTR_MATCH_DISC_ATTR_INFRASTRUCTURE_SSID_VAL,
+
+ NAN_EVT_ATTR_MATCH_NUM_CHANS,
+ NAN_EVT_ATTR_MATCH_FAMCHAN,
+/*FAMCHAN[32],*/
+ NAN_EVT_ATTR_MATCH_FAM_ENTRY_CONTROL,
+ NAN_EVT_ATTR_MATCH_FAM_CLASS_VAL,
+ NAN_EVT_ATTR_MATCH_FAM_CHANNEL,
+ NAN_EVT_ATTR_MATCH_FAM_MAPID,
+ NAN_EVT_ATTR_MATCH_FAM_AVAIL_INTERVAL_BITMAP,
+ NAN_EVT_ATTR_MATCH_CLUSTER_ATTRIBUTE_LEN,
+ NAN_EVT_ATTR_MATCH_CLUSTER_ATTRIBUTE,
+ NAN_EVT_ATTR_PUBLISH_ID,
+ NAN_EVT_ATTR_PUBLISH_REASON,
+ NAN_EVT_ATTR_SUBSCRIBE_ID,
+ NAN_EVT_ATTR_SUBSCRIBE_REASON,
+ NAN_EVT_ATTR_DISABLED_REASON,
+ NAN_EVT_ATTR_FOLLOWUP_PUBLISH_SUBSCRIBE_ID,
+ NAN_EVT_ATTR_FOLLOWUP_REQUESTOR_INSTANCE_ID,
+ NAN_EVT_ATTR_FOLLOWUP_ADDR,
+ NAN_EVT_ATTR_FOLLOWUP_DW_OR_FAW,
+ NAN_EVT_ATTR_FOLLOWUP_SERVICE_SPECIFIC_INFO_LEN,
+ NAN_EVT_ATTR_FOLLOWUP_SERVICE_SPECIFIC_INFO,
+ NAN_EVT_ATTR_DISCOVERY_ENGINE_EVT_TYPE ,
+ NAN_EVT_ATTR_DISCOVERY_ENGINE_MAC_ADDR,
+ NAN_EVT_ATTR_DISCOVERY_ENGINE_CLUSTER
+
+} NAN_EVT_ATTRIBUTES;
+
+class NanCommand : public WifiCommand {
+ static NanCallbackHandler callbackEventHandler;
+ int subscribeID[2];
+ int publishID[2];
+ int followupID[2];
+ int version;
+ NanCapabilities capabilities;
+
+ void registerNanEvents(void) {
+ registerVendorHandler(GOOGLE_OUI, SLSI_NAN_EVENT_PUBLISH_TERMINATED);
+ registerVendorHandler(GOOGLE_OUI, SLSI_NAN_EVENT_MATCH);
+ registerVendorHandler(GOOGLE_OUI, SLSI_NAN_EVENT_MATCH_EXPIRED);
+ registerVendorHandler(GOOGLE_OUI, SLSI_NAN_EVENT_SUBSCRIBE_TERMINATED);
+ registerVendorHandler(GOOGLE_OUI, SLSI_NAN_EVENT_FOLLOWUP);
+ registerVendorHandler(GOOGLE_OUI, SLSI_NAN_EVENT_DISCOVERY_ENGINE);
+ }
+
+ void unregisterNanEvents(void) {
+ unregisterVendorHandler(GOOGLE_OUI, SLSI_NAN_EVENT_PUBLISH_TERMINATED);
+ unregisterVendorHandler(GOOGLE_OUI, SLSI_NAN_EVENT_MATCH);
+ unregisterVendorHandler(GOOGLE_OUI, SLSI_NAN_EVENT_MATCH_EXPIRED);
+ unregisterVendorHandler(GOOGLE_OUI, SLSI_NAN_EVENT_SUBSCRIBE_TERMINATED);
+ unregisterVendorHandler(GOOGLE_OUI, SLSI_NAN_EVENT_FOLLOWUP);
+ unregisterVendorHandler(GOOGLE_OUI, SLSI_NAN_EVENT_DISCOVERY_ENGINE);
+ }
+
+ int processResponse(WifiEvent &reply, NanResponseMsg *response) {
+ NanCapabilities *capabilities = &response->body.nan_capabilities;
+ nlattr *vendor_data = reply.get_attribute(NL80211_ATTR_VENDOR_DATA);
+ int len = reply.get_vendor_data_len();
+ unsigned int val;
+
+ for(nl_iterator nl_itr(vendor_data); nl_itr.has_next(); nl_itr.next()) {
+ switch(nl_itr.get_type()) {
+ case NAN_REPLY_ATTR_STATUS_TYPE:
+ response->status = NanStatusType(nl_itr.get_u32());
+ break;
+ case NAN_REPLY_ATTR_VALUE:
+ val = nl_itr.get_u32();
+ if (val) {
+ strncpy(response->nan_error, "Lower_layer_error",NAN_ERROR_STR_LEN);
+ }
+ break;
+ case NAN_REPLY_ATTR_RESPONSE_TYPE:
+ response->response_type = NanResponseType(nl_itr.get_u32());
+ break;
+ case NAN_REPLY_ATTR_PUBLISH_SUBSCRIBE_TYPE:
+ response->body.publish_response.publish_id = nl_itr.get_u16();
+ break;
+ case NAN_REPLY_ATTR_CAP_MAX_CONCURRENT_CLUSTER:
+ capabilities->max_concurrent_nan_clusters = nl_itr.get_u32();
+ break;
+ case NAN_REPLY_ATTR_CAP_MAX_PUBLISHES:
+ capabilities->max_publishes = nl_itr.get_u32();
+ break;
+ case NAN_REPLY_ATTR_CAP_MAX_SUBSCRIBES:
+ capabilities->max_subscribes = nl_itr.get_u32();
+ break;
+ case NAN_REPLY_ATTR_CAP_MAX_SERVICE_NAME_LEN:
+ capabilities->max_service_name_len = nl_itr.get_u32();
+ break;
+ case NAN_REPLY_ATTR_CAP_MAX_MATCH_FILTER_LEN:
+ capabilities->max_match_filter_len = nl_itr.get_u32();
+ break;
+ case NAN_REPLY_ATTR_CAP_MAX_TOTAL_MATCH_FILTER_LEN:
+ capabilities->max_total_match_filter_len = nl_itr.get_u32();
+ break;
+ case NAN_REPLY_ATTR_CAP_MAX_SERVICE_SPECIFIC_INFO_LEN:
+ capabilities->max_service_specific_info_len = nl_itr.get_u32();
+ break;
+ case NAN_REPLY_ATTR_CAP_MAX_VSA_DATA_LEN:
+ capabilities->max_vsa_data_len = nl_itr.get_u32();
+ break;
+ case NAN_REPLY_ATTR_CAP_MAX_MESH_DATA_LEN:
+ capabilities->max_mesh_data_len = nl_itr.get_u32();
+ break;
+ case NAN_REPLY_ATTR_CAP_MAX_NDI_INTERFACES:
+ capabilities->max_ndi_interfaces = nl_itr.get_u32();
+ break;
+ case NAN_REPLY_ATTR_CAP_MAX_NDP_SESSIONS:
+ capabilities->max_ndp_sessions = nl_itr.get_u32();
+ break;
+ case NAN_REPLY_ATTR_CAP_MAX_APP_INFO_LEN:
+ capabilities->max_app_info_len = nl_itr.get_u32();
+ break;
+ default :
+ ALOGE("received unknown type(%d) in response", nl_itr.get_type());
+ return NL_SKIP;
+ }
+ }
+ this->capabilities = *capabilities;
+ return NL_OK;
+ }
+
+ int processMatchEvent(WifiEvent &event) {
+ NanMatchInd ind;
+ memset(&ind,0,sizeof(NanMatchInd));
+ int famchan_idx = 0, disc_idx = 0;
+ nlattr *vendor_data = event.get_attribute(NL80211_ATTR_VENDOR_DATA);
+
+ for(nl_iterator nl_itr(vendor_data); nl_itr.has_next(); nl_itr.next()) {
+ switch(nl_itr.get_type()) {
+ case NAN_EVT_ATTR_MATCH_PUBLISH_SUBSCRIBE_ID:
+ ind.publish_subscribe_id = nl_itr.get_u16();
+ break;
+ case NAN_EVT_ATTR_MATCH_REQUESTOR_INSTANCE_ID:
+ ind.requestor_instance_id = nl_itr.get_u32();
+ break;
+ case NAN_EVT_ATTR_MATCH_ADDR:
+ memcpy(ind.addr, nl_itr.get_data(), NAN_MAC_ADDR_LEN);
+ break;
+ case NAN_EVT_ATTR_MATCH_SERVICE_SPECIFIC_INFO_LEN:
+ ind.service_specific_info_len = nl_itr.get_u16();
+ break;
+ case NAN_EVT_ATTR_MATCH_SERVICE_SPECIFIC_INFO:
+ memcpy(ind.service_specific_info, nl_itr.get_data(), ind.service_specific_info_len);
+ break;
+ case NAN_EVT_ATTR_MATCH_SDF_MATCH_FILTER_LEN:
+ ind.sdf_match_filter_len = nl_itr.get_u16();
+ break;
+ case NAN_EVT_ATTR_MATCH_SDF_MATCH_FILTER:
+ memcpy(ind.sdf_match_filter, nl_itr.get_data(), ind.sdf_match_filter_len);
+ break;
+ case NAN_EVT_ATTR_MATCH_MATCH_OCCURED_FLAG:
+ ind.match_occured_flag = nl_itr.get_u8();
+ break;
+ case NAN_EVT_ATTR_MATCH_OUT_OF_RESOURCE_FLAG:
+ ind.out_of_resource_flag = nl_itr.get_u8();
+ break;
+ case NAN_EVT_ATTR_MATCH_RSSI_VALUE:
+ ind.rssi_value = nl_itr.get_u8();
+ break;
+ case NAN_EVT_ATTR_MATCH_CONN_CAPABILITY_IS_IBSS_SUPPORTED:
+ ind.conn_capability.is_ibss_supported = nl_itr.get_u8();
+ break;
+ case NAN_EVT_ATTR_MATCH_CONN_CAPABILITY_IS_WFD_SUPPORTED:
+ ind.conn_capability.is_wfd_supported = nl_itr.get_u8();
+ break;
+ case NAN_EVT_ATTR_MATCH_CONN_CAPABILITY_IS_WFDS_SUPPORTED:
+ ind.conn_capability.is_wfds_supported = nl_itr.get_u8();
+ break;
+ case NAN_EVT_ATTR_MATCH_CONN_CAPABILITY_IS_TDLS_SUPPORTED:
+ ind.conn_capability.is_tdls_supported = nl_itr.get_u8();
+ break;
+ case NAN_EVT_ATTR_MATCH_CONN_CAPABILITY_IS_MESH_SUPPORTED:
+ ind.conn_capability.is_mesh_supported= nl_itr.get_u8();
+ break;
+ case NAN_EVT_ATTR_MATCH_CONN_CAPABILITY_WLAN_INFRA_FIELD:
+ ind.conn_capability.wlan_infra_field = nl_itr.get_u8();
+ break;
+ case NAN_EVT_ATTR_MATCH_NUM_RX_DISCOVERY_ATTR:
+ ind.num_rx_discovery_attr = nl_itr.get_u8();
+ break;
+ case NAN_EVT_ATTR_MATCH_RX_DISCOVERY_ATTR:
+ NanReceivePostDiscovery *disc_attr;
+ disc_attr = &ind.discovery_attr[disc_idx];
+ disc_idx++;
+ for(nl_iterator nl_nested_itr((struct nlattr *)nl_itr.get_data()); nl_nested_itr.has_next(); nl_nested_itr.next()) {
+ switch(nl_nested_itr.get_type()) {
+ case NAN_EVT_ATTR_MATCH_DISC_ATTR_TYPE:
+ disc_attr->type = (NanConnectionType)nl_nested_itr.get_u8();
+ break;
+ case NAN_EVT_ATTR_MATCH_DISC_ATTR_ROLE:
+ disc_attr->role = (NanDeviceRole)nl_nested_itr.get_u8();
+ break;
+ case NAN_EVT_ATTR_MATCH_DISC_ATTR_DURATION:
+ disc_attr->duration = (NanAvailDuration)nl_nested_itr.get_u8();
+ break;
+ case NAN_EVT_ATTR_MATCH_DISC_ATTR_AVAIL_INTERVAL_BITMAP:
+ disc_attr->avail_interval_bitmap = nl_nested_itr.get_u32();
+ break;
+ case NAN_EVT_ATTR_MATCH_DISC_ATTR_MAPID:
+ disc_attr->mapid = nl_nested_itr.get_u8();
+ break;
+ case NAN_EVT_ATTR_MATCH_DISC_ATTR_ADDR:
+ memcpy(disc_attr->addr, nl_nested_itr.get_data(), NAN_MAC_ADDR_LEN);
+ break;
+ case NAN_EVT_ATTR_MATCH_DISC_ATTR_MESH_ID_LEN:
+ disc_attr->mesh_id_len = nl_nested_itr.get_u8();
+ break;
+ case NAN_EVT_ATTR_MATCH_DISC_ATTR_MESH_ID:
+ memcpy(disc_attr->mesh_id, nl_nested_itr.get_data(), disc_attr->mesh_id_len);
+ break;
+ case NAN_EVT_ATTR_MATCH_DISC_ATTR_INFRASTRUCTURE_SSID_LEN:
+ disc_attr->infrastructure_ssid_len = nl_nested_itr.get_u16();
+ break;
+ case NAN_EVT_ATTR_MATCH_DISC_ATTR_INFRASTRUCTURE_SSID_VAL:
+ memcpy(disc_attr->infrastructure_ssid_val, nl_nested_itr.get_data(), disc_attr->infrastructure_ssid_len);
+ break;
+ }
+ }
+ break;
+ case NAN_EVT_ATTR_MATCH_NUM_CHANS:
+ ind.num_chans = nl_itr.get_u8();
+ break;
+ case NAN_EVT_ATTR_MATCH_FAMCHAN:
+ NanFurtherAvailabilityChannel *famchan;
+ famchan = &ind.famchan[famchan_idx];
+ famchan_idx++;
+ for(nl_iterator nl_nested_itr((struct nlattr *)nl_itr.get_data()); nl_nested_itr.has_next(); nl_nested_itr.next()) {
+ switch(nl_nested_itr.get_type()) {
+ case NAN_EVT_ATTR_MATCH_FAM_ENTRY_CONTROL:
+ famchan->entry_control = (NanAvailDuration)nl_nested_itr.get_u8();
+ break;
+ case NAN_EVT_ATTR_MATCH_FAM_CLASS_VAL:
+ famchan->class_val = nl_nested_itr.get_u8();
+ break;
+ case NAN_EVT_ATTR_MATCH_FAM_CHANNEL:
+ famchan->channel = nl_nested_itr.get_u8();
+ break;
+ case NAN_EVT_ATTR_MATCH_FAM_MAPID:
+ famchan->mapid = nl_nested_itr.get_u8();
+ break;
+ case NAN_EVT_ATTR_MATCH_FAM_AVAIL_INTERVAL_BITMAP:
+ famchan->avail_interval_bitmap = nl_nested_itr.get_u32();
+ break;
+ }
+ }
+ case NAN_EVT_ATTR_MATCH_CLUSTER_ATTRIBUTE_LEN:
+ ind.cluster_attribute_len = nl_itr.get_u8();
+ break;
+ case NAN_EVT_ATTR_MATCH_CLUSTER_ATTRIBUTE:
+ memcpy(ind.cluster_attribute, nl_itr.get_data(), ind.cluster_attribute_len);
+ break;
+ }
+ }
+
+ if (this->callbackEventHandler.EventMatch)
+ this->callbackEventHandler.EventMatch(&ind);
+ return NL_OK;
+ }
+
+ int processMatchExpiredEvent(WifiEvent &event) {
+ NanMatchExpiredInd ind;
+ memset(&ind,0,sizeof(NanMatchExpiredInd));
+
+ for(nl_iterator nl_itr((struct nlattr *)event.get_vendor_data()); nl_itr.has_next(); nl_itr.next()) {
+ switch(nl_itr.get_type()) {
+ case NAN_EVT_ATTR_MATCH_PUBLISH_SUBSCRIBE_ID:
+ ind.publish_subscribe_id = nl_itr.get_u16();
+ break;
+ case NAN_EVT_ATTR_MATCH_REQUESTOR_INSTANCE_ID:
+ ind.requestor_instance_id = nl_itr.get_u32();
+ break;
+ default :
+ ALOGE("processMatchExpiredEvent: unknown attribute(%d)", nl_itr.get_type());
+ return NL_SKIP;
+ }
+ }
+
+ if (callbackEventHandler.EventMatchExpired)
+ callbackEventHandler.EventMatchExpired(&ind);
+
+ return NL_OK;
+ }
+
+ int processPublishTerminatedEvent(WifiEvent &event) {
+ NanPublishTerminatedInd ind;
+ memset(&ind,0,sizeof(ind));
+
+ for(nl_iterator nl_itr((struct nlattr *)event.get_vendor_data()); nl_itr.has_next(); nl_itr.next()) {
+ switch(nl_itr.get_type()) {
+ case NAN_EVT_ATTR_PUBLISH_ID:
+ ind.publish_id = nl_itr.get_u16();
+ break;
+ case NAN_EVT_ATTR_PUBLISH_REASON:
+ ind.reason = (NanStatusType)nl_itr.get_u32();
+ break;
+ default :
+ ALOGE("processPublishTerminatedEvent: unknown attribute(%d)", nl_itr.get_type());
+ return NL_SKIP;
+ }
+ }
+
+ if (callbackEventHandler.EventPublishTerminated)
+ callbackEventHandler.EventPublishTerminated(&ind);
+
+ return NL_OK;
+
+ }
+
+ int processSubscribeTerminatedEvent(WifiEvent &event) {
+ NanSubscribeTerminatedInd ind;
+ memset(&ind,0,sizeof(ind));
+
+ for(nl_iterator nl_itr((struct nlattr *)event.get_vendor_data()); nl_itr.has_next(); nl_itr.next()) {
+ switch(nl_itr.get_type()) {
+ case NAN_EVT_ATTR_SUBSCRIBE_ID:
+ ind.subscribe_id = nl_itr.get_u16();
+ break;
+ case NAN_EVT_ATTR_SUBSCRIBE_REASON:
+ ind.reason = (NanStatusType)nl_itr.get_u32();
+ break;
+ default :
+ ALOGE("processSubscribeTerminatedEvent: unknown attribute(%d)", nl_itr.get_type());
+ return NL_SKIP;
+ }
+ }
+
+ if (callbackEventHandler.EventSubscribeTerminated)
+ callbackEventHandler.EventSubscribeTerminated(&ind);
+
+ return NL_OK;
+ }
+
+ int processFollowupEvent(WifiEvent &event) {
+ NanFollowupInd ind;
+ memset(&ind,0,sizeof(ind));
+
+ for(nl_iterator nl_itr((struct nlattr *)event.get_vendor_data()); nl_itr.has_next(); nl_itr.next()) {
+ switch(nl_itr.get_type()) {
+ case NAN_EVT_ATTR_FOLLOWUP_PUBLISH_SUBSCRIBE_ID:
+ ind.publish_subscribe_id = nl_itr.get_u16();
+ break;
+ case NAN_EVT_ATTR_FOLLOWUP_REQUESTOR_INSTANCE_ID:
+ ind.requestor_instance_id = nl_itr.get_u32();
+ break;
+ case NAN_EVT_ATTR_FOLLOWUP_ADDR:
+ memcpy(ind.addr, nl_itr.get_data(), NAN_MAC_ADDR_LEN);
+ break;
+ case NAN_EVT_ATTR_FOLLOWUP_DW_OR_FAW:
+ ind.dw_or_faw = nl_itr.get_u8();
+ break;
+ case NAN_EVT_ATTR_FOLLOWUP_SERVICE_SPECIFIC_INFO_LEN:
+ ind.service_specific_info_len = nl_itr.get_u16();
+ break;
+ case NAN_EVT_ATTR_FOLLOWUP_SERVICE_SPECIFIC_INFO:
+ memcpy(ind.service_specific_info, nl_itr.get_data(), ind.service_specific_info_len);
+ break;
+ default :
+ ALOGE("processNanDisabledEvent: unknown attribute(%d)", nl_itr.get_type());
+ return NL_SKIP;
+ }
+ }
+
+ if (callbackEventHandler.EventFollowup)
+ callbackEventHandler.EventFollowup(&ind);
+
+ return NL_OK;
+ }
+
+ int processNanDisabledEvent(WifiEvent &event) {
+ NanDisabledInd ind;
+ memset(&ind,0,sizeof(ind));
+
+ for(nl_iterator nl_itr((struct nlattr *)event.get_vendor_data()); nl_itr.has_next(); nl_itr.next()) {
+ switch(nl_itr.get_type()) {
+ case NAN_EVT_ATTR_DISABLED_REASON:
+ ind.reason = (NanStatusType)nl_itr.get_u32();
+ break;
+ default :
+ ALOGE("processNanDisabledEvent: unknown attribute(%d)", nl_itr.get_type());
+ return NL_SKIP;
+ }
+ }
+
+ if (callbackEventHandler.EventDisabled)
+ callbackEventHandler.EventDisabled(&ind);
+
+ return NL_OK;
+ }
+
+ int processNanDiscoveryEvent(WifiEvent &event) {
+ NanDiscEngEventInd ind;
+ memset(&ind,0,sizeof(ind));
+ u8 *addr;
+
+ for(nl_iterator nl_itr((struct nlattr *)event.get_vendor_data()); nl_itr.has_next(); nl_itr.next()) {
+ switch(nl_itr.get_type()) {
+ case NAN_EVT_ATTR_DISCOVERY_ENGINE_EVT_TYPE:
+ ind.event_type = (NanDiscEngEventType)nl_itr.get_u16();
+ break;
+ case NAN_EVT_ATTR_DISCOVERY_ENGINE_MAC_ADDR:
+ addr = (u8 *)nl_itr.get_data();
+ break;
+ default :
+ ALOGE("processNanDiscoveryEvent: unknown attribute(%d)", nl_itr.get_type());
+ return NL_SKIP;
+ }
+ }
+ if (ind.event_type == NAN_EVENT_ID_DISC_MAC_ADDR)
+ memcpy(ind.data.mac_addr.addr, addr, NAN_MAC_ADDR_LEN);
+ else
+ memcpy(ind.data.cluster.addr, addr, NAN_MAC_ADDR_LEN);
+
+ if (callbackEventHandler.EventDiscEngEvent)
+ callbackEventHandler.EventDiscEngEvent(&ind);
+
+ return NL_OK;
+ }
+
+public:
+ NanCommand(wifi_interface_handle iface, int id)
+ : WifiCommand(iface, id)
+ {
+ subscribeID[0] = 0;
+ subscribeID[1] = 0;
+ publishID[0] = 0;
+ publishID[1] = 0;
+ followupID[0] = 0;
+ followupID[0] = 0;
+ version = 0;
+ memset(&capabilities, 0, sizeof(capabilities));
+ }
+
+ int enable(NanEnableRequest *msg) {
+ ALOGD("Start NAN...");
+ WifiRequest request(familyId(), ifaceId());
+
+ int result = request.create(GOOGLE_OUI, SLSI_NL80211_VENDOR_SUBCMD_NAN_ENABLE);
+ CHECK_WIFI_STATUS_RETURN_FAIL(result, "enable:Failed to create WifiRequest");
+
+ nlattr *data = request.attr_start(NL80211_ATTR_VENDOR_DATA);
+ if (!data) {
+ ALOGE("enable: request.attr_start fail");
+ return WIFI_ERROR_OUT_OF_MEMORY;
+ }
+ result = request.put_u8(NAN_REQ_ATTR_MASTER_PREF, msg->master_pref);
+ CHECK_WIFI_STATUS_RETURN_FAIL(result, "enable:Failed to put master_pref");
+
+ result = request.put_u16(NAN_REQ_ATTR_CLUSTER_LOW, msg->cluster_low);
+ CHECK_WIFI_STATUS_RETURN_FAIL(result, "enable:Failed to put cluster_low");
+
+ result = request.put_u16(NAN_REQ_ATTR_CLUSTER_HIGH, msg->cluster_high);
+ CHECK_WIFI_STATUS_RETURN_FAIL(result, "enable:Failed to put cluster_high");
+
+ CHECK_CONFIG_PUT_8_RETURN_FAIL(msg->config_support_5g, msg->support_5g_val,
+ NAN_REQ_ATTR_SUPPORT_5G_VAL, request, result, "enable:Failed to put support_5g_val");
+
+ CHECK_CONFIG_PUT_8_RETURN_FAIL(msg->config_sid_beacon, msg->sid_beacon_val,
+ NAN_REQ_ATTR_SID_BEACON_VAL, request, result, "enable:Failed to put sid_beacon_val");
+
+ CHECK_CONFIG_PUT_8_RETURN_FAIL(msg->config_2dot4g_rssi_close, msg->rssi_close_2dot4g_val,
+ NAN_REQ_ATTR_RSSI_CLOSE_2G4_VAL, request, result, "enable:Failed to put rssi_close_2dot4g_val");
+
+ CHECK_CONFIG_PUT_8_RETURN_FAIL(msg->config_2dot4g_rssi_middle, msg->rssi_middle_2dot4g_val,
+ NAN_REQ_ATTR_RSSI_MIDDLE_2G4_VAL, request, result, "enable:Failed to put rssi_middle_2dot4g_val");
+
+ CHECK_CONFIG_PUT_8_RETURN_FAIL(msg->config_2dot4g_rssi_proximity, msg->rssi_proximity_2dot4g_val,
+ NAN_REQ_ATTR_RSSI_PROXIMITY_2G4_VAL, request, result, "enable:Failed to put rssi_proximity_2dot4g_val");
+
+ CHECK_CONFIG_PUT_8_RETURN_FAIL(msg->config_hop_count_limit, msg->hop_count_limit_val,
+ NAN_REQ_ATTR_HOP_COUNT_LIMIT_VAL, request, result, "enable:Failed to put hop_count_limit_val");
+
+ CHECK_CONFIG_PUT_8_RETURN_FAIL(msg->config_2dot4g_support, msg->support_2dot4g_val,
+ NAN_REQ_ATTR_SUPPORT_2G4_VAL, request, result, "enable:Failed to put support_2dot4g_val");
+
+ CHECK_CONFIG_PUT_8_RETURN_FAIL(msg->config_2dot4g_beacons, msg->beacon_2dot4g_val,
+ NAN_REQ_ATTR_BEACONS_2G4_VAL, request, result, "enable:Failed to put beacon_2dot4g_val");
+
+ CHECK_CONFIG_PUT_8_RETURN_FAIL(msg->config_2dot4g_sdf, msg->sdf_2dot4g_val,
+ NAN_REQ_ATTR_SDF_2G4_VAL, request, result, "enable:Failed to put sdf_2dot4g_val");
+
+ CHECK_CONFIG_PUT_8_RETURN_FAIL(msg->config_5g_beacons, msg->beacon_5g_val,
+ NAN_REQ_ATTR_BEACON_5G_VAL, request, result, "enable:Failed to put beacon_5g_val");
+
+ CHECK_CONFIG_PUT_8_RETURN_FAIL(msg->config_5g_sdf, msg->sdf_5g_val,
+ NAN_REQ_ATTR_SDF_5G_VAL, request, result, "enable:Failed to put sdf_5g_val");
+
+ CHECK_CONFIG_PUT_8_RETURN_FAIL(msg->config_5g_rssi_close, msg->rssi_close_5g_val,
+ NAN_REQ_ATTR_RSSI_CLOSE_5G_VAL, request, result, "enable:Failed to put rssi_close_5g_val");
+
+ CHECK_CONFIG_PUT_8_RETURN_FAIL(msg->config_5g_rssi_middle, msg->rssi_middle_5g_val,
+ NAN_REQ_ATTR_RSSI_MIDDLE_5G_VAL, request, result, "enable:Failed to put rssi_middle_5g_val");
+
+ CHECK_CONFIG_PUT_8_RETURN_FAIL(msg->config_5g_rssi_close_proximity, msg->rssi_close_proximity_5g_val,
+ NAN_REQ_ATTR_RSSI_CLOSE_PROXIMITY_5G_VAL, request, result, "enable:Failed to put rssi_close_proximity_5g_val");
+
+ CHECK_CONFIG_PUT_8_RETURN_FAIL(msg->config_rssi_window_size, msg->rssi_window_size_val,
+ NAN_REQ_ATTR_RSSI_WINDOW_SIZE_VAL, request, result, "enable:Failed to put rssi_window_size_val");
+
+ CHECK_CONFIG_PUT_32_RETURN_FAIL(msg->config_oui, msg->oui_val,
+ NAN_REQ_ATTR_OUI_VAL, request, result, "enable:Failed to put oui_val");
+
+ CHECK_CONFIG_PUT_RETURN_FAIL(msg->config_intf_addr, msg->intf_addr_val, NAN_MAC_ADDR_LEN,
+ NAN_REQ_ATTR_MAC_ADDR_VAL, request, result, "enable:Failed to put intf_addr_val");
+
+ CHECK_CONFIG_PUT_8_RETURN_FAIL(1, msg->config_cluster_attribute_val,
+ NAN_REQ_ATTR_CLUSTER_VAL, request, result, "enable:Failed to put config_cluster_attribute_val");
+
+ CHECK_CONFIG_PUT_RETURN_FAIL(msg->config_scan_params, msg->scan_params_val.dwell_time, sizeof(msg->scan_params_val.dwell_time),
+ NAN_REQ_ATTR_SOCIAL_CH_SCAN_DWELL_TIME, request, result, "enable:Failed to put scan_params_val.dwell_time");
+
+ CHECK_CONFIG_PUT_RETURN_FAIL(msg->config_scan_params, msg->scan_params_val.scan_period, sizeof(msg->scan_params_val.scan_period),
+ NAN_REQ_ATTR_SOCIAL_CH_SCAN_PERIOD, request, result, "enable:Failed to put scan_params_val.scan_period");
+
+ CHECK_CONFIG_PUT_8_RETURN_FAIL(msg->config_random_factor_force, msg->random_factor_force_val,
+ NAN_REQ_ATTR_RANDOM_FACTOR_FORCE_VAL, request, result, "enable:Failed to put random_factor_force_val");
+
+ CHECK_CONFIG_PUT_8_RETURN_FAIL(msg->config_hop_count_force, msg->hop_count_force_val,
+ NAN_REQ_ATTR_HOP_COUNT_FORCE_VAL, request, result, "enable:Failed to put hop_count_force_val");
+
+ CHECK_CONFIG_PUT_32_RETURN_FAIL(msg->config_24g_channel, msg->channel_24g_val,
+ NAN_REQ_ATTR_CHANNEL_2G4_MHZ_VAL, request, result, "enable:Failed to put channel_24g_val");
+
+ CHECK_CONFIG_PUT_32_RETURN_FAIL(msg->config_5g_channel, msg->channel_5g_val,
+ NAN_REQ_ATTR_CHANNEL_5G_MHZ_VAL, request, result, "enable:Failed to put channel_5g_val");
+
+ request.attr_end(data);
+
+ registerNanEvents();
+
+ result = requestResponse(request);
+ if (result != WIFI_SUCCESS) {
+ ALOGE("failed to NAN; result = %d", result);
+ unregisterNanEvents();
+ } else {
+ ALOGD("Start NAN...success");
+ }
+ return result;
+ }
+
+ int disable()
+ {
+ ALOGD("Stop NAN...");
+ WifiRequest request(familyId(), ifaceId());
+
+ unregisterNanEvents();
+
+ int result = request.create(GOOGLE_OUI, SLSI_NL80211_VENDOR_SUBCMD_NAN_DISABLE);
+ CHECK_WIFI_STATUS_RETURN_FAIL(result, "disable:Failed to create WifiRequest");
+ result = requestResponse(request);
+ CHECK_WIFI_STATUS_RETURN_FAIL(result, "disable:Failed to requestResponse");
+ return result;
+ }
+
+ int config(NanConfigRequest *msg) {
+ ALOGD("config...");
+ WifiRequest request(familyId(), ifaceId());
+
+ int result = request.create(GOOGLE_OUI, SLSI_NL80211_VENDOR_SUBCMD_NAN_CONFIG);
+ CHECK_WIFI_STATUS_RETURN_FAIL(result, "config:Failed to create WifiRequest");
+
+ nlattr *data = request.attr_start(NL80211_ATTR_VENDOR_DATA);
+ if (!data) {
+ ALOGE("config: request.attr_start fail");
+ return WIFI_ERROR_OUT_OF_MEMORY;
+ }
+
+ CHECK_CONFIG_PUT_8_RETURN_FAIL(msg->config_sid_beacon, msg->sid_beacon,
+ NAN_REQ_ATTR_SID_BEACON_VAL, request, result, "config:Failed to put sid_beacon");
+
+ CHECK_CONFIG_PUT_8_RETURN_FAIL(msg->config_rssi_proximity, msg->rssi_proximity,
+ NAN_REQ_ATTR_RSSI_PROXIMITY_2G4_VAL, request, result, "config:Failed to put rssi_proximity");
+
+ CHECK_CONFIG_PUT_8_RETURN_FAIL(msg->config_master_pref, msg->master_pref,
+ NAN_REQ_ATTR_MASTER_PREF, request, result, "config:Failed to put master_pref");
+
+ CHECK_CONFIG_PUT_8_RETURN_FAIL(msg->config_5g_rssi_close_proximity, msg->rssi_close_proximity_5g_val,
+ NAN_REQ_ATTR_RSSI_CLOSE_PROXIMITY_5G_VAL, request, result, "config:Failed to put rssi_close_proximity_5g_val");
+
+ CHECK_CONFIG_PUT_8_RETURN_FAIL(msg->config_rssi_window_size, msg->rssi_window_size_val,
+ NAN_REQ_ATTR_RSSI_WINDOW_SIZE_VAL, request, result, "config:Failed to put rssi_window_size_val");
+
+ CHECK_CONFIG_PUT_8_RETURN_FAIL(1, msg->config_cluster_attribute_val,
+ NAN_REQ_ATTR_CLUSTER_VAL, request, result, "config:Failed to put config_cluster_attribute_val");
+
+ CHECK_CONFIG_PUT_RETURN_FAIL(msg->config_scan_params, msg->scan_params_val.dwell_time, sizeof(msg->scan_params_val.dwell_time),
+ NAN_REQ_ATTR_SOCIAL_CH_SCAN_DWELL_TIME, request, result, "config:Failed to put scan_params_val.dwell_time");
+
+ CHECK_CONFIG_PUT_RETURN_FAIL(msg->config_scan_params, msg->scan_params_val.scan_period, sizeof(msg->scan_params_val.scan_period),
+ NAN_REQ_ATTR_SOCIAL_CH_SCAN_PERIOD, request, result, "config:Failed to put scan_params_val.scan_period");
+
+ CHECK_CONFIG_PUT_8_RETURN_FAIL(msg->config_random_factor_force, msg->random_factor_force_val,
+ NAN_REQ_ATTR_RANDOM_FACTOR_FORCE_VAL, request, result, "config:Failed to put random_factor_force_val");
+
+ CHECK_CONFIG_PUT_8_RETURN_FAIL(msg->config_hop_count_force, msg->hop_count_force_val,
+ NAN_REQ_ATTR_HOP_COUNT_FORCE_VAL, request, result, "config:Failed to put hop_count_force_val");
+
+ CHECK_CONFIG_PUT_8_RETURN_FAIL(msg->config_conn_capability, msg->conn_capability_val.payload_transmit_flag,
+ NAN_REQ_ATTR_CONN_CAPABILITY_PAYLOAD_TX, request, result, "config:Failed to put payload_transmit_flag");
+
+ CHECK_CONFIG_PUT_8_RETURN_FAIL(msg->config_conn_capability, msg->conn_capability_val.is_wfd_supported,
+ NAN_REQ_ATTR_CONN_CAPABILITY_WFD, request, result, "config:Failed to put is_wfd_supported");
+
+ CHECK_CONFIG_PUT_8_RETURN_FAIL(msg->config_conn_capability, msg->conn_capability_val.is_wfds_supported,
+ NAN_REQ_ATTR_CONN_CAPABILITY_WFDS, request, result, "config:Failed to put is_wfds_supported");
+
+ CHECK_CONFIG_PUT_8_RETURN_FAIL(msg->config_conn_capability, msg->conn_capability_val.is_tdls_supported,
+ NAN_REQ_ATTR_CONN_CAPABILITY_TDLS, request, result, "config:Failed to put is_tdls_supported");
+
+ CHECK_CONFIG_PUT_8_RETURN_FAIL(msg->config_conn_capability, msg->conn_capability_val.is_ibss_supported,
+ NAN_REQ_ATTR_CONN_CAPABILITY_IBSS, request, result, "config:Failed to put is_ibss_supported");
+
+ CHECK_CONFIG_PUT_8_RETURN_FAIL(msg->config_conn_capability, msg->conn_capability_val.is_mesh_supported,
+ NAN_REQ_ATTR_CONN_CAPABILITY_MESH, request, result, "config:Failed to put is_mesh_supported");
+
+ CHECK_CONFIG_PUT_8_RETURN_FAIL(msg->config_conn_capability, msg->conn_capability_val.wlan_infra_field,
+ NAN_REQ_ATTR_CONN_CAPABILITY_WLAN_INFRA, request, result, "config:Failed to put wlan_infra_field");
+
+ if (msg->num_config_discovery_attr) {
+ CHECK_CONFIG_PUT_8_RETURN_FAIL(1, msg->num_config_discovery_attr,
+ NAN_REQ_ATTR_DISCOVERY_ATTR_NUM_ENTRIES, request, result, "config:Failed to put msg->num_config_discovery_attr");
+ for (int i = 0; i < msg->num_config_discovery_attr; i++) {
+ nlattr *nl_disc_attribute = request.attr_start(NAN_REQ_ATTR_DISCOVERY_ATTR_VAL);
+ NanTransmitPostDiscovery *discovery_attr = &msg->discovery_attr_val[i];
+ CHECK_CONFIG_PUT_8_RETURN_FAIL(1, discovery_attr->type,
+ NAN_REQ_ATTR_CONN_TYPE, request, result, "config:Failed to put discovery_attr->type");
+ CHECK_CONFIG_PUT_8_RETURN_FAIL(1, discovery_attr->role,
+ NAN_REQ_ATTR_NAN_ROLE, request, result, "config:Failed to put discovery_attr->role");
+ CHECK_CONFIG_PUT_8_RETURN_FAIL(1, discovery_attr->transmit_freq,
+ NAN_REQ_ATTR_TRANSMIT_FREQ, request, result, "config:Failed to put discovery_attr->transmit_freq");
+ CHECK_CONFIG_PUT_8_RETURN_FAIL(1, discovery_attr->duration,
+ NAN_REQ_ATTR_AVAILABILITY_DURATION, request, result, "config:Failed to put discovery_attr->duration");
+ CHECK_CONFIG_PUT_32_RETURN_FAIL(1, discovery_attr->avail_interval_bitmap,
+ NAN_REQ_ATTR_AVAILABILITY_INTERVAL, request, result, "config:Failed to put discovery_attr->avail_interval_bitmap");
+ CHECK_CONFIG_PUT_RETURN_FAIL(1, discovery_attr->addr, NAN_MAC_ADDR_LEN,
+ NAN_REQ_ATTR_MAC_ADDR_VAL, request, result, "config:Failed to put discovery_attr->addr");
+ CHECK_CONFIG_PUT_16_RETURN_FAIL(1, discovery_attr->mesh_id_len,
+ NAN_REQ_ATTR_MESH_ID_LEN, request, result, "config:Failed to put discovery_attr->mesh_id");
+ CHECK_CONFIG_PUT_RETURN_FAIL(discovery_attr->mesh_id_len, discovery_attr->mesh_id, discovery_attr->mesh_id_len,
+ NAN_REQ_ATTR_MESH_ID, request, result, "config:Failed to put discovery_attr->mesh_id");
+ CHECK_CONFIG_PUT_16_RETURN_FAIL(1, discovery_attr->infrastructure_ssid_len,
+ NAN_REQ_ATTR_INFRASTRUCTURE_SSID_LEN, request, result, "config:Failed to put discovery_attr->infrastructure_ssid_val");
+ CHECK_CONFIG_PUT_RETURN_FAIL(discovery_attr->infrastructure_ssid_len, discovery_attr->infrastructure_ssid_val, discovery_attr->infrastructure_ssid_len,
+ NAN_REQ_ATTR_INFRASTRUCTURE_SSID, request, result, "config:Failed to put discovery_attr->infrastructure_ssid_val");
+ request.attr_end(nl_disc_attribute);
+ }
+ }
+
+ if (msg->config_fam) {
+ CHECK_CONFIG_PUT_8_RETURN_FAIL(1, msg->fam_val.numchans,
+ NAN_REQ_ATTR_FURTHER_AVAIL_NUM_ENTRIES, request, result, "config:Failed to put msg->fam_val.numchans");
+ for (int i = 0; i < msg->fam_val.numchans; i++) {
+ nlattr *nl_fam_attribute = request.attr_start(NAN_REQ_ATTR_FURTHER_AVAIL_VAL);
+ NanFurtherAvailabilityChannel *further_avail_chan = &msg->fam_val.famchan[i];
+ CHECK_CONFIG_PUT_8_RETURN_FAIL(1, further_avail_chan->entry_control,
+ NAN_REQ_ATTR_FURTHER_AVAIL_ENTRY_CTRL, request, result, "config:Failed to put further_avail_chan->entry_control");
+ CHECK_CONFIG_PUT_8_RETURN_FAIL(1, further_avail_chan->class_val,
+ NAN_REQ_ATTR_FURTHER_AVAIL_CHAN_CLASS, request, result, "config:Failed to put further_avail_chan->class_val");
+ CHECK_CONFIG_PUT_8_RETURN_FAIL(1, further_avail_chan->channel,
+ NAN_REQ_ATTR_FURTHER_AVAIL_CHAN, request, result, "config:Failed to put further_avail_chan->channel");
+ CHECK_CONFIG_PUT_8_RETURN_FAIL(1, further_avail_chan->mapid,
+ NAN_REQ_ATTR_FURTHER_AVAIL_CHAN_MAPID, request, result, "config:Failed to put further_avail_chan->mapid");
+ CHECK_CONFIG_PUT_32_RETURN_FAIL(1, further_avail_chan->avail_interval_bitmap,
+ NAN_REQ_ATTR_FURTHER_AVAIL_INTERVAL_BITMAP, request, result, "config:Failed to put further_avail_chan->avail_interval_bitmap");
+ request.attr_end(nl_fam_attribute);
+ }
+ }
+
+ request.attr_end(data);
+ result = requestResponse(request);
+ if (result != WIFI_SUCCESS) {
+ ALOGE("failed to set_config; result = %d", result);
+ } else {
+ ALOGD("config...success");
+ }
+ return result;
+ }
+
+ static int setCallbackHandler(NanCallbackHandler handlers) {
+ callbackEventHandler = handlers;
+ return WIFI_SUCCESS;
+ }
+
+ static int getVersion(NanVersion *version) {
+ *version = SLSI_WIFI_HAL_NAN_VERSION;
+ return WIFI_SUCCESS;
+ }
+
+ int publish(NanPublishRequest *msg) {
+ ALOGD("publish...");
+ WifiRequest request(familyId(), ifaceId());
+
+ int result = request.create(GOOGLE_OUI, SLSI_NL80211_VENDOR_SUBCMD_NAN_PUBLISH);
+ CHECK_WIFI_STATUS_RETURN_FAIL(result, "publish:Failed to create WifiRequest");
+
+ nlattr *data = request.attr_start(NL80211_ATTR_VENDOR_DATA);
+ if (!data) {
+ ALOGE("publish: request.attr_start fail");
+ return WIFI_ERROR_OUT_OF_MEMORY;
+ }
+
+ CHECK_CONFIG_PUT_16_RETURN_FAIL(msg->publish_id, msg->publish_id,
+ NAN_REQ_ATTR_PUBLISH_ID, request, result, "publish:Failed to put msg->publish_id");
+
+ CHECK_CONFIG_PUT_16_RETURN_FAIL(msg->ttl, msg->ttl,
+ NAN_REQ_ATTR_PUBLISH_TTL, request, result, "publish:Failed to put msg->ttl");
+
+ CHECK_CONFIG_PUT_16_RETURN_FAIL(1, msg->period,
+ NAN_REQ_ATTR_PUBLISH_PERIOD, request, result, "publish:Failed to put msg->period");
+
+ CHECK_CONFIG_PUT_8_RETURN_FAIL(1, msg->publish_type,
+ NAN_REQ_ATTR_PUBLISH_TYPE, request, result, "publish:Failed to put msg->publish_type");
+
+ CHECK_CONFIG_PUT_8_RETURN_FAIL(1, msg->tx_type,
+ NAN_REQ_ATTR_PUBLISH_TX_TYPE, request, result, "publish:Failed to put msg->tx_type");
+
+ CHECK_CONFIG_PUT_8_RETURN_FAIL(1, msg->publish_count,
+ NAN_REQ_ATTR_PUBLISH_COUNT, request, result, "publish:Failed to put msg->publish_count");
+
+ CHECK_CONFIG_PUT_16_RETURN_FAIL(msg->service_name_len, msg->service_name_len,
+ NAN_REQ_ATTR_PUBLISH_SERVICE_NAME_LEN, request, result, "publish:Failed to put msg->service_name_len");
+
+ CHECK_CONFIG_PUT_RETURN_FAIL(msg->service_name_len, msg->service_name, msg->service_name_len,
+ NAN_REQ_ATTR_PUBLISH_SERVICE_NAME, request, result, "publish:Failed to put msg->service_name");
+
+ CHECK_CONFIG_PUT_8_RETURN_FAIL(1, msg->publish_match_indicator,
+ NAN_REQ_ATTR_PUBLISH_MATCH_ALGO, request, result, "publish:Failed to put msg->publish_match_indicator");
+
+ CHECK_CONFIG_PUT_16_RETURN_FAIL(msg->service_specific_info_len, msg->service_specific_info_len,
+ NAN_REQ_ATTR_PUBLISH_SERVICE_INFO_LEN, request, result, "publish:Failed to put msg->service_specific_info_len");
+
+ CHECK_CONFIG_PUT_RETURN_FAIL(msg->service_specific_info_len, msg->service_specific_info, msg->service_specific_info_len,
+ NAN_REQ_ATTR_PUBLISH_SERVICE_INFO, request, result, "publish:Failed to put msg->service_specific_info");
+
+ CHECK_CONFIG_PUT_16_RETURN_FAIL(msg->rx_match_filter_len, msg->rx_match_filter_len,
+ NAN_REQ_ATTR_PUBLISH_RX_MATCH_FILTER_LEN, request, result, "publish:Failed to put msg->rx_match_filter_len");
+
+ CHECK_CONFIG_PUT_RETURN_FAIL(msg->rx_match_filter_len, msg->rx_match_filter, msg->rx_match_filter_len,
+ NAN_REQ_ATTR_PUBLISH_RX_MATCH_FILTER, request, result, "publish:Failed to put msg->rx_match_filter");
+
+ CHECK_CONFIG_PUT_16_RETURN_FAIL(msg->tx_match_filter_len, msg->tx_match_filter_len,
+ NAN_REQ_ATTR_PUBLISH_TX_MATCH_FILTER_LEN, request, result, "publish:Failed to put msg->tx_match_filter_len");
+
+ CHECK_CONFIG_PUT_RETURN_FAIL(msg->tx_match_filter_len, msg->tx_match_filter, msg->tx_match_filter_len,
+ NAN_REQ_ATTR_PUBLISH_TX_MATCH_FILTER, request, result, "publish:Failed to put msg->tx_match_filter");
+
+ CHECK_CONFIG_PUT_8_RETURN_FAIL(1, msg->rssi_threshold_flag,
+ NAN_REQ_ATTR_PUBLISH_RSSI_THRESHOLD_FLAG, request, result, "publish:Failed to put msg->rssi_threshold_flag");
+
+ CHECK_CONFIG_PUT_8_RETURN_FAIL(1, msg->connmap,
+ NAN_REQ_ATTR_PUBLISH_CONN_MAP, request, result, "publish:Failed to put msg->connmap");
+
+ CHECK_CONFIG_PUT_8_RETURN_FAIL(1, msg->recv_indication_cfg,
+ NAN_REQ_ATTR_PUBLISH_RECV_IND_CFG, request, result, "publish:Failed to put msg->recv_indication_cfg");
+
+ request.attr_end(data);
+ result = requestResponse(request);
+ if (result != WIFI_SUCCESS) {
+ ALOGE("failed to publish; result = %d", result);
+ } else {
+ ALOGD("publish...success");
+ }
+ return result;
+ }
+
+ int publishCancel(NanPublishCancelRequest *msg) {
+ ALOGD("publishCancel...");
+ WifiRequest request(familyId(), ifaceId());
+
+ int result = request.create(GOOGLE_OUI, SLSI_NL80211_VENDOR_SUBCMD_NAN_PUBLISHCANCEL);
+ CHECK_WIFI_STATUS_RETURN_FAIL(result, "publishCancel:Failed to create WifiRequest");
+
+ nlattr *data = request.attr_start(NL80211_ATTR_VENDOR_DATA);
+ if (!data) {
+ ALOGE("publishCancel: request.attr_start fail");
+ return WIFI_ERROR_OUT_OF_MEMORY;
+ }
+
+ CHECK_CONFIG_PUT_16_RETURN_FAIL(1, msg->publish_id,
+ NAN_REQ_ATTR_PUBLISH_ID, request, result, "publishCancel:Failed to put msg->publish_id");
+
+ request.attr_end(data);
+ result = requestResponse(request);
+ if (result != WIFI_SUCCESS) {
+ ALOGE("failed to publishCancel; result = %d", result);
+ } else {
+ ALOGD("publishCancel...success");
+ }
+ return result;
+
+ }
+
+ int subscribe(NanSubscribeRequest *msg) {
+ ALOGD("subscribe...");
+ WifiRequest request(familyId(), ifaceId());
+
+ int result = request.create(GOOGLE_OUI, SLSI_NL80211_VENDOR_SUBCMD_NAN_SUBSCRIBE);
+ CHECK_WIFI_STATUS_RETURN_FAIL(result, "subscribe:Failed to create WifiRequest");
+
+ nlattr *data = request.attr_start(NL80211_ATTR_VENDOR_DATA);
+ if (!data) {
+ ALOGE("subscribe: request.attr_start fail");
+ return WIFI_ERROR_OUT_OF_MEMORY;
+ }
+
+ CHECK_CONFIG_PUT_16_RETURN_FAIL(msg->subscribe_id, msg->subscribe_id,
+ NAN_REQ_ATTR_SUBSCRIBE_ID, request, result, "subscribe:Failed to put msg->publish_id");
+
+ CHECK_CONFIG_PUT_16_RETURN_FAIL(1, msg->ttl,
+ NAN_REQ_ATTR_SUBSCRIBE_TTL, request, result, "subscribe:Failed to put msg->ttl");
+
+ CHECK_CONFIG_PUT_16_RETURN_FAIL(1, msg->period,
+ NAN_REQ_ATTR_SUBSCRIBE_PERIOD, request, result, "subscribe:Failed to put msg->period");
+
+ CHECK_CONFIG_PUT_8_RETURN_FAIL(1, msg->subscribe_type,
+ NAN_REQ_ATTR_SUBSCRIBE_TYPE, request, result, "subscribe:Failed to put msg->subscribe_type");
+
+ CHECK_CONFIG_PUT_8_RETURN_FAIL(1, msg->serviceResponseFilter,
+ NAN_REQ_ATTR_SUBSCRIBE_RESP_FILTER_TYPE, request, result, "subscribe:Failed to put msg->serviceResponseFilter");
+
+ CHECK_CONFIG_PUT_8_RETURN_FAIL(1, msg->serviceResponseInclude,
+ NAN_REQ_ATTR_SUBSCRIBE_RESP_INCLUDE, request, result, "subscribe:Failed to put msg->serviceResponseInclude");
+
+ CHECK_CONFIG_PUT_8_RETURN_FAIL(1, msg->useServiceResponseFilter,
+ NAN_REQ_ATTR_SUBSCRIBE_USE_RESP_FILTER, request, result, "subscribe:Failed to put msg->useServiceResponseFilter");
+
+ CHECK_CONFIG_PUT_8_RETURN_FAIL(1, msg->ssiRequiredForMatchIndication,
+ NAN_REQ_ATTR_SUBSCRIBE_SSI_REQUIRED, request, result, "subscribe:Failed to put msg->ssiRequiredForMatchIndication");
+
+ CHECK_CONFIG_PUT_8_RETURN_FAIL(1, msg->subscribe_match_indicator,
+ NAN_REQ_ATTR_SUBSCRIBE_MATCH_INDICATOR, request, result, "subscribe:Failed to put msg->subscribe_match_indicator");
+
+ CHECK_CONFIG_PUT_8_RETURN_FAIL(1, msg->subscribe_count,
+ NAN_REQ_ATTR_SUBSCRIBE_COUNT, request, result, "subscribe:Failed to put msg->subscribe_count");
+
+ CHECK_CONFIG_PUT_16_RETURN_FAIL(msg->service_name_len, msg->service_name_len,
+ NAN_REQ_ATTR_SUBSCRIBE_SERVICE_NAME_LEN, request, result, "subscribe:Failed to put msg->service_name_len");
+
+ CHECK_CONFIG_PUT_RETURN_FAIL(msg->service_name_len, msg->service_name, msg->service_name_len,
+ NAN_REQ_ATTR_SUBSCRIBE_SERVICE_NAME, request, result, "subscribe:Failed to put msg->service_name");
+
+ CHECK_CONFIG_PUT_16_RETURN_FAIL(msg->service_specific_info_len, msg->service_specific_info_len,
+ NAN_REQ_ATTR_SUBSCRIBE_SERVICE_INFO_LEN, request, result, "subscribe:Failed to put msg->service_specific_info_len");
+
+ CHECK_CONFIG_PUT_RETURN_FAIL(msg->service_specific_info_len, msg->service_specific_info, msg->service_specific_info_len,
+ NAN_REQ_ATTR_SUBSCRIBE_SERVICE_INFO, request, result, "subscribe:Failed to put msg->service_specific_info");
+
+ CHECK_CONFIG_PUT_16_RETURN_FAIL(msg->rx_match_filter_len, msg->rx_match_filter_len,
+ NAN_REQ_ATTR_SUBSCRIBE_RX_MATCH_FILTER_LEN, request, result, "subscribe:Failed to put msg->rx_match_filter_len");
+
+ CHECK_CONFIG_PUT_RETURN_FAIL(msg->rx_match_filter_len, msg->rx_match_filter, msg->rx_match_filter_len,
+ NAN_REQ_ATTR_SUBSCRIBE_RX_MATCH_FILTER, request, result, "subscribe:Failed to put msg->rx_match_filter");
+
+ CHECK_CONFIG_PUT_16_RETURN_FAIL(msg->tx_match_filter_len, msg->tx_match_filter_len,
+ NAN_REQ_ATTR_SUBSCRIBE_TX_MATCH_FILTER_LEN, request, result, "subscribe:Failed to put msg->tx_match_filter_len");
+
+ CHECK_CONFIG_PUT_RETURN_FAIL(msg->tx_match_filter_len, msg->tx_match_filter, msg->tx_match_filter_len,
+ NAN_REQ_ATTR_SUBSCRIBE_TX_MATCH_FILTER, request, result, "subscribe:Failed to put msg->tx_match_filter");
+
+ CHECK_CONFIG_PUT_8_RETURN_FAIL(1, msg->rssi_threshold_flag,
+ NAN_REQ_ATTR_SUBSCRIBE_RSSI_THRESHOLD_FLAG, request, result, "subscribe:Failed to put msg->rssi_threshold_flag");
+
+ CHECK_CONFIG_PUT_8_RETURN_FAIL(1, msg->connmap,
+ NAN_REQ_ATTR_SUBSCRIBE_CONN_MAP, request, result, "subscribe:Failed to put msg->connmap");
+
+ CHECK_CONFIG_PUT_8_RETURN_FAIL(msg->num_intf_addr_present, msg->num_intf_addr_present,
+ NAN_REQ_ATTR_SUBSCRIBE_NUM_INTF_ADDR_PRESENT, request, result, "subscribe:Failed to put msg->num_intf_addr_present");
+
+ CHECK_CONFIG_PUT_RETURN_FAIL(msg->num_intf_addr_present, msg->intf_addr, NAN_MAC_ADDR_LEN * msg->num_intf_addr_present,
+ NAN_REQ_ATTR_SUBSCRIBE_INTF_ADDR, request, result, "subscribe:Failed to put msg->intf_addr");
+
+ CHECK_CONFIG_PUT_8_RETURN_FAIL(1, msg->recv_indication_cfg,
+ NAN_REQ_ATTR_SUBSCRIBE_RECV_IND_CFG, request, result, "subscribe:Failed to put msg->recv_indication_cfg");
+
+ request.attr_end(data);
+ result = requestResponse(request);
+ if (result != WIFI_SUCCESS) {
+ ALOGE("failed to subscribe; result = %d", result);
+ } else {
+ ALOGD("subscribe...success");
+ }
+ return result;
+
+ }
+
+ int subscribeCancel(NanSubscribeCancelRequest *msg) {
+ ALOGD("subscribeCancel...");
+ WifiRequest request(familyId(), ifaceId());
+
+ int result = request.create(GOOGLE_OUI, SLSI_NL80211_VENDOR_SUBCMD_NAN_SUBSCRIBECANCEL);
+ CHECK_WIFI_STATUS_RETURN_FAIL(result, "subscribeCancel:Failed to create WifiRequest");
+
+ nlattr *data = request.attr_start(NL80211_ATTR_VENDOR_DATA);
+ if (!data) {
+ ALOGE("subscribeCancel: request.attr_start fail");
+ return WIFI_ERROR_OUT_OF_MEMORY;
+ }
+
+ CHECK_CONFIG_PUT_16_RETURN_FAIL(1, msg->subscribe_id,
+ NAN_REQ_ATTR_SUBSCRIBE_ID, request, result, "subscribeCancel:Failed to put msg->subscribe_id");
+
+ request.attr_end(data);
+ result = requestResponse(request);
+ if (result != WIFI_SUCCESS) {
+ ALOGE("failed to subscribeCancel; result = %d", result);
+ } else {
+ ALOGD("subscribeCancel...success");
+ }
+ return result;
+ }
+
+ int followup(NanTransmitFollowupRequest *msg) {
+ ALOGD("followup...");
+ WifiRequest request(familyId(), ifaceId());
+
+ int result = request.create(GOOGLE_OUI, SLSI_NL80211_VENDOR_SUBCMD_NAN_TXFOLLOWUP);
+ CHECK_WIFI_STATUS_RETURN_FAIL(result, "followup:Failed to create WifiRequest");
+
+ nlattr *data = request.attr_start(NL80211_ATTR_VENDOR_DATA);
+ if (!data) {
+ ALOGE("followup: request.attr_start fail");
+ return WIFI_ERROR_OUT_OF_MEMORY;
+ }
+
+ CHECK_CONFIG_PUT_16_RETURN_FAIL(1, msg->publish_subscribe_id,
+ NAN_REQ_ATTR_FOLLOWUP_ID, request, result, "followup:Failed to put msg->publish_subscribe_id");
+
+ CHECK_CONFIG_PUT_32_RETURN_FAIL(1, msg->requestor_instance_id,
+ NAN_REQ_ATTR_FOLLOWUP_REQUESTOR_ID, request, result, "followup:Failed to put msg->requestor_instance_id");
+
+ CHECK_CONFIG_PUT_RETURN_FAIL(1, msg->addr, NAN_MAC_ADDR_LEN,
+ NAN_REQ_ATTR_FOLLOWUP_ADDR, request, result, "followup:Failed to put msg->addr");
+
+ CHECK_CONFIG_PUT_8_RETURN_FAIL(1, msg->priority,
+ NAN_REQ_ATTR_FOLLOWUP_PRIORITY, request, result, "followup:Failed to put msg->priority");
+
+ CHECK_CONFIG_PUT_8_RETURN_FAIL(1, msg->dw_or_faw,
+ NAN_REQ_ATTR_FOLLOWUP_TX_WINDOW, request, result, "followup:Failed to put msg->dw_or_faw");
+
+ CHECK_CONFIG_PUT_16_RETURN_FAIL(msg->service_specific_info_len, msg->service_specific_info_len,
+ NAN_REQ_ATTR_FOLLOWUP_SERVICE_NAME_LEN, request, result, "followup:Failed to put msg->service_specific_info_len");
+
+ CHECK_CONFIG_PUT_RETURN_FAIL(msg->service_specific_info_len, msg->service_specific_info, msg->service_specific_info_len,
+ NAN_REQ_ATTR_FOLLOWUP_SERVICE_NAME, request, result, "followup:Failed to put msg->service_specific_info");
+
+ CHECK_CONFIG_PUT_8_RETURN_FAIL(1, msg->recv_indication_cfg,
+ NAN_REQ_ATTR_FOLLOWUP_RECV_IND_CFG, request, result, "followup:Failed to put msg->recv_indication_cfg");
+
+ request.attr_end(data);
+ result = requestResponse(request);
+ if (result != WIFI_SUCCESS) {
+ ALOGE("failed to followup; result = %d", result);
+ } else {
+ ALOGD("followup...success");
+ }
+ return result;
+
+ }
+
+ int getCapabilities(void) {
+ ALOGD("getCapabilities...");
+ WifiRequest request(familyId(), ifaceId());
+
+ int result = request.create(GOOGLE_OUI, SLSI_NL80211_VENDOR_SUBCMD_NAN_CAPABILITIES);
+ CHECK_WIFI_STATUS_RETURN_FAIL(result, "getCapabilities:Failed to create WifiRequest");
+
+ result = requestResponse(request);
+ if (result != WIFI_SUCCESS) {
+ ALOGE("failed to getCapabilities; result = %d", result);
+ } else {
+ ALOGD("getCapabilities...success");
+ }
+ return result;
+ }
+
+ int handleEvent(WifiEvent &event) {
+ int ret;
+ ALOGD("handleEvent...");
+
+ if (event.get_cmd() != NL80211_CMD_VENDOR) {
+ ALOGD("Ignoring event with cmd = %d", event.get_cmd());
+ return NL_SKIP;
+ }
+
+ int id = event.get_vendor_id();
+ int subcmd = event.get_vendor_subcmd();
+
+ ALOGI("Id = %0x, subcmd = %d", id, subcmd);
+
+ switch(subcmd) {
+ case SLSI_NAN_EVENT_MATCH:
+ ret = processMatchEvent(event);
+ break;
+ case SLSI_NAN_EVENT_MATCH_EXPIRED:
+ ret = processMatchExpiredEvent(event);
+ break;
+ case SLSI_NAN_EVENT_PUBLISH_TERMINATED:
+ ret = processPublishTerminatedEvent(event);
+ break;
+ case SLSI_NAN_EVENT_SUBSCRIBE_TERMINATED:
+ ret = processSubscribeTerminatedEvent(event);
+ break;
+ case SLSI_NAN_EVENT_FOLLOWUP:
+ ret = processFollowupEvent(event);
+ break;
+ case SLSI_NAN_EVENT_DISABLED:
+ ret = processNanDisabledEvent(event);
+ break;
+ case SLSI_NAN_EVENT_DISCOVERY_ENGINE:
+ ret = processNanDiscoveryEvent(event);
+ break;
+
+ }
+
+ return NL_OK;
+ }
+
+ int handleResponse(WifiEvent &reply) {
+ ALOGD("handleResponse...");
+
+ if (reply.get_cmd() != NL80211_CMD_VENDOR) {
+ ALOGD("Ignoring reply with cmd = %d", reply.get_cmd());
+ return NL_SKIP;
+ }
+
+ int vendorId = reply.get_vendor_id();
+ int subcmd = reply.get_vendor_subcmd();
+
+ ALOGI("Id = %0x, subcmd = %d", vendorId, subcmd);
+
+ NanResponseMsg response;
+ memset(&response, 0, sizeof(response));
+
+ if (processResponse(reply, &response) == NL_SKIP)
+ return NL_SKIP;
+
+ if (callbackEventHandler.NotifyResponse)
+ callbackEventHandler.NotifyResponse(id(), &response);
+ return NL_OK;
+ }
+};
+
+NanCallbackHandler NanCommand::callbackEventHandler;
+
+NanCommand *nan_get_object(transaction_id id,
+ wifi_interface_handle iface) {
+ wifi_handle handle = getWifiHandle(iface);
+ NanCommand *nanRequest = (NanCommand *)wifi_get_cmd(handle, id);
+ if (!nanRequest) {
+ nanRequest = new NanCommand(iface, id);
+ if (!nanRequest){
+ ALOGE("Could not alloc NanCommand");
+ return NULL;
+ }
+ }
+ return nanRequest;
+}
+
+wifi_error nan_enable_request(transaction_id id,
+ wifi_interface_handle iface,
+ NanEnableRequest *msg) {
+ wifi_handle handle = getWifiHandle(iface);
+ wifi_error ret;
+
+ NanCommand *nanRequest = new NanCommand(iface, id);
+ if (!nanRequest) {
+ ALOGE("nan_enable_request:: Unable to create NanCommand");
+ return WIFI_ERROR_OUT_OF_MEMORY;
+ }
+
+ wifi_register_cmd(handle, id, nanRequest);
+ ret = (wifi_error)nanRequest->enable(msg);
+ if (ret != WIFI_SUCCESS) {
+ wifi_unregister_cmd(handle, id);
+ delete nanRequest;
+ }
+ return ret;
+}
+
+/* Disable NAN functionality. */
+wifi_error nan_disable_request(transaction_id id, wifi_interface_handle iface) {
+ NanCommand *nanRequest = nan_get_object(id, iface);
+ wifi_error ret;
+
+ if (!nanRequest) {
+ return WIFI_ERROR_OUT_OF_MEMORY;
+ }
+ ret = (wifi_error)nanRequest->disable();
+ delete nanRequest;
+ return ret;
+}
+
+/* Publish request to advertize a service. */
+wifi_error nan_publish_request(transaction_id id,
+ wifi_interface_handle iface,
+ NanPublishRequest *msg) {
+ NanCommand *nanRequest = nan_get_object(id, iface);
+ if (!nanRequest) {
+ return WIFI_ERROR_OUT_OF_MEMORY;
+ }
+ return (wifi_error)nanRequest->publish(msg);
+}
+
+/* Cancel previous publish requests. */
+wifi_error nan_publish_cancel_request(transaction_id id,
+ wifi_interface_handle iface,
+ NanPublishCancelRequest *msg) {
+ NanCommand *nanRequest = nan_get_object(id, iface);
+ if (!nanRequest) {
+ return WIFI_ERROR_OUT_OF_MEMORY;
+ }
+ return (wifi_error)nanRequest->publishCancel(msg);
+}
+
+/* Subscribe request to search for a service. */
+wifi_error nan_subscribe_request(transaction_id id,
+ wifi_interface_handle iface,
+ NanSubscribeRequest *msg) {
+ NanCommand *nanRequest = nan_get_object(id, iface);
+ if (!nanRequest) {
+ return WIFI_ERROR_OUT_OF_MEMORY;
+ }
+ return (wifi_error)nanRequest->subscribe(msg);
+}
+
+/* Cancel previous subscribe requests. */
+wifi_error nan_subscribe_cancel_request(transaction_id id,
+ wifi_interface_handle iface,
+ NanSubscribeCancelRequest *msg) {
+ NanCommand *nanRequest = nan_get_object(id, iface);
+ if (!nanRequest) {
+ return WIFI_ERROR_OUT_OF_MEMORY;
+ }
+ return (wifi_error)nanRequest->subscribeCancel(msg);
+}
+
+/* NAN transmit follow up request. */
+wifi_error nan_transmit_followup_request(transaction_id id,
+ wifi_interface_handle iface,
+ NanTransmitFollowupRequest *msg) {
+ NanCommand *nanRequest = nan_get_object(id, iface);
+ if (!nanRequest) {
+ return WIFI_ERROR_OUT_OF_MEMORY;
+ }
+ return (wifi_error)nanRequest->followup(msg);
+}
+
+/* NAN configuration request. */
+wifi_error nan_config_request(transaction_id id,
+ wifi_interface_handle iface,
+ NanConfigRequest *msg) {
+ NanCommand *nanRequest = nan_get_object(id, iface);
+ if (!nanRequest) {
+ return WIFI_ERROR_OUT_OF_MEMORY;
+ }
+ return (wifi_error)nanRequest->config(msg);
+}
+
+/* Register NAN callbacks. */
+wifi_error nan_register_handler(wifi_interface_handle iface,
+ NanCallbackHandler handlers) {
+ return (wifi_error)NanCommand::setCallbackHandler(handlers);
+}
+
+/* Get NAN HAL version. */
+wifi_error nan_get_version(wifi_handle handle,
+ NanVersion *version) {
+ return (wifi_error)NanCommand::getVersion(version);
+}
+
+/* Get NAN capabilities. */
+wifi_error nan_get_capabilities(transaction_id id,
+ wifi_interface_handle iface) {
+ NanCommand *nanRequest = nan_get_object(id, iface);
+ if (!nanRequest) {
+ return WIFI_ERROR_OUT_OF_MEMORY;
+ }
+ return (wifi_error)nanRequest->getCapabilities();
+}
+
projects / GitHub / LineageOS / android_hardware_samsung_slsi_scsc_wifibt_wifi_hal.git / commitdiff