/* $NetBSD: rfcomm_sppd.c,v 1.12 2009/09/24 18:30:37 plunky 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.12 2009/09/24 18:30:37 plunky Exp $"); #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include int open_tty(const char *); int open_client(bdaddr_t *, bdaddr_t *, int, uintmax_t, const char *); int open_server(bdaddr_t *, uint16_t, uint8_t, int, const char *); void copy_data(int, int); int service_search(const bdaddr_t *, const bdaddr_t *, uint16_t, uintmax_t *, uintmax_t *); void sighandler(int); void usage(void); void reset_tio(void); int done; /* got a signal */ struct termios tio; /* stored termios for reset on exit */ 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; fd_set rdset; const char *service; char *ep, *tty; int lm, n, rfcomm, tty_in, tty_out; uint16_t psm; uint8_t channel; bdaddr_copy(&laddr, BDADDR_ANY); bdaddr_copy(&raddr, BDADDR_ANY); service = "SP"; tty = NULL; channel = 0; 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 < 1 || channel > 30) 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, "%s: unknown mode", 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: * must have channel or remote address but not both */ if ((channel == 0 && bdaddr_any(&raddr)) || (channel != 0 && !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 (channel == 0) 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) < 0) err(EXIT_FAILURE, "tcgetattr"); memcpy(&tio, &t, sizeof(tio)); t.c_lflag &= ~(ECHO | ICANON); t.c_iflag &= ~(ICRNL); if (memcmp(&tio, &t, sizeof(tio))) { if (tcsetattr(tty_in, TCSANOW, &t) < 0) err(EXIT_FAILURE, "tcsetattr"); atexit(reset_tio); } } else { if (daemon(0, 0) < 0) 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")); n = MAX(tty_in, rfcomm) + 1; while (!done) { FD_ZERO(&rdset); FD_SET(tty_in, &rdset); FD_SET(rfcomm, &rdset); if (select(n, &rdset, NULL, NULL, NULL) < 0) { if (errno == EINTR) continue; syslog(LOG_ERR, "select error: %m"); exit(EXIT_FAILURE); } if (FD_ISSET(tty_in, &rdset)) copy_data(tty_in, rfcomm); if (FD_ISSET(rfcomm, &rdset)) copy_data(rfcomm, tty_out); } syslog(LOG_INFO, "Completed on %s", (tty ? tty : "stdio")); exit(EXIT_SUCCESS); } 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 then * PATH_MAX characters in length, must contain '/' character and * must not end with '/'. */ if (strlen(tty) >= sizeof(pty)) errx(EXIT_FAILURE, ": tty name too long"); strlcpy(pty, tty, sizeof(pty)); slash = strrchr(pty, '/'); if (slash == NULL || slash[1] == '\0') errx(EXIT_FAILURE, "%s: invalid tty", 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, 0)) < 0) err(EXIT_FAILURE, "%s", pty); /* * Slave TTY */ if ((gr = getgrnam("tty")) != NULL) ttygid = gr->gr_gid; else ttygid = (gid_t)-1; (void)chown(tty, getuid(), ttygid); (void)chmod(tty, S_IRUSR | S_IWUSR | S_IWGRP); (void)revoke(tty); return master; } int open_client(bdaddr_t *laddr, bdaddr_t *raddr, int lm, uintmax_t psm, const char *service) { struct sockaddr_bt sa; struct service *s; struct linger l; char *ep; int fd, error; uintmax_t channel; for (s = services ; ; s++) { if (s->name == NULL) { channel = strtoul(service, &ep, 10); if (*ep != '\0') errx(EXIT_FAILURE, "Unknown service: %s", service); break; } if (strcasecmp(s->name, service) == 0) { error = service_search(laddr, raddr, s->class, &psm, &channel); if (error != 0) errx(EXIT_FAILURE, "%s: %s", s->name, strerror(error)); 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 < 0) err(EXIT_FAILURE, "socket()"); if (bind(fd, (struct sockaddr *)&sa, sizeof(sa)) < 0) 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)) < 0) err(EXIT_FAILURE, "linger()"); if (setsockopt(fd, BTPROTO_RFCOMM, SO_RFCOMM_LM, &lm, sizeof(lm)) < 0) 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)) < 0) err(EXIT_FAILURE, "connect(%s, 0x%04"PRIxMAX", %"PRIuMAX")", bt_ntoa(raddr, NULL), psm, channel); return fd; } 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; 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 < 0) 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)) < 0) 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)) < 0) err(EXIT_FAILURE, "link mode"); if (listen(sv, 1) < 0) err(EXIT_FAILURE, "listen()"); /* 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, 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 < 0) 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)) < 0) err(EXIT_FAILURE, "linger()"); close(sv); return fd; } 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); } } } 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 errno; rv = sdp_service_search_attribute(ss, &ssp, &ail, &rsp); if (!rv) { sdp_close(ss); return errno; } /* * 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); return (rv) ? 0 : ENOATTR; } void sighandler(int s) { done++; } void reset_tio(void) { tcsetattr(STDIN_FILENO, TCSAFLUSH, &tio); } void usage(void) { const char *cmd = getprogname(); 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); }