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