src/ap/ctrl_iface_ap.c

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