hostapd/ctrl_iface.c

   1 /*
   2  * hostapd / UNIX domain socket -based control interface
   3  * Copyright (c) 2004-2010, Jouni Malinen <j@w1.fi>
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License version 2 as
   7  * published by the Free Software Foundation.
   8  *
   9  * Alternatively, this software may be distributed under the terms of BSD
  10  * license.
  11  *
  12  * See README and COPYING for more details.
  13  */
  14
  15 #include "utils/includes.h"
  16
  17 #ifndef CONFIG_NATIVE_WINDOWS
  18
  19 #include <sys/un.h>
  20 #include <sys/stat.h>
  21 #include <stddef.h>
  22
  23 #include "utils/common.h"
  24 #include "utils/eloop.h"
  25 #include "common/version.h"
  26 #include "common/ieee802_11_defs.h"
  27 #include "drivers/driver.h"
  28 #include "radius/radius_client.h"
  29 #include "ap/hostapd.h"
  30 #include "ap/ap_config.h"
  31 #include "ap/ieee802_1x.h"
  32 #include "ap/wpa_auth.h"
  33 #include "ap/ieee802_11.h"
  34 #include "ap/sta_info.h"
  35 #include "ap/accounting.h"
  36 #include "ap/wps_hostapd.h"
  37 #include "ap/ctrl_iface_ap.h"
  38 #include "ap/ap_drv_ops.h"
  39 #include "wps/wps_defs.h"
  40 #include "wps/wps.h"
  41 #include "ctrl_iface.h"
  42
  43
  44 struct wpa_ctrl_dst {
  45         struct wpa_ctrl_dst *next;
  46         struct sockaddr_un addr;
  47         socklen_t addrlen;
  48         int debug_level;
  49         int errors;
  50 };
  51
  52
  53 static void hostapd_ctrl_iface_send(struct hostapd_data *hapd, int level,
  54                                     const char *buf, size_t len);
  55
  56
  57 static int hostapd_ctrl_iface_attach(struct hostapd_data *hapd,
  58                                      struct sockaddr_un *from,
  59                                      socklen_t fromlen)
  60 {
  61         struct wpa_ctrl_dst *dst;
  62
  63         dst = os_zalloc(sizeof(*dst));
  64         if (dst == NULL)
  65                 return -1;
  66         os_memcpy(&dst->addr, from, sizeof(struct sockaddr_un));
  67         dst->addrlen = fromlen;
  68         dst->debug_level = MSG_INFO;
  69         dst->next = hapd->ctrl_dst;
  70         hapd->ctrl_dst = dst;
  71         wpa_hexdump(MSG_DEBUG, "CTRL_IFACE monitor attached",
  72                     (u8 *) from->sun_path,
  73                     fromlen - offsetof(struct sockaddr_un, sun_path));
  74         return 0;
  75 }
  76
  77
  78 static int hostapd_ctrl_iface_detach(struct hostapd_data *hapd,
  79                                      struct sockaddr_un *from,
  80                                      socklen_t fromlen)
  81 {
  82         struct wpa_ctrl_dst *dst, *prev = NULL;
  83
  84         dst = hapd->ctrl_dst;
  85         while (dst) {
  86                 if (fromlen == dst->addrlen &&
  87                     os_memcmp(from->sun_path, dst->addr.sun_path,
  88                               fromlen - offsetof(struct sockaddr_un, sun_path))
  89                     == 0) {
  90                         if (prev == NULL)
  91                                 hapd->ctrl_dst = dst->next;
  92                         else
  93                                 prev->next = dst->next;
  94                         os_free(dst);
  95                         wpa_hexdump(MSG_DEBUG, "CTRL_IFACE monitor detached",
  96                                     (u8 *) from->sun_path,
  97                                     fromlen -
  98                                     offsetof(struct sockaddr_un, sun_path));
  99                         return 0;
 100                 }
 101                 prev = dst;
 102                 dst = dst->next;
 103         }
 104         return -1;
 105 }
 106
 107
 108 static int hostapd_ctrl_iface_level(struct hostapd_data *hapd,
 109                                     struct sockaddr_un *from,
 110                                     socklen_t fromlen,
 111                                     char *level)
 112 {
 113         struct wpa_ctrl_dst *dst;
 114
 115         wpa_printf(MSG_DEBUG, "CTRL_IFACE LEVEL %s", level);
 116
 117         dst = hapd->ctrl_dst;
 118         while (dst) {
 119                 if (fromlen == dst->addrlen &&
 120                     os_memcmp(from->sun_path, dst->addr.sun_path,
 121                               fromlen - offsetof(struct sockaddr_un, sun_path))
 122                     == 0) {
 123                         wpa_hexdump(MSG_DEBUG, "CTRL_IFACE changed monitor "
 124                                     "level", (u8 *) from->sun_path, fromlen -
 125                                     offsetof(struct sockaddr_un, sun_path));
 126                         dst->debug_level = atoi(level);
 127                         return 0;
 128                 }
 129                 dst = dst->next;
 130         }
 131
 132         return -1;
 133 }
 134
 135
 136 static int hostapd_ctrl_iface_new_sta(struct hostapd_data *hapd,
 137                                       const char *txtaddr)
 138 {
 139         u8 addr[ETH_ALEN];
 140         struct sta_info *sta;
 141
 142         wpa_printf(MSG_DEBUG, "CTRL_IFACE NEW_STA %s", txtaddr);
 143
 144         if (hwaddr_aton(txtaddr, addr))
 145                 return -1;
 146
 147         sta = ap_get_sta(hapd, addr);
 148         if (sta)
 149                 return 0;
 150
 151         wpa_printf(MSG_DEBUG, "Add new STA " MACSTR " based on ctrl_iface "
 152                    "notification", MAC2STR(addr));
 153         sta = ap_sta_add(hapd, addr);
 154         if (sta == NULL)
 155                 return -1;
 156
 157         hostapd_new_assoc_sta(hapd, sta, 0);
 158         return 0;
 159 }
 160
 161
 162 #ifdef CONFIG_P2P_MANAGER
 163 static int p2p_manager_disconnect(struct hostapd_data *hapd, u16 stype,
 164                                   u8 minor_reason_code, const u8 *addr)
 165 {
 166         struct ieee80211_mgmt *mgmt;
 167         int ret;
 168         u8 *pos;
 169
 170         if (hapd->driver->send_frame == NULL)
 171                 return -1;
 172
 173         mgmt = os_zalloc(sizeof(*mgmt) + 100);
 174         if (mgmt == NULL)
 175                 return -1;
 176
 177         wpa_printf(MSG_DEBUG, "P2P: Disconnect STA " MACSTR " with minor "
 178                    "reason code %u (stype=%u)",
 179                    MAC2STR(addr), minor_reason_code, stype);
 180
 181         mgmt->frame_control = IEEE80211_FC(WLAN_FC_TYPE_MGMT, stype);
 182         os_memcpy(mgmt->da, addr, ETH_ALEN);
 183         os_memcpy(mgmt->sa, hapd->own_addr, ETH_ALEN);
 184         os_memcpy(mgmt->bssid, hapd->own_addr, ETH_ALEN);
 185         if (stype == WLAN_FC_STYPE_DEAUTH) {
 186                 mgmt->u.deauth.reason_code =
 187                         host_to_le16(WLAN_REASON_PREV_AUTH_NOT_VALID);
 188                 pos = (u8 *) (&mgmt->u.deauth.reason_code + 1);
 189         } else {
 190                 mgmt->u.disassoc.reason_code =
 191                         host_to_le16(WLAN_REASON_PREV_AUTH_NOT_VALID);
 192                 pos = (u8 *) (&mgmt->u.disassoc.reason_code + 1);
 193         }
 194
 195         *pos++ = WLAN_EID_VENDOR_SPECIFIC;
 196         *pos++ = 4 + 3 + 1;
 197         WPA_PUT_BE24(pos, OUI_WFA);
 198         pos += 3;
 199         *pos++ = P2P_OUI_TYPE;
 200
 201         *pos++ = P2P_ATTR_MINOR_REASON_CODE;
 202         WPA_PUT_LE16(pos, 1);
 203         pos += 2;
 204         *pos++ = minor_reason_code;
 205
 206         ret = hapd->driver->send_frame(hapd->drv_priv, (u8 *) mgmt,
 207                                        pos - (u8 *) mgmt, 1);
 208         os_free(mgmt);
 209
 210         return ret < 0 ? -1 : 0;
 211 }
 212 #endif /* CONFIG_P2P_MANAGER */
 213
 214
 215 static int hostapd_ctrl_iface_deauthenticate(struct hostapd_data *hapd,
 216                                              const char *txtaddr)
 217 {
 218         u8 addr[ETH_ALEN];
 219         struct sta_info *sta;
 220         const char *pos;
 221
 222         wpa_printf(MSG_DEBUG, "CTRL_IFACE DEAUTHENTICATE %s", txtaddr);
 223
 224         if (hwaddr_aton(txtaddr, addr))
 225                 return -1;
 226
 227         pos = os_strstr(txtaddr, " test=");
 228         if (pos) {
 229                 struct ieee80211_mgmt mgmt;
 230                 int encrypt;
 231                 if (hapd->driver->send_frame == NULL)
 232                         return -1;
 233                 pos += 6;
 234                 encrypt = atoi(pos);
 235                 os_memset(&mgmt, 0, sizeof(mgmt));
 236                 mgmt.frame_control = IEEE80211_FC(WLAN_FC_TYPE_MGMT,
 237                                                   WLAN_FC_STYPE_DEAUTH);
 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                 mgmt.u.deauth.reason_code =
 242                         host_to_le16(WLAN_REASON_PREV_AUTH_NOT_VALID);
 243                 if (hapd->driver->send_frame(hapd->drv_priv, (u8 *) &mgmt,
 244                                              IEEE80211_HDRLEN +
 245                                              sizeof(mgmt.u.deauth),
 246                                              encrypt) < 0)
 247                         return -1;
 248                 return 0;
 249         }
 250
 251 #ifdef CONFIG_P2P_MANAGER
 252         pos = os_strstr(txtaddr, " p2p=");
 253         if (pos) {
 254                 return p2p_manager_disconnect(hapd, WLAN_FC_STYPE_DEAUTH,
 255                                               atoi(pos + 5), addr);
 256         }
 257 #endif /* CONFIG_P2P_MANAGER */
 258
 259         hostapd_drv_sta_deauth(hapd, addr, WLAN_REASON_PREV_AUTH_NOT_VALID);
 260         sta = ap_get_sta(hapd, addr);
 261         if (sta)
 262                 ap_sta_deauthenticate(hapd, sta,
 263                                       WLAN_REASON_PREV_AUTH_NOT_VALID);
 264         else if (addr[0] == 0xff)
 265                 hostapd_free_stas(hapd);
 266
 267         return 0;
 268 }
 269
 270
 271 static int hostapd_ctrl_iface_disassociate(struct hostapd_data *hapd,
 272                                            const char *txtaddr)
 273 {
 274         u8 addr[ETH_ALEN];
 275         struct sta_info *sta;
 276         const char *pos;
 277
 278         wpa_printf(MSG_DEBUG, "CTRL_IFACE DISASSOCIATE %s", txtaddr);
 279
 280         if (hwaddr_aton(txtaddr, addr))
 281                 return -1;
 282
 283         pos = os_strstr(txtaddr, " test=");
 284         if (pos) {
 285                 struct ieee80211_mgmt mgmt;
 286                 int encrypt;
 287                 if (hapd->driver->send_frame == NULL)
 288                         return -1;
 289                 pos += 6;
 290                 encrypt = atoi(pos);
 291                 os_memset(&mgmt, 0, sizeof(mgmt));
 292                 mgmt.frame_control = IEEE80211_FC(WLAN_FC_TYPE_MGMT,
 293                                                   WLAN_FC_STYPE_DISASSOC);
 294                 os_memcpy(mgmt.da, addr, ETH_ALEN);
 295                 os_memcpy(mgmt.sa, hapd->own_addr, ETH_ALEN);
 296                 os_memcpy(mgmt.bssid, hapd->own_addr, ETH_ALEN);
 297                 mgmt.u.disassoc.reason_code =
 298                         host_to_le16(WLAN_REASON_PREV_AUTH_NOT_VALID);
 299                 if (hapd->driver->send_frame(hapd->drv_priv, (u8 *) &mgmt,
 300                                              IEEE80211_HDRLEN +
 301                                              sizeof(mgmt.u.deauth),
 302                                              encrypt) < 0)
 303                         return -1;
 304                 return 0;
 305         }
 306
 307 #ifdef CONFIG_P2P_MANAGER
 308         pos = os_strstr(txtaddr, " p2p=");
 309         if (pos) {
 310                 return p2p_manager_disconnect(hapd, WLAN_FC_STYPE_DISASSOC,
 311                                               atoi(pos + 5), addr);
 312         }
 313 #endif /* CONFIG_P2P_MANAGER */
 314
 315         hostapd_drv_sta_disassoc(hapd, addr, WLAN_REASON_PREV_AUTH_NOT_VALID);
 316         sta = ap_get_sta(hapd, addr);
 317         if (sta)
 318                 ap_sta_disassociate(hapd, sta,
 319                                     WLAN_REASON_PREV_AUTH_NOT_VALID);
 320         else if (addr[0] == 0xff)
 321                 hostapd_free_stas(hapd);
 322
 323         return 0;
 324 }
 325
 326
 327 #ifdef CONFIG_IEEE80211W
 328 #ifdef NEED_AP_MLME
 329 static int hostapd_ctrl_iface_sa_query(struct hostapd_data *hapd,
 330                                        const char *txtaddr)
 331 {
 332         u8 addr[ETH_ALEN];
 333         u8 trans_id[WLAN_SA_QUERY_TR_ID_LEN];
 334
 335         wpa_printf(MSG_DEBUG, "CTRL_IFACE SA_QUERY %s", txtaddr);
 336
 337         if (hwaddr_aton(txtaddr, addr) ||
 338             os_get_random(trans_id, WLAN_SA_QUERY_TR_ID_LEN) < 0)
 339                 return -1;
 340
 341         ieee802_11_send_sa_query_req(hapd, addr, trans_id);
 342
 343         return 0;
 344 }
 345 #endif /* NEED_AP_MLME */
 346 #endif /* CONFIG_IEEE80211W */
 347
 348
 349 #ifdef CONFIG_WPS
 350 static int hostapd_ctrl_iface_wps_pin(struct hostapd_data *hapd, char *txt)
 351 {
 352         char *pin = os_strchr(txt, ' ');
 353         char *timeout_txt;
 354         int timeout;
 355         u8 addr_buf[ETH_ALEN], *addr = NULL;
 356         char *pos;
 357
 358         if (pin == NULL)
 359                 return -1;
 360         *pin++ = '\0';
 361
 362         timeout_txt = os_strchr(pin, ' ');
 363         if (timeout_txt) {
 364                 *timeout_txt++ = '\0';
 365                 timeout = atoi(timeout_txt);
 366                 pos = os_strchr(timeout_txt, ' ');
 367                 if (pos) {
 368                         *pos++ = '\0';
 369                         if (hwaddr_aton(pos, addr_buf) == 0)
 370                                 addr = addr_buf;
 371                 }
 372         } else
 373                 timeout = 0;
 374
 375         return hostapd_wps_add_pin(hapd, addr, txt, pin, timeout);
 376 }
 377
 378
 379 static int hostapd_ctrl_iface_wps_check_pin(
 380         struct hostapd_data *hapd, char *cmd, char *buf, size_t buflen)
 381 {
 382         char pin[9];
 383         size_t len;
 384         char *pos;
 385         int ret;
 386
 387         wpa_hexdump_ascii_key(MSG_DEBUG, "WPS_CHECK_PIN",
 388                               (u8 *) cmd, os_strlen(cmd));
 389         for (pos = cmd, len = 0; *pos != '\0'; pos++) {
 390                 if (*pos < '0' || *pos > '9')
 391                         continue;
 392                 pin[len++] = *pos;
 393                 if (len == 9) {
 394                         wpa_printf(MSG_DEBUG, "WPS: Too long PIN");
 395                         return -1;
 396                 }
 397         }
 398         if (len != 4 && len != 8) {
 399                 wpa_printf(MSG_DEBUG, "WPS: Invalid PIN length %d", (int) len);
 400                 return -1;
 401         }
 402         pin[len] = '\0';
 403
 404         if (len == 8) {
 405                 unsigned int pin_val;
 406                 pin_val = atoi(pin);
 407                 if (!wps_pin_valid(pin_val)) {
 408                         wpa_printf(MSG_DEBUG, "WPS: Invalid checksum digit");
 409                         ret = os_snprintf(buf, buflen, "FAIL-CHECKSUM\n");
 410                         if (ret < 0 || (size_t) ret >= buflen)
 411                                 return -1;
 412                         return ret;
 413                 }
 414         }
 415
 416         ret = os_snprintf(buf, buflen, "%s", pin);
 417         if (ret < 0 || (size_t) ret >= buflen)
 418                 return -1;
 419
 420         return ret;
 421 }
 422
 423
 424 #ifdef CONFIG_WPS_OOB
 425 static int hostapd_ctrl_iface_wps_oob(struct hostapd_data *hapd, char *txt)
 426 {
 427         char *path, *method, *name;
 428
 429         path = os_strchr(txt, ' ');
 430         if (path == NULL)
 431                 return -1;
 432         *path++ = '\0';
 433
 434         method = os_strchr(path, ' ');
 435         if (method == NULL)
 436                 return -1;
 437         *method++ = '\0';
 438
 439         name = os_strchr(method, ' ');
 440         if (name != NULL)
 441                 *name++ = '\0';
 442
 443         return hostapd_wps_start_oob(hapd, txt, path, method, name);
 444 }
 445 #endif /* CONFIG_WPS_OOB */
 446
 447
 448 static int hostapd_ctrl_iface_wps_ap_pin(struct hostapd_data *hapd, char *txt,
 449                                          char *buf, size_t buflen)
 450 {
 451         int timeout = 300;
 452         char *pos;
 453         const char *pin_txt;
 454
 455         pos = os_strchr(txt, ' ');
 456         if (pos)
 457                 *pos++ = '\0';
 458
 459         if (os_strcmp(txt, "disable") == 0) {
 460                 hostapd_wps_ap_pin_disable(hapd);
 461                 return os_snprintf(buf, buflen, "OK\n");
 462         }
 463
 464         if (os_strcmp(txt, "random") == 0) {
 465                 if (pos)
 466                         timeout = atoi(pos);
 467                 pin_txt = hostapd_wps_ap_pin_random(hapd, timeout);
 468                 if (pin_txt == NULL)
 469                         return -1;
 470                 return os_snprintf(buf, buflen, "%s", pin_txt);
 471         }
 472
 473         if (os_strcmp(txt, "get") == 0) {
 474                 pin_txt = hostapd_wps_ap_pin_get(hapd);
 475                 if (pin_txt == NULL)
 476                         return -1;
 477                 return os_snprintf(buf, buflen, "%s", pin_txt);
 478         }
 479
 480         if (os_strcmp(txt, "set") == 0) {
 481                 char *pin;
 482                 if (pos == NULL)
 483                         return -1;
 484                 pin = pos;
 485                 pos = os_strchr(pos, ' ');
 486                 if (pos) {
 487                         *pos++ = '\0';
 488                         timeout = atoi(pos);
 489                 }
 490                 if (os_strlen(pin) > buflen)
 491                         return -1;
 492                 if (hostapd_wps_ap_pin_set(hapd, pin, timeout) < 0)
 493                         return -1;
 494                 return os_snprintf(buf, buflen, "%s", pin);
 495         }
 496
 497         return -1;
 498 }
 499
 500
 501 static int hostapd_ctrl_iface_wps_config(struct hostapd_data *hapd, char *txt)
 502 {
 503         char *pos;
 504         char *ssid, *auth, *encr = NULL, *key = NULL;
 505
 506         ssid = txt;
 507         pos = os_strchr(txt, ' ');
 508         if (!pos)
 509                 return -1;
 510         *pos++ = '\0';
 511
 512         auth = pos;
 513         pos = os_strchr(pos, ' ');
 514         if (pos) {
 515                 *pos++ = '\0';
 516                 encr = pos;
 517                 pos = os_strchr(pos, ' ');
 518                 if (pos) {
 519                         *pos++ = '\0';
 520                         key = pos;
 521                 }
 522         }
 523
 524         return hostapd_wps_config_ap(hapd, ssid, auth, encr, key);
 525 }
 526 #endif /* CONFIG_WPS */
 527
 528
 529 static int hostapd_ctrl_iface_get_config(struct hostapd_data *hapd,
 530                                          char *buf, size_t buflen)
 531 {
 532         int ret;
 533         char *pos, *end;
 534
 535         pos = buf;
 536         end = buf + buflen;
 537
 538         ret = os_snprintf(pos, end - pos, "bssid=" MACSTR "\n"
 539                           "ssid=%s\n",
 540                           MAC2STR(hapd->own_addr),
 541                           hapd->conf->ssid.ssid);
 542         if (ret < 0 || ret >= end - pos)
 543                 return pos - buf;
 544         pos += ret;
 545
 546 #ifdef CONFIG_WPS
 547         ret = os_snprintf(pos, end - pos, "wps_state=%s\n",
 548                           hapd->conf->wps_state == 0 ? "disabled" :
 549                           (hapd->conf->wps_state == 1 ? "not configured" :
 550                            "configured"));
 551         if (ret < 0 || ret >= end - pos)
 552                 return pos - buf;
 553         pos += ret;
 554
 555         if (hapd->conf->wps_state && hapd->conf->wpa &&
 556             hapd->conf->ssid.wpa_passphrase) {
 557                 ret = os_snprintf(pos, end - pos, "passphrase=%s\n",
 558                                   hapd->conf->ssid.wpa_passphrase);
 559                 if (ret < 0 || ret >= end - pos)
 560                         return pos - buf;
 561                 pos += ret;
 562         }
 563
 564         if (hapd->conf->wps_state && hapd->conf->wpa &&
 565             hapd->conf->ssid.wpa_psk &&
 566             hapd->conf->ssid.wpa_psk->group) {
 567                 char hex[PMK_LEN * 2 + 1];
 568                 wpa_snprintf_hex(hex, sizeof(hex),
 569                                  hapd->conf->ssid.wpa_psk->psk, PMK_LEN);
 570                 ret = os_snprintf(pos, end - pos, "psk=%s\n", hex);
 571                 if (ret < 0 || ret >= end - pos)
 572                         return pos - buf;
 573                 pos += ret;
 574         }
 575 #endif /* CONFIG_WPS */
 576
 577         if (hapd->conf->wpa && hapd->conf->wpa_key_mgmt) {
 578                 ret = os_snprintf(pos, end - pos, "key_mgmt=");
 579                 if (ret < 0 || ret >= end - pos)
 580                         return pos - buf;
 581                 pos += ret;
 582
 583                 if (hapd->conf->wpa_key_mgmt & WPA_KEY_MGMT_PSK) {
 584                         ret = os_snprintf(pos, end - pos, "WPA-PSK ");
 585                         if (ret < 0 || ret >= end - pos)
 586                                 return pos - buf;
 587                         pos += ret;
 588                 }
 589                 if (hapd->conf->wpa_key_mgmt & WPA_KEY_MGMT_IEEE8021X) {
 590                         ret = os_snprintf(pos, end - pos, "WPA-EAP ");
 591                         if (ret < 0 || ret >= end - pos)
 592                                 return pos - buf;
 593                         pos += ret;
 594                 }
 595 #ifdef CONFIG_IEEE80211R
 596                 if (hapd->conf->wpa_key_mgmt & WPA_KEY_MGMT_FT_PSK) {
 597                         ret = os_snprintf(pos, end - pos, "FT-PSK ");
 598                         if (ret < 0 || ret >= end - pos)
 599                                 return pos - buf;
 600                         pos += ret;
 601                 }
 602                 if (hapd->conf->wpa_key_mgmt & WPA_KEY_MGMT_FT_IEEE8021X) {
 603                         ret = os_snprintf(pos, end - pos, "FT-EAP ");
 604                         if (ret < 0 || ret >= end - pos)
 605                                 return pos - buf;
 606                         pos += ret;
 607                 }
 608 #endif /* CONFIG_IEEE80211R */
 609 #ifdef CONFIG_IEEE80211W
 610                 if (hapd->conf->wpa_key_mgmt & WPA_KEY_MGMT_PSK_SHA256) {
 611                         ret = os_snprintf(pos, end - pos, "WPA-PSK-SHA256 ");
 612                         if (ret < 0 || ret >= end - pos)
 613                                 return pos - buf;
 614                         pos += ret;
 615                 }
 616                 if (hapd->conf->wpa_key_mgmt & WPA_KEY_MGMT_IEEE8021X_SHA256) {
 617                         ret = os_snprintf(pos, end - pos, "WPA-EAP-SHA256 ");
 618                         if (ret < 0 || ret >= end - pos)
 619                                 return pos - buf;
 620                         pos += ret;
 621                 }
 622 #endif /* CONFIG_IEEE80211W */
 623
 624                 ret = os_snprintf(pos, end - pos, "\n");
 625                 if (ret < 0 || ret >= end - pos)
 626                         return pos - buf;
 627                 pos += ret;
 628         }
 629
 630         if (hapd->conf->wpa && hapd->conf->wpa_group == WPA_CIPHER_CCMP) {
 631                 ret = os_snprintf(pos, end - pos, "group_cipher=CCMP\n");
 632                 if (ret < 0 || ret >= end - pos)
 633                         return pos - buf;
 634                 pos += ret;
 635         } else if (hapd->conf->wpa &&
 636                    hapd->conf->wpa_group == WPA_CIPHER_TKIP) {
 637                 ret = os_snprintf(pos, end - pos, "group_cipher=TKIP\n");
 638                 if (ret < 0 || ret >= end - pos)
 639                         return pos - buf;
 640                 pos += ret;
 641         }
 642
 643         if ((hapd->conf->wpa & WPA_PROTO_RSN) && hapd->conf->rsn_pairwise) {
 644                 ret = os_snprintf(pos, end - pos, "rsn_pairwise_cipher=");
 645                 if (ret < 0 || ret >= end - pos)
 646                         return pos - buf;
 647                 pos += ret;
 648
 649                 if (hapd->conf->rsn_pairwise & WPA_CIPHER_CCMP) {
 650                         ret = os_snprintf(pos, end - pos, "CCMP ");
 651                         if (ret < 0 || ret >= end - pos)
 652                                 return pos - buf;
 653                         pos += ret;
 654                 }
 655                 if (hapd->conf->rsn_pairwise & WPA_CIPHER_TKIP) {
 656                         ret = os_snprintf(pos, end - pos, "TKIP ");
 657                         if (ret < 0 || ret >= end - pos)
 658                                 return pos - buf;
 659                         pos += ret;
 660                 }
 661
 662                 ret = os_snprintf(pos, end - pos, "\n");
 663                 if (ret < 0 || ret >= end - pos)
 664                         return pos - buf;
 665                 pos += ret;
 666         }
 667
 668         if ((hapd->conf->wpa & WPA_PROTO_WPA) && hapd->conf->wpa_pairwise) {
 669                 ret = os_snprintf(pos, end - pos, "wpa_pairwise_cipher=");
 670                 if (ret < 0 || ret >= end - pos)
 671                         return pos - buf;
 672                 pos += ret;
 673
 674                 if (hapd->conf->wpa_pairwise & WPA_CIPHER_CCMP) {
 675                         ret = os_snprintf(pos, end - pos, "CCMP ");
 676                         if (ret < 0 || ret >= end - pos)
 677                                 return pos - buf;
 678                         pos += ret;
 679                 }
 680                 if (hapd->conf->wpa_pairwise & WPA_CIPHER_TKIP) {
 681                         ret = os_snprintf(pos, end - pos, "TKIP ");
 682                         if (ret < 0 || ret >= end - pos)
 683                                 return pos - buf;
 684                         pos += ret;
 685                 }
 686
 687                 ret = os_snprintf(pos, end - pos, "\n");
 688                 if (ret < 0 || ret >= end - pos)
 689                         return pos - buf;
 690                 pos += ret;
 691         }
 692
 693         return pos - buf;
 694 }
 695
 696
 697 static int hostapd_ctrl_iface_set(struct hostapd_data *hapd, char *cmd)
 698 {
 699         char *value;
 700         int ret = 0;
 701
 702         value = os_strchr(cmd, ' ');
 703         if (value == NULL)
 704                 return -1;
 705         *value++ = '\0';
 706
 707         wpa_printf(MSG_DEBUG, "CTRL_IFACE SET '%s'='%s'", cmd, value);
 708         if (0) {
 709 #ifdef CONFIG_WPS_TESTING
 710         } else if (os_strcasecmp(cmd, "wps_version_number") == 0) {
 711                 long int val;
 712                 val = strtol(value, NULL, 0);
 713                 if (val < 0 || val > 0xff) {
 714                         ret = -1;
 715                         wpa_printf(MSG_DEBUG, "WPS: Invalid "
 716                                    "wps_version_number %ld", val);
 717                 } else {
 718                         wps_version_number = val;
 719                         wpa_printf(MSG_DEBUG, "WPS: Testing - force WPS "
 720                                    "version %u.%u",
 721                                    (wps_version_number & 0xf0) >> 4,
 722                                    wps_version_number & 0x0f);
 723                         hostapd_wps_update_ie(hapd);
 724                 }
 725         } else if (os_strcasecmp(cmd, "wps_testing_dummy_cred") == 0) {
 726                 wps_testing_dummy_cred = atoi(value);
 727                 wpa_printf(MSG_DEBUG, "WPS: Testing - dummy_cred=%d",
 728                            wps_testing_dummy_cred);
 729 #endif /* CONFIG_WPS_TESTING */
 730         } else {
 731                 ret = -1;
 732         }
 733
 734         return ret;
 735 }
 736
 737
 738 static int hostapd_ctrl_iface_get(struct hostapd_data *hapd, char *cmd,
 739                                   char *buf, size_t buflen)
 740 {
 741         int res;
 742
 743         wpa_printf(MSG_DEBUG, "CTRL_IFACE GET '%s'", cmd);
 744
 745         if (os_strcmp(cmd, "version") == 0) {
 746                 res = os_snprintf(buf, buflen, "%s", VERSION_STR);
 747                 if (res < 0 || (unsigned int) res >= buflen)
 748                         return -1;
 749                 return res;
 750         }
 751
 752         return -1;
 753 }
 754
 755
 756 static void hostapd_ctrl_iface_receive(int sock, void *eloop_ctx,
 757                                        void *sock_ctx)
 758 {
 759         struct hostapd_data *hapd = eloop_ctx;
 760         char buf[256];
 761         int res;
 762         struct sockaddr_un from;
 763         socklen_t fromlen = sizeof(from);
 764         char *reply;
 765         const int reply_size = 4096;
 766         int reply_len;
 767         int level = MSG_DEBUG;
 768
 769         res = recvfrom(sock, buf, sizeof(buf) - 1, 0,
 770                        (struct sockaddr *) &from, &fromlen);
 771         if (res < 0) {
 772                 perror("recvfrom(ctrl_iface)");
 773                 return;
 774         }
 775         buf[res] = '\0';
 776         if (os_strcmp(buf, "PING") == 0)
 777                 level = MSG_EXCESSIVE;
 778         wpa_hexdump_ascii(level, "RX ctrl_iface", (u8 *) buf, res);
 779
 780         reply = os_malloc(reply_size);
 781         if (reply == NULL) {
 782                 sendto(sock, "FAIL\n", 5, 0, (struct sockaddr *) &from,
 783                        fromlen);
 784                 return;
 785         }
 786
 787         os_memcpy(reply, "OK\n", 3);
 788         reply_len = 3;
 789
 790         if (os_strcmp(buf, "PING") == 0) {
 791                 os_memcpy(reply, "PONG\n", 5);
 792                 reply_len = 5;
 793         } else if (os_strncmp(buf, "RELOG", 5) == 0) {
 794                 if (wpa_debug_reopen_file() < 0)
 795                         reply_len = -1;
 796         } else if (os_strcmp(buf, "MIB") == 0) {
 797                 reply_len = ieee802_11_get_mib(hapd, reply, reply_size);
 798                 if (reply_len >= 0) {
 799                         res = wpa_get_mib(hapd->wpa_auth, reply + reply_len,
 800                                           reply_size - reply_len);
 801                         if (res < 0)
 802                                 reply_len = -1;
 803                         else
 804                                 reply_len += res;
 805                 }
 806                 if (reply_len >= 0) {
 807                         res = ieee802_1x_get_mib(hapd, reply + reply_len,
 808                                                  reply_size - reply_len);
 809                         if (res < 0)
 810                                 reply_len = -1;
 811                         else
 812                                 reply_len += res;
 813                 }
 814 #ifndef CONFIG_NO_RADIUS
 815                 if (reply_len >= 0) {
 816                         res = radius_client_get_mib(hapd->radius,
 817                                                     reply + reply_len,
 818                                                     reply_size - reply_len);
 819                         if (res < 0)
 820                                 reply_len = -1;
 821                         else
 822                                 reply_len += res;
 823                 }
 824 #endif /* CONFIG_NO_RADIUS */
 825         } else if (os_strcmp(buf, "STA-FIRST") == 0) {
 826                 reply_len = hostapd_ctrl_iface_sta_first(hapd, reply,
 827                                                          reply_size);
 828         } else if (os_strncmp(buf, "STA ", 4) == 0) {
 829                 reply_len = hostapd_ctrl_iface_sta(hapd, buf + 4, reply,
 830                                                    reply_size);
 831         } else if (os_strncmp(buf, "STA-NEXT ", 9) == 0) {
 832                 reply_len = hostapd_ctrl_iface_sta_next(hapd, buf + 9, reply,
 833                                                         reply_size);
 834         } else if (os_strcmp(buf, "ATTACH") == 0) {
 835                 if (hostapd_ctrl_iface_attach(hapd, &from, fromlen))
 836                         reply_len = -1;
 837         } else if (os_strcmp(buf, "DETACH") == 0) {
 838                 if (hostapd_ctrl_iface_detach(hapd, &from, fromlen))
 839                         reply_len = -1;
 840         } else if (os_strncmp(buf, "LEVEL ", 6) == 0) {
 841                 if (hostapd_ctrl_iface_level(hapd, &from, fromlen,
 842                                                     buf + 6))
 843                         reply_len = -1;
 844         } else if (os_strncmp(buf, "NEW_STA ", 8) == 0) {
 845                 if (hostapd_ctrl_iface_new_sta(hapd, buf + 8))
 846                         reply_len = -1;
 847         } else if (os_strncmp(buf, "DEAUTHENTICATE ", 15) == 0) {
 848                 if (hostapd_ctrl_iface_deauthenticate(hapd, buf + 15))
 849                         reply_len = -1;
 850         } else if (os_strncmp(buf, "DISASSOCIATE ", 13) == 0) {
 851                 if (hostapd_ctrl_iface_disassociate(hapd, buf + 13))
 852                         reply_len = -1;
 853 #ifdef CONFIG_IEEE80211W
 854 #ifdef NEED_AP_MLME
 855         } else if (os_strncmp(buf, "SA_QUERY ", 9) == 0) {
 856                 if (hostapd_ctrl_iface_sa_query(hapd, buf + 9))
 857                         reply_len = -1;
 858 #endif /* NEED_AP_MLME */
 859 #endif /* CONFIG_IEEE80211W */
 860 #ifdef CONFIG_WPS
 861         } else if (os_strncmp(buf, "WPS_PIN ", 8) == 0) {
 862                 if (hostapd_ctrl_iface_wps_pin(hapd, buf + 8))
 863                         reply_len = -1;
 864         } else if (os_strncmp(buf, "WPS_CHECK_PIN ", 14) == 0) {
 865                 reply_len = hostapd_ctrl_iface_wps_check_pin(
 866                         hapd, buf + 14, reply, reply_size);
 867         } else if (os_strcmp(buf, "WPS_PBC") == 0) {
 868                 if (hostapd_wps_button_pushed(hapd))
 869                         reply_len = -1;
 870 #ifdef CONFIG_WPS_OOB
 871         } else if (os_strncmp(buf, "WPS_OOB ", 8) == 0) {
 872                 if (hostapd_ctrl_iface_wps_oob(hapd, buf + 8))
 873                         reply_len = -1;
 874 #endif /* CONFIG_WPS_OOB */
 875         } else if (os_strncmp(buf, "WPS_AP_PIN ", 11) == 0) {
 876                 reply_len = hostapd_ctrl_iface_wps_ap_pin(hapd, buf + 11,
 877                                                           reply, reply_size);
 878         } else if (os_strncmp(buf, "WPS_CONFIG ", 11) == 0) {
 879                 if (hostapd_ctrl_iface_wps_config(hapd, buf + 11) < 0)
 880                         reply_len = -1;
 881 #endif /* CONFIG_WPS */
 882         } else if (os_strcmp(buf, "GET_CONFIG") == 0) {
 883                 reply_len = hostapd_ctrl_iface_get_config(hapd, reply,
 884                                                           reply_size);
 885         } else if (os_strncmp(buf, "SET ", 4) == 0) {
 886                 if (hostapd_ctrl_iface_set(hapd, buf + 4))
 887                         reply_len = -1;
 888         } else if (os_strncmp(buf, "GET ", 4) == 0) {
 889                 reply_len = hostapd_ctrl_iface_get(hapd, buf + 4, reply,
 890                                                    reply_size);
 891         } else {
 892                 os_memcpy(reply, "UNKNOWN COMMAND\n", 16);
 893                 reply_len = 16;
 894         }
 895
 896         if (reply_len < 0) {
 897                 os_memcpy(reply, "FAIL\n", 5);
 898                 reply_len = 5;
 899         }
 900         sendto(sock, reply, reply_len, 0, (struct sockaddr *) &from, fromlen);
 901         os_free(reply);
 902 }
 903
 904
 905 static char * hostapd_ctrl_iface_path(struct hostapd_data *hapd)
 906 {
 907         char *buf;
 908         size_t len;
 909
 910         if (hapd->conf->ctrl_interface == NULL)
 911                 return NULL;
 912
 913         len = os_strlen(hapd->conf->ctrl_interface) +
 914                 os_strlen(hapd->conf->iface) + 2;
 915         buf = os_malloc(len);
 916         if (buf == NULL)
 917                 return NULL;
 918
 919         os_snprintf(buf, len, "%s/%s",
 920                     hapd->conf->ctrl_interface, hapd->conf->iface);
 921         buf[len - 1] = '\0';
 922         return buf;
 923 }
 924
 925
 926 static void hostapd_ctrl_iface_msg_cb(void *ctx, int level,
 927                                       const char *txt, size_t len)
 928 {
 929         struct hostapd_data *hapd = ctx;
 930         if (hapd == NULL)
 931                 return;
 932         hostapd_ctrl_iface_send(hapd, level, txt, len);
 933 }
 934
 935
 936 int hostapd_ctrl_iface_init(struct hostapd_data *hapd)
 937 {
 938         struct sockaddr_un addr;
 939         int s = -1;
 940         char *fname = NULL;
 941
 942         hapd->ctrl_sock = -1;
 943
 944         if (hapd->conf->ctrl_interface == NULL)
 945                 return 0;
 946
 947         if (mkdir(hapd->conf->ctrl_interface, S_IRWXU | S_IRWXG) < 0) {
 948                 if (errno == EEXIST) {
 949                         wpa_printf(MSG_DEBUG, "Using existing control "
 950                                    "interface directory.");
 951                 } else {
 952                         perror("mkdir[ctrl_interface]");
 953                         goto fail;
 954                 }
 955         }
 956
 957         if (hapd->conf->ctrl_interface_gid_set &&
 958             chown(hapd->conf->ctrl_interface, 0,
 959                   hapd->conf->ctrl_interface_gid) < 0) {
 960                 perror("chown[ctrl_interface]");
 961                 return -1;
 962         }
 963
 964         if (os_strlen(hapd->conf->ctrl_interface) + 1 +
 965             os_strlen(hapd->conf->iface) >= sizeof(addr.sun_path))
 966                 goto fail;
 967
 968         s = socket(PF_UNIX, SOCK_DGRAM, 0);
 969         if (s < 0) {
 970                 perror("socket(PF_UNIX)");
 971                 goto fail;
 972         }
 973
 974         os_memset(&addr, 0, sizeof(addr));
 975 #ifdef __FreeBSD__
 976         addr.sun_len = sizeof(addr);
 977 #endif /* __FreeBSD__ */
 978         addr.sun_family = AF_UNIX;
 979         fname = hostapd_ctrl_iface_path(hapd);
 980         if (fname == NULL)
 981                 goto fail;
 982         os_strlcpy(addr.sun_path, fname, sizeof(addr.sun_path));
 983         if (bind(s, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
 984                 wpa_printf(MSG_DEBUG, "ctrl_iface bind(PF_UNIX) failed: %s",
 985                            strerror(errno));
 986                 if (connect(s, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
 987                         wpa_printf(MSG_DEBUG, "ctrl_iface exists, but does not"
 988                                    " allow connections - assuming it was left"
 989                                    "over from forced program termination");
 990                         if (unlink(fname) < 0) {
 991                                 perror("unlink[ctrl_iface]");
 992                                 wpa_printf(MSG_ERROR, "Could not unlink "
 993                                            "existing ctrl_iface socket '%s'",
 994                                            fname);
 995                                 goto fail;
 996                         }
 997                         if (bind(s, (struct sockaddr *) &addr, sizeof(addr)) <
 998                             0) {
 999                                 perror("bind(PF_UNIX)");
1000                                 goto fail;
1001                         }
1002                         wpa_printf(MSG_DEBUG, "Successfully replaced leftover "
1003                                    "ctrl_iface socket '%s'", fname);
1004                 } else {
1005                         wpa_printf(MSG_INFO, "ctrl_iface exists and seems to "
1006                                    "be in use - cannot override it");
1007                         wpa_printf(MSG_INFO, "Delete '%s' manually if it is "
1008                                    "not used anymore", fname);
1009                         os_free(fname);
1010                         fname = NULL;
1011                         goto fail;
1012                 }
1013         }
1014
1015         if (hapd->conf->ctrl_interface_gid_set &&
1016             chown(fname, 0, hapd->conf->ctrl_interface_gid) < 0) {
1017                 perror("chown[ctrl_interface/ifname]");
1018                 goto fail;
1019         }
1020
1021         if (chmod(fname, S_IRWXU | S_IRWXG) < 0) {
1022                 perror("chmod[ctrl_interface/ifname]");
1023                 goto fail;
1024         }
1025         os_free(fname);
1026
1027         hapd->ctrl_sock = s;
1028         eloop_register_read_sock(s, hostapd_ctrl_iface_receive, hapd,
1029                                  NULL);
1030         hapd->msg_ctx = hapd;
1031         wpa_msg_register_cb(hostapd_ctrl_iface_msg_cb);
1032
1033         return 0;
1034
1035 fail:
1036         if (s >= 0)
1037                 close(s);
1038         if (fname) {
1039                 unlink(fname);
1040                 os_free(fname);
1041         }
1042         return -1;
1043 }
1044
1045
1046 void hostapd_ctrl_iface_deinit(struct hostapd_data *hapd)
1047 {
1048         struct wpa_ctrl_dst *dst, *prev;
1049
1050         if (hapd->ctrl_sock > -1) {
1051                 char *fname;
1052                 eloop_unregister_read_sock(hapd->ctrl_sock);
1053                 close(hapd->ctrl_sock);
1054                 hapd->ctrl_sock = -1;
1055                 fname = hostapd_ctrl_iface_path(hapd);
1056                 if (fname)
1057                         unlink(fname);
1058                 os_free(fname);
1059
1060                 if (hapd->conf->ctrl_interface &&
1061                     rmdir(hapd->conf->ctrl_interface) < 0) {
1062                         if (errno == ENOTEMPTY) {
1063                                 wpa_printf(MSG_DEBUG, "Control interface "
1064                                            "directory not empty - leaving it "
1065                                            "behind");
1066                         } else {
1067                                 perror("rmdir[ctrl_interface]");
1068                         }
1069                 }
1070         }
1071
1072         dst = hapd->ctrl_dst;
1073         while (dst) {
1074                 prev = dst;
1075                 dst = dst->next;
1076                 os_free(prev);
1077         }
1078 }
1079
1080
1081 static void hostapd_ctrl_iface_send(struct hostapd_data *hapd, int level,
1082                                     const char *buf, size_t len)
1083 {
1084         struct wpa_ctrl_dst *dst, *next;
1085         struct msghdr msg;
1086         int idx;
1087         struct iovec io[2];
1088         char levelstr[10];
1089
1090         dst = hapd->ctrl_dst;
1091         if (hapd->ctrl_sock < 0 || dst == NULL)
1092                 return;
1093
1094         os_snprintf(levelstr, sizeof(levelstr), "<%d>", level);
1095         io[0].iov_base = levelstr;
1096         io[0].iov_len = os_strlen(levelstr);
1097         io[1].iov_base = (char *) buf;
1098         io[1].iov_len = len;
1099         os_memset(&msg, 0, sizeof(msg));
1100         msg.msg_iov = io;
1101         msg.msg_iovlen = 2;
1102
1103         idx = 0;
1104         while (dst) {
1105                 next = dst->next;
1106                 if (level >= dst->debug_level) {
1107                         wpa_hexdump(MSG_DEBUG, "CTRL_IFACE monitor send",
1108                                     (u8 *) dst->addr.sun_path, dst->addrlen -
1109                                     offsetof(struct sockaddr_un, sun_path));
1110                         msg.msg_name = &dst->addr;
1111                         msg.msg_namelen = dst->addrlen;
1112                         if (sendmsg(hapd->ctrl_sock, &msg, 0) < 0) {
1113                                 int _errno = errno;
1114                                 wpa_printf(MSG_INFO, "CTRL_IFACE monitor[%d]: "
1115                                            "%d - %s",
1116                                            idx, errno, strerror(errno));
1117                                 dst->errors++;
1118                                 if (dst->errors > 10 || _errno == ENOENT) {
1119                                         hostapd_ctrl_iface_detach(
1120                                                 hapd, &dst->addr,
1121                                                 dst->addrlen);
1122                                 }
1123                         } else
1124                                 dst->errors = 0;
1125                 }
1126                 idx++;
1127                 dst = next;
1128         }
1129 }
1130
1131 #endif /* CONFIG_NATIVE_WINDOWS */