1 /* 2 * wpa_supplicant/hostapd control interface library 3 * Copyright (c) 2004-2007, 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 "includes.h" 10 11 #ifdef CONFIG_CTRL_IFACE 12 13 #ifdef CONFIG_CTRL_IFACE_UNIX 14 #include <sys/stat.h> 15 #include <fcntl.h> 16 #include <sys/un.h> 17 #include <unistd.h> 18 #include <fcntl.h> 19 #endif /* CONFIG_CTRL_IFACE_UNIX */ 20 #ifdef CONFIG_CTRL_IFACE_UDP_REMOTE 21 #include <netdb.h> 22 #endif /* CONFIG_CTRL_IFACE_UDP_REMOTE */ 23 24 #ifdef ANDROID 25 #include <dirent.h> 26 #include <sys/stat.h> 27 #include <cutils/sockets.h> 28 #include "private/android_filesystem_config.h" 29 #endif /* ANDROID */ 30 31 #ifdef CONFIG_CTRL_IFACE_UDP_IPV6 32 #include <net/if.h> 33 #endif /* CONFIG_CTRL_IFACE_UDP_IPV6 */ 34 35 #include "wpa_ctrl.h" 36 #include "common.h" 37 38 39 #if defined(CONFIG_CTRL_IFACE_UNIX) || defined(CONFIG_CTRL_IFACE_UDP) 40 #define CTRL_IFACE_SOCKET 41 #endif /* CONFIG_CTRL_IFACE_UNIX || CONFIG_CTRL_IFACE_UDP */ 42 43 44 /** 45 * struct wpa_ctrl - Internal structure for control interface library 46 * 47 * This structure is used by the wpa_supplicant/hostapd control interface 48 * library to store internal data. Programs using the library should not touch 49 * this data directly. They can only use the pointer to the data structure as 50 * an identifier for the control interface connection and use this as one of 51 * the arguments for most of the control interface library functions. 52 */ 53 struct wpa_ctrl { 54 #ifdef CONFIG_CTRL_IFACE_UDP 55 int s; 56 #ifdef CONFIG_CTRL_IFACE_UDP_IPV6 57 struct sockaddr_in6 local; 58 struct sockaddr_in6 dest; 59 #else /* CONFIG_CTRL_IFACE_UDP_IPV6 */ 60 struct sockaddr_in local; 61 struct sockaddr_in dest; 62 #endif /* CONFIG_CTRL_IFACE_UDP_IPV6 */ 63 char *cookie; 64 char *remote_ifname; 65 char *remote_ip; 66 #endif /* CONFIG_CTRL_IFACE_UDP */ 67 #ifdef CONFIG_CTRL_IFACE_UNIX 68 int s; 69 struct sockaddr_un local; 70 struct sockaddr_un dest; 71 #endif /* CONFIG_CTRL_IFACE_UNIX */ 72 #ifdef CONFIG_CTRL_IFACE_NAMED_PIPE 73 HANDLE pipe; 74 #endif /* CONFIG_CTRL_IFACE_NAMED_PIPE */ 75 }; 76 77 78 #ifdef CONFIG_CTRL_IFACE_UNIX 79 80 #ifndef CONFIG_CTRL_IFACE_CLIENT_DIR 81 #define CONFIG_CTRL_IFACE_CLIENT_DIR "/tmp" 82 #endif /* CONFIG_CTRL_IFACE_CLIENT_DIR */ 83 #ifndef CONFIG_CTRL_IFACE_CLIENT_PREFIX 84 #define CONFIG_CTRL_IFACE_CLIENT_PREFIX "wpa_ctrl_" 85 #endif /* CONFIG_CTRL_IFACE_CLIENT_PREFIX */ 86 87 wpa_ctrl_open(const char * ctrl_path)88 struct wpa_ctrl * wpa_ctrl_open(const char *ctrl_path) 89 { 90 return wpa_ctrl_open2(ctrl_path, NULL); 91 } 92 93 wpa_ctrl_open2(const char * ctrl_path,const char * cli_path)94 struct wpa_ctrl * wpa_ctrl_open2(const char *ctrl_path, 95 const char *cli_path) 96 { 97 struct wpa_ctrl *ctrl; 98 static int counter = 0; 99 int ret; 100 size_t res; 101 int tries = 0; 102 int flags; 103 104 if (ctrl_path == NULL) 105 return NULL; 106 107 ctrl = os_zalloc(sizeof(*ctrl)); 108 if (ctrl == NULL) 109 return NULL; 110 111 ctrl->s = socket(PF_UNIX, SOCK_DGRAM, 0); 112 if (ctrl->s < 0) { 113 os_free(ctrl); 114 return NULL; 115 } 116 117 ctrl->local.sun_family = AF_UNIX; 118 counter++; 119 try_again: 120 if (cli_path && cli_path[0] == '/') { 121 ret = os_snprintf(ctrl->local.sun_path, 122 sizeof(ctrl->local.sun_path), 123 "%s/" CONFIG_CTRL_IFACE_CLIENT_PREFIX "%d-%d", 124 cli_path, (int) getpid(), counter); 125 } else { 126 ret = os_snprintf(ctrl->local.sun_path, 127 sizeof(ctrl->local.sun_path), 128 CONFIG_CTRL_IFACE_CLIENT_DIR "/" 129 CONFIG_CTRL_IFACE_CLIENT_PREFIX "%d-%d", 130 (int) getpid(), counter); 131 } 132 if (os_snprintf_error(sizeof(ctrl->local.sun_path), ret)) { 133 close(ctrl->s); 134 os_free(ctrl); 135 return NULL; 136 } 137 tries++; 138 #ifdef ANDROID 139 /* Set client socket file permissions so that bind() creates the client 140 * socket with these permissions and there is no need to try to change 141 * them with chmod() after bind() which would have potential issues with 142 * race conditions. These permissions are needed to make sure the server 143 * side (wpa_supplicant or hostapd) can reply to the control interface 144 * messages. 145 * 146 * The lchown() calls below after bind() are also part of the needed 147 * operations to allow the response to go through. Those are using the 148 * no-deference-symlinks version to avoid races. */ 149 fchmod(ctrl->s, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP); 150 #endif /* ANDROID */ 151 if (bind(ctrl->s, (struct sockaddr *) &ctrl->local, 152 sizeof(ctrl->local)) < 0) { 153 if (errno == EADDRINUSE && tries < 2) { 154 /* 155 * getpid() returns unique identifier for this instance 156 * of wpa_ctrl, so the existing socket file must have 157 * been left by unclean termination of an earlier run. 158 * Remove the file and try again. 159 */ 160 unlink(ctrl->local.sun_path); 161 goto try_again; 162 } 163 close(ctrl->s); 164 os_free(ctrl); 165 return NULL; 166 } 167 168 #ifdef ANDROID 169 /* Set group even if we do not have privileges to change owner */ 170 lchown(ctrl->local.sun_path, -1, AID_WIFI); 171 lchown(ctrl->local.sun_path, AID_SYSTEM, AID_WIFI); 172 173 if (os_strncmp(ctrl_path, "@android:", 9) == 0) { 174 if (socket_local_client_connect( 175 ctrl->s, ctrl_path + 9, 176 ANDROID_SOCKET_NAMESPACE_RESERVED, 177 SOCK_DGRAM) < 0) { 178 close(ctrl->s); 179 unlink(ctrl->local.sun_path); 180 os_free(ctrl); 181 return NULL; 182 } 183 return ctrl; 184 } 185 186 /* 187 * If the ctrl_path isn't an absolute pathname, assume that 188 * it's the name of a socket in the Android reserved namespace. 189 * Otherwise, it's a normal UNIX domain socket appearing in the 190 * filesystem. 191 */ 192 if (*ctrl_path != '/') { 193 char buf[21]; 194 os_snprintf(buf, sizeof(buf), "wpa_%s", ctrl_path); 195 if (socket_local_client_connect( 196 ctrl->s, buf, 197 ANDROID_SOCKET_NAMESPACE_RESERVED, 198 SOCK_DGRAM) < 0) { 199 close(ctrl->s); 200 unlink(ctrl->local.sun_path); 201 os_free(ctrl); 202 return NULL; 203 } 204 return ctrl; 205 } 206 #endif /* ANDROID */ 207 208 ctrl->dest.sun_family = AF_UNIX; 209 if (os_strncmp(ctrl_path, "@abstract:", 10) == 0) { 210 ctrl->dest.sun_path[0] = '\0'; 211 os_strlcpy(ctrl->dest.sun_path + 1, ctrl_path + 10, 212 sizeof(ctrl->dest.sun_path) - 1); 213 } else { 214 res = os_strlcpy(ctrl->dest.sun_path, ctrl_path, 215 sizeof(ctrl->dest.sun_path)); 216 if (res >= sizeof(ctrl->dest.sun_path)) { 217 close(ctrl->s); 218 os_free(ctrl); 219 return NULL; 220 } 221 } 222 if (connect(ctrl->s, (struct sockaddr *) &ctrl->dest, 223 sizeof(ctrl->dest)) < 0) { 224 close(ctrl->s); 225 unlink(ctrl->local.sun_path); 226 os_free(ctrl); 227 return NULL; 228 } 229 230 /* 231 * Make socket non-blocking so that we don't hang forever if 232 * target dies unexpectedly. 233 */ 234 flags = fcntl(ctrl->s, F_GETFL); 235 if (flags >= 0) { 236 flags |= O_NONBLOCK; 237 if (fcntl(ctrl->s, F_SETFL, flags) < 0) { 238 perror("fcntl(ctrl->s, O_NONBLOCK)"); 239 /* Not fatal, continue on.*/ 240 } 241 } 242 243 return ctrl; 244 } 245 246 wpa_ctrl_close(struct wpa_ctrl * ctrl)247 void wpa_ctrl_close(struct wpa_ctrl *ctrl) 248 { 249 if (ctrl == NULL) 250 return; 251 unlink(ctrl->local.sun_path); 252 if (ctrl->s >= 0) 253 close(ctrl->s); 254 os_free(ctrl); 255 } 256 257 258 #ifdef ANDROID 259 /** 260 * wpa_ctrl_cleanup() - Delete any local UNIX domain socket files that 261 * may be left over from clients that were previously connected to 262 * wpa_supplicant. This keeps these files from being orphaned in the 263 * event of crashes that prevented them from being removed as part 264 * of the normal orderly shutdown. 265 */ wpa_ctrl_cleanup(void)266 void wpa_ctrl_cleanup(void) 267 { 268 DIR *dir; 269 struct dirent *result; 270 size_t dirnamelen; 271 size_t maxcopy; 272 char pathname[PATH_MAX]; 273 char *namep; 274 275 if ((dir = opendir(CONFIG_CTRL_IFACE_CLIENT_DIR)) == NULL) 276 return; 277 278 dirnamelen = (size_t) os_snprintf(pathname, sizeof(pathname), "%s/", 279 CONFIG_CTRL_IFACE_CLIENT_DIR); 280 if (dirnamelen >= sizeof(pathname)) { 281 closedir(dir); 282 return; 283 } 284 namep = pathname + dirnamelen; 285 maxcopy = PATH_MAX - dirnamelen; 286 while ((result = readdir(dir)) != NULL) { 287 if (os_strlcpy(namep, result->d_name, maxcopy) < maxcopy) 288 unlink(pathname); 289 } 290 closedir(dir); 291 } 292 #endif /* ANDROID */ 293 294 #else /* CONFIG_CTRL_IFACE_UNIX */ 295 296 #ifdef ANDROID wpa_ctrl_cleanup(void)297 void wpa_ctrl_cleanup(void) 298 { 299 } 300 #endif /* ANDROID */ 301 302 #endif /* CONFIG_CTRL_IFACE_UNIX */ 303 304 305 #ifdef CONFIG_CTRL_IFACE_UDP 306 wpa_ctrl_open(const char * ctrl_path)307 struct wpa_ctrl * wpa_ctrl_open(const char *ctrl_path) 308 { 309 struct wpa_ctrl *ctrl; 310 char buf[128]; 311 size_t len; 312 #ifdef CONFIG_CTRL_IFACE_UDP_REMOTE 313 struct hostent *h; 314 #endif /* CONFIG_CTRL_IFACE_UDP_REMOTE */ 315 316 ctrl = os_zalloc(sizeof(*ctrl)); 317 if (ctrl == NULL) 318 return NULL; 319 320 #ifdef CONFIG_CTRL_IFACE_UDP_IPV6 321 ctrl->s = socket(PF_INET6, SOCK_DGRAM, 0); 322 #else /* CONFIG_CTRL_IFACE_UDP_IPV6 */ 323 ctrl->s = socket(PF_INET, SOCK_DGRAM, 0); 324 #endif /* CONFIG_CTRL_IFACE_UDP_IPV6 */ 325 if (ctrl->s < 0) { 326 perror("socket"); 327 os_free(ctrl); 328 return NULL; 329 } 330 331 #ifdef CONFIG_CTRL_IFACE_UDP_IPV6 332 ctrl->local.sin6_family = AF_INET6; 333 #ifdef CONFIG_CTRL_IFACE_UDP_REMOTE 334 ctrl->local.sin6_addr = in6addr_any; 335 #else /* CONFIG_CTRL_IFACE_UDP_REMOTE */ 336 inet_pton(AF_INET6, "::1", &ctrl->local.sin6_addr); 337 #endif /* CONFIG_CTRL_IFACE_UDP_REMOTE */ 338 #else /* CONFIG_CTRL_IFACE_UDP_IPV6 */ 339 ctrl->local.sin_family = AF_INET; 340 #ifdef CONFIG_CTRL_IFACE_UDP_REMOTE 341 ctrl->local.sin_addr.s_addr = INADDR_ANY; 342 #else /* CONFIG_CTRL_IFACE_UDP_REMOTE */ 343 ctrl->local.sin_addr.s_addr = htonl((127 << 24) | 1); 344 #endif /* CONFIG_CTRL_IFACE_UDP_REMOTE */ 345 #endif /* CONFIG_CTRL_IFACE_UDP_IPV6 */ 346 347 if (bind(ctrl->s, (struct sockaddr *) &ctrl->local, 348 sizeof(ctrl->local)) < 0) { 349 close(ctrl->s); 350 os_free(ctrl); 351 return NULL; 352 } 353 354 #ifdef CONFIG_CTRL_IFACE_UDP_IPV6 355 ctrl->dest.sin6_family = AF_INET6; 356 inet_pton(AF_INET6, "::1", &ctrl->dest.sin6_addr); 357 ctrl->dest.sin6_port = htons(WPA_CTRL_IFACE_PORT); 358 #else /* CONFIG_CTRL_IFACE_UDP_IPV6 */ 359 ctrl->dest.sin_family = AF_INET; 360 ctrl->dest.sin_addr.s_addr = htonl((127 << 24) | 1); 361 ctrl->dest.sin_port = htons(WPA_CTRL_IFACE_PORT); 362 #endif /* CONFIG_CTRL_IFACE_UDP_IPV6 */ 363 364 #ifdef CONFIG_CTRL_IFACE_UDP_REMOTE 365 if (ctrl_path) { 366 char *port, *name; 367 int port_id; 368 #ifdef CONFIG_CTRL_IFACE_UDP_IPV6 369 char *scope; 370 int scope_id = 0; 371 #endif /* CONFIG_CTRL_IFACE_UDP_IPV6 */ 372 373 name = os_strdup(ctrl_path); 374 if (name == NULL) { 375 close(ctrl->s); 376 os_free(ctrl); 377 return NULL; 378 } 379 #ifdef CONFIG_CTRL_IFACE_UDP_IPV6 380 port = os_strchr(name, ','); 381 #else /* CONFIG_CTRL_IFACE_UDP_IPV6 */ 382 port = os_strchr(name, ':'); 383 #endif /* CONFIG_CTRL_IFACE_UDP_IPV6 */ 384 385 if (port) { 386 port_id = atoi(&port[1]); 387 port[0] = '\0'; 388 } else 389 port_id = WPA_CTRL_IFACE_PORT; 390 391 #ifdef CONFIG_CTRL_IFACE_UDP_IPV6 392 scope = os_strchr(name, '%'); 393 if (scope) { 394 scope_id = if_nametoindex(&scope[1]); 395 scope[0] = '\0'; 396 } 397 h = gethostbyname2(name, AF_INET6); 398 #else /* CONFIG_CTRL_IFACE_UDP_IPV6 */ 399 h = gethostbyname(name); 400 #endif /* CONFIG_CTRL_IFACE_UDP_IPV6 */ 401 ctrl->remote_ip = os_strdup(name); 402 os_free(name); 403 if (h == NULL) { 404 perror("gethostbyname"); 405 close(ctrl->s); 406 os_free(ctrl->remote_ip); 407 os_free(ctrl); 408 return NULL; 409 } 410 #ifdef CONFIG_CTRL_IFACE_UDP_IPV6 411 ctrl->dest.sin6_scope_id = scope_id; 412 ctrl->dest.sin6_port = htons(port_id); 413 os_memcpy(&ctrl->dest.sin6_addr, h->h_addr, h->h_length); 414 #else /* CONFIG_CTRL_IFACE_UDP_IPV6 */ 415 ctrl->dest.sin_port = htons(port_id); 416 os_memcpy(&ctrl->dest.sin_addr.s_addr, h->h_addr, h->h_length); 417 #endif /* CONFIG_CTRL_IFACE_UDP_IPV6 */ 418 } else 419 ctrl->remote_ip = os_strdup("localhost"); 420 #endif /* CONFIG_CTRL_IFACE_UDP_REMOTE */ 421 422 if (connect(ctrl->s, (struct sockaddr *) &ctrl->dest, 423 sizeof(ctrl->dest)) < 0) { 424 #ifdef CONFIG_CTRL_IFACE_UDP_IPV6 425 char addr[INET6_ADDRSTRLEN]; 426 wpa_printf(MSG_ERROR, "connect(%s:%d) failed: %s", 427 inet_ntop(AF_INET6, &ctrl->dest.sin6_addr, addr, 428 sizeof(ctrl->dest)), 429 ntohs(ctrl->dest.sin6_port), 430 strerror(errno)); 431 #else /* CONFIG_CTRL_IFACE_UDP_IPV6 */ 432 wpa_printf(MSG_ERROR, "connect(%s:%d) failed: %s", 433 inet_ntoa(ctrl->dest.sin_addr), 434 ntohs(ctrl->dest.sin_port), 435 strerror(errno)); 436 #endif /* CONFIG_CTRL_IFACE_UDP_IPV6 */ 437 close(ctrl->s); 438 os_free(ctrl->remote_ip); 439 os_free(ctrl); 440 return NULL; 441 } 442 443 len = sizeof(buf) - 1; 444 if (wpa_ctrl_request(ctrl, "GET_COOKIE", 10, buf, &len, NULL) == 0) { 445 buf[len] = '\0'; 446 ctrl->cookie = os_strdup(buf); 447 } 448 449 if (wpa_ctrl_request(ctrl, "IFNAME", 6, buf, &len, NULL) == 0) { 450 buf[len] = '\0'; 451 ctrl->remote_ifname = os_strdup(buf); 452 } 453 454 return ctrl; 455 } 456 457 wpa_ctrl_get_remote_ifname(struct wpa_ctrl * ctrl)458 char * wpa_ctrl_get_remote_ifname(struct wpa_ctrl *ctrl) 459 { 460 #define WPA_CTRL_MAX_PS_NAME 100 461 static char ps[WPA_CTRL_MAX_PS_NAME] = {}; 462 os_snprintf(ps, WPA_CTRL_MAX_PS_NAME, "%s/%s", 463 ctrl->remote_ip, ctrl->remote_ifname); 464 return ps; 465 } 466 467 wpa_ctrl_close(struct wpa_ctrl * ctrl)468 void wpa_ctrl_close(struct wpa_ctrl *ctrl) 469 { 470 close(ctrl->s); 471 os_free(ctrl->cookie); 472 os_free(ctrl->remote_ifname); 473 os_free(ctrl->remote_ip); 474 os_free(ctrl); 475 } 476 477 #endif /* CONFIG_CTRL_IFACE_UDP */ 478 479 480 #ifdef CTRL_IFACE_SOCKET wpa_ctrl_request(struct wpa_ctrl * ctrl,const char * cmd,size_t cmd_len,char * reply,size_t * reply_len,void (* msg_cb)(char * msg,size_t len))481 int wpa_ctrl_request(struct wpa_ctrl *ctrl, const char *cmd, size_t cmd_len, 482 char *reply, size_t *reply_len, 483 void (*msg_cb)(char *msg, size_t len)) 484 { 485 struct timeval tv; 486 struct os_reltime started_at, ending_at; 487 int res; 488 fd_set rfds; 489 const char *_cmd; 490 char *cmd_buf = NULL; 491 size_t _cmd_len; 492 493 #ifdef CONFIG_CTRL_IFACE_UDP 494 if (ctrl->cookie) { 495 char *pos; 496 _cmd_len = os_strlen(ctrl->cookie) + 1 + cmd_len; 497 cmd_buf = os_malloc(_cmd_len); 498 if (cmd_buf == NULL) 499 return -1; 500 _cmd = cmd_buf; 501 pos = cmd_buf; 502 os_strlcpy(pos, ctrl->cookie, _cmd_len); 503 pos += os_strlen(ctrl->cookie); 504 *pos++ = ' '; 505 os_memcpy(pos, cmd, cmd_len); 506 } else 507 #endif /* CONFIG_CTRL_IFACE_UDP */ 508 { 509 _cmd = cmd; 510 _cmd_len = cmd_len; 511 } 512 513 errno = 0; 514 started_at.sec = 0; 515 started_at.usec = 0; 516 retry_send: 517 if (send(ctrl->s, _cmd, _cmd_len, 0) < 0) { 518 if (errno == EAGAIN || errno == EBUSY || errno == EWOULDBLOCK) 519 { 520 /* 521 * Must be a non-blocking socket... Try for a bit 522 * longer before giving up. 523 */ 524 if (started_at.sec == 0) 525 os_get_reltime(&started_at); 526 else { 527 struct os_reltime n; 528 os_get_reltime(&n); 529 /* Try for a few seconds. */ 530 if (os_reltime_expired(&n, &started_at, 5)) 531 goto send_err; 532 } 533 os_sleep(1, 0); 534 goto retry_send; 535 } 536 send_err: 537 os_free(cmd_buf); 538 return -1; 539 } 540 os_free(cmd_buf); 541 542 os_get_reltime(&ending_at); 543 ending_at.sec += 10; 544 545 for (;;) { 546 struct os_reltime diff; 547 548 os_get_reltime(&started_at); 549 if (os_reltime_before(&ending_at, &started_at)) 550 return -2; 551 os_reltime_sub(&ending_at, &started_at, &diff); 552 tv.tv_sec = diff.sec; 553 tv.tv_usec = diff.usec; 554 555 FD_ZERO(&rfds); 556 FD_SET(ctrl->s, &rfds); 557 res = select(ctrl->s + 1, &rfds, NULL, NULL, &tv); 558 if (res < 0 && errno == EINTR) 559 continue; 560 if (res < 0) 561 return res; 562 if (FD_ISSET(ctrl->s, &rfds)) { 563 res = recv(ctrl->s, reply, *reply_len, 0); 564 if (res < 0) 565 return res; 566 if ((res > 0 && reply[0] == '<') || 567 (res > 6 && strncmp(reply, "IFNAME=", 7) == 0)) { 568 /* This is an unsolicited message from 569 * wpa_supplicant, not the reply to the 570 * request. Use msg_cb to report this to the 571 * caller. */ 572 if (msg_cb) { 573 /* Make sure the message is nul 574 * terminated. */ 575 if ((size_t) res == *reply_len) 576 res = (*reply_len) - 1; 577 reply[res] = '\0'; 578 msg_cb(reply, res); 579 } 580 continue; 581 } 582 *reply_len = res; 583 break; 584 } else { 585 return -2; 586 } 587 } 588 return 0; 589 } 590 #endif /* CTRL_IFACE_SOCKET */ 591 592 wpa_ctrl_attach_helper(struct wpa_ctrl * ctrl,int attach)593 static int wpa_ctrl_attach_helper(struct wpa_ctrl *ctrl, int attach) 594 { 595 char buf[10]; 596 int ret; 597 size_t len = 10; 598 599 ret = wpa_ctrl_request(ctrl, attach ? "ATTACH" : "DETACH", 6, 600 buf, &len, NULL); 601 if (ret < 0) 602 return ret; 603 if (len == 3 && os_memcmp(buf, "OK\n", 3) == 0) 604 return 0; 605 return -1; 606 } 607 608 wpa_ctrl_attach(struct wpa_ctrl * ctrl)609 int wpa_ctrl_attach(struct wpa_ctrl *ctrl) 610 { 611 return wpa_ctrl_attach_helper(ctrl, 1); 612 } 613 614 wpa_ctrl_detach(struct wpa_ctrl * ctrl)615 int wpa_ctrl_detach(struct wpa_ctrl *ctrl) 616 { 617 return wpa_ctrl_attach_helper(ctrl, 0); 618 } 619 620 621 #ifdef CTRL_IFACE_SOCKET 622 wpa_ctrl_recv(struct wpa_ctrl * ctrl,char * reply,size_t * reply_len)623 int wpa_ctrl_recv(struct wpa_ctrl *ctrl, char *reply, size_t *reply_len) 624 { 625 int res; 626 627 res = recv(ctrl->s, reply, *reply_len, 0); 628 if (res < 0) 629 return res; 630 *reply_len = res; 631 return 0; 632 } 633 634 wpa_ctrl_pending(struct wpa_ctrl * ctrl)635 int wpa_ctrl_pending(struct wpa_ctrl *ctrl) 636 { 637 struct timeval tv; 638 fd_set rfds; 639 tv.tv_sec = 0; 640 tv.tv_usec = 0; 641 FD_ZERO(&rfds); 642 FD_SET(ctrl->s, &rfds); 643 select(ctrl->s + 1, &rfds, NULL, NULL, &tv); 644 return FD_ISSET(ctrl->s, &rfds); 645 } 646 647 wpa_ctrl_get_fd(struct wpa_ctrl * ctrl)648 int wpa_ctrl_get_fd(struct wpa_ctrl *ctrl) 649 { 650 return ctrl->s; 651 } 652 653 #endif /* CTRL_IFACE_SOCKET */ 654 655 656 #ifdef CONFIG_CTRL_IFACE_NAMED_PIPE 657 658 #ifndef WPA_SUPPLICANT_NAMED_PIPE 659 #define WPA_SUPPLICANT_NAMED_PIPE "WpaSupplicant" 660 #endif 661 #define NAMED_PIPE_PREFIX TEXT("\\\\.\\pipe\\") TEXT(WPA_SUPPLICANT_NAMED_PIPE) 662 wpa_ctrl_open(const char * ctrl_path)663 struct wpa_ctrl * wpa_ctrl_open(const char *ctrl_path) 664 { 665 struct wpa_ctrl *ctrl; 666 DWORD mode; 667 TCHAR name[256]; 668 int i, ret; 669 670 ctrl = os_malloc(sizeof(*ctrl)); 671 if (ctrl == NULL) 672 return NULL; 673 os_memset(ctrl, 0, sizeof(*ctrl)); 674 675 #ifdef UNICODE 676 if (ctrl_path == NULL) 677 ret = _snwprintf(name, 256, NAMED_PIPE_PREFIX); 678 else 679 ret = _snwprintf(name, 256, NAMED_PIPE_PREFIX TEXT("-%S"), 680 ctrl_path); 681 #else /* UNICODE */ 682 if (ctrl_path == NULL) 683 ret = os_snprintf(name, 256, NAMED_PIPE_PREFIX); 684 else 685 ret = os_snprintf(name, 256, NAMED_PIPE_PREFIX "-%s", 686 ctrl_path); 687 #endif /* UNICODE */ 688 if (os_snprintf_error(256, ret)) { 689 os_free(ctrl); 690 return NULL; 691 } 692 693 for (i = 0; i < 10; i++) { 694 ctrl->pipe = CreateFile(name, GENERIC_READ | GENERIC_WRITE, 0, 695 NULL, OPEN_EXISTING, 0, NULL); 696 /* 697 * Current named pipe server side in wpa_supplicant is 698 * re-opening the pipe for new clients only after the previous 699 * one is taken into use. This leaves a small window for race 700 * conditions when two connections are being opened at almost 701 * the same time. Retry if that was the case. 702 */ 703 if (ctrl->pipe != INVALID_HANDLE_VALUE || 704 GetLastError() != ERROR_PIPE_BUSY) 705 break; 706 WaitNamedPipe(name, 1000); 707 } 708 if (ctrl->pipe == INVALID_HANDLE_VALUE) { 709 os_free(ctrl); 710 return NULL; 711 } 712 713 mode = PIPE_READMODE_MESSAGE; 714 if (!SetNamedPipeHandleState(ctrl->pipe, &mode, NULL, NULL)) { 715 CloseHandle(ctrl->pipe); 716 os_free(ctrl); 717 return NULL; 718 } 719 720 return ctrl; 721 } 722 723 wpa_ctrl_close(struct wpa_ctrl * ctrl)724 void wpa_ctrl_close(struct wpa_ctrl *ctrl) 725 { 726 CloseHandle(ctrl->pipe); 727 os_free(ctrl); 728 } 729 730 wpa_ctrl_request(struct wpa_ctrl * ctrl,const char * cmd,size_t cmd_len,char * reply,size_t * reply_len,void (* msg_cb)(char * msg,size_t len))731 int wpa_ctrl_request(struct wpa_ctrl *ctrl, const char *cmd, size_t cmd_len, 732 char *reply, size_t *reply_len, 733 void (*msg_cb)(char *msg, size_t len)) 734 { 735 DWORD written; 736 DWORD readlen = *reply_len; 737 738 if (!WriteFile(ctrl->pipe, cmd, cmd_len, &written, NULL)) 739 return -1; 740 741 if (!ReadFile(ctrl->pipe, reply, *reply_len, &readlen, NULL)) 742 return -1; 743 *reply_len = readlen; 744 745 return 0; 746 } 747 748 wpa_ctrl_recv(struct wpa_ctrl * ctrl,char * reply,size_t * reply_len)749 int wpa_ctrl_recv(struct wpa_ctrl *ctrl, char *reply, size_t *reply_len) 750 { 751 DWORD len = *reply_len; 752 if (!ReadFile(ctrl->pipe, reply, *reply_len, &len, NULL)) 753 return -1; 754 *reply_len = len; 755 return 0; 756 } 757 758 wpa_ctrl_pending(struct wpa_ctrl * ctrl)759 int wpa_ctrl_pending(struct wpa_ctrl *ctrl) 760 { 761 DWORD left; 762 763 if (!PeekNamedPipe(ctrl->pipe, NULL, 0, NULL, &left, NULL)) 764 return -1; 765 return left ? 1 : 0; 766 } 767 768 wpa_ctrl_get_fd(struct wpa_ctrl * ctrl)769 int wpa_ctrl_get_fd(struct wpa_ctrl *ctrl) 770 { 771 return -1; 772 } 773 774 #endif /* CONFIG_CTRL_IFACE_NAMED_PIPE */ 775 776 #endif /* CONFIG_CTRL_IFACE */ 777