src/drivers/driver_privsep.c

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