1 /* 2 * WPA Supplicant - privilege separated driver interface 3 * Copyright (c) 2007-2009, Jouni Malinen <j (at) 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 #include <sys/un.h> 11 12 #include "common.h" 13 #include "driver.h" 14 #include "eloop.h" 15 #include "common/privsep_commands.h" 16 17 18 struct wpa_driver_privsep_data { 19 void *ctx; 20 u8 own_addr[ETH_ALEN]; 21 int priv_socket; 22 char *own_socket_path; 23 int cmd_socket; 24 char *own_cmd_path; 25 struct sockaddr_un priv_addr; 26 char ifname[16]; 27 }; 28 29 30 static int wpa_priv_reg_cmd(struct wpa_driver_privsep_data *drv, int cmd) 31 { 32 int res; 33 34 res = sendto(drv->priv_socket, &cmd, sizeof(cmd), 0, 35 (struct sockaddr *) &drv->priv_addr, 36 sizeof(drv->priv_addr)); 37 if (res < 0) 38 perror("sendto"); 39 return res < 0 ? -1 : 0; 40 } 41 42 43 static int wpa_priv_cmd(struct wpa_driver_privsep_data *drv, int cmd, 44 const void *data, size_t data_len, 45 void *reply, size_t *reply_len) 46 { 47 struct msghdr msg; 48 struct iovec io[2]; 49 50 io[0].iov_base = &cmd; 51 io[0].iov_len = sizeof(cmd); 52 io[1].iov_base = (u8 *) data; 53 io[1].iov_len = data_len; 54 55 os_memset(&msg, 0, sizeof(msg)); 56 msg.msg_iov = io; 57 msg.msg_iovlen = data ? 2 : 1; 58 msg.msg_name = &drv->priv_addr; 59 msg.msg_namelen = sizeof(drv->priv_addr); 60 61 if (sendmsg(drv->cmd_socket, &msg, 0) < 0) { 62 perror("sendmsg(cmd_socket)"); 63 return -1; 64 } 65 66 if (reply) { 67 fd_set rfds; 68 struct timeval tv; 69 int res; 70 71 FD_ZERO(&rfds); 72 FD_SET(drv->cmd_socket, &rfds); 73 tv.tv_sec = 5; 74 tv.tv_usec = 0; 75 res = select(drv->cmd_socket + 1, &rfds, NULL, NULL, &tv); 76 if (res < 0 && errno != EINTR) { 77 perror("select"); 78 return -1; 79 } 80 81 if (FD_ISSET(drv->cmd_socket, &rfds)) { 82 res = recv(drv->cmd_socket, reply, *reply_len, 0); 83 if (res < 0) { 84 perror("recv"); 85 return -1; 86 } 87 *reply_len = res; 88 } else { 89 wpa_printf(MSG_DEBUG, "PRIVSEP: Timeout while waiting " 90 "for reply (cmd=%d)", cmd); 91 return -1; 92 } 93 } 94 95 return 0; 96 } 97 98 99 static int wpa_driver_privsep_scan(void *priv, 100 struct wpa_driver_scan_params *params) 101 { 102 struct wpa_driver_privsep_data *drv = priv; 103 const u8 *ssid = params->ssids[0].ssid; 104 size_t ssid_len = params->ssids[0].ssid_len; 105 wpa_printf(MSG_DEBUG, "%s: priv=%p", __func__, priv); 106 return wpa_priv_cmd(drv, PRIVSEP_CMD_SCAN, ssid, ssid_len, 107 NULL, NULL); 108 } 109 110 111 static struct wpa_scan_results * 112 wpa_driver_privsep_get_scan_results2(void *priv) 113 { 114 struct wpa_driver_privsep_data *drv = priv; 115 int res, num; 116 u8 *buf, *pos, *end; 117 size_t reply_len = 60000; 118 struct wpa_scan_results *results; 119 struct wpa_scan_res *r; 120 121 buf = os_malloc(reply_len); 122 if (buf == NULL) 123 return NULL; 124 res = wpa_priv_cmd(drv, PRIVSEP_CMD_GET_SCAN_RESULTS, 125 NULL, 0, buf, &reply_len); 126 if (res < 0) { 127 os_free(buf); 128 return NULL; 129 } 130 131 wpa_printf(MSG_DEBUG, "privsep: Received %lu bytes of scan results", 132 (unsigned long) reply_len); 133 if (reply_len < sizeof(int)) { 134 wpa_printf(MSG_DEBUG, "privsep: Invalid scan result len %lu", 135 (unsigned long) reply_len); 136 os_free(buf); 137 return NULL; 138 } 139 140 pos = buf; 141 end = buf + reply_len; 142 os_memcpy(&num, pos, sizeof(int)); 143 if (num < 0 || num > 1000) { 144 os_free(buf); 145 return NULL; 146 } 147 pos += sizeof(int); 148 149 results = os_zalloc(sizeof(*results)); 150 if (results == NULL) { 151 os_free(buf); 152 return NULL; 153 } 154 155 results->res = os_zalloc(num * sizeof(struct wpa_scan_res *)); 156 if (results->res == NULL) { 157 os_free(results); 158 os_free(buf); 159 return NULL; 160 } 161 162 while (results->num < (size_t) num && pos + sizeof(int) < end) { 163 int len; 164 os_memcpy(&len, pos, sizeof(int)); 165 pos += sizeof(int); 166 if (len < 0 || len > 10000 || pos + len > end) 167 break; 168 169 r = os_malloc(len); 170 if (r == NULL) 171 break; 172 os_memcpy(r, pos, len); 173 pos += len; 174 if (sizeof(*r) + r->ie_len > (size_t) len) { 175 os_free(r); 176 break; 177 } 178 179 results->res[results->num++] = r; 180 } 181 182 os_free(buf); 183 return results; 184 } 185 186 187 static int wpa_driver_privsep_set_key(const char *ifname, void *priv, 188 enum wpa_alg alg, const u8 *addr, 189 int key_idx, int set_tx, 190 const u8 *seq, size_t seq_len, 191 const u8 *key, size_t key_len) 192 { 193 struct wpa_driver_privsep_data *drv = priv; 194 struct privsep_cmd_set_key cmd; 195 196 wpa_printf(MSG_DEBUG, "%s: priv=%p alg=%d key_idx=%d set_tx=%d", 197 __func__, priv, alg, key_idx, set_tx); 198 199 os_memset(&cmd, 0, sizeof(cmd)); 200 cmd.alg = alg; 201 if (addr) 202 os_memcpy(cmd.addr, addr, ETH_ALEN); 203 else 204 os_memset(cmd.addr, 0xff, ETH_ALEN); 205 cmd.key_idx = key_idx; 206 cmd.set_tx = set_tx; 207 if (seq && seq_len > 0 && seq_len < sizeof(cmd.seq)) { 208 os_memcpy(cmd.seq, seq, seq_len); 209 cmd.seq_len = seq_len; 210 } 211 if (key && key_len > 0 && key_len < sizeof(cmd.key)) { 212 os_memcpy(cmd.key, key, key_len); 213 cmd.key_len = key_len; 214 } 215 216 return wpa_priv_cmd(drv, PRIVSEP_CMD_SET_KEY, &cmd, sizeof(cmd), 217 NULL, NULL); 218 } 219 220 221 static int wpa_driver_privsep_associate( 222 void *priv, struct wpa_driver_associate_params *params) 223 { 224 struct wpa_driver_privsep_data *drv = priv; 225 struct privsep_cmd_associate *data; 226 int res; 227 size_t buflen; 228 229 wpa_printf(MSG_DEBUG, "%s: priv=%p freq=%d pairwise_suite=%d " 230 "group_suite=%d key_mgmt_suite=%d auth_alg=%d mode=%d", 231 __func__, priv, params->freq, params->pairwise_suite, 232 params->group_suite, params->key_mgmt_suite, 233 params->auth_alg, params->mode); 234 235 buflen = sizeof(*data) + params->wpa_ie_len; 236 data = os_zalloc(buflen); 237 if (data == NULL) 238 return -1; 239 240 if (params->bssid) 241 os_memcpy(data->bssid, params->bssid, ETH_ALEN); 242 os_memcpy(data->ssid, params->ssid, params->ssid_len); 243 data->ssid_len = params->ssid_len; 244 data->freq = params->freq; 245 data->pairwise_suite = params->pairwise_suite; 246 data->group_suite = params->group_suite; 247 data->key_mgmt_suite = params->key_mgmt_suite; 248 data->auth_alg = params->auth_alg; 249 data->mode = params->mode; 250 data->wpa_ie_len = params->wpa_ie_len; 251 if (params->wpa_ie) 252 os_memcpy(data + 1, params->wpa_ie, params->wpa_ie_len); 253 /* TODO: add support for other assoc parameters */ 254 255 res = wpa_priv_cmd(drv, PRIVSEP_CMD_ASSOCIATE, data, buflen, 256 NULL, NULL); 257 os_free(data); 258 259 return res; 260 } 261 262 263 static int wpa_driver_privsep_get_bssid(void *priv, u8 *bssid) 264 { 265 struct wpa_driver_privsep_data *drv = priv; 266 int res; 267 size_t len = ETH_ALEN; 268 269 res = wpa_priv_cmd(drv, PRIVSEP_CMD_GET_BSSID, NULL, 0, bssid, &len); 270 if (res < 0 || len != ETH_ALEN) 271 return -1; 272 return 0; 273 } 274 275 276 static int wpa_driver_privsep_get_ssid(void *priv, u8 *ssid) 277 { 278 struct wpa_driver_privsep_data *drv = priv; 279 int res, ssid_len; 280 u8 reply[sizeof(int) + 32]; 281 size_t len = sizeof(reply); 282 283 res = wpa_priv_cmd(drv, PRIVSEP_CMD_GET_SSID, NULL, 0, reply, &len); 284 if (res < 0 || len < sizeof(int)) 285 return -1; 286 os_memcpy(&ssid_len, reply, sizeof(int)); 287 if (ssid_len < 0 || ssid_len > 32 || sizeof(int) + ssid_len > len) { 288 wpa_printf(MSG_DEBUG, "privsep: Invalid get SSID reply"); 289 return -1; 290 } 291 os_memcpy(ssid, &reply[sizeof(int)], ssid_len); 292 return ssid_len; 293 } 294 295 296 static int wpa_driver_privsep_deauthenticate(void *priv, const u8 *addr, 297 int reason_code) 298 { 299 //struct wpa_driver_privsep_data *drv = priv; 300 wpa_printf(MSG_DEBUG, "%s addr=" MACSTR " reason_code=%d", 301 __func__, MAC2STR(addr), reason_code); 302 wpa_printf(MSG_DEBUG, "%s - TODO", __func__); 303 return 0; 304 } 305 306 307 static int wpa_driver_privsep_disassociate(void *priv, const u8 *addr, 308 int reason_code) 309 { 310 //struct wpa_driver_privsep_data *drv = priv; 311 wpa_printf(MSG_DEBUG, "%s addr=" MACSTR " reason_code=%d", 312 __func__, MAC2STR(addr), reason_code); 313 wpa_printf(MSG_DEBUG, "%s - TODO", __func__); 314 return 0; 315 } 316 317 318 static void wpa_driver_privsep_event_assoc(void *ctx, 319 enum wpa_event_type event, 320 u8 *buf, size_t len) 321 { 322 union wpa_event_data data; 323 int inc_data = 0; 324 u8 *pos, *end; 325 int ie_len; 326 327 os_memset(&data, 0, sizeof(data)); 328 329 pos = buf; 330 end = buf + len; 331 332 if (end - pos < (int) sizeof(int)) 333 return; 334 os_memcpy(&ie_len, pos, sizeof(int)); 335 pos += sizeof(int); 336 if (ie_len < 0 || ie_len > end - pos) 337 return; 338 if (ie_len) { 339 data.assoc_info.req_ies = pos; 340 data.assoc_info.req_ies_len = ie_len; 341 pos += ie_len; 342 inc_data = 1; 343 } 344 345 wpa_supplicant_event(ctx, event, inc_data ? &data : NULL); 346 } 347 348 349 static void wpa_driver_privsep_event_interface_status(void *ctx, u8 *buf, 350 size_t len) 351 { 352 union wpa_event_data data; 353 int ievent; 354 355 if (len < sizeof(int) || 356 len - sizeof(int) > sizeof(data.interface_status.ifname)) 357 return; 358 359 os_memcpy(&ievent, buf, sizeof(int)); 360 361 os_memset(&data, 0, sizeof(data)); 362 data.interface_status.ievent = ievent; 363 os_memcpy(data.interface_status.ifname, buf + sizeof(int), 364 len - sizeof(int)); 365 wpa_supplicant_event(ctx, EVENT_INTERFACE_STATUS, &data); 366 } 367 368 369 static void wpa_driver_privsep_event_michael_mic_failure( 370 void *ctx, u8 *buf, size_t len) 371 { 372 union wpa_event_data data; 373 374 if (len != sizeof(int)) 375 return; 376 377 os_memset(&data, 0, sizeof(data)); 378 os_memcpy(&data.michael_mic_failure.unicast, buf, sizeof(int)); 379 wpa_supplicant_event(ctx, EVENT_MICHAEL_MIC_FAILURE, &data); 380 } 381 382 383 static void wpa_driver_privsep_event_pmkid_candidate(void *ctx, u8 *buf, 384 size_t len) 385 { 386 union wpa_event_data data; 387 388 if (len != sizeof(struct pmkid_candidate)) 389 return; 390 391 os_memset(&data, 0, sizeof(data)); 392 os_memcpy(&data.pmkid_candidate, buf, len); 393 wpa_supplicant_event(ctx, EVENT_PMKID_CANDIDATE, &data); 394 } 395 396 397 static void wpa_driver_privsep_event_stkstart(void *ctx, u8 *buf, size_t len) 398 { 399 union wpa_event_data data; 400 401 if (len != ETH_ALEN) 402 return; 403 404 os_memset(&data, 0, sizeof(data)); 405 os_memcpy(data.stkstart.peer, buf, ETH_ALEN); 406 wpa_supplicant_event(ctx, EVENT_STKSTART, &data); 407 } 408 409 410 static void wpa_driver_privsep_event_ft_response(void *ctx, u8 *buf, 411 size_t len) 412 { 413 union wpa_event_data data; 414 415 if (len < sizeof(int) + ETH_ALEN) 416 return; 417 418 os_memset(&data, 0, sizeof(data)); 419 os_memcpy(&data.ft_ies.ft_action, buf, sizeof(int)); 420 os_memcpy(data.ft_ies.target_ap, buf + sizeof(int), ETH_ALEN); 421 data.ft_ies.ies = buf + sizeof(int) + ETH_ALEN; 422 data.ft_ies.ies_len = len - sizeof(int) - ETH_ALEN; 423 wpa_supplicant_event(ctx, EVENT_FT_RESPONSE, &data); 424 } 425 426 427 static void wpa_driver_privsep_event_rx_eapol(void *ctx, u8 *buf, size_t len) 428 { 429 if (len < ETH_ALEN) 430 return; 431 drv_event_eapol_rx(ctx, buf, buf + ETH_ALEN, len - ETH_ALEN); 432 } 433 434 435 static void wpa_driver_privsep_receive(int sock, void *eloop_ctx, 436 void *sock_ctx) 437 { 438 struct wpa_driver_privsep_data *drv = eloop_ctx; 439 u8 *buf, *event_buf; 440 size_t event_len; 441 int res, event; 442 enum privsep_event e; 443 struct sockaddr_un from; 444 socklen_t fromlen = sizeof(from); 445 const size_t buflen = 2000; 446 447 buf = os_malloc(buflen); 448 if (buf == NULL) 449 return; 450 res = recvfrom(sock, buf, buflen, 0, 451 (struct sockaddr *) &from, &fromlen); 452 if (res < 0) { 453 perror("recvfrom(priv_socket)"); 454 os_free(buf); 455 return; 456 } 457 458 wpa_printf(MSG_DEBUG, "privsep_driver: received %u bytes", res); 459 460 if (res < (int) sizeof(int)) { 461 wpa_printf(MSG_DEBUG, "Too short event message (len=%d)", res); 462 return; 463 } 464 465 os_memcpy(&event, buf, sizeof(int)); 466 event_buf = &buf[sizeof(int)]; 467 event_len = res - sizeof(int); 468 wpa_printf(MSG_DEBUG, "privsep: Event %d received (len=%lu)", 469 event, (unsigned long) event_len); 470 471 e = event; 472 switch (e) { 473 case PRIVSEP_EVENT_SCAN_RESULTS: 474 wpa_supplicant_event(drv->ctx, EVENT_SCAN_RESULTS, NULL); 475 break; 476 case PRIVSEP_EVENT_ASSOC: 477 wpa_driver_privsep_event_assoc(drv->ctx, EVENT_ASSOC, 478 event_buf, event_len); 479 break; 480 case PRIVSEP_EVENT_DISASSOC: 481 wpa_supplicant_event(drv->ctx, EVENT_DISASSOC, NULL); 482 break; 483 case PRIVSEP_EVENT_ASSOCINFO: 484 wpa_driver_privsep_event_assoc(drv->ctx, EVENT_ASSOCINFO, 485 event_buf, event_len); 486 break; 487 case PRIVSEP_EVENT_MICHAEL_MIC_FAILURE: 488 wpa_driver_privsep_event_michael_mic_failure( 489 drv->ctx, event_buf, event_len); 490 break; 491 case PRIVSEP_EVENT_INTERFACE_STATUS: 492 wpa_driver_privsep_event_interface_status(drv->ctx, event_buf, 493 event_len); 494 break; 495 case PRIVSEP_EVENT_PMKID_CANDIDATE: 496 wpa_driver_privsep_event_pmkid_candidate(drv->ctx, event_buf, 497 event_len); 498 break; 499 case PRIVSEP_EVENT_STKSTART: 500 wpa_driver_privsep_event_stkstart(drv->ctx, event_buf, 501 event_len); 502 break; 503 case PRIVSEP_EVENT_FT_RESPONSE: 504 wpa_driver_privsep_event_ft_response(drv->ctx, event_buf, 505 event_len); 506 break; 507 case PRIVSEP_EVENT_RX_EAPOL: 508 wpa_driver_privsep_event_rx_eapol(drv->ctx, event_buf, 509 event_len); 510 break; 511 } 512 513 os_free(buf); 514 } 515 516 517 static void * wpa_driver_privsep_init(void *ctx, const char *ifname) 518 { 519 struct wpa_driver_privsep_data *drv; 520 521 drv = os_zalloc(sizeof(*drv)); 522 if (drv == NULL) 523 return NULL; 524 drv->ctx = ctx; 525 drv->priv_socket = -1; 526 drv->cmd_socket = -1; 527 os_strlcpy(drv->ifname, ifname, sizeof(drv->ifname)); 528 529 return drv; 530 } 531 532 533 static void wpa_driver_privsep_deinit(void *priv) 534 { 535 struct wpa_driver_privsep_data *drv = priv; 536 537 if (drv->priv_socket >= 0) { 538 wpa_priv_reg_cmd(drv, PRIVSEP_CMD_UNREGISTER); 539 eloop_unregister_read_sock(drv->priv_socket); 540 close(drv->priv_socket); 541 } 542 543 if (drv->own_socket_path) { 544 unlink(drv->own_socket_path); 545 os_free(drv->own_socket_path); 546 } 547 548 if (drv->cmd_socket >= 0) { 549 eloop_unregister_read_sock(drv->cmd_socket); 550 close(drv->cmd_socket); 551 } 552 553 if (drv->own_cmd_path) { 554 unlink(drv->own_cmd_path); 555 os_free(drv->own_cmd_path); 556 } 557 558 os_free(drv); 559 } 560 561 562 static int wpa_driver_privsep_set_param(void *priv, const char *param) 563 { 564 struct wpa_driver_privsep_data *drv = priv; 565 const char *pos; 566 char *own_dir, *priv_dir; 567 static unsigned int counter = 0; 568 size_t len; 569 struct sockaddr_un addr; 570 571 wpa_printf(MSG_DEBUG, "%s: param='%s'", __func__, param); 572 if (param == NULL) 573 pos = NULL; 574 else 575 pos = os_strstr(param, "own_dir="); 576 if (pos) { 577 char *end; 578 own_dir = os_strdup(pos + 8); 579 if (own_dir == NULL) 580 return -1; 581 end = os_strchr(own_dir, ' '); 582 if (end) 583 *end = '\0'; 584 } else { 585 own_dir = os_strdup("/tmp"); 586 if (own_dir == NULL) 587 return -1; 588 } 589 590 if (param == NULL) 591 pos = NULL; 592 else 593 pos = os_strstr(param, "priv_dir="); 594 if (pos) { 595 char *end; 596 priv_dir = os_strdup(pos + 9); 597 if (priv_dir == NULL) { 598 os_free(own_dir); 599 return -1; 600 } 601 end = os_strchr(priv_dir, ' '); 602 if (end) 603 *end = '\0'; 604 } else { 605 priv_dir = os_strdup("/var/run/wpa_priv"); 606 if (priv_dir == NULL) { 607 os_free(own_dir); 608 return -1; 609 } 610 } 611 612 len = os_strlen(own_dir) + 50; 613 drv->own_socket_path = os_malloc(len); 614 if (drv->own_socket_path == NULL) { 615 os_free(priv_dir); 616 os_free(own_dir); 617 return -1; 618 } 619 os_snprintf(drv->own_socket_path, len, "%s/wpa_privsep-%d-%d", 620 own_dir, getpid(), counter++); 621 622 len = os_strlen(own_dir) + 50; 623 drv->own_cmd_path = os_malloc(len); 624 if (drv->own_cmd_path == NULL) { 625 os_free(drv->own_socket_path); 626 drv->own_socket_path = NULL; 627 os_free(priv_dir); 628 os_free(own_dir); 629 return -1; 630 } 631 os_snprintf(drv->own_cmd_path, len, "%s/wpa_privsep-%d-%d", 632 own_dir, getpid(), counter++); 633 634 os_free(own_dir); 635 636 drv->priv_addr.sun_family = AF_UNIX; 637 os_snprintf(drv->priv_addr.sun_path, sizeof(drv->priv_addr.sun_path), 638 "%s/%s", priv_dir, drv->ifname); 639 os_free(priv_dir); 640 641 drv->priv_socket = socket(PF_UNIX, SOCK_DGRAM, 0); 642 if (drv->priv_socket < 0) { 643 perror("socket(PF_UNIX)"); 644 os_free(drv->own_socket_path); 645 drv->own_socket_path = NULL; 646 return -1; 647 } 648 649 os_memset(&addr, 0, sizeof(addr)); 650 addr.sun_family = AF_UNIX; 651 os_strlcpy(addr.sun_path, drv->own_socket_path, sizeof(addr.sun_path)); 652 if (bind(drv->priv_socket, (struct sockaddr *) &addr, sizeof(addr)) < 653 0) { 654 perror("bind(PF_UNIX)"); 655 close(drv->priv_socket); 656 drv->priv_socket = -1; 657 unlink(drv->own_socket_path); 658 os_free(drv->own_socket_path); 659 drv->own_socket_path = NULL; 660 return -1; 661 } 662 663 eloop_register_read_sock(drv->priv_socket, wpa_driver_privsep_receive, 664 drv, NULL); 665 666 drv->cmd_socket = socket(PF_UNIX, SOCK_DGRAM, 0); 667 if (drv->cmd_socket < 0) { 668 perror("socket(PF_UNIX)"); 669 os_free(drv->own_cmd_path); 670 drv->own_cmd_path = NULL; 671 return -1; 672 } 673 674 os_memset(&addr, 0, sizeof(addr)); 675 addr.sun_family = AF_UNIX; 676 os_strlcpy(addr.sun_path, drv->own_cmd_path, sizeof(addr.sun_path)); 677 if (bind(drv->cmd_socket, (struct sockaddr *) &addr, sizeof(addr)) < 0) 678 { 679 perror("bind(PF_UNIX)"); 680 close(drv->cmd_socket); 681 drv->cmd_socket = -1; 682 unlink(drv->own_cmd_path); 683 os_free(drv->own_cmd_path); 684 drv->own_cmd_path = NULL; 685 return -1; 686 } 687 688 if (wpa_priv_reg_cmd(drv, PRIVSEP_CMD_REGISTER) < 0) { 689 wpa_printf(MSG_ERROR, "Failed to register with wpa_priv"); 690 return -1; 691 } 692 693 return 0; 694 } 695 696 697 static int wpa_driver_privsep_get_capa(void *priv, 698 struct wpa_driver_capa *capa) 699 { 700 struct wpa_driver_privsep_data *drv = priv; 701 int res; 702 size_t len = sizeof(*capa); 703 704 res = wpa_priv_cmd(drv, PRIVSEP_CMD_GET_CAPA, NULL, 0, capa, &len); 705 if (res < 0 || len != sizeof(*capa)) 706 return -1; 707 return 0; 708 } 709 710 711 static const u8 * wpa_driver_privsep_get_mac_addr(void *priv) 712 { 713 struct wpa_driver_privsep_data *drv = priv; 714 wpa_printf(MSG_DEBUG, "%s", __func__); 715 return drv->own_addr; 716 } 717 718 719 static int wpa_driver_privsep_set_country(void *priv, const char *alpha2) 720 { 721 struct wpa_driver_privsep_data *drv = priv; 722 wpa_printf(MSG_DEBUG, "%s country='%s'", __func__, alpha2); 723 return wpa_priv_cmd(drv, PRIVSEP_CMD_SET_COUNTRY, alpha2, 724 os_strlen(alpha2), NULL, NULL); 725 } 726 727 728 struct wpa_driver_ops wpa_driver_privsep_ops = { 729 "privsep", 730 "wpa_supplicant privilege separated driver", 731 .get_bssid = wpa_driver_privsep_get_bssid, 732 .get_ssid = wpa_driver_privsep_get_ssid, 733 .set_key = wpa_driver_privsep_set_key, 734 .init = wpa_driver_privsep_init, 735 .deinit = wpa_driver_privsep_deinit, 736 .set_param = wpa_driver_privsep_set_param, 737 .scan2 = wpa_driver_privsep_scan, 738 .deauthenticate = wpa_driver_privsep_deauthenticate, 739 .disassociate = wpa_driver_privsep_disassociate, 740 .associate = wpa_driver_privsep_associate, 741 .get_capa = wpa_driver_privsep_get_capa, 742 .get_mac_addr = wpa_driver_privsep_get_mac_addr, 743 .get_scan_results2 = wpa_driver_privsep_get_scan_results2, 744 .set_country = wpa_driver_privsep_set_country, 745 }; 746 747 748 struct wpa_driver_ops *wpa_drivers[] = 749 { 750 &wpa_driver_privsep_ops, 751 NULL 752 }; 753
