wifi_nan.cpp

   1
   2 #include <stdint.h>
   3 #include <stddef.h>
   4 #include <fcntl.h>
   5 #include <sys/socket.h>
   6 #include <netlink/genl/genl.h>
   7 #include <netlink/genl/family.h>
   8 #include <netlink/genl/ctrl.h>
   9 #include <linux/rtnetlink.h>
  10 #include <netpacket/packet.h>
  11 #include <linux/filter.h>
  12 #include <linux/errqueue.h>
  13 #include <linux/pkt_sched.h>
  14 #include <netlink/object-api.h>
  15 #include <netlink/netlink.h>
  16 #include <netlink/socket.h>
  17 #include <netlink/handlers.h>
  18
  19 #include "sync.h"
  20
  21 #include <utils/Log.h>
  22
  23 #include "wifi_hal.h"
  24 #include "common.h"
  25 #include "cpp_bindings.h"
  26
  27 #define SLSI_WIFI_HAL_NAN_VERSION 1
  28
  29 #define CHECK_WIFI_STATUS_RETURN_FAIL(result, LOGSTR) \
  30     if (result != WIFI_SUCCESS) {\
  31         ALOGE(LOGSTR" [result:%d]", result);\
  32         return result;\
  33     }
  34
  35 #define CHECK_CONFIG_PUT_8_RETURN_FAIL(config, val, nan_attribute, request, result, FAIL_STR) \
  36     if (config) {\
  37         result = request.put_u8(nan_attribute, val); \
  38         if (result != WIFI_SUCCESS) {\
  39             ALOGE(FAIL_STR" [result:%d]", result);\
  40             return result;\
  41         }\
  42     }
  43
  44 #define CHECK_CONFIG_PUT_16_RETURN_FAIL(config, val, nan_attribute, request, result, FAIL_STR) \
  45     if (config) {\
  46         result = request.put_u16(nan_attribute, val); \
  47         if (result != WIFI_SUCCESS) {\
  48             ALOGE(FAIL_STR" [result:%d]", result);\
  49             return result;\
  50         }\
  51     }
  52
  53
  54 #define CHECK_CONFIG_PUT_32_RETURN_FAIL(config, val, nan_attribute, request, result, FAIL_STR) \
  55     if (config) {\
  56         result = request.put_u32(nan_attribute, val); \
  57         if (result != WIFI_SUCCESS) {\
  58             ALOGE(FAIL_STR" [result:%d]", result);\
  59             return result;\
  60         }\
  61     }
  62
  63 #define CHECK_CONFIG_PUT_RETURN_FAIL(config, valptr, len, nan_attribute, request, result, FAIL_STR) \
  64     if (config) {\
  65         result = request.put(nan_attribute, valptr, len); \
  66         if (result != WIFI_SUCCESS) {\
  67             ALOGE(FAIL_STR" [result:%d]", result);\
  68             return result;\
  69         }\
  70     }
  71
  72 typedef enum {
  73     NAN_REQ_ATTR_MASTER_PREF,
  74     NAN_REQ_ATTR_CLUSTER_LOW,
  75     NAN_REQ_ATTR_CLUSTER_HIGH,
  76     NAN_REQ_ATTR_HOP_COUNT_LIMIT_VAL,
  77     NAN_REQ_ATTR_SID_BEACON_VAL,
  78
  79     NAN_REQ_ATTR_SUPPORT_2G4_VAL,
  80     NAN_REQ_ATTR_SUPPORT_5G_VAL,
  81
  82     NAN_REQ_ATTR_RSSI_CLOSE_2G4_VAL,
  83     NAN_REQ_ATTR_RSSI_MIDDLE_2G4_VAL,
  84     NAN_REQ_ATTR_RSSI_PROXIMITY_2G4_VAL,
  85     NAN_REQ_ATTR_BEACONS_2G4_VAL,
  86     NAN_REQ_ATTR_SDF_2G4_VAL,
  87     NAN_REQ_ATTR_CHANNEL_2G4_MHZ_VAL,
  88     NAN_REQ_ATTR_RSSI_PROXIMITY_VAL,
  89
  90
  91     NAN_REQ_ATTR_RSSI_CLOSE_5G_VAL,
  92     NAN_REQ_ATTR_RSSI_CLOSE_PROXIMITY_5G_VAL,
  93     NAN_REQ_ATTR_RSSI_MIDDLE_5G_VAL,
  94     NAN_REQ_ATTR_RSSI_PROXIMITY_5G_VAL,
  95     NAN_REQ_ATTR_BEACON_5G_VAL,
  96     NAN_REQ_ATTR_SDF_5G_VAL,
  97     NAN_REQ_ATTR_CHANNEL_5G_MHZ_VAL,
  98
  99     NAN_REQ_ATTR_RSSI_WINDOW_SIZE_VAL,
 100     NAN_REQ_ATTR_OUI_VAL,
 101     NAN_REQ_ATTR_MAC_ADDR_VAL,
 102     NAN_REQ_ATTR_CLUSTER_VAL,
 103     NAN_REQ_ATTR_SOCIAL_CH_SCAN_DWELL_TIME,
 104     NAN_REQ_ATTR_SOCIAL_CH_SCAN_PERIOD,
 105     NAN_REQ_ATTR_RANDOM_FACTOR_FORCE_VAL,
 106     NAN_REQ_ATTR_HOP_COUNT_FORCE_VAL,
 107     NAN_REQ_ATTR_CONN_CAPABILITY_PAYLOAD_TX,
 108     NAN_REQ_ATTR_CONN_CAPABILITY_IBSS,
 109     NAN_REQ_ATTR_CONN_CAPABILITY_WFD,
 110     NAN_REQ_ATTR_CONN_CAPABILITY_WFDS,
 111     NAN_REQ_ATTR_CONN_CAPABILITY_TDLS,
 112     NAN_REQ_ATTR_CONN_CAPABILITY_MESH,
 113     NAN_REQ_ATTR_CONN_CAPABILITY_WLAN_INFRA,
 114     NAN_REQ_ATTR_DISCOVERY_ATTR_NUM_ENTRIES,
 115     NAN_REQ_ATTR_DISCOVERY_ATTR_VAL,
 116     NAN_REQ_ATTR_CONN_TYPE,
 117     NAN_REQ_ATTR_NAN_ROLE,
 118     NAN_REQ_ATTR_TRANSMIT_FREQ,
 119     NAN_REQ_ATTR_AVAILABILITY_DURATION,
 120     NAN_REQ_ATTR_AVAILABILITY_INTERVAL,
 121     NAN_REQ_ATTR_MESH_ID_LEN,
 122     NAN_REQ_ATTR_MESH_ID,
 123     NAN_REQ_ATTR_INFRASTRUCTURE_SSID_LEN,
 124     NAN_REQ_ATTR_INFRASTRUCTURE_SSID,
 125     NAN_REQ_ATTR_FURTHER_AVAIL_NUM_ENTRIES,
 126     NAN_REQ_ATTR_FURTHER_AVAIL_VAL,
 127     NAN_REQ_ATTR_FURTHER_AVAIL_ENTRY_CTRL,
 128     NAN_REQ_ATTR_FURTHER_AVAIL_CHAN_CLASS,
 129     NAN_REQ_ATTR_FURTHER_AVAIL_CHAN,
 130     NAN_REQ_ATTR_FURTHER_AVAIL_CHAN_MAPID,
 131     NAN_REQ_ATTR_FURTHER_AVAIL_INTERVAL_BITMAP,
 132     NAN_REQ_ATTR_PUBLISH_ID,
 133     NAN_REQ_ATTR_PUBLISH_TTL,
 134     NAN_REQ_ATTR_PUBLISH_PERIOD,
 135     NAN_REQ_ATTR_PUBLISH_TYPE,
 136     NAN_REQ_ATTR_PUBLISH_TX_TYPE,
 137     NAN_REQ_ATTR_PUBLISH_COUNT,
 138     NAN_REQ_ATTR_PUBLISH_SERVICE_NAME_LEN,
 139     NAN_REQ_ATTR_PUBLISH_SERVICE_NAME,
 140     NAN_REQ_ATTR_PUBLISH_MATCH_ALGO,
 141     NAN_REQ_ATTR_PUBLISH_SERVICE_INFO_LEN,
 142     NAN_REQ_ATTR_PUBLISH_SERVICE_INFO,
 143     NAN_REQ_ATTR_PUBLISH_RX_MATCH_FILTER_LEN,
 144     NAN_REQ_ATTR_PUBLISH_RX_MATCH_FILTER,
 145     NAN_REQ_ATTR_PUBLISH_TX_MATCH_FILTER_LEN,
 146     NAN_REQ_ATTR_PUBLISH_TX_MATCH_FILTER,
 147     NAN_REQ_ATTR_PUBLISH_RSSI_THRESHOLD_FLAG,
 148     NAN_REQ_ATTR_PUBLISH_CONN_MAP,
 149     NAN_REQ_ATTR_PUBLISH_RECV_IND_CFG,
 150     NAN_REQ_ATTR_SUBSCRIBE_ID,
 151     NAN_REQ_ATTR_SUBSCRIBE_TTL,
 152     NAN_REQ_ATTR_SUBSCRIBE_PERIOD,
 153     NAN_REQ_ATTR_SUBSCRIBE_TYPE,
 154     NAN_REQ_ATTR_SUBSCRIBE_RESP_FILTER_TYPE,
 155     NAN_REQ_ATTR_SUBSCRIBE_RESP_INCLUDE,
 156     NAN_REQ_ATTR_SUBSCRIBE_USE_RESP_FILTER,
 157     NAN_REQ_ATTR_SUBSCRIBE_SSI_REQUIRED,
 158     NAN_REQ_ATTR_SUBSCRIBE_MATCH_INDICATOR,
 159     NAN_REQ_ATTR_SUBSCRIBE_COUNT,
 160     NAN_REQ_ATTR_SUBSCRIBE_SERVICE_NAME_LEN,
 161     NAN_REQ_ATTR_SUBSCRIBE_SERVICE_NAME,
 162     NAN_REQ_ATTR_SUBSCRIBE_SERVICE_INFO_LEN,
 163     NAN_REQ_ATTR_SUBSCRIBE_SERVICE_INFO,
 164     NAN_REQ_ATTR_SUBSCRIBE_RX_MATCH_FILTER_LEN,
 165     NAN_REQ_ATTR_SUBSCRIBE_RX_MATCH_FILTER,
 166     NAN_REQ_ATTR_SUBSCRIBE_TX_MATCH_FILTER_LEN,
 167     NAN_REQ_ATTR_SUBSCRIBE_TX_MATCH_FILTER,
 168     NAN_REQ_ATTR_SUBSCRIBE_RSSI_THRESHOLD_FLAG,
 169     NAN_REQ_ATTR_SUBSCRIBE_CONN_MAP,
 170     NAN_REQ_ATTR_SUBSCRIBE_NUM_INTF_ADDR_PRESENT,
 171     NAN_REQ_ATTR_SUBSCRIBE_INTF_ADDR,
 172     NAN_REQ_ATTR_SUBSCRIBE_RECV_IND_CFG,
 173     NAN_REQ_ATTR_FOLLOWUP_ID,
 174     NAN_REQ_ATTR_FOLLOWUP_REQUESTOR_ID,
 175     NAN_REQ_ATTR_FOLLOWUP_ADDR,
 176     NAN_REQ_ATTR_FOLLOWUP_PRIORITY,
 177     NAN_REQ_ATTR_FOLLOWUP_SERVICE_NAME_LEN,
 178     NAN_REQ_ATTR_FOLLOWUP_SERVICE_NAME,
 179     NAN_REQ_ATTR_FOLLOWUP_TX_WINDOW,
 180     NAN_REQ_ATTR_FOLLOWUP_RECV_IND_CFG,
 181 } NAN_REQ_ATTRIBUTES;
 182
 183 typedef enum {
 184         NAN_REPLY_ATTR_STATUS_TYPE,
 185         NAN_REPLY_ATTR_VALUE,
 186         NAN_REPLY_ATTR_RESPONSE_TYPE,
 187         NAN_REPLY_ATTR_PUBLISH_SUBSCRIBE_TYPE,
 188         NAN_REPLY_ATTR_CAP_MAX_CONCURRENT_CLUSTER,
 189         NAN_REPLY_ATTR_CAP_MAX_PUBLISHES,
 190         NAN_REPLY_ATTR_CAP_MAX_SUBSCRIBES,
 191         NAN_REPLY_ATTR_CAP_MAX_SERVICE_NAME_LEN,
 192         NAN_REPLY_ATTR_CAP_MAX_MATCH_FILTER_LEN,
 193         NAN_REPLY_ATTR_CAP_MAX_TOTAL_MATCH_FILTER_LEN,
 194         NAN_REPLY_ATTR_CAP_MAX_SERVICE_SPECIFIC_INFO_LEN,
 195         NAN_REPLY_ATTR_CAP_MAX_VSA_DATA_LEN,
 196         NAN_REPLY_ATTR_CAP_MAX_MESH_DATA_LEN,
 197         NAN_REPLY_ATTR_CAP_MAX_NDI_INTERFACES,
 198         NAN_REPLY_ATTR_CAP_MAX_NDP_SESSIONS,
 199         NAN_REPLY_ATTR_CAP_MAX_APP_INFO_LEN,
 200 } NAN_RESP_ATTRIBUTES;
 201
 202 typedef enum {
 203     NAN_EVT_ATTR_MATCH_PUBLISH_SUBSCRIBE_ID,
 204     NAN_EVT_ATTR_MATCH_REQUESTOR_INSTANCE_ID,
 205     NAN_EVT_ATTR_MATCH_ADDR,
 206     NAN_EVT_ATTR_MATCH_SERVICE_SPECIFIC_INFO_LEN,
 207     NAN_EVT_ATTR_MATCH_SERVICE_SPECIFIC_INFO,
 208     NAN_EVT_ATTR_MATCH_SDF_MATCH_FILTER_LEN,
 209     NAN_EVT_ATTR_MATCH_SDF_MATCH_FILTER,
 210     NAN_EVT_ATTR_MATCH_MATCH_OCCURED_FLAG,
 211     NAN_EVT_ATTR_MATCH_OUT_OF_RESOURCE_FLAG,
 212     NAN_EVT_ATTR_MATCH_RSSI_VALUE,
 213 /*CONN_CAPABILITY*/
 214     NAN_EVT_ATTR_MATCH_CONN_CAPABILITY_IS_WFD_SUPPORTED,
 215     NAN_EVT_ATTR_MATCH_CONN_CAPABILITY_IS_WFDS_SUPPORTED,
 216     NAN_EVT_ATTR_MATCH_CONN_CAPABILITY_IS_TDLS_SUPPORTED,
 217     NAN_EVT_ATTR_MATCH_CONN_CAPABILITY_IS_IBSS_SUPPORTED,
 218     NAN_EVT_ATTR_MATCH_CONN_CAPABILITY_IS_MESH_SUPPORTED,
 219     NAN_EVT_ATTR_MATCH_CONN_CAPABILITY_WLAN_INFRA_FIELD,
 220     NAN_EVT_ATTR_MATCH_NUM_RX_DISCOVERY_ATTR,
 221     NAN_EVT_ATTR_MATCH_RX_DISCOVERY_ATTR,
 222 /*NANRECEIVEPOSTDISCOVERY DISCOVERY_ATTR,*/
 223     NAN_EVT_ATTR_MATCH_DISC_ATTR_TYPE,
 224     NAN_EVT_ATTR_MATCH_DISC_ATTR_ROLE,
 225     NAN_EVT_ATTR_MATCH_DISC_ATTR_DURATION,
 226     NAN_EVT_ATTR_MATCH_DISC_ATTR_AVAIL_INTERVAL_BITMAP,
 227     NAN_EVT_ATTR_MATCH_DISC_ATTR_MAPID,
 228     NAN_EVT_ATTR_MATCH_DISC_ATTR_ADDR,
 229     NAN_EVT_ATTR_MATCH_DISC_ATTR_MESH_ID_LEN,
 230     NAN_EVT_ATTR_MATCH_DISC_ATTR_MESH_ID,
 231     NAN_EVT_ATTR_MATCH_DISC_ATTR_INFRASTRUCTURE_SSID_LEN,
 232     NAN_EVT_ATTR_MATCH_DISC_ATTR_INFRASTRUCTURE_SSID_VAL,
 233
 234     NAN_EVT_ATTR_MATCH_NUM_CHANS,
 235     NAN_EVT_ATTR_MATCH_FAMCHAN,
 236 /*FAMCHAN[32],*/
 237     NAN_EVT_ATTR_MATCH_FAM_ENTRY_CONTROL,
 238     NAN_EVT_ATTR_MATCH_FAM_CLASS_VAL,
 239     NAN_EVT_ATTR_MATCH_FAM_CHANNEL,
 240     NAN_EVT_ATTR_MATCH_FAM_MAPID,
 241     NAN_EVT_ATTR_MATCH_FAM_AVAIL_INTERVAL_BITMAP,
 242     NAN_EVT_ATTR_MATCH_CLUSTER_ATTRIBUTE_LEN,
 243     NAN_EVT_ATTR_MATCH_CLUSTER_ATTRIBUTE,
 244     NAN_EVT_ATTR_PUBLISH_ID,
 245     NAN_EVT_ATTR_PUBLISH_REASON,
 246     NAN_EVT_ATTR_SUBSCRIBE_ID,
 247     NAN_EVT_ATTR_SUBSCRIBE_REASON,
 248     NAN_EVT_ATTR_DISABLED_REASON,
 249     NAN_EVT_ATTR_FOLLOWUP_PUBLISH_SUBSCRIBE_ID,
 250     NAN_EVT_ATTR_FOLLOWUP_REQUESTOR_INSTANCE_ID,
 251     NAN_EVT_ATTR_FOLLOWUP_ADDR,
 252     NAN_EVT_ATTR_FOLLOWUP_DW_OR_FAW,
 253     NAN_EVT_ATTR_FOLLOWUP_SERVICE_SPECIFIC_INFO_LEN,
 254     NAN_EVT_ATTR_FOLLOWUP_SERVICE_SPECIFIC_INFO,
 255     NAN_EVT_ATTR_DISCOVERY_ENGINE_EVT_TYPE      ,
 256     NAN_EVT_ATTR_DISCOVERY_ENGINE_MAC_ADDR,
 257     NAN_EVT_ATTR_DISCOVERY_ENGINE_CLUSTER
 258
 259 } NAN_EVT_ATTRIBUTES;
 260
 261 class NanCommand : public WifiCommand {
 262     static NanCallbackHandler callbackEventHandler;
 263     int subscribeID[2];
 264     int publishID[2];
 265     int followupID[2];
 266     int version;
 267     NanCapabilities capabilities;
 268
 269     void registerNanEvents(void) {
 270         registerVendorHandler(GOOGLE_OUI, SLSI_NAN_EVENT_PUBLISH_TERMINATED);
 271         registerVendorHandler(GOOGLE_OUI, SLSI_NAN_EVENT_MATCH);
 272         registerVendorHandler(GOOGLE_OUI, SLSI_NAN_EVENT_MATCH_EXPIRED);
 273         registerVendorHandler(GOOGLE_OUI, SLSI_NAN_EVENT_SUBSCRIBE_TERMINATED);
 274         registerVendorHandler(GOOGLE_OUI, SLSI_NAN_EVENT_FOLLOWUP);
 275         registerVendorHandler(GOOGLE_OUI, SLSI_NAN_EVENT_DISCOVERY_ENGINE);
 276     }
 277
 278     void unregisterNanEvents(void) {
 279         unregisterVendorHandler(GOOGLE_OUI, SLSI_NAN_EVENT_PUBLISH_TERMINATED);
 280         unregisterVendorHandler(GOOGLE_OUI, SLSI_NAN_EVENT_MATCH);
 281         unregisterVendorHandler(GOOGLE_OUI, SLSI_NAN_EVENT_MATCH_EXPIRED);
 282         unregisterVendorHandler(GOOGLE_OUI, SLSI_NAN_EVENT_SUBSCRIBE_TERMINATED);
 283         unregisterVendorHandler(GOOGLE_OUI, SLSI_NAN_EVENT_FOLLOWUP);
 284         unregisterVendorHandler(GOOGLE_OUI, SLSI_NAN_EVENT_DISCOVERY_ENGINE);
 285     }
 286
 287     int processResponse(WifiEvent &reply, NanResponseMsg *response) {
 288         NanCapabilities *capabilities = &response->body.nan_capabilities;
 289         nlattr *vendor_data = reply.get_attribute(NL80211_ATTR_VENDOR_DATA);
 290         unsigned int val;
 291
 292         for(nl_iterator nl_itr(vendor_data); nl_itr.has_next(); nl_itr.next()) {
 293             switch(nl_itr.get_type()) {
 294             case NAN_REPLY_ATTR_STATUS_TYPE:
 295                 response->status = NanStatusType(nl_itr.get_u32());
 296                 break;
 297             case NAN_REPLY_ATTR_VALUE:
 298                 val = nl_itr.get_u32();
 299                 if (val) {
 300                     strncpy(response->nan_error, "Lower_layer_error",NAN_ERROR_STR_LEN);
 301                 }
 302                 break;
 303             case NAN_REPLY_ATTR_RESPONSE_TYPE:
 304                 response->response_type = NanResponseType(nl_itr.get_u32());
 305                 break;
 306             case NAN_REPLY_ATTR_PUBLISH_SUBSCRIBE_TYPE:
 307                 response->body.publish_response.publish_id = nl_itr.get_u16();
 308                 break;
 309             case NAN_REPLY_ATTR_CAP_MAX_CONCURRENT_CLUSTER:
 310                 capabilities->max_concurrent_nan_clusters = nl_itr.get_u32();
 311                 break;
 312             case NAN_REPLY_ATTR_CAP_MAX_PUBLISHES:
 313                 capabilities->max_publishes = nl_itr.get_u32();
 314                 break;
 315             case NAN_REPLY_ATTR_CAP_MAX_SUBSCRIBES:
 316                 capabilities->max_subscribes = nl_itr.get_u32();
 317                 break;
 318             case NAN_REPLY_ATTR_CAP_MAX_SERVICE_NAME_LEN:
 319                 capabilities->max_service_name_len = nl_itr.get_u32();
 320                 break;
 321             case NAN_REPLY_ATTR_CAP_MAX_MATCH_FILTER_LEN:
 322                 capabilities->max_match_filter_len = nl_itr.get_u32();
 323                 break;
 324             case NAN_REPLY_ATTR_CAP_MAX_TOTAL_MATCH_FILTER_LEN:
 325                 capabilities->max_total_match_filter_len = nl_itr.get_u32();
 326                 break;
 327             case NAN_REPLY_ATTR_CAP_MAX_SERVICE_SPECIFIC_INFO_LEN:
 328                 capabilities->max_service_specific_info_len = nl_itr.get_u32();
 329                 break;
 330             case NAN_REPLY_ATTR_CAP_MAX_VSA_DATA_LEN:
 331                 capabilities->max_vsa_data_len = nl_itr.get_u32();
 332                 break;
 333             case NAN_REPLY_ATTR_CAP_MAX_MESH_DATA_LEN:
 334                 capabilities->max_mesh_data_len = nl_itr.get_u32();
 335                 break;
 336             case NAN_REPLY_ATTR_CAP_MAX_NDI_INTERFACES:
 337                 capabilities->max_ndi_interfaces = nl_itr.get_u32();
 338                 break;
 339             case NAN_REPLY_ATTR_CAP_MAX_NDP_SESSIONS:
 340                 capabilities->max_ndp_sessions = nl_itr.get_u32();
 341                 break;
 342             case NAN_REPLY_ATTR_CAP_MAX_APP_INFO_LEN:
 343                 capabilities->max_app_info_len = nl_itr.get_u32();
 344                 break;
 345             default :
 346                 ALOGE("received unknown type(%d) in response", nl_itr.get_type());
 347                 return NL_SKIP;
 348             }
 349         }
 350         this->capabilities = *capabilities;
 351         return NL_OK;
 352     }
 353
 354     int processMatchEvent(WifiEvent &event) {
 355         NanMatchInd ind;
 356         memset(&ind,0,sizeof(NanMatchInd));
 357         int famchan_idx = 0, disc_idx = 0;
 358         nlattr *vendor_data = event.get_attribute(NL80211_ATTR_VENDOR_DATA);
 359
 360         for(nl_iterator nl_itr(vendor_data); nl_itr.has_next(); nl_itr.next()) {
 361             switch(nl_itr.get_type()) {
 362             case NAN_EVT_ATTR_MATCH_PUBLISH_SUBSCRIBE_ID:
 363                 ind.publish_subscribe_id = nl_itr.get_u16();
 364                 break;
 365             case NAN_EVT_ATTR_MATCH_REQUESTOR_INSTANCE_ID:
 366                 ind.requestor_instance_id = nl_itr.get_u32();
 367                 break;
 368             case NAN_EVT_ATTR_MATCH_ADDR:
 369                 memcpy(ind.addr, nl_itr.get_data(), NAN_MAC_ADDR_LEN);
 370                 break;
 371             case NAN_EVT_ATTR_MATCH_SERVICE_SPECIFIC_INFO_LEN:
 372                 ind.service_specific_info_len = nl_itr.get_u16();
 373                 break;
 374             case NAN_EVT_ATTR_MATCH_SERVICE_SPECIFIC_INFO:
 375                 memcpy(ind.service_specific_info, nl_itr.get_data(), ind.service_specific_info_len);
 376                 break;
 377             case NAN_EVT_ATTR_MATCH_SDF_MATCH_FILTER_LEN:
 378                 ind.sdf_match_filter_len = nl_itr.get_u16();
 379                 break;
 380             case NAN_EVT_ATTR_MATCH_SDF_MATCH_FILTER:
 381                 memcpy(ind.sdf_match_filter, nl_itr.get_data(), ind.sdf_match_filter_len);
 382                 break;
 383             case NAN_EVT_ATTR_MATCH_MATCH_OCCURED_FLAG:
 384                 ind.match_occured_flag = nl_itr.get_u8();
 385                 break;
 386             case NAN_EVT_ATTR_MATCH_OUT_OF_RESOURCE_FLAG:
 387                 ind.out_of_resource_flag = nl_itr.get_u8();
 388                 break;
 389             case NAN_EVT_ATTR_MATCH_RSSI_VALUE:
 390                 ind.rssi_value = nl_itr.get_u8();
 391                 break;
 392             case NAN_EVT_ATTR_MATCH_CONN_CAPABILITY_IS_IBSS_SUPPORTED:
 393                 ind.conn_capability.is_ibss_supported = nl_itr.get_u8();
 394                 break;
 395             case NAN_EVT_ATTR_MATCH_CONN_CAPABILITY_IS_WFD_SUPPORTED:
 396                 ind.conn_capability.is_wfd_supported = nl_itr.get_u8();
 397                 break;
 398             case NAN_EVT_ATTR_MATCH_CONN_CAPABILITY_IS_WFDS_SUPPORTED:
 399                 ind.conn_capability.is_wfds_supported = nl_itr.get_u8();
 400                 break;
 401             case NAN_EVT_ATTR_MATCH_CONN_CAPABILITY_IS_TDLS_SUPPORTED:
 402                 ind.conn_capability.is_tdls_supported = nl_itr.get_u8();
 403                 break;
 404             case NAN_EVT_ATTR_MATCH_CONN_CAPABILITY_IS_MESH_SUPPORTED:
 405                 ind.conn_capability.is_mesh_supported= nl_itr.get_u8();
 406                 break;
 407             case NAN_EVT_ATTR_MATCH_CONN_CAPABILITY_WLAN_INFRA_FIELD:
 408                 ind.conn_capability.wlan_infra_field = nl_itr.get_u8();
 409                 break;
 410             case NAN_EVT_ATTR_MATCH_NUM_RX_DISCOVERY_ATTR:
 411                 ind.num_rx_discovery_attr = nl_itr.get_u8();
 412                 break;
 413             case NAN_EVT_ATTR_MATCH_RX_DISCOVERY_ATTR:
 414                 NanReceivePostDiscovery *disc_attr;
 415                 disc_attr = &ind.discovery_attr[disc_idx];
 416                 disc_idx++;
 417                 for(nl_iterator nl_nested_itr((struct nlattr *)nl_itr.get_data()); nl_nested_itr.has_next(); nl_nested_itr.next()) {
 418                     switch(nl_nested_itr.get_type()) {
 419                     case NAN_EVT_ATTR_MATCH_DISC_ATTR_TYPE:
 420                         disc_attr->type = (NanConnectionType)nl_nested_itr.get_u8();
 421                         break;
 422                     case NAN_EVT_ATTR_MATCH_DISC_ATTR_ROLE:
 423                         disc_attr->role = (NanDeviceRole)nl_nested_itr.get_u8();
 424                         break;
 425                     case NAN_EVT_ATTR_MATCH_DISC_ATTR_DURATION:
 426                         disc_attr->duration = (NanAvailDuration)nl_nested_itr.get_u8();
 427                         break;
 428                     case NAN_EVT_ATTR_MATCH_DISC_ATTR_AVAIL_INTERVAL_BITMAP:
 429                         disc_attr->avail_interval_bitmap = nl_nested_itr.get_u32();
 430                         break;
 431                     case NAN_EVT_ATTR_MATCH_DISC_ATTR_MAPID:
 432                         disc_attr->mapid = nl_nested_itr.get_u8();
 433                         break;
 434                     case NAN_EVT_ATTR_MATCH_DISC_ATTR_ADDR:
 435                         memcpy(disc_attr->addr, nl_nested_itr.get_data(), NAN_MAC_ADDR_LEN);
 436                         break;
 437                     case NAN_EVT_ATTR_MATCH_DISC_ATTR_MESH_ID_LEN:
 438                         disc_attr->mesh_id_len = nl_nested_itr.get_u8();
 439                         break;
 440                     case NAN_EVT_ATTR_MATCH_DISC_ATTR_MESH_ID:
 441                         memcpy(disc_attr->mesh_id, nl_nested_itr.get_data(), disc_attr->mesh_id_len);
 442                         break;
 443                     case NAN_EVT_ATTR_MATCH_DISC_ATTR_INFRASTRUCTURE_SSID_LEN:
 444                         disc_attr->infrastructure_ssid_len = nl_nested_itr.get_u16();
 445                         break;
 446                     case NAN_EVT_ATTR_MATCH_DISC_ATTR_INFRASTRUCTURE_SSID_VAL:
 447                         memcpy(disc_attr->infrastructure_ssid_val, nl_nested_itr.get_data(), disc_attr->infrastructure_ssid_len);
 448                         break;
 449                     }
 450                 }
 451                 break;
 452             case NAN_EVT_ATTR_MATCH_NUM_CHANS:
 453                 ind.num_chans = nl_itr.get_u8();
 454                 break;
 455             case NAN_EVT_ATTR_MATCH_FAMCHAN:
 456                 NanFurtherAvailabilityChannel *famchan;
 457                 famchan = &ind.famchan[famchan_idx];
 458                 famchan_idx++;
 459                 for(nl_iterator nl_nested_itr((struct nlattr *)nl_itr.get_data()); nl_nested_itr.has_next(); nl_nested_itr.next()) {
 460                     switch(nl_nested_itr.get_type()) {
 461                     case NAN_EVT_ATTR_MATCH_FAM_ENTRY_CONTROL:
 462                         famchan->entry_control = (NanAvailDuration)nl_nested_itr.get_u8();
 463                         break;
 464                     case NAN_EVT_ATTR_MATCH_FAM_CLASS_VAL:
 465                         famchan->class_val = nl_nested_itr.get_u8();
 466                         break;
 467                     case NAN_EVT_ATTR_MATCH_FAM_CHANNEL:
 468                         famchan->channel = nl_nested_itr.get_u8();
 469                         break;
 470                     case NAN_EVT_ATTR_MATCH_FAM_MAPID:
 471                         famchan->mapid = nl_nested_itr.get_u8();
 472                         break;
 473                     case NAN_EVT_ATTR_MATCH_FAM_AVAIL_INTERVAL_BITMAP:
 474                         famchan->avail_interval_bitmap = nl_nested_itr.get_u32();
 475                         break;
 476                     }
 477                 }
 478             case NAN_EVT_ATTR_MATCH_CLUSTER_ATTRIBUTE_LEN:
 479                 ind.cluster_attribute_len = nl_itr.get_u8();
 480                 break;
 481             case NAN_EVT_ATTR_MATCH_CLUSTER_ATTRIBUTE:
 482                 memcpy(ind.cluster_attribute, nl_itr.get_data(), ind.cluster_attribute_len);
 483                 break;
 484             }
 485         }
 486
 487         if (this->callbackEventHandler.EventMatch)
 488             this->callbackEventHandler.EventMatch(&ind);
 489         return NL_OK;
 490     }
 491
 492     int processMatchExpiredEvent(WifiEvent &event) {
 493         NanMatchExpiredInd ind;
 494         memset(&ind,0,sizeof(NanMatchExpiredInd));
 495
 496         for(nl_iterator nl_itr((struct nlattr *)event.get_vendor_data()); nl_itr.has_next(); nl_itr.next()) {
 497             switch(nl_itr.get_type()) {
 498             case NAN_EVT_ATTR_MATCH_PUBLISH_SUBSCRIBE_ID:
 499                 ind.publish_subscribe_id = nl_itr.get_u16();
 500                 break;
 501             case NAN_EVT_ATTR_MATCH_REQUESTOR_INSTANCE_ID:
 502                 ind.requestor_instance_id = nl_itr.get_u32();
 503                 break;
 504             default :
 505                 ALOGE("processMatchExpiredEvent: unknown attribute(%d)", nl_itr.get_type());
 506                 return NL_SKIP;
 507             }
 508         }
 509
 510         if (callbackEventHandler.EventMatchExpired)
 511             callbackEventHandler.EventMatchExpired(&ind);
 512
 513         return NL_OK;
 514     }
 515
 516     int processPublishTerminatedEvent(WifiEvent &event) {
 517         NanPublishTerminatedInd ind;
 518         memset(&ind,0,sizeof(ind));
 519
 520         for(nl_iterator nl_itr((struct nlattr *)event.get_vendor_data()); nl_itr.has_next(); nl_itr.next()) {
 521             switch(nl_itr.get_type()) {
 522             case NAN_EVT_ATTR_PUBLISH_ID:
 523                 ind.publish_id = nl_itr.get_u16();
 524                 break;
 525             case NAN_EVT_ATTR_PUBLISH_REASON:
 526                 ind.reason = (NanStatusType)nl_itr.get_u32();
 527                 break;
 528             default :
 529                 ALOGE("processPublishTerminatedEvent: unknown attribute(%d)", nl_itr.get_type());
 530                 return NL_SKIP;
 531             }
 532         }
 533
 534         if (callbackEventHandler.EventPublishTerminated)
 535             callbackEventHandler.EventPublishTerminated(&ind);
 536
 537         return NL_OK;
 538
 539     }
 540
 541     int processSubscribeTerminatedEvent(WifiEvent &event) {
 542         NanSubscribeTerminatedInd ind;
 543         memset(&ind,0,sizeof(ind));
 544
 545         for(nl_iterator nl_itr((struct nlattr *)event.get_vendor_data()); nl_itr.has_next(); nl_itr.next()) {
 546             switch(nl_itr.get_type()) {
 547             case NAN_EVT_ATTR_SUBSCRIBE_ID:
 548                 ind.subscribe_id = nl_itr.get_u16();
 549                 break;
 550             case NAN_EVT_ATTR_SUBSCRIBE_REASON:
 551                 ind.reason = (NanStatusType)nl_itr.get_u32();
 552                 break;
 553             default :
 554                 ALOGE("processSubscribeTerminatedEvent: unknown attribute(%d)", nl_itr.get_type());
 555                 return NL_SKIP;
 556             }
 557         }
 558
 559         if (callbackEventHandler.EventSubscribeTerminated)
 560             callbackEventHandler.EventSubscribeTerminated(&ind);
 561
 562         return NL_OK;
 563     }
 564
 565     int processFollowupEvent(WifiEvent &event) {
 566         NanFollowupInd ind;
 567         memset(&ind,0,sizeof(ind));
 568
 569         for(nl_iterator nl_itr((struct nlattr *)event.get_vendor_data()); nl_itr.has_next(); nl_itr.next()) {
 570             switch(nl_itr.get_type()) {
 571             case NAN_EVT_ATTR_FOLLOWUP_PUBLISH_SUBSCRIBE_ID:
 572                 ind.publish_subscribe_id = nl_itr.get_u16();
 573                 break;
 574             case NAN_EVT_ATTR_FOLLOWUP_REQUESTOR_INSTANCE_ID:
 575                 ind.requestor_instance_id = nl_itr.get_u32();
 576                 break;
 577             case NAN_EVT_ATTR_FOLLOWUP_ADDR:
 578                 memcpy(ind.addr, nl_itr.get_data(), NAN_MAC_ADDR_LEN);
 579                 break;
 580             case NAN_EVT_ATTR_FOLLOWUP_DW_OR_FAW:
 581                 ind.dw_or_faw = nl_itr.get_u8();
 582                 break;
 583             case NAN_EVT_ATTR_FOLLOWUP_SERVICE_SPECIFIC_INFO_LEN:
 584                 ind.service_specific_info_len = nl_itr.get_u16();
 585                 break;
 586             case NAN_EVT_ATTR_FOLLOWUP_SERVICE_SPECIFIC_INFO:
 587                 memcpy(ind.service_specific_info, nl_itr.get_data(), ind.service_specific_info_len);
 588                 break;
 589             default :
 590                 ALOGE("processNanDisabledEvent: unknown attribute(%d)", nl_itr.get_type());
 591                 return NL_SKIP;
 592             }
 593         }
 594
 595         if (callbackEventHandler.EventFollowup)
 596             callbackEventHandler.EventFollowup(&ind);
 597
 598         return NL_OK;
 599     }
 600
 601     int processNanDisabledEvent(WifiEvent &event) {
 602         NanDisabledInd ind;
 603         memset(&ind,0,sizeof(ind));
 604
 605         for(nl_iterator nl_itr((struct nlattr *)event.get_vendor_data()); nl_itr.has_next(); nl_itr.next()) {
 606             switch(nl_itr.get_type()) {
 607             case NAN_EVT_ATTR_DISABLED_REASON:
 608                 ind.reason = (NanStatusType)nl_itr.get_u32();
 609                 break;
 610             default :
 611                 ALOGE("processNanDisabledEvent: unknown attribute(%d)", nl_itr.get_type());
 612                 return NL_SKIP;
 613             }
 614         }
 615
 616         if (callbackEventHandler.EventDisabled)
 617             callbackEventHandler.EventDisabled(&ind);
 618
 619         return NL_OK;
 620     }
 621
 622     int processNanDiscoveryEvent(WifiEvent &event) {
 623         NanDiscEngEventInd ind;
 624         memset(&ind,0,sizeof(ind));
 625         u8 *addr = NULL;
 626
 627         for(nl_iterator nl_itr((struct nlattr *)event.get_vendor_data()); nl_itr.has_next(); nl_itr.next()) {
 628             switch(nl_itr.get_type()) {
 629             case NAN_EVT_ATTR_DISCOVERY_ENGINE_EVT_TYPE:
 630                 ind.event_type = (NanDiscEngEventType)nl_itr.get_u16();
 631                 break;
 632             case NAN_EVT_ATTR_DISCOVERY_ENGINE_MAC_ADDR:
 633                 addr = (u8 *)nl_itr.get_data();
 634                 break;
 635             default :
 636                 ALOGE("processNanDiscoveryEvent: unknown attribute(%d)", nl_itr.get_type());
 637                 return NL_SKIP;
 638             }
 639         }
 640         if (addr) {
 641             if (ind.event_type == NAN_EVENT_ID_DISC_MAC_ADDR)
 642                 memcpy(ind.data.mac_addr.addr, addr, NAN_MAC_ADDR_LEN);
 643             else
 644                 memcpy(ind.data.cluster.addr, addr, NAN_MAC_ADDR_LEN);
 645         } else {
 646             ALOGE("processNanDiscoveryEvent: No Mac/cluster Address");
 647         }
 648
 649         if (callbackEventHandler.EventDiscEngEvent)
 650             callbackEventHandler.EventDiscEngEvent(&ind);
 651
 652         return NL_OK;
 653     }
 654
 655 public:
 656     NanCommand(wifi_interface_handle iface, int id)
 657         : WifiCommand(iface, id)
 658     {
 659         subscribeID[0] = 0;
 660         subscribeID[1] = 0;
 661         publishID[0] = 0;
 662         publishID[1] = 0;
 663         followupID[0] = 0;
 664         followupID[0] = 0;
 665         version = 0;
 666         memset(&capabilities, 0, sizeof(capabilities));
 667     }
 668
 669     int enable(NanEnableRequest *msg) {
 670         ALOGD("Start NAN...");
 671         WifiRequest request(familyId(), ifaceId());
 672
 673         int result = request.create(GOOGLE_OUI, SLSI_NL80211_VENDOR_SUBCMD_NAN_ENABLE);
 674         CHECK_WIFI_STATUS_RETURN_FAIL(result, "enable:Failed to create WifiRequest");
 675
 676         nlattr *data = request.attr_start(NL80211_ATTR_VENDOR_DATA);
 677         if (!data) {
 678             ALOGE("enable: request.attr_start fail");
 679             return WIFI_ERROR_OUT_OF_MEMORY;
 680         }
 681         result = request.put_u8(NAN_REQ_ATTR_MASTER_PREF, msg->master_pref);
 682         CHECK_WIFI_STATUS_RETURN_FAIL(result, "enable:Failed to put master_pref");
 683
 684         result = request.put_u16(NAN_REQ_ATTR_CLUSTER_LOW, msg->cluster_low);
 685         CHECK_WIFI_STATUS_RETURN_FAIL(result, "enable:Failed to put cluster_low");
 686
 687         result = request.put_u16(NAN_REQ_ATTR_CLUSTER_HIGH, msg->cluster_high);
 688         CHECK_WIFI_STATUS_RETURN_FAIL(result, "enable:Failed to put cluster_high");
 689
 690         CHECK_CONFIG_PUT_8_RETURN_FAIL(msg->config_support_5g, msg->support_5g_val,
 691                     NAN_REQ_ATTR_SUPPORT_5G_VAL, request, result, "enable:Failed to put support_5g_val");
 692
 693         CHECK_CONFIG_PUT_8_RETURN_FAIL(msg->config_sid_beacon, msg->sid_beacon_val,
 694                     NAN_REQ_ATTR_SID_BEACON_VAL, request, result, "enable:Failed to put sid_beacon_val");
 695
 696         CHECK_CONFIG_PUT_8_RETURN_FAIL(msg->config_2dot4g_rssi_close, msg->rssi_close_2dot4g_val,
 697                     NAN_REQ_ATTR_RSSI_CLOSE_2G4_VAL, request, result, "enable:Failed to put rssi_close_2dot4g_val");
 698
 699         CHECK_CONFIG_PUT_8_RETURN_FAIL(msg->config_2dot4g_rssi_middle, msg->rssi_middle_2dot4g_val,
 700                     NAN_REQ_ATTR_RSSI_MIDDLE_2G4_VAL, request, result, "enable:Failed to put rssi_middle_2dot4g_val");
 701
 702         CHECK_CONFIG_PUT_8_RETURN_FAIL(msg->config_2dot4g_rssi_proximity, msg->rssi_proximity_2dot4g_val,
 703                     NAN_REQ_ATTR_RSSI_PROXIMITY_2G4_VAL, request, result, "enable:Failed to put rssi_proximity_2dot4g_val");
 704
 705         CHECK_CONFIG_PUT_8_RETURN_FAIL(msg->config_hop_count_limit, msg->hop_count_limit_val,
 706                     NAN_REQ_ATTR_HOP_COUNT_LIMIT_VAL, request, result, "enable:Failed to put hop_count_limit_val");
 707
 708         CHECK_CONFIG_PUT_8_RETURN_FAIL(msg->config_2dot4g_support, msg->support_2dot4g_val,
 709                     NAN_REQ_ATTR_SUPPORT_2G4_VAL, request, result, "enable:Failed to put support_2dot4g_val");
 710
 711         CHECK_CONFIG_PUT_8_RETURN_FAIL(msg->config_2dot4g_beacons, msg->beacon_2dot4g_val,
 712                     NAN_REQ_ATTR_BEACONS_2G4_VAL, request, result, "enable:Failed to put beacon_2dot4g_val");
 713
 714         CHECK_CONFIG_PUT_8_RETURN_FAIL(msg->config_2dot4g_sdf, msg->sdf_2dot4g_val,
 715                     NAN_REQ_ATTR_SDF_2G4_VAL, request, result, "enable:Failed to put sdf_2dot4g_val");
 716
 717         CHECK_CONFIG_PUT_8_RETURN_FAIL(msg->config_5g_beacons, msg->beacon_5g_val,
 718                     NAN_REQ_ATTR_BEACON_5G_VAL, request, result, "enable:Failed to put beacon_5g_val");
 719
 720         CHECK_CONFIG_PUT_8_RETURN_FAIL(msg->config_5g_sdf, msg->sdf_5g_val,
 721                     NAN_REQ_ATTR_SDF_5G_VAL, request, result, "enable:Failed to put sdf_5g_val");
 722
 723         CHECK_CONFIG_PUT_8_RETURN_FAIL(msg->config_5g_rssi_close, msg->rssi_close_5g_val,
 724                     NAN_REQ_ATTR_RSSI_CLOSE_5G_VAL, request, result, "enable:Failed to put rssi_close_5g_val");
 725
 726         CHECK_CONFIG_PUT_8_RETURN_FAIL(msg->config_5g_rssi_middle, msg->rssi_middle_5g_val,
 727                     NAN_REQ_ATTR_RSSI_MIDDLE_5G_VAL, request, result, "enable:Failed to put rssi_middle_5g_val");
 728
 729         CHECK_CONFIG_PUT_8_RETURN_FAIL(msg->config_5g_rssi_close_proximity, msg->rssi_close_proximity_5g_val,
 730                     NAN_REQ_ATTR_RSSI_CLOSE_PROXIMITY_5G_VAL, request, result, "enable:Failed to put rssi_close_proximity_5g_val");
 731
 732         CHECK_CONFIG_PUT_8_RETURN_FAIL(msg->config_rssi_window_size, msg->rssi_window_size_val,
 733                     NAN_REQ_ATTR_RSSI_WINDOW_SIZE_VAL, request, result, "enable:Failed to put rssi_window_size_val");
 734
 735         CHECK_CONFIG_PUT_32_RETURN_FAIL(msg->config_oui, msg->oui_val,
 736                     NAN_REQ_ATTR_OUI_VAL, request, result, "enable:Failed to put oui_val");
 737
 738         CHECK_CONFIG_PUT_RETURN_FAIL(msg->config_intf_addr, msg->intf_addr_val, NAN_MAC_ADDR_LEN,
 739                     NAN_REQ_ATTR_MAC_ADDR_VAL, request, result, "enable:Failed to put intf_addr_val");
 740
 741         CHECK_CONFIG_PUT_8_RETURN_FAIL(1, msg->config_cluster_attribute_val,
 742                     NAN_REQ_ATTR_CLUSTER_VAL, request, result, "enable:Failed to put config_cluster_attribute_val");
 743
 744         CHECK_CONFIG_PUT_RETURN_FAIL(msg->config_scan_params, msg->scan_params_val.dwell_time, sizeof(msg->scan_params_val.dwell_time),
 745                     NAN_REQ_ATTR_SOCIAL_CH_SCAN_DWELL_TIME, request, result, "enable:Failed to put scan_params_val.dwell_time");
 746
 747         CHECK_CONFIG_PUT_RETURN_FAIL(msg->config_scan_params, msg->scan_params_val.scan_period, sizeof(msg->scan_params_val.scan_period),
 748                     NAN_REQ_ATTR_SOCIAL_CH_SCAN_PERIOD, request, result, "enable:Failed to put scan_params_val.scan_period");
 749
 750         CHECK_CONFIG_PUT_8_RETURN_FAIL(msg->config_random_factor_force, msg->random_factor_force_val,
 751                     NAN_REQ_ATTR_RANDOM_FACTOR_FORCE_VAL, request, result, "enable:Failed to put random_factor_force_val");
 752
 753         CHECK_CONFIG_PUT_8_RETURN_FAIL(msg->config_hop_count_force, msg->hop_count_force_val,
 754                     NAN_REQ_ATTR_HOP_COUNT_FORCE_VAL, request, result, "enable:Failed to put hop_count_force_val");
 755
 756         CHECK_CONFIG_PUT_32_RETURN_FAIL(msg->config_24g_channel, msg->channel_24g_val,
 757                     NAN_REQ_ATTR_CHANNEL_2G4_MHZ_VAL, request, result, "enable:Failed to put channel_24g_val");
 758
 759         CHECK_CONFIG_PUT_32_RETURN_FAIL(msg->config_5g_channel, msg->channel_5g_val,
 760                     NAN_REQ_ATTR_CHANNEL_5G_MHZ_VAL, request, result, "enable:Failed to put channel_5g_val");
 761
 762         request.attr_end(data);
 763
 764         registerNanEvents();
 765
 766         result = requestResponse(request);
 767         if (result != WIFI_SUCCESS) {
 768             ALOGE("failed to NAN; result = %d", result);
 769             unregisterNanEvents();
 770         } else {
 771             ALOGD("Start NAN...success");
 772         }
 773         return result;
 774     }
 775
 776     int disable()
 777     {
 778         ALOGD("Stop NAN...");
 779         WifiRequest request(familyId(), ifaceId());
 780
 781         unregisterNanEvents();
 782
 783         int result = request.create(GOOGLE_OUI, SLSI_NL80211_VENDOR_SUBCMD_NAN_DISABLE);
 784         CHECK_WIFI_STATUS_RETURN_FAIL(result, "disable:Failed to create WifiRequest");
 785         result = requestResponse(request);
 786         CHECK_WIFI_STATUS_RETURN_FAIL(result, "disable:Failed to requestResponse");
 787         return result;
 788     }
 789
 790     int config(NanConfigRequest *msg) {
 791         ALOGD("config...");
 792         WifiRequest request(familyId(), ifaceId());
 793
 794         int result = request.create(GOOGLE_OUI, SLSI_NL80211_VENDOR_SUBCMD_NAN_CONFIG);
 795         CHECK_WIFI_STATUS_RETURN_FAIL(result, "config:Failed to create WifiRequest");
 796
 797         nlattr *data = request.attr_start(NL80211_ATTR_VENDOR_DATA);
 798         if (!data) {
 799             ALOGE("config: request.attr_start fail");
 800             return WIFI_ERROR_OUT_OF_MEMORY;
 801         }
 802
 803         CHECK_CONFIG_PUT_8_RETURN_FAIL(msg->config_sid_beacon, msg->sid_beacon,
 804                     NAN_REQ_ATTR_SID_BEACON_VAL, request, result, "config:Failed to put sid_beacon");
 805
 806         CHECK_CONFIG_PUT_8_RETURN_FAIL(msg->config_rssi_proximity, msg->rssi_proximity,
 807                     NAN_REQ_ATTR_RSSI_PROXIMITY_2G4_VAL, request, result, "config:Failed to put rssi_proximity");
 808
 809         CHECK_CONFIG_PUT_8_RETURN_FAIL(msg->config_master_pref, msg->master_pref,
 810                     NAN_REQ_ATTR_MASTER_PREF, request, result, "config:Failed to put master_pref");
 811
 812         CHECK_CONFIG_PUT_8_RETURN_FAIL(msg->config_5g_rssi_close_proximity, msg->rssi_close_proximity_5g_val,
 813                     NAN_REQ_ATTR_RSSI_CLOSE_PROXIMITY_5G_VAL, request, result, "config:Failed to put rssi_close_proximity_5g_val");
 814
 815         CHECK_CONFIG_PUT_8_RETURN_FAIL(msg->config_rssi_window_size, msg->rssi_window_size_val,
 816                     NAN_REQ_ATTR_RSSI_WINDOW_SIZE_VAL, request, result, "config:Failed to put rssi_window_size_val");
 817
 818         CHECK_CONFIG_PUT_8_RETURN_FAIL(1, msg->config_cluster_attribute_val,
 819                     NAN_REQ_ATTR_CLUSTER_VAL, request, result, "config:Failed to put config_cluster_attribute_val");
 820
 821         CHECK_CONFIG_PUT_RETURN_FAIL(msg->config_scan_params, msg->scan_params_val.dwell_time, sizeof(msg->scan_params_val.dwell_time),
 822                     NAN_REQ_ATTR_SOCIAL_CH_SCAN_DWELL_TIME, request, result, "config:Failed to put scan_params_val.dwell_time");
 823
 824         CHECK_CONFIG_PUT_RETURN_FAIL(msg->config_scan_params, msg->scan_params_val.scan_period, sizeof(msg->scan_params_val.scan_period),
 825                     NAN_REQ_ATTR_SOCIAL_CH_SCAN_PERIOD, request, result, "config:Failed to put scan_params_val.scan_period");
 826
 827         CHECK_CONFIG_PUT_8_RETURN_FAIL(msg->config_random_factor_force, msg->random_factor_force_val,
 828                     NAN_REQ_ATTR_RANDOM_FACTOR_FORCE_VAL, request, result, "config:Failed to put random_factor_force_val");
 829
 830         CHECK_CONFIG_PUT_8_RETURN_FAIL(msg->config_hop_count_force, msg->hop_count_force_val,
 831                     NAN_REQ_ATTR_HOP_COUNT_FORCE_VAL, request, result, "config:Failed to put hop_count_force_val");
 832
 833         CHECK_CONFIG_PUT_8_RETURN_FAIL(msg->config_conn_capability, msg->conn_capability_val.payload_transmit_flag,
 834                     NAN_REQ_ATTR_CONN_CAPABILITY_PAYLOAD_TX, request, result, "config:Failed to put payload_transmit_flag");
 835
 836         CHECK_CONFIG_PUT_8_RETURN_FAIL(msg->config_conn_capability, msg->conn_capability_val.is_wfd_supported,
 837                     NAN_REQ_ATTR_CONN_CAPABILITY_WFD, request, result, "config:Failed to put is_wfd_supported");
 838
 839         CHECK_CONFIG_PUT_8_RETURN_FAIL(msg->config_conn_capability, msg->conn_capability_val.is_wfds_supported,
 840                     NAN_REQ_ATTR_CONN_CAPABILITY_WFDS, request, result, "config:Failed to put is_wfds_supported");
 841
 842         CHECK_CONFIG_PUT_8_RETURN_FAIL(msg->config_conn_capability, msg->conn_capability_val.is_tdls_supported,
 843                     NAN_REQ_ATTR_CONN_CAPABILITY_TDLS, request, result, "config:Failed to put is_tdls_supported");
 844
 845         CHECK_CONFIG_PUT_8_RETURN_FAIL(msg->config_conn_capability, msg->conn_capability_val.is_ibss_supported,
 846                     NAN_REQ_ATTR_CONN_CAPABILITY_IBSS, request, result, "config:Failed to put is_ibss_supported");
 847
 848         CHECK_CONFIG_PUT_8_RETURN_FAIL(msg->config_conn_capability, msg->conn_capability_val.is_mesh_supported,
 849                     NAN_REQ_ATTR_CONN_CAPABILITY_MESH, request, result, "config:Failed to put is_mesh_supported");
 850
 851         CHECK_CONFIG_PUT_8_RETURN_FAIL(msg->config_conn_capability, msg->conn_capability_val.wlan_infra_field,
 852                     NAN_REQ_ATTR_CONN_CAPABILITY_WLAN_INFRA, request, result, "config:Failed to put wlan_infra_field");
 853
 854         if (msg->num_config_discovery_attr) {
 855             CHECK_CONFIG_PUT_8_RETURN_FAIL(1, msg->num_config_discovery_attr,
 856                         NAN_REQ_ATTR_DISCOVERY_ATTR_NUM_ENTRIES, request, result, "config:Failed to put msg->num_config_discovery_attr");
 857             for (int i = 0; i < msg->num_config_discovery_attr; i++) {
 858                 nlattr *nl_disc_attribute = request.attr_start(NAN_REQ_ATTR_DISCOVERY_ATTR_VAL);
 859                 NanTransmitPostDiscovery *discovery_attr = &msg->discovery_attr_val[i];
 860                 CHECK_CONFIG_PUT_8_RETURN_FAIL(1, discovery_attr->type,
 861                     NAN_REQ_ATTR_CONN_TYPE, request, result, "config:Failed to put discovery_attr->type");
 862                 CHECK_CONFIG_PUT_8_RETURN_FAIL(1, discovery_attr->role,
 863                     NAN_REQ_ATTR_NAN_ROLE, request, result, "config:Failed to put discovery_attr->role");
 864                 CHECK_CONFIG_PUT_8_RETURN_FAIL(1, discovery_attr->transmit_freq,
 865                     NAN_REQ_ATTR_TRANSMIT_FREQ, request, result, "config:Failed to put discovery_attr->transmit_freq");
 866                 CHECK_CONFIG_PUT_8_RETURN_FAIL(1, discovery_attr->duration,
 867                     NAN_REQ_ATTR_AVAILABILITY_DURATION, request, result, "config:Failed to put discovery_attr->duration");
 868                 CHECK_CONFIG_PUT_32_RETURN_FAIL(1, discovery_attr->avail_interval_bitmap,
 869                     NAN_REQ_ATTR_AVAILABILITY_INTERVAL, request, result, "config:Failed to put discovery_attr->avail_interval_bitmap");
 870                 CHECK_CONFIG_PUT_RETURN_FAIL(1, discovery_attr->addr, NAN_MAC_ADDR_LEN,
 871                     NAN_REQ_ATTR_MAC_ADDR_VAL, request, result, "config:Failed to put discovery_attr->addr");
 872                 CHECK_CONFIG_PUT_16_RETURN_FAIL(1, discovery_attr->mesh_id_len,
 873                     NAN_REQ_ATTR_MESH_ID_LEN, request, result, "config:Failed to put discovery_attr->mesh_id");
 874                 CHECK_CONFIG_PUT_RETURN_FAIL(discovery_attr->mesh_id_len, discovery_attr->mesh_id, discovery_attr->mesh_id_len,
 875                     NAN_REQ_ATTR_MESH_ID, request, result, "config:Failed to put discovery_attr->mesh_id");
 876                 CHECK_CONFIG_PUT_16_RETURN_FAIL(1, discovery_attr->infrastructure_ssid_len,
 877                     NAN_REQ_ATTR_INFRASTRUCTURE_SSID_LEN, request, result, "config:Failed to put discovery_attr->infrastructure_ssid_val");
 878                 CHECK_CONFIG_PUT_RETURN_FAIL(discovery_attr->infrastructure_ssid_len, discovery_attr->infrastructure_ssid_val, discovery_attr->infrastructure_ssid_len,
 879                     NAN_REQ_ATTR_INFRASTRUCTURE_SSID, request, result, "config:Failed to put discovery_attr->infrastructure_ssid_val");
 880                 request.attr_end(nl_disc_attribute);
 881             }
 882         }
 883
 884         if (msg->config_fam) {
 885             CHECK_CONFIG_PUT_8_RETURN_FAIL(1, msg->fam_val.numchans,
 886                         NAN_REQ_ATTR_FURTHER_AVAIL_NUM_ENTRIES, request, result, "config:Failed to put msg->fam_val.numchans");
 887             for (int i = 0; i < msg->fam_val.numchans; i++) {
 888                 nlattr *nl_fam_attribute = request.attr_start(NAN_REQ_ATTR_FURTHER_AVAIL_VAL);
 889                 NanFurtherAvailabilityChannel *further_avail_chan = &msg->fam_val.famchan[i];
 890                 CHECK_CONFIG_PUT_8_RETURN_FAIL(1, further_avail_chan->entry_control,
 891                             NAN_REQ_ATTR_FURTHER_AVAIL_ENTRY_CTRL, request, result, "config:Failed to put further_avail_chan->entry_control");
 892                 CHECK_CONFIG_PUT_8_RETURN_FAIL(1, further_avail_chan->class_val,
 893                             NAN_REQ_ATTR_FURTHER_AVAIL_CHAN_CLASS, request, result, "config:Failed to put further_avail_chan->class_val");
 894                 CHECK_CONFIG_PUT_8_RETURN_FAIL(1, further_avail_chan->channel,
 895                             NAN_REQ_ATTR_FURTHER_AVAIL_CHAN, request, result, "config:Failed to put further_avail_chan->channel");
 896                 CHECK_CONFIG_PUT_8_RETURN_FAIL(1, further_avail_chan->mapid,
 897                             NAN_REQ_ATTR_FURTHER_AVAIL_CHAN_MAPID, request, result, "config:Failed to put further_avail_chan->mapid");
 898                 CHECK_CONFIG_PUT_32_RETURN_FAIL(1, further_avail_chan->avail_interval_bitmap,
 899                             NAN_REQ_ATTR_FURTHER_AVAIL_INTERVAL_BITMAP, request, result, "config:Failed to put further_avail_chan->avail_interval_bitmap");
 900                 request.attr_end(nl_fam_attribute);
 901             }
 902         }
 903
 904         request.attr_end(data);
 905         result = requestResponse(request);
 906         if (result != WIFI_SUCCESS) {
 907             ALOGE("failed to set_config; result = %d", result);
 908         } else {
 909             ALOGD("config...success");
 910         }
 911         return result;
 912     }
 913
 914     static int setCallbackHandler(NanCallbackHandler handlers) {
 915         callbackEventHandler = handlers;
 916         return WIFI_SUCCESS;
 917     }
 918
 919     static int getVersion(NanVersion *version) {
 920         *version = SLSI_WIFI_HAL_NAN_VERSION;
 921         return WIFI_SUCCESS;
 922     }
 923
 924     int publish(NanPublishRequest *msg) {
 925         ALOGD("publish...");
 926         WifiRequest request(familyId(), ifaceId());
 927
 928         int result = request.create(GOOGLE_OUI, SLSI_NL80211_VENDOR_SUBCMD_NAN_PUBLISH);
 929         CHECK_WIFI_STATUS_RETURN_FAIL(result, "publish:Failed to create WifiRequest");
 930
 931         nlattr *data = request.attr_start(NL80211_ATTR_VENDOR_DATA);
 932         if (!data) {
 933             ALOGE("publish: request.attr_start fail");
 934             return WIFI_ERROR_OUT_OF_MEMORY;
 935         }
 936
 937         CHECK_CONFIG_PUT_16_RETURN_FAIL(msg->publish_id, msg->publish_id,
 938                 NAN_REQ_ATTR_PUBLISH_ID, request, result, "publish:Failed to put msg->publish_id");
 939
 940         CHECK_CONFIG_PUT_16_RETURN_FAIL(msg->ttl, msg->ttl,
 941                 NAN_REQ_ATTR_PUBLISH_TTL, request, result, "publish:Failed to put msg->ttl");
 942
 943         CHECK_CONFIG_PUT_16_RETURN_FAIL(1, msg->period,
 944                 NAN_REQ_ATTR_PUBLISH_PERIOD, request, result, "publish:Failed to put msg->period");
 945
 946         CHECK_CONFIG_PUT_8_RETURN_FAIL(1, msg->publish_type,
 947                 NAN_REQ_ATTR_PUBLISH_TYPE, request, result, "publish:Failed to put msg->publish_type");
 948
 949         CHECK_CONFIG_PUT_8_RETURN_FAIL(1, msg->tx_type,
 950                 NAN_REQ_ATTR_PUBLISH_TX_TYPE, request, result, "publish:Failed to put msg->tx_type");
 951
 952         CHECK_CONFIG_PUT_8_RETURN_FAIL(1, msg->publish_count,
 953                 NAN_REQ_ATTR_PUBLISH_COUNT, request, result, "publish:Failed to put msg->publish_count");
 954
 955         CHECK_CONFIG_PUT_16_RETURN_FAIL(msg->service_name_len, msg->service_name_len,
 956                 NAN_REQ_ATTR_PUBLISH_SERVICE_NAME_LEN, request, result, "publish:Failed to put msg->service_name_len");
 957
 958         CHECK_CONFIG_PUT_RETURN_FAIL(msg->service_name_len, msg->service_name, msg->service_name_len,
 959                 NAN_REQ_ATTR_PUBLISH_SERVICE_NAME, request, result, "publish:Failed to put msg->service_name");
 960
 961         CHECK_CONFIG_PUT_8_RETURN_FAIL(1, msg->publish_match_indicator,
 962                 NAN_REQ_ATTR_PUBLISH_MATCH_ALGO, request, result, "publish:Failed to put msg->publish_match_indicator");
 963
 964         CHECK_CONFIG_PUT_16_RETURN_FAIL(msg->service_specific_info_len, msg->service_specific_info_len,
 965                 NAN_REQ_ATTR_PUBLISH_SERVICE_INFO_LEN, request, result, "publish:Failed to put msg->service_specific_info_len");
 966
 967         CHECK_CONFIG_PUT_RETURN_FAIL(msg->service_specific_info_len, msg->service_specific_info, msg->service_specific_info_len,
 968                 NAN_REQ_ATTR_PUBLISH_SERVICE_INFO, request, result, "publish:Failed to put msg->service_specific_info");
 969
 970         CHECK_CONFIG_PUT_16_RETURN_FAIL(msg->rx_match_filter_len, msg->rx_match_filter_len,
 971                 NAN_REQ_ATTR_PUBLISH_RX_MATCH_FILTER_LEN, request, result, "publish:Failed to put msg->rx_match_filter_len");
 972
 973         CHECK_CONFIG_PUT_RETURN_FAIL(msg->rx_match_filter_len, msg->rx_match_filter, msg->rx_match_filter_len,
 974                 NAN_REQ_ATTR_PUBLISH_RX_MATCH_FILTER, request, result, "publish:Failed to put msg->rx_match_filter");
 975
 976         CHECK_CONFIG_PUT_16_RETURN_FAIL(msg->tx_match_filter_len, msg->tx_match_filter_len,
 977                 NAN_REQ_ATTR_PUBLISH_TX_MATCH_FILTER_LEN, request, result, "publish:Failed to put msg->tx_match_filter_len");
 978
 979         CHECK_CONFIG_PUT_RETURN_FAIL(msg->tx_match_filter_len, msg->tx_match_filter, msg->tx_match_filter_len,
 980                 NAN_REQ_ATTR_PUBLISH_TX_MATCH_FILTER, request, result, "publish:Failed to put msg->tx_match_filter");
 981
 982         CHECK_CONFIG_PUT_8_RETURN_FAIL(1, msg->rssi_threshold_flag,
 983                 NAN_REQ_ATTR_PUBLISH_RSSI_THRESHOLD_FLAG, request, result, "publish:Failed to put msg->rssi_threshold_flag");
 984
 985         CHECK_CONFIG_PUT_8_RETURN_FAIL(1, msg->connmap,
 986                 NAN_REQ_ATTR_PUBLISH_CONN_MAP, request, result, "publish:Failed to put msg->connmap");
 987
 988         CHECK_CONFIG_PUT_8_RETURN_FAIL(1, msg->recv_indication_cfg,
 989                 NAN_REQ_ATTR_PUBLISH_RECV_IND_CFG, request, result, "publish:Failed to put msg->recv_indication_cfg");
 990
 991         request.attr_end(data);
 992         result = requestResponse(request);
 993         if (result != WIFI_SUCCESS) {
 994             ALOGE("failed to publish; result = %d", result);
 995         } else {
 996             ALOGD("publish...success");
 997         }
 998         return result;
 999     }
1000
1001     int publishCancel(NanPublishCancelRequest *msg) {
1002         ALOGD("publishCancel...");
1003         WifiRequest request(familyId(), ifaceId());
1004
1005         int result = request.create(GOOGLE_OUI, SLSI_NL80211_VENDOR_SUBCMD_NAN_PUBLISHCANCEL);
1006         CHECK_WIFI_STATUS_RETURN_FAIL(result, "publishCancel:Failed to create WifiRequest");
1007
1008         nlattr *data = request.attr_start(NL80211_ATTR_VENDOR_DATA);
1009         if (!data) {
1010             ALOGE("publishCancel: request.attr_start fail");
1011             return WIFI_ERROR_OUT_OF_MEMORY;
1012         }
1013
1014         CHECK_CONFIG_PUT_16_RETURN_FAIL(1, msg->publish_id,
1015                 NAN_REQ_ATTR_PUBLISH_ID, request, result, "publishCancel:Failed to put msg->publish_id");
1016
1017         request.attr_end(data);
1018         result = requestResponse(request);
1019         if (result != WIFI_SUCCESS) {
1020             ALOGE("failed to publishCancel; result = %d", result);
1021         } else {
1022             ALOGD("publishCancel...success");
1023         }
1024         return result;
1025
1026     }
1027
1028     int subscribe(NanSubscribeRequest *msg) {
1029         ALOGD("subscribe...");
1030         WifiRequest request(familyId(), ifaceId());
1031
1032         int result = request.create(GOOGLE_OUI, SLSI_NL80211_VENDOR_SUBCMD_NAN_SUBSCRIBE);
1033         CHECK_WIFI_STATUS_RETURN_FAIL(result, "subscribe:Failed to create WifiRequest");
1034
1035         nlattr *data = request.attr_start(NL80211_ATTR_VENDOR_DATA);
1036         if (!data) {
1037             ALOGE("subscribe: request.attr_start fail");
1038             return WIFI_ERROR_OUT_OF_MEMORY;
1039         }
1040
1041         CHECK_CONFIG_PUT_16_RETURN_FAIL(msg->subscribe_id, msg->subscribe_id,
1042                 NAN_REQ_ATTR_SUBSCRIBE_ID, request, result, "subscribe:Failed to put msg->publish_id");
1043
1044         CHECK_CONFIG_PUT_16_RETURN_FAIL(1, msg->ttl,
1045                 NAN_REQ_ATTR_SUBSCRIBE_TTL, request, result, "subscribe:Failed to put msg->ttl");
1046
1047         CHECK_CONFIG_PUT_16_RETURN_FAIL(1, msg->period,
1048                 NAN_REQ_ATTR_SUBSCRIBE_PERIOD, request, result, "subscribe:Failed to put msg->period");
1049
1050         CHECK_CONFIG_PUT_8_RETURN_FAIL(1, msg->subscribe_type,
1051                 NAN_REQ_ATTR_SUBSCRIBE_TYPE, request, result, "subscribe:Failed to put msg->subscribe_type");
1052
1053         CHECK_CONFIG_PUT_8_RETURN_FAIL(1, msg->serviceResponseFilter,
1054                 NAN_REQ_ATTR_SUBSCRIBE_RESP_FILTER_TYPE, request, result, "subscribe:Failed to put msg->serviceResponseFilter");
1055
1056         CHECK_CONFIG_PUT_8_RETURN_FAIL(1, msg->serviceResponseInclude,
1057                 NAN_REQ_ATTR_SUBSCRIBE_RESP_INCLUDE, request, result, "subscribe:Failed to put msg->serviceResponseInclude");
1058
1059         CHECK_CONFIG_PUT_8_RETURN_FAIL(1, msg->useServiceResponseFilter,
1060                 NAN_REQ_ATTR_SUBSCRIBE_USE_RESP_FILTER, request, result, "subscribe:Failed to put msg->useServiceResponseFilter");
1061
1062         CHECK_CONFIG_PUT_8_RETURN_FAIL(1, msg->ssiRequiredForMatchIndication,
1063                 NAN_REQ_ATTR_SUBSCRIBE_SSI_REQUIRED, request, result, "subscribe:Failed to put msg->ssiRequiredForMatchIndication");
1064
1065         CHECK_CONFIG_PUT_8_RETURN_FAIL(1, msg->subscribe_match_indicator,
1066                 NAN_REQ_ATTR_SUBSCRIBE_MATCH_INDICATOR, request, result, "subscribe:Failed to put msg->subscribe_match_indicator");
1067
1068         CHECK_CONFIG_PUT_8_RETURN_FAIL(1, msg->subscribe_count,
1069                 NAN_REQ_ATTR_SUBSCRIBE_COUNT, request, result, "subscribe:Failed to put msg->subscribe_count");
1070
1071         CHECK_CONFIG_PUT_16_RETURN_FAIL(msg->service_name_len, msg->service_name_len,
1072                 NAN_REQ_ATTR_SUBSCRIBE_SERVICE_NAME_LEN, request, result, "subscribe:Failed to put msg->service_name_len");
1073
1074         CHECK_CONFIG_PUT_RETURN_FAIL(msg->service_name_len, msg->service_name, msg->service_name_len,
1075                 NAN_REQ_ATTR_SUBSCRIBE_SERVICE_NAME, request, result, "subscribe:Failed to put msg->service_name");
1076
1077         CHECK_CONFIG_PUT_16_RETURN_FAIL(msg->service_specific_info_len, msg->service_specific_info_len,
1078                 NAN_REQ_ATTR_SUBSCRIBE_SERVICE_INFO_LEN, request, result, "subscribe:Failed to put msg->service_specific_info_len");
1079
1080         CHECK_CONFIG_PUT_RETURN_FAIL(msg->service_specific_info_len, msg->service_specific_info, msg->service_specific_info_len,
1081                 NAN_REQ_ATTR_SUBSCRIBE_SERVICE_INFO, request, result, "subscribe:Failed to put msg->service_specific_info");
1082
1083         CHECK_CONFIG_PUT_16_RETURN_FAIL(msg->rx_match_filter_len, msg->rx_match_filter_len,
1084                 NAN_REQ_ATTR_SUBSCRIBE_RX_MATCH_FILTER_LEN, request, result, "subscribe:Failed to put msg->rx_match_filter_len");
1085
1086         CHECK_CONFIG_PUT_RETURN_FAIL(msg->rx_match_filter_len, msg->rx_match_filter, msg->rx_match_filter_len,
1087                 NAN_REQ_ATTR_SUBSCRIBE_RX_MATCH_FILTER, request, result, "subscribe:Failed to put msg->rx_match_filter");
1088
1089         CHECK_CONFIG_PUT_16_RETURN_FAIL(msg->tx_match_filter_len, msg->tx_match_filter_len,
1090                 NAN_REQ_ATTR_SUBSCRIBE_TX_MATCH_FILTER_LEN, request, result, "subscribe:Failed to put msg->tx_match_filter_len");
1091
1092         CHECK_CONFIG_PUT_RETURN_FAIL(msg->tx_match_filter_len, msg->tx_match_filter, msg->tx_match_filter_len,
1093                 NAN_REQ_ATTR_SUBSCRIBE_TX_MATCH_FILTER, request, result, "subscribe:Failed to put msg->tx_match_filter");
1094
1095         CHECK_CONFIG_PUT_8_RETURN_FAIL(1, msg->rssi_threshold_flag,
1096                 NAN_REQ_ATTR_SUBSCRIBE_RSSI_THRESHOLD_FLAG, request, result, "subscribe:Failed to put msg->rssi_threshold_flag");
1097
1098         CHECK_CONFIG_PUT_8_RETURN_FAIL(1, msg->connmap,
1099                 NAN_REQ_ATTR_SUBSCRIBE_CONN_MAP, request, result, "subscribe:Failed to put msg->connmap");
1100
1101         CHECK_CONFIG_PUT_8_RETURN_FAIL(msg->num_intf_addr_present, msg->num_intf_addr_present,
1102                 NAN_REQ_ATTR_SUBSCRIBE_NUM_INTF_ADDR_PRESENT, request, result, "subscribe:Failed to put msg->num_intf_addr_present");
1103
1104         CHECK_CONFIG_PUT_RETURN_FAIL(msg->num_intf_addr_present, msg->intf_addr, NAN_MAC_ADDR_LEN * msg->num_intf_addr_present,
1105                 NAN_REQ_ATTR_SUBSCRIBE_INTF_ADDR, request, result, "subscribe:Failed to put msg->intf_addr");
1106
1107         CHECK_CONFIG_PUT_8_RETURN_FAIL(1, msg->recv_indication_cfg,
1108                 NAN_REQ_ATTR_SUBSCRIBE_RECV_IND_CFG, request, result, "subscribe:Failed to put msg->recv_indication_cfg");
1109
1110         request.attr_end(data);
1111         result = requestResponse(request);
1112         if (result != WIFI_SUCCESS) {
1113             ALOGE("failed to subscribe; result = %d", result);
1114         } else {
1115             ALOGD("subscribe...success");
1116         }
1117         return result;
1118
1119     }
1120
1121     int subscribeCancel(NanSubscribeCancelRequest *msg) {
1122         ALOGD("subscribeCancel...");
1123         WifiRequest request(familyId(), ifaceId());
1124
1125         int result = request.create(GOOGLE_OUI, SLSI_NL80211_VENDOR_SUBCMD_NAN_SUBSCRIBECANCEL);
1126         CHECK_WIFI_STATUS_RETURN_FAIL(result, "subscribeCancel:Failed to create WifiRequest");
1127
1128         nlattr *data = request.attr_start(NL80211_ATTR_VENDOR_DATA);
1129         if (!data) {
1130             ALOGE("subscribeCancel: request.attr_start fail");
1131             return WIFI_ERROR_OUT_OF_MEMORY;
1132         }
1133
1134         CHECK_CONFIG_PUT_16_RETURN_FAIL(1, msg->subscribe_id,
1135                 NAN_REQ_ATTR_SUBSCRIBE_ID, request, result, "subscribeCancel:Failed to put msg->subscribe_id");
1136
1137         request.attr_end(data);
1138         result = requestResponse(request);
1139         if (result != WIFI_SUCCESS) {
1140             ALOGE("failed to subscribeCancel; result = %d", result);
1141         } else {
1142             ALOGD("subscribeCancel...success");
1143         }
1144         return result;
1145     }
1146
1147     int followup(NanTransmitFollowupRequest *msg) {
1148         ALOGD("followup...");
1149         WifiRequest request(familyId(), ifaceId());
1150
1151         int result = request.create(GOOGLE_OUI, SLSI_NL80211_VENDOR_SUBCMD_NAN_TXFOLLOWUP);
1152         CHECK_WIFI_STATUS_RETURN_FAIL(result, "followup:Failed to create WifiRequest");
1153
1154         nlattr *data = request.attr_start(NL80211_ATTR_VENDOR_DATA);
1155         if (!data) {
1156             ALOGE("followup: request.attr_start fail");
1157             return WIFI_ERROR_OUT_OF_MEMORY;
1158         }
1159
1160         CHECK_CONFIG_PUT_16_RETURN_FAIL(1, msg->publish_subscribe_id,
1161                 NAN_REQ_ATTR_FOLLOWUP_ID, request, result, "followup:Failed to put msg->publish_subscribe_id");
1162
1163         CHECK_CONFIG_PUT_32_RETURN_FAIL(1, msg->requestor_instance_id,
1164                 NAN_REQ_ATTR_FOLLOWUP_REQUESTOR_ID, request, result, "followup:Failed to put msg->requestor_instance_id");
1165
1166         CHECK_CONFIG_PUT_RETURN_FAIL(1, msg->addr, NAN_MAC_ADDR_LEN,
1167             NAN_REQ_ATTR_FOLLOWUP_ADDR, request, result, "followup:Failed to put msg->addr");
1168
1169         CHECK_CONFIG_PUT_8_RETURN_FAIL(1, msg->priority,
1170             NAN_REQ_ATTR_FOLLOWUP_PRIORITY, request, result, "followup:Failed to put msg->priority");
1171
1172         CHECK_CONFIG_PUT_8_RETURN_FAIL(1, msg->dw_or_faw,
1173             NAN_REQ_ATTR_FOLLOWUP_TX_WINDOW, request, result, "followup:Failed to put msg->dw_or_faw");
1174
1175         CHECK_CONFIG_PUT_16_RETURN_FAIL(msg->service_specific_info_len, msg->service_specific_info_len,
1176             NAN_REQ_ATTR_FOLLOWUP_SERVICE_NAME_LEN, request, result, "followup:Failed to put msg->service_specific_info_len");
1177
1178         CHECK_CONFIG_PUT_RETURN_FAIL(msg->service_specific_info_len, msg->service_specific_info, msg->service_specific_info_len,
1179             NAN_REQ_ATTR_FOLLOWUP_SERVICE_NAME, request, result, "followup:Failed to put msg->service_specific_info");
1180
1181         CHECK_CONFIG_PUT_8_RETURN_FAIL(1, msg->recv_indication_cfg,
1182             NAN_REQ_ATTR_FOLLOWUP_RECV_IND_CFG, request, result, "followup:Failed to put msg->recv_indication_cfg");
1183
1184         request.attr_end(data);
1185         result = requestResponse(request);
1186         if (result != WIFI_SUCCESS) {
1187             ALOGE("failed to followup; result = %d", result);
1188         } else {
1189             ALOGD("followup...success");
1190         }
1191         return result;
1192
1193     }
1194
1195     int getCapabilities(void) {
1196         ALOGD("getCapabilities...");
1197         WifiRequest request(familyId(), ifaceId());
1198
1199         int result = request.create(GOOGLE_OUI, SLSI_NL80211_VENDOR_SUBCMD_NAN_CAPABILITIES);
1200         CHECK_WIFI_STATUS_RETURN_FAIL(result, "getCapabilities:Failed to create WifiRequest");
1201
1202         result = requestResponse(request);
1203         if (result != WIFI_SUCCESS) {
1204             ALOGE("failed to getCapabilities; result = %d", result);
1205         } else {
1206             ALOGD("getCapabilities...success");
1207         }
1208         return result;
1209     }
1210
1211     int handleEvent(WifiEvent &event) {
1212         int ret;
1213         ALOGD("handleEvent...");
1214
1215         if (event.get_cmd() != NL80211_CMD_VENDOR) {
1216             ALOGD("Ignoring event with cmd = %d", event.get_cmd());
1217             return NL_SKIP;
1218         }
1219
1220         int id = event.get_vendor_id();
1221         int subcmd = event.get_vendor_subcmd();
1222
1223         ALOGI("Id = %0x, subcmd = %d", id, subcmd);
1224
1225         switch(subcmd) {
1226         case SLSI_NAN_EVENT_MATCH:
1227             ret = processMatchEvent(event);
1228             break;
1229         case SLSI_NAN_EVENT_MATCH_EXPIRED:
1230             ret = processMatchExpiredEvent(event);
1231             break;
1232         case SLSI_NAN_EVENT_PUBLISH_TERMINATED:
1233             ret = processPublishTerminatedEvent(event);
1234             break;
1235         case SLSI_NAN_EVENT_SUBSCRIBE_TERMINATED:
1236             ret = processSubscribeTerminatedEvent(event);
1237             break;
1238         case SLSI_NAN_EVENT_FOLLOWUP:
1239             ret = processFollowupEvent(event);
1240             break;
1241         case SLSI_NAN_EVENT_DISABLED:
1242             ret = processNanDisabledEvent(event);
1243             break;
1244         case SLSI_NAN_EVENT_DISCOVERY_ENGINE:
1245             ret = processNanDiscoveryEvent(event);
1246             break;
1247
1248         }
1249
1250         return NL_OK;
1251     }
1252
1253     int handleResponse(WifiEvent &reply) {
1254         ALOGD("handleResponse...");
1255
1256         if (reply.get_cmd() != NL80211_CMD_VENDOR) {
1257             ALOGD("Ignoring reply with cmd = %d", reply.get_cmd());
1258             return NL_SKIP;
1259         }
1260
1261         int vendorId = reply.get_vendor_id();
1262         int subcmd = reply.get_vendor_subcmd();
1263
1264         ALOGI("Id = %0x, subcmd = %d", vendorId, subcmd);
1265
1266         NanResponseMsg response;
1267         memset(&response, 0, sizeof(response));
1268
1269         if (processResponse(reply, &response) == NL_SKIP)
1270             return NL_SKIP;
1271
1272         if (callbackEventHandler.NotifyResponse)
1273             callbackEventHandler.NotifyResponse(id(), &response);
1274         return NL_OK;
1275     }
1276 };
1277
1278 NanCallbackHandler NanCommand::callbackEventHandler;
1279
1280 NanCommand *nan_get_object(transaction_id id,
1281                               wifi_interface_handle iface) {
1282     wifi_handle handle = getWifiHandle(iface);
1283     NanCommand *nanRequest = (NanCommand *)wifi_get_cmd(handle, id);
1284     if (!nanRequest) {
1285         nanRequest = new NanCommand(iface, id);
1286         if (!nanRequest){
1287             ALOGE("Could not alloc NanCommand");
1288             return NULL;
1289         }
1290     }
1291     return nanRequest;
1292 }
1293
1294 wifi_error nan_enable_request(transaction_id id,
1295                               wifi_interface_handle iface,
1296                               NanEnableRequest *msg) {
1297     wifi_handle handle = getWifiHandle(iface);
1298     wifi_error ret;
1299
1300     NanCommand *nanRequest = new NanCommand(iface, id);
1301     if (!nanRequest) {
1302         ALOGE("nan_enable_request:: Unable to create NanCommand");
1303         return WIFI_ERROR_OUT_OF_MEMORY;
1304     }
1305
1306     wifi_register_cmd(handle, id, nanRequest);
1307     ret = (wifi_error)nanRequest->enable(msg);
1308     if (ret != WIFI_SUCCESS) {
1309         wifi_unregister_cmd(handle, id);
1310         delete nanRequest;
1311     }
1312     return ret;
1313 }
1314
1315 /*  Disable NAN functionality. */
1316 wifi_error nan_disable_request(transaction_id id, wifi_interface_handle iface) {
1317     NanCommand *nanRequest = nan_get_object(id, iface);
1318     wifi_error ret;
1319
1320     if (!nanRequest) {
1321         return WIFI_ERROR_OUT_OF_MEMORY;
1322     }
1323     ret = (wifi_error)nanRequest->disable();
1324     delete nanRequest;
1325     return ret;
1326 }
1327
1328 /*  Publish request to advertize a service. */
1329 wifi_error nan_publish_request(transaction_id id,
1330                                wifi_interface_handle iface,
1331                                NanPublishRequest *msg) {
1332     NanCommand *nanRequest = nan_get_object(id, iface);
1333     if (!nanRequest) {
1334         return WIFI_ERROR_OUT_OF_MEMORY;
1335     }
1336     return (wifi_error)nanRequest->publish(msg);
1337 }
1338
1339 /*  Cancel previous publish requests. */
1340 wifi_error nan_publish_cancel_request(transaction_id id,
1341                                       wifi_interface_handle iface,
1342                                       NanPublishCancelRequest *msg) {
1343     NanCommand *nanRequest = nan_get_object(id, iface);
1344     if (!nanRequest) {
1345         return WIFI_ERROR_OUT_OF_MEMORY;
1346     }
1347     return (wifi_error)nanRequest->publishCancel(msg);
1348 }
1349
1350 /*  Subscribe request to search for a service. */
1351 wifi_error nan_subscribe_request(transaction_id id,
1352                                  wifi_interface_handle iface,
1353                                  NanSubscribeRequest *msg) {
1354     NanCommand *nanRequest = nan_get_object(id, iface);
1355     if (!nanRequest) {
1356         return WIFI_ERROR_OUT_OF_MEMORY;
1357     }
1358     return (wifi_error)nanRequest->subscribe(msg);
1359 }
1360
1361 /*  Cancel previous subscribe requests. */
1362 wifi_error nan_subscribe_cancel_request(transaction_id id,
1363                                         wifi_interface_handle iface,
1364                                         NanSubscribeCancelRequest *msg) {
1365     NanCommand *nanRequest = nan_get_object(id, iface);
1366     if (!nanRequest) {
1367         return WIFI_ERROR_OUT_OF_MEMORY;
1368     }
1369     return (wifi_error)nanRequest->subscribeCancel(msg);
1370 }
1371
1372 /*  NAN transmit follow up request. */
1373 wifi_error nan_transmit_followup_request(transaction_id id,
1374                                          wifi_interface_handle iface,
1375                                          NanTransmitFollowupRequest *msg) {
1376     NanCommand *nanRequest = nan_get_object(id, iface);
1377     if (!nanRequest) {
1378         return WIFI_ERROR_OUT_OF_MEMORY;
1379     }
1380     return (wifi_error)nanRequest->followup(msg);
1381 }
1382
1383 /* NAN configuration request. */
1384 wifi_error nan_config_request(transaction_id id,
1385                               wifi_interface_handle iface,
1386                               NanConfigRequest *msg) {
1387     NanCommand *nanRequest = nan_get_object(id, iface);
1388     if (!nanRequest) {
1389         return WIFI_ERROR_OUT_OF_MEMORY;
1390     }
1391     return (wifi_error)nanRequest->config(msg);
1392 }
1393
1394 /* Register NAN callbacks. */
1395 wifi_error nan_register_handler(wifi_interface_handle iface,
1396                                 NanCallbackHandler handlers) {
1397     return (wifi_error)NanCommand::setCallbackHandler(handlers);
1398 }
1399
1400 /*  Get NAN HAL version. */
1401 wifi_error nan_get_version(wifi_handle handle,
1402                            NanVersion *version) {
1403     return (wifi_error)NanCommand::getVersion(version);
1404 }
1405
1406 /*  Get NAN capabilities. */
1407 wifi_error nan_get_capabilities(transaction_id id,
1408                                 wifi_interface_handle iface) {
1409     NanCommand *nanRequest = nan_get_object(id, iface);
1410     if (!nanRequest) {
1411         return WIFI_ERROR_OUT_OF_MEMORY;
1412     }
1413     return (wifi_error)nanRequest->getCapabilities();
1414 }
1415