summaryrefslogtreecommitdiffstats
path: root/serial
diff options
context:
space:
mode:
Diffstat (limited to 'serial')
-rw-r--r--serial/Makefile.am24
-rw-r--r--serial/main.c150
-rw-r--r--serial/manager.c1956
-rw-r--r--serial/manager.h34
-rw-r--r--serial/port.c404
-rw-r--r--serial/port.h34
-rw-r--r--serial/serial-api.txt176
-rw-r--r--serial/storage.c170
-rw-r--r--serial/storage.h30
-rwxr-xr-xserial/test-serial40
10 files changed, 3018 insertions, 0 deletions
diff --git a/serial/Makefile.am b/serial/Makefile.am
new file mode 100644
index 00000000..0e6c47f7
--- /dev/null
+++ b/serial/Makefile.am
@@ -0,0 +1,24 @@
+
+if SERIALPLUGIN
+plugindir = $(libdir)/bluetooth/plugins
+
+plugin_LTLIBRARIES = serial.la
+
+serial_la_SOURCES = main.c \
+ manager.h manager.c port.h port.c \
+ storage.h storage.c
+
+LDADD = $(top_builddir)/common/libhelper.a \
+ @GDBUS_LIBS@ @GLIB_LIBS@ @DBUS_LIBS@ @BLUEZ_LIBS@
+endif
+
+AM_LDFLAGS = -module -avoid-version -no-undefined \
+ -export-symbols-regex bluetooth_plugin_desc
+
+AM_CFLAGS = @BLUEZ_CFLAGS@ @DBUS_CFLAGS@ @GLIB_CFLAGS@ @GDBUS_CFLAGS@
+
+INCLUDES = -I$(top_srcdir)/common -I$(top_srcdir)/hcid -I$(top_srcdir)/sdpd
+
+EXTRA_DIST = serial-api.txt test-serial
+
+MAINTAINERCLEANFILES = Makefile.in
diff --git a/serial/main.c b/serial/main.c
new file mode 100644
index 00000000..20aea93a
--- /dev/null
+++ b/serial/main.c
@@ -0,0 +1,150 @@
+/*
+ *
+ * BlueZ - Bluetooth protocol stack for Linux
+ *
+ * Copyright (C) 2004-2008 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 <sys/types.h>
+
+#include <bluetooth/bluetooth.h>
+#include <bluetooth/sdp.h>
+
+#include <gdbus.h>
+
+#include "plugin.h"
+#include "device.h"
+#include "adapter.h"
+#include "logging.h"
+#include "manager.h"
+#include "port.h"
+
+#define SERIAL_PORT_UUID "00001101-0000-1000-8000-00805F9B34FB"
+#define DIALUP_NET_UUID "00001103-0000-1000-8000-00805F9B34FB"
+
+#define SERIAL_INTERFACE "org.bluez.Serial"
+#define ERROR_INVALID_ARGS "org.bluez.Error.InvalidArguments"
+#define ERROR_DOES_NOT_EXIST "org.bluez.Error.DoesNotExist"
+
+static DBusMessage *serial_connect(DBusConnection *conn,
+ DBusMessage *msg, void *user_data)
+{
+ struct btd_device *device = user_data;
+ const char *target;
+ char src[18], dst[18];
+
+ if (dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &target,
+ DBUS_TYPE_INVALID) == FALSE)
+ return NULL;
+
+ ba2str(&device->src, src);
+ ba2str(&device->dst, dst);
+
+ service_connect(conn, msg, src, dst, target);
+
+ return NULL;
+}
+
+static DBusMessage *serial_disconnect(DBusConnection *conn,
+ DBusMessage *msg, void *user_data)
+{
+ const char *device, *sender;
+ int err, id;
+
+ if (dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &device,
+ DBUS_TYPE_INVALID) == FALSE)
+ return NULL;
+
+ sender = dbus_message_get_sender(msg);
+
+ if (sscanf(device, "/dev/rfcomm%d", &id) != 1)
+ return g_dbus_create_error(msg, ERROR_INVALID_ARGS, NULL);
+
+ err = port_remove_listener(sender, device);
+ if (err < 0)
+ return g_dbus_create_error(msg, ERROR_DOES_NOT_EXIST, NULL);
+
+ return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
+}
+
+static GDBusMethodTable serial_methods[] = {
+ { "Connect", "s", "s", serial_connect, G_DBUS_METHOD_FLAG_ASYNC },
+ { "Disconnect", "s", "", serial_disconnect },
+ { }
+};
+
+static DBusConnection *conn;
+
+static int serial_probe(struct btd_device *device)
+{
+ DBG("path %s", device->path);
+
+ if (g_dbus_register_interface(conn, device->path, SERIAL_INTERFACE,
+ serial_methods, NULL, NULL,
+ device, NULL) == FALSE)
+ return -1;
+
+ return 0;
+}
+
+static void serial_remove(struct btd_device *device)
+{
+ DBG("path %s", device->path);
+
+ g_dbus_unregister_interface(conn, device->path, SERIAL_INTERFACE);
+}
+
+static struct btd_device_driver serial_driver = {
+ .name = "serial",
+ .uuids = BTD_UUIDS(SERIAL_PORT_UUID, DIALUP_NET_UUID),
+ .probe = serial_probe,
+ .remove = serial_remove,
+};
+
+static int serial_init(void)
+{
+ conn = dbus_bus_get(DBUS_BUS_SYSTEM, NULL);
+ if (conn == NULL)
+ return -EIO;
+
+ if (serial_manager_init(conn) < 0) {
+ dbus_connection_unref(conn);
+ return -EIO;
+ }
+
+ btd_register_device_driver(&serial_driver);
+
+ return 0;
+}
+
+static void serial_exit(void)
+{
+ btd_unregister_device_driver(&serial_driver);
+
+ serial_manager_exit();
+
+ dbus_connection_unref(conn);
+}
+
+BLUETOOTH_PLUGIN_DEFINE("serial", serial_init, serial_exit)
diff --git a/serial/manager.c b/serial/manager.c
new file mode 100644
index 00000000..442c386e
--- /dev/null
+++ b/serial/manager.c
@@ -0,0 +1,1956 @@
+/*
+ *
+ * BlueZ - Bluetooth protocol stack for Linux
+ *
+ * Copyright (C) 2004-2008 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 <ctype.h>
+#include <dirent.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <termios.h>
+#include <unistd.h>
+#include <arpa/inet.h>
+#include <sys/param.h>
+#include <sys/ioctl.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <sys/un.h>
+
+#include <bluetooth/bluetooth.h>
+#include <bluetooth/hci.h>
+#include <bluetooth/hci_lib.h>
+#include <bluetooth/sdp.h>
+#include <bluetooth/sdp_lib.h>
+#include <bluetooth/rfcomm.h>
+
+#include <glib.h>
+#include <gdbus.h>
+
+#include "../hcid/dbus-common.h"
+
+#include "logging.h"
+#include "textfile.h"
+
+#include "error.h"
+#include "port.h"
+#include "storage.h"
+#include "manager.h"
+#include "sdpd.h"
+#include "glib-helper.h"
+
+#define SERIAL_PROXY_INTERFACE "org.bluez.serial.Proxy"
+#define BUF_SIZE 1024
+
+/* Waiting for udev to create the device node */
+#define MAX_OPEN_TRIES 5
+#define OPEN_WAIT 300 /* ms */
+
+struct pending_connect {
+ DBusConnection *conn;
+ DBusMessage *msg;
+ char *adapter; /* Adapter address */
+ char *address; /* Destination address */
+ char *pattern; /* Connection request pattern */
+ uint8_t channel;
+ char *dev; /* tty device name */
+ int id; /* RFCOMM device id */
+ int ntries; /* Open attempts */
+ int canceled; /* Operation canceled */
+ guint listener_id;
+};
+
+/* FIXME: Common file required */
+static struct {
+ const char *name;
+ uint16_t class;
+} serial_services[] = {
+ { "vcp", VIDEO_CONF_SVCLASS_ID },
+ { "pbap", PBAP_SVCLASS_ID },
+ { "sap", SAP_SVCLASS_ID },
+ { "ftp", OBEX_FILETRANS_SVCLASS_ID },
+ { "bpp", BASIC_PRINTING_SVCLASS_ID },
+ { "bip", IMAGING_SVCLASS_ID },
+ { "synch", IRMC_SYNC_SVCLASS_ID },
+ { "dun", DIALUP_NET_SVCLASS_ID },
+ { "opp", OBEX_OBJPUSH_SVCLASS_ID },
+ { "fax", FAX_SVCLASS_ID },
+ { "spp", SERIAL_PORT_SVCLASS_ID },
+ { NULL }
+};
+
+typedef enum {
+ TTY_PROXY,
+ UNIX_SOCKET_PROXY,
+ TCP_SOCKET_PROXY,
+ UNKNOWN_PROXY_TYPE = 0xFF
+} proxy_type_t;
+
+struct proxy {
+ bdaddr_t src;
+ bdaddr_t dst;
+ char *uuid128; /* UUID 128 */
+ char *address; /* TTY or Unix socket name */
+ char *path; /* D-Bus path */
+ short int port; /* TCP port */
+ proxy_type_t type; /* TTY or Unix socket */
+ struct termios sys_ti; /* Default TTY setting */
+ struct termios proxy_ti; /* Proxy TTY settings */
+ uint8_t channel; /* RFCOMM channel */
+ uint32_t record_id; /* Service record id */
+ GIOChannel *io; /* Server listen */
+ guint rfcomm_watch; /* RFCOMM watch: Remote */
+ guint local_watch; /* Local watch: TTY or Unix socket */
+};
+
+static DBusConnection *connection = NULL;
+static GSList *pending_connects = NULL;
+static GSList *ports_paths = NULL;
+static GSList *proxies = NULL;
+static int rfcomm_ctl = -1;
+static int sk_counter = 0;
+
+static void disable_proxy(struct proxy *prx)
+{
+ if (prx->rfcomm_watch) {
+ g_source_remove(prx->rfcomm_watch);
+ prx->rfcomm_watch = 0;
+ }
+
+ if (prx->local_watch) {
+ g_source_remove(prx->local_watch);
+ prx->local_watch = 0;
+ }
+
+ remove_record_from_server(prx->record_id);
+ prx->record_id = 0;
+
+ g_io_channel_unref(prx->io);
+ prx->io = NULL;
+}
+
+static void proxy_free(struct proxy *prx)
+{
+ g_free(prx->address);
+ g_free(prx->uuid128);
+ g_free(prx);
+}
+
+static void pending_connect_free(struct pending_connect *pc)
+{
+ if (pc->conn)
+ dbus_connection_unref(pc->conn);
+ if (pc->msg)
+ dbus_message_unref(pc->msg);
+ if (pc->adapter)
+ g_free(pc->adapter);
+ if (pc->address)
+ g_free(pc->address);
+ if (pc->pattern)
+ g_free(pc->pattern);
+ if (pc->dev)
+ g_free(pc->dev);
+ g_free(pc);
+}
+
+static struct pending_connect *find_pending_connect_by_pattern(const char *bda,
+ const char *pattern)
+{
+ GSList *l;
+
+ /* Pattern can be friendly name, uuid128, record handle or channel */
+ for (l = pending_connects; l != NULL; l = l->next) {
+ struct pending_connect *pending = l->data;
+ if (!strcasecmp(pending->address, bda) &&
+ !strcasecmp(pending->pattern, pattern))
+ return pending;
+ }
+
+ return NULL;
+}
+
+static void transaction_owner_exited(void *data)
+{
+ struct pending_connect *pc = data;
+
+ debug("transaction owner exited");
+
+ if (pc->id >= 0)
+ rfcomm_release(pc->id);
+
+ pending_connects = g_slist_remove(pending_connects, pc);
+
+ pending_connect_free(pc);
+}
+
+static void pending_connect_remove(struct pending_connect *pc)
+{
+ g_dbus_remove_watch(pc->conn, pc->listener_id);
+ pending_connects = g_slist_remove(pending_connects, pc);
+ pending_connect_free(pc);
+}
+
+static void open_notify(int fd, int err, struct pending_connect *pc)
+{
+ DBusMessage *reply;
+ bdaddr_t dst;
+
+ if (err) {
+ /* Max tries exceeded */
+ rfcomm_release(pc->id);
+ error_connection_attempt_failed(pc->conn, pc->msg, err);
+ return;
+ }
+
+ if (pc->canceled) {
+ rfcomm_release(pc->id);
+ error_canceled(pc->conn, pc->msg, "Connection canceled");
+ return;
+ }
+
+ /* Reply to the requestor */
+ reply = dbus_message_new_method_return(pc->msg);
+ dbus_message_append_args(reply,
+ DBUS_TYPE_STRING, &pc->dev,
+ DBUS_TYPE_INVALID);
+ dbus_connection_send(pc->conn, reply, NULL);
+ dbus_message_unref(reply);
+
+ /* Send the D-Bus signal */
+ g_dbus_emit_signal(pc->conn, SERIAL_MANAGER_PATH,
+ SERIAL_MANAGER_INTERFACE, "ServiceConnected" ,
+ DBUS_TYPE_STRING, &pc->dev,
+ DBUS_TYPE_INVALID);
+
+ str2ba(pc->address, &dst);
+
+ /* Add the RFCOMM connection listener */
+ port_add_listener(pc->conn, pc->id, &dst, fd,
+ pc->dev, dbus_message_get_sender(pc->msg));
+}
+
+static gboolean open_continue(struct pending_connect *pc)
+{
+ int fd;
+
+ if (!g_slist_find(pending_connects, pc))
+ return FALSE; /* Owner exited */
+
+ fd = open(pc->dev, O_RDONLY | O_NOCTTY);
+ if (fd < 0) {
+ int err = errno;
+ error("Could not open %s: %s (%d)",
+ pc->dev, strerror(err), err);
+ if (++pc->ntries >= MAX_OPEN_TRIES) {
+ /* Reporting error */
+ open_notify(fd, err, pc);
+ pending_connect_remove(pc);
+ return FALSE;
+ }
+ return TRUE;
+ }
+ /* Connection succeeded */
+ open_notify(fd, 0, pc);
+ pending_connect_remove(pc);
+ return FALSE;
+}
+
+int port_open(struct pending_connect *pc)
+{
+ int fd;
+
+ fd = open(pc->dev, O_RDONLY | O_NOCTTY);
+ if (fd < 0) {
+ g_timeout_add(OPEN_WAIT, (GSourceFunc) open_continue, pc);
+ return -EINPROGRESS;
+ }
+
+ return fd;
+}
+
+static uint16_t str2class(const char *pattern)
+{
+ int i;
+
+ for (i = 0; serial_services[i].name; i++) {
+ if (strcasecmp(serial_services[i].name, pattern) == 0)
+ return serial_services[i].class;
+ }
+
+ return 0;
+}
+
+int rfcomm_release(int16_t id)
+{
+ struct rfcomm_dev_req req;
+
+ memset(&req, 0, sizeof(req));
+ req.dev_id = id;
+
+ /*
+ * We are hitting a kernel bug inside RFCOMM code when
+ * RFCOMM_HANGUP_NOW bit is set on request's flags passed to
+ * ioctl(RFCOMMRELEASEDEV)!
+ */
+ req.flags = (1 << RFCOMM_HANGUP_NOW);
+
+ if (ioctl(rfcomm_ctl, RFCOMMRELEASEDEV, &req) < 0) {
+ int err = errno;
+ error("Can't release device %d: %s (%d)",
+ id, strerror(err), err);
+ return -err;
+ }
+
+ return 0;
+}
+
+static int rfcomm_bind(bdaddr_t *src, bdaddr_t *dst, int16_t dev_id, uint8_t ch)
+{
+ struct rfcomm_dev_req req;
+ int id;
+
+ memset(&req, 0, sizeof(req));
+ req.dev_id = dev_id;
+ req.flags = 0;
+ bacpy(&req.src, src);
+ bacpy(&req.dst, dst);
+ req.channel = ch;
+
+ id = ioctl(rfcomm_ctl, RFCOMMCREATEDEV, &req);
+ if (id < 0) {
+ int err = errno;
+ error("RFCOMMCREATEDEV failed: %s (%d)", strerror(err), err);
+ return -err;
+ }
+
+ return id;
+}
+
+static void rfcomm_connect_cb(GIOChannel *chan, int err_cb, const bdaddr_t *src,
+ const bdaddr_t *dst, gpointer user_data)
+{
+ struct pending_connect *pc = user_data;
+ struct rfcomm_dev_req req;
+ int sk, err, fd;
+
+ /* Owner exited? */
+ if (!g_slist_find(pending_connects, pc))
+ return;
+
+ if (pc->canceled) {
+ error_canceled(pc->conn, pc->msg, "Connection canceled");
+ goto fail;
+ }
+
+ if (err_cb < 0) {
+ error("connect(): %s (%d)", strerror(-err_cb), -err_cb);
+ error_connection_attempt_failed(pc->conn, pc->msg, -err_cb);
+ goto fail;
+ }
+
+ debug("rfcomm_connect_cb: connected");
+
+ memset(&req, 0, sizeof(req));
+ req.dev_id = -1;
+ req.flags = (1 << RFCOMM_REUSE_DLC);
+ str2ba(pc->adapter, &req.src);
+ str2ba(pc->address, &req.dst);
+ req.channel = pc->channel;
+
+ sk = g_io_channel_unix_get_fd(chan);
+ pc->id = ioctl(sk, RFCOMMCREATEDEV, &req);
+ g_io_channel_close(chan);
+ g_io_channel_unref(chan);
+ if (pc->id < 0) {
+ err = errno;
+ error("ioctl(RFCOMMCREATEDEV): %s (%d)", strerror(err), err);
+ error_connection_attempt_failed(pc->conn, pc->msg, err);
+ goto fail;
+ }
+ pc->dev = g_new0(char, 16);
+ snprintf(pc->dev, 16, "/dev/rfcomm%d", pc->id);
+
+ /* Addressing connect port */
+ fd = port_open(pc);
+ if (fd < 0)
+ /* Open in progress: Wait the callback */
+ return;
+
+ open_notify(fd, 0, pc);
+fail:
+ pending_connect_remove(pc);
+}
+
+static inline DBusMessage *does_not_exist(DBusMessage *msg,
+ const char *description)
+{
+ return g_dbus_create_error(msg, ERROR_INTERFACE ".DoesNotExist",
+ description);
+}
+
+static inline DBusMessage *invalid_arguments(DBusMessage *msg,
+ const char *description)
+{
+ return g_dbus_create_error(msg, ERROR_INTERFACE ".InvalidArguments",
+ description);
+}
+
+static inline DBusMessage *failed(DBusMessage *msg, const char *description)
+{
+ return g_dbus_create_error(msg, ERROR_INTERFACE ".Failed",
+ description);
+}
+
+static DBusMessage *create_channel_port(DBusConnection *conn,
+ DBusMessage *msg, const char *adapter,
+ const char *address, const char *name,
+ long channel, void *data)
+{
+ char path[MAX_PATH_LENGTH], port_name[16];
+ const char *ppath = path;
+ DBusMessage *reply;
+ int err;
+ bdaddr_t src, dst;
+
+ if (channel < 1 || channel > 30)
+ return invalid_arguments(msg, "Invalid RFCOMM channel");
+
+ str2ba(adapter, &src);
+ str2ba(address, &dst);
+ err = rfcomm_bind(&src, &dst, -1, channel);
+ if (err < 0)
+ return failed(msg, strerror(-err));
+
+ snprintf(port_name, sizeof(port_name), "/dev/rfcomm%d", err);
+ port_store(&src, &dst, err, channel, name);
+ port_register(conn, err, &src, &dst, port_name, path, name);
+ ports_paths = g_slist_append(ports_paths, g_strdup(path));
+
+ reply = dbus_message_new_method_return(msg);
+ if (!reply)
+ return NULL;
+
+ dbus_message_append_args(reply,
+ DBUS_TYPE_STRING, &ppath,
+ DBUS_TYPE_INVALID);
+ dbus_connection_send(conn, reply, NULL);
+ dbus_message_unref(reply);
+
+ g_dbus_emit_signal(conn, SERIAL_MANAGER_PATH,
+ SERIAL_MANAGER_INTERFACE, "PortCreated" ,
+ DBUS_TYPE_STRING, &ppath,
+ DBUS_TYPE_INVALID);
+
+ return NULL;
+}
+
+static DBusMessage *connect_pending(DBusConnection *conn, DBusMessage *msg,
+ struct pending_connect *pc)
+{
+ int err;
+ bdaddr_t src, dst;
+
+ if (!g_slist_find(pending_connects, pc)) {
+ pending_connects = g_slist_append(pending_connects, pc);
+ pc->listener_id = g_dbus_add_disconnect_watch(conn,
+ dbus_message_get_sender(msg),
+ transaction_owner_exited, pc,
+ NULL);
+ }
+
+ str2ba(pc->adapter, &src);
+ str2ba(pc->address, &dst);
+
+ err = bt_rfcomm_connect(&src, &dst, pc->channel, rfcomm_connect_cb, pc);
+ if (err < 0) {
+ const char *strerr = strerror(-err);
+ error("RFCOMM connect failed: %s(%d)", strerr, -err);
+ pending_connects = g_slist_remove(pending_connects, pc);
+ pending_connect_free(pc);
+ return g_dbus_create_error(msg, ERROR_INTERFACE
+ ".ConnectionAttemptFailed",
+ "%s", strerror(-err));
+ }
+
+ return NULL;
+}
+
+static void record_cb(sdp_list_t *recs, int err, gpointer data)
+{
+ struct pending_connect *pc;
+ sdp_record_t *rec = NULL;
+ sdp_list_t *protos;
+ int ch;
+ bdaddr_t dst;
+
+ /* Owner exited? */
+ if (!g_slist_find(pending_connects, data))
+ return;
+
+ pc = data;
+ if (pc->canceled) {
+ error_canceled(pc->conn, pc->msg, "Connection canceled");
+ goto fail;
+ }
+
+ if (err < 0) {
+ error_connection_attempt_failed(pc->conn, pc->msg, -err);
+ goto fail;
+ }
+
+ if (!recs || !recs->data) {
+ error_not_supported(pc->conn, pc->msg);
+ error("Invalid service record length");
+ goto fail;
+ }
+
+ rec = recs->data;
+ if (sdp_get_access_protos(rec, &protos) < 0) {
+ error_not_supported(pc->conn, pc->msg);
+ goto fail;
+ }
+
+ ch = sdp_get_proto_port(protos, RFCOMM_UUID);
+ sdp_list_foreach(protos, (sdp_list_func_t) sdp_list_free, NULL);
+ sdp_list_free(protos, NULL);
+
+ if (ch < 1 || ch > 30) {
+ error("Channel out of range: %d", ch);
+ error_not_supported(pc->conn, pc->msg);
+ goto fail;
+ }
+
+ str2ba(pc->address, &dst);
+
+ if (dbus_message_has_member(pc->msg, "CreatePort")) {
+ sdp_data_t *d;
+ char *svcname = NULL;
+
+ d = sdp_data_get(rec, SDP_ATTR_SVCNAME_PRIMARY);
+ if (d) {
+ svcname = g_new0(char, d->unitSize);
+ snprintf(svcname, d->unitSize, "%.*s",
+ d->unitSize, d->val.str);
+ }
+
+ create_channel_port(pc->conn, pc->msg, pc->adapter,
+ pc->address, svcname, ch, data);
+
+ if (svcname)
+ g_free(svcname);
+ } else {
+ /* ConnectService */
+ pc->channel = ch;
+
+ connect_pending(pc->conn, pc->msg, pc);
+
+ /* Wait the connect callback */
+ goto done;
+ }
+
+fail:
+ pending_connect_remove(pc);
+done:
+ if (recs)
+ sdp_list_free(recs, (sdp_free_func_t) sdp_record_free);
+}
+
+static int pattern2uuid(const char *pattern, uuid_t *uuid)
+{
+ uint16_t cls;
+ int i;
+
+ /* Friendly name */
+ cls = str2class(pattern);
+ if (cls) {
+ sdp_uuid16_create(uuid, cls);
+ return 0;
+ }
+
+ /* UUID 128*/
+ if (strlen(pattern) != 36)
+ return -EINVAL;
+
+ for (i = 0; i < 36; i++) {
+ if (i == 8 || i == 13 || i == 18 || i == 23) {
+ if (pattern[i] != '-')
+ return -EINVAL;
+
+ } else if (!isxdigit(pattern[i]))
+ return -EINVAL;
+ }
+
+ bt_string2uuid(uuid, pattern);
+ return 0;
+}
+
+static int pattern2long(const char *pattern, long *pval)
+{
+ char *endptr;
+ long val;
+
+ errno = 0;
+ val = strtol(pattern, &endptr, 0);
+ if ((errno == ERANGE && (val == LONG_MAX || val == LONG_MIN)) ||
+ (errno != 0 && val == 0) || (pattern == endptr)) {
+ return -EINVAL;
+ }
+
+ *pval = val;
+
+ return 0;
+}
+
+static DBusMessage *search_uuid(DBusConnection *conn, DBusMessage *msg,
+ const char *adapter, const char *address,
+ const char *pattern, uuid_t *uuid, void *data)
+{
+ struct pending_connect *pc;
+ int err;
+ bdaddr_t src, dst;
+
+ pc = g_new0(struct pending_connect, 1);
+ pc->conn = dbus_connection_ref(conn);
+ pc->msg = dbus_message_ref(msg);
+ pc->adapter = g_strdup(adapter);
+ pc->address = g_strdup(address);
+ pc->id = -1;
+ pc->pattern = g_strdup(pattern);
+
+ str2ba(adapter, &src);
+ str2ba(address, &dst);
+
+ err = bt_search_service(&src, &dst, uuid, record_cb, pc, NULL);
+ if (err < 0) {
+ pending_connect_free(pc);
+ return g_dbus_create_error(msg, ERROR_INTERFACE ".NotSuppported",
+ "Not Supported");
+ }
+
+ pending_connects = g_slist_append(pending_connects, pc);
+ pc->listener_id = g_dbus_add_disconnect_watch(conn,
+ dbus_message_get_sender(msg),
+ transaction_owner_exited, pc, NULL);
+
+ return NULL;
+}
+
+static DBusMessage *create_port(DBusConnection *conn,
+ DBusMessage *msg, void *data)
+{
+ const char *address, *pattern;
+ struct pending_connect *pending;
+ long val;
+ uuid_t uuid;
+ char adp[18];
+ int dev_id;
+ bdaddr_t src;
+
+ if (!dbus_message_get_args(msg, NULL,
+ DBUS_TYPE_STRING, &address,
+ DBUS_TYPE_STRING, &pattern,
+ DBUS_TYPE_INVALID))
+ return NULL;
+
+ dev_id = hci_get_route(NULL);
+ if ((dev_id < 0) || (hci_devba(dev_id, &src) < 0))
+ return g_dbus_create_error(msg, ERROR_INTERFACE ".NotAvailable",
+ "Adapter not Available");
+
+ pending = find_pending_connect_by_pattern(address, pattern);
+ if (pending)
+ return g_dbus_create_error(msg, ERROR_INTERFACE ".InProgress",
+ "Connection in Progress");
+
+ ba2str(&src, adp);
+
+ /* Friendly name or uuid128 */
+ if (pattern2uuid(pattern, &uuid) == 0)
+ return search_uuid(conn, msg, adp, address, pattern, &uuid,
+ data);
+
+ /* RFCOMM Channel */
+ if (pattern2long(pattern, &val) == 0)
+ return create_channel_port(conn, msg, adp, address, pattern,
+ val, data);
+
+ return g_dbus_create_error(msg, ERROR_INTERFACE ".InvalidArgument",
+ "Invalid pattern");
+}
+
+static void message_append_paths(DBusMessage *msg, const GSList *list)
+{
+ const GSList *l;
+ const char *path;
+ DBusMessageIter iter, iter_array;
+
+ dbus_message_iter_init_append(msg, &iter);
+ dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY,
+ DBUS_TYPE_STRING_AS_STRING, &iter_array);
+
+ for (l = list; l; l = l->next) {
+ path = l->data;
+ dbus_message_iter_append_basic(&iter_array,
+ DBUS_TYPE_STRING, &path);
+ }
+
+ dbus_message_iter_close_container(&iter, &iter_array);
+}
+
+static DBusMessage *list_ports(DBusConnection *conn,
+ DBusMessage *msg, void *data)
+{
+ DBusMessage *reply;
+
+ reply = dbus_message_new_method_return(msg);
+ if (!reply)
+ return NULL;
+
+ message_append_paths(reply, ports_paths);
+
+ return reply;
+}
+
+static DBusMessage *remove_port(DBusConnection *conn,
+ DBusMessage *msg, void *data)
+{
+ struct rfcomm_dev_info di;
+ const char *path;
+ GSList *l;
+ int16_t id;
+
+ if (!dbus_message_get_args(msg, NULL,
+ DBUS_TYPE_STRING, &path,
+ DBUS_TYPE_INVALID))
+ return NULL;
+
+ if (sscanf(path, SERIAL_MANAGER_PATH"/rfcomm%hd", &id) != 1)
+ return does_not_exist(msg, "Invalid RFCOMM node");
+
+ di.id = id;
+ if (ioctl(rfcomm_ctl, RFCOMMGETDEVINFO, &di) < 0)
+ return does_not_exist(msg, "Invalid RFCOMM node");
+ port_delete(&di.src, &di.dst, id);
+
+ if (port_unregister(path) < 0)
+ return does_not_exist(msg, "Invalid RFCOMM node");
+
+ g_dbus_emit_signal(conn, SERIAL_MANAGER_PATH,
+ SERIAL_MANAGER_INTERFACE, "PortRemoved" ,
+ DBUS_TYPE_STRING, &path,
+ DBUS_TYPE_INVALID);
+
+ l = g_slist_find_custom(ports_paths, path, (GCompareFunc) strcmp);
+ if (l) {
+ g_free(l->data);
+ ports_paths = g_slist_remove(ports_paths, l->data);
+ }
+
+ return dbus_message_new_method_return(msg);
+}
+
+static void add_lang_attr(sdp_record_t *r)
+{
+ sdp_lang_attr_t base_lang;
+ sdp_list_t *langs = 0;
+
+ /* UTF-8 MIBenum (http://www.iana.org/assignments/character-sets) */
+ base_lang.code_ISO639 = (0x65 << 8) | 0x6e;
+ base_lang.encoding = 106;
+ base_lang.base_offset = SDP_PRIMARY_LANG_BASE;
+ langs = sdp_list_append(0, &base_lang);
+ sdp_set_lang_attr(r, langs);
+ sdp_list_free(langs, 0);
+}
+
+static sdp_record_t *proxy_record_new(const char *uuid128, uint8_t channel)
+{
+ sdp_list_t *apseq, *aproto, *profiles, *proto[2], *root, *svclass_id;
+ uuid_t uuid, root_uuid, l2cap, rfcomm;
+ sdp_profile_desc_t profile;
+ sdp_record_t *record;
+ sdp_data_t *ch;
+
+ 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_list_free(root, NULL);
+
+ bt_string2uuid(&uuid, uuid128);
+ svclass_id = sdp_list_append(NULL, &uuid);
+ sdp_set_service_classes(record, svclass_id);
+ sdp_list_free(svclass_id, NULL);
+
+ sdp_uuid16_create(&profile.uuid, SERIAL_PORT_PROFILE_ID);
+ profile.version = 0x0100;
+ profiles = sdp_list_append(NULL, &profile);
+ sdp_set_profile_descs(record, profiles);
+ sdp_list_free(profiles, NULL);
+
+ 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);
+ ch = sdp_data_alloc(SDP_UINT8, &channel);
+ proto[1] = sdp_list_append(proto[1], ch);
+ apseq = sdp_list_append(apseq, proto[1]);
+
+ aproto = sdp_list_append(NULL, apseq);
+ sdp_set_access_protos(record, aproto);
+
+ add_lang_attr(record);
+
+ sdp_set_info_attr(record, "Port Proxy Entity",
+ NULL, "Port Proxy Entity");
+
+ sdp_data_free(ch);
+ sdp_list_free(proto[0], NULL);
+ sdp_list_free(proto[1], NULL);
+ sdp_list_free(apseq, NULL);
+ sdp_list_free(aproto, NULL);
+
+ return record;
+}
+
+static GIOError channel_write(GIOChannel *chan, char *buf, size_t size)
+{
+ GIOError err = G_IO_ERROR_NONE;
+ gsize wbytes, written;
+
+ wbytes = written = 0;
+ while (wbytes < size) {
+ err = g_io_channel_write(chan,
+ buf + wbytes,
+ size - wbytes,
+ &written);
+
+ if (err != G_IO_ERROR_NONE)
+ return err;
+
+ wbytes += written;
+ }
+
+ return err;
+}
+
+static gboolean forward_data(GIOChannel *chan, GIOCondition cond, gpointer data)
+{
+ char buf[BUF_SIZE];
+ GIOChannel *dest = data;
+ GIOError err;
+ size_t rbytes;
+
+ if (cond & G_IO_NVAL)
+ return FALSE;
+
+ if (cond & (G_IO_HUP | G_IO_ERR)) {
+ /* Try forward remaining data */
+ do {
+ rbytes = 0;
+ err = g_io_channel_read(chan, buf, sizeof(buf), &rbytes);
+ if (err != G_IO_ERROR_NONE || rbytes == 0)
+ break;
+
+ err = channel_write(dest, buf, rbytes);
+ } while (err == G_IO_ERROR_NONE);
+
+ g_io_channel_close(dest);
+ return FALSE;
+ }
+
+ rbytes = 0;
+ err = g_io_channel_read(chan, buf, sizeof(buf), &rbytes);
+ if (err != G_IO_ERROR_NONE)
+ return FALSE;
+
+ err = channel_write(dest, buf, rbytes);
+ if (err != G_IO_ERROR_NONE)
+ return FALSE;
+
+ return TRUE;
+}
+
+static inline int unix_socket_connect(const char *address)
+{
+ struct sockaddr_un addr;
+ int err, sk;
+
+ memset(&addr, 0, sizeof(addr));
+ addr.sun_family = PF_UNIX;
+
+ if (strncmp("x00", address, 3) == 0) {
+ /*
+ * Abstract namespace: first byte NULL, x00
+ * must be removed from the original address.
+ */
+ strcpy(addr.sun_path + 1, address + 3);
+ } else {
+ /* Filesystem address */
+ strcpy(addr.sun_path, address);
+ }
+
+ /* Unix socket */
+ sk = socket(AF_UNIX, SOCK_STREAM, 0);
+ if (sk < 0) {
+ err = errno;
+ error("Unix socket(%s) create failed: %s(%d)",
+ address, strerror(err), err);
+ return -err;
+ }
+
+ if (connect(sk, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
+ err = errno;
+ error("Unix socket(%s) connect failed: %s(%d)",
+ address, strerror(err), err);
+ close(sk);
+ errno = err;
+ return -err;
+ }
+
+ return sk;
+}
+
+static int tcp_socket_connect(const char *address)
+{
+ struct sockaddr_in addr;
+ int err, sk;
+ unsigned short int port;
+
+ memset(&addr, 0, sizeof(addr));
+
+ if (strncmp(address, "localhost", 9) != 0) {
+ error("Address should have the form localhost:port.");
+ return -1;
+ }
+ port = atoi(strchr(address, ':') + 1);
+ if (port <= 0) {
+ error("Invalid port '%d'.", port);
+ return -1;
+ }
+ addr.sin_family = AF_INET;
+ addr.sin_addr.s_addr = inet_addr("127.0.0.1");
+ addr.sin_port = htons(port);
+
+ sk = socket(PF_INET, SOCK_STREAM, 0);
+ if (sk < 0) {
+ err = errno;
+ error("TCP socket(%s) create failed %s(%d)", address,
+ strerror(err), err);
+ return -err;
+ }
+ if (connect(sk, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
+ err = errno;
+ error("TCP socket(%s) connect failed: %s(%d)",
+ address, strerror(err), err);
+ close(sk);
+ errno = err;
+ return -err;
+ }
+ return sk;
+}
+
+static inline int tty_open(const char *tty, struct termios *ti)
+{
+ int err, sk;
+
+ sk = open(tty, O_RDWR | O_NOCTTY);
+ if (sk < 0) {
+ err = errno;
+ error("Can't open TTY %s: %s(%d)", tty, strerror(err), err);
+ return -err;
+ }
+
+ if (ti && tcsetattr(sk, TCSANOW, ti) < 0) {
+ err = errno;
+ error("Can't change serial settings: %s(%d)",
+ strerror(err), err);
+ close(sk);
+ errno = err;
+ return -err;
+ }
+
+ return sk;
+}
+
+static void connect_event_cb(GIOChannel *chan, int err, const bdaddr_t *src,
+ const bdaddr_t *dst, gpointer data)
+{
+ struct proxy *prx = data;
+ GIOChannel *io;
+ int sk;
+
+ if (err < 0) {
+ error("accept: %s (%d)", strerror(-err), -err);
+ return;
+ }
+
+ bacpy(&prx->dst, dst);
+
+ switch (prx->type) {
+ case UNIX_SOCKET_PROXY:
+ sk = unix_socket_connect(prx->address);
+ break;
+ case TTY_PROXY:
+ sk = tty_open(prx->address, &prx->proxy_ti);
+ break;
+ case TCP_SOCKET_PROXY:
+ sk = tcp_socket_connect(prx->address);
+ break;
+ default:
+ sk = -1;
+ }
+
+ if (sk < 0) {
+ g_io_channel_unref(chan);
+ return;
+ }
+
+ g_io_channel_set_close_on_unref(chan, TRUE);
+ io = g_io_channel_unix_new(sk);
+ g_io_channel_set_close_on_unref(io, TRUE);
+
+ prx->rfcomm_watch = g_io_add_watch(chan,
+ G_IO_IN | G_IO_HUP | G_IO_ERR | G_IO_NVAL,
+ forward_data, io);
+
+ prx->local_watch = g_io_add_watch(io,
+ G_IO_IN | G_IO_HUP | G_IO_ERR | G_IO_NVAL,
+ forward_data, chan);
+
+ g_io_channel_unref(chan);
+ g_io_channel_unref(io);
+
+ return;
+}
+
+static DBusMessage *proxy_enable(DBusConnection *conn,
+ DBusMessage *msg, void *data)
+{
+ struct proxy *prx = data;
+ sdp_record_t *record;
+
+ if (prx->io)
+ return failed(msg, "Already enabled");
+
+ /* Listen */
+ prx->io = bt_rfcomm_listen_allocate(&prx->src, &prx->channel, 0,
+ connect_event_cb, prx);
+ if (!prx->io) {
+ const char *strerr = strerror(errno);
+ error("RFCOMM listen socket failed: %s(%d)", strerr, errno);
+ return failed(msg, strerr);
+ }
+
+ g_io_channel_set_close_on_unref(prx->io, TRUE);
+
+ record = proxy_record_new(prx->uuid128, prx->channel);
+ if (!record) {
+ g_io_channel_unref(prx->io);
+ return failed(msg, "Unable to allocate new service record");
+ }
+
+ if (add_record_to_server(&prx->src, record) < 0) {
+ sdp_record_free(record);
+ g_io_channel_unref(prx->io);
+ return failed(msg, "Service registration failed");
+ }
+
+ prx->record_id = record->handle;
+
+ return dbus_message_new_method_return(msg);
+}
+
+static DBusMessage *proxy_disable(DBusConnection *conn,
+ DBusMessage *msg, void *data)
+{
+ struct proxy *prx = data;
+
+ if (!prx->io)
+ return failed(msg, "Not enabled");
+
+ /* Remove the watches and unregister the record */
+ disable_proxy(prx);
+
+ return dbus_message_new_method_return(msg);
+}
+
+static DBusMessage *proxy_get_info(DBusConnection *conn,
+ DBusMessage *msg, void *data)
+{
+ struct proxy *prx = data;
+ DBusMessage *reply;
+ DBusMessageIter iter, dict;
+ dbus_bool_t boolean;
+
+ reply = dbus_message_new_method_return(msg);
+ if (!reply)
+ return NULL;
+
+ dbus_message_iter_init_append(reply, &iter);
+
+ dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY,
+ DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
+ DBUS_TYPE_STRING_AS_STRING DBUS_TYPE_VARIANT_AS_STRING
+ DBUS_DICT_ENTRY_END_CHAR_AS_STRING, &dict);
+
+ dbus_message_iter_append_dict_entry(&dict, "uuid",
+ DBUS_TYPE_STRING, &prx->uuid128);
+
+ dbus_message_iter_append_dict_entry(&dict, "address",
+ DBUS_TYPE_STRING, &prx->address);
+
+ if (prx->channel)
+ dbus_message_iter_append_dict_entry(&dict, "channel",
+ DBUS_TYPE_BYTE, &prx->channel);
+
+ boolean = (prx->io ? TRUE : FALSE);
+ dbus_message_iter_append_dict_entry(&dict, "enabled",
+ DBUS_TYPE_BOOLEAN, &boolean);
+
+ boolean = (prx->rfcomm_watch ? TRUE : FALSE);
+ dbus_message_iter_append_dict_entry(&dict, "connected",
+ DBUS_TYPE_BOOLEAN, &boolean);
+
+ /* If connected: append the remote address */
+ if (boolean) {
+ char bda[18];
+ const char *pstr = bda;
+
+ ba2str(&prx->dst, bda);
+ dbus_message_iter_append_dict_entry(&dict, "address",
+ DBUS_TYPE_STRING, &pstr);
+ }
+
+ dbus_message_iter_close_container(&iter, &dict);
+
+ return reply;
+}
+
+static struct {
+ const char *str;
+ speed_t speed;
+} supported_speed[] = {
+ {"50", B50 },
+ {"300", B300 },
+ {"600", B600 },
+ {"1200", B1200 },
+ {"1800", B1800 },
+ {"2400", B2400 },
+ {"4800", B4800 },
+ {"9600", B9600 },
+ {"19200", B19200 },
+ {"38400", B38400 },
+ {"57600", B57600 },
+ {"115200", B115200 },
+ { NULL, B0 }
+};
+
+static speed_t str2speed(const char *str, speed_t *speed)
+{
+ int i;
+
+ for (i = 0; supported_speed[i].str; i++) {
+ if (strcmp(supported_speed[i].str, str) != 0)
+ continue;
+
+ if (speed)
+ *speed = supported_speed[i].speed;
+
+ return supported_speed[i].speed;
+ }
+
+ return B0;
+}
+
+static int set_parity(const char *str, tcflag_t *ctrl)
+{
+ if (strcasecmp("even", str) == 0) {
+ *ctrl |= PARENB;
+ *ctrl &= ~PARODD;
+ } else if (strcasecmp("odd", str) == 0) {
+ *ctrl |= PARENB;
+ *ctrl |= PARODD;
+ } else if (strcasecmp("mark", str) == 0)
+ *ctrl |= PARENB;
+ else if ((strcasecmp("none", str) == 0) ||
+ (strcasecmp("space", str) == 0))
+ *ctrl &= ~PARENB;
+ else
+ return -1;
+
+ return 0;
+}
+
+static int set_databits(uint8_t databits, tcflag_t *ctrl)
+{
+ if (databits < 5 || databits > 8)
+ return -EINVAL;
+
+ *ctrl &= ~CSIZE;
+ switch (databits) {
+ case 5:
+ *ctrl |= CS5;
+ break;
+ case 6:
+ *ctrl |= CS6;
+ break;
+ case 7:
+ *ctrl |= CS7;
+ break;
+ case 8:
+ *ctrl |= CS8;
+ break;
+ }
+
+ return 0;
+}
+
+static int set_stopbits(uint8_t stopbits, tcflag_t *ctrl)
+{
+ /* 1.5 will not be allowed */
+ switch (stopbits) {
+ case 1:
+ *ctrl &= ~CSTOPB;
+ return 0;
+ case 2:
+ *ctrl |= CSTOPB;
+ return 0;
+ }
+
+ return -EINVAL;
+}
+
+static DBusMessage *proxy_set_serial_params(DBusConnection *conn,
+ DBusMessage *msg, void *data)
+{
+ struct proxy *prx = data;
+ const char *ratestr, *paritystr;
+ uint8_t databits, stopbits;
+ tcflag_t ctrl; /* Control mode flags */
+ speed_t speed = B0; /* In/Out speed */
+
+ /* Don't allow change TTY settings if it is open */
+ if (prx->local_watch)
+ return failed(msg, "Not allowed");
+
+ if (!dbus_message_get_args(msg, NULL,
+ DBUS_TYPE_STRING, &ratestr,
+ DBUS_TYPE_BYTE, &databits,
+ DBUS_TYPE_BYTE, &stopbits,
+ DBUS_TYPE_STRING, &paritystr,
+ DBUS_TYPE_INVALID))
+ return NULL;
+
+ if (str2speed(ratestr, &speed) == B0)
+ return invalid_arguments(msg, "Invalid baud rate");
+
+ ctrl = prx->proxy_ti.c_cflag;
+ if (set_databits(databits, &ctrl) < 0)
+ return invalid_arguments(msg, "Invalid data bits");
+
+ if (set_stopbits(stopbits, &ctrl) < 0)
+ return invalid_arguments(msg, "Invalid stop bits");
+
+ if (set_parity(paritystr, &ctrl) < 0)
+ return invalid_arguments(msg, "Invalid parity");
+
+ prx->proxy_ti.c_cflag = ctrl;
+ prx->proxy_ti.c_cflag |= (CLOCAL | CREAD);
+ cfsetispeed(&prx->proxy_ti, speed);
+ cfsetospeed(&prx->proxy_ti, speed);
+
+ proxy_store(&prx->src, prx->uuid128, prx->address, NULL,
+ prx->channel, 0, &prx->proxy_ti);
+
+ return dbus_message_new_method_return(msg);
+}
+
+static GDBusMethodTable proxy_methods[] = {
+ { "Enable", "", "", proxy_enable },
+ { "Disable", "", "", proxy_disable },
+ { "GetInfo", "", "a{sv}",proxy_get_info },
+ { "SetSerialParameters", "syys", "", proxy_set_serial_params },
+ { },
+};
+
+static void proxy_unregister(gpointer data)
+{
+ struct proxy *prx = data;
+ int sk;
+
+ info("Unregistered proxy: %s", prx->address);
+
+ if (prx->type != TTY_PROXY)
+ goto done;
+
+ /* Restore the initial TTY configuration */
+ sk = open(prx->address, O_RDWR | O_NOCTTY);
+ if (sk) {
+ tcsetattr(sk, TCSAFLUSH, &prx->sys_ti);
+ close(sk);
+ }
+done:
+
+ proxy_free(prx);
+}
+
+static int register_proxy_object(struct proxy *prx, char *outpath, size_t size)
+{
+ char path[MAX_PATH_LENGTH + 1];
+
+ snprintf(path, MAX_PATH_LENGTH, "/org/bluez/serial/proxy%d",
+ sk_counter++);
+
+ if (!g_dbus_register_interface(connection, path,
+ SERIAL_PROXY_INTERFACE,
+ proxy_methods, NULL, NULL,
+ prx, proxy_unregister)) {
+ error("D-Bus failed to register %s path", path);
+ return -1;
+ }
+
+ prx->path = g_strdup(path);
+ proxies = g_slist_append(proxies, prx);
+
+ if (outpath)
+ strncpy(outpath, path, size);
+
+ info("Registered proxy:%s", path);
+
+ return 0;
+}
+
+static int proxy_tty_register(bdaddr_t *src, const char *uuid128,
+ const char *address, struct termios *ti,
+ char *outpath, size_t size, gboolean save)
+{
+ struct termios sys_ti;
+ struct proxy *prx;
+ int sk, ret;
+
+ sk = open(address, O_RDONLY | O_NOCTTY);
+ if (sk < 0) {
+ error("Cant open TTY: %s(%d)", strerror(errno), errno);
+ return -EINVAL;
+ }
+
+ prx = g_new0(struct proxy, 1);
+ prx->address = g_strdup(address);
+ prx->uuid128 = g_strdup(uuid128);
+ prx->type = TTY_PROXY;
+ bacpy(&prx->src, src);
+
+ /* Current TTY settings */
+ memset(&sys_ti, 0, sizeof(sys_ti));
+ tcgetattr(sk, &sys_ti);
+ memcpy(&prx->sys_ti, &sys_ti, sizeof(sys_ti));
+ close(sk);
+
+ if (!ti) {
+ /* Use current settings */
+ memcpy(&prx->proxy_ti, &sys_ti, sizeof(sys_ti));
+ } else {
+ /* New TTY settings: user provided */
+ memcpy(&prx->proxy_ti, ti, sizeof(*ti));
+ }
+
+ ret = register_proxy_object(prx, outpath, size);
+ if (ret < 0)
+ proxy_free(prx);
+
+ if (save)
+ proxy_store(src, uuid128, address, NULL,
+ prx->channel, 0, &prx->proxy_ti);
+
+ return ret;
+}
+
+static int proxy_socket_register(bdaddr_t *src, const char *uuid128,
+ const char *address, char *outpath,
+ size_t size, gboolean save)
+{
+ struct proxy *prx;
+ int ret;
+
+ prx = g_new0(struct proxy, 1);
+ prx->address = g_strdup(address);
+ prx->uuid128 = g_strdup(uuid128);
+ prx->type = UNIX_SOCKET_PROXY;
+ bacpy(&prx->src, src);
+
+ ret = register_proxy_object(prx, outpath, size);
+ if (ret < 0)
+ proxy_free(prx);
+
+ if (save)
+ proxy_store(src, uuid128, address, NULL,
+ prx->channel, 0, NULL);
+
+ return ret;
+}
+
+static int proxy_tcp_register(bdaddr_t *src, const char *uuid128,
+ const char *address, char *outpath,
+ size_t size, gboolean save)
+{
+ struct proxy *prx;
+ int ret;
+
+ prx = g_new0(struct proxy, 1);
+ prx->address = g_strdup(address);
+ prx->uuid128 = g_strdup(uuid128);
+ prx->type = TCP_SOCKET_PROXY;
+ bacpy(&prx->src, src);
+
+ ret = register_proxy_object(prx, outpath, size);
+ if (ret < 0)
+ proxy_free(prx);
+
+ if (save)
+ proxy_store(src, uuid128, address, NULL,
+ prx->channel, 0, NULL);
+
+ return ret;
+}
+
+static proxy_type_t addr2type(const char *address)
+{
+ struct stat st;
+
+ if (stat(address, &st) < 0) {
+ /*
+ * Unix socket: if the sun_path starts with null byte
+ * it refers to abstract namespace. 'x00' will be used
+ * to represent the null byte.
+ */
+ if (strncmp("localhost:", address, 10) == 0)
+ return TCP_SOCKET_PROXY;
+ if (strncmp("x00", address, 3) != 0)
+ return UNKNOWN_PROXY_TYPE;
+ else
+ return UNIX_SOCKET_PROXY;
+ } else {
+ /* Filesystem: char device or unix socket */
+ if (S_ISCHR(st.st_mode) && strncmp("/dev/", address, 4) == 0)
+ return TTY_PROXY;
+ else if (S_ISSOCK(st.st_mode))
+ return UNIX_SOCKET_PROXY;
+ else
+ return UNKNOWN_PROXY_TYPE;
+ }
+}
+
+static int proxy_addrcmp(gconstpointer proxy, gconstpointer addr)
+{
+ const struct proxy *prx = proxy;
+ const char *address = addr;
+
+ return strcmp(prx->address, address);
+}
+
+static int proxy_pathcmp(gconstpointer proxy, gconstpointer p)
+{
+ const struct proxy *prx = proxy;
+ const char *path = p;
+
+ return strcmp(prx->path, path);
+}
+
+static DBusMessage *create_proxy(DBusConnection *conn,
+ DBusMessage *msg, void *data)
+{
+ char path[MAX_PATH_LENGTH + 1];
+ const char *uuid128, *address, *ppath = path;
+ DBusMessage *reply;
+ proxy_type_t type;
+ bdaddr_t src;
+ uuid_t uuid;
+ int dev_id, ret;
+
+ if (!dbus_message_get_args(msg, NULL,
+ DBUS_TYPE_STRING, &uuid128,
+ DBUS_TYPE_STRING, &address,
+ DBUS_TYPE_INVALID))
+ return NULL;
+
+ if (bt_string2uuid(&uuid, uuid128) < 0)
+ return invalid_arguments(msg, "Invalid UUID");
+
+ type = addr2type(address);
+ if (type == UNKNOWN_PROXY_TYPE)
+ return invalid_arguments(msg, "Invalid address");
+
+ /* Only one proxy per address(TTY or unix socket) is allowed */
+ if (g_slist_find_custom(proxies, address, proxy_addrcmp))
+ return g_dbus_create_error(msg, ERROR_INTERFACE ".AlreadyExist",
+ "Proxy already exists");
+
+ dev_id = hci_get_route(NULL);
+ if ((dev_id < 0) || (hci_devba(dev_id, &src) < 0)) {
+ error("Adapter not available");
+ return failed(msg, "Adapter no available");
+ }
+
+ reply = dbus_message_new_method_return(msg);
+ if (!reply)
+ return NULL;
+
+ switch (type) {
+ case UNIX_SOCKET_PROXY:
+ ret = proxy_socket_register(&src, uuid128, address,
+ path, sizeof(path), TRUE);
+ break;
+ case TTY_PROXY:
+ ret = proxy_tty_register(&src, uuid128, address,
+ NULL, path, sizeof(path), TRUE);
+ break;
+ case TCP_SOCKET_PROXY:
+ ret = proxy_tcp_register(&src, uuid128, address,
+ path, sizeof(path), TRUE);
+ break;
+ default:
+ ret = -1;
+ }
+ if (ret < 0) {
+ dbus_message_unref(reply);
+ return failed(msg, "Create object path failed");
+ }
+
+ g_dbus_emit_signal(connection, SERIAL_MANAGER_PATH,
+ SERIAL_MANAGER_INTERFACE, "ProxyCreated",
+ DBUS_TYPE_STRING, &ppath,
+ DBUS_TYPE_INVALID);
+
+ dbus_message_append_args(reply,
+ DBUS_TYPE_STRING, &ppath,
+ DBUS_TYPE_INVALID);
+
+ return reply;
+}
+
+static DBusMessage *list_proxies(DBusConnection *conn,
+ DBusMessage *msg, void *data)
+{
+ struct proxy *prx;
+ const GSList *l;
+ DBusMessage *reply;
+ DBusMessageIter iter, iter_array;
+
+ reply = dbus_message_new_method_return(msg);
+ if (!reply)
+ return NULL;
+
+ dbus_message_iter_init_append(reply, &iter);
+ dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY,
+ DBUS_TYPE_STRING_AS_STRING, &iter_array);
+
+ for (l = proxies; l; l = l->next) {
+ prx = l->data;
+ dbus_message_iter_append_basic(&iter_array,
+ DBUS_TYPE_STRING, &prx->path);
+ }
+
+ dbus_message_iter_close_container(&iter, &iter_array);
+
+ return reply;
+}
+
+static DBusMessage *remove_proxy(DBusConnection *conn,
+ DBusMessage *msg, void *data)
+{
+ struct proxy *prx;
+ const char *path;
+ GSList *l;
+
+ if (!dbus_message_get_args(msg, NULL,
+ DBUS_TYPE_STRING, &path,
+ DBUS_TYPE_INVALID))
+ return NULL;
+
+ l = g_slist_find_custom(proxies, path, proxy_pathcmp);
+ if (!l)
+ return does_not_exist(msg, "Invalid proxy path");
+
+ g_dbus_emit_signal(conn, SERIAL_MANAGER_PATH,
+ SERIAL_MANAGER_INTERFACE, "ProxyRemoved",
+ DBUS_TYPE_STRING, &path,
+ DBUS_TYPE_INVALID);
+
+ prx = l->data;
+ proxy_delete(&prx->src, prx->address);
+ proxies = g_slist_remove(proxies, prx);
+
+ g_dbus_unregister_interface(conn, path, SERIAL_PROXY_INTERFACE);
+
+ return dbus_message_new_method_return(msg);
+}
+
+static DBusMessage *connect_channel(DBusConnection *conn, DBusMessage *msg,
+ const char *adapter, const char *address,
+ const char *pattern, long channel, void *data)
+{
+ struct pending_connect *pc;
+
+ if (channel < 1 || channel > 30)
+ return invalid_arguments(msg, "Invalid RFCOMM channel");
+
+ pc = g_new0(struct pending_connect, 1);
+ pc->conn = dbus_connection_ref(conn);
+ pc->msg = dbus_message_ref(msg);
+ pc->adapter = g_strdup(adapter);
+ pc->address = g_strdup(address);
+ pc->id = -1;
+ pc->pattern = g_strdup(pattern);
+ pc->channel = channel;
+
+ return connect_pending(conn, msg, pc);
+}
+
+DBusMessage *service_connect(DBusConnection *conn, DBusMessage *msg,
+ const char *adapter,
+ const char *address,
+ const char *pattern)
+{
+ int dev_id;
+ bdaddr_t src;
+ char adp[18];
+ uuid_t uuid;
+ long val;
+
+ if (!adapter)
+ dev_id = hci_get_route(NULL);
+ else
+ dev_id = hci_devid(adapter);
+
+ if ((dev_id < 0) || (hci_devba(dev_id, &src) < 0))
+ return failed(msg, "Adapter not Available");
+
+ ba2str(&src, adp);
+
+ /* Friendly name or uuid128 */
+ if (pattern2uuid(pattern, &uuid) == 0)
+ return search_uuid(conn, msg, adp, address,
+ pattern, &uuid, NULL);
+
+ /* RFCOMM Channel */
+ if (pattern2long(pattern, &val) == 0)
+ return connect_channel(conn, msg, adp, address,
+ pattern, val, NULL);
+
+ return invalid_arguments(msg, "Invalid Pattern");
+}
+
+static DBusMessage *connect_service(DBusConnection *conn,
+ DBusMessage *msg, void *data)
+{
+ const char *address, *pattern;
+
+ if (!dbus_message_get_args(msg, NULL,
+ DBUS_TYPE_STRING, &address,
+ DBUS_TYPE_STRING, &pattern,
+ DBUS_TYPE_INVALID))
+ return NULL;
+
+ return service_connect(conn, msg, NULL, address, pattern);
+}
+
+static DBusMessage *connect_service_from_adapter(DBusConnection *conn,
+ DBusMessage *msg, void *data)
+{
+ const char *adapter, *address, *pattern;
+
+ if (!dbus_message_get_args(msg, NULL,
+ DBUS_TYPE_STRING, &adapter,
+ DBUS_TYPE_STRING, &address,
+ DBUS_TYPE_STRING, &pattern,
+ DBUS_TYPE_INVALID))
+ return NULL;
+
+ return service_connect(conn, msg, adapter, address, pattern);
+}
+
+static DBusMessage *disconnect_service(DBusConnection *conn,
+ DBusMessage *msg, void *data)
+{
+ const char *name;
+ int err, id;
+
+ if (!dbus_message_get_args(msg, NULL,
+ DBUS_TYPE_STRING, &name,
+ DBUS_TYPE_INVALID))
+ return NULL;
+
+ if (sscanf(name, "/dev/rfcomm%d", &id) != 1)
+ return invalid_arguments(msg, "Invalid RFCOMM node");
+
+ err = port_remove_listener(dbus_message_get_sender(msg), name);
+ if (err < 0)
+ return does_not_exist(msg, "Invalid RFCOMM node");
+
+ g_dbus_emit_signal(conn, SERIAL_MANAGER_PATH,
+ SERIAL_MANAGER_INTERFACE, "ServiceDisconnected" ,
+ DBUS_TYPE_STRING, &name,
+ DBUS_TYPE_INVALID);
+
+ return dbus_message_new_method_return(msg);
+}
+
+static DBusMessage *cancel_connect_service(DBusConnection *conn,
+ DBusMessage *msg, void *data)
+{
+ struct pending_connect *pending;
+ const char *bda, *pattern;
+
+ if (!dbus_message_get_args(msg, NULL,
+ DBUS_TYPE_STRING, &bda,
+ DBUS_TYPE_STRING, &pattern,
+ DBUS_TYPE_INVALID))
+ return NULL;
+
+ pending = find_pending_connect_by_pattern(bda, pattern);
+ if (!pending)
+ return does_not_exist(msg, "No such connection request");
+
+ pending->canceled = 1;
+
+ return dbus_message_new_method_return(msg);
+}
+
+static void manager_unregister(void *data)
+{
+ if (pending_connects) {
+ g_slist_foreach(pending_connects,
+ (GFunc) pending_connect_free, NULL);
+ g_slist_free(pending_connects);
+ pending_connects = NULL;
+ }
+
+ if (proxies) {
+ g_slist_foreach(proxies,
+ (GFunc) proxy_unregister, NULL);
+ g_slist_free(proxies);
+ proxies = NULL;
+ }
+
+ if (ports_paths) {
+ g_slist_foreach(ports_paths,
+ (GFunc) g_free, NULL);
+ g_slist_free(ports_paths);
+ ports_paths = NULL;
+ }
+}
+
+static GDBusMethodTable manager_methods[] = {
+ { "CreatePort", "ss", "s", create_port,
+ G_DBUS_METHOD_FLAG_ASYNC },
+ { "ListPorts", "", "as", list_ports },
+ { "RemovePort", "s", "", remove_port },
+ { "CreateProxy", "ss", "s", create_proxy },
+ { "ListProxies", "", "as", list_proxies },
+ { "RemoveProxy", "s", "", remove_proxy },
+ { "ConnectService", "ss", "s", connect_service,
+ G_DBUS_METHOD_FLAG_ASYNC },
+ { "ConnectServiceFromAdapter", "sss", "s", connect_service_from_adapter,
+ G_DBUS_METHOD_FLAG_ASYNC },
+ { "DisconnectService", "s", "", disconnect_service },
+ { "CancelConnectService", "ss", "", cancel_connect_service },
+ { },
+};
+
+static GDBusSignalTable manager_signals[] = {
+ { "PortCreated", "s" },
+ { "PortRemoved", "s" },
+ { "ProxyCreated", "s" },
+ { "ProxyRemoved", "s" },
+ { "ServiceConnected", "s" },
+ { "ServiceDisconnected", "s" },
+ { }
+};
+
+static void parse_port(char *key, char *value, void *data)
+{
+ char path[MAX_PATH_LENGTH], port_name[16], dst_addr[18], *svc;
+ char *src_addr = data;
+ bdaddr_t dst, src;
+ int ch, id;
+
+ memset(dst_addr, 0, sizeof(dst_addr));
+ if (sscanf(key,"%17s#%d", dst_addr, &id) != 2)
+ return;
+
+ if (sscanf(value,"%d:", &ch) != 1)
+ return;
+
+ svc = strchr(value, ':');
+ if (svc && *svc)
+ svc++;
+
+ str2ba(dst_addr, &dst);
+ str2ba(src_addr, &src);
+
+ if (rfcomm_bind(&src, &dst, id, ch) < 0)
+ return;
+
+ snprintf(port_name, sizeof(port_name), "/dev/rfcomm%d", id);
+
+ if (port_register(connection, id, &src, &dst,
+ port_name, path, svc) < 0) {
+ rfcomm_release(id);
+ return;
+ }
+
+ ports_paths = g_slist_append(ports_paths, g_strdup(path));
+}
+
+static void parse_proxy(char *key, char *value, void *data)
+{
+ char uuid128[MAX_LEN_UUID_STR], tmp[3];
+ char *pvalue, *src_addr = data;
+ proxy_type_t type;
+ int ch, opts, pos;
+ bdaddr_t src;
+ struct termios ti;
+ uint8_t *pti;
+
+ memset(uuid128, 0, sizeof(uuid128));
+ ch = opts = pos = 0;
+ if (sscanf(value,"%s %d 0x%04X %n", uuid128, &ch, &opts, &pos) != 3)
+ return;
+
+ /* Extracting name */
+ value += pos;
+ pvalue = strchr(value, ':');
+ if (!pvalue)
+ return;
+
+ /* FIXME: currently name is not used */
+ *pvalue = '\0';
+
+ str2ba(src_addr, &src);
+ type = addr2type(key);
+ switch (type) {
+ case TTY_PROXY:
+ /* Extracting termios */
+ pvalue++;
+ if (!pvalue || strlen(pvalue) != (2 * sizeof(ti)))
+ return;
+
+ memset(&ti, 0, sizeof(ti));
+ memset(tmp, 0, sizeof(tmp));
+
+ /* Converting to termios struct */
+ pti = (uint8_t *) &ti;
+ for (pos = 0; pos < sizeof(ti); pos++, pvalue += 2, pti++) {
+ memcpy(tmp, pvalue, 2);
+ *pti = (uint8_t) strtol(tmp, NULL, 16);
+ }
+
+ proxy_tty_register(&src, uuid128, key, &ti, NULL, 0, FALSE);
+ break;
+ case UNIX_SOCKET_PROXY:
+ proxy_socket_register(&src, uuid128, key, NULL, 0, FALSE);
+ break;
+ case TCP_SOCKET_PROXY:
+ proxy_tcp_register(&src, uuid128, key, NULL, 0, FALSE);
+ break;
+ default:
+ return;
+ }
+}
+
+static void register_stored(void)
+{
+ char filename[PATH_MAX + 1];
+ struct dirent *de;
+ DIR *dir;
+
+ snprintf(filename, PATH_MAX, "%s", STORAGEDIR);
+
+ dir = opendir(filename);
+ if (!dir)
+ return;
+
+ while ((de = readdir(dir)) != NULL) {
+ if (!isdigit(de->d_name[0]))
+ continue;
+
+ snprintf(filename, PATH_MAX, "%s/%s/serial", STORAGEDIR, de->d_name);
+ textfile_foreach(filename, parse_port, de->d_name);
+
+ snprintf(filename, PATH_MAX, "%s/%s/proxy", STORAGEDIR, de->d_name);
+ textfile_foreach(filename, parse_proxy, de->d_name);
+ }
+
+ closedir(dir);
+}
+
+int serial_manager_init(DBusConnection *conn)
+{
+
+ if (rfcomm_ctl < 0) {
+ rfcomm_ctl = socket(AF_BLUETOOTH, SOCK_RAW, BTPROTO_RFCOMM);
+ if (rfcomm_ctl < 0)
+ return -errno;
+ }
+
+ if (!g_dbus_register_interface(conn, SERIAL_MANAGER_PATH,
+ SERIAL_MANAGER_INTERFACE,
+ manager_methods, manager_signals, NULL,
+ NULL, manager_unregister)) {
+ error("Failed to register %s interface to %s",
+ SERIAL_MANAGER_INTERFACE, SERIAL_MANAGER_PATH);
+ return -1;
+ }
+
+ connection = dbus_connection_ref(conn);
+
+ info("Registered manager path:%s", SERIAL_MANAGER_PATH);
+
+ register_stored();
+
+ return 0;
+}
+
+void serial_manager_exit(void)
+{
+ g_dbus_unregister_interface(connection, SERIAL_MANAGER_PATH,
+ SERIAL_MANAGER_INTERFACE);
+
+ dbus_connection_unref(connection);
+ connection = NULL;
+
+ port_release_all();
+
+ if (rfcomm_ctl >= 0)
+ close(rfcomm_ctl);
+}
diff --git a/serial/manager.h b/serial/manager.h
new file mode 100644
index 00000000..fdcc8ab9
--- /dev/null
+++ b/serial/manager.h
@@ -0,0 +1,34 @@
+/*
+ *
+ * BlueZ - Bluetooth protocol stack for Linux
+ *
+ * Copyright (C) 2004-2008 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
+ *
+ */
+
+#define SERIAL_MANAGER_PATH "/org/bluez/serial"
+#define SERIAL_MANAGER_INTERFACE "org.bluez.serial.Manager"
+
+int serial_manager_init(DBusConnection *conn);
+void serial_manager_exit(void);
+int rfcomm_release(int16_t id);
+
+DBusMessage *service_connect(DBusConnection *conn, DBusMessage *msg,
+ const char *adapter,
+ const char *address,
+ const char *pattern);
diff --git a/serial/port.c b/serial/port.c
new file mode 100644
index 00000000..f0563244
--- /dev/null
+++ b/serial/port.c
@@ -0,0 +1,404 @@
+/*
+ *
+ * BlueZ - Bluetooth protocol stack for Linux
+ *
+ * Copyright (C) 2004-2008 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 <stdio.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+#include <termios.h>
+#include <sys/ioctl.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+
+#include <bluetooth/bluetooth.h>
+#include <bluetooth/rfcomm.h>
+#include <bluetooth/sdp.h>
+
+#include <glib.h>
+#include <gdbus.h>
+
+#include "../hcid/dbus-common.h"
+
+#include "logging.h"
+
+#include "error.h"
+#include "manager.h"
+#include "storage.h"
+
+#define SERIAL_PORT_INTERFACE "org.bluez.serial.Port"
+
+struct rfcomm_node {
+ int16_t id; /* RFCOMM device id */
+ bdaddr_t src; /* Source (local) address */
+ bdaddr_t dst; /* Destination address */
+ char *svcname; /* RFCOMM service name */
+ char *device; /* RFCOMM device name */
+ DBusConnection *conn; /* for name listener handling */
+ char *owner; /* Bus name */
+ GIOChannel *io; /* Connected node IO Channel */
+ guint io_id; /* IO Channel ID */
+ guint listener_id;
+};
+
+static GSList *connected_nodes = NULL;
+static GSList *bound_nodes = NULL;
+
+static struct rfcomm_node *find_node_by_name(GSList *nodes, const char *dev)
+{
+ GSList *l;
+
+ for (l = nodes; l != NULL; l = l->next) {
+ struct rfcomm_node *node = l->data;
+ if (!strcmp(node->device, dev))
+ return node;
+ }
+
+ return NULL;
+}
+
+static DBusMessage *port_get_address(DBusConnection *conn,
+ DBusMessage *msg, void *data)
+{
+ struct rfcomm_node *node = data;
+ DBusMessage *reply;
+ char bda[18];
+ const char *pbda = bda;
+
+ reply = dbus_message_new_method_return(msg);
+ if (!reply)
+ return NULL;
+
+ ba2str(&node->dst, bda);
+ dbus_message_append_args(reply,
+ DBUS_TYPE_STRING, &pbda,
+ DBUS_TYPE_INVALID);
+
+ return reply;
+}
+
+static DBusMessage *port_get_device(DBusConnection *conn,
+ DBusMessage *msg, void *data)
+{
+ struct rfcomm_node *node = data;
+ DBusMessage *reply;
+
+ reply = dbus_message_new_method_return(msg);
+ if (!reply)
+ return NULL;
+
+ dbus_message_append_args(reply,
+ DBUS_TYPE_STRING, &node->device,
+ DBUS_TYPE_INVALID);
+
+ return reply;
+
+}
+
+static DBusMessage *port_get_adapter(DBusConnection *conn,
+ DBusMessage *msg, void *data)
+{
+ struct rfcomm_node *node = data;
+ DBusMessage *reply;
+ char addr[18];
+ const char *paddr = addr;
+
+ ba2str(&node->src, addr);
+
+ reply = dbus_message_new_method_return(msg);
+ if (!reply)
+ return NULL;
+
+ dbus_message_append_args(reply,
+ DBUS_TYPE_STRING, &paddr,
+ DBUS_TYPE_INVALID);
+
+ return reply;
+}
+
+
+static DBusMessage *port_get_name(DBusConnection *conn,
+ DBusMessage *msg, void *data)
+{
+ struct rfcomm_node *node = data;
+ DBusMessage *reply;
+ const char *pname;
+ char *name = NULL;
+
+ reply = dbus_message_new_method_return(msg);
+ if (!reply)
+ return NULL;
+
+ read_device_name(&node->src, &node->dst, &name);
+
+ pname = (name ? name : "");
+ dbus_message_append_args(reply,
+ DBUS_TYPE_STRING, &pname,
+ DBUS_TYPE_INVALID);
+
+ if (name)
+ g_free(name);
+
+ return reply;
+}
+
+static DBusMessage *port_get_service_name(DBusConnection *conn,
+ DBusMessage *msg, void *data)
+{
+ struct rfcomm_node *node = data;
+ DBusMessage *reply;
+
+ reply = dbus_message_new_method_return(msg);
+ if (!reply)
+ return NULL;
+
+ dbus_message_append_args(reply,
+ DBUS_TYPE_STRING, &node->svcname,
+ DBUS_TYPE_INVALID);
+
+ return reply;
+}
+
+static DBusMessage *port_get_info(DBusConnection *conn,
+ DBusMessage *msg, void *data)
+{
+ struct rfcomm_node *node = data;
+ DBusMessage *reply;
+ DBusMessageIter iter, dict;
+ char bda[18];
+ const char *pbda = bda;
+
+ reply = dbus_message_new_method_return(msg);
+ if (!reply)
+ return NULL;
+
+ dbus_message_iter_init_append(reply, &iter);
+
+ dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY,
+ DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
+ DBUS_TYPE_STRING_AS_STRING DBUS_TYPE_VARIANT_AS_STRING
+ DBUS_DICT_ENTRY_END_CHAR_AS_STRING, &dict);
+
+ dbus_message_iter_append_dict_entry(&dict, "device",
+ DBUS_TYPE_STRING, &node->device);
+
+ ba2str(&node->dst, bda);
+ dbus_message_iter_append_dict_entry(&dict, "address",
+ DBUS_TYPE_STRING, &pbda);
+
+ dbus_message_iter_close_container(&iter, &dict);
+
+ return reply;
+}
+
+static GDBusMethodTable port_methods[] = {
+ { "GetAddress", "", "s", port_get_address },
+ { "GetDevice", "", "s", port_get_device },
+ { "GetAdapter", "", "s", port_get_adapter },
+ { "GetName", "", "s", port_get_name },
+ { "GetServiceName", "", "s", port_get_service_name },
+ { "GetInfo", "", "a{sv}",port_get_info },
+ { NULL, NULL, NULL, NULL },
+};
+
+static GDBusSignalTable port_signals[] = {
+ { NULL, NULL }
+};
+
+static void rfcomm_node_free(struct rfcomm_node *node)
+{
+ if (node->device)
+ g_free(node->device);
+ if (node->conn)
+ dbus_connection_unref(node->conn);
+ if (node->owner)
+ g_free(node->owner);
+ if (node->svcname)
+ g_free(node->svcname);
+ if (node->io) {
+ g_source_remove(node->io_id);
+ g_io_channel_close(node->io);
+ g_io_channel_unref(node->io);
+ }
+ rfcomm_release(node->id);
+ g_free(node);
+}
+
+static void connection_owner_exited(void *user_data)
+{
+ struct rfcomm_node *node = user_data;
+
+ debug("Connect requestor exited. Releasing %s node",
+ node->device);
+
+ g_dbus_emit_signal(node->conn, SERIAL_MANAGER_PATH,
+ SERIAL_MANAGER_INTERFACE, "ServiceDisconnected" ,
+ DBUS_TYPE_STRING, &node->device,
+ DBUS_TYPE_INVALID);
+
+ connected_nodes = g_slist_remove(connected_nodes, node);
+ rfcomm_node_free(node);
+}
+
+static gboolean rfcomm_disconnect_cb(GIOChannel *io,
+ GIOCondition cond, struct rfcomm_node *node)
+{
+ debug("RFCOMM node %s was disconnected", node->device);
+
+ g_dbus_remove_watch(node->conn, node->listener_id);
+
+ g_dbus_emit_signal(node->conn, SERIAL_MANAGER_PATH,
+ SERIAL_MANAGER_INTERFACE, "ServiceDisconnected" ,
+ DBUS_TYPE_STRING, &node->device,
+ DBUS_TYPE_INVALID);
+
+ connected_nodes = g_slist_remove(connected_nodes, node);
+ rfcomm_node_free(node);
+
+ return FALSE;
+}
+
+static void port_handler_unregister(void *data)
+{
+ struct rfcomm_node *node = data;
+
+ debug("Unregistered serial port: %s", node->device);
+
+ bound_nodes = g_slist_remove(bound_nodes, node);
+ rfcomm_node_free(node);
+}
+
+void port_add_listener(DBusConnection *conn, int16_t id, bdaddr_t *dst,
+ int fd, const char *dev, const char *owner)
+{
+ struct rfcomm_node *node;
+
+ node = g_new0(struct rfcomm_node, 1);
+ bacpy(&node->dst, dst);
+ node->id = id;
+ node->device = g_strdup(dev);
+ node->conn = dbus_connection_ref(conn);
+ node->owner = g_strdup(owner);
+ node->io = g_io_channel_unix_new(fd);
+ node->io_id = g_io_add_watch(node->io, G_IO_ERR | G_IO_NVAL | G_IO_HUP,
+ (GIOFunc) rfcomm_disconnect_cb, node);
+
+ connected_nodes = g_slist_append(connected_nodes, node);
+
+ /* Service connection listener */
+ node->listener_id = g_dbus_add_disconnect_watch(conn, owner,
+ connection_owner_exited, node,
+ NULL);
+}
+
+int port_remove_listener(const char *owner, const char *dev)
+{
+ struct rfcomm_node *node;
+
+ node = find_node_by_name(connected_nodes, dev);
+ if (!node)
+ return -ENOENT;
+ if (strcmp(node->owner, owner) != 0)
+ return -EPERM;
+
+ g_dbus_remove_watch(node->conn, node->listener_id);
+
+ connected_nodes = g_slist_remove(connected_nodes, node);
+ rfcomm_node_free(node);
+
+ return 0;
+}
+
+void port_release_all(void)
+{
+ struct rfcomm_node *node;
+ GSList *l;
+
+ for (l = connected_nodes; l; l = l->next) {
+ node = l->data;
+
+ connected_nodes = g_slist_remove(connected_nodes, node);
+ rfcomm_node_free(node);
+ }
+}
+
+int port_register(DBusConnection *conn, int16_t id, bdaddr_t *src,
+ bdaddr_t *dst, const char *dev, char *ppath, const char *svc)
+{
+ char path[MAX_PATH_LENGTH];
+ struct rfcomm_node *node;
+
+ node = g_new0(struct rfcomm_node, 1);
+ bacpy(&node->dst, dst);
+ bacpy(&node->src, src);
+ node->id = id;
+ node->device = g_strdup(dev);
+ node->conn = dbus_connection_ref(conn);
+ node->svcname = g_strdup(svc?:"Bluetooth RFCOMM port");
+
+ snprintf(path, MAX_PATH_LENGTH, "%s/rfcomm%hd", SERIAL_MANAGER_PATH, id);
+
+
+ if (!g_dbus_register_interface(conn, path,
+ SERIAL_PORT_INTERFACE,
+ port_methods, port_signals, NULL,
+ node, port_handler_unregister)) {
+ error("D-Bus failed to register %s interface",
+ SERIAL_PORT_INTERFACE);
+ rfcomm_node_free(node);
+ return -1;
+ }
+
+ info("Registered RFCOMM:%s, path:%s", dev, path);
+
+ if (ppath)
+ strcpy(ppath, path);
+
+ bound_nodes = g_slist_append(bound_nodes, node);
+
+ return 0;
+}
+
+int port_unregister(const char *path)
+{
+ struct rfcomm_node *node;
+ char dev[16];
+ int16_t id;
+
+ if (sscanf(path, SERIAL_MANAGER_PATH"/rfcomm%hd", &id) != 1)
+ return -ENOENT;
+
+ snprintf(dev, sizeof(dev), "/dev/rfcomm%hd", id);
+ node = find_node_by_name(bound_nodes, dev);
+ if (!node)
+ return -ENOENT;
+
+ g_dbus_unregister_interface(node->conn, path, SERIAL_PORT_INTERFACE);
+
+ return 0;
+}
diff --git a/serial/port.h b/serial/port.h
new file mode 100644
index 00000000..5471525b
--- /dev/null
+++ b/serial/port.h
@@ -0,0 +1,34 @@
+/*
+ *
+ * BlueZ - Bluetooth protocol stack for Linux
+ *
+ * Copyright (C) 2004-2008 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
+ *
+ */
+
+int port_add_listener(DBusConnection *conn, int16_t id, bdaddr_t *dst,
+ int fd, const char *dev, const char *owner);
+
+int port_remove_listener(const char *owner, const char *dev);
+
+void port_release_all(void);
+
+int port_register(DBusConnection *conn, int16_t id, bdaddr_t *src,
+ bdaddr_t *dst, const char *dev, char *ppath, const char *svc);
+
+int port_unregister(const char *path);
diff --git a/serial/serial-api.txt b/serial/serial-api.txt
new file mode 100644
index 00000000..7e17b86e
--- /dev/null
+++ b/serial/serial-api.txt
@@ -0,0 +1,176 @@
+Bluetooth serial service API description
+****************************************
+
+Copyright (C) 2006-2007 Marcel Holtmann <marcel@holtmann.org>
+
+
+Manager hierarchy
+=================
+
+Interface org.bluez.serial.Manager
+Object path /org/bluez/serial
+
+Methods string CreateProxy(string uuid, string address)
+
+ Creates a serial port proxy object.
+
+ Service identifier must be provided in the uuid 128
+ format. Addresses can be either TTY char devices,
+ unix socket address or a local TCP port. Abstract
+ namespace can be informed replacing the null byte
+ by 'x00'. eg: "/dev/ttyS0", "/tmp/gps-data",
+ "x00/org/bluez/echo", "localhost:2947".
+
+ Possible errors:org.bluez.Error.InvalidArguments
+ org.bluez.Error.NotAvailable
+ org.bluez.Error.Failed
+
+ void RemoveProxy(string path) [experimental]
+
+ Removes the serial port proxy object for given path.
+
+ Possible errors:org.bluez.Error.DoesNotExist
+
+ string CreatePort(string address, string pattern) [experimental]
+
+ Creates a serial port object.
+
+ Possible errors:org.bluez.Error.InvalidArguments
+ org.bluez.Error.Canceled
+ org.bluez.Error.InProgress
+ org.bluez.Error.ConnectionAttemptFailed
+ org.bluez.Error.NotSupported
+ org.bluez.Error.Failed
+
+ void RemovePort(string path) [experimental]
+
+ Removes the serial port object for given path.
+
+ Possible errors:org.bluez.Error.DoesNotExist
+
+ array{string} ListPorts() [experimental]
+
+ Returns an array of available serial port paths.
+
+ array{string} ListProxies() [experimental]
+
+ Returns an array of available serial port proxy paths.
+
+ string ConnectService(string address, string pattern)
+
+ Connects to a specific RFCOMM based service on a
+ remote device and then creates a RFCOMM TTY
+ device for it. The RFCOMM TTY device is returned.
+
+ Possible errors:org.bluez.Error.InvalidArguments
+ org.bluez.Error.Canceled
+ org.bluez.Error.InProgress
+ org.bluez.Error.ConnectionAttemptFailed
+ org.bluez.Error.NotSupported
+ org.bluez.Error.Failed
+
+ string ConnectServiceFromAdapter(string adapter,
+ string address, string pattern) [experimental]
+
+ Use the given adapter to connect to a specific RFCOMM
+ based service on a remote device and then creates a
+ RFCOMM TTY device for it. The RFCOMM TTY device is
+ returned.
+
+ Possible errors:org.bluez.Error.InvalidArguments
+ org.bluez.Error.Canceled
+ org.bluez.Error.InProgress
+ org.bluez.Error.ConnectionAttemptFailed
+ org.bluez.Error.NotSupported
+ org.bluez.Error.Failed
+
+ void CancelConnectService(string address, string pattern)
+
+ Cancel a previous ConnectService method call.
+
+ Possible errors:org.bluez.serial.InvalidArguments
+
+ void DisconnectService(string device)
+
+ Disconnect a RFCOMM TTY device that has been
+ created via the ConnectService method.
+
+ Possible errors:org.bluez.Error.InvalidArguments
+ org.bluez.Error.DoesNotExist
+
+Signals void PortCreated(string path) [experimental]
+
+ void PortRemoved(string path) [experimental]
+
+ void ProxyCreated(string path) [experimental]
+
+ void ProxyRemoved(string path) [experimental]
+
+ void ServiceConnected(string device)
+
+ void ServiceDisconnected(string device)
+
+
+Port hierarchy (experimental)
+=============================
+
+Interface org.bluez.serial.Port
+Object path /org/bluez/serial/rfcomm*
+
+Methods string GetAdapter() [experimental]
+
+ Returns the adapter address.
+
+ string GetAddress() [experimental]
+
+ Returns the Bluetooth address of the ending point.
+
+ string GetDevice() [experimental]
+
+ Returns the TTY device node name
+
+ dict GetInfo() [experimental]
+
+ Returns the port properties.
+
+ string GetName()
+
+ Returns the name of the remote device.
+
+ string GetServiceName()
+
+ Returns the name of the remote service.
+ e.g.: "Dial-up networking Gateway"
+
+Proxy hierarchy (experimental)
+=============================
+Interface org.bluez.serial.Proxy
+Object path /org/bluez/serial/rfcomm*
+
+Methods: void Enable() [experimental]
+
+ Register the serial proxy service record and start
+ listenning on the specified adapter/channel.
+
+ Possible errors:org.bluez.Error.Failed
+
+ void Disable() [experimental]
+
+ Unregister the service record and stop listenning.
+
+ Possible errors:org.bluez.Error.Failed
+
+ dict GetInfo() [experimental]
+ Returns the proxy properties
+
+ void SetSerialParameters(string rate, byte databits,
+ byte stopbits, string parity) [experimental]
+
+ Change the TTY settings. Available rates: "50", "300",
+ "600", "1200", "1800", "2400", "4800", "9600", "19200",
+ "38400", "57600" and "115200". Available data bits: 5,
+ 6, 7 and 8. Available stop bits: 1 and 2. Available
+ parity: "even", "odd", "mark", "space" and "none".
+
+ Possible errors:org.bluez.Error.InvalidArguments
+ org.bluez.Error.Failed
diff --git a/serial/storage.c b/serial/storage.c
new file mode 100644
index 00000000..98cd5b84
--- /dev/null
+++ b/serial/storage.c
@@ -0,0 +1,170 @@
+/*
+ *
+ * BlueZ - Bluetooth protocol stack for Linux
+ *
+ * Copyright (C) 2004-2008 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 <stdlib.h>
+#include <termios.h>
+#include <unistd.h>
+#include <sys/stat.h>
+#include <sys/param.h>
+
+#include <bluetooth/bluetooth.h>
+#include <bluetooth/sdp.h>
+#include <bluetooth/sdp_lib.h>
+
+#include <glib.h>
+
+#include "logging.h"
+#include "textfile.h"
+
+#include "storage.h"
+
+int port_delete(bdaddr_t *src, bdaddr_t *dst, int16_t id)
+{
+ char filename[PATH_MAX + 1];
+ char src_addr[18], dst_addr[18];
+ char key[32];
+
+ ba2str(src, src_addr);
+ ba2str(dst, dst_addr);
+
+ create_name(filename, PATH_MAX, STORAGEDIR, src_addr, "serial");
+ snprintf(key, sizeof(key), "%s#%hd", dst_addr, id);
+
+ return textfile_del(filename, key);
+}
+
+int port_store(bdaddr_t *src, bdaddr_t *dst, int16_t id,
+ uint8_t ch, const char *svcname)
+{
+ char filename[PATH_MAX + 1];
+ char src_addr[18], dst_addr[18];
+ char key[32];
+ char *value;
+ int size, err;
+
+ if (!svcname)
+ svcname = "Bluetooth RFCOMM port";
+
+ ba2str(src, src_addr);
+ ba2str(dst, dst_addr);
+
+ create_name(filename, PATH_MAX, STORAGEDIR, src_addr, "serial");
+ create_file(filename, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
+
+ size = strlen(svcname) + 5;
+ value = g_malloc0(size);
+
+ snprintf(key, 32, "%s#%hd", dst_addr, id);
+ snprintf(value, size, "%d:%s", ch, svcname);
+
+ err = textfile_put(filename, key, value);
+ g_free(value);
+
+ return err;
+}
+
+int proxy_delete(bdaddr_t *src, const char *tty)
+{
+ char filename[PATH_MAX + 1], src_addr[18];
+
+ ba2str(src, src_addr);
+
+ create_name(filename, PATH_MAX, STORAGEDIR, src_addr, "proxy");
+
+ return textfile_del(filename, tty);
+}
+
+int proxy_store(bdaddr_t *src, const char *uuid, const char *tty,
+ const char *name, uint8_t ch, int opts, struct termios *ti)
+{
+ char filename[PATH_MAX + 1], key[32], src_addr[18], *value;
+ int i, pos, size, err;
+ uint8_t *pti;
+
+ ba2str(src, src_addr);
+
+ create_name(filename, PATH_MAX, STORAGEDIR, src_addr, "proxy");
+ create_file(filename, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
+
+ if (!name)
+ name = "Port Proxy Entity";
+
+ size = MAX_LEN_UUID_STR + 16 + strlen(name) + sizeof(struct termios) * 2;
+ value = g_malloc0(size);
+
+ snprintf(key, 32, "%s", tty);
+
+ /* tty uuid 00 0x0000 name:termios */
+ pos = snprintf(value, size, "%s %d 0x%04X %s:", uuid, ch, opts, name);
+
+ if (!ti)
+ goto done;
+
+ for (i = 0, pti = (uint8_t *) ti; i < sizeof(struct termios); i++, pti++)
+ sprintf(value + pos + (i * 2), "%2.2X", *pti);
+
+done:
+ err = textfile_put(filename, key, value);
+ g_free(value);
+
+ return err;
+}
+
+int read_device_name(bdaddr_t *src, bdaddr_t *dst, char **name)
+{
+ char filename[PATH_MAX + 1], *str;
+ char src_addr[18], dst_addr[18];
+ int len;
+
+ ba2str(src, src_addr);
+ ba2str(dst, dst_addr);
+
+ create_name(filename, PATH_MAX, STORAGEDIR, src_addr, "names");
+
+ str = textfile_get(filename, dst_addr);
+ if (!str)
+ return -ENOENT;
+
+ len = strlen(str);
+
+ /* Max remote device name */
+ if (len < 248) {
+ *name = str;
+ return 0;
+ }
+
+ *name = g_try_malloc0(248);
+ if (!*name)
+ return -ENOMEM;
+
+ snprintf(*name, 248, "%s", str);
+
+ free(str);
+
+ return 0;
+}
diff --git a/serial/storage.h b/serial/storage.h
new file mode 100644
index 00000000..32b04a03
--- /dev/null
+++ b/serial/storage.h
@@ -0,0 +1,30 @@
+/*
+ *
+ * BlueZ - Bluetooth protocol stack for Linux
+ *
+ * Copyright (C) 2004-2008 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
+ *
+ */
+
+int port_delete(bdaddr_t *src, bdaddr_t *dst, int16_t id);
+int port_store(bdaddr_t *src, bdaddr_t *dst, int16_t id,
+ uint8_t ch, const char *svcname);
+int proxy_delete(bdaddr_t *src, const char *tty);
+int proxy_store(bdaddr_t *src, const char *uuid, const char *tty,
+ const char *name, uint8_t ch, int opts, struct termios *ti);
+int read_device_name(bdaddr_t *src, bdaddr_t *dst, char **name);
diff --git a/serial/test-serial b/serial/test-serial
new file mode 100755
index 00000000..aec728d4
--- /dev/null
+++ b/serial/test-serial
@@ -0,0 +1,40 @@
+#!/usr/bin/python
+
+import sys
+import time
+import dbus
+
+bus = dbus.SystemBus()
+
+manager = dbus.Interface(bus.get_object('org.bluez', '/org/bluez'),
+ 'org.bluez.Manager')
+
+conn = manager.ActivateService('serial')
+
+serial = dbus.Interface(bus.get_object(conn, '/org/bluez/serial'),
+ 'org.bluez.serial.Manager')
+
+if (len(sys.argv) < 2):
+ print "Usage: %s <address> [service]" % (sys.argv[0])
+ sys.exit(1)
+
+address = sys.argv[1]
+
+if (len(sys.argv) < 3):
+ service = "spp"
+else:
+ service = sys.argv[2]
+
+device = serial.ConnectService(address, service)
+
+print "Connected %s to %s" % (device, address)
+
+print "Press CTRL-C to disconnect"
+
+try:
+ time.sleep(1000)
+ print "Terminating connection"
+except:
+ pass
+
+serial.DisconnectService(device)
generated by cgit (git 2.34.1) at 2024-06-29 20:11:53 +0000