rk3588-game
/
android13
3
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
android13/hardware/broadcom/wlan/bcmdhd/wifi_hal/nan.cpp

5712 lines
235 KiB
C++
Executable File
Raw Blame History

/*
* Copyright (C) 2017 The Android Open Source Project
*
* Portions copyright (C) 2017 Broadcom Limited
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <stdint.h>
#include <fcntl.h>
#include <sys/socket.h>
#include <netlink/genl/genl.h>
#include <netlink/genl/family.h>
#include <netlink/genl/ctrl.h>
#include <linux/rtnetlink.h>
#include <netpacket/packet.h>
#include <linux/filter.h>
#include <linux/errqueue.h>
#include <ctype.h>
#include <linux/pkt_sched.h>
#include <netlink/object-api.h>
#include <netlink/netlink.h>
#include <netlink/socket.h>
#include "nl80211_copy.h"
#include "sync.h"
#define LOG_TAG "WifiHAL"
#include <utils/Log.h>
#include <log/log.h>
#include "wifi_hal.h"
#include "common.h"
#include "cpp_bindings.h"
#include "netinet/in.h"
#include "arpa/inet.h"
#include <openssl/sha.h>
#include <openssl/evp.h>
#include <sys/ioctl.h>
/* Changes between incompatible Version of NAN */
#define NAN_MAJOR_REL_VERSION 1
/* Changes between Source and Binary compatible Version of NAN */
#define NAN_MINOR_REL_VERSION 2
/* Changes between perfectly compatible Version of NAN */
#define NAN_PATCH_REL_VERSION 3
#define SVC_NAME_TO_HASH 1
#define NAN_SVC_HASH_SIZE 6
#define C2S(x) case x: return #x;
#define NAN_PUB_RECV_FLAG_MAX 15
#define NAN_SUB_RECV_FLAG_MAX 7
#define NAN_DISC_IND_MAX 7
#define NAN_MAX 255
#define NAN_MIN 0
#define INVALID 0xFF
#define NAN_MAX_PERIOD 16
#define ISGREATER(i, x) (i > x) ? 1 : 0
#define NAN_MAX_RSSI 90
#define NAN_SECURITY_SALT_SIZE 14
#define NAN_MAC_INVALID_TRANSID 0xFFFF
#define SVCHASH_ISNULL(svc_hash) ((((u8 *)(svc_hash))[0] | \
((u8 *)(svc_hash))[1] | \
((u8 *)(svc_hash))[2] | \
((u8 *)(svc_hash))[3] | \
((u8 *)(svc_hash))[4] | \
((u8 *)(svc_hash))[5]) == 0)
#define ETHER_ISNULLADDR(ea) ((((u8 *)(ea))[0] | \
((u8 *)(ea))[1] | \
((u8 *)(ea))[2] | \
((u8 *)(ea))[3] | \
((u8 *)(ea))[4] | \
((u8 *)(ea))[5]) == 0)
/* NAN structs versioning b/w DHD and HAL
* TODO:add versions for each struct*/
#define NAN_HAL_VERSION_1 0x2
struct nan_dbg_cntrs {
u32 dp_req; /* cmd */
u32 dp_resp; /* cmd */
u32 dp_req_evt;
u32 dp_confirm_evt;
u32 transmit_req; /* cmd */
u32 transmit_txs; /* event */
u32 transmit_recv; /* event */
};
nan_dbg_cntrs counters;
u32 current_dhd_hal_ver = 0;
/* TODO: Known bug in Android which was discovered too late and then left in for backward compatibility.
* The issue is that the Service Name selected by the framework is invalid - it contains a space.
* Therefore, the underlying implementation partially converts it to lower case and uses the results for PMK generation.
* I.e. the PMK is generated based on the following service name: "Wi-Fi Aware Data Path"
*/
/* SVC Hash generated for svc name string "Wi-Fi Aware Data Path" */
u8 NAN_OOB_INTEROP_SVC_HASH[NAN_SVC_HASH_SIZE] = {0x05, 0x9e, 0xd4, 0xcf, 0x89, 0x1a};
#define NAN_OOB_INTEROP_SVC_NAME "Wi-Fi Aware Data Path"
static const char *NanStatusToString(NanStatusType status)
{
switch (status) {
C2S(NAN_STATUS_SUCCESS)
C2S(NAN_STATUS_INTERNAL_FAILURE)
C2S(NAN_STATUS_PROTOCOL_FAILURE)
C2S(NAN_STATUS_INVALID_PUBLISH_SUBSCRIBE_ID)
C2S(NAN_STATUS_NO_RESOURCE_AVAILABLE)
C2S(NAN_STATUS_INVALID_PARAM)
C2S(NAN_STATUS_INVALID_REQUESTOR_INSTANCE_ID)
C2S(NAN_STATUS_INVALID_NDP_ID)
C2S(NAN_STATUS_NAN_NOT_ALLOWED)
C2S(NAN_STATUS_NO_OTA_ACK)
C2S(NAN_STATUS_ALREADY_ENABLED)
C2S(NAN_STATUS_FOLLOWUP_QUEUE_FULL)
C2S(NAN_STATUS_UNSUPPORTED_CONCURRENCY_NAN_DISABLED)
default:
return "NAN_STATUS_INTERNAL_FAILURE";
}
}
/* Nan Data Path Security Information */
typedef struct {
/*
Unique Instance Id identifying the Responder's service.
This is same as publish_id notified on the subscribe side
in a publish/subscribe scenario
*/
u32 requestor_instance_id; /* Value 0 for no publish/subscribe */
/*
Discovery MAC addr of the publisher/peer
*/
u8 peer_disc_mac_addr[NAN_MAC_ADDR_LEN];
/*
Unique token Id generated on the initiator/responder
side used for a NDP session between two NAN devices
*/
NanDataPathId ndp_instance_id;
} NanDataPathSecInfoRequest;
/*
* Note: NAN_ATTRIBUTE should match with one that on driver side, wl_cfgnan.h and
* NanAttrToString as well for enum to string.
*/
typedef enum {
NAN_ATTRIBUTE_HEADER = 100,
NAN_ATTRIBUTE_HANDLE = 101,
NAN_ATTRIBUTE_TRANSAC_ID = 102,
/* NAN Enable request attributes */
NAN_ATTRIBUTE_2G_SUPPORT = 103,
NAN_ATTRIBUTE_5G_SUPPORT = 104,
NAN_ATTRIBUTE_CLUSTER_LOW = 105,
NAN_ATTRIBUTE_CLUSTER_HIGH = 106,
NAN_ATTRIBUTE_SID_BEACON = 107,
NAN_ATTRIBUTE_SYNC_DISC_2G_BEACON = 108,
NAN_ATTRIBUTE_SYNC_DISC_5G_BEACON = 109,
NAN_ATTRIBUTE_SDF_2G_SUPPORT = 110,
NAN_ATTRIBUTE_SDF_5G_SUPPORT = 111,
NAN_ATTRIBUTE_RSSI_CLOSE = 112,
NAN_ATTRIBUTE_RSSI_MIDDLE = 113,
NAN_ATTRIBUTE_RSSI_PROXIMITY = 114,
NAN_ATTRIBUTE_HOP_COUNT_LIMIT = 115,
NAN_ATTRIBUTE_RANDOM_FACTOR = 116,
NAN_ATTRIBUTE_MASTER_PREF = 117,
NAN_ATTRIBUTE_PERIODIC_SCAN_INTERVAL = 118,
/* Nan Publish/Subscribe request attributes */
NAN_ATTRIBUTE_PUBLISH_ID = 119,
NAN_ATTRIBUTE_TTL = 120,
NAN_ATTRIBUTE_PERIOD = 121,
NAN_ATTRIBUTE_REPLIED_EVENT_FLAG = 122,
NAN_ATTRIBUTE_PUBLISH_TYPE = 123,
NAN_ATTRIBUTE_TX_TYPE = 124,
NAN_ATTRIBUTE_PUBLISH_COUNT = 125,
NAN_ATTRIBUTE_SERVICE_NAME_LEN = 126,
NAN_ATTRIBUTE_SERVICE_NAME = 127,
NAN_ATTRIBUTE_SERVICE_SPECIFIC_INFO_LEN = 128,
NAN_ATTRIBUTE_SERVICE_SPECIFIC_INFO = 129,
NAN_ATTRIBUTE_RX_MATCH_FILTER_LEN = 130,
NAN_ATTRIBUTE_RX_MATCH_FILTER = 131,
NAN_ATTRIBUTE_TX_MATCH_FILTER_LEN = 132,
NAN_ATTRIBUTE_TX_MATCH_FILTER = 133,
NAN_ATTRIBUTE_SUBSCRIBE_ID = 134,
NAN_ATTRIBUTE_SUBSCRIBE_TYPE = 135,
NAN_ATTRIBUTE_SERVICERESPONSEFILTER = 136,
NAN_ATTRIBUTE_SERVICERESPONSEINCLUDE = 137,
NAN_ATTRIBUTE_USESERVICERESPONSEFILTER = 138,
NAN_ATTRIBUTE_SSIREQUIREDFORMATCHINDICATION = 139,
NAN_ATTRIBUTE_SUBSCRIBE_MATCH = 140,
NAN_ATTRIBUTE_SUBSCRIBE_COUNT = 141,
NAN_ATTRIBUTE_MAC_ADDR = 142,
NAN_ATTRIBUTE_MAC_ADDR_LIST = 143,
NAN_ATTRIBUTE_MAC_ADDR_LIST_NUM_ENTRIES = 144,
NAN_ATTRIBUTE_PUBLISH_MATCH = 145,
/* Nan Event attributes */
NAN_ATTRIBUTE_ENABLE_STATUS = 146,
NAN_ATTRIBUTE_JOIN_STATUS = 147,
NAN_ATTRIBUTE_ROLE = 148,
NAN_ATTRIBUTE_MASTER_RANK = 149,
NAN_ATTRIBUTE_ANCHOR_MASTER_RANK = 150,
NAN_ATTRIBUTE_CNT_PEND_TXFRM = 151,
NAN_ATTRIBUTE_CNT_BCN_TX = 152,
NAN_ATTRIBUTE_CNT_BCN_RX = 153,
NAN_ATTRIBUTE_CNT_SVC_DISC_TX = 154,
NAN_ATTRIBUTE_CNT_SVC_DISC_RX = 155,
NAN_ATTRIBUTE_AMBTT = 156,
NAN_ATTRIBUTE_CLUSTER_ID = 157,
NAN_ATTRIBUTE_INST_ID = 158,
NAN_ATTRIBUTE_OUI = 159,
NAN_ATTRIBUTE_STATUS = 160,
NAN_ATTRIBUTE_DE_EVENT_TYPE = 161,
NAN_ATTRIBUTE_MERGE = 162,
NAN_ATTRIBUTE_IFACE = 163,
NAN_ATTRIBUTE_CHANNEL = 164,
NAN_ATTRIBUTE_PEER_ID = 165,
NAN_ATTRIBUTE_NDP_ID = 167,
NAN_ATTRIBUTE_SECURITY = 168,
NAN_ATTRIBUTE_QOS = 169,
NAN_ATTRIBUTE_RSP_CODE = 170,
NAN_ATTRIBUTE_INST_COUNT = 171,
NAN_ATTRIBUTE_PEER_DISC_MAC_ADDR = 172,
NAN_ATTRIBUTE_PEER_NDI_MAC_ADDR = 173,
NAN_ATTRIBUTE_IF_ADDR = 174,
NAN_ATTRIBUTE_WARMUP_TIME = 175,
NAN_ATTRIBUTE_RECV_IND_CFG = 176,
NAN_ATTRIBUTE_RSSI_CLOSE_5G = 177,
NAN_ATTRIBUTE_RSSI_MIDDLE_5G = 178,
NAN_ATTRIBUTE_RSSI_PROXIMITY_5G = 179,
NAN_ATTRIBUTE_CONNMAP = 180,
NAN_ATTRIBUTE_24G_CHANNEL = 181,
NAN_ATTRIBUTE_5G_CHANNEL = 182,
NAN_ATTRIBUTE_DWELL_TIME = 183,
NAN_ATTRIBUTE_SCAN_PERIOD = 184,
NAN_ATTRIBUTE_RSSI_WINDOW_SIZE = 185,
NAN_ATTRIBUTE_CONF_CLUSTER_VAL = 186,
NAN_ATTRIBUTE_AVAIL_BIT_MAP = 187,
NAN_ATTRIBUTE_ENTRY_CONTROL = 188,
NAN_ATTRIBUTE_CIPHER_SUITE_TYPE = 189,
NAN_ATTRIBUTE_KEY_TYPE = 190,
NAN_ATTRIBUTE_KEY_LEN = 191,
NAN_ATTRIBUTE_SCID = 192,
NAN_ATTRIBUTE_SCID_LEN = 193,
NAN_ATTRIBUTE_SDE_CONTROL_CONFIG_DP = 194,
NAN_ATTRIBUTE_SDE_CONTROL_SECURITY = 195,
NAN_ATTRIBUTE_SDE_CONTROL_DP_TYPE = 196,
NAN_ATTRIBUTE_SDE_CONTROL_RANGE_SUPPORT = 197,
NAN_ATTRIBUTE_NO_CONFIG_AVAIL = 198,
NAN_ATTRIBUTE_2G_AWAKE_DW = 199,
NAN_ATTRIBUTE_5G_AWAKE_DW = 200,
NAN_ATTRIBUTE_RANGING_INTERVAL = 201,
NAN_ATTRIBUTE_RANGING_INDICATION = 202,
NAN_ATTRIBUTE_RANGING_INGRESS_LIMIT = 203,
NAN_ATTRIBUTE_RANGING_EGRESS_LIMIT = 204,
NAN_ATTRIBUTE_RANGING_AUTO_ACCEPT = 205,
NAN_ATTRIBUTE_RANGING_RESULT = 206,
NAN_ATTRIBUTE_DISC_IND_CFG = 207,
NAN_ATTRIBUTE_RSSI_THRESHOLD_FLAG = 208,
NAN_ATTRIBUTE_KEY_DATA = 209,
NAN_ATTRIBUTE_SDEA_SERVICE_SPECIFIC_INFO_LEN = 210,
NAN_ATTRIBUTE_SDEA_SERVICE_SPECIFIC_INFO = 211,
NAN_ATTRIBUTE_REASON = 212,
NAN_ATTRIBUTE_MATCH_OCCURRED_FLAG = 213,
NAN_ATTRIBUTE_OUT_OF_RESOURCE_FLAG = 214,
NAN_ATTRIBUTE_DWELL_TIME_5G = 215,
NAN_ATTRIBUTE_SCAN_PERIOD_5G = 216,
NAN_ATTRIBUTE_SVC_RESPONDER_POLICY = 217,
NAN_ATTRIBUTE_EVENT_MASK = 218,
NAN_ATTRIBUTE_SUB_SID_BEACON = 219,
NAN_ATTRIBUTE_RANDOMIZATION_INTERVAL = 220,
NAN_ATTRIBUTE_CMD_RESP_DATA = 221,
NAN_ATTRIBUTE_CMD_USE_NDPE = 222,
NAN_ATTRIBUTE_ENABLE_MERGE = 223,
NAN_ATTRIBUTE_DISCOVERY_BEACON_INTERVAL = 224,
NAN_ATTRIBUTE_NSS = 225,
NAN_ATTRIBUTE_ENABLE_RANGING = 226,
NAN_ATTRIBUTE_DW_EARLY_TERM = 227,
NAN_ATTRIBUTE_CHANNEL_INFO = 228,
NAN_ATTRIBUTE_NUM_CHANNELS = 229,
NAN_ATTRIBUTE_INSTANT_MODE_ENABLE = 230,
NAN_ATTRIBUTE_INSTANT_COMM_CHAN = 231,
NAN_ATTRIBUTE_CHRE_REQUEST = 232,
} NAN_ATTRIBUTE;
typedef enum {
NAN_REQUEST_ENABLE = 0,
NAN_REQUEST_DISABLE = 1,
NAN_REQUEST_PUBLISH = 2,
NAN_REQUEST_PUBLISH_CANCEL = 3,
NAN_REQUEST_TRANSMIT_FOLLOWUP = 4,
NAN_REQUEST_SUBSCRIBE = 5,
NAN_REQUEST_SUBSCRIBE_CANCEL = 6,
NAN_REQUEST_STATS = 7,
NAN_REQUEST_CONFIG = 8,
NAN_REQUEST_TCA = 9,
NAN_REQUEST_EVENT_CHECK = 10,
NAN_REQUEST_GET_CAPABILTIES = 11,
NAN_DATA_PATH_IFACE_CREATE = 12,
NAN_DATA_PATH_IFACE_DELETE = 13,
NAN_DATA_PATH_INIT_REQUEST = 14,
NAN_DATA_PATH_IND_RESPONSE = 15,
NAN_DATA_PATH_END = 16,
NAN_DATA_PATH_IFACE_UP = 17,
NAN_DATA_PATH_SEC_INFO = 18,
NAN_VERSION_INFO = 19,
NAN_REQUEST_LAST = 0xFFFF
} NanRequestType;
/*
* The enum is based on the BCME Response defs
* used in the firmware and defined at
* path: src/include/bcmeutils.h
*/
enum nan_response_status {
BCME_OK = 0,
BCME_ERROR = -1,
BCME_BADARG = -2,
BCME_BADRATESET = -12,
BCME_BADBAND = -13,
BCME_BUSY = -16,
BCME_BADCHAN = -20,
BCME_UNSUPPORTED = -23,
BCME_BADLEN = -24,
BCME_NOTREADY = -25,
BCME_NOMEM = -27,
BCME_NOTFOUND = -30,
BCME_TXFAIL = -38,
BCME_RXFAIL = -39,
BCME_SCANREJECT = -43,
BCME_USAGE_ERROR = -44,
BCME_IOCTL_ERROR = -45
};
enum nan_de_event_type {
NAN_EVENT_IFACE = 0,
NAN_EVENT_START = 1,
NAN_EVENT_JOIN = 2,
NAN_EVENT_ROLE_CHANGE = 3,
NAN_EVENT_MERGE = 4
};
typedef struct _nan_hal_resp {
u16 instance_id;
u16 subcmd;
int32_t status;
int32_t value;
/* Identifier for the instance of the NDP */
u16 ndp_instance_id;
/* Publisher NMI */
u8 pub_nmi[NAN_MAC_ADDR_LEN];
/* SVC_HASH */
u8 svc_hash[NAN_SVC_HASH_SIZE];
char nan_reason[NAN_ERROR_STR_LEN]; /* Describe the NAN reason type */
char pad[3];
NanCapabilities capabilities;
} nan_hal_resp_t;
typedef int (*match_fn)(void *p1, void *data);
typedef struct _nan_hal_info {
void *nan_handle;
void *nan_mac_control;
void *nan_disc_control;
void *nan_dp_control;
} nan_hal_info_t;
u8 mNmi[NAN_MAC_ADDR_LEN];
/* Static functions */
static int is_de_event(int cmd);
static int is_dp_event(int cmd);
static int is_cmd_response(int cmd);
static int get_svc_hash(unsigned char *svc_name, u16 svc_name_len,
u8 *svc_hash, u16 svc_hash_len);
NanResponseType get_response_type(WIFI_SUB_COMMAND nan_subcmd);
NanResponseType get_response_type_frm_req_type(NanRequestType cmdType);
static NanStatusType nan_map_response_status(int vendor_status);
/* Function to separate the common events to NAN1.0 events */
static int is_de_event(int cmd) {
bool is_de_evt = false;
switch(cmd) {
case NAN_EVENT_SUBSCRIBE_UNMATCH:
case NAN_EVENT_SUBSCRIBE_TERMINATED:
case NAN_EVENT_PUBLISH_TERMINATED:
case NAN_EVENT_SUBSCRIBE_MATCH:
case NAN_EVENT_FOLLOWUP:
case NAN_EVENT_TRANSMIT_FOLLOWUP_IND:
case NAN_EVENT_PUBLISH_REPLIED_IND:
case NAN_EVENT_MATCH_EXPIRY:
is_de_evt = true;
break;
default:
/* Not used */
break;
}
return is_de_evt;
}
/* Function to separate NAN2.0 events */
static int is_dp_event(int cmd) {
bool is_dp_evt = false;
switch(cmd) {
case NAN_EVENT_DATA_REQUEST:
case NAN_EVENT_DATA_CONFIRMATION:
case NAN_EVENT_DATA_END:
is_dp_evt = true;
break;
default:
/* Not used */
break;
}
return is_dp_evt;
}
static int is_cmd_response(int cmd) {
bool is_cmd_resp = false;
switch(cmd) {
case NAN_ASYNC_RESPONSE_DISABLED:
is_cmd_resp = true;
break;
default:
break;
}
return is_cmd_resp;
}
static NanStatusType nan_map_response_status (int vendor_status) {
NanStatusType hal_status;
switch(vendor_status) {
case BCME_OK:
hal_status = NAN_STATUS_SUCCESS;
break;
case BCME_BUSY:
hal_status = NAN_STATUS_NO_RESOURCE_AVAILABLE;
break;
case BCME_NOTREADY:
hal_status = NAN_STATUS_NAN_NOT_ALLOWED;
break;
case BCME_BADLEN:
case BCME_BADBAND:
hal_status = NAN_STATUS_INVALID_PARAM;
break;
case BCME_NOMEM:
hal_status = NAN_STATUS_NO_RESOURCE_AVAILABLE;
break;
case NAN_STATUS_INTERNAL_FAILURE:
case NAN_STATUS_PROTOCOL_FAILURE:
case NAN_STATUS_INVALID_PUBLISH_SUBSCRIBE_ID:
case NAN_STATUS_NO_RESOURCE_AVAILABLE:
case NAN_STATUS_INVALID_PARAM:
case NAN_STATUS_INVALID_REQUESTOR_INSTANCE_ID:
case NAN_STATUS_INVALID_NDP_ID:
case NAN_STATUS_NAN_NOT_ALLOWED:
case NAN_STATUS_NO_OTA_ACK:
case NAN_STATUS_ALREADY_ENABLED:
case NAN_STATUS_FOLLOWUP_QUEUE_FULL:
case NAN_STATUS_UNSUPPORTED_CONCURRENCY_NAN_DISABLED:
hal_status = (NanStatusType)vendor_status;
break;
default:
ALOGE("%s Unknown vendor status, status = %d\n",
__func__, vendor_status);
/* Generic error */
hal_status = NAN_STATUS_INTERNAL_FAILURE;
}
return hal_status;
}
static void prhex(const char *msg, u8 *buf, u32 nbytes);
static const char *NanAttrToString(u16 cmd);
static const char *NanCmdToString(int cmd);
static const char *NanRspToString(int cmd);
#define NAN_DBG_ENTER() {ALOGI("Enter: %s\n", __func__);}
#define NAN_DBG_EXIT() {ALOGI("Exit: %s\n", __func__);}
static int passphrase_to_pmk(u8 *peer_mac, u32 cipher_type,
u8 *svc_hash, NanSecurityKeyInfo *key_info, u8 *pmk_hex) {
int result = NAN_STATUS_SUCCESS;
u8 salt[NAN_SECURITY_SALT_SIZE];
NAN_DBG_ENTER();
salt[0] = 0; /* salt_version */
salt[1] = cipher_type;
if (svc_hash && peer_mac) {
memcpy(&salt[2], svc_hash, NAN_SVC_HASH_SIZE);
memcpy(&salt[2 + NAN_SVC_HASH_SIZE], peer_mac,
ETHER_ADDR_LEN);
prhex("Salt", salt, NAN_SECURITY_SALT_SIZE);
} else {
ALOGE("Mandory parameters are not present\n");
return WIFI_ERROR_INVALID_ARGS;
}
if (key_info->body.passphrase_info.passphrase_len < NAN_SECURITY_MIN_PASSPHRASE_LEN ||
key_info->body.passphrase_info.passphrase_len > NAN_SECURITY_MAX_PASSPHRASE_LEN) {
ALOGE("passphrase must be between %d and %d characters long\n",
NAN_SECURITY_MIN_PASSPHRASE_LEN,
NAN_SECURITY_MAX_PASSPHRASE_LEN);
return WIFI_ERROR_INVALID_ARGS;
}
result = PKCS5_PBKDF2_HMAC((const char *) key_info->body.passphrase_info.passphrase,
key_info->body.passphrase_info.passphrase_len, salt, sizeof(salt),
4096, ((cipher_type == NAN_CIPHER_SUITE_SHARED_KEY_128_MASK) ?
(const EVP_MD *)EVP_sha256():(const EVP_MD *)EVP_sha384()), NAN_PMK_INFO_LEN, pmk_hex);
prhex("PMK_HEX", pmk_hex, 32);
NAN_DBG_EXIT();
return result;
}
typedef void *NanRequest;
nan_hal_info_t info;
#define SVC_LIST(info) ((info).svc_list)
#define SVC_LIST_SIZE(info) ((info).svc_list.total_items)
#define DP_SVC_LIST(info) ((info).dp_svc_list)
#define DP_SVC_LIST_SIZE(info) ((info).dp_svc_list.total_items)
#define NAN_HANDLE(info) ((info).nan_handle)
#define GET_NAN_HANDLE(info) ((NanHandle *)info.nan_handle)
#define NAN_MAC_CONTROL(info) ((info).nan_mac_control)
///////////////////////////////////////////////////////////////////////////////
class NanHandle
{
public:
NanCallbackHandler mHandlers;
NanHandle(wifi_handle handle, NanCallbackHandler handlers):mHandlers(handlers)
{}
};
void HandleExpiryEvent(nan_hal_info_t info, nlattr *vendor_data) {
ALOGI("Received NAN_EVENT_MATCH_EXPIRY\n");
u16 attr_type;
NanMatchExpiredInd expired_event;
memset(&expired_event, 0, sizeof(NanMatchExpiredInd));
for (nl_iterator it(vendor_data); it.has_next(); it.next()) {
attr_type = it.get_type();
if (attr_type == NAN_ATTRIBUTE_SUBSCRIBE_ID) {
expired_event.publish_subscribe_id = it.get_u16();
ALOGI("pub_sub id = %u\n",
expired_event.publish_subscribe_id);
} else if (attr_type == NAN_ATTRIBUTE_PUBLISH_ID) {
expired_event.requestor_instance_id = it.get_u32();
ALOGI("req_inst id = %u\n", expired_event.requestor_instance_id);
}
}
if (expired_event.requestor_instance_id && expired_event.publish_subscribe_id) {
GET_NAN_HANDLE(info)->mHandlers.EventMatchExpired(&expired_event);
} else {
ALOGE("Invalid values for notifying the expired event, dropping the event\n");
}
}
///////////////////////////////////////////////////////////////////////////////
class NanDiscEnginePrimitive : public WifiCommand
{
NanRequest mParams;
NanRequestType mType;
u16 mInstId;
u32 mPeerId;
u16 mTxId;
public:
NanDiscEnginePrimitive(wifi_interface_handle iface, int id,
NanRequest params, NanRequestType cmdType)
: WifiCommand("NanCommand", iface, id), mParams(params), mType(cmdType)
{
mInstId = 0;
mPeerId = 0;
setTransactionId(id);
}
~NanDiscEnginePrimitive() {
ALOGE("NanDiscEnginePrimitive destroyed\n");
}
void setType(NanRequestType type) {
mType = type;
}
void setInstId(u16 inst_id) {
mInstId = inst_id;
}
int getInstanceId() {
return mInstId;
}
void setTransactionId(u16 tx_id) {
mTxId = tx_id;
}
int getTransactionId() {
return mTxId;
}
void setParams(NanRequest params) {
mParams = params;
}
int createRequest(WifiRequest& request)
{
ALOGI("NAN CMD: %s\n", NanCmdToString(mType));
if (mType == NAN_REQUEST_SUBSCRIBE) {
return createSubscribeRequest(request,
(NanSubscribeRequest *)mParams);
} else if (mType == NAN_REQUEST_SUBSCRIBE_CANCEL) {
return createSubscribeCancelRequest(request,
(NanSubscribeCancelRequest *)mParams);
} else if (mType == NAN_REQUEST_PUBLISH) {
return createPublishRequest(request,
(NanPublishRequest *)mParams);
} else if (mType == NAN_REQUEST_PUBLISH_CANCEL) {
return createPublishCancelRequest(request,
(NanPublishCancelRequest *)mParams);
} else if (mType == NAN_REQUEST_TRANSMIT_FOLLOWUP) {
return createTransmitFollowupRequest(request,
(NanTransmitFollowupRequest *)mParams);
} else if (mType == NAN_REQUEST_GET_CAPABILTIES) {
return getCapabilitiesRequest(request);
} else {
ALOGE("%s Unknown Nan request\n", __func__);
}
return WIFI_SUCCESS;
}
int createPublishRequest(WifiRequest& request, NanPublishRequest *mParams)
{
NAN_DBG_ENTER();
u8 pmk_hex[NAN_PMK_INFO_LEN];
int result = request.create(GOOGLE_OUI, NAN_SUBCMD_PUBLISH);
if (result < 0) {
ALOGE("%s Failed to create request, result = %d\n", __func__, result);
return result;
}
/* If handle is 0xFFFF, then update instance_id in response of this request
* otherwise, update not needed
*/
mInstId = mParams->publish_id;
nlattr *data = request.attr_start(NL80211_ATTR_VENDOR_DATA);
result = request.put_u32(NAN_ATTRIBUTE_PUBLISH_ID, mInstId);
if (result < 0) {
ALOGE("%s: Failed to fill pub id, result = %d\n", __func__, result);
return result;
}
result = request.put_u16(NAN_ATTRIBUTE_TTL, mParams->ttl);
if (result < 0) {
ALOGE("%s: Failed to fill ttl, result = %d\n", __func__, result);
return result;
}
if (ISGREATER(mParams->period, NAN_MAX_PERIOD)) {
ALOGE("%s:Invalid period value.\n", __FUNCTION__);
return WIFI_ERROR_NOT_SUPPORTED;
}
result = request.put_u16(NAN_ATTRIBUTE_PERIOD, mParams->period);
if (result < 0) {
ALOGE("%s: Failed to fill period, result = %d\n", __func__, result);
return result;
}
result = request.put_u8(NAN_ATTRIBUTE_PUBLISH_TYPE, mParams->publish_type);
if (result < 0) {
ALOGE("%s: Failed to fill pub type, result = %d\n", __func__, result);
return result;
}
result = request.put_u8(NAN_ATTRIBUTE_TX_TYPE, mParams->tx_type);
if (result < 0) {
ALOGE("%s: Failed to fill tx type, result = %d\n", __func__, result);
return result;
}
result = request.put_u8(NAN_ATTRIBUTE_PUBLISH_COUNT, mParams->publish_count);
if (result < 0) {
ALOGE("%s: Failed to fill pub cnt, result = %d\n", __func__, result);
return result;
}
if (mParams->service_name_len) {
u8 svc_hash[NAN_SVC_HASH_SIZE];
u16 len = min(mParams->service_name_len, sizeof(mParams->service_name) - 1);
mParams->service_name[len] = '\0';
result = get_svc_hash(mParams->service_name, mParams->service_name_len,
svc_hash, NAN_SVC_HASH_SIZE);
if (result < 0) {
ALOGE("%s: Failed to get hashed svc name\n", __func__);
return result;
}
mParams->service_name_len = NAN_SVC_HASH_SIZE;
memcpy(mParams->service_name, svc_hash, mParams->service_name_len);
result = request.put_u16(NAN_ATTRIBUTE_SERVICE_NAME_LEN, mParams->service_name_len);
if (result < 0) {
ALOGE("%s: Failed to fill svc name len, result = %d\n", __func__, result);
return result;
}
result = request.put(NAN_ATTRIBUTE_SERVICE_NAME, (void *)mParams->service_name,
mParams->service_name_len);
if (result < 0) {
ALOGE("%s: Failed to fill svc name, result = %d\n", __func__, result);
return result;
}
}
if (mParams->service_specific_info_len) {
result = request.put_u16(NAN_ATTRIBUTE_SERVICE_SPECIFIC_INFO_LEN,
mParams->service_specific_info_len);
if (result < 0) {
ALOGE("%s: Failed to fill svc info len, result = %d\n", __func__, result);
return result;
}
result = request.put(NAN_ATTRIBUTE_SERVICE_SPECIFIC_INFO,
(void *)mParams->service_specific_info, mParams->service_specific_info_len);
if (result < 0) {
ALOGE("%s: Failed to fill svc info, result = %d\n", __func__, result);
return result;
}
}
if (mParams->rx_match_filter_len) {
result = request.put_u16(NAN_ATTRIBUTE_RX_MATCH_FILTER_LEN,
mParams->rx_match_filter_len);
if (result < 0) {
ALOGE("%s: Failed to fill rx match filter len, result = %d\n",
__func__, result);
return result;
}
prhex(NULL, mParams->rx_match_filter, mParams->rx_match_filter_len);
result = request.put(NAN_ATTRIBUTE_RX_MATCH_FILTER,
(void *)mParams->rx_match_filter, mParams->rx_match_filter_len);
if (result < 0) {
ALOGE("%s: Failed to fill rx match filter, result = %d\n", __func__, result);
return result;
}
}
if (mParams->tx_match_filter_len) {
result = request.put_u16(NAN_ATTRIBUTE_TX_MATCH_FILTER_LEN,
mParams->tx_match_filter_len);
if (result < 0) {
ALOGE("%s: Failed to fill tx match filter, result = %d\n", __func__, result);
return result;
}
prhex(NULL, mParams->tx_match_filter, mParams->tx_match_filter_len);
result = request.put(NAN_ATTRIBUTE_TX_MATCH_FILTER,
(void *)mParams->tx_match_filter, mParams->tx_match_filter_len);
if (result < 0) {
ALOGE("%s: Failed to fill tx match filter, result = %d\n",
__func__, result);
return result;
}
}
result = request.put_u8(NAN_ATTRIBUTE_PUBLISH_MATCH, mParams->publish_match_indicator);
if (result < 0) {
ALOGE("%s: Failed to fill NAN_ATTRIBUTE_PUBLISH_MATCH, result = %d\n",
__func__, result);
return result;
}
if (ISGREATER(mParams->recv_indication_cfg, NAN_PUB_RECV_FLAG_MAX)) {
ALOGE("%s:Invalid recv_flag value.\n", __FUNCTION__);
return WIFI_ERROR_NOT_SUPPORTED;
}
result = request.put_u8(NAN_ATTRIBUTE_RECV_IND_CFG,
mParams->recv_indication_cfg);
if (result < 0) {
ALOGE("%s: Failed to fill NAN_ATTRIBUTE_RECV_IND_CFG, result = %d\n",
__func__, result);
return result;
}
result = request.put_u8(NAN_ATTRIBUTE_CIPHER_SUITE_TYPE,
mParams->cipher_type);
if (result < 0) {
ALOGE("%s: Failed to fill NAN_ATTRIBUTE_CIPHER_SUITE_TYPE, result = %d\n",
__func__, result);
return result;
}
result = request.put_u8(NAN_ATTRIBUTE_KEY_TYPE,
mParams->key_info.key_type);
if (result < 0) {
ALOGE("%s: Failed to fill NAN_ATTRIBUTE_KEY_TYPE, result = %d\n",
__func__, result);
return result;
}
if (mParams->key_info.key_type == NAN_SECURITY_KEY_INPUT_PMK) {
if (mParams->key_info.body.pmk_info.pmk_len) {
result = request.put_u32(NAN_ATTRIBUTE_KEY_LEN,
mParams->key_info.body.pmk_info.pmk_len);
if (result < 0) {
ALOGE("%s: Failed to fill pmk len, result = %d\n", __func__, result);
return result;
}
result = request.put(NAN_ATTRIBUTE_KEY_DATA,
(void *)mParams->key_info.body.pmk_info.pmk,
mParams->key_info.body.pmk_info.pmk_len);
if (result < 0) {
ALOGE("%s: Failed to fill pmk, result = %d\n", __func__, result);
return result;
}
}
}
if (mParams->key_info.key_type == NAN_SECURITY_KEY_INPUT_PASSPHRASE) {
if (mParams->key_info.body.passphrase_info.passphrase_len < NAN_SECURITY_MIN_PASSPHRASE_LEN ||
mParams->key_info.body.passphrase_info.passphrase_len > NAN_SECURITY_MAX_PASSPHRASE_LEN) {
ALOGE("passphrase must be between %d and %d characters long\n",
NAN_SECURITY_MIN_PASSPHRASE_LEN,
NAN_SECURITY_MAX_PASSPHRASE_LEN);
return NAN_STATUS_INVALID_PARAM;
} else {
memset(pmk_hex, 0, NAN_PMK_INFO_LEN);
result = passphrase_to_pmk(mNmi, mParams->cipher_type,
mParams->service_name, &mParams->key_info, pmk_hex);
if (result < 0) {
ALOGE("%s: Failed to convert passphrase to key data, result = %d\n", __func__, result);
return result;
}
result = request.put_u32(NAN_ATTRIBUTE_KEY_LEN, NAN_PMK_INFO_LEN);
if (result < 0) {
ALOGE("%s: Failed to fill passphrase len, result = %d\n", __func__, result);
return result;
}
result = request.put(NAN_ATTRIBUTE_KEY_DATA, pmk_hex, NAN_PMK_INFO_LEN);
if (result < 0) {
ALOGE("%s: Failed to fill passphrase, result = %d\n", __func__, result);
return result;
}
}
}
if (mParams->scid_len) {
if ((mParams->scid_len > NAN_MAX_SCID_BUF_LEN) ||
(mParams->scid_len % NAN_SCID_INFO_LEN)) {
ALOGE("%s: Invalid scid len, = %d\n", __func__, mParams->scid_len);
return NAN_STATUS_INVALID_PARAM;
}
result = request.put_u32(NAN_ATTRIBUTE_SCID_LEN,
mParams->scid_len);
if (result < 0) {
ALOGE("%s: Failed to fill scid len, result = %d\n", __func__, result);
return result;
}
prhex(NULL, mParams->scid, mParams->scid_len);
result = request.put(NAN_ATTRIBUTE_SCID,
(void *)mParams->scid, mParams->scid_len);
if (result < 0) {
ALOGE("%s: Failed to fill scid, result = %d\n", __func__, result);
return result;
}
}
result = request.put_u8(NAN_ATTRIBUTE_SDE_CONTROL_CONFIG_DP,
mParams->sdea_params.config_nan_data_path);
if (result < 0) {
ALOGE("%s: Failed to fill NAN_ATTRIBUTE_SDE_CONTROL_CONFIG_DP, result = %d\n", __func__, result);
return result;
}
result = request.put_u8(NAN_ATTRIBUTE_SDE_CONTROL_SECURITY,
mParams->sdea_params.security_cfg);
if (result < 0) {
ALOGE("%s: Failed to fill NAN_ATTRIBUTE_SDE_CONTROL_SECURITY, result = %d\n", __func__, result);
return result;
}
result = request.put_u8(NAN_ATTRIBUTE_SDE_CONTROL_DP_TYPE,
mParams->sdea_params.ndp_type);
if (result < 0) {
ALOGE("%s: Failed to fill NAN_ATTRIBUTE_SDE_CONTROL_DP_TYPE, result = %d\n", __func__, result);
return result;
}
result = request.put_u8(NAN_ATTRIBUTE_SDE_CONTROL_RANGE_SUPPORT,
mParams->sdea_params.ranging_state);
if (result < 0) {
ALOGE("%s: Failed to fill NAN_ATTRIBUTE_SDE_CONTROL_RANGE_SUPPORT, result = %d\n", __func__, result);
return result;
}
result = request.put_u8(NAN_ATTRIBUTE_RSSI_THRESHOLD_FLAG,
mParams->rssi_threshold_flag);
if (result < 0) {
ALOGE("%s: Failed to fill NAN_ATTRIBUTE_RSSI_THRESHOLD_FLAG, result = %d\n",
__func__, result);
return result;
}
if (mParams->sdea_service_specific_info_len) {
result = request.put_u16(NAN_ATTRIBUTE_SDEA_SERVICE_SPECIFIC_INFO_LEN,
mParams->sdea_service_specific_info_len);
if (result < 0) {
ALOGE("%s: Failed to fill sdea svc info len, result = %d\n", __func__, result);
return result;
}
prhex(NULL, mParams->sdea_service_specific_info, mParams->sdea_service_specific_info_len);
result = request.put(NAN_ATTRIBUTE_SDEA_SERVICE_SPECIFIC_INFO,
(void *)mParams->sdea_service_specific_info, mParams->sdea_service_specific_info_len);
if (result < 0) {
ALOGE("%s: Failed to fill sdea svc info, result = %d\n", __func__, result);
return result;
}
}
result = request.put_u8(NAN_ATTRIBUTE_SVC_RESPONDER_POLICY,
mParams->service_responder_policy);
if (result < 0) {
ALOGE("%s: Failed to fill NAN_ATTRIBUTE_SVC_RESPONDER_POLICY, result = %d\n",
__func__, result);
return result;
}
request.attr_end(data);
ALOGI("Returning successfully\n");
NAN_DBG_EXIT();
return result;
}
int createPublishCancelRequest(WifiRequest& request, NanPublishCancelRequest *mParams)
{
int result = request.create(GOOGLE_OUI, NAN_SUBCMD_PUBLISH_CANCEL);
if (result < 0) {
ALOGE("%s: Failed to create request, result = %d\n", __func__, result);
return result;
}
NAN_DBG_ENTER();
nlattr *data = request.attr_start(NL80211_ATTR_VENDOR_DATA);
if (ISGREATER(mInstId, NAN_MAX)) {
ALOGE("%s:Invalid publish count value.\n", __FUNCTION__);
return WIFI_ERROR_NOT_SUPPORTED;
}
ALOGI("%s: pub id = %d, inst_id = %d\n", __func__, mParams->publish_id, mInstId);
result = request.put_u32(NAN_ATTRIBUTE_PUBLISH_ID, mInstId);
if (result < 0) {
ALOGE("%s: Failed to fill NAN_ATTRIBUTE_PUBLISH_ID, result = %d\n",
__func__, result);
return result;
}
request.attr_end(data);
NAN_DBG_EXIT();
return WIFI_SUCCESS;
}
int createSubscribeRequest(WifiRequest& request, NanSubscribeRequest *mParams)
{
int result = request.create(GOOGLE_OUI, NAN_SUBCMD_SUBSCRIBE);
if (result < 0) {
ALOGE("%s Failed to create request\n", __func__);
return result;
}
NAN_DBG_ENTER();
/* If handle is 0xFFFF, then update instance_id in response of this request
* otherwise, update not needed
*/
mInstId = mParams->subscribe_id;
nlattr *data = request.attr_start(NL80211_ATTR_VENDOR_DATA);
result = request.put_u16(NAN_ATTRIBUTE_SUBSCRIBE_ID, mInstId);
if (result < 0) {
ALOGE("%s: Failed to fill sub id, result = %d\n", __func__, result);
return result;
}
result = request.put_u16(NAN_ATTRIBUTE_TTL, mParams->ttl);
if (result < 0) {
ALOGE("%s: Failed to fill ttl, result = %d\n", __func__, result);
return result;
}
if (ISGREATER(mParams->period, NAN_MAX_PERIOD)) {
ALOGE("%s:Invalid period value.\n", __FUNCTION__);
return WIFI_ERROR_NOT_SUPPORTED;
}
result = request.put_u16(NAN_ATTRIBUTE_PERIOD, mParams->period);
if (result < 0) {
ALOGE("%s: Failed to fill period, result = %d\n", __func__, result);
return result;
}
result = request.put_u8(NAN_ATTRIBUTE_SUBSCRIBE_TYPE, mParams->subscribe_type);
if (result < 0) {
ALOGE("%s: Failed to fill sub type, result = %d\n", __func__, result);
return result;
}
result = request.put_u8(NAN_ATTRIBUTE_SERVICERESPONSEFILTER,
mParams->serviceResponseFilter);
if (result < 0) {
ALOGE("%s: Failed to fill svc resp filter, result = %d\n", __func__, result);
return result;
}
result = request.put_u8(NAN_ATTRIBUTE_SERVICERESPONSEINCLUDE,
mParams->serviceResponseInclude);
if (result < 0) {
ALOGE("%s: Failed to fill svc resp include, result = %d\n", __func__, result);
return result;
}
result = request.put_u8(NAN_ATTRIBUTE_USESERVICERESPONSEFILTER,
mParams->useServiceResponseFilter);
if (result < 0) {
ALOGE("%s: Failed to fill use svc resp filter, result = %d\n", __func__, result);
return result;
}
result = request.put_u8(NAN_ATTRIBUTE_SSIREQUIREDFORMATCHINDICATION,
mParams->ssiRequiredForMatchIndication);
if (result < 0) {
ALOGE("%s: Failed to fill ssi req match ind, result = %d\n", __func__, result);
return result;
}
result = request.put_u8(NAN_ATTRIBUTE_SUBSCRIBE_MATCH,
mParams->subscribe_match_indicator);
if (result < 0) {
ALOGE("%s: Failed to fill sub match, result = %d\n", __func__, result);
return result;
}
result = request.put_u8(NAN_ATTRIBUTE_SUBSCRIBE_COUNT, mParams->subscribe_count);
if (result < 0) {
ALOGE("%s: Failed to fill sub cnt, result = %d\n", __func__, result);
return result;
}
if (mParams->service_name_len) {
u8 svc_hash[NAN_SVC_HASH_SIZE];
u16 len = min(mParams->service_name_len, sizeof(mParams->service_name) - 1);
mParams->service_name[len] = '\0';
result = get_svc_hash(mParams->service_name, mParams->service_name_len,
svc_hash, NAN_SVC_HASH_SIZE);
if (result < 0) {
ALOGE("%s: Failed to get hashed svc name\n", __func__);
return result;
}
mParams->service_name_len = NAN_SVC_HASH_SIZE;
memcpy(mParams->service_name, svc_hash, mParams->service_name_len);
result = request.put_u16(NAN_ATTRIBUTE_SERVICE_NAME_LEN, mParams->service_name_len);
if (result < 0) {
ALOGE("%s: Failed to fill svc hash len, result = %d\n",
__func__, result);
return result;
}
result = request.put(NAN_ATTRIBUTE_SERVICE_NAME, (void *)mParams->service_name,
mParams->service_name_len);
if (result < 0) {
ALOGE("%s: Failed to fill hashed svc name, result = %d\n", __func__, result);
return result;
}
}
if (mParams->service_specific_info_len) {
result = request.put_u16(NAN_ATTRIBUTE_SERVICE_SPECIFIC_INFO_LEN,
mParams->service_specific_info_len);
if (result < 0) {
ALOGE("%s: Failed to fill svc info len, result = %d\n", __func__, result);
return result;
}
result = request.put(NAN_ATTRIBUTE_SERVICE_SPECIFIC_INFO,
(void *)mParams->service_specific_info, mParams->service_specific_info_len);
if (result < 0) {
ALOGE("%s: Failed to fill svc info, result = %d\n", __func__, result);
return result;
}
}
if (mParams->rx_match_filter_len) {
result = request.put_u16(NAN_ATTRIBUTE_RX_MATCH_FILTER_LEN,
mParams->rx_match_filter_len);
if (result < 0) {
ALOGE("%s: Failed to fill rx match filter len, result = %d\n", __func__, result);
return result;
}
prhex(NULL, mParams->rx_match_filter, mParams->rx_match_filter_len);
result = request.put(NAN_ATTRIBUTE_RX_MATCH_FILTER,
(void *)mParams->rx_match_filter, mParams->rx_match_filter_len);
if (result < 0) {
ALOGE("%s: Failed to fill rx match filter, result = %d\n", __func__, result);
return result;
}
}
if (mParams->tx_match_filter_len) {
result = request.put_u16(NAN_ATTRIBUTE_TX_MATCH_FILTER_LEN,
mParams->tx_match_filter_len);
if (result < 0) {
ALOGE("%s: Failed to fill tx match filter len, result = %d\n", __func__, result);
return result;
}
prhex(NULL, mParams->tx_match_filter, mParams->tx_match_filter_len);
result = request.put(NAN_ATTRIBUTE_TX_MATCH_FILTER,
(void *)mParams->tx_match_filter, mParams->tx_match_filter_len);
if (result < 0) {
ALOGE("%s: Failed to fill tx match filter, result = %d\n", __func__, result);
return result;
}
}
if (mParams->num_intf_addr_present > NAN_MAX_SUBSCRIBE_MAX_ADDRESS) {
ALOGE("%s: Number of mac addrs: %d have crossed the threshold, fail to subscribe\n",
__func__, mParams->num_intf_addr_present);
return WIFI_ERROR_NOT_SUPPORTED;
} else if (mParams->num_intf_addr_present) {
result = request.put_u16(NAN_ATTRIBUTE_MAC_ADDR_LIST_NUM_ENTRIES,
mParams->num_intf_addr_present);
if (result < 0) {
ALOGE("%s: Failed to fill mac addr list no, result = %d\n",
__func__, result);
return result;
}
prhex(NULL, (u8 *)mParams->intf_addr,
(mParams->num_intf_addr_present * NAN_MAC_ADDR_LEN));
result = request.put(NAN_ATTRIBUTE_MAC_ADDR_LIST, (void *)mParams->intf_addr,
(mParams->num_intf_addr_present * NAN_MAC_ADDR_LEN));
if (result < 0) {
ALOGE("%s: Failed to fill mac addr list, result = %d\n", __func__, result);
return result;
}
}
if (ISGREATER(mParams->recv_indication_cfg, NAN_SUB_RECV_FLAG_MAX)) {
ALOGE("%s:Invalid recv_flag value.\n", __FUNCTION__);
return WIFI_ERROR_NOT_SUPPORTED;
}
result = request.put_u8(NAN_ATTRIBUTE_RECV_IND_CFG,
mParams->recv_indication_cfg);
if (result < 0) {
ALOGE("%s: Failed to fill recv_indication_cfg, result = %d\n",
__func__, result);
return result;
}
result = request.put_u8(NAN_ATTRIBUTE_CIPHER_SUITE_TYPE,
mParams->cipher_type);
if (result < 0) {
ALOGE("%s: Failed to fill NAN_ATTRIBUTE_CIPHER_SUITE_TYPE, result = %d\n",
__func__, result);
return result;
}
result = request.put_u8(NAN_ATTRIBUTE_KEY_TYPE,
mParams->key_info.key_type);
if (result < 0) {
ALOGE("%s: Failed to fill NAN_ATTRIBUTE_KEY_TYPE, result = %d\n",
__func__, result);
return result;
}
if (mParams->key_info.key_type == NAN_SECURITY_KEY_INPUT_PMK) {
if (mParams->key_info.body.pmk_info.pmk_len) {
result = request.put_u32(NAN_ATTRIBUTE_KEY_LEN,
mParams->key_info.body.pmk_info.pmk_len);
if (result < 0) {
ALOGE("%s: Failed to fill pmk len, result = %d\n", __func__, result);
return result;
}
result = request.put(NAN_ATTRIBUTE_KEY_DATA,
(void *)mParams->key_info.body.pmk_info.pmk,
mParams->key_info.body.pmk_info.pmk_len);
if (result < 0) {
ALOGE("%s: Failed to fill pmk, result = %d\n", __func__, result);
return result;
}
}
}
if (mParams->scid_len) {
if (mParams->scid_len != NAN_SCID_INFO_LEN) {
ALOGE("%s: Invalid scid len, = %d\n", __func__, mParams->scid_len);
return NAN_STATUS_INVALID_PARAM;
}
result = request.put_u32(NAN_ATTRIBUTE_SCID_LEN,
mParams->scid_len);
if (result < 0) {
ALOGE("%s: Failed to fill scid len, result = %d\n", __func__, result);
return result;
}
result = request.put(NAN_ATTRIBUTE_SCID,
(void *)mParams->scid, mParams->scid_len);
if (result < 0) {
ALOGE("%s: Failed to fill scid, result = %d\n", __func__, result);
return result;
}
}
result = request.put_u8(NAN_ATTRIBUTE_SDE_CONTROL_CONFIG_DP,
mParams->sdea_params.config_nan_data_path);
if (result < 0) {
ALOGE("%s: Failed to fill config_nan_data_path, result = %d\n", __func__, result);
return result;
}
result = request.put_u8(NAN_ATTRIBUTE_SDE_CONTROL_SECURITY,
mParams->sdea_params.security_cfg);
if (result < 0) {
ALOGE("%s: Failed to fill security_cfg, result = %d\n", __func__, result);
return result;
}
result = request.put_u8(NAN_ATTRIBUTE_SDE_CONTROL_DP_TYPE,
mParams->sdea_params.ndp_type);
if (result < 0) {
ALOGE("%s: Failed to fill ndp_type, result = %d\n", __func__, result);
return result;
}
result = request.put_u8(NAN_ATTRIBUTE_SDE_CONTROL_RANGE_SUPPORT,
mParams->sdea_params.ranging_state);
if (result < 0) {
ALOGE("%s: Failed to fill ranging state, result = %d\n", __func__, result);
return result;
}
if (mParams->sdea_params.ranging_state == NAN_RANGING_ENABLE) {
result = request.put_u32(NAN_ATTRIBUTE_RANGING_INTERVAL,
mParams->ranging_cfg.ranging_interval_msec);
if (result < 0) {
ALOGE("%s: Failed to fill ranging_interval_msec, result = %d\n", __func__, result);
return result;
}
result = request.put_u32(NAN_ATTRIBUTE_RANGING_EGRESS_LIMIT,
mParams->ranging_cfg.distance_egress_mm);
if (result < 0) {
ALOGE("%s: Failed to fill distance_egress_mm, result = %d\n", __func__, result);
return result;
}
result = request.put_u32(NAN_ATTRIBUTE_RANGING_INDICATION,
mParams->ranging_cfg.config_ranging_indications);
if (result < 0) {
ALOGE("%s: Failed to fill config_ranging_indications, result = %d\n", __func__, result);
return result;
}
result = request.put_u32(NAN_ATTRIBUTE_RANGING_INGRESS_LIMIT,
mParams->ranging_cfg.distance_ingress_mm);
if (result < 0) {
ALOGE("%s: Failed to fill distance_ingress_mm, result = %d\n", __func__, result);
return result;
}
}
ALOGI("%s:RSSI threshold flag %d", __func__, mParams->rssi_threshold_flag);
result = request.put_u8(NAN_ATTRIBUTE_RSSI_THRESHOLD_FLAG,
mParams->rssi_threshold_flag);
if (result < 0) {
ALOGE("%s: Failed to fill rssi_threshold_flag, result = %d\n",
__func__, result);
return result;
}
if (mParams->sdea_service_specific_info_len) {
result = request.put_u16(NAN_ATTRIBUTE_SDEA_SERVICE_SPECIFIC_INFO_LEN,
mParams->sdea_service_specific_info_len);
if (result < 0) {
ALOGE("%s: Failed to fill sdea svc info len, result = %d\n", __func__, result);
return result;
}
prhex(NULL, mParams->sdea_service_specific_info, mParams->sdea_service_specific_info_len);
result = request.put(NAN_ATTRIBUTE_SDEA_SERVICE_SPECIFIC_INFO,
(void *)mParams->sdea_service_specific_info, mParams->sdea_service_specific_info_len);
if (result < 0) {
ALOGE("%s: Failed to fill sdea svc info, result = %d\n", __func__, result);
return result;
}
}
request.attr_end(data);
NAN_DBG_EXIT();
return WIFI_SUCCESS;
}
int createSubscribeCancelRequest(WifiRequest& request,
NanSubscribeCancelRequest *mParams) {
int result = request.create(GOOGLE_OUI, NAN_SUBCMD_SUBSCRIBE_CANCEL);
if (result < 0) {
ALOGE("%s Failed to create request \n", __func__);
return result;
}
NAN_DBG_ENTER();
nlattr *data = request.attr_start(NL80211_ATTR_VENDOR_DATA);
if (ISGREATER(mInstId, NAN_MAX)) {
ALOGE("%s:Invalid subscribe id value.\n", __FUNCTION__);
return WIFI_ERROR_NOT_SUPPORTED;
}
ALOGI("%s: sub id = %u\n", __func__, mInstId);
result = request.put_u16(NAN_ATTRIBUTE_SUBSCRIBE_ID, mInstId);
if (result < 0) {
ALOGE("%s: Failed to fill sub id, result = %d\n", __func__, result);
return result;
}
request.attr_end(data);
NAN_DBG_EXIT();
return WIFI_SUCCESS;
}
int createTransmitFollowupRequest(WifiRequest& request,
NanTransmitFollowupRequest *mParams)
{
int result = request.create(GOOGLE_OUI, NAN_SUBCMD_TRANSMIT_FOLLOWUP);
if (result < 0) {
ALOGE("%s Failed to create request \n", __func__);
return result;
}
NAN_DBG_ENTER();
/* If handle is 0xFFFF, then update instance_id in response of this request
* otherwise, update not needed
*/
mInstId = mParams->publish_subscribe_id;
mPeerId = mParams->requestor_instance_id;
mTxId = getTransactionId();
nlattr *data = request.attr_start(NL80211_ATTR_VENDOR_DATA);
result = request.put_u32(NAN_ATTRIBUTE_PEER_ID, mPeerId);
if (result < 0) {
ALOGE("%s: Failed to fill peer id, result = %d\n", __func__, result);
return result;
}
result = request.put_u16(NAN_ATTRIBUTE_INST_ID, mInstId);
if (result < 0) {
ALOGE("%s Failed to fill inst id = %d \n", __func__, mInstId);
return result;
}
result = request.put_addr(NAN_ATTRIBUTE_MAC_ADDR, mParams->addr);
if (result < 0) {
ALOGE("%s: Failed to fill mac addr\n", __func__);
return result;
}
if (mParams->service_specific_info_len > 0) {
u16 len = min(mParams->service_specific_info_len,
sizeof(mParams->service_specific_info) - 1);
result = request.put_u16(NAN_ATTRIBUTE_SERVICE_SPECIFIC_INFO_LEN,
mParams->service_specific_info_len);
if (result < 0) {
ALOGE("%s: Failed to fill svc info len \n", __func__);
return result;
}
prhex(NULL, mParams->service_specific_info, mParams->service_specific_info_len);
result = request.put(NAN_ATTRIBUTE_SERVICE_SPECIFIC_INFO,
(void *)mParams->service_specific_info, mParams->service_specific_info_len);
if (result < 0) {
ALOGE("%s: Failed to put svc info, result = %d", __func__, result);
return result;
}
mParams->service_specific_info[len] = '\0';
ALOGI("Transmit service info string is %s\n", mParams->service_specific_info);
}
if (ISGREATER(mParams->recv_indication_cfg, NAN_PUB_RECV_FLAG_MAX)) {
ALOGE("%s:Invalid recv_flag value.\n", __FUNCTION__);
return WIFI_ERROR_NOT_SUPPORTED;
}
result = request.put_u8(NAN_ATTRIBUTE_RECV_IND_CFG,
mParams->recv_indication_cfg);
if (result < 0) {
ALOGE("%s: Failed to fill NAN_ATTRIBUTE_RECV_IND_CFG, result = %d\n",
__func__, result);
return result;
}
result = request.put_u16(NAN_ATTRIBUTE_TRANSAC_ID, mTxId);
if (result < 0) {
ALOGE("%s: Failed to fill NAN_ATTRIBUTE_TRANSAC_ID, result = %d\n",
__func__, result);
return result;
}
if (mParams->sdea_service_specific_info_len) {
result = request.put_u16(NAN_ATTRIBUTE_SDEA_SERVICE_SPECIFIC_INFO_LEN,
mParams->sdea_service_specific_info_len);
if (result < 0) {
ALOGE("%s: Failed to fill sdea svc info len, result = %d\n", __func__, result);
return result;
}
prhex(NULL, mParams->sdea_service_specific_info, mParams->sdea_service_specific_info_len);
result = request.put(NAN_ATTRIBUTE_SDEA_SERVICE_SPECIFIC_INFO,
(void *)mParams->sdea_service_specific_info, mParams->sdea_service_specific_info_len);
if (result < 0) {
ALOGE("%s: Failed to fill sdea svc info, result = %d\n", __func__, result);
return result;
}
}
request.attr_end(data);
NAN_DBG_EXIT();
return WIFI_SUCCESS;
}
int getCapabilitiesRequest(WifiRequest& request) {
int result = 0;
NAN_DBG_ENTER();
result = request.create(GOOGLE_OUI, NAN_SUBCMD_GET_CAPABILITIES);
if (result < 0) {
ALOGE("%s Failed to create request \n", __func__);
return result;
}
nlattr *data = request.attr_start(NL80211_ATTR_VENDOR_DATA);
request.attr_end(data);
NAN_DBG_EXIT();
return WIFI_SUCCESS;
}
int start()
{
int result = 0;
WifiRequest request(familyId(), ifaceId());
result = createRequest(request);
if (result != WIFI_SUCCESS) {
ALOGE("%s: Failed to create setup request; result = %d\n", __func__, result);
return result;
}
result = requestResponse(request);
if (result != WIFI_SUCCESS) {
ALOGE("%s: Failed to configure setup; result = %d\n", __func__, result);
return result;
}
request.destroy();
return WIFI_SUCCESS;
}
virtual bool valid_disc_response_type(int response_type) {
bool valid = false;
switch(response_type) {
case NAN_RESPONSE_PUBLISH:
case NAN_RESPONSE_SUBSCRIBE:
case NAN_GET_CAPABILITIES:
case NAN_RESPONSE_PUBLISH_CANCEL:
case NAN_RESPONSE_SUBSCRIBE_CANCEL:
case NAN_RESPONSE_TRANSMIT_FOLLOWUP:
valid = true;
break;
default:
ALOGE("NanDiscEnginePrmitive:Unknown cmd Response: %d\n", response_type);
break;
}
return valid;
}
int handleResponse(WifiEvent& reply)
{
nan_hal_resp_t *rsp_vndr_data = NULL;
NanResponseMsg rsp_data;
if (reply.get_cmd() != NL80211_CMD_VENDOR || reply.get_vendor_data() == NULL) {
ALOGD("Ignoring reply with cmd = %d", reply.get_cmd());
return NL_SKIP;
}
rsp_vndr_data = (nan_hal_resp_t *)reply.get_vendor_data();
ALOGI("NanDiscEnginePrmitive::handle response\n");
memset(&rsp_data, 0, sizeof(NanResponseMsg));
rsp_data.response_type = get_response_type((WIFI_SUB_COMMAND)rsp_vndr_data->subcmd);
if (!valid_disc_response_type(rsp_data.response_type))
return NL_SKIP;
rsp_data.status = nan_map_response_status(rsp_vndr_data->status);
ALOGE("Mapped hal status = %d\n", rsp_data.status);
if (rsp_vndr_data->nan_reason[0] == '\0') {
memcpy(rsp_data.nan_error, NanStatusToString(rsp_data.status),
strlen(NanStatusToString(rsp_data.status)));
rsp_data.nan_error[strlen(NanStatusToString(rsp_data.status))] = '\0';
}
rsp_data.nan_error[NAN_ERROR_STR_LEN - 1] = '\0';
ALOGI("\n Received nan_error string %s\n", (u8*)rsp_data.nan_error);
if (mInstId == 0 &&
(rsp_data.response_type == NAN_RESPONSE_PUBLISH ||
rsp_data.response_type == NAN_RESPONSE_SUBSCRIBE)) {
ALOGI("Received service instance_id %d\n", rsp_vndr_data->instance_id);
mInstId = rsp_vndr_data->instance_id;
}
if (rsp_data.response_type == NAN_RESPONSE_PUBLISH) {
rsp_data.body.publish_response.publish_id = mInstId;
} else if (rsp_data.response_type == NAN_RESPONSE_SUBSCRIBE) {
rsp_data.body.subscribe_response.subscribe_id = mInstId;
} else if (rsp_data.response_type == NAN_GET_CAPABILITIES) {
memcpy((void *)&rsp_data.body.nan_capabilities, (void *)&rsp_vndr_data->capabilities,
sizeof(rsp_data.body.nan_capabilities));
}
GET_NAN_HANDLE(info)->mHandlers.NotifyResponse(id(), &rsp_data);
ALOGI("NanDiscEnginePrmitive:Received response for cmd [%s], ret %d\n",
NanRspToString(rsp_data.response_type), rsp_data.status);
return NL_SKIP;
}
int handleEvent(WifiEvent& event) {
int cmd = event.get_vendor_subcmd();
u16 attr_type;
ALOGI("Received NanDiscEnginePrimitive event: %d\n", event.get_cmd());
nlattr *vendor_data = event.get_attribute(NL80211_ATTR_VENDOR_DATA);
switch(cmd) {
case NAN_EVENT_PUBLISH_TERMINATED:
NanPublishTerminatedInd pub_term_event;
memset(&pub_term_event, 0, sizeof(NanPublishTerminatedInd));
for (nl_iterator it(vendor_data); it.has_next(); it.next()) {
attr_type = it.get_type();
if (attr_type == NAN_ATTRIBUTE_PUBLISH_ID) {
pub_term_event.publish_id = it.get_u32();
ALOGI("pub id = %u", pub_term_event.publish_id);
} else if (attr_type == NAN_ATTRIBUTE_STATUS) {
pub_term_event.reason = (NanStatusType)it.get_u8();
ALOGI("pub termination status %u", pub_term_event.reason);
} else if (attr_type == NAN_ATTRIBUTE_REASON) {
u8 len = min(it.get_len(), sizeof(pub_term_event.nan_reason) - 1);
memcpy(pub_term_event.nan_reason, it.get_data(), len);
pub_term_event.nan_reason[len] = '\0';
ALOGI("pub termination reason: %s, len = %d\n",
pub_term_event.nan_reason, len);
} else {
ALOGE("Unknown attr: %u\n", attr_type);
}
}
GET_NAN_HANDLE(info)->mHandlers.EventPublishTerminated(&pub_term_event);
break;
case NAN_EVENT_SUBSCRIBE_MATCH:
NanMatchInd subscribe_event;
memset(&subscribe_event, 0, sizeof(NanMatchInd));
/* By default FW is unable to cache this match */
subscribe_event.out_of_resource_flag = true;
for (nl_iterator it(vendor_data); it.has_next(); it.next()) {
attr_type = it.get_type();
if (attr_type == NAN_ATTRIBUTE_SUBSCRIBE_ID) {
ALOGI("sub id: %u", it.get_u16());
subscribe_event.publish_subscribe_id = it.get_u8();
} else if (attr_type == NAN_ATTRIBUTE_PUBLISH_ID) {
ALOGI("pub id: %u", it.get_u32());
subscribe_event.requestor_instance_id = it.get_u8();
} else if (attr_type == NAN_ATTRIBUTE_MAC_ADDR) {
memcpy(subscribe_event.addr, it.get_data(), NAN_MAC_ADDR_LEN);
ALOGI("Publisher mac: " MACSTR, MAC2STR(subscribe_event.addr));
} else if (attr_type == NAN_ATTRIBUTE_SERVICE_SPECIFIC_INFO_LEN) {
ALOGI("svc length %d", it.get_u16());
subscribe_event.service_specific_info_len = it.get_u16();
} else if (attr_type == NAN_ATTRIBUTE_SERVICE_SPECIFIC_INFO) {
memcpy(subscribe_event.service_specific_info, it.get_data(),
subscribe_event.service_specific_info_len);
subscribe_event.service_specific_info
[subscribe_event.service_specific_info_len] = '\0';
ALOGI("service info: %s", subscribe_event.service_specific_info);
} else if (attr_type == NAN_ATTRIBUTE_TX_MATCH_FILTER_LEN) {
ALOGI("sdf match filter length: %d", subscribe_event.sdf_match_filter_len);
subscribe_event.sdf_match_filter_len = it.get_u16();
} else if (attr_type == NAN_ATTRIBUTE_TX_MATCH_FILTER) {
memcpy(subscribe_event.sdf_match_filter, it.get_data(),
subscribe_event.sdf_match_filter_len);
subscribe_event.sdf_match_filter
[subscribe_event.sdf_match_filter_len] = '\0';
ALOGI("sdf match filter: %s", subscribe_event.sdf_match_filter);
} else if (attr_type == NAN_ATTRIBUTE_CIPHER_SUITE_TYPE) {
ALOGI("Peer Cipher suite type: %u", it.get_u8());
subscribe_event.peer_cipher_type = it.get_u8();
} else if (attr_type == NAN_ATTRIBUTE_SCID_LEN) {
ALOGI("scid length %d", it.get_u32());
subscribe_event.scid_len= it.get_u32();
} else if (attr_type == NAN_ATTRIBUTE_SCID) {
memcpy(subscribe_event.scid, it.get_data(),
subscribe_event.scid_len);
subscribe_event.scid
[subscribe_event.scid_len] = '\0';
ALOGI("scid: %s", subscribe_event.scid);
} else if (attr_type == NAN_ATTRIBUTE_RANGING_INDICATION) {
subscribe_event.range_info.ranging_event_type = it.get_u32();
ALOGI("ranging indication %d", it.get_u32());
} else if (attr_type == NAN_ATTRIBUTE_RANGING_RESULT) {
subscribe_event.range_info.range_measurement_mm = it.get_u32();
ALOGI("ranging result %d", it.get_u32());
} else if (attr_type == NAN_ATTRIBUTE_RSSI_PROXIMITY) {
subscribe_event.rssi_value = it.get_u8();
ALOGI("rssi value : %u", it.get_u8());
} else if (attr_type == NAN_ATTRIBUTE_SDEA_SERVICE_SPECIFIC_INFO_LEN) {
ALOGI("sdea svc length %d", it.get_u16());
subscribe_event.sdea_service_specific_info_len = it.get_u16();
} else if (attr_type == NAN_ATTRIBUTE_SDEA_SERVICE_SPECIFIC_INFO) {
memcpy(subscribe_event.sdea_service_specific_info, it.get_data(),
subscribe_event.sdea_service_specific_info_len);
subscribe_event.sdea_service_specific_info
[subscribe_event.sdea_service_specific_info_len] = '\0';
ALOGI("sdea service info: %s", subscribe_event.sdea_service_specific_info);
} else if (attr_type == NAN_ATTRIBUTE_MATCH_OCCURRED_FLAG) {
ALOGI("match occurred flag: %u", it.get_u8());
subscribe_event.match_occured_flag = it.get_u8();
} else if (attr_type == NAN_ATTRIBUTE_OUT_OF_RESOURCE_FLAG) {
ALOGI("Out of resource flag: %u", it.get_u8());
subscribe_event.out_of_resource_flag = it.get_u8();
} else if (attr_type == NAN_ATTRIBUTE_SDE_CONTROL_CONFIG_DP) {
ALOGI("Peer config for data path needed: %u", it.get_u8());
subscribe_event.peer_sdea_params.config_nan_data_path = it.get_u8();
} else if (attr_type == NAN_ATTRIBUTE_SDE_CONTROL_DP_TYPE) {
ALOGI("Data Path type: %u", it.get_u8());
subscribe_event.peer_sdea_params.ndp_type = (NdpType)it.get_u8();
} else if (attr_type == NAN_ATTRIBUTE_SDE_CONTROL_SECURITY) {
ALOGI("Security configuration: %u", it.get_u8());
subscribe_event.peer_sdea_params.security_cfg =
(NanDataPathSecurityCfgStatus)it.get_u8();
} else if (attr_type == NAN_ATTRIBUTE_SDE_CONTROL_RANGE_SUPPORT) {
ALOGI("Ranging report state: %u", it.get_u8());
subscribe_event.peer_sdea_params.range_report = (NanRangeReport)it.get_u8();
}
}
GET_NAN_HANDLE(info)->mHandlers.EventMatch(&subscribe_event);
break;
case NAN_EVENT_SUBSCRIBE_UNMATCH:
ALOGE("%s: Not applicable yet\n", __func__);
break;
case NAN_EVENT_SUBSCRIBE_TERMINATED:
NanSubscribeTerminatedInd sub_term_event;
memset(&sub_term_event, 0, sizeof(NanSubscribeTerminatedInd));
for (nl_iterator it(vendor_data); it.has_next(); it.next()) {
attr_type = it.get_type();
if (attr_type == NAN_ATTRIBUTE_SUBSCRIBE_ID) {
sub_term_event.subscribe_id = it.get_u16();
ALOGI("sub id = %u", sub_term_event.subscribe_id);
} else if (attr_type == NAN_ATTRIBUTE_STATUS) {
sub_term_event.reason = (NanStatusType)it.get_u16();
ALOGI("sub termination status %u", sub_term_event.reason);
} else if (attr_type == NAN_ATTRIBUTE_REASON) {
u8 len = min(it.get_len(), sizeof(sub_term_event.nan_reason) - 1);
memcpy(sub_term_event.nan_reason, it.get_data(), len);
sub_term_event.nan_reason[len] = '\0';
ALOGI("sub termination nan reason: %s, len = %d\n",
sub_term_event.nan_reason, len);
} else {
ALOGI("Unknown attr: %d\n", attr_type);
}
}
GET_NAN_HANDLE(info)->mHandlers.EventSubscribeTerminated(&sub_term_event);
break;
case NAN_EVENT_MATCH_EXPIRY:
HandleExpiryEvent(info, vendor_data);
break;
case NAN_EVENT_FOLLOWUP:
NanFollowupInd followup_event;
memset(&followup_event, 0, sizeof(NanFollowupInd));
for (nl_iterator it(vendor_data); it.has_next(); it.next()) {
attr_type = it.get_type();
if (attr_type == NAN_ATTRIBUTE_MAC_ADDR) {
memcpy(followup_event.addr, it.get_data(), NAN_MAC_ADDR_LEN);
} else if (attr_type == NAN_ATTRIBUTE_PEER_ID) {
followup_event.publish_subscribe_id = it.get_u16();
} else if (attr_type == NAN_ATTRIBUTE_INST_ID) {
followup_event.requestor_instance_id = it.get_u32();
} else if (attr_type == NAN_ATTRIBUTE_SERVICE_SPECIFIC_INFO_LEN) {
followup_event.service_specific_info_len = it.get_u16();
} else if (attr_type == NAN_ATTRIBUTE_SERVICE_SPECIFIC_INFO) {
memcpy(followup_event.service_specific_info, it.get_data(),
followup_event.service_specific_info_len);
} else if (attr_type == NAN_ATTRIBUTE_SDEA_SERVICE_SPECIFIC_INFO) {
memcpy(followup_event.sdea_service_specific_info, it.get_data(),
followup_event.sdea_service_specific_info_len);
}
}
counters.transmit_recv++;
GET_NAN_HANDLE(info)->mHandlers.EventFollowup(&followup_event);
break;
case NAN_EVENT_TRANSMIT_FOLLOWUP_IND:
NanTransmitFollowupInd followup_ind;
counters.transmit_txs++;
memset(&followup_ind, 0, sizeof(NanTransmitFollowupInd));
for (nl_iterator it(vendor_data); it.has_next(); it.next()) {
attr_type = it.get_type();
if (attr_type == NAN_ATTRIBUTE_TRANSAC_ID) {
followup_ind.id = it.get_u16();
} else if (attr_type == NAN_ATTRIBUTE_STATUS) {
followup_ind.reason = (NanStatusType)it.get_u8();
} else if (attr_type == NAN_ATTRIBUTE_REASON) {
u8 len = min(it.get_len(), sizeof(followup_ind.nan_reason) - 1);
memcpy(followup_ind.nan_reason, it.get_data(), len);
followup_ind.nan_reason[len] = '\0';
ALOGI("nan transmit followup ind: reason: %s, len = %d\n",
followup_ind.nan_reason, len);
}
}
GET_NAN_HANDLE(info)->mHandlers.EventTransmitFollowup(&followup_ind);
break;
#ifdef NOT_YET
case NAN_EVENT_PUBLISH_REPLIED_IND:
NanPublishRepliedInd pub_reply_event;
memset(&pub_reply_event, 0, sizeof(pub_reply_event));
for (nl_iterator it(vendor_data); it.has_next(); it.next()) {
attr_type = it.get_type();
if (attr_type == NAN_ATTRIBUTE_SUBSCRIBE_ID) {
ALOGI("sub id: %u", it.get_u16());
pub_reply_event.requestor_instance_id = it.get_u8();
} else if (attr_type == NAN_ATTRIBUTE_MAC_ADDR) {
memcpy(pub_reply_event.addr, it.get_data(), NAN_MAC_ADDR_LEN);
ALOGI("Subscriber mac: " MACSTR, MAC2STR(pub_reply_event.addr));
} else if (attr_type == NAN_ATTRIBUTE_RSSI_PROXIMITY) {
pub_reply_event.rssi_value = it.get_u8();
ALOGI("Received rssi value : %u", it.get_u8());
}
}
GET_NAN_HANDLE(info)->mHandlers.EventPublishReplied(&pub_reply_event);
break;
#endif /* NOT_YET */
} // end-of-switch-case
return NL_SKIP;
}
};
///////////////////////////////////////////////////////////////////////////////
class NanDataPathPrimitive : public WifiCommand
{
NanRequest reqContext;
u32 mNdpId;
NanRequestType mType;
u8 count;
public:
NanDataPathPrimitive(wifi_interface_handle iface, int id,
NanRequest params, NanRequestType cmdType)
: WifiCommand("NanCommand", iface, id), reqContext(params), mType(cmdType)
{
mNdpId = 0;
count = 0;
}
~NanDataPathPrimitive() {
ALOGE("NanDataPathPrimitive destroyed\n");
}
u8 mSvcHash[NAN_SVC_HASH_SIZE];
u8 mPubNmi[NAN_MAC_ADDR_LEN];
void setType(NanRequestType type ) {
mType = type;
}
int getNdpId() {
return mNdpId;
}
int createRequest(WifiRequest& request)
{
ALOGI("NAN CMD: %s\n", NanCmdToString(mType));
if (mType == NAN_DATA_PATH_IFACE_CREATE) {
return createDataPathIfaceRequest(request, (char *)reqContext);
} else if (mType == NAN_DATA_PATH_IFACE_DELETE) {
return deleteDataPathIfaceRequest(request, (char *)reqContext);
} else if (mType == NAN_DATA_PATH_INIT_REQUEST) {
return createDataPathInitRequest(request,
(NanDataPathInitiatorRequest *)reqContext);
} else if (mType == NAN_DATA_PATH_IND_RESPONSE) {
return createDataPathIndResponse(request,
(NanDataPathIndicationResponse *)reqContext);
} else if (mType == NAN_DATA_PATH_END) {
return createDataPathEndRequest(request,
(NanDataPathEndRequest *)reqContext);
} else if (mType == NAN_DATA_PATH_SEC_INFO) {
return createDataPathSecInfoRequest(request,
(NanDataPathSecInfoRequest *)reqContext);
} else {
ALOGE("%s: Unknown NDP request: %d\n", __func__, mType);
}
return WIFI_SUCCESS;
}
int createDataPathIfaceRequest(WifiRequest& request, char *iface_name)
{
ALOGD("add ifname = %s, iface_type = %d", iface_name, NL80211_IFTYPE_STATION);
u32 wlan0_id = if_nametoindex("wlan0");
if (!wlan0_id) {
ALOGE("%s: Error wlan0 not present\n", __FUNCTION__);
return WIFI_ERROR_UNKNOWN;
}
/* Do not create interface if already exist. */
if (if_nametoindex(iface_name)) {
ALOGD("%s: if_nametoindex(%s) = %d already exists, skip create \n",
__FUNCTION__, iface_name, if_nametoindex(iface_name));
return WIFI_SUCCESS;
}
int result = request.create(NL80211_CMD_NEW_INTERFACE);
if (result < 0) {
ALOGE("failed to create NL80211_CMD_NEW_INTERFACE; result = %d", result);
return result;
}
result = request.put_u32(NL80211_ATTR_IFINDEX, wlan0_id);
if (result < 0) {
ALOGE("failed to put NL80211_ATTR_IFINDEX; result = %d", result);
return result;
}
result = request.put_string(NL80211_ATTR_IFNAME, iface_name);
if (result < 0) {
ALOGE("failed to put NL80211_ATTR_IFNAME = %s; result = %d", iface_name, result);
return result;
}
result = request.put_u32(NL80211_ATTR_IFTYPE, NL80211_IFTYPE_STATION);
if (result < 0) {
ALOGE("failed to put NL80211_ATTR_IFTYPE; result = %d", result);
return result;
}
return WIFI_SUCCESS;
}
int deleteDataPathIfaceRequest(WifiRequest& request, char *iface_name)
{
ALOGD("delete ifname = %s\n", iface_name);
int result = request.create(NL80211_CMD_DEL_INTERFACE);
if (result < 0) {
ALOGE("failed to create NL80211_CMD_DEL_INTERFACE; result = %d", result);
return result;
}
result = request.put_u32(NL80211_ATTR_IFINDEX, if_nametoindex(iface_name));
if (result < 0) {
ALOGE("failed to put NL80211_ATTR_IFINDEX = %d; result = %d",
if_nametoindex(iface_name), result);
return result;
}
result = request.put_string(NL80211_ATTR_IFNAME, iface_name);
if (result < 0) {
ALOGE("failed to put NL80211_ATTR_IFNAME = %s; result = %d", iface_name, result);
return result;
}
return WIFI_SUCCESS;
}
int createDataPathSecInfoRequest(WifiRequest& request, NanDataPathSecInfoRequest *mParams)
{
int result = request.create(GOOGLE_OUI, NAN_SUBCMD_DATA_PATH_SEC_INFO);
if (result < 0) {
ALOGE("%s Failed to create request\n", __func__);
return result;
}
nlattr *data = request.attr_start(NL80211_ATTR_VENDOR_DATA);
result = request.put_u32(NAN_ATTRIBUTE_PUBLISH_ID, mParams->requestor_instance_id);
if (result < 0) {
ALOGE("%s: Failed to fill instance id = %d, result = %d\n",
__func__, mParams->requestor_instance_id, result);
return result;
}
result = request.put_addr(NAN_ATTRIBUTE_MAC_ADDR, mParams->peer_disc_mac_addr);
if (result < 0) {
ALOGE("%s: Failed to fill mac addr, result = %d\n", __func__, result);
return result;
}
result = request.put_u32(NAN_ATTRIBUTE_NDP_ID, mParams->ndp_instance_id);
if (result < 0) {
ALOGE("%s: Failed to fill ndp_instance_id = %d, result = %d\n",
__func__, mParams->ndp_instance_id, result);
return result;
}
request.attr_end(data);
return WIFI_SUCCESS;
}
int createDataPathInitRequest(WifiRequest& request, NanDataPathInitiatorRequest *mParams)
{
int result = request.create(GOOGLE_OUI, NAN_SUBCMD_DATA_PATH_REQUEST);
u8 pmk_hex[NAN_PMK_INFO_LEN];
if (result < 0) {
ALOGE("%s: Failed to create request, result = %d\n", __func__, result);
return result;
}
mNdpId = mParams->requestor_instance_id;
nlattr *data = request.attr_start(NL80211_ATTR_VENDOR_DATA);
result = request.put_u32(NAN_ATTRIBUTE_PUBLISH_ID, mParams->requestor_instance_id);
if (result < 0) {
ALOGE("%s: Failed to fill pub id = %d, result = %d\n",
__func__, mParams->requestor_instance_id, result);
return result;
}
result = request.put_u32(NAN_ATTRIBUTE_CHANNEL, (u32)mParams->channel);
if (result < 0) {
ALOGE("%s: Failed to fill channel = %d, result = %d\n",
__func__, mParams->channel, result);
return result;
}
result = request.put_addr(NAN_ATTRIBUTE_MAC_ADDR, mParams->peer_disc_mac_addr);
if (result < 0) {
ALOGE("%s: Failed to fill mac addr, result = %d\n", __func__, result);
return result;
}
result = request.put_string(NAN_ATTRIBUTE_IFACE, mParams->ndp_iface);
if (result < 0) {
ALOGE("%s: Failed to fill ndp_iface, result = %d\n", __func__, result);
return result;
}
result = request.put_u8(NAN_ATTRIBUTE_SECURITY,
(NanDataPathSecurityCfgStatus)mParams->ndp_cfg.security_cfg);
if (result < 0) {
ALOGE("%s: Failed to fill security, result = %d\n", __func__, result);
return result;
}
result = request.put_u8(NAN_ATTRIBUTE_QOS,
(NanDataPathQosCfg) mParams->ndp_cfg.qos_cfg);
if (result < 0) {
ALOGE("%s: Failed to fill QoS, result = %d\n", __func__, result);
return result;
}
if (mParams->app_info.ndp_app_info_len) {
result = request.put_u16(NAN_ATTRIBUTE_SERVICE_SPECIFIC_INFO_LEN,
mParams->app_info.ndp_app_info_len);
if (result < 0) {
ALOGE("%s: Failed to fill svc info len = %d, result = %d\n",
__func__, mParams->app_info.ndp_app_info_len, result);
return result;
}
result = request.put(NAN_ATTRIBUTE_SERVICE_SPECIFIC_INFO,
(void *)mParams->app_info.ndp_app_info, mParams->app_info.ndp_app_info_len);
if (result < 0) {
ALOGE("%s: Failed to fill svc info, result = %d\n", __func__, result);
return result;
}
}
result = request.put_u8(NAN_ATTRIBUTE_CIPHER_SUITE_TYPE,
mParams->cipher_type);
if (result < 0) {
ALOGE("%s: Failed to fill NAN_ATTRIBUTE_CIPHER_SUITE_TYPE, result = %d\n",
__func__, result);
return result;
}
result = request.put_u8(NAN_ATTRIBUTE_KEY_TYPE,
mParams->key_info.key_type);
if (result < 0) {
ALOGE("%s: Failed to fill NAN_ATTRIBUTE_KEY_TYPE, result = %d\n",
__func__, result);
return result;
}
if (mParams->service_name_len) {
result = request.put_u16(NAN_ATTRIBUTE_SERVICE_NAME_LEN, mParams->service_name_len);
if (result < 0) {
ALOGE("%s: Failed to fill svc name len, result = %d\n", __func__, result);
return result;
}
prhex(NULL, mParams->service_name, mParams->service_name_len);
result = request.put(NAN_ATTRIBUTE_SERVICE_NAME, (void *)mParams->service_name,
mParams->service_name_len);
if (result < 0) {
ALOGE("%s: Failed to fill svc name, result = %d\n", __func__, result);
return result;
}
}
if (mParams->key_info.key_type == NAN_SECURITY_KEY_INPUT_PMK) {
if (mParams->key_info.body.pmk_info.pmk_len) {
result = request.put_u32(NAN_ATTRIBUTE_KEY_LEN,
mParams->key_info.body.pmk_info.pmk_len);
if (result < 0) {
ALOGE("%s: Failed to fill pmk len, result = %d\n", __func__, result);
return result;
}
result = request.put(NAN_ATTRIBUTE_KEY_DATA,
(void *)mParams->key_info.body.pmk_info.pmk,
mParams->key_info.body.pmk_info.pmk_len);
if (result < 0) {
ALOGE("%s: Failed to fill pmk, result = %d\n", __func__, result);
return result;
}
}
}
if (mParams->key_info.key_type == NAN_SECURITY_KEY_INPUT_PASSPHRASE) {
if (mParams->key_info.body.passphrase_info.passphrase_len < NAN_SECURITY_MIN_PASSPHRASE_LEN ||
mParams->key_info.body.passphrase_info.passphrase_len > NAN_SECURITY_MAX_PASSPHRASE_LEN) {
ALOGE("passphrase must be between %d and %d characters long\n",
NAN_SECURITY_MIN_PASSPHRASE_LEN,
NAN_SECURITY_MAX_PASSPHRASE_LEN);
return NAN_STATUS_INVALID_PARAM;
} else {
memset(pmk_hex, 0, NAN_PMK_INFO_LEN);
result = passphrase_to_pmk(mParams->peer_disc_mac_addr, mParams->cipher_type,
mParams->service_name, &mParams->key_info, pmk_hex);
if (result < 0) {
ALOGE("%s: Failed to convert passphrase to key data, result = %d\n", __func__, result);
return result;
}
result = request.put_u32(NAN_ATTRIBUTE_KEY_LEN, NAN_PMK_INFO_LEN);
if (result < 0) {
ALOGE("%s: Failed to fill passphrase len, result = %d\n", __func__, result);
return result;
}
result = request.put(NAN_ATTRIBUTE_KEY_DATA, pmk_hex, NAN_PMK_INFO_LEN);
if (result < 0) {
ALOGE("%s: Failed to fill passphrase, result = %d\n", __func__, result);
return result;
}
prhex("PMK", pmk_hex, NAN_PMK_INFO_LEN);
}
}
if (mParams->scid_len) {
if (mParams->scid_len != NAN_SCID_INFO_LEN) {
ALOGE("%s: Invalid scid len, = %d\n", __func__, mParams->scid_len);
return NAN_STATUS_INVALID_PARAM;
}
result = request.put_u32(NAN_ATTRIBUTE_SCID_LEN,
mParams->scid_len);
if (result < 0) {
ALOGE("%s: Failed to fill scid len, result = %d\n", __func__, result);
return result;
}
result = request.put(NAN_ATTRIBUTE_SCID,
(void *)mParams->scid, mParams->scid_len);
if (result < 0) {
ALOGE("%s: Failed to fill scid, result = %d\n", __func__, result);
return result;
}
}
request.attr_end(data);
return WIFI_SUCCESS;
}
int createDataPathIndResponse(WifiRequest& request,
NanDataPathIndicationResponse *mParams)
{
int result = request.create(GOOGLE_OUI, NAN_SUBCMD_DATA_PATH_RESPONSE);
u8 pmk_hex[NAN_PMK_INFO_LEN];
if (result < 0) {
ALOGE("%s: Failed to create request, result = %d\n", __func__, result);
return result;
}
nlattr *data = request.attr_start(NL80211_ATTR_VENDOR_DATA);
result = request.put_u32(NAN_ATTRIBUTE_NDP_ID, mParams->ndp_instance_id);
if (result < 0) {
ALOGE("%s: Failed to fill ndp_instance_id = %d, result = %d\n",
__func__, mParams->ndp_instance_id, result);
return result;
}
result = request.put_string(NAN_ATTRIBUTE_IFACE, mParams->ndp_iface);
if (result < 0) {
ALOGE("%s: Failed to fill ndp_iface, result = %d\n", __func__, result);
return result;
}
result = request.put_u8(NAN_ATTRIBUTE_SECURITY,
(NanDataPathSecurityCfgStatus)mParams->ndp_cfg.security_cfg);
if (result < 0) {
ALOGE("%s: Failed to fill security_cfg, result = %d\n", __func__, result);
return result;
}
result = request.put_u8(NAN_ATTRIBUTE_QOS,
(NanDataPathQosCfg)mParams->ndp_cfg.qos_cfg);
if (result < 0) {
ALOGE("%s: Failed to fill qos_cfg, result = %d\n", __func__, result);
return result;
}
if (mParams->app_info.ndp_app_info_len) {
result = request.put_u16(NAN_ATTRIBUTE_SERVICE_SPECIFIC_INFO_LEN,
mParams->app_info.ndp_app_info_len);
if (result < 0) {
ALOGE("%s: Failed to fill svc info len = %d, result = %d\n",
__func__, mParams->app_info.ndp_app_info_len, result);
return result;
}
result = request.put(NAN_ATTRIBUTE_SERVICE_SPECIFIC_INFO,
(void *)mParams->app_info.ndp_app_info, mParams->app_info.ndp_app_info_len);
if (result < 0) {
ALOGE("%s: Failed to fill svc info, result = %d\n", __func__, result);
return result;
}
}
result = request.put_u8(NAN_ATTRIBUTE_RSP_CODE, mParams->rsp_code);
if (result < 0) {
ALOGE("%s: Failed to fill resp code = %d, result = %d\n",
__func__, mParams->rsp_code, result);
return result;
}
result = request.put_u8(NAN_ATTRIBUTE_CIPHER_SUITE_TYPE,
mParams->cipher_type);
if (result < 0) {
ALOGE("%s: Failed to fill cipher_type, result = %d\n",
__func__, result);
return result;
}
result = request.put_u8(NAN_ATTRIBUTE_KEY_TYPE,
mParams->key_info.key_type);
if (result < 0) {
ALOGE("%s: Failed to fill key type, result = %d\n",
__func__, result);
return result;
}
if (mParams->service_name_len) {
result = request.put_u16(NAN_ATTRIBUTE_SERVICE_NAME_LEN, mParams->service_name_len);
if (result < 0) {
ALOGE("%s: Failed to fill svc name len, result = %d\n", __func__, result);
return result;
}
prhex(NULL, mParams->service_name, mParams->service_name_len);
result = request.put(NAN_ATTRIBUTE_SERVICE_NAME, (void *)mParams->service_name,
mParams->service_name_len);
if (result < 0) {
ALOGE("%s: Failed to fill svc name, result = %d\n", __func__, result);
return result;
}
}
if (mParams->key_info.key_type == NAN_SECURITY_KEY_INPUT_PMK) {
if (mParams->key_info.body.pmk_info.pmk_len) {
result = request.put_u32(NAN_ATTRIBUTE_KEY_LEN,
mParams->key_info.body.pmk_info.pmk_len);
if (result < 0) {
ALOGE("%s: Failed to fill pmk len, result = %d\n", __func__, result);
return result;
}
result = request.put(NAN_ATTRIBUTE_KEY_DATA,
(void *)mParams->key_info.body.pmk_info.pmk,
mParams->key_info.body.pmk_info.pmk_len);
if (result < 0) {
ALOGE("%s: Failed to fill pmk, result = %d\n", __func__, result);
return result;
}
}
}
if (mParams->key_info.key_type == NAN_SECURITY_KEY_INPUT_PASSPHRASE) {
if (mParams->key_info.body.passphrase_info.passphrase_len < NAN_SECURITY_MIN_PASSPHRASE_LEN ||
mParams->key_info.body.passphrase_info.passphrase_len > NAN_SECURITY_MAX_PASSPHRASE_LEN) {
ALOGE("passphrase must be between %d and %d characters long\n",
NAN_SECURITY_MIN_PASSPHRASE_LEN,
NAN_SECURITY_MAX_PASSPHRASE_LEN);
return NAN_STATUS_INVALID_PARAM;
} else {
memset(pmk_hex, 0, NAN_PMK_INFO_LEN);
result = passphrase_to_pmk(mPubNmi, mParams->cipher_type,
mParams->service_name, &mParams->key_info, pmk_hex);
if (result < 0) {
ALOGE("%s: Failed to convert passphrase to key data, result = %d\n", __func__, result);
return result;
}
result = request.put_u32(NAN_ATTRIBUTE_KEY_LEN, NAN_PMK_INFO_LEN);
if (result < 0) {
ALOGE("%s: Failed to fill passphrase len, result = %d\n", __func__, result);
return result;
}
result = request.put(NAN_ATTRIBUTE_KEY_DATA, pmk_hex, NAN_PMK_INFO_LEN);
if (result < 0) {
ALOGE("%s: Failed to fill passphrase, result = %d\n", __func__, result);
return result;
}
}
}
if (mParams->scid_len) {
if (mParams->scid_len != NAN_SCID_INFO_LEN) {
ALOGE("%s: Invalid scid len, = %d\n", __func__, mParams->scid_len);
return NAN_STATUS_INVALID_PARAM;
}
result = request.put_u32(NAN_ATTRIBUTE_SCID_LEN,
mParams->scid_len);
if (result < 0) {
ALOGE("%s: Failed to fill scid len, result = %d\n", __func__, result);
return result;
}
prhex(NULL, mParams->scid, mParams->scid_len);
result = request.put(NAN_ATTRIBUTE_SCID,
(void *)mParams->scid, mParams->scid_len);
if (result < 0) {
ALOGE("%s: Failed to fill scid, result = %d\n", __func__, result);
return result;
}
}
request.attr_end(data);
return WIFI_SUCCESS;
}
int createDataPathEndRequest(WifiRequest& request, NanDataPathEndRequest *mParams)
{
int result = request.create(GOOGLE_OUI, NAN_SUBCMD_DATA_PATH_END);
if (result < 0) {
ALOGE("%s: Failed to create request, result = %d\n", __func__, result);
return result;
}
count = mParams->num_ndp_instances;
nlattr *data = request.attr_start(NL80211_ATTR_VENDOR_DATA);
result = request.put_u8(NAN_ATTRIBUTE_INST_COUNT, mParams->num_ndp_instances);
if (result < 0) {
ALOGE("%s: Failed to fill num_ndp_instances = %d, result = %d\n",
__func__, mParams->num_ndp_instances, result);
return result;
}
while (count) {
result = request.put_u32(NAN_ATTRIBUTE_NDP_ID, mParams->ndp_instance_id[count-1]);
if (result < 0) {
ALOGE("%s: Failed to fill ndp id = %d, result = %d\n",
__func__, mParams->ndp_instance_id[count-1], result);
return result;
}
ALOGE("%s:NDP ID = %d\n", __func__, mParams->ndp_instance_id[count-1]);
count -= 1;
}
request.attr_end(data);
return WIFI_SUCCESS;
}
int open()
{
WifiRequest request(familyId(), ifaceId());
int result = createRequest(request);
if (result != WIFI_SUCCESS) {
ALOGE("%s: failed to create setup request; result = %d", __func__, result);
return result;
}
result = requestResponse(request);
if (result != WIFI_SUCCESS) {
ALOGE("%s: failed to configure setup; result = %d", __func__, result);
return result;
}
ALOGI("NanDataPathPrmitive::request Response\n");
if (mType == NAN_DATA_PATH_IFACE_DELETE) {
NanResponseMsg rsp_data;
memset(&rsp_data, 0, sizeof(NanResponseMsg));
/* Prepare the NanResponseMsg payload */
rsp_data.response_type = get_response_type_frm_req_type((NanRequestType)mType);
/* Return success even for no dev case also, nothing to do */
rsp_data.status = NAN_STATUS_SUCCESS;
memcpy(rsp_data.nan_error, NanStatusToString(rsp_data.status),
strlen(NanStatusToString(rsp_data.status)));
rsp_data.nan_error[strlen(NanStatusToString(rsp_data.status))] = '\0';
rsp_data.nan_error[NAN_ERROR_STR_LEN - 1] = '\0';
ALOGI("Mapped hal status = %d\n", rsp_data.status);
ALOGI("Received nan_error string %s\n", (u8*)rsp_data.nan_error);
GET_NAN_HANDLE(info)->mHandlers.NotifyResponse(id(), &rsp_data);
ALOGE("Notified by cmd ret!!");
}
request.destroy();
return WIFI_SUCCESS;
}
virtual bool valid_dp_response_type(int response_type) {
bool valid = false;
switch(response_type) {
case NAN_DP_INTERFACE_CREATE:
case NAN_DP_INTERFACE_DELETE:
case NAN_DP_INITIATOR_RESPONSE:
case NAN_DP_RESPONDER_RESPONSE:
case NAN_DP_END:
valid = true;
break;
default:
ALOGE("NanDataPathPrmitive::Unknown cmd Response: %d\n", response_type);
break;
}
return valid;
}
int handleResponse(WifiEvent& reply)
{
nan_hal_resp_t *rsp_vndr_data = NULL;
NanResponseMsg rsp_data;
int32_t result = BCME_OK;
ALOGI("NanDataPathPrmitive::handle Response\n");
memset(&rsp_data, 0, sizeof(NanResponseMsg));
if (mType == NAN_DATA_PATH_IFACE_CREATE) {
/* NDI creation and deletion are done through vendor ops,
* driver does not send the cmd response payload,
* but for framework,
* mimicking the NanResponseMsg for iface create and delete nan cmds
*/
rsp_data.response_type = get_response_type_frm_req_type((NanRequestType)mType);
/* Return success even for no dev case also, nothing to do */
if (result == WIFI_SUCCESS || result == WIFI_ERROR_NOT_AVAILABLE) {
rsp_data.status = NAN_STATUS_SUCCESS;
} else {
rsp_data.status = NAN_STATUS_INTERNAL_FAILURE;
}
} else if (reply.get_cmd() != NL80211_CMD_VENDOR || reply.get_vendor_data() == NULL) {
ALOGD("Ignoring reply with cmd = %d", reply.get_cmd());
return NL_SKIP;
} else {
rsp_vndr_data = (nan_hal_resp_t *)reply.get_vendor_data();
result = rsp_vndr_data->value;
rsp_data.response_type = get_response_type((WIFI_SUB_COMMAND)rsp_vndr_data->subcmd);
if ((WIFI_SUB_COMMAND)rsp_vndr_data->subcmd == NAN_SUBCMD_DATA_PATH_SEC_INFO) {
/* Follow through */
} else if (!valid_dp_response_type(rsp_data.response_type)) {
return NL_SKIP;
}
rsp_data.status = nan_map_response_status(rsp_vndr_data->status);
if (rsp_data.response_type == NAN_DP_INITIATOR_RESPONSE) {
ALOGI("received ndp instance_id %d and ret = %d\n",
rsp_vndr_data->ndp_instance_id, result);
rsp_data.body.data_request_response.ndp_instance_id =
rsp_vndr_data->ndp_instance_id;
mNdpId = rsp_vndr_data->ndp_instance_id;
} else if ((WIFI_SUB_COMMAND)rsp_vndr_data->subcmd == NAN_SUBCMD_DATA_PATH_SEC_INFO) {
memcpy(mPubNmi, rsp_vndr_data->pub_nmi, NAN_MAC_ADDR_LEN);
memcpy(mSvcHash, rsp_vndr_data->svc_hash, NAN_SVC_HASH_SIZE);
return NL_SKIP;
}
}
memcpy(rsp_data.nan_error, NanStatusToString(rsp_data.status),
strlen(NanStatusToString(rsp_data.status)));
rsp_data.nan_error[strlen(NanStatusToString(rsp_data.status))] = '\0';
rsp_data.nan_error[NAN_ERROR_STR_LEN - 1] = '\0';
ALOGI("Mapped hal status = %d\n", rsp_data.status);
ALOGI("Received nan_error string %s\n", (u8*)rsp_data.nan_error);
ALOGI("NanDataPathPrmitive:Received response for cmd [%s], ret %d\n",
NanRspToString(rsp_data.response_type), rsp_data.status);
GET_NAN_HANDLE(info)->mHandlers.NotifyResponse(id(), &rsp_data);
ALOGE("Notified by cmd reply!!");
return NL_SKIP;
}
int handleEvent(WifiEvent& event)
{
int cmd = event.get_vendor_subcmd();
u16 attr_type;
nlattr *vendor_data = event.get_attribute(NL80211_ATTR_VENDOR_DATA);
switch(cmd) {
case NAN_EVENT_DATA_REQUEST: {
NanDataPathRequestInd ndp_request_event;
memset(&ndp_request_event, 0, sizeof(NanDataPathRequestInd));
u16 ndp_ind_app_info_len = 0;
counters.dp_req_evt++;
ALOGI("Received NAN_EVENT_DATA_REQUEST_INDICATION\n");
for (nl_iterator it(vendor_data); it.has_next(); it.next()) {
attr_type = it.get_type();
if (attr_type == NAN_ATTRIBUTE_PUBLISH_ID) {
ALOGI("publish_id: %u\n", it.get_u32());
ndp_request_event.service_instance_id = it.get_u32();
} else if (attr_type == NAN_ATTRIBUTE_MAC_ADDR) {
memcpy(ndp_request_event.peer_disc_mac_addr,
it.get_data(), NAN_MAC_ADDR_LEN);
ALOGI("Discovery MAC addr of the peer/initiator: " MACSTR "\n",
MAC2STR(ndp_request_event.peer_disc_mac_addr));
} else if (attr_type == NAN_ATTRIBUTE_NDP_ID) {
ALOGI("ndp id: %u\n", it.get_u32());
ndp_request_event.ndp_instance_id = it.get_u32();
} else if (attr_type == NAN_ATTRIBUTE_SECURITY) {
ALOGI("security: %u\n",
(NanDataPathSecurityCfgStatus)it.get_u8());
ndp_request_event.ndp_cfg.security_cfg =
(NanDataPathSecurityCfgStatus)it.get_u8();
} else if (attr_type == NAN_ATTRIBUTE_QOS) {
ALOGI("QoS: %u\n", (NanDataPathQosCfg)it.get_u8());
ndp_request_event.ndp_cfg.qos_cfg = (NanDataPathQosCfg)it.get_u8();
} else if (attr_type == NAN_ATTRIBUTE_SERVICE_SPECIFIC_INFO_LEN) {
ndp_request_event.app_info.ndp_app_info_len = it.get_u16();
ndp_ind_app_info_len = ndp_request_event.app_info.ndp_app_info_len;
} else if (attr_type == NAN_ATTRIBUTE_SERVICE_SPECIFIC_INFO) {
memcpy(ndp_request_event.app_info.ndp_app_info, it.get_data(),
ndp_ind_app_info_len);
ndp_request_event.app_info.ndp_app_info
[ndp_ind_app_info_len] = '\0';
ALOGI("service info: %s\n", ndp_request_event.app_info.ndp_app_info);
} else if (attr_type == NAN_ATTRIBUTE_SCID_LEN) {
ALOGI("scid len: %u\n", it.get_u32());
ndp_request_event.scid_len = it.get_u32();
} else if (attr_type == NAN_ATTRIBUTE_SCID) {
memcpy(ndp_request_event.scid, it.get_data(),
ndp_request_event.scid_len);
ndp_request_event.scid[ndp_request_event.scid_len] = '\0';
ALOGI("scid : %s\n", ndp_request_event.scid);
}
}
GET_NAN_HANDLE(info)->mHandlers.EventDataRequest(&ndp_request_event);
break;
}
case NAN_EVENT_DATA_CONFIRMATION: {
NanDataPathConfirmInd ndp_create_confirmation_event;
memset(&ndp_create_confirmation_event, 0, sizeof(NanDataPathConfirmInd));
u16 ndp_conf_app_info_len = 0;
u8 chan_idx = 0;
counters.dp_confirm_evt++;
ALOGI("Received NAN_EVENT_DATA_CONFIRMATION\n");
for (nl_iterator it(vendor_data); it.has_next(); it.next()) {
attr_type = it.get_type();
if (attr_type == NAN_ATTRIBUTE_NDP_ID) {
ALOGI("ndp id: %u", it.get_u32());
ndp_create_confirmation_event.ndp_instance_id = it.get_u32();
} else if (attr_type == NAN_ATTRIBUTE_PEER_NDI_MAC_ADDR) {
memcpy(ndp_create_confirmation_event.peer_ndi_mac_addr, it.get_data(),
NAN_MAC_ADDR_LEN);
ALOGI("NDI mac address of the peer: " MACSTR "\n",
MAC2STR(ndp_create_confirmation_event.peer_ndi_mac_addr));
} else if (attr_type == NAN_ATTRIBUTE_SERVICE_SPECIFIC_INFO_LEN) {
ALOGI("service info len: %d", it.get_u16());
ndp_create_confirmation_event.app_info.ndp_app_info_len = it.get_u16();
ndp_conf_app_info_len = ndp_create_confirmation_event.app_info.ndp_app_info_len;
} else if (attr_type == NAN_ATTRIBUTE_SERVICE_SPECIFIC_INFO) {
memcpy(ndp_create_confirmation_event.app_info.ndp_app_info,
it.get_data(), ndp_conf_app_info_len);
ndp_create_confirmation_event.app_info.ndp_app_info[ndp_conf_app_info_len]
= '\0';
ALOGI("service info: %s",
ndp_create_confirmation_event.app_info.ndp_app_info);
} else if (attr_type == NAN_ATTRIBUTE_RSP_CODE) {
ALOGI("response code: %u", (NanDataPathResponseCode)it.get_u8());
ndp_create_confirmation_event.rsp_code =
(NanDataPathResponseCode)it.get_u8();
} else if (attr_type == NAN_ATTRIBUTE_STATUS) {
ALOGI("reason code %u", (NanDataPathResponseCode)it.get_u8());
ndp_create_confirmation_event.rsp_code =
(NanDataPathResponseCode)it.get_u8();
} else if (attr_type == NAN_ATTRIBUTE_NUM_CHANNELS) {
ALOGI("num channels %u", it.get_u32());
if (it.get_u32() <= NAN_MAX_CHANNEL_INFO_SUPPORTED) {
ndp_create_confirmation_event.num_channels = it.get_u32();
} else {
ndp_create_confirmation_event.num_channels =
NAN_MAX_CHANNEL_INFO_SUPPORTED;
ALOGE("num channels reset to max allowed %u",
ndp_create_confirmation_event.num_channels);
}
} else if (attr_type == NAN_ATTRIBUTE_CHANNEL_INFO) {
ALOGI("Channel info \n");
memcpy((u8 *)ndp_create_confirmation_event.channel_info, it.get_data(),
ndp_create_confirmation_event.num_channels * sizeof(NanChannelInfo));
while (chan_idx < ndp_create_confirmation_event.num_channels) {
ALOGI("channel: %u, Bandwidth: %u, nss: %u\n",
ndp_create_confirmation_event.channel_info[chan_idx].channel,
ndp_create_confirmation_event.channel_info[chan_idx].bandwidth,
ndp_create_confirmation_event.channel_info[chan_idx].nss);
chan_idx++;
}
}
}
GET_NAN_HANDLE(info)->mHandlers.EventDataConfirm(&ndp_create_confirmation_event);
break;
}
case NAN_EVENT_DATA_END: {
NanDataPathEndInd ndp_end_event;
memset(&ndp_end_event, 0, sizeof(NanDataPathEndInd));
u16 attr_type;
ALOGI("Received NAN_EVENT_DATA_END\n");
for (nl_iterator it(vendor_data); it.has_next(); it.next()) {
attr_type = it.get_type();
if (attr_type == NAN_ATTRIBUTE_INST_COUNT) {
ALOGI("ndp count: %u\n", it.get_u8());
ndp_end_event.num_ndp_instances = it.get_u8();
count = it.get_u8();
} else if (attr_type == NAN_ATTRIBUTE_NDP_ID) {
while (count) {
ndp_end_event.ndp_instance_id[count-1] = it.get_u32();
ALOGI("NDP Id from the Event = %u\n", ndp_end_event.ndp_instance_id[count-1]);
count -= 1;
}
} else {
ALOGI("Unknown attr_type: %s\n", NanAttrToString(attr_type));
}
}
GET_NAN_HANDLE(info)->mHandlers.EventDataEnd(&ndp_end_event);
break;
}
} // end-of-switch
return NL_SKIP;
}
};
///////////////////////////////////////////////////////////////////////////////
class NanMacControl : public WifiCommand
{
NanRequest mParams;
transaction_id mId = NAN_MAC_INVALID_TRANSID;
wifi_interface_handle mIface;
NanRequestType mType;
u32 mVersion;
u8 mChreNan;
public:
NanMacControl(wifi_interface_handle iface, int id,
NanRequest params, NanRequestType cmdType)
: WifiCommand("NanCommand", iface, id), mParams(params), mType(cmdType)
{
mVersion = 0;
setIface(iface);
setId(id);
}
~NanMacControl() {
ALOGE("NanMacControl destroyed\n");
}
void setIface(wifi_interface_handle iface ) {
mIface = iface;
}
void setId(transaction_id id) {
if (id != NAN_MAC_INVALID_TRANSID) {
mId = id;
}
}
transaction_id getId() {
return mId;
}
void setType(NanRequestType type) {
mType = type;
}
u32 getVersion() {
return mVersion;
}
void setMsg(NanRequest params) {
mParams = params;
}
void setChreNan(u8 chre_nan) {
mChreNan = chre_nan;
}
int createRequest(WifiRequest& request) {
ALOGI("NAN CMD: %s\n", NanCmdToString(mType));
if (mType == NAN_REQUEST_ENABLE) {
return createEnableRequest(request, (NanEnableRequest *)mParams);
} else if (mType == NAN_REQUEST_DISABLE) {
return createDisableRequest(request);
} else if (mType == NAN_REQUEST_CONFIG) {
return createConfigRequest(request, (NanConfigRequest*)mParams);
} else if (mType == NAN_REQUEST_STATS) {
/* TODO: Not yet implemented */
} else if (mType == NAN_REQUEST_TCA) {
/* TODO: Not yet implemented */
} else if (mType == NAN_VERSION_INFO) {
return createVersionRequest(request);
} else {
ALOGE("Unknown Nan request\n");
}
return WIFI_SUCCESS;
}
int createVersionRequest(WifiRequest& request) {
int result = request.create(GOOGLE_OUI, NAN_SUBCMD_VERSION_INFO);
if (result < 0) {
ALOGE("%s: Fail to create request\n", __func__);
return result;
}
nlattr *data = request.attr_start(NL80211_ATTR_VENDOR_DATA);
request.attr_end(data);
NAN_DBG_EXIT();
return WIFI_SUCCESS;
}
int createEnableRequest(WifiRequest& request, NanEnableRequest *mParams) {
int result = request.create(GOOGLE_OUI, NAN_SUBCMD_ENABLE);
s8 rssi;
if (result < 0) {
ALOGE("%s: Fail to create request\n", __func__);
return result;
}
NAN_DBG_ENTER();
nlattr *data = request.attr_start(NL80211_ATTR_VENDOR_DATA);
if (mParams->config_2dot4g_support) {
result = request.put_u8(NAN_ATTRIBUTE_2G_SUPPORT, mParams->support_2dot4g_val);
if (result < 0) {
ALOGE("%s: Failing in 2g support, result = %d\n", __func__, result);
return result;
}
}
if (mParams->config_support_5g) {
result = request.put_u8(NAN_ATTRIBUTE_5G_SUPPORT, mParams->support_5g_val);
if (result < 0) {
ALOGE("%s: Failing in 5g support, result = %d\n", __func__, result);
return result;
}
}
result = request.put_u16(NAN_ATTRIBUTE_CLUSTER_LOW, mParams->cluster_low);
if (result < 0) {
ALOGE("%s: Failing in cluster low, result = %d\n", __func__, result);
return result;
}
result = request.put_u16(NAN_ATTRIBUTE_CLUSTER_HIGH, mParams->cluster_high);
if (result < 0) {
ALOGE("%s: Failing in cluster high, result = %d\n", __func__, result);
return result;
}
if (mParams->config_sid_beacon) {
result = request.put_u8(NAN_ATTRIBUTE_SID_BEACON, mParams->sid_beacon_val);
if (result < 0) {
ALOGE("%s: Failing in sid beacon, result = %d\n", __func__, result);
return result;
}
}
if (mParams->config_subscribe_sid_beacon) {
result = request.put_u8(NAN_ATTRIBUTE_SUB_SID_BEACON, mParams->subscribe_sid_beacon_val);
if (result < 0) {
ALOGE("%s: Failing in sub sid beacon, result = %d\n", __func__, result);
return result;
}
}
if (mParams->config_2dot4g_beacons) {
result = request.put_u8(NAN_ATTRIBUTE_SYNC_DISC_2G_BEACON, mParams->beacon_2dot4g_val);
if (result < 0) {
ALOGE("%s: Failing in beacon_2dot4g_val, result = %d\n", __func__, result);
return result;
}
}
if (mParams->config_5g_beacons) {
result = request.put_u8(NAN_ATTRIBUTE_SYNC_DISC_5G_BEACON, mParams->beacon_5g_val);
if (result < 0) {
ALOGE("%s: Failing in 5g beacon, result = %d\n", __func__, result);
return result;
}
}
if (mParams->config_2dot4g_sdf) {
result = request.put_u8(NAN_ATTRIBUTE_SDF_2G_SUPPORT, mParams->sdf_2dot4g_val);
if (result < 0) {
ALOGE("%s: Failing in 2dot4g sdf, result = %d\n", __func__, result);
return result;
}
}
if (mParams->config_5g_sdf) {
result = request.put_u8(NAN_ATTRIBUTE_SDF_5G_SUPPORT, mParams->sdf_5g_val);
if (result < 0) {
ALOGE("%s: Failing in 5g sdf, result = %d\n", __func__, result);
return result;
}
}
if (mParams->config_2dot4g_rssi_close) {
if (ISGREATER(mParams->rssi_close_2dot4g_val, NAN_MAX_RSSI)) {
ALOGI("%s: Invalid rssi param \n", __func__);
return WIFI_ERROR_INVALID_ARGS;
}
rssi = -mParams->rssi_close_2dot4g_val;
result = request.put_s8(NAN_ATTRIBUTE_RSSI_CLOSE, rssi);
if (result < 0) {
ALOGE("%s: Failing in 2g rssi close, result = %d\n", __func__, result);
return result;
}
}
if (mParams->config_2dot4g_rssi_middle) {
if (ISGREATER(mParams->rssi_middle_2dot4g_val, NAN_MAX_RSSI)) {
ALOGI("%s: Invalid rssi param \n", __func__);
return WIFI_ERROR_INVALID_ARGS;
}
rssi = -mParams->rssi_middle_2dot4g_val;
result = request.put_s8(NAN_ATTRIBUTE_RSSI_MIDDLE, rssi);
if (result < 0) {
ALOGE("%s: Failing in 2g rssi middle, result = %d\n", __func__, result);
return result;
}
}
if (mParams->config_2dot4g_rssi_proximity) {
if (ISGREATER(mParams->rssi_proximity_2dot4g_val, NAN_MAX_RSSI)) {
ALOGI("%s: Invalid rssi param \n", __func__);
return WIFI_ERROR_INVALID_ARGS;
}
rssi = -mParams->rssi_proximity_2dot4g_val;
result = request.put_s8(NAN_ATTRIBUTE_RSSI_PROXIMITY, rssi);
if (result < 0) {
ALOGE("%s: Failing in 2g rssi proximity, result = %d\n", __func__, result);
return result;
}
}
if (mParams->config_5g_rssi_close) {
if (ISGREATER(mParams->rssi_close_5g_val, NAN_MAX_RSSI)) {
ALOGI("%s: Invalid rssi param \n", __func__);
return WIFI_ERROR_INVALID_ARGS;
}
rssi = -mParams->rssi_close_5g_val;
result = request.put_s8(NAN_ATTRIBUTE_RSSI_CLOSE_5G, rssi);
if (result < 0) {
ALOGE("%s: Failing in 5g rssi close, result = %d\n", __func__, result);
return result;
}
}
if (mParams->config_5g_rssi_middle) {
if (ISGREATER(mParams->rssi_middle_5g_val, NAN_MAX_RSSI)) {
ALOGI("%s: Invalid rssi param \n", __func__);
return WIFI_ERROR_INVALID_ARGS;
}
rssi = -mParams->rssi_middle_5g_val;
result = request.put_s8(NAN_ATTRIBUTE_RSSI_MIDDLE_5G, rssi);
if (result < 0) {
ALOGE("%s: Failing in 5g rssi middle, result = %d\n", __func__, result);
return result;
}
}
if (mParams->config_5g_rssi_close_proximity) {
if (ISGREATER(mParams->rssi_close_proximity_5g_val, NAN_MAX_RSSI)) {
ALOGI("%s: Invalid rssi param \n", __func__);
return WIFI_ERROR_INVALID_ARGS;
}
rssi = -mParams->rssi_close_proximity_5g_val;
result = request.put_s8(NAN_ATTRIBUTE_RSSI_PROXIMITY_5G, rssi);
if (result < 0) {
ALOGE("%s: Failing in rssi_close_proximity_5g_val, result = %d\n", __func__, result);
return result;
}
}
if (mParams->config_cluster_attribute_val) {
result = request.put_u8(NAN_ATTRIBUTE_CONF_CLUSTER_VAL, mParams->config_cluster_attribute_val);
if (result < 0) {
ALOGE("%s: Failing in config_cluster_attribute_val, result = %d\n", __func__, result);
return result;
}
}
if (mParams->config_hop_count_limit) {
result = request.put_u8(NAN_ATTRIBUTE_HOP_COUNT_LIMIT,
mParams->hop_count_limit_val);
if (result < 0) {
ALOGE("%s: Failing in hop cnt limit, result = %d\n", __func__, result);
return result;
}
}
if (mParams->config_oui) {
ALOGI("%s: oui = 0x%04x\n", __func__, mParams->oui_val);
result = request.put_u32(NAN_ATTRIBUTE_OUI, mParams->oui_val);
if (result < 0) {
ALOGE("%s: Failing in oui, result = %d\n", __func__, result);
return result;
}
}
result = request.put_u8(NAN_ATTRIBUTE_MASTER_PREF, mParams->master_pref);
if (result < 0) {
ALOGE("%s: Failing in master pref, result = %d\n", __func__, result);
return result;
}
if (mParams->config_random_factor_force) {
result = request.put_u8(NAN_ATTRIBUTE_RANDOM_FACTOR, mParams->random_factor_force_val);
if (result < 0) {
ALOGE("%s: Failing in random factor, result = %d\n", __func__, result);
return result;
}
}
if (mParams->config_24g_channel) {
result = request.put_u32(NAN_ATTRIBUTE_24G_CHANNEL, mParams->channel_24g_val);
if (result < 0) {
ALOGE("%s: Failing in 2.4g channel, result = %d\n", __func__, result);
return result;
}
}
if (mParams->config_5g_channel) {
result = request.put_u32(NAN_ATTRIBUTE_5G_CHANNEL, mParams->channel_5g_val);
if (result < 0) {
ALOGE("%s: Failing in 5g channel, result = %d\n", __func__, result);
return result;
}
}
if (mParams->config_intf_addr) {
result = request.put_addr(NAN_ATTRIBUTE_IF_ADDR, mParams->intf_addr_val);
if (result < 0) {
ALOGE("%s: Failing in intf addr val, result = %d\n", __func__, result);
return result;
}
}
if (mParams->config_dw.config_2dot4g_dw_band) {
result = request.put_u32(NAN_ATTRIBUTE_2G_AWAKE_DW, mParams->config_dw.dw_2dot4g_interval_val);
if (result < 0) {
ALOGE("%s: Failing in 2dot4g awake dw, result = %d\n", __func__, result);
return result;
}
}
if (mParams->config_dw.config_5g_dw_band) {
result = request.put_u32(NAN_ATTRIBUTE_5G_AWAKE_DW, mParams->config_dw.dw_5g_interval_val);
if (result < 0) {
ALOGE("%s: Failing in 5g awake dw, result = %d\n", __func__, result);
return result;
}
}
if (ISGREATER(mParams->discovery_indication_cfg, NAN_DISC_IND_MAX)) {
ALOGE("%s:Invalid disc_ind_cfg value.\n", __FUNCTION__);
return WIFI_ERROR_INVALID_ARGS;
}
result = request.put_u8(NAN_ATTRIBUTE_DISC_IND_CFG,
mParams->discovery_indication_cfg);
if (result < 0) {
ALOGE("%s: Failed to fill NAN_ATTRIBUTE_DISC_IND_CFG, result = %d\n",
__func__, result);
return result;
}
if (mParams->config_rssi_window_size) {
result = request.put_u8(NAN_ATTRIBUTE_RSSI_WINDOW_SIZE,
mParams->rssi_window_size_val);
if (result < 0) {
ALOGE("%s: Failing in rssi_window_size_val, result = %d\n", __func__, result);
return result;
}
}
if (mParams->config_scan_params) {
result = request.put_u8(NAN_ATTRIBUTE_DWELL_TIME,
mParams->scan_params_val.dwell_time[0]);
if (result < 0) {
ALOGE("%s: Failing in dwell time, result = %d\n", __func__, result);
return result;
}
result = request.put_u8(NAN_ATTRIBUTE_DWELL_TIME_5G,
mParams->scan_params_val.dwell_time[1]);
if (result < 0) {
ALOGE("%s: Failing in 5g dwell time, result = %d\n", __func__, result);
return result;
}
result = request.put_u16(NAN_ATTRIBUTE_SCAN_PERIOD,
mParams->scan_params_val.scan_period[0]);
if (result < 0) {
ALOGE("%s: Failing in scan_period, result = %d\n", __func__, result);
return result;
}
result = request.put_u16(NAN_ATTRIBUTE_SCAN_PERIOD_5G,
mParams->scan_params_val.scan_period[1]);
if (result < 0) {
ALOGE("%s: Failing in 5g scan_period, result = %d\n", __func__, result);
return result;
}
}
if (mParams->config_disc_mac_addr_randomization) {
result = request.put_u32(NAN_ATTRIBUTE_RANDOMIZATION_INTERVAL,
mParams->disc_mac_addr_rand_interval_sec);
if (result < 0) {
ALOGE("%s: Failing to fill rand mac address interval, result = %d\n", __func__, result);
return result;
}
}
if (mParams->config_discovery_beacon_int) {
result = request.put_u32(NAN_ATTRIBUTE_DISCOVERY_BEACON_INTERVAL,
mParams->discovery_beacon_interval);
if (result < 0) {
ALOGE("%s: Failing to fill disc beacon interval, result = %d\n", __func__, result);
return result;
}
}
if (mParams->config_nss) {
result = request.put_u32(NAN_ATTRIBUTE_NSS, mParams->nss);
if (result < 0) {
ALOGE("%s: Failing to fill nss, result = %d\n", __func__, result);
return result;
}
}
if (mParams->config_enable_ranging) {
result = request.put_u32(NAN_ATTRIBUTE_ENABLE_RANGING, mParams->enable_ranging);
if (result < 0) {
ALOGE("%s: Failing to fill enable ranging value, result = %d\n", __func__, result);
return result;
}
}
if (mParams->config_dw_early_termination) {
result = request.put_u32(NAN_ATTRIBUTE_DW_EARLY_TERM, mParams->enable_dw_termination);
if (result < 0) {
ALOGE("%s: Failing to fill enable dw termination value, result = %d\n",
__func__, result);
return result;
}
}
if (mParams->config_ndpe_attr) {
result = request.put_u32(NAN_ATTRIBUTE_CMD_USE_NDPE,
mParams->use_ndpe_attr);
if (result < 0) {
ALOGE("%s: Failing to fill use_ndpe, result = %d\n", __func__, result);
return result;
}
}
if (mParams->config_enable_instant_mode) {
result = request.put_u32(NAN_ATTRIBUTE_INSTANT_MODE_ENABLE,
mParams->enable_instant_mode);
if (result < 0) {
ALOGE("%s: Failing to fill enable instant mode, result = %d\n", __func__, result);
return result;
}
}
if (mParams->enable_instant_mode && mParams->config_instant_mode_channel
&& mParams->instant_mode_channel) {
result = request.put_u32(NAN_ATTRIBUTE_INSTANT_COMM_CHAN,
mParams->instant_mode_channel);
if (result < 0) {
ALOGE("%s: Failing in config instant channel, result = %d\n", __func__, result);
return result;
}
ALOGI("%s: instant mode channel = %d\n", __func__, mParams->instant_mode_channel);
}
result = request.put_u8(NAN_ATTRIBUTE_CHRE_REQUEST, mChreNan);
if (result < 0) {
ALOGE("%s: Failing in config chreNan, result = %d\n", __func__, result);
return result;
}
request.attr_end(data);
NAN_DBG_EXIT();
return WIFI_SUCCESS;
}
int createDisableRequest(WifiRequest& request) {
NAN_DBG_ENTER();
int result = request.create(GOOGLE_OUI, NAN_SUBCMD_DISABLE);
if (result < 0) {
ALOGE("%s: Fail to create request, result = %d\n", __func__, result);
return result;
}
nlattr *data = request.attr_start(NL80211_ATTR_VENDOR_DATA);
result = request.put_u8(NAN_ATTRIBUTE_CHRE_REQUEST, mChreNan);
if (result < 0) {
ALOGE("%s: Failing in config chreNan, result = %d\n", __func__, result);
return result;
}
request.attr_end(data);
NAN_DBG_EXIT();
return result;
}
int createConfigRequest(WifiRequest& request, NanConfigRequest *mParams) {
int result = request.create(GOOGLE_OUI, NAN_SUBCMD_CONFIG);
s8 rssi;
if (result < 0) {
ALOGE("%s: Fail to create config request\n", __func__);
return result;
}
NAN_DBG_ENTER();
nlattr *data = request.attr_start(NL80211_ATTR_VENDOR_DATA);
if (mParams->config_sid_beacon) {
result = request.put_u8(NAN_ATTRIBUTE_SID_BEACON, mParams->sid_beacon);
if (result < 0) {
ALOGE("%s: Failing in sid beacon, result = %d\n", __func__, result);
return result;
}
}
if (mParams->config_subscribe_sid_beacon) {
result = request.put_u8(NAN_ATTRIBUTE_SUB_SID_BEACON, mParams->subscribe_sid_beacon_val);
if (result < 0) {
ALOGE("%s: Failing in sub sid beacon, result = %d\n", __func__, result);
return result;
}
}
if (mParams->config_rssi_proximity) {
if (ISGREATER(mParams->rssi_proximity, NAN_MAX_RSSI)) {
ALOGI("%s: Invalid rssi param \n", __func__);
return WIFI_ERROR_INVALID_ARGS;
}
rssi = -mParams->rssi_proximity;
result = request.put_s8(NAN_ATTRIBUTE_RSSI_PROXIMITY, rssi);
if (result < 0) {
ALOGE("%s: Failing in rssi_proximity, result = %d\n", __func__, result);
return result;
}
}
if (mParams->config_master_pref) {
ALOGI("%s: master pref = %u\n", __func__, mParams->master_pref);
result = request.put_u8(NAN_ATTRIBUTE_MASTER_PREF, mParams->master_pref);
if (result < 0) {
ALOGE("%s: Failing in master pref, result = %d\n", __func__, result);
return result;
}
}
if (mParams->config_5g_rssi_close_proximity) {
if (ISGREATER(mParams->rssi_close_proximity_5g_val, NAN_MAX_RSSI)) {
ALOGI("%s: Invalid rssi param \n", __func__);
return WIFI_ERROR_INVALID_ARGS;
}
rssi = -mParams->rssi_close_proximity_5g_val;
result = request.put_s8(NAN_ATTRIBUTE_RSSI_PROXIMITY_5G, rssi);
if (result < 0) {
ALOGE("%s: Failing in rssi_close_proximity_5g_val, result = %d\n", __func__, result);
return result;
}
}
if (mParams->config_rssi_window_size) {
result = request.put_u8(NAN_ATTRIBUTE_RSSI_WINDOW_SIZE,
mParams->rssi_window_size_val);
if (result < 0) {
ALOGE("%s: Failing in rssi_window_size_val, result = %d\n", __func__, result);
return result;
}
}
if (mParams->config_scan_params) {
result = request.put_u8(NAN_ATTRIBUTE_DWELL_TIME,
mParams->scan_params_val.dwell_time[0]);
if (result < 0) {
ALOGE("%s: Failing in dwell time, result = %d\n", __func__, result);
return result;
}
result = request.put_u8(NAN_ATTRIBUTE_DWELL_TIME_5G,
mParams->scan_params_val.dwell_time[1]);
if (result < 0) {
ALOGE("%s: Failing in 5g dwell time, result = %d\n", __func__, result);
return result;
}
result = request.put_u16(NAN_ATTRIBUTE_SCAN_PERIOD,
mParams->scan_params_val.scan_period[0]);
if (result < 0) {
ALOGE("%s: Failing in scan_period, result = %d\n", __func__, result);
return result;
}
result = request.put_u16(NAN_ATTRIBUTE_SCAN_PERIOD_5G,
mParams->scan_params_val.scan_period[1]);
if (result < 0) {
ALOGE("%s: Failing in 5g scan_period, result = %d\n", __func__, result);
return result;
}
}
if (mParams->config_random_factor_force) {
result = request.put_u8(NAN_ATTRIBUTE_RANDOM_FACTOR, mParams->random_factor_force_val);
if (result < 0) {
ALOGE("%s: Failing in random factor, result = %d\n", __func__, result);
return result;
}
}
if (mParams->config_hop_count_force) {
result = request.put_u8(NAN_ATTRIBUTE_HOP_COUNT_LIMIT,
mParams->hop_count_force_val);
if (result < 0) {
ALOGE("%s: Failing in hop cnt limit, result = %d\n", __func__, result);
return result;
}
}
if (mParams->config_cluster_attribute_val) {
result = request.put_u8(NAN_ATTRIBUTE_CONF_CLUSTER_VAL, mParams->config_cluster_attribute_val);
if (result < 0) {
ALOGE("%s: Failing in config_cluster_attribute_val, result = %d\n", __func__, result);
return result;
}
}
if (mParams->config_fam) {
while (mParams->fam_val.numchans) {
result = request.put_u8(NAN_ATTRIBUTE_ENTRY_CONTROL,
mParams->fam_val.famchan[mParams->fam_val.numchans].entry_control);
if (result < 0) {
ALOGE("%s: Failing in entry control, result = %d\n", __func__, result);
return result;
}
result = request.put_u32(NAN_ATTRIBUTE_CHANNEL,
(u32)mParams->fam_val.famchan[mParams->fam_val.numchans].channel);
if (result < 0) {
ALOGE("%s: Failed to fill channel = %d, result = %d\n", __func__,
mParams->fam_val.famchan[mParams->fam_val.numchans].channel, result);
return result;
}
result = request.put_u32(NAN_ATTRIBUTE_AVAIL_BIT_MAP,
(u32)mParams->fam_val.famchan[mParams->fam_val.numchans].avail_interval_bitmap);
if (result < 0) {
ALOGE("%s: Failed to fill avail interval bitmap = %d, result = %d\n", __func__,
mParams->fam_val.famchan[mParams->fam_val.numchans].avail_interval_bitmap, result);
return result;
}
mParams->fam_val.numchans -= 1;
}
}
if (mParams->config_dw.config_2dot4g_dw_band) {
result = request.put_u32(NAN_ATTRIBUTE_2G_AWAKE_DW, mParams->config_dw.dw_2dot4g_interval_val);
if (result < 0) {
ALOGE("%s: Failing in 2dot4g awake dw, result = %d\n", __func__, result);
return result;
}
}
if (mParams->config_dw.config_5g_dw_band) {
result = request.put_u32(NAN_ATTRIBUTE_5G_AWAKE_DW, mParams->config_dw.dw_5g_interval_val);
if (result < 0) {
ALOGE("%s: Failing in 5g awake dw, result = %d\n", __func__, result);
return result;
}
}
if (ISGREATER(mParams->discovery_indication_cfg, NAN_DISC_IND_MAX)) {
ALOGE("%s:Invalid disc_ind_cfg value.\n", __FUNCTION__);
return WIFI_ERROR_INVALID_ARGS;
}
result = request.put_u8(NAN_ATTRIBUTE_DISC_IND_CFG,
mParams->discovery_indication_cfg);
if (result < 0) {
ALOGE("%s: Failed to fill NAN_ATTRIBUTE_DISC_IND_CFG, result = %d\n",
__func__, result);
return result;
}
if (mParams->config_disc_mac_addr_randomization) {
result = request.put_u32(NAN_ATTRIBUTE_RANDOMIZATION_INTERVAL,
mParams->disc_mac_addr_rand_interval_sec);
if (result < 0) {
ALOGE("%s: Failing in 5g scan_period, result = %d\n", __func__, result);
return result;
}
}
if (mParams->config_ndpe_attr) {
result = request.put_u32(NAN_ATTRIBUTE_CMD_USE_NDPE,
mParams->use_ndpe_attr);
if (result < 0) {
ALOGE("%s: Failing to fill use_ndpe, result = %d\n", __func__, result);
return result;
}
}
if (mParams->config_disc_mac_addr_randomization) {
result = request.put_u32(NAN_ATTRIBUTE_RANDOMIZATION_INTERVAL,
mParams->disc_mac_addr_rand_interval_sec);
if (result < 0) {
ALOGE("%s: Failing to fill rand mac interval, result = %d\n", __func__, result);
return result;
}
}
if (mParams->config_discovery_beacon_int) {
result = request.put_u32(NAN_ATTRIBUTE_DISCOVERY_BEACON_INTERVAL,
mParams->discovery_beacon_interval);
if (result < 0) {
ALOGE("%s: Failing to fill disc beacon interval, result = %d\n", __func__, result);
return result;
}
}
if (mParams->config_nss) {
result = request.put_u32(NAN_ATTRIBUTE_NSS, mParams->nss);
if (result < 0) {
ALOGE("%s: Failing to fill nss, result = %d\n", __func__, result);
return result;
}
}
if (mParams->config_enable_ranging) {
result = request.put_u32(NAN_ATTRIBUTE_ENABLE_RANGING, mParams->enable_ranging);
if (result < 0) {
ALOGE("%s: Failing to fill enable ranging value, result = %d\n", __func__, result);
return result;
}
}
if (mParams->config_dw_early_termination) {
result = request.put_u32(NAN_ATTRIBUTE_DW_EARLY_TERM, mParams->enable_dw_termination);
if (result < 0) {
ALOGE("%s: Failing to fill enable dw termination value, result = %d\n",
__func__, result);
return result;
}
}
if (mParams->config_enable_instant_mode) {
result = request.put_u32(NAN_ATTRIBUTE_INSTANT_MODE_ENABLE,
mParams->enable_instant_mode);
if (result < 0) {
ALOGE("%s: Failing to fill enable instant mode, result = %d\n", __func__, result);
return result;
}
}
if (mParams->enable_instant_mode && mParams->config_instant_mode_channel
&& mParams->instant_mode_channel) {
result = request.put_u32(NAN_ATTRIBUTE_INSTANT_COMM_CHAN,
mParams->instant_mode_channel);
if (result < 0) {
ALOGE("%s: Failing in config instant channel, result = %d\n", __func__, result);
return result;
}
ALOGI("%s: instant mode channel = %d\n", __func__, mParams->instant_mode_channel);
}
request.attr_end(data);
NAN_DBG_EXIT();
return WIFI_SUCCESS;
}
int start()
{
NAN_DBG_ENTER();
WifiRequest request(familyId(), ifaceId());
int result = createRequest(request);
if (result != WIFI_SUCCESS) {
ALOGE("%s: Failed to create setup request; result = %d", __func__, result);
return result;
}
result = requestResponse(request);
if (result != WIFI_SUCCESS) {
ALOGE("%s: Failed to configure setup; result = %d", __func__, result);
return result;
}
request.destroy();
NAN_DBG_EXIT();
return WIFI_SUCCESS;
}
int cancel()
{
NAN_DBG_ENTER();
WifiRequest request(familyId(), ifaceId());
int result = createRequest(request);
if (result != WIFI_SUCCESS) {
ALOGE("%s: Failed to create setup request; result = %d", __func__, result);
return result;
}
result = requestResponse(request);
if (result != WIFI_SUCCESS) {
ALOGE("%s: Failed to configure setup; result = %d", __func__, result);
return result;
}
request.destroy();
NAN_DBG_EXIT();
return WIFI_SUCCESS;
}
int handleResponse(WifiEvent& reply) {
nan_hal_resp_t *rsp_vndr_data = NULL;
if (reply.get_cmd() != NL80211_CMD_VENDOR || reply.get_vendor_data() == NULL) {
ALOGD("Ignoring reply with cmd = %d", reply.get_cmd());
return NL_SKIP;
}
if (mChreNan) {
return NL_SKIP;
}
rsp_vndr_data = (nan_hal_resp_t *)reply.get_vendor_data();
ALOGI("NanMacControl::handleResponse\n");
if (mType == NAN_VERSION_INFO) {
mVersion = *((u32*)reply.get_vendor_data());
ALOGI("Response not required for version cmd %d\n", mVersion);
return NL_SKIP;
}
if (rsp_vndr_data->subcmd == NAN_SUBCMD_CONFIG) {
NanResponseMsg rsp_data;
memset(&rsp_data, 0, sizeof(NanResponseMsg));
rsp_data.response_type = get_response_type((WIFI_SUB_COMMAND)rsp_vndr_data->subcmd);
rsp_data.status = nan_map_response_status(rsp_vndr_data->status);
ALOGI("NanMacControl:Received response for cmd [%s], TxID %d ret %d\n",
NanRspToString(rsp_data.response_type), id(), rsp_data.status);
GET_NAN_HANDLE(info)->mHandlers.NotifyResponse(id(), &rsp_data);
}
if (rsp_vndr_data->subcmd == NAN_SUBCMD_ENABLE) {
NanResponseMsg rsp_data;
memset(&rsp_data, 0, sizeof(NanResponseMsg));
rsp_data.response_type = get_response_type((WIFI_SUB_COMMAND)rsp_vndr_data->subcmd);
rsp_data.status = nan_map_response_status(rsp_vndr_data->status);
ALOGI("NanMacControl:Received response for cmd [%s], TxID %d ret %d\n",
NanRspToString(rsp_data.response_type), mId, rsp_data.status);
if( rsp_data.status != NAN_STATUS_SUCCESS) {
GET_NAN_HANDLE(info)->mHandlers.NotifyResponse(mId, &rsp_data);
}
}
return NL_SKIP;
}
int handleAsyncResponse(nan_hal_resp_t *rsp_vndr_data) {
NanResponseMsg rsp_data;
ALOGI("NanMacControl::handleAsyncResponse\n");
/* Enable response will be provided to framework in event path */
if (rsp_vndr_data->subcmd == NAN_SUBCMD_ENABLE) {
return NL_SKIP;
}
memset(&rsp_data, 0, sizeof(NanResponseMsg));
rsp_data.response_type = get_response_type((WIFI_SUB_COMMAND)rsp_vndr_data->subcmd);
rsp_data.status = nan_map_response_status(rsp_vndr_data->status);
ALOGE("Mapped hal status = %d\n", rsp_data.status);
/* populate error string if not coming from DHD */
if (rsp_vndr_data->nan_reason[0] == '\0') {
memcpy(rsp_data.nan_error, NanStatusToString(rsp_data.status),
strlen(NanStatusToString(rsp_data.status)));
rsp_data.nan_error[strlen(NanStatusToString(rsp_data.status))] = '\0';
}
rsp_data.nan_error[NAN_ERROR_STR_LEN - 1] = '\0';
ALOGI("\n Received nan_error string %s\n", (u8*)rsp_data.nan_error);
ALOGI("Retrieved ID = %d\n", mId);
if ((rsp_vndr_data->subcmd == NAN_SUBCMD_DISABLE) &&
(mId != NAN_MAC_INVALID_TRANSID)) {
GET_NAN_HANDLE(info)->mHandlers.NotifyResponse(mId, &rsp_data);
mId = NAN_MAC_INVALID_TRANSID;
}
return NL_SKIP;
}
int handleEvent(WifiEvent& event) {
u32 ndp_instance_id = 0;
int event_id = event.get_vendor_subcmd();
nlattr *vendor_data = event.get_attribute(NL80211_ATTR_VENDOR_DATA);
int len = event.get_vendor_data_len();
u16 attr_type;
nan_hal_resp_t *rsp_vndr_data = NULL;
ALOGI("%s: Received NanMacControl event = %d (len=%d)\n",
__func__, event.get_cmd(), len);
if (!vendor_data || len == 0) {
ALOGE("No event data found");
return NL_SKIP;
}
if (mChreNan) {
return NL_SKIP;
}
for (nl_iterator it(vendor_data); it.has_next(); it.next()) {
attr_type = it.get_type();
if (it.get_type() == NAN_ATTRIBUTE_HANDLE) {
} else if (it.get_type() == NAN_ATTRIBUTE_NDP_ID) {
ndp_instance_id = it.get_u32();
ALOGI("handleEvent: ndp_instance_id = [%d]\n", ndp_instance_id);
} else if (attr_type == NAN_ATTRIBUTE_CMD_RESP_DATA) {
ALOGI("sizeof cmd response data: %ld, it.get_len() = %d\n",
sizeof(nan_hal_resp_t), it.get_len());
if (it.get_len() == sizeof(nan_hal_resp_t)) {
rsp_vndr_data = (nan_hal_resp_t*)it.get_data();
} else {
ALOGE("Wrong cmd response data received\n");
return NL_SKIP;
}
}
}
ALOGI("Received vendor sub cmd %d\n", event_id);
if (is_de_event(event_id)) {
NanDiscEnginePrimitive *de_prim =
(NanDiscEnginePrimitive *)(info.nan_disc_control);
if (de_prim != NULL) {
de_prim->handleEvent(event);
} else {
ALOGE("%s: de_primitive is no more available\n", __func__);
}
return NL_SKIP;
} else if (is_dp_event(event_id)) {
NanDataPathPrimitive *dp_prim =
(NanDataPathPrimitive *)(info.nan_dp_control);
ALOGI("ndp_instance_id = [%d]\n", ndp_instance_id);
if (dp_prim != NULL) {
dp_prim->handleEvent(event);
} else {
ALOGE("%s: dp_primitive is no more available\n", __func__);
}
return NL_SKIP;
} else {
if (is_cmd_response(event_id)) {
ALOGE("Handling cmd response asynchronously\n");
if (rsp_vndr_data != NULL) {
handleAsyncResponse(rsp_vndr_data);
} else {
ALOGE("Wrong response data, rsp_vndr_data is NULL\n");
return NL_SKIP;
}
}
}
switch(event_id) {
case NAN_EVENT_DE_EVENT:
NanDiscEngEventInd de_event;
memset(&de_event, 0, sizeof(de_event));
for (nl_iterator it(vendor_data); it.has_next(); it.next()) {
attr_type = it.get_type();
if (attr_type == NAN_ATTRIBUTE_CLUSTER_ID) {
memcpy(&de_event.data.cluster.addr, it.get_data(), NAN_MAC_ADDR_LEN);
ALOGI("cluster id = " MACSTR "\n", MAC2STR(de_event.data.cluster.addr));
} else if (attr_type == NAN_ATTRIBUTE_ENABLE_STATUS) {
ALOGI("nan enable status = %u\n", it.get_u16());
} else if (attr_type == NAN_ATTRIBUTE_JOIN_STATUS) {
ALOGI("nan joined status = %u\n", it.get_u16());
} else if (attr_type == NAN_ATTRIBUTE_DE_EVENT_TYPE) {
u8 de_type = it.get_u8();
ALOGI("nan de event type = %u\n", de_type);
if (de_type == NAN_EVENT_IFACE) {
de_event.event_type = NAN_EVENT_ID_DISC_MAC_ADDR;
ALOGI("received NAN_EVENT_ID_DISC_MAC_ADDR event\n");
} else if (de_type == NAN_EVENT_START) {
de_event.event_type = NAN_EVENT_ID_STARTED_CLUSTER;
ALOGI("received NAN cluster started event\n");
} else if (de_type == NAN_EVENT_JOIN) {
/* To be deprecated */
de_event.event_type = NAN_EVENT_ID_JOINED_CLUSTER;
ALOGI("received join event\n");
} else if (de_type == NAN_EVENT_ROLE_CHANGE) {
ALOGI("received device role change event\n");
} else if (de_type == NAN_EVENT_MERGE) {
ALOGI("received merge event\n");
} else {
ALOGI("received unknown DE event, [%d]\n", de_type);
}
} else if (attr_type == NAN_ATTRIBUTE_MAC_ADDR) {
memcpy(&de_event.data.mac_addr.addr, it.get_data(), NAN_MAC_ADDR_LEN);
memcpy(mNmi, it.get_data(), NAN_MAC_ADDR_LEN);
ALOGI("Primary discovery mac address = " MACSTR "\n",
MAC2STR(mNmi));
}
}
GET_NAN_HANDLE(info)->mHandlers.EventDiscEngEvent(&de_event);
/* XXX: WAR for sending intf addr to generate Identity
* change callback in framework
* Also WAR for enable response
*/
if (de_event.event_type == NAN_EVENT_ID_STARTED_CLUSTER) {
NanResponseMsg rsp_data;
memcpy(&de_event.data.mac_addr.addr, mNmi, NAN_MAC_ADDR_LEN);
de_event.event_type = NAN_EVENT_ID_DISC_MAC_ADDR;
GET_NAN_HANDLE(info)->mHandlers.EventDiscEngEvent(&de_event);
rsp_data.response_type = NAN_RESPONSE_ENABLED;
rsp_data.status = NAN_STATUS_SUCCESS;
memcpy(rsp_data.nan_error, NanStatusToString(rsp_data.status),
strlen(NanStatusToString(rsp_data.status)));
GET_NAN_HANDLE(info)->mHandlers.NotifyResponse(mId, &rsp_data);
/* clean up mId to distinguish duplciated disable command */
mId = NAN_MAC_INVALID_TRANSID;
}
break;
case NAN_EVENT_DISABLED:
ALOGI("Received NAN_EVENT_DISABLED\n");
NanDisabledInd disabled_ind;
memset(&disabled_ind, 0, sizeof(NanDisabledInd));
for (nl_iterator it(vendor_data); it.has_next(); it.next()) {
attr_type = it.get_type();
if (attr_type == NAN_ATTRIBUTE_STATUS) {
disabled_ind.reason = (NanStatusType)it.get_u8();
ALOGI("Nan Disable:status %u", disabled_ind.reason);
} else if (attr_type == NAN_ATTRIBUTE_REASON) {
u8 len = min(it.get_len(), sizeof(disabled_ind.nan_reason) - 1);
memcpy(disabled_ind.nan_reason, it.get_data(), len);
disabled_ind.nan_reason[len] = '\0';
ALOGI("Disabled nan reason: %s, len = %d\n",
disabled_ind.nan_reason, len);
}
}
GET_NAN_HANDLE(info)->mHandlers.EventDisabled(&disabled_ind);
/* unregister Nan vendor events */
unRegisterNanVendorEvents();
break;
case NAN_EVENT_SDF:
ALOGI("Received NAN_EVENT_SDF:\n");
NanBeaconSdfPayloadInd sdfInd;
memset(&sdfInd, 0, sizeof(sdfInd));
for (nl_iterator it(vendor_data); it.has_next(); it.next()) {
attr_type = it.get_type();
if (attr_type == NAN_ATTRIBUTE_SERVICE_SPECIFIC_INFO_LEN) {
sdfInd.data.frame_len = it.get_u16();
if (sdfInd.data.frame_len > NAN_MAX_FRAME_DATA_LEN) {
sdfInd.data.frame_len = NAN_MAX_FRAME_DATA_LEN;
}
ALOGI("Received NAN_ATTRIBUTE_SERVICE_SPECIFIC_INFO_LEN: 0x%x(%d)\n",
sdfInd.data.frame_len, sdfInd.data.frame_len);
} else if (attr_type == NAN_ATTRIBUTE_SERVICE_SPECIFIC_INFO) {
ALOGI("Received NAN_ATTRIBUTE_SERVICE_SPECIFIC_INFO\n");
memcpy(&sdfInd.data.frame_data, it.get_data(), sdfInd.data.frame_len);
prhex("sdfInd.data.frame_data: ", (u8*)sdfInd.data.frame_data,
sdfInd.data.frame_len);
}
}
GET_NAN_HANDLE(info)->mHandlers.EventBeaconSdfPayload(&sdfInd);
break;
case NAN_EVENT_TCA:
ALOGI("Received NAN_EVENT_TCA\n");
break;
case NAN_EVENT_UNKNOWN:
ALOGI("Received NAN_EVENT_UNKNOWN\n");
break;
} // end-of-switch
return NL_SKIP;
}
void unRegisterNanVendorEvents()
{
int i = 0;
for (i = NAN_EVENT_ENABLED; i <= NAN_EVENT_DATA_END; i++) {
unregisterVendorHandler(GOOGLE_OUI, i);
}
unregisterVendorHandler(GOOGLE_OUI, NAN_ASYNC_RESPONSE_DISABLED);
unregisterVendorHandler(GOOGLE_OUI, NAN_EVENT_MATCH_EXPIRY);
}
void registerNanVendorEvents()
{
int i = 0;
for (i = NAN_EVENT_ENABLED; i <= NAN_EVENT_DATA_END; i++) {
registerVendorHandler(GOOGLE_OUI, i);
}
registerVendorHandler(GOOGLE_OUI, NAN_ASYNC_RESPONSE_DISABLED);
registerVendorHandler(GOOGLE_OUI, NAN_EVENT_MATCH_EXPIRY);
}
};
/* pretty hex print a contiguous buffer */
static void prhex(const char *msg, u8 *buf, u32 nbytes)
{
char line[128];
char *p;
int len = sizeof(line);
int nchar;
u32 i;
if (msg && (msg[0] != '\0')) {
printf("%s:\n", msg);
}
p = line;
for (i = 0; i < nbytes; i++) {
if (i % 16 == 0) {
nchar = snprintf(p, len, " %04d: ", i); /* line prefix */
p += nchar;
len -= nchar;
}
if (len > 0) {
nchar = snprintf(p, len, "%02x ", buf[i]);
p += nchar;
len -= nchar;
}
if (i % 16 == 15) {
ALOGE("%s\n", line); /* flush line */
p = line;
len = sizeof(line);
}
}
/* flush last partial line */
if (p != line) {
ALOGE("%s\n", line);
}
}
static const char *NanRspToString(int cmd_resp)
{
switch (cmd_resp) {
C2S(NAN_RESPONSE_ENABLED)
C2S(NAN_RESPONSE_DISABLED)
C2S(NAN_RESPONSE_PUBLISH)
C2S(NAN_RESPONSE_SUBSCRIBE)
C2S(NAN_RESPONSE_PUBLISH_CANCEL)
C2S(NAN_RESPONSE_SUBSCRIBE_CANCEL)
C2S(NAN_RESPONSE_TRANSMIT_FOLLOWUP)
C2S(NAN_RESPONSE_CONFIG)
C2S(NAN_RESPONSE_TCA)
C2S(NAN_RESPONSE_STATS)
C2S(NAN_DP_INTERFACE_CREATE)
C2S(NAN_DP_INTERFACE_DELETE)
C2S(NAN_DP_INITIATOR_RESPONSE)
C2S(NAN_DP_RESPONDER_RESPONSE)
C2S(NAN_DP_END)
C2S(NAN_GET_CAPABILITIES)
default:
return "UNKNOWN_NAN_CMD_RESPONSE";
}
}
static const char *NanCmdToString(int cmd)
{
switch (cmd) {
C2S(NAN_REQUEST_ENABLE)
C2S(NAN_REQUEST_DISABLE)
C2S(NAN_REQUEST_PUBLISH)
C2S(NAN_REQUEST_PUBLISH_CANCEL)
C2S(NAN_REQUEST_TRANSMIT_FOLLOWUP)
C2S(NAN_REQUEST_SUBSCRIBE)
C2S(NAN_REQUEST_SUBSCRIBE_CANCEL)
C2S(NAN_REQUEST_STATS)
C2S(NAN_REQUEST_CONFIG)
C2S(NAN_REQUEST_TCA)
C2S(NAN_REQUEST_EVENT_CHECK)
C2S(NAN_REQUEST_GET_CAPABILTIES)
C2S(NAN_DATA_PATH_IFACE_CREATE)
C2S(NAN_DATA_PATH_IFACE_DELETE)
C2S(NAN_DATA_PATH_INIT_REQUEST)
C2S(NAN_DATA_PATH_IND_RESPONSE)
C2S(NAN_DATA_PATH_END)
C2S(NAN_DATA_PATH_IFACE_UP)
C2S(NAN_DATA_PATH_SEC_INFO)
C2S(NAN_VERSION_INFO)
default:
return "UNKNOWN_NAN_CMD";
}
}
static const char *NanAttrToString(u16 cmd)
{
switch (cmd) {
C2S(NAN_ATTRIBUTE_HEADER)
C2S(NAN_ATTRIBUTE_HANDLE)
C2S(NAN_ATTRIBUTE_TRANSAC_ID)
C2S(NAN_ATTRIBUTE_5G_SUPPORT)
C2S(NAN_ATTRIBUTE_CLUSTER_LOW)
C2S(NAN_ATTRIBUTE_CLUSTER_HIGH)
C2S(NAN_ATTRIBUTE_SID_BEACON)
C2S(NAN_ATTRIBUTE_SYNC_DISC_5G_BEACON)
C2S(NAN_ATTRIBUTE_RSSI_CLOSE)
C2S(NAN_ATTRIBUTE_RSSI_MIDDLE)
C2S(NAN_ATTRIBUTE_RSSI_PROXIMITY)
C2S(NAN_ATTRIBUTE_HOP_COUNT_LIMIT)
C2S(NAN_ATTRIBUTE_RANDOM_FACTOR)
C2S(NAN_ATTRIBUTE_MASTER_PREF)
C2S(NAN_ATTRIBUTE_PERIODIC_SCAN_INTERVAL)
C2S(NAN_ATTRIBUTE_PUBLISH_ID)
C2S(NAN_ATTRIBUTE_TTL)
C2S(NAN_ATTRIBUTE_PERIOD)
C2S(NAN_ATTRIBUTE_REPLIED_EVENT_FLAG)
C2S(NAN_ATTRIBUTE_PUBLISH_TYPE)
C2S(NAN_ATTRIBUTE_TX_TYPE)
C2S(NAN_ATTRIBUTE_PUBLISH_COUNT)
C2S(NAN_ATTRIBUTE_SERVICE_NAME_LEN)
C2S(NAN_ATTRIBUTE_SERVICE_NAME)
C2S(NAN_ATTRIBUTE_SERVICE_SPECIFIC_INFO_LEN)
C2S(NAN_ATTRIBUTE_SERVICE_SPECIFIC_INFO)
C2S(NAN_ATTRIBUTE_RX_MATCH_FILTER_LEN)
C2S(NAN_ATTRIBUTE_RX_MATCH_FILTER)
C2S(NAN_ATTRIBUTE_TX_MATCH_FILTER_LEN)
C2S(NAN_ATTRIBUTE_TX_MATCH_FILTER)
C2S(NAN_ATTRIBUTE_SUBSCRIBE_ID)
C2S(NAN_ATTRIBUTE_SUBSCRIBE_TYPE)
C2S(NAN_ATTRIBUTE_SERVICERESPONSEFILTER)
C2S(NAN_ATTRIBUTE_SERVICERESPONSEINCLUDE)
C2S(NAN_ATTRIBUTE_USESERVICERESPONSEFILTER)
C2S(NAN_ATTRIBUTE_SSIREQUIREDFORMATCHINDICATION)
C2S(NAN_ATTRIBUTE_SUBSCRIBE_MATCH)
C2S(NAN_ATTRIBUTE_SUBSCRIBE_COUNT)
C2S(NAN_ATTRIBUTE_MAC_ADDR)
C2S(NAN_ATTRIBUTE_MAC_ADDR_LIST)
C2S(NAN_ATTRIBUTE_MAC_ADDR_LIST_NUM_ENTRIES)
C2S(NAN_ATTRIBUTE_PUBLISH_MATCH)
C2S(NAN_ATTRIBUTE_ENABLE_STATUS)
C2S(NAN_ATTRIBUTE_JOIN_STATUS)
C2S(NAN_ATTRIBUTE_ROLE)
C2S(NAN_ATTRIBUTE_MASTER_RANK)
C2S(NAN_ATTRIBUTE_ANCHOR_MASTER_RANK)
C2S(NAN_ATTRIBUTE_CNT_PEND_TXFRM)
C2S(NAN_ATTRIBUTE_CNT_BCN_TX)
C2S(NAN_ATTRIBUTE_CNT_BCN_RX)
C2S(NAN_ATTRIBUTE_CNT_SVC_DISC_TX)
C2S(NAN_ATTRIBUTE_CNT_SVC_DISC_RX)
C2S(NAN_ATTRIBUTE_AMBTT)
C2S(NAN_ATTRIBUTE_CLUSTER_ID)
C2S(NAN_ATTRIBUTE_INST_ID)
C2S(NAN_ATTRIBUTE_OUI)
C2S(NAN_ATTRIBUTE_STATUS)
C2S(NAN_ATTRIBUTE_DE_EVENT_TYPE)
C2S(NAN_ATTRIBUTE_MERGE)
C2S(NAN_ATTRIBUTE_IFACE)
C2S(NAN_ATTRIBUTE_CHANNEL)
C2S(NAN_ATTRIBUTE_PEER_ID)
C2S(NAN_ATTRIBUTE_NDP_ID)
C2S(NAN_ATTRIBUTE_SECURITY)
C2S(NAN_ATTRIBUTE_QOS)
C2S(NAN_ATTRIBUTE_RSP_CODE)
C2S(NAN_ATTRIBUTE_INST_COUNT)
C2S(NAN_ATTRIBUTE_PEER_DISC_MAC_ADDR)
C2S(NAN_ATTRIBUTE_PEER_NDI_MAC_ADDR)
C2S(NAN_ATTRIBUTE_IF_ADDR)
C2S(NAN_ATTRIBUTE_WARMUP_TIME)
C2S(NAN_ATTRIBUTE_RANGING_RESULT)
C2S(NAN_ATTRIBUTE_RANGING_INDICATION)
C2S(NAN_ATTRIBUTE_SDEA_SERVICE_SPECIFIC_INFO_LEN)
C2S(NAN_ATTRIBUTE_SDEA_SERVICE_SPECIFIC_INFO)
C2S(NAN_ATTRIBUTE_RANDOMIZATION_INTERVAL)
C2S(NAN_ATTRIBUTE_ENABLE_MERGE)
default:
return "NAN_ATTRIBUTE_UNKNOWN";
}
}
NanResponseType get_response_type(WIFI_SUB_COMMAND nan_subcmd)
{
NanResponseType response_type;
switch(nan_subcmd) {
case NAN_SUBCMD_ENABLE:
response_type = NAN_RESPONSE_ENABLED;
break;
case NAN_SUBCMD_DISABLE:
response_type = NAN_RESPONSE_DISABLED;
break;
case NAN_SUBCMD_PUBLISH:
response_type = NAN_RESPONSE_PUBLISH;
break;
case NAN_SUBCMD_SUBSCRIBE:
response_type = NAN_RESPONSE_SUBSCRIBE;
break;
case NAN_SUBCMD_PUBLISH_CANCEL:
response_type = NAN_RESPONSE_PUBLISH_CANCEL;
break;
case NAN_SUBCMD_SUBSCRIBE_CANCEL:
response_type = NAN_RESPONSE_SUBSCRIBE_CANCEL;
break;
case NAN_SUBCMD_TRANSMIT_FOLLOWUP:
response_type = NAN_RESPONSE_TRANSMIT_FOLLOWUP;
break;
case NAN_SUBCMD_CONFIG:
response_type = NAN_RESPONSE_CONFIG;
break;
case NAN_SUBCMD_TCA:
response_type = NAN_RESPONSE_TCA;
break;
case NAN_SUBCMD_STATS:
response_type = NAN_RESPONSE_STATS;
break;
case NAN_SUBCMD_DATA_PATH_IFACE_CREATE:
response_type = NAN_DP_INTERFACE_CREATE;
break;
case NAN_SUBCMD_DATA_PATH_IFACE_DELETE:
response_type = NAN_DP_INTERFACE_DELETE;
break;
case NAN_SUBCMD_DATA_PATH_REQUEST:
response_type = NAN_DP_INITIATOR_RESPONSE;
break;
case NAN_SUBCMD_DATA_PATH_RESPONSE:
response_type = NAN_DP_RESPONDER_RESPONSE;
break;
case NAN_SUBCMD_DATA_PATH_END:
response_type = NAN_DP_END;
break;
case NAN_SUBCMD_GET_CAPABILITIES:
response_type = NAN_GET_CAPABILITIES;
break;
default:
/* unknown response for a command */
response_type = NAN_RESPONSE_ERROR;
break;
}
return response_type;
}
NanResponseType get_response_type_frm_req_type(NanRequestType cmdType) {
NanResponseType response_type;
switch (cmdType) {
case NAN_DATA_PATH_IFACE_CREATE:
response_type = NAN_DP_INTERFACE_CREATE;
break;
case NAN_DATA_PATH_IFACE_DELETE:
response_type = NAN_DP_INTERFACE_DELETE;
break;
default:
/* unknown response for a request type */
response_type = NAN_RESPONSE_ERROR;
break;
}
return response_type;
}
static int get_svc_hash(unsigned char *svc_name,
u16 svc_name_len, u8 *svc_hash, u16 svc_hash_len)
{
SHA256_CTX sha_ctx;
u8 sha_hash[SHA256_DIGEST_LENGTH];
unsigned char *p;
int len = svc_name_len;
if (!svc_name || !svc_hash) {
ALOGE("Bad arguments!!\n");
return WIFI_ERROR_UNKNOWN;
}
if (svc_hash_len < NAN_SVC_HASH_SIZE) {
ALOGE("Bad len!!\n");
return WIFI_ERROR_UNKNOWN;
}
for (p = svc_name; *p; p++)
{
*p = tolower((int)*p);
}
SHA256_Init(&sha_ctx);
SHA256_Update(&sha_ctx, svc_name, len);
SHA256_Final(sha_hash, &sha_ctx);
memcpy(svc_hash, sha_hash, NAN_SVC_HASH_SIZE);
ALOGI("svc_name: %s\n", svc_name);
prhex("svc_hash:", svc_hash, NAN_SVC_HASH_SIZE);
return WIFI_SUCCESS;
}
static int dump_NanEnableRequest(NanEnableRequest* msg)
{
ALOGI("%s: Dump NanEnableRequest msg:\n", __func__);
if (msg == NULL) {
ALOGE("Invalid msg\n");
return WIFI_ERROR_UNKNOWN;
}
ALOGI("master_pref=%u\n", msg->master_pref);
ALOGI("cluster_low=%u\n", msg->cluster_low);
ALOGI("cluster_high=%u\n", msg->cluster_high);
ALOGI("config_support_5g=%u\n", msg->config_support_5g);
ALOGI("support_5g_val=%u\n", msg->support_5g_val);
ALOGI("config_sid_beacon=%u\n", msg->config_sid_beacon);
ALOGI("sid beacon=%u\n", msg->sid_beacon_val);
ALOGI("config_sub_sid_beacon=%u\n", msg->config_subscribe_sid_beacon);
ALOGI("sub sid beacon=%u\n", msg->subscribe_sid_beacon_val);
ALOGI("config_2dot4g_rssi_close=%u\n", msg->config_2dot4g_rssi_close);
ALOGI("rssi_close_2dot4g_val=%u\n", msg->rssi_close_2dot4g_val);
ALOGI("config_2dot4g_rssi_middle=%u\n", msg->config_2dot4g_rssi_middle);
ALOGI("rssi_middle_2dot4g_val=%u\n", msg->rssi_middle_2dot4g_val);
ALOGI("config_2dot4g_rssi_proximity=%u\n", msg->config_2dot4g_rssi_proximity);
ALOGI("rssi_proximity_2dot4g_val=%u\n", msg->rssi_proximity_2dot4g_val);
ALOGI("config_hop_count_limit=%u\n", msg->config_hop_count_limit);
ALOGI("hop_count_limit_val=%u\n", msg->hop_count_limit_val);
ALOGI("config_2dot4g_support=%u\n", msg->config_2dot4g_support);
ALOGI("support_2dot4g_val=%u\n", msg->support_2dot4g_val);
ALOGI("config_2dot4g_beacons=%u\n", msg->config_2dot4g_beacons);
ALOGI("beacon_2dot4g_val=%u\n", msg->beacon_2dot4g_val);
ALOGI("config_2dot4g_sdf=%u\n", msg->config_2dot4g_sdf);
ALOGI("sdf_2dot4g_val=%u\n", msg->sdf_2dot4g_val);
ALOGI("config_5g_beacons=%u\n", msg->config_5g_beacons);
ALOGI("beacon_5g_val=%u\n", msg->beacon_5g_val);
ALOGI("config_5g_sdf=%u\n", msg->config_5g_sdf);
ALOGI("config_5g_rssi_close=%u\n", msg->config_5g_rssi_close);
ALOGI("rssi_close_5g_val=%u\n", msg->rssi_close_5g_val);
ALOGI("config_5g_rssi_middle=%u\n", msg->config_5g_rssi_middle);
ALOGI("rssi_middle_5g_val=%u\n", msg->rssi_middle_5g_val);
ALOGI("config_5g_rssi_close_proximity=%u\n", msg->config_5g_rssi_close_proximity);
ALOGI("rssi_close_proximity_5g_val=%u\n", msg->rssi_close_proximity_5g_val);
ALOGI("config_rssi_window_size=%u\n", msg->config_rssi_window_size);
ALOGI("rssi_window_size_val=%u\n", msg->rssi_window_size_val);
ALOGI("config_oui=%u\n", msg->config_oui);
ALOGI("oui_val=%u\n", msg->oui_val);
ALOGI("config_intf_addr=%u\n", msg->config_intf_addr);
ALOGI("intf_addr_val=" MACSTR "\n", MAC2STR(msg->intf_addr_val));
ALOGI("config_cluster_attribute_val=%u\n", msg->config_cluster_attribute_val);
ALOGI("config_scan_params=%u\n", msg->config_scan_params);
if (msg->config_scan_params) {
ALOGI("dwell_time=%u\n", msg->scan_params_val.dwell_time[0]);
ALOGI("scan_period=%u\n", msg->scan_params_val.scan_period[0]);
}
ALOGI("config_random_factor_force=%u\n", msg->config_random_factor_force);
ALOGI("random_factor_force_val=%u\n", msg->random_factor_force_val);
ALOGI("config_hop_count_force=%u\n", msg->config_hop_count_force);
ALOGI("config_24g_channel=%u\n", msg->config_24g_channel);
ALOGI("channel_24g_val=%u\n", msg->channel_24g_val);
ALOGI("config_5g_channel=%u\n", msg->config_5g_channel);
ALOGI("channel_5g_val=%u\n", msg->channel_5g_val);
ALOGI("config_dw.config_2dot4g_dw_band=%u\n", msg->config_dw.config_2dot4g_dw_band);
if (msg->config_dw.config_2dot4g_dw_band) {
ALOGI("dw_2dot4g_interval_val=%u\n", msg->config_dw.dw_2dot4g_interval_val);
}
ALOGI("config_dw.config_5g_dw_band=%u\n", msg->config_dw.config_5g_dw_band);
if (msg->config_dw.config_5g_dw_band) {
ALOGI("dw_5g_interval_val=%u\n", msg->config_dw.dw_5g_interval_val);
}
ALOGI("discovery_indication_cfg=%u\n", msg->discovery_indication_cfg);
ALOGI("config_ndpe_attr=%u\n", msg->config_ndpe_attr);
if (msg->config_ndpe_attr) {
ALOGI("use_ndpe_attr=%u\n", msg->use_ndpe_attr);
}
ALOGI("config_discovery_beacon_int=%u\n", msg->config_discovery_beacon_int);
if (msg->config_discovery_beacon_int) {
ALOGI("discovery beacon interval =%u\n", msg->discovery_beacon_interval);
}
ALOGI("config_nss=%u\n", msg->config_nss);
if (msg->config_nss) {
ALOGI("nss =%u\n", msg->nss);
}
ALOGI("config_enable_ranging =%u\n", msg->config_enable_ranging);
if (msg->config_enable_ranging) {
ALOGI("enable_ranging =%u\n", msg->enable_ranging);
}
ALOGI("config_dw_early_termination =%u\n", msg->config_dw_early_termination);
if (msg->config_dw_early_termination) {
ALOGI("enable_dw_termination =%u\n", msg->enable_dw_termination);
}
ALOGI("config_disc_mac_addr_randomization=%u\n", msg->config_disc_mac_addr_randomization);
if (msg->config_disc_mac_addr_randomization) {
ALOGI("disc_mac_addr_rand_interval_sec =%u\n", msg->disc_mac_addr_rand_interval_sec);
}
ALOGI("config_enable_instant_mode =%u\n", msg->config_enable_instant_mode);
if (msg->config_enable_instant_mode) {
ALOGI("enable_instant_mode =%u\n", msg->enable_instant_mode);
}
ALOGI("config_instant_mode_channel=%u\n", msg->config_instant_mode_channel);
if (msg->config_instant_mode_channel) {
ALOGI("instant_mode_channel=%u\n", msg->instant_mode_channel);
}
return WIFI_SUCCESS;
}
#ifdef CONFIG_BRCM
static int dump_NanConfigRequestRequest(NanConfigRequest* msg)
{
ALOGI("%s: Dump NanConfigRequest msg:\n", __func__);
if (msg == NULL) {
ALOGE("Invalid msg\n");
return WIFI_ERROR_UNKNOWN;
}
ALOGI("master_pref=%u\n", msg->master_pref);
ALOGI("sid beacon=%u\n", msg->sid_beacon);
ALOGI("config_sub_sid_beacon=%u\n", msg->config_subscribe_sid_beacon);
ALOGI("sub sid beacon=%u\n", msg->subscribe_sid_beacon_val);
ALOGI("rssi_proximity=%u\n", msg->rssi_proximity);
ALOGI("rssi_close_proximity_5g_val=%u\n", msg->rssi_close_proximity_5g_val);
ALOGI("rssi_window_size_val=%u\n", msg->rssi_window_size_val);
ALOGI("scan_params_val.dwell_time[0]=%u\n", msg->scan_params_val.dwell_time[0]);
ALOGI("scan_params_val.scan_period[0]=%u\n", msg->scan_params_val.scan_period[0]);
ALOGI("config_scan_params=%u\n", msg->config_scan_params);
ALOGI("random_factor_force_val=%u\n", msg->random_factor_force_val);
ALOGI("hop_count_force_val=%u\n", msg->hop_count_force_val);
ALOGI("fam_val.numchans=%u\n", msg->fam_val.numchans);
ALOGI("fam_val.famchan[0].entry_control=%u\n", msg->fam_val.famchan[0].entry_control);
ALOGI("fam_val.famchan[0].class_val=%u\n", msg->fam_val.famchan[0].class_val);
ALOGI("fam_val.famchan[0].channel=%u\n", msg->fam_val.famchan[0].channel);
ALOGI("fam_val.famchan[0].mapid=%u\n", msg->fam_val.famchan[0].mapid);
ALOGI("fam_val.famchan[0].avail_interval_bitmap=%u\n", msg->fam_val.famchan[0].avail_interval_bitmap);
ALOGI("config_dw.config_2dot4g_dw_band=%u\n", msg->config_dw.config_2dot4g_dw_band);
if (msg->config_dw.config_2dot4g_dw_band) {
ALOGI("dw_2dot4g_interval_val=%u\n", msg->config_dw.dw_2dot4g_interval_val);
}
ALOGI("config_dw.config_5g_dw_band=%u\n", msg->config_dw.config_5g_dw_band);
if (msg->config_dw.config_5g_dw_band) {
ALOGI("dw_5g_interval_val=%u\n", msg->config_dw.dw_5g_interval_val);
}
ALOGI("discovery_indication_cfg=%u\n", msg->discovery_indication_cfg);
ALOGI("config_ndpe_attr=%u\n", msg->config_ndpe_attr);
if (msg->config_ndpe_attr) {
ALOGI("use_ndpe_attr=%u\n", msg->use_ndpe_attr);
}
ALOGI("config_discovery_beacon_int=%u\n", msg->config_discovery_beacon_int);
if (msg->config_discovery_beacon_int) {
ALOGI("discovery beacon interval =%u\n", msg->discovery_beacon_interval);
}
ALOGI("config_nss=%u\n", msg->config_nss);
if (msg->config_nss) {
ALOGI("nss =%u\n", msg->nss);
}
ALOGI("config_enable_ranging =%u\n", msg->config_enable_ranging);
if (msg->config_enable_ranging) {
ALOGI("enable_ranging =%u\n", msg->enable_ranging);
}
ALOGI("config_dw_early_termination =%u\n", msg->config_dw_early_termination);
if (msg->config_dw_early_termination) {
ALOGI("enable_dw_termination =%u\n", msg->enable_dw_termination);
}
ALOGI("config_disc_mac_addr_randomization=%u\n", msg->config_disc_mac_addr_randomization);
if (msg->config_disc_mac_addr_randomization) {
ALOGI("disc_mac_addr_rand_interval_sec =%u\n", msg->disc_mac_addr_rand_interval_sec);
}
ALOGI("config_enable_instant_mode =%u\n", msg->config_enable_instant_mode);
if (msg->config_enable_instant_mode) {
ALOGI("enable_instant_mode =%u\n", msg->enable_instant_mode);
}
ALOGI("config_instant_mode_channel=%u\n", msg->config_instant_mode_channel);
if (msg->config_instant_mode_channel) {
ALOGI("instant_mode_channel=%u\n", msg->instant_mode_channel);
}
return WIFI_SUCCESS;
}
static int dump_NanPublishRequest(NanPublishRequest* msg)
{
ALOGI("%s: Dump NanPublishRequest msg:\n", __func__);
if (msg == NULL) {
ALOGE("Invalid msg\n");
return WIFI_ERROR_UNKNOWN;
}
ALOGI("publish_id=%u\n", msg->publish_id);
ALOGI("ttl=%u\n", msg->ttl);
ALOGI("period=%u\n", msg->period);
ALOGI("publish_type=%u\n", msg->publish_type);
ALOGI("tx_type=%u\n", msg->tx_type);
ALOGI("publish_count=%u\n", msg->publish_count);
ALOGI("publish_match_indicator=%u\n", msg->publish_match_indicator);
ALOGI("service_responder_policy=%u\n", msg->service_responder_policy);
ALOGI("service_name_len=%u\n", msg->service_name_len);
if (msg->service_name_len) {
ALOGI("service_name=%s\n", msg->service_name);
}
ALOGI("service_specific_info_len=%u\n", msg->service_specific_info_len);
if (msg->service_specific_info_len) {
ALOGI("service_specific_info=%s\n", msg->service_specific_info);
}
ALOGI("rx_match_filter_len=%u\n", msg->rx_match_filter_len);
if (msg->rx_match_filter_len) {
prhex("rx_match_filter", msg->rx_match_filter, msg->rx_match_filter_len);
}
ALOGI("tx_match_filter_len=%u\n", msg->tx_match_filter_len);
if (msg->tx_match_filter_len) {
prhex("tx_match_filter", msg->tx_match_filter, msg->tx_match_filter_len);
}
ALOGI("rssi_threshold_flag=%u\n", msg->rssi_threshold_flag);
ALOGI("connmap=%u\n", msg->connmap);
ALOGI("recv_indication_cfg=%u\n", msg->recv_indication_cfg);
ALOGI("cipher_type=%u\n", msg->cipher_type);
ALOGI("key_info: key_type =%u\n", msg->key_info.key_type);
ALOGI("key_info: pmk info=%s\n", msg->key_info.body.pmk_info.pmk);
ALOGI("key_info: passphrase_info=%s\n", msg->key_info.body.passphrase_info.passphrase);
ALOGI("scid_len=%u\n", msg->scid_len);
if (msg->scid_len) {
ALOGI("scid=%s\n", msg->scid);
}
ALOGI("NanSdeaCtrlParams NdpType=%u\n", msg->sdea_params.ndp_type);
ALOGI("NanSdeaCtrlParams security_cfg=%u\n", msg->sdea_params.security_cfg);
ALOGI("NanSdeaCtrlParams ranging_state=%u\n", msg->sdea_params.ranging_state);
ALOGI("NanSdeaCtrlParams range_report=%u\n", msg->sdea_params.range_report);
ALOGI("NanRangingCfg ranging_interval_msec=%u\n", msg->ranging_cfg.ranging_interval_msec);
ALOGI("NanRangingCfg config_ranging_indications=%u\n", msg->ranging_cfg.config_ranging_indications);
ALOGI("NanRangingCfg distance_ingress_mm=%u\n", msg->ranging_cfg.distance_ingress_mm);
ALOGI("NanRangingCfg distance_egress_mm=%u\n", msg->ranging_cfg.distance_egress_mm);
ALOGI("NanRangingAutoResponse = %u\n", msg->ranging_auto_response);
ALOGI("range_response_cfg=%u\n", msg->range_response_cfg.ranging_response);
ALOGI("sdea_service_specific_info_len=%u\n", msg->sdea_service_specific_info_len);
if (msg->sdea_service_specific_info_len) {
ALOGI("sdea_service_specific_info=%s\n", msg->sdea_service_specific_info);
}
return WIFI_SUCCESS;
}
static int dump_NanSubscribeRequest(NanSubscribeRequest* msg)
{
ALOGI("%s: Dump NanSubscribeRequest msg:\n", __func__);
u8 i = 0;
if (msg == NULL) {
ALOGE("Invalid msg\n");
return WIFI_ERROR_UNKNOWN;
}
ALOGI("subscribe_id=%u\n", msg->subscribe_id);
ALOGI("ttl=%u\n", msg->ttl);
ALOGI("period=%u\n", msg->period);
ALOGI("subscribe_type=%u\n", msg->subscribe_type);
ALOGI("serviceResponseFilter=%u\n", msg->serviceResponseFilter);
ALOGI("serviceResponseInclude=%u\n", msg->serviceResponseInclude);
ALOGI("useServiceResponseFilter=%u\n", msg->useServiceResponseFilter);
ALOGI("ssiRequiredForMatchIndication=%u\n", msg->ssiRequiredForMatchIndication);
ALOGI("subscribe_count=%u\n", msg->subscribe_count);
ALOGI("subscribe_match_indicator=%u\n", msg->subscribe_match_indicator);
ALOGI("service_name_len=%u\n", msg->service_name_len);
if (msg->service_name_len)
ALOGI("service_name=%s\n", msg->service_name);
ALOGI("service_specific_info_len=%u\n", msg->service_specific_info_len);
if (msg->service_specific_info_len)
ALOGI("service_specific_info=%s\n", msg->service_specific_info);
ALOGI("rx_match_filter_len=%u\n", msg->rx_match_filter_len);
if (msg->rx_match_filter_len)
prhex("rx_match_filter", msg->rx_match_filter, msg->rx_match_filter_len);
ALOGI("tx_match_filter_len=%u\n", msg->tx_match_filter_len);
if (msg->tx_match_filter_len)
prhex("tx_match_filter", msg->tx_match_filter, msg->tx_match_filter_len);
ALOGI("rssi_threshold_flag=%u\n", msg->rssi_threshold_flag);
ALOGI("connmap=%u\n", msg->connmap);
ALOGI("num_intf_addr_present=%u\n", msg->num_intf_addr_present);
if (msg->num_intf_addr_present) {
for (i = 0; i < NAN_MAX_SUBSCRIBE_MAX_ADDRESS; i++) {
ALOGI("peer_disc_mac_addr=" MACSTR "\n", MAC2STR(msg->intf_addr[i]));
}
}
ALOGI("recv_indication_cfg=%u\n", msg->recv_indication_cfg);
ALOGI("cipher_type=%u\n", msg->cipher_type);
ALOGI("key_info: key_type =%u\n", msg->key_info.key_type);
ALOGI("key_info: pmk info=%s\n", msg->key_info.body.pmk_info.pmk);
ALOGI("key_info: passphrase_info=%s\n", msg->key_info.body.passphrase_info.passphrase);
ALOGI("scid_len=%u\n", msg->scid_len);
if (msg->scid_len) {
ALOGI("scid=%s\n", msg->scid);
}
ALOGI("NanSdeaCtrlParams NdpType=%u\n", msg->sdea_params.ndp_type);
ALOGI("NanSdeaCtrlParams security_cfg=%u\n", msg->sdea_params.security_cfg);
ALOGI("NanSdeaCtrlParams ranging_state=%u\n", msg->sdea_params.ranging_state);
ALOGI("NanSdeaCtrlParams range_report=%u\n", msg->sdea_params.range_report);
ALOGI("NanRangingCfg ranging_interval_msec=%u\n", msg->ranging_cfg.ranging_interval_msec);
ALOGI("NanRangingCfg config_ranging_indications=%u\n", msg->ranging_cfg.config_ranging_indications);
ALOGI("NanRangingCfg distance_ingress_mm=%u\n", msg->ranging_cfg.distance_ingress_mm);
ALOGI("NanRangingCfg distance_egress_mm=%u\n", msg->ranging_cfg.distance_egress_mm);
ALOGI("NanRangingAutoResponse = %u\n", msg->ranging_auto_response);
ALOGI("range_response = %u\n", msg->range_response_cfg.ranging_response);
ALOGI("sdea_service_specific_info_len=%u\n", msg->sdea_service_specific_info_len);
if (msg->sdea_service_specific_info_len)
ALOGI("sdea_service_specific_info=%s\n", msg->sdea_service_specific_info);
return WIFI_SUCCESS;
}
static int dump_NanTransmitFollowupRequest(NanTransmitFollowupRequest* msg)
{
ALOGI("%s: Dump NanTransmitFollowupRequest msg:\n", __func__);
if (msg == NULL) {
ALOGE("Invalid msg\n");
return WIFI_ERROR_UNKNOWN;
}
ALOGI("publish_subscribe_id=%u\n", msg->publish_subscribe_id);
ALOGI("requestor_instance_id=%u\n", msg->requestor_instance_id);
ALOGI("addr=" MACSTR "\n", MAC2STR(msg->addr));
ALOGI("priority=%u\n", msg->priority);
ALOGI("dw_or_faw=%u\n", msg->dw_or_faw);
ALOGI("service_specific_info_len=%u\n", msg->service_specific_info_len);
if (msg->service_specific_info_len)
ALOGI("service_specific_info=%s\n", msg->service_specific_info);
ALOGI("recv_indication_cfg=%u\n", msg->recv_indication_cfg);
ALOGI("sdea_service_specific_info_len=%u\n", msg->sdea_service_specific_info_len);
if (msg->sdea_service_specific_info_len)
ALOGI("sdea_service_specific_info=%s\n", msg->sdea_service_specific_info);
return WIFI_SUCCESS;
}
static int dump_NanDataPathInitiatorRequest(NanDataPathInitiatorRequest* msg)
{
ALOGI("%s: Dump NanDataPathInitiatorRequest msg:\n", __func__);
if (msg == NULL) {
ALOGE("Invalid msg\n");
return WIFI_ERROR_UNKNOWN;
}
ALOGI("requestor_instance_id=%d\n", msg->requestor_instance_id);
ALOGI("channel_request_type=%d\n", msg->channel_request_type);
ALOGI("channel=%u\n", msg->channel);
ALOGI("peer_disc_mac_addr=" MACSTR "\n", MAC2STR(msg->peer_disc_mac_addr));
ALOGI("ndp_iface=%s\n", msg->ndp_iface);
ALOGI("ndp_cfg: security_cfg =%u\n", msg->ndp_cfg.security_cfg);
ALOGI("ndp_cfg: qos_cfg=%u\n", msg->ndp_cfg.qos_cfg);
ALOGI("dp app info len=%u\n", msg->app_info.ndp_app_info_len);
if (msg->app_info.ndp_app_info_len) {
prhex("dp app info=: ", (u8*)msg->app_info.ndp_app_info,
msg->app_info.ndp_app_info_len);
}
ALOGI("cipher_type=%u\n", msg->cipher_type);
ALOGI("key_info: key_type =%u\n", msg->key_info.key_type);
ALOGI("key_info: pmk info=%s\n", msg->key_info.body.pmk_info.pmk);
ALOGI("key_info: passphrase_info=%s\n", msg->key_info.body.passphrase_info.passphrase);
ALOGI("scid_len=%u\n", msg->scid_len);
if (msg->scid_len) {
ALOGI("scid=%s\n", msg->scid);
}
if (msg->service_name_len) {
ALOGI("service_name=%s\n", msg->service_name);
}
return WIFI_SUCCESS;
}
static int dump_NanDataPathIndicationResponse(NanDataPathIndicationResponse* msg)
{
ALOGI("%s: Dump NanDataPathIndicationResponse msg:\n", __func__);
if (msg == NULL) {
ALOGE("Invalid msg\n");
return WIFI_ERROR_UNKNOWN;
}
ALOGI("ndp_instance_id=%d\n", msg->ndp_instance_id);
ALOGI("ndp_iface=%s\n", msg->ndp_iface);
ALOGI("ndp_cfg: security_cfg =%u\n", msg->ndp_cfg.security_cfg);
ALOGI("response code =%u\n", msg->rsp_code);
ALOGI("ndp_cfg: qos_cfg=%u\n", msg->ndp_cfg.qos_cfg);
ALOGI("dp app info len=%u\n", msg->app_info.ndp_app_info_len);
if (msg->app_info.ndp_app_info_len) {
prhex("dp app info=: ", (u8*)msg->app_info.ndp_app_info,
msg->app_info.ndp_app_info_len);
}
ALOGI("cipher_type=%u\n", msg->cipher_type);
ALOGI("key_info: key_type =%u\n", msg->key_info.key_type);
ALOGI("key_info: pmk info=%s\n", msg->key_info.body.pmk_info.pmk);
ALOGI("key_info: passphrase_info=%s\n", msg->key_info.body.passphrase_info.passphrase);
ALOGI("service_name_len=%u\n", msg->service_name_len);
ALOGI("scid_len=%u\n", msg->scid_len);
if (msg->scid_len) {
ALOGI("scid=%s\n", msg->scid);
}
if (msg->service_name_len) {
ALOGI("service_name=%s\n", msg->service_name);
}
return WIFI_SUCCESS;
}
#endif /* CONFIG_BRCM */
void nan_reset_dbg_counters()
{
memset(&counters, 0, sizeof(counters));
}
///////////////////////////////////////////////////////////////////////////////
wifi_error nan_cmn_enabe_request(transaction_id id,
NanMacControl *cmd, NanEnableRequest* msg)
{
wifi_error ret = WIFI_SUCCESS;
#ifdef CONFIG_BRCM
// check up nan enable params from Nan manager level
dump_NanEnableRequest(msg);
#endif /* CONFIG_BRCM */
nan_reset_dbg_counters();
cmd->setType(NAN_REQUEST_ENABLE);
cmd->setId(id);
cmd->setMsg((void *)msg);
ret = (wifi_error)cmd->start();
if (ret != WIFI_SUCCESS) {
ALOGE("%s : failed in start, error = %d\n", __func__, ret);
}
return ret;
}
wifi_error nan_enable_request(transaction_id id,
wifi_interface_handle iface, NanEnableRequest* msg)
{
wifi_error ret = WIFI_SUCCESS;
hal_info *h_info = getHalInfo(iface);
ALOGE("nan_enable_request: nan_state = %d\n", h_info->nan_state);
#ifdef CHRE_NAN
//check if host NAN is pre-empting CHRE NAN
if (h_info->nan_state == NAN_STATE_CHRE) {
/* notify pre-empt to chre */
if (h_info->chre_nan_cb.on_chre_nan_rtt_change != NULL) {
h_info->chre_nan_cb.on_chre_nan_rtt_change(CHRE_PREMPTED);
}
/* first disable NAN for chre */
ret = nan_chre_disable_request(1, iface);
if (ret != WIFI_SUCCESS) {
ALOGE("Failed to disable NAN for CHRE ret %d\n", ret);
return ret;
}
}
/* notify unavailable status to chre */
if (h_info->chre_nan_cb.on_chre_nan_rtt_change != NULL) {
h_info->chre_nan_cb.on_chre_nan_rtt_change(CHRE_UNAVAILABLE);
}
#endif /* CHRE_NAN */
NanMacControl *cmd = (NanMacControl*)(info.nan_mac_control);
NULL_CHECK_RETURN(cmd, "memory allocation failure", WIFI_ERROR_OUT_OF_MEMORY);
cmd->setChreNan(0);
ret = nan_cmn_enabe_request(id, cmd, msg);
if (ret == WIFI_SUCCESS) {
h_info->nan_state = NAN_STATE_AP;
}
return ret;
}
void nan_dump_dbg_counters()
{
ALOGI("Num Data Path Requests %d\n", counters.dp_req);
ALOGI("Num Data Path Responses %d\n", counters.dp_resp);
ALOGI("Num Data Path Confirms %d\n", counters.dp_confirm_evt);
ALOGI("Num Data Path Request Events %d\n", counters.dp_req_evt);
ALOGI("Num Transmit Requests %d\n", counters.transmit_req);
ALOGI("Num Followup Transmits Recvd %d\n", counters.transmit_recv);
ALOGI("Num Transmit Success %d\n", counters.transmit_txs);
}
wifi_error nan_cmn_disable_request(transaction_id id, NanMacControl *mac)
{
wifi_error ret = WIFI_SUCCESS;
nan_dump_dbg_counters();
mac->setType(NAN_REQUEST_DISABLE);
ret = (wifi_error)mac->cancel();
if (ret != WIFI_SUCCESS) {
ALOGE("cancel failed, error = %d\n", ret);
} else {
ALOGE("Deinitializing Nan Mac Control = %p\n", mac);
}
mac->releaseRef();
return ret;
}
wifi_error nan_disable_request(transaction_id id,
wifi_interface_handle iface)
{
wifi_error ret = WIFI_SUCCESS;
hal_info *h_info = getHalInfo(iface);
ALOGE("nan_disable_request: nan_state %d\n", h_info->nan_state);
if (h_info->nan_state == NAN_STATE_CHRE) {
ALOGE("nan_disable_request: Not enabled for AP.. return\n");
return ret;
}
NanMacControl *mac_prim = (NanMacControl*)(info.nan_mac_control);
NanMacControl *cmd = new NanMacControl(iface, id, NULL, NAN_REQUEST_LAST);
NULL_CHECK_RETURN(cmd, "memory allocation failure", WIFI_ERROR_OUT_OF_MEMORY);
if (id != NAN_MAC_INVALID_TRANSID) {
ALOGE("Disable NAN MAC transId= %d\n", id);
mac_prim->setId(id);
} else {
ALOGE("Invalid transId= %d cur= %d\n", id,
mac_prim ? mac_prim->getId() : -1);
}
cmd->setChreNan(0);
ret = nan_cmn_disable_request(id, cmd);
if (ret == WIFI_SUCCESS) {
h_info->nan_state = NAN_STATE_DISABLED;
/* notify pre-empt / unavailable status to chre */
if (h_info->chre_nan_cb.on_chre_nan_rtt_change != NULL) {
h_info->chre_nan_cb.on_chre_nan_rtt_change(CHRE_AVAILABLE);
}
}
return ret;
}
wifi_error nan_publish_request(transaction_id id,
wifi_interface_handle iface, NanPublishRequest* msg)
{
wifi_error ret = WIFI_SUCCESS;
wifi_handle handle = getWifiHandle(iface);
ALOGI("Publish Nan, halHandle = %p\n", handle);
#ifdef CONFIG_BRCM
dump_NanPublishRequest(msg);
#endif /* CONFIG_BRCM */
NanRequestType cmdType = NAN_REQUEST_PUBLISH;
NanDiscEnginePrimitive *cmd = new NanDiscEnginePrimitive(iface, id, (void *)msg, cmdType);
NULL_CHECK_RETURN(cmd, "memory allocation failure", WIFI_ERROR_OUT_OF_MEMORY);
ret = (wifi_error)cmd->start();
if (ret != WIFI_SUCCESS) {
ALOGE("%s : failed in start, error = %d\n", __func__, ret);
}
cmd->releaseRef();
return ret;
}
/* Function to send NAN request to the wifi driver */
wifi_error nan_publish_cancel_request(transaction_id id,
wifi_interface_handle iface, NanPublishCancelRequest* msg)
{
wifi_error ret = WIFI_SUCCESS;
NanDiscEnginePrimitive *cmd;
NanRequestType cmdType = NAN_REQUEST_PUBLISH_CANCEL;
ALOGE("Cancellling publish request %d\n", msg->publish_id);
cmd = new NanDiscEnginePrimitive(iface, id, (void *)msg, cmdType);
cmd->setInstId(msg->publish_id);
cmd->setType(cmdType);
NULL_CHECK_RETURN(cmd, "memory allocation failure", WIFI_ERROR_OUT_OF_MEMORY);
ret = (wifi_error)cmd->start();
if (ret != WIFI_SUCCESS) {
ALOGE("%s : failed in start, error = %d\n", __func__, ret);
}
cmd->releaseRef();
return ret;
}
/* Function to send NAN request to the wifi driver */
wifi_error nan_subscribe_request(transaction_id id,
wifi_interface_handle iface, NanSubscribeRequest* msg)
{
wifi_error ret = WIFI_SUCCESS;
wifi_handle handle = getWifiHandle(iface);
ALOGI("Subscribe Nan, halHandle = %p handle[%d]\n", handle, msg->subscribe_id);
NanDiscEnginePrimitive *cmd;
#ifdef CONFIG_BRCM
dump_NanSubscribeRequest(msg);
#endif /* CONFIG_BRCM */
NanRequestType cmdType = NAN_REQUEST_SUBSCRIBE;
cmd = new NanDiscEnginePrimitive(iface, id, (void *)msg, cmdType);
NULL_CHECK_RETURN(cmd, "memory allocation failure", WIFI_ERROR_OUT_OF_MEMORY);
ret = (wifi_error)cmd->start();
if (ret != WIFI_SUCCESS) {
ALOGE("%s : failed in start, error = %d\n", __func__, ret);
}
cmd->releaseRef();
return ret;
}
/* Function to send NAN request to the wifi driver.*/
wifi_error nan_subscribe_cancel_request(transaction_id id,
wifi_interface_handle iface, NanSubscribeCancelRequest* msg)
{
wifi_error ret = WIFI_SUCCESS;
NanDiscEnginePrimitive *cmd;
NanRequestType cmdType = NAN_REQUEST_SUBSCRIBE_CANCEL;
ALOGE("creating new instance + %d\n", msg->subscribe_id);
cmd = new NanDiscEnginePrimitive(iface, id, (void *)msg, cmdType);
cmd->setInstId(msg->subscribe_id);
cmd->setType(cmdType);
ret = (wifi_error)cmd->start();
if (ret != WIFI_SUCCESS) {
ALOGE("%s : failed in start, error = %d\n", __func__, ret);
}
cmd->releaseRef();
return ret;
}
/* Function to send nan transmit followup Request to the wifi driver.*/
wifi_error nan_transmit_followup_request(transaction_id id,
wifi_interface_handle iface, NanTransmitFollowupRequest* msg)
{
NanDiscEnginePrimitive *cmd = NULL;
NanRequestType cmdType = NAN_REQUEST_TRANSMIT_FOLLOWUP;
wifi_error ret = WIFI_SUCCESS;
#ifdef CONFIG_BRCM
dump_NanTransmitFollowupRequest(msg);
#endif /* CONFIG_BRCM */
counters.transmit_req++;
cmd = new NanDiscEnginePrimitive(iface, id, (void *)msg, cmdType);
NULL_CHECK_RETURN(cmd, "memory allocation failure", WIFI_ERROR_OUT_OF_MEMORY);
cmd->setTransactionId(id);
ret = (wifi_error)cmd->start();
if (ret != WIFI_SUCCESS) {
ALOGE("%s : failed in start, error = %d\n", __func__, ret);
}
cmd->releaseRef();
return ret;
}
/* Function to send NAN statistics request to the wifi driver */
wifi_error nan_stats_request(transaction_id id,
wifi_interface_handle iface, NanStatsRequest* msg)
{
wifi_handle handle = getWifiHandle(iface);
ALOGI("Nan Stats, halHandle = %p", handle);
#ifdef NOT_SUPPORTED
NanRequestType cmdType = NAN_REQUEST_STATS;
wifi_error ret = WIFI_SUCCESS;
NanCommand *cmd = new NanCommand(iface, id, (void *)msg, cmdType);
NULL_CHECK_RETURN(cmd, "memory allocation failure", WIFI_ERROR_OUT_OF_MEMORY);
ret = (wifi_error)cmd->start();
if (ret != WIFI_SUCCESS) {
ALOGE("%s : failed in start, error = %d\n", __func__, ret);
}
cmd->releaseRef();
return ret;
#else
return WIFI_ERROR_NOT_SUPPORTED;
#endif
}
/* Function to send NAN configuration request to the wifi driver */
wifi_error nan_config_request(transaction_id id,
wifi_interface_handle iface, NanConfigRequest* msg)
{
wifi_error ret = WIFI_SUCCESS;
wifi_handle handle = getWifiHandle(iface);
NanRequestType cmdType = NAN_REQUEST_CONFIG;
ALOGI("Configuring Nan, halHandle = %p\n", handle);
#ifdef CONFIG_BRCM
/* check up nan config params from Nan manager level */
dump_NanConfigRequestRequest(msg);
#endif /* CONFIG_BRCM */
NanMacControl *cmd = new NanMacControl(iface, id, (void *)msg, cmdType);
NULL_CHECK_RETURN(cmd, "memory allocation failure", WIFI_ERROR_OUT_OF_MEMORY);
cmd->setType(cmdType);
ret = (wifi_error)cmd->start();
if (ret != WIFI_SUCCESS) {
ALOGE("start failed, error = %d\n", ret);
} else {
ALOGE("Initializing Nan Mac Control = %p\n", cmd);
}
cmd->releaseRef();
return ret;
}
/* Function to send NAN request to the wifi driver */
wifi_error nan_tca_request(transaction_id id,
wifi_interface_handle iface, NanTCARequest* msg)
{
wifi_handle handle = getWifiHandle(iface);
ALOGI("Nan TCA, halHandle = %p", handle);
#ifdef NOT_SUPPORTED
NanRequestType cmdType = NAN_REQUEST_TCA;
wifi_error ret = WIFI_SUCCESS;
NanCommand *cmd = new NanCommand(iface, id, (void *)msg, cmdType);
NULL_CHECK_RETURN(cmd, "memory allocation failure", WIFI_ERROR_OUT_OF_MEMORY);
ret = (wifi_error)cmd->start();
if (ret != WIFI_SUCCESS) {
ALOGE("%s : failed in start, error = %d\n", __func__, ret);
}
cmd->releaseRef();
return ret;
#else
return WIFI_ERROR_NOT_SUPPORTED;
#endif
}
wifi_error nan_beacon_sdf_payload_request(transaction_id id,
wifi_interface_handle iface, NanBeaconSdfPayloadRequest* msg)
{
ALOGI("Nan Beacon Sdf Payload Request");
return WIFI_ERROR_NOT_SUPPORTED;
}
wifi_error nan_get_capabilities(transaction_id id, wifi_interface_handle iface)
{
wifi_error ret = WIFI_SUCCESS;
wifi_handle handle = getWifiHandle(iface);
ALOGI("Get Nan Capabilties, id=%d, halHandle=%p\n", id, handle);
NanRequestType cmdType = NAN_REQUEST_GET_CAPABILTIES;
NanDiscEnginePrimitive *cmd = new NanDiscEnginePrimitive(iface, id, NULL, cmdType);
NULL_CHECK_RETURN(cmd, "memory allocation failure", WIFI_ERROR_OUT_OF_MEMORY);
ret = (wifi_error)cmd->start();
if (ret != WIFI_SUCCESS) {
ALOGE("%s : failed in start, error = %d\n", __func__, ret);
}
cmd->releaseRef();
return ret;
}
wifi_error nan_check_dhd_hal_version(wifi_interface_handle iface,
wifi_handle handle)
{
NanRequestType cmdType = NAN_VERSION_INFO;
NanMacControl *cmd = new NanMacControl(iface, 0, NULL, cmdType);
wifi_error ret = WIFI_SUCCESS;
u32 version;
NULL_CHECK_RETURN(cmd, "memory allocation failure", WIFI_ERROR_OUT_OF_MEMORY);
cmd->setType(cmdType);
ret = (wifi_error)cmd->start();
if (ret != WIFI_SUCCESS) {
ALOGI("\nVersion subcmd failed ret = %x\n", ret);
ret = WIFI_ERROR_NOT_SUPPORTED;
goto done;
}
version = cmd->getVersion();
/* check if version handled..can support multiple versions */
if (version == NAN_HAL_VERSION_1) {
ALOGI("\nGot the supported version %d\n", version);
current_dhd_hal_ver = version;
ret = WIFI_SUCCESS;
goto done;
} else {
ALOGI("\nGot the unsupported version %d\n", version);
ret = WIFI_ERROR_NOT_SUPPORTED;
goto done;
}
done:
cmd->releaseRef();
return ret;
}
wifi_error nan_deinit_handler()
{
if (info.nan_mac_control) {
/* register for Nan vendor events with info mac class*/
NanMacControl *cmd_event = (NanMacControl*)(info.nan_mac_control);
cmd_event->unRegisterNanVendorEvents();
delete (NanMacControl*)info.nan_mac_control;
info.nan_mac_control = NULL;
}
if (info.nan_disc_control) {
delete (NanDiscEnginePrimitive*)info.nan_disc_control;
info.nan_disc_control = NULL;
}
if (info.nan_dp_control) {
delete (NanDataPathPrimitive*)info.nan_dp_control;
info.nan_dp_control = NULL;
}
if (NAN_HANDLE(info)) {
delete GET_NAN_HANDLE(info);
NAN_HANDLE(info) = NULL;
}
ALOGI("wifi nan internal clean up done");
return WIFI_SUCCESS;
}
wifi_error nan_register_handler(wifi_interface_handle iface,
NanCallbackHandler handlers)
{
wifi_handle handle = getWifiHandle(iface);
if (NAN_HANDLE(info)) {
/* cleanup and re-register */
nan_deinit_handler();
}
ALOGI("\nChecking version compat\n");
/* checking version compat b/w DHD and HAL */
if (nan_check_dhd_hal_version(iface, handle) != WIFI_SUCCESS) {
ALOGE("\n Get version failed..check DHD\n");
return WIFI_ERROR_NOT_SUPPORTED;
}
memset(&info, 0, sizeof(info));
NAN_HANDLE(info) = new NanHandle(handle, handlers);
info.nan_mac_control =
(void*)new NanMacControl(iface, 0, NULL, NAN_REQUEST_LAST);
NULL_CHECK_RETURN(info.nan_mac_control, "memory allocation failure", WIFI_ERROR_OUT_OF_MEMORY);
info.nan_disc_control =
(void*)new NanDiscEnginePrimitive(iface, 0, NULL, NAN_REQUEST_LAST);
NULL_CHECK_RETURN(info.nan_disc_control, "memory allocation failure", WIFI_ERROR_OUT_OF_MEMORY);
info.nan_dp_control =
(void*)new NanDataPathPrimitive(iface, 0, NULL, NAN_REQUEST_LAST);
NULL_CHECK_RETURN(info.nan_dp_control, "memory allocation failure", WIFI_ERROR_OUT_OF_MEMORY);
/* register for Nan vendor events with info mac class*/
NanMacControl *cmd_event = (NanMacControl*)(info.nan_mac_control);
cmd_event->registerNanVendorEvents();
return WIFI_SUCCESS;
}
wifi_error nan_get_version(wifi_handle handle, NanVersion* version)
{
wifi_error ret = WIFI_SUCCESS;
if (version) {
*version = (NAN_MAJOR_REL_VERSION << 16 | NAN_MINOR_REL_VERSION << 8 |
NAN_PATCH_REL_VERSION);
} else {
ret = WIFI_ERROR_INVALID_ARGS;
}
return ret;
}
///////////////////////////////////////////////////////////////////////////////
class NanEventCap : public WifiCommand
{
public:
NanEventCap(wifi_interface_handle iface, int id)
: WifiCommand("NanCommand", iface, id)
{}
int start()
{
registerNanVendorEvents();
return WIFI_SUCCESS;
}
int handleResponse(WifiEvent& reply) {
return NL_SKIP;
}
void unRegisterNanVendorEvents()
{
int i = 0;
for (i = NAN_EVENT_ENABLED; i <= NAN_EVENT_DATA_END; i++) {
unregisterVendorHandler(GOOGLE_OUI, i);
}
unregisterVendorHandler(GOOGLE_OUI, NAN_ASYNC_RESPONSE_DISABLED);
unregisterVendorHandler(GOOGLE_OUI, NAN_EVENT_MATCH_EXPIRY);
}
void registerNanVendorEvents()
{
int i = 0;
for (i = NAN_EVENT_ENABLED; i <= NAN_EVENT_DATA_END; i++) {
registerVendorHandler(GOOGLE_OUI, i);
}
registerVendorHandler(GOOGLE_OUI, NAN_ASYNC_RESPONSE_DISABLED);
registerVendorHandler(GOOGLE_OUI, NAN_EVENT_MATCH_EXPIRY);
}
int handleEvent(WifiEvent& event) {
int cmd = event.get_vendor_subcmd();
u16 attr_type;
nlattr *vendor_data = event.get_attribute(NL80211_ATTR_VENDOR_DATA);
switch(cmd) {
case NAN_EVENT_DE_EVENT: {
u16 attr_type;
NanDiscEngEventInd de_event;
memset(&de_event, 0, sizeof(NanDiscEngEventInd));
for (nl_iterator it(vendor_data); it.has_next(); it.next()) {
attr_type = it.get_type();
if (attr_type == NAN_ATTRIBUTE_CLUSTER_ID) {
memcpy(&de_event.data.cluster.addr, it.get_data(), NAN_MAC_ADDR_LEN);
ALOGI("cluster id = " MACSTR "\n", MAC2STR(de_event.data.cluster.addr));
} else if (attr_type == NAN_ATTRIBUTE_ENABLE_STATUS) {
ALOGI("nan enable status = %u\n", it.get_u16());
} else if (attr_type == NAN_ATTRIBUTE_JOIN_STATUS) {
ALOGI("nan joined status = %u\n", it.get_u16());
} else if (attr_type == NAN_ATTRIBUTE_DE_EVENT_TYPE) {
u8 de_type = it.get_u8();
ALOGI("nan de event type = %u\n", de_type);
if (de_type == NAN_EVENT_IFACE) {
de_event.event_type = NAN_EVENT_ID_DISC_MAC_ADDR;
ALOGI("received NAN_EVENT_ID_DISC_MAC_ADDR event\n");
} else if (de_type == NAN_EVENT_START) {
de_event.event_type = NAN_EVENT_ID_STARTED_CLUSTER;
ALOGI("received NAN cluster started event\n");
} else if (de_type == NAN_EVENT_JOIN) {
/* To be deprecated */
de_event.event_type = NAN_EVENT_ID_JOINED_CLUSTER;
ALOGI("received join event\n");
} else if (de_type == NAN_EVENT_ROLE_CHANGE) {
ALOGI("received device role change event\n");
} else if (de_type == NAN_EVENT_MERGE) {
ALOGI("received Merge Event\n");
} else {
ALOGI("received unknown DE event, [%d]\n", de_type);
}
} else if (attr_type == NAN_ATTRIBUTE_MAC_ADDR) {
memcpy(&de_event.data.cluster.addr, it.get_data(), NAN_MAC_ADDR_LEN);
memcpy(mNmi, it.get_data(), NAN_MAC_ADDR_LEN);
ALOGI("Primary discovery mac address = " MACSTR "\n",
MAC2STR(mNmi));
}
}
GET_NAN_HANDLE(info)->mHandlers.EventDiscEngEvent(&de_event);
break;
}
case NAN_EVENT_DISABLED: {
ALOGI("Received NAN_EVENT_DISABLED\n");
NanDisabledInd disabled_ind;
memset(&disabled_ind, 0, sizeof(NanDisabledInd));
for (nl_iterator it(vendor_data); it.has_next(); it.next()) {
attr_type = it.get_type();
if (attr_type == NAN_ATTRIBUTE_STATUS) {
disabled_ind.reason = (NanStatusType)it.get_u8();
ALOGI("Nan Disable:status %u", disabled_ind.reason);
} else if (attr_type == NAN_ATTRIBUTE_REASON) {
u8 len = min(it.get_len(), sizeof(disabled_ind.nan_reason) - 1);
memcpy(disabled_ind.nan_reason, it.get_data(), len);
disabled_ind.nan_reason[len] = '\0';
ALOGI("nan disabled reason: %s, len = %d\n",
disabled_ind.nan_reason, len);
}
}
GET_NAN_HANDLE(info)->mHandlers.EventDisabled(&disabled_ind);
unRegisterNanVendorEvents();
break;
}
case NAN_EVENT_PUBLISH_TERMINATED: {
ALOGI("Received NAN_EVENT_PUBLISH_TERMINATED\n");
NanPublishTerminatedInd pub_term_event;
memset(&pub_term_event, 0, sizeof(NanPublishTerminatedInd));
for (nl_iterator it(vendor_data); it.has_next(); it.next()) {
attr_type = it.get_type();
if (attr_type == NAN_ATTRIBUTE_PUBLISH_ID) {
pub_term_event.publish_id = it.get_u32();
ALOGI("pub id %u", pub_term_event.publish_id);
} else if (attr_type == NAN_ATTRIBUTE_STATUS) {
pub_term_event.reason = (NanStatusType)it.get_u8();
ALOGI("pub termination status %u", pub_term_event.reason);
} else if (attr_type == NAN_ATTRIBUTE_REASON) {
u8 len = min(it.get_len(), sizeof(pub_term_event.nan_reason) - 1);
memcpy(pub_term_event.nan_reason, it.get_data(), len);
pub_term_event.nan_reason[len] = '\0';
ALOGI("Pub termination nan reason: %s, len = %d\n",
pub_term_event.nan_reason, len);
} else {
ALOGE("Unknown attr\n");
}
}
GET_NAN_HANDLE(info)->mHandlers.EventPublishTerminated(&pub_term_event);
break;
}
case NAN_EVENT_SUBSCRIBE_MATCH: {
NanMatchInd subscribe_event;
memset(&subscribe_event, 0, sizeof(NanMatchInd));
ALOGI("Received NAN_EVENT_SUBSCRIBE_MATCH\n");
/* By default FW is unable to cache this match */
subscribe_event.out_of_resource_flag = true;
for (nl_iterator it(vendor_data); it.has_next(); it.next()) {
attr_type = it.get_type();
if (attr_type == NAN_ATTRIBUTE_SUBSCRIBE_ID) {
ALOGI("sub id: %u", it.get_u16());
subscribe_event.publish_subscribe_id = it.get_u16();
} else if (attr_type == NAN_ATTRIBUTE_PUBLISH_ID) {
ALOGI("pub id %u", it.get_u32());
subscribe_event.requestor_instance_id = it.get_u32();
} else if (attr_type == NAN_ATTRIBUTE_MAC_ADDR) {
memcpy(subscribe_event.addr, it.get_data(), NAN_MAC_ADDR_LEN);
ALOGI("publisher mac: " MACSTR, MAC2STR(subscribe_event.addr));
} else if (attr_type == NAN_ATTRIBUTE_SERVICE_SPECIFIC_INFO_LEN) {
ALOGI("svc length: %d", it.get_u16());
subscribe_event.service_specific_info_len = it.get_u16();
} else if (attr_type == NAN_ATTRIBUTE_SERVICE_SPECIFIC_INFO) {
memcpy(subscribe_event.service_specific_info, it.get_data(),
subscribe_event.service_specific_info_len);
subscribe_event.service_specific_info
[subscribe_event.service_specific_info_len] = '\0';
ALOGI("service info: %s", subscribe_event.service_specific_info);
} else if (attr_type == NAN_ATTRIBUTE_TX_MATCH_FILTER_LEN) {
ALOGI("sdf match filter length: %d", subscribe_event.sdf_match_filter_len);
subscribe_event.sdf_match_filter_len = it.get_u16();
} else if (attr_type == NAN_ATTRIBUTE_TX_MATCH_FILTER) {
memcpy(subscribe_event.sdf_match_filter, it.get_data(),
subscribe_event.sdf_match_filter_len);
subscribe_event.sdf_match_filter
[subscribe_event.sdf_match_filter_len] = '\0';
ALOGI("sdf match filter: %s", subscribe_event.sdf_match_filter);
} else if (attr_type == NAN_ATTRIBUTE_CIPHER_SUITE_TYPE) {
ALOGI("Peer Cipher suite type: %u", it.get_u8());
subscribe_event.peer_cipher_type = it.get_u8();
} else if (attr_type == NAN_ATTRIBUTE_SCID_LEN) {
ALOGI("scid length %d", it.get_u32());
subscribe_event.scid_len= it.get_u32();
} else if (attr_type == NAN_ATTRIBUTE_SCID) {
memcpy(subscribe_event.scid, it.get_data(),
subscribe_event.scid_len);
subscribe_event.scid
[subscribe_event.scid_len] = '\0';
ALOGI("scid: %s", subscribe_event.scid);
} else if (attr_type == NAN_ATTRIBUTE_RANGING_INDICATION) {
subscribe_event.range_info.ranging_event_type = it.get_u32();
ALOGI("ranging indication %d", it.get_u32());
} else if (attr_type == NAN_ATTRIBUTE_RANGING_RESULT) {
subscribe_event.range_info.range_measurement_mm = it.get_u32();
ALOGI("ranging result %d", it.get_u32());
} else if (attr_type == NAN_ATTRIBUTE_RSSI_PROXIMITY) {
subscribe_event.rssi_value = it.get_u8();
ALOGI("rssi value : %u", it.get_u8());
} else if (attr_type == NAN_ATTRIBUTE_SDEA_SERVICE_SPECIFIC_INFO_LEN) {
ALOGI("sdea svc length %d", it.get_u16());
subscribe_event.sdea_service_specific_info_len = it.get_u16();
} else if (attr_type == NAN_ATTRIBUTE_SDEA_SERVICE_SPECIFIC_INFO) {
memcpy(subscribe_event.sdea_service_specific_info, it.get_data(),
subscribe_event.sdea_service_specific_info_len);
subscribe_event.sdea_service_specific_info
[subscribe_event.sdea_service_specific_info_len] = '\0';
ALOGI("sdea service info: %s", subscribe_event.sdea_service_specific_info);
} else if (attr_type == NAN_ATTRIBUTE_MATCH_OCCURRED_FLAG) {
ALOGI("match occurred flag: %u", it.get_u8());
subscribe_event.match_occured_flag = it.get_u8();
} else if (attr_type == NAN_ATTRIBUTE_OUT_OF_RESOURCE_FLAG) {
ALOGI("Out of resource flag: %u", it.get_u8());
subscribe_event.out_of_resource_flag = it.get_u8();
} else if (attr_type == NAN_ATTRIBUTE_SDE_CONTROL_CONFIG_DP) {
ALOGI("Peer config for data path needed: %u", it.get_u8());
subscribe_event.peer_sdea_params.config_nan_data_path = it.get_u8();
} else if (attr_type == NAN_ATTRIBUTE_SDE_CONTROL_DP_TYPE) {
ALOGI("Data Path type: %u", it.get_u8());
subscribe_event.peer_sdea_params.ndp_type = (NdpType)it.get_u8();
} else if (attr_type == NAN_ATTRIBUTE_SDE_CONTROL_SECURITY) {
ALOGI("Security configuration: %u", it.get_u8());
subscribe_event.peer_sdea_params.security_cfg =
(NanDataPathSecurityCfgStatus)it.get_u8();
} else if (attr_type == NAN_ATTRIBUTE_SDE_CONTROL_RANGE_SUPPORT) {
ALOGI("Ranging report state: %u", it.get_u8());
subscribe_event.peer_sdea_params.range_report = (NanRangeReport)it.get_u8();
}
}
GET_NAN_HANDLE(info)->mHandlers.EventMatch(&subscribe_event);
break;
}
case NAN_EVENT_SUBSCRIBE_UNMATCH: {
ALOGI("Received NAN_EVENT_SUBSCRIBE_UNMATCH\n");
ALOGE("%s: Not applicable yet\n", __func__);
break;
}
case NAN_EVENT_SUBSCRIBE_TERMINATED: {
NanSubscribeTerminatedInd sub_term_event;
memset(&sub_term_event, 0, sizeof(NanSubscribeTerminatedInd));
ALOGI("Received NAN_EVENT_SUBSCRIBE_TERMINATED\n");
for (nl_iterator it(vendor_data); it.has_next(); it.next()) {
attr_type = it.get_type();
if (attr_type == NAN_ATTRIBUTE_SUBSCRIBE_ID) {
sub_term_event.subscribe_id = it.get_u16();
ALOGI("sub id: %u", sub_term_event.subscribe_id);
} else if (attr_type == NAN_ATTRIBUTE_STATUS) {
sub_term_event.reason = (NanStatusType)it.get_u8();
ALOGI("sub termination status %u", sub_term_event.reason);
} else if (attr_type == NAN_ATTRIBUTE_REASON) {
u8 len = min(it.get_len(), sizeof(sub_term_event.nan_reason) - 1);
memcpy(sub_term_event.nan_reason, it.get_data(), len);
sub_term_event.nan_reason[len] = '\0';
ALOGI("sub termination nan reason: %s, len = %d\n",
sub_term_event.nan_reason, len);
} else {
ALOGE("Unknown attr: %u\n", attr_type);
}
}
GET_NAN_HANDLE(info)->mHandlers.EventSubscribeTerminated(&sub_term_event);
break;
}
case NAN_EVENT_MATCH_EXPIRY:
HandleExpiryEvent(info, vendor_data);
break;
case NAN_EVENT_FOLLOWUP: {
NanFollowupInd followup_event;
memset(&followup_event, 0, sizeof(NanFollowupInd));
ALOGI("Received NAN_EVENT_FOLLOWUP\n");
for (nl_iterator it(vendor_data); it.has_next(); it.next()) {
attr_type = it.get_type();
if (attr_type == NAN_ATTRIBUTE_MAC_ADDR) {
memcpy(followup_event.addr, it.get_data(), NAN_MAC_ADDR_LEN);
} else if (attr_type == NAN_ATTRIBUTE_PEER_ID) {
followup_event.publish_subscribe_id = it.get_u16();
} else if (attr_type == NAN_ATTRIBUTE_INST_ID) {
followup_event.requestor_instance_id = it.get_u32();
} else if (attr_type == NAN_ATTRIBUTE_SERVICE_SPECIFIC_INFO_LEN) {
followup_event.service_specific_info_len = it.get_u16();
} else if (attr_type == NAN_ATTRIBUTE_SERVICE_SPECIFIC_INFO) {
memcpy(followup_event.service_specific_info, it.get_data(),
followup_event.service_specific_info_len);
followup_event.service_specific_info[followup_event.service_specific_info_len] =
'\0';
} else if (attr_type == NAN_ATTRIBUTE_SDEA_SERVICE_SPECIFIC_INFO_LEN) {
ALOGI("sdea svc length %d", it.get_u16());
followup_event.sdea_service_specific_info_len = it.get_u16();
} else if (attr_type == NAN_ATTRIBUTE_SDEA_SERVICE_SPECIFIC_INFO) {
memcpy(followup_event.sdea_service_specific_info, it.get_data(),
followup_event.sdea_service_specific_info_len);
followup_event.sdea_service_specific_info[followup_event.sdea_service_specific_info_len] = '\0';
ALOGI("sdea service info: %s", followup_event.sdea_service_specific_info);
}
}
GET_NAN_HANDLE(info)->mHandlers.EventFollowup(&followup_event);
break;
}
case NAN_EVENT_SDF: {
ALOGI("Received NAN_EVENT_SDF:\n");
NanBeaconSdfPayloadInd sdfInd;
memset(&sdfInd, 0, sizeof(sdfInd));
for (nl_iterator it(vendor_data); it.has_next(); it.next()) {
attr_type = it.get_type();
if (attr_type == NAN_ATTRIBUTE_SERVICE_SPECIFIC_INFO_LEN) {
sdfInd.data.frame_len = it.get_u16();
if (sdfInd.data.frame_len > NAN_MAX_FRAME_DATA_LEN) {
sdfInd.data.frame_len = NAN_MAX_FRAME_DATA_LEN;
}
ALOGI("Received NAN_ATTRIBUTE_SERVICE_SPECIFIC_INFO_LEN: 0x%x(%d)\n",
sdfInd.data.frame_len, sdfInd.data.frame_len);
} else if (attr_type == NAN_ATTRIBUTE_SERVICE_SPECIFIC_INFO) {
ALOGI("Received NAN_ATTRIBUTE_SERVICE_SPECIFIC_INFO\n");
memcpy(&sdfInd.data.frame_data, it.get_data(), sdfInd.data.frame_len);
prhex("sdfInd.data.frame_data: ", (u8*)sdfInd.data.frame_data,
sdfInd.data.frame_len);
}
}
GET_NAN_HANDLE(info)->mHandlers.EventBeaconSdfPayload(&sdfInd);
break;
}
#ifdef NOT_YET
case NAN_EVENT_PUBLISH_REPLIED_IND: {
ALOGI("Received NAN_EVENT_PUBLISH_REPLIED_IND\n");
NanPublishRepliedInd pub_reply_event;
memset(&pub_reply_event, 0, sizeof(pub_reply_event));
for (nl_iterator it(vendor_data); it.has_next(); it.next()) {
attr_type = it.get_type();
if (attr_type == NAN_ATTRIBUTE_SUBSCRIBE_ID) {
ALOGI("sub id: %u", it.get_u32());
pub_reply_event.requestor_instance_id = it.get_u32();
} else if (attr_type == NAN_ATTRIBUTE_MAC_ADDR) {
memcpy(pub_reply_event.addr, it.get_data(), NAN_MAC_ADDR_LEN);
ALOGI("Subscriber mac: " MACSTR, MAC2STR(pub_reply_event.addr));
} else if (attr_type == NAN_ATTRIBUTE_RSSI_PROXIMITY) {
pub_reply_event.rssi_value = it.get_u8();
ALOGI("Received rssi value : %u", it.get_u8());
}
}
GET_NAN_HANDLE(info)->mHandlers.EventPublishReplied(&pub_reply_event);
break;
}
#endif /* NOT_YET */
case NAN_EVENT_TCA: {
ALOGI("Received NAN_EVENT_TCA\n");
//GET_NAN_HANDLE(info)->mHandlers.EventTca(&sdfPayload);
break;
}
case NAN_EVENT_DATA_REQUEST: {
ALOGI("Received NAN_EVENT_DATA_REQUEST_INDICATION\n");
NanDataPathRequestInd ndp_request_event;
memset(&ndp_request_event, 0, sizeof(NanDataPathRequestInd));
u16 ndp_ind_app_info_len = 0;
for (nl_iterator it(vendor_data); it.has_next(); it.next()) {
attr_type = it.get_type();
if (attr_type == NAN_ATTRIBUTE_PUBLISH_ID) {
ALOGI("publish_id: %u\n", it.get_u32());
ndp_request_event.service_instance_id = it.get_u32();
} else if (attr_type == NAN_ATTRIBUTE_MAC_ADDR) {
memcpy(ndp_request_event.peer_disc_mac_addr,
it.get_data(), NAN_MAC_ADDR_LEN);
ALOGI("Discovery MAC addr of the peer/initiator: " MACSTR "\n",
MAC2STR(ndp_request_event.peer_disc_mac_addr));
} else if (attr_type == NAN_ATTRIBUTE_NDP_ID) {
ALOGI("ndp id: %u\n", it.get_u32());
ndp_request_event.ndp_instance_id = it.get_u32();
} else if (attr_type == NAN_ATTRIBUTE_SECURITY) {
ALOGI("security: %u\n", (NanDataPathSecurityCfgStatus) it.get_u8());
ndp_request_event.ndp_cfg.security_cfg =
(NanDataPathSecurityCfgStatus)it.get_u8();
} else if (attr_type == NAN_ATTRIBUTE_QOS) {
ALOGI("QoS: %u", (NanDataPathQosCfg)it.get_u8());
ndp_request_event.ndp_cfg.qos_cfg = (NanDataPathQosCfg)it.get_u8();
} else if (attr_type == NAN_ATTRIBUTE_SERVICE_SPECIFIC_INFO_LEN) {
ALOGI("service info len: %d\n", it.get_u16());
ndp_ind_app_info_len = it.get_u16();
ndp_request_event.app_info.ndp_app_info_len = ndp_ind_app_info_len;
} else if (attr_type == NAN_ATTRIBUTE_SERVICE_SPECIFIC_INFO) {
memcpy(ndp_request_event.app_info.ndp_app_info,
it.get_data(), ndp_ind_app_info_len);
ndp_request_event.app_info.ndp_app_info[ndp_ind_app_info_len] = '\0';
ALOGI("service info: %s\n", ndp_request_event.app_info.ndp_app_info);
} else if (attr_type == NAN_ATTRIBUTE_SCID_LEN) {
ALOGI("scid length %d\n", it.get_u32());
ndp_request_event.scid_len= it.get_u32();
} else if (attr_type == NAN_ATTRIBUTE_SCID) {
memcpy(ndp_request_event.scid, it.get_data(),
ndp_request_event.scid_len);
ndp_request_event.scid[ndp_request_event.scid_len] = '\0';
ALOGI("scid: %s\n", ndp_request_event.scid);
}
}
GET_NAN_HANDLE(info)->mHandlers.EventDataRequest(&ndp_request_event);
break;
}
case NAN_EVENT_DATA_CONFIRMATION: {
ALOGI("Received NAN_EVENT_DATA_CONFIRMATION\n");
NanDataPathConfirmInd ndp_create_confirmation_event;
memset(&ndp_create_confirmation_event, 0, sizeof(NanDataPathConfirmInd));
u16 ndp_conf_app_info_len = 0;
for (nl_iterator it(vendor_data); it.has_next(); it.next()) {
attr_type = it.get_type();
if (attr_type == NAN_ATTRIBUTE_NDP_ID) {
ALOGI("ndp id: %u", it.get_u32());
ndp_create_confirmation_event.ndp_instance_id = it.get_u32();
} else if (attr_type == NAN_ATTRIBUTE_PEER_NDI_MAC_ADDR) {
memcpy(ndp_create_confirmation_event.peer_ndi_mac_addr,
it.get_data(), NAN_MAC_ADDR_LEN);
ALOGI("NDI mac address of the peer: " MACSTR "\n",
MAC2STR(ndp_create_confirmation_event.peer_ndi_mac_addr));
} else if (attr_type == NAN_ATTRIBUTE_SERVICE_SPECIFIC_INFO_LEN) {
ALOGI("service info string len: %d\n", it.get_u16());
ndp_conf_app_info_len = it.get_u16();
ndp_create_confirmation_event.app_info.ndp_app_info_len =
ndp_conf_app_info_len;
} else if (attr_type == NAN_ATTRIBUTE_SERVICE_SPECIFIC_INFO) {
memcpy(ndp_create_confirmation_event.app_info.ndp_app_info, it.get_data(),
ndp_conf_app_info_len);
ndp_create_confirmation_event.app_info.ndp_app_info[ndp_conf_app_info_len] =
'\0';
ALOGI("service info string: %s\n",
ndp_create_confirmation_event.app_info.ndp_app_info);
} else if (attr_type == NAN_ATTRIBUTE_RSP_CODE) {
ALOGI("response code %u\n", (NanDataPathResponseCode) it.get_u8());
ndp_create_confirmation_event.rsp_code =
(NanDataPathResponseCode)it.get_u8();
}
}
GET_NAN_HANDLE(info)->mHandlers.EventDataConfirm(&ndp_create_confirmation_event);
break;
}
case NAN_EVENT_DATA_END: {
ALOGI("Received NAN_EVENT_DATA_END\n");
NanDataPathEndInd ndp_end_event;
memset(&ndp_end_event, 0, sizeof(NanDataPathEndInd));
u8 count = 0;
for (nl_iterator it(vendor_data); it.has_next(); it.next()) {
attr_type = it.get_type();
if (attr_type == NAN_ATTRIBUTE_INST_COUNT) {
ALOGI("ndp count: %u\n", it.get_u8());
ndp_end_event.num_ndp_instances = it.get_u8();
count = it.get_u8();
} else if (attr_type == NAN_ATTRIBUTE_NDP_ID) {
ALOGI("count: %u\n", count);
while (count) {
ndp_end_event.ndp_instance_id[count-1] = it.get_u32();
ALOGI("ndp id: %u\n", ndp_end_event.ndp_instance_id[count-1]);
count -= 1;
}
} else {
ALOGI("Unknown attr_type: %s\n", NanAttrToString(attr_type));
}
}
GET_NAN_HANDLE(info)->mHandlers.EventDataEnd(&ndp_end_event);
break;
}
case NAN_EVENT_TRANSMIT_FOLLOWUP_IND: {
ALOGI("Received NAN_EVENT_TRANSMIT_FOLLOWUP_IND\n");
NanTransmitFollowupInd followup_ind;
memset(&followup_ind, 0, sizeof(NanTransmitFollowupInd));
for (nl_iterator it(vendor_data); it.has_next(); it.next()) {
attr_type = it.get_type();
if (attr_type == NAN_ATTRIBUTE_TRANSAC_ID) {
followup_ind.id = it.get_u16();
} else if (attr_type == NAN_ATTRIBUTE_STATUS) {
followup_ind.reason = (NanStatusType)it.get_u8();
} else if (attr_type == NAN_ATTRIBUTE_REASON) {
u8 len = min(it.get_len(), sizeof(followup_ind.nan_reason) - 1);
memcpy(followup_ind.nan_reason, it.get_data(), len);
followup_ind.nan_reason[len] = '\0';
ALOGI("nan transmit followup ind: reason: %s, len = %d\n",
followup_ind.nan_reason, len);
}
}
GET_NAN_HANDLE(info)->mHandlers.EventTransmitFollowup(&followup_ind);
break;
}
case NAN_EVENT_UNKNOWN:
ALOGI("Received NAN_EVENT_UNKNOWN\n");
break;
} // end-of-switch
return NL_SKIP;
}
};
/* To see event prints in console */
wifi_error nan_event_check_request(transaction_id id, wifi_interface_handle iface)
{
NanEventCap *cmd = new NanEventCap(iface, id);
if (cmd == NULL) {
return WIFI_ERROR_NOT_SUPPORTED;
}
return (wifi_error)cmd->start();
}
/* Create NAN Data Interface */
wifi_error nan_data_interface_create(transaction_id id,
wifi_interface_handle iface, char* iface_name)
{
wifi_error ret = WIFI_SUCCESS;
NAN_DBG_ENTER();
NanRequestType cmdType = NAN_DATA_PATH_IFACE_CREATE;
NanDataPathPrimitive *cmd =
new NanDataPathPrimitive(iface, id, (void *)iface_name, cmdType);
NULL_CHECK_RETURN(cmd, "memory allocation failure", WIFI_ERROR_OUT_OF_MEMORY);
ret = (wifi_error)cmd->open();
if (ret != WIFI_SUCCESS) {
ALOGE("%s : failed in open, error = %d\n", __func__, ret);
}
cmd->releaseRef();
NAN_DBG_EXIT();
return ret;
}
/* Delete NAN Data Interface */
wifi_error nan_data_interface_delete(transaction_id id,
wifi_interface_handle iface, char* iface_name)
{
wifi_error ret = WIFI_SUCCESS;
NAN_DBG_ENTER();
NanRequestType cmdType = NAN_DATA_PATH_IFACE_DELETE;
NanDataPathPrimitive *cmd =
new NanDataPathPrimitive(iface, id, (void *)iface_name, cmdType);
NULL_CHECK_RETURN(cmd, "memory allocation failure", WIFI_ERROR_OUT_OF_MEMORY);
ret = (wifi_error)cmd->open();
if (ret != WIFI_SUCCESS) {
ALOGE("%s : failed in open, error = %d\n", __func__, ret);
}
cmd->releaseRef();
NAN_DBG_EXIT();
return ret;
}
/* Initiate a NDP session: Initiator */
wifi_error nan_data_request_initiator(transaction_id id,
wifi_interface_handle iface, NanDataPathInitiatorRequest* msg)
{
wifi_error ret = WIFI_SUCCESS;
NAN_DBG_ENTER();
NanRequestType cmdType;
NanDataPathPrimitive *cmd = NULL;
#ifdef CONFIG_BRCM
dump_NanDataPathInitiatorRequest(msg);
#endif /* CONFIG_BRCM */
counters.dp_req++;
if (msg->service_name_len) {
u16 len = min(msg->service_name_len, sizeof(msg->service_name) - 1);
msg->service_name[len] = '\0';
if (strncmp(NAN_OOB_INTEROP_SVC_NAME,
(char*)msg->service_name, msg->service_name_len) == 0) {
ALOGI("Use Hardcoded svc_hash\n");
msg->service_name_len = NAN_SVC_HASH_SIZE;
memcpy(msg->service_name, NAN_OOB_INTEROP_SVC_HASH, NAN_SVC_HASH_SIZE);
} else {
u8 svc_hash[NAN_SVC_HASH_SIZE];
ret = (wifi_error)get_svc_hash(msg->service_name, msg->service_name_len,
svc_hash, NAN_SVC_HASH_SIZE);
if (ret < 0) {
ALOGE("%s: Failed to get hashed svc name\n", __func__);
goto done;
}
ALOGI("Created svc_hash\n");
msg->service_name_len = NAN_SVC_HASH_SIZE;
memcpy(msg->service_name, svc_hash, msg->service_name_len);
}
} else if (msg->key_info.key_type == NAN_SECURITY_KEY_INPUT_PASSPHRASE) {
NanDataPathSecInfoRequest msg_sec_info;
if (msg->requestor_instance_id == 0) {
ALOGE("Invalid Pub ID = %d, Mandatory param is missing\n", msg->requestor_instance_id);
ret = WIFI_ERROR_INVALID_ARGS;
goto done;
} else {
ALOGI("Pub ID = %d, Mandatory param is present\n", msg->requestor_instance_id);
}
if (ETHER_ISNULLADDR(msg->peer_disc_mac_addr)) {
ALOGE("Invalid Pub NMI, Mandatory param is missing\n");
ret = WIFI_ERROR_INVALID_ARGS;
goto done;
}
msg_sec_info.requestor_instance_id = msg->requestor_instance_id;
memcpy(msg_sec_info.peer_disc_mac_addr, msg->peer_disc_mac_addr, NAN_MAC_ADDR_LEN);
msg_sec_info.ndp_instance_id = 0;
cmdType = NAN_DATA_PATH_SEC_INFO;
cmd = new NanDataPathPrimitive(iface, id, (void *)&msg_sec_info, cmdType);
NULL_CHECK_RETURN(cmd, "memory allocation failure", WIFI_ERROR_OUT_OF_MEMORY);
ret = (wifi_error)cmd->open();
if (ret != WIFI_SUCCESS) {
ALOGE("%s : failed in start, error = %d\n", __func__, ret);
goto done;
}
memcpy(msg->service_name, cmd->mSvcHash, NAN_SVC_HASH_SIZE);
}
/* free old command */
if (cmd) {
cmd->releaseRef();
}
cmdType = NAN_DATA_PATH_INIT_REQUEST;
cmd = new NanDataPathPrimitive(iface, id, (void *)msg, cmdType);
NULL_CHECK_RETURN(cmd, "memory allocation failure", WIFI_ERROR_OUT_OF_MEMORY);
ret = (wifi_error)cmd->open();
if (ret != WIFI_SUCCESS) {
ALOGE("%s : failed in open, error = %d\n", __func__, ret);
goto done;
}
done:
if (cmd) {
cmd->releaseRef();
}
NAN_DBG_EXIT();
return ret;
}
/* Response to a data indication received corresponding to a NDP session.
* An indication is received with a data request and the responder will send a data response
*/
wifi_error nan_data_indication_response(transaction_id id,
wifi_interface_handle iface, NanDataPathIndicationResponse* msg)
{
wifi_error ret = WIFI_SUCCESS;
NAN_DBG_ENTER();
NanRequestType cmdType;
u8 pub_nmi[NAN_MAC_ADDR_LEN] = {0};
NanDataPathPrimitive *cmd = NULL;
#ifdef CONFIG_BRCM
dump_NanDataPathIndicationResponse(msg);
#endif /* CONFIG_BRCM */
counters.dp_resp++;
if (msg->service_name_len) {
u16 len = min(msg->service_name_len, sizeof(msg->service_name) - 1);
msg->service_name[len] = '\0';
if (strncmp(NAN_OOB_INTEROP_SVC_NAME,
(char*)msg->service_name, msg->service_name_len) == 0) {
ALOGI("Use Hardcoded svc_hash\n");
msg->service_name_len = NAN_SVC_HASH_SIZE;
memcpy(msg->service_name, NAN_OOB_INTEROP_SVC_HASH, NAN_SVC_HASH_SIZE);
} else {
u8 svc_hash[NAN_SVC_HASH_SIZE];
ret = (wifi_error)get_svc_hash(msg->service_name, msg->service_name_len,
svc_hash, NAN_SVC_HASH_SIZE);
if (ret < 0) {
ALOGE("%s: Failed to get hashed svc name\n", __func__);
goto done;
}
ALOGI("Created svc_hash\n");
msg->service_name_len = NAN_SVC_HASH_SIZE;
memcpy(msg->service_name, svc_hash, msg->service_name_len);
}
}
if (msg->key_info.key_type == NAN_SECURITY_KEY_INPUT_PASSPHRASE) {
NanDataPathSecInfoRequest msg_sec_info;
if (msg->ndp_instance_id == 0) {
ALOGE("Invalid NDP ID, Mandatory info is not present\n");
ret = WIFI_ERROR_INVALID_ARGS;
goto done;
} else {
ALOGI("NDP ID = %d, Mandatory info is present\n", msg->ndp_instance_id);
}
msg_sec_info.ndp_instance_id = msg->ndp_instance_id;
msg_sec_info.requestor_instance_id = 0;
cmdType = NAN_DATA_PATH_SEC_INFO;
cmd = new NanDataPathPrimitive(iface, id, (void *)&msg_sec_info, cmdType);
NULL_CHECK_RETURN(cmd, "memory allocation failure", WIFI_ERROR_OUT_OF_MEMORY);
ret = (wifi_error)cmd->open();
if (ret != WIFI_SUCCESS) {
ALOGE("%s : failed in start, error = %d\n", __func__, ret);
goto done;
}
if (ETHER_ISNULLADDR(cmd->mPubNmi)) {
ALOGE("Invalid Pub NMI\n");
ret = WIFI_ERROR_INVALID_ARGS;
goto done;
}
memcpy(pub_nmi, cmd->mPubNmi, NAN_MAC_ADDR_LEN);
if (!msg->service_name_len) {
if (SVCHASH_ISNULL(cmd->mSvcHash)) {
ALOGE("Invalid svc_hash\n");
ret = WIFI_ERROR_INVALID_ARGS;
goto done;
}
memcpy(msg->service_name, cmd->mSvcHash, NAN_SVC_HASH_SIZE);
}
}
/* free old command */
if (cmd) {
cmd->releaseRef();
}
cmdType = NAN_DATA_PATH_IND_RESPONSE;
cmd = new NanDataPathPrimitive(iface, id, (void *)msg, cmdType);
NULL_CHECK_RETURN(cmd, "memory allocation failure", WIFI_ERROR_OUT_OF_MEMORY);
memcpy(cmd->mPubNmi, pub_nmi, NAN_MAC_ADDR_LEN);
ret = (wifi_error)cmd->open();
if (ret != WIFI_SUCCESS) {
ALOGE("%s : failed in open, error = %d\n", __func__, ret);
goto done;
}
done:
if (cmd) {
cmd->releaseRef();
}
NAN_DBG_EXIT();
return ret;
}
/* NDL termination request: from either Initiator/Responder */
wifi_error nan_data_end(transaction_id id,
wifi_interface_handle iface, NanDataPathEndRequest* msg)
{
wifi_error ret = WIFI_SUCCESS;
NanDataPathPrimitive *cmd;
NanRequestType cmdType = NAN_DATA_PATH_END;
NAN_DBG_ENTER();
cmd = new NanDataPathPrimitive(iface, id, (void *)msg, cmdType);
NULL_CHECK_RETURN(cmd, "memory allocation failure", WIFI_ERROR_OUT_OF_MEMORY);
ret = (wifi_error)cmd->open();
if (ret != WIFI_SUCCESS) {
ALOGE("%s : failed in open, error = %d\n", __func__, ret);
}
cmd->releaseRef();
NAN_DBG_EXIT();
return ret;
}
wifi_error nan_chre_enable_request(transaction_id id,
wifi_interface_handle iface, NanEnableRequest* msg)
{
wifi_error ret = WIFI_SUCCESS;
NanEnableRequest def_msg;
hal_info *h_info = getHalInfo(iface);
ALOGI("nan_chre_enable_request: nan_state %d\n", h_info->nan_state);
if (h_info->nan_state == NAN_STATE_CHRE) {
return WIFI_SUCCESS;
} else if (h_info->nan_state == NAN_STATE_AP) {
ALOGE("nan_chre_enable_request: Nan is enabled for AP. Fail CHRE request\n");
return WIFI_ERROR_BUSY;
}
NanMacControl *mac = new NanMacControl(iface, 0, NULL, NAN_REQUEST_LAST);
NULL_CHECK_RETURN(mac, "memory allocation failure", WIFI_ERROR_OUT_OF_MEMORY);
mac->setChreNan(1);
if (msg == NULL) {
/* default enable params */
ALOGI("Input Enable config is NULL, use default config\n");
memset(&def_msg, 0, sizeof(def_msg));
def_msg.hop_count_limit_val = 5;
def_msg.config_2dot4g_support = 1;
def_msg.support_2dot4g_val = 1;
def_msg.config_2dot4g_beacons = 1;
def_msg.beacon_2dot4g_val = 1;
def_msg.config_2dot4g_sdf = 1;
def_msg.sdf_2dot4g_val = 1;
def_msg.config_disc_mac_addr_randomization = true;
def_msg.disc_mac_addr_rand_interval_sec = 0;
def_msg.config_ndpe_attr = false;
ret = nan_cmn_enabe_request(id, mac, &def_msg);
} else {
ret = nan_cmn_enabe_request(id, mac, msg);
}
if (ret == WIFI_SUCCESS) {
h_info->nan_state = NAN_STATE_CHRE;
}
return ret;
}
wifi_error nan_chre_disable_request(transaction_id id,
wifi_interface_handle iface)
{
wifi_error ret = WIFI_SUCCESS;
hal_info *h_info = getHalInfo(iface);
ALOGI("nan_chre_disable_request: nan_state %d\n", h_info->nan_state);
if (h_info->nan_state == NAN_STATE_AP) {
ALOGE("nan_chre_disable_request: Not enabled for CHRE.. return\n");
return ret;
}
NanMacControl *cmd = new NanMacControl(iface, id, NULL, NAN_REQUEST_LAST);
NULL_CHECK_RETURN(cmd, "memory allocation failure", WIFI_ERROR_OUT_OF_MEMORY);
cmd->setChreNan(1);
ret = nan_cmn_disable_request(id, cmd);
if (ret == WIFI_SUCCESS) {
h_info->nan_state = NAN_STATE_DISABLED;
}
return ret;
}
wifi_error nan_chre_register_handler(wifi_interface_handle iface,
wifi_chre_handler handler)
{
wifi_error ret = WIFI_SUCCESS;
hal_info *h_info = getHalInfo(iface);
if (h_info) {
ALOGE("Registering CHRE handler for Nan Status %p\n", handler.on_chre_nan_rtt_change);
h_info->chre_nan_cb = handler;
}
return ret;
}
Reference in New Issue View Git Blame Copy Permalink