bt-service-adaptation/services/obex/bt-service-oob.c

   1 /*
   2  * Bluetooth-frwk
   3  *
   4  * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Contact:  Hocheol Seo <hocheol.seo@samsung.com>
   7  *               Girishashok Joshi <girish.joshi@samsung.com>
   8  *               Chanyeol Park <chanyeol.park@samsung.com>
   9  *
  10  * Licensed under the Apache License, Version 2.0 (the "License");
  11  * you may not use this file except in compliance with the License.
  12  * You may obtain a copy of the License at
  13  *
  14  *              http://www.apache.org/licenses/LICENSE-2.0
  15  *
  16  * Unless required by applicable law or agreed to in writing, software
  17  * distributed under the License is distributed on an "AS IS" BASIS,
  18  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  19  * See the License for the specific language governing permissions and
  20  * limitations under the License.
  21  *
  22  */
  23
  24 #include <glib.h>
  25 #include <dlog.h>
  26 #include <string.h>
  27 #include <gio/gio.h>
  28
  29 #include "bluetooth-api.h"
  30 #include "bt-service-common.h"
  31 #include "bt-service-oob.h"
  32 #include "bt-service-event.h"
  33
  34 static int __get_oob_data_from_variant(GVariant *variant,
  35                 unsigned char *buf, int size)
  36 {
  37         int i;
  38         unsigned char *v;
  39
  40         i = g_variant_get_size(variant);
  41         v = (unsigned char *)g_variant_get_data(variant);
  42         if (i && v) {
  43                 i = i > size ? size : i;
  44                 memcpy(buf, v, i);
  45         }
  46
  47         return i;
  48 }
  49
  50 int _bt_oob_read_local_data(bt_oob_data_t *local_oob_data)
  51 {
  52         GDBusProxy *proxy;
  53         GVariant *reply;
  54         GError *err = NULL;
  55         char *adapter_path;
  56         GDBusConnection *conn;
  57         GVariant *hash192 = NULL;
  58         GVariant *randomizer192 = NULL;
  59         GVariant *hash256 = NULL;
  60         GVariant *randomizer256 = NULL;
  61
  62         BT_CHECK_PARAMETER(local_oob_data, return);
  63
  64         conn = _bt_gdbus_get_system_gconn();
  65         retv_if(conn == NULL, BLUETOOTH_ERROR_INTERNAL);
  66
  67         adapter_path = _bt_get_adapter_path();
  68         retv_if(adapter_path == NULL, BLUETOOTH_ERROR_INTERNAL);
  69
  70         proxy =  g_dbus_proxy_new_sync(conn,
  71                         G_DBUS_PROXY_FLAGS_NONE, NULL,
  72                         BT_BLUEZ_NAME, adapter_path,
  73                         BT_OOB_INTERFACE, NULL, &err);
  74         g_free(adapter_path);
  75         if (!proxy) {
  76                 BT_ERR("Unable to create proxy");
  77                 if (err) {
  78                         BT_ERR("Error: %s", err->message);
  79                         g_clear_error(&err);
  80                 }
  81                 return BLUETOOTH_ERROR_INTERNAL;
  82         }
  83
  84         reply = g_dbus_proxy_call_sync(proxy, "ReadLocalData",
  85                         NULL,
  86                         G_DBUS_CALL_FLAGS_NONE, -1,
  87                         NULL, &err);
  88         g_object_unref(proxy);
  89
  90         if (reply == NULL) {
  91                 BT_ERR("ReadLocalData dBUS-RPC is failed");
  92                 if (err != NULL) {
  93                         BT_ERR("D-Bus API failure: errCode[%x], message[%s]",
  94                                         err->code, err->message);
  95                         g_clear_error(&err);
  96                 }
  97                 return BLUETOOTH_ERROR_INTERNAL;
  98         }
  99
 100         g_variant_get(reply, "(@ay@ay@ay@ay)", &hash192, &randomizer192,
 101                         &hash256, &randomizer256);
 102         g_variant_unref(reply);
 103
 104         if (hash192) {
 105                 local_oob_data->hash_len = __get_oob_data_from_variant(hash192,
 106                                 local_oob_data->hash,
 107                                 sizeof(local_oob_data->hash));
 108                 g_variant_unref(hash192);
 109         }
 110
 111         if (randomizer192) {
 112                 local_oob_data->randomizer_len = __get_oob_data_from_variant(randomizer192,
 113                                 local_oob_data->randomizer,
 114                                 sizeof(local_oob_data->randomizer));
 115                 g_variant_unref(randomizer192);
 116         }
 117
 118         if (hash256) {
 119                 local_oob_data->hash256_len = __get_oob_data_from_variant(hash256,
 120                                 local_oob_data->hash256,
 121                                 sizeof(local_oob_data->hash256));
 122                 g_variant_unref(hash256);
 123         }
 124
 125         if (randomizer256) {
 126                 local_oob_data->randomizer256_len = __get_oob_data_from_variant(randomizer256,
 127                                 local_oob_data->randomizer256,
 128                                 sizeof(local_oob_data->randomizer256));
 129                 g_variant_unref(randomizer256);
 130         }
 131
 132         return BLUETOOTH_ERROR_NONE;
 133 }
 134
 135 int _bt_oob_add_remote_data(
 136                         bluetooth_device_address_t *remote_device_address,
 137                         unsigned short address_type,
 138                         bt_oob_data_t *remote_oob_data)
 139 {
 140         int i;
 141         GDBusProxy *proxy;
 142         GVariant *reply;
 143         GError *err = NULL;
 144         char *dev_addr;
 145         char *adapter_path;
 146         char address[BT_ADDRESS_STRING_SIZE] = { 0 };
 147         unsigned char *remote_hash;
 148         unsigned char *remote_randomizer;
 149         GDBusConnection *conn;
 150         GVariantBuilder *builder;
 151         GVariantBuilder *builder2;
 152         GVariant *hash192;
 153         GVariant *randomizer192;
 154         GVariant *hash256;
 155         GVariant *randomizer256;
 156
 157         BT_CHECK_PARAMETER(remote_device_address, return);
 158         BT_CHECK_PARAMETER(remote_oob_data, return);
 159
 160         conn = _bt_gdbus_get_system_gconn();
 161         retv_if(conn == NULL, BLUETOOTH_ERROR_INTERNAL);
 162
 163         adapter_path = _bt_get_adapter_path();
 164         retv_if(adapter_path == NULL, BLUETOOTH_ERROR_INTERNAL);
 165
 166         _bt_convert_addr_type_to_string(address, remote_device_address->addr);
 167
 168         proxy =  g_dbus_proxy_new_sync(conn,
 169                         G_DBUS_PROXY_FLAGS_NONE, NULL,
 170                         BT_BLUEZ_NAME, adapter_path,
 171                         BT_OOB_INTERFACE, NULL, &err);
 172         g_free(adapter_path);
 173         if (!proxy) {
 174                 BT_ERR("Unable to create proxy");
 175                 if (err) {
 176                         BT_ERR("Error: %s", err->message);
 177                         g_clear_error(&err);
 178                 }
 179                 return BLUETOOTH_ERROR_INTERNAL;
 180         }
 181
 182         BT_DBG("address type: %d", address_type);
 183
 184         /* Remote address */
 185         dev_addr = g_strdup(address);
 186
 187         /* P-192 */
 188         remote_hash = remote_oob_data->hash;
 189         remote_randomizer = remote_oob_data->randomizer;
 190
 191         builder = g_variant_builder_new(G_VARIANT_TYPE("ay"));
 192         builder2 = g_variant_builder_new(G_VARIANT_TYPE("ay"));
 193
 194         for (i = 0; i < remote_oob_data->hash_len; i++)
 195                 g_variant_builder_add(builder, "y", remote_hash[i]);
 196
 197         for (i = 0; i < remote_oob_data->randomizer_len; i++)
 198                 g_variant_builder_add(builder2, "y", remote_randomizer[i]);
 199
 200         hash192 = g_variant_new("ay", builder);
 201         randomizer192 = g_variant_new("ay", builder2);
 202
 203         g_variant_builder_unref(builder2);
 204         g_variant_builder_unref(builder);
 205
 206         /* P-256 */
 207         remote_hash = remote_oob_data->hash256;
 208         remote_randomizer = remote_oob_data->randomizer256;
 209
 210         builder = g_variant_builder_new(G_VARIANT_TYPE("ay"));
 211         builder2 = g_variant_builder_new(G_VARIANT_TYPE("ay"));
 212
 213         for (i = 0; i < remote_oob_data->hash256_len; i++)
 214                 g_variant_builder_add(builder, "y", remote_hash[i]);
 215
 216         for (i = 0; i < remote_oob_data->randomizer256_len; i++)
 217                 g_variant_builder_add(builder2, "y", remote_randomizer[i]);
 218
 219         hash256 = g_variant_new("ay", builder);
 220         randomizer256 = g_variant_new("ay", builder2);
 221
 222         g_variant_builder_unref(builder2);
 223         g_variant_builder_unref(builder);
 224
 225         /* Call AddRemoteData Method */
 226         reply = g_dbus_proxy_call_sync(proxy, "AddRemoteData",
 227                         g_variant_new("(sy@ay@ay@ay@ay)", dev_addr, address_type,
 228                                 hash192, randomizer192, hash256, randomizer256),
 229                         G_DBUS_CALL_FLAGS_NONE, -1,
 230                         NULL, &err);
 231         g_object_unref(proxy);
 232         g_free(dev_addr);
 233
 234         BT_DBG("Add remote OOB data!!");
 235
 236         /* Check the reply */
 237         if (reply == NULL) {
 238                 BT_ERR("AddRemoteData dBUS-RPC is failed");
 239                 if (err != NULL) {
 240                         BT_ERR("D-Bus API failure: errCode[%x], message[%s]",
 241                                         err->code, err->message);
 242                         g_clear_error(&err);
 243                 }
 244                 return BLUETOOTH_ERROR_INTERNAL;
 245         }
 246         g_variant_unref(reply);
 247
 248         BT_DBG("No error");
 249
 250         return BLUETOOTH_ERROR_NONE;
 251 }
 252
 253 int _bt_oob_remove_remote_data(
 254                         bluetooth_device_address_t *remote_device_address)
 255 {
 256         GDBusProxy *proxy;
 257         GVariant *reply;
 258         GError *err = NULL;
 259         char *dev_addr;
 260         char *adapter_path;
 261         char address[BT_ADDRESS_STRING_SIZE] = { 0 };
 262         GDBusConnection *conn;
 263
 264         BT_CHECK_PARAMETER(remote_device_address, return);
 265
 266         conn = _bt_gdbus_get_system_gconn();
 267         retv_if(conn == NULL, BLUETOOTH_ERROR_INTERNAL);
 268
 269         adapter_path = _bt_get_adapter_path();
 270         retv_if(adapter_path == NULL, BLUETOOTH_ERROR_INTERNAL);
 271
 272         _bt_convert_addr_type_to_string(address,
 273                 remote_device_address->addr);
 274
 275         proxy =  g_dbus_proxy_new_sync(conn,
 276                         G_DBUS_PROXY_FLAGS_NONE, NULL,
 277                         BT_BLUEZ_NAME, adapter_path,
 278                         BT_OOB_INTERFACE, NULL, &err);
 279         g_free(adapter_path);
 280         if (!proxy) {
 281                 BT_ERR("Unable to create proxy");
 282                 if (err) {
 283                         BT_ERR("Error: %s", err->message);
 284                         g_clear_error(&err);
 285                 }
 286                 return BLUETOOTH_ERROR_INTERNAL;
 287         }
 288
 289         dev_addr = g_strdup(address);
 290
 291         /* Call RemoveRemoteData Method*/
 292         reply = g_dbus_proxy_call_sync(proxy, "RemoveRemoteData",
 293                         g_variant_new("(s)", dev_addr),
 294                         G_DBUS_CALL_FLAGS_NONE, -1,
 295                         NULL, &err);
 296         g_object_unref(proxy);
 297         g_free(dev_addr);
 298
 299         /* Check the reply*/
 300         if (reply == NULL) {
 301                 BT_ERR("RemoveRemoteData dBUS-RPC is failed");
 302                 if (err != NULL) {
 303                         BT_ERR("D-Bus API failure: errCode[%x], message[%s]",
 304                                         err->code, err->message);
 305                         g_clear_error(&err);
 306                 }
 307                 return BLUETOOTH_ERROR_INTERNAL;
 308         }
 309
 310         g_variant_unref(reply);
 311         return BLUETOOTH_ERROR_NONE;
 312 }