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_associate(struct wpa_priv_interface *iface,
199 void *buf, size_t len)
201 struct wpa_driver_associate_params params;
202 struct privsep_cmd_associate *assoc;
206 if (iface->drv_priv == NULL || iface->driver->associate == NULL)
209 if (len < sizeof(*assoc)) {
210 wpa_printf(MSG_DEBUG, "Invalid association request");
215 if (sizeof(*assoc) + assoc->wpa_ie_len > len) {
216 wpa_printf(MSG_DEBUG, "Association request overflow");
220 os_memset(¶ms, 0, sizeof(params));
221 bssid = assoc->bssid;
222 if (bssid[0] | bssid[1] | bssid[2] | bssid[3] | bssid[4] | bssid[5])
223 params.bssid = bssid;
224 params.ssid = assoc->ssid;
225 if (assoc->ssid_len > SSID_MAX_LEN)
227 params.ssid_len = assoc->ssid_len;
228 params.freq.mode = assoc->hwmode;
229 params.freq.freq = assoc->freq;
230 params.freq.channel = assoc->channel;
231 if (assoc->wpa_ie_len) {
232 params.wpa_ie = (u8 *) (assoc + 1);
233 params.wpa_ie_len = assoc->wpa_ie_len;
235 params.pairwise_suite = assoc->pairwise_suite;
236 params.group_suite = assoc->group_suite;
237 params.key_mgmt_suite = assoc->key_mgmt_suite;
238 params.auth_alg = assoc->auth_alg;
239 params.mode = assoc->mode;
241 res = iface->driver->associate(iface->drv_priv, ¶ms);
242 wpa_printf(MSG_DEBUG, "drv->associate: res=%d", res);
246 static void wpa_priv_cmd_get_bssid(struct wpa_priv_interface *iface,
247 struct sockaddr_un *from)
251 if (iface->drv_priv == NULL)
254 if (iface->driver->get_bssid == NULL ||
255 iface->driver->get_bssid(iface->drv_priv, bssid) < 0)
258 sendto(iface->fd, bssid, ETH_ALEN, 0, (struct sockaddr *) from,
263 sendto(iface->fd, "", 0, 0, (struct sockaddr *) from, sizeof(*from));
267 static void wpa_priv_cmd_get_ssid(struct wpa_priv_interface *iface,
268 struct sockaddr_un *from)
270 u8 ssid[sizeof(int) + SSID_MAX_LEN];
273 if (iface->drv_priv == NULL)
276 if (iface->driver->get_ssid == NULL)
279 res = iface->driver->get_ssid(iface->drv_priv, &ssid[sizeof(int)]);
280 if (res < 0 || res > SSID_MAX_LEN)
282 os_memcpy(ssid, &res, sizeof(int));
284 sendto(iface->fd, ssid, sizeof(ssid), 0, (struct sockaddr *) from,
289 sendto(iface->fd, "", 0, 0, (struct sockaddr *) from, sizeof(*from));
293 static void wpa_priv_cmd_set_key(struct wpa_priv_interface *iface,
294 void *buf, size_t len)
296 struct privsep_cmd_set_key *params;
299 if (iface->drv_priv == NULL || iface->driver->set_key == NULL)
302 if (len != sizeof(*params)) {
303 wpa_printf(MSG_DEBUG, "Invalid set_key request");
309 res = iface->driver->set_key(iface->ifname, iface->drv_priv,
311 params->addr, params->key_idx,
313 params->seq_len ? params->seq : NULL,
315 params->key_len ? params->key : NULL,
317 wpa_printf(MSG_DEBUG, "drv->set_key: res=%d", res);
321 static void wpa_priv_cmd_get_capa(struct wpa_priv_interface *iface,
322 struct sockaddr_un *from)
324 struct wpa_driver_capa capa;
326 if (iface->drv_priv == NULL)
329 if (iface->driver->get_capa == NULL ||
330 iface->driver->get_capa(iface->drv_priv, &capa) < 0)
333 /* For now, no support for passing extended_capa pointers */
334 capa.extended_capa = NULL;
335 capa.extended_capa_mask = NULL;
336 capa.extended_capa_len = 0;
337 sendto(iface->fd, &capa, sizeof(capa), 0, (struct sockaddr *) from,
342 sendto(iface->fd, "", 0, 0, (struct sockaddr *) from, sizeof(*from));
346 static void wpa_priv_l2_rx(void *ctx, const u8 *src_addr, const u8 *buf,
349 struct wpa_priv_interface *iface = ctx;
353 io[0].iov_base = (u8 *) src_addr;
354 io[0].iov_len = ETH_ALEN;
355 io[1].iov_base = (u8 *) buf;
358 os_memset(&msg, 0, sizeof(msg));
361 msg.msg_name = &iface->l2_addr;
362 msg.msg_namelen = sizeof(iface->l2_addr);
364 if (sendmsg(iface->fd, &msg, 0) < 0) {
365 wpa_printf(MSG_ERROR, "sendmsg(l2 rx): %s", strerror(errno));
370 static void wpa_priv_cmd_l2_register(struct wpa_priv_interface *iface,
371 struct sockaddr_un *from,
372 void *buf, size_t len)
375 u8 own_addr[ETH_ALEN];
379 if (len != 2 * sizeof(int)) {
380 wpa_printf(MSG_DEBUG, "Invalid l2_register length %lu",
381 (unsigned long) len);
386 if (proto != ETH_P_EAPOL && proto != ETH_P_RSN_PREAUTH &&
387 proto != ETH_P_80211_ENCAP) {
388 wpa_printf(MSG_DEBUG, "Refused l2_packet connection for "
389 "ethertype 0x%x", proto);
394 wpa_printf(MSG_DEBUG, "Cleaning up forgotten l2_packet "
396 l2_packet_deinit(iface->l2);
400 os_memcpy(&iface->l2_addr, from, sizeof(iface->l2_addr));
402 iface->l2 = l2_packet_init(iface->ifname, NULL, proto,
403 wpa_priv_l2_rx, iface, reg_cmd[1]);
404 if (iface->l2 == NULL) {
405 wpa_printf(MSG_DEBUG, "Failed to initialize l2_packet "
406 "instance for protocol %d", proto);
410 if (l2_packet_get_own_addr(iface->l2, own_addr) < 0) {
411 wpa_printf(MSG_DEBUG, "Failed to get own address from "
413 l2_packet_deinit(iface->l2);
418 res = sendto(iface->fd, own_addr, ETH_ALEN, 0,
419 (struct sockaddr *) from, sizeof(*from));
420 wpa_printf(MSG_DEBUG, "L2 registration: res=%d", res);
424 static void wpa_priv_cmd_l2_unregister(struct wpa_priv_interface *iface,
425 struct sockaddr_un *from)
428 l2_packet_deinit(iface->l2);
434 static void wpa_priv_cmd_l2_notify_auth_start(struct wpa_priv_interface *iface,
435 struct sockaddr_un *from)
438 l2_packet_notify_auth_start(iface->l2);
442 static void wpa_priv_cmd_l2_send(struct wpa_priv_interface *iface,
443 struct sockaddr_un *from,
444 void *buf, size_t len)
450 if (iface->l2 == NULL)
453 if (len < ETH_ALEN + 2) {
454 wpa_printf(MSG_DEBUG, "Too short L2 send packet (len=%lu)",
455 (unsigned long) len);
460 os_memcpy(&proto, buf + ETH_ALEN, 2);
462 if (proto != ETH_P_EAPOL && proto != ETH_P_RSN_PREAUTH) {
463 wpa_printf(MSG_DEBUG, "Refused l2_packet send for ethertype "
468 res = l2_packet_send(iface->l2, dst_addr, proto, buf + ETH_ALEN + 2,
470 wpa_printf(MSG_DEBUG, "L2 send: res=%d", res);
474 static void wpa_priv_cmd_set_country(struct wpa_priv_interface *iface,
477 if (iface->drv_priv == NULL || iface->driver->set_country == NULL ||
481 iface->driver->set_country(iface->drv_priv, buf);
485 static void wpa_priv_receive(int sock, void *eloop_ctx, void *sock_ctx)
487 struct wpa_priv_interface *iface = eloop_ctx;
488 char buf[2000], *pos;
492 struct sockaddr_un from;
493 socklen_t fromlen = sizeof(from);
495 res = recvfrom(sock, buf, sizeof(buf), 0, (struct sockaddr *) &from,
498 wpa_printf(MSG_ERROR, "recvfrom: %s", strerror(errno));
502 if (res < (int) sizeof(int)) {
503 wpa_printf(MSG_DEBUG, "Too short command (len=%d)", res);
507 os_memcpy(&cmd, buf, sizeof(int));
508 wpa_printf(MSG_DEBUG, "Command %d for interface %s",
510 cmd_buf = &buf[sizeof(int)];
511 cmd_len = res - sizeof(int);
514 case PRIVSEP_CMD_REGISTER:
515 wpa_priv_cmd_register(iface, &from);
517 case PRIVSEP_CMD_UNREGISTER:
518 wpa_priv_cmd_unregister(iface, &from);
520 case PRIVSEP_CMD_SCAN:
521 wpa_priv_cmd_scan(iface, cmd_buf, cmd_len);
523 case PRIVSEP_CMD_GET_SCAN_RESULTS:
524 wpa_priv_cmd_get_scan_results(iface, &from);
526 case PRIVSEP_CMD_ASSOCIATE:
527 wpa_priv_cmd_associate(iface, cmd_buf, cmd_len);
529 case PRIVSEP_CMD_GET_BSSID:
530 wpa_priv_cmd_get_bssid(iface, &from);
532 case PRIVSEP_CMD_GET_SSID:
533 wpa_priv_cmd_get_ssid(iface, &from);
535 case PRIVSEP_CMD_SET_KEY:
536 wpa_priv_cmd_set_key(iface, cmd_buf, cmd_len);
538 case PRIVSEP_CMD_GET_CAPA:
539 wpa_priv_cmd_get_capa(iface, &from);
541 case PRIVSEP_CMD_L2_REGISTER:
542 wpa_priv_cmd_l2_register(iface, &from, cmd_buf, cmd_len);
544 case PRIVSEP_CMD_L2_UNREGISTER:
545 wpa_priv_cmd_l2_unregister(iface, &from);
547 case PRIVSEP_CMD_L2_NOTIFY_AUTH_START:
548 wpa_priv_cmd_l2_notify_auth_start(iface, &from);
550 case PRIVSEP_CMD_L2_SEND:
551 wpa_priv_cmd_l2_send(iface, &from, cmd_buf, cmd_len);
553 case PRIVSEP_CMD_SET_COUNTRY:
555 if (pos + cmd_len >= buf + sizeof(buf))
558 wpa_priv_cmd_set_country(iface, pos);
564 static void wpa_priv_interface_deinit(struct wpa_priv_interface *iface)
566 if (iface->drv_priv && iface->driver->deinit)
567 iface->driver->deinit(iface->drv_priv);
569 if (iface->fd >= 0) {
570 eloop_unregister_read_sock(iface->fd);
572 unlink(iface->sock_name);
576 l2_packet_deinit(iface->l2);
578 os_free(iface->ifname);
579 os_free(iface->driver_name);
580 os_free(iface->sock_name);
585 static struct wpa_priv_interface *
586 wpa_priv_interface_init(const char *dir, const char *params)
588 struct wpa_priv_interface *iface;
591 struct sockaddr_un addr;
594 pos = os_strchr(params, ':');
598 iface = os_zalloc(sizeof(*iface));
604 iface->driver_name = dup_binstr(params, len);
605 if (iface->driver_name == NULL) {
606 wpa_priv_interface_deinit(iface);
610 for (i = 0; wpa_drivers[i]; i++) {
611 if (os_strcmp(iface->driver_name,
612 wpa_drivers[i]->name) == 0) {
613 iface->driver = wpa_drivers[i];
617 if (iface->driver == NULL) {
618 wpa_printf(MSG_ERROR, "Unsupported driver '%s'",
620 wpa_priv_interface_deinit(iface);
625 iface->ifname = os_strdup(pos);
626 if (iface->ifname == NULL) {
627 wpa_priv_interface_deinit(iface);
631 len = os_strlen(dir) + 1 + os_strlen(iface->ifname);
632 iface->sock_name = os_malloc(len + 1);
633 if (iface->sock_name == NULL) {
634 wpa_priv_interface_deinit(iface);
638 os_snprintf(iface->sock_name, len + 1, "%s/%s", dir, iface->ifname);
639 if (os_strlen(iface->sock_name) >= sizeof(addr.sun_path)) {
640 wpa_priv_interface_deinit(iface);
644 iface->fd = socket(PF_UNIX, SOCK_DGRAM, 0);
646 wpa_printf(MSG_ERROR, "socket(PF_UNIX): %s", strerror(errno));
647 wpa_priv_interface_deinit(iface);
651 os_memset(&addr, 0, sizeof(addr));
652 addr.sun_family = AF_UNIX;
653 os_strlcpy(addr.sun_path, iface->sock_name, sizeof(addr.sun_path));
655 if (bind(iface->fd, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
656 wpa_printf(MSG_DEBUG, "bind(PF_UNIX) failed: %s",
658 if (connect(iface->fd, (struct sockaddr *) &addr,
660 wpa_printf(MSG_DEBUG, "Socket exists, but does not "
661 "allow connections - assuming it was "
662 "leftover from forced program termination");
663 if (unlink(iface->sock_name) < 0) {
664 wpa_printf(MSG_ERROR,
665 "Could not unlink existing ctrl_iface socket '%s': %s",
666 iface->sock_name, strerror(errno));
669 if (bind(iface->fd, (struct sockaddr *) &addr,
671 wpa_printf(MSG_ERROR,
672 "wpa-priv-iface-init: bind(PF_UNIX): %s",
676 wpa_printf(MSG_DEBUG, "Successfully replaced leftover "
677 "socket '%s'", iface->sock_name);
679 wpa_printf(MSG_INFO, "Socket exists and seems to be "
680 "in use - cannot override it");
681 wpa_printf(MSG_INFO, "Delete '%s' manually if it is "
682 "not used anymore", iface->sock_name);
687 if (chmod(iface->sock_name, S_IRWXU | S_IRWXG | S_IRWXO) < 0) {
688 wpa_printf(MSG_ERROR, "chmod: %s", strerror(errno));
692 eloop_register_read_sock(iface->fd, wpa_priv_receive, iface, NULL);
697 wpa_priv_interface_deinit(iface);
702 static int wpa_priv_send_event(struct wpa_priv_interface *iface, int event,
703 const void *data, size_t data_len)
708 io[0].iov_base = &event;
709 io[0].iov_len = sizeof(event);
710 io[1].iov_base = (u8 *) data;
711 io[1].iov_len = data_len;
713 os_memset(&msg, 0, sizeof(msg));
715 msg.msg_iovlen = data ? 2 : 1;
716 msg.msg_name = &iface->drv_addr;
717 msg.msg_namelen = sizeof(iface->drv_addr);
719 if (sendmsg(iface->fd, &msg, 0) < 0) {
720 wpa_printf(MSG_ERROR, "sendmsg(wpas_socket): %s",
729 static void wpa_priv_send_assoc(struct wpa_priv_interface *iface, int event,
730 union wpa_event_data *data)
732 size_t buflen = 3 * sizeof(int);
737 buflen += data->assoc_info.req_ies_len +
738 data->assoc_info.resp_ies_len +
739 data->assoc_info.beacon_ies_len;
742 buf = os_malloc(buflen);
748 if (data && data->assoc_info.req_ies) {
749 len = data->assoc_info.req_ies_len;
750 os_memcpy(pos, &len, sizeof(int));
752 os_memcpy(pos, data->assoc_info.req_ies, len);
756 os_memcpy(pos, &len, sizeof(int));
760 if (data && data->assoc_info.resp_ies) {
761 len = data->assoc_info.resp_ies_len;
762 os_memcpy(pos, &len, sizeof(int));
764 os_memcpy(pos, data->assoc_info.resp_ies, len);
768 os_memcpy(pos, &len, sizeof(int));
772 if (data && data->assoc_info.beacon_ies) {
773 len = data->assoc_info.beacon_ies_len;
774 os_memcpy(pos, &len, sizeof(int));
776 os_memcpy(pos, data->assoc_info.beacon_ies, len);
780 os_memcpy(pos, &len, sizeof(int));
784 wpa_priv_send_event(iface, event, buf, buflen);
790 static void wpa_priv_send_interface_status(struct wpa_priv_interface *iface,
791 union wpa_event_data *data)
801 ievent = data->interface_status.ievent;
802 maxlen = sizeof(data->interface_status.ifname);
803 ifname = data->interface_status.ifname;
804 for (len = 0; len < maxlen && ifname[len]; len++)
807 buf = os_malloc(sizeof(int) + len);
811 os_memcpy(buf, &ievent, sizeof(int));
812 os_memcpy(buf + sizeof(int), ifname, len);
814 wpa_priv_send_event(iface, PRIVSEP_EVENT_INTERFACE_STATUS,
815 buf, sizeof(int) + len);
822 static void wpa_priv_send_ft_response(struct wpa_priv_interface *iface,
823 union wpa_event_data *data)
828 if (data == NULL || data->ft_ies.ies == NULL)
831 len = sizeof(int) + ETH_ALEN + data->ft_ies.ies_len;
832 buf = os_malloc(len);
837 os_memcpy(pos, &data->ft_ies.ft_action, sizeof(int));
839 os_memcpy(pos, data->ft_ies.target_ap, ETH_ALEN);
841 os_memcpy(pos, data->ft_ies.ies, data->ft_ies.ies_len);
843 wpa_priv_send_event(iface, PRIVSEP_EVENT_FT_RESPONSE, buf, len);
850 void wpa_supplicant_event(void *ctx, enum wpa_event_type event,
851 union wpa_event_data *data)
853 struct wpa_priv_interface *iface = ctx;
855 wpa_printf(MSG_DEBUG, "%s - event=%d", __func__, event);
857 if (!iface->wpas_registered) {
858 wpa_printf(MSG_DEBUG, "Driver event received, but "
859 "wpa_supplicant not registered");
865 wpa_priv_send_assoc(iface, PRIVSEP_EVENT_ASSOC, data);
868 wpa_priv_send_event(iface, PRIVSEP_EVENT_DISASSOC, NULL, 0);
870 case EVENT_ASSOCINFO:
873 wpa_priv_send_assoc(iface, PRIVSEP_EVENT_ASSOCINFO, data);
875 case EVENT_MICHAEL_MIC_FAILURE:
878 wpa_priv_send_event(iface, PRIVSEP_EVENT_MICHAEL_MIC_FAILURE,
879 &data->michael_mic_failure.unicast,
882 case EVENT_SCAN_RESULTS:
883 wpa_priv_send_event(iface, PRIVSEP_EVENT_SCAN_RESULTS, NULL,
886 case EVENT_INTERFACE_STATUS:
887 wpa_priv_send_interface_status(iface, data);
889 case EVENT_PMKID_CANDIDATE:
892 wpa_priv_send_event(iface, PRIVSEP_EVENT_PMKID_CANDIDATE,
893 &data->pmkid_candidate,
894 sizeof(struct pmkid_candidate));
899 wpa_priv_send_event(iface, PRIVSEP_EVENT_STKSTART,
900 &data->stkstart.peer, ETH_ALEN);
902 case EVENT_FT_RESPONSE:
903 wpa_priv_send_ft_response(iface, data);
906 wpa_printf(MSG_DEBUG, "Unsupported driver event %d - TODO",
913 void wpa_supplicant_rx_eapol(void *ctx, const u8 *src_addr,
914 const u8 *buf, size_t len)
916 struct wpa_priv_interface *iface = ctx;
919 int event = PRIVSEP_EVENT_RX_EAPOL;
921 wpa_printf(MSG_DEBUG, "RX EAPOL from driver");
922 io[0].iov_base = &event;
923 io[0].iov_len = sizeof(event);
924 io[1].iov_base = (u8 *) src_addr;
925 io[1].iov_len = ETH_ALEN;
926 io[2].iov_base = (u8 *) buf;
929 os_memset(&msg, 0, sizeof(msg));
932 msg.msg_name = &iface->drv_addr;
933 msg.msg_namelen = sizeof(iface->drv_addr);
935 if (sendmsg(iface->fd, &msg, 0) < 0)
936 wpa_printf(MSG_ERROR, "sendmsg(wpas_socket): %s",
941 static void wpa_priv_terminate(int sig, void *signal_ctx)
943 wpa_printf(MSG_DEBUG, "wpa_priv termination requested");
948 static void wpa_priv_fd_workaround(void)
952 /* When started from pcmcia-cs scripts, wpa_supplicant might start with
953 * fd 0, 1, and 2 closed. This will cause some issues because many
954 * places in wpa_supplicant are still printing out to stdout. As a
955 * workaround, make sure that fd's 0, 1, and 2 are not used for other
957 for (i = 0; i < 3; i++) {
958 s = open("/dev/null", O_RDWR);
964 #endif /* __linux__ */
968 static void usage(void)
970 printf("wpa_priv v" VERSION_STR "\n"
971 "Copyright (c) 2007-2009, Jouni Malinen <j@w1.fi> and "
975 " wpa_priv [-Bdd] [-c<ctrl dir>] [-P<pid file>] "
976 "<driver:ifname> \\\n"
977 " [driver:ifname ...]\n");
981 int main(int argc, char *argv[])
985 char *pid_file = NULL;
987 char *ctrl_dir = "/var/run/wpa_priv";
988 struct wpa_priv_interface *interfaces = NULL, *iface;
990 if (os_program_init())
993 wpa_priv_fd_workaround();
996 c = getopt(argc, argv, "Bc:dP:");
1010 pid_file = os_rel2abs_path(optarg);
1018 if (optind >= argc) {
1023 wpa_printf(MSG_DEBUG, "wpa_priv control directory: '%s'", ctrl_dir);
1026 wpa_printf(MSG_ERROR, "Failed to initialize event loop");
1030 for (i = optind; i < argc; i++) {
1031 wpa_printf(MSG_DEBUG, "Adding driver:interface %s", argv[i]);
1032 iface = wpa_priv_interface_init(ctrl_dir, argv[i]);
1035 iface->next = interfaces;
1039 if (daemonize && os_daemonize(pid_file))
1042 eloop_register_signal_terminate(wpa_priv_terminate, NULL);
1050 struct wpa_priv_interface *prev = iface;
1051 iface = iface->next;
1052 wpa_priv_interface_deinit(prev);
1059 os_daemonize_terminate(pid_file);
1061 os_program_deinit();