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