xref: /dragonfly/usr.sbin/bthcid/client.c (revision dca3c15d) 
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/stat.h>
36 #include <sys/time.h>
37 #include <sys/un.h>
38 #include <bluetooth.h>
39 #include <errno.h>
40 #include <event.h>
41 #include <fcntl.h>
42 #include <stdlib.h>
43 #include <string.h>
44 #include <syslog.h>
45 #include <unistd.h>
46 
47 #include "bthcid.h"
48 
49 /*
50  * A client is anybody who connects to our control socket to
51  * receive PIN requests.
52  */
53 struct client {
54 	struct event		ev;
55 	int			fd;		/* client descriptor */
56 	LIST_ENTRY(client)	next;
57 };
58 
59 /*
60  * PIN cache items are made when we have sent a client pin
61  * request. The event is used to expire the item.
62  */
63 struct item {
64 	struct event	 ev;
65 	bdaddr_t	 laddr;			/* local device BDADDR */
66 	bdaddr_t	 raddr;			/* remote device BDADDR */
67 	uint8_t		 pin[HCI_PIN_SIZE];	/* PIN */
68 	int		 hci;			/* HCI socket */
69 	LIST_ENTRY(item) next;
70 };
71 
72 static struct event		control_ev;
73 
74 static LIST_HEAD(,client)	client_list;
75 static LIST_HEAD(,item)		item_list;
76 
77 static void process_control	(int, short, void *);
78 static void process_client	(int, short, void *);
79 static void process_item	(int, short, void *);
80 
81 #define PIN_REQUEST_TIMEOUT	30	/* Request is valid */
82 #define PIN_TIMEOUT		300	/* PIN is valid */
83 
84 int
85 init_control(const char *name, mode_t mode)
86 {
87 	struct sockaddr_un	un;
88 	int			ctl;
89 
90 	LIST_INIT(&client_list);
91 	LIST_INIT(&item_list);
92 
93 	if (name == NULL)
94 		return 0;
95 
96 	if (unlink(name) < 0 && errno != ENOENT)
97 		return -1;
98 
99 	ctl = socket(PF_LOCAL, SOCK_STREAM, 0);
100 	if (ctl < 0)
101 		return -1;
102 
103 	memset(&un, 0, sizeof(un));
104 	un.sun_len = sizeof(un);
105 	un.sun_family = AF_LOCAL;
106 	strlcpy(un.sun_path, name, sizeof(un.sun_path));
107 	if (bind(ctl, (struct sockaddr *)&un, sizeof(un)) < 0) {
108 		close(ctl);
109 		return -1;
110 	}
111 
112 	if (chmod(name, mode) < 0) {
113 		close(ctl);
114 		unlink(name);
115 		return -1;
116 	}
117 
118 	if (listen(ctl, 10) < 0) {
119 		close(ctl);
120 		unlink(name);
121 		return -1;
122 	}
123 
124 	event_set(&control_ev, ctl, EV_READ | EV_PERSIST, process_control, NULL);
125 	if (event_add(&control_ev, NULL) < 0) {
126 		close(ctl);
127 		unlink(name);
128 		return -1;
129 	}
130 
131 	return 0;
132 }
133 
134 /* Process control socket event */
135 static void
136 process_control(int sock, short ev __unused, void *arg __unused)
137 {
138 	struct sockaddr_un	un;
139 	socklen_t		n;
140 	int			fd;
141 	struct client		*cl;
142 
143 	n = sizeof(un);
144 	fd = accept(sock, (struct sockaddr *)&un, &n);
145 	if (fd < 0) {
146 		syslog(LOG_ERR, "Could not accept PIN client connection");
147 		return;
148 	}
149 
150 	n = 1;
151 	if (ioctl(fd, FIONBIO, &n) < 0) {
152 		syslog(LOG_ERR, "Could not set non blocking IO for client");
153 		close(fd);
154 		return;
155 	}
156 
157 	cl = malloc(sizeof(struct client));
158 	if (cl == NULL) {
159 		syslog(LOG_ERR, "Could not malloc client");
160 		close(fd);
161 		return;
162 	}
163 
164 	memset(cl, 0, sizeof(struct client));
165 	cl->fd = fd;
166 
167 	event_set(&cl->ev, fd, EV_READ | EV_PERSIST, process_client, cl);
168 	if (event_add(&cl->ev, NULL) < 0) {
169 		syslog(LOG_ERR, "Could not add client event");
170 		free(cl);
171 		close(fd);
172 		return;
173 	}
174 
175 	syslog(LOG_DEBUG, "New Client");
176 	LIST_INSERT_HEAD(&client_list, cl, next);
177 }
178 
179 /* Process client response packet */
180 static void
181 process_client(int sock, short ev __unused, void *arg)
182 {
183 	bthcid_pin_response_t	 rp;
184 	struct timeval		 tv;
185 	struct sockaddr_bt	 sa;
186 	struct client		*cl = arg;
187 	struct item		*item;
188 	int			 n;
189 
190 	n = recv(sock, &rp, sizeof(rp), 0);
191 	if (n != sizeof(rp)) {
192 		if (n != 0)
193 			syslog(LOG_ERR, "Bad Client");
194 
195 		close(sock);
196 		LIST_REMOVE(cl, next);
197 		free(cl);
198 
199 		syslog(LOG_DEBUG, "Client Closed");
200 		return;
201 	}
202 
203 	syslog(LOG_DEBUG, "Received PIN for %s", bt_ntoa(&rp.raddr, NULL));
204 
205 	LIST_FOREACH(item, &item_list, next) {
206 		if (bdaddr_same(&rp.laddr, &item->laddr) == 0
207 		    || bdaddr_same(&rp.raddr, &item->raddr) == 0)
208 			continue;
209 
210 		evtimer_del(&item->ev);
211 		if (item->hci != -1) {
212 			memset(&sa, 0, sizeof(sa));
213 			sa.bt_len = sizeof(sa);
214 			sa.bt_family = AF_BLUETOOTH;
215 			bdaddr_copy(&sa.bt_bdaddr, &item->laddr);
216 
217 			send_pin_code_reply(item->hci, &sa, &item->raddr, rp.pin);
218 			LIST_REMOVE(item, next);
219 			free(item);
220 			return;
221 		}
222 		goto newpin;
223 	}
224 
225 	item = malloc(sizeof(struct item));
226 	if (item == NULL) {
227 		syslog(LOG_ERR, "Item allocation failed");
228 		return;
229 	}
230 
231 	memset(item, 0, sizeof(struct item));
232 	bdaddr_copy(&item->laddr, &rp.laddr);
233 	bdaddr_copy(&item->raddr, &rp.raddr);
234 	evtimer_set(&item->ev, process_item, item);
235 	LIST_INSERT_HEAD(&item_list, item, next);
236 
237 newpin:
238 	syslog(LOG_DEBUG, "Caching PIN for %s", bt_ntoa(&rp.raddr, NULL));
239 
240 	memcpy(item->pin, rp.pin, HCI_PIN_SIZE);
241 	item->hci = -1;
242 
243 	tv.tv_sec = PIN_TIMEOUT;
244 	tv.tv_usec = 0;
245 
246 	if (evtimer_add(&item->ev, &tv) < 0) {
247 		syslog(LOG_ERR, "Cannot add event timer for item");
248 		LIST_REMOVE(item, next);
249 		free(item);
250 	}
251 }
252 
253 /* Send PIN request to client */
254 int
255 send_client_request(bdaddr_t *laddr, bdaddr_t *raddr, int hci)
256 {
257 	bthcid_pin_request_t	 cp;
258 	struct client		*cl;
259 	struct item		*item;
260 	int			 n = 0;
261 	struct timeval		 tv;
262 
263 	memset(&cp, 0, sizeof(cp));
264 	bdaddr_copy(&cp.laddr, laddr);
265 	bdaddr_copy(&cp.raddr, raddr);
266 	cp.time = PIN_REQUEST_TIMEOUT;
267 
268 	LIST_FOREACH(cl, &client_list, next) {
269 		if (send(cl->fd, &cp, sizeof(cp), 0) != sizeof(cp))
270 			syslog(LOG_ERR, "send PIN request failed");
271 		else
272 			n++;
273 	}
274 
275 	if (n == 0)
276 		return 0;
277 
278 	syslog(LOG_DEBUG, "Sent PIN requests to %d client%s.",
279 				n, (n == 1 ? "" : "s"));
280 
281 	item = malloc(sizeof(struct item));
282 	if (item == NULL) {
283 		syslog(LOG_ERR, "Cannot allocate PIN request item");
284 		return 0;
285 	}
286 
287 	memset(item, 0, sizeof(struct item));
288 	bdaddr_copy(&item->laddr, laddr);
289 	bdaddr_copy(&item->raddr, raddr);
290 	item->hci = hci;
291 	evtimer_set(&item->ev, process_item, item);
292 
293 	tv.tv_sec = cp.time;
294 	tv.tv_usec = 0;
295 
296 	if (evtimer_add(&item->ev, &tv) < 0) {
297 		syslog(LOG_ERR, "Cannot add request timer");
298 		free(item);
299 		return 0;
300 	}
301 
302 	LIST_INSERT_HEAD(&item_list, item, next);
303 	return 1;
304 }
305 
306 /* Process item event (by expiring it) */
307 static void
308 process_item(int fd __unused, short ev __unused, void *arg)
309 {
310 	struct item *item = arg;
311 
312 	syslog(LOG_DEBUG, "PIN for %s expired", bt_ntoa(&item->raddr, NULL));
313 	LIST_REMOVE(item, next);
314 	evtimer_del(&item->ev);
315 	free(item);
316 }
317 
318 /* lookup PIN in item cache */
319 uint8_t *
320 lookup_pin(bdaddr_t *laddr, bdaddr_t *raddr)
321 {
322 	static uint8_t pin[HCI_PIN_SIZE];
323 	struct item *item;
324 
325 	LIST_FOREACH(item, &item_list, next) {
326 		if (bdaddr_same(raddr, &item->raddr) == 0)
327 			continue;
328 
329 		if (bdaddr_same(laddr, &item->laddr) == 0
330 		    && bdaddr_any(&item->laddr) == 0)
331 			continue;
332 
333 		if (item->hci >= 0)
334 			break;
335 
336 		syslog(LOG_DEBUG, "Matched PIN from cache");
337 		memcpy(pin, item->pin, sizeof(pin));
338 
339 		LIST_REMOVE(item, next);
340 		evtimer_del(&item->ev);
341 		free(item);
342 
343 		return pin;
344 	}
345 
346 	return NULL;
347 }
348