diff options
Diffstat (limited to 'plugins/pnat.c')
-rw-r--r-- | plugins/pnat.c | 526 |
1 files changed, 526 insertions, 0 deletions
diff --git a/plugins/pnat.c b/plugins/pnat.c new file mode 100644 index 0000000..2d73910 --- /dev/null +++ b/plugins/pnat.c @@ -0,0 +1,526 @@ +/* + * + * BlueZ - Bluetooth protocol stack for Linux + * + * Copyright (C) 2010 Nokia Corporation + * Copyright (C) 2010 Marcel Holtmann <marcel@holtmann.org> + * + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + * + */ + +#ifdef HAVE_CONFIG_H +#include <config.h> +#endif + +#include <errno.h> +#include <unistd.h> +#include <sys/socket.h> +#include <sys/ioctl.h> +#include <sys/types.h> +#include <sys/stat.h> +#include <sys/wait.h> +#include <fcntl.h> + +#include <bluetooth/bluetooth.h> +#include <bluetooth/rfcomm.h> +#include <bluetooth/sdp.h> +#include <bluetooth/sdp_lib.h> + +#include <glib.h> + +#include <gdbus.h> + +#include "plugin.h" +#include "sdpd.h" +#include "btio.h" +#include "adapter.h" +#include "log.h" + +/* FIXME: This location should be build-time configurable */ +#define PNATD "/usr/bin/phonet-at" + +#define DUN_CHANNEL 1 +#define DUN_UUID "00001103-0000-1000-8000-00805F9B34FB" + +#define TTY_TIMEOUT 100 +#define TTY_TRIES 10 + +struct dun_client { + bdaddr_t bda; + + GIOChannel *io; /* Client socket */ + guint io_watch; /* Client IO watch id */ + + guint tty_timer; + int tty_tries; + gboolean tty_open; + int tty_id; + char tty_name[PATH_MAX]; + + GPid pnatd_pid; +}; + +struct dun_server { + bdaddr_t bda; /* Local adapter address */ + + uint32_t record_handle; /* Local SDP record handle */ + GIOChannel *server; /* Server socket */ + + int rfcomm_ctl; + + struct dun_client client; +}; + +static GSList *servers = NULL; + +static void disconnect(struct dun_server *server) +{ + struct dun_client *client = &server->client; + + if (!client->io) + return; + + if (client->io_watch > 0) { + g_source_remove(client->io_watch); + client->io_watch = 0; + } + + g_io_channel_shutdown(client->io, TRUE, NULL); + g_io_channel_unref(client->io); + client->io = NULL; + + if (client->pnatd_pid > 0) { + kill(client->pnatd_pid, SIGTERM); + client->pnatd_pid = 0; + } + + if (client->tty_timer > 0) { + g_source_remove(client->tty_timer); + client->tty_timer = 0; + } + + if (client->tty_id >= 0) { + struct rfcomm_dev_req req; + + memset(&req, 0, sizeof(req)); + req.dev_id = client->tty_id; + req.flags = (1 << RFCOMM_HANGUP_NOW); + ioctl(server->rfcomm_ctl, RFCOMMRELEASEDEV, &req); + + client->tty_name[0] = '\0'; + client->tty_open = FALSE; + client->tty_id = -1; + } +} + +static gboolean client_event(GIOChannel *chan, + GIOCondition cond, gpointer data) +{ + struct dun_server *server = data; + struct dun_client *client = &server->client; + char addr[18]; + + ba2str(&client->bda, addr); + + DBG("Disconnected DUN from %s (%s)", addr, client->tty_name); + + client->io_watch = 0; + disconnect(server); + + return FALSE; +} + +static void pnatd_exit(GPid pid, gint status, gpointer user_data) +{ + struct dun_server *server = user_data; + struct dun_client *client = &server->client; + + if (WIFEXITED(status)) + DBG("pnatd (%d) exited with status %d", pid, + WEXITSTATUS(status)); + else + DBG("pnatd (%d) was killed by signal %d", pid, + WTERMSIG(status)); + g_spawn_close_pid(pid); + + if (pid != client->pnatd_pid) + return; + + /* So disconnect() doesn't send SIGTERM to a non-existing process */ + client->pnatd_pid = 0; + + disconnect(server); +} + +static gboolean start_pnatd(struct dun_server *server) +{ + struct dun_client *client = &server->client; + GSpawnFlags flags = G_SPAWN_DO_NOT_REAP_CHILD | G_SPAWN_SEARCH_PATH; + char *argv[] = { PNATD, client->tty_name, NULL }; + GError *err = NULL; + GPid pid; + + g_spawn_async(NULL, argv, NULL, flags, NULL, NULL, &pid, &err); + if (err != NULL) { + error("Unable to spawn pnatd: %s", err->message); + g_error_free(err); + return FALSE; + } + + DBG("pnatd started for %s with pid %d", client->tty_name, pid); + + client->pnatd_pid = pid; + + /* We do not store the GSource id since g_remove_source doesn't + * make sense for a child watch. If the callback gets removed + * waitpid won't be called and the child remains as a zombie) + */ + g_child_watch_add(pid, pnatd_exit, server); + + return TRUE; +} + +static gboolean tty_try_open(gpointer user_data) +{ + struct dun_server *server = user_data; + struct dun_client *client = &server->client; + int tty_fd; + + tty_fd = open(client->tty_name, O_RDONLY | O_NOCTTY); + if (tty_fd < 0) { + if (errno == EACCES) + goto disconnect; + + client->tty_tries--; + + if (client->tty_tries <= 0) + goto disconnect; + + return TRUE; + } + + DBG("%s created for DUN", client->tty_name); + + client->tty_open = TRUE; + client->tty_timer = 0; + + g_io_channel_unref(client->io); + g_source_remove(client->io_watch); + + client->io = g_io_channel_unix_new(tty_fd); + client->io_watch = g_io_add_watch(client->io, + G_IO_HUP | G_IO_ERR | G_IO_NVAL, + client_event, server); + + if (!start_pnatd(server)) + goto disconnect; + + return FALSE; + +disconnect: + client->tty_timer = 0; + disconnect(server); + return FALSE; +} + +static gboolean create_tty(struct dun_server *server) +{ + struct dun_client *client = &server->client; + struct rfcomm_dev_req req; + int sk = g_io_channel_unix_get_fd(client->io); + + memset(&req, 0, sizeof(req)); + req.dev_id = -1; + req.flags = (1 << RFCOMM_REUSE_DLC) | (1 << RFCOMM_RELEASE_ONHUP); + + bacpy(&req.src, &server->bda); + bacpy(&req.dst, &client->bda); + + bt_io_get(client->io, BT_IO_RFCOMM, NULL, + BT_IO_OPT_DEST_CHANNEL, &req.channel, + BT_IO_OPT_INVALID); + + client->tty_id = ioctl(sk, RFCOMMCREATEDEV, &req); + if (client->tty_id < 0) { + error("Can't create RFCOMM TTY: %s", strerror(errno)); + return FALSE; + } + + snprintf(client->tty_name, PATH_MAX - 1, "/dev/rfcomm%d", + client->tty_id); + + client->tty_tries = TTY_TRIES; + + tty_try_open(server); + if (!client->tty_open && client->tty_tries > 0) + client->tty_timer = g_timeout_add(TTY_TIMEOUT, + tty_try_open, server); + + return TRUE; +} + +static void connect_cb(GIOChannel *io, GError *err, gpointer user_data) +{ + struct dun_server *server = user_data; + + if (err) { + error("Accepting DUN connection failed: %s", err->message); + disconnect(server); + return; + } + + if (!create_tty(server)) { + error("Device creation failed"); + disconnect(server); + } +} + +static void auth_cb(DBusError *derr, void *user_data) +{ + struct dun_server *server = user_data; + struct dun_client *client = &server->client; + GError *err = NULL; + + if (derr && dbus_error_is_set(derr)) { + error("DUN access denied: %s", derr->message); + goto drop; + } + + if (!bt_io_accept(client->io, connect_cb, server, NULL, &err)) { + error("bt_io_accept: %s", err->message); + g_error_free(err); + goto drop; + } + + return; + +drop: + disconnect(server); +} + +static gboolean auth_watch(GIOChannel *chan, GIOCondition cond, gpointer data) +{ + struct dun_server *server = data; + struct dun_client *client = &server->client; + + error("DUN client disconnected while waiting for authorization"); + + btd_cancel_authorization(&server->bda, &client->bda); + + disconnect(server); + + return FALSE; +} + +static void confirm_cb(GIOChannel *io, gpointer user_data) +{ + struct dun_server *server = user_data; + struct dun_client *client = &server->client; + GError *err = NULL; + + if (client->io) { + error("Rejecting DUN connection since one already exists"); + return; + } + + bt_io_get(io, BT_IO_RFCOMM, &err, + BT_IO_OPT_DEST_BDADDR, &client->bda, + BT_IO_OPT_INVALID); + if (err != NULL) { + error("Unable to get DUN source and dest address: %s", + err->message); + g_error_free(err); + return; + } + + if (btd_request_authorization(&server->bda, &client->bda, DUN_UUID, + auth_cb, user_data) < 0) { + error("Requesting DUN authorization failed"); + return; + } + + client->io_watch = g_io_add_watch(io, G_IO_ERR | G_IO_HUP | G_IO_NVAL, + (GIOFunc) auth_watch, server); + client->io = g_io_channel_ref(io); +} + +static sdp_record_t *dun_record(uint8_t ch) +{ + sdp_list_t *svclass_id, *pfseq, *apseq, *root, *aproto; + uuid_t root_uuid, dun, gn, l2cap, rfcomm; + sdp_profile_desc_t profile; + sdp_list_t *proto[2]; + sdp_record_t *record; + sdp_data_t *channel; + + record = sdp_record_alloc(); + if (!record) + return NULL; + + sdp_uuid16_create(&root_uuid, PUBLIC_BROWSE_GROUP); + root = sdp_list_append(NULL, &root_uuid); + sdp_set_browse_groups(record, root); + + sdp_uuid16_create(&dun, DIALUP_NET_SVCLASS_ID); + svclass_id = sdp_list_append(NULL, &dun); + sdp_uuid16_create(&gn, GENERIC_NETWORKING_SVCLASS_ID); + svclass_id = sdp_list_append(svclass_id, &gn); + sdp_set_service_classes(record, svclass_id); + + sdp_uuid16_create(&profile.uuid, DIALUP_NET_PROFILE_ID); + profile.version = 0x0100; + pfseq = sdp_list_append(NULL, &profile); + sdp_set_profile_descs(record, pfseq); + + sdp_uuid16_create(&l2cap, L2CAP_UUID); + proto[0] = sdp_list_append(NULL, &l2cap); + apseq = sdp_list_append(NULL, proto[0]); + + sdp_uuid16_create(&rfcomm, RFCOMM_UUID); + proto[1] = sdp_list_append(NULL, &rfcomm); + channel = sdp_data_alloc(SDP_UINT8, &ch); + proto[1] = sdp_list_append(proto[1], channel); + apseq = sdp_list_append(apseq, proto[1]); + + aproto = sdp_list_append(0, apseq); + sdp_set_access_protos(record, aproto); + + sdp_set_info_attr(record, "Dial-Up Networking", 0, 0); + + sdp_data_free(channel); + sdp_list_free(root, NULL); + sdp_list_free(svclass_id, NULL); + sdp_list_free(proto[0], NULL); + sdp_list_free(proto[1], NULL); + sdp_list_free(pfseq, NULL); + sdp_list_free(apseq, NULL); + sdp_list_free(aproto, NULL); + + return record; +} + +static gint server_cmp(gconstpointer a, gconstpointer b) +{ + const struct dun_server *server = a; + const bdaddr_t *src = b; + + return bacmp(src, &server->bda); +} + +static int pnat_probe(struct btd_adapter *adapter) +{ + struct dun_server *server; + GIOChannel *io; + GError *err = NULL; + sdp_record_t *record; + bdaddr_t src; + + adapter_get_address(adapter, &src); + + server = g_new0(struct dun_server, 1); + + io = bt_io_listen(BT_IO_RFCOMM, NULL, confirm_cb, server, NULL, &err, + BT_IO_OPT_SOURCE_BDADDR, &src, + BT_IO_OPT_CHANNEL, DUN_CHANNEL, + BT_IO_OPT_INVALID); + if (err != NULL) { + error("Failed to start DUN server: %s", err->message); + g_error_free(err); + goto fail; + } + + record = dun_record(DUN_CHANNEL); + if (!record) { + error("Unable to allocate new service record"); + goto fail; + } + + if (add_record_to_server(&src, record) < 0) { + error("Unable to register DUN service record"); + goto fail; + } + + server->rfcomm_ctl = socket(AF_BLUETOOTH, SOCK_RAW, BTPROTO_RFCOMM); + if (server->rfcomm_ctl < 0) { + error("Unable to create RFCOMM control socket: %s (%d)", + strerror(errno), errno); + goto fail; + } + + server->server = io; + server->record_handle = record->handle; + bacpy(&server->bda, &src); + + servers = g_slist_append(servers, server); + + return 0; + +fail: + if (io != NULL) + g_io_channel_unref(io); + g_free(server); + return -EIO; +} + +static void pnat_remove(struct btd_adapter *adapter) +{ + struct dun_server *server; + GSList *match; + bdaddr_t src; + + adapter_get_address(adapter, &src); + + match = g_slist_find_custom(servers, &src, server_cmp); + if (match == NULL) + return; + + server = match->data; + + servers = g_slist_delete_link(servers, match); + + disconnect(server); + + remove_record_from_server(server->record_handle); + close(server->rfcomm_ctl); + g_io_channel_shutdown(server->server, TRUE, NULL); + g_io_channel_unref(server->server); + g_free(server); +} + +static struct btd_adapter_driver pnat_server = { + .name = "pnat-server", + .probe = pnat_probe, + .remove = pnat_remove, +}; + +static int pnat_init(void) +{ + DBG("Setup Phonet AT (DUN) plugin"); + + return btd_register_adapter_driver(&pnat_server); +} + +static void pnat_exit(void) +{ + DBG("Cleanup Phonet AT (DUN) plugin"); + + btd_unregister_adapter_driver(&pnat_server); +} + +BLUETOOTH_PLUGIN_DEFINE(pnat, VERSION, + BLUETOOTH_PLUGIN_PRIORITY_DEFAULT, + pnat_init, pnat_exit) |