From cfb4d2ae65f9dc2c2f792dfeb1afc164ee598efc Mon Sep 17 00:00:00 2001 From: Luiz Augusto von Dentz Date: Tue, 12 Aug 2008 18:59:10 -0300 Subject: Make serial plugin to register adapter drivers. --- serial/proxy.c | 1151 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 1151 insertions(+) create mode 100644 serial/proxy.c (limited to 'serial/proxy.c') diff --git a/serial/proxy.c b/serial/proxy.c new file mode 100644 index 00000000..88c517a0 --- /dev/null +++ b/serial/proxy.c @@ -0,0 +1,1151 @@ +/* + * + * BlueZ - Bluetooth protocol stack for Linux + * + * Copyright (C) 2004-2008 Marcel Holtmann + * + * + * 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 +#endif + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include + +#include +#include + +#include "../src/dbus-common.h" + +#include "logging.h" +#include "textfile.h" + +#include "error.h" +#include "storage.h" +#include "sdpd.h" +#include "glib-helper.h" + +#define SERIAL_PORT_NAME "spp" +#define SERIAL_PORT_UUID "00001101-0000-1000-8000-00805F9B34FB" + +#define DIALUP_NET_NAME "dun" +#define DIALUP_NET_UUID "00001103-0000-1000-8000-00805F9B34FB" + +#define SERIAL_PROXY_INTERFACE "org.bluez.serial.Proxy" +#define SERIAL_MANAGER_INTERFACE "org.bluez.serial.ProxyManager" +#define BUF_SIZE 1024 + +typedef enum { + TTY_PROXY, + UNIX_SOCKET_PROXY, + TCP_SOCKET_PROXY, + UNKNOWN_PROXY_TYPE = 0xFF +} proxy_type_t; + +struct serial_adapter { + bdaddr_t src; /* Adapter address */ + char *path; /* D-Bus path */ + DBusConnection *conn; /* Adapter connection */ + GSList *proxies; /* Proxies list */ +}; + +struct serial_proxy { + bdaddr_t dst; /* Remote address */ + char *path; /* Proxy path */ + char *uuid128; /* UUID 128 */ + char *address; /* TTY or Unix socket name */ + 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 */ + struct serial_adapter *adapter; /* Adapter pointer */ +}; + +static GSList *adapters = NULL; +static int sk_counter = 0; + +static void disable_proxy(struct serial_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 serial_proxy *prx) +{ + g_free(prx->path); + g_free(prx->address); + g_free(prx->uuid128); + g_free(prx); +} + +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 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 serial_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 serial_proxy *prx = data; + struct serial_adapter *adapter = prx->adapter; + sdp_record_t *record; + + if (prx->io) + return failed(msg, "Already enabled"); + + /* Listen */ + prx->io = bt_rfcomm_listen_allocate(&adapter->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(&adapter->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 serial_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 serial_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 serial_proxy *prx = data; + struct serial_adapter *adapter = prx->adapter; + 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(&adapter->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_path_unregister(gpointer data) +{ + struct serial_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 serial_proxy *prx, char *outpath, size_t size) +{ + struct serial_adapter *adapter = prx->adapter; + char path[MAX_PATH_LENGTH + 1]; + + snprintf(path, MAX_PATH_LENGTH, "%s/proxy%d", + adapter->path, sk_counter++); + + if (!g_dbus_register_interface(adapter->conn, path, + SERIAL_PROXY_INTERFACE, + proxy_methods, NULL, NULL, + prx, proxy_path_unregister)) { + error("D-Bus failed to register %s path", path); + return -1; + } + + prx->path = g_strdup(path); + adapter->proxies = g_slist_append(adapter->proxies, prx); + + if (outpath) + strncpy(outpath, path, size); + + info("Registered proxy: %s", path); + + return 0; +} + +static int proxy_tty_register(struct serial_adapter *adapter, + const char *uuid128, const char *address, + struct termios *ti, char *outpath, size_t size, + gboolean save) +{ + struct termios sys_ti; + struct serial_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 serial_proxy, 1); + prx->address = g_strdup(address); + prx->uuid128 = g_strdup(uuid128); + prx->type = TTY_PROXY; + prx->adapter = adapter; + + /* 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(&adapter->src, uuid128, address, NULL, + prx->channel, 0, &prx->proxy_ti); + + return ret; +} + +static int proxy_socket_register(struct serial_adapter *adapter, + const char *uuid128, const char *address, + char *outpath, size_t size, gboolean save) +{ + struct serial_proxy *prx; + int ret; + + prx = g_new0(struct serial_proxy, 1); + prx->address = g_strdup(address); + prx->uuid128 = g_strdup(uuid128); + prx->type = UNIX_SOCKET_PROXY; + prx->adapter = adapter; + + ret = register_proxy_object(prx, outpath, size); + if (ret < 0) + proxy_free(prx); + + if (save) + proxy_store(&adapter->src, uuid128, address, NULL, + prx->channel, 0, NULL); + + return ret; +} + +static int proxy_tcp_register(struct serial_adapter *adapter, + const char *uuid128, const char *address, + char *outpath, size_t size, gboolean save) +{ + struct serial_proxy *prx; + int ret; + + prx = g_new0(struct serial_proxy, 1); + prx->address = g_strdup(address); + prx->uuid128 = g_strdup(uuid128); + prx->type = TCP_SOCKET_PROXY; + prx->adapter = adapter; + + ret = register_proxy_object(prx, outpath, size); + if (ret < 0) + proxy_free(prx); + + if (save) + proxy_store(&adapter->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 serial_proxy *prx = proxy; + const char *address = addr; + + return strcmp(prx->address, address); +} + +static int proxy_pathcmp(gconstpointer proxy, gconstpointer p) +{ + const struct serial_proxy *prx = proxy; + const char *path = p; + + return strcmp(prx->path, path); +} + +static DBusMessage *create_proxy(DBusConnection *conn, + DBusMessage *msg, void *data) +{ + struct serial_adapter *adapter = data; + char path[MAX_PATH_LENGTH + 1]; + const char *uuid128, *address, *ppath = path; + DBusMessage *reply; + proxy_type_t type; + uuid_t uuid; + int 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(adapter->proxies, address, proxy_addrcmp)) + return g_dbus_create_error(msg, ERROR_INTERFACE ".AlreadyExist", + "Proxy already exists"); + + reply = dbus_message_new_method_return(msg); + if (!reply) + return NULL; + + switch (type) { + case UNIX_SOCKET_PROXY: + ret = proxy_socket_register(adapter, uuid128, address, + path, sizeof(path), TRUE); + break; + case TTY_PROXY: + ret = proxy_tty_register(adapter, uuid128, address, + NULL, path, sizeof(path), TRUE); + break; + case TCP_SOCKET_PROXY: + ret = proxy_tcp_register(adapter, 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(adapter->conn, adapter->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 serial_adapter *adapter = data; + 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 = adapter->proxies; l; l = l->next) { + struct serial_proxy *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 serial_adapter *adapter = data; + struct serial_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(adapter->proxies, path, proxy_pathcmp); + if (!l) + return does_not_exist(msg, "Invalid proxy path"); + + g_dbus_emit_signal(conn, adapter->path, + SERIAL_MANAGER_INTERFACE, "ProxyRemoved", + DBUS_TYPE_STRING, &path, + DBUS_TYPE_INVALID); + + prx = l->data; + proxy_delete(&adapter->src, prx->address); + adapter->proxies = g_slist_remove(adapter->proxies, prx); + + g_dbus_unregister_interface(conn, path, SERIAL_PROXY_INTERFACE); + + return dbus_message_new_method_return(msg); +} + +static void manager_path_unregister(void *data) +{ + struct serial_adapter *adapter = data; + GSList *l; + + /* Remove proxy objects */ + for (l = adapter->proxies; l; l = l->next) { + struct serial_proxy *prx = l->data; + + g_dbus_unregister_interface(adapter->conn, prx->path, + SERIAL_PROXY_INTERFACE); + } + + if (adapter->conn) + dbus_connection_unref(adapter->conn); + g_slist_free(adapter->proxies); + g_free(adapter->path); + g_free(adapter); +} + +static GDBusMethodTable manager_methods[] = { + { "CreateProxy", "ss", "s", create_proxy }, + { "ListProxies", "", "as", list_proxies }, + { "RemoveProxy", "s", "", remove_proxy }, + { }, +}; + +static GDBusSignalTable manager_signals[] = { + { "ProxyCreated", "s" }, + { "ProxyRemoved", "s" }, + { } +}; + +static void parse_proxy(char *key, char *value, void *data) +{ + struct serial_adapter *adapter = data; + char uuid128[MAX_LEN_UUID_STR], tmp[3]; + char *pvalue; + proxy_type_t type; + int ch, opts, pos; + 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'; + + 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(adapter, uuid128, key, &ti, NULL, 0, FALSE); + break; + case UNIX_SOCKET_PROXY: + proxy_socket_register(adapter, uuid128, key, NULL, 0, FALSE); + break; + case TCP_SOCKET_PROXY: + proxy_tcp_register(adapter, uuid128, key, NULL, 0, FALSE); + break; + default: + return; + } +} + +static void register_stored(struct serial_adapter *adapter) +{ + char filename[PATH_MAX + 1]; + char address[18]; + + ba2str(&adapter->src, address); + snprintf(filename, PATH_MAX, "%s/%s/proxy", STORAGEDIR, address); + textfile_foreach(filename, parse_proxy, adapter); +} + +static struct serial_adapter *find_adapter(GSList *list, const char *path) +{ + GSList *l; + + for (l = list; l; l = l->next) { + struct serial_adapter *adapter = l->data; + + if (g_str_equal(adapter->path, path)) + return adapter; + } + + return NULL; +} + +int proxy_register(DBusConnection *conn, const char *path, bdaddr_t *src) +{ + struct serial_adapter *adapter; + + adapter = find_adapter(adapters, path); + if (adapter) + return -EINVAL; + + adapter = g_new0(struct serial_adapter, 1); + adapter->conn = dbus_connection_ref(conn); + bacpy(&adapter->src, src); + adapter->path = g_strdup(path); + + if (!g_dbus_register_interface(conn, path, + SERIAL_MANAGER_INTERFACE, + manager_methods, manager_signals, NULL, + adapter, manager_path_unregister)) { + error("Failed to register %s interface to %s", + SERIAL_MANAGER_INTERFACE, path); + return -1; + } + + register_stored(adapter); + + adapters = g_slist_append(adapters, adapter); + + info("Registered interface %s on path %s", + SERIAL_MANAGER_INTERFACE, path); + + return 0; +} + +void proxy_unregister(const char *path) +{ + struct serial_adapter *adapter; + + adapter = find_adapter(adapters, path); + if (!adapter) + return; + + g_dbus_unregister_interface(adapter->conn, path, + SERIAL_MANAGER_INTERFACE); +} -- cgit