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