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