[thirdparty/hostap.git] / wpa_supplicant / ctrl_iface_unix.c

/*
 * WPA Supplicant / UNIX domain socket -based control interface
 * Copyright (c) 2004-2009, Jouni Malinen <j@w1.fi>
 *
 * This software may be distributed under the terms of the BSD license.
 * See README for more details.
 */

#include "includes.h"
#include <sys/un.h>
#include <sys/stat.h>
#include <grp.h>
#include <stddef.h>
#include <unistd.h>
#include <fcntl.h>
#ifdef ANDROID
#include <cutils/sockets.h>
#endif /* ANDROID */

#include "utils/common.h"
#include "utils/eloop.h"
#include "utils/list.h"
#include "eapol_supp/eapol_supp_sm.h"
#include "config.h"
#include "wpa_supplicant_i.h"
#include "ctrl_iface.h"

/* Per-interface ctrl_iface */

/**
 * struct wpa_ctrl_dst - Internal data structure of control interface monitors
 *
 * This structure is used to store information about registered control
 * interface monitors into struct wpa_supplicant. This data is private to
 * ctrl_iface_unix.c and should not be touched directly from other files.
 */
struct wpa_ctrl_dst {
	struct dl_list list;
	struct sockaddr_un addr;
	socklen_t addrlen;
	int debug_level;
	int errors;
};


struct ctrl_iface_priv {
	struct wpa_supplicant *wpa_s;
	int sock;
	struct dl_list ctrl_dst;
};


static void wpa_supplicant_ctrl_iface_send(struct ctrl_iface_priv *priv,
					   int level, const char *buf,
					   size_t len);


static int wpa_supplicant_ctrl_iface_attach(struct ctrl_iface_priv *priv,
					    struct sockaddr_un *from,
					    socklen_t fromlen)
{
	struct wpa_ctrl_dst *dst;

	dst = os_zalloc(sizeof(*dst));
	if (dst == NULL)
		return -1;
	os_memcpy(&dst->addr, from, sizeof(struct sockaddr_un));
	dst->addrlen = fromlen;
	dst->debug_level = MSG_INFO;
	dl_list_add(&priv->ctrl_dst, &dst->list);
	wpa_hexdump(MSG_DEBUG, "CTRL_IFACE monitor attached",
		    (u8 *) from->sun_path,
		    fromlen - offsetof(struct sockaddr_un, sun_path));
	return 0;
}


static int wpa_supplicant_ctrl_iface_detach(struct ctrl_iface_priv *priv,
					    struct sockaddr_un *from,
					    socklen_t fromlen)
{
	struct wpa_ctrl_dst *dst;

	dl_list_for_each(dst, &priv->ctrl_dst, struct wpa_ctrl_dst, list) {
		if (fromlen == dst->addrlen &&
		    os_memcmp(from->sun_path, dst->addr.sun_path,
			      fromlen - offsetof(struct sockaddr_un, sun_path))
		    == 0) {
			dl_list_del(&dst->list);
			os_free(dst);
			wpa_hexdump(MSG_DEBUG, "CTRL_IFACE monitor detached",
				    (u8 *) from->sun_path,
				    fromlen -
				    offsetof(struct sockaddr_un, sun_path));
			return 0;
		}
	}
	return -1;
}


static int wpa_supplicant_ctrl_iface_level(struct ctrl_iface_priv *priv,
					   struct sockaddr_un *from,
					   socklen_t fromlen,
					   char *level)
{
	struct wpa_ctrl_dst *dst;

	wpa_printf(MSG_DEBUG, "CTRL_IFACE LEVEL %s", level);

	dl_list_for_each(dst, &priv->ctrl_dst, struct wpa_ctrl_dst, list) {
		if (fromlen == dst->addrlen &&
		    os_memcmp(from->sun_path, dst->addr.sun_path,
			      fromlen - offsetof(struct sockaddr_un, sun_path))
		    == 0) {
			wpa_hexdump(MSG_DEBUG, "CTRL_IFACE changed monitor "
				    "level", (u8 *) from->sun_path,
				    fromlen -
				    offsetof(struct sockaddr_un, sun_path));
			dst->debug_level = atoi(level);
			return 0;
		}
	}

	return -1;
}


static void wpa_supplicant_ctrl_iface_receive(int sock, void *eloop_ctx,
					      void *sock_ctx)
{
	struct wpa_supplicant *wpa_s = eloop_ctx;
	struct ctrl_iface_priv *priv = sock_ctx;
	char buf[4096];
	int res;
	struct sockaddr_un from;
	socklen_t fromlen = sizeof(from);
	char *reply = NULL;
	size_t reply_len = 0;
	int new_attached = 0;

	res = recvfrom(sock, buf, sizeof(buf) - 1, 0,
		       (struct sockaddr *) &from, &fromlen);
	if (res < 0) {
		perror("recvfrom(ctrl_iface)");
		return;
	}
	buf[res] = '\0';

	if (os_strcmp(buf, "ATTACH") == 0) {
		if (wpa_supplicant_ctrl_iface_attach(priv, &from, fromlen))
			reply_len = 1;
		else {
			new_attached = 1;
			reply_len = 2;
		}
	} else if (os_strcmp(buf, "DETACH") == 0) {
		if (wpa_supplicant_ctrl_iface_detach(priv, &from, fromlen))
			reply_len = 1;
		else
			reply_len = 2;
	} else if (os_strncmp(buf, "LEVEL ", 6) == 0) {
		if (wpa_supplicant_ctrl_iface_level(priv, &from, fromlen,
						    buf + 6))
			reply_len = 1;
		else
			reply_len = 2;
	} else {
		reply = wpa_supplicant_ctrl_iface_process(wpa_s, buf,
							  &reply_len);
	}

	if (reply) {
		sendto(sock, reply, reply_len, 0, (struct sockaddr *) &from,
		       fromlen);
		os_free(reply);
	} else if (reply_len == 1) {
		sendto(sock, "FAIL\n", 5, 0, (struct sockaddr *) &from,
		       fromlen);
	} else if (reply_len == 2) {
		sendto(sock, "OK\n", 3, 0, (struct sockaddr *) &from,
		       fromlen);
	}

	if (new_attached)
		eapol_sm_notify_ctrl_attached(wpa_s->eapol);
}


static char * wpa_supplicant_ctrl_iface_path(struct wpa_supplicant *wpa_s)
{
	char *buf;
	size_t len;
	char *pbuf, *dir = NULL, *gid_str = NULL;
	int res;

	if (wpa_s->conf->ctrl_interface == NULL)
		return NULL;

	pbuf = os_strdup(wpa_s->conf->ctrl_interface);
	if (pbuf == NULL)
		return NULL;
	if (os_strncmp(pbuf, "DIR=", 4) == 0) {
		dir = pbuf + 4;
		gid_str = os_strstr(dir, " GROUP=");
		if (gid_str) {
			*gid_str = '\0';
			gid_str += 7;
		}
	} else
		dir = pbuf;

	len = os_strlen(dir) + os_strlen(wpa_s->ifname) + 2;
	buf = os_malloc(len);
	if (buf == NULL) {
		os_free(pbuf);
		return NULL;
	}

	res = os_snprintf(buf, len, "%s/%s", dir, wpa_s->ifname);
	if (res < 0 || (size_t) res >= len) {
		os_free(pbuf);
		os_free(buf);
		return NULL;
	}
#ifdef __CYGWIN__
	{
		/* Windows/WinPcap uses interface names that are not suitable
		 * as a file name - convert invalid chars to underscores */
		char *pos = buf;
		while (*pos) {
			if (*pos == '\\')
				*pos = '_';
			pos++;
		}
	}
#endif /* __CYGWIN__ */
	os_free(pbuf);
	return buf;
}


static void wpa_supplicant_ctrl_iface_msg_cb(void *ctx, int level,
					     const char *txt, size_t len)
{
	struct wpa_supplicant *wpa_s = ctx;
	if (wpa_s == NULL || wpa_s->ctrl_iface == NULL)
		return;
	wpa_supplicant_ctrl_iface_send(wpa_s->ctrl_iface, level, txt, len);
}


struct ctrl_iface_priv *
wpa_supplicant_ctrl_iface_init(struct wpa_supplicant *wpa_s)
{
	struct ctrl_iface_priv *priv;
	struct sockaddr_un addr;
	char *fname = NULL;
	gid_t gid = 0;
	int gid_set = 0;
	char *buf, *dir = NULL, *gid_str = NULL;
	struct group *grp;
	char *endp;
	int flags;

	priv = os_zalloc(sizeof(*priv));
	if (priv == NULL)
		return NULL;
	dl_list_init(&priv->ctrl_dst);
	priv->wpa_s = wpa_s;
	priv->sock = -1;

	if (wpa_s->conf->ctrl_interface == NULL)
		return priv;

	buf = os_strdup(wpa_s->conf->ctrl_interface);
	if (buf == NULL)
		goto fail;
#ifdef ANDROID
	os_snprintf(addr.sun_path, sizeof(addr.sun_path), "wpa_%s",
		    wpa_s->conf->ctrl_interface);
	priv->sock = android_get_control_socket(addr.sun_path);
	if (priv->sock >= 0)
		goto havesock;
#endif /* ANDROID */
	if (os_strncmp(buf, "DIR=", 4) == 0) {
		dir = buf + 4;
		gid_str = os_strstr(dir, " GROUP=");
		if (gid_str) {
			*gid_str = '\0';
			gid_str += 7;
		}
	} else {
		dir = buf;
		gid_str = wpa_s->conf->ctrl_interface_group;
	}

	if (mkdir(dir, S_IRWXU | S_IRWXG) < 0) {
		if (errno == EEXIST) {
			wpa_printf(MSG_DEBUG, "Using existing control "
				   "interface directory.");
		} else {
			perror("mkdir[ctrl_interface]");
			goto fail;
		}
	}

#ifdef ANDROID
	/*
	 * wpa_supplicant is started from /init.*.rc on Android and that seems
	 * to be using umask 0077 which would leave the control interface
	 * directory without group access. This breaks things since Wi-Fi
	 * framework assumes that this directory can be accessed by other
	 * applications in the wifi group. Fix this by adding group access even
	 * if umask value would prevent this.
	 */
	if (chmod(dir, S_IRWXU | S_IRWXG) < 0) {
		wpa_printf(MSG_ERROR, "CTRL: Could not chmod directory: %s",
			   strerror(errno));
		/* Try to continue anyway */
	}
#endif /* ANDROID */

	if (gid_str) {
		grp = getgrnam(gid_str);
		if (grp) {
			gid = grp->gr_gid;
			gid_set = 1;
			wpa_printf(MSG_DEBUG, "ctrl_interface_group=%d"
				   " (from group name '%s')",
				   (int) gid, gid_str);
		} else {
			/* Group name not found - try to parse this as gid */
			gid = strtol(gid_str, &endp, 10);
			if (*gid_str == '\0' || *endp != '\0') {
				wpa_printf(MSG_ERROR, "CTRL: Invalid group "
					   "'%s'", gid_str);
				goto fail;
			}
			gid_set = 1;
			wpa_printf(MSG_DEBUG, "ctrl_interface_group=%d",
				   (int) gid);
		}
	}

	if (gid_set && chown(dir, -1, gid) < 0) {
		perror("chown[ctrl_interface]");
		goto fail;
	}

	/* Make sure the group can enter and read the directory */
	if (gid_set &&
	    chmod(dir, S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IXGRP) < 0) {
		wpa_printf(MSG_ERROR, "CTRL: chmod[ctrl_interface]: %s",
			   strerror(errno));
		goto fail;
	}

	if (os_strlen(dir) + 1 + os_strlen(wpa_s->ifname) >=
	    sizeof(addr.sun_path)) {
		wpa_printf(MSG_ERROR, "ctrl_iface path limit exceeded");
		goto fail;
	}

	priv->sock = socket(PF_UNIX, SOCK_DGRAM, 0);
	if (priv->sock < 0) {
		perror("socket(PF_UNIX)");
		goto fail;
	}

	os_memset(&addr, 0, sizeof(addr));
#if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
	addr.sun_len = sizeof(addr);
#endif /* __FreeBSD__ */
	addr.sun_family = AF_UNIX;
	fname = wpa_supplicant_ctrl_iface_path(wpa_s);
	if (fname == NULL)
		goto fail;
	os_strlcpy(addr.sun_path, fname, sizeof(addr.sun_path));
	if (bind(priv->sock, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
		wpa_printf(MSG_DEBUG, "ctrl_iface bind(PF_UNIX) failed: %s",
			   strerror(errno));
		if (connect(priv->sock, (struct sockaddr *) &addr,
			    sizeof(addr)) < 0) {
			wpa_printf(MSG_DEBUG, "ctrl_iface exists, but does not"
				   " allow connections - assuming it was left"
				   "over from forced program termination");
			if (unlink(fname) < 0) {
				perror("unlink[ctrl_iface]");
				wpa_printf(MSG_ERROR, "Could not unlink "
					   "existing ctrl_iface socket '%s'",
					   fname);
				goto fail;
			}
			if (bind(priv->sock, (struct sockaddr *) &addr,
				 sizeof(addr)) < 0) {
				perror("supp-ctrl-iface-init: bind(PF_UNIX)");
				goto fail;
			}
			wpa_printf(MSG_DEBUG, "Successfully replaced leftover "
				   "ctrl_iface socket '%s'", fname);
		} else {
			wpa_printf(MSG_INFO, "ctrl_iface exists and seems to "
				   "be in use - cannot override it");
			wpa_printf(MSG_INFO, "Delete '%s' manually if it is "
				   "not used anymore", fname);
			os_free(fname);
			fname = NULL;
			goto fail;
		}
	}

	if (gid_set && chown(fname, -1, gid) < 0) {
		perror("chown[ctrl_interface/ifname]");
		goto fail;
	}

	if (chmod(fname, S_IRWXU | S_IRWXG) < 0) {
		perror("chmod[ctrl_interface/ifname]");
		goto fail;
	}
	os_free(fname);

#ifdef ANDROID
havesock:
#endif /* ANDROID */

	/*
	 * Make socket non-blocking so that we don't hang forever if
	 * target dies unexpectedly.
	 */
	flags = fcntl(priv->sock, F_GETFL);
	if (flags >= 0) {
		flags |= O_NONBLOCK;
		if (fcntl(priv->sock, F_SETFL, flags) < 0) {
			perror("fcntl(ctrl, O_NONBLOCK)");
			/* Not fatal, continue on.*/
		}
	}

	eloop_register_read_sock(priv->sock, wpa_supplicant_ctrl_iface_receive,
				 wpa_s, priv);
	wpa_msg_register_cb(wpa_supplicant_ctrl_iface_msg_cb);

	os_free(buf);
	return priv;

fail:
	if (priv->sock >= 0)
		close(priv->sock);
	os_free(priv);
	if (fname) {
		unlink(fname);
		os_free(fname);
	}
	os_free(buf);
	return NULL;
}


void wpa_supplicant_ctrl_iface_deinit(struct ctrl_iface_priv *priv)
{
	struct wpa_ctrl_dst *dst, *prev;

	if (priv->sock > -1) {
		char *fname;
		char *buf, *dir = NULL, *gid_str = NULL;
		eloop_unregister_read_sock(priv->sock);
		if (!dl_list_empty(&priv->ctrl_dst)) {
			/*
			 * Wait a second before closing the control socket if
			 * there are any attached monitors in order to allow
			 * them to receive any pending messages.
			 */
			wpa_printf(MSG_DEBUG, "CTRL_IFACE wait for attached "
				   "monitors to receive messages");
			os_sleep(1, 0);
		}
		close(priv->sock);
		priv->sock = -1;
		fname = wpa_supplicant_ctrl_iface_path(priv->wpa_s);
		if (fname) {
			unlink(fname);
			os_free(fname);
		}

		buf = os_strdup(priv->wpa_s->conf->ctrl_interface);
		if (buf == NULL)
			goto free_dst;
		if (os_strncmp(buf, "DIR=", 4) == 0) {
			dir = buf + 4;
			gid_str = os_strstr(dir, " GROUP=");
			if (gid_str) {
				*gid_str = '\0';
				gid_str += 7;
			}
		} else
			dir = buf;

		if (rmdir(dir) < 0) {
			if (errno == ENOTEMPTY) {
				wpa_printf(MSG_DEBUG, "Control interface "
					   "directory not empty - leaving it "
					   "behind");
			} else {
				perror("rmdir[ctrl_interface]");
			}
		}
		os_free(buf);
	}

free_dst:
	dl_list_for_each_safe(dst, prev, &priv->ctrl_dst, struct wpa_ctrl_dst,
			      list)
		os_free(dst);
	os_free(priv);
}


/**
 * wpa_supplicant_ctrl_iface_send - Send a control interface packet to monitors
 * @priv: Pointer to private data from wpa_supplicant_ctrl_iface_init()
 * @level: Priority level of the message
 * @buf: Message data
 * @len: Message length
 *
 * Send a packet to all monitor programs attached to the control interface.
 */
static void wpa_supplicant_ctrl_iface_send(struct ctrl_iface_priv *priv,
					   int level, const char *buf,
					   size_t len)
{
	struct wpa_ctrl_dst *dst, *next;
	char levelstr[10];
	int idx, res;
	struct msghdr msg;
	struct iovec io[2];

	if (priv->sock < 0 || dl_list_empty(&priv->ctrl_dst))
		return;

	res = os_snprintf(levelstr, sizeof(levelstr), "<%d>", level);
	if (res < 0 || (size_t) res >= sizeof(levelstr))
		return;
	io[0].iov_base = levelstr;
	io[0].iov_len = os_strlen(levelstr);
	io[1].iov_base = (char *) buf;
	io[1].iov_len = len;
	os_memset(&msg, 0, sizeof(msg));
	msg.msg_iov = io;
	msg.msg_iovlen = 2;

	idx = 0;
	dl_list_for_each_safe(dst, next, &priv->ctrl_dst, struct wpa_ctrl_dst,
			      list) {
		if (level >= dst->debug_level) {
			wpa_hexdump(MSG_DEBUG, "CTRL_IFACE monitor send",
				    (u8 *) dst->addr.sun_path, dst->addrlen -
				    offsetof(struct sockaddr_un, sun_path));
			msg.msg_name = (void *) &dst->addr;
			msg.msg_namelen = dst->addrlen;
			if (sendmsg(priv->sock, &msg, 0) < 0) {
				int _errno = errno;
				wpa_printf(MSG_INFO, "CTRL_IFACE monitor[%d]: "
					   "%d - %s",
					   idx, errno, strerror(errno));
				dst->errors++;
				if (dst->errors > 1000 ||
				    (_errno != ENOBUFS && dst->errors > 10) ||
				    _errno == ENOENT) {
					wpa_supplicant_ctrl_iface_detach(
						priv, &dst->addr,
						dst->addrlen);
				}
			} else
				dst->errors = 0;
		}
		idx++;
	}
}


void wpa_supplicant_ctrl_iface_wait(struct ctrl_iface_priv *priv)
{
	char buf[256];
	int res;
	struct sockaddr_un from;
	socklen_t fromlen = sizeof(from);

	for (;;) {
		wpa_printf(MSG_DEBUG, "CTRL_IFACE - %s - wait for monitor to "
			   "attach", priv->wpa_s->ifname);
		eloop_wait_for_read_sock(priv->sock);

		res = recvfrom(priv->sock, buf, sizeof(buf) - 1, 0,
			       (struct sockaddr *) &from, &fromlen);
		if (res < 0) {
			perror("recvfrom(ctrl_iface)");
			continue;
		}
		buf[res] = '\0';

		if (os_strcmp(buf, "ATTACH") == 0) {
			/* handle ATTACH signal of first monitor interface */
			if (!wpa_supplicant_ctrl_iface_attach(priv, &from,
							      fromlen)) {
				sendto(priv->sock, "OK\n", 3, 0,
				       (struct sockaddr *) &from, fromlen);
				/* OK to continue */
				return;
			} else {
				sendto(priv->sock, "FAIL\n", 5, 0,
				       (struct sockaddr *) &from, fromlen);
			}
		} else {
			/* return FAIL for all other signals */
			sendto(priv->sock, "FAIL\n", 5, 0,
			       (struct sockaddr *) &from, fromlen);
		}
	}
}


/* Global ctrl_iface */

struct ctrl_iface_global_priv {
	struct wpa_global *global;
	int sock;
};


static void wpa_supplicant_global_ctrl_iface_receive(int sock, void *eloop_ctx,
						     void *sock_ctx)
{
	struct wpa_global *global = eloop_ctx;
	char buf[256];
	int res;
	struct sockaddr_un from;
	socklen_t fromlen = sizeof(from);
	char *reply;
	size_t reply_len;

	res = recvfrom(sock, buf, sizeof(buf) - 1, 0,
		       (struct sockaddr *) &from, &fromlen);
	if (res < 0) {
		perror("recvfrom(ctrl_iface)");
		return;
	}
	buf[res] = '\0';

	reply = wpa_supplicant_global_ctrl_iface_process(global, buf,
							 &reply_len);

	if (reply) {
		sendto(sock, reply, reply_len, 0, (struct sockaddr *) &from,
		       fromlen);
		os_free(reply);
	} else if (reply_len) {
		sendto(sock, "FAIL\n", 5, 0, (struct sockaddr *) &from,
		       fromlen);
	}
}


struct ctrl_iface_global_priv *
wpa_supplicant_global_ctrl_iface_init(struct wpa_global *global)
{
	struct ctrl_iface_global_priv *priv;
	struct sockaddr_un addr;

	priv = os_zalloc(sizeof(*priv));
	if (priv == NULL)
		return NULL;
	priv->global = global;
	priv->sock = -1;

	if (global->params.ctrl_interface == NULL)
		return priv;

#ifdef ANDROID
	priv->sock = android_get_control_socket(global->params.ctrl_interface);
	if (priv->sock >= 0)
		goto havesock;
#endif /* ANDROID */

	wpa_printf(MSG_DEBUG, "Global control interface '%s'",
		   global->params.ctrl_interface);

	priv->sock = socket(PF_UNIX, SOCK_DGRAM, 0);
	if (priv->sock < 0) {
		perror("socket(PF_UNIX)");
		goto fail;
	}

	os_memset(&addr, 0, sizeof(addr));
#if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
	addr.sun_len = sizeof(addr);
#endif /* __FreeBSD__ */
	addr.sun_family = AF_UNIX;
	os_strlcpy(addr.sun_path, global->params.ctrl_interface,
		   sizeof(addr.sun_path));
	if (bind(priv->sock, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
		perror("supp-global-ctrl-iface-init (will try fixup): "
		       "bind(PF_UNIX)");
		if (connect(priv->sock, (struct sockaddr *) &addr,
			    sizeof(addr)) < 0) {
			wpa_printf(MSG_DEBUG, "ctrl_iface exists, but does not"
				   " allow connections - assuming it was left"
				   "over from forced program termination");
			if (unlink(global->params.ctrl_interface) < 0) {
				perror("unlink[ctrl_iface]");
				wpa_printf(MSG_ERROR, "Could not unlink "
					   "existing ctrl_iface socket '%s'",
					   global->params.ctrl_interface);
				goto fail;
			}
			if (bind(priv->sock, (struct sockaddr *) &addr,
				 sizeof(addr)) < 0) {
				perror("supp-glb-iface-init: bind(PF_UNIX)");
				goto fail;
			}
			wpa_printf(MSG_DEBUG, "Successfully replaced leftover "
				   "ctrl_iface socket '%s'",
				   global->params.ctrl_interface);
		} else {
			wpa_printf(MSG_INFO, "ctrl_iface exists and seems to "
				   "be in use - cannot override it");
			wpa_printf(MSG_INFO, "Delete '%s' manually if it is "
				   "not used anymore",
				   global->params.ctrl_interface);
			goto fail;
		}
	}

#ifdef ANDROID
havesock:
#endif /* ANDROID */
	eloop_register_read_sock(priv->sock,
				 wpa_supplicant_global_ctrl_iface_receive,
				 global, NULL);

	return priv;

fail:
	if (priv->sock >= 0)
		close(priv->sock);
	os_free(priv);
	return NULL;
}


void
wpa_supplicant_global_ctrl_iface_deinit(struct ctrl_iface_global_priv *priv)
{
	if (priv->sock >= 0) {
		eloop_unregister_read_sock(priv->sock);
		close(priv->sock);
	}
	if (priv->global->params.ctrl_interface)
		unlink(priv->global->params.ctrl_interface);
	os_free(priv);
}
Commit	Line	Data
6fc6879b JM	1	/*
6fc6879b JM	2	* WPA Supplicant / UNIX domain socket -based control interface
09e47a07	3	* Copyright (c) 2004-2009, Jouni Malinen <j@w1.fi>
6fc6879b	4	*
0f3d578e JM	5	* This software may be distributed under the terms of the BSD license.
0f3d578e JM	6	* See README for more details.
6fc6879b JM	7	*/
	8
	9	#include "includes.h"
	10	#include <sys/un.h>
	11	#include <sys/stat.h>
	12	#include <grp.h>
19b9436c	13	#include <stddef.h>
4fdc8def BG	14	#include <unistd.h>
4fdc8def BG	15	#include <fcntl.h>
b3f3865e DS	16	#ifdef ANDROID
	17	#include <cutils/sockets.h>
	18	#endif /* ANDROID */
6fc6879b	19
09e47a07 JM	20	#include "utils/common.h"
	21	#include "utils/eloop.h"
	22	#include "utils/list.h"
6fc6879b	23	#include "eapol_supp/eapol_supp_sm.h"
09e47a07	24	#include "config.h"
6fc6879b JM	25	#include "wpa_supplicant_i.h"
	26	#include "ctrl_iface.h"
	27
	28	/* Per-interface ctrl_iface */
	29
	30	/**
	31	* struct wpa_ctrl_dst - Internal data structure of control interface monitors
	32	*
	33	* This structure is used to store information about registered control
	34	* interface monitors into struct wpa_supplicant. This data is private to
	35	* ctrl_iface_unix.c and should not be touched directly from other files.
	36	*/
	37	struct wpa_ctrl_dst {
09e47a07	38	struct dl_list list;
6fc6879b JM	39	struct sockaddr_un addr;
	40	socklen_t addrlen;
	41	int debug_level;
	42	int errors;
	43	};
	44
	45
	46	struct ctrl_iface_priv {
	47	struct wpa_supplicant *wpa_s;
	48	int sock;
09e47a07	49	struct dl_list ctrl_dst;
6fc6879b JM	50	};
	51
	52
	53	static void wpa_supplicant_ctrl_iface_send(struct ctrl_iface_priv *priv,
	54	int level, const char *buf,
	55	size_t len);
	56
	57
	58	static int wpa_supplicant_ctrl_iface_attach(struct ctrl_iface_priv *priv,
	59	struct sockaddr_un *from,
	60	socklen_t fromlen)
	61	{
	62	struct wpa_ctrl_dst *dst;
	63
	64	dst = os_zalloc(sizeof(*dst));
	65	if (dst == NULL)
	66	return -1;
	67	os_memcpy(&dst->addr, from, sizeof(struct sockaddr_un));
	68	dst->addrlen = fromlen;
	69	dst->debug_level = MSG_INFO;
09e47a07	70	dl_list_add(&priv->ctrl_dst, &dst->list);
6fc6879b	71	wpa_hexdump(MSG_DEBUG, "CTRL_IFACE monitor attached",
19b9436c SL	72	(u8 *) from->sun_path,
19b9436c SL	73	fromlen - offsetof(struct sockaddr_un, sun_path));
6fc6879b JM	74	return 0;
	75	}
	76
	77
	78	static int wpa_supplicant_ctrl_iface_detach(struct ctrl_iface_priv *priv,
	79	struct sockaddr_un *from,
	80	socklen_t fromlen)
	81	{
09e47a07	82	struct wpa_ctrl_dst *dst;
6fc6879b	83
09e47a07	84	dl_list_for_each(dst, &priv->ctrl_dst, struct wpa_ctrl_dst, list) {
6fc6879b JM	85	if (fromlen == dst->addrlen &&
6fc6879b JM	86	os_memcmp(from->sun_path, dst->addr.sun_path,
19b9436c SL	87	fromlen - offsetof(struct sockaddr_un, sun_path))
19b9436c SL	88	== 0) {
09e47a07	89	dl_list_del(&dst->list);
6fc6879b JM	90	os_free(dst);
	91	wpa_hexdump(MSG_DEBUG, "CTRL_IFACE monitor detached",
	92	(u8 *) from->sun_path,
19b9436c SL	93	fromlen -
19b9436c SL	94	offsetof(struct sockaddr_un, sun_path));
6fc6879b JM	95	return 0;
6fc6879b JM	96	}
6fc6879b JM	97	}
	98	return -1;
	99	}
	100
	101
	102	static int wpa_supplicant_ctrl_iface_level(struct ctrl_iface_priv *priv,
	103	struct sockaddr_un *from,
	104	socklen_t fromlen,
	105	char *level)
	106	{
	107	struct wpa_ctrl_dst *dst;
	108
	109	wpa_printf(MSG_DEBUG, "CTRL_IFACE LEVEL %s", level);
	110
09e47a07	111	dl_list_for_each(dst, &priv->ctrl_dst, struct wpa_ctrl_dst, list) {
6fc6879b JM	112	if (fromlen == dst->addrlen &&
6fc6879b JM	113	os_memcmp(from->sun_path, dst->addr.sun_path,
19b9436c SL	114	fromlen - offsetof(struct sockaddr_un, sun_path))
19b9436c SL	115	== 0) {
6fc6879b JM	116	wpa_hexdump(MSG_DEBUG, "CTRL_IFACE changed monitor "
6fc6879b JM	117	"level", (u8 *) from->sun_path,
19b9436c SL	118	fromlen -
19b9436c SL	119	offsetof(struct sockaddr_un, sun_path));
6fc6879b JM	120	dst->debug_level = atoi(level);
	121	return 0;
	122	}
6fc6879b JM	123	}
	124
	125	return -1;
	126	}
	127
	128
	129	static void wpa_supplicant_ctrl_iface_receive(int sock, void *eloop_ctx,
	130	void *sock_ctx)
	131	{
	132	struct wpa_supplicant *wpa_s = eloop_ctx;
	133	struct ctrl_iface_priv *priv = sock_ctx;
b563b388	134	char buf[4096];
6fc6879b JM	135	int res;
	136	struct sockaddr_un from;
	137	socklen_t fromlen = sizeof(from);
	138	char *reply = NULL;
	139	size_t reply_len = 0;
	140	int new_attached = 0;
	141
	142	res = recvfrom(sock, buf, sizeof(buf) - 1, 0,
	143	(struct sockaddr *) &from, &fromlen);
	144	if (res < 0) {
	145	perror("recvfrom(ctrl_iface)");
	146	return;
	147	}
	148	buf[res] = '\0';
	149
	150	if (os_strcmp(buf, "ATTACH") == 0) {
	151	if (wpa_supplicant_ctrl_iface_attach(priv, &from, fromlen))
	152	reply_len = 1;
	153	else {
	154	new_attached = 1;
	155	reply_len = 2;
	156	}
	157	} else if (os_strcmp(buf, "DETACH") == 0) {
	158	if (wpa_supplicant_ctrl_iface_detach(priv, &from, fromlen))
	159	reply_len = 1;
	160	else
	161	reply_len = 2;
	162	} else if (os_strncmp(buf, "LEVEL ", 6) == 0) {
	163	if (wpa_supplicant_ctrl_iface_level(priv, &from, fromlen,
	164	buf + 6))
	165	reply_len = 1;
	166	else
	167	reply_len = 2;
	168	} else {
	169	reply = wpa_supplicant_ctrl_iface_process(wpa_s, buf,
	170	&reply_len);
	171	}
	172
	173	if (reply) {
	174	sendto(sock, reply, reply_len, 0, (struct sockaddr *) &from,
	175	fromlen);
	176	os_free(reply);
	177	} else if (reply_len == 1) {
	178	sendto(sock, "FAIL\n", 5, 0, (struct sockaddr *) &from,
	179	fromlen);
	180	} else if (reply_len == 2) {
	181	sendto(sock, "OK\n", 3, 0, (struct sockaddr *) &from,
	182	fromlen);
	183	}
	184
	185	if (new_attached)
	186	eapol_sm_notify_ctrl_attached(wpa_s->eapol);
	187	}
	188
	189
	190	static char * wpa_supplicant_ctrl_iface_path(struct wpa_supplicant *wpa_s)
	191	{
	192	char *buf;
	193	size_t len;
	194	char pbuf, dir = NULL, *gid_str = NULL;
	195	int res;
	196
	197	if (wpa_s->conf->ctrl_interface == NULL)
	198	return NULL;
199
200	pbuf = os_strdup(wpa_s->conf->ctrl_interface);
201	if (pbuf == NULL)
202	return NULL;
203	if (os_strncmp(pbuf, "DIR=", 4) == 0) {
204	dir = pbuf + 4;
205	gid_str = os_strstr(dir, " GROUP=");
206	if (gid_str) {
207	*gid_str = '\0';
208	gid_str += 7;
209	}
210	} else
211	dir = pbuf;
212
213	len = os_strlen(dir) + os_strlen(wpa_s->ifname) + 2;
214	buf = os_malloc(len);
215	if (buf == NULL) {
216	os_free(pbuf);
217	return NULL;
218	}
219
220	res = os_snprintf(buf, len, "%s/%s", dir, wpa_s->ifname);
221	if (res < 0 \|\| (size_t) res >= len) {
222	os_free(pbuf);
223	os_free(buf);
224	return NULL;
225	}
226	#ifdef __CYGWIN__
227	{
228	/* Windows/WinPcap uses interface names that are not suitable
229	* as a file name - convert invalid chars to underscores */
230	char *pos = buf;
231	while (*pos) {
232	if (*pos == '\\')
233	*pos = '_';
234	pos++;
235	}
236	}
237	#endif /* __CYGWIN__ */
238	os_free(pbuf);
239	return buf;
240	}
241
242
243	static void wpa_supplicant_ctrl_iface_msg_cb(void *ctx, int level,
244	const char *txt, size_t len)
245	{
246	struct wpa_supplicant *wpa_s = ctx;
247	if (wpa_s == NULL \|\| wpa_s->ctrl_iface == NULL)
248	return;
249	wpa_supplicant_ctrl_iface_send(wpa_s->ctrl_iface, level, txt, len);
250	}
251
252
253	struct ctrl_iface_priv *
254	wpa_supplicant_ctrl_iface_init(struct wpa_supplicant *wpa_s)
255	{
256	struct ctrl_iface_priv *priv;
257	struct sockaddr_un addr;
258	char *fname = NULL;
259	gid_t gid = 0;
260	int gid_set = 0;
261	char buf, dir = NULL, *gid_str = NULL;
262	struct group *grp;
263	char *endp;
4fdc8def	264	int flags;
6fc6879b JM	265
	266	priv = os_zalloc(sizeof(*priv));
	267	if (priv == NULL)
	268	return NULL;
09e47a07	269	dl_list_init(&priv->ctrl_dst);
6fc6879b JM	270	priv->wpa_s = wpa_s;
	271	priv->sock = -1;
	272
	273	if (wpa_s->conf->ctrl_interface == NULL)
	274	return priv;
	275
	276	buf = os_strdup(wpa_s->conf->ctrl_interface);
	277	if (buf == NULL)
	278	goto fail;
b3f3865e DS	279	#ifdef ANDROID
	280	os_snprintf(addr.sun_path, sizeof(addr.sun_path), "wpa_%s",
	281	wpa_s->conf->ctrl_interface);
	282	priv->sock = android_get_control_socket(addr.sun_path);
	283	if (priv->sock >= 0)
	284	goto havesock;
	285	#endif /* ANDROID */
6fc6879b JM	286	if (os_strncmp(buf, "DIR=", 4) == 0) {
	287	dir = buf + 4;
	288	gid_str = os_strstr(dir, " GROUP=");
	289	if (gid_str) {
	290	*gid_str = '\0';
	291	gid_str += 7;
	292	}
	293	} else {
	294	dir = buf;
	295	gid_str = wpa_s->conf->ctrl_interface_group;
	296	}
	297
	298	if (mkdir(dir, S_IRWXU \| S_IRWXG) < 0) {
	299	if (errno == EEXIST) {
	300	wpa_printf(MSG_DEBUG, "Using existing control "
	301	"interface directory.");
	302	} else {
	303	perror("mkdir[ctrl_interface]");
	304	goto fail;
	305	}
	306	}
	307
d49ea682 JM	308	#ifdef ANDROID
	309	/*
	310	* wpa_supplicant is started from /init.*.rc on Android and that seems
	311	* to be using umask 0077 which would leave the control interface
	312	* directory without group access. This breaks things since Wi-Fi
	313	* framework assumes that this directory can be accessed by other
	314	* applications in the wifi group. Fix this by adding group access even
	315	* if umask value would prevent this.
	316	*/
	317	if (chmod(dir, S_IRWXU \| S_IRWXG) < 0) {
	318	wpa_printf(MSG_ERROR, "CTRL: Could not chmod directory: %s",
	319	strerror(errno));
	320	/* Try to continue anyway */
	321	}
	322	#endif /* ANDROID */
	323
6fc6879b JM	324	if (gid_str) {
	325	grp = getgrnam(gid_str);
	326	if (grp) {
	327	gid = grp->gr_gid;
	328	gid_set = 1;
	329	wpa_printf(MSG_DEBUG, "ctrl_interface_group=%d"
	330	" (from group name '%s')",
	331	(int) gid, gid_str);
	332	} else {
	333	/* Group name not found - try to parse this as gid */
	334	gid = strtol(gid_str, &endp, 10);
	335	if (gid_str == '\0' \|\| endp != '\0') {
8e888179	336	wpa_printf(MSG_ERROR, "CTRL: Invalid group "
6fc6879b JM	337	"'%s'", gid_str);
	338	goto fail;
	339	}
	340	gid_set = 1;
	341	wpa_printf(MSG_DEBUG, "ctrl_interface_group=%d",
	342	(int) gid);
	343	}
	344	}
	345
	346	if (gid_set && chown(dir, -1, gid) < 0) {
	347	perror("chown[ctrl_interface]");
	348	goto fail;
	349	}
	350
3fd2a226 AAS	351	/* Make sure the group can enter and read the directory */
	352	if (gid_set &&
	353	chmod(dir, S_IRUSR \| S_IWUSR \| S_IXUSR \| S_IRGRP \| S_IXGRP) < 0) {
	354	wpa_printf(MSG_ERROR, "CTRL: chmod[ctrl_interface]: %s",
	355	strerror(errno));
	356	goto fail;
	357	}
	358
6fc6879b JM	359	if (os_strlen(dir) + 1 + os_strlen(wpa_s->ifname) >=
	360	sizeof(addr.sun_path)) {
	361	wpa_printf(MSG_ERROR, "ctrl_iface path limit exceeded");
	362	goto fail;
	363	}
	364
	365	priv->sock = socket(PF_UNIX, SOCK_DGRAM, 0);
	366	if (priv->sock < 0) {
	367	perror("socket(PF_UNIX)");
	368	goto fail;
	369	}
	370
	371	os_memset(&addr, 0, sizeof(addr));
09bd6e8c	372	#if defined(__FreeBSD__) \|\| defined(__FreeBSD_kernel__)
19b9436c SL	373	addr.sun_len = sizeof(addr);
19b9436c SL	374	#endif /* __FreeBSD__ */
6fc6879b JM	375	addr.sun_family = AF_UNIX;
	376	fname = wpa_supplicant_ctrl_iface_path(wpa_s);
	377	if (fname == NULL)
	378	goto fail;
	379	os_strlcpy(addr.sun_path, fname, sizeof(addr.sun_path));
	380	if (bind(priv->sock, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
	381	wpa_printf(MSG_DEBUG, "ctrl_iface bind(PF_UNIX) failed: %s",
	382	strerror(errno));
	383	if (connect(priv->sock, (struct sockaddr *) &addr,
	384	sizeof(addr)) < 0) {
	385	wpa_printf(MSG_DEBUG, "ctrl_iface exists, but does not"
	386	" allow connections - assuming it was left"
	387	"over from forced program termination");
	388	if (unlink(fname) < 0) {
	389	perror("unlink[ctrl_iface]");
	390	wpa_printf(MSG_ERROR, "Could not unlink "
	391	"existing ctrl_iface socket '%s'",
	392	fname);
	393	goto fail;
	394	}
	395	if (bind(priv->sock, (struct sockaddr *) &addr,
	396	sizeof(addr)) < 0) {
9d053747	397	perror("supp-ctrl-iface-init: bind(PF_UNIX)");
6fc6879b JM	398	goto fail;
	399	}
	400	wpa_printf(MSG_DEBUG, "Successfully replaced leftover "
	401	"ctrl_iface socket '%s'", fname);
	402	} else {
	403	wpa_printf(MSG_INFO, "ctrl_iface exists and seems to "
	404	"be in use - cannot override it");
	405	wpa_printf(MSG_INFO, "Delete '%s' manually if it is "
	406	"not used anymore", fname);
	407	os_free(fname);
	408	fname = NULL;
	409	goto fail;
	410	}
	411	}
	412
	413	if (gid_set && chown(fname, -1, gid) < 0) {
	414	perror("chown[ctrl_interface/ifname]");
	415	goto fail;
	416	}
	417
	418	if (chmod(fname, S_IRWXU \| S_IRWXG) < 0) {
	419	perror("chmod[ctrl_interface/ifname]");
	420	goto fail;
	421	}
	422	os_free(fname);
	423
b3f3865e DS	424	#ifdef ANDROID
	425	havesock:
	426	#endif /* ANDROID */
4fdc8def BG	427
	428	/*
	429	* Make socket non-blocking so that we don't hang forever if
	430	* target dies unexpectedly.
	431	*/
	432	flags = fcntl(priv->sock, F_GETFL);
	433	if (flags >= 0) {
	434	flags \|= O_NONBLOCK;
	435	if (fcntl(priv->sock, F_SETFL, flags) < 0) {
	436	perror("fcntl(ctrl, O_NONBLOCK)");
	437	/* Not fatal, continue on.*/
	438	}
	439	}
	440
6fc6879b JM	441	eloop_register_read_sock(priv->sock, wpa_supplicant_ctrl_iface_receive,
	442	wpa_s, priv);
	443	wpa_msg_register_cb(wpa_supplicant_ctrl_iface_msg_cb);
	444
	445	os_free(buf);
	446	return priv;
	447
	448	fail:
	449	if (priv->sock >= 0)
	450	close(priv->sock);
	451	os_free(priv);
	452	if (fname) {
	453	unlink(fname);
	454	os_free(fname);
	455	}
	456	os_free(buf);
	457	return NULL;
	458	}
	459
	460
	461	void wpa_supplicant_ctrl_iface_deinit(struct ctrl_iface_priv *priv)
	462	{
	463	struct wpa_ctrl_dst dst, prev;
	464
	465	if (priv->sock > -1) {
	466	char *fname;
	467	char buf, dir = NULL, *gid_str = NULL;
	468	eloop_unregister_read_sock(priv->sock);
09e47a07	469	if (!dl_list_empty(&priv->ctrl_dst)) {
6fc6879b JM	470	/*
	471	* Wait a second before closing the control socket if
	472	* there are any attached monitors in order to allow
	473	* them to receive any pending messages.
	474	*/
	475	wpa_printf(MSG_DEBUG, "CTRL_IFACE wait for attached "
	476	"monitors to receive messages");
	477	os_sleep(1, 0);
	478	}
	479	close(priv->sock);
	480	priv->sock = -1;
	481	fname = wpa_supplicant_ctrl_iface_path(priv->wpa_s);
	482	if (fname) {
	483	unlink(fname);
	484	os_free(fname);
	485	}
	486
	487	buf = os_strdup(priv->wpa_s->conf->ctrl_interface);
	488	if (buf == NULL)
	489	goto free_dst;
	490	if (os_strncmp(buf, "DIR=", 4) == 0) {
	491	dir = buf + 4;
	492	gid_str = os_strstr(dir, " GROUP=");
	493	if (gid_str) {
	494	*gid_str = '\0';
	495	gid_str += 7;
	496	}
	497	} else
	498	dir = buf;
	499
	500	if (rmdir(dir) < 0) {
	501	if (errno == ENOTEMPTY) {
	502	wpa_printf(MSG_DEBUG, "Control interface "
	503	"directory not empty - leaving it "
	504	"behind");
	505	} else {
	506	perror("rmdir[ctrl_interface]");
	507	}
	508	}
	509	os_free(buf);
	510	}
	511
	512	free_dst:
09e47a07 JM	513	dl_list_for_each_safe(dst, prev, &priv->ctrl_dst, struct wpa_ctrl_dst,
	514	list)
	515	os_free(dst);
6fc6879b JM	516	os_free(priv);
	517	}
	518
	519
	520	/**
	521	* wpa_supplicant_ctrl_iface_send - Send a control interface packet to monitors
	522	* @priv: Pointer to private data from wpa_supplicant_ctrl_iface_init()
	523	* @level: Priority level of the message
	524	* @buf: Message data
	525	* @len: Message length
	526	*
	527	* Send a packet to all monitor programs attached to the control interface.
	528	*/
	529	static void wpa_supplicant_ctrl_iface_send(struct ctrl_iface_priv *priv,
	530	int level, const char *buf,
	531	size_t len)
	532	{
	533	struct wpa_ctrl_dst dst, next;
	534	char levelstr[10];
	535	int idx, res;
	536	struct msghdr msg;
	537	struct iovec io[2];
	538
09e47a07	539	if (priv->sock < 0 \|\| dl_list_empty(&priv->ctrl_dst))
6fc6879b JM	540	return;
	541
	542	res = os_snprintf(levelstr, sizeof(levelstr), "<%d>", level);
	543	if (res < 0 \|\| (size_t) res >= sizeof(levelstr))
	544	return;
	545	io[0].iov_base = levelstr;
	546	io[0].iov_len = os_strlen(levelstr);
	547	io[1].iov_base = (char *) buf;
	548	io[1].iov_len = len;
	549	os_memset(&msg, 0, sizeof(msg));
	550	msg.msg_iov = io;
	551	msg.msg_iovlen = 2;
	552
	553	idx = 0;
09e47a07 JM	554	dl_list_for_each_safe(dst, next, &priv->ctrl_dst, struct wpa_ctrl_dst,
09e47a07 JM	555	list) {
6fc6879b JM	556	if (level >= dst->debug_level) {
	557	wpa_hexdump(MSG_DEBUG, "CTRL_IFACE monitor send",
	558	(u8 *) dst->addr.sun_path, dst->addrlen -
19b9436c	559	offsetof(struct sockaddr_un, sun_path));
6fc6879b JM	560	msg.msg_name = (void *) &dst->addr;
	561	msg.msg_namelen = dst->addrlen;
	562	if (sendmsg(priv->sock, &msg, 0) < 0) {
c5aaa015 JM	563	int _errno = errno;
	564	wpa_printf(MSG_INFO, "CTRL_IFACE monitor[%d]: "
	565	"%d - %s",
	566	idx, errno, strerror(errno));
6fc6879b	567	dst->errors++;
6700a277 JM	568	if (dst->errors > 1000 \|\|
	569	(_errno != ENOBUFS && dst->errors > 10) \|\|
	570	_errno == ENOENT) {
6fc6879b JM	571	wpa_supplicant_ctrl_iface_detach(
	572	priv, &dst->addr,
	573	dst->addrlen);
	574	}
	575	} else
	576	dst->errors = 0;
	577	}
	578	idx++;
6fc6879b JM	579	}
	580	}
	581
	582
	583	void wpa_supplicant_ctrl_iface_wait(struct ctrl_iface_priv *priv)
	584	{
	585	char buf[256];
	586	int res;
	587	struct sockaddr_un from;
	588	socklen_t fromlen = sizeof(from);
	589
	590	for (;;) {
	591	wpa_printf(MSG_DEBUG, "CTRL_IFACE - %s - wait for monitor to "
	592	"attach", priv->wpa_s->ifname);
	593	eloop_wait_for_read_sock(priv->sock);
	594
	595	res = recvfrom(priv->sock, buf, sizeof(buf) - 1, 0,
	596	(struct sockaddr *) &from, &fromlen);
	597	if (res < 0) {
	598	perror("recvfrom(ctrl_iface)");
	599	continue;
	600	}
	601	buf[res] = '\0';
	602
	603	if (os_strcmp(buf, "ATTACH") == 0) {
	604	/* handle ATTACH signal of first monitor interface */
	605	if (!wpa_supplicant_ctrl_iface_attach(priv, &from,
	606	fromlen)) {
	607	sendto(priv->sock, "OK\n", 3, 0,
	608	(struct sockaddr *) &from, fromlen);
	609	/* OK to continue */
	610	return;
	611	} else {
	612	sendto(priv->sock, "FAIL\n", 5, 0,
	613	(struct sockaddr *) &from, fromlen);
	614	}
	615	} else {
	616	/* return FAIL for all other signals */
	617	sendto(priv->sock, "FAIL\n", 5, 0,
	618	(struct sockaddr *) &from, fromlen);
	619	}
	620	}
	621	}
	622
	623
	624	/* Global ctrl_iface */
	625
	626	struct ctrl_iface_global_priv {
	627	struct wpa_global *global;
	628	int sock;
	629	};
	630
	631
	632	static void wpa_supplicant_global_ctrl_iface_receive(int sock, void *eloop_ctx,
	633	void *sock_ctx)
	634	{
	635	struct wpa_global *global = eloop_ctx;
	636	char buf[256];
	637	int res;
	638	struct sockaddr_un from;
	639	socklen_t fromlen = sizeof(from);
	640	char *reply;
	641	size_t reply_len;
	642
643	res = recvfrom(sock, buf, sizeof(buf) - 1, 0,
644	(struct sockaddr *) &from, &fromlen);
645	if (res < 0) {
646	perror("recvfrom(ctrl_iface)");
647	return;
648	}
649	buf[res] = '\0';
650
651	reply = wpa_supplicant_global_ctrl_iface_process(global, buf,
652	&reply_len);
653
654	if (reply) {
655	sendto(sock, reply, reply_len, 0, (struct sockaddr *) &from,
656	fromlen);
657	os_free(reply);
658	} else if (reply_len) {
659	sendto(sock, "FAIL\n", 5, 0, (struct sockaddr *) &from,
660	fromlen);
661	}
662	}
663
664
665	struct ctrl_iface_global_priv *
666	wpa_supplicant_global_ctrl_iface_init(struct wpa_global *global)
667	{
668	struct ctrl_iface_global_priv *priv;
669	struct sockaddr_un addr;
670
671	priv = os_zalloc(sizeof(*priv));
672	if (priv == NULL)
673	return NULL;
674	priv->global = global;
675	priv->sock = -1;
676
677	if (global->params.ctrl_interface == NULL)
678	return priv;
679
b3f3865e DS	680	#ifdef ANDROID
	681	priv->sock = android_get_control_socket(global->params.ctrl_interface);
	682	if (priv->sock >= 0)
	683	goto havesock;
	684	#endif /* ANDROID */
	685
6fc6879b JM	686	wpa_printf(MSG_DEBUG, "Global control interface '%s'",
	687	global->params.ctrl_interface);
	688
	689	priv->sock = socket(PF_UNIX, SOCK_DGRAM, 0);
	690	if (priv->sock < 0) {
	691	perror("socket(PF_UNIX)");
	692	goto fail;
	693	}
	694
	695	os_memset(&addr, 0, sizeof(addr));
09bd6e8c	696	#if defined(__FreeBSD__) \|\| defined(__FreeBSD_kernel__)
19b9436c SL	697	addr.sun_len = sizeof(addr);
19b9436c SL	698	#endif /* __FreeBSD__ */
6fc6879b JM	699	addr.sun_family = AF_UNIX;
	700	os_strlcpy(addr.sun_path, global->params.ctrl_interface,
	701	sizeof(addr.sun_path));
	702	if (bind(priv->sock, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
9d053747 BG	703	perror("supp-global-ctrl-iface-init (will try fixup): "
9d053747 BG	704	"bind(PF_UNIX)");
6fc6879b JM	705	if (connect(priv->sock, (struct sockaddr *) &addr,
	706	sizeof(addr)) < 0) {
	707	wpa_printf(MSG_DEBUG, "ctrl_iface exists, but does not"
	708	" allow connections - assuming it was left"
	709	"over from forced program termination");
	710	if (unlink(global->params.ctrl_interface) < 0) {
	711	perror("unlink[ctrl_iface]");
	712	wpa_printf(MSG_ERROR, "Could not unlink "
	713	"existing ctrl_iface socket '%s'",
	714	global->params.ctrl_interface);
	715	goto fail;
	716	}
	717	if (bind(priv->sock, (struct sockaddr *) &addr,
	718	sizeof(addr)) < 0) {
9d053747	719	perror("supp-glb-iface-init: bind(PF_UNIX)");
6fc6879b JM	720	goto fail;
	721	}
	722	wpa_printf(MSG_DEBUG, "Successfully replaced leftover "
	723	"ctrl_iface socket '%s'",
	724	global->params.ctrl_interface);
	725	} else {
	726	wpa_printf(MSG_INFO, "ctrl_iface exists and seems to "
	727	"be in use - cannot override it");
	728	wpa_printf(MSG_INFO, "Delete '%s' manually if it is "
	729	"not used anymore",
	730	global->params.ctrl_interface);
	731	goto fail;
	732	}
	733	}
	734
b3f3865e DS	735	#ifdef ANDROID
	736	havesock:
	737	#endif /* ANDROID */
6fc6879b JM	738	eloop_register_read_sock(priv->sock,
	739	wpa_supplicant_global_ctrl_iface_receive,
	740	global, NULL);
	741
	742	return priv;
	743
	744	fail:
	745	if (priv->sock >= 0)
	746	close(priv->sock);
	747	os_free(priv);
	748	return NULL;
	749	}
	750
	751
	752	void
	753	wpa_supplicant_global_ctrl_iface_deinit(struct ctrl_iface_global_priv *priv)
	754	{
	755	if (priv->sock >= 0) {
	756	eloop_unregister_read_sock(priv->sock);
	757	close(priv->sock);
	758	}
	759	if (priv->global->params.ctrl_interface)
	760	unlink(priv->global->params.ctrl_interface);
	761	os_free(priv);
	762	}