xref: /dragonfly/usr.sbin/bthcid/client.c (revision e293de53) 
1 /* $NetBSD: client.c,v 1.4 2006/09/29 20:06:11 plunky Exp $ */
2 /* $DragonFly: src/usr.sbin/bthcid/client.c,v 1.1 2008/01/30 14:10:19 hasso Exp $ */
3 
4 /*-
5  * Copyright (c) 2006 Itronix Inc.
6  * All rights reserved.
7  *
8  * Redistribution and use in source and binary forms, with or without
9  * modification, are permitted provided that the following conditions
10  * are met:
11  * 1. Redistributions of source code must retain the above copyright
12  *    notice, this list of conditions and the following disclaimer.
13  * 2. Redistributions in binary form must reproduce the above copyright
14  *    notice, this list of conditions and the following disclaimer in the
15  *    documentation and/or other materials provided with the distribution.
16  * 3. The name of Itronix Inc. may not be used to endorse
17  *    or promote products derived from this software without specific
18  *    prior written permission.
19  *
20  * THIS SOFTWARE IS PROVIDED BY ITRONIX INC. ``AS IS'' AND
21  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
22  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
23  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL ITRONIX INC. BE LIABLE FOR ANY
24  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
25  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
26  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
27  * ON ANY THEORY OF LIABILITY, WHETHER IN
28  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
29  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
30  * POSSIBILITY OF SUCH DAMAGE.
31  */
32 
33 #include <sys/ioctl.h>
34 #include <sys/queue.h>
35 #include <sys/time.h>
36 #include <sys/un.h>
37 #include <bluetooth.h>
38 #include <errno.h>
39 #include <event.h>
40 #include <fcntl.h>
41 #include <stdlib.h>
42 #include <string.h>
43 #include <syslog.h>
44 #include <unistd.h>
45 
46 #include "bthcid.h"
47 
48 /*
49  * A client is anybody who connects to our control socket to
50  * receive PIN requests.
51  */
52 struct client {
53 	struct event		ev;
54 	int			fd;		/* client descriptor */
55 	LIST_ENTRY(client)	next;
56 };
57 
58 /*
59  * PIN cache items are made when we have sent a client pin
60  * request. The event is used to expire the item.
61  */
62 struct item {
63 	struct event	 ev;
64 	bdaddr_t	 laddr;			/* local device BDADDR */
65 	bdaddr_t	 raddr;			/* remote device BDADDR */
66 	uint8_t		 pin[HCI_PIN_SIZE];	/* PIN */
67 	int		 hci;			/* HCI socket */
68 	LIST_ENTRY(item) next;
69 };
70 
71 static struct event		control_ev;
72 
73 static LIST_HEAD(,client)	client_list;
74 static LIST_HEAD(,item)		item_list;
75 
76 static void process_control	(int, short, void *);
77 static void process_client	(int, short, void *);
78 static void process_item	(int, short, void *);
79 
80 #define PIN_REQUEST_TIMEOUT	30	/* Request is valid */
81 #define PIN_TIMEOUT		300	/* PIN is valid */
82 
83 int
84 init_control(const char *name, mode_t mode)
85 {
86 	struct sockaddr_un	un;
87 	int			ctl;
88 
89 	LIST_INIT(&client_list);
90 	LIST_INIT(&item_list);
91 
92 	if (name == NULL)
93 		return 0;
94 
95 	if (unlink(name) < 0 && errno != ENOENT)
96 		return -1;
97 
98 	ctl = socket(PF_LOCAL, SOCK_STREAM, 0);
99 	if (ctl < 0)
100 		return -1;
101 
102 	memset(&un, 0, sizeof(un));
103 	un.sun_len = sizeof(un);
104 	un.sun_family = AF_LOCAL;
105 	strlcpy(un.sun_path, name, sizeof(un.sun_path));
106 	if (bind(ctl, (struct sockaddr *)&un, sizeof(un)) < 0) {
107 		close(ctl);
108 		return -1;
109 	}
110 
111 	if (chmod(name, mode) < 0) {
112 		close(ctl);
113 		unlink(name);
114 		return -1;
115 	}
116 
117 	if (listen(ctl, 10) < 0) {
118 		close(ctl);
119 		unlink(name);
120 		return -1;
121 	}
122 
123 	event_set(&control_ev, ctl, EV_READ | EV_PERSIST, process_control, NULL);
124 	if (event_add(&control_ev, NULL) < 0) {
125 		close(ctl);
126 		unlink(name);
127 		return -1;
128 	}
129 
130 	return 0;
131 }
132 
133 /* Process control socket event */
134 static void
135 process_control(int sock, short ev, void *arg)
136 {
137 	struct sockaddr_un	un;
138 	socklen_t		n;
139 	int			fd;
140 	struct client		*cl;
141 
142 	n = sizeof(un);
143 	fd = accept(sock, (struct sockaddr *)&un, &n);
144 	if (fd < 0) {
145 		syslog(LOG_ERR, "Could not accept PIN client connection");
146 		return;
147 	}
148 
149 	n = 1;
150 	if (ioctl(fd, FIONBIO, &n) < 0) {
151 		syslog(LOG_ERR, "Could not set non blocking IO for client");
152 		close(fd);
153 		return;
154 	}
155 
156 	cl = malloc(sizeof(struct client));
157 	if (cl == NULL) {
158 		syslog(LOG_ERR, "Could not malloc client");
159 		close(fd);
160 		return;
161 	}
162 
163 	memset(cl, 0, sizeof(struct client));
164 	cl->fd = fd;
165 
166 	event_set(&cl->ev, fd, EV_READ | EV_PERSIST, process_client, cl);
167 	if (event_add(&cl->ev, NULL) < 0) {
168 		syslog(LOG_ERR, "Could not add client event");
169 		free(cl);
170 		close(fd);
171 		return;
172 	}
173 
174 	syslog(LOG_DEBUG, "New Client");
175 	LIST_INSERT_HEAD(&client_list, cl, next);
176 }
177 
178 /* Process client response packet */
179 static void
180 process_client(int sock, short ev, void *arg)
181 {
182 	bthcid_pin_response_t	 rp;
183 	struct timeval		 tv;
184 	struct sockaddr_bt	 sa;
185 	struct client		*cl = arg;
186 	struct item		*item;
187 	int			 n;
188 
189 	n = recv(sock, &rp, sizeof(rp), 0);
190 	if (n != sizeof(rp)) {
191 		if (n != 0)
192 			syslog(LOG_ERR, "Bad Client");
193 
194 		close(sock);
195 		LIST_REMOVE(cl, next);
196 		free(cl);
197 
198 		syslog(LOG_DEBUG, "Client Closed");
199 		return;
200 	}
201 
202 	syslog(LOG_DEBUG, "Received PIN for %s", bt_ntoa(&rp.raddr, NULL));
203 
204 	LIST_FOREACH(item, &item_list, next) {
205 		if (bdaddr_same(&rp.laddr, &item->laddr) == 0
206 		    || bdaddr_same(&rp.raddr, &item->raddr) == 0)
207 			continue;
208 
209 		evtimer_del(&item->ev);
210 		if (item->hci != -1) {
211 			memset(&sa, 0, sizeof(sa));
212 			sa.bt_len = sizeof(sa);
213 			sa.bt_family = AF_BLUETOOTH;
214 			bdaddr_copy(&sa.bt_bdaddr, &item->laddr);
215 
216 			send_pin_code_reply(item->hci, &sa, &item->raddr, rp.pin);
217 			LIST_REMOVE(item, next);
218 			free(item);
219 			return;
220 		}
221 		goto newpin;
222 	}
223 
224 	item = malloc(sizeof(struct item));
225 	if (item == NULL) {
226 		syslog(LOG_ERR, "Item allocation failed");
227 		return;
228 	}
229 
230 	memset(item, 0, sizeof(struct item));
231 	bdaddr_copy(&item->laddr, &rp.laddr);
232 	bdaddr_copy(&item->raddr, &rp.raddr);
233 	evtimer_set(&item->ev, process_item, item);
234 	LIST_INSERT_HEAD(&item_list, item, next);
235 
236 newpin:
237 	syslog(LOG_DEBUG, "Caching PIN for %s", bt_ntoa(&rp.raddr, NULL));
238 
239 	memcpy(item->pin, rp.pin, HCI_PIN_SIZE);
240 	item->hci = -1;
241 
242 	tv.tv_sec = PIN_TIMEOUT;
243 	tv.tv_usec = 0;
244 
245 	if (evtimer_add(&item->ev, &tv) < 0) {
246 		syslog(LOG_ERR, "Cannot add event timer for item");
247 		LIST_REMOVE(item, next);
248 		free(item);
249 	}
250 }
251 
252 /* Send PIN request to client */
253 int
254 send_client_request(bdaddr_t *laddr, bdaddr_t *raddr, int hci)
255 {
256 	bthcid_pin_request_t	 cp;
257 	struct client		*cl;
258 	struct item		*item;
259 	int			 n = 0;
260 	struct timeval		 tv;
261 
262 	memset(&cp, 0, sizeof(cp));
263 	bdaddr_copy(&cp.laddr, laddr);
264 	bdaddr_copy(&cp.raddr, raddr);
265 	cp.time = PIN_REQUEST_TIMEOUT;
266 
267 	LIST_FOREACH(cl, &client_list, next) {
268 		if (send(cl->fd, &cp, sizeof(cp), 0) != sizeof(cp))
269 			syslog(LOG_ERR, "send PIN request failed");
270 		else
271 			n++;
272 	}
273 
274 	if (n == 0)
275 		return 0;
276 
277 	syslog(LOG_DEBUG, "Sent PIN requests to %d client%s.",
278 				n, (n == 1 ? "" : "s"));
279 
280 	item = malloc(sizeof(struct item));
281 	if (item == NULL) {
282 		syslog(LOG_ERR, "Cannot allocate PIN request item");
283 		return 0;
284 	}
285 
286 	memset(item, 0, sizeof(struct item));
287 	bdaddr_copy(&item->laddr, laddr);
288 	bdaddr_copy(&item->raddr, raddr);
289 	item->hci = hci;
290 	evtimer_set(&item->ev, process_item, item);
291 
292 	tv.tv_sec = cp.time;
293 	tv.tv_usec = 0;
294 
295 	if (evtimer_add(&item->ev, &tv) < 0) {
296 		syslog(LOG_ERR, "Cannot add request timer");
297 		free(item);
298 		return 0;
299 	}
300 
301 	LIST_INSERT_HEAD(&item_list, item, next);
302 	return 1;
303 }
304 
305 /* Process item event (by expiring it) */
306 static void
307 process_item(int fd, short ev, void *arg)
308 {
309 	struct item *item = arg;
310 
311 	syslog(LOG_DEBUG, "PIN for %s expired", bt_ntoa(&item->raddr, NULL));
312 	LIST_REMOVE(item, next);
313 	evtimer_del(&item->ev);
314 	free(item);
315 }
316 
317 /* lookup PIN in item cache */
318 uint8_t *
319 lookup_pin(bdaddr_t *laddr, bdaddr_t *raddr)
320 {
321 	static uint8_t pin[HCI_PIN_SIZE];
322 	struct item *item;
323 
324 	LIST_FOREACH(item, &item_list, next) {
325 		if (bdaddr_same(raddr, &item->raddr) == 0)
326 			continue;
327 
328 		if (bdaddr_same(laddr, &item->laddr) == 0
329 		    && bdaddr_any(&item->laddr) == 0)
330 			continue;
331 
332 		if (item->hci >= 0)
333 			break;
334 
335 		syslog(LOG_DEBUG, "Matched PIN from cache");
336 		memcpy(pin, item->pin, sizeof(pin));
337 
338 		LIST_REMOVE(item, next);
339 		evtimer_del(&item->ev);
340 		free(item);
341 
342 		return pin;
343 	}
344 
345 	return NULL;
346 }
347