 @@ -1,226 +1,226 @@
-.\" $NetBSD: rfcomm_sppd.1,v 1.8 2010/11/02 19:44:09 plunky Exp $
+.\" $NetBSD: rfcomm_sppd.1,v 1.9 2010/11/03 08:27:27 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) 2001-2003 Maksim Yevmenkin <m_evmenkin@yahoo.com>
 .\" 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.
 .\"
 .Dd November 2, 2010
 .Dt RFCOMM_SPPD 1
 .Os
 .Sh NAME
 .Nm rfcomm_sppd
 .Nd RFCOMM Serial Port Profile daemon
 .Sh SYNOPSIS
 .Nm
 .Op Fl d Ar device
 .Op Fl m Ar mode
 .Op Fl p Ar psm
 .Op Fl s Ar service
 .Op Fl t Ar tty
-.Brq Fl a Ar address | Fl c Ar channel
+.Brq Fl a Ar address | Op Fl c Ar channel
 .Sh DESCRIPTION
 The
 .Nm
 utility is a Serial Port Profile daemon, providing serial access over
 an RFCOMM connection to a remote device.
 .Nm
 can work in client or server mode.
 .Pp
 In client mode,
 .Nm
 initiates an RFCOMM connection to the
 .Ar service
 at the remote
 .Ar address .
 .Pp
 In server mode,
 .Nm
 registers the
 .Ar service
 with the local SDP server and listens on the specified RFCOMM
 .Ar channel
-for an incoming connection.
+for an incoming connection, or the first unused channel if none
 was given.
 .Pp
 The options are as follows:
 .Bl -tag -width ".Fl c Ar channel"
 .It Fl a Ar address
 Client mode.
 Specify the address of the remote RFCOMM device.
 The address can be specified as BD_ADDR or name.
 If given as a name, then the
 .Nm
 utility will attempt to resolve the name via
 .Xr bt_gethostbyname 3 .
 .It Fl c Ar channel
-Server mode.
+In server mode, specify the RFCOMM channel number to listen on.
 Specify the RFCOMM channel number to listen on.
 .Nm
 will register the service with the local
 .Xr sdpd 8
 daemon.
 Note that registering services with
 .Xr sdpd 8
 is a privileged operation.
 .It Fl d Ar device
 Use the local device with the specified address.
 The device can be specified by BD_ADDR or device name.
 See
 .Xr btconfig 8
 for a list of available devices.
 If no
 .Ar device
 is specified, the connection will be set up on a system determined device.
 .It Fl m Ar mode
 Set connection link mode.
 Supported modes are:
 .Pp
 .Bl -tag -compact -offset indent
 .It auth
 require devices be paired.
 .It encrypt
 auth, plus enable encryption.
 .It secure
 encryption, plus change of link key.
 .El
 .It Fl p Ar psm
 Specify the
 .Qq Protocol/Service Multiplexer
 value to be used for the RFCOMM protocol.
 In client mode where Service Discovery is being used, this value
 will be ignored.
 .It Fl s Ar service
 Name of service class to connect to or register.
 If no
 .Ar service
 is given, the default
 .Qq Serial Port
 service class will be used.
 Known service classes are:
 .Pp
 .Bl -tag -compact -offset indent
 .It DUN
 Dialup Networking
 .It LAN
 LAN access using PPP
 .It SP
 Serial Port
 .El
 .Pp
 In client mode, the service class may be given as a channel number, for instances
 where the remote device does not provide Service Discovery.
 .It Fl t Ar tty
 Slave pseudo tty name.
 If this option is given,
 .Nm
 will detach from the controlling process after the Bluetooth connection is
 made, and operate over the named
 .Xr pty 4
 pair.
 Otherwise, stdin/stdout will be used.
 .El
 .Sh EXIT STATUS
 .Ex -std
 .Sh FILES
 .Bl -tag -width ".Pa /dev/tty[p-sP-S][0-9a-v]" -compact
 .It Pa /dev/pty[p-sP-S][0-9a-v]
 master pseudo terminals
 .It Pa /dev/tty[p-sP-S][0-9a-v]
 slave pseudo terminals
 .El
 .Sh EXAMPLES
 .Dl rfcomm_sppd -a 00:01:02:03:04:05 -s 1 -t /dev/ttyp1
 .Pp
 Will open an RFCOMM connection to the server at
 .Li 00:01:02:03:04:05
 on channel
 .Li 1 .
 Once the connection has been established,
 .Nm
 will detach and
 .Pa /dev/ttyp1
 can be used to communicate with the remote serial port on the
 server, e.g. with the use of
 .Pp
 .Dl cu -l /dev/ttyp1
 .Pp
 In order to use
 .Nm
 to automatically create a secured link for
 .Xr pppd 8 ,
 use
 .Dl pty Qo rfcomm_sppd -a 00:01:02:03:04:05 -s DUN -m secure Qc
 .Pp
 in your
 .Xr pppd 8
 configuration file.
 .Sh SEE ALSO
 .Xr bluetooth 3 ,
 .Xr bluetooth 4 ,
 .Xr pty 4 ,
 .Xr btconfig 8 ,
 .Xr pppd 8 ,
 .Xr sdpd 8
 .Sh HISTORY
 The
 .Nm
 program first appeared in
 .Fx
 and was ported to
 .Nx 4.0
 by
 .An Iain Hibbert
 under the sponsorship of
 .An Itronix, Inc .
 .Sh AUTHORS
 .An Maksim Yevmenkin Aq m_evmenkin@yahoo.com ,
 .An Iain Hibbert
 .Sh BUGS
 Please report if found.

 @@ -1,691 +1,698 @@
-/*	$NetBSD: rfcomm_sppd.c,v 1.12 2009/09/24 18:30:37 plunky Exp $	*/
+/*	$NetBSD: rfcomm_sppd.c,v 1.13 2010/11/03 08:27:27 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 <m_evmenkin@yahoo.com>
  * 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 <sys/cdefs.h>
 __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 $");
+__RCSID("$NetBSD: rfcomm_sppd.c,v 1.13 2010/11/03 08:27:27 plunky Exp $");
 #include <sys/param.h>
 #include <bluetooth.h>
 #include <ctype.h>
 #include <err.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <grp.h>
 #include <limits.h>
 #include <paths.h>
 #include <sdp.h>
 #include <signal.h>
 #include <stdarg.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <syslog.h>
 #include <termios.h>
 #include <unistd.h>
 #include <netbt/rfcomm.h>
 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;
+	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 < 1 || channel > 30)
+			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, "%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
+	 *	cannot have remote address if channel was given
 	 */
-	if ((channel == 0 && bdaddr_any(&raddr))
+	if (channel != RFCOMM_CHANNEL_ANY && !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)
+	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) < 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()");
 	len = sizeof(sa);
 	if (getsockname(sv, (struct sockaddr *)&sa, &len) < 0)
 		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, channel);
+	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 < 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"
+			"       %*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);
+}