wpa_ctrl.c revision b6e9aaf735990dc64cdb6efccc03d076768eabf3
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 */ 46struct 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 76struct 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++; 101try_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 207void 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 */ 226void wpa_ctrl_cleanup(void) 227{ 228 DIR *dir; 229 struct dirent entry; 230 struct dirent *result; 231 size_t dirnamelen; 232 int prefixlen = os_strlen(CONFIG_CTRL_IFACE_CLIENT_PREFIX); 233 size_t maxcopy; 234 char pathname[PATH_MAX]; 235 char *namep; 236 237 if ((dir = opendir(CONFIG_CTRL_IFACE_CLIENT_DIR)) == NULL) 238 return; 239 240 dirnamelen = (size_t) os_snprintf(pathname, sizeof(pathname), "%s/", 241 CONFIG_CTRL_IFACE_CLIENT_DIR); 242 if (dirnamelen >= sizeof(pathname)) { 243 closedir(dir); 244 return; 245 } 246 namep = pathname + dirnamelen; 247 maxcopy = PATH_MAX - dirnamelen; 248 while (readdir_r(dir, &entry, &result) == 0 && result != NULL) { 249 if (os_strncmp(entry.d_name, CONFIG_CTRL_IFACE_CLIENT_PREFIX, 250 prefixlen) == 0) { 251 if (os_strlcpy(namep, entry.d_name, maxcopy) < maxcopy) 252 unlink(pathname); 253 } 254 } 255 closedir(dir); 256} 257#endif /* ANDROID */ 258 259#else /* CONFIG_CTRL_IFACE_UNIX */ 260 261#ifdef ANDROID 262void wpa_ctrl_cleanup(void) 263{ 264} 265#endif /* ANDROID */ 266 267#endif /* CONFIG_CTRL_IFACE_UNIX */ 268 269 270#ifdef CONFIG_CTRL_IFACE_UDP 271 272struct wpa_ctrl * wpa_ctrl_open(const char *ctrl_path) 273{ 274 struct wpa_ctrl *ctrl; 275 char buf[128]; 276 size_t len; 277#ifdef CONFIG_CTRL_IFACE_UDP_REMOTE 278 struct hostent *h; 279#endif /* CONFIG_CTRL_IFACE_UDP_REMOTE */ 280 281 ctrl = os_malloc(sizeof(*ctrl)); 282 if (ctrl == NULL) 283 return NULL; 284 os_memset(ctrl, 0, sizeof(*ctrl)); 285 286 ctrl->s = socket(PF_INET, SOCK_DGRAM, 0); 287 if (ctrl->s < 0) { 288 perror("socket"); 289 os_free(ctrl); 290 return NULL; 291 } 292 293 ctrl->local.sin_family = AF_INET; 294#ifdef CONFIG_CTRL_IFACE_UDP_REMOTE 295 ctrl->local.sin_addr.s_addr = INADDR_ANY; 296#else /* CONFIG_CTRL_IFACE_UDP_REMOTE */ 297 ctrl->local.sin_addr.s_addr = htonl((127 << 24) | 1); 298#endif /* CONFIG_CTRL_IFACE_UDP_REMOTE */ 299 if (bind(ctrl->s, (struct sockaddr *) &ctrl->local, 300 sizeof(ctrl->local)) < 0) { 301 close(ctrl->s); 302 os_free(ctrl); 303 return NULL; 304 } 305 306 ctrl->dest.sin_family = AF_INET; 307 ctrl->dest.sin_addr.s_addr = htonl((127 << 24) | 1); 308 ctrl->dest.sin_port = htons(WPA_CTRL_IFACE_PORT); 309 310#ifdef CONFIG_CTRL_IFACE_UDP_REMOTE 311 if (ctrl_path) { 312 char *port, *name; 313 int port_id; 314 315 name = os_strdup(ctrl_path); 316 if (name == NULL) { 317 close(ctrl->s); 318 os_free(ctrl); 319 return NULL; 320 } 321 port = os_strchr(name, ':'); 322 323 if (port) { 324 port_id = atoi(&port[1]); 325 port[0] = '\0'; 326 } else 327 port_id = WPA_CTRL_IFACE_PORT; 328 329 h = gethostbyname(name); 330 ctrl->remote_ip = os_strdup(name); 331 os_free(name); 332 if (h == NULL) { 333 perror("gethostbyname"); 334 close(ctrl->s); 335 os_free(ctrl->remote_ip); 336 os_free(ctrl); 337 return NULL; 338 } 339 ctrl->dest.sin_port = htons(port_id); 340 os_memcpy(h->h_addr, (char *) &ctrl->dest.sin_addr.s_addr, 341 h->h_length); 342 } else 343 ctrl->remote_ip = os_strdup("localhost"); 344#endif /* CONFIG_CTRL_IFACE_UDP_REMOTE */ 345 346 if (connect(ctrl->s, (struct sockaddr *) &ctrl->dest, 347 sizeof(ctrl->dest)) < 0) { 348 perror("connect"); 349 close(ctrl->s); 350 os_free(ctrl->remote_ip); 351 os_free(ctrl); 352 return NULL; 353 } 354 355 len = sizeof(buf) - 1; 356 if (wpa_ctrl_request(ctrl, "GET_COOKIE", 10, buf, &len, NULL) == 0) { 357 buf[len] = '\0'; 358 ctrl->cookie = os_strdup(buf); 359 } 360 361 if (wpa_ctrl_request(ctrl, "IFNAME", 6, buf, &len, NULL) == 0) { 362 buf[len] = '\0'; 363 ctrl->remote_ifname = os_strdup(buf); 364 } 365 366 return ctrl; 367} 368 369 370char * wpa_ctrl_get_remote_ifname(struct wpa_ctrl *ctrl) 371{ 372#define WPA_CTRL_MAX_PS_NAME 100 373 static char ps[WPA_CTRL_MAX_PS_NAME] = {}; 374 os_snprintf(ps, WPA_CTRL_MAX_PS_NAME, "%s/%s", 375 ctrl->remote_ip, ctrl->remote_ifname); 376 return ps; 377} 378 379 380void wpa_ctrl_close(struct wpa_ctrl *ctrl) 381{ 382 close(ctrl->s); 383 os_free(ctrl->cookie); 384 os_free(ctrl->remote_ifname); 385 os_free(ctrl->remote_ip); 386 os_free(ctrl); 387} 388 389#endif /* CONFIG_CTRL_IFACE_UDP */ 390 391 392#ifdef CTRL_IFACE_SOCKET 393int wpa_ctrl_request(struct wpa_ctrl *ctrl, const char *cmd, size_t cmd_len, 394 char *reply, size_t *reply_len, 395 void (*msg_cb)(char *msg, size_t len)) 396{ 397 struct timeval tv; 398 struct os_time started_at; 399 int res; 400 fd_set rfds; 401 const char *_cmd; 402 char *cmd_buf = NULL; 403 size_t _cmd_len; 404 405#ifdef CONFIG_CTRL_IFACE_UDP 406 if (ctrl->cookie) { 407 char *pos; 408 _cmd_len = os_strlen(ctrl->cookie) + 1 + cmd_len; 409 cmd_buf = os_malloc(_cmd_len); 410 if (cmd_buf == NULL) 411 return -1; 412 _cmd = cmd_buf; 413 pos = cmd_buf; 414 os_strlcpy(pos, ctrl->cookie, _cmd_len); 415 pos += os_strlen(ctrl->cookie); 416 *pos++ = ' '; 417 os_memcpy(pos, cmd, cmd_len); 418 } else 419#endif /* CONFIG_CTRL_IFACE_UDP */ 420 { 421 _cmd = cmd; 422 _cmd_len = cmd_len; 423 } 424 425 errno = 0; 426 started_at.sec = 0; 427 started_at.usec = 0; 428retry_send: 429 if (send(ctrl->s, _cmd, _cmd_len, 0) < 0) { 430 if (errno == EAGAIN || errno == EBUSY || errno == EWOULDBLOCK) 431 { 432 /* 433 * Must be a non-blocking socket... Try for a bit 434 * longer before giving up. 435 */ 436 if (started_at.sec == 0) 437 os_get_time(&started_at); 438 else { 439 struct os_time n; 440 os_get_time(&n); 441 /* Try for a few seconds. */ 442 if (n.sec > started_at.sec + 5) 443 goto send_err; 444 } 445 os_sleep(1, 0); 446 goto retry_send; 447 } 448 send_err: 449 os_free(cmd_buf); 450 return -1; 451 } 452 os_free(cmd_buf); 453 454 for (;;) { 455 tv.tv_sec = 10; 456 tv.tv_usec = 0; 457 FD_ZERO(&rfds); 458 FD_SET(ctrl->s, &rfds); 459 res = select(ctrl->s + 1, &rfds, NULL, NULL, &tv); 460 if (res < 0) 461 return res; 462 if (FD_ISSET(ctrl->s, &rfds)) { 463 res = recv(ctrl->s, reply, *reply_len, 0); 464 if (res < 0) 465 return res; 466 if (res > 0 && reply[0] == '<') { 467 /* This is an unsolicited message from 468 * wpa_supplicant, not the reply to the 469 * request. Use msg_cb to report this to the 470 * caller. */ 471 if (msg_cb) { 472 /* Make sure the message is nul 473 * terminated. */ 474 if ((size_t) res == *reply_len) 475 res = (*reply_len) - 1; 476 reply[res] = '\0'; 477 msg_cb(reply, res); 478 } 479 continue; 480 } 481 *reply_len = res; 482 break; 483 } else { 484 return -2; 485 } 486 } 487 return 0; 488} 489#endif /* CTRL_IFACE_SOCKET */ 490 491 492static int wpa_ctrl_attach_helper(struct wpa_ctrl *ctrl, int attach) 493{ 494 char buf[10]; 495 int ret; 496 size_t len = 10; 497 498 ret = wpa_ctrl_request(ctrl, attach ? "ATTACH" : "DETACH", 6, 499 buf, &len, NULL); 500 if (ret < 0) 501 return ret; 502 if (len == 3 && os_memcmp(buf, "OK\n", 3) == 0) 503 return 0; 504 return -1; 505} 506 507 508int wpa_ctrl_attach(struct wpa_ctrl *ctrl) 509{ 510 return wpa_ctrl_attach_helper(ctrl, 1); 511} 512 513 514int wpa_ctrl_detach(struct wpa_ctrl *ctrl) 515{ 516 return wpa_ctrl_attach_helper(ctrl, 0); 517} 518 519 520#ifdef CTRL_IFACE_SOCKET 521 522int wpa_ctrl_recv(struct wpa_ctrl *ctrl, char *reply, size_t *reply_len) 523{ 524 int res; 525 526 res = recv(ctrl->s, reply, *reply_len, 0); 527 if (res < 0) 528 return res; 529 *reply_len = res; 530 return 0; 531} 532 533 534int wpa_ctrl_pending(struct wpa_ctrl *ctrl) 535{ 536 struct timeval tv; 537 fd_set rfds; 538 tv.tv_sec = 0; 539 tv.tv_usec = 0; 540 FD_ZERO(&rfds); 541 FD_SET(ctrl->s, &rfds); 542 select(ctrl->s + 1, &rfds, NULL, NULL, &tv); 543 return FD_ISSET(ctrl->s, &rfds); 544} 545 546 547int wpa_ctrl_get_fd(struct wpa_ctrl *ctrl) 548{ 549 return ctrl->s; 550} 551 552#endif /* CTRL_IFACE_SOCKET */ 553 554 555#ifdef CONFIG_CTRL_IFACE_NAMED_PIPE 556 557#ifndef WPA_SUPPLICANT_NAMED_PIPE 558#define WPA_SUPPLICANT_NAMED_PIPE "WpaSupplicant" 559#endif 560#define NAMED_PIPE_PREFIX TEXT("\\\\.\\pipe\\") TEXT(WPA_SUPPLICANT_NAMED_PIPE) 561 562struct wpa_ctrl * wpa_ctrl_open(const char *ctrl_path) 563{ 564 struct wpa_ctrl *ctrl; 565 DWORD mode; 566 TCHAR name[256]; 567 int i, ret; 568 569 ctrl = os_malloc(sizeof(*ctrl)); 570 if (ctrl == NULL) 571 return NULL; 572 os_memset(ctrl, 0, sizeof(*ctrl)); 573 574#ifdef UNICODE 575 if (ctrl_path == NULL) 576 ret = _snwprintf(name, 256, NAMED_PIPE_PREFIX); 577 else 578 ret = _snwprintf(name, 256, NAMED_PIPE_PREFIX TEXT("-%S"), 579 ctrl_path); 580#else /* UNICODE */ 581 if (ctrl_path == NULL) 582 ret = os_snprintf(name, 256, NAMED_PIPE_PREFIX); 583 else 584 ret = os_snprintf(name, 256, NAMED_PIPE_PREFIX "-%s", 585 ctrl_path); 586#endif /* UNICODE */ 587 if (ret < 0 || ret >= 256) { 588 os_free(ctrl); 589 return NULL; 590 } 591 592 for (i = 0; i < 10; i++) { 593 ctrl->pipe = CreateFile(name, GENERIC_READ | GENERIC_WRITE, 0, 594 NULL, OPEN_EXISTING, 0, NULL); 595 /* 596 * Current named pipe server side in wpa_supplicant is 597 * re-opening the pipe for new clients only after the previous 598 * one is taken into use. This leaves a small window for race 599 * conditions when two connections are being opened at almost 600 * the same time. Retry if that was the case. 601 */ 602 if (ctrl->pipe != INVALID_HANDLE_VALUE || 603 GetLastError() != ERROR_PIPE_BUSY) 604 break; 605 WaitNamedPipe(name, 1000); 606 } 607 if (ctrl->pipe == INVALID_HANDLE_VALUE) { 608 os_free(ctrl); 609 return NULL; 610 } 611 612 mode = PIPE_READMODE_MESSAGE; 613 if (!SetNamedPipeHandleState(ctrl->pipe, &mode, NULL, NULL)) { 614 CloseHandle(ctrl->pipe); 615 os_free(ctrl); 616 return NULL; 617 } 618 619 return ctrl; 620} 621 622 623void wpa_ctrl_close(struct wpa_ctrl *ctrl) 624{ 625 CloseHandle(ctrl->pipe); 626 os_free(ctrl); 627} 628 629 630int wpa_ctrl_request(struct wpa_ctrl *ctrl, const char *cmd, size_t cmd_len, 631 char *reply, size_t *reply_len, 632 void (*msg_cb)(char *msg, size_t len)) 633{ 634 DWORD written; 635 DWORD readlen = *reply_len; 636 637 if (!WriteFile(ctrl->pipe, cmd, cmd_len, &written, NULL)) 638 return -1; 639 640 if (!ReadFile(ctrl->pipe, reply, *reply_len, &readlen, NULL)) 641 return -1; 642 *reply_len = readlen; 643 644 return 0; 645} 646 647 648int wpa_ctrl_recv(struct wpa_ctrl *ctrl, char *reply, size_t *reply_len) 649{ 650 DWORD len = *reply_len; 651 if (!ReadFile(ctrl->pipe, reply, *reply_len, &len, NULL)) 652 return -1; 653 *reply_len = len; 654 return 0; 655} 656 657 658int wpa_ctrl_pending(struct wpa_ctrl *ctrl) 659{ 660 DWORD left; 661 662 if (!PeekNamedPipe(ctrl->pipe, NULL, 0, NULL, &left, NULL)) 663 return -1; 664 return left ? 1 : 0; 665} 666 667 668int wpa_ctrl_get_fd(struct wpa_ctrl *ctrl) 669{ 670 return -1; 671} 672 673#endif /* CONFIG_CTRL_IFACE_NAMED_PIPE */ 674 675#endif /* CONFIG_CTRL_IFACE */ 676