roam.cpp

   1 #include <stdint.h>
   2 #include <stddef.h>
   3 #include <fcntl.h>
   4 #include <sys/socket.h>
   5 #include <netlink/genl/genl.h>
   6 #include <netlink/genl/family.h>
   7 #include <netlink/genl/ctrl.h>
   8 #include <linux/rtnetlink.h>
   9 #include <netpacket/packet.h>
  10 #include <linux/filter.h>
  11 #include <linux/errqueue.h>
  12
  13 #include <linux/pkt_sched.h>
  14 #include <netlink/object-api.h>
  15 #include <netlink/netlink.h>
  16 #include <netlink/socket.h>
  17 #include <netlink/handlers.h>
  18
  19 #include "sync.h"
  20
  21 #define LOG_TAG  "WifiHAL"
  22
  23 #include <utils/Log.h>
  24
  25 #include "wifi_hal.h"
  26 #include "common.h"
  27 #include "cpp_bindings.h"
  28
  29 #define REQUEST_ID_MAX 1000
  30 #define get_requestid() ((arc4random()%REQUEST_ID_MAX) + 1)
  31
  32 enum roam_attributes {
  33     SLSI_ATTR_ROAM_CAPABILITY_BLACKLIST_SIZE,
  34     SLSI_ATTR_ROAM_CAPABILITY_WHITELIST_SIZE,
  35     SLSI_ATTR_ROAM_STATE
  36 };
  37
  38 class BssidBlacklistCommand : public WifiCommand
  39 {
  40 private:
  41     wifi_bssid_params *mParams;
  42 public:
  43     BssidBlacklistCommand(wifi_interface_handle handle, int id,
  44             wifi_bssid_params *params)
  45         : WifiCommand(handle, id), mParams(params)
  46     { }
  47      int createRequest(WifiRequest& request) {
  48         int result = request.create(GOOGLE_OUI, SLSI_NL80211_VENDOR_SUBCMD_SET_BSSID_BLACKLIST);
  49         if (result < 0) {
  50             return result;
  51         }
  52
  53         nlattr *data = request.attr_start(NL80211_ATTR_VENDOR_DATA);
  54         result = request.put_u32(GSCAN_ATTRIBUTE_NUM_BSSID, mParams->num_bssid);
  55         if (result < 0) {
  56             return result;
  57         }
  58
  59         for (int i = 0; i < mParams->num_bssid; i++) {
  60             result = request.put_addr(GSCAN_ATTRIBUTE_BLACKLIST_BSSID, mParams->bssids[i]);
  61             if (result < 0) {
  62                 return result;
  63             }
  64         }
  65         request.attr_end(data);
  66         return result;
  67     }
  68
  69     int start() {
  70         WifiRequest request(familyId(), ifaceId());
  71         int result = createRequest(request);
  72         if (result < 0) {
  73             return result;
  74         }
  75
  76         result = requestResponse(request);
  77         if (result < 0) {
  78             ALOGE("Failed to execute bssid blacklist request, result = %d", result);
  79             return result;
  80         }
  81
  82         return result;
  83     }
  84
  85
  86     virtual int handleResponse(WifiEvent& reply) {
  87         /* Nothing to do on response! */
  88         return NL_SKIP;
  89     }
  90 };
  91
  92 wifi_error wifi_set_bssid_blacklist(wifi_request_id id, wifi_interface_handle iface,
  93         wifi_bssid_params params)
  94 {
  95     BssidBlacklistCommand *cmd = new BssidBlacklistCommand(iface, id, &params);
  96     wifi_error result = (wifi_error)cmd->start();
  97     //release the reference of command as well
  98     cmd->releaseRef();
  99     return result;
 100 }
 101
 102
 103 class RoamingCapabilitiesCommand : public WifiCommand
 104 {
 105 private:
 106     wifi_roaming_capabilities *mCaps;
 107
 108 public:
 109     RoamingCapabilitiesCommand(wifi_interface_handle handle, wifi_roaming_capabilities *caps)
 110         : WifiCommand(handle, 0) {
 111         mCaps = caps;
 112     }
 113
 114     virtual int create() {
 115         int ret;
 116
 117         ret = mMsg.create(GOOGLE_OUI, SLSI_NL80211_VENDOR_SUBCMD_GET_ROAMING_CAPABILITIES);
 118         if (ret < 0) {
 119              ALOGE("Can't create message to send to driver - %d", ret);
 120              return ret;
 121         }
 122         return WIFI_SUCCESS;
 123
 124     }
 125
 126     virtual int handleResponse(WifiEvent& reply) {
 127
 128         if (reply.get_cmd() != NL80211_CMD_VENDOR) {
 129             ALOGD("Ignore reply; cmd = %d", reply.get_cmd());
 130             return NL_SKIP;
 131         }
 132
 133         nlattr *vendor_data = reply.get_attribute(NL80211_ATTR_VENDOR_DATA);
 134         int len = reply.get_vendor_data_len();
 135
 136         if (vendor_data == NULL || len == 0) {
 137             ALOGE("vendor data in GetFeatureSetCommand missing!!");
 138             return NL_SKIP;
 139         }
 140
 141         for (nl_iterator it(vendor_data); it.has_next(); it.next()) {
 142             switch(it.get_type()) {
 143                 case SLSI_ATTR_ROAM_CAPABILITY_BLACKLIST_SIZE:
 144                     mCaps->max_blacklist_size = it.get_u32();
 145                     break;
 146                 case SLSI_ATTR_ROAM_CAPABILITY_WHITELIST_SIZE:
 147                     mCaps->max_whitelist_size = it.get_u32();
 148                     break;
 149                 default :
 150                     break;
 151             }
 152         }
 153         return NL_OK;
 154     }
 155 };
 156
 157 wifi_error wifi_get_roaming_capabilities(wifi_interface_handle handle,
 158                                          wifi_roaming_capabilities *caps)
 159 {
 160     RoamingCapabilitiesCommand cmd(handle, caps);
 161     return (wifi_error) cmd.requestResponse();
 162 }
 163
 164 class RoamingStateCommand : public WifiCommand
 165 {
 166 private:
 167     fw_roaming_state_t mRoamingState;
 168
 169 public:
 170     RoamingStateCommand(wifi_interface_handle handle, fw_roaming_state_t roaming_state)
 171         : WifiCommand(handle, 0) {
 172         mRoamingState = roaming_state;
 173     }
 174
 175     virtual int create() {
 176         int ret;
 177         ret = mMsg.create(GOOGLE_OUI, SLSI_NL80211_VENDOR_SUBCMD_SET_ROAMING_STATE);
 178         if (ret < 0) {
 179              ALOGE("Can't create message to send to driver - %d", ret);
 180              return ret;
 181         }
 182
 183         nlattr *data = mMsg.attr_start(NL80211_ATTR_VENDOR_DATA);
 184         ret = mMsg.put_u8(SLSI_ATTR_ROAM_STATE, mRoamingState);
 185         if (ret < 0) {
 186             return ret;
 187         }
 188         mMsg.attr_end(data);
 189         return WIFI_SUCCESS;
 190     }
 191 };
 192
 193 wifi_error wifi_enable_firmware_roaming(wifi_interface_handle handle, fw_roaming_state_t state) {
 194     RoamingStateCommand cmd(handle, state);
 195     wifi_error ret = (wifi_error) cmd.requestResponse();
 196     return ret;
 197 }
 198
 199 wifi_error wifi_configure_roaming(wifi_interface_handle iface, wifi_roaming_config *roaming_config)
 200 {
 201     wifi_error ret;
 202     int requestId;
 203     wifi_bssid_params bssid_params;
 204
 205     if (!roaming_config) {
 206         ALOGE("%s: Invalid Buffer provided. Exit", __FUNCTION__);
 207         return WIFI_ERROR_INVALID_ARGS;
 208    }
 209
 210     /* Generate request id randomly*/
 211    requestId = get_requestid();
 212    bssid_params.num_bssid = roaming_config->num_blacklist_bssid;
 213
 214    memcpy(bssid_params.bssids, roaming_config->blacklist_bssid,
 215            (bssid_params.num_bssid * sizeof(mac_addr)));
 216
 217     ret = wifi_set_bssid_blacklist(requestId, iface, bssid_params);
 218     if (ret != WIFI_SUCCESS) {
 219         ALOGE("%s: Failed to configure blacklist bssids", __FUNCTION__);
 220         return WIFI_ERROR_UNKNOWN;
 221     }
 222
 223     return ret;
 224 }