2 * WPA Supplicant / privileged helper program
3 * Copyright (c) 2007-2009, Jouni Malinen <j@w1.fi>
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.
9 * Alternatively, this software may be distributed under the terms of BSD
12 * See README and COPYING for more details.
18 #endif /* __linux__ */
25 #include "drivers/driver.h"
26 #include "l2_packet/l2_packet.h"
27 #include "privsep_commands.h"
28 #include "ieee802_11_defs.h"
31 #define ETH_P_EAPOL 0x888e
34 #ifndef ETH_P_RSN_PREAUTH
35 #define ETH_P_RSN_PREAUTH 0x88c7
39 struct wpa_priv_interface {
40 struct wpa_priv_interface *next;
46 struct wpa_driver_ops *driver;
48 struct sockaddr_un drv_addr;
51 /* TODO: add support for multiple l2 connections */
52 struct l2_packet_data *l2;
53 struct sockaddr_un l2_addr;
57 static void wpa_priv_cmd_register(struct wpa_priv_interface *iface,
58 struct sockaddr_un *from)
60 if (iface->drv_priv) {
61 wpa_printf(MSG_DEBUG, "Cleaning up forgotten driver instance");
62 if (iface->driver->set_wpa)
63 iface->driver->set_wpa(iface->drv_priv, 0);
64 if (iface->driver->deinit)
65 iface->driver->deinit(iface->drv_priv);
66 iface->drv_priv = NULL;
67 iface->wpas_registered = 0;
71 wpa_printf(MSG_DEBUG, "Cleaning up forgotten l2_packet "
73 l2_packet_deinit(iface->l2);
77 if (iface->driver->init == NULL)
80 iface->drv_priv = iface->driver->init(iface, iface->ifname);
81 if (iface->drv_priv == NULL) {
82 wpa_printf(MSG_DEBUG, "Failed to initialize driver wrapper");
86 wpa_printf(MSG_DEBUG, "Driver wrapper '%s' initialized for interface "
87 "'%s'", iface->driver_name, iface->ifname);
89 os_memcpy(&iface->drv_addr, from, sizeof(iface->drv_addr));
90 iface->wpas_registered = 1;
92 if (iface->driver->set_param &&
93 iface->driver->set_param(iface->drv_priv, NULL) < 0) {
94 wpa_printf(MSG_ERROR, "Driver interface rejected param");
97 if (iface->driver->set_wpa)
98 iface->driver->set_wpa(iface->drv_priv, 1);
102 static void wpa_priv_cmd_unregister(struct wpa_priv_interface *iface,
103 struct sockaddr_un *from)
105 if (iface->drv_priv) {
106 if (iface->driver->set_wpa)
107 iface->driver->set_wpa(iface->drv_priv, 0);
108 if (iface->driver->deinit)
109 iface->driver->deinit(iface->drv_priv);
110 iface->drv_priv = NULL;
111 iface->wpas_registered = 0;
116 static void wpa_priv_cmd_set_wpa(struct wpa_priv_interface *iface,
117 char *buf, size_t len)
119 if (iface->drv_priv == NULL || len != sizeof(int))
122 if (iface->driver->set_wpa)
123 iface->driver->set_wpa(iface->drv_priv, *((int *) buf));
127 static void wpa_priv_cmd_scan(struct wpa_priv_interface *iface,
128 char *buf, size_t len)
130 if (iface->drv_priv == NULL)
133 if (iface->driver->scan)
134 iface->driver->scan(iface->drv_priv, len ? (u8 *) buf : NULL,
139 static void wpa_priv_get_scan_results2(struct wpa_priv_interface *iface,
140 struct sockaddr_un *from)
142 struct wpa_scan_results *res;
143 u8 *buf = NULL, *pos, *end;
147 res = iface->driver->get_scan_results2(iface->drv_priv);
151 buf = os_malloc(60000);
157 os_memcpy(pos, &val, sizeof(int));
160 for (i = 0; i < res->num; i++) {
161 struct wpa_scan_res *r = res->res[i];
162 val = sizeof(*r) + r->ie_len;
163 if (end - pos < (int) sizeof(int) + val)
165 os_memcpy(pos, &val, sizeof(int));
167 os_memcpy(pos, r, val);
171 sendto(iface->fd, buf, pos - buf, 0, (struct sockaddr *) from,
181 sendto(iface->fd, "", 0, 0, (struct sockaddr *) from, sizeof(*from));
185 static void wpa_priv_send_old_scan_results(struct wpa_priv_interface *iface,
186 struct sockaddr_un *from)
188 #define SCAN_AP_LIMIT 128
190 struct wpa_scan_result *results = NULL;
191 u8 *buf = NULL, *pos, *end;
192 struct wpa_scan_res nres;
194 results = os_malloc(SCAN_AP_LIMIT * sizeof(*results));
198 res = iface->driver->get_scan_results(iface->drv_priv, results,
200 if (res < 0 || res > SCAN_AP_LIMIT)
203 buf = os_malloc(60000);
208 os_memcpy(pos, &res, sizeof(int));
211 os_memset(&nres, 0, sizeof(nres));
212 for (i = 0; i < res; i++) {
213 struct wpa_scan_result *r = &results[i];
216 ie_len = 2 + r->ssid_len + r->rsn_ie_len + r->wpa_ie_len;
222 val = sizeof(nres) + ie_len;
223 if (end - pos < (int) sizeof(int) + val)
225 os_memcpy(pos, &val, sizeof(int));
228 os_memcpy(nres.bssid, r->bssid, ETH_ALEN);
232 nres.noise = r->noise;
233 nres.level = r->level;
235 nres.ie_len = ie_len;
237 os_memcpy(pos, &nres, sizeof(nres));
241 *pos++ = WLAN_EID_SSID;
242 *pos++ = r->ssid_len;
243 os_memcpy(pos, r->ssid, r->ssid_len);
247 /* Fake Supported Rate IE to include max rate */
248 *pos++ = WLAN_EID_SUPP_RATES;
254 os_memcpy(pos, r->rsn_ie, r->rsn_ie_len);
255 pos += r->rsn_ie_len;
258 if (r->mdie_present) {
259 os_memcpy(pos, r->mdie, 5);
264 os_memcpy(pos, r->wpa_ie, r->wpa_ie_len);
265 pos += r->wpa_ie_len;
269 sendto(iface->fd, buf, pos - buf, 0, (struct sockaddr *) from,
279 sendto(iface->fd, "", 0, 0, (struct sockaddr *) from, sizeof(*from));
283 static void wpa_priv_cmd_get_scan_results(struct wpa_priv_interface *iface,
284 struct sockaddr_un *from)
286 if (iface->drv_priv == NULL)
289 if (iface->driver->get_scan_results2)
290 wpa_priv_get_scan_results2(iface, from);
291 else if (iface->driver->get_scan_results)
292 wpa_priv_send_old_scan_results(iface, from);
294 sendto(iface->fd, "", 0, 0, (struct sockaddr *) from,
299 static void wpa_priv_cmd_associate(struct wpa_priv_interface *iface,
300 void *buf, size_t len)
302 struct wpa_driver_associate_params params;
303 struct privsep_cmd_associate *assoc;
307 if (iface->drv_priv == NULL || iface->driver->associate == NULL)
310 if (len < sizeof(*assoc)) {
311 wpa_printf(MSG_DEBUG, "Invalid association request");
316 if (sizeof(*assoc) + assoc->wpa_ie_len > len) {
317 wpa_printf(MSG_DEBUG, "Association request overflow");
321 os_memset(¶ms, 0, sizeof(params));
322 bssid = assoc->bssid;
323 if (bssid[0] | bssid[1] | bssid[2] | bssid[3] | bssid[4] | bssid[5])
324 params.bssid = bssid;
325 params.ssid = assoc->ssid;
326 if (assoc->ssid_len > 32)
328 params.ssid_len = assoc->ssid_len;
329 params.freq = assoc->freq;
330 if (assoc->wpa_ie_len) {
331 params.wpa_ie = (u8 *) (assoc + 1);
332 params.wpa_ie_len = assoc->wpa_ie_len;
334 params.pairwise_suite = assoc->pairwise_suite;
335 params.group_suite = assoc->group_suite;
336 params.key_mgmt_suite = assoc->key_mgmt_suite;
337 params.auth_alg = assoc->auth_alg;
338 params.mode = assoc->mode;
340 res = iface->driver->associate(iface->drv_priv, ¶ms);
341 wpa_printf(MSG_DEBUG, "drv->associate: res=%d", res);
345 static void wpa_priv_cmd_get_bssid(struct wpa_priv_interface *iface,
346 struct sockaddr_un *from)
350 if (iface->drv_priv == NULL)
353 if (iface->driver->get_bssid == NULL ||
354 iface->driver->get_bssid(iface->drv_priv, bssid) < 0)
357 sendto(iface->fd, bssid, ETH_ALEN, 0, (struct sockaddr *) from,
362 sendto(iface->fd, "", 0, 0, (struct sockaddr *) from, sizeof(*from));
366 static void wpa_priv_cmd_get_ssid(struct wpa_priv_interface *iface,
367 struct sockaddr_un *from)
369 u8 ssid[sizeof(int) + 32];
372 if (iface->drv_priv == NULL)
375 if (iface->driver->get_ssid == NULL)
378 res = iface->driver->get_ssid(iface->drv_priv, &ssid[sizeof(int)]);
379 if (res < 0 || res > 32)
381 os_memcpy(ssid, &res, sizeof(int));
383 sendto(iface->fd, ssid, sizeof(ssid), 0, (struct sockaddr *) from,
388 sendto(iface->fd, "", 0, 0, (struct sockaddr *) from, sizeof(*from));
392 static void wpa_priv_cmd_set_key(struct wpa_priv_interface *iface,
393 void *buf, size_t len)
395 struct privsep_cmd_set_key *params;
398 if (iface->drv_priv == NULL || iface->driver->set_key == NULL)
401 if (len != sizeof(*params)) {
402 wpa_printf(MSG_DEBUG, "Invalid set_key request");
408 res = iface->driver->set_key(iface->drv_priv, params->alg,
409 params->addr, params->key_idx,
411 params->seq_len ? params->seq : NULL,
413 params->key_len ? params->key : NULL,
415 wpa_printf(MSG_DEBUG, "drv->set_key: res=%d", res);
419 static void wpa_priv_cmd_get_capa(struct wpa_priv_interface *iface,
420 struct sockaddr_un *from)
422 struct wpa_driver_capa capa;
424 if (iface->drv_priv == NULL)
427 if (iface->driver->get_capa == NULL ||
428 iface->driver->get_capa(iface->drv_priv, &capa) < 0)
431 sendto(iface->fd, &capa, sizeof(capa), 0, (struct sockaddr *) from,
436 sendto(iface->fd, "", 0, 0, (struct sockaddr *) from, sizeof(*from));
440 static void wpa_priv_l2_rx(void *ctx, const u8 *src_addr, const u8 *buf,
443 struct wpa_priv_interface *iface = ctx;
447 io[0].iov_base = (u8 *) src_addr;
448 io[0].iov_len = ETH_ALEN;
449 io[1].iov_base = (u8 *) buf;
452 os_memset(&msg, 0, sizeof(msg));
455 msg.msg_name = &iface->l2_addr;
456 msg.msg_namelen = sizeof(iface->l2_addr);
458 if (sendmsg(iface->fd, &msg, 0) < 0) {
459 perror("sendmsg(l2 rx)");
464 static void wpa_priv_cmd_l2_register(struct wpa_priv_interface *iface,
465 struct sockaddr_un *from,
466 void *buf, size_t len)
469 u8 own_addr[ETH_ALEN];
473 if (len != 2 * sizeof(int)) {
474 wpa_printf(MSG_DEBUG, "Invalid l2_register length %lu",
475 (unsigned long) len);
480 if (proto != ETH_P_EAPOL && proto != ETH_P_RSN_PREAUTH) {
481 wpa_printf(MSG_DEBUG, "Refused l2_packet connection for "
482 "ethertype 0x%x", proto);
487 wpa_printf(MSG_DEBUG, "Cleaning up forgotten l2_packet "
489 l2_packet_deinit(iface->l2);
493 os_memcpy(&iface->l2_addr, from, sizeof(iface->l2_addr));
495 iface->l2 = l2_packet_init(iface->ifname, NULL, proto,
496 wpa_priv_l2_rx, iface, reg_cmd[1]);
497 if (iface->l2 == NULL) {
498 wpa_printf(MSG_DEBUG, "Failed to initialize l2_packet "
499 "instance for protocol %d", proto);
503 if (l2_packet_get_own_addr(iface->l2, own_addr) < 0) {
504 wpa_printf(MSG_DEBUG, "Failed to get own address from "
506 l2_packet_deinit(iface->l2);
511 res = sendto(iface->fd, own_addr, ETH_ALEN, 0,
512 (struct sockaddr *) from, sizeof(*from));
513 wpa_printf(MSG_DEBUG, "L2 registration: res=%d", res);
517 static void wpa_priv_cmd_l2_unregister(struct wpa_priv_interface *iface,
518 struct sockaddr_un *from)
521 l2_packet_deinit(iface->l2);
527 static void wpa_priv_cmd_l2_notify_auth_start(struct wpa_priv_interface *iface,
528 struct sockaddr_un *from)
531 l2_packet_notify_auth_start(iface->l2);
535 static void wpa_priv_cmd_l2_send(struct wpa_priv_interface *iface,
536 struct sockaddr_un *from,
537 void *buf, size_t len)
543 if (iface->l2 == NULL)
546 if (len < ETH_ALEN + 2) {
547 wpa_printf(MSG_DEBUG, "Too short L2 send packet (len=%lu)",
548 (unsigned long) len);
553 os_memcpy(&proto, buf + ETH_ALEN, 2);
555 if (proto != ETH_P_EAPOL && proto != ETH_P_RSN_PREAUTH) {
556 wpa_printf(MSG_DEBUG, "Refused l2_packet send for ethertype "
561 res = l2_packet_send(iface->l2, dst_addr, proto, buf + ETH_ALEN + 2,
563 wpa_printf(MSG_DEBUG, "L2 send: res=%d", res);
567 static void wpa_priv_cmd_set_mode(struct wpa_priv_interface *iface,
568 void *buf, size_t len)
570 if (iface->drv_priv == NULL || iface->driver->set_mode == NULL ||
574 iface->driver->set_mode(iface->drv_priv, *((int *) buf));
578 static void wpa_priv_cmd_set_country(struct wpa_priv_interface *iface,
581 if (iface->drv_priv == NULL || iface->driver->set_country == NULL ||
585 iface->driver->set_country(iface->drv_priv, buf);
589 static void wpa_priv_receive(int sock, void *eloop_ctx, void *sock_ctx)
591 struct wpa_priv_interface *iface = eloop_ctx;
592 char buf[2000], *pos;
596 struct sockaddr_un from;
597 socklen_t fromlen = sizeof(from);
599 res = recvfrom(sock, buf, sizeof(buf), 0, (struct sockaddr *) &from,
606 if (res < (int) sizeof(int)) {
607 wpa_printf(MSG_DEBUG, "Too short command (len=%d)", res);
611 os_memcpy(&cmd, buf, sizeof(int));
612 wpa_printf(MSG_DEBUG, "Command %d for interface %s",
614 cmd_buf = &buf[sizeof(int)];
615 cmd_len = res - sizeof(int);
618 case PRIVSEP_CMD_REGISTER:
619 wpa_priv_cmd_register(iface, &from);
621 case PRIVSEP_CMD_UNREGISTER:
622 wpa_priv_cmd_unregister(iface, &from);
624 case PRIVSEP_CMD_SET_WPA:
625 wpa_priv_cmd_set_wpa(iface, cmd_buf, cmd_len);
627 case PRIVSEP_CMD_SCAN:
628 wpa_priv_cmd_scan(iface, cmd_buf, cmd_len);
630 case PRIVSEP_CMD_GET_SCAN_RESULTS:
631 wpa_priv_cmd_get_scan_results(iface, &from);
633 case PRIVSEP_CMD_ASSOCIATE:
634 wpa_priv_cmd_associate(iface, cmd_buf, cmd_len);
636 case PRIVSEP_CMD_GET_BSSID:
637 wpa_priv_cmd_get_bssid(iface, &from);
639 case PRIVSEP_CMD_GET_SSID:
640 wpa_priv_cmd_get_ssid(iface, &from);
642 case PRIVSEP_CMD_SET_KEY:
643 wpa_priv_cmd_set_key(iface, cmd_buf, cmd_len);
645 case PRIVSEP_CMD_GET_CAPA:
646 wpa_priv_cmd_get_capa(iface, &from);
648 case PRIVSEP_CMD_L2_REGISTER:
649 wpa_priv_cmd_l2_register(iface, &from, cmd_buf, cmd_len);
651 case PRIVSEP_CMD_L2_UNREGISTER:
652 wpa_priv_cmd_l2_unregister(iface, &from);
654 case PRIVSEP_CMD_L2_NOTIFY_AUTH_START:
655 wpa_priv_cmd_l2_notify_auth_start(iface, &from);
657 case PRIVSEP_CMD_L2_SEND:
658 wpa_priv_cmd_l2_send(iface, &from, cmd_buf, cmd_len);
660 case PRIVSEP_CMD_SET_MODE:
661 wpa_priv_cmd_set_mode(iface, cmd_buf, cmd_len);
663 case PRIVSEP_CMD_SET_COUNTRY:
665 if (pos + cmd_len >= buf + sizeof(buf))
668 wpa_priv_cmd_set_country(iface, pos);
674 static void wpa_priv_interface_deinit(struct wpa_priv_interface *iface)
676 if (iface->drv_priv && iface->driver->deinit)
677 iface->driver->deinit(iface->drv_priv);
679 if (iface->fd >= 0) {
680 eloop_unregister_read_sock(iface->fd);
682 unlink(iface->sock_name);
686 l2_packet_deinit(iface->l2);
688 os_free(iface->ifname);
689 os_free(iface->driver_name);
690 os_free(iface->sock_name);
695 extern struct wpa_driver_ops *wpa_drivers[];
697 static struct wpa_priv_interface *
698 wpa_priv_interface_init(const char *dir, const char *params)
700 struct wpa_priv_interface *iface;
703 struct sockaddr_un addr;
706 pos = os_strchr(params, ':');
710 iface = os_zalloc(sizeof(*iface));
716 iface->driver_name = os_malloc(len + 1);
717 if (iface->driver_name == NULL) {
718 wpa_priv_interface_deinit(iface);
721 os_memcpy(iface->driver_name, params, len);
722 iface->driver_name[len] = '\0';
724 for (i = 0; wpa_drivers[i]; i++) {
725 if (os_strcmp(iface->driver_name,
726 wpa_drivers[i]->name) == 0) {
727 iface->driver = wpa_drivers[i];
731 if (iface->driver == NULL) {
732 wpa_printf(MSG_ERROR, "Unsupported driver '%s'",
734 wpa_priv_interface_deinit(iface);
739 iface->ifname = os_strdup(pos);
740 if (iface->ifname == NULL) {
741 wpa_priv_interface_deinit(iface);
745 len = os_strlen(dir) + 1 + os_strlen(iface->ifname);
746 iface->sock_name = os_malloc(len + 1);
747 if (iface->sock_name == NULL) {
748 wpa_priv_interface_deinit(iface);
752 os_snprintf(iface->sock_name, len + 1, "%s/%s", dir, iface->ifname);
753 if (os_strlen(iface->sock_name) >= sizeof(addr.sun_path)) {
754 wpa_priv_interface_deinit(iface);
758 iface->fd = socket(PF_UNIX, SOCK_DGRAM, 0);
760 perror("socket(PF_UNIX)");
761 wpa_priv_interface_deinit(iface);
765 os_memset(&addr, 0, sizeof(addr));
766 addr.sun_family = AF_UNIX;
767 os_strlcpy(addr.sun_path, iface->sock_name, sizeof(addr.sun_path));
769 if (bind(iface->fd, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
770 wpa_printf(MSG_DEBUG, "bind(PF_UNIX) failed: %s",
772 if (connect(iface->fd, (struct sockaddr *) &addr,
774 wpa_printf(MSG_DEBUG, "Socket exists, but does not "
775 "allow connections - assuming it was "
776 "leftover from forced program termination");
777 if (unlink(iface->sock_name) < 0) {
778 perror("unlink[ctrl_iface]");
779 wpa_printf(MSG_ERROR, "Could not unlink "
780 "existing ctrl_iface socket '%s'",
784 if (bind(iface->fd, (struct sockaddr *) &addr,
786 perror("bind(PF_UNIX)");
789 wpa_printf(MSG_DEBUG, "Successfully replaced leftover "
790 "socket '%s'", iface->sock_name);
792 wpa_printf(MSG_INFO, "Socket exists and seems to be "
793 "in use - cannot override it");
794 wpa_printf(MSG_INFO, "Delete '%s' manually if it is "
795 "not used anymore", iface->sock_name);
800 if (chmod(iface->sock_name, S_IRWXU | S_IRWXG | S_IRWXO) < 0) {
805 eloop_register_read_sock(iface->fd, wpa_priv_receive, iface, NULL);
810 wpa_priv_interface_deinit(iface);
815 static int wpa_priv_send_event(struct wpa_priv_interface *iface, int event,
816 const void *data, size_t data_len)
821 io[0].iov_base = &event;
822 io[0].iov_len = sizeof(event);
823 io[1].iov_base = (u8 *) data;
824 io[1].iov_len = data_len;
826 os_memset(&msg, 0, sizeof(msg));
828 msg.msg_iovlen = data ? 2 : 1;
829 msg.msg_name = &iface->drv_addr;
830 msg.msg_namelen = sizeof(iface->drv_addr);
832 if (sendmsg(iface->fd, &msg, 0) < 0) {
833 perror("sendmsg(wpas_socket)");
841 static void wpa_priv_send_assoc(struct wpa_priv_interface *iface, int event,
842 union wpa_event_data *data)
844 size_t buflen = 3 * sizeof(int);
849 buflen += data->assoc_info.req_ies_len +
850 data->assoc_info.resp_ies_len +
851 data->assoc_info.beacon_ies_len;
854 buf = os_malloc(buflen);
860 if (data && data->assoc_info.req_ies) {
861 len = data->assoc_info.req_ies_len;
862 os_memcpy(pos, &len, sizeof(int));
864 os_memcpy(pos, data->assoc_info.req_ies, len);
868 os_memcpy(pos, &len, sizeof(int));
872 if (data && data->assoc_info.resp_ies) {
873 len = data->assoc_info.resp_ies_len;
874 os_memcpy(pos, &len, sizeof(int));
876 os_memcpy(pos, data->assoc_info.resp_ies, len);
880 os_memcpy(pos, &len, sizeof(int));
884 if (data && data->assoc_info.beacon_ies) {
885 len = data->assoc_info.beacon_ies_len;
886 os_memcpy(pos, &len, sizeof(int));
888 os_memcpy(pos, data->assoc_info.beacon_ies, len);
892 os_memcpy(pos, &len, sizeof(int));
896 wpa_priv_send_event(iface, event, buf, buflen);
902 static void wpa_priv_send_interface_status(struct wpa_priv_interface *iface,
903 union wpa_event_data *data)
913 ievent = data->interface_status.ievent;
914 maxlen = sizeof(data->interface_status.ifname);
915 ifname = data->interface_status.ifname;
916 for (len = 0; len < maxlen && ifname[len]; len++)
919 buf = os_malloc(sizeof(int) + len);
923 os_memcpy(buf, &ievent, sizeof(int));
924 os_memcpy(buf + sizeof(int), ifname, len);
926 wpa_priv_send_event(iface, PRIVSEP_EVENT_INTERFACE_STATUS,
927 buf, sizeof(int) + len);
934 static void wpa_priv_send_ft_response(struct wpa_priv_interface *iface,
935 union wpa_event_data *data)
940 if (data == NULL || data->ft_ies.ies == NULL)
943 len = sizeof(int) + ETH_ALEN + data->ft_ies.ies_len;
944 buf = os_malloc(len);
949 os_memcpy(pos, &data->ft_ies.ft_action, sizeof(int));
951 os_memcpy(pos, data->ft_ies.target_ap, ETH_ALEN);
953 os_memcpy(pos, data->ft_ies.ies, data->ft_ies.ies_len);
955 wpa_priv_send_event(iface, PRIVSEP_EVENT_FT_RESPONSE, buf, len);
962 void wpa_supplicant_event(void *ctx, wpa_event_type event,
963 union wpa_event_data *data)
965 struct wpa_priv_interface *iface = ctx;
967 wpa_printf(MSG_DEBUG, "%s - event=%d", __func__, event);
969 if (!iface->wpas_registered) {
970 wpa_printf(MSG_DEBUG, "Driver event received, but "
971 "wpa_supplicant not registered");
977 wpa_priv_send_assoc(iface, PRIVSEP_EVENT_ASSOC, data);
980 wpa_priv_send_event(iface, PRIVSEP_EVENT_DISASSOC, NULL, 0);
982 case EVENT_ASSOCINFO:
985 wpa_priv_send_assoc(iface, PRIVSEP_EVENT_ASSOCINFO, data);
987 case EVENT_MICHAEL_MIC_FAILURE:
990 wpa_priv_send_event(iface, PRIVSEP_EVENT_MICHAEL_MIC_FAILURE,
991 &data->michael_mic_failure.unicast,
994 case EVENT_SCAN_RESULTS:
995 wpa_priv_send_event(iface, PRIVSEP_EVENT_SCAN_RESULTS, NULL,
998 case EVENT_INTERFACE_STATUS:
999 wpa_priv_send_interface_status(iface, data);
1001 case EVENT_PMKID_CANDIDATE:
1004 wpa_priv_send_event(iface, PRIVSEP_EVENT_PMKID_CANDIDATE,
1005 &data->pmkid_candidate,
1006 sizeof(struct pmkid_candidate));
1008 case EVENT_STKSTART:
1011 wpa_priv_send_event(iface, PRIVSEP_EVENT_STKSTART,
1012 &data->stkstart.peer, ETH_ALEN);
1014 case EVENT_FT_RESPONSE:
1015 wpa_priv_send_ft_response(iface, data);
1018 wpa_printf(MSG_DEBUG, "Unsupported driver event %d - TODO",
1025 void wpa_supplicant_rx_eapol(void *ctx, const u8 *src_addr,
1026 const u8 *buf, size_t len)
1028 struct wpa_priv_interface *iface = ctx;
1031 int event = PRIVSEP_EVENT_RX_EAPOL;
1033 wpa_printf(MSG_DEBUG, "RX EAPOL from driver");
1034 io[0].iov_base = &event;
1035 io[0].iov_len = sizeof(event);
1036 io[1].iov_base = (u8 *) src_addr;
1037 io[1].iov_len = ETH_ALEN;
1038 io[2].iov_base = (u8 *) buf;
1039 io[2].iov_len = len;
1041 os_memset(&msg, 0, sizeof(msg));
1044 msg.msg_name = &iface->drv_addr;
1045 msg.msg_namelen = sizeof(iface->drv_addr);
1047 if (sendmsg(iface->fd, &msg, 0) < 0)
1048 perror("sendmsg(wpas_socket)");
1052 #ifdef CONFIG_CLIENT_MLME
1053 void wpa_supplicant_sta_rx(void *ctx, const u8 *buf, size_t len,
1054 struct ieee80211_rx_status *rx_status)
1056 struct wpa_priv_interface *iface = ctx;
1059 int event = PRIVSEP_EVENT_STA_RX;
1061 wpa_printf(MSG_DEBUG, "STA RX from driver");
1062 io[0].iov_base = &event;
1063 io[0].iov_len = sizeof(event);
1064 io[1].iov_base = (u8 *) rx_status;
1065 io[1].iov_len = sizeof(*rx_status);
1066 io[2].iov_base = (u8 *) buf;
1067 io[2].iov_len = len;
1069 os_memset(&msg, 0, sizeof(msg));
1072 msg.msg_name = &iface->drv_addr;
1073 msg.msg_namelen = sizeof(iface->drv_addr);
1075 if (sendmsg(iface->fd, &msg, 0) < 0)
1076 perror("sendmsg(wpas_socket)");
1078 #endif /* CONFIG_CLIENT_MLME */
1081 static void wpa_priv_terminate(int sig, void *eloop_ctx, void *signal_ctx)
1083 wpa_printf(MSG_DEBUG, "wpa_priv termination requested");
1088 static void wpa_priv_fd_workaround(void)
1092 /* When started from pcmcia-cs scripts, wpa_supplicant might start with
1093 * fd 0, 1, and 2 closed. This will cause some issues because many
1094 * places in wpa_supplicant are still printing out to stdout. As a
1095 * workaround, make sure that fd's 0, 1, and 2 are not used for other
1097 for (i = 0; i < 3; i++) {
1098 s = open("/dev/null", O_RDWR);
1104 #endif /* __linux__ */
1108 static void usage(void)
1110 printf("wpa_priv v" VERSION_STR "\n"
1111 "Copyright (c) 2007-2009, Jouni Malinen <j@w1.fi> and "
1115 " wpa_priv [-Bdd] [-P<pid file>] <driver:ifname> "
1116 "[driver:ifname ...]\n");
1120 extern int wpa_debug_level;
1122 int main(int argc, char *argv[])
1126 char *pid_file = NULL;
1128 char *ctrl_dir = "/var/run/wpa_priv";
1129 struct wpa_priv_interface *interfaces = NULL, *iface;
1131 if (os_program_init())
1134 wpa_priv_fd_workaround();
1137 c = getopt(argc, argv, "Bc:dP:");
1151 pid_file = os_rel2abs_path(optarg);
1159 if (optind >= argc) {
1164 wpa_printf(MSG_DEBUG, "wpa_priv control directory: '%s'", ctrl_dir);
1166 if (eloop_init(NULL)) {
1167 wpa_printf(MSG_ERROR, "Failed to initialize event loop");
1171 for (i = optind; i < argc; i++) {
1172 wpa_printf(MSG_DEBUG, "Adding driver:interface %s", argv[i]);
1173 iface = wpa_priv_interface_init(ctrl_dir, argv[i]);
1176 iface->next = interfaces;
1180 if (daemonize && os_daemonize(pid_file))
1183 eloop_register_signal_terminate(wpa_priv_terminate, NULL);
1191 struct wpa_priv_interface *prev = iface;
1192 iface = iface->next;
1193 wpa_priv_interface_deinit(prev);
1198 os_daemonize_terminate(pid_file);
1200 os_program_deinit();