src/ap/ctrl_iface_ap.c

   1 /*
   2  * Control interface for shared AP commands
   3  * Copyright (c) 2004-2014, Jouni Malinen <j@w1.fi>
   4  *
   5  * This software may be distributed under the terms of the BSD license.
   6  * See README for more details.
   7  */
   8
   9 #include "utils/includes.h"
  10
  11 #include "utils/common.h"
  12 #include "common/ieee802_11_defs.h"
  13 #include "common/sae.h"
  14 #include "eapol_auth/eapol_auth_sm.h"
  15 #include "fst/fst_ctrl_iface.h"
  16 #include "hostapd.h"
  17 #include "ieee802_1x.h"
  18 #include "wpa_auth.h"
  19 #include "ieee802_11.h"
  20 #include "sta_info.h"
  21 #include "wps_hostapd.h"
  22 #include "p2p_hostapd.h"
  23 #include "ctrl_iface_ap.h"
  24 #include "ap_drv_ops.h"
  25 #include "mbo_ap.h"
  26
  27
  28 static int hostapd_get_sta_tx_rx(struct hostapd_data *hapd,
  29                                  struct sta_info *sta,
  30                                  char *buf, size_t buflen)
  31 {
  32         struct hostap_sta_driver_data data;
  33         int ret;
  34
  35         if (hostapd_drv_read_sta_data(hapd, &data, sta->addr) < 0)
  36                 return 0;
  37
  38         ret = os_snprintf(buf, buflen, "rx_packets=%lu\ntx_packets=%lu\n"
  39                           "rx_bytes=%llu\ntx_bytes=%llu\n",
  40                           data.rx_packets, data.tx_packets,
  41                           data.rx_bytes, data.tx_bytes);
  42         if (os_snprintf_error(buflen, ret))
  43                 return 0;
  44         return ret;
  45 }
  46
  47
  48 static int hostapd_get_sta_conn_time(struct sta_info *sta,
  49                                      char *buf, size_t buflen)
  50 {
  51         struct os_reltime age;
  52         int ret;
  53
  54         if (!sta->connected_time.sec)
  55                 return 0;
  56
  57         os_reltime_age(&sta->connected_time, &age);
  58
  59         ret = os_snprintf(buf, buflen, "connected_time=%u\n",
  60                           (unsigned int) age.sec);
  61         if (os_snprintf_error(buflen, ret))
  62                 return 0;
  63         return ret;
  64 }
  65
  66
  67 static const char * timeout_next_str(int val)
  68 {
  69         switch (val) {
  70         case STA_NULLFUNC:
  71                 return "NULLFUNC POLL";
  72         case STA_DISASSOC:
  73                 return "DISASSOC";
  74         case STA_DEAUTH:
  75                 return "DEAUTH";
  76         case STA_REMOVE:
  77                 return "REMOVE";
  78         case STA_DISASSOC_FROM_CLI:
  79                 return "DISASSOC_FROM_CLI";
  80         }
  81
  82         return "?";
  83 }
  84
  85
  86 static int hostapd_ctrl_iface_sta_mib(struct hostapd_data *hapd,
  87                                       struct sta_info *sta,
  88                                       char *buf, size_t buflen)
  89 {
  90         int len, res, ret, i;
  91
  92         if (!sta)
  93                 return 0;
  94
  95         len = 0;
  96         ret = os_snprintf(buf + len, buflen - len, MACSTR "\nflags=",
  97                           MAC2STR(sta->addr));
  98         if (os_snprintf_error(buflen - len, ret))
  99                 return len;
 100         len += ret;
 101
 102         ret = ap_sta_flags_txt(sta->flags, buf + len, buflen - len);
 103         if (ret < 0)
 104                 return len;
 105         len += ret;
 106
 107         ret = os_snprintf(buf + len, buflen - len, "\naid=%d\ncapability=0x%x\n"
 108                           "listen_interval=%d\nsupported_rates=",
 109                           sta->aid, sta->capability, sta->listen_interval);
 110         if (os_snprintf_error(buflen - len, ret))
 111                 return len;
 112         len += ret;
 113
 114         for (i = 0; i < sta->supported_rates_len; i++) {
 115                 ret = os_snprintf(buf + len, buflen - len, "%02x%s",
 116                                   sta->supported_rates[i],
 117                                   i + 1 < sta->supported_rates_len ? " " : "");
 118                 if (os_snprintf_error(buflen - len, ret))
 119                         return len;
 120                 len += ret;
 121         }
 122
 123         ret = os_snprintf(buf + len, buflen - len, "\ntimeout_next=%s\n",
 124                           timeout_next_str(sta->timeout_next));
 125         if (os_snprintf_error(buflen - len, ret))
 126                 return len;
 127         len += ret;
 128
 129         res = ieee802_11_get_mib_sta(hapd, sta, buf + len, buflen - len);
 130         if (res >= 0)
 131                 len += res;
 132         res = wpa_get_mib_sta(sta->wpa_sm, buf + len, buflen - len);
 133         if (res >= 0)
 134                 len += res;
 135         res = ieee802_1x_get_mib_sta(hapd, sta, buf + len, buflen - len);
 136         if (res >= 0)
 137                 len += res;
 138         res = hostapd_wps_get_mib_sta(hapd, sta->addr, buf + len,
 139                                       buflen - len);
 140         if (res >= 0)
 141                 len += res;
 142         res = hostapd_p2p_get_mib_sta(hapd, sta, buf + len, buflen - len);
 143         if (res >= 0)
 144                 len += res;
 145
 146         len += hostapd_get_sta_tx_rx(hapd, sta, buf + len, buflen - len);
 147         len += hostapd_get_sta_conn_time(sta, buf + len, buflen - len);
 148
 149 #ifdef CONFIG_SAE
 150         if (sta->sae && sta->sae->state == SAE_ACCEPTED) {
 151                 res = os_snprintf(buf + len, buflen - len, "sae_group=%d\n",
 152                                   sta->sae->group);
 153                 if (!os_snprintf_error(buflen - len, res))
 154                         len += res;
 155         }
 156 #endif /* CONFIG_SAE */
 157
 158         if (sta->vlan_id > 0) {
 159                 res = os_snprintf(buf + len, buflen - len, "vlan_id=%d\n",
 160                                   sta->vlan_id);
 161                 if (!os_snprintf_error(buflen - len, res))
 162                         len += res;
 163         }
 164
 165         res = mbo_ap_get_info(sta, buf + len, buflen - len);
 166         if (res >= 0)
 167                 len += res;
 168
 169         if (sta->supp_op_classes &&
 170             buflen - len > (unsigned) (17 + 2 * sta->supp_op_classes[0])) {
 171                 len += os_snprintf(buf + len, buflen - len, "supp_op_classes=");
 172                 len += wpa_snprintf_hex(buf + len, buflen - len,
 173                                         sta->supp_op_classes + 1,
 174                                         sta->supp_op_classes[0]);
 175                 len += os_snprintf(buf + len, buflen - len, "\n");
 176         }
 177
 178         return len;
 179 }
 180
 181
 182 int hostapd_ctrl_iface_sta_first(struct hostapd_data *hapd,
 183                                  char *buf, size_t buflen)
 184 {
 185         return hostapd_ctrl_iface_sta_mib(hapd, hapd->sta_list, buf, buflen);
 186 }
 187
 188
 189 int hostapd_ctrl_iface_sta(struct hostapd_data *hapd, const char *txtaddr,
 190                            char *buf, size_t buflen)
 191 {
 192         u8 addr[ETH_ALEN];
 193         int ret;
 194         const char *pos;
 195         struct sta_info *sta;
 196
 197         if (hwaddr_aton(txtaddr, addr)) {
 198                 ret = os_snprintf(buf, buflen, "FAIL\n");
 199                 if (os_snprintf_error(buflen, ret))
 200                         return 0;
 201                 return ret;
 202         }
 203
 204         sta = ap_get_sta(hapd, addr);
 205         if (sta == NULL)
 206                 return -1;
 207
 208         pos = os_strchr(txtaddr, ' ');
 209         if (pos) {
 210                 pos++;
 211
 212 #ifdef HOSTAPD_DUMP_STATE
 213                 if (os_strcmp(pos, "eapol") == 0) {
 214                         if (sta->eapol_sm == NULL)
 215                                 return -1;
 216                         return eapol_auth_dump_state(sta->eapol_sm, buf,
 217                                                      buflen);
 218                 }
 219 #endif /* HOSTAPD_DUMP_STATE */
 220
 221                 return -1;
 222         }
 223
 224         ret = hostapd_ctrl_iface_sta_mib(hapd, sta, buf, buflen);
 225         ret += fst_ctrl_iface_mb_info(addr, buf + ret, buflen - ret);
 226
 227         return ret;
 228 }
 229
 230
 231 int hostapd_ctrl_iface_sta_next(struct hostapd_data *hapd, const char *txtaddr,
 232                                 char *buf, size_t buflen)
 233 {
 234         u8 addr[ETH_ALEN];
 235         struct sta_info *sta;
 236         int ret;
 237
 238         if (hwaddr_aton(txtaddr, addr) ||
 239             (sta = ap_get_sta(hapd, addr)) == NULL) {
 240                 ret = os_snprintf(buf, buflen, "FAIL\n");
 241                 if (os_snprintf_error(buflen, ret))
 242                         return 0;
 243                 return ret;
 244         }
 245
 246         if (!sta->next)
 247                 return 0;
 248
 249         return hostapd_ctrl_iface_sta_mib(hapd, sta->next, buf, buflen);
 250 }
 251
 252
 253 #ifdef CONFIG_P2P_MANAGER
 254 static int p2p_manager_disconnect(struct hostapd_data *hapd, u16 stype,
 255                                   u8 minor_reason_code, const u8 *addr)
 256 {
 257         struct ieee80211_mgmt *mgmt;
 258         int ret;
 259         u8 *pos;
 260
 261         if (hapd->driver->send_frame == NULL)
 262                 return -1;
 263
 264         mgmt = os_zalloc(sizeof(*mgmt) + 100);
 265         if (mgmt == NULL)
 266                 return -1;
 267
 268         mgmt->frame_control = IEEE80211_FC(WLAN_FC_TYPE_MGMT, stype);
 269         wpa_dbg(hapd->msg_ctx, MSG_DEBUG, "P2P: Disconnect STA " MACSTR
 270                 " with minor reason code %u (stype=%u (%s))",
 271                 MAC2STR(addr), minor_reason_code, stype,
 272                 fc2str(mgmt->frame_control));
 273
 274         os_memcpy(mgmt->da, addr, ETH_ALEN);
 275         os_memcpy(mgmt->sa, hapd->own_addr, ETH_ALEN);
 276         os_memcpy(mgmt->bssid, hapd->own_addr, ETH_ALEN);
 277         if (stype == WLAN_FC_STYPE_DEAUTH) {
 278                 mgmt->u.deauth.reason_code =
 279                         host_to_le16(WLAN_REASON_PREV_AUTH_NOT_VALID);
 280                 pos = (u8 *) (&mgmt->u.deauth.reason_code + 1);
 281         } else {
 282                 mgmt->u.disassoc.reason_code =
 283                         host_to_le16(WLAN_REASON_PREV_AUTH_NOT_VALID);
 284                 pos = (u8 *) (&mgmt->u.disassoc.reason_code + 1);
 285         }
 286
 287         *pos++ = WLAN_EID_VENDOR_SPECIFIC;
 288         *pos++ = 4 + 3 + 1;
 289         WPA_PUT_BE32(pos, P2P_IE_VENDOR_TYPE);
 290         pos += 4;
 291
 292         *pos++ = P2P_ATTR_MINOR_REASON_CODE;
 293         WPA_PUT_LE16(pos, 1);
 294         pos += 2;
 295         *pos++ = minor_reason_code;
 296
 297         ret = hapd->driver->send_frame(hapd->drv_priv, (u8 *) mgmt,
 298                                        pos - (u8 *) mgmt, 1);
 299         os_free(mgmt);
 300
 301         return ret < 0 ? -1 : 0;
 302 }
 303 #endif /* CONFIG_P2P_MANAGER */
 304
 305
 306 int hostapd_ctrl_iface_deauthenticate(struct hostapd_data *hapd,
 307                                       const char *txtaddr)
 308 {
 309         u8 addr[ETH_ALEN];
 310         struct sta_info *sta;
 311         const char *pos;
 312         u16 reason = WLAN_REASON_PREV_AUTH_NOT_VALID;
 313
 314         wpa_dbg(hapd->msg_ctx, MSG_DEBUG, "CTRL_IFACE DEAUTHENTICATE %s",
 315                 txtaddr);
 316
 317         if (hwaddr_aton(txtaddr, addr))
 318                 return -1;
 319
 320         pos = os_strstr(txtaddr, " reason=");
 321         if (pos)
 322                 reason = atoi(pos + 8);
 323
 324         pos = os_strstr(txtaddr, " test=");
 325         if (pos) {
 326                 struct ieee80211_mgmt mgmt;
 327                 int encrypt;
 328                 if (hapd->driver->send_frame == NULL)
 329                         return -1;
 330                 pos += 6;
 331                 encrypt = atoi(pos);
 332                 os_memset(&mgmt, 0, sizeof(mgmt));
 333                 mgmt.frame_control = IEEE80211_FC(WLAN_FC_TYPE_MGMT,
 334                                                   WLAN_FC_STYPE_DEAUTH);
 335                 os_memcpy(mgmt.da, addr, ETH_ALEN);
 336                 os_memcpy(mgmt.sa, hapd->own_addr, ETH_ALEN);
 337                 os_memcpy(mgmt.bssid, hapd->own_addr, ETH_ALEN);
 338                 mgmt.u.deauth.reason_code = host_to_le16(reason);
 339                 if (hapd->driver->send_frame(hapd->drv_priv, (u8 *) &mgmt,
 340                                              IEEE80211_HDRLEN +
 341                                              sizeof(mgmt.u.deauth),
 342                                              encrypt) < 0)
 343                         return -1;
 344                 return 0;
 345         }
 346
 347 #ifdef CONFIG_P2P_MANAGER
 348         pos = os_strstr(txtaddr, " p2p=");
 349         if (pos) {
 350                 return p2p_manager_disconnect(hapd, WLAN_FC_STYPE_DEAUTH,
 351                                               atoi(pos + 5), addr);
 352         }
 353 #endif /* CONFIG_P2P_MANAGER */
 354
 355         hostapd_drv_sta_deauth(hapd, addr, reason);
 356         sta = ap_get_sta(hapd, addr);
 357         if (sta)
 358                 ap_sta_deauthenticate(hapd, sta, reason);
 359         else if (addr[0] == 0xff)
 360                 hostapd_free_stas(hapd);
 361
 362         return 0;
 363 }
 364
 365
 366 int hostapd_ctrl_iface_disassociate(struct hostapd_data *hapd,
 367                                     const char *txtaddr)
 368 {
 369         u8 addr[ETH_ALEN];
 370         struct sta_info *sta;
 371         const char *pos;
 372         u16 reason = WLAN_REASON_PREV_AUTH_NOT_VALID;
 373
 374         wpa_dbg(hapd->msg_ctx, MSG_DEBUG, "CTRL_IFACE DISASSOCIATE %s",
 375                 txtaddr);
 376
 377         if (hwaddr_aton(txtaddr, addr))
 378                 return -1;
 379
 380         pos = os_strstr(txtaddr, " reason=");
 381         if (pos)
 382                 reason = atoi(pos + 8);
 383
 384         pos = os_strstr(txtaddr, " test=");
 385         if (pos) {
 386                 struct ieee80211_mgmt mgmt;
 387                 int encrypt;
 388                 if (hapd->driver->send_frame == NULL)
 389                         return -1;
 390                 pos += 6;
 391                 encrypt = atoi(pos);
 392                 os_memset(&mgmt, 0, sizeof(mgmt));
 393                 mgmt.frame_control = IEEE80211_FC(WLAN_FC_TYPE_MGMT,
 394                                                   WLAN_FC_STYPE_DISASSOC);
 395                 os_memcpy(mgmt.da, addr, ETH_ALEN);
 396                 os_memcpy(mgmt.sa, hapd->own_addr, ETH_ALEN);
 397                 os_memcpy(mgmt.bssid, hapd->own_addr, ETH_ALEN);
 398                 mgmt.u.disassoc.reason_code = host_to_le16(reason);
 399                 if (hapd->driver->send_frame(hapd->drv_priv, (u8 *) &mgmt,
 400                                              IEEE80211_HDRLEN +
 401                                              sizeof(mgmt.u.deauth),
 402                                              encrypt) < 0)
 403                         return -1;
 404                 return 0;
 405         }
 406
 407 #ifdef CONFIG_P2P_MANAGER
 408         pos = os_strstr(txtaddr, " p2p=");
 409         if (pos) {
 410                 return p2p_manager_disconnect(hapd, WLAN_FC_STYPE_DISASSOC,
 411                                               atoi(pos + 5), addr);
 412         }
 413 #endif /* CONFIG_P2P_MANAGER */
 414
 415         hostapd_drv_sta_disassoc(hapd, addr, reason);
 416         sta = ap_get_sta(hapd, addr);
 417         if (sta)
 418                 ap_sta_disassociate(hapd, sta, reason);
 419         else if (addr[0] == 0xff)
 420                 hostapd_free_stas(hapd);
 421
 422         return 0;
 423 }
 424
 425
 426 int hostapd_ctrl_iface_status(struct hostapd_data *hapd, char *buf,
 427                               size_t buflen)
 428 {
 429         struct hostapd_iface *iface = hapd->iface;
 430         int len = 0, ret;
 431         size_t i;
 432
 433         ret = os_snprintf(buf + len, buflen - len,
 434                           "state=%s\n"
 435                           "phy=%s\n"
 436                           "freq=%d\n"
 437                           "num_sta_non_erp=%d\n"
 438                           "num_sta_no_short_slot_time=%d\n"
 439                           "num_sta_no_short_preamble=%d\n"
 440                           "olbc=%d\n"
 441                           "num_sta_ht_no_gf=%d\n"
 442                           "num_sta_no_ht=%d\n"
 443                           "num_sta_ht_20_mhz=%d\n"
 444                           "num_sta_ht40_intolerant=%d\n"
 445                           "olbc_ht=%d\n"
 446                           "ht_op_mode=0x%x\n",
 447                           hostapd_state_text(iface->state),
 448                           iface->phy,
 449                           iface->freq,
 450                           iface->num_sta_non_erp,
 451                           iface->num_sta_no_short_slot_time,
 452                           iface->num_sta_no_short_preamble,
 453                           iface->olbc,
 454                           iface->num_sta_ht_no_gf,
 455                           iface->num_sta_no_ht,
 456                           iface->num_sta_ht_20mhz,
 457                           iface->num_sta_ht40_intolerant,
 458                           iface->olbc_ht,
 459                           iface->ht_op_mode);
 460         if (os_snprintf_error(buflen - len, ret))
 461                 return len;
 462         len += ret;
 463
 464         if (!iface->cac_started || !iface->dfs_cac_ms) {
 465                 ret = os_snprintf(buf + len, buflen - len,
 466                                   "cac_time_seconds=%d\n"
 467                                   "cac_time_left_seconds=N/A\n",
 468                                   iface->dfs_cac_ms / 1000);
 469         } else {
 470                 /* CAC started and CAC time set - calculate remaining time */
 471                 struct os_reltime now;
 472                 unsigned int left_time;
 473
 474                 os_reltime_age(&iface->dfs_cac_start, &now);
 475                 left_time = iface->dfs_cac_ms / 1000 - now.sec;
 476                 ret = os_snprintf(buf + len, buflen - len,
 477                                   "cac_time_seconds=%u\n"
 478                                   "cac_time_left_seconds=%u\n",
 479                                   iface->dfs_cac_ms / 1000,
 480                                   left_time);
 481         }
 482         if (os_snprintf_error(buflen - len, ret))
 483                 return len;
 484         len += ret;
 485
 486         ret = os_snprintf(buf + len, buflen - len,
 487                           "channel=%u\n"
 488                           "secondary_channel=%d\n"
 489                           "ieee80211n=%d\n"
 490                           "ieee80211ac=%d\n"
 491                           "vht_oper_chwidth=%d\n"
 492                           "vht_oper_centr_freq_seg0_idx=%d\n"
 493                           "vht_oper_centr_freq_seg1_idx=%d\n",
 494                           iface->conf->channel,
 495                           iface->conf->secondary_channel,
 496                           iface->conf->ieee80211n,
 497                           iface->conf->ieee80211ac,
 498                           iface->conf->vht_oper_chwidth,
 499                           iface->conf->vht_oper_centr_freq_seg0_idx,
 500                           iface->conf->vht_oper_centr_freq_seg1_idx);
 501         if (os_snprintf_error(buflen - len, ret))
 502                 return len;
 503         len += ret;
 504
 505         for (i = 0; i < iface->num_bss; i++) {
 506                 struct hostapd_data *bss = iface->bss[i];
 507                 ret = os_snprintf(buf + len, buflen - len,
 508                                   "bss[%d]=%s\n"
 509                                   "bssid[%d]=" MACSTR "\n"
 510                                   "ssid[%d]=%s\n"
 511                                   "num_sta[%d]=%d\n",
 512                                   (int) i, bss->conf->iface,
 513                                   (int) i, MAC2STR(bss->own_addr),
 514                                   (int) i,
 515                                   wpa_ssid_txt(bss->conf->ssid.ssid,
 516                                                bss->conf->ssid.ssid_len),
 517                                   (int) i, bss->num_sta);
 518                 if (os_snprintf_error(buflen - len, ret))
 519                         return len;
 520                 len += ret;
 521         }
 522
 523         return len;
 524 }
 525
 526
 527 int hostapd_parse_csa_settings(const char *pos,
 528                                struct csa_settings *settings)
 529 {
 530         char *end;
 531
 532         os_memset(settings, 0, sizeof(*settings));
 533         settings->cs_count = strtol(pos, &end, 10);
 534         if (pos == end) {
 535                 wpa_printf(MSG_ERROR, "chanswitch: invalid cs_count provided");
 536                 return -1;
 537         }
 538
 539         settings->freq_params.freq = atoi(end);
 540         if (settings->freq_params.freq == 0) {
 541                 wpa_printf(MSG_ERROR, "chanswitch: invalid freq provided");
 542                 return -1;
 543         }
 544
 545 #define SET_CSA_SETTING(str) \
 546         do { \
 547                 const char *pos2 = os_strstr(pos, " " #str "="); \
 548                 if (pos2) { \
 549                         pos2 += sizeof(" " #str "=") - 1; \
 550                         settings->freq_params.str = atoi(pos2); \
 551                 } \
 552         } while (0)
 553
 554         SET_CSA_SETTING(center_freq1);
 555         SET_CSA_SETTING(center_freq2);
 556         SET_CSA_SETTING(bandwidth);
 557         SET_CSA_SETTING(sec_channel_offset);
 558         settings->freq_params.ht_enabled = !!os_strstr(pos, " ht");
 559         settings->freq_params.vht_enabled = !!os_strstr(pos, " vht");
 560         settings->block_tx = !!os_strstr(pos, " blocktx");
 561 #undef SET_CSA_SETTING
 562
 563         return 0;
 564 }
 565
 566
 567 int hostapd_ctrl_iface_stop_ap(struct hostapd_data *hapd)
 568 {
 569         return hostapd_drv_stop_ap(hapd);
 570 }