diff options
Diffstat (limited to 'binding')
| -rw-r--r-- | binding/CMakeLists.txt | 35 | ||||
| -rw-r--r-- | binding/bluetooth-map-api.c | 538 | ||||
| -rw-r--r-- | binding/bluetooth-map-api.h | 146 | ||||
| -rw-r--r-- | binding/bluetooth-map-bluez.c | 481 | ||||
| -rw-r--r-- | binding/bluetooth-map-common.h | 163 |
5 files changed, 1363 insertions, 0 deletions
diff --git a/binding/CMakeLists.txt b/binding/CMakeLists.txt new file mode 100644 index 0000000..6c137e9 --- /dev/null +++ b/binding/CMakeLists.txt @@ -0,0 +1,35 @@ +########################################################################### +# Copyright 2015, 2016, 2017 IoT.bzh +# +# author: Fulup Ar Foll <fulup@iot.bzh> +# contrib: Romain Forlot <romain.forlot@iot.bzh> +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +########################################################################### + +# Add target to project dependency list +PROJECT_TARGET_ADD(bluetooth-map-binding) + + # Define project Targets + add_library(bluetooth-map-binding MODULE bluetooth-map-api.c bluetooth-map-bluez.c) + + # Binder exposes a unique public entry point + SET_TARGET_PROPERTIES(${TARGET_NAME} PROPERTIES + PREFIX "afb-" + LABELS "BINDING" + LINK_FLAGS ${BINDINGS_LINK_FLAG} + OUTPUT_NAME ${TARGET_NAME} + ) + + # Library dependencies (include updates automatically) + TARGET_LINK_LIBRARIES(${TARGET_NAME} ${link_libraries}) diff --git a/binding/bluetooth-map-api.c b/binding/bluetooth-map-api.c new file mode 100644 index 0000000..798c9fa --- /dev/null +++ b/binding/bluetooth-map-api.c @@ -0,0 +1,538 @@ +/* + * Copyright (C) 2019 Konsulko Group + * Author: Matt Ranostay <matt.ranostay@konsulko.com> + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#define _GNU_SOURCE +#include <errno.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <sys/time.h> +#include <time.h> + +#include <glib.h> +#include <gio/gio.h> +#include <json-c/json.h> + +#define AFB_BINDING_VERSION 3 +#include <afb/afb-binding.h> + +#include "bluetooth-map-api.h" +#include "bluetooth-map-common.h" + +/** + * The global thread + */ +static GThread *global_thread; + +static void signal_init_done(struct init_data *id, int rc) +{ + g_mutex_lock(&id->mutex); + id->init_done = TRUE; + id->rc = rc; + g_cond_signal(&id->cond); + g_mutex_unlock(&id->mutex); +} + +struct map_state *map_get_userdata(afb_req_t request) { + afb_api_t api = afb_req_get_api(request); + return afb_api_get_userdata(api); +} + +void call_work_lock(struct map_state *ns) +{ + g_mutex_lock(&ns->cw_mutex); +} + +void call_work_unlock(struct map_state *ns) +{ + g_mutex_unlock(&ns->cw_mutex); +} + +static afb_event_t get_event_from_value(struct map_state *ns, + const char *value) +{ + if (!g_strcmp0(value, "notification")) + return ns->notification_event; + + return NULL; +} + +static void map_subscribe_unsubscribe(afb_req_t request, + gboolean unsub) +{ + struct map_state *ns = map_get_userdata(request); + json_object *jresp = json_object_new_object(); + const char *value; + afb_event_t event; + int rc; + + /* if value exists means to set offline mode */ + value = afb_req_value(request, "value"); + if (!value) { + afb_req_fail_f(request, "failed", "Missing \"value\" event"); + return; + } + + event = get_event_from_value(ns, value); + if (!event) { + afb_req_fail_f(request, "failed", "Bad \"value\" event \"%s\"", + value); + return; + } + + if (!unsub) { + rc = afb_req_subscribe(request, event); + } else { + rc = afb_req_unsubscribe(request, event); + } + if (rc != 0) { + afb_req_fail_f(request, "failed", + "%s error on \"value\" event \"%s\"", + !unsub ? "subscribe" : "unsubscribe", + value); + return; + } + + afb_req_success_f(request, jresp, "Bluetooth MAP %s to event \"%s\"", + !unsub ? "subscribed" : "unsubscribed", + value); +} + +static void subscribe(afb_req_t request) +{ + map_subscribe_unsubscribe(request, FALSE); +} + +static void unsubscribe(afb_req_t request) +{ + map_subscribe_unsubscribe(request, TRUE); +} + +static void map_request_message(struct map_state *ns, const gchar *path) +{ + GVariant *params = + g_variant_new("(&sb)", "", g_variant_new_boolean(FALSE)); + bluez_call(ns, BLUEZ_AT_MESSAGE, path, "Get", params, NULL); +} + +static void map_notification_event(struct map_state *ns, gchar *filename) +{ + json_object *jresp; + gchar *buf; + + if (!g_file_get_contents(filename, &buf, NULL, NULL)) + return; + + jresp = json_object_new_object(); + json_object_object_add(jresp, "bmessage", json_object_new_string(buf)); + + afb_event_push(ns->notification_event, jresp); + g_free(buf); +} + +static void bluez_map_signal_callback( + GDBusConnection *connection, + const gchar *sender_name, + const gchar *object_path, + const gchar *interface_name, + const gchar *signal_name, + GVariant *parameters, + gpointer user_data) +{ + struct map_state *ns = user_data; + GVariant *var = NULL; + const gchar *path = NULL; + const gchar *key = NULL; + GVariantIter *array = NULL, *array1 = NULL; + + /* AFB_INFO("sender=%s", sender_name); + AFB_INFO("object_path=%s", object_path); + AFB_INFO("interface=%s", interface_name); + AFB_INFO("signal=%s", signal_name); */ + + if (!g_strcmp0(signal_name, "InterfacesAdded")) { + + g_variant_get(parameters, "(&oa{sa{sv}})", &path, &array); + + while (g_variant_iter_next(array, "{&s@a{sv}}", &key, &var)) { + const char *name = NULL; + GVariant *val = NULL; + + if (!g_strcmp0(key, BLUEZ_OBEX_MESSAGE_INTERFACE)) { + map_request_message(ns, path); + continue; + } + + if (g_strcmp0(key, BLUEZ_OBEX_TRANSFER_INTERFACE)) + continue; + + array1 = g_variant_iter_new(var); + + while (g_variant_iter_next(array1, "{&sv}", &name, &val)) { + if (g_strcmp0(name, "Filename")) + continue; + + call_work_lock(ns); + g_hash_table_insert(ns->xfer_queue, g_strdup(path), + g_strdup(g_variant_get_string(val, NULL))); + call_work_unlock(ns); + break; + } + } + + } else if (!g_strcmp0(signal_name, "PropertiesChanged")) { + + g_variant_get(parameters, "(&sa{sv}as)", &path, &array, &array1); + + if (g_strcmp0(path, BLUEZ_OBEX_TRANSFER_INTERFACE)) + return; + + while (g_variant_iter_next(array, "{&sv}", &key, &var)) { + gchar *filename; + + // only check Status field + if (g_strcmp0(key, "Status")) + continue; + + // only need the "complete" Status + if (g_strcmp0(g_variant_get_string(var, NULL), "complete")) + return; + + call_work_lock(ns); + filename = (gchar *) g_hash_table_lookup(ns->xfer_queue, object_path); + if (filename) { + g_hash_table_remove(ns->xfer_queue, object_path); + call_work_unlock(ns); + + map_notification_event(ns, filename); + g_free(filename); + break; + } + call_work_unlock(ns); + } + } +} + +static struct map_state *map_init(GMainLoop *loop) +{ + struct map_state *ns; + GError *error = NULL; + + ns = g_try_malloc0(sizeof(*ns)); + if (!ns) { + AFB_ERROR("out of memory allocating map state"); + goto err_no_ns; + } + + AFB_INFO("connecting to dbus"); + + ns->loop = loop; + ns->conn = g_bus_get_sync(G_BUS_TYPE_SESSION, NULL, &error); + if (!ns->conn) { + if (error) + g_dbus_error_strip_remote_error(error); + AFB_ERROR("Cannot connect to D-Bus, %s", + error ? error->message : "unspecified"); + g_error_free(error); + goto err_no_conn; + + } + + AFB_INFO("connected to dbus"); + + ns->notification_event = + afb_daemon_make_event("notification"); + + if (!afb_event_is_valid(ns->notification_event)) { + AFB_ERROR("Cannot create events"); + goto err_no_events; + } + + ns->xfer_queue = g_hash_table_new(g_str_hash, g_str_equal); + ns->message_sub = g_dbus_connection_signal_subscribe( + ns->conn, + BLUEZ_OBEX_SERVICE, + NULL, /* interface */ + NULL, /* member */ + NULL, /* object path */ + NULL, /* arg0 */ + G_DBUS_SIGNAL_FLAGS_NONE, + bluez_map_signal_callback, + ns, + NULL); + if (!ns->message_sub) { + AFB_ERROR("Unable to subscribe to interface signals"); + goto err_no_message_sub; + } + + g_mutex_init(&ns->cw_mutex); + ns->next_cw_id = 1; + + return ns; + +err_no_message_sub: + /* no way to clear the events */ +err_no_events: + g_dbus_connection_close(ns->conn, NULL, NULL, NULL); +err_no_conn: + g_free(ns); +err_no_ns: + return NULL; +} + +static void map_cleanup(struct map_state *ns) +{ + g_dbus_connection_signal_unsubscribe(ns->conn, ns->message_sub); + g_dbus_connection_close(ns->conn, NULL, NULL, NULL); + g_free(ns); +} + +static gpointer map_func(gpointer ptr) +{ + struct init_data *id = ptr; + struct map_state *ns; + GMainLoop *loop; + + loop = g_main_loop_new(NULL, FALSE); + if (!loop) { + AFB_ERROR("Unable to create main loop"); + goto err_no_loop; + } + + /* real map init */ + ns = map_init(loop); + if (!ns) { + AFB_ERROR("map_init() failed"); + goto err_no_ns; + } + + id->ns = ns; + ns->loop = loop; + + afb_api_set_userdata(id->api, ns); + signal_init_done(id, 0); + + g_main_loop_run(loop); + g_main_loop_unref(ns->loop); + + map_cleanup(ns); + afb_api_set_userdata(id->api, NULL); + + return NULL; + +err_no_ns: + g_main_loop_unref(loop); + +err_no_loop: + return NULL; +} + +static gboolean map_create_session(struct map_state *ns, const char *address) +{ + GVariant *reply, *params, *dict; + GVariantBuilder builder; + gchar *val; + + g_variant_builder_init(&builder, G_VARIANT_TYPE("a{sv}")); + g_variant_builder_add(&builder, "{sv}", "Target", g_variant_new_string("map")); + dict = g_variant_builder_end(&builder); + params = g_variant_new("(&s@a{sv})", address, dict); + + reply = bluez_call(ns, BLUEZ_AT_CLIENT, NULL, "CreateSession", params, NULL); + if (!reply) { + AFB_ERROR("Cannot open MAP OBEX session"); + return FALSE; + } + + call_work_lock(ns); + + g_variant_get(reply, "(&o)", &val); + ns->session_path = g_strdup(val); + + call_work_unlock(ns); + + g_variant_unref(reply); + + return TRUE; +} + +static gboolean is_map_dev_and_init(struct map_state *ns, struct json_object *dev) +{ + struct json_object *props = NULL, *val = NULL; + int i; + + json_object_object_get_ex(dev, "properties", &props); + if (!props) + return FALSE; + + json_object_object_get_ex(props, "connected", &val); + if (!val || !json_object_get_boolean(val)) + return FALSE; + + json_object_object_get_ex(props, "uuids", &val); + for (i = 0; i < json_object_array_length(val); i++) { + const char *uuid = json_object_get_string(json_object_array_get_idx(val, i)); + const char *address = NULL; + struct json_object *val1 = NULL; + + if (g_strcmp0(MAP_UUID, uuid)) + continue; + + json_object_object_get_ex(props, "address", &val1); + address = json_object_get_string(val1); + + if (!address) + return FALSE; + + if (map_create_session(ns, address)) { + json_object_object_get_ex(dev, "device", &val1); + AFB_NOTICE("MAP device connected: %s", json_object_get_string(val1)); + + return TRUE; + } + break; + } + + return FALSE; +} + +static void discovery_result_cb(void *closure, struct json_object *result, + const char *error, const char *info, + afb_api_t api) +{ + struct map_state *ns = afb_api_get_userdata(api); + enum json_type type; + struct json_object *dev, *tmp; + int i; + + if (!json_object_object_get_ex(result, "devices", &tmp)) + return; + type = json_object_get_type(tmp); + + if (type != json_type_array) + return; + + for (i = 0; i < json_object_array_length(tmp); i++) { + dev = json_object_array_get_idx(tmp, i); + if (is_map_dev_and_init(ns, dev)) + return; + } +} + +static void process_connection_event(afb_api_t api, struct json_object *object) +{ + struct json_object *val = NULL, *props = NULL; + const char *action, *device; + + json_object_object_get_ex(object, "action", &val); + if (!val) + return; + action = json_object_get_string(val); + if (g_strcmp0("changed", action)) + return; + + json_object_object_get_ex(object, "properties", &props); + if (!props) + return; + + json_object_object_get_ex(props, "connected", &val); + if (!val) + return; + + if (json_object_get_boolean(val)) { + struct json_object *args = json_object_new_object(); + afb_api_call(api, "Bluetooth-Manager", "managed_objects", + args, discovery_result_cb, NULL); + return; + } + + json_object_object_get_ex(object, "device", &val); + if (!val) + return; + + device = json_object_get_string(val); + + AFB_NOTICE("MAP device disconnected: %s", device); +} + +static int init(afb_api_t api) +{ + struct init_data init_data, *id = &init_data; + json_object *args; + gint64 end_time; + int ret; + + memset(id, 0, sizeof(*id)); + id->init_done = FALSE; + id->rc = 0; + id->api = api; + g_cond_init(&id->cond); + g_mutex_init(&id->mutex); + + ret = afb_daemon_require_api("Bluetooth-Manager", 1); + if (ret) { + AFB_ERROR("unable to initialize bluetooth binding"); + return -EINVAL; + } + + global_thread = g_thread_new("agl-service-bluetooth-map", map_func, id); + + AFB_INFO("bluetooth-map binding waiting for init done"); + + /* wait maximum 3 seconds for init done */ + end_time = g_get_monotonic_time () + 3 * G_TIME_SPAN_SECOND; + g_mutex_lock(&id->mutex); + while (!id->init_done) { + if (!g_cond_wait_until(&id->cond, &id->mutex, end_time)) + break; + } + g_mutex_unlock(&id->mutex); + + /* subscribe to Bluetooth-Manager events */ + args = json_object_new_object(); + json_object_object_add(args , "value", json_object_new_string("device_changes")); + afb_api_call_sync(api, "Bluetooth-Manager", "subscribe", args, NULL, NULL, NULL); + + args = json_object_new_object(); + afb_api_call(api, "Bluetooth-Manager", "managed_objects", args, discovery_result_cb, NULL); + + return id->rc; +} + +static void onevent(afb_api_t api, const char *event, struct json_object *object) +{ + if (!g_ascii_strcasecmp(event, "Bluetooth-Manager/device_changes")) + process_connection_event(api, object); + else + AFB_ERROR("Unsupported event: %s\n", event); +} + +static const afb_verb_t binding_verbs[] = { + { .verb = "subscribe", .callback = subscribe, .info = "Subscribe to events" }, + { .verb = "unsubscribe",.callback = unsubscribe,.info = "Unsubscribe to events" }, + {} +}; + +/* + * description of the binding for afb-daemon + */ +const afb_binding_t afbBindingV3 = { + .api = "bluetooth-map", + .verbs = binding_verbs, + .init = init, + .onevent = onevent, +}; diff --git a/binding/bluetooth-map-api.h b/binding/bluetooth-map-api.h new file mode 100644 index 0000000..906c360 --- /dev/null +++ b/binding/bluetooth-map-api.h @@ -0,0 +1,146 @@ +/* + * Copyright 2019 Konsulko Group + * Author: Matt Ranostay <matt.ranostay@konsulko.com> + * Author: Pantelis Antoniou <pantelis.antoniou@konsulko.com> + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef BLUETOOTH_MAP_API_H +#define BLUETOOTH_MAP_API_H + +#include <stdio.h> +#include <stddef.h> +#include <string.h> +#include <glib.h> +#include <json-c/json.h> + +#define BLUEZ_OBEX_SERVICE "org.bluez.obex" +#define BLUEZ_OBEX_CLIENT_INTERFACE BLUEZ_OBEX_SERVICE ".Client1" +#define BLUEZ_OBEX_SESSION_INTERFACE BLUEZ_OBEX_SERVICE ".Session1" +#define BLUEZ_OBEX_TRANSFER_INTERFACE BLUEZ_OBEX_SERVICE ".Transfer1" +#define BLUEZ_OBEX_MESSAGE_INTERFACE BLUEZ_OBEX_SERVICE ".Message1" + +#define BLUEZ_OBJECT_PATH "/" +#define BLUEZ_OBEX_PATH "/org/bluez/obex" + +#define BLUEZ_ERRMSG(error) \ + (error ? error->message : "unspecified") + +#define FREEDESKTOP_INTROSPECT "org.freedesktop.DBus.Introspectable" +#define FREEDESKTOP_PROPERTIES "org.freedesktop.DBus.Properties" +#define FREEDESKTOP_OBJECTMANAGER "org.freedesktop.DBus.ObjectManager" + +#define DBUS_REPLY_TIMEOUT (120 * 1000) +#define DBUS_REPLY_TIMEOUT_SHORT (10 * 1000) + +#define BLUEZ_AT_OBJECT "object" +#define BLUEZ_AT_CLIENT "client" +#define BLUEZ_AT_SESSION "session" +#define BLUEZ_AT_TRANSFER "transfer" +#define BLUEZ_AT_MESSAGE "message" + +struct map_state; + +struct map_state *map_get_userdata(afb_req_t request); + +struct call_work *call_work_create_unlocked(struct map_state *ns, + const char *access_type, const char *type_arg, + const char *method, const char *bluez_method, + GError **error); + +void call_work_destroy_unlocked(struct call_work *cw); + +void call_work_lock(struct map_state *ns); + +void call_work_unlock(struct map_state *ns); + +struct call_work *call_work_lookup_unlocked( + struct map_state *ns, + const char *access_type, const char *type_arg, + const char *method); + +const struct property_info *bluez_get_property_info( + const char *access_type, GError **error); + +gboolean bluez_property_dbus2json(const char *access_type, + json_object *jprop, const gchar *key, GVariant *var, + gboolean *is_config, + GError **error); + +GVariant *bluez_call(struct map_state *ns, + const char *access_type, const char *type_arg, + const char *method, GVariant *params, GError **error); + +json_object *bluez_get_properties(struct map_state *ns, + const char *access_type, const char *path, + GError **error); + +json_object *bluez_get_property(struct map_state *ns, + const char *access_type, const char *type_arg, + gboolean is_json_name, const char *name, GError **error); + +gboolean bluez_set_property(struct map_state *ns, + const char *access_type, const char *type_arg, + gboolean is_json_name, const char *name, json_object *jval, + GError **error); + +gboolean bluetooth_autoconnect(gpointer data); + +/* convenience access methods */ +static inline gboolean session_property_dbus2json(json_object *jprop, + const gchar *key, GVariant *var, gboolean *is_config, + GError **error) +{ + return bluez_property_dbus2json(BLUEZ_AT_SESSION, + jprop, key, var, is_config, error); +} + +static inline gboolean transfer_property_dbus2json(json_object *jprop, + const gchar *key, GVariant *var, gboolean *is_config, + GError **error) +{ + return bluez_property_dbus2json(BLUEZ_AT_TRANSFER, + jprop, key, var, is_config, error); +} + +static inline json_object *object_properties(struct map_state *ns, + GError **error) +{ + return bluez_get_properties(ns, + BLUEZ_AT_OBJECT, BLUEZ_OBJECT_PATH, error); +} + +struct bluez_pending_work { + struct map_state *ns; + void *user_data; + GCancellable *cancel; + void (*callback)(void *user_data, GVariant *result, GError **error); +}; + +void bluez_cancel_call(struct map_state *ns, + struct bluez_pending_work *cpw); + +struct bluez_pending_work * +bluez_call_async(struct map_state *ns, + const char *access_type, const char *type_arg, + const char *method, GVariant *params, GError **error, + void (*callback)(void *user_data, GVariant *result, GError **error), + void *user_data); + +void bluez_decode_call_error(struct map_state *ns, + const char *access_type, const char *type_arg, + const char *method, + GError **error); + +#endif /* BLUETOOTH_MAP_API_H */ diff --git a/binding/bluetooth-map-bluez.c b/binding/bluetooth-map-bluez.c new file mode 100644 index 0000000..6d70fab --- /dev/null +++ b/binding/bluetooth-map-bluez.c @@ -0,0 +1,481 @@ +/* + * Copyright (C) 2019 Konsulko Group + * Author: Matt Ranostay <matt.ranostay@konsulko.com> + * Author: Pantelis Antoniou <pantelis.antoniou@konsulko.com> + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#define _GNU_SOURCE +#include <stdio.h> +#include <string.h> +#include <stdlib.h> +#include <unistd.h> +#include <errno.h> +#include <pthread.h> +#include <semaphore.h> + +#include <glib.h> +#include <stdlib.h> +#include <gio/gio.h> +#include <glib-object.h> + +#include <json-c/json.h> + +#define AFB_BINDING_VERSION 3 +#include <afb/afb-binding.h> + +#include "bluetooth-map-api.h" +#include "bluetooth-map-common.h" + +G_DEFINE_QUARK(bluetooth-map-error-quark, nb_error); + +static const struct property_info session_props[] = { + { .name = "Source", .fmt = "s", }, + { .name = "Destination", .fmt = "s", }, + { .name = "Channel", .fmt = "y", }, + { .name = "Target", .fmt = "s", }, + { .name = "Root", .fmt = "s", }, + {}, +}; + +static const struct property_info transfer_props[] = { + { .name = "Status", .fmt = "s", }, + { .name = "Session", .fmt = "o", }, + { .name = "Name", .fmt = "s", }, + { .name = "Type", .fmt = "s", }, + { .name = "Time", .fmt = "t", }, + { .name = "Size", .fmt = "t", }, + { .name = "Transferred", .fmt = "t", }, + { .name = "Filename", .fmt = "s", }, + {}, +}; + +static const struct property_info message_props[] = { + { .name = "Folder", .fmt = "s", }, + { .name = "Subject", .fmt = "s", }, + { .name = "Timestamp", .fmt = "s", }, + { .name = "Sender", .fmt = "s", }, + { .name = "SenderAddress", .fmt = "s", }, + { .name = "ReplyTo", .fmt = "s", }, + { .name = "Recipient", .fmt = "s", }, + { .name = "RecipientAddress", .fmt = "s", }, + { .name = "Type", .fmt = "s", }, + { .name = "Size", .fmt = "t", }, + { .name = "Status", .fmt = "s", }, + { .name = "Priority", .fmt = "b", }, + { .name = "Read", .fmt = "b", }, + { .name = "Deleted", .fmt = "b", }, + { .name = "Sent", .fmt = "b", }, + { .name = "Protected", .fmt = "b", }, + {}, +}; + +const struct property_info *bluez_get_property_info( + const char *access_type, GError **error) +{ + const struct property_info *pi = NULL; + + if (!strcmp(access_type, BLUEZ_AT_SESSION)) + pi = session_props; + else if (!strcmp(access_type, BLUEZ_AT_TRANSFER)) + pi = transfer_props; + else if (!strcmp(access_type, BLUEZ_AT_MESSAGE)) + pi = message_props; + else + g_set_error(error, NB_ERROR, NB_ERROR_ILLEGAL_ARGUMENT, + "illegal %s argument", access_type); + return pi; +} + +gboolean bluez_property_dbus2json(const char *access_type, + json_object *jprop, const gchar *key, GVariant *var, + gboolean *is_config, + GError **error) +{ + const struct property_info *pi; + gboolean ret; + + *is_config = FALSE; + pi = bluez_get_property_info(access_type, error); + if (!pi) + return FALSE; + + ret = root_property_dbus2json(jprop, pi, key, var, is_config); + if (!ret) + g_set_error(error, NB_ERROR, NB_ERROR_UNKNOWN_PROPERTY, + "unknown %s property %s", + access_type, key); + + return ret; +} + +void bluez_decode_call_error(struct map_state *ns, + const char *access_type, const char *type_arg, + const char *method, + GError **error) +{ + if (!error || !*error) + return; + + if (strstr((*error)->message, + "org.freedesktop.DBus.Error.UnknownObject")) { + + if (!strcmp(method, "Set") || + !strcmp(method, "Get") || + !strcmp(method, "GetAll")) { + + g_clear_error(error); + g_set_error(error, NB_ERROR, + NB_ERROR_UNKNOWN_PROPERTY, + "unknown %s property on %s", + access_type, type_arg); + + } else if (!strcmp(method, "CreateSession") || + !strcmp(method, "RemoveSession")) { + + g_clear_error(error); + g_set_error(error, NB_ERROR, + NB_ERROR_UNKNOWN_SERVICE, + "unknown service %s", + type_arg); + + } else if (!strcmp(method, "Cancel") || + !strcmp(method, "Suspend") || + !strcmp(method, "Resume")) { + + g_clear_error(error); + g_set_error(error, NB_ERROR, + NB_ERROR_UNKNOWN_TRANSFER, + "unknown transfer %s", + type_arg); + + } + } +} + +GVariant *bluez_call(struct map_state *ns, + const char *access_type, const char *path, + const char *method, GVariant *params, GError **error) +{ + const char *interface; + GVariant *reply; + + if (!path && (!strcmp(access_type, BLUEZ_AT_SESSION) || + !strcmp(access_type, BLUEZ_AT_TRANSFER) || + !strcmp(access_type, BLUEZ_AT_MESSAGE))) { + g_set_error(error, NB_ERROR, NB_ERROR_MISSING_ARGUMENT, + "missing %s argument", + access_type); + return NULL; + } + + if (!strcmp(access_type, BLUEZ_AT_CLIENT)) { + path = BLUEZ_OBEX_PATH; + interface = BLUEZ_OBEX_CLIENT_INTERFACE; + } else if (!strcmp(access_type, BLUEZ_AT_SESSION)) { + interface = BLUEZ_OBEX_SESSION_INTERFACE; + } else if (!strcmp(access_type, BLUEZ_AT_TRANSFER)) { + interface = BLUEZ_OBEX_TRANSFER_INTERFACE; + } else if (!strcmp(access_type, BLUEZ_AT_MESSAGE)) { + interface = BLUEZ_OBEX_MESSAGE_INTERFACE; + } else { + g_set_error(error, NB_ERROR, NB_ERROR_ILLEGAL_ARGUMENT, + "illegal %s argument", + access_type); + return NULL; + } + + reply = g_dbus_connection_call_sync(ns->conn, + BLUEZ_OBEX_SERVICE, path, interface, method, params, + NULL, G_DBUS_CALL_FLAGS_NONE, DBUS_REPLY_TIMEOUT, + NULL, error); + bluez_decode_call_error(ns, access_type, path, method, + error); + if (!reply && error) { + if (*error) + g_dbus_error_strip_remote_error(*error); + AFB_ERROR("Error calling %s%s%s %s method %s", + access_type, + path ? "/" : "", + path ? path : "", + method, + error && *error ? (*error)->message : + "unspecified"); + } + + return reply; +} + +static void bluez_call_async_ready(GObject *source_object, + GAsyncResult *res, gpointer user_data) +{ + struct bluez_pending_work *cpw = user_data; + struct map_state *ns = cpw->ns; + GVariant *result; + GError *error = NULL; + + result = g_dbus_connection_call_finish(ns->conn, res, &error); + + cpw->callback(cpw->user_data, result, &error); + + g_clear_error(&error); + g_cancellable_reset(cpw->cancel); + g_free(cpw); +} + +void bluez_cancel_call(struct map_state *ns, + struct bluez_pending_work *cpw) +{ + g_cancellable_cancel(cpw->cancel); +} + +struct bluez_pending_work * +bluez_call_async(struct map_state *ns, + const char *access_type, const char *type_arg, + const char *method, GVariant *params, GError **error, + void (*callback)(void *user_data, GVariant *result, GError **error), + void *user_data) +{ + const char *path; + const char *interface; + struct bluez_pending_work *cpw; + + if (!type_arg && (!strcmp(access_type, BLUEZ_AT_SESSION) || + !strcmp(access_type, BLUEZ_AT_TRANSFER))) { + g_set_error(error, NB_ERROR, NB_ERROR_MISSING_ARGUMENT, + "missing %s argument", + access_type); + return NULL; + } + + if (!strcmp(access_type, BLUEZ_AT_SESSION)) { + path = type_arg; + interface = BLUEZ_OBEX_SESSION_INTERFACE; + } else if (!strcmp(access_type, BLUEZ_AT_TRANSFER)) { + path = type_arg; + interface = BLUEZ_OBEX_TRANSFER_INTERFACE; + } else { + g_set_error(error, NB_ERROR, NB_ERROR_ILLEGAL_ARGUMENT, + "illegal %s argument", + access_type); + return NULL; + } + + cpw = g_malloc(sizeof(*cpw)); + if (!cpw) { + g_set_error(error, NB_ERROR, NB_ERROR_OUT_OF_MEMORY, + "out of memory"); + return NULL; + } + cpw->ns = ns; + cpw->user_data = user_data; + cpw->cancel = g_cancellable_new(); + if (!cpw->cancel) { + g_free(cpw); + g_set_error(error, NB_ERROR, NB_ERROR_OUT_OF_MEMORY, + "out of memory"); + return NULL; + } + cpw->callback = callback; + + g_dbus_connection_call(ns->conn, + BLUEZ_OBEX_SERVICE, path, interface, method, params, + NULL, /* reply type */ + G_DBUS_CALL_FLAGS_NONE, DBUS_REPLY_TIMEOUT, + cpw->cancel, /* cancellable? */ + bluez_call_async_ready, + cpw); + + return cpw; +} + +json_object *bluez_get_properties(struct map_state *ns, + const char *access_type, const char *path, + GError **error) +{ + const struct property_info *pi = NULL; + const char *method = NULL; + GVariant *reply = NULL, *var = NULL; + GVariantIter *array; + const char *interface, *interface2; + const gchar *key = NULL; + json_object *jprop = NULL, *jresp = NULL; + gboolean is_config; + + if (!strcmp(access_type, BLUEZ_AT_SESSION) || + !strcmp(access_type, BLUEZ_AT_TRANSFER) || + !strcmp(access_type, BLUEZ_AT_MESSAGE)) { + + pi = bluez_get_property_info(access_type, error); + if (!pi) + return NULL; + + interface = FREEDESKTOP_PROPERTIES; + method = "GetAll"; + } else if (!strcmp(access_type, BLUEZ_AT_OBJECT)) { + interface = FREEDESKTOP_OBJECTMANAGER; + method = "GetManagedObjects"; + } else { + return FALSE; + } + + if (!strcmp(access_type, BLUEZ_AT_SESSION)) + interface2 = BLUEZ_OBEX_SESSION_INTERFACE; + else if (!strcmp(access_type, BLUEZ_AT_TRANSFER)) + interface2 = BLUEZ_OBEX_TRANSFER_INTERFACE; + else if (!strcmp(access_type, BLUEZ_AT_MESSAGE)) + interface2 = BLUEZ_OBEX_MESSAGE_INTERFACE; + else if (!strcmp(access_type, BLUEZ_AT_OBJECT)) + interface2 = NULL; + else + return FALSE; + + if (!method) { + g_set_error(error, NB_ERROR, NB_ERROR_ILLEGAL_ARGUMENT, + "illegal %s argument", + access_type); + return NULL; + } + + reply = g_dbus_connection_call_sync(ns->conn, + BLUEZ_OBEX_SERVICE, path, interface, method, + interface2 ? g_variant_new("(s)", interface2) : NULL, + NULL, G_DBUS_CALL_FLAGS_NONE, DBUS_REPLY_TIMEOUT, + NULL, error); + + if (!reply) + return NULL; + + if (!strcmp(access_type, BLUEZ_AT_SESSION) || + !strcmp(access_type, BLUEZ_AT_TRANSFER) || + !strcmp(access_type, BLUEZ_AT_MESSAGE)) { + jprop = json_object_new_object(); + g_variant_get(reply, "(a{sv})", &array); + while (g_variant_iter_loop(array, "{sv}", &key, &var)) { + root_property_dbus2json(jprop, pi, + key, var, &is_config); + } + g_variant_iter_free(array); + g_variant_unref(reply); + jresp = jprop; + } else if (!strcmp(access_type, BLUEZ_AT_OBJECT)) { + /* TODO: maybe not needed */ + + g_variant_iter_free(array); + g_variant_unref(reply); + } + + if (!jresp) { + g_set_error(error, NB_ERROR, NB_ERROR_ILLEGAL_ARGUMENT, + "No %s", access_type); + } + + return jresp; +} + +json_object *bluez_get_property(struct map_state *ns, + const char *access_type, const char *path, + gboolean is_json_name, const char *name, GError **error) +{ + const struct property_info *pi; + json_object *jprop, *jval; + + pi = bluez_get_property_info(access_type, error); + if (!pi) + return NULL; + + jprop = bluez_get_properties(ns, access_type, path, error); + if (!jprop) + return NULL; + + jval = get_named_property(pi, is_json_name, name, jprop); + json_object_put(jprop); + + if (!jval) + g_set_error(error, NB_ERROR, NB_ERROR_BAD_PROPERTY, + "Bad property %s on %s%s%s", name, + access_type, + path ? "/" : "", + path ? path : ""); + return jval; +} + +/* NOTE: jval is consumed */ +gboolean bluez_set_property(struct map_state *ns, + const char *access_type, const char *path, + gboolean is_json_name, const char *name, json_object *jval, + GError **error) +{ + const struct property_info *pi; + GVariant *reply, *arg; + const char *interface; + gboolean is_config; + gchar *propname; + + g_assert(path); + + /* get start of properties */ + pi = bluez_get_property_info(access_type, error); + if (!pi) + return FALSE; + + /* get actual property */ + pi = property_by_name(pi, is_json_name, name, &is_config); + if (!pi) { + g_set_error(error, NB_ERROR, NB_ERROR_UNKNOWN_PROPERTY, + "unknown property with name %s", name); + json_object_put(jval); + return FALSE; + } + + /* convert to gvariant */ + arg = property_json_to_gvariant(pi, NULL, NULL, jval, error); + + /* we don't need this anymore */ + json_object_put(jval); + jval = NULL; + + /* no variant? error */ + if (!arg) + return FALSE; + + if (!is_config) + propname = g_strdup(pi->name); + else + propname = configuration_dbus_name(pi->name); + + if (!strcmp(access_type, BLUEZ_AT_SESSION)) + interface = BLUEZ_OBEX_SESSION_INTERFACE; + else if (!strcmp(access_type, BLUEZ_AT_TRANSFER)) + interface = BLUEZ_OBEX_TRANSFER_INTERFACE; + else if (!strcmp(access_type, BLUEZ_AT_MESSAGE)) + interface = BLUEZ_OBEX_MESSAGE_INTERFACE; + else + return FALSE; + + reply = g_dbus_connection_call_sync(ns->conn, + BLUEZ_OBEX_SERVICE, path, FREEDESKTOP_PROPERTIES, "Set", + g_variant_new("(ssv)", interface, propname, arg), + NULL, G_DBUS_CALL_FLAGS_NONE, DBUS_REPLY_TIMEOUT, + NULL, error); + + g_free(propname); + + if (!reply) + return FALSE; + + g_variant_unref(reply); + + return TRUE; +} diff --git a/binding/bluetooth-map-common.h b/binding/bluetooth-map-common.h new file mode 100644 index 0000000..0ce618e --- /dev/null +++ b/binding/bluetooth-map-common.h @@ -0,0 +1,163 @@ +/* + * Copyright (C) 2019 Konsulko Group + * Author: Matt Ranostay <matt.ranostay@konsulko.com> + * Author: Pantelis Antoniou <pantelis.antoniou@konsulko.com> + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef BLUETOOTH_MAP_COMMON_H +#define BLUETOOTH_MAP_COMMON_H + +#include <stddef.h> + +#define _GNU_SOURCE +#include <glib.h> +#include <stdlib.h> +#include <gio/gio.h> +#include <glib-object.h> + +#include <json-c/json.h> + +#define AFB_BINDING_VERSION 3 +#include <afb/afb-binding.h> + +#define MAP_UUID "00001133-0000-1000-8000-00805f9b34fb" + +struct call_work; + +struct map_state { + GMainLoop *loop; + GDBusConnection *conn; + guint message_sub; + + afb_event_t notification_event; + + /* NOTE: single connection allowed for now */ + /* NOTE: needs locking and a list */ + GMutex cw_mutex; + int next_cw_id; + GSList *cw_pending; + struct call_work *cw; + + /* OBEX session path */ + gchar *session_path; + + /* xfer queue table */ + GHashTable *xfer_queue; +}; + +struct init_data { + GCond cond; + GMutex mutex; + gboolean init_done; + afb_api_t api; + struct map_state *ns; /* before setting afb_api_set_userdata() */ + int rc; +}; + +struct call_work { + struct bluetooth_state *ns; + int id; + gchar *access_type; + gchar *type_arg; + gchar *method; + struct bluez_pending_work *cpw; + afb_req_t request; + GDBusMethodInvocation *invocation; +}; + +/** + * Structure for converting from dbus properties to json + * and vice-versa. + * Note this is _not_ a generic dbus json bridge since + * some constructs are not easily mapped. + */ +struct property_info { + const char *name; /* the connman property name */ + const char *json_name; /* the json name (if NULL autoconvert) */ + const char *fmt; + unsigned int flags; + const struct property_info *sub; +}; + +#define PI_CONFIG (1U << 0) + +const struct property_info *property_by_dbus_name( + const struct property_info *pi, + const gchar *dbus_name, + gboolean *is_config); +const struct property_info *property_by_json_name( + const struct property_info *pi, + const gchar *json_name, + gboolean *is_config); +const struct property_info *property_by_name( + const struct property_info *pi, + gboolean is_json_name, const gchar *name, + gboolean *is_config); + +gchar *property_get_json_name(const struct property_info *pi, + const gchar *name); +gchar *property_get_name(const struct property_info *pi, + const gchar *json_name); + +gchar *configuration_dbus_name(const gchar *dbus_name); +gchar *configuration_json_name(const gchar *json_name); + +gchar *property_name_dbus2json(const struct property_info *pi, + gboolean is_config); + +json_object *property_dbus2json( + const struct property_info **pip, + const gchar *key, GVariant *var, + gboolean *is_config); + +gboolean root_property_dbus2json( + json_object *jparent, + const struct property_info *pi, + const gchar *key, GVariant *var, + gboolean *is_config); + +GVariant *property_json_to_gvariant( + const struct property_info *pi, + const char *fmt, /* if NULL use pi->fmt */ + const struct property_info *pi_parent, + json_object *jval, + GError **error); + +typedef enum { + NB_ERROR_BAD_TECHNOLOGY, + NB_ERROR_BAD_SERVICE, + NB_ERROR_OUT_OF_MEMORY, + NB_ERROR_NO_SERVICES, + NB_ERROR_BAD_PROPERTY, + NB_ERROR_UNIMPLEMENTED, + NB_ERROR_UNKNOWN_PROPERTY, + NB_ERROR_UNKNOWN_SERVICE, + NB_ERROR_UNKNOWN_TRANSFER, + NB_ERROR_MISSING_ARGUMENT, + NB_ERROR_ILLEGAL_ARGUMENT, + NB_ERROR_CALL_IN_PROGRESS, +} NBError; + +#define NB_ERROR (nb_error_quark()) + +extern GQuark nb_error_quark(void); + +json_object *get_property_collect(json_object *jreqprop, json_object *jprop, + GError **error); +json_object *get_named_property(const struct property_info *pi, + gboolean is_json_name, const char *name, json_object *jprop); + + +#endif /* BLUETOOTH_MAP_COMMON_H */ |