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