private_lib/driver_cmd_nl80211.c

   1 /*
   2  * Driver interaction with extended Linux CFG8021
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License version 2 as
   6  * published by the Free Software Foundation.
   7  *
   8  * Alternatively, this software may be distributed under the terms of BSD
   9  * license.
  10  *
  11  */
  12
  13 #include "driver_nl80211.h"
  14 #include "driver_cmd_common.h"
  15
  16 #include "wpa_supplicant_i.h"
  17 #include "config.h"
  18
  19 #define WPA_PS_ENABLED          0
  20 #define WPA_PS_DISABLED         1
  21
  22 typedef struct android_wifi_priv_cmd {
  23         char *buf;
  24         int used_len;
  25         int total_len;
  26 } android_wifi_priv_cmd;
  27
  28 int send_and_recv_msgs(struct wpa_driver_nl80211_data *drv, struct nl_msg *msg,
  29                        int (*valid_handler)(struct nl_msg *, void *),
  30                        void *valid_data);
  31
  32 static int drv_errors = 0;
  33
  34 static void wpa_driver_send_hang_msg(struct wpa_driver_nl80211_data *drv)
  35 {
  36         drv_errors++;
  37         if (drv_errors > DRV_NUMBER_SEQUENTIAL_ERRORS) {
  38                 drv_errors = 0;
  39                 wpa_msg(drv->ctx, MSG_INFO, WPA_EVENT_DRIVER_STATE "HANGED");
  40         }
  41 }
  42
  43 static int wpa_driver_set_power_save(void *priv, int state)
  44 {
  45         struct i802_bss *bss = priv;
  46         struct wpa_driver_nl80211_data *drv = bss->drv;
  47         struct nl_msg *msg;
  48         int ret = -1;
  49         enum nl80211_ps_state ps_state;
  50
  51         msg = nlmsg_alloc();
  52         if (!msg)
  53                 return -1;
  54
  55         genlmsg_put(msg, 0, 0, genl_family_get_id(drv->nl80211), 0, 0,
  56                     NL80211_CMD_SET_POWER_SAVE, 0);
  57
  58         if (state == WPA_PS_ENABLED)
  59                 ps_state = NL80211_PS_ENABLED;
  60         else
  61                 ps_state = NL80211_PS_DISABLED;
  62
  63         NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, drv->ifindex);
  64         NLA_PUT_U32(msg, NL80211_ATTR_PS_STATE, ps_state);
  65
  66         ret = send_and_recv_msgs(drv, msg, NULL, NULL);
  67         msg = NULL;
  68         if (ret < 0)
  69                 wpa_printf(MSG_ERROR, "nl80211: Set power mode fail: %d", ret);
  70 nla_put_failure:
  71         nlmsg_free(msg);
  72         return ret;
  73 }
  74
  75 static int get_power_mode_handler(struct nl_msg *msg, void *arg)
  76 {
  77         struct nlattr *tb[NL80211_ATTR_MAX + 1];
  78         struct genlmsghdr *gnlh = nlmsg_data(nlmsg_hdr(msg));
  79         int *state = (int *)arg;
  80
  81         nla_parse(tb, NL80211_ATTR_MAX, genlmsg_attrdata(gnlh, 0),
  82                   genlmsg_attrlen(gnlh, 0), NULL);
  83
  84         if (!tb[NL80211_ATTR_PS_STATE])
  85                 return NL_SKIP;
  86
  87         if (state) {
  88                 *state = (int)nla_get_u32(tb[NL80211_ATTR_PS_STATE]);
  89                 wpa_printf(MSG_DEBUG, "nl80211: Get power mode = %d", *state);
  90                 *state = (*state == NL80211_PS_ENABLED) ?
  91                                 WPA_PS_ENABLED : WPA_PS_DISABLED;
  92         }
  93
  94         return NL_SKIP;
  95 }
  96
  97 static int wpa_driver_get_power_save(void *priv, int *state)
  98 {
  99         struct i802_bss *bss = priv;
 100         struct wpa_driver_nl80211_data *drv = bss->drv;
 101         struct nl_msg *msg;
 102         int ret = -1;
 103         enum nl80211_ps_state ps_state;
 104
 105         msg = nlmsg_alloc();
 106         if (!msg)
 107                 return -1;
 108
 109         genlmsg_put(msg, 0, 0, genl_family_get_id(drv->nl80211), 0, 0,
 110                     NL80211_CMD_GET_POWER_SAVE, 0);
 111
 112         NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, drv->ifindex);
 113
 114         ret = send_and_recv_msgs(drv, msg, get_power_mode_handler, state);
 115         msg = NULL;
 116         if (ret < 0)
 117                 wpa_printf(MSG_ERROR, "nl80211: Get power mode fail: %d", ret);
 118 nla_put_failure:
 119         nlmsg_free(msg);
 120         return ret;
 121 }
 122
 123 static int wpa_driver_set_backgroundscan_params(void *priv)
 124 {
 125         struct i802_bss *bss = priv;
 126         struct wpa_driver_nl80211_data *drv = bss->drv;
 127         struct wpa_supplicant *wpa_s;
 128         struct ifreq ifr;
 129         android_wifi_priv_cmd priv_cmd;
 130         int ret = 0, i = 0, bp;
 131         char buf[WEXT_PNO_MAX_COMMAND_SIZE];
 132         struct wpa_ssid *ssid_conf;
 133
 134         if (drv == NULL) {
 135                 wpa_printf(MSG_ERROR, "%s: drv is NULL. Exiting", __func__);
 136                 return -1;
 137         }
 138         if (drv->ctx == NULL) {
 139                 wpa_printf(MSG_ERROR, "%s: drv->ctx is NULL. Exiting", __func__);
 140                 return -1;
 141         }
 142         wpa_s = (struct wpa_supplicant *)(drv->ctx);
 143         if (wpa_s->conf == NULL) {
 144                 wpa_printf(MSG_ERROR, "%s: wpa_s->conf is NULL. Exiting", __func__);
 145                 return -1;
 146         }
 147         ssid_conf = wpa_s->conf->ssid;
 148
 149         bp = WEXT_PNOSETUP_HEADER_SIZE;
 150         os_memcpy(buf, WEXT_PNOSETUP_HEADER, bp);
 151         buf[bp++] = WEXT_PNO_TLV_PREFIX;
 152         buf[bp++] = WEXT_PNO_TLV_VERSION;
 153         buf[bp++] = WEXT_PNO_TLV_SUBVERSION;
 154         buf[bp++] = WEXT_PNO_TLV_RESERVED;
 155
 156         while ((i < WEXT_PNO_AMOUNT) && (ssid_conf != NULL)) {
 157                 /* Check that there is enough space needed for 1 more SSID, the other sections and null termination */
 158                 if ((bp + WEXT_PNO_SSID_HEADER_SIZE + MAX_SSID_LEN + WEXT_PNO_NONSSID_SECTIONS_SIZE + 1) >= (int)sizeof(buf))
 159                         break;
 160                 if ((!ssid_conf->disabled) && (ssid_conf->ssid_len <= MAX_SSID_LEN)){
 161                         wpa_printf(MSG_DEBUG, "For PNO Scan: %s", ssid_conf->ssid);
 162                         buf[bp++] = WEXT_PNO_SSID_SECTION;
 163                         buf[bp++] = ssid_conf->ssid_len;
 164                         os_memcpy(&buf[bp], ssid_conf->ssid, ssid_conf->ssid_len);
 165                         bp += ssid_conf->ssid_len;
 166                         i++;
 167                 }
 168                 ssid_conf = ssid_conf->next;
 169         }
 170
 171         buf[bp++] = WEXT_PNO_SCAN_INTERVAL_SECTION;
 172         os_snprintf(&buf[bp], WEXT_PNO_SCAN_INTERVAL_LENGTH + 1, "%x", WEXT_PNO_SCAN_INTERVAL);
 173         bp += WEXT_PNO_SCAN_INTERVAL_LENGTH;
 174
 175         buf[bp++] = WEXT_PNO_REPEAT_SECTION;
 176         os_snprintf(&buf[bp], WEXT_PNO_REPEAT_LENGTH + 1, "%x", WEXT_PNO_REPEAT);
 177         bp += WEXT_PNO_REPEAT_LENGTH;
 178
 179         buf[bp++] = WEXT_PNO_MAX_REPEAT_SECTION;
 180         os_snprintf(&buf[bp], WEXT_PNO_MAX_REPEAT_LENGTH + 1, "%x", WEXT_PNO_MAX_REPEAT);
 181         bp += WEXT_PNO_MAX_REPEAT_LENGTH + 1;
 182
 183         memset(&ifr, 0, sizeof(ifr));
 184         memset(&priv_cmd, 0, sizeof(priv_cmd));
 185         os_strncpy(ifr.ifr_name, bss->ifname, IFNAMSIZ);
 186
 187         priv_cmd.buf = buf;
 188         priv_cmd.used_len = bp;
 189         priv_cmd.total_len = bp;
 190         ifr.ifr_data = &priv_cmd;
 191
 192         ret = ioctl(drv->ioctl_sock, SIOCDEVPRIVATE + 1, &ifr);
 193
 194         if (ret < 0) {
 195                 wpa_printf(MSG_ERROR, "ioctl[SIOCSIWPRIV] (pnosetup): %d", ret);
 196                 wpa_driver_send_hang_msg(drv);
 197         } else {
 198                 drv_errors = 0;
 199         }
 200         return ret;
 201 }
 202
 203 int wpa_driver_nl80211_driver_cmd(void *priv, char *cmd, char *buf,
 204                                   size_t buf_len )
 205 {
 206         struct i802_bss *bss = priv;
 207         struct wpa_driver_nl80211_data *drv = bss->drv;
 208         struct ifreq ifr;
 209         android_wifi_priv_cmd priv_cmd;
 210         int ret = 0;
 211
 212         if (os_strcasecmp(cmd, "STOP") == 0) {
 213                 linux_set_iface_flags(drv->ioctl_sock, bss->ifname, 0);
 214                 wpa_msg(drv->ctx, MSG_INFO, WPA_EVENT_DRIVER_STATE "STOPPED");
 215         } else if (os_strcasecmp(cmd, "START") == 0) {
 216                 linux_set_iface_flags(drv->ioctl_sock, bss->ifname, 1);
 217                 wpa_msg(drv->ctx, MSG_INFO, WPA_EVENT_DRIVER_STATE "STARTED");
 218         } else if (os_strcasecmp(cmd, "MACADDR") == 0) {
 219                 u8 macaddr[ETH_ALEN] = {};
 220
 221                 ret = linux_get_ifhwaddr(drv->ioctl_sock, bss->ifname, macaddr);
 222                 if (!ret)
 223                         ret = os_snprintf(buf, buf_len,
 224                                           "Macaddr = " MACSTR "\n", MAC2STR(macaddr));
 225         } else if (os_strcasecmp(cmd, "RELOAD") == 0) {
 226                 wpa_msg(drv->ctx, MSG_INFO, WPA_EVENT_DRIVER_STATE "HANGED");
 227         } else if (os_strncasecmp(cmd, "POWERMODE ", 10) == 0) {
 228                 int state;
 229
 230                 state = atoi(cmd + 10);
 231                 ret = wpa_driver_set_power_save(priv, state);
 232                 if (ret < 0)
 233                         wpa_driver_send_hang_msg(drv);
 234                 else
 235                         drv_errors = 0;
 236         } else if (os_strncasecmp(cmd, "GETPOWER", 8) == 0) {
 237                 int state = -1;
 238
 239                 ret = wpa_driver_get_power_save(priv, &state);
 240                 if (!ret && (state != -1)) {
 241                         ret = os_snprintf(buf, buf_len, "POWERMODE = %d\n", state);
 242                         drv_errors = 0;
 243                 } else {
 244                         wpa_driver_send_hang_msg(drv);
 245                 }
 246         } else { /* Use private command */
 247                 if (os_strcasecmp(cmd, "BGSCAN-START") == 0) {
 248                         ret = wpa_driver_set_backgroundscan_params(priv);
 249                         if (ret < 0) {
 250                                 return ret;
 251                         }
 252                         os_memcpy(buf, "PNOFORCE 1", 11);
 253                 } else if (os_strcasecmp(cmd, "BGSCAN-STOP") == 0) {
 254                         os_memcpy(buf, "PNOFORCE 0", 11);
 255                 } else {
 256                         os_memcpy(buf, cmd, strlen(cmd) + 1);
 257                 }
 258                 memset(&ifr, 0, sizeof(ifr));
 259                 memset(&priv_cmd, 0, sizeof(priv_cmd));
 260                 os_strncpy(ifr.ifr_name, bss->ifname, IFNAMSIZ);
 261
 262                 priv_cmd.buf = buf;
 263                 priv_cmd.used_len = buf_len;
 264                 priv_cmd.total_len = buf_len;
 265                 ifr.ifr_data = &priv_cmd;
 266
 267 #ifndef __i386__ /* we don't support SIOCDEVPRIVATE */
 268                 if ((ret = ioctl(drv->ioctl_sock, SIOCDEVPRIVATE + 1, &ifr)) < 0) {
 269                         wpa_printf(MSG_ERROR, "%s: failed to issue private commands\n", __func__);
 270                         wpa_driver_send_hang_msg(drv);
 271                 } else {
 272                         drv_errors = 0;
 273                         ret = 0;
 274                         if ((os_strcasecmp(cmd, "LINKSPEED") == 0) ||
 275                             (os_strcasecmp(cmd, "RSSI") == 0) ||
 276                             (os_strcasecmp(cmd, "GETBAND") == 0) ||
 277                             (os_strcasecmp(cmd, "P2P_GET_NOA") == 0))
 278                                 ret = strlen(buf);
 279
 280                         wpa_printf(MSG_DEBUG, "%s %s len = %d, %d", __func__, buf, ret, strlen(buf));
 281                 }
 282 #endif
 283         }
 284         return ret;
 285 }
 286
 287 int wpa_driver_set_p2p_noa(void *priv, u8 count, int start, int duration)
 288 {
 289         char buf[MAX_DRV_CMD_SIZE];
 290
 291         memset(buf, 0, sizeof(buf));
 292         wpa_printf(MSG_DEBUG, "%s: Entry", __func__);
 293         snprintf(buf, sizeof(buf), "P2P_SET_NOA %d %d %d", count, start, duration);
 294         return wpa_driver_nl80211_driver_cmd(priv, buf, buf, strlen(buf)+1);
 295 }
 296
 297 int wpa_driver_get_p2p_noa(void *priv, u8 *buf, size_t len)
 298 {
 299         char rbuf[MAX_DRV_CMD_SIZE];
 300         char *cmd = "P2P_GET_NOA";
 301         int ret;
 302
 303         wpa_printf(MSG_DEBUG, "%s: Entry", __func__);
 304         os_memset(buf, 0, len);
 305         ret = wpa_driver_nl80211_driver_cmd(priv, cmd, rbuf, sizeof(rbuf));
 306         if (ret <= 0)
 307                 return 0;
 308         ret >>= 1;
 309         if (ret > (int)len)
 310                 ret = (int)len;
 311         hexstr2bin(rbuf, buf, ret);
 312         return ret;
 313 }
 314
 315 int wpa_driver_set_p2p_ps(void *priv, int legacy_ps, int opp_ps, int ctwindow)
 316 {
 317         char buf[MAX_DRV_CMD_SIZE];
 318
 319         memset(buf, 0, sizeof(buf));
 320         wpa_printf(MSG_DEBUG, "%s: Entry", __func__);
 321         snprintf(buf, sizeof(buf), "P2P_SET_PS %d %d %d", legacy_ps, opp_ps, ctwindow);
 322         return wpa_driver_nl80211_driver_cmd(priv, buf, buf, strlen(buf) + 1);
 323 }
 324
 325 int wpa_driver_set_ap_wps_p2p_ie(void *priv, const struct wpabuf *beacon,
 326                                  const struct wpabuf *proberesp,
 327                                  const struct wpabuf *assocresp)
 328 {
 329         char buf[MAX_WPSP2PIE_CMD_SIZE];
 330         struct wpabuf *ap_wps_p2p_ie = NULL;
 331         char *_cmd = "SET_AP_WPS_P2P_IE";
 332         char *pbuf;
 333         int ret = 0;
 334         int i;
 335         struct cmd_desc {
 336                 int cmd;
 337                 const struct wpabuf *src;
 338         } cmd_arr[] = {
 339                 {0x1, beacon},
 340                 {0x2, proberesp},
 341                 {0x4, assocresp},
 342                 {-1, NULL}
 343         };
 344
 345         wpa_printf(MSG_DEBUG, "%s: Entry", __func__);
 346         for (i = 0; cmd_arr[i].cmd != -1; i++) {
 347                 os_memset(buf, 0, sizeof(buf));
 348                 pbuf = buf;
 349                 pbuf += sprintf(pbuf, "%s %d", _cmd, cmd_arr[i].cmd);
 350                 *pbuf++ = '\0';
 351                 ap_wps_p2p_ie = cmd_arr[i].src ?
 352                         wpabuf_dup(cmd_arr[i].src) : NULL;
 353                 if (ap_wps_p2p_ie) {
 354                         os_memcpy(pbuf, wpabuf_head(ap_wps_p2p_ie), wpabuf_len(ap_wps_p2p_ie));
 355                         ret = wpa_driver_nl80211_driver_cmd(priv, buf, buf,
 356                                 strlen(_cmd) + 3 + wpabuf_len(ap_wps_p2p_ie));
 357                         wpabuf_free(ap_wps_p2p_ie);
 358                         if (ret < 0)
 359                                 break;
 360                 }
 361         }
 362
 363         return ret;
 364 }