/* $NetBSD: rfcomm_sppd.c,v 1.17 2017/01/10 21:12:03 christos Exp $ */ /*- * Copyright (c) 2006 Itronix Inc. * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. The name of Itronix Inc. may not be used to endorse * or promote products derived from this software without specific * prior written permission. * * THIS SOFTWARE IS PROVIDED BY ITRONIX INC. ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL ITRONIX INC. BE LIABLE FOR ANY * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND * ON ANY THEORY OF LIABILITY, WHETHER IN * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE * POSSIBILITY OF SUCH DAMAGE. */ /* * Copyright (c) 2009 The NetBSD Foundation, Inc. * Copyright (c) 2007 Iain Hibbert * Copyright (c) 2003 Maksim Yevmenkin * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ #include __COPYRIGHT("@(#) Copyright (c) 2009 The NetBSD Foundation, Inc.\ Copyright (c) 2007 Iain Hibbert.\ Copyright (c) 2006 Itronix, Inc.\ Copyright (c) 2003 Maksim Yevmenkin m_evmenkin@yahoo.com.\ All rights reserved."); __RCSID("$NetBSD: rfcomm_sppd.c,v 1.17 2017/01/10 21:12:03 christos Exp $"); #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include static int open_tty(const char *); static int open_client(bdaddr_t *, bdaddr_t *, int, uintmax_t, const char *); static int open_server(bdaddr_t *, uint16_t, uint8_t, int, const char *); static void copy_data(int, int); static int service_search(const bdaddr_t *, const bdaddr_t *, uint16_t, uintmax_t *, uintmax_t *); static void sighandler(int); static void usage(void) __attribute__((__noreturn__)); static void reset_tio(void); static sig_atomic_t done; /* got a signal */ static struct termios tio; /* stored termios for reset on exit */ static const struct service { const char * name; const char * description; uint16_t class; } services[] = { { "DUN", "Dialup Networking", SDP_SERVICE_CLASS_DIALUP_NETWORKING }, { "LAN", "LAN access using PPP", SDP_SERVICE_CLASS_LAN_ACCESS_USING_PPP }, { "SP", "Serial Port", SDP_SERVICE_CLASS_SERIAL_PORT }, { NULL, NULL, 0 } }; int main(int argc, char *argv[]) { struct termios t; bdaddr_t laddr, raddr; struct pollfd pfd[2]; const char *service; char *ep, *tty; int n, lm, rfcomm, tty_in, tty_out; uint16_t psm; uint8_t channel; setprogname(argv[0]); bdaddr_copy(&laddr, BDADDR_ANY); bdaddr_copy(&raddr, BDADDR_ANY); service = "SP"; tty = NULL; channel = RFCOMM_CHANNEL_ANY; psm = L2CAP_PSM_RFCOMM; lm = 0; /* Parse command line options */ while ((n = getopt(argc, argv, "a:c:d:hm:p:s:t:")) != -1) { switch (n) { case 'a': /* remote device address */ if (!bt_aton(optarg, &raddr)) { struct hostent *he = NULL; if ((he = bt_gethostbyname(optarg)) == NULL) errx(EXIT_FAILURE, "%s: %s", optarg, hstrerror(h_errno)); bdaddr_copy(&raddr, (bdaddr_t *)he->h_addr); } break; case 'c': /* RFCOMM channel */ channel = strtoul(optarg, &ep, 10); if (*ep != '\0' || channel < RFCOMM_CHANNEL_MIN || channel > RFCOMM_CHANNEL_MAX) errx(EXIT_FAILURE, "Invalid channel: %s", optarg); break; case 'd': /* local device address */ if (!bt_devaddr(optarg, &laddr)) err(EXIT_FAILURE, "%s", optarg); break; case 'm': /* Link Mode */ if (strcasecmp(optarg, "auth") == 0) lm = RFCOMM_LM_AUTH; else if (strcasecmp(optarg, "encrypt") == 0) lm = RFCOMM_LM_ENCRYPT; else if (strcasecmp(optarg, "secure") == 0) lm = RFCOMM_LM_SECURE; else errx(EXIT_FAILURE, "Unknown mode: %s", optarg); break; case 'p': /* PSM */ psm = strtoul(optarg, &ep, 0); if (*ep != '\0' || L2CAP_PSM_INVALID(psm)) errx(EXIT_FAILURE, "Invalid PSM: %s", optarg); break; case 's': /* service class */ service = optarg; break; case 't': /* Slave TTY name */ if (optarg[0] != '/') asprintf(&tty, "%s%s", _PATH_DEV, optarg); else tty = optarg; break; case 'h': default: usage(); /* NOT REACHED */ } } /* * validate options: * cannot have remote address if channel was given */ if (channel != RFCOMM_CHANNEL_ANY && !bdaddr_any(&raddr)) usage(); /* * grab ttys before we start the bluetooth */ if (tty == NULL) { tty_in = STDIN_FILENO; tty_out = STDOUT_FILENO; } else { tty_in = open_tty(tty); tty_out = tty_in; } /* open RFCOMM */ if (!bdaddr_any(&raddr)) rfcomm = open_client(&laddr, &raddr, lm, psm, service); else rfcomm = open_server(&laddr, psm, channel, lm, service); /* * now we are ready to go, so either detach or maybe turn * off some input processing, so that rfcomm_sppd can * be used directly with stdio */ if (tty == NULL) { if (tcgetattr(tty_in, &t) != -1) { tio = t; t.c_lflag &= ~(ECHO | ICANON); t.c_iflag &= ~(ICRNL); if (tio.c_lflag != t.c_lflag || tio.c_iflag != t.c_iflag) { if (tcsetattr(tty_in, TCSANOW, &t) == -1) err(EXIT_FAILURE, "tcsetattr"); atexit(reset_tio); } } } else { if (daemon(0, 0) == -1) err(EXIT_FAILURE, "daemon() failed"); } /* catch signals */ done = 0; (void)signal(SIGHUP, sighandler); (void)signal(SIGINT, sighandler); (void)signal(SIGPIPE, sighandler); (void)signal(SIGTERM, sighandler); openlog(getprogname(), LOG_PERROR | LOG_PID, LOG_DAEMON); syslog(LOG_INFO, "Starting on %s...", (tty ? tty : "stdio")); pfd[0].fd = tty_in; pfd[1].fd = rfcomm; pfd[0].events = POLLIN|POLLRDNORM; pfd[1].events = POLLIN|POLLRDNORM; while (!done) { if (poll(pfd, 2, INFTIM) == -1) { if (errno == EINTR) continue; syslog(LOG_ERR, "poll error: %m"); } if (pfd[0].revents & (POLLIN|POLLRDNORM)) copy_data(tty_in, rfcomm); if (pfd[1].revents & (POLLIN|POLLRDNORM)) copy_data(rfcomm, tty_out); } syslog(LOG_INFO, "Completed on %s", (tty ? tty : "stdio")); return EXIT_SUCCESS; } static int open_tty(const char *tty) { char pty[PATH_MAX], *slash; struct group *gr = NULL; gid_t ttygid; int master; /* * Construct master PTY name. The slave tty name must be less than * PATH_MAX characters in length, must contain '/' character and * must not end with '/'. */ if (strlcpy(pty, tty, sizeof(pty)) >= sizeof(pty)) errx(EXIT_FAILURE, "Tty name too long `%s'", tty); slash = strrchr(pty, '/'); if (slash == NULL || slash[1] == '\0') errx(EXIT_FAILURE, "Invalid tty `%s'", tty); slash[1] = 'p'; if (strcmp(pty, tty) == 0) errx(EXIT_FAILURE, "Master and slave tty are the same (%s)", tty); if ((master = open(pty, O_RDWR)) == -1) err(EXIT_FAILURE, "Cannot open `%s'", pty); /* * Slave TTY */ if ((gr = getgrnam("tty")) != NULL) ttygid = gr->gr_gid; else ttygid = (gid_t)-1; if (chown(tty, getuid(), ttygid) == -1) err(EXIT_FAILURE, "Cannot chown `%s'", pty); if (chmod(tty, S_IRUSR | S_IWUSR | S_IWGRP) == -1) err(EXIT_FAILURE, "Cannot chmod `%s'", pty); if (revoke(tty) == -1) err(EXIT_FAILURE, "Cannot revoke `%s'", pty); return master; } static int open_client(bdaddr_t *laddr, bdaddr_t *raddr, int lm, uintmax_t psm, const char *service) { struct sockaddr_bt sa; const struct service *s; struct linger l; char *ep; int fd; uintmax_t channel; for (s = services ; ; s++) { if (s->name == NULL) { errno = 0; channel = strtoul(service, &ep, 10); if (service == ep || *ep != '\0') errx(EXIT_FAILURE, "Unknown service `%s'", service); if (channel == ULONG_MAX && errno == ERANGE) err(EXIT_FAILURE, "Service `%s'", service); break; } if (strcasecmp(s->name, service) == 0) { if (service_search(laddr, raddr, s->class, &psm, &channel) == -1) err(EXIT_FAILURE, "%s", s->name); break; } } if (channel < RFCOMM_CHANNEL_MIN || channel > RFCOMM_CHANNEL_MAX) errx(EXIT_FAILURE, "Invalid channel %"PRIuMAX, channel); if (L2CAP_PSM_INVALID(psm)) errx(EXIT_FAILURE, "Invalid PSM 0x%04"PRIxMAX, psm); memset(&sa, 0, sizeof(sa)); sa.bt_len = sizeof(sa); sa.bt_family = AF_BLUETOOTH; bdaddr_copy(&sa.bt_bdaddr, laddr); fd = socket(PF_BLUETOOTH, SOCK_STREAM, BTPROTO_RFCOMM); if (fd == -1) err(EXIT_FAILURE, "socket()"); if (bind(fd, (struct sockaddr *)&sa, sizeof(sa)) == -1) err(EXIT_FAILURE, "bind(%s)", bt_ntoa(laddr, NULL)); memset(&l, 0, sizeof(l)); l.l_onoff = 1; l.l_linger = 5; if (setsockopt(fd, SOL_SOCKET, SO_LINGER, &l, sizeof(l)) == -1) err(EXIT_FAILURE, "linger()"); if (setsockopt(fd, BTPROTO_RFCOMM, SO_RFCOMM_LM, &lm, sizeof(lm)) == -1) err(EXIT_FAILURE, "link mode"); sa.bt_psm = psm; sa.bt_channel = channel; bdaddr_copy(&sa.bt_bdaddr, raddr); if (connect(fd, (struct sockaddr *)&sa, sizeof(sa)) == -1) err(EXIT_FAILURE, "connect(%s, 0x%04"PRIxMAX", %"PRIuMAX")", bt_ntoa(raddr, NULL), psm, channel); return fd; } static int open_server(bdaddr_t *laddr, uint16_t psm, uint8_t channel, int lm, const char *service) { uint8_t buffer[256]; struct sockaddr_bt sa; const struct service *s; struct linger l; socklen_t len; sdp_session_t ss; sdp_data_t rec; int sv, fd; for (s = services; ; s++) { if (s->name == NULL) usage(); if (strcasecmp(s->name, service) == 0) break; } /* Open server socket */ sv = socket(PF_BLUETOOTH, SOCK_STREAM, BTPROTO_RFCOMM); if (sv == -1) err(EXIT_FAILURE, "socket()"); memset(&sa, 0, sizeof(sa)); sa.bt_len = sizeof(sa); sa.bt_family = AF_BLUETOOTH; sa.bt_psm = psm; sa.bt_channel = channel; bdaddr_copy(&sa.bt_bdaddr, laddr); if (bind(sv, (struct sockaddr *)&sa, sizeof(sa)) == -1) err(EXIT_FAILURE, "bind(%s, 0x%04x, %d)", bt_ntoa(laddr, NULL), psm, channel); if (setsockopt(sv, BTPROTO_RFCOMM, SO_RFCOMM_LM, &lm, sizeof(lm)) == -1) err(EXIT_FAILURE, "link mode"); if (listen(sv, 1) == -1) err(EXIT_FAILURE, "listen()"); len = sizeof(sa); if (getsockname(sv, (struct sockaddr *)&sa, &len) == -1) err(EXIT_FAILURE, "getsockname()"); if (len != sizeof(sa)) errx(EXIT_FAILURE, "getsockname()"); /* Build SDP record */ rec.next = buffer; rec.end = buffer + sizeof(buffer); sdp_put_uint16(&rec, SDP_ATTR_SERVICE_RECORD_HANDLE); sdp_put_uint32(&rec, 0x00000000); sdp_put_uint16(&rec, SDP_ATTR_SERVICE_CLASS_ID_LIST); sdp_put_seq(&rec, 3); sdp_put_uuid16(&rec, s->class); len = (psm == L2CAP_PSM_RFCOMM ? 0 : 3); sdp_put_uint16(&rec, SDP_ATTR_PROTOCOL_DESCRIPTOR_LIST); sdp_put_seq(&rec, 12 + len); sdp_put_seq(&rec, 3 + len); sdp_put_uuid16(&rec, SDP_UUID_PROTOCOL_L2CAP); if (len > 0) sdp_put_uint16(&rec, psm); sdp_put_seq(&rec, 5); sdp_put_uuid16(&rec, SDP_UUID_PROTOCOL_RFCOMM); sdp_put_uint8(&rec, sa.bt_channel); sdp_put_uint16(&rec, SDP_ATTR_BROWSE_GROUP_LIST); sdp_put_seq(&rec, 3); sdp_put_uuid16(&rec, SDP_SERVICE_CLASS_PUBLIC_BROWSE_GROUP); sdp_put_uint16(&rec, SDP_ATTR_LANGUAGE_BASE_ATTRIBUTE_ID_LIST); sdp_put_seq(&rec, 9); sdp_put_uint16(&rec, 0x656e); /* "en" */ sdp_put_uint16(&rec, 106); /* UTF-8 */ sdp_put_uint16(&rec, SDP_ATTR_PRIMARY_LANGUAGE_BASE_ID); if (s->class == SDP_SERVICE_CLASS_LAN_ACCESS_USING_PPP) { sdp_put_uint16(&rec, SDP_ATTR_SERVICE_AVAILABILITY); sdp_put_uint8(&rec, 0x00); } sdp_put_uint16(&rec, SDP_ATTR_BLUETOOTH_PROFILE_DESCRIPTOR_LIST); sdp_put_seq(&rec, 8); sdp_put_seq(&rec, 6); sdp_put_uuid16(&rec, s->class); sdp_put_uint16(&rec, 0x0100); /* v1.0 */ sdp_put_uint16(&rec, SDP_ATTR_PRIMARY_LANGUAGE_BASE_ID + SDP_ATTR_SERVICE_NAME_OFFSET); sdp_put_str(&rec, s->description, -1); if (s->class == SDP_SERVICE_CLASS_DIALUP_NETWORKING) { sdp_put_uint16(&rec, SDP_ATTR_AUDIO_FEEDBACK_SUPPORT); sdp_put_bool(&rec, false); } #if 0 if (s->class == SDP_SERVICE_CLASS_LAN_ACCESS_USING_PPP) { sdp_put_uint16(&rec, SDP_ATTR_IP_SUBNET); /* TODO */ sdp_put_str(&rec, "0.0.0.0/0", -1); } #endif rec.end = rec.next; rec.next = buffer; /* Register service with SDP server */ ss = sdp_open_local(NULL); if (ss == NULL) err(EXIT_FAILURE, "sdp_open_local"); if (!sdp_record_insert(ss, laddr, NULL, &rec)) err(EXIT_FAILURE, "sdp_record_insert"); /* Accept client connection */ len = sizeof(sa); fd = accept(sv, (struct sockaddr *)&sa, &len); if (fd == -1) err(EXIT_FAILURE, "accept"); memset(&l, 0, sizeof(l)); l.l_onoff = 1; l.l_linger = 5; if (setsockopt(fd, SOL_SOCKET, SO_LINGER, &l, sizeof(l)) == -1) err(EXIT_FAILURE, "linger()"); close(sv); return fd; } static void copy_data(int src, int dst) { static char buf[BUFSIZ]; ssize_t nr, nw, off; while ((nr = read(src, buf, sizeof(buf))) == -1) { if (errno != EINTR) { syslog(LOG_ERR, "read failed: %m"); exit(EXIT_FAILURE); } } if (nr == 0) /* reached EOF */ done++; for (off = 0 ; nr ; nr -= nw, off += nw) { if ((nw = write(dst, buf + off, (size_t)nr)) == -1) { syslog(LOG_ERR, "write failed: %m"); exit(EXIT_FAILURE); } } } static int service_search(bdaddr_t const *laddr, bdaddr_t const *raddr, uint16_t class, uintmax_t *psm, uintmax_t *channel) { uint8_t buffer[6]; /* SSP (3 bytes) + AIL (3 bytes) */ sdp_session_t ss; sdp_data_t ail, ssp, rsp, rec, value, pdl, seq; uint16_t attr; bool rv; seq.next = buffer; seq.end = buffer + sizeof(buffer); /* * build ServiceSearchPattern (3 bytes) */ ssp.next = seq.next; sdp_put_uuid16(&seq, class); ssp.end = seq.next; /* * build AttributeIDList (3 bytes) */ ail.next = seq.next; sdp_put_uint16(&seq, SDP_ATTR_PROTOCOL_DESCRIPTOR_LIST); ail.end = seq.next; ss = sdp_open(laddr, raddr); if (ss == NULL) return -1; rv = sdp_service_search_attribute(ss, &ssp, &ail, &rsp); if (!rv) { sdp_close(ss); return -1; } /* * The response will be a list of records that matched our * ServiceSearchPattern, where each record is a sequence * containing a single ProtocolDescriptorList attribute and * value * * seq * uint16 ProtocolDescriptorList * value * seq * uint16 ProtocolDescriptorList * value * * If the ProtocolDescriptorList describes a single stack, * the attribute value takes the form of a single Data Element * Sequence where each member is a protocol descriptor. * * seq * list * * If it is possible for more than one kind of protocol * stack to be used to gain access to the service, the * ProtocolDescriptorList takes the form of a Data Element * Alternative where each member is a Data Element Sequence * describing an alternative protocol stack. * * alt * seq * list * seq * list * * Each protocol stack description contains a sequence for each * protocol, where each sequence contains the protocol UUID as * the first element, and any ProtocolSpecificParameters. We are * interested in the L2CAP psm if provided, and the RFCOMM channel * number, stored as parameter#1 in each case. * * seq * uuid L2CAP * uint16 psm * seq * uuid RFCOMM * uint8 channel */ rv = false; while (!rv && sdp_get_seq(&rsp, &rec)) { if (!sdp_get_attr(&rec, &attr, &value) || attr != SDP_ATTR_PROTOCOL_DESCRIPTOR_LIST) continue; sdp_get_alt(&value, &value); /* strip any alt container */ while (!rv && sdp_get_seq(&value, &pdl)) { *psm = L2CAP_PSM_RFCOMM; if (sdp_get_seq(&pdl, &seq) && sdp_match_uuid16(&seq, SDP_UUID_PROTOCOL_L2CAP) && (sdp_get_uint(&seq, psm) || true) && sdp_get_seq(&pdl, &seq) && sdp_match_uuid16(&seq, SDP_UUID_PROTOCOL_RFCOMM) && sdp_get_uint(&seq, channel)) rv = true; } } sdp_close(ss); if (rv) return 0; errno = ENOATTR; return -1; } static void sighandler(int s) { done++; } static void reset_tio(void) { tcsetattr(STDIN_FILENO, TCSAFLUSH, &tio); } static void usage(void) { const char *cmd = getprogname(); const struct service *s; fprintf(stderr, "Usage: %s [-d device] [-m mode] [-p psm] [-s service]" " [-t tty]\n" " %*s {-a bdaddr | [-c channel]}\n" "\n" "Where:\n" "\t-a bdaddr remote device address\n" "\t-c channel local RFCOMM channel\n" "\t-d device local device address\n" "\t-m mode link mode\n" "\t-p psm protocol/service multiplexer\n" "\t-s service service class\n" "\t-t tty run in background using pty\n" "\n", cmd, (int)strlen(cmd), ""); fprintf(stderr, "Known service classes:\n"); for (s = services ; s->name != NULL ; s++) fprintf(stderr, "\t%-13s%s\n", s->name, s->description); exit(EXIT_FAILURE); }