1/* 2 * WPA Supplicant / UDP socket -based control interface 3 * Copyright (c) 2004-2005, 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#include "common.h" 12#include "eloop.h" 13#include "config.h" 14#include "eapol_supp/eapol_supp_sm.h" 15#include "wpa_supplicant_i.h" 16#include "ctrl_iface.h" 17#include "common/wpa_ctrl.h" 18 19 20#define COOKIE_LEN 8 21 22/* Per-interface ctrl_iface */ 23 24/** 25 * struct wpa_ctrl_dst - Internal data structure of control interface monitors 26 * 27 * This structure is used to store information about registered control 28 * interface monitors into struct wpa_supplicant. This data is private to 29 * ctrl_iface_udp.c and should not be touched directly from other files. 30 */ 31struct wpa_ctrl_dst { 32 struct wpa_ctrl_dst *next; 33#ifdef CONFIG_CTRL_IFACE_UDP_IPV6 34 struct sockaddr_in6 addr; 35#else /* CONFIG_CTRL_IFACE_UDP_IPV6 */ 36 struct sockaddr_in addr; 37#endif /* CONFIG_CTRL_IFACE_UDP_IPV6 */ 38 socklen_t addrlen; 39 int debug_level; 40 int errors; 41}; 42 43 44struct ctrl_iface_priv { 45 struct wpa_supplicant *wpa_s; 46 int sock; 47 struct wpa_ctrl_dst *ctrl_dst; 48 u8 cookie[COOKIE_LEN]; 49}; 50 51 52static void wpa_supplicant_ctrl_iface_send(struct ctrl_iface_priv *priv, 53 int level, const char *buf, 54 size_t len); 55 56 57static int wpa_supplicant_ctrl_iface_attach(struct ctrl_iface_priv *priv, 58#ifdef CONFIG_CTRL_IFACE_UDP_IPV6 59 struct sockaddr_in6 *from, 60#else /* CONFIG_CTRL_IFACE_UDP_IPV6 */ 61 struct sockaddr_in *from, 62#endif /* CONFIG_CTRL_IFACE_UDP_IPV6 */ 63 socklen_t fromlen) 64{ 65 struct wpa_ctrl_dst *dst; 66#ifdef CONFIG_CTRL_IFACE_UDP_IPV6 67 char addr[INET6_ADDRSTRLEN]; 68#endif /* CONFIG_UDP_IPV6 */ 69 70 dst = os_zalloc(sizeof(*dst)); 71 if (dst == NULL) 72 return -1; 73 os_memcpy(&dst->addr, from, sizeof(*from)); 74 dst->addrlen = fromlen; 75 dst->debug_level = MSG_INFO; 76 dst->next = priv->ctrl_dst; 77 priv->ctrl_dst = dst; 78#ifdef CONFIG_CTRL_IFACE_UDP_IPV6 79 wpa_printf(MSG_DEBUG, "CTRL_IFACE monitor attached %s:%d", 80 inet_ntop(AF_INET6, &from->sin6_addr, addr, sizeof(*from)), 81 ntohs(from->sin6_port)); 82#else /* CONFIG_CTRL_IFACE_UDP_IPV6 */ 83 wpa_printf(MSG_DEBUG, "CTRL_IFACE monitor attached %s:%d", 84 inet_ntoa(from->sin_addr), ntohs(from->sin_port)); 85#endif /* CONFIG_CTRL_IFACE_UDP_IPV6 */ 86 return 0; 87} 88 89 90static int wpa_supplicant_ctrl_iface_detach(struct ctrl_iface_priv *priv, 91#ifdef CONFIG_CTRL_IFACE_UDP_IPV6 92 struct sockaddr_in6 *from, 93#else /* CONFIG_CTRL_IFACE_UDP_IPV6 */ 94 struct sockaddr_in *from, 95#endif /* CONFIG_CTRL_IFACE_UDP_IPV6 */ 96 socklen_t fromlen) 97{ 98 struct wpa_ctrl_dst *dst, *prev = NULL; 99#ifdef CONFIG_CTRL_IFACE_UDP_IPV6 100 char addr[INET6_ADDRSTRLEN]; 101#endif /* CONFIG_CTRL_IFACE_UDP_IPV6 */ 102 103 dst = priv->ctrl_dst; 104 while (dst) { 105#ifdef CONFIG_CTRL_IFACE_UDP_IPV6 106 if (from->sin6_port == dst->addr.sin6_port && 107 !os_memcmp(&from->sin6_addr, &dst->addr.sin6_addr, 108 sizeof(from->sin6_addr))) { 109 wpa_printf(MSG_DEBUG, "CTRL_IFACE monitor detached %s:%d", 110 inet_ntop(AF_INET6, &from->sin6_addr, addr, 111 sizeof(*from)), 112 ntohs(from->sin6_port)); 113#else /* CONFIG_CTRL_IFACE_UDP_IPV6 */ 114 if (from->sin_addr.s_addr == dst->addr.sin_addr.s_addr && 115 from->sin_port == dst->addr.sin_port) { 116 wpa_printf(MSG_DEBUG, "CTRL_IFACE monitor detached " 117 "%s:%d", inet_ntoa(from->sin_addr), 118 ntohs(from->sin_port)); 119#endif /* CONFIG_CTRL_IFACE_UDP_IPV6 */ 120 if (prev == NULL) 121 priv->ctrl_dst = dst->next; 122 else 123 prev->next = dst->next; 124 os_free(dst); 125 return 0; 126 } 127 prev = dst; 128 dst = dst->next; 129 } 130 return -1; 131} 132 133 134static int wpa_supplicant_ctrl_iface_level(struct ctrl_iface_priv *priv, 135#ifdef CONFIG_CTRL_IFACE_UDP_IPV6 136 struct sockaddr_in6 *from, 137#else /* CONFIG_CTRL_IFACE_UDP_IPV6 */ 138 struct sockaddr_in *from, 139#endif /* CONFIG_CTRL_IFACE_UDP_IPV6 */ 140 socklen_t fromlen, 141 char *level) 142{ 143 struct wpa_ctrl_dst *dst; 144#ifdef CONFIG_CTRL_IFACE_UDP_IPV6 145 char addr[INET6_ADDRSTRLEN]; 146#endif /* CONFIG_CTRL_IFACE_UDP_IPV6 */ 147 148 wpa_printf(MSG_DEBUG, "CTRL_IFACE LEVEL %s", level); 149 150 dst = priv->ctrl_dst; 151 while (dst) { 152#if CONFIG_CTRL_IFACE_UDP_IPV6 153 if (from->sin6_port == dst->addr.sin6_port && 154 !os_memcmp(&from->sin6_addr, &dst->addr.sin6_addr, 155 sizeof(from->sin6_addr))) { 156 wpa_printf(MSG_DEBUG, "CTRL_IFACE changed monitor level %s:%d", 157 inet_ntop(AF_INET6, &from->sin6_addr, addr, 158 sizeof(*from)), 159 ntohs(from->sin6_port)); 160#else /* CONFIG_CTRL_IFACE_UDP_IPV6 */ 161 if (from->sin_addr.s_addr == dst->addr.sin_addr.s_addr && 162 from->sin_port == dst->addr.sin_port) { 163 wpa_printf(MSG_DEBUG, "CTRL_IFACE changed monitor " 164 "level %s:%d", inet_ntoa(from->sin_addr), 165 ntohs(from->sin_port)); 166#endif /* CONFIG_CTRL_IFACE_UDP_IPV6 */ 167 dst->debug_level = atoi(level); 168 return 0; 169 } 170 dst = dst->next; 171 } 172 173 return -1; 174} 175 176 177static char * 178wpa_supplicant_ctrl_iface_get_cookie(struct ctrl_iface_priv *priv, 179 size_t *reply_len) 180{ 181 char *reply; 182 reply = os_malloc(7 + 2 * COOKIE_LEN + 1); 183 if (reply == NULL) { 184 *reply_len = 1; 185 return NULL; 186 } 187 188 os_memcpy(reply, "COOKIE=", 7); 189 wpa_snprintf_hex(reply + 7, 2 * COOKIE_LEN + 1, 190 priv->cookie, COOKIE_LEN); 191 192 *reply_len = 7 + 2 * COOKIE_LEN; 193 return reply; 194} 195 196 197static void wpa_supplicant_ctrl_iface_receive(int sock, void *eloop_ctx, 198 void *sock_ctx) 199{ 200 struct wpa_supplicant *wpa_s = eloop_ctx; 201 struct ctrl_iface_priv *priv = sock_ctx; 202 char buf[256], *pos; 203 int res; 204#ifdef CONFIG_CTRL_IFACE_UDP_IPV6 205 struct sockaddr_in6 from; 206#ifndef CONFIG_CTRL_IFACE_UDP_REMOTE 207 char addr[INET6_ADDRSTRLEN]; 208#endif /* CONFIG_CTRL_IFACE_UDP_REMOTE */ 209#else /* CONFIG_CTRL_IFACE_UDP_IPV6 */ 210 struct sockaddr_in from; 211#endif /* CONFIG_CTRL_IFACE_UDP_IPV6 */ 212 socklen_t fromlen = sizeof(from); 213 char *reply = NULL; 214 size_t reply_len = 0; 215 int new_attached = 0; 216 u8 cookie[COOKIE_LEN]; 217 218 res = recvfrom(sock, buf, sizeof(buf) - 1, 0, 219 (struct sockaddr *) &from, &fromlen); 220 if (res < 0) { 221 perror("recvfrom(ctrl_iface)"); 222 return; 223 } 224 225#ifndef CONFIG_CTRL_IFACE_UDP_REMOTE 226#ifdef CONFIG_CTRL_IFACE_UDP_IPV6 227 inet_ntop(AF_INET6, &from.sin6_addr, addr, sizeof(from)); 228 if (os_strcmp(addr, "::1")) { 229 wpa_printf(MSG_DEBUG, "CTRL: Drop packet from unexpected source %s", 230 addr); 231 } 232#else /* CONFIG_CTRL_IFACE_UDP_IPV6 */ 233 if (from.sin_addr.s_addr != htonl((127 << 24) | 1)) { 234 /* 235 * The OS networking stack is expected to drop this kind of 236 * frames since the socket is bound to only localhost address. 237 * Just in case, drop the frame if it is coming from any other 238 * address. 239 */ 240 wpa_printf(MSG_DEBUG, "CTRL: Drop packet from unexpected " 241 "source %s", inet_ntoa(from.sin_addr)); 242 return; 243 } 244#endif /* CONFIG_CTRL_IFACE_UDP_IPV6 */ 245#endif /* CONFIG_CTRL_IFACE_UDP_REMOTE */ 246 247 buf[res] = '\0'; 248 249 if (os_strcmp(buf, "GET_COOKIE") == 0) { 250 reply = wpa_supplicant_ctrl_iface_get_cookie(priv, &reply_len); 251 goto done; 252 } 253 254 /* 255 * Require that the client includes a prefix with the 'cookie' value 256 * fetched with GET_COOKIE command. This is used to verify that the 257 * client has access to a bidirectional link over UDP in order to 258 * avoid attacks using forged localhost IP address even if the OS does 259 * not block such frames from remote destinations. 260 */ 261 if (os_strncmp(buf, "COOKIE=", 7) != 0) { 262 wpa_printf(MSG_DEBUG, "CTLR: No cookie in the request - " 263 "drop request"); 264 return; 265 } 266 267 if (hexstr2bin(buf + 7, cookie, COOKIE_LEN) < 0) { 268 wpa_printf(MSG_DEBUG, "CTLR: Invalid cookie format in the " 269 "request - drop request"); 270 return; 271 } 272 273 if (os_memcmp(cookie, priv->cookie, COOKIE_LEN) != 0) { 274 wpa_printf(MSG_DEBUG, "CTLR: Invalid cookie in the request - " 275 "drop request"); 276 return; 277 } 278 279 pos = buf + 7 + 2 * COOKIE_LEN; 280 while (*pos == ' ') 281 pos++; 282 283 if (os_strcmp(pos, "ATTACH") == 0) { 284 if (wpa_supplicant_ctrl_iface_attach(priv, &from, fromlen)) 285 reply_len = 1; 286 else { 287 new_attached = 1; 288 reply_len = 2; 289 } 290 } else if (os_strcmp(pos, "DETACH") == 0) { 291 if (wpa_supplicant_ctrl_iface_detach(priv, &from, fromlen)) 292 reply_len = 1; 293 else 294 reply_len = 2; 295 } else if (os_strncmp(pos, "LEVEL ", 6) == 0) { 296 if (wpa_supplicant_ctrl_iface_level(priv, &from, fromlen, 297 pos + 6)) 298 reply_len = 1; 299 else 300 reply_len = 2; 301 } else { 302 reply = wpa_supplicant_ctrl_iface_process(wpa_s, pos, 303 &reply_len); 304 } 305 306 done: 307 if (reply) { 308 sendto(sock, reply, reply_len, 0, (struct sockaddr *) &from, 309 fromlen); 310 os_free(reply); 311 } else if (reply_len == 1) { 312 sendto(sock, "FAIL\n", 5, 0, (struct sockaddr *) &from, 313 fromlen); 314 } else if (reply_len == 2) { 315 sendto(sock, "OK\n", 3, 0, (struct sockaddr *) &from, 316 fromlen); 317 } 318 319 if (new_attached) 320 eapol_sm_notify_ctrl_attached(wpa_s->eapol); 321} 322 323 324static void wpa_supplicant_ctrl_iface_msg_cb(void *ctx, int level, int global, 325 const char *txt, size_t len) 326{ 327 struct wpa_supplicant *wpa_s = ctx; 328 if (wpa_s == NULL || wpa_s->ctrl_iface == NULL) 329 return; 330 wpa_supplicant_ctrl_iface_send(wpa_s->ctrl_iface, level, txt, len); 331} 332 333 334struct ctrl_iface_priv * 335wpa_supplicant_ctrl_iface_init(struct wpa_supplicant *wpa_s) 336{ 337 struct ctrl_iface_priv *priv; 338 int port = WPA_CTRL_IFACE_PORT; 339#ifdef CONFIG_CTRL_IFACE_UDP_IPV6 340 struct sockaddr_in6 addr; 341 int domain = PF_INET6; 342#else /* CONFIG_CTRL_IFACE_UDP_IPV6 */ 343 struct sockaddr_in addr; 344 int domain = PF_INET; 345#endif /* CONFIG_CTRL_IFACE_UDP_IPV6 */ 346 347 priv = os_zalloc(sizeof(*priv)); 348 if (priv == NULL) 349 return NULL; 350 priv->wpa_s = wpa_s; 351 priv->sock = -1; 352 os_get_random(priv->cookie, COOKIE_LEN); 353 354 if (wpa_s->conf->ctrl_interface == NULL) 355 return priv; 356 357 priv->sock = socket(domain, SOCK_DGRAM, 0); 358 if (priv->sock < 0) { 359 perror("socket(PF_INET)"); 360 goto fail; 361 } 362 363 os_memset(&addr, 0, sizeof(addr)); 364#ifdef CONFIG_CTRL_IFACE_UDP_IPV6 365 addr.sin6_family = AF_INET6; 366#ifdef CONFIG_CTRL_IFACE_UDP_REMOTE 367 addr.sin6_addr = in6addr_any; 368#else /* CONFIG_CTRL_IFACE_UDP_REMOTE */ 369 inet_pton(AF_INET6, "::1", &addr.sin6_addr); 370#endif /* CONFIG_CTRL_IFACE_UDP_REMOTE */ 371#else /* CONFIG_CTRL_IFACE_UDP_IPV6 */ 372 addr.sin_family = AF_INET; 373#ifdef CONFIG_CTRL_IFACE_UDP_REMOTE 374 addr.sin_addr.s_addr = INADDR_ANY; 375#else /* CONFIG_CTRL_IFACE_UDP_REMOTE */ 376 addr.sin_addr.s_addr = htonl((127 << 24) | 1); 377#endif /* CONFIG_CTRL_IFACE_UDP_REMOTE */ 378#endif /* CONFIG_CTRL_IFACE_UDP_IPV6 */ 379try_again: 380#ifdef CONFIG_CTRL_IFACE_UDP_IPV6 381 addr.sin6_port = htons(port); 382#else /* CONFIG_CTRL_IFACE_UDP_IPV6 */ 383 addr.sin_port = htons(port); 384#endif /* CONFIG_CTRL_IFACE_UDP_IPV6 */ 385 if (bind(priv->sock, (struct sockaddr *) &addr, sizeof(addr)) < 0) { 386 port--; 387 if ((WPA_CTRL_IFACE_PORT - port) < WPA_CTRL_IFACE_PORT_LIMIT) 388 goto try_again; 389 perror("bind(AF_INET)"); 390 goto fail; 391 } 392 393#ifdef CONFIG_CTRL_IFACE_UDP_REMOTE 394 wpa_msg(wpa_s, MSG_DEBUG, "ctrl_iface_init UDP port: %d", port); 395#endif /* CONFIG_CTRL_IFACE_UDP_REMOTE */ 396 397 eloop_register_read_sock(priv->sock, wpa_supplicant_ctrl_iface_receive, 398 wpa_s, priv); 399 wpa_msg_register_cb(wpa_supplicant_ctrl_iface_msg_cb); 400 401 return priv; 402 403fail: 404 if (priv->sock >= 0) 405 close(priv->sock); 406 os_free(priv); 407 return NULL; 408} 409 410 411void wpa_supplicant_ctrl_iface_deinit(struct ctrl_iface_priv *priv) 412{ 413 struct wpa_ctrl_dst *dst, *prev; 414 415 if (priv->sock > -1) { 416 eloop_unregister_read_sock(priv->sock); 417 if (priv->ctrl_dst) { 418 /* 419 * Wait before closing the control socket if 420 * there are any attached monitors in order to allow 421 * them to receive any pending messages. 422 */ 423 wpa_printf(MSG_DEBUG, "CTRL_IFACE wait for attached " 424 "monitors to receive messages"); 425 os_sleep(0, 100000); 426 } 427 close(priv->sock); 428 priv->sock = -1; 429 } 430 431 dst = priv->ctrl_dst; 432 while (dst) { 433 prev = dst; 434 dst = dst->next; 435 os_free(prev); 436 } 437 os_free(priv); 438} 439 440 441static void wpa_supplicant_ctrl_iface_send(struct ctrl_iface_priv *priv, 442 int level, const char *buf, 443 size_t len) 444{ 445 struct wpa_ctrl_dst *dst, *next; 446 char levelstr[10]; 447 int idx; 448 char *sbuf; 449 int llen; 450#ifdef CONFIG_CTRL_IFACE_UDP_IPV6 451 char addr[INET6_ADDRSTRLEN]; 452#endif /* CONFIG_CTRL_IFACE_UDP_IPV6 */ 453 454 dst = priv->ctrl_dst; 455 if (priv->sock < 0 || dst == NULL) 456 return; 457 458 os_snprintf(levelstr, sizeof(levelstr), "<%d>", level); 459 460 llen = os_strlen(levelstr); 461 sbuf = os_malloc(llen + len); 462 if (sbuf == NULL) 463 return; 464 465 os_memcpy(sbuf, levelstr, llen); 466 os_memcpy(sbuf + llen, buf, len); 467 468 idx = 0; 469 while (dst) { 470 next = dst->next; 471 if (level >= dst->debug_level) { 472#ifdef CONFIG_CTRL_IFACE_UDP_IPV6 473 wpa_printf(MSG_DEBUG, "CTRL_IFACE monitor send %s:%d", 474 inet_ntop(AF_INET6, &dst->addr.sin6_addr, 475 addr, sizeof(dst->addr)), 476 ntohs(dst->addr.sin6_port)); 477#else /* CONFIG_CTRL_IFACE_UDP_IPV6 */ 478 wpa_printf(MSG_DEBUG, "CTRL_IFACE monitor send %s:%d", 479 inet_ntoa(dst->addr.sin_addr), 480 ntohs(dst->addr.sin_port)); 481#endif /* CONFIG_CTRL_IFACE_UDP_IPV6 */ 482 if (sendto(priv->sock, sbuf, llen + len, 0, 483 (struct sockaddr *) &dst->addr, 484 sizeof(dst->addr)) < 0) { 485 perror("sendto(CTRL_IFACE monitor)"); 486 dst->errors++; 487 if (dst->errors > 10) { 488 wpa_supplicant_ctrl_iface_detach( 489 priv, &dst->addr, 490 dst->addrlen); 491 } 492 } else 493 dst->errors = 0; 494 } 495 idx++; 496 dst = next; 497 } 498 os_free(sbuf); 499} 500 501 502void wpa_supplicant_ctrl_iface_wait(struct ctrl_iface_priv *priv) 503{ 504 wpa_printf(MSG_DEBUG, "CTRL_IFACE - %s - wait for monitor", 505 priv->wpa_s->ifname); 506 eloop_wait_for_read_sock(priv->sock); 507} 508 509 510/* Global ctrl_iface */ 511 512struct ctrl_iface_global_priv { 513 int sock; 514 u8 cookie[COOKIE_LEN]; 515}; 516 517 518static char * 519wpa_supplicant_global_get_cookie(struct ctrl_iface_global_priv *priv, 520 size_t *reply_len) 521{ 522 char *reply; 523 reply = os_malloc(7 + 2 * COOKIE_LEN + 1); 524 if (reply == NULL) { 525 *reply_len = 1; 526 return NULL; 527 } 528 529 os_memcpy(reply, "COOKIE=", 7); 530 wpa_snprintf_hex(reply + 7, 2 * COOKIE_LEN + 1, 531 priv->cookie, COOKIE_LEN); 532 533 *reply_len = 7 + 2 * COOKIE_LEN; 534 return reply; 535} 536 537 538static void wpa_supplicant_global_ctrl_iface_receive(int sock, void *eloop_ctx, 539 void *sock_ctx) 540{ 541 struct wpa_global *global = eloop_ctx; 542 struct ctrl_iface_global_priv *priv = sock_ctx; 543 char buf[256], *pos; 544 int res; 545 struct sockaddr_in from; 546 socklen_t fromlen = sizeof(from); 547 char *reply; 548 size_t reply_len; 549 u8 cookie[COOKIE_LEN]; 550 551 res = recvfrom(sock, buf, sizeof(buf) - 1, 0, 552 (struct sockaddr *) &from, &fromlen); 553 if (res < 0) { 554 perror("recvfrom(ctrl_iface)"); 555 return; 556 } 557 558#ifndef CONFIG_CTRL_IFACE_UDP_REMOTE 559 if (from.sin_addr.s_addr != htonl((127 << 24) | 1)) { 560 /* 561 * The OS networking stack is expected to drop this kind of 562 * frames since the socket is bound to only localhost address. 563 * Just in case, drop the frame if it is coming from any other 564 * address. 565 */ 566 wpa_printf(MSG_DEBUG, "CTRL: Drop packet from unexpected " 567 "source %s", inet_ntoa(from.sin_addr)); 568 return; 569 } 570#endif /* CONFIG_CTRL_IFACE_UDP_REMOTE */ 571 572 buf[res] = '\0'; 573 574 if (os_strcmp(buf, "GET_COOKIE") == 0) { 575 reply = wpa_supplicant_global_get_cookie(priv, &reply_len); 576 goto done; 577 } 578 579 if (os_strncmp(buf, "COOKIE=", 7) != 0) { 580 wpa_printf(MSG_DEBUG, "CTLR: No cookie in the request - " 581 "drop request"); 582 return; 583 } 584 585 if (hexstr2bin(buf + 7, cookie, COOKIE_LEN) < 0) { 586 wpa_printf(MSG_DEBUG, "CTLR: Invalid cookie format in the " 587 "request - drop request"); 588 return; 589 } 590 591 if (os_memcmp(cookie, priv->cookie, COOKIE_LEN) != 0) { 592 wpa_printf(MSG_DEBUG, "CTLR: Invalid cookie in the request - " 593 "drop request"); 594 return; 595 } 596 597 pos = buf + 7 + 2 * COOKIE_LEN; 598 while (*pos == ' ') 599 pos++; 600 601 reply = wpa_supplicant_global_ctrl_iface_process(global, pos, 602 &reply_len); 603 604 done: 605 if (reply) { 606 sendto(sock, reply, reply_len, 0, (struct sockaddr *) &from, 607 fromlen); 608 os_free(reply); 609 } else if (reply_len) { 610 sendto(sock, "FAIL\n", 5, 0, (struct sockaddr *) &from, 611 fromlen); 612 } 613} 614 615 616struct ctrl_iface_global_priv * 617wpa_supplicant_global_ctrl_iface_init(struct wpa_global *global) 618{ 619 struct ctrl_iface_global_priv *priv; 620 struct sockaddr_in addr; 621 int port = WPA_GLOBAL_CTRL_IFACE_PORT; 622 623 priv = os_zalloc(sizeof(*priv)); 624 if (priv == NULL) 625 return NULL; 626 priv->sock = -1; 627 os_get_random(priv->cookie, COOKIE_LEN); 628 629 if (global->params.ctrl_interface == NULL) 630 return priv; 631 632 wpa_printf(MSG_DEBUG, "Global control interface '%s'", 633 global->params.ctrl_interface); 634 635 priv->sock = socket(PF_INET, SOCK_DGRAM, 0); 636 if (priv->sock < 0) { 637 perror("socket(PF_INET)"); 638 goto fail; 639 } 640 641 os_memset(&addr, 0, sizeof(addr)); 642 addr.sin_family = AF_INET; 643#ifdef CONFIG_CTRL_IFACE_UDP_REMOTE 644 addr.sin_addr.s_addr = INADDR_ANY; 645#else /* CONFIG_CTRL_IFACE_UDP_REMOTE */ 646 addr.sin_addr.s_addr = htonl((127 << 24) | 1); 647#endif /* CONFIG_CTRL_IFACE_UDP_REMOTE */ 648try_again: 649 addr.sin_port = htons(port); 650 if (bind(priv->sock, (struct sockaddr *) &addr, sizeof(addr)) < 0) { 651 port++; 652 if ((port - WPA_GLOBAL_CTRL_IFACE_PORT) < 653 WPA_GLOBAL_CTRL_IFACE_PORT_LIMIT) 654 goto try_again; 655 perror("bind(AF_INET)"); 656 goto fail; 657 } 658 659#ifdef CONFIG_CTRL_IFACE_UDP_REMOTE 660 wpa_printf(MSG_DEBUG, "global_ctrl_iface_init UDP port: %d", port); 661#endif /* CONFIG_CTRL_IFACE_UDP_REMOTE */ 662 663 eloop_register_read_sock(priv->sock, 664 wpa_supplicant_global_ctrl_iface_receive, 665 global, priv); 666 667 return priv; 668 669fail: 670 if (priv->sock >= 0) 671 close(priv->sock); 672 os_free(priv); 673 return NULL; 674} 675 676 677void 678wpa_supplicant_global_ctrl_iface_deinit(struct ctrl_iface_global_priv *priv) 679{ 680 if (priv->sock >= 0) { 681 eloop_unregister_read_sock(priv->sock); 682 close(priv->sock); 683 } 684 os_free(priv); 685} 686