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"
25 struct wpa_priv_interface {
26 struct wpa_priv_interface *next;
32 const struct wpa_driver_ops *driver;
34 void *drv_global_priv;
35 struct sockaddr_un drv_addr;
38 /* TODO: add support for multiple l2 connections */
39 struct l2_packet_data *l2;
40 struct sockaddr_un l2_addr;
44 static void wpa_priv_cmd_register(struct wpa_priv_interface *iface,
45 struct sockaddr_un *from)
47 if (iface->drv_priv) {
48 wpa_printf(MSG_DEBUG, "Cleaning up forgotten driver instance");
49 if (iface->driver->deinit)
50 iface->driver->deinit(iface->drv_priv);
51 iface->drv_priv = NULL;
52 if (iface->drv_global_priv) {
53 iface->driver->global_deinit(iface->drv_global_priv);
54 iface->drv_global_priv = NULL;
56 iface->wpas_registered = 0;
60 wpa_printf(MSG_DEBUG, "Cleaning up forgotten l2_packet "
62 l2_packet_deinit(iface->l2);
66 if (iface->driver->init2) {
67 if (iface->driver->global_init) {
68 iface->drv_global_priv = iface->driver->global_init();
69 if (!iface->drv_global_priv) {
71 "Failed to initialize driver global context");
75 iface->drv_global_priv = NULL;
77 iface->drv_priv = iface->driver->init2(iface, iface->ifname,
78 iface->drv_global_priv);
79 } else if (iface->driver->init) {
80 iface->drv_priv = iface->driver->init(iface, iface->ifname);
84 if (iface->drv_priv == NULL) {
85 wpa_printf(MSG_DEBUG, "Failed to initialize driver wrapper");
89 wpa_printf(MSG_DEBUG, "Driver wrapper '%s' initialized for interface "
90 "'%s'", iface->driver_name, iface->ifname);
92 os_memcpy(&iface->drv_addr, from, sizeof(iface->drv_addr));
93 iface->wpas_registered = 1;
95 if (iface->driver->set_param &&
96 iface->driver->set_param(iface->drv_priv, NULL) < 0) {
97 wpa_printf(MSG_ERROR, "Driver interface rejected param");
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->deinit)
107 iface->driver->deinit(iface->drv_priv);
108 iface->drv_priv = NULL;
109 if (iface->drv_global_priv) {
110 iface->driver->global_deinit(iface->drv_global_priv);
111 iface->drv_global_priv = NULL;
113 iface->wpas_registered = 0;
118 static void wpa_priv_cmd_scan(struct wpa_priv_interface *iface,
119 char *buf, size_t len)
121 struct wpa_driver_scan_params params;
123 if (iface->drv_priv == NULL)
126 os_memset(¶ms, 0, sizeof(params));
128 params.ssids[0].ssid = (u8 *) buf;
129 params.ssids[0].ssid_len = len;
130 params.num_ssids = 1;
133 if (iface->driver->scan2)
134 iface->driver->scan2(iface->drv_priv, ¶ms);
138 static void wpa_priv_get_scan_results2(struct wpa_priv_interface *iface,
139 struct sockaddr_un *from)
141 struct wpa_scan_results *res;
142 u8 *buf = NULL, *pos, *end;
146 res = iface->driver->get_scan_results2(iface->drv_priv);
150 buf = os_malloc(60000);
156 os_memcpy(pos, &val, sizeof(int));
159 for (i = 0; i < res->num; i++) {
160 struct wpa_scan_res *r = res->res[i];
161 val = sizeof(*r) + r->ie_len;
162 if (end - pos < (int) sizeof(int) + val)
164 os_memcpy(pos, &val, sizeof(int));
166 os_memcpy(pos, r, val);
170 sendto(iface->fd, buf, pos - buf, 0, (struct sockaddr *) from,
174 wpa_scan_results_free(res);
179 wpa_scan_results_free(res);
180 sendto(iface->fd, "", 0, 0, (struct sockaddr *) from, sizeof(*from));
184 static void wpa_priv_cmd_get_scan_results(struct wpa_priv_interface *iface,
185 struct sockaddr_un *from)
187 if (iface->drv_priv == NULL)
190 if (iface->driver->get_scan_results2)
191 wpa_priv_get_scan_results2(iface, from);
193 sendto(iface->fd, "", 0, 0, (struct sockaddr *) from,
198 static void wpa_priv_cmd_authenticate(struct wpa_priv_interface *iface,
199 void *buf, size_t len)
201 struct wpa_driver_auth_params params;
202 struct privsep_cmd_authenticate *auth;
205 if (iface->drv_priv == NULL || iface->driver->authenticate == NULL)
208 if (len < sizeof(*auth)) {
209 wpa_printf(MSG_DEBUG, "Invalid authentication request");
214 if (sizeof(*auth) + auth->ie_len + auth->sae_data_len > len) {
215 wpa_printf(MSG_DEBUG, "Authentication request overflow");
219 os_memset(¶ms, 0, sizeof(params));
220 params.freq = auth->freq;
221 params.bssid = auth->bssid;
222 params.ssid = auth->ssid;
223 if (auth->ssid_len > SSID_MAX_LEN)
225 params.ssid_len = auth->ssid_len;
226 params.auth_alg = auth->auth_alg;
227 for (i = 0; i < 4; i++) {
228 if (auth->wep_key_len[i]) {
229 params.wep_key[i] = auth->wep_key[i];
230 params.wep_key_len[i] = auth->wep_key_len[i];
233 params.wep_tx_keyidx = auth->wep_tx_keyidx;
234 params.local_state_change = auth->local_state_change;
235 params.p2p = auth->p2p;
237 params.ie = (u8 *) (auth + 1);
238 params.ie_len = auth->ie_len;
240 if (auth->sae_data_len) {
241 params.sae_data = ((u8 *) (auth + 1)) + auth->ie_len;
242 params.sae_data_len = auth->sae_data_len;
245 res = iface->driver->authenticate(iface->drv_priv, ¶ms);
246 wpa_printf(MSG_DEBUG, "drv->authenticate: res=%d", res);
250 static void wpa_priv_cmd_associate(struct wpa_priv_interface *iface,
251 void *buf, size_t len)
253 struct wpa_driver_associate_params params;
254 struct privsep_cmd_associate *assoc;
258 if (iface->drv_priv == NULL || iface->driver->associate == NULL)
261 if (len < sizeof(*assoc)) {
262 wpa_printf(MSG_DEBUG, "Invalid association request");
267 if (sizeof(*assoc) + assoc->wpa_ie_len > len) {
268 wpa_printf(MSG_DEBUG, "Association request overflow");
272 os_memset(¶ms, 0, sizeof(params));
273 bssid = assoc->bssid;
274 if (bssid[0] | bssid[1] | bssid[2] | bssid[3] | bssid[4] | bssid[5])
275 params.bssid = bssid;
276 params.ssid = assoc->ssid;
277 if (assoc->ssid_len > SSID_MAX_LEN)
279 params.ssid_len = assoc->ssid_len;
280 params.freq.mode = assoc->hwmode;
281 params.freq.freq = assoc->freq;
282 params.freq.channel = assoc->channel;
283 if (assoc->wpa_ie_len) {
284 params.wpa_ie = (u8 *) (assoc + 1);
285 params.wpa_ie_len = assoc->wpa_ie_len;
287 params.pairwise_suite = assoc->pairwise_suite;
288 params.group_suite = assoc->group_suite;
289 params.key_mgmt_suite = assoc->key_mgmt_suite;
290 params.auth_alg = assoc->auth_alg;
291 params.mode = assoc->mode;
293 res = iface->driver->associate(iface->drv_priv, ¶ms);
294 wpa_printf(MSG_DEBUG, "drv->associate: res=%d", res);
298 static void wpa_priv_cmd_get_bssid(struct wpa_priv_interface *iface,
299 struct sockaddr_un *from)
303 if (iface->drv_priv == NULL)
306 if (iface->driver->get_bssid == NULL ||
307 iface->driver->get_bssid(iface->drv_priv, bssid) < 0)
310 sendto(iface->fd, bssid, ETH_ALEN, 0, (struct sockaddr *) from,
315 sendto(iface->fd, "", 0, 0, (struct sockaddr *) from, sizeof(*from));
319 static void wpa_priv_cmd_get_ssid(struct wpa_priv_interface *iface,
320 struct sockaddr_un *from)
322 u8 ssid[sizeof(int) + SSID_MAX_LEN];
325 if (iface->drv_priv == NULL)
328 if (iface->driver->get_ssid == NULL)
331 res = iface->driver->get_ssid(iface->drv_priv, &ssid[sizeof(int)]);
332 if (res < 0 || res > SSID_MAX_LEN)
334 os_memcpy(ssid, &res, sizeof(int));
336 sendto(iface->fd, ssid, sizeof(ssid), 0, (struct sockaddr *) from,
341 sendto(iface->fd, "", 0, 0, (struct sockaddr *) from, sizeof(*from));
345 static void wpa_priv_cmd_set_key(struct wpa_priv_interface *iface,
346 void *buf, size_t len)
348 struct privsep_cmd_set_key *params;
351 if (iface->drv_priv == NULL || iface->driver->set_key == NULL)
354 if (len != sizeof(*params)) {
355 wpa_printf(MSG_DEBUG, "Invalid set_key request");
361 res = iface->driver->set_key(iface->ifname, iface->drv_priv,
363 params->addr, params->key_idx,
365 params->seq_len ? params->seq : NULL,
367 params->key_len ? params->key : NULL,
369 wpa_printf(MSG_DEBUG, "drv->set_key: res=%d", res);
373 static void wpa_priv_cmd_get_capa(struct wpa_priv_interface *iface,
374 struct sockaddr_un *from)
376 struct wpa_driver_capa capa;
378 if (iface->drv_priv == NULL)
381 if (iface->driver->get_capa == NULL ||
382 iface->driver->get_capa(iface->drv_priv, &capa) < 0)
385 /* For now, no support for passing extended_capa pointers */
386 capa.extended_capa = NULL;
387 capa.extended_capa_mask = NULL;
388 capa.extended_capa_len = 0;
389 sendto(iface->fd, &capa, sizeof(capa), 0, (struct sockaddr *) from,
394 sendto(iface->fd, "", 0, 0, (struct sockaddr *) from, sizeof(*from));
398 static void wpa_priv_l2_rx(void *ctx, const u8 *src_addr, const u8 *buf,
401 struct wpa_priv_interface *iface = ctx;
405 io[0].iov_base = (u8 *) src_addr;
406 io[0].iov_len = ETH_ALEN;
407 io[1].iov_base = (u8 *) buf;
410 os_memset(&msg, 0, sizeof(msg));
413 msg.msg_name = &iface->l2_addr;
414 msg.msg_namelen = sizeof(iface->l2_addr);
416 if (sendmsg(iface->fd, &msg, 0) < 0) {
417 wpa_printf(MSG_ERROR, "sendmsg(l2 rx): %s", strerror(errno));
422 static void wpa_priv_cmd_l2_register(struct wpa_priv_interface *iface,
423 struct sockaddr_un *from,
424 void *buf, size_t len)
427 u8 own_addr[ETH_ALEN];
431 if (len != 2 * sizeof(int)) {
432 wpa_printf(MSG_DEBUG, "Invalid l2_register length %lu",
433 (unsigned long) len);
438 if (proto != ETH_P_EAPOL && proto != ETH_P_RSN_PREAUTH &&
439 proto != ETH_P_80211_ENCAP) {
440 wpa_printf(MSG_DEBUG, "Refused l2_packet connection for "
441 "ethertype 0x%x", proto);
446 wpa_printf(MSG_DEBUG, "Cleaning up forgotten l2_packet "
448 l2_packet_deinit(iface->l2);
452 os_memcpy(&iface->l2_addr, from, sizeof(iface->l2_addr));
454 iface->l2 = l2_packet_init(iface->ifname, NULL, proto,
455 wpa_priv_l2_rx, iface, reg_cmd[1]);
456 if (iface->l2 == NULL) {
457 wpa_printf(MSG_DEBUG, "Failed to initialize l2_packet "
458 "instance for protocol %d", proto);
462 if (l2_packet_get_own_addr(iface->l2, own_addr) < 0) {
463 wpa_printf(MSG_DEBUG, "Failed to get own address from "
465 l2_packet_deinit(iface->l2);
470 res = sendto(iface->fd, own_addr, ETH_ALEN, 0,
471 (struct sockaddr *) from, sizeof(*from));
472 wpa_printf(MSG_DEBUG, "L2 registration: res=%d", res);
476 static void wpa_priv_cmd_l2_unregister(struct wpa_priv_interface *iface,
477 struct sockaddr_un *from)
480 l2_packet_deinit(iface->l2);
486 static void wpa_priv_cmd_l2_notify_auth_start(struct wpa_priv_interface *iface,
487 struct sockaddr_un *from)
490 l2_packet_notify_auth_start(iface->l2);
494 static void wpa_priv_cmd_l2_send(struct wpa_priv_interface *iface,
495 struct sockaddr_un *from,
496 void *buf, size_t len)
502 if (iface->l2 == NULL)
505 if (len < ETH_ALEN + 2) {
506 wpa_printf(MSG_DEBUG, "Too short L2 send packet (len=%lu)",
507 (unsigned long) len);
512 os_memcpy(&proto, buf + ETH_ALEN, 2);
514 if (proto != ETH_P_EAPOL && proto != ETH_P_RSN_PREAUTH) {
515 wpa_printf(MSG_DEBUG, "Refused l2_packet send for ethertype "
520 res = l2_packet_send(iface->l2, dst_addr, proto, buf + ETH_ALEN + 2,
522 wpa_printf(MSG_DEBUG, "L2 send: res=%d", res);
526 static void wpa_priv_cmd_set_country(struct wpa_priv_interface *iface,
529 if (iface->drv_priv == NULL || iface->driver->set_country == NULL ||
533 iface->driver->set_country(iface->drv_priv, buf);
537 static void wpa_priv_receive(int sock, void *eloop_ctx, void *sock_ctx)
539 struct wpa_priv_interface *iface = eloop_ctx;
540 char buf[2000], *pos;
544 struct sockaddr_un from;
545 socklen_t fromlen = sizeof(from);
547 res = recvfrom(sock, buf, sizeof(buf), 0, (struct sockaddr *) &from,
550 wpa_printf(MSG_ERROR, "recvfrom: %s", strerror(errno));
554 if (res < (int) sizeof(int)) {
555 wpa_printf(MSG_DEBUG, "Too short command (len=%d)", res);
559 os_memcpy(&cmd, buf, sizeof(int));
560 wpa_printf(MSG_DEBUG, "Command %d for interface %s",
562 cmd_buf = &buf[sizeof(int)];
563 cmd_len = res - sizeof(int);
566 case PRIVSEP_CMD_REGISTER:
567 wpa_priv_cmd_register(iface, &from);
569 case PRIVSEP_CMD_UNREGISTER:
570 wpa_priv_cmd_unregister(iface, &from);
572 case PRIVSEP_CMD_SCAN:
573 wpa_priv_cmd_scan(iface, cmd_buf, cmd_len);
575 case PRIVSEP_CMD_GET_SCAN_RESULTS:
576 wpa_priv_cmd_get_scan_results(iface, &from);
578 case PRIVSEP_CMD_ASSOCIATE:
579 wpa_priv_cmd_associate(iface, cmd_buf, cmd_len);
581 case PRIVSEP_CMD_GET_BSSID:
582 wpa_priv_cmd_get_bssid(iface, &from);
584 case PRIVSEP_CMD_GET_SSID:
585 wpa_priv_cmd_get_ssid(iface, &from);
587 case PRIVSEP_CMD_SET_KEY:
588 wpa_priv_cmd_set_key(iface, cmd_buf, cmd_len);
590 case PRIVSEP_CMD_GET_CAPA:
591 wpa_priv_cmd_get_capa(iface, &from);
593 case PRIVSEP_CMD_L2_REGISTER:
594 wpa_priv_cmd_l2_register(iface, &from, cmd_buf, cmd_len);
596 case PRIVSEP_CMD_L2_UNREGISTER:
597 wpa_priv_cmd_l2_unregister(iface, &from);
599 case PRIVSEP_CMD_L2_NOTIFY_AUTH_START:
600 wpa_priv_cmd_l2_notify_auth_start(iface, &from);
602 case PRIVSEP_CMD_L2_SEND:
603 wpa_priv_cmd_l2_send(iface, &from, cmd_buf, cmd_len);
605 case PRIVSEP_CMD_SET_COUNTRY:
607 if (pos + cmd_len >= buf + sizeof(buf))
610 wpa_priv_cmd_set_country(iface, pos);
612 case PRIVSEP_CMD_AUTHENTICATE:
613 wpa_priv_cmd_authenticate(iface, cmd_buf, cmd_len);
619 static void wpa_priv_interface_deinit(struct wpa_priv_interface *iface)
621 if (iface->drv_priv && iface->driver->deinit)
622 iface->driver->deinit(iface->drv_priv);
624 if (iface->fd >= 0) {
625 eloop_unregister_read_sock(iface->fd);
627 unlink(iface->sock_name);
631 l2_packet_deinit(iface->l2);
633 os_free(iface->ifname);
634 os_free(iface->driver_name);
635 os_free(iface->sock_name);
640 static struct wpa_priv_interface *
641 wpa_priv_interface_init(const char *dir, const char *params)
643 struct wpa_priv_interface *iface;
646 struct sockaddr_un addr;
649 pos = os_strchr(params, ':');
653 iface = os_zalloc(sizeof(*iface));
659 iface->driver_name = dup_binstr(params, len);
660 if (iface->driver_name == NULL) {
661 wpa_priv_interface_deinit(iface);
665 for (i = 0; wpa_drivers[i]; i++) {
666 if (os_strcmp(iface->driver_name,
667 wpa_drivers[i]->name) == 0) {
668 iface->driver = wpa_drivers[i];
672 if (iface->driver == NULL) {
673 wpa_printf(MSG_ERROR, "Unsupported driver '%s'",
675 wpa_priv_interface_deinit(iface);
680 iface->ifname = os_strdup(pos);
681 if (iface->ifname == NULL) {
682 wpa_priv_interface_deinit(iface);
686 len = os_strlen(dir) + 1 + os_strlen(iface->ifname);
687 iface->sock_name = os_malloc(len + 1);
688 if (iface->sock_name == NULL) {
689 wpa_priv_interface_deinit(iface);
693 os_snprintf(iface->sock_name, len + 1, "%s/%s", dir, iface->ifname);
694 if (os_strlen(iface->sock_name) >= sizeof(addr.sun_path)) {
695 wpa_priv_interface_deinit(iface);
699 iface->fd = socket(PF_UNIX, SOCK_DGRAM, 0);
701 wpa_printf(MSG_ERROR, "socket(PF_UNIX): %s", strerror(errno));
702 wpa_priv_interface_deinit(iface);
706 os_memset(&addr, 0, sizeof(addr));
707 addr.sun_family = AF_UNIX;
708 os_strlcpy(addr.sun_path, iface->sock_name, sizeof(addr.sun_path));
710 if (bind(iface->fd, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
711 wpa_printf(MSG_DEBUG, "bind(PF_UNIX) failed: %s",
713 if (connect(iface->fd, (struct sockaddr *) &addr,
715 wpa_printf(MSG_DEBUG, "Socket exists, but does not "
716 "allow connections - assuming it was "
717 "leftover from forced program termination");
718 if (unlink(iface->sock_name) < 0) {
719 wpa_printf(MSG_ERROR,
720 "Could not unlink existing ctrl_iface socket '%s': %s",
721 iface->sock_name, strerror(errno));
724 if (bind(iface->fd, (struct sockaddr *) &addr,
726 wpa_printf(MSG_ERROR,
727 "wpa-priv-iface-init: bind(PF_UNIX): %s",
731 wpa_printf(MSG_DEBUG, "Successfully replaced leftover "
732 "socket '%s'", iface->sock_name);
734 wpa_printf(MSG_INFO, "Socket exists and seems to be "
735 "in use - cannot override it");
736 wpa_printf(MSG_INFO, "Delete '%s' manually if it is "
737 "not used anymore", iface->sock_name);
742 if (chmod(iface->sock_name, S_IRWXU | S_IRWXG | S_IRWXO) < 0) {
743 wpa_printf(MSG_ERROR, "chmod: %s", strerror(errno));
747 eloop_register_read_sock(iface->fd, wpa_priv_receive, iface, NULL);
752 wpa_priv_interface_deinit(iface);
757 static int wpa_priv_send_event(struct wpa_priv_interface *iface, int event,
758 const void *data, size_t data_len)
763 io[0].iov_base = &event;
764 io[0].iov_len = sizeof(event);
765 io[1].iov_base = (u8 *) data;
766 io[1].iov_len = data_len;
768 os_memset(&msg, 0, sizeof(msg));
770 msg.msg_iovlen = data ? 2 : 1;
771 msg.msg_name = &iface->drv_addr;
772 msg.msg_namelen = sizeof(iface->drv_addr);
774 if (sendmsg(iface->fd, &msg, 0) < 0) {
775 wpa_printf(MSG_ERROR, "sendmsg(wpas_socket): %s",
784 static void wpa_priv_send_auth(struct wpa_priv_interface *iface,
785 union wpa_event_data *data)
787 size_t buflen = sizeof(struct privsep_event_auth) + data->auth.ies_len;
788 struct privsep_event_auth *auth;
791 buf = os_malloc(buflen);
795 auth = (struct privsep_event_auth *) buf;
796 pos = (u8 *) (auth + 1);
798 os_memcpy(auth->peer, data->auth.peer, ETH_ALEN);
799 os_memcpy(auth->bssid, data->auth.bssid, ETH_ALEN);
800 auth->auth_type = data->auth.auth_type;
801 auth->auth_transaction = data->auth.auth_transaction;
802 auth->status_code = data->auth.status_code;
803 if (data->auth.ies) {
804 os_memcpy(pos, data->auth.ies, data->auth.ies_len);
805 auth->ies_len = data->auth.ies_len;
808 wpa_priv_send_event(iface, PRIVSEP_EVENT_AUTH, buf, buflen);
814 static void wpa_priv_send_assoc(struct wpa_priv_interface *iface, int event,
815 union wpa_event_data *data)
817 size_t buflen = 3 * sizeof(int);
822 buflen += data->assoc_info.req_ies_len +
823 data->assoc_info.resp_ies_len +
824 data->assoc_info.beacon_ies_len;
827 buf = os_malloc(buflen);
833 if (data && data->assoc_info.req_ies) {
834 len = data->assoc_info.req_ies_len;
835 os_memcpy(pos, &len, sizeof(int));
837 os_memcpy(pos, data->assoc_info.req_ies, len);
841 os_memcpy(pos, &len, sizeof(int));
845 if (data && data->assoc_info.resp_ies) {
846 len = data->assoc_info.resp_ies_len;
847 os_memcpy(pos, &len, sizeof(int));
849 os_memcpy(pos, data->assoc_info.resp_ies, len);
853 os_memcpy(pos, &len, sizeof(int));
857 if (data && data->assoc_info.beacon_ies) {
858 len = data->assoc_info.beacon_ies_len;
859 os_memcpy(pos, &len, sizeof(int));
861 os_memcpy(pos, data->assoc_info.beacon_ies, len);
865 os_memcpy(pos, &len, sizeof(int));
869 wpa_priv_send_event(iface, event, buf, buflen);
875 static void wpa_priv_send_interface_status(struct wpa_priv_interface *iface,
876 union wpa_event_data *data)
886 ievent = data->interface_status.ievent;
887 maxlen = sizeof(data->interface_status.ifname);
888 ifname = data->interface_status.ifname;
889 for (len = 0; len < maxlen && ifname[len]; len++)
892 buf = os_malloc(sizeof(int) + len);
896 os_memcpy(buf, &ievent, sizeof(int));
897 os_memcpy(buf + sizeof(int), ifname, len);
899 wpa_priv_send_event(iface, PRIVSEP_EVENT_INTERFACE_STATUS,
900 buf, sizeof(int) + len);
907 static void wpa_priv_send_ft_response(struct wpa_priv_interface *iface,
908 union wpa_event_data *data)
913 if (data == NULL || data->ft_ies.ies == NULL)
916 len = sizeof(int) + ETH_ALEN + data->ft_ies.ies_len;
917 buf = os_malloc(len);
922 os_memcpy(pos, &data->ft_ies.ft_action, sizeof(int));
924 os_memcpy(pos, data->ft_ies.target_ap, ETH_ALEN);
926 os_memcpy(pos, data->ft_ies.ies, data->ft_ies.ies_len);
928 wpa_priv_send_event(iface, PRIVSEP_EVENT_FT_RESPONSE, buf, len);
935 void wpa_supplicant_event(void *ctx, enum wpa_event_type event,
936 union wpa_event_data *data)
938 struct wpa_priv_interface *iface = ctx;
940 wpa_printf(MSG_DEBUG, "%s - event=%d", __func__, event);
942 if (!iface->wpas_registered) {
943 wpa_printf(MSG_DEBUG, "Driver event received, but "
944 "wpa_supplicant not registered");
950 wpa_priv_send_assoc(iface, PRIVSEP_EVENT_ASSOC, data);
953 wpa_priv_send_event(iface, PRIVSEP_EVENT_DISASSOC, NULL, 0);
955 case EVENT_ASSOCINFO:
958 wpa_priv_send_assoc(iface, PRIVSEP_EVENT_ASSOCINFO, data);
960 case EVENT_MICHAEL_MIC_FAILURE:
963 wpa_priv_send_event(iface, PRIVSEP_EVENT_MICHAEL_MIC_FAILURE,
964 &data->michael_mic_failure.unicast,
967 case EVENT_SCAN_STARTED:
968 wpa_priv_send_event(iface, PRIVSEP_EVENT_SCAN_STARTED, NULL,
971 case EVENT_SCAN_RESULTS:
972 wpa_priv_send_event(iface, PRIVSEP_EVENT_SCAN_RESULTS, NULL,
975 case EVENT_INTERFACE_STATUS:
976 wpa_priv_send_interface_status(iface, data);
978 case EVENT_PMKID_CANDIDATE:
981 wpa_priv_send_event(iface, PRIVSEP_EVENT_PMKID_CANDIDATE,
982 &data->pmkid_candidate,
983 sizeof(struct pmkid_candidate));
988 wpa_priv_send_event(iface, PRIVSEP_EVENT_STKSTART,
989 &data->stkstart.peer, ETH_ALEN);
991 case EVENT_FT_RESPONSE:
992 wpa_priv_send_ft_response(iface, data);
995 wpa_priv_send_auth(iface, data);
998 wpa_printf(MSG_DEBUG, "Unsupported driver event %d (%s) - TODO",
999 event, event_to_string(event));
1005 void wpa_supplicant_rx_eapol(void *ctx, const u8 *src_addr,
1006 const u8 *buf, size_t len)
1008 struct wpa_priv_interface *iface = ctx;
1011 int event = PRIVSEP_EVENT_RX_EAPOL;
1013 wpa_printf(MSG_DEBUG, "RX EAPOL from driver");
1014 io[0].iov_base = &event;
1015 io[0].iov_len = sizeof(event);
1016 io[1].iov_base = (u8 *) src_addr;
1017 io[1].iov_len = ETH_ALEN;
1018 io[2].iov_base = (u8 *) buf;
1019 io[2].iov_len = len;
1021 os_memset(&msg, 0, sizeof(msg));
1024 msg.msg_name = &iface->drv_addr;
1025 msg.msg_namelen = sizeof(iface->drv_addr);
1027 if (sendmsg(iface->fd, &msg, 0) < 0)
1028 wpa_printf(MSG_ERROR, "sendmsg(wpas_socket): %s",
1033 static void wpa_priv_terminate(int sig, void *signal_ctx)
1035 wpa_printf(MSG_DEBUG, "wpa_priv termination requested");
1040 static void wpa_priv_fd_workaround(void)
1044 /* When started from pcmcia-cs scripts, wpa_supplicant might start with
1045 * fd 0, 1, and 2 closed. This will cause some issues because many
1046 * places in wpa_supplicant are still printing out to stdout. As a
1047 * workaround, make sure that fd's 0, 1, and 2 are not used for other
1049 for (i = 0; i < 3; i++) {
1050 s = open("/dev/null", O_RDWR);
1056 #endif /* __linux__ */
1060 static void usage(void)
1062 printf("wpa_priv v" VERSION_STR "\n"
1063 "Copyright (c) 2007-2009, Jouni Malinen <j@w1.fi> and "
1067 " wpa_priv [-Bdd] [-c<ctrl dir>] [-P<pid file>] "
1068 "<driver:ifname> \\\n"
1069 " [driver:ifname ...]\n");
1073 int main(int argc, char *argv[])
1077 char *pid_file = NULL;
1079 char *ctrl_dir = "/var/run/wpa_priv";
1080 struct wpa_priv_interface *interfaces = NULL, *iface;
1082 if (os_program_init())
1085 wpa_priv_fd_workaround();
1088 c = getopt(argc, argv, "Bc:dP:");
1102 pid_file = os_rel2abs_path(optarg);
1110 if (optind >= argc) {
1115 wpa_printf(MSG_DEBUG, "wpa_priv control directory: '%s'", ctrl_dir);
1118 wpa_printf(MSG_ERROR, "Failed to initialize event loop");
1122 for (i = optind; i < argc; i++) {
1123 wpa_printf(MSG_DEBUG, "Adding driver:interface %s", argv[i]);
1124 iface = wpa_priv_interface_init(ctrl_dir, argv[i]);
1127 iface->next = interfaces;
1131 if (daemonize && os_daemonize(pid_file))
1134 eloop_register_signal_terminate(wpa_priv_terminate, NULL);
1142 struct wpa_priv_interface *prev = iface;
1143 iface = iface->next;
1144 wpa_priv_interface_deinit(prev);
1151 os_daemonize_terminate(pid_file);
1153 os_program_deinit();