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