1 /* $NetBSD: client.c,v 1.6 2024/09/07 13:57:25 mlelstv 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.6 2024/09/07 13:57:25 mlelstv 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 */ 55 struct 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 */ 65 struct 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 74 static struct event control_ev; 75 76 static LIST_HEAD(,client) client_list; 77 static LIST_HEAD(,item) item_list; 78 79 static void process_control (int, short, void *); 80 static void process_client (int, short, void *); 81 static 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 86 int 87 init_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 */ 137 static void 138 process_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 */ 182 static void 183 process_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 239 newpin: 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 */ 256 int 257 send_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), MSG_NOSIGNAL) != 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) */ 309 static void 310 process_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 */ 321 uint8_t * 322 lookup_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