diff options
Diffstat (limited to 'network/manager.c')
| -rw-r--r-- | network/manager.c | 855 |
1 files changed, 855 insertions, 0 deletions
diff --git a/network/manager.c b/network/manager.c new file mode 100644 index 00000000..dd23b58d --- /dev/null +++ b/network/manager.c @@ -0,0 +1,855 @@ +/* + * + * 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 <ctype.h> +#include <dirent.h> + +#include <sys/stat.h> + +#include <bluetooth/bluetooth.h> +#include <bluetooth/hci.h> +#include <bluetooth/hci_lib.h> +#include <bluetooth/bnep.h> +#include <bluetooth/sdp.h> +#include <bluetooth/sdp_lib.h> + +#include <glib.h> +#include <gdbus.h> + +#include "logging.h" +#include "textfile.h" +#include "glib-helper.h" + +#define NETWORK_MANAGER_INTERFACE "org.bluez.network.Manager" + +#include "error.h" +#include "bridge.h" +#include "manager.h" +#include "common.h" + +#define MAX_NAME_SIZE 256 + +struct pending_reply { + DBusConnection *conn; + DBusMessage *msg; + bdaddr_t src; /* Source address */ + bdaddr_t dst; /* Destination address */ + char *addr; /* Destination address */ + char *path; /* D-Bus object path */ + char *adapter_path; /* Default adapter path */ + uint16_t id; /* Role */ +}; + +static struct network_conf *conf = NULL;/* Network service configuration */ +static GSList *server_paths = NULL; /* Network registered servers paths */ +static GSList *connection_paths = NULL; /* Network registered connections paths */ +static int default_index = -1; /* Network default connection path index */ +static int net_uid = 0; /* Network objects identifier */ + +static DBusConnection *connection = NULL; + +static void pending_reply_free(struct pending_reply *pr) +{ + if (pr->addr) + g_free(pr->addr); + if (pr->path) + g_free(pr->path); + if (pr->adapter_path) + g_free(pr->adapter_path); + if (pr->msg) + dbus_message_unref(pr->msg); + if (pr->conn) + dbus_connection_unref(pr->conn); +} + +static inline DBusMessage *does_not_exist(DBusMessage *msg) +{ + return g_dbus_create_error(msg, ERROR_INTERFACE ".AlreadyExists", + "No such connection"); +} + +static inline DBusMessage *already_exists(DBusMessage *msg) +{ + return g_dbus_create_error(msg, ERROR_INTERFACE ".AlreadyExists", + "Connection already exists"); +} + +static inline DBusMessage *not_supported(DBusMessage *msg) +{ + return g_dbus_create_error(msg, ERROR_INTERFACE ".NotSupported", + "Not supported"); +} + +static inline DBusMessage *connection_is_busy(DBusMessage *msg) +{ + return g_dbus_create_error(msg, ERROR_INTERFACE ".Failed", + "Connection is Busy"); +} + +static inline DBusMessage *adapter_not_available(DBusMessage *msg) +{ + return g_dbus_create_error(msg, ERROR_INTERFACE ".Failed", + "Adapter not available"); +} + +static void create_path(DBusConnection *conn, DBusMessage *msg, + const char *path, const char *sname) +{ + /* emit signal when it is a new path */ + if (sname) { + g_dbus_emit_signal(conn, NETWORK_PATH, + NETWORK_MANAGER_INTERFACE, + sname, DBUS_TYPE_STRING, &path, + DBUS_TYPE_INVALID); + } + + g_dbus_send_reply(conn, msg, DBUS_TYPE_STRING, &path, + DBUS_TYPE_INVALID); +} + +static DBusMessage *list_paths(DBusConnection *conn, DBusMessage *msg, + GSList *list) +{ + DBusMessage *reply; + DBusMessageIter iter; + DBusMessageIter array_iter; + + reply = dbus_message_new_method_return(msg); + if (reply == NULL) + return NULL; + + dbus_message_iter_init_append(reply, &iter); + dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, + DBUS_TYPE_STRING_AS_STRING, &array_iter); + + for (; list; list = list->next) { + dbus_message_iter_append_basic(&array_iter, + DBUS_TYPE_STRING, + &list->data); + } + + dbus_message_iter_close_container(&iter, &array_iter); + + return reply; +} + +static const char *last_connection_used(DBusConnection *conn) +{ + const char *path = NULL; + GSList *l; + int i; + + for (i = g_slist_length (connection_paths) -1; i > -1; i--) { + path = g_slist_nth_data (connection_paths, i); + if (connection_is_connected(path)) + break; + } + + /* No connection connected fallback to last connection */ + if (i == -1) { + l = g_slist_last(connection_paths); + path = l->data; + } + + return path; +} + +static DBusMessage *remove_path(DBusConnection *conn, + DBusMessage *msg, GSList **list, + const char *sname) +{ + const char *path; + GSList *l; + + if (dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &path, + DBUS_TYPE_INVALID) == FALSE) + return NULL; + + l = g_slist_find_custom(*list, path, (GCompareFunc) strcmp); + if (!l) + return does_not_exist(msg); + + /* Remove references from the storage */ + if (*list == connection_paths) { + if (connection_has_pending(path)) + return connection_is_busy(msg); + + connection_remove_stored(path); + /* Reset default connection */ + if (l == g_slist_nth(*list, default_index)) { + const char *dpath; + + dpath = last_connection_used(conn); + connection_store(dpath, TRUE); + } + } + + g_free(l->data); + *list = g_slist_remove(*list, l->data); + + g_dbus_emit_signal(conn, NETWORK_PATH, + NETWORK_MANAGER_INTERFACE, + sname, DBUS_TYPE_STRING, &path, + DBUS_TYPE_INVALID); + + g_dbus_unregister_interface(conn, path, NETWORK_CONNECTION_INTERFACE); + + return g_dbus_create_reply(msg, DBUS_TYPE_INVALID); +} + +static void records_cb(sdp_list_t *recs, int err, gpointer data) +{ + struct pending_reply *pr = data; + int len; + sdp_data_t *d; + sdp_record_t *rec = NULL; + char name[MAX_NAME_SIZE], *desc = NULL; + + if (err < 0) { + error_connection_attempt_failed(pr->conn, pr->msg, -err); + goto fail; + } + + if (!recs || !recs->data) { + error_not_supported(pr->conn, pr->msg); + error("Invalid PAN service record"); + goto fail; + } + + rec = recs->data; + + /* Concat remote name and service name */ + memset(name, 0, MAX_NAME_SIZE); + if (read_remote_name(&pr->src, &pr->dst, name, MAX_NAME_SIZE) < 0) + len = 0; + else + len = strlen(name); + + d = sdp_data_get(rec, SDP_ATTR_SVCNAME_PRIMARY); + if (d) { + snprintf(name + len, MAX_NAME_SIZE - len, + len ? " (%.*s)" : "%.*s", d->unitSize, d->val.str); + } + + /* Extract service description from record */ + d = sdp_data_get(rec, SDP_ATTR_SVCDESC_PRIMARY); + if (d) { + desc = g_new0(char, d->unitSize); + snprintf(desc, d->unitSize, "%.*s", + d->unitSize, d->val.str); + } + + sdp_list_free(recs, (sdp_free_func_t) sdp_record_free); + + if (connection_register(pr->path, &pr->src, &pr->dst, pr->id, name, + desc) < 0) { + error_failed(pr->conn, pr->msg, "D-Bus path registration failed"); + goto fail; + } + + connection_store(pr->path, FALSE); + connection_paths = g_slist_append(connection_paths, g_strdup(pr->path)); + + create_path(pr->conn, pr->msg, pr->path, "ConnectionCreated"); + +fail: + g_free(desc); + pending_reply_free(pr); +} + +static DBusMessage *list_servers(DBusConnection *conn, + DBusMessage *msg, void *data) +{ + return list_paths(conn, msg, server_paths); +} + +static DBusMessage *find_server(DBusConnection *conn, + DBusMessage *msg, void *data) +{ + const char *pattern; + const char *path; + GSList *list; + + if (dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &pattern, + DBUS_TYPE_INVALID) == FALSE) + return NULL; + + for (list = server_paths; list; list = list->next) { + path = (const char *) list->data; + if (server_find_data(path, pattern) == 0) + break; + } + + if (list == NULL) + return does_not_exist(msg); + + return g_dbus_create_reply(msg, DBUS_TYPE_STRING, &path, + DBUS_TYPE_INVALID); +} + +static DBusMessage *list_connections(DBusConnection *conn, + DBusMessage *msg, void *data) +{ + return list_paths(conn, msg, connection_paths); +} + +static GSList *find_connection_pattern(DBusConnection *conn, + const char *pattern) +{ + const char *path; + GSList *list; + + if (pattern == NULL) + return NULL; + + for (list = connection_paths; list; list = list->next) { + path = (const char *) list->data; + if (connection_find_data(path, pattern) == 0) + break; + } + + return list; +} + +static DBusMessage *find_connection(DBusConnection *conn, + DBusMessage *msg, void *data) +{ + const char *pattern; + const char *path; + GSList *list; + + if (dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &pattern, + DBUS_TYPE_INVALID) == FALSE) + return NULL; + + list = find_connection_pattern(conn, pattern); + if (list == NULL) + return does_not_exist(msg); + + path = list->data; + + return g_dbus_create_reply(msg, DBUS_TYPE_STRING, &path, + DBUS_TYPE_INVALID); +} + +static DBusMessage *create_connection(DBusConnection *conn, + DBusMessage *msg, void *data) +{ + struct pending_reply *pr; + const char *addr; + const char *str; + bdaddr_t src; + uint16_t id; + int dev_id, err; + char key[32]; + GSList *l; + uuid_t uuid; + + if (dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &addr, + DBUS_TYPE_STRING, &str, DBUS_TYPE_INVALID) == FALSE) + return NULL; + + id = bnep_service_id(str); + if (id != BNEP_SVC_GN && id != BNEP_SVC_NAP && id != BNEP_SVC_PANU) + return not_supported(msg); + + snprintf(key, 32, "%s#%s", addr, bnep_name(id)); + + /* Checks if the connection was already been made */ + for (l = connection_paths; l; l = l->next) { + if (connection_find_data(l->data, key) == 0) + return already_exists(msg); + } + + bacpy(&src, BDADDR_ANY); + dev_id = hci_get_route(&src); + if (dev_id < 0 || hci_devba(dev_id, &src) < 0) + return adapter_not_available(msg); + + pr = g_new0(struct pending_reply, 1); + + /* FIXME just to maintain compatibility */ + pr->adapter_path = g_strdup_printf("/org/bluez/hci%d", dev_id); + if (!pr->adapter_path) { + pending_reply_free (pr); + return adapter_not_available(msg); + } + + pr->conn = dbus_connection_ref(conn); + pr->msg = dbus_message_ref(msg); + bacpy(&pr->src, &src); + str2ba(addr, &pr->dst); + pr->addr = g_strdup(addr); + pr->id = id; + pr->path = g_new0(char, MAX_PATH_LENGTH); + snprintf(pr->path, MAX_PATH_LENGTH, + NETWORK_PATH "/connection%d", net_uid++); + + sdp_uuid16_create(&uuid, pr->id); + err = bt_search_service(&pr->src, &pr->dst, &uuid, records_cb, pr, + NULL); + if (err < 0) { + pending_reply_free(pr); + return not_supported(msg); + } + + return NULL; +} + +static DBusMessage *remove_connection(DBusConnection *conn, + DBusMessage *msg, void *data) +{ + return remove_path(conn, msg, &connection_paths, "ConnectionRemoved"); +} + +static DBusMessage *last_connection(DBusConnection *conn, + DBusMessage *msg, void *data) +{ + const char *path; + + if (connection_paths == NULL || + g_slist_length(connection_paths) == 0) + return does_not_exist(msg); + + path = last_connection_used(conn); + + return g_dbus_create_reply(msg, DBUS_TYPE_STRING, &path, + DBUS_TYPE_INVALID); +} + +static DBusMessage *default_connection(DBusConnection *conn, + DBusMessage *msg, void *data) +{ + const char *path; + + if (connection_paths == NULL || + g_slist_length (connection_paths) == 0) + return does_not_exist(msg); + + path = g_slist_nth_data (connection_paths, default_index); + + if (path == NULL) { + path = last_connection_used(conn); + connection_store(path, TRUE); + } + + return g_dbus_create_reply(msg, DBUS_TYPE_STRING, &path, + DBUS_TYPE_INVALID); +} + +static DBusMessage *change_default_connection(DBusConnection *conn, + DBusMessage *msg, void *data) +{ + const char *path; + const char *pattern; + GSList *list; + + if (dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &pattern, + DBUS_TYPE_INVALID) == FALSE) + return NULL; + + if (connection_paths == NULL || + g_slist_length(connection_paths) == 0) + return does_not_exist(msg); + + list = g_slist_find_custom(connection_paths, pattern, + (GCompareFunc) strcmp); + + /* Find object path via pattern */ + if (list == NULL) { + list = find_connection_pattern(conn, pattern); + if (list == NULL) + return does_not_exist(msg); + + path = list->data; + } else + path = list->data; + + default_index = g_slist_position(connection_paths, list); + connection_store(path, TRUE); + + g_dbus_emit_signal(connection, NETWORK_PATH, + NETWORK_MANAGER_INTERFACE, + "DefaultConnectionChanged", + DBUS_TYPE_STRING, &path, + DBUS_TYPE_INVALID); + + return g_dbus_create_reply(msg, DBUS_TYPE_STRING, &path, + DBUS_TYPE_INVALID); +} + +static void manager_unregister(void *data) +{ + info("Unregistered manager path"); + + if (server_paths) { + g_slist_foreach(server_paths, (GFunc) g_free, NULL); + g_slist_free(server_paths); + server_paths = NULL; + } + + if (connection_paths) { + g_slist_foreach(connection_paths, (GFunc) g_free, NULL); + g_slist_free(connection_paths); + connection_paths = NULL; + } + + bnep_kill_all_connections(); +} + +static void parse_stored_connection(char *key, char *value, void *data) +{ + bdaddr_t dst, *src = data; + char path[MAX_PATH_LENGTH]; + char addr[18]; + const char *ptr; + char *name; + int len, id; + + /* Format: XX:XX:XX:XX:XX:XX#{NAP, GN} name:description */ + + /* Parsing the key: address#role */ + ptr = strchr(key, '#'); + + /* Empty address or invalid len */ + if (!ptr || ((ptr - key) != 17)) + return; + + memset(addr, 0, 18); + strncpy(addr, key, 17); + str2ba(addr, &dst); + + /* Empty role */ + if (++ptr == NULL) + return; + + if (strcasecmp("nap", ptr) == 0) + id = BNEP_SVC_NAP; + else if (strcasecmp("gn", ptr) == 0) + id = BNEP_SVC_GN; + else if (strcasecmp("panu", ptr) == 0) + id = BNEP_SVC_PANU; + else + return; + + snprintf(path, MAX_PATH_LENGTH, + NETWORK_PATH "/connection%d", net_uid++); + + /* Parsing the value: name and description */ + ptr = strchr(value, ':'); + + /* Empty name */ + if (!ptr) + return; + + len = ptr-value; + name = g_malloc0(len + 1); + strncpy(name, value, len); + + /* Empty description */ + if (++ptr == NULL) { + g_free(name); + return; + } + + if (connection_register(path, src, &dst, id, name, ptr) == 0) { + char *rpath = g_strdup(path); + connection_paths = g_slist_append(connection_paths, rpath); + } + + g_free(name); +} + +static void register_connections_stored(const char *adapter) +{ + char filename[PATH_MAX + 1]; + char *pattern; + struct stat st; + GSList *list; + bdaddr_t src; + bdaddr_t default_src; + int dev_id; + + create_name(filename, PATH_MAX, STORAGEDIR, adapter, "network"); + + str2ba(adapter, &src); + + if (stat(filename, &st) < 0) + return; + + if (!(st.st_mode & __S_IFREG)) + return; + + textfile_foreach(filename, parse_stored_connection, &src); + + /* Check default connection for current default adapter */ + bacpy(&default_src, BDADDR_ANY); + dev_id = hci_get_route(&default_src); + if (dev_id < 0 || hci_devba(dev_id, &default_src) < 0) + return; + + if (bacmp(&default_src, &src) != 0) + return; + + pattern = textfile_get(filename, "default"); + if (!pattern) + return; + + list = find_connection_pattern(connection, pattern); + if (!list) + return; + default_index = g_slist_position(connection_paths, list); +} + +static void register_server(uint16_t id) +{ + char path[MAX_PATH_LENGTH]; + bdaddr_t src; + int dev_id; + + if (!conf->server_enabled) + return; + + snprintf(path, MAX_PATH_LENGTH, NETWORK_PATH "/%s", bnep_name(id)); + + if (g_slist_find_custom(server_paths, path, + (GCompareFunc) strcmp)) + return; + + bacpy(&src, BDADDR_ANY); + dev_id = hci_get_route(&src); + if (dev_id < 0 || hci_devba(dev_id, &src)) + return; + + if (server_register(path, &src, id) < 0) + return; + + server_store(path); + + server_paths = g_slist_append(server_paths, g_strdup(path)); +} + +static void register_servers_stored(const char *adapter, const char *profile) +{ + char filename[PATH_MAX + 1]; + char path[MAX_PATH_LENGTH]; + uint16_t id; + struct stat s; + bdaddr_t src; + + if (strcmp(profile, "nap") == 0) + id = BNEP_SVC_NAP; + else if (strcmp(profile, "gn") == 0) + id = BNEP_SVC_GN; + else + id = BNEP_SVC_PANU; + + create_name(filename, PATH_MAX, STORAGEDIR, adapter, profile); + + str2ba(adapter, &src); + + if (stat (filename, &s) == 0 && (s.st_mode & __S_IFREG)) { + snprintf(path, MAX_PATH_LENGTH, NETWORK_PATH "/%s", profile); + if (server_register_from_file(path, &src, id, filename) == 0) { + server_paths = g_slist_append(server_paths, + g_strdup(path)); + } + } +} + +static void register_stored(void) +{ + char dirname[PATH_MAX + 1]; + struct dirent *de; + DIR *dir; + + snprintf(dirname, PATH_MAX, "%s", STORAGEDIR); + + dir = opendir(dirname); + if (!dir) + return; + + while ((de = readdir(dir)) != NULL) { + if (!isdigit(de->d_name[0])) + continue; + + /* Connection objects */ + if (conf->connection_enabled) + register_connections_stored(de->d_name); + + /* Server objects */ + if (conf->server_enabled) { + /* NAP objects */ + register_servers_stored(de->d_name, "nap"); + + /* GN objects */ + register_servers_stored(de->d_name, "gn"); + + /* PANU objects */ + register_servers_stored(de->d_name, "panu"); + } + } + + closedir(dir); +} + +static GDBusMethodTable connection_methods[] = { + { "ListConnections", "", "as", list_connections }, + { "FindConnection", "s", "s", find_connection }, + { "CreateConnection", "ss", "s", create_connection, + G_DBUS_METHOD_FLAG_ASYNC }, + { "RemoveConnection", "s", "", remove_connection }, + { "LastConnection", "", "s", last_connection }, + { "DefaultConnection", "", "s", default_connection }, + { "ChangeDefaultConnection", "s", "s", change_default_connection }, + { } +}; + +static GDBusSignalTable connection_signals[] = { + { "ConnectionCreated", "s" }, + { "ConnectionRemoved", "s" }, + { "DefaultConnectionChanged", "s" }, + { } +}; + +static GDBusMethodTable server_methods[] = { + { "ListServers", "", "as", list_servers }, + { "FindServer", "s", "s", find_server }, + { } +}; + +static GDBusMethodTable manager_methods[] = { + { "ListServers", "", "as", list_servers }, + { "FindServer", "s", "s", find_server }, + { "ListConnections", "", "as", list_connections }, + { "FindConnection", "s", "s", find_connection }, + { "CreateConnection", "ss", "s", create_connection, + G_DBUS_METHOD_FLAG_ASYNC }, + { "RemoveConnection", "s", "", remove_connection }, + { "LastConnection", "", "s", last_connection }, + { "DefaultConnection", "", "s", default_connection }, + { "ChangeDefaultConnection", "s", "s", change_default_connection }, + { } +}; + +int network_manager_init(DBusConnection *conn, struct network_conf *service_conf) +{ + GDBusMethodTable *methods = NULL; + GDBusSignalTable *signals = NULL; + + conf = service_conf; + + if (conf->server_enabled && conf->connection_enabled) { + methods = manager_methods; + signals = connection_signals; + } else if (conf->connection_enabled) { + methods = connection_methods; + signals = connection_signals; + } else if (conf->server_enabled) + methods = server_methods; + else { + error ("All interfaces were disabled"); + return -1; + } + + if (bnep_init(conf->panu_script, conf->gn_script, conf->nap_script)) { + error("Can't init bnep module"); + return -1; + } + + /* + * There is one socket to handle the incomming connections. NAP, + * GN and PANU servers share the same PSM. The initial BNEP message + * (setup connection request) contains the destination service + * field that defines which service the source is connecting to. + */ + if (conf->server_enabled) { + if (bridge_init(conf->gn_iface, conf->nap_iface) < 0) { + error("Can't init bridge module"); + return -1; + } + + if (server_init(conn, conf->iface_prefix, conf->security) < 0) + return -1; + } + + if (conf->connection_enabled) { + if (connection_init(conn, conf->iface_prefix) < 0) + return -1; + } + + if (g_dbus_register_interface(conn, NETWORK_PATH, + NETWORK_MANAGER_INTERFACE, + methods, signals, NULL, + NULL, manager_unregister) == FALSE) { + error("Failed to register %s interface to %s", + NETWORK_MANAGER_INTERFACE, NETWORK_PATH); + return -1; + } + + connection = dbus_connection_ref(conn); + + info("Registered manager path:%s", NETWORK_PATH); + + register_stored(); + + /* Register PANU, GN and NAP servers if they don't exist */ + register_server(BNEP_SVC_PANU); + register_server(BNEP_SVC_GN); + register_server(BNEP_SVC_NAP); + + return 0; +} + +void network_manager_exit(void) +{ + if (conf->server_enabled) + server_exit(); + + if (conf->connection_enabled) + connection_exit(); + + g_dbus_unregister_interface(connection, NETWORK_PATH, + NETWORK_MANAGER_INTERFACE); + + dbus_connection_unref(connection); + connection = NULL; + + bnep_cleanup(); + bridge_cleanup(); +} + +static inline int create_filename(char *buf, size_t size, + bdaddr_t *bdaddr, const char *name) +{ + char addr[18]; + + ba2str(bdaddr, addr); + + return create_name(buf, size, STORAGEDIR, addr, name); +} |