2 * WPA Supplicant / privileged helper program
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.
12 #endif /* __linux__ */
18 #include "common/version.h"
19 #include "drivers/driver.h"
20 #include "l2_packet/l2_packet.h"
21 #include "common/privsep_commands.h"
22 #include "common/ieee802_11_defs.h"
24 #define WPA_PRIV_MAX_L2 3
26 struct wpa_priv_interface {
27 struct wpa_priv_interface *next;
35 const struct wpa_driver_ops *driver;
37 void *drv_global_priv;
38 struct sockaddr_un drv_addr;
39 socklen_t drv_addr_len;
42 struct l2_packet_data *l2[WPA_PRIV_MAX_L2];
43 struct sockaddr_un l2_addr[WPA_PRIV_MAX_L2];
44 socklen_t l2_addr_len[WPA_PRIV_MAX_L2];
46 struct wpa_priv_interface *parent;
48 } l2_ctx[WPA_PRIV_MAX_L2];
51 struct wpa_priv_global {
52 struct wpa_priv_interface *interfaces;
56 static void wpa_priv_cmd_register(struct wpa_priv_interface *iface,
57 struct sockaddr_un *from, socklen_t fromlen)
61 if (iface->drv_priv) {
62 wpa_printf(MSG_DEBUG, "Cleaning up forgotten driver instance");
63 if (iface->driver->deinit)
64 iface->driver->deinit(iface->drv_priv);
65 iface->drv_priv = NULL;
66 if (iface->drv_global_priv) {
67 iface->driver->global_deinit(iface->drv_global_priv);
68 iface->drv_global_priv = NULL;
70 iface->wpas_registered = 0;
73 for (i = 0; i < WPA_PRIV_MAX_L2; i++) {
76 "Cleaning up forgotten l2_packet instance");
77 l2_packet_deinit(iface->l2[i]);
82 if (iface->driver->init2) {
83 if (iface->driver->global_init) {
84 iface->drv_global_priv =
85 iface->driver->global_init(iface->ctx);
86 if (!iface->drv_global_priv) {
88 "Failed to initialize driver global context");
92 iface->drv_global_priv = NULL;
94 iface->drv_priv = iface->driver->init2(iface, iface->ifname,
95 iface->drv_global_priv);
96 } else if (iface->driver->init) {
97 iface->drv_priv = iface->driver->init(iface, iface->ifname);
101 if (iface->drv_priv == NULL) {
102 wpa_printf(MSG_DEBUG, "Failed to initialize driver wrapper");
106 wpa_printf(MSG_DEBUG, "Driver wrapper '%s' initialized for interface "
107 "'%s'", iface->driver_name, iface->ifname);
109 os_memcpy(&iface->drv_addr, from, fromlen);
110 iface->drv_addr_len = fromlen;
111 iface->wpas_registered = 1;
113 if (iface->driver->set_param &&
114 iface->driver->set_param(iface->drv_priv, NULL) < 0) {
115 wpa_printf(MSG_ERROR, "Driver interface rejected param");
120 static void wpa_priv_cmd_unregister(struct wpa_priv_interface *iface,
121 struct sockaddr_un *from)
123 if (iface->drv_priv) {
124 if (iface->driver->deinit)
125 iface->driver->deinit(iface->drv_priv);
126 iface->drv_priv = NULL;
127 if (iface->drv_global_priv) {
128 iface->driver->global_deinit(iface->drv_global_priv);
129 iface->drv_global_priv = NULL;
131 iface->wpas_registered = 0;
136 static void wpa_priv_cmd_scan(struct wpa_priv_interface *iface,
137 void *buf, size_t len)
139 struct wpa_driver_scan_params params;
140 struct privsep_cmd_scan *scan;
142 int freqs[PRIVSEP_MAX_SCAN_FREQS + 1];
144 if (iface->drv_priv == NULL)
147 if (len < sizeof(*scan)) {
148 wpa_printf(MSG_DEBUG, "Invalid scan request");
154 os_memset(¶ms, 0, sizeof(params));
155 if (scan->num_ssids > WPAS_MAX_SCAN_SSIDS) {
156 wpa_printf(MSG_DEBUG, "Invalid scan request (num_ssids)");
159 params.num_ssids = scan->num_ssids;
160 for (i = 0; i < scan->num_ssids; i++) {
161 params.ssids[i].ssid = scan->ssids[i];
162 params.ssids[i].ssid_len = scan->ssid_lens[i];
165 if (scan->num_freqs > PRIVSEP_MAX_SCAN_FREQS) {
166 wpa_printf(MSG_DEBUG, "Invalid scan request (num_freqs)");
169 if (scan->num_freqs) {
170 for (i = 0; i < scan->num_freqs; i++)
171 freqs[i] = scan->freqs[i];
173 params.freqs = freqs;
176 if (iface->driver->scan2)
177 iface->driver->scan2(iface->drv_priv, ¶ms);
181 static void wpa_priv_get_scan_results2(struct wpa_priv_interface *iface,
182 struct sockaddr_un *from,
185 struct wpa_scan_results *res;
186 u8 *buf = NULL, *pos, *end;
190 res = iface->driver->get_scan_results2(iface->drv_priv);
194 buf = os_malloc(60000);
200 os_memcpy(pos, &val, sizeof(int));
203 for (i = 0; i < res->num; i++) {
204 struct wpa_scan_res *r = res->res[i];
205 val = sizeof(*r) + r->ie_len + r->beacon_ie_len;
206 if (end - pos < (int) sizeof(int) + val)
208 os_memcpy(pos, &val, sizeof(int));
210 os_memcpy(pos, r, val);
214 sendto(iface->fd, buf, pos - buf, 0, (struct sockaddr *) from, fromlen);
217 wpa_scan_results_free(res);
222 wpa_scan_results_free(res);
223 sendto(iface->fd, "", 0, 0, (struct sockaddr *) from, fromlen);
227 static void wpa_priv_cmd_get_scan_results(struct wpa_priv_interface *iface,
228 struct sockaddr_un *from,
231 if (iface->drv_priv == NULL)
234 if (iface->driver->get_scan_results2)
235 wpa_priv_get_scan_results2(iface, from, fromlen);
237 sendto(iface->fd, "", 0, 0, (struct sockaddr *) from, fromlen);
241 static void wpa_priv_cmd_authenticate(struct wpa_priv_interface *iface,
242 void *buf, size_t len)
244 struct wpa_driver_auth_params params;
245 struct privsep_cmd_authenticate *auth;
248 if (iface->drv_priv == NULL || iface->driver->authenticate == NULL)
251 if (len < sizeof(*auth)) {
252 wpa_printf(MSG_DEBUG, "Invalid authentication request");
257 if (sizeof(*auth) + auth->ie_len + auth->auth_data_len > len) {
258 wpa_printf(MSG_DEBUG, "Authentication request overflow");
262 os_memset(¶ms, 0, sizeof(params));
263 params.freq = auth->freq;
264 params.bssid = auth->bssid;
265 params.ssid = auth->ssid;
266 if (auth->ssid_len > SSID_MAX_LEN)
268 params.ssid_len = auth->ssid_len;
269 params.auth_alg = auth->auth_alg;
270 for (i = 0; i < 4; i++) {
271 if (auth->wep_key_len[i]) {
272 params.wep_key[i] = auth->wep_key[i];
273 params.wep_key_len[i] = auth->wep_key_len[i];
276 params.wep_tx_keyidx = auth->wep_tx_keyidx;
277 params.local_state_change = auth->local_state_change;
278 params.p2p = auth->p2p;
280 params.ie = (u8 *) (auth + 1);
281 params.ie_len = auth->ie_len;
283 if (auth->auth_data_len) {
284 params.auth_data = ((u8 *) (auth + 1)) + auth->ie_len;
285 params.auth_data_len = auth->auth_data_len;
288 res = iface->driver->authenticate(iface->drv_priv, ¶ms);
289 wpa_printf(MSG_DEBUG, "drv->authenticate: res=%d", res);
293 static void wpa_priv_cmd_associate(struct wpa_priv_interface *iface,
294 void *buf, size_t len)
296 struct wpa_driver_associate_params params;
297 struct privsep_cmd_associate *assoc;
301 if (iface->drv_priv == NULL || iface->driver->associate == NULL)
304 if (len < sizeof(*assoc)) {
305 wpa_printf(MSG_DEBUG, "Invalid association request");
310 if (sizeof(*assoc) + assoc->wpa_ie_len > len) {
311 wpa_printf(MSG_DEBUG, "Association request overflow");
315 os_memset(¶ms, 0, sizeof(params));
316 bssid = assoc->bssid;
317 if (bssid[0] | bssid[1] | bssid[2] | bssid[3] | bssid[4] | bssid[5])
318 params.bssid = bssid;
319 params.ssid = assoc->ssid;
320 if (assoc->ssid_len > SSID_MAX_LEN)
322 params.ssid_len = assoc->ssid_len;
323 params.freq.mode = assoc->hwmode;
324 params.freq.freq = assoc->freq;
325 params.freq.channel = assoc->channel;
326 if (assoc->wpa_ie_len) {
327 params.wpa_ie = (u8 *) (assoc + 1);
328 params.wpa_ie_len = assoc->wpa_ie_len;
330 params.pairwise_suite = assoc->pairwise_suite;
331 params.group_suite = assoc->group_suite;
332 params.key_mgmt_suite = assoc->key_mgmt_suite;
333 params.auth_alg = assoc->auth_alg;
334 params.mode = assoc->mode;
336 res = iface->driver->associate(iface->drv_priv, ¶ms);
337 wpa_printf(MSG_DEBUG, "drv->associate: res=%d", res);
341 static void wpa_priv_cmd_get_bssid(struct wpa_priv_interface *iface,
342 struct sockaddr_un *from, socklen_t fromlen)
346 if (iface->drv_priv == NULL)
349 if (iface->driver->get_bssid == NULL ||
350 iface->driver->get_bssid(iface->drv_priv, bssid) < 0)
353 sendto(iface->fd, bssid, ETH_ALEN, 0, (struct sockaddr *) from,
358 sendto(iface->fd, "", 0, 0, (struct sockaddr *) from, fromlen);
362 static void wpa_priv_cmd_get_ssid(struct wpa_priv_interface *iface,
363 struct sockaddr_un *from, socklen_t fromlen)
365 u8 ssid[sizeof(int) + SSID_MAX_LEN];
368 if (iface->drv_priv == NULL)
371 if (iface->driver->get_ssid == NULL)
374 os_memset(ssid, 0, sizeof(ssid));
375 res = iface->driver->get_ssid(iface->drv_priv, &ssid[sizeof(int)]);
376 if (res < 0 || res > SSID_MAX_LEN)
378 os_memcpy(ssid, &res, sizeof(int));
380 sendto(iface->fd, ssid, sizeof(ssid), 0, (struct sockaddr *) from,
385 sendto(iface->fd, "", 0, 0, (struct sockaddr *) from, fromlen);
389 static void wpa_priv_cmd_set_key(struct wpa_priv_interface *iface,
390 void *buf, size_t len)
392 struct privsep_cmd_set_key *params;
395 if (iface->drv_priv == NULL || iface->driver->set_key == NULL)
398 if (len != sizeof(*params)) {
399 wpa_printf(MSG_DEBUG, "Invalid set_key request");
405 res = iface->driver->set_key(iface->ifname, iface->drv_priv,
407 params->addr, params->key_idx,
409 params->seq_len ? params->seq : NULL,
411 params->key_len ? params->key : NULL,
413 wpa_printf(MSG_DEBUG, "drv->set_key: res=%d", res);
417 static void wpa_priv_cmd_get_capa(struct wpa_priv_interface *iface,
418 struct sockaddr_un *from, socklen_t fromlen)
420 struct wpa_driver_capa capa;
422 if (iface->drv_priv == NULL)
425 if (iface->driver->get_capa == NULL ||
426 iface->driver->get_capa(iface->drv_priv, &capa) < 0)
429 /* For now, no support for passing extended_capa pointers */
430 capa.extended_capa = NULL;
431 capa.extended_capa_mask = NULL;
432 capa.extended_capa_len = 0;
433 sendto(iface->fd, &capa, sizeof(capa), 0, (struct sockaddr *) from,
438 sendto(iface->fd, "", 0, 0, (struct sockaddr *) from, fromlen);
442 static void wpa_priv_l2_rx(void *ctx, const u8 *src_addr, const u8 *buf,
445 struct wpa_priv_l2 *l2_ctx = ctx;
446 struct wpa_priv_interface *iface = l2_ctx->parent;
450 io[0].iov_base = (u8 *) src_addr;
451 io[0].iov_len = ETH_ALEN;
452 io[1].iov_base = (u8 *) buf;
455 os_memset(&msg, 0, sizeof(msg));
458 msg.msg_name = &iface->l2_addr[l2_ctx->idx];
459 msg.msg_namelen = iface->l2_addr_len[l2_ctx->idx];
461 if (sendmsg(iface->fd, &msg, 0) < 0) {
462 wpa_printf(MSG_ERROR, "sendmsg(l2 rx): %s", strerror(errno));
467 static int wpa_priv_allowed_l2_proto(u16 proto)
469 return proto == ETH_P_EAPOL || proto == ETH_P_RSN_PREAUTH ||
470 proto == ETH_P_80211_ENCAP;
474 static void wpa_priv_cmd_l2_register(struct wpa_priv_interface *iface,
475 struct sockaddr_un *from,
477 void *buf, size_t len)
480 u8 own_addr[ETH_ALEN];
485 if (len != 2 * sizeof(int)) {
486 wpa_printf(MSG_DEBUG, "Invalid l2_register length %lu",
487 (unsigned long) len);
492 if (!wpa_priv_allowed_l2_proto(proto)) {
493 wpa_printf(MSG_DEBUG, "Refused l2_packet connection for "
494 "ethertype 0x%x", proto);
498 for (idx = 0; idx < WPA_PRIV_MAX_L2; idx++) {
502 if (idx == WPA_PRIV_MAX_L2) {
503 wpa_printf(MSG_DEBUG, "No free l2_packet connection found");
507 os_memcpy(&iface->l2_addr[idx], from, fromlen);
508 iface->l2_addr_len[idx] = fromlen;
510 iface->l2_ctx[idx].idx = idx;
511 iface->l2_ctx[idx].parent = iface;
512 iface->l2[idx] = l2_packet_init(iface->ifname, NULL, proto,
513 wpa_priv_l2_rx, &iface->l2_ctx[idx],
515 if (!iface->l2[idx]) {
516 wpa_printf(MSG_DEBUG, "Failed to initialize l2_packet "
517 "instance for protocol %d", proto);
521 if (l2_packet_get_own_addr(iface->l2[idx], own_addr) < 0) {
522 wpa_printf(MSG_DEBUG, "Failed to get own address from "
524 l2_packet_deinit(iface->l2[idx]);
525 iface->l2[idx] = NULL;
529 res = sendto(iface->fd, own_addr, ETH_ALEN, 0,
530 (struct sockaddr *) from, fromlen);
531 wpa_printf(MSG_DEBUG, "L2 registration[idx=%d]: res=%d", idx, res);
535 static void wpa_priv_cmd_l2_unregister(struct wpa_priv_interface *iface,
536 struct sockaddr_un *from,
541 for (idx = 0; idx < WPA_PRIV_MAX_L2; idx++) {
542 if (iface->l2_addr_len[idx] == fromlen &&
543 os_memcmp(&iface->l2_addr[idx], from, fromlen) == 0)
546 if (idx == WPA_PRIV_MAX_L2) {
547 wpa_printf(MSG_DEBUG,
548 "No registered l2_packet socket found for unregister request");
552 if (iface->l2[idx]) {
553 l2_packet_deinit(iface->l2[idx]);
554 iface->l2[idx] = NULL;
559 static void wpa_priv_cmd_l2_notify_auth_start(struct wpa_priv_interface *iface,
560 struct sockaddr_un *from)
564 for (idx = 0; idx < WPA_PRIV_MAX_L2; idx++) {
566 l2_packet_notify_auth_start(iface->l2[idx]);
571 static void wpa_priv_cmd_l2_send(struct wpa_priv_interface *iface,
572 struct sockaddr_un *from, socklen_t fromlen,
573 void *buf, size_t len)
580 for (idx = 0; idx < WPA_PRIV_MAX_L2; idx++) {
581 if (iface->l2_addr_len[idx] == fromlen &&
582 os_memcmp(&iface->l2_addr[idx], from, fromlen) == 0)
585 if (idx == WPA_PRIV_MAX_L2) {
586 wpa_printf(MSG_DEBUG,
587 "No registered l2_packet socket found for send request");
591 if (iface->l2[idx] == NULL)
594 if (len < ETH_ALEN + 2) {
595 wpa_printf(MSG_DEBUG, "Too short L2 send packet (len=%lu)",
596 (unsigned long) len);
601 os_memcpy(&proto, buf + ETH_ALEN, 2);
603 if (!wpa_priv_allowed_l2_proto(proto)) {
604 wpa_printf(MSG_DEBUG, "Refused l2_packet send for ethertype "
609 res = l2_packet_send(iface->l2[idx], dst_addr, proto,
610 buf + ETH_ALEN + 2, len - ETH_ALEN - 2);
611 wpa_printf(MSG_DEBUG, "L2 send[idx=%d]: res=%d", idx, res);
615 static void wpa_priv_cmd_set_country(struct wpa_priv_interface *iface,
618 if (iface->drv_priv == NULL || iface->driver->set_country == NULL ||
622 iface->driver->set_country(iface->drv_priv, buf);
626 static void wpa_priv_receive(int sock, void *eloop_ctx, void *sock_ctx)
628 struct wpa_priv_interface *iface = eloop_ctx;
629 char buf[2000], *pos;
633 struct sockaddr_un from;
634 socklen_t fromlen = sizeof(from);
636 res = recvfrom(sock, buf, sizeof(buf), 0, (struct sockaddr *) &from,
639 wpa_printf(MSG_ERROR, "recvfrom: %s", strerror(errno));
643 if (res < (int) sizeof(int)) {
644 wpa_printf(MSG_DEBUG, "Too short command (len=%d)", res);
648 os_memcpy(&cmd, buf, sizeof(int));
649 wpa_printf(MSG_DEBUG, "Command %d for interface %s",
651 cmd_buf = &buf[sizeof(int)];
652 cmd_len = res - sizeof(int);
655 case PRIVSEP_CMD_REGISTER:
656 wpa_priv_cmd_register(iface, &from, fromlen);
658 case PRIVSEP_CMD_UNREGISTER:
659 wpa_priv_cmd_unregister(iface, &from);
661 case PRIVSEP_CMD_SCAN:
662 wpa_priv_cmd_scan(iface, cmd_buf, cmd_len);
664 case PRIVSEP_CMD_GET_SCAN_RESULTS:
665 wpa_priv_cmd_get_scan_results(iface, &from, fromlen);
667 case PRIVSEP_CMD_ASSOCIATE:
668 wpa_priv_cmd_associate(iface, cmd_buf, cmd_len);
670 case PRIVSEP_CMD_GET_BSSID:
671 wpa_priv_cmd_get_bssid(iface, &from, fromlen);
673 case PRIVSEP_CMD_GET_SSID:
674 wpa_priv_cmd_get_ssid(iface, &from, fromlen);
676 case PRIVSEP_CMD_SET_KEY:
677 wpa_priv_cmd_set_key(iface, cmd_buf, cmd_len);
679 case PRIVSEP_CMD_GET_CAPA:
680 wpa_priv_cmd_get_capa(iface, &from, fromlen);
682 case PRIVSEP_CMD_L2_REGISTER:
683 wpa_priv_cmd_l2_register(iface, &from, fromlen,
686 case PRIVSEP_CMD_L2_UNREGISTER:
687 wpa_priv_cmd_l2_unregister(iface, &from, fromlen);
689 case PRIVSEP_CMD_L2_NOTIFY_AUTH_START:
690 wpa_priv_cmd_l2_notify_auth_start(iface, &from);
692 case PRIVSEP_CMD_L2_SEND:
693 wpa_priv_cmd_l2_send(iface, &from, fromlen, cmd_buf, cmd_len);
695 case PRIVSEP_CMD_SET_COUNTRY:
697 if (pos + cmd_len >= buf + sizeof(buf))
700 wpa_priv_cmd_set_country(iface, pos);
702 case PRIVSEP_CMD_AUTHENTICATE:
703 wpa_priv_cmd_authenticate(iface, cmd_buf, cmd_len);
709 static void wpa_priv_interface_deinit(struct wpa_priv_interface *iface)
713 if (iface->drv_priv) {
714 if (iface->driver->deinit)
715 iface->driver->deinit(iface->drv_priv);
716 if (iface->drv_global_priv)
717 iface->driver->global_deinit(iface->drv_global_priv);
720 if (iface->fd >= 0) {
721 eloop_unregister_read_sock(iface->fd);
723 unlink(iface->sock_name);
726 for (i = 0; i < WPA_PRIV_MAX_L2; i++) {
728 l2_packet_deinit(iface->l2[i]);
731 os_free(iface->ifname);
732 os_free(iface->driver_name);
733 os_free(iface->sock_name);
738 static struct wpa_priv_interface *
739 wpa_priv_interface_init(void *ctx, const char *dir, const char *params)
741 struct wpa_priv_interface *iface;
744 struct sockaddr_un addr;
747 pos = os_strchr(params, ':');
751 iface = os_zalloc(sizeof(*iface));
758 iface->driver_name = dup_binstr(params, len);
759 if (iface->driver_name == NULL) {
760 wpa_priv_interface_deinit(iface);
764 for (i = 0; wpa_drivers[i]; i++) {
765 if (os_strcmp(iface->driver_name,
766 wpa_drivers[i]->name) == 0) {
767 iface->driver = wpa_drivers[i];
771 if (iface->driver == NULL) {
772 wpa_printf(MSG_ERROR, "Unsupported driver '%s'",
774 wpa_priv_interface_deinit(iface);
779 iface->ifname = os_strdup(pos);
780 if (iface->ifname == NULL) {
781 wpa_priv_interface_deinit(iface);
785 len = os_strlen(dir) + 1 + os_strlen(iface->ifname);
786 iface->sock_name = os_malloc(len + 1);
787 if (iface->sock_name == NULL) {
788 wpa_priv_interface_deinit(iface);
792 os_snprintf(iface->sock_name, len + 1, "%s/%s", dir, iface->ifname);
793 if (os_strlen(iface->sock_name) >= sizeof(addr.sun_path)) {
794 wpa_priv_interface_deinit(iface);
798 iface->fd = socket(PF_UNIX, SOCK_DGRAM, 0);
800 wpa_printf(MSG_ERROR, "socket(PF_UNIX): %s", strerror(errno));
801 wpa_priv_interface_deinit(iface);
805 os_memset(&addr, 0, sizeof(addr));
806 addr.sun_family = AF_UNIX;
807 os_strlcpy(addr.sun_path, iface->sock_name, sizeof(addr.sun_path));
809 if (bind(iface->fd, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
810 wpa_printf(MSG_DEBUG, "bind(PF_UNIX) failed: %s",
812 if (connect(iface->fd, (struct sockaddr *) &addr,
814 wpa_printf(MSG_DEBUG, "Socket exists, but does not "
815 "allow connections - assuming it was "
816 "leftover from forced program termination");
817 if (unlink(iface->sock_name) < 0) {
818 wpa_printf(MSG_ERROR,
819 "Could not unlink existing ctrl_iface socket '%s': %s",
820 iface->sock_name, strerror(errno));
823 if (bind(iface->fd, (struct sockaddr *) &addr,
825 wpa_printf(MSG_ERROR,
826 "wpa-priv-iface-init: bind(PF_UNIX): %s",
830 wpa_printf(MSG_DEBUG, "Successfully replaced leftover "
831 "socket '%s'", iface->sock_name);
833 wpa_printf(MSG_INFO, "Socket exists and seems to be "
834 "in use - cannot override it");
835 wpa_printf(MSG_INFO, "Delete '%s' manually if it is "
836 "not used anymore", iface->sock_name);
841 if (chmod(iface->sock_name, S_IRWXU | S_IRWXG | S_IRWXO) < 0) {
842 wpa_printf(MSG_ERROR, "chmod: %s", strerror(errno));
846 eloop_register_read_sock(iface->fd, wpa_priv_receive, iface, NULL);
851 wpa_priv_interface_deinit(iface);
856 static int wpa_priv_send_event(struct wpa_priv_interface *iface, int event,
857 const void *data, size_t data_len)
862 io[0].iov_base = &event;
863 io[0].iov_len = sizeof(event);
864 io[1].iov_base = (u8 *) data;
865 io[1].iov_len = data_len;
867 os_memset(&msg, 0, sizeof(msg));
869 msg.msg_iovlen = data ? 2 : 1;
870 msg.msg_name = &iface->drv_addr;
871 msg.msg_namelen = iface->drv_addr_len;
873 if (sendmsg(iface->fd, &msg, 0) < 0) {
874 wpa_printf(MSG_ERROR, "sendmsg(wpas_socket): %s",
883 static void wpa_priv_send_auth(struct wpa_priv_interface *iface,
884 union wpa_event_data *data)
886 size_t buflen = sizeof(struct privsep_event_auth) + data->auth.ies_len;
887 struct privsep_event_auth *auth;
890 buf = os_zalloc(buflen);
894 auth = (struct privsep_event_auth *) buf;
895 pos = (u8 *) (auth + 1);
897 os_memcpy(auth->peer, data->auth.peer, ETH_ALEN);
898 os_memcpy(auth->bssid, data->auth.bssid, ETH_ALEN);
899 auth->auth_type = data->auth.auth_type;
900 auth->auth_transaction = data->auth.auth_transaction;
901 auth->status_code = data->auth.status_code;
902 if (data->auth.ies) {
903 os_memcpy(pos, data->auth.ies, data->auth.ies_len);
904 auth->ies_len = data->auth.ies_len;
907 wpa_priv_send_event(iface, PRIVSEP_EVENT_AUTH, buf, buflen);
913 static void wpa_priv_send_assoc(struct wpa_priv_interface *iface, int event,
914 union wpa_event_data *data)
916 size_t buflen = 3 * sizeof(int);
921 buflen += data->assoc_info.req_ies_len +
922 data->assoc_info.resp_ies_len +
923 data->assoc_info.beacon_ies_len;
926 buf = os_malloc(buflen);
932 if (data && data->assoc_info.req_ies) {
933 len = data->assoc_info.req_ies_len;
934 os_memcpy(pos, &len, sizeof(int));
936 os_memcpy(pos, data->assoc_info.req_ies, len);
940 os_memcpy(pos, &len, sizeof(int));
944 if (data && data->assoc_info.resp_ies) {
945 len = data->assoc_info.resp_ies_len;
946 os_memcpy(pos, &len, sizeof(int));
948 os_memcpy(pos, data->assoc_info.resp_ies, len);
952 os_memcpy(pos, &len, sizeof(int));
956 if (data && data->assoc_info.beacon_ies) {
957 len = data->assoc_info.beacon_ies_len;
958 os_memcpy(pos, &len, sizeof(int));
960 os_memcpy(pos, data->assoc_info.beacon_ies, len);
964 os_memcpy(pos, &len, sizeof(int));
968 wpa_priv_send_event(iface, event, buf, buflen);
974 static void wpa_priv_send_interface_status(struct wpa_priv_interface *iface,
975 union wpa_event_data *data)
985 ievent = data->interface_status.ievent;
986 maxlen = sizeof(data->interface_status.ifname);
987 ifname = data->interface_status.ifname;
988 for (len = 0; len < maxlen && ifname[len]; len++)
991 buf = os_malloc(sizeof(int) + len);
995 os_memcpy(buf, &ievent, sizeof(int));
996 os_memcpy(buf + sizeof(int), ifname, len);
998 wpa_priv_send_event(iface, PRIVSEP_EVENT_INTERFACE_STATUS,
999 buf, sizeof(int) + len);
1006 static void wpa_priv_send_ft_response(struct wpa_priv_interface *iface,
1007 union wpa_event_data *data)
1012 if (data == NULL || data->ft_ies.ies == NULL)
1015 len = sizeof(int) + ETH_ALEN + data->ft_ies.ies_len;
1016 buf = os_malloc(len);
1021 os_memcpy(pos, &data->ft_ies.ft_action, sizeof(int));
1023 os_memcpy(pos, data->ft_ies.target_ap, ETH_ALEN);
1025 os_memcpy(pos, data->ft_ies.ies, data->ft_ies.ies_len);
1027 wpa_priv_send_event(iface, PRIVSEP_EVENT_FT_RESPONSE, buf, len);
1034 void wpa_supplicant_event(void *ctx, enum wpa_event_type event,
1035 union wpa_event_data *data)
1037 struct wpa_priv_interface *iface = ctx;
1039 wpa_printf(MSG_DEBUG, "%s - event=%d", __func__, event);
1041 if (!iface->wpas_registered) {
1042 wpa_printf(MSG_DEBUG, "Driver event received, but "
1043 "wpa_supplicant not registered");
1049 wpa_priv_send_assoc(iface, PRIVSEP_EVENT_ASSOC, data);
1051 case EVENT_DISASSOC:
1052 wpa_priv_send_event(iface, PRIVSEP_EVENT_DISASSOC, NULL, 0);
1054 case EVENT_ASSOCINFO:
1057 wpa_priv_send_assoc(iface, PRIVSEP_EVENT_ASSOCINFO, data);
1059 case EVENT_MICHAEL_MIC_FAILURE:
1062 wpa_priv_send_event(iface, PRIVSEP_EVENT_MICHAEL_MIC_FAILURE,
1063 &data->michael_mic_failure.unicast,
1066 case EVENT_SCAN_STARTED:
1067 wpa_priv_send_event(iface, PRIVSEP_EVENT_SCAN_STARTED, NULL,
1070 case EVENT_SCAN_RESULTS:
1071 wpa_priv_send_event(iface, PRIVSEP_EVENT_SCAN_RESULTS, NULL,
1074 case EVENT_INTERFACE_STATUS:
1075 wpa_priv_send_interface_status(iface, data);
1077 case EVENT_PMKID_CANDIDATE:
1080 wpa_priv_send_event(iface, PRIVSEP_EVENT_PMKID_CANDIDATE,
1081 &data->pmkid_candidate,
1082 sizeof(struct pmkid_candidate));
1084 case EVENT_FT_RESPONSE:
1085 wpa_priv_send_ft_response(iface, data);
1088 wpa_priv_send_auth(iface, data);
1091 wpa_printf(MSG_DEBUG, "Unsupported driver event %d (%s) - TODO",
1092 event, event_to_string(event));
1098 void wpa_supplicant_event_global(void *ctx, enum wpa_event_type event,
1099 union wpa_event_data *data)
1101 struct wpa_priv_global *global = ctx;
1102 struct wpa_priv_interface *iface;
1104 if (event != EVENT_INTERFACE_STATUS)
1107 for (iface = global->interfaces; iface; iface = iface->next) {
1108 if (os_strcmp(iface->ifname, data->interface_status.ifname) ==
1112 if (iface && iface->driver->get_ifindex) {
1113 unsigned int ifindex;
1115 ifindex = iface->driver->get_ifindex(iface->drv_priv);
1116 if (ifindex != data->interface_status.ifindex) {
1117 wpa_printf(MSG_DEBUG,
1118 "%s: interface status ifindex %d mismatch (%d)",
1119 iface->ifname, ifindex,
1120 data->interface_status.ifindex);
1125 wpa_supplicant_event(iface, event, data);
1129 void wpa_supplicant_rx_eapol(void *ctx, const u8 *src_addr,
1130 const u8 *buf, size_t len)
1132 struct wpa_priv_interface *iface = ctx;
1135 int event = PRIVSEP_EVENT_RX_EAPOL;
1137 wpa_printf(MSG_DEBUG, "RX EAPOL from driver");
1138 io[0].iov_base = &event;
1139 io[0].iov_len = sizeof(event);
1140 io[1].iov_base = (u8 *) src_addr;
1141 io[1].iov_len = ETH_ALEN;
1142 io[2].iov_base = (u8 *) buf;
1143 io[2].iov_len = len;
1145 os_memset(&msg, 0, sizeof(msg));
1148 msg.msg_name = &iface->drv_addr;
1149 msg.msg_namelen = iface->drv_addr_len;
1151 if (sendmsg(iface->fd, &msg, 0) < 0)
1152 wpa_printf(MSG_ERROR, "sendmsg(wpas_socket): %s",
1157 static void wpa_priv_terminate(int sig, void *signal_ctx)
1159 wpa_printf(MSG_DEBUG, "wpa_priv termination requested");
1164 static void wpa_priv_fd_workaround(void)
1168 /* When started from pcmcia-cs scripts, wpa_supplicant might start with
1169 * fd 0, 1, and 2 closed. This will cause some issues because many
1170 * places in wpa_supplicant are still printing out to stdout. As a
1171 * workaround, make sure that fd's 0, 1, and 2 are not used for other
1173 for (i = 0; i < 3; i++) {
1174 s = open("/dev/null", O_RDWR);
1180 #endif /* __linux__ */
1184 static void usage(void)
1186 printf("wpa_priv v" VERSION_STR "\n"
1187 "Copyright (c) 2007-2017, Jouni Malinen <j@w1.fi> and "
1191 " wpa_priv [-Bdd] [-c<ctrl dir>] [-P<pid file>] "
1192 "<driver:ifname> \\\n"
1193 " [driver:ifname ...]\n");
1197 int main(int argc, char *argv[])
1201 char *pid_file = NULL;
1203 char *ctrl_dir = "/var/run/wpa_priv";
1204 struct wpa_priv_global global;
1205 struct wpa_priv_interface *iface;
1207 if (os_program_init())
1210 wpa_priv_fd_workaround();
1212 os_memset(&global, 0, sizeof(global));
1213 global.interfaces = NULL;
1216 c = getopt(argc, argv, "Bc:dP:");
1230 pid_file = os_rel2abs_path(optarg);
1238 if (optind >= argc) {
1243 wpa_printf(MSG_DEBUG, "wpa_priv control directory: '%s'", ctrl_dir);
1246 wpa_printf(MSG_ERROR, "Failed to initialize event loop");
1250 for (i = optind; i < argc; i++) {
1251 wpa_printf(MSG_DEBUG, "Adding driver:interface %s", argv[i]);
1252 iface = wpa_priv_interface_init(&global, ctrl_dir, argv[i]);
1255 iface->next = global.interfaces;
1256 global.interfaces = iface;
1259 if (daemonize && os_daemonize(pid_file) && eloop_sock_requeue())
1262 eloop_register_signal_terminate(wpa_priv_terminate, NULL);
1268 iface = global.interfaces;
1270 struct wpa_priv_interface *prev = iface;
1271 iface = iface->next;
1272 wpa_priv_interface_deinit(prev);
1279 os_daemonize_terminate(pid_file);
1281 os_program_deinit();