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