diff options
Diffstat (limited to 'binding/bluetooth-pbap-binding.c')
| -rw-r--r-- | binding/bluetooth-pbap-binding.c | 615 |
1 files changed, 615 insertions, 0 deletions
diff --git a/binding/bluetooth-pbap-binding.c b/binding/bluetooth-pbap-binding.c new file mode 100644 index 0000000..f706c3b --- /dev/null +++ b/binding/bluetooth-pbap-binding.c @@ -0,0 +1,615 @@ +/* + * Copyright (C) 2018 Konsulko Group + * Author: Matt Porter <mporter@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 <glib.h> +#include <json-c/json.h> +#include <math.h> +#include <stdio.h> +#include <stdlib.h> +#include <sys/time.h> +#include <time.h> + +#define AFB_BINDING_VERSION 2 +#include <afb/afb-binding.h> + +#include "obex_client1_interface.h" +#include "obex_session1_interface.h" +#include "obex_transfer1_interface.h" +#include "obex_phonebookaccess1_interface.h" +#include "freedesktop_dbus_properties_interface.h" + +static GDBusObjectManager *obj_manager; +static OrgBluezObexClient1 *client; +static OrgBluezObexSession1 *session; +static OrgBluezObexPhonebookAccess1 *phonebook; +static GHashTable *xfer_queue; +static GMutex xfer_queue_mutex; +static GHashTable *xfer_complete; +static GMutex xfer_complete_mutex; +static GCond xfer_complete_cond; +static gboolean connected = FALSE; + +#define PBAP_UUID "0000112f-0000-1000-8000-00805f9b34fb" + +#define INTERNAL "int" +#define SIM "sim" +#define SIM1 SIM +#define SIM2 "sim2" + +#define CONTACTS "pb" +#define COMBINED "cch" +#define INCOMING "ich" +#define OUTGOING "och" +#define MISSED "mch" + +static void on_interface_proxy_properties_changed( + GDBusObjectManagerClient *manager, + GDBusObjectProxy *object_proxy, + GDBusProxy *interface_proxy, + GVariant *changed_properties, + const gchar *const *invalidated_properties, + gpointer user_data) +{ + GVariantIter iter; + const gchar *key; + GVariant *value; + gchar *filename; + + const gchar *path = g_dbus_object_get_object_path(G_DBUS_OBJECT(object_proxy)); + + if ((filename = g_hash_table_lookup(xfer_queue, path))) { + g_variant_iter_init(&iter, changed_properties); + while (g_variant_iter_next(&iter, "{&sv}", &key, &value)) { + if ((!g_strcmp0(key, "Status")) && + (!g_strcmp0(g_variant_get_string(value, NULL), "complete"))) { + g_mutex_lock(&xfer_complete_mutex); + g_hash_table_insert(xfer_complete, g_strdup(path), g_strdup(filename)); + g_cond_signal(&xfer_complete_cond); + g_mutex_unlock(&xfer_complete_mutex); + g_mutex_lock(&xfer_queue_mutex); + g_hash_table_remove(xfer_queue, path); + g_mutex_unlock(&xfer_queue_mutex); + } + } + } +} + +static json_object *get_vcard_xfer(gchar *filename) +{ + FILE *fp; + json_object *vcard_str; + gchar *vcard_data; + size_t size, n; + + fp = fopen(filename, "ro"); + fseek(fp, 0L, SEEK_END); + size = ftell(fp); + vcard_data = calloc(1, size); + fseek(fp, 0L, SEEK_SET); + n = fread(vcard_data, 1, size, fp); + if (n != size) { + AFB_ERROR("Read only %ld/%ld bytes from %s", n, size, filename); + return NULL; + } + + vcard_str = json_object_new_string(vcard_data); + free(vcard_data); + fclose(fp); + unlink(filename); + + return vcard_str; +} + +static void get_filename(gchar *filename) +{ + struct tm* tm_info;; + struct timeval tv; + long ms; + gchar buffer[64]; + + gettimeofday(&tv, NULL); + + ms = lrint((double)tv.tv_usec/1000.0); + if (ms >= 1000) { + ms -=1000; + tv.tv_sec++; + } + tm_info = localtime(&tv.tv_sec); + + strftime(buffer, 26, "%Y%m%d%H%M%S", tm_info); + + sprintf(filename, "/tmp/vcard-%s%03ld.dat", buffer, ms); +} + +static gchar *pull_vcard(const gchar *handle) +{ + GVariantBuilder *b; + GVariant *filter, *properties; + gchar filename[256]; + gchar *tpath; + + b = g_variant_builder_new (G_VARIANT_TYPE ("a{sv}")); + g_variant_builder_add(b, "{sv}", "Format", g_variant_new_string("vcard30")); + filter = g_variant_builder_end(b); + + get_filename(filename); + org_bluez_obex_phonebook_access1_call_pull_sync( + phonebook, handle, filename, filter, &tpath, &properties, NULL, NULL); + g_variant_builder_unref(b); + g_mutex_lock(&xfer_queue_mutex); + g_hash_table_insert(xfer_queue, g_strdup(tpath), g_strdup(filename)); + g_mutex_unlock(&xfer_queue_mutex); + + return tpath; +} + +static json_object *get_vcard(const gchar *handle) +{ + json_object *vcard_str, *vcard; + gchar *tpath, *filename; + + tpath = pull_vcard(handle); + g_mutex_lock(&xfer_complete_mutex); + while (!(filename = g_hash_table_lookup(xfer_complete, tpath))) + g_cond_wait(&xfer_complete_cond, &xfer_complete_mutex); + + vcard_str = get_vcard_xfer(filename); + + g_hash_table_remove(xfer_complete, tpath); + g_mutex_unlock(&xfer_complete_mutex); + + vcard = json_object_new_object(); + json_object_object_add(vcard, "vcard", vcard_str); + + return vcard; +} + +static gchar *pull_vcards(int max_entries) +{ + GVariantBuilder *b; + GVariant *filter, *properties; + gchar filename[256]; + gchar *tpath; + + b = g_variant_builder_new (G_VARIANT_TYPE ("a{sv}")); + g_variant_builder_add(b, "{sv}", "Format", g_variant_new_string("vcard30")); + g_variant_builder_add(b, "{sv}", "Order", g_variant_new_string("indexed")); + g_variant_builder_add(b, "{sv}", "Offset", g_variant_new_uint16(0)); + if (max_entries >= 0) + g_variant_builder_add(b, "{sv}", "MaxCount", g_variant_new_uint16((guint16)max_entries)); + filter = g_variant_builder_end(b); + + get_filename(filename); + org_bluez_obex_phonebook_access1_call_pull_all_sync( + phonebook, filename, filter, &tpath, &properties, NULL, NULL); + g_variant_builder_unref(b); + g_mutex_lock(&xfer_queue_mutex); + g_hash_table_insert(xfer_queue, g_strdup(tpath), g_strdup(filename)); + g_mutex_unlock(&xfer_queue_mutex); + + return tpath; +} + +static json_object *get_vcards(int max_entries) +{ + json_object *vcards_str, *vcards; + gchar *tpath, *filename; + + tpath = pull_vcards(max_entries); + g_mutex_lock(&xfer_complete_mutex); + while (!(filename = g_hash_table_lookup(xfer_complete, tpath))) + g_cond_wait(&xfer_complete_cond, &xfer_complete_mutex); + + vcards_str = get_vcard_xfer(filename); + + g_hash_table_remove(xfer_complete, tpath); + g_mutex_unlock(&xfer_complete_mutex); + + vcards = json_object_new_object(); + json_object_object_add(vcards, "vcards", vcards_str); + + return vcards; +} + +static gboolean parse_list_parameter(struct afb_req request, gchar **list) +{ + struct json_object *list_obj, *query; + const gchar *list_str; + + query = afb_req_json(request); + + if (json_object_object_get_ex(query, "list", &list_obj) == TRUE) { + if (json_object_is_type(list_obj, json_type_string)) { + list_str = json_object_get_string(list_obj); + if (!g_strcmp0(list_str, COMBINED)) { + *list = COMBINED; + } else if (!g_strcmp0(list_str, INCOMING)) { + *list = INCOMING; + } else if (!g_strcmp0(list_str, OUTGOING)) { + *list = OUTGOING; + } else if (!g_strcmp0(list_str, MISSED)) { + *list = MISSED; + } else { + afb_req_fail(request, "invalid list", NULL); + return FALSE; + } + } else { + afb_req_fail(request, "list not string", NULL); + return FALSE; + } + } else { + afb_req_fail(request, "no list", NULL); + return FALSE; + } + + return TRUE; +} + +static gboolean parse_max_entries_parameter(struct afb_req request, int *max_entries) +{ + struct json_object *max_obj, *query; + + query = afb_req_json(request); + + if (json_object_object_get_ex(query, "max_entries", &max_obj) == TRUE) { + if (json_object_is_type(max_obj, json_type_int)) { + *max_entries = json_object_get_int(max_obj); + if ((*max_entries < 0) || (*max_entries > (2e16-1))) { + afb_req_fail(request, "max_entries out of range", NULL); + return FALSE; + } + } else { + afb_req_fail(request, "max_entries not integer", NULL); + return FALSE; + } + } + + return TRUE; +} + +void contacts(struct afb_req request) +{ + struct json_object *jresp; + int max_entries = -1; + + if (!connected) { + afb_req_fail(request, "not connected", NULL); + return; + } + + if (!parse_max_entries_parameter(request, &max_entries)) + return; + + org_bluez_obex_phonebook_access1_call_select_sync( + phonebook, INTERNAL, CONTACTS, NULL, NULL); + jresp = get_vcards(max_entries); + + afb_req_success(request, jresp, "contacts"); +} + +void entry(struct afb_req request) +{ + struct json_object *handle_obj, *jresp, *query; + const gchar *handle; + gchar *list = NULL; + + if (!connected) { + afb_req_fail(request, "not connected", NULL); + return; + } + + query = afb_req_json(request); + + if (json_object_object_get_ex(query, "handle", &handle_obj) == TRUE) { + if (json_object_is_type(handle_obj, json_type_string)) { + handle = json_object_get_string(handle_obj); + } else { + afb_req_fail(request, "handle not string", NULL); + return; + } + } else { + afb_req_fail(request, "no handle", NULL); + return; + } + + if (!parse_list_parameter(request, &list)) + return; + + org_bluez_obex_phonebook_access1_call_select_sync( + phonebook, INTERNAL, list, NULL, NULL); + jresp = get_vcard(handle); + + afb_req_success(request, jresp, "list entry"); +} + +void history(struct afb_req request) +{ + struct json_object *jresp; + gchar *list = NULL; + int max_entries = -1; + + if (!connected) { + afb_req_fail(request, "not connected", NULL); + return; + } + + if (!parse_list_parameter(request, &list)) + return; + + if (!parse_max_entries_parameter(request, &max_entries)) + return; + + org_bluez_obex_phonebook_access1_call_select_sync( + phonebook, INTERNAL, list, NULL, NULL); + jresp = get_vcards(max_entries); + + afb_req_success(request, jresp, "call history"); +} + +static void search(struct afb_req request) +{ + struct json_object *query, *val, *results_array, *response; + const char *number = NULL; + GVariantIter iter; + GVariantBuilder *b; + GVariant *entry, *filter, *results; + gchar *card, *name; + int max_entries = -1; + + if (!connected) { + afb_req_fail(request, "not connected", NULL); + return; + } + + query = afb_req_json(request); + + json_object_object_get_ex(query, "number", &val); + if (json_object_is_type(val, json_type_string)) { + number = json_object_get_string(val); + } + else { + afb_req_fail(request, "no number", NULL); + return; + } + + if (!parse_max_entries_parameter(request, &max_entries)) + return; + + org_bluez_obex_phonebook_access1_call_select_sync( + phonebook, INTERNAL, CONTACTS, NULL, NULL); + + b = g_variant_builder_new (G_VARIANT_TYPE ("a{sv}")); + g_variant_builder_add(b, "{sv}", "Order", g_variant_new_string("indexed")); + g_variant_builder_add(b, "{sv}", "Offset", g_variant_new_uint16(0)); + if (max_entries >= 0) + g_variant_builder_add(b, "{sv}", "MaxCount", g_variant_new_uint16((guint16)max_entries)); + filter = g_variant_builder_end(b); + + org_bluez_obex_phonebook_access1_call_search_sync( + phonebook, "number", number, filter, &results, NULL, NULL); + + g_variant_builder_unref(b); + + results_array = json_object_new_array(); + g_variant_iter_init(&iter, results); + while ((entry = g_variant_iter_next_value(&iter))) { + g_variant_get(entry, "(ss)", &card, &name); + g_variant_unref(entry); + json_object *result_obj = json_object_new_object(); + json_object *card_str = json_object_new_string(card); + json_object *name_str = json_object_new_string(name); + json_object_object_add(result_obj, "card", card_str); + json_object_object_add(result_obj, "name", name_str); + json_object_array_add(results_array, result_obj); + g_free(card); + g_free(name); + } + response = json_object_new_object(); + json_object_object_add(response, "results", results_array); + + afb_req_success(request, response, NULL); +} + +static gboolean init_session(const gchar *address) +{ + GVariant *args; + GVariantBuilder *b; + const gchar *target; + gchar *spath; + + xfer_queue = g_hash_table_new(g_str_hash, g_str_equal); + xfer_complete = g_hash_table_new(g_str_hash, g_str_equal); + + obj_manager = object_manager_client_new_for_bus_sync( + G_BUS_TYPE_SESSION, + G_DBUS_OBJECT_MANAGER_CLIENT_FLAGS_NONE, + "org.bluez.obex", "/", NULL, NULL); + + if (obj_manager == NULL) { + AFB_ERROR("Failed to create object manager"); + return FALSE; + } + + g_signal_connect(obj_manager, + "interface-proxy-properties-changed", + G_CALLBACK (on_interface_proxy_properties_changed), + NULL); + + client = org_bluez_obex_client1_proxy_new_for_bus_sync( + G_BUS_TYPE_SESSION, G_DBUS_PROXY_FLAGS_NONE, + "org.bluez.obex", "/org/bluez/obex", NULL, NULL); + + if (client == NULL) { + AFB_ERROR("Failed to create client proxy"); + return FALSE; + } + + b = g_variant_builder_new (G_VARIANT_TYPE ("a{sv}")); + g_variant_builder_add(b, "{sv}", "Target", g_variant_new_string("pbap")); + args = g_variant_builder_end(b); + + org_bluez_obex_client1_call_create_session_sync( + client, address, args, &spath, NULL, NULL); + + session = org_bluez_obex_session1_proxy_new_for_bus_sync( + G_BUS_TYPE_SESSION, G_DBUS_PROXY_FLAGS_NONE, + "org.bluez.obex", spath, NULL, NULL); + + target = org_bluez_obex_session1_get_target(session); + if (g_strcmp0(target, PBAP_UUID) != 0) { + AFB_ERROR("Device does not support PBAP"); + return FALSE; + } + + phonebook = org_bluez_obex_phonebook_access1_proxy_new_for_bus_sync( + G_BUS_TYPE_SESSION, G_DBUS_PROXY_FLAGS_NONE, + "org.bluez.obex", spath, NULL, NULL); + + return TRUE; +} + +static gboolean is_pbap_dev_and_init(struct json_object *dev) +{ + struct json_object *name, *address, *hfp_connected; + json_object_object_get_ex(dev, "Name", &name); + json_object_object_get_ex(dev, "Address", &address); + json_object_object_get_ex(dev, "HFPConnected", &hfp_connected); + if (!g_strcmp0(json_object_get_string(hfp_connected), "True")) { + if (init_session(json_object_get_string(address))) { + AFB_NOTICE("PBAP device connected: %s", json_object_get_string(address)); + connected = TRUE; + } + } + + return connected; +} + +static void discovery_result_cb(void *closure, int status, struct json_object *result) +{ + enum json_type type; + struct json_object *devs, *dev; + int i; + + json_object_object_foreach(result, key, val) { + type = json_object_get_type(val); + switch (type) { + case json_type_array: + json_object_object_get_ex(result, key, &devs); + for (i = 0; i < json_object_array_length(devs); i++) { + dev = json_object_array_get_idx(devs, i); + if (is_pbap_dev_and_init(dev)) + break; + } + break; + case json_type_string: + case json_type_boolean: + case json_type_double: + case json_type_int: + case json_type_object: + case json_type_null: + default: + break; + } + } +} + +static void init_bt(void) +{ + struct json_object *args, *response; + + args = json_object_new_object(); + json_object_object_add(args , "value", json_object_new_string("connection")); + afb_service_call_sync("Bluetooth-Manager", "subscribe", args, &response); + + args = json_object_new_object(); + afb_service_call("Bluetooth-Manager", "discovery_result", args, discovery_result_cb, &response); +} + +static const struct afb_verb_v2 binding_verbs[] = { + { .verb = "contacts", .callback = contacts, .info = "List contacts" }, + { .verb = "entry", .callback = entry, .info = "List call entry" }, + { .verb = "history", .callback = history, .info = "List call history" }, + { .verb = "search", .callback = search, .info = "Search for entry" }, + { } +}; + +static void *main_loop_thread(void *unused) +{ + GMainLoop *loop = g_main_loop_new(NULL, FALSE); + g_main_loop_run(loop); + + return NULL; +} + +static int init() +{ + AFB_NOTICE("PBAP binding init"); + + pthread_t tid; + int ret = 0; + + ret = afb_daemon_require_api("Bluetooth-Manager", 1); + if (ret) { + AFB_ERROR("unable to initialize bluetooth binding"); + return -1; + } + + /* Start the main loop thread */ + pthread_create(&tid, NULL, main_loop_thread, NULL); + + init_bt(); + + return ret; +} + +static void process_connection_event(struct json_object *object) +{ + struct json_object *args, *response, *status_obj, *address_obj; + const char *status, *address; + + json_object_object_get_ex(object, "Status", &status_obj); + status = json_object_get_string(status_obj); + + if (!g_strcmp0(status, "connected")) { + args = json_object_new_object(); + afb_service_call("Bluetooth-Manager", "discovery_result", + args, discovery_result_cb, &response); + } else if (!g_strcmp0(status, "disconnected")) { + json_object_object_get_ex(object, "Address", &address_obj); + address = json_object_get_string(address_obj); + AFB_NOTICE("PBAP device disconnected: %s", address); + connected = FALSE; + } else + AFB_ERROR("Unsupported connection status: %s\n", status); +} + +static void onevent(const char *event, struct json_object *object) +{ + if (!g_strcmp0(event, "Bluetooth-Manager/connection")) + process_connection_event(object); + else + AFB_ERROR("Unsupported event: %s\n", event); +} + +const struct afb_binding_v2 afbBindingV2 = { + .api = "bluetooth-pbap", + .specification = NULL, + .verbs = binding_verbs, + .init = init, + .onevent = onevent, +}; |