2 * WPA Supplicant - privilege separated driver interface
3 * Copyright (c) 2007-2009, Jouni Malinen <j@w1.fi>
5 * This software may be distributed under the terms of the BSD license.
6 * See README for more details.
15 #include "common/privsep_commands.h"
18 struct wpa_driver_privsep_data
{
20 u8 own_addr
[ETH_ALEN
];
22 char *own_socket_path
;
25 struct sockaddr_un priv_addr
;
30 static int wpa_priv_reg_cmd(struct wpa_driver_privsep_data
*drv
, int cmd
)
34 res
= sendto(drv
->priv_socket
, &cmd
, sizeof(cmd
), 0,
35 (struct sockaddr
*) &drv
->priv_addr
,
36 sizeof(drv
->priv_addr
));
38 wpa_printf(MSG_ERROR
, "sendto: %s", strerror(errno
));
39 return res
< 0 ? -1 : 0;
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
)
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
;
55 os_memset(&msg
, 0, sizeof(msg
));
57 msg
.msg_iovlen
= data
? 2 : 1;
58 msg
.msg_name
= &drv
->priv_addr
;
59 msg
.msg_namelen
= sizeof(drv
->priv_addr
);
61 if (sendmsg(drv
->cmd_socket
, &msg
, 0) < 0) {
62 wpa_printf(MSG_ERROR
, "sendmsg(cmd_socket): %s",
73 FD_SET(drv
->cmd_socket
, &rfds
);
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
));
82 if (FD_ISSET(drv
->cmd_socket
, &rfds
)) {
83 res
= recv(drv
->cmd_socket
, reply
, *reply_len
, 0);
85 wpa_printf(MSG_ERROR
, "recv: %s",
91 wpa_printf(MSG_DEBUG
, "PRIVSEP: Timeout while waiting "
92 "for reply (cmd=%d)", cmd
);
101 static int wpa_driver_privsep_scan(void *priv
,
102 struct wpa_driver_scan_params
*params
)
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
,
113 static struct wpa_scan_results
*
114 wpa_driver_privsep_get_scan_results2(void *priv
)
116 struct wpa_driver_privsep_data
*drv
= priv
;
119 size_t reply_len
= 60000;
120 struct wpa_scan_results
*results
;
121 struct wpa_scan_res
*r
;
123 buf
= os_malloc(reply_len
);
126 res
= wpa_priv_cmd(drv
, PRIVSEP_CMD_GET_SCAN_RESULTS
,
127 NULL
, 0, buf
, &reply_len
);
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
);
143 end
= buf
+ reply_len
;
144 os_memcpy(&num
, pos
, sizeof(int));
145 if (num
< 0 || num
> 1000) {
151 results
= os_zalloc(sizeof(*results
));
152 if (results
== NULL
) {
157 results
->res
= os_calloc(num
, sizeof(struct wpa_scan_res
*));
158 if (results
->res
== NULL
) {
164 while (results
->num
< (size_t) num
&& pos
+ sizeof(int) < end
) {
166 os_memcpy(&len
, pos
, sizeof(int));
168 if (len
< 0 || len
> 10000 || pos
+ len
> end
)
174 os_memcpy(r
, pos
, len
);
176 if (sizeof(*r
) + r
->ie_len
> (size_t) len
) {
181 results
->res
[results
->num
++] = r
;
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
)
195 struct wpa_driver_privsep_data
*drv
= priv
;
196 struct privsep_cmd_set_key cmd
;
198 wpa_printf(MSG_DEBUG
, "%s: priv=%p alg=%d key_idx=%d set_tx=%d",
199 __func__
, priv
, alg
, key_idx
, set_tx
);
201 os_memset(&cmd
, 0, sizeof(cmd
));
204 os_memcpy(cmd
.addr
, addr
, ETH_ALEN
);
206 os_memset(cmd
.addr
, 0xff, ETH_ALEN
);
207 cmd
.key_idx
= key_idx
;
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
;
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
;
218 return wpa_priv_cmd(drv
, PRIVSEP_CMD_SET_KEY
, &cmd
, sizeof(cmd
),
223 static int wpa_driver_privsep_associate(
224 void *priv
, struct wpa_driver_associate_params
*params
)
226 struct wpa_driver_privsep_data
*drv
= priv
;
227 struct privsep_cmd_associate
*data
;
231 wpa_printf(MSG_DEBUG
, "%s: priv=%p freq=%d pairwise_suite=%d "
232 "group_suite=%d key_mgmt_suite=%d auth_alg=%d mode=%d",
233 __func__
, priv
, params
->freq
.freq
, params
->pairwise_suite
,
234 params
->group_suite
, params
->key_mgmt_suite
,
235 params
->auth_alg
, params
->mode
);
237 buflen
= sizeof(*data
) + params
->wpa_ie_len
;
238 data
= os_zalloc(buflen
);
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
->hwmode
= params
->freq
.mode
;
247 data
->freq
= params
->freq
.freq
;
248 data
->channel
= params
->freq
.channel
;
249 data
->pairwise_suite
= params
->pairwise_suite
;
250 data
->group_suite
= params
->group_suite
;
251 data
->key_mgmt_suite
= params
->key_mgmt_suite
;
252 data
->auth_alg
= params
->auth_alg
;
253 data
->mode
= params
->mode
;
254 data
->wpa_ie_len
= params
->wpa_ie_len
;
256 os_memcpy(data
+ 1, params
->wpa_ie
, params
->wpa_ie_len
);
257 /* TODO: add support for other assoc parameters */
259 res
= wpa_priv_cmd(drv
, PRIVSEP_CMD_ASSOCIATE
, data
, buflen
,
267 static int wpa_driver_privsep_get_bssid(void *priv
, u8
*bssid
)
269 struct wpa_driver_privsep_data
*drv
= priv
;
271 size_t len
= ETH_ALEN
;
273 res
= wpa_priv_cmd(drv
, PRIVSEP_CMD_GET_BSSID
, NULL
, 0, bssid
, &len
);
274 if (res
< 0 || len
!= ETH_ALEN
)
280 static int wpa_driver_privsep_get_ssid(void *priv
, u8
*ssid
)
282 struct wpa_driver_privsep_data
*drv
= priv
;
284 u8 reply
[sizeof(int) + 32];
285 size_t len
= sizeof(reply
);
287 res
= wpa_priv_cmd(drv
, PRIVSEP_CMD_GET_SSID
, NULL
, 0, reply
, &len
);
288 if (res
< 0 || len
< sizeof(int))
290 os_memcpy(&ssid_len
, reply
, sizeof(int));
291 if (ssid_len
< 0 || ssid_len
> 32 || sizeof(int) + ssid_len
> len
) {
292 wpa_printf(MSG_DEBUG
, "privsep: Invalid get SSID reply");
295 os_memcpy(ssid
, &reply
[sizeof(int)], ssid_len
);
300 static int wpa_driver_privsep_deauthenticate(void *priv
, const u8
*addr
,
303 //struct wpa_driver_privsep_data *drv = priv;
304 wpa_printf(MSG_DEBUG
, "%s addr=" MACSTR
" reason_code=%d",
305 __func__
, MAC2STR(addr
), reason_code
);
306 wpa_printf(MSG_DEBUG
, "%s - TODO", __func__
);
311 static void wpa_driver_privsep_event_assoc(void *ctx
,
312 enum wpa_event_type event
,
315 union wpa_event_data data
;
320 os_memset(&data
, 0, sizeof(data
));
325 if (end
- pos
< (int) sizeof(int))
327 os_memcpy(&ie_len
, pos
, sizeof(int));
329 if (ie_len
< 0 || ie_len
> end
- pos
)
332 data
.assoc_info
.req_ies
= pos
;
333 data
.assoc_info
.req_ies_len
= ie_len
;
338 wpa_supplicant_event(ctx
, event
, inc_data
? &data
: NULL
);
342 static void wpa_driver_privsep_event_interface_status(void *ctx
, u8
*buf
,
345 union wpa_event_data data
;
348 if (len
< sizeof(int) ||
349 len
- sizeof(int) > sizeof(data
.interface_status
.ifname
))
352 os_memcpy(&ievent
, buf
, sizeof(int));
354 os_memset(&data
, 0, sizeof(data
));
355 data
.interface_status
.ievent
= ievent
;
356 os_memcpy(data
.interface_status
.ifname
, buf
+ sizeof(int),
358 wpa_supplicant_event(ctx
, EVENT_INTERFACE_STATUS
, &data
);
362 static void wpa_driver_privsep_event_michael_mic_failure(
363 void *ctx
, u8
*buf
, size_t len
)
365 union wpa_event_data data
;
367 if (len
!= sizeof(int))
370 os_memset(&data
, 0, sizeof(data
));
371 os_memcpy(&data
.michael_mic_failure
.unicast
, buf
, sizeof(int));
372 wpa_supplicant_event(ctx
, EVENT_MICHAEL_MIC_FAILURE
, &data
);
376 static void wpa_driver_privsep_event_pmkid_candidate(void *ctx
, u8
*buf
,
379 union wpa_event_data data
;
381 if (len
!= sizeof(struct pmkid_candidate
))
384 os_memset(&data
, 0, sizeof(data
));
385 os_memcpy(&data
.pmkid_candidate
, buf
, len
);
386 wpa_supplicant_event(ctx
, EVENT_PMKID_CANDIDATE
, &data
);
390 static void wpa_driver_privsep_event_stkstart(void *ctx
, u8
*buf
, size_t len
)
392 union wpa_event_data data
;
397 os_memset(&data
, 0, sizeof(data
));
398 os_memcpy(data
.stkstart
.peer
, buf
, ETH_ALEN
);
399 wpa_supplicant_event(ctx
, EVENT_STKSTART
, &data
);
403 static void wpa_driver_privsep_event_ft_response(void *ctx
, u8
*buf
,
406 union wpa_event_data data
;
408 if (len
< sizeof(int) + ETH_ALEN
)
411 os_memset(&data
, 0, sizeof(data
));
412 os_memcpy(&data
.ft_ies
.ft_action
, buf
, sizeof(int));
413 os_memcpy(data
.ft_ies
.target_ap
, buf
+ sizeof(int), ETH_ALEN
);
414 data
.ft_ies
.ies
= buf
+ sizeof(int) + ETH_ALEN
;
415 data
.ft_ies
.ies_len
= len
- sizeof(int) - ETH_ALEN
;
416 wpa_supplicant_event(ctx
, EVENT_FT_RESPONSE
, &data
);
420 static void wpa_driver_privsep_event_rx_eapol(void *ctx
, u8
*buf
, size_t len
)
424 drv_event_eapol_rx(ctx
, buf
, buf
+ ETH_ALEN
, len
- ETH_ALEN
);
428 static void wpa_driver_privsep_receive(int sock
, void *eloop_ctx
,
431 struct wpa_driver_privsep_data
*drv
= eloop_ctx
;
435 enum privsep_event e
;
436 struct sockaddr_un from
;
437 socklen_t fromlen
= sizeof(from
);
438 const size_t buflen
= 2000;
440 buf
= os_malloc(buflen
);
443 res
= recvfrom(sock
, buf
, buflen
, 0,
444 (struct sockaddr
*) &from
, &fromlen
);
446 wpa_printf(MSG_ERROR
, "recvfrom(priv_socket): %s",
452 wpa_printf(MSG_DEBUG
, "privsep_driver: received %u bytes", res
);
454 if (res
< (int) sizeof(int)) {
455 wpa_printf(MSG_DEBUG
, "Too short event message (len=%d)", res
);
459 os_memcpy(&event
, buf
, sizeof(int));
460 event_buf
= &buf
[sizeof(int)];
461 event_len
= res
- sizeof(int);
462 wpa_printf(MSG_DEBUG
, "privsep: Event %d received (len=%lu)",
463 event
, (unsigned long) event_len
);
467 case PRIVSEP_EVENT_SCAN_RESULTS
:
468 wpa_supplicant_event(drv
->ctx
, EVENT_SCAN_RESULTS
, NULL
);
470 case PRIVSEP_EVENT_ASSOC
:
471 wpa_driver_privsep_event_assoc(drv
->ctx
, EVENT_ASSOC
,
472 event_buf
, event_len
);
474 case PRIVSEP_EVENT_DISASSOC
:
475 wpa_supplicant_event(drv
->ctx
, EVENT_DISASSOC
, NULL
);
477 case PRIVSEP_EVENT_ASSOCINFO
:
478 wpa_driver_privsep_event_assoc(drv
->ctx
, EVENT_ASSOCINFO
,
479 event_buf
, event_len
);
481 case PRIVSEP_EVENT_MICHAEL_MIC_FAILURE
:
482 wpa_driver_privsep_event_michael_mic_failure(
483 drv
->ctx
, event_buf
, event_len
);
485 case PRIVSEP_EVENT_INTERFACE_STATUS
:
486 wpa_driver_privsep_event_interface_status(drv
->ctx
, event_buf
,
489 case PRIVSEP_EVENT_PMKID_CANDIDATE
:
490 wpa_driver_privsep_event_pmkid_candidate(drv
->ctx
, event_buf
,
493 case PRIVSEP_EVENT_STKSTART
:
494 wpa_driver_privsep_event_stkstart(drv
->ctx
, event_buf
,
497 case PRIVSEP_EVENT_FT_RESPONSE
:
498 wpa_driver_privsep_event_ft_response(drv
->ctx
, event_buf
,
501 case PRIVSEP_EVENT_RX_EAPOL
:
502 wpa_driver_privsep_event_rx_eapol(drv
->ctx
, event_buf
,
511 static void * wpa_driver_privsep_init(void *ctx
, const char *ifname
)
513 struct wpa_driver_privsep_data
*drv
;
515 drv
= os_zalloc(sizeof(*drv
));
519 drv
->priv_socket
= -1;
520 drv
->cmd_socket
= -1;
521 os_strlcpy(drv
->ifname
, ifname
, sizeof(drv
->ifname
));
527 static void wpa_driver_privsep_deinit(void *priv
)
529 struct wpa_driver_privsep_data
*drv
= priv
;
531 if (drv
->priv_socket
>= 0) {
532 wpa_priv_reg_cmd(drv
, PRIVSEP_CMD_UNREGISTER
);
533 eloop_unregister_read_sock(drv
->priv_socket
);
534 close(drv
->priv_socket
);
537 if (drv
->own_socket_path
) {
538 unlink(drv
->own_socket_path
);
539 os_free(drv
->own_socket_path
);
542 if (drv
->cmd_socket
>= 0) {
543 eloop_unregister_read_sock(drv
->cmd_socket
);
544 close(drv
->cmd_socket
);
547 if (drv
->own_cmd_path
) {
548 unlink(drv
->own_cmd_path
);
549 os_free(drv
->own_cmd_path
);
556 static int wpa_driver_privsep_set_param(void *priv
, const char *param
)
558 struct wpa_driver_privsep_data
*drv
= priv
;
560 char *own_dir
, *priv_dir
;
561 static unsigned int counter
= 0;
563 struct sockaddr_un addr
;
565 wpa_printf(MSG_DEBUG
, "%s: param='%s'", __func__
, param
);
569 pos
= os_strstr(param
, "own_dir=");
572 own_dir
= os_strdup(pos
+ 8);
575 end
= os_strchr(own_dir
, ' ');
579 own_dir
= os_strdup("/tmp");
587 pos
= os_strstr(param
, "priv_dir=");
590 priv_dir
= os_strdup(pos
+ 9);
591 if (priv_dir
== NULL
) {
595 end
= os_strchr(priv_dir
, ' ');
599 priv_dir
= os_strdup("/var/run/wpa_priv");
600 if (priv_dir
== NULL
) {
606 len
= os_strlen(own_dir
) + 50;
607 drv
->own_socket_path
= os_malloc(len
);
608 if (drv
->own_socket_path
== NULL
) {
613 os_snprintf(drv
->own_socket_path
, len
, "%s/wpa_privsep-%d-%d",
614 own_dir
, getpid(), counter
++);
616 len
= os_strlen(own_dir
) + 50;
617 drv
->own_cmd_path
= os_malloc(len
);
618 if (drv
->own_cmd_path
== NULL
) {
619 os_free(drv
->own_socket_path
);
620 drv
->own_socket_path
= NULL
;
625 os_snprintf(drv
->own_cmd_path
, len
, "%s/wpa_privsep-%d-%d",
626 own_dir
, getpid(), counter
++);
630 drv
->priv_addr
.sun_family
= AF_UNIX
;
631 os_snprintf(drv
->priv_addr
.sun_path
, sizeof(drv
->priv_addr
.sun_path
),
632 "%s/%s", priv_dir
, drv
->ifname
);
635 drv
->priv_socket
= socket(PF_UNIX
, SOCK_DGRAM
, 0);
636 if (drv
->priv_socket
< 0) {
637 wpa_printf(MSG_ERROR
, "socket(PF_UNIX): %s", strerror(errno
));
638 os_free(drv
->own_socket_path
);
639 drv
->own_socket_path
= NULL
;
643 os_memset(&addr
, 0, sizeof(addr
));
644 addr
.sun_family
= AF_UNIX
;
645 os_strlcpy(addr
.sun_path
, drv
->own_socket_path
, sizeof(addr
.sun_path
));
646 if (bind(drv
->priv_socket
, (struct sockaddr
*) &addr
, sizeof(addr
)) <
648 wpa_printf(MSG_ERROR
,
649 "privsep-set-params priv-sock: bind(PF_UNIX): %s",
651 close(drv
->priv_socket
);
652 drv
->priv_socket
= -1;
653 unlink(drv
->own_socket_path
);
654 os_free(drv
->own_socket_path
);
655 drv
->own_socket_path
= NULL
;
659 eloop_register_read_sock(drv
->priv_socket
, wpa_driver_privsep_receive
,
662 drv
->cmd_socket
= socket(PF_UNIX
, SOCK_DGRAM
, 0);
663 if (drv
->cmd_socket
< 0) {
664 wpa_printf(MSG_ERROR
, "socket(PF_UNIX): %s", strerror(errno
));
665 os_free(drv
->own_cmd_path
);
666 drv
->own_cmd_path
= NULL
;
670 os_memset(&addr
, 0, sizeof(addr
));
671 addr
.sun_family
= AF_UNIX
;
672 os_strlcpy(addr
.sun_path
, drv
->own_cmd_path
, sizeof(addr
.sun_path
));
673 if (bind(drv
->cmd_socket
, (struct sockaddr
*) &addr
, sizeof(addr
)) < 0)
675 wpa_printf(MSG_ERROR
,
676 "privsep-set-params cmd-sock: bind(PF_UNIX): %s",
678 close(drv
->cmd_socket
);
679 drv
->cmd_socket
= -1;
680 unlink(drv
->own_cmd_path
);
681 os_free(drv
->own_cmd_path
);
682 drv
->own_cmd_path
= NULL
;
686 if (wpa_priv_reg_cmd(drv
, PRIVSEP_CMD_REGISTER
) < 0) {
687 wpa_printf(MSG_ERROR
, "Failed to register with wpa_priv");
695 static int wpa_driver_privsep_get_capa(void *priv
,
696 struct wpa_driver_capa
*capa
)
698 struct wpa_driver_privsep_data
*drv
= priv
;
700 size_t len
= sizeof(*capa
);
702 res
= wpa_priv_cmd(drv
, PRIVSEP_CMD_GET_CAPA
, NULL
, 0, capa
, &len
);
703 if (res
< 0 || len
!= sizeof(*capa
))
709 static const u8
* wpa_driver_privsep_get_mac_addr(void *priv
)
711 struct wpa_driver_privsep_data
*drv
= priv
;
712 wpa_printf(MSG_DEBUG
, "%s", __func__
);
713 return drv
->own_addr
;
717 static int wpa_driver_privsep_set_country(void *priv
, const char *alpha2
)
719 struct wpa_driver_privsep_data
*drv
= priv
;
720 wpa_printf(MSG_DEBUG
, "%s country='%s'", __func__
, alpha2
);
721 return wpa_priv_cmd(drv
, PRIVSEP_CMD_SET_COUNTRY
, alpha2
,
722 os_strlen(alpha2
), NULL
, NULL
);
726 struct wpa_driver_ops wpa_driver_privsep_ops
= {
728 "wpa_supplicant privilege separated driver",
729 .get_bssid
= wpa_driver_privsep_get_bssid
,
730 .get_ssid
= wpa_driver_privsep_get_ssid
,
731 .set_key
= wpa_driver_privsep_set_key
,
732 .init
= wpa_driver_privsep_init
,
733 .deinit
= wpa_driver_privsep_deinit
,
734 .set_param
= wpa_driver_privsep_set_param
,
735 .scan2
= wpa_driver_privsep_scan
,
736 .deauthenticate
= wpa_driver_privsep_deauthenticate
,
737 .associate
= wpa_driver_privsep_associate
,
738 .get_capa
= wpa_driver_privsep_get_capa
,
739 .get_mac_addr
= wpa_driver_privsep_get_mac_addr
,
740 .get_scan_results2
= wpa_driver_privsep_get_scan_results2
,
741 .set_country
= wpa_driver_privsep_set_country
,
745 struct wpa_driver_ops
*wpa_drivers
[] =
747 &wpa_driver_privsep_ops
,