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