1 /* $NetBSD: rfcomm_sppd.c,v 1.8 2007/04/21 10:39:30 dsl Exp $ */ 2 /* $DragonFly: src/usr.bin/rfcomm_sppd/rfcomm_sppd.c,v 1.2 2008/02/11 20:10:23 swildner 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 * rfcomm_sppd.c 34 * 35 * Copyright (c) 2007 Iain Hibbert 36 * Copyright (c) 2003 Maksim Yevmenkin <m_evmenkin@yahoo.com> 37 * All rights reserved. 38 * 39 * Redistribution and use in source and binary forms, with or without 40 * modification, are permitted provided that the following conditions 41 * are met: 42 * 1. Redistributions of source code must retain the above copyright 43 * notice, this list of conditions and the following disclaimer. 44 * 2. Redistributions in binary form must reproduce the above copyright 45 * notice, this list of conditions and the following disclaimer in the 46 * documentation and/or other materials provided with the distribution. 47 * 48 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 49 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 50 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 51 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 52 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 53 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 54 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 55 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 56 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 57 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 58 * SUCH DAMAGE. 59 */ 60 61 #include <bluetooth.h> 62 #include <ctype.h> 63 #include <err.h> 64 #include <errno.h> 65 #include <fcntl.h> 66 #include <grp.h> 67 #include <limits.h> 68 #include <paths.h> 69 #include <sdp.h> 70 #include <signal.h> 71 #include <stdarg.h> 72 #include <stdio.h> 73 #include <stdlib.h> 74 #include <string.h> 75 #include <syslog.h> 76 #include <termios.h> 77 #include <unistd.h> 78 #include <sys/stat.h> 79 80 #include <netbt/rfcomm.h> 81 82 #include "rfcomm_sdp.h" 83 84 #define max(a, b) ((a) > (b) ? (a) : (b)) 85 86 int open_tty(const char *); 87 int open_client(bdaddr_t *, bdaddr_t *, int, const char *); 88 int open_server(bdaddr_t *, uint8_t, int, const char *); 89 void copy_data(int, int); 90 void sighandler(int); 91 void usage(void); 92 void reset_tio(void); 93 94 int done; /* got a signal */ 95 struct termios tio; /* stored termios for reset on exit */ 96 97 struct service { 98 const char *name; 99 const char *description; 100 uint16_t class; 101 int pdulen; 102 } services[] = { 103 { "DUN", "Dialup Networking", 104 SDP_SERVICE_CLASS_DIALUP_NETWORKING, 105 sizeof(struct sdp_dun_profile) 106 }, 107 { "LAN", "Lan access using PPP", 108 SDP_SERVICE_CLASS_LAN_ACCESS_USING_PPP, 109 sizeof(struct sdp_lan_profile) 110 }, 111 { "SP", "Serial Port", 112 SDP_SERVICE_CLASS_SERIAL_PORT, 113 sizeof(struct sdp_sp_profile) 114 }, 115 { NULL, NULL, 116 0, 117 0 118 } 119 }; 120 121 int 122 main(int argc, char *argv[]) 123 { 124 struct termios t; 125 bdaddr_t laddr, raddr; 126 fd_set rdset; 127 const char *service; 128 char *ep, *tty; 129 int lm, n, rfcomm, tty_in, tty_out; 130 uint8_t channel; 131 132 bdaddr_copy(&laddr, BDADDR_ANY); 133 bdaddr_copy(&raddr, BDADDR_ANY); 134 service = "SP"; 135 tty = NULL; 136 channel = 0; 137 lm = 0; 138 139 /* Parse command line options */ 140 while ((n = getopt(argc, argv, "a:c:d:hm:s:t:")) != -1) { 141 switch (n) { 142 case 'a': /* remote device address */ 143 if (!bt_aton(optarg, &raddr)) { 144 struct hostent *he = NULL; 145 146 if ((he = bt_gethostbyname(optarg)) == NULL) 147 errx(EXIT_FAILURE, "%s: %s", optarg, 148 hstrerror(h_errno)); 149 150 bdaddr_copy(&raddr, (bdaddr_t *)he->h_addr); 151 } 152 break; 153 154 case 'c': /* RFCOMM channel */ 155 channel = strtoul(optarg, &ep, 10); 156 if (*ep != '\0' || channel < 1 || channel > 30) 157 errx(EXIT_FAILURE, "Invalid channel: %s", optarg); 158 159 break; 160 161 case 'd': /* local device address */ 162 if (!bt_devaddr(optarg, &laddr)) 163 err(EXIT_FAILURE, "%s", optarg); 164 165 break; 166 167 case 'm': /* Link Mode */ 168 if (strcasecmp(optarg, "auth") == 0) 169 lm = RFCOMM_LM_AUTH; 170 else if (strcasecmp(optarg, "encrypt") == 0) 171 lm = RFCOMM_LM_ENCRYPT; 172 else if (strcasecmp(optarg, "secure") == 0) 173 lm = RFCOMM_LM_SECURE; 174 else 175 errx(EXIT_FAILURE, "%s: unknown mode", optarg); 176 177 break; 178 179 case 's': /* service class */ 180 service = optarg; 181 break; 182 183 case 't': /* Slave TTY name */ 184 if (optarg[0] != '/') 185 asprintf(&tty, "%s%s", _PATH_DEV, optarg); 186 else 187 tty = optarg; 188 189 break; 190 191 case 'h': 192 default: 193 usage(); 194 /* NOT REACHED */ 195 } 196 } 197 198 /* 199 * validate options: 200 * must have channel or remote address but not both 201 */ 202 if ((channel == 0 && bdaddr_any(&raddr)) 203 || (channel != 0 && !bdaddr_any(&raddr))) 204 usage(); 205 206 /* 207 * grab ttys before we start the bluetooth 208 */ 209 if (tty == NULL) { 210 tty_in = STDIN_FILENO; 211 tty_out = STDOUT_FILENO; 212 } else { 213 tty_in = open_tty(tty); 214 tty_out = tty_in; 215 } 216 217 /* open RFCOMM */ 218 if (channel == 0) 219 rfcomm = open_client(&laddr, &raddr, lm, service); 220 else 221 rfcomm = open_server(&laddr, channel, lm, service); 222 223 /* 224 * now we are ready to go, so either detach or maybe turn 225 * off some input processing, so that rfcomm_sppd can 226 * be used directly with stdio 227 */ 228 if (tty == NULL) { 229 if (tcgetattr(tty_in, &t) < 0) 230 err(EXIT_FAILURE, "tcgetattr"); 231 232 memcpy(&tio, &t, sizeof(tio)); 233 t.c_lflag &= ~(ECHO | ICANON); 234 t.c_iflag &= ~(ICRNL); 235 236 if (memcmp(&tio, &t, sizeof(tio))) { 237 if (tcsetattr(tty_in, TCSANOW, &t) < 0) 238 err(EXIT_FAILURE, "tcsetattr"); 239 240 atexit(reset_tio); 241 } 242 } else { 243 if (daemon(0, 0) < 0) 244 err(EXIT_FAILURE, "daemon() failed"); 245 } 246 247 /* catch signals */ 248 done = 0; 249 (void)signal(SIGHUP, sighandler); 250 (void)signal(SIGINT, sighandler); 251 (void)signal(SIGPIPE, sighandler); 252 (void)signal(SIGTERM, sighandler); 253 254 openlog(getprogname(), LOG_PERROR | LOG_PID, LOG_DAEMON); 255 syslog(LOG_INFO, "Starting on %s...", (tty ? tty : "stdio")); 256 257 n = max(tty_in, rfcomm) + 1; 258 while (!done) { 259 FD_ZERO(&rdset); 260 FD_SET(tty_in, &rdset); 261 FD_SET(rfcomm, &rdset); 262 263 if (select(n, &rdset, NULL, NULL, NULL) < 0) { 264 if (errno == EINTR) 265 continue; 266 267 syslog(LOG_ERR, "select error: %m"); 268 exit(EXIT_FAILURE); 269 } 270 271 if (FD_ISSET(tty_in, &rdset)) 272 copy_data(tty_in, rfcomm); 273 274 if (FD_ISSET(rfcomm, &rdset)) 275 copy_data(rfcomm, tty_out); 276 } 277 278 syslog(LOG_INFO, "Completed on %s", (tty ? tty : "stdio")); 279 exit(EXIT_SUCCESS); 280 } 281 282 int 283 open_tty(const char *tty) 284 { 285 char pty[PATH_MAX], *slash; 286 struct group *gr = NULL; 287 gid_t ttygid; 288 int master; 289 290 /* 291 * Construct master PTY name. The slave tty name must be less then 292 * PATH_MAX characters in length, must contain '/' character and 293 * must not end with '/'. 294 */ 295 if (strlen(tty) >= sizeof(pty)) 296 errx(EXIT_FAILURE, ": tty name too long"); 297 298 strlcpy(pty, tty, sizeof(pty)); 299 slash = strrchr(pty, '/'); 300 if (slash == NULL || slash[1] == '\0') 301 errx(EXIT_FAILURE, "%s: invalid tty", tty); 302 303 slash[1] = 'p'; 304 if (strcmp(pty, tty) == 0) 305 errx(EXIT_FAILURE, "Master and slave tty are the same (%s)", tty); 306 307 if ((master = open(pty, O_RDWR, 0)) < 0) 308 err(EXIT_FAILURE, "%s", pty); 309 310 /* 311 * Slave TTY 312 */ 313 314 if ((gr = getgrnam("tty")) != NULL) 315 ttygid = gr->gr_gid; 316 else 317 ttygid = (gid_t)-1; 318 319 (void)chown(tty, getuid(), ttygid); 320 (void)chmod(tty, S_IRUSR | S_IWUSR | S_IWGRP); 321 (void)revoke(tty); 322 323 return master; 324 } 325 326 int 327 open_client(bdaddr_t *laddr, bdaddr_t *raddr, int lm, const char *service) 328 { 329 struct sockaddr_bt sa; 330 struct service *s; 331 struct linger l; 332 char *ep; 333 int fd; 334 uint8_t channel; 335 336 for (s = services ; ; s++) { 337 if (s->name == NULL) { 338 channel = strtoul(service, &ep, 10); 339 if (*ep != '\0' || channel < 1 || channel > 30) 340 errx(EXIT_FAILURE, "Invalid service: %s", service); 341 342 break; 343 } 344 345 if (strcasecmp(s->name, service) == 0) { 346 if (rfcomm_channel_lookup(laddr, raddr, s->class, &channel, &errno) < 0) 347 err(EXIT_FAILURE, "%s", s->name); 348 349 break; 350 } 351 } 352 353 memset(&sa, 0, sizeof(sa)); 354 sa.bt_len = sizeof(sa); 355 sa.bt_family = AF_BLUETOOTH; 356 bdaddr_copy(&sa.bt_bdaddr, laddr); 357 358 fd = socket(PF_BLUETOOTH, SOCK_STREAM, BTPROTO_RFCOMM); 359 if (fd < 0) 360 err(EXIT_FAILURE, "socket()"); 361 362 if (bind(fd, (struct sockaddr *)&sa, sizeof(sa)) < 0) 363 err(EXIT_FAILURE, "bind(%s)", bt_ntoa(laddr, NULL)); 364 365 memset(&l, 0, sizeof(l)); 366 l.l_onoff = 1; 367 l.l_linger = 5; 368 if (setsockopt(fd, SOL_SOCKET, SO_LINGER, &l, sizeof(l)) < 0) 369 err(EXIT_FAILURE, "linger()"); 370 371 if (setsockopt(fd, BTPROTO_RFCOMM, SO_RFCOMM_LM, &lm, sizeof(lm)) < 0) 372 err(EXIT_FAILURE, "link mode"); 373 374 sa.bt_channel = channel; 375 bdaddr_copy(&sa.bt_bdaddr, raddr); 376 377 if (connect(fd, (struct sockaddr *)&sa, sizeof(sa)) < 0) 378 err(EXIT_FAILURE, "connect(%s, %d)", bt_ntoa(raddr, NULL), 379 channel); 380 381 return fd; 382 } 383 384 /* 385 * In all the profiles we currently support registering, the channel 386 * is the first octet in the PDU, and it seems all the rest can be 387 * zero, so we just use an array of uint8_t big enough to store the 388 * largest, currently LAN. See <sdp.h> for definitions.. 389 */ 390 #define pdu_len sizeof(struct sdp_lan_profile) 391 392 int 393 open_server(bdaddr_t *laddr, uint8_t channel, int lm, const char *service) 394 { 395 struct sockaddr_bt sa; 396 struct linger l; 397 socklen_t len; 398 void *ss; 399 int sv, fd, n; 400 uint8_t pdu[pdu_len]; 401 402 memset(&sa, 0, sizeof(sa)); 403 sa.bt_len = sizeof(sa); 404 sa.bt_family = AF_BLUETOOTH; 405 bdaddr_copy(&sa.bt_bdaddr, laddr); 406 sa.bt_channel = channel; 407 408 sv = socket(PF_BLUETOOTH, SOCK_STREAM, BTPROTO_RFCOMM); 409 if (sv < 0) 410 err(EXIT_FAILURE, "socket()"); 411 412 if (bind(sv, (struct sockaddr *)&sa, sizeof(sa)) < 0) 413 err(EXIT_FAILURE, "bind(%s, %d)", bt_ntoa(laddr, NULL), 414 channel); 415 416 if (setsockopt(sv, BTPROTO_RFCOMM, SO_RFCOMM_LM, &lm, sizeof(lm)) < 0) 417 err(EXIT_FAILURE, "link mode"); 418 419 if (listen(sv, 1) < 0) 420 err(EXIT_FAILURE, "listen()"); 421 422 /* Register service with SDP server */ 423 for (n = 0 ; ; n++) { 424 if (services[n].name == NULL) 425 usage(); 426 427 if (strcasecmp(services[n].name, service) == 0) 428 break; 429 } 430 431 memset(pdu, 0, pdu_len); 432 pdu[0] = channel; 433 434 ss = sdp_open_local(NULL); 435 if (ss == NULL || (errno = sdp_error(ss)) != 0) 436 err(EXIT_FAILURE, "sdp_open_local"); 437 438 if (sdp_register_service(ss, services[n].class, laddr, 439 pdu, services[n].pdulen, NULL) != 0) { 440 errno = sdp_error(ss); 441 err(EXIT_FAILURE, "sdp_register_service"); 442 } 443 444 len = sizeof(sa); 445 fd = accept(sv, (struct sockaddr *)&sa, &len); 446 if (fd < 0) 447 err(EXIT_FAILURE, "accept"); 448 449 memset(&l, 0, sizeof(l)); 450 l.l_onoff = 1; 451 l.l_linger = 5; 452 if (setsockopt(fd, SOL_SOCKET, SO_LINGER, &l, sizeof(l)) < 0) 453 err(EXIT_FAILURE, "linger()"); 454 455 close(sv); 456 return fd; 457 } 458 459 void 460 copy_data(int src, int dst) 461 { 462 static char buf[BUFSIZ]; 463 ssize_t nr, nw, off; 464 465 while ((nr = read(src, buf, sizeof(buf))) == -1) { 466 if (errno != EINTR) { 467 syslog(LOG_ERR, "read failed: %m"); 468 exit(EXIT_FAILURE); 469 } 470 } 471 472 if (nr == 0) /* reached EOF */ 473 done++; 474 475 for (off = 0 ; nr ; nr -= nw, off += nw) { 476 if ((nw = write(dst, buf + off, (size_t)nr)) == -1) { 477 syslog(LOG_ERR, "write failed: %m"); 478 exit(EXIT_FAILURE); 479 } 480 } 481 } 482 483 void 484 sighandler(int s __unused) 485 { 486 487 done++; 488 } 489 490 void 491 reset_tio(void) 492 { 493 494 tcsetattr(STDIN_FILENO, TCSAFLUSH, &tio); 495 } 496 497 void 498 usage(void) 499 { 500 const char *cmd = getprogname(); 501 struct service *s; 502 503 fprintf(stderr, "Usage: %s [-d device] [-m mode] [-s service] [-t tty]\n" 504 " %*s {-a bdaddr | -c channel}\n" 505 "\n" 506 "Where:\n" 507 "\t-a bdaddr remote device address\n" 508 "\t-c channel local RFCOMM channel\n" 509 "\t-d device local device address\n" 510 "\t-m mode link mode\n" 511 "\t-s service service class\n" 512 "\t-t tty run in background using pty\n" 513 "\n", cmd, (int)strlen(cmd), ""); 514 515 fprintf(stderr, "Known service classes:\n"); 516 for (s = services ; s->name != NULL ; s++) 517 fprintf(stderr, "\t%-13s%s\n", s->name, s->description); 518 519 exit(EXIT_FAILURE); 520 } 521