bt-service/bt-service-common.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 <stdio.h>
  25 #include <string.h>
  26 #include <glib.h>
  27 #include <dlog.h>
  28 #include <fcntl.h>
  29 #include <errno.h>
  30 #include <termios.h>
  31 #include <net_connection.h>
  32 #include <dbus/dbus-glib-lowlevel.h>
  33 #include <dbus/dbus-glib.h>
  34 #include <dbus/dbus.h>
  35 #include <glib.h>
  36 #include <dlog.h>
  37 #include <fcntl.h>
  38 #include <errno.h>
  39 #include <termios.h>
  40 #include <net_connection.h>
  41 #include <bundle.h>
  42 #if 0
  43 #include <eventsystem.h>
  44 #endif
  45
  46 #include "bluetooth-api.h"
  47 #include "bt-service-common.h"
  48 #include "bt-service-agent.h"
  49
  50 static GDBusConnection *system_conn;
  51 static GDBusConnection *session_conn;
  52 static GDBusProxy *manager_proxy;
  53 static GDBusProxy *adapter_proxy;
  54 static void *net_conn;
  55
  56 static GDBusProxy *adapter_properties_proxy;
  57
  58 static GDBusConnection *system_gconn = NULL;
  59
  60 GDBusConnection *_bt_gdbus_init_system_gconn(void)
  61 {
  62         GError *error = NULL;
  63
  64         if (!g_thread_supported()) {
  65                 g_thread_init(NULL);
  66         }
  67
  68 //      dbus_g_thread_init();
  69
  70         g_type_init();
  71
  72         if (system_gconn != NULL)
  73                 return system_gconn;
  74
  75         system_gconn = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &error);
  76
  77         if (!system_gconn) {
  78                 BT_ERR("Unable to connect to dbus: %s", error->message);
  79                 g_clear_error(&error);
  80         }
  81
  82         return system_gconn;
  83 }
  84
  85 GDBusConnection *_bt_gdbus_get_system_gconn(void)
  86 {
  87         GDBusConnection *local_system_gconn = NULL;
  88         GError *error = NULL;
  89
  90         if (system_gconn == NULL) {
  91                 system_gconn = _bt_gdbus_init_system_gconn();
  92         } else if (g_dbus_connection_is_closed(system_gconn)){
  93
  94                 local_system_gconn = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &error);
  95
  96                 if (!local_system_gconn) {
  97                         BT_ERR("Unable to connect to dbus: %s", error->message);
  98                         g_clear_error(&error);
  99                 }
 100
 101                 system_gconn = local_system_gconn;
 102         }
 103
 104         return system_gconn;
 105 }
 106
 107 static GDBusProxy *__bt_init_manager_proxy(void)
 108 {
 109         GDBusProxy *proxy;
 110
 111         g_type_init();
 112
 113         if (system_conn == NULL) {
 114                 system_conn = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, NULL);
 115                 retv_if(system_conn == NULL, NULL);
 116         }
 117
 118         proxy = g_dbus_proxy_new_sync(system_conn, G_DBUS_PROXY_FLAGS_NONE,
 119                                                                 NULL, BT_BLUEZ_NAME,
 120                                                                 BT_MANAGER_PATH, BT_MANAGER_INTERFACE,  NULL, NULL);
 121
 122         retv_if(proxy == NULL, NULL);
 123
 124         manager_proxy = proxy;
 125
 126         return proxy;
 127 }
 128
 129 static GDBusProxy *__bt_init_adapter_proxy(void)
 130 {
 131         GDBusProxy *manager_proxy;
 132         GDBusProxy *proxy;
 133         char *adapter_path = NULL;
 134
 135         g_type_init();
 136
 137         if (system_conn == NULL) {
 138                 system_conn = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, NULL);
 139                 retv_if(system_conn == NULL, NULL);
 140         }
 141
 142         adapter_path = _bt_get_adapter_path();
 143         retv_if(adapter_path == NULL, NULL);
 144
 145         proxy = g_dbus_proxy_new_sync(system_conn, G_DBUS_PROXY_FLAGS_NONE,
 146                                                                 NULL, BT_BLUEZ_NAME,
 147                                                                 adapter_path, BT_ADAPTER_INTERFACE,  NULL, NULL);
 148
 149         g_free(adapter_path);
 150
 151         retv_if(proxy == NULL, NULL);
 152
 153         adapter_proxy = proxy;
 154
 155         return proxy;
 156 }
 157
 158 static GDBusProxy *__bt_init_adapter_properties_proxy(void)
 159 {
 160         GDBusProxy *manager_proxy;
 161         GDBusProxy *proxy;
 162         char *adapter_path = NULL;
 163
 164         g_type_init();
 165
 166         if (system_conn == NULL) {
 167                 system_conn = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, NULL);
 168                 retv_if(system_conn == NULL, NULL);
 169         }
 170
 171         adapter_path = _bt_get_adapter_path();
 172         retv_if(adapter_path == NULL, NULL);
 173
 174         proxy = g_dbus_proxy_new_sync(system_conn, G_DBUS_PROXY_FLAGS_NONE,
 175                                                                         NULL, BT_BLUEZ_NAME,
 176                                                                         adapter_path, BT_PROPERTIES_INTERFACE,  NULL, NULL);
 177
 178         g_free(adapter_path);
 179
 180         retv_if(proxy == NULL, NULL);
 181
 182         adapter_properties_proxy = proxy;
 183
 184         return proxy;
 185 }
 186
 187 GDBusConnection *__bt_init_system_gconn(void)
 188 {
 189         g_type_init();
 190
 191         if (system_conn == NULL)
 192                 system_conn = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, NULL);
 193
 194         return system_conn;
 195 }
 196
 197 GDBusConnection *__bt_init_session_conn(void)
 198 {
 199         if (session_conn == NULL)
 200                 session_conn =g_bus_get_sync(G_BUS_TYPE_SESSION, NULL, NULL);
 201
 202         return session_conn;
 203 }
 204
 205 GDBusConnection *_bt_get_session_gconn(void)
 206 {
 207         return (session_conn) ? session_conn : __bt_init_session_conn();
 208 }
 209
 210 GDBusConnection *_bt_get_system_gconn(void)
 211 {
 212         return (system_conn) ? system_conn : __bt_init_system_gconn();
 213 }
 214
 215 GDBusConnection *_bt_get_system_conn(void)
 216 {
 217         GDBusConnection *g_conn;
 218
 219         if (system_conn == NULL) {
 220                 g_conn = __bt_init_system_gconn();
 221         } else {
 222                 g_conn = system_conn;
 223         }
 224
 225         retv_if(g_conn == NULL, NULL);
 226
 227         return g_conn;
 228 }
 229
 230 GDBusProxy *_bt_get_manager_proxy(void)
 231 {
 232         if (manager_proxy) {
 233                 const gchar *path =  g_dbus_proxy_get_object_path(manager_proxy);
 234                 if (path == NULL) {
 235                         BT_ERR("Already proxy released hence creating new proxy");
 236                         return  __bt_init_manager_proxy();
 237                 }
 238                 return manager_proxy;
 239         }
 240         return  __bt_init_manager_proxy();
 241 }
 242
 243 static void *__bt_init_net_conn(void)
 244 {
 245         int result;
 246         connection_h connection = NULL;
 247
 248         if (net_conn == NULL) {
 249                 result = connection_create(&connection);
 250
 251         if (result != CONNECTION_ERROR_NONE ||
 252                                         connection == NULL) {
 253                 BT_DBG("connection_create() failed: %d", result);
 254                 net_conn = NULL;
 255                 return NULL;
 256         }
 257                 net_conn = connection;
 258         }
 259         return net_conn;
 260 }
 261
 262 void *_bt_get_net_conn(void)
 263 {
 264         return (net_conn) ? net_conn : __bt_init_net_conn();
 265 }
 266
 267 GDBusProxy *_bt_get_adapter_proxy(void)
 268 {
 269         if (adapter_proxy) {
 270                 const char *path =  g_dbus_proxy_get_object_path(adapter_proxy);
 271                 if (path == NULL) {
 272                         BT_ERR("Already proxy released hence creating new proxy");
 273                         return  __bt_init_adapter_proxy();
 274                 }
 275
 276                 return adapter_proxy;
 277         }
 278         return  __bt_init_adapter_proxy();
 279
 280 }
 281
 282 GDBusProxy *_bt_get_adapter_properties_proxy(void)
 283 {
 284         return (adapter_properties_proxy) ? adapter_properties_proxy :
 285                                         __bt_init_adapter_properties_proxy();
 286 }
 287
 288 static char *__bt_extract_adapter_path(GVariantIter *iter)
 289 {
 290         char *object_path = NULL;
 291         GVariantIter *interface_iter;
 292         GVariantIter *svc_iter;
 293         char *interface_str = NULL;
 294
 295         /* Parse the signature: oa{sa{sv}}} */
 296         while (g_variant_iter_loop(iter, "{&oa{sa{sv}}}", &object_path,
 297                         &interface_iter)) {
 298
 299                 if (object_path == NULL)
 300                         continue;
 301
 302                 while (g_variant_iter_loop(interface_iter, "{sa{sv}}",
 303                                 &interface_str, &svc_iter)) {
 304                         if (g_strcmp0(interface_str, "org.bluez.Adapter1") != 0)
 305                                 continue;
 306
 307                         BT_DBG("Object Path: %s", object_path);
 308                         g_free(interface_str);
 309                         g_variant_iter_free(svc_iter);
 310                         g_variant_iter_free(interface_iter);
 311                         return g_strdup(object_path);
 312                 }
 313         }
 314         return NULL;
 315 }
 316
 317 char *_bt_get_adapter_path(void)
 318 {
 319         GDBusConnection *conn;
 320         GDBusProxy *manager_proxy;
 321         GVariant *result = NULL;
 322         GVariantIter *iter = NULL;
 323         char *adapter_path = NULL;
 324
 325         conn = _bt_get_system_conn();
 326         retv_if(conn == NULL, NULL);
 327
 328         manager_proxy = _bt_get_manager_proxy();
 329         retv_if(manager_proxy == NULL, NULL);
 330
 331         result = g_dbus_proxy_call_sync(manager_proxy, "GetManagedObjects",
 332                                 NULL,
 333                                 G_DBUS_CALL_FLAGS_NONE,
 334                                 -1,
 335                                 NULL,
 336                                 NULL);
 337         if (!result) {
 338                 BT_ERR("Can't get managed objects");
 339                 return NULL;
 340         }
 341
 342         /* signature of GetManagedObjects:  a{oa{sa{sv}}} */
 343         g_variant_get(result, "(a{oa{sa{sv}}})", &iter);
 344
 345         adapter_path = __bt_extract_adapter_path(iter);
 346         g_variant_iter_free(iter);
 347         g_variant_unref(result);
 348         return adapter_path;
 349 }
 350
 351 void _bt_deinit_bluez_proxy(void)
 352 {
 353         if (manager_proxy) {
 354                 g_object_unref(manager_proxy);
 355                 manager_proxy = NULL;
 356         }
 357
 358         if (adapter_proxy) {
 359                 g_object_unref(adapter_proxy);
 360                 adapter_proxy = NULL;
 361         }
 362         if (adapter_properties_proxy) {
 363                 g_object_unref(adapter_properties_proxy);
 364                 adapter_properties_proxy = NULL;
 365         }
 366 }
 367
 368 void _bt_deinit_proxys(void)
 369 {
 370         int ret;
 371         _bt_deinit_bluez_proxy();
 372
 373         if (system_conn) {
 374                 g_object_unref(system_conn);
 375                 system_conn = NULL;
 376         }
 377
 378         if (session_conn) {
 379                 g_object_unref(session_conn);
 380                 session_conn = NULL;
 381         }
 382
 383         if (net_conn) {
 384                 ret = connection_destroy(net_conn);
 385                 net_conn = NULL;
 386                 if (ret != 0)
 387                         BT_ERR("connection_destroy failed : %d", ret);
 388         }
 389 }
 390
 391 void _bt_convert_device_path_to_address(const char *device_path,
 392                                                 char *device_address)
 393 {
 394         char address[BT_ADDRESS_STRING_SIZE] = { 0 };
 395         char *dev_addr;
 396
 397         ret_if(device_path == NULL);
 398         ret_if(device_address == NULL);
 399
 400         dev_addr = strstr(device_path, "dev_");
 401         if (dev_addr != NULL) {
 402                 char *pos = NULL;
 403                 dev_addr += 4;
 404                 g_strlcpy(address, dev_addr, sizeof(address));
 405
 406                 while ((pos = strchr(address, '_')) != NULL) {
 407                         *pos = ':';
 408                 }
 409
 410                 g_strlcpy(device_address, address, BT_ADDRESS_STRING_SIZE);
 411         }
 412 }
 413
 414
 415 void _bt_convert_addr_string_to_type(unsigned char *addr,
 416                                         const char *address)
 417 {
 418         int i;
 419         char *ptr = NULL;
 420
 421         ret_if(address == NULL);
 422         ret_if(addr == NULL);
 423
 424         for (i = 0; i < BT_ADDRESS_LENGTH_MAX; i++) {
 425                 addr[i] = strtol(address, &ptr, 16);
 426                 if (ptr[0] != '\0') {
 427                         if (ptr[0] != ':')
 428                                 return;
 429
 430                         address = ptr + 1;
 431                 }
 432         }
 433 }
 434
 435 void _bt_convert_addr_type_to_string(char *address,
 436                                 unsigned char *addr)
 437 {
 438         ret_if(address == NULL);
 439         ret_if(addr == NULL);
 440
 441         snprintf(address, BT_ADDRESS_STRING_SIZE,
 442                         "%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X",
 443                         addr[0], addr[1], addr[2],
 444                         addr[3], addr[4], addr[5]);
 445 }
 446
 447 void _bt_print_device_address_t(const bluetooth_device_address_t *addr)
 448 {
 449         BT_DBG("%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X\n", addr->addr[0], addr->addr[1], addr->addr[2],
 450                                 addr->addr[3], addr->addr[4], addr->addr[5]);
 451 }
 452
 453 void _bt_divide_device_class(bluetooth_device_class_t *device_class,
 454                                 unsigned int cod)
 455 {
 456         ret_if(device_class == NULL);
 457
 458         device_class->major_class = (unsigned short)(cod & 0x00001F00) >> 8;
 459         device_class->minor_class = (unsigned short)((cod & 0x000000FC));
 460         device_class->service_class = (unsigned long)((cod & 0x00FF0000));
 461
 462         if (cod & 0x002000) {
 463                 device_class->service_class |=
 464                 BLUETOOTH_DEVICE_SERVICE_CLASS_LIMITED_DISCOVERABLE_MODE;
 465         }
 466 }
 467
 468 void _bt_free_device_info(bt_remote_dev_info_t *dev_info)
 469 {
 470         int i;
 471
 472         ret_if(dev_info == NULL);
 473
 474         g_free(dev_info->address);
 475         g_free(dev_info->name);
 476         g_free(dev_info->manufacturer_data);
 477
 478         if (dev_info->uuids) {
 479                 for (i = 0; i < dev_info->uuid_count && dev_info->uuids[i]; i++)
 480                         g_free(dev_info->uuids[i]);
 481
 482                 g_free(dev_info->uuids);
 483         }
 484
 485         g_free(dev_info);
 486 }
 487
 488 void _bt_free_le_device_info(bt_remote_le_dev_info_t *le_dev_info)
 489 {
 490         ret_if(le_dev_info == NULL);
 491
 492         g_free(le_dev_info->adv_data);
 493         g_free(le_dev_info);
 494 }
 495
 496 int _bt_copy_utf8_string(char *dest, const char *src, unsigned int length)
 497 {
 498         int i;
 499         const char *p = src;
 500         char *next;
 501         int count;
 502
 503         if (dest == NULL || src == NULL)
 504                 return BLUETOOTH_ERROR_INVALID_PARAM;
 505
 506         BT_DBG("+src : %s", src);
 507         BT_DBG("+dest : %s", dest);
 508
 509         i = 0;
 510         while (*p != '\0' && i < length) {
 511                 next = g_utf8_next_char(p);
 512                 count = next - p;
 513
 514                 while (count > 0 && ((i + count) < length)) {
 515                         dest[i++] = *p;
 516                         p++;
 517                         count --;
 518                 }
 519                 p = next;
 520         }
 521         return BLUETOOTH_ERROR_NONE;
 522 }
 523
 524 gboolean _bt_utf8_validate(char *name)
 525 {
 526         BT_DBG("+");
 527         gunichar2 *u16;
 528         glong items_written = 0;
 529
 530         if (FALSE == g_utf8_validate(name, -1, NULL))
 531                 return FALSE;
 532
 533         u16 = g_utf8_to_utf16(name, -1, NULL, &items_written, NULL);
 534         if (u16 == NULL)
 535                 return FALSE;
 536
 537         g_free(u16);
 538
 539         if (items_written != g_utf8_strlen(name, -1))
 540                 return FALSE;
 541
 542         BT_DBG("-");
 543         return TRUE;
 544 }
 545
 546 int _bt_register_osp_server_in_agent(int type, char *uuid, char *path, int fd)
 547 {
 548         BT_DBG("+");
 549         if (!_bt_agent_register_osp_server( type, uuid, path, fd))
 550                 return BLUETOOTH_ERROR_INTERNAL;
 551
 552         return BLUETOOTH_ERROR_NONE;
 553 }
 554
 555 int _bt_unregister_osp_server_in_agent(int type, char *uuid)
 556 {
 557         BT_DBG("+");
 558         if (!_bt_agent_unregister_osp_server( type, uuid))
 559                 return BLUETOOTH_ERROR_INTERNAL;
 560
 561         return BLUETOOTH_ERROR_NONE;
 562 }
 563
 564 int _bt_set_socket_non_blocking(int socket_fd)
 565 {
 566         /* Set Nonblocking */
 567         long arg;
 568
 569         arg = fcntl(socket_fd, F_GETFL);
 570
 571         if (arg < 0)
 572                 return -errno;
 573
 574         if (arg & O_NONBLOCK) {
 575                 BT_ERR("Already Non-blocking \n");
 576         }
 577
 578         arg |= O_NONBLOCK;
 579
 580         if (fcntl(socket_fd, F_SETFL, arg) < 0)
 581                 return -errno;
 582
 583         return BLUETOOTH_ERROR_NONE;
 584 }
 585
 586 int _bt_set_non_blocking_tty(int sk)
 587 {
 588         struct termios ti = {0,};
 589         int err;
 590
 591         err = _bt_set_socket_non_blocking(sk);
 592
 593         if (err < 0) {
 594                 BT_ERR("Error in set non blocking!\n");
 595                 return err;
 596         }
 597
 598         tcflush(sk, TCIOFLUSH);
 599
 600         /* Switch tty to RAW mode */
 601         cfmakeraw(&ti);
 602         tcsetattr(sk, TCSANOW, &ti);
 603
 604         return BLUETOOTH_ERROR_NONE;
 605 }
 606
 607 static char *__bt_extract_device_path(GVariantIter *iter, char *address)
 608 {
 609         char *object_path = NULL;
 610         char device_address[BT_ADDRESS_STRING_SIZE] = { 0 };
 611
 612         /* Parse the signature: oa{sa{sv}}} */
 613         while (g_variant_iter_loop(iter, "{&oa{sa{sv}}}", &object_path,
 614                         NULL)) {
 615                 retv_if(object_path == NULL, NULL);
 616                 _bt_convert_device_path_to_address(object_path, device_address);
 617                 if (g_strcmp0(address, device_address) == 0) {
 618                         return g_strdup(object_path);
 619                 }
 620         }
 621         return NULL;
 622 }
 623
 624 char *_bt_get_device_object_path(char *address)
 625 {
 626         char *object_path = NULL;
 627         GDBusConnection *conn;
 628         GDBusProxy *manager_proxy;
 629         GVariant *result = NULL;
 630         GVariantIter *iter = NULL;
 631
 632         conn = _bt_get_system_conn();
 633         retv_if(conn == NULL, NULL);
 634
 635         manager_proxy = _bt_get_manager_proxy();
 636         retv_if(manager_proxy == NULL, NULL);
 637
 638         result = g_dbus_proxy_call_sync(manager_proxy, "GetManagedObjects",
 639                                 NULL,
 640                                 G_DBUS_CALL_FLAGS_NONE,
 641                                 -1,
 642                                 NULL,
 643                                 NULL);
 644         if (!result) {
 645                 BT_ERR("Can't get managed objects");
 646                 return NULL;
 647         }
 648
 649         /* signature of GetManagedObjects:  a{oa{sa{sv}}} */
 650         g_variant_get(result, "(a{oa{sa{sv}}})", &iter);
 651         object_path = __bt_extract_device_path(iter, address);
 652         g_variant_iter_free(iter);
 653         g_variant_unref(result);
 654         return object_path;
 655 }
 656
 657 char *_bt_get_profile_uuid128(bt_profile_type_t profile_type)
 658 {
 659         switch(profile_type) {
 660         case BT_PROFILE_CONN_RFCOMM:
 661                 return strdup(RFCOMM_UUID_STR);
 662         case BT_PROFILE_CONN_A2DP:
 663                 return strdup(A2DP_SINK_UUID);
 664         case BT_PROFILE_CONN_A2DP_SINK:
 665                 return strdup(A2DP_SOURCE_UUID);
 666         case BT_PROFILE_CONN_HSP:
 667                 return strdup(HFP_HS_UUID);
 668         case BT_PROFILE_CONN_HID:
 669                 return strdup(HID_UUID);
 670         case BT_PROFILE_CONN_NAP:
 671                 return strdup(NAP_UUID);
 672         case BT_PROFILE_CONN_HFG:
 673                 return strdup(HFP_AG_UUID);
 674         case BT_PROFILE_CONN_GATT:
 675         case BT_PROFILE_CONN_ALL: /* NULL UUID will connect to both the audio profiles*/
 676         default:
 677                 return NULL;
 678         };
 679 }
 680
 681 char *_bt_convert_error_to_string(int error)
 682 {
 683         switch (error) {
 684         case BLUETOOTH_ERROR_CANCEL:
 685                 return "CANCELLED";
 686         case BLUETOOTH_ERROR_INVALID_PARAM:
 687                 return "INVALID_PARAMETER";
 688         case BLUETOOTH_ERROR_INVALID_DATA:
 689                 return "INVALID DATA";
 690         case BLUETOOTH_ERROR_MEMORY_ALLOCATION:
 691         case BLUETOOTH_ERROR_OUT_OF_MEMORY:
 692                 return "OUT_OF_MEMORY";
 693         case BLUETOOTH_ERROR_TIMEOUT:
 694                 return "TIMEOUT";
 695         case BLUETOOTH_ERROR_NO_RESOURCES:
 696                 return "NO_RESOURCES";
 697         case BLUETOOTH_ERROR_INTERNAL:
 698                 return "INTERNAL";
 699         case BLUETOOTH_ERROR_NOT_SUPPORT:
 700                 return "NOT_SUPPORT";
 701         case BLUETOOTH_ERROR_DEVICE_NOT_ENABLED:
 702                 return "NOT_ENABLED";
 703         case BLUETOOTH_ERROR_DEVICE_ALREADY_ENABLED:
 704                 return "ALREADY_ENABLED";
 705         case BLUETOOTH_ERROR_DEVICE_BUSY:
 706                 return "DEVICE_BUSY";
 707         case BLUETOOTH_ERROR_ACCESS_DENIED:
 708                 return "ACCESS_DENIED";
 709         case BLUETOOTH_ERROR_MAX_CLIENT:
 710                 return "MAX_CLIENT";
 711         case BLUETOOTH_ERROR_NOT_FOUND:
 712                 return "NOT_FOUND";
 713         case BLUETOOTH_ERROR_SERVICE_SEARCH_ERROR:
 714                 return "SERVICE_SEARCH_ERROR";
 715         case BLUETOOTH_ERROR_PARING_FAILED:
 716                 return "PARING_FAILED";
 717         case BLUETOOTH_ERROR_NOT_PAIRED:
 718                 return "NOT_PAIRED";
 719         case BLUETOOTH_ERROR_SERVICE_NOT_FOUND:
 720                 return "SERVICE_NOT_FOUND";
 721         case BLUETOOTH_ERROR_NOT_CONNECTED:
 722                 return "NOT_CONNECTED";
 723         case BLUETOOTH_ERROR_ALREADY_CONNECT:
 724                 return "ALREADY_CONNECT";
 725         case BLUETOOTH_ERROR_CONNECTION_BUSY:
 726                 return "CONNECTION_BUSY";
 727         case BLUETOOTH_ERROR_CONNECTION_ERROR:
 728                 return "CONNECTION_ERROR";
 729         case BLUETOOTH_ERROR_MAX_CONNECTION:
 730                 return "MAX_CONNECTION";
 731         case BLUETOOTH_ERROR_NOT_IN_OPERATION:
 732                 return "NOT_IN_OPERATION";
 733         case BLUETOOTH_ERROR_CANCEL_BY_USER:
 734                 return "CANCEL_BY_USER";
 735         case BLUETOOTH_ERROR_REGISTRATION_FAILED:
 736                 return "REGISTRATION_FAILED";
 737         case BLUETOOTH_ERROR_IN_PROGRESS:
 738                 return "IN_PROGRESS";
 739         case BLUETOOTH_ERROR_AUTHENTICATION_FAILED:
 740                 return "AUTHENTICATION_FAILED";
 741         case BLUETOOTH_ERROR_HOST_DOWN:
 742                 return "HOST_DOWN";
 743         case BLUETOOTH_ERROR_END_OF_DEVICE_LIST:
 744                 return "END_OF_DEVICE_LIST";
 745         case BLUETOOTH_ERROR_AGENT_ALREADY_EXIST:
 746                 return "AGENT_ALREADY_EXIST";
 747         case BLUETOOTH_ERROR_AGENT_DOES_NOT_EXIST:
 748                 return "AGENT_DOES_NOT_EXIST";
 749         case BLUETOOTH_ERROR_ALREADY_INITIALIZED:
 750                 return "ALREADY_INITIALIZED";
 751         case BLUETOOTH_ERROR_PERMISSION_DEINED:
 752                 return "PERMISSION_DEINED";
 753         case BLUETOOTH_ERROR_ALREADY_DEACTIVATED:
 754                 return "ALREADY_DEACTIVATED";
 755         case BLUETOOTH_ERROR_NOT_INITIALIZED:
 756                 return "NOT_INITIALIZED";
 757         default:
 758                 return "UNKNOWN";
 759         }
 760 }
 761
 762 char * _bt_convert_disc_reason_to_string(int reason)
 763 {
 764         switch(reason) {
 765         case 1:
 766                 return "Link loss";
 767         case 2:
 768                 return "Connection terminated by local host";
 769         case 3:
 770                 return "Remote user terminated connection";
 771         case 0:
 772         default:
 773                 return "Unknown";
 774         }
 775 }
 776
 777 void _bt_logging_connection(gboolean connect, int addr_type)
 778 {
 779         static int le_conn = 0;
 780         static int le_disc = 0;
 781         static int edr_conn = 0;
 782         static int edr_disc = 0;
 783
 784         if (connect) {
 785                 if (addr_type)
 786                         le_conn++;
 787                 else
 788                         edr_conn++;
 789         } else {
 790                 if (addr_type)
 791                         le_disc++;
 792                 else
 793                         edr_disc++;
 794         }
 795
 796         BT_INFO("[PM] Number of LE conn: %d disc: %d, Number of BR/EDR conn: %d disc: %d",
 797                         le_conn, le_disc, edr_conn, edr_disc);
 798 }
 799 #if 0
 800 int _bt_eventsystem_set_value(const char *event, const char *key, const char *value)
 801 {
 802         int ret;
 803         bundle *b = NULL;
 804
 805         b = bundle_create();
 806
 807         bundle_add_str(b, key, value);
 808
 809         ret = eventsystem_request_sending_system_event(event, b);
 810
 811         BT_DBG("request_sending_system_event result: %d", ret);
 812
 813         bundle_free(b);
 814
 815         return ret;
 816 }
 817 #endif
 818 void _bt_swap_byte_ordering(char *data, int data_len)
 819 {
 820         char temp;
 821         int i, j;
 822
 823         ret_if(data == NULL);
 824         /* Swap to opposite endian */
 825         for (i = 0, j = data_len - 1; i < data_len; i++, j--) {
 826                 temp = data[i];
 827                 data[i] = data[j];
 828                 data[j] = temp;
 829                 }
 830 }
 831
 832 int _bt_byte_arr_cmp(const char *data1, const char *data2, int data_len)
 833 {
 834         int i;
 835
 836         retv_if(data1 == NULL, -1);
 837         retv_if(data2 == NULL, -1);
 838         for (i = 0; i < data_len; i++) {
 839                 if (data1[i] != data2[i])
 840                         return data1[i] - data2[i];
 841                 }
 842         return 0;
 843 }
 844 int _bt_byte_arr_cmp_with_mask(const char *data1, const char *data2,
 845         const char *mask, int data_len)
 846 {
 847         int i;
 848         char a, b;
 849
 850         retv_if(data1 == NULL, -1);
 851         retv_if(data2 == NULL, -1);
 852         retv_if(mask == NULL, -1);
 853         for (i = 0; i < data_len; i++) {
 854                 a = data1[i] & mask[i];
 855                 b = data2[i] & mask[i];
 856                 if (a != b)
 857                         return (int)(a - b);
 858                 }
 859         return 0;
 860 }