projects / GitHub / MotorolaMobilityLLC / hardware-samsung_slsi-scsc_wifibt-wifi_hal.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge KeystoneQ-ww-20190522
[GitHub/MotorolaMobilityLLC/hardware-samsung_slsi-scsc_wifibt-wifi_hal.git] / wifi_nan.cpp
CommitLineData
d3a587e8
JPS		 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
72typedef 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
183typedef 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
202typedef 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
261class 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);
d3a587e8
JPS		 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 }
45011ff7 478 break;
d3a587e8
JPS		 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 }
45011ff7 487
d3a587e8
JPS		 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));
cdcc8b21 626 u8 *addr = NULL;
d3a587e8
JPS		 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 }
cdcc8b21
JPS		 641 if (addr) {
642 if (ind.event_type == NAN_EVENT_ID_DISC_MAC_ADDR)
643 memcpy(ind.data.mac_addr.addr, addr, NAN_MAC_ADDR_LEN);
644 else
645 memcpy(ind.data.cluster.addr, addr, NAN_MAC_ADDR_LEN);
646 } else {
647 ALOGE("processNanDiscoveryEvent: No Mac/cluster Address");
648 }
d3a587e8
JPS		 649
650 if (callbackEventHandler.EventDiscEngEvent)
651 callbackEventHandler.EventDiscEngEvent(&ind);
652
653 return NL_OK;
654 }
655
656public:
657 NanCommand(wifi_interface_handle iface, int id)
658 : WifiCommand(iface, id)
659 {
660 subscribeID[0] = 0;
661 subscribeID[1] = 0;
662 publishID[0] = 0;
663 publishID[1] = 0;
664 followupID[0] = 0;
665 followupID[0] = 0;
666 version = 0;
667 memset(&capabilities, 0, sizeof(capabilities));
668 }
669
670 int enable(NanEnableRequest *msg) {
671 ALOGD("Start NAN...");
672 WifiRequest request(familyId(), ifaceId());
673
674 int result = request.create(GOOGLE_OUI, SLSI_NL80211_VENDOR_SUBCMD_NAN_ENABLE);
675 CHECK_WIFI_STATUS_RETURN_FAIL(result, "enable:Failed to create WifiRequest");
676
677 nlattr *data = request.attr_start(NL80211_ATTR_VENDOR_DATA);
678 if (!data) {
679 ALOGE("enable: request.attr_start fail");
680 return WIFI_ERROR_OUT_OF_MEMORY;
681 }
49e66671
JPS		 682 /* Valid master pref values are 2-254 */
683 int master_pref;
684 if (msg->master_pref < 2)
685 master_pref = 2;
686 else if (msg->master_pref > 254)
687 master_pref = 254;
688 else
689 master_pref = msg->master_pref;
690 result = request.put_u8(NAN_REQ_ATTR_MASTER_PREF, master_pref);
d3a587e8
JPS		 691 CHECK_WIFI_STATUS_RETURN_FAIL(result, "enable:Failed to put master_pref");
692
693 result = request.put_u16(NAN_REQ_ATTR_CLUSTER_LOW, msg->cluster_low);
694 CHECK_WIFI_STATUS_RETURN_FAIL(result, "enable:Failed to put cluster_low");
695
696 result = request.put_u16(NAN_REQ_ATTR_CLUSTER_HIGH, msg->cluster_high);
697 CHECK_WIFI_STATUS_RETURN_FAIL(result, "enable:Failed to put cluster_high");
698
699 CHECK_CONFIG_PUT_8_RETURN_FAIL(msg->config_support_5g, msg->support_5g_val,
700 NAN_REQ_ATTR_SUPPORT_5G_VAL, request, result, "enable:Failed to put support_5g_val");
701
702 CHECK_CONFIG_PUT_8_RETURN_FAIL(msg->config_sid_beacon, msg->sid_beacon_val,
703 NAN_REQ_ATTR_SID_BEACON_VAL, request, result, "enable:Failed to put sid_beacon_val");
704
705 CHECK_CONFIG_PUT_8_RETURN_FAIL(msg->config_2dot4g_rssi_close, msg->rssi_close_2dot4g_val,
706 NAN_REQ_ATTR_RSSI_CLOSE_2G4_VAL, request, result, "enable:Failed to put rssi_close_2dot4g_val");
707
708 CHECK_CONFIG_PUT_8_RETURN_FAIL(msg->config_2dot4g_rssi_middle, msg->rssi_middle_2dot4g_val,
709 NAN_REQ_ATTR_RSSI_MIDDLE_2G4_VAL, request, result, "enable:Failed to put rssi_middle_2dot4g_val");
710
711 CHECK_CONFIG_PUT_8_RETURN_FAIL(msg->config_2dot4g_rssi_proximity, msg->rssi_proximity_2dot4g_val,
712 NAN_REQ_ATTR_RSSI_PROXIMITY_2G4_VAL, request, result, "enable:Failed to put rssi_proximity_2dot4g_val");
713
714 CHECK_CONFIG_PUT_8_RETURN_FAIL(msg->config_hop_count_limit, msg->hop_count_limit_val,
715 NAN_REQ_ATTR_HOP_COUNT_LIMIT_VAL, request, result, "enable:Failed to put hop_count_limit_val");
716
717 CHECK_CONFIG_PUT_8_RETURN_FAIL(msg->config_2dot4g_support, msg->support_2dot4g_val,
718 NAN_REQ_ATTR_SUPPORT_2G4_VAL, request, result, "enable:Failed to put support_2dot4g_val");
719
720 CHECK_CONFIG_PUT_8_RETURN_FAIL(msg->config_2dot4g_beacons, msg->beacon_2dot4g_val,
721 NAN_REQ_ATTR_BEACONS_2G4_VAL, request, result, "enable:Failed to put beacon_2dot4g_val");
722
723 CHECK_CONFIG_PUT_8_RETURN_FAIL(msg->config_2dot4g_sdf, msg->sdf_2dot4g_val,
724 NAN_REQ_ATTR_SDF_2G4_VAL, request, result, "enable:Failed to put sdf_2dot4g_val");
725
726 CHECK_CONFIG_PUT_8_RETURN_FAIL(msg->config_5g_beacons, msg->beacon_5g_val,
727 NAN_REQ_ATTR_BEACON_5G_VAL, request, result, "enable:Failed to put beacon_5g_val");
728
729 CHECK_CONFIG_PUT_8_RETURN_FAIL(msg->config_5g_sdf, msg->sdf_5g_val,
730 NAN_REQ_ATTR_SDF_5G_VAL, request, result, "enable:Failed to put sdf_5g_val");
731
732 CHECK_CONFIG_PUT_8_RETURN_FAIL(msg->config_5g_rssi_close, msg->rssi_close_5g_val,
733 NAN_REQ_ATTR_RSSI_CLOSE_5G_VAL, request, result, "enable:Failed to put rssi_close_5g_val");
734
735 CHECK_CONFIG_PUT_8_RETURN_FAIL(msg->config_5g_rssi_middle, msg->rssi_middle_5g_val,
736 NAN_REQ_ATTR_RSSI_MIDDLE_5G_VAL, request, result, "enable:Failed to put rssi_middle_5g_val");
737
738 CHECK_CONFIG_PUT_8_RETURN_FAIL(msg->config_5g_rssi_close_proximity, msg->rssi_close_proximity_5g_val,
739 NAN_REQ_ATTR_RSSI_CLOSE_PROXIMITY_5G_VAL, request, result, "enable:Failed to put rssi_close_proximity_5g_val");
740
741 CHECK_CONFIG_PUT_8_RETURN_FAIL(msg->config_rssi_window_size, msg->rssi_window_size_val,
742 NAN_REQ_ATTR_RSSI_WINDOW_SIZE_VAL, request, result, "enable:Failed to put rssi_window_size_val");
743
744 CHECK_CONFIG_PUT_32_RETURN_FAIL(msg->config_oui, msg->oui_val,
745 NAN_REQ_ATTR_OUI_VAL, request, result, "enable:Failed to put oui_val");
746
747 CHECK_CONFIG_PUT_RETURN_FAIL(msg->config_intf_addr, msg->intf_addr_val, NAN_MAC_ADDR_LEN,
748 NAN_REQ_ATTR_MAC_ADDR_VAL, request, result, "enable:Failed to put intf_addr_val");
749
750 CHECK_CONFIG_PUT_8_RETURN_FAIL(1, msg->config_cluster_attribute_val,
751 NAN_REQ_ATTR_CLUSTER_VAL, request, result, "enable:Failed to put config_cluster_attribute_val");
752
753 CHECK_CONFIG_PUT_RETURN_FAIL(msg->config_scan_params, msg->scan_params_val.dwell_time, sizeof(msg->scan_params_val.dwell_time),
754 NAN_REQ_ATTR_SOCIAL_CH_SCAN_DWELL_TIME, request, result, "enable:Failed to put scan_params_val.dwell_time");
755
756 CHECK_CONFIG_PUT_RETURN_FAIL(msg->config_scan_params, msg->scan_params_val.scan_period, sizeof(msg->scan_params_val.scan_period),
757 NAN_REQ_ATTR_SOCIAL_CH_SCAN_PERIOD, request, result, "enable:Failed to put scan_params_val.scan_period");
758
759 CHECK_CONFIG_PUT_8_RETURN_FAIL(msg->config_random_factor_force, msg->random_factor_force_val,
760 NAN_REQ_ATTR_RANDOM_FACTOR_FORCE_VAL, request, result, "enable:Failed to put random_factor_force_val");
761
762 CHECK_CONFIG_PUT_8_RETURN_FAIL(msg->config_hop_count_force, msg->hop_count_force_val,
763 NAN_REQ_ATTR_HOP_COUNT_FORCE_VAL, request, result, "enable:Failed to put hop_count_force_val");
764
765 CHECK_CONFIG_PUT_32_RETURN_FAIL(msg->config_24g_channel, msg->channel_24g_val,
766 NAN_REQ_ATTR_CHANNEL_2G4_MHZ_VAL, request, result, "enable:Failed to put channel_24g_val");
767
768 CHECK_CONFIG_PUT_32_RETURN_FAIL(msg->config_5g_channel, msg->channel_5g_val,
769 NAN_REQ_ATTR_CHANNEL_5G_MHZ_VAL, request, result, "enable:Failed to put channel_5g_val");
770
771 request.attr_end(data);
772
773 registerNanEvents();
774
775 result = requestResponse(request);
776 if (result != WIFI_SUCCESS) {
777 ALOGE("failed to NAN; result = %d", result);
778 unregisterNanEvents();
779 } else {
780 ALOGD("Start NAN...success");
781 }
782 return result;
783 }
784
785 int disable()
786 {
787 ALOGD("Stop NAN...");
788 WifiRequest request(familyId(), ifaceId());
789
790 unregisterNanEvents();
791
792 int result = request.create(GOOGLE_OUI, SLSI_NL80211_VENDOR_SUBCMD_NAN_DISABLE);
793 CHECK_WIFI_STATUS_RETURN_FAIL(result, "disable:Failed to create WifiRequest");
794 result = requestResponse(request);
795 CHECK_WIFI_STATUS_RETURN_FAIL(result, "disable:Failed to requestResponse");
796 return result;
797 }
798
799 int config(NanConfigRequest *msg) {
49e66671 800 ALOGD("NAN config...");
d3a587e8
JPS		 801 WifiRequest request(familyId(), ifaceId());
802
803 int result = request.create(GOOGLE_OUI, SLSI_NL80211_VENDOR_SUBCMD_NAN_CONFIG);
804 CHECK_WIFI_STATUS_RETURN_FAIL(result, "config:Failed to create WifiRequest");
805
806 nlattr *data = request.attr_start(NL80211_ATTR_VENDOR_DATA);
807 if (!data) {
808 ALOGE("config: request.attr_start fail");
809 return WIFI_ERROR_OUT_OF_MEMORY;
810 }
811
812 CHECK_CONFIG_PUT_8_RETURN_FAIL(msg->config_sid_beacon, msg->sid_beacon,
813 NAN_REQ_ATTR_SID_BEACON_VAL, request, result, "config:Failed to put sid_beacon");
814
815 CHECK_CONFIG_PUT_8_RETURN_FAIL(msg->config_rssi_proximity, msg->rssi_proximity,
816 NAN_REQ_ATTR_RSSI_PROXIMITY_2G4_VAL, request, result, "config:Failed to put rssi_proximity");
817
818 CHECK_CONFIG_PUT_8_RETURN_FAIL(msg->config_master_pref, msg->master_pref,
819 NAN_REQ_ATTR_MASTER_PREF, request, result, "config:Failed to put master_pref");
820
821 CHECK_CONFIG_PUT_8_RETURN_FAIL(msg->config_5g_rssi_close_proximity, msg->rssi_close_proximity_5g_val,
822 NAN_REQ_ATTR_RSSI_CLOSE_PROXIMITY_5G_VAL, request, result, "config:Failed to put rssi_close_proximity_5g_val");
823
824 CHECK_CONFIG_PUT_8_RETURN_FAIL(msg->config_rssi_window_size, msg->rssi_window_size_val,
825 NAN_REQ_ATTR_RSSI_WINDOW_SIZE_VAL, request, result, "config:Failed to put rssi_window_size_val");
826
827 CHECK_CONFIG_PUT_8_RETURN_FAIL(1, msg->config_cluster_attribute_val,
828 NAN_REQ_ATTR_CLUSTER_VAL, request, result, "config:Failed to put config_cluster_attribute_val");
829
830 CHECK_CONFIG_PUT_RETURN_FAIL(msg->config_scan_params, msg->scan_params_val.dwell_time, sizeof(msg->scan_params_val.dwell_time),
831 NAN_REQ_ATTR_SOCIAL_CH_SCAN_DWELL_TIME, request, result, "config:Failed to put scan_params_val.dwell_time");
832
833 CHECK_CONFIG_PUT_RETURN_FAIL(msg->config_scan_params, msg->scan_params_val.scan_period, sizeof(msg->scan_params_val.scan_period),
834 NAN_REQ_ATTR_SOCIAL_CH_SCAN_PERIOD, request, result, "config:Failed to put scan_params_val.scan_period");
835
836 CHECK_CONFIG_PUT_8_RETURN_FAIL(msg->config_random_factor_force, msg->random_factor_force_val,
837 NAN_REQ_ATTR_RANDOM_FACTOR_FORCE_VAL, request, result, "config:Failed to put random_factor_force_val");
838
839 CHECK_CONFIG_PUT_8_RETURN_FAIL(msg->config_hop_count_force, msg->hop_count_force_val,
840 NAN_REQ_ATTR_HOP_COUNT_FORCE_VAL, request, result, "config:Failed to put hop_count_force_val");
841
842 CHECK_CONFIG_PUT_8_RETURN_FAIL(msg->config_conn_capability, msg->conn_capability_val.payload_transmit_flag,
843 NAN_REQ_ATTR_CONN_CAPABILITY_PAYLOAD_TX, request, result, "config:Failed to put payload_transmit_flag");
844
845 CHECK_CONFIG_PUT_8_RETURN_FAIL(msg->config_conn_capability, msg->conn_capability_val.is_wfd_supported,
846 NAN_REQ_ATTR_CONN_CAPABILITY_WFD, request, result, "config:Failed to put is_wfd_supported");
847
848 CHECK_CONFIG_PUT_8_RETURN_FAIL(msg->config_conn_capability, msg->conn_capability_val.is_wfds_supported,
849 NAN_REQ_ATTR_CONN_CAPABILITY_WFDS, request, result, "config:Failed to put is_wfds_supported");
850
851 CHECK_CONFIG_PUT_8_RETURN_FAIL(msg->config_conn_capability, msg->conn_capability_val.is_tdls_supported,
852 NAN_REQ_ATTR_CONN_CAPABILITY_TDLS, request, result, "config:Failed to put is_tdls_supported");
853
854 CHECK_CONFIG_PUT_8_RETURN_FAIL(msg->config_conn_capability, msg->conn_capability_val.is_ibss_supported,
855 NAN_REQ_ATTR_CONN_CAPABILITY_IBSS, request, result, "config:Failed to put is_ibss_supported");
856
857 CHECK_CONFIG_PUT_8_RETURN_FAIL(msg->config_conn_capability, msg->conn_capability_val.is_mesh_supported,
858 NAN_REQ_ATTR_CONN_CAPABILITY_MESH, request, result, "config:Failed to put is_mesh_supported");
859
860 CHECK_CONFIG_PUT_8_RETURN_FAIL(msg->config_conn_capability, msg->conn_capability_val.wlan_infra_field,
861 NAN_REQ_ATTR_CONN_CAPABILITY_WLAN_INFRA, request, result, "config:Failed to put wlan_infra_field");
862
863 if (msg->num_config_discovery_attr) {
864 CHECK_CONFIG_PUT_8_RETURN_FAIL(1, msg->num_config_discovery_attr,
865 NAN_REQ_ATTR_DISCOVERY_ATTR_NUM_ENTRIES, request, result, "config:Failed to put msg->num_config_discovery_attr");
866 for (int i = 0; i < msg->num_config_discovery_attr; i++) {
867 nlattr *nl_disc_attribute = request.attr_start(NAN_REQ_ATTR_DISCOVERY_ATTR_VAL);
868 NanTransmitPostDiscovery *discovery_attr = &msg->discovery_attr_val[i];
869 CHECK_CONFIG_PUT_8_RETURN_FAIL(1, discovery_attr->type,
870 NAN_REQ_ATTR_CONN_TYPE, request, result, "config:Failed to put discovery_attr->type");
871 CHECK_CONFIG_PUT_8_RETURN_FAIL(1, discovery_attr->role,
872 NAN_REQ_ATTR_NAN_ROLE, request, result, "config:Failed to put discovery_attr->role");
873 CHECK_CONFIG_PUT_8_RETURN_FAIL(1, discovery_attr->transmit_freq,
874 NAN_REQ_ATTR_TRANSMIT_FREQ, request, result, "config:Failed to put discovery_attr->transmit_freq");
875 CHECK_CONFIG_PUT_8_RETURN_FAIL(1, discovery_attr->duration,
876 NAN_REQ_ATTR_AVAILABILITY_DURATION, request, result, "config:Failed to put discovery_attr->duration");
877 CHECK_CONFIG_PUT_32_RETURN_FAIL(1, discovery_attr->avail_interval_bitmap,
878 NAN_REQ_ATTR_AVAILABILITY_INTERVAL, request, result, "config:Failed to put discovery_attr->avail_interval_bitmap");
879 CHECK_CONFIG_PUT_RETURN_FAIL(1, discovery_attr->addr, NAN_MAC_ADDR_LEN,
880 NAN_REQ_ATTR_MAC_ADDR_VAL, request, result, "config:Failed to put discovery_attr->addr");
881 CHECK_CONFIG_PUT_16_RETURN_FAIL(1, discovery_attr->mesh_id_len,
882 NAN_REQ_ATTR_MESH_ID_LEN, request, result, "config:Failed to put discovery_attr->mesh_id");
883 CHECK_CONFIG_PUT_RETURN_FAIL(discovery_attr->mesh_id_len, discovery_attr->mesh_id, discovery_attr->mesh_id_len,
884 NAN_REQ_ATTR_MESH_ID, request, result, "config:Failed to put discovery_attr->mesh_id");
885 CHECK_CONFIG_PUT_16_RETURN_FAIL(1, discovery_attr->infrastructure_ssid_len,
886 NAN_REQ_ATTR_INFRASTRUCTURE_SSID_LEN, request, result, "config:Failed to put discovery_attr->infrastructure_ssid_val");
887 CHECK_CONFIG_PUT_RETURN_FAIL(discovery_attr->infrastructure_ssid_len, discovery_attr->infrastructure_ssid_val, discovery_attr->infrastructure_ssid_len,
888 NAN_REQ_ATTR_INFRASTRUCTURE_SSID, request, result, "config:Failed to put discovery_attr->infrastructure_ssid_val");
889 request.attr_end(nl_disc_attribute);
890 }
891 }
892
893 if (msg->config_fam) {
894 CHECK_CONFIG_PUT_8_RETURN_FAIL(1, msg->fam_val.numchans,
895 NAN_REQ_ATTR_FURTHER_AVAIL_NUM_ENTRIES, request, result, "config:Failed to put msg->fam_val.numchans");
896 for (int i = 0; i < msg->fam_val.numchans; i++) {
897 nlattr *nl_fam_attribute = request.attr_start(NAN_REQ_ATTR_FURTHER_AVAIL_VAL);
898 NanFurtherAvailabilityChannel *further_avail_chan = &msg->fam_val.famchan[i];
899 CHECK_CONFIG_PUT_8_RETURN_FAIL(1, further_avail_chan->entry_control,
900 NAN_REQ_ATTR_FURTHER_AVAIL_ENTRY_CTRL, request, result, "config:Failed to put further_avail_chan->entry_control");
901 CHECK_CONFIG_PUT_8_RETURN_FAIL(1, further_avail_chan->class_val,
902 NAN_REQ_ATTR_FURTHER_AVAIL_CHAN_CLASS, request, result, "config:Failed to put further_avail_chan->class_val");
903 CHECK_CONFIG_PUT_8_RETURN_FAIL(1, further_avail_chan->channel,
904 NAN_REQ_ATTR_FURTHER_AVAIL_CHAN, request, result, "config:Failed to put further_avail_chan->channel");
905 CHECK_CONFIG_PUT_8_RETURN_FAIL(1, further_avail_chan->mapid,
906 NAN_REQ_ATTR_FURTHER_AVAIL_CHAN_MAPID, request, result, "config:Failed to put further_avail_chan->mapid");
907 CHECK_CONFIG_PUT_32_RETURN_FAIL(1, further_avail_chan->avail_interval_bitmap,
908 NAN_REQ_ATTR_FURTHER_AVAIL_INTERVAL_BITMAP, request, result, "config:Failed to put further_avail_chan->avail_interval_bitmap");
909 request.attr_end(nl_fam_attribute);
910 }
911 }
912
913 request.attr_end(data);
914 result = requestResponse(request);
915 if (result != WIFI_SUCCESS) {
916 ALOGE("failed to set_config; result = %d", result);
917 } else {
49e66671 918 ALOGD("NAN config...success");
d3a587e8
JPS		 919 }
920 return result;
921 }
922
923 static int setCallbackHandler(NanCallbackHandler handlers) {
924 callbackEventHandler = handlers;
925 return WIFI_SUCCESS;
926 }
927
928 static int getVersion(NanVersion *version) {
929 *version = SLSI_WIFI_HAL_NAN_VERSION;
930 return WIFI_SUCCESS;
931 }
932
933 int publish(NanPublishRequest *msg) {
49e66671 934 ALOGD("NAN publish...");
d3a587e8
JPS		 935 WifiRequest request(familyId(), ifaceId());
936
937 int result = request.create(GOOGLE_OUI, SLSI_NL80211_VENDOR_SUBCMD_NAN_PUBLISH);
938 CHECK_WIFI_STATUS_RETURN_FAIL(result, "publish:Failed to create WifiRequest");
939
940 nlattr *data = request.attr_start(NL80211_ATTR_VENDOR_DATA);
941 if (!data) {
942 ALOGE("publish: request.attr_start fail");
943 return WIFI_ERROR_OUT_OF_MEMORY;
944 }
945
946 CHECK_CONFIG_PUT_16_RETURN_FAIL(msg->publish_id, msg->publish_id,
947 NAN_REQ_ATTR_PUBLISH_ID, request, result, "publish:Failed to put msg->publish_id");
948
949 CHECK_CONFIG_PUT_16_RETURN_FAIL(msg->ttl, msg->ttl,
950 NAN_REQ_ATTR_PUBLISH_TTL, request, result, "publish:Failed to put msg->ttl");
951
952 CHECK_CONFIG_PUT_16_RETURN_FAIL(1, msg->period,
953 NAN_REQ_ATTR_PUBLISH_PERIOD, request, result, "publish:Failed to put msg->period");
954
955 CHECK_CONFIG_PUT_8_RETURN_FAIL(1, msg->publish_type,
956 NAN_REQ_ATTR_PUBLISH_TYPE, request, result, "publish:Failed to put msg->publish_type");
957
958 CHECK_CONFIG_PUT_8_RETURN_FAIL(1, msg->tx_type,
959 NAN_REQ_ATTR_PUBLISH_TX_TYPE, request, result, "publish:Failed to put msg->tx_type");
960
961 CHECK_CONFIG_PUT_8_RETURN_FAIL(1, msg->publish_count,
962 NAN_REQ_ATTR_PUBLISH_COUNT, request, result, "publish:Failed to put msg->publish_count");
963
964 CHECK_CONFIG_PUT_16_RETURN_FAIL(msg->service_name_len, msg->service_name_len,
965 NAN_REQ_ATTR_PUBLISH_SERVICE_NAME_LEN, request, result, "publish:Failed to put msg->service_name_len");
966
967 CHECK_CONFIG_PUT_RETURN_FAIL(msg->service_name_len, msg->service_name, msg->service_name_len,
968 NAN_REQ_ATTR_PUBLISH_SERVICE_NAME, request, result, "publish:Failed to put msg->service_name");
969
970 CHECK_CONFIG_PUT_8_RETURN_FAIL(1, msg->publish_match_indicator,
971 NAN_REQ_ATTR_PUBLISH_MATCH_ALGO, request, result, "publish:Failed to put msg->publish_match_indicator");
972
973 CHECK_CONFIG_PUT_16_RETURN_FAIL(msg->service_specific_info_len, msg->service_specific_info_len,
974 NAN_REQ_ATTR_PUBLISH_SERVICE_INFO_LEN, request, result, "publish:Failed to put msg->service_specific_info_len");
975
976 CHECK_CONFIG_PUT_RETURN_FAIL(msg->service_specific_info_len, msg->service_specific_info, msg->service_specific_info_len,
977 NAN_REQ_ATTR_PUBLISH_SERVICE_INFO, request, result, "publish:Failed to put msg->service_specific_info");
978
979 CHECK_CONFIG_PUT_16_RETURN_FAIL(msg->rx_match_filter_len, msg->rx_match_filter_len,
980 NAN_REQ_ATTR_PUBLISH_RX_MATCH_FILTER_LEN, request, result, "publish:Failed to put msg->rx_match_filter_len");
981
982 CHECK_CONFIG_PUT_RETURN_FAIL(msg->rx_match_filter_len, msg->rx_match_filter, msg->rx_match_filter_len,
983 NAN_REQ_ATTR_PUBLISH_RX_MATCH_FILTER, request, result, "publish:Failed to put msg->rx_match_filter");
984
985 CHECK_CONFIG_PUT_16_RETURN_FAIL(msg->tx_match_filter_len, msg->tx_match_filter_len,
986 NAN_REQ_ATTR_PUBLISH_TX_MATCH_FILTER_LEN, request, result, "publish:Failed to put msg->tx_match_filter_len");
987
988 CHECK_CONFIG_PUT_RETURN_FAIL(msg->tx_match_filter_len, msg->tx_match_filter, msg->tx_match_filter_len,
989 NAN_REQ_ATTR_PUBLISH_TX_MATCH_FILTER, request, result, "publish:Failed to put msg->tx_match_filter");
990
991 CHECK_CONFIG_PUT_8_RETURN_FAIL(1, msg->rssi_threshold_flag,
992 NAN_REQ_ATTR_PUBLISH_RSSI_THRESHOLD_FLAG, request, result, "publish:Failed to put msg->rssi_threshold_flag");
993
994 CHECK_CONFIG_PUT_8_RETURN_FAIL(1, msg->connmap,
995 NAN_REQ_ATTR_PUBLISH_CONN_MAP, request, result, "publish:Failed to put msg->connmap");
996
997 CHECK_CONFIG_PUT_8_RETURN_FAIL(1, msg->recv_indication_cfg,
998 NAN_REQ_ATTR_PUBLISH_RECV_IND_CFG, request, result, "publish:Failed to put msg->recv_indication_cfg");
999
1000 request.attr_end(data);
1001 result = requestResponse(request);
1002 if (result != WIFI_SUCCESS) {
1003 ALOGE("failed to publish; result = %d", result);
1004 } else {
49e66671 1005 ALOGD("NAN publish...success");
d3a587e8
JPS		 1006 }
1007 return result;
1008 }
1009
1010 int publishCancel(NanPublishCancelRequest *msg) {
49e66671 1011 ALOGD("NAN publishCancel...");
d3a587e8
JPS		 1012 WifiRequest request(familyId(), ifaceId());
1013
1014 int result = request.create(GOOGLE_OUI, SLSI_NL80211_VENDOR_SUBCMD_NAN_PUBLISHCANCEL);
1015 CHECK_WIFI_STATUS_RETURN_FAIL(result, "publishCancel:Failed to create WifiRequest");
1016
1017 nlattr *data = request.attr_start(NL80211_ATTR_VENDOR_DATA);
1018 if (!data) {
1019 ALOGE("publishCancel: request.attr_start fail");
1020 return WIFI_ERROR_OUT_OF_MEMORY;
1021 }
1022
1023 CHECK_CONFIG_PUT_16_RETURN_FAIL(1, msg->publish_id,
1024 NAN_REQ_ATTR_PUBLISH_ID, request, result, "publishCancel:Failed to put msg->publish_id");
1025
1026 request.attr_end(data);
1027 result = requestResponse(request);
1028 if (result != WIFI_SUCCESS) {
1029 ALOGE("failed to publishCancel; result = %d", result);
1030 } else {
49e66671 1031 ALOGD("NAN publishCancel...success");
d3a587e8
JPS		 1032 }
1033 return result;
1034
1035 }
1036
1037 int subscribe(NanSubscribeRequest *msg) {
49e66671 1038 ALOGD("NAN subscribe...");
d3a587e8
JPS		 1039 WifiRequest request(familyId(), ifaceId());
1040
1041 int result = request.create(GOOGLE_OUI, SLSI_NL80211_VENDOR_SUBCMD_NAN_SUBSCRIBE);
1042 CHECK_WIFI_STATUS_RETURN_FAIL(result, "subscribe:Failed to create WifiRequest");
1043
1044 nlattr *data = request.attr_start(NL80211_ATTR_VENDOR_DATA);
1045 if (!data) {
1046 ALOGE("subscribe: request.attr_start fail");
1047 return WIFI_ERROR_OUT_OF_MEMORY;
1048 }
1049
1050 CHECK_CONFIG_PUT_16_RETURN_FAIL(msg->subscribe_id, msg->subscribe_id,
1051 NAN_REQ_ATTR_SUBSCRIBE_ID, request, result, "subscribe:Failed to put msg->publish_id");
1052
1053 CHECK_CONFIG_PUT_16_RETURN_FAIL(1, msg->ttl,
1054 NAN_REQ_ATTR_SUBSCRIBE_TTL, request, result, "subscribe:Failed to put msg->ttl");
1055
1056 CHECK_CONFIG_PUT_16_RETURN_FAIL(1, msg->period,
1057 NAN_REQ_ATTR_SUBSCRIBE_PERIOD, request, result, "subscribe:Failed to put msg->period");
1058
1059 CHECK_CONFIG_PUT_8_RETURN_FAIL(1, msg->subscribe_type,
1060 NAN_REQ_ATTR_SUBSCRIBE_TYPE, request, result, "subscribe:Failed to put msg->subscribe_type");
1061
1062 CHECK_CONFIG_PUT_8_RETURN_FAIL(1, msg->serviceResponseFilter,
1063 NAN_REQ_ATTR_SUBSCRIBE_RESP_FILTER_TYPE, request, result, "subscribe:Failed to put msg->serviceResponseFilter");
1064
1065 CHECK_CONFIG_PUT_8_RETURN_FAIL(1, msg->serviceResponseInclude,
1066 NAN_REQ_ATTR_SUBSCRIBE_RESP_INCLUDE, request, result, "subscribe:Failed to put msg->serviceResponseInclude");
1067
1068 CHECK_CONFIG_PUT_8_RETURN_FAIL(1, msg->useServiceResponseFilter,
1069 NAN_REQ_ATTR_SUBSCRIBE_USE_RESP_FILTER, request, result, "subscribe:Failed to put msg->useServiceResponseFilter");
1070
1071 CHECK_CONFIG_PUT_8_RETURN_FAIL(1, msg->ssiRequiredForMatchIndication,
1072 NAN_REQ_ATTR_SUBSCRIBE_SSI_REQUIRED, request, result, "subscribe:Failed to put msg->ssiRequiredForMatchIndication");
1073
1074 CHECK_CONFIG_PUT_8_RETURN_FAIL(1, msg->subscribe_match_indicator,
1075 NAN_REQ_ATTR_SUBSCRIBE_MATCH_INDICATOR, request, result, "subscribe:Failed to put msg->subscribe_match_indicator");
1076
1077 CHECK_CONFIG_PUT_8_RETURN_FAIL(1, msg->subscribe_count,
1078 NAN_REQ_ATTR_SUBSCRIBE_COUNT, request, result, "subscribe:Failed to put msg->subscribe_count");
1079
1080 CHECK_CONFIG_PUT_16_RETURN_FAIL(msg->service_name_len, msg->service_name_len,
1081 NAN_REQ_ATTR_SUBSCRIBE_SERVICE_NAME_LEN, request, result, "subscribe:Failed to put msg->service_name_len");
1082
1083 CHECK_CONFIG_PUT_RETURN_FAIL(msg->service_name_len, msg->service_name, msg->service_name_len,
1084 NAN_REQ_ATTR_SUBSCRIBE_SERVICE_NAME, request, result, "subscribe:Failed to put msg->service_name");
1085
1086 CHECK_CONFIG_PUT_16_RETURN_FAIL(msg->service_specific_info_len, msg->service_specific_info_len,
1087 NAN_REQ_ATTR_SUBSCRIBE_SERVICE_INFO_LEN, request, result, "subscribe:Failed to put msg->service_specific_info_len");
1088
1089 CHECK_CONFIG_PUT_RETURN_FAIL(msg->service_specific_info_len, msg->service_specific_info, msg->service_specific_info_len,
1090 NAN_REQ_ATTR_SUBSCRIBE_SERVICE_INFO, request, result, "subscribe:Failed to put msg->service_specific_info");
1091
1092 CHECK_CONFIG_PUT_16_RETURN_FAIL(msg->rx_match_filter_len, msg->rx_match_filter_len,
1093 NAN_REQ_ATTR_SUBSCRIBE_RX_MATCH_FILTER_LEN, request, result, "subscribe:Failed to put msg->rx_match_filter_len");
1094
1095 CHECK_CONFIG_PUT_RETURN_FAIL(msg->rx_match_filter_len, msg->rx_match_filter, msg->rx_match_filter_len,
1096 NAN_REQ_ATTR_SUBSCRIBE_RX_MATCH_FILTER, request, result, "subscribe:Failed to put msg->rx_match_filter");
1097
1098 CHECK_CONFIG_PUT_16_RETURN_FAIL(msg->tx_match_filter_len, msg->tx_match_filter_len,
1099 NAN_REQ_ATTR_SUBSCRIBE_TX_MATCH_FILTER_LEN, request, result, "subscribe:Failed to put msg->tx_match_filter_len");
1100
1101 CHECK_CONFIG_PUT_RETURN_FAIL(msg->tx_match_filter_len, msg->tx_match_filter, msg->tx_match_filter_len,
1102 NAN_REQ_ATTR_SUBSCRIBE_TX_MATCH_FILTER, request, result, "subscribe:Failed to put msg->tx_match_filter");
1103
1104 CHECK_CONFIG_PUT_8_RETURN_FAIL(1, msg->rssi_threshold_flag,
1105 NAN_REQ_ATTR_SUBSCRIBE_RSSI_THRESHOLD_FLAG, request, result, "subscribe:Failed to put msg->rssi_threshold_flag");
1106
1107 CHECK_CONFIG_PUT_8_RETURN_FAIL(1, msg->connmap,
1108 NAN_REQ_ATTR_SUBSCRIBE_CONN_MAP, request, result, "subscribe:Failed to put msg->connmap");
1109
1110 CHECK_CONFIG_PUT_8_RETURN_FAIL(msg->num_intf_addr_present, msg->num_intf_addr_present,
1111 NAN_REQ_ATTR_SUBSCRIBE_NUM_INTF_ADDR_PRESENT, request, result, "subscribe:Failed to put msg->num_intf_addr_present");
1112
1113 CHECK_CONFIG_PUT_RETURN_FAIL(msg->num_intf_addr_present, msg->intf_addr, NAN_MAC_ADDR_LEN * msg->num_intf_addr_present,
1114 NAN_REQ_ATTR_SUBSCRIBE_INTF_ADDR, request, result, "subscribe:Failed to put msg->intf_addr");
1115
1116 CHECK_CONFIG_PUT_8_RETURN_FAIL(1, msg->recv_indication_cfg,
1117 NAN_REQ_ATTR_SUBSCRIBE_RECV_IND_CFG, request, result, "subscribe:Failed to put msg->recv_indication_cfg");
1118
1119 request.attr_end(data);
1120 result = requestResponse(request);
1121 if (result != WIFI_SUCCESS) {
1122 ALOGE("failed to subscribe; result = %d", result);
1123 } else {
49e66671 1124 ALOGD("NAN subscribe...success");
d3a587e8
JPS		 1125 }
1126 return result;
1127
1128 }
1129
1130 int subscribeCancel(NanSubscribeCancelRequest *msg) {
49e66671 1131 ALOGD("NAN subscribeCancel...");
d3a587e8
JPS		 1132 WifiRequest request(familyId(), ifaceId());
1133
1134 int result = request.create(GOOGLE_OUI, SLSI_NL80211_VENDOR_SUBCMD_NAN_SUBSCRIBECANCEL);
1135 CHECK_WIFI_STATUS_RETURN_FAIL(result, "subscribeCancel:Failed to create WifiRequest");
1136
1137 nlattr *data = request.attr_start(NL80211_ATTR_VENDOR_DATA);
1138 if (!data) {
1139 ALOGE("subscribeCancel: request.attr_start fail");
1140 return WIFI_ERROR_OUT_OF_MEMORY;
1141 }
1142
1143 CHECK_CONFIG_PUT_16_RETURN_FAIL(1, msg->subscribe_id,
1144 NAN_REQ_ATTR_SUBSCRIBE_ID, request, result, "subscribeCancel:Failed to put msg->subscribe_id");
1145
1146 request.attr_end(data);
1147 result = requestResponse(request);
1148 if (result != WIFI_SUCCESS) {
1149 ALOGE("failed to subscribeCancel; result = %d", result);
1150 } else {
49e66671 1151 ALOGD("NAN subscribeCancel...success");
d3a587e8
JPS		 1152 }
1153 return result;
1154 }
1155
1156 int followup(NanTransmitFollowupRequest *msg) {
49e66671 1157 ALOGD("NAN followup...");
d3a587e8
JPS		 1158 WifiRequest request(familyId(), ifaceId());
1159
1160 int result = request.create(GOOGLE_OUI, SLSI_NL80211_VENDOR_SUBCMD_NAN_TXFOLLOWUP);
1161 CHECK_WIFI_STATUS_RETURN_FAIL(result, "followup:Failed to create WifiRequest");
1162
1163 nlattr *data = request.attr_start(NL80211_ATTR_VENDOR_DATA);
1164 if (!data) {
1165 ALOGE("followup: request.attr_start fail");
1166 return WIFI_ERROR_OUT_OF_MEMORY;
1167 }
1168
1169 CHECK_CONFIG_PUT_16_RETURN_FAIL(1, msg->publish_subscribe_id,
1170 NAN_REQ_ATTR_FOLLOWUP_ID, request, result, "followup:Failed to put msg->publish_subscribe_id");
1171
1172 CHECK_CONFIG_PUT_32_RETURN_FAIL(1, msg->requestor_instance_id,
1173 NAN_REQ_ATTR_FOLLOWUP_REQUESTOR_ID, request, result, "followup:Failed to put msg->requestor_instance_id");
1174
1175 CHECK_CONFIG_PUT_RETURN_FAIL(1, msg->addr, NAN_MAC_ADDR_LEN,
1176 NAN_REQ_ATTR_FOLLOWUP_ADDR, request, result, "followup:Failed to put msg->addr");
1177
1178 CHECK_CONFIG_PUT_8_RETURN_FAIL(1, msg->priority,
1179 NAN_REQ_ATTR_FOLLOWUP_PRIORITY, request, result, "followup:Failed to put msg->priority");
1180
1181 CHECK_CONFIG_PUT_8_RETURN_FAIL(1, msg->dw_or_faw,
1182 NAN_REQ_ATTR_FOLLOWUP_TX_WINDOW, request, result, "followup:Failed to put msg->dw_or_faw");
1183
1184 CHECK_CONFIG_PUT_16_RETURN_FAIL(msg->service_specific_info_len, msg->service_specific_info_len,
1185 NAN_REQ_ATTR_FOLLOWUP_SERVICE_NAME_LEN, request, result, "followup:Failed to put msg->service_specific_info_len");
1186
1187 CHECK_CONFIG_PUT_RETURN_FAIL(msg->service_specific_info_len, msg->service_specific_info, msg->service_specific_info_len,
1188 NAN_REQ_ATTR_FOLLOWUP_SERVICE_NAME, request, result, "followup:Failed to put msg->service_specific_info");
1189
1190 CHECK_CONFIG_PUT_8_RETURN_FAIL(1, msg->recv_indication_cfg,
1191 NAN_REQ_ATTR_FOLLOWUP_RECV_IND_CFG, request, result, "followup:Failed to put msg->recv_indication_cfg");
1192
1193 request.attr_end(data);
1194 result = requestResponse(request);
1195 if (result != WIFI_SUCCESS) {
1196 ALOGE("failed to followup; result = %d", result);
1197 } else {
49e66671 1198 ALOGD("NAN followup...success");
d3a587e8
JPS		 1199 }
1200 return result;
1201
1202 }
1203
1204 int getCapabilities(void) {
49e66671 1205 ALOGD("NAN getCapabilities...");
d3a587e8
JPS		 1206 WifiRequest request(familyId(), ifaceId());
1207
1208 int result = request.create(GOOGLE_OUI, SLSI_NL80211_VENDOR_SUBCMD_NAN_CAPABILITIES);
1209 CHECK_WIFI_STATUS_RETURN_FAIL(result, "getCapabilities:Failed to create WifiRequest");
1210
1211 result = requestResponse(request);
1212 if (result != WIFI_SUCCESS) {
1213 ALOGE("failed to getCapabilities; result = %d", result);
1214 } else {
49e66671 1215 ALOGD("NAN getCapabilities...success");
d3a587e8
JPS		 1216 }
1217 return result;
1218 }
1219
1220 int handleEvent(WifiEvent &event) {
1221 int ret;
49e66671 1222 ALOGD("NAN handleEvent...");
d3a587e8
JPS		 1223
1224 if (event.get_cmd() != NL80211_CMD_VENDOR) {
1225 ALOGD("Ignoring event with cmd = %d", event.get_cmd());
1226 return NL_SKIP;
1227 }
1228
1229 int id = event.get_vendor_id();
1230 int subcmd = event.get_vendor_subcmd();
1231
1232 ALOGI("Id = %0x, subcmd = %d", id, subcmd);
1233
1234 switch(subcmd) {
1235 case SLSI_NAN_EVENT_MATCH:
1236 ret = processMatchEvent(event);
1237 break;
1238 case SLSI_NAN_EVENT_MATCH_EXPIRED:
1239 ret = processMatchExpiredEvent(event);
1240 break;
1241 case SLSI_NAN_EVENT_PUBLISH_TERMINATED:
1242 ret = processPublishTerminatedEvent(event);
1243 break;
1244 case SLSI_NAN_EVENT_SUBSCRIBE_TERMINATED:
1245 ret = processSubscribeTerminatedEvent(event);
1246 break;
1247 case SLSI_NAN_EVENT_FOLLOWUP:
1248 ret = processFollowupEvent(event);
1249 break;
1250 case SLSI_NAN_EVENT_DISABLED:
1251 ret = processNanDisabledEvent(event);
1252 break;
1253 case SLSI_NAN_EVENT_DISCOVERY_ENGINE:
1254 ret = processNanDiscoveryEvent(event);
1255 break;
1256
1257 }
1258
1259 return NL_OK;
1260 }
1261
1262 int handleResponse(WifiEvent &reply) {
49e66671 1263 ALOGD("NAN handleResponse...");
d3a587e8
JPS		 1264
1265 if (reply.get_cmd() != NL80211_CMD_VENDOR) {
1266 ALOGD("Ignoring reply with cmd = %d", reply.get_cmd());
1267 return NL_SKIP;
1268 }
1269
d3a587e8
JPS		 1270 NanResponseMsg response;
1271 memset(&response, 0, sizeof(response));
1272
1273 if (processResponse(reply, &response) == NL_SKIP)
1274 return NL_SKIP;
1275
1276 if (callbackEventHandler.NotifyResponse)
1277 callbackEventHandler.NotifyResponse(id(), &response);
1278 return NL_OK;
1279 }
1280};
1281
1282NanCallbackHandler NanCommand::callbackEventHandler;
1283
1284NanCommand *nan_get_object(transaction_id id,
1285 wifi_interface_handle iface) {
1286 wifi_handle handle = getWifiHandle(iface);
1287 NanCommand *nanRequest = (NanCommand *)wifi_get_cmd(handle, id);
1288 if (!nanRequest) {
1289 nanRequest = new NanCommand(iface, id);
1290 if (!nanRequest){
1291 ALOGE("Could not alloc NanCommand");
1292 return NULL;
1293 }
1294 }
1295 return nanRequest;
1296}
1297
1298wifi_error nan_enable_request(transaction_id id,
1299 wifi_interface_handle iface,
1300 NanEnableRequest *msg) {
1301 wifi_handle handle = getWifiHandle(iface);
1302 wifi_error ret;
1303
1304 NanCommand *nanRequest = new NanCommand(iface, id);
1305 if (!nanRequest) {
1306 ALOGE("nan_enable_request:: Unable to create NanCommand");
1307 return WIFI_ERROR_OUT_OF_MEMORY;
1308 }
1309
1310 wifi_register_cmd(handle, id, nanRequest);
1311 ret = (wifi_error)nanRequest->enable(msg);
1312 if (ret != WIFI_SUCCESS) {
1313 wifi_unregister_cmd(handle, id);
1314 delete nanRequest;
1315 }
1316 return ret;
1317}
1318
1319/* Disable NAN functionality. */
1320wifi_error nan_disable_request(transaction_id id, wifi_interface_handle iface) {
1321 NanCommand *nanRequest = nan_get_object(id, iface);
1322 wifi_error ret;
1323
1324 if (!nanRequest) {
1325 return WIFI_ERROR_OUT_OF_MEMORY;
1326 }
1327 ret = (wifi_error)nanRequest->disable();
1328 delete nanRequest;
1329 return ret;
1330}
1331
1332/* Publish request to advertize a service. */
1333wifi_error nan_publish_request(transaction_id id,
1334 wifi_interface_handle iface,
1335 NanPublishRequest *msg) {
1336 NanCommand *nanRequest = nan_get_object(id, iface);
1337 if (!nanRequest) {
1338 return WIFI_ERROR_OUT_OF_MEMORY;
1339 }
1340 return (wifi_error)nanRequest->publish(msg);
1341}
1342
1343/* Cancel previous publish requests. */
1344wifi_error nan_publish_cancel_request(transaction_id id,
1345 wifi_interface_handle iface,
1346 NanPublishCancelRequest *msg) {
1347 NanCommand *nanRequest = nan_get_object(id, iface);
1348 if (!nanRequest) {
1349 return WIFI_ERROR_OUT_OF_MEMORY;
1350 }
1351 return (wifi_error)nanRequest->publishCancel(msg);
1352}
1353
1354/* Subscribe request to search for a service. */
1355wifi_error nan_subscribe_request(transaction_id id,
1356 wifi_interface_handle iface,
1357 NanSubscribeRequest *msg) {
1358 NanCommand *nanRequest = nan_get_object(id, iface);
1359 if (!nanRequest) {
1360 return WIFI_ERROR_OUT_OF_MEMORY;
1361 }
1362 return (wifi_error)nanRequest->subscribe(msg);
1363}
1364
1365/* Cancel previous subscribe requests. */
1366wifi_error nan_subscribe_cancel_request(transaction_id id,
1367 wifi_interface_handle iface,
1368 NanSubscribeCancelRequest *msg) {
1369 NanCommand *nanRequest = nan_get_object(id, iface);
1370 if (!nanRequest) {
1371 return WIFI_ERROR_OUT_OF_MEMORY;
1372 }
1373 return (wifi_error)nanRequest->subscribeCancel(msg);
1374}
1375
1376/* NAN transmit follow up request. */
1377wifi_error nan_transmit_followup_request(transaction_id id,
1378 wifi_interface_handle iface,
1379 NanTransmitFollowupRequest *msg) {
1380 NanCommand *nanRequest = nan_get_object(id, iface);
1381 if (!nanRequest) {
1382 return WIFI_ERROR_OUT_OF_MEMORY;
1383 }
1384 return (wifi_error)nanRequest->followup(msg);
1385}
1386
1387/* NAN configuration request. */
1388wifi_error nan_config_request(transaction_id id,
1389 wifi_interface_handle iface,
1390 NanConfigRequest *msg) {
1391 NanCommand *nanRequest = nan_get_object(id, iface);
1392 if (!nanRequest) {
1393 return WIFI_ERROR_OUT_OF_MEMORY;
1394 }
1395 return (wifi_error)nanRequest->config(msg);
1396}
1397
1398/* Register NAN callbacks. */
1399wifi_error nan_register_handler(wifi_interface_handle iface,
1400 NanCallbackHandler handlers) {
1401 return (wifi_error)NanCommand::setCallbackHandler(handlers);
1402}
1403
1404/* Get NAN HAL version. */
1405wifi_error nan_get_version(wifi_handle handle,
1406 NanVersion *version) {
1407 return (wifi_error)NanCommand::getVersion(version);
1408}
1409
1410/* Get NAN capabilities. */
1411wifi_error nan_get_capabilities(transaction_id id,
1412 wifi_interface_handle iface) {
1413 NanCommand *nanRequest = nan_get_object(id, iface);
1414 if (!nanRequest) {
1415 return WIFI_ERROR_OUT_OF_MEMORY;
1416 }
1417 return (wifi_error)nanRequest->getCapabilities();
1418}
1419