hostapd/ctrl_iface.c

   1 /*
   2  * hostapd / UNIX domain socket -based control interface
   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 #ifndef CONFIG_NATIVE_WINDOWS
  12
  13 #include <sys/un.h>
  14 #include <sys/stat.h>
  15 #include <stddef.h>
  16
  17 #include "utils/common.h"
  18 #include "utils/eloop.h"
  19 #include "common/version.h"
  20 #include "common/ieee802_11_defs.h"
  21 #include "drivers/driver.h"
  22 #include "radius/radius_client.h"
  23 #include "radius/radius_server.h"
  24 #include "ap/hostapd.h"
  25 #include "ap/ap_config.h"
  26 #include "ap/ieee802_1x.h"
  27 #include "ap/wpa_auth.h"
  28 #include "ap/ieee802_11.h"
  29 #include "ap/sta_info.h"
  30 #include "ap/wps_hostapd.h"
  31 #include "ap/ctrl_iface_ap.h"
  32 #include "ap/ap_drv_ops.h"
  33 #include "ap/hs20.h"
  34 #include "ap/wnm_ap.h"
  35 #include "ap/wpa_auth.h"
  36 #include "wps/wps_defs.h"
  37 #include "wps/wps.h"
  38 #include "config_file.h"
  39 #include "ctrl_iface.h"
  40
  41
  42 struct wpa_ctrl_dst {
  43         struct wpa_ctrl_dst *next;
  44         struct sockaddr_un addr;
  45         socklen_t addrlen;
  46         int debug_level;
  47         int errors;
  48 };
  49
  50
  51 static void hostapd_ctrl_iface_send(struct hostapd_data *hapd, int level,
  52                                     const char *buf, size_t len);
  53
  54
  55 static int hostapd_ctrl_iface_attach(struct hostapd_data *hapd,
  56                                      struct sockaddr_un *from,
  57                                      socklen_t fromlen)
  58 {
  59         struct wpa_ctrl_dst *dst;
  60
  61         dst = os_zalloc(sizeof(*dst));
  62         if (dst == NULL)
  63                 return -1;
  64         os_memcpy(&dst->addr, from, sizeof(struct sockaddr_un));
  65         dst->addrlen = fromlen;
  66         dst->debug_level = MSG_INFO;
  67         dst->next = hapd->ctrl_dst;
  68         hapd->ctrl_dst = dst;
  69         wpa_hexdump(MSG_DEBUG, "CTRL_IFACE monitor attached",
  70                     (u8 *) from->sun_path,
  71                     fromlen - offsetof(struct sockaddr_un, sun_path));
  72         return 0;
  73 }
  74
  75
  76 static int hostapd_ctrl_iface_detach(struct hostapd_data *hapd,
  77                                      struct sockaddr_un *from,
  78                                      socklen_t fromlen)
  79 {
  80         struct wpa_ctrl_dst *dst, *prev = NULL;
  81
  82         dst = hapd->ctrl_dst;
  83         while (dst) {
  84                 if (fromlen == dst->addrlen &&
  85                     os_memcmp(from->sun_path, dst->addr.sun_path,
  86                               fromlen - offsetof(struct sockaddr_un, sun_path))
  87                     == 0) {
  88                         wpa_hexdump(MSG_DEBUG, "CTRL_IFACE monitor detached",
  89                                     (u8 *) from->sun_path,
  90                                     fromlen -
  91                                     offsetof(struct sockaddr_un, sun_path));
  92                         if (prev == NULL)
  93                                 hapd->ctrl_dst = dst->next;
  94                         else
  95                                 prev->next = dst->next;
  96                         os_free(dst);
  97                         return 0;
  98                 }
  99                 prev = dst;
 100                 dst = dst->next;
 101         }
 102         return -1;
 103 }
 104
 105
 106 static int hostapd_ctrl_iface_level(struct hostapd_data *hapd,
 107                                     struct sockaddr_un *from,
 108                                     socklen_t fromlen,
 109                                     char *level)
 110 {
 111         struct wpa_ctrl_dst *dst;
 112
 113         wpa_printf(MSG_DEBUG, "CTRL_IFACE LEVEL %s", level);
 114
 115         dst = hapd->ctrl_dst;
 116         while (dst) {
 117                 if (fromlen == dst->addrlen &&
 118                     os_memcmp(from->sun_path, dst->addr.sun_path,
 119                               fromlen - offsetof(struct sockaddr_un, sun_path))
 120                     == 0) {
 121                         wpa_hexdump(MSG_DEBUG, "CTRL_IFACE changed monitor "
 122                                     "level", (u8 *) from->sun_path, fromlen -
 123                                     offsetof(struct sockaddr_un, sun_path));
 124                         dst->debug_level = atoi(level);
 125                         return 0;
 126                 }
 127                 dst = dst->next;
 128         }
 129
 130         return -1;
 131 }
 132
 133
 134 static int hostapd_ctrl_iface_new_sta(struct hostapd_data *hapd,
 135                                       const char *txtaddr)
 136 {
 137         u8 addr[ETH_ALEN];
 138         struct sta_info *sta;
 139
 140         wpa_printf(MSG_DEBUG, "CTRL_IFACE NEW_STA %s", txtaddr);
 141
 142         if (hwaddr_aton(txtaddr, addr))
 143                 return -1;
 144
 145         sta = ap_get_sta(hapd, addr);
 146         if (sta)
 147                 return 0;
 148
 149         wpa_printf(MSG_DEBUG, "Add new STA " MACSTR " based on ctrl_iface "
 150                    "notification", MAC2STR(addr));
 151         sta = ap_sta_add(hapd, addr);
 152         if (sta == NULL)
 153                 return -1;
 154
 155         hostapd_new_assoc_sta(hapd, sta, 0);
 156         return 0;
 157 }
 158
 159
 160 #ifdef CONFIG_IEEE80211W
 161 #ifdef NEED_AP_MLME
 162 static int hostapd_ctrl_iface_sa_query(struct hostapd_data *hapd,
 163                                        const char *txtaddr)
 164 {
 165         u8 addr[ETH_ALEN];
 166         u8 trans_id[WLAN_SA_QUERY_TR_ID_LEN];
 167
 168         wpa_printf(MSG_DEBUG, "CTRL_IFACE SA_QUERY %s", txtaddr);
 169
 170         if (hwaddr_aton(txtaddr, addr) ||
 171             os_get_random(trans_id, WLAN_SA_QUERY_TR_ID_LEN) < 0)
 172                 return -1;
 173
 174         ieee802_11_send_sa_query_req(hapd, addr, trans_id);
 175
 176         return 0;
 177 }
 178 #endif /* NEED_AP_MLME */
 179 #endif /* CONFIG_IEEE80211W */
 180
 181
 182 #ifdef CONFIG_WPS
 183 static int hostapd_ctrl_iface_wps_pin(struct hostapd_data *hapd, char *txt)
 184 {
 185         char *pin = os_strchr(txt, ' ');
 186         char *timeout_txt;
 187         int timeout;
 188         u8 addr_buf[ETH_ALEN], *addr = NULL;
 189         char *pos;
 190
 191         if (pin == NULL)
 192                 return -1;
 193         *pin++ = '\0';
 194
 195         timeout_txt = os_strchr(pin, ' ');
 196         if (timeout_txt) {
 197                 *timeout_txt++ = '\0';
 198                 timeout = atoi(timeout_txt);
 199                 pos = os_strchr(timeout_txt, ' ');
 200                 if (pos) {
 201                         *pos++ = '\0';
 202                         if (hwaddr_aton(pos, addr_buf) == 0)
 203                                 addr = addr_buf;
 204                 }
 205         } else
 206                 timeout = 0;
 207
 208         return hostapd_wps_add_pin(hapd, addr, txt, pin, timeout);
 209 }
 210
 211
 212 static int hostapd_ctrl_iface_wps_check_pin(
 213         struct hostapd_data *hapd, char *cmd, char *buf, size_t buflen)
 214 {
 215         char pin[9];
 216         size_t len;
 217         char *pos;
 218         int ret;
 219
 220         wpa_hexdump_ascii_key(MSG_DEBUG, "WPS_CHECK_PIN",
 221                               (u8 *) cmd, os_strlen(cmd));
 222         for (pos = cmd, len = 0; *pos != '\0'; pos++) {
 223                 if (*pos < '0' || *pos > '9')
 224                         continue;
 225                 pin[len++] = *pos;
 226                 if (len == 9) {
 227                         wpa_printf(MSG_DEBUG, "WPS: Too long PIN");
 228                         return -1;
 229                 }
 230         }
 231         if (len != 4 && len != 8) {
 232                 wpa_printf(MSG_DEBUG, "WPS: Invalid PIN length %d", (int) len);
 233                 return -1;
 234         }
 235         pin[len] = '\0';
 236
 237         if (len == 8) {
 238                 unsigned int pin_val;
 239                 pin_val = atoi(pin);
 240                 if (!wps_pin_valid(pin_val)) {
 241                         wpa_printf(MSG_DEBUG, "WPS: Invalid checksum digit");
 242                         ret = os_snprintf(buf, buflen, "FAIL-CHECKSUM\n");
 243                         if (ret < 0 || (size_t) ret >= buflen)
 244                                 return -1;
 245                         return ret;
 246                 }
 247         }
 248
 249         ret = os_snprintf(buf, buflen, "%s", pin);
 250         if (ret < 0 || (size_t) ret >= buflen)
 251                 return -1;
 252
 253         return ret;
 254 }
 255
 256
 257 #ifdef CONFIG_WPS_NFC
 258 static int hostapd_ctrl_iface_wps_nfc_tag_read(struct hostapd_data *hapd,
 259                                                char *pos)
 260 {
 261         size_t len;
 262         struct wpabuf *buf;
 263         int ret;
 264
 265         len = os_strlen(pos);
 266         if (len & 0x01)
 267                 return -1;
 268         len /= 2;
 269
 270         buf = wpabuf_alloc(len);
 271         if (buf == NULL)
 272                 return -1;
 273         if (hexstr2bin(pos, wpabuf_put(buf, len), len) < 0) {
 274                 wpabuf_free(buf);
 275                 return -1;
 276         }
 277
 278         ret = hostapd_wps_nfc_tag_read(hapd, buf);
 279         wpabuf_free(buf);
 280
 281         return ret;
 282 }
 283
 284
 285 static int hostapd_ctrl_iface_wps_nfc_config_token(struct hostapd_data *hapd,
 286                                                    char *cmd, char *reply,
 287                                                    size_t max_len)
 288 {
 289         int ndef;
 290         struct wpabuf *buf;
 291         int res;
 292
 293         if (os_strcmp(cmd, "WPS") == 0)
 294                 ndef = 0;
 295         else if (os_strcmp(cmd, "NDEF") == 0)
 296                 ndef = 1;
 297         else
 298                 return -1;
 299
 300         buf = hostapd_wps_nfc_config_token(hapd, ndef);
 301         if (buf == NULL)
 302                 return -1;
 303
 304         res = wpa_snprintf_hex_uppercase(reply, max_len, wpabuf_head(buf),
 305                                          wpabuf_len(buf));
 306         reply[res++] = '\n';
 307         reply[res] = '\0';
 308
 309         wpabuf_free(buf);
 310
 311         return res;
 312 }
 313
 314
 315 static int hostapd_ctrl_iface_wps_nfc_token_gen(struct hostapd_data *hapd,
 316                                                 char *reply, size_t max_len,
 317                                                 int ndef)
 318 {
 319         struct wpabuf *buf;
 320         int res;
 321
 322         buf = hostapd_wps_nfc_token_gen(hapd, ndef);
 323         if (buf == NULL)
 324                 return -1;
 325
 326         res = wpa_snprintf_hex_uppercase(reply, max_len, wpabuf_head(buf),
 327                                          wpabuf_len(buf));
 328         reply[res++] = '\n';
 329         reply[res] = '\0';
 330
 331         wpabuf_free(buf);
 332
 333         return res;
 334 }
 335
 336
 337 static int hostapd_ctrl_iface_wps_nfc_token(struct hostapd_data *hapd,
 338                                             char *cmd, char *reply,
 339                                             size_t max_len)
 340 {
 341         if (os_strcmp(cmd, "WPS") == 0)
 342                 return hostapd_ctrl_iface_wps_nfc_token_gen(hapd, reply,
 343                                                             max_len, 0);
 344
 345         if (os_strcmp(cmd, "NDEF") == 0)
 346                 return hostapd_ctrl_iface_wps_nfc_token_gen(hapd, reply,
 347                                                             max_len, 1);
 348
 349         if (os_strcmp(cmd, "enable") == 0)
 350                 return hostapd_wps_nfc_token_enable(hapd);
 351
 352         if (os_strcmp(cmd, "disable") == 0) {
 353                 hostapd_wps_nfc_token_disable(hapd);
 354                 return 0;
 355         }
 356
 357         return -1;
 358 }
 359
 360
 361 static int hostapd_ctrl_iface_nfc_get_handover_sel(struct hostapd_data *hapd,
 362                                                    char *cmd, char *reply,
 363                                                    size_t max_len)
 364 {
 365         struct wpabuf *buf;
 366         int res;
 367         char *pos;
 368         int ndef;
 369
 370         pos = os_strchr(cmd, ' ');
 371         if (pos == NULL)
 372                 return -1;
 373         *pos++ = '\0';
 374
 375         if (os_strcmp(cmd, "WPS") == 0)
 376                 ndef = 0;
 377         else if (os_strcmp(cmd, "NDEF") == 0)
 378                 ndef = 1;
 379         else
 380                 return -1;
 381
 382         if (os_strcmp(pos, "WPS-CR") == 0)
 383                 buf = hostapd_wps_nfc_hs_cr(hapd, ndef);
 384         else
 385                 buf = NULL;
 386         if (buf == NULL)
 387                 return -1;
 388
 389         res = wpa_snprintf_hex_uppercase(reply, max_len, wpabuf_head(buf),
 390                                          wpabuf_len(buf));
 391         reply[res++] = '\n';
 392         reply[res] = '\0';
 393
 394         wpabuf_free(buf);
 395
 396         return res;
 397 }
 398
 399
 400 static int hostapd_ctrl_iface_nfc_report_handover(struct hostapd_data *hapd,
 401                                                   char *cmd)
 402 {
 403         size_t len;
 404         struct wpabuf *req, *sel;
 405         int ret;
 406         char *pos, *role, *type, *pos2;
 407
 408         role = cmd;
 409         pos = os_strchr(role, ' ');
 410         if (pos == NULL)
 411                 return -1;
 412         *pos++ = '\0';
 413
 414         type = pos;
 415         pos = os_strchr(type, ' ');
 416         if (pos == NULL)
 417                 return -1;
 418         *pos++ = '\0';
 419
 420         pos2 = os_strchr(pos, ' ');
 421         if (pos2 == NULL)
 422                 return -1;
 423         *pos2++ = '\0';
 424
 425         len = os_strlen(pos);
 426         if (len & 0x01)
 427                 return -1;
 428         len /= 2;
 429
 430         req = wpabuf_alloc(len);
 431         if (req == NULL)
 432                 return -1;
 433         if (hexstr2bin(pos, wpabuf_put(req, len), len) < 0) {
 434                 wpabuf_free(req);
 435                 return -1;
 436         }
 437
 438         len = os_strlen(pos2);
 439         if (len & 0x01) {
 440                 wpabuf_free(req);
 441                 return -1;
 442         }
 443         len /= 2;
 444
 445         sel = wpabuf_alloc(len);
 446         if (sel == NULL) {
 447                 wpabuf_free(req);
 448                 return -1;
 449         }
 450         if (hexstr2bin(pos2, wpabuf_put(sel, len), len) < 0) {
 451                 wpabuf_free(req);
 452                 wpabuf_free(sel);
 453                 return -1;
 454         }
 455
 456         if (os_strcmp(role, "RESP") == 0 && os_strcmp(type, "WPS") == 0) {
 457                 ret = hostapd_wps_nfc_report_handover(hapd, req, sel);
 458         } else {
 459                 wpa_printf(MSG_DEBUG, "NFC: Unsupported connection handover "
 460                            "reported: role=%s type=%s", role, type);
 461                 ret = -1;
 462         }
 463         wpabuf_free(req);
 464         wpabuf_free(sel);
 465
 466         return ret;
 467 }
 468
 469 #endif /* CONFIG_WPS_NFC */
 470
 471
 472 static int hostapd_ctrl_iface_wps_ap_pin(struct hostapd_data *hapd, char *txt,
 473                                          char *buf, size_t buflen)
 474 {
 475         int timeout = 300;
 476         char *pos;
 477         const char *pin_txt;
 478
 479         pos = os_strchr(txt, ' ');
 480         if (pos)
 481                 *pos++ = '\0';
 482
 483         if (os_strcmp(txt, "disable") == 0) {
 484                 hostapd_wps_ap_pin_disable(hapd);
 485                 return os_snprintf(buf, buflen, "OK\n");
 486         }
 487
 488         if (os_strcmp(txt, "random") == 0) {
 489                 if (pos)
 490                         timeout = atoi(pos);
 491                 pin_txt = hostapd_wps_ap_pin_random(hapd, timeout);
 492                 if (pin_txt == NULL)
 493                         return -1;
 494                 return os_snprintf(buf, buflen, "%s", pin_txt);
 495         }
 496
 497         if (os_strcmp(txt, "get") == 0) {
 498                 pin_txt = hostapd_wps_ap_pin_get(hapd);
 499                 if (pin_txt == NULL)
 500                         return -1;
 501                 return os_snprintf(buf, buflen, "%s", pin_txt);
 502         }
 503
 504         if (os_strcmp(txt, "set") == 0) {
 505                 char *pin;
 506                 if (pos == NULL)
 507                         return -1;
 508                 pin = pos;
 509                 pos = os_strchr(pos, ' ');
 510                 if (pos) {
 511                         *pos++ = '\0';
 512                         timeout = atoi(pos);
 513                 }
 514                 if (os_strlen(pin) > buflen)
 515                         return -1;
 516                 if (hostapd_wps_ap_pin_set(hapd, pin, timeout) < 0)
 517                         return -1;
 518                 return os_snprintf(buf, buflen, "%s", pin);
 519         }
 520
 521         return -1;
 522 }
 523
 524
 525 static int hostapd_ctrl_iface_wps_config(struct hostapd_data *hapd, char *txt)
 526 {
 527         char *pos;
 528         char *ssid, *auth, *encr = NULL, *key = NULL;
 529
 530         ssid = txt;
 531         pos = os_strchr(txt, ' ');
 532         if (!pos)
 533                 return -1;
 534         *pos++ = '\0';
 535
 536         auth = pos;
 537         pos = os_strchr(pos, ' ');
 538         if (pos) {
 539                 *pos++ = '\0';
 540                 encr = pos;
 541                 pos = os_strchr(pos, ' ');
 542                 if (pos) {
 543                         *pos++ = '\0';
 544                         key = pos;
 545                 }
 546         }
 547
 548         return hostapd_wps_config_ap(hapd, ssid, auth, encr, key);
 549 }
 550
 551
 552 static const char * pbc_status_str(enum pbc_status status)
 553 {
 554         switch (status) {
 555         case WPS_PBC_STATUS_DISABLE:
 556                 return "Disabled";
 557         case WPS_PBC_STATUS_ACTIVE:
 558                 return "Active";
 559         case WPS_PBC_STATUS_TIMEOUT:
 560                 return "Timed-out";
 561         case WPS_PBC_STATUS_OVERLAP:
 562                 return "Overlap";
 563         default:
 564                 return "Unknown";
 565         }
 566 }
 567
 568
 569 static int hostapd_ctrl_iface_wps_get_status(struct hostapd_data *hapd,
 570                                              char *buf, size_t buflen)
 571 {
 572         int ret;
 573         char *pos, *end;
 574
 575         pos = buf;
 576         end = buf + buflen;
 577
 578         ret = os_snprintf(pos, end - pos, "PBC Status: %s\n",
 579                           pbc_status_str(hapd->wps_stats.pbc_status));
 580
 581         if (ret < 0 || ret >= end - pos)
 582                 return pos - buf;
 583         pos += ret;
 584
 585         ret = os_snprintf(pos, end - pos, "Last WPS result: %s\n",
 586                           (hapd->wps_stats.status == WPS_STATUS_SUCCESS ?
 587                            "Success":
 588                            (hapd->wps_stats.status == WPS_STATUS_FAILURE ?
 589                             "Failed" : "None")));
 590
 591         if (ret < 0 || ret >= end - pos)
 592                 return pos - buf;
 593         pos += ret;
 594
 595         /* If status == Failure - Add possible Reasons */
 596         if(hapd->wps_stats.status == WPS_STATUS_FAILURE &&
 597            hapd->wps_stats.failure_reason > 0) {
 598                 ret = os_snprintf(pos, end - pos,
 599                                   "Failure Reason: %s\n",
 600                                   wps_ei_str(hapd->wps_stats.failure_reason));
 601
 602                 if (ret < 0 || ret >= end - pos)
 603                         return pos - buf;
 604                 pos += ret;
 605         }
 606
 607         if (hapd->wps_stats.status) {
 608                 ret = os_snprintf(pos, end - pos, "Peer Address: " MACSTR "\n",
 609                                   MAC2STR(hapd->wps_stats.peer_addr));
 610
 611                 if (ret < 0 || ret >= end - pos)
 612                         return pos - buf;
 613                 pos += ret;
 614         }
 615
 616         return pos - buf;
 617 }
 618
 619 #endif /* CONFIG_WPS */
 620
 621 #ifdef CONFIG_HS20
 622
 623 static int hostapd_ctrl_iface_hs20_wnm_notif(struct hostapd_data *hapd,
 624                                              const char *cmd)
 625 {
 626         u8 addr[ETH_ALEN];
 627         const char *url;
 628
 629         if (hwaddr_aton(cmd, addr))
 630                 return -1;
 631         url = cmd + 17;
 632         if (*url == '\0') {
 633                 url = NULL;
 634         } else {
 635                 if (*url != ' ')
 636                         return -1;
 637                 url++;
 638                 if (*url == '\0')
 639                         url = NULL;
 640         }
 641
 642         return hs20_send_wnm_notification(hapd, addr, 1, url);
 643 }
 644
 645
 646 static int hostapd_ctrl_iface_hs20_deauth_req(struct hostapd_data *hapd,
 647                                               const char *cmd)
 648 {
 649         u8 addr[ETH_ALEN];
 650         int code, reauth_delay, ret;
 651         const char *pos;
 652         size_t url_len;
 653         struct wpabuf *req;
 654
 655         /* <STA MAC Addr> <Code(0/1)> <Re-auth-Delay(sec)> [URL] */
 656         if (hwaddr_aton(cmd, addr))
 657                 return -1;
 658
 659         pos = os_strchr(cmd, ' ');
 660         if (pos == NULL)
 661                 return -1;
 662         pos++;
 663         code = atoi(pos);
 664
 665         pos = os_strchr(pos, ' ');
 666         if (pos == NULL)
 667                 return -1;
 668         pos++;
 669         reauth_delay = atoi(pos);
 670
 671         url_len = 0;
 672         pos = os_strchr(pos, ' ');
 673         if (pos) {
 674                 pos++;
 675                 url_len = os_strlen(pos);
 676         }
 677
 678         req = wpabuf_alloc(4 + url_len);
 679         if (req == NULL)
 680                 return -1;
 681         wpabuf_put_u8(req, code);
 682         wpabuf_put_le16(req, reauth_delay);
 683         wpabuf_put_u8(req, url_len);
 684         if (pos)
 685                 wpabuf_put_data(req, pos, url_len);
 686
 687         wpa_printf(MSG_DEBUG, "HS 2.0: Send WNM-Notification to " MACSTR
 688                    " to indicate imminent deauthentication (code=%d "
 689                    "reauth_delay=%d)", MAC2STR(addr), code, reauth_delay);
 690         ret = hs20_send_wnm_notification_deauth_req(hapd, addr, req);
 691         wpabuf_free(req);
 692         return ret;
 693 }
 694
 695 #endif /* CONFIG_HS20 */
 696
 697
 698 #ifdef CONFIG_INTERWORKING
 699
 700 static int hostapd_ctrl_iface_set_qos_map_set(struct hostapd_data *hapd,
 701                                               const char *cmd)
 702 {
 703         u8 qos_map_set[16 + 2 * 21], count = 0;
 704         const char *pos = cmd;
 705         int val, ret;
 706
 707         for (;;) {
 708                 if (count == sizeof(qos_map_set)) {
 709                         wpa_printf(MSG_ERROR, "Too many qos_map_set parameters");
 710                         return -1;
 711                 }
 712
 713                 val = atoi(pos);
 714                 if (val < 0 || val > 255) {
 715                         wpa_printf(MSG_INFO, "Invalid QoS Map Set");
 716                         return -1;
 717                 }
 718
 719                 qos_map_set[count++] = val;
 720                 pos = os_strchr(pos, ',');
 721                 if (!pos)
 722                         break;
 723                 pos++;
 724         }
 725
 726         if (count < 16 || count & 1) {
 727                 wpa_printf(MSG_INFO, "Invalid QoS Map Set");
 728                 return -1;
 729         }
 730
 731         ret = hostapd_drv_set_qos_map(hapd, qos_map_set, count);
 732         if (ret) {
 733                 wpa_printf(MSG_INFO, "Failed to set QoS Map Set");
 734                 return -1;
 735         }
 736
 737         os_memcpy(hapd->conf->qos_map_set, qos_map_set, count);
 738         hapd->conf->qos_map_set_len = count;
 739
 740         return 0;
 741 }
 742
 743
 744 static int hostapd_ctrl_iface_send_qos_map_conf(struct hostapd_data *hapd,
 745                                                 const char *cmd)
 746 {
 747         u8 addr[ETH_ALEN];
 748         struct sta_info *sta;
 749         struct wpabuf *buf;
 750         u8 *qos_map_set = hapd->conf->qos_map_set;
 751         u8 qos_map_set_len = hapd->conf->qos_map_set_len;
 752         int ret;
 753
 754         if (!qos_map_set_len) {
 755                 wpa_printf(MSG_INFO, "QoS Map Set is not set");
 756                 return -1;
 757         }
 758
 759         if (hwaddr_aton(cmd, addr))
 760                 return -1;
 761
 762         sta = ap_get_sta(hapd, addr);
 763         if (sta == NULL) {
 764                 wpa_printf(MSG_DEBUG, "Station " MACSTR " not found "
 765                            "for QoS Map Configuration message",
 766                            MAC2STR(addr));
 767                 return -1;
 768         }
 769
 770         if (!sta->qos_map_enabled) {
 771                 wpa_printf(MSG_DEBUG, "Station " MACSTR " did not indicate "
 772                            "support for QoS Map", MAC2STR(addr));
 773                 return -1;
 774         }
 775
 776         buf = wpabuf_alloc(2 + 2 + qos_map_set_len);
 777         if (buf == NULL)
 778                 return -1;
 779
 780         wpabuf_put_u8(buf, WLAN_ACTION_QOS);
 781         wpabuf_put_u8(buf, QOS_QOS_MAP_CONFIG);
 782
 783         /* QoS Map Set Element */
 784         wpabuf_put_u8(buf, WLAN_EID_QOS_MAP_SET);
 785         wpabuf_put_u8(buf, qos_map_set_len);
 786         wpabuf_put_data(buf, qos_map_set, qos_map_set_len);
 787
 788         ret = hostapd_drv_send_action(hapd, hapd->iface->freq, 0, addr,
 789                                       wpabuf_head(buf), wpabuf_len(buf));
 790         wpabuf_free(buf);
 791
 792         return ret;
 793 }
 794
 795 #endif /* CONFIG_INTERWORKING */
 796
 797
 798 #ifdef CONFIG_WNM
 799
 800 static int hostapd_ctrl_iface_disassoc_imminent(struct hostapd_data *hapd,
 801                                                 const char *cmd)
 802 {
 803         u8 addr[ETH_ALEN];
 804         int disassoc_timer;
 805         struct sta_info *sta;
 806
 807         if (hwaddr_aton(cmd, addr))
 808                 return -1;
 809         if (cmd[17] != ' ')
 810                 return -1;
 811         disassoc_timer = atoi(cmd + 17);
 812
 813         sta = ap_get_sta(hapd, addr);
 814         if (sta == NULL) {
 815                 wpa_printf(MSG_DEBUG, "Station " MACSTR
 816                            " not found for disassociation imminent message",
 817                            MAC2STR(addr));
 818                 return -1;
 819         }
 820
 821         return wnm_send_disassoc_imminent(hapd, sta, disassoc_timer);
 822 }
 823
 824
 825 static int hostapd_ctrl_iface_ess_disassoc(struct hostapd_data *hapd,
 826                                            const char *cmd)
 827 {
 828         u8 addr[ETH_ALEN];
 829         const char *url, *timerstr;
 830         int disassoc_timer;
 831         struct sta_info *sta;
 832
 833         if (hwaddr_aton(cmd, addr))
 834                 return -1;
 835
 836         sta = ap_get_sta(hapd, addr);
 837         if (sta == NULL) {
 838                 wpa_printf(MSG_DEBUG, "Station " MACSTR
 839                            " not found for ESS disassociation imminent message",
 840                            MAC2STR(addr));
 841                 return -1;
 842         }
 843
 844         timerstr = cmd + 17;
 845         if (*timerstr != ' ')
 846                 return -1;
 847         timerstr++;
 848         disassoc_timer = atoi(timerstr);
 849         if (disassoc_timer < 0 || disassoc_timer > 65535)
 850                 return -1;
 851
 852         url = os_strchr(timerstr, ' ');
 853         if (url == NULL)
 854                 return -1;
 855         url++;
 856
 857         return wnm_send_ess_disassoc_imminent(hapd, sta, url, disassoc_timer);
 858 }
 859
 860 #endif /* CONFIG_WNM */
 861
 862
 863 static int hostapd_ctrl_iface_get_config(struct hostapd_data *hapd,
 864                                          char *buf, size_t buflen)
 865 {
 866         int ret;
 867         char *pos, *end;
 868
 869         pos = buf;
 870         end = buf + buflen;
 871
 872         ret = os_snprintf(pos, end - pos, "bssid=" MACSTR "\n"
 873                           "ssid=%s\n",
 874                           MAC2STR(hapd->own_addr),
 875                           wpa_ssid_txt(hapd->conf->ssid.ssid,
 876                                        hapd->conf->ssid.ssid_len));
 877         if (ret < 0 || ret >= end - pos)
 878                 return pos - buf;
 879         pos += ret;
 880
 881 #ifdef CONFIG_WPS
 882         ret = os_snprintf(pos, end - pos, "wps_state=%s\n",
 883                           hapd->conf->wps_state == 0 ? "disabled" :
 884                           (hapd->conf->wps_state == 1 ? "not configured" :
 885                            "configured"));
 886         if (ret < 0 || ret >= end - pos)
 887                 return pos - buf;
 888         pos += ret;
 889
 890         if (hapd->conf->wps_state && hapd->conf->wpa &&
 891             hapd->conf->ssid.wpa_passphrase) {
 892                 ret = os_snprintf(pos, end - pos, "passphrase=%s\n",
 893                                   hapd->conf->ssid.wpa_passphrase);
 894                 if (ret < 0 || ret >= end - pos)
 895                         return pos - buf;
 896                 pos += ret;
 897         }
 898
 899         if (hapd->conf->wps_state && hapd->conf->wpa &&
 900             hapd->conf->ssid.wpa_psk &&
 901             hapd->conf->ssid.wpa_psk->group) {
 902                 char hex[PMK_LEN * 2 + 1];
 903                 wpa_snprintf_hex(hex, sizeof(hex),
 904                                  hapd->conf->ssid.wpa_psk->psk, PMK_LEN);
 905                 ret = os_snprintf(pos, end - pos, "psk=%s\n", hex);
 906                 if (ret < 0 || ret >= end - pos)
 907                         return pos - buf;
 908                 pos += ret;
 909         }
 910 #endif /* CONFIG_WPS */
 911
 912         if (hapd->conf->wpa && hapd->conf->wpa_key_mgmt) {
 913                 ret = os_snprintf(pos, end - pos, "key_mgmt=");
 914                 if (ret < 0 || ret >= end - pos)
 915                         return pos - buf;
 916                 pos += ret;
 917
 918                 if (hapd->conf->wpa_key_mgmt & WPA_KEY_MGMT_PSK) {
 919                         ret = os_snprintf(pos, end - pos, "WPA-PSK ");
 920                         if (ret < 0 || ret >= end - pos)
 921                                 return pos - buf;
 922                         pos += ret;
 923                 }
 924                 if (hapd->conf->wpa_key_mgmt & WPA_KEY_MGMT_IEEE8021X) {
 925                         ret = os_snprintf(pos, end - pos, "WPA-EAP ");
 926                         if (ret < 0 || ret >= end - pos)
 927                                 return pos - buf;
 928                         pos += ret;
 929                 }
 930 #ifdef CONFIG_IEEE80211R
 931                 if (hapd->conf->wpa_key_mgmt & WPA_KEY_MGMT_FT_PSK) {
 932                         ret = os_snprintf(pos, end - pos, "FT-PSK ");
 933                         if (ret < 0 || ret >= end - pos)
 934                                 return pos - buf;
 935                         pos += ret;
 936                 }
 937                 if (hapd->conf->wpa_key_mgmt & WPA_KEY_MGMT_FT_IEEE8021X) {
 938                         ret = os_snprintf(pos, end - pos, "FT-EAP ");
 939                         if (ret < 0 || ret >= end - pos)
 940                                 return pos - buf;
 941                         pos += ret;
 942                 }
 943 #ifdef CONFIG_SAE
 944                 if (hapd->conf->wpa_key_mgmt & WPA_KEY_MGMT_FT_SAE) {
 945                         ret = os_snprintf(pos, end - pos, "FT-SAE ");
 946                         if (ret < 0 || ret >= end - pos)
 947                                 return pos - buf;
 948                         pos += ret;
 949                 }
 950 #endif /* CONFIG_SAE */
 951 #endif /* CONFIG_IEEE80211R */
 952 #ifdef CONFIG_IEEE80211W
 953                 if (hapd->conf->wpa_key_mgmt & WPA_KEY_MGMT_PSK_SHA256) {
 954                         ret = os_snprintf(pos, end - pos, "WPA-PSK-SHA256 ");
 955                         if (ret < 0 || ret >= end - pos)
 956                                 return pos - buf;
 957                         pos += ret;
 958                 }
 959                 if (hapd->conf->wpa_key_mgmt & WPA_KEY_MGMT_IEEE8021X_SHA256) {
 960                         ret = os_snprintf(pos, end - pos, "WPA-EAP-SHA256 ");
 961                         if (ret < 0 || ret >= end - pos)
 962                                 return pos - buf;
 963                         pos += ret;
 964                 }
 965 #endif /* CONFIG_IEEE80211W */
 966 #ifdef CONFIG_SAE
 967                 if (hapd->conf->wpa_key_mgmt & WPA_KEY_MGMT_SAE) {
 968                         ret = os_snprintf(pos, end - pos, "SAE ");
 969                         if (ret < 0 || ret >= end - pos)
 970                                 return pos - buf;
 971                         pos += ret;
 972                 }
 973 #endif /* CONFIG_SAE */
 974
 975                 ret = os_snprintf(pos, end - pos, "\n");
 976                 if (ret < 0 || ret >= end - pos)
 977                         return pos - buf;
 978                 pos += ret;
 979         }
 980
 981         if (hapd->conf->wpa) {
 982                 ret = os_snprintf(pos, end - pos, "group_cipher=%s\n",
 983                                   wpa_cipher_txt(hapd->conf->wpa_group));
 984                 if (ret < 0 || ret >= end - pos)
 985                         return pos - buf;
 986                 pos += ret;
 987         }
 988
 989         if ((hapd->conf->wpa & WPA_PROTO_RSN) && hapd->conf->rsn_pairwise) {
 990                 ret = os_snprintf(pos, end - pos, "rsn_pairwise_cipher=");
 991                 if (ret < 0 || ret >= end - pos)
 992                         return pos - buf;
 993                 pos += ret;
 994
 995                 ret = wpa_write_ciphers(pos, end, hapd->conf->rsn_pairwise,
 996                                         " ");
 997                 if (ret < 0)
 998                         return pos - buf;
 999                 pos += ret;
1000
1001                 ret = os_snprintf(pos, end - pos, "\n");
1002                 if (ret < 0 || ret >= end - pos)
1003                         return pos - buf;
1004                 pos += ret;
1005         }
1006
1007         if ((hapd->conf->wpa & WPA_PROTO_WPA) && hapd->conf->wpa_pairwise) {
1008                 ret = os_snprintf(pos, end - pos, "wpa_pairwise_cipher=");
1009                 if (ret < 0 || ret >= end - pos)
1010                         return pos - buf;
1011                 pos += ret;
1012
1013                 ret = wpa_write_ciphers(pos, end, hapd->conf->wpa_pairwise,
1014                                         " ");
1015                 if (ret < 0)
1016                         return pos - buf;
1017                 pos += ret;
1018
1019                 ret = os_snprintf(pos, end - pos, "\n");
1020                 if (ret < 0 || ret >= end - pos)
1021                         return pos - buf;
1022                 pos += ret;
1023         }
1024
1025         return pos - buf;
1026 }
1027
1028
1029 static int hostapd_ctrl_iface_set(struct hostapd_data *hapd, char *cmd)
1030 {
1031         char *value;
1032         int ret = 0;
1033
1034         value = os_strchr(cmd, ' ');
1035         if (value == NULL)
1036                 return -1;
1037         *value++ = '\0';
1038
1039         wpa_printf(MSG_DEBUG, "CTRL_IFACE SET '%s'='%s'", cmd, value);
1040         if (0) {
1041 #ifdef CONFIG_WPS_TESTING
1042         } else if (os_strcasecmp(cmd, "wps_version_number") == 0) {
1043                 long int val;
1044                 val = strtol(value, NULL, 0);
1045                 if (val < 0 || val > 0xff) {
1046                         ret = -1;
1047                         wpa_printf(MSG_DEBUG, "WPS: Invalid "
1048                                    "wps_version_number %ld", val);
1049                 } else {
1050                         wps_version_number = val;
1051                         wpa_printf(MSG_DEBUG, "WPS: Testing - force WPS "
1052                                    "version %u.%u",
1053                                    (wps_version_number & 0xf0) >> 4,
1054                                    wps_version_number & 0x0f);
1055                         hostapd_wps_update_ie(hapd);
1056                 }
1057         } else if (os_strcasecmp(cmd, "wps_testing_dummy_cred") == 0) {
1058                 wps_testing_dummy_cred = atoi(value);
1059                 wpa_printf(MSG_DEBUG, "WPS: Testing - dummy_cred=%d",
1060                            wps_testing_dummy_cred);
1061         } else if (os_strcasecmp(cmd, "wps_corrupt_pkhash") == 0) {
1062                 wps_corrupt_pkhash = atoi(value);
1063                 wpa_printf(MSG_DEBUG, "WPS: Testing - wps_corrupt_pkhash=%d",
1064                            wps_corrupt_pkhash);
1065 #endif /* CONFIG_WPS_TESTING */
1066 #ifdef CONFIG_INTERWORKING
1067         } else if (os_strcasecmp(cmd, "gas_frag_limit") == 0) {
1068                 int val = atoi(value);
1069                 if (val <= 0)
1070                         ret = -1;
1071                 else
1072                         hapd->gas_frag_limit = val;
1073 #endif /* CONFIG_INTERWORKING */
1074 #ifdef CONFIG_TESTING_OPTIONS
1075         } else if (os_strcasecmp(cmd, "ext_mgmt_frame_handling") == 0) {
1076                 hapd->ext_mgmt_frame_handling = atoi(value);
1077         } else if (os_strcasecmp(cmd, "ext_eapol_frame_io") == 0) {
1078                 hapd->ext_eapol_frame_io = atoi(value);
1079 #endif /* CONFIG_TESTING_OPTIONS */
1080         } else {
1081                 struct sta_info *sta;
1082                 int vlan_id;
1083
1084                 ret = hostapd_set_iface(hapd->iconf, hapd->conf, cmd, value);
1085                 if (ret)
1086                         return ret;
1087
1088                 if (os_strcasecmp(cmd, "deny_mac_file") == 0) {
1089                         for (sta = hapd->sta_list; sta; sta = sta->next) {
1090                                 if (hostapd_maclist_found(
1091                                             hapd->conf->deny_mac,
1092                                             hapd->conf->num_deny_mac, sta->addr,
1093                                             &vlan_id) &&
1094                                     (!vlan_id || vlan_id == sta->vlan_id))
1095                                         ap_sta_disconnect(
1096                                                 hapd, sta, sta->addr,
1097                                                 WLAN_REASON_UNSPECIFIED);
1098                         }
1099                 } else if (hapd->conf->macaddr_acl == DENY_UNLESS_ACCEPTED &&
1100                            os_strcasecmp(cmd, "accept_mac_file") == 0) {
1101                         for (sta = hapd->sta_list; sta; sta = sta->next) {
1102                                 if (!hostapd_maclist_found(
1103                                             hapd->conf->accept_mac,
1104                                             hapd->conf->num_accept_mac,
1105                                             sta->addr, &vlan_id) ||
1106                                     (vlan_id && vlan_id != sta->vlan_id))
1107                                         ap_sta_disconnect(
1108                                                 hapd, sta, sta->addr,
1109                                                 WLAN_REASON_UNSPECIFIED);
1110                         }
1111                 }
1112         }
1113
1114         return ret;
1115 }
1116
1117
1118 static int hostapd_ctrl_iface_get(struct hostapd_data *hapd, char *cmd,
1119                                   char *buf, size_t buflen)
1120 {
1121         int res;
1122
1123         wpa_printf(MSG_DEBUG, "CTRL_IFACE GET '%s'", cmd);
1124
1125         if (os_strcmp(cmd, "version") == 0) {
1126                 res = os_snprintf(buf, buflen, "%s", VERSION_STR);
1127                 if (res < 0 || (unsigned int) res >= buflen)
1128                         return -1;
1129                 return res;
1130         }
1131
1132         return -1;
1133 }
1134
1135
1136 static int hostapd_ctrl_iface_enable(struct hostapd_iface *iface)
1137 {
1138         if (hostapd_enable_iface(iface) < 0) {
1139                 wpa_printf(MSG_ERROR, "Enabling of interface failed");
1140                 return -1;
1141         }
1142         return 0;
1143 }
1144
1145
1146 static int hostapd_ctrl_iface_reload(struct hostapd_iface *iface)
1147 {
1148         if (hostapd_reload_iface(iface) < 0) {
1149                 wpa_printf(MSG_ERROR, "Reloading of interface failed");
1150                 return -1;
1151         }
1152         return 0;
1153 }
1154
1155
1156 static int hostapd_ctrl_iface_disable(struct hostapd_iface *iface)
1157 {
1158         if (hostapd_disable_iface(iface) < 0) {
1159                 wpa_printf(MSG_ERROR, "Disabling of interface failed");
1160                 return -1;
1161         }
1162         return 0;
1163 }
1164
1165
1166 #ifdef CONFIG_TESTING_OPTIONS
1167
1168 static int hostapd_ctrl_iface_radar(struct hostapd_data *hapd, char *cmd)
1169 {
1170         union wpa_event_data data;
1171         char *pos, *param;
1172         enum wpa_event_type event;
1173
1174         wpa_printf(MSG_DEBUG, "RADAR TEST: %s", cmd);
1175
1176         os_memset(&data, 0, sizeof(data));
1177
1178         param = os_strchr(cmd, ' ');
1179         if (param == NULL)
1180                 return -1;
1181         *param++ = '\0';
1182
1183         if (os_strcmp(cmd, "DETECTED") == 0)
1184                 event = EVENT_DFS_RADAR_DETECTED;
1185         else if (os_strcmp(cmd, "CAC-FINISHED") == 0)
1186                 event = EVENT_DFS_CAC_FINISHED;
1187         else if (os_strcmp(cmd, "CAC-ABORTED") == 0)
1188                 event = EVENT_DFS_CAC_ABORTED;
1189         else if (os_strcmp(cmd, "NOP-FINISHED") == 0)
1190                 event = EVENT_DFS_NOP_FINISHED;
1191         else {
1192                 wpa_printf(MSG_DEBUG, "Unsupported RADAR test command: %s",
1193                            cmd);
1194                 return -1;
1195         }
1196
1197         pos = os_strstr(param, "freq=");
1198         if (pos)
1199                 data.dfs_event.freq = atoi(pos + 5);
1200
1201         pos = os_strstr(param, "ht_enabled=1");
1202         if (pos)
1203                 data.dfs_event.ht_enabled = 1;
1204
1205         pos = os_strstr(param, "chan_offset=");
1206         if (pos)
1207                 data.dfs_event.chan_offset = atoi(pos + 12);
1208
1209         pos = os_strstr(param, "chan_width=");
1210         if (pos)
1211                 data.dfs_event.chan_width = atoi(pos + 11);
1212
1213         pos = os_strstr(param, "cf1=");
1214         if (pos)
1215                 data.dfs_event.cf1 = atoi(pos + 4);
1216
1217         pos = os_strstr(param, "cf2=");
1218         if (pos)
1219                 data.dfs_event.cf2 = atoi(pos + 4);
1220
1221         wpa_supplicant_event(hapd, event, &data);
1222
1223         return 0;
1224 }
1225
1226
1227 static int hostapd_ctrl_iface_mgmt_tx(struct hostapd_data *hapd, char *cmd)
1228 {
1229         size_t len;
1230         u8 *buf;
1231         int res;
1232
1233         wpa_printf(MSG_DEBUG, "External MGMT TX: %s", cmd);
1234
1235         len = os_strlen(cmd);
1236         if (len & 1)
1237                 return -1;
1238         len /= 2;
1239
1240         buf = os_malloc(len);
1241         if (buf == NULL)
1242                 return -1;
1243
1244         if (hexstr2bin(cmd, buf, len) < 0) {
1245                 os_free(buf);
1246                 return -1;
1247         }
1248
1249         res = hostapd_drv_send_mlme(hapd, buf, len, 0);
1250         os_free(buf);
1251         return res;
1252 }
1253
1254
1255 static int hostapd_ctrl_iface_eapol_rx(struct hostapd_data *hapd, char *cmd)
1256 {
1257         char *pos;
1258         u8 src[ETH_ALEN], *buf;
1259         int used;
1260         size_t len;
1261
1262         wpa_printf(MSG_DEBUG, "External EAPOL RX: %s", cmd);
1263
1264         pos = cmd;
1265         used = hwaddr_aton2(pos, src);
1266         if (used < 0)
1267                 return -1;
1268         pos += used;
1269         while (*pos == ' ')
1270                 pos++;
1271
1272         len = os_strlen(pos);
1273         if (len & 1)
1274                 return -1;
1275         len /= 2;
1276
1277         buf = os_malloc(len);
1278         if (buf == NULL)
1279                 return -1;
1280
1281         if (hexstr2bin(pos, buf, len) < 0) {
1282                 os_free(buf);
1283                 return -1;
1284         }
1285
1286         ieee802_1x_receive(hapd, src, buf, len);
1287         os_free(buf);
1288
1289         return 0;
1290 }
1291
1292 #endif /* CONFIG_TESTING_OPTIONS */
1293
1294
1295 static int hostapd_ctrl_iface_chan_switch(struct hostapd_iface *iface,
1296                                           char *pos)
1297 {
1298 #ifdef NEED_AP_MLME
1299         struct csa_settings settings;
1300         int ret;
1301         unsigned int i;
1302
1303         ret = hostapd_parse_csa_settings(pos, &settings);
1304         if (ret)
1305                 return ret;
1306
1307         for (i = 0; i < iface->num_bss; i++) {
1308                 ret = hostapd_switch_channel(iface->bss[i], &settings);
1309                 if (ret) {
1310                         /* FIX: What do we do if CSA fails in the middle of
1311                          * submitting multi-BSS CSA requests? */
1312                         return ret;
1313                 }
1314         }
1315
1316         return 0;
1317 #else /* NEED_AP_MLME */
1318         return -1;
1319 #endif /* NEED_AP_MLME */
1320 }
1321
1322
1323 static int hostapd_ctrl_iface_mib(struct hostapd_data *hapd, char *reply,
1324                                   int reply_size, const char *param)
1325 {
1326 #ifdef RADIUS_SERVER
1327         if (os_strcmp(param, "radius_server") == 0) {
1328                 return radius_server_get_mib(hapd->radius_srv, reply,
1329                                              reply_size);
1330         }
1331 #endif /* RADIUS_SERVER */
1332         return -1;
1333 }
1334
1335
1336 static int hostapd_ctrl_iface_vendor(struct hostapd_data *hapd, char *cmd,
1337                                      char *buf, size_t buflen)
1338 {
1339         int ret;
1340         char *pos;
1341         u8 *data = NULL;
1342         unsigned int vendor_id, subcmd;
1343         struct wpabuf *reply;
1344         size_t data_len = 0;
1345
1346         /* cmd: <vendor id> <subcommand id> [<hex formatted data>] */
1347         vendor_id = strtoul(cmd, &pos, 16);
1348         if (!isblank(*pos))
1349                 return -EINVAL;
1350
1351         subcmd = strtoul(pos, &pos, 10);
1352
1353         if (*pos != '\0') {
1354                 if (!isblank(*pos++))
1355                         return -EINVAL;
1356                 data_len = os_strlen(pos);
1357         }
1358
1359         if (data_len) {
1360                 data_len /= 2;
1361                 data = os_malloc(data_len);
1362                 if (!data)
1363                         return -ENOBUFS;
1364
1365                 if (hexstr2bin(pos, data, data_len)) {
1366                         wpa_printf(MSG_DEBUG,
1367                                    "Vendor command: wrong parameter format");
1368                         os_free(data);
1369                         return -EINVAL;
1370                 }
1371         }
1372
1373         reply = wpabuf_alloc((buflen - 1) / 2);
1374         if (!reply) {
1375                 os_free(data);
1376                 return -ENOBUFS;
1377         }
1378
1379         ret = hostapd_drv_vendor_cmd(hapd, vendor_id, subcmd, data, data_len,
1380                                      reply);
1381
1382         if (ret == 0)
1383                 ret = wpa_snprintf_hex(buf, buflen, wpabuf_head_u8(reply),
1384                                        wpabuf_len(reply));
1385
1386         wpabuf_free(reply);
1387         os_free(data);
1388
1389         return ret;
1390 }
1391
1392
1393 static void hostapd_ctrl_iface_receive(int sock, void *eloop_ctx,
1394                                        void *sock_ctx)
1395 {
1396         struct hostapd_data *hapd = eloop_ctx;
1397         char buf[4096];
1398         int res;
1399         struct sockaddr_un from;
1400         socklen_t fromlen = sizeof(from);
1401         char *reply;
1402         const int reply_size = 4096;
1403         int reply_len;
1404         int level = MSG_DEBUG;
1405
1406         res = recvfrom(sock, buf, sizeof(buf) - 1, 0,
1407                        (struct sockaddr *) &from, &fromlen);
1408         if (res < 0) {
1409                 perror("recvfrom(ctrl_iface)");
1410                 return;
1411         }
1412         buf[res] = '\0';
1413         if (os_strcmp(buf, "PING") == 0)
1414                 level = MSG_EXCESSIVE;
1415         wpa_hexdump_ascii(level, "RX ctrl_iface", (u8 *) buf, res);
1416
1417         reply = os_malloc(reply_size);
1418         if (reply == NULL) {
1419                 if (sendto(sock, "FAIL\n", 5, 0, (struct sockaddr *) &from,
1420                            fromlen) < 0) {
1421                         wpa_printf(MSG_DEBUG, "CTRL: sendto failed: %s",
1422                                    strerror(errno));
1423                 }
1424                 return;
1425         }
1426
1427         os_memcpy(reply, "OK\n", 3);
1428         reply_len = 3;
1429
1430         if (os_strcmp(buf, "PING") == 0) {
1431                 os_memcpy(reply, "PONG\n", 5);
1432                 reply_len = 5;
1433         } else if (os_strncmp(buf, "RELOG", 5) == 0) {
1434                 if (wpa_debug_reopen_file() < 0)
1435                         reply_len = -1;
1436         } else if (os_strcmp(buf, "STATUS") == 0) {
1437                 reply_len = hostapd_ctrl_iface_status(hapd, reply,
1438                                                       reply_size);
1439         } else if (os_strcmp(buf, "STATUS-DRIVER") == 0) {
1440                 reply_len = hostapd_drv_status(hapd, reply, reply_size);
1441         } else if (os_strcmp(buf, "MIB") == 0) {
1442                 reply_len = ieee802_11_get_mib(hapd, reply, reply_size);
1443                 if (reply_len >= 0) {
1444                         res = wpa_get_mib(hapd->wpa_auth, reply + reply_len,
1445                                           reply_size - reply_len);
1446                         if (res < 0)
1447                                 reply_len = -1;
1448                         else
1449                                 reply_len += res;
1450                 }
1451                 if (reply_len >= 0) {
1452                         res = ieee802_1x_get_mib(hapd, reply + reply_len,
1453                                                  reply_size - reply_len);
1454                         if (res < 0)
1455                                 reply_len = -1;
1456                         else
1457                                 reply_len += res;
1458                 }
1459 #ifndef CONFIG_NO_RADIUS
1460                 if (reply_len >= 0) {
1461                         res = radius_client_get_mib(hapd->radius,
1462                                                     reply + reply_len,
1463                                                     reply_size - reply_len);
1464                         if (res < 0)
1465                                 reply_len = -1;
1466                         else
1467                                 reply_len += res;
1468                 }
1469 #endif /* CONFIG_NO_RADIUS */
1470         } else if (os_strncmp(buf, "MIB ", 4) == 0) {
1471                 reply_len = hostapd_ctrl_iface_mib(hapd, reply, reply_size,
1472                                                    buf + 4);
1473         } else if (os_strcmp(buf, "STA-FIRST") == 0) {
1474                 reply_len = hostapd_ctrl_iface_sta_first(hapd, reply,
1475                                                          reply_size);
1476         } else if (os_strncmp(buf, "STA ", 4) == 0) {
1477                 reply_len = hostapd_ctrl_iface_sta(hapd, buf + 4, reply,
1478                                                    reply_size);
1479         } else if (os_strncmp(buf, "STA-NEXT ", 9) == 0) {
1480                 reply_len = hostapd_ctrl_iface_sta_next(hapd, buf + 9, reply,
1481                                                         reply_size);
1482         } else if (os_strcmp(buf, "ATTACH") == 0) {
1483                 if (hostapd_ctrl_iface_attach(hapd, &from, fromlen))
1484                         reply_len = -1;
1485         } else if (os_strcmp(buf, "DETACH") == 0) {
1486                 if (hostapd_ctrl_iface_detach(hapd, &from, fromlen))
1487                         reply_len = -1;
1488         } else if (os_strncmp(buf, "LEVEL ", 6) == 0) {
1489                 if (hostapd_ctrl_iface_level(hapd, &from, fromlen,
1490                                                     buf + 6))
1491                         reply_len = -1;
1492         } else if (os_strncmp(buf, "NEW_STA ", 8) == 0) {
1493                 if (hostapd_ctrl_iface_new_sta(hapd, buf + 8))
1494                         reply_len = -1;
1495         } else if (os_strncmp(buf, "DEAUTHENTICATE ", 15) == 0) {
1496                 if (hostapd_ctrl_iface_deauthenticate(hapd, buf + 15))
1497                         reply_len = -1;
1498         } else if (os_strncmp(buf, "DISASSOCIATE ", 13) == 0) {
1499                 if (hostapd_ctrl_iface_disassociate(hapd, buf + 13))
1500                         reply_len = -1;
1501 #ifdef CONFIG_IEEE80211W
1502 #ifdef NEED_AP_MLME
1503         } else if (os_strncmp(buf, "SA_QUERY ", 9) == 0) {
1504                 if (hostapd_ctrl_iface_sa_query(hapd, buf + 9))
1505                         reply_len = -1;
1506 #endif /* NEED_AP_MLME */
1507 #endif /* CONFIG_IEEE80211W */
1508 #ifdef CONFIG_WPS
1509         } else if (os_strncmp(buf, "WPS_PIN ", 8) == 0) {
1510                 if (hostapd_ctrl_iface_wps_pin(hapd, buf + 8))
1511                         reply_len = -1;
1512         } else if (os_strncmp(buf, "WPS_CHECK_PIN ", 14) == 0) {
1513                 reply_len = hostapd_ctrl_iface_wps_check_pin(
1514                         hapd, buf + 14, reply, reply_size);
1515         } else if (os_strcmp(buf, "WPS_PBC") == 0) {
1516                 if (hostapd_wps_button_pushed(hapd, NULL))
1517                         reply_len = -1;
1518         } else if (os_strcmp(buf, "WPS_CANCEL") == 0) {
1519                 if (hostapd_wps_cancel(hapd))
1520                         reply_len = -1;
1521         } else if (os_strncmp(buf, "WPS_AP_PIN ", 11) == 0) {
1522                 reply_len = hostapd_ctrl_iface_wps_ap_pin(hapd, buf + 11,
1523                                                           reply, reply_size);
1524         } else if (os_strncmp(buf, "WPS_CONFIG ", 11) == 0) {
1525                 if (hostapd_ctrl_iface_wps_config(hapd, buf + 11) < 0)
1526                         reply_len = -1;
1527         } else if (os_strncmp(buf, "WPS_GET_STATUS", 13) == 0) {
1528                 reply_len = hostapd_ctrl_iface_wps_get_status(hapd, reply,
1529                                                               reply_size);
1530 #ifdef CONFIG_WPS_NFC
1531         } else if (os_strncmp(buf, "WPS_NFC_TAG_READ ", 17) == 0) {
1532                 if (hostapd_ctrl_iface_wps_nfc_tag_read(hapd, buf + 17))
1533                         reply_len = -1;
1534         } else if (os_strncmp(buf, "WPS_NFC_CONFIG_TOKEN ", 21) == 0) {
1535                 reply_len = hostapd_ctrl_iface_wps_nfc_config_token(
1536                         hapd, buf + 21, reply, reply_size);
1537         } else if (os_strncmp(buf, "WPS_NFC_TOKEN ", 14) == 0) {
1538                 reply_len = hostapd_ctrl_iface_wps_nfc_token(
1539                         hapd, buf + 14, reply, reply_size);
1540         } else if (os_strncmp(buf, "NFC_GET_HANDOVER_SEL ", 21) == 0) {
1541                 reply_len = hostapd_ctrl_iface_nfc_get_handover_sel(
1542                         hapd, buf + 21, reply, reply_size);
1543         } else if (os_strncmp(buf, "NFC_REPORT_HANDOVER ", 20) == 0) {
1544                 if (hostapd_ctrl_iface_nfc_report_handover(hapd, buf + 20))
1545                         reply_len = -1;
1546 #endif /* CONFIG_WPS_NFC */
1547 #endif /* CONFIG_WPS */
1548 #ifdef CONFIG_INTERWORKING
1549         } else if (os_strncmp(buf, "SET_QOS_MAP_SET ", 16) == 0) {
1550                 if (hostapd_ctrl_iface_set_qos_map_set(hapd, buf + 16))
1551                         reply_len = -1;
1552         } else if (os_strncmp(buf, "SEND_QOS_MAP_CONF ", 18) == 0) {
1553                 if (hostapd_ctrl_iface_send_qos_map_conf(hapd, buf + 18))
1554                         reply_len = -1;
1555 #endif /* CONFIG_INTERWORKING */
1556 #ifdef CONFIG_HS20
1557         } else if (os_strncmp(buf, "HS20_WNM_NOTIF ", 15) == 0) {
1558                 if (hostapd_ctrl_iface_hs20_wnm_notif(hapd, buf + 15))
1559                         reply_len = -1;
1560         } else if (os_strncmp(buf, "HS20_DEAUTH_REQ ", 16) == 0) {
1561                 if (hostapd_ctrl_iface_hs20_deauth_req(hapd, buf + 16))
1562                         reply_len = -1;
1563 #endif /* CONFIG_HS20 */
1564 #ifdef CONFIG_WNM
1565         } else if (os_strncmp(buf, "DISASSOC_IMMINENT ", 18) == 0) {
1566                 if (hostapd_ctrl_iface_disassoc_imminent(hapd, buf + 18))
1567                         reply_len = -1;
1568         } else if (os_strncmp(buf, "ESS_DISASSOC ", 13) == 0) {
1569                 if (hostapd_ctrl_iface_ess_disassoc(hapd, buf + 13))
1570                         reply_len = -1;
1571 #endif /* CONFIG_WNM */
1572         } else if (os_strcmp(buf, "GET_CONFIG") == 0) {
1573                 reply_len = hostapd_ctrl_iface_get_config(hapd, reply,
1574                                                           reply_size);
1575         } else if (os_strncmp(buf, "SET ", 4) == 0) {
1576                 if (hostapd_ctrl_iface_set(hapd, buf + 4))
1577                         reply_len = -1;
1578         } else if (os_strncmp(buf, "GET ", 4) == 0) {
1579                 reply_len = hostapd_ctrl_iface_get(hapd, buf + 4, reply,
1580                                                    reply_size);
1581         } else if (os_strncmp(buf, "ENABLE", 6) == 0) {
1582                 if (hostapd_ctrl_iface_enable(hapd->iface))
1583                         reply_len = -1;
1584         } else if (os_strncmp(buf, "RELOAD", 6) == 0) {
1585                 if (hostapd_ctrl_iface_reload(hapd->iface))
1586                         reply_len = -1;
1587         } else if (os_strncmp(buf, "DISABLE", 7) == 0) {
1588                 if (hostapd_ctrl_iface_disable(hapd->iface))
1589                         reply_len = -1;
1590 #ifdef CONFIG_TESTING_OPTIONS
1591         } else if (os_strncmp(buf, "RADAR ", 6) == 0) {
1592                 if (hostapd_ctrl_iface_radar(hapd, buf + 6))
1593                         reply_len = -1;
1594         } else if (os_strncmp(buf, "MGMT_TX ", 8) == 0) {
1595                 if (hostapd_ctrl_iface_mgmt_tx(hapd, buf + 8))
1596                         reply_len = -1;
1597         } else if (os_strncmp(buf, "EAPOL_RX ", 9) == 0) {
1598                 if (hostapd_ctrl_iface_eapol_rx(hapd, buf + 9) < 0)
1599                         reply_len = -1;
1600 #endif /* CONFIG_TESTING_OPTIONS */
1601         } else if (os_strncmp(buf, "CHAN_SWITCH ", 12) == 0) {
1602                 if (hostapd_ctrl_iface_chan_switch(hapd->iface, buf + 12))
1603                         reply_len = -1;
1604         } else if (os_strncmp(buf, "VENDOR ", 7) == 0) {
1605                 reply_len = hostapd_ctrl_iface_vendor(hapd, buf + 7, reply,
1606                                                       reply_size);
1607
1608         } else {
1609                 os_memcpy(reply, "UNKNOWN COMMAND\n", 16);
1610                 reply_len = 16;
1611         }
1612
1613         if (reply_len < 0) {
1614                 os_memcpy(reply, "FAIL\n", 5);
1615                 reply_len = 5;
1616         }
1617         if (sendto(sock, reply, reply_len, 0, (struct sockaddr *) &from,
1618                    fromlen) < 0) {
1619                 wpa_printf(MSG_DEBUG, "CTRL: sendto failed: %s",
1620                            strerror(errno));
1621         }
1622         os_free(reply);
1623 }
1624
1625
1626 static char * hostapd_ctrl_iface_path(struct hostapd_data *hapd)
1627 {
1628         char *buf;
1629         size_t len;
1630
1631         if (hapd->conf->ctrl_interface == NULL)
1632                 return NULL;
1633
1634         len = os_strlen(hapd->conf->ctrl_interface) +
1635                 os_strlen(hapd->conf->iface) + 2;
1636         buf = os_malloc(len);
1637         if (buf == NULL)
1638                 return NULL;
1639
1640         os_snprintf(buf, len, "%s/%s",
1641                     hapd->conf->ctrl_interface, hapd->conf->iface);
1642         buf[len - 1] = '\0';
1643         return buf;
1644 }
1645
1646
1647 static void hostapd_ctrl_iface_msg_cb(void *ctx, int level, int global,
1648                                       const char *txt, size_t len)
1649 {
1650         struct hostapd_data *hapd = ctx;
1651         if (hapd == NULL)
1652                 return;
1653         hostapd_ctrl_iface_send(hapd, level, txt, len);
1654 }
1655
1656
1657 int hostapd_ctrl_iface_init(struct hostapd_data *hapd)
1658 {
1659         struct sockaddr_un addr;
1660         int s = -1;
1661         char *fname = NULL;
1662
1663         if (hapd->ctrl_sock > -1) {
1664                 wpa_printf(MSG_DEBUG, "ctrl_iface already exists!");
1665                 return 0;
1666         }
1667
1668         if (hapd->conf->ctrl_interface == NULL)
1669                 return 0;
1670
1671         if (mkdir(hapd->conf->ctrl_interface, S_IRWXU | S_IRWXG) < 0) {
1672                 if (errno == EEXIST) {
1673                         wpa_printf(MSG_DEBUG, "Using existing control "
1674                                    "interface directory.");
1675                 } else {
1676                         perror("mkdir[ctrl_interface]");
1677                         goto fail;
1678                 }
1679         }
1680
1681         if (hapd->conf->ctrl_interface_gid_set &&
1682             chown(hapd->conf->ctrl_interface, -1,
1683                   hapd->conf->ctrl_interface_gid) < 0) {
1684                 perror("chown[ctrl_interface]");
1685                 return -1;
1686         }
1687
1688         if (!hapd->conf->ctrl_interface_gid_set &&
1689             hapd->iface->interfaces->ctrl_iface_group &&
1690             chown(hapd->conf->ctrl_interface, -1,
1691                   hapd->iface->interfaces->ctrl_iface_group) < 0) {
1692                 perror("chown[ctrl_interface]");
1693                 return -1;
1694         }
1695
1696 #ifdef ANDROID
1697         /*
1698          * Android is using umask 0077 which would leave the control interface
1699          * directory without group access. This breaks things since Wi-Fi
1700          * framework assumes that this directory can be accessed by other
1701          * applications in the wifi group. Fix this by adding group access even
1702          * if umask value would prevent this.
1703          */
1704         if (chmod(hapd->conf->ctrl_interface, S_IRWXU | S_IRWXG) < 0) {
1705                 wpa_printf(MSG_ERROR, "CTRL: Could not chmod directory: %s",
1706                            strerror(errno));
1707                 /* Try to continue anyway */
1708         }
1709 #endif /* ANDROID */
1710
1711         if (os_strlen(hapd->conf->ctrl_interface) + 1 +
1712             os_strlen(hapd->conf->iface) >= sizeof(addr.sun_path))
1713                 goto fail;
1714
1715         s = socket(PF_UNIX, SOCK_DGRAM, 0);
1716         if (s < 0) {
1717                 perror("socket(PF_UNIX)");
1718                 goto fail;
1719         }
1720
1721         os_memset(&addr, 0, sizeof(addr));
1722 #ifdef __FreeBSD__
1723         addr.sun_len = sizeof(addr);
1724 #endif /* __FreeBSD__ */
1725         addr.sun_family = AF_UNIX;
1726         fname = hostapd_ctrl_iface_path(hapd);
1727         if (fname == NULL)
1728                 goto fail;
1729         os_strlcpy(addr.sun_path, fname, sizeof(addr.sun_path));
1730         if (bind(s, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
1731                 wpa_printf(MSG_DEBUG, "ctrl_iface bind(PF_UNIX) failed: %s",
1732                            strerror(errno));
1733                 if (connect(s, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
1734                         wpa_printf(MSG_DEBUG, "ctrl_iface exists, but does not"
1735                                    " allow connections - assuming it was left"
1736                                    "over from forced program termination");
1737                         if (unlink(fname) < 0) {
1738                                 perror("unlink[ctrl_iface]");
1739                                 wpa_printf(MSG_ERROR, "Could not unlink "
1740                                            "existing ctrl_iface socket '%s'",
1741                                            fname);
1742                                 goto fail;
1743                         }
1744                         if (bind(s, (struct sockaddr *) &addr, sizeof(addr)) <
1745                             0) {
1746                                 perror("hostapd-ctrl-iface: bind(PF_UNIX)");
1747                                 goto fail;
1748                         }
1749                         wpa_printf(MSG_DEBUG, "Successfully replaced leftover "
1750                                    "ctrl_iface socket '%s'", fname);
1751                 } else {
1752                         wpa_printf(MSG_INFO, "ctrl_iface exists and seems to "
1753                                    "be in use - cannot override it");
1754                         wpa_printf(MSG_INFO, "Delete '%s' manually if it is "
1755                                    "not used anymore", fname);
1756                         os_free(fname);
1757                         fname = NULL;
1758                         goto fail;
1759                 }
1760         }
1761
1762         if (hapd->conf->ctrl_interface_gid_set &&
1763             chown(fname, -1, hapd->conf->ctrl_interface_gid) < 0) {
1764                 perror("chown[ctrl_interface/ifname]");
1765                 goto fail;
1766         }
1767
1768         if (!hapd->conf->ctrl_interface_gid_set &&
1769             hapd->iface->interfaces->ctrl_iface_group &&
1770             chown(fname, -1, hapd->iface->interfaces->ctrl_iface_group) < 0) {
1771                 perror("chown[ctrl_interface/ifname]");
1772                 goto fail;
1773         }
1774
1775         if (chmod(fname, S_IRWXU | S_IRWXG) < 0) {
1776                 perror("chmod[ctrl_interface/ifname]");
1777                 goto fail;
1778         }
1779         os_free(fname);
1780
1781         hapd->ctrl_sock = s;
1782         eloop_register_read_sock(s, hostapd_ctrl_iface_receive, hapd,
1783                                  NULL);
1784         hapd->msg_ctx = hapd;
1785         wpa_msg_register_cb(hostapd_ctrl_iface_msg_cb);
1786
1787         return 0;
1788
1789 fail:
1790         if (s >= 0)
1791                 close(s);
1792         if (fname) {
1793                 unlink(fname);
1794                 os_free(fname);
1795         }
1796         return -1;
1797 }
1798
1799
1800 void hostapd_ctrl_iface_deinit(struct hostapd_data *hapd)
1801 {
1802         struct wpa_ctrl_dst *dst, *prev;
1803
1804         if (hapd->ctrl_sock > -1) {
1805                 char *fname;
1806                 eloop_unregister_read_sock(hapd->ctrl_sock);
1807                 close(hapd->ctrl_sock);
1808                 hapd->ctrl_sock = -1;
1809                 fname = hostapd_ctrl_iface_path(hapd);
1810                 if (fname)
1811                         unlink(fname);
1812                 os_free(fname);
1813
1814                 if (hapd->conf->ctrl_interface &&
1815                     rmdir(hapd->conf->ctrl_interface) < 0) {
1816                         if (errno == ENOTEMPTY) {
1817                                 wpa_printf(MSG_DEBUG, "Control interface "
1818                                            "directory not empty - leaving it "
1819                                            "behind");
1820                         } else {
1821                                 wpa_printf(MSG_ERROR,
1822                                            "rmdir[ctrl_interface=%s]: %s",
1823                                            hapd->conf->ctrl_interface,
1824                                            strerror(errno));
1825                         }
1826                 }
1827         }
1828
1829         dst = hapd->ctrl_dst;
1830         while (dst) {
1831                 prev = dst;
1832                 dst = dst->next;
1833                 os_free(prev);
1834         }
1835 }
1836
1837
1838 static int hostapd_ctrl_iface_add(struct hapd_interfaces *interfaces,
1839                                   char *buf)
1840 {
1841         if (hostapd_add_iface(interfaces, buf) < 0) {
1842                 wpa_printf(MSG_ERROR, "Adding interface %s failed", buf);
1843                 return -1;
1844         }
1845         return 0;
1846 }
1847
1848
1849 static int hostapd_ctrl_iface_remove(struct hapd_interfaces *interfaces,
1850                                      char *buf)
1851 {
1852         if (hostapd_remove_iface(interfaces, buf) < 0) {
1853                 wpa_printf(MSG_ERROR, "Removing interface %s failed", buf);
1854                 return -1;
1855         }
1856         return 0;
1857 }
1858
1859
1860 static void hostapd_ctrl_iface_flush(struct hapd_interfaces *interfaces)
1861 {
1862 #ifdef CONFIG_WPS_TESTING
1863         wps_version_number = 0x20;
1864         wps_testing_dummy_cred = 0;
1865         wps_corrupt_pkhash = 0;
1866 #endif /* CONFIG_WPS_TESTING */
1867 }
1868
1869
1870 static void hostapd_global_ctrl_iface_receive(int sock, void *eloop_ctx,
1871                                               void *sock_ctx)
1872 {
1873         void *interfaces = eloop_ctx;
1874         char buf[256];
1875         int res;
1876         struct sockaddr_un from;
1877         socklen_t fromlen = sizeof(from);
1878         char reply[24];
1879         int reply_len;
1880
1881         res = recvfrom(sock, buf, sizeof(buf) - 1, 0,
1882                        (struct sockaddr *) &from, &fromlen);
1883         if (res < 0) {
1884                 perror("recvfrom(ctrl_iface)");
1885                 return;
1886         }
1887         buf[res] = '\0';
1888         wpa_printf(MSG_DEBUG, "Global ctrl_iface command: %s", buf);
1889
1890         os_memcpy(reply, "OK\n", 3);
1891         reply_len = 3;
1892
1893         if (os_strcmp(buf, "PING") == 0) {
1894                 os_memcpy(reply, "PONG\n", 5);
1895                 reply_len = 5;
1896         } else if (os_strncmp(buf, "RELOG", 5) == 0) {
1897                 if (wpa_debug_reopen_file() < 0)
1898                         reply_len = -1;
1899         } else if (os_strcmp(buf, "FLUSH") == 0) {
1900                 hostapd_ctrl_iface_flush(interfaces);
1901         } else if (os_strncmp(buf, "ADD ", 4) == 0) {
1902                 if (hostapd_ctrl_iface_add(interfaces, buf + 4) < 0)
1903                         reply_len = -1;
1904         } else if (os_strncmp(buf, "REMOVE ", 7) == 0) {
1905                 if (hostapd_ctrl_iface_remove(interfaces, buf + 7) < 0)
1906                         reply_len = -1;
1907 #ifdef CONFIG_MODULE_TESTS
1908         } else if (os_strcmp(buf, "MODULE_TESTS") == 0) {
1909                 int hapd_module_tests(void);
1910                 if (hapd_module_tests() < 0)
1911                         reply_len = -1;
1912 #endif /* CONFIG_MODULE_TESTS */
1913         } else {
1914                 wpa_printf(MSG_DEBUG, "Unrecognized global ctrl_iface command "
1915                            "ignored");
1916                 reply_len = -1;
1917         }
1918
1919         if (reply_len < 0) {
1920                 os_memcpy(reply, "FAIL\n", 5);
1921                 reply_len = 5;
1922         }
1923
1924         if (sendto(sock, reply, reply_len, 0, (struct sockaddr *) &from,
1925                    fromlen) < 0) {
1926                 wpa_printf(MSG_DEBUG, "CTRL: sendto failed: %s",
1927                            strerror(errno));
1928         }
1929 }
1930
1931
1932 static char * hostapd_global_ctrl_iface_path(struct hapd_interfaces *interface)
1933 {
1934         char *buf;
1935         size_t len;
1936
1937         if (interface->global_iface_path == NULL)
1938                 return NULL;
1939
1940         len = os_strlen(interface->global_iface_path) +
1941                 os_strlen(interface->global_iface_name) + 2;
1942         buf = os_malloc(len);
1943         if (buf == NULL)
1944                 return NULL;
1945
1946         os_snprintf(buf, len, "%s/%s", interface->global_iface_path,
1947                     interface->global_iface_name);
1948         buf[len - 1] = '\0';
1949         return buf;
1950 }
1951
1952
1953 int hostapd_global_ctrl_iface_init(struct hapd_interfaces *interface)
1954 {
1955         struct sockaddr_un addr;
1956         int s = -1;
1957         char *fname = NULL;
1958
1959         if (interface->global_iface_path == NULL) {
1960                 wpa_printf(MSG_DEBUG, "ctrl_iface not configured!");
1961                 return 0;
1962         }
1963
1964         if (mkdir(interface->global_iface_path, S_IRWXU | S_IRWXG) < 0) {
1965                 if (errno == EEXIST) {
1966                         wpa_printf(MSG_DEBUG, "Using existing control "
1967                                    "interface directory.");
1968                 } else {
1969                         perror("mkdir[ctrl_interface]");
1970                         goto fail;
1971                 }
1972         } else if (interface->ctrl_iface_group &&
1973                    chown(interface->global_iface_path, -1,
1974                          interface->ctrl_iface_group) < 0) {
1975                 perror("chown[ctrl_interface]");
1976                 goto fail;
1977         }
1978
1979         if (os_strlen(interface->global_iface_path) + 1 +
1980             os_strlen(interface->global_iface_name) >= sizeof(addr.sun_path))
1981                 goto fail;
1982
1983         s = socket(PF_UNIX, SOCK_DGRAM, 0);
1984         if (s < 0) {
1985                 perror("socket(PF_UNIX)");
1986                 goto fail;
1987         }
1988
1989         os_memset(&addr, 0, sizeof(addr));
1990 #ifdef __FreeBSD__
1991         addr.sun_len = sizeof(addr);
1992 #endif /* __FreeBSD__ */
1993         addr.sun_family = AF_UNIX;
1994         fname = hostapd_global_ctrl_iface_path(interface);
1995         if (fname == NULL)
1996                 goto fail;
1997         os_strlcpy(addr.sun_path, fname, sizeof(addr.sun_path));
1998         if (bind(s, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
1999                 wpa_printf(MSG_DEBUG, "ctrl_iface bind(PF_UNIX) failed: %s",
2000                            strerror(errno));
2001                 if (connect(s, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
2002                         wpa_printf(MSG_DEBUG, "ctrl_iface exists, but does not"
2003                                    " allow connections - assuming it was left"
2004                                    "over from forced program termination");
2005                         if (unlink(fname) < 0) {
2006                                 perror("unlink[ctrl_iface]");
2007                                 wpa_printf(MSG_ERROR, "Could not unlink "
2008                                            "existing ctrl_iface socket '%s'",
2009                                            fname);
2010                                 goto fail;
2011                         }
2012                         if (bind(s, (struct sockaddr *) &addr, sizeof(addr)) <
2013                             0) {
2014                                 perror("bind(PF_UNIX)");
2015                                 goto fail;
2016                         }
2017                         wpa_printf(MSG_DEBUG, "Successfully replaced leftover "
2018                                    "ctrl_iface socket '%s'", fname);
2019                 } else {
2020                         wpa_printf(MSG_INFO, "ctrl_iface exists and seems to "
2021                                    "be in use - cannot override it");
2022                         wpa_printf(MSG_INFO, "Delete '%s' manually if it is "
2023                                    "not used anymore", fname);
2024                         os_free(fname);
2025                         fname = NULL;
2026                         goto fail;
2027                 }
2028         }
2029
2030         if (interface->ctrl_iface_group &&
2031             chown(fname, -1, interface->ctrl_iface_group) < 0) {
2032                 perror("chown[ctrl_interface]");
2033                 goto fail;
2034         }
2035
2036         if (chmod(fname, S_IRWXU | S_IRWXG) < 0) {
2037                 perror("chmod[ctrl_interface/ifname]");
2038                 goto fail;
2039         }
2040         os_free(fname);
2041
2042         interface->global_ctrl_sock = s;
2043         eloop_register_read_sock(s, hostapd_global_ctrl_iface_receive,
2044                                  interface, NULL);
2045
2046         return 0;
2047
2048 fail:
2049         if (s >= 0)
2050                 close(s);
2051         if (fname) {
2052                 unlink(fname);
2053                 os_free(fname);
2054         }
2055         return -1;
2056 }
2057
2058
2059 void hostapd_global_ctrl_iface_deinit(struct hapd_interfaces *interfaces)
2060 {
2061         char *fname = NULL;
2062
2063         if (interfaces->global_ctrl_sock > -1) {
2064                 eloop_unregister_read_sock(interfaces->global_ctrl_sock);
2065                 close(interfaces->global_ctrl_sock);
2066                 interfaces->global_ctrl_sock = -1;
2067                 fname = hostapd_global_ctrl_iface_path(interfaces);
2068                 if (fname) {
2069                         unlink(fname);
2070                         os_free(fname);
2071                 }
2072
2073                 if (interfaces->global_iface_path &&
2074                     rmdir(interfaces->global_iface_path) < 0) {
2075                         if (errno == ENOTEMPTY) {
2076                                 wpa_printf(MSG_DEBUG, "Control interface "
2077                                            "directory not empty - leaving it "
2078                                            "behind");
2079                         } else {
2080                                 wpa_printf(MSG_ERROR,
2081                                            "rmdir[ctrl_interface=%s]: %s",
2082                                            interfaces->global_iface_path,
2083                                            strerror(errno));
2084                         }
2085                 }
2086                 os_free(interfaces->global_iface_path);
2087                 interfaces->global_iface_path = NULL;
2088         }
2089 }
2090
2091
2092 static void hostapd_ctrl_iface_send(struct hostapd_data *hapd, int level,
2093                                     const char *buf, size_t len)
2094 {
2095         struct wpa_ctrl_dst *dst, *next;
2096         struct msghdr msg;
2097         int idx;
2098         struct iovec io[2];
2099         char levelstr[10];
2100
2101         dst = hapd->ctrl_dst;
2102         if (hapd->ctrl_sock < 0 || dst == NULL)
2103                 return;
2104
2105         os_snprintf(levelstr, sizeof(levelstr), "<%d>", level);
2106         io[0].iov_base = levelstr;
2107         io[0].iov_len = os_strlen(levelstr);
2108         io[1].iov_base = (char *) buf;
2109         io[1].iov_len = len;
2110         os_memset(&msg, 0, sizeof(msg));
2111         msg.msg_iov = io;
2112         msg.msg_iovlen = 2;
2113
2114         idx = 0;
2115         while (dst) {
2116                 next = dst->next;
2117                 if (level >= dst->debug_level) {
2118                         wpa_hexdump(MSG_DEBUG, "CTRL_IFACE monitor send",
2119                                     (u8 *) dst->addr.sun_path, dst->addrlen -
2120                                     offsetof(struct sockaddr_un, sun_path));
2121                         msg.msg_name = &dst->addr;
2122                         msg.msg_namelen = dst->addrlen;
2123                         if (sendmsg(hapd->ctrl_sock, &msg, 0) < 0) {
2124                                 int _errno = errno;
2125                                 wpa_printf(MSG_INFO, "CTRL_IFACE monitor[%d]: "
2126                                            "%d - %s",
2127                                            idx, errno, strerror(errno));
2128                                 dst->errors++;
2129                                 if (dst->errors > 10 || _errno == ENOENT) {
2130                                         hostapd_ctrl_iface_detach(
2131                                                 hapd, &dst->addr,
2132                                                 dst->addrlen);
2133                                 }
2134                         } else
2135                                 dst->errors = 0;
2136                 }
2137                 idx++;
2138                 dst = next;
2139         }
2140 }
2141
2142 #endif /* CONFIG_NATIVE_WINDOWS */