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/types.h> 37 #include <sys/event.h> 38 #include <sys/time.h> 39 #include <sys/un.h> 40 #include <bluetooth.h> 41 #include <errno.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 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 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 LIST_HEAD(,client) client_list; 72 static LIST_HEAD(,item) item_list; 73 74 #define PIN_REQUEST_TIMEOUT 30 /* Request is valid */ 75 #define PIN_TIMEOUT 300 /* PIN is valid */ 76 77 int 78 init_control(const char *name, mode_t mode) 79 { 80 struct sockaddr_un un; 81 struct kevent change; 82 struct timespec timeout = { 0, 0 }; 83 int ctl; 84 85 LIST_INIT(&client_list); 86 LIST_INIT(&item_list); 87 88 if (name == NULL) 89 return 0; 90 91 if (unlink(name) < 0 && errno != ENOENT) 92 return -1; 93 94 ctl = socket(PF_LOCAL, SOCK_STREAM, 0); 95 if (ctl < 0) 96 return -1; 97 98 memset(&un, 0, sizeof(un)); 99 un.sun_len = sizeof(un); 100 un.sun_family = AF_LOCAL; 101 strlcpy(un.sun_path, name, sizeof(un.sun_path)); 102 if (bind(ctl, (struct sockaddr *)&un, sizeof(un)) < 0) { 103 close(ctl); 104 return -1; 105 } 106 107 if (chmod(name, mode) < 0) { 108 close(ctl); 109 unlink(name); 110 return -1; 111 } 112 113 if (listen(ctl, 10) < 0) { 114 close(ctl); 115 unlink(name); 116 return -1; 117 } 118 119 EV_SET(&change, ctl, EVFILT_READ, EV_ADD, 0, 0, NULL); 120 if (kevent(hci_kq, &change, 1, NULL, 0, &timeout) == -1) { 121 close(ctl); 122 unlink(name); 123 return -1; 124 } 125 126 return ctl; 127 } 128 129 /* Process control socket event */ 130 void 131 process_control(int sock) 132 { 133 struct sockaddr_un un; 134 socklen_t n; 135 struct kevent change; 136 struct timespec timeout = { 0, 0 }; 137 int fd; 138 struct client *cl; 139 140 n = sizeof(un); 141 fd = accept(sock, (struct sockaddr *)&un, &n); 142 if (fd < 0) { 143 syslog(LOG_ERR, "Could not accept PIN client connection"); 144 return; 145 } 146 147 n = 1; 148 if (ioctl(fd, FIONBIO, &n) < 0) { 149 syslog(LOG_ERR, "Could not set non blocking IO for client"); 150 close(fd); 151 return; 152 } 153 154 cl = malloc(sizeof(struct client)); 155 if (cl == NULL) { 156 syslog(LOG_ERR, "Could not malloc client"); 157 close(fd); 158 return; 159 } 160 161 memset(cl, 0, sizeof(struct client)); 162 cl->fd = fd; 163 164 EV_SET(&change, cl->fd, EVFILT_READ, EV_ADD, 0, 0, cl); 165 if (kevent(hci_kq, &change, 1, NULL, 0, &timeout) == -1) { 166 syslog(LOG_ERR, "Could not add client event"); 167 free(cl); 168 close(fd); 169 return; 170 } 171 172 syslog(LOG_DEBUG, "New Client"); 173 LIST_INSERT_HEAD(&client_list, cl, next); 174 } 175 176 /* Process client response packet */ 177 void 178 process_client(int sock, void *arg) 179 { 180 bthcid_pin_response_t rp; 181 struct sockaddr_bt sa; 182 struct client *cl = arg; 183 struct item *item; 184 struct kevent change; 185 struct timespec timeout = { 0, 0 }; 186 int n; 187 188 n = recv(sock, &rp, sizeof(rp), 0); 189 if (n != sizeof(rp)) { 190 if (n != 0) 191 syslog(LOG_ERR, "Bad Client"); 192 193 close(sock); 194 LIST_REMOVE(cl, next); 195 free(cl); 196 197 syslog(LOG_DEBUG, "Client Closed"); 198 return; 199 } 200 201 syslog(LOG_DEBUG, "Received PIN for %s", bt_ntoa(&rp.raddr, NULL)); 202 203 LIST_FOREACH(item, &item_list, next) { 204 if (bdaddr_same(&rp.laddr, &item->laddr) == 0 205 || bdaddr_same(&rp.raddr, &item->raddr) == 0) 206 continue; 207 208 EV_SET(&change, sock, EVFILT_TIMER, EV_DELETE, 0, 0, NULL); 209 kevent(hci_kq, &change, 1, NULL, 0, &timeout); 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 LIST_INSERT_HEAD(&item_list, item, next); 234 235 newpin: 236 syslog(LOG_DEBUG, "Caching PIN for %s", bt_ntoa(&rp.raddr, NULL)); 237 238 memcpy(item->pin, rp.pin, HCI_PIN_SIZE); 239 item->hci = -1; 240 241 EV_SET(&change, sock, EVFILT_TIMER, EV_ADD, 0, PIN_TIMEOUT * 1000, NULL); 242 if (kevent(hci_kq, &change, 1, NULL, 0, &timeout) == -1) { 243 syslog(LOG_ERR, "Cannot add event timer for item"); 244 LIST_REMOVE(item, next); 245 free(item); 246 } 247 } 248 249 /* Send PIN request to client */ 250 int 251 send_client_request(bdaddr_t *laddr, bdaddr_t *raddr, int hci) 252 { 253 bthcid_pin_request_t cp; 254 struct client *cl; 255 struct item *item; 256 struct kevent change; 257 struct timespec timeout = { 0, 0 }; 258 int n = 0; 259 260 memset(&cp, 0, sizeof(cp)); 261 bdaddr_copy(&cp.laddr, laddr); 262 bdaddr_copy(&cp.raddr, raddr); 263 cp.time = PIN_REQUEST_TIMEOUT; 264 265 LIST_FOREACH(cl, &client_list, next) { 266 if (send(cl->fd, &cp, sizeof(cp), 0) != sizeof(cp)) 267 syslog(LOG_ERR, "send PIN request failed"); 268 else 269 n++; 270 } 271 272 if (n == 0) 273 return 0; 274 275 syslog(LOG_DEBUG, "Sent PIN requests to %d client%s.", 276 n, (n == 1 ? "" : "s")); 277 278 item = malloc(sizeof(struct item)); 279 if (item == NULL) { 280 syslog(LOG_ERR, "Cannot allocate PIN request item"); 281 return 0; 282 } 283 284 memset(item, 0, sizeof(struct item)); 285 bdaddr_copy(&item->laddr, laddr); 286 bdaddr_copy(&item->raddr, raddr); 287 item->hci = hci; 288 EV_SET(&change, item->hci, EVFILT_TIMER, EV_ADD, 0, cp.time * 1000, item); 289 if (kevent(hci_kq, &change, 1, NULL, 0, &timeout) == -1) { 290 syslog(LOG_ERR, "Cannot add request timer"); 291 free(item); 292 return 0; 293 } 294 295 LIST_INSERT_HEAD(&item_list, item, next); 296 return 1; 297 } 298 299 /* Process item event (by expiring it) */ 300 void 301 process_item(void *arg) 302 { 303 struct item *item = arg; 304 struct kevent change; 305 struct timespec timeout = { 0, 0 }; 306 307 syslog(LOG_DEBUG, "PIN for %s expired", bt_ntoa(&item->raddr, NULL)); 308 LIST_REMOVE(item, next); 309 EV_SET(&change, item->hci, EVFILT_TIMER, EV_DELETE, 0, 0, 0); 310 kevent(hci_kq, &change, 1, NULL, 0, &timeout); 311 free(item); 312 } 313 314 /* lookup PIN in item cache */ 315 uint8_t * 316 lookup_pin(bdaddr_t *laddr, bdaddr_t *raddr) 317 { 318 static uint8_t pin[HCI_PIN_SIZE]; 319 struct item *item; 320 struct kevent change; 321 struct timespec timeout = { 0, 0 }; 322 323 LIST_FOREACH(item, &item_list, next) { 324 if (bdaddr_same(raddr, &item->raddr) == 0) 325 continue; 326 327 if (bdaddr_same(laddr, &item->laddr) == 0 328 && bdaddr_any(&item->laddr) == 0) 329 continue; 330 331 if (item->hci >= 0) 332 break; 333 334 syslog(LOG_DEBUG, "Matched PIN from cache"); 335 memcpy(pin, item->pin, sizeof(pin)); 336 337 LIST_REMOVE(item, next); 338 EV_SET(&change, item->hci, EVFILT_TIMER, EV_DELETE, 0, 0, 0); 339 kevent(hci_kq, &change, 1, NULL, 0, &timeout); 340 free(item); 341 342 return pin; 343 } 344 345 return NULL; 346 } 347