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