OpenBSD-4.6/usr.sbin/btd/btd.c
/* $OpenBSD: btd.c,v 1.4 2008/11/27 00:51:17 uwe Exp $ */
/*
* Copyright (c) 2008 Uwe Stuehler <uwe@openbsd.org>
* Copyright (c) 2003 Can Erkin Acar
* Copyright (c) 2003 Anil Madhavapeddy <anil@recoil.org>
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
#include <sys/ioctl.h>
#include <sys/wait.h>
#include <dev/bluetooth/btdev.h>
#include <err.h>
#include <errno.h>
#include <fcntl.h>
#include <libgen.h>
#include <poll.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include "btd.h"
static void sighdlr(int);
static __dead void usage(void);
static int check_child(pid_t, const char *);
static int read_all(void *, size_t);
static int write_all(const void *, size_t);
static int dispatch_imsg(struct btd *);
static void btd_open_hci(struct btd *);
static void btd_set_link_policy(struct btd *);
static void btd_set_interface_flags(struct btd *);
static void btd_devctl(struct btd *, enum imsg_type);
static const char *progname;
static volatile sig_atomic_t quit = 0;
static volatile sig_atomic_t reconfig = 0;
static volatile sig_atomic_t sigchld = 0;
static int pipe_fd;
static void
sighdlr(int sig)
{
switch (sig) {
case SIGTERM:
case SIGINT:
quit = 1;
break;
case SIGCHLD:
sigchld = 1;
break;
case SIGHUP:
reconfig = 1;
break;
}
}
static __dead void
usage(void)
{
fprintf(stderr, "usage: %s [-d]\n", progname);
exit(2);
}
int
main(int argc, char *argv[])
{
struct btd env;
pid_t chld_pid, pid;
int pipe_chld[2];
struct passwd *pw;
struct pollfd pfd;
int ch;
progname = basename(argv[0]);
bzero(&env, sizeof(env));
TAILQ_INIT(&env.interfaces);
TAILQ_INIT(&env.devices);
while ((ch = getopt(argc, argv, "d")) != -1) {
switch (ch) {
case 'd':
env.debug = 1;
break;
default:
usage();
/* NOTREACHED */
}
}
argc -= optind;
argv += optind;
if (argc > 0) {
usage();
/* NOTREACHED */
}
if (geteuid() != 0)
errx(1, "need root privileges");
if ((pw = getpwnam(BTD_USER)) == NULL)
errx(1, "unknown user %s", BTD_USER);
endpwent();
log_init(env.debug);
if (!env.debug && daemon(1, 0))
fatal("daemon");
if (socketpair(AF_UNIX, SOCK_STREAM, PF_UNSPEC, pipe_chld) == -1)
fatal("socketpair");
/* fork child process */
sigchld = 1;
chld_pid = bt_main(pipe_chld, &env, pw);
setproctitle("[priv]");
signal(SIGCHLD, sighdlr);
signal(SIGTERM, sighdlr);
signal(SIGINT, sighdlr);
signal(SIGHUP, sighdlr);
close(pipe_chld[1]);
pipe_fd = pipe_chld[0];
while (quit == 0) {
int nfds;
pfd.fd = pipe_fd;
pfd.events = POLLIN;
if ((nfds = poll(&pfd, 1, 0)) == -1)
if (errno != EINTR) {
log_warn("poll error");
quit = 1;
}
if (pfd.revents & POLLIN)
if (dispatch_imsg(&env) == -1)
quit = 1;
if (sigchld) {
if (check_child(chld_pid, "child")) {
quit = 1;
chld_pid = 0;
}
sigchld = 0;
}
}
signal(SIGCHLD, SIG_DFL);
if (chld_pid)
kill(chld_pid, SIGTERM);
do {
if ((pid = wait(NULL)) == -1 &&
errno != EINTR && errno != ECHILD)
fatal("wait");
} while (pid != -1 || (pid == -1 && errno == EINTR));
log_info("Terminating");
control_cleanup();
return 0;
}
int
check_child(pid_t pid, const char *pname)
{
int status, sig;
char *signame;
if (waitpid(pid, &status, WNOHANG) > 0) {
if (WIFEXITED(status)) {
log_warnx("Lost child: %s exited", pname);
return (1);
}
if (WIFSIGNALED(status)) {
sig = WTERMSIG(status);
signame = strsignal(sig) ? strsignal(sig) : "unknown";
log_warnx("Lost child: %s terminated; signal %d (%s)",
pname, sig, signame);
return (1);
}
}
return (0);
}
static int
read_all(void *buf, size_t n)
{
if (atomic_read(pipe_fd, buf, n) < 0) {
close(pipe_fd);
pipe_fd = -1;
quit = 1;
return -1;
}
return 0;
}
static int
write_all(const void *buf, size_t n)
{
if (atomic_write(pipe_fd, buf, n) < 0) {
close(pipe_fd);
pipe_fd = -1;
quit = 1;
return -1;
}
return 0;
}
static int
dispatch_imsg(struct btd *env)
{
enum imsg_type type;
if (read_all(&type, sizeof(type)) < 0) {
log_warnx("read_all");
return -1;
}
switch (type) {
case IMSG_OPEN_HCI:
btd_open_hci(env);
break;
case IMSG_SET_LINK_POLICY:
btd_set_link_policy(env);
break;
case IMSG_SET_INTERFACE_FLAGS:
btd_set_interface_flags(env);
break;
case IMSG_ATTACH:
case IMSG_DETACH:
btd_devctl(env, type);
break;
default:
log_warnx("invalid message, type=%#x", type);
return -1;
}
return 0;
}
static void
btd_open_hci(struct btd *env)
{
struct sockaddr_bt sa;
bdaddr_t addr;
int fd;
int err = 0;
if (read_all(&addr, sizeof(addr)) < 0)
return;
if ((fd = socket(PF_BLUETOOTH, SOCK_RAW, BTPROTO_HCI)) == -1) {
err = errno;
write_all(&err, sizeof(err));
return;
}
bzero(&sa, sizeof(sa));
sa.bt_len = sizeof(sa);
sa.bt_family = AF_BLUETOOTH;
bdaddr_copy(&sa.bt_bdaddr, &addr);
if (bind(fd, (struct sockaddr *)&sa, sizeof(sa)) < 0 ||
connect(fd, (struct sockaddr *)&sa, sizeof(sa)) < 0) {
err = errno;
close(fd);
fd = -1;
}
send_fd(pipe_fd, fd);
(void)write_all(&err, sizeof(err));
if (fd != -1)
close(fd);
}
static void
btd_set_link_policy(struct btd *env)
{
struct btreq btr;
bdaddr_t addr;
uint16_t link_policy;
int err = 0;
int fd;
if (read_all(&addr, sizeof(addr)) < 0 ||
read_all(&link_policy, sizeof(link_policy)) < 0)
return;
if ((fd = socket(PF_BLUETOOTH, SOCK_RAW, BTPROTO_HCI)) == -1) {
err = errno;
write_all(&err, sizeof(err));
return;
}
bdaddr_copy(&btr.btr_bdaddr, &addr);
if (ioctl(fd, SIOCGBTINFOA, &btr) < 0) {
err = errno;
close(fd);
write_all(&err, sizeof(err));
return;
}
btr.btr_link_policy = link_policy;
if (ioctl(fd, SIOCSBTPOLICY, &btr) < 0)
err = errno;
write_all(&err, sizeof(err));
close(fd);
}
static void
btd_set_interface_flags(struct btd *env)
{
struct btreq btr;
uint16_t mask;
uint16_t flags;
int err = 0;
int fd;
memset(&btr, 0, sizeof(btr));
if (read_all(&btr.btr_name, sizeof(btr.btr_name)) < 0 ||
read_all(&flags, sizeof(flags)) < 0)
return;
if ((fd = socket(PF_BLUETOOTH, SOCK_RAW, BTPROTO_HCI)) == -1) {
err = errno;
write_all(&err, sizeof(err));
return;
}
if (ioctl(fd, SIOCGBTINFO, &btr) < 0) {
err = errno;
log_warn("SIOCGBTINFO");
close(fd);
write_all(&err, sizeof(err));
return;
}
/* limit allowed flags */
mask = BTF_UP;
btr.btr_flags &= ~mask;
btr.btr_flags |= (flags & mask);
if (ioctl(fd, SIOCSBTFLAGS, &btr) < 0) {
err = errno;
log_warn("SIOCSBTFLAGS");
}
sleep(1); /* XXX wait until it comes up */
write_all(&err, sizeof(err));
close(fd);
}
void
btd_devctl(struct btd *env, enum imsg_type type)
{
struct btdev_attach_args baa;
unsigned long cmd;
void *data;
size_t datalen;
int res = 0;
int fd;
if (read_all(&datalen, sizeof(datalen)) < 0)
return;
if (datalen < sizeof(baa) || datalen > sizeof(baa) + 65536)
fatalx("invalid data length in IMSG_ATTACH/DETACH");
if ((data = malloc(datalen)) == NULL)
fatal("btd_devctl");
if (read_all(data, datalen) < 0) {
free(data);
return;
}
if (devinfo_load_attach_args(&baa, data, datalen))
fatalx("invalid IMSG_ATTACH/DETACH received");
if ((fd = open(BTHUB_PATH, O_WRONLY, 0)) == -1) {
res = errno;
goto ret;
}
cmd = type == IMSG_ATTACH ? BTDEV_ATTACH : BTDEV_DETACH;
if (ioctl(fd, cmd, &baa) != 0)
res = errno;
(void)close(fd);
ret:
if (data != NULL)
free(data);
devinfo_unload_attach_args(&baa);
write_all(&res, sizeof(res));
}