bt-service/bt-service-common.c

   1 /*
   2  * bluetooth-frwk
   3  *
   4  * Copyright (c) 2012-2013 Samsung Electronics Co., Ltd.
   5  *
   6  * Licensed under the Apache License, Version 2.0 (the "License");
   7  * you may not use this file except in compliance with the License.
   8  * You may obtain a copy of the License at
   9  *
  10  *              http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  * Unless required by applicable law or agreed to in writing, software
  13  * distributed under the License is distributed on an "AS IS" BASIS,
  14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  * See the License for the specific language governing permissions and
  16  * limitations under the License.
  17  *
  18  */
  19
  20 #include <stdio.h>
  21 #include <string.h>
  22 #include <dbus/dbus-glib-lowlevel.h>
  23 #include <dbus/dbus-glib.h>
  24 #include <dbus/dbus.h>
  25 #include <glib.h>
  26 #include <dlog.h>
  27 #include <fcntl.h>
  28 #include <errno.h>
  29 #include <termios.h>
  30
  31 #include "bluetooth-api.h"
  32 #include "bt-service-common.h"
  33 #include "bt-service-agent.h"
  34
  35 static DBusGConnection *system_conn;
  36 static DBusGConnection *session_conn;
  37 static DBusGProxy *manager_proxy;
  38 static DBusGProxy *adapter_proxy;
  39
  40 static DBusGProxy *__bt_init_manager_proxy(void)
  41 {
  42         DBusGProxy *proxy;
  43
  44         g_type_init();
  45
  46         if (system_conn == NULL) {
  47                 system_conn = dbus_g_bus_get(DBUS_BUS_SYSTEM, NULL);
  48                 retv_if(system_conn == NULL, NULL);
  49         }
  50
  51         proxy = dbus_g_proxy_new_for_name(system_conn, BT_BLUEZ_NAME,
  52                         BT_MANAGER_PATH, BT_MANAGER_INTERFACE);
  53
  54         retv_if(proxy == NULL, NULL);
  55
  56         manager_proxy = proxy;
  57
  58         return proxy;
  59 }
  60
  61 static DBusGProxy *__bt_init_adapter_proxy(void)
  62 {
  63         DBusGProxy *manager_proxy;
  64         DBusGProxy *proxy;
  65         char *adapter_path = NULL;
  66
  67         g_type_init();
  68
  69         if (system_conn == NULL) {
  70                 system_conn = dbus_g_bus_get(DBUS_BUS_SYSTEM, NULL);
  71                 retv_if(system_conn == NULL, NULL);
  72         }
  73
  74         manager_proxy = _bt_get_manager_proxy();
  75         retv_if(manager_proxy == NULL, NULL);
  76
  77         if (!dbus_g_proxy_call(manager_proxy, "DefaultAdapter", NULL,
  78                         G_TYPE_INVALID, DBUS_TYPE_G_OBJECT_PATH,
  79                         &adapter_path, G_TYPE_INVALID)) {
  80                 BT_ERR("Fait to get DefaultAdapter");
  81                 return NULL;
  82         }
  83
  84         adapter_path = g_strdup(adapter_path);
  85         retv_if(adapter_path == NULL, NULL);
  86
  87         proxy = dbus_g_proxy_new_for_name(system_conn, BT_BLUEZ_NAME,
  88                                 adapter_path, BT_ADAPTER_INTERFACE);
  89
  90         g_free(adapter_path);
  91
  92         retv_if(proxy == NULL, NULL);
  93
  94         adapter_proxy = proxy;
  95
  96         return proxy;
  97 }
  98
  99 DBusGConnection *__bt_init_system_gconn(void)
 100 {
 101         g_type_init();
 102
 103         if (system_conn == NULL)
 104                 system_conn = dbus_g_bus_get(DBUS_BUS_SYSTEM, NULL);
 105
 106         return system_conn;
 107 }
 108
 109 DBusGConnection *__bt_init_session_conn(void)
 110 {
 111         if (session_conn == NULL)
 112                 session_conn = dbus_g_bus_get(DBUS_BUS_SESSION, NULL);
 113
 114         return session_conn;
 115 }
 116
 117 DBusGConnection *_bt_get_session_gconn(void)
 118 {
 119         return (session_conn) ? session_conn : __bt_init_session_conn();
 120 }
 121
 122 DBusGConnection *_bt_get_system_gconn(void)
 123 {
 124         return (system_conn) ? system_conn : __bt_init_system_gconn();
 125 }
 126
 127 DBusConnection *_bt_get_system_conn(void)
 128 {
 129         DBusGConnection *g_conn;
 130
 131         if (system_conn == NULL) {
 132                 g_conn = __bt_init_system_gconn();
 133         } else {
 134                 g_conn = system_conn;
 135         }
 136
 137         retv_if(g_conn == NULL, NULL);
 138
 139         return dbus_g_connection_get_connection(g_conn);
 140 }
 141
 142 DBusGProxy *_bt_get_manager_proxy(void)
 143 {
 144         return (manager_proxy) ? manager_proxy : __bt_init_manager_proxy();
 145 }
 146
 147 DBusGProxy *_bt_get_adapter_proxy(void)
 148 {
 149         return (adapter_proxy) ? adapter_proxy : __bt_init_adapter_proxy();
 150 }
 151
 152 char *_bt_get_adapter_path(void)
 153 {
 154         char *adapter_path = NULL;
 155         DBusGProxy *proxy;
 156         GError *err = NULL;
 157
 158         proxy = _bt_get_manager_proxy();
 159
 160         if (!dbus_g_proxy_call(proxy, "DefaultAdapter", &err,
 161                                G_TYPE_INVALID, DBUS_TYPE_G_OBJECT_PATH,
 162                                &adapter_path, G_TYPE_INVALID)) {
 163                 if (err != NULL) {
 164                         BT_ERR("Getting DefaultAdapter failed: [%s]\n",
 165                                                         err->message);
 166                         g_error_free(err);
 167                 }
 168                 return NULL;
 169         }
 170
 171         return adapter_path;
 172 }
 173
 174 void _bt_deinit_bluez_proxy(void)
 175 {
 176         if (manager_proxy) {
 177                 g_object_unref(manager_proxy);
 178                 manager_proxy = NULL;
 179         }
 180
 181         if (adapter_proxy) {
 182                 g_object_unref(adapter_proxy);
 183                 adapter_proxy = NULL;
 184         }
 185 }
 186
 187 void _bt_deinit_proxys(void)
 188 {
 189
 190         _bt_deinit_bluez_proxy();
 191
 192         if (system_conn) {
 193                 dbus_g_connection_unref(system_conn);
 194                 system_conn = NULL;
 195         }
 196
 197         if (session_conn) {
 198                 dbus_g_connection_unref(session_conn);
 199                 session_conn = NULL;
 200         }
 201
 202 }
 203
 204 void _bt_convert_device_path_to_address(const char *device_path,
 205                                                 char *device_address)
 206 {
 207         char address[BT_ADDRESS_STRING_SIZE] = { 0 };
 208         char *dev_addr;
 209
 210         ret_if(device_path == NULL);
 211         ret_if(device_address == NULL);
 212
 213         dev_addr = strstr(device_path, "dev_");
 214         if (dev_addr != NULL) {
 215                 char *pos = NULL;
 216                 dev_addr += 4;
 217                 g_strlcpy(address, dev_addr, sizeof(address));
 218
 219                 while ((pos = strchr(address, '_')) != NULL) {
 220                         *pos = ':';
 221                 }
 222
 223                 g_strlcpy(device_address, address, BT_ADDRESS_STRING_SIZE);
 224         }
 225 }
 226
 227
 228 void _bt_convert_addr_string_to_type(unsigned char *addr,
 229                                         const char *address)
 230 {
 231         int i;
 232         char *ptr = NULL;
 233
 234         ret_if(address == NULL);
 235         ret_if(addr == NULL);
 236
 237         for (i = 0; i < BT_ADDRESS_LENGTH_MAX; i++) {
 238                 addr[i] = strtol(address, &ptr, 16);
 239                 if (ptr != NULL) {
 240                         if (ptr[0] != ':')
 241                                 return;
 242
 243                         address = ptr + 1;
 244                 }
 245         }
 246 }
 247
 248 void _bt_convert_addr_type_to_string(char *address,
 249                                 unsigned char *addr)
 250 {
 251         ret_if(address == NULL);
 252         ret_if(addr == NULL);
 253
 254         snprintf(address, BT_ADDRESS_STRING_SIZE,
 255                         "%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X",
 256                         addr[0], addr[1], addr[2],
 257                         addr[3], addr[4], addr[5]);
 258 }
 259
 260 void _bt_print_device_address_t(const bluetooth_device_address_t *addr)
 261 {
 262         BT_DBG("%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X\n", addr->addr[0], addr->addr[1], addr->addr[2],
 263                                 addr->addr[3], addr->addr[4], addr->addr[5]);
 264 }
 265
 266 void _bt_divide_device_class(bluetooth_device_class_t *device_class,
 267                                 unsigned int cod)
 268 {
 269         ret_if(device_class == NULL);
 270
 271         device_class->major_class = (unsigned short)(cod & 0x00001F00) >> 8;
 272         device_class->minor_class = (unsigned short)((cod & 0x000000FC));
 273         device_class->service_class = (unsigned long)((cod & 0x00FF0000));
 274
 275         if (cod & 0x002000) {
 276                 device_class->service_class |=
 277                 BLUETOOTH_DEVICE_SERVICE_CLASS_LIMITED_DISCOVERABLE_MODE;
 278         }
 279 }
 280
 281 void _bt_free_device_info(bt_remote_dev_info_t *dev_info)
 282 {
 283         int i;
 284
 285         ret_if(dev_info == NULL);
 286
 287         g_free(dev_info->address);
 288         g_free(dev_info->name);
 289
 290         if (dev_info->uuids) {
 291                 for (i = 0; dev_info->uuids[i] != NULL; i++)
 292                         g_free(dev_info->uuids[i]);
 293
 294                 g_free(dev_info->uuids);
 295         }
 296
 297         g_free(dev_info);
 298 }
 299
 300 int _bt_register_osp_server_in_agent(int type, char *uuid)
 301 {
 302         if (!_bt_agent_register_osp_server( type, uuid))
 303                 return BLUETOOTH_ERROR_INTERNAL;
 304
 305         return BLUETOOTH_ERROR_NONE;
 306 }
 307
 308 int _bt_unregister_osp_server_in_agent(int type, char *uuid)
 309 {
 310         if (!_bt_agent_unregister_osp_server( type, uuid))
 311                 return BLUETOOTH_ERROR_INTERNAL;
 312
 313         return BLUETOOTH_ERROR_NONE;
 314 }
 315
 316 int _bt_set_socket_non_blocking(int socket_fd)
 317 {
 318         /* Set Nonblocking */
 319         long arg;
 320
 321         arg = fcntl(socket_fd, F_GETFL);
 322
 323         if (arg < 0)
 324                 return -errno;
 325
 326         if (arg & O_NONBLOCK) {
 327                 BT_ERR("Already Non-blocking \n");
 328         }
 329
 330         arg |= O_NONBLOCK;
 331
 332         if (fcntl(socket_fd, F_SETFL, arg) < 0)
 333                 return -errno;
 334
 335         return BLUETOOTH_ERROR_NONE;
 336 }
 337
 338 int _bt_set_non_blocking_tty(int sk)
 339 {
 340         struct termios ti = {0,};
 341         int err;
 342
 343         err = _bt_set_socket_non_blocking(sk);
 344
 345         if (err < 0) {
 346                 BT_ERR("Error in set non blocking!\n");
 347                 return err;
 348         }
 349
 350         tcflush(sk, TCIOFLUSH);
 351
 352         /* Switch tty to RAW mode */
 353         cfmakeraw(&ti);
 354         tcsetattr(sk, TCSANOW, &ti);
 355
 356         return BLUETOOTH_ERROR_NONE;
 357 }
 358
 359 gboolean _bt_is_headset_class(int dev_class)
 360 {
 361         gboolean is_headset = FALSE;
 362
 363         switch ((dev_class & 0x1f00) >> 8) {
 364         case 0x04:
 365                 switch ((dev_class & 0xfc) >> 2) {
 366                 case 0x01:
 367                 case 0x02:
 368                         /* Headset */
 369                         is_headset = TRUE;
 370                         break;
 371                 case 0x06:
 372                         /* Headphone */
 373                         is_headset = TRUE;
 374                         break;
 375                 case 0x0b:      /* VCR */
 376                 case 0x0c:      /* Video Camera */
 377                 case 0x0d:      /* Camcorder */
 378                         break;
 379                 default:
 380                         /* Other audio device */
 381                         is_headset = TRUE;
 382                         break;
 383                 }
 384                 break;
 385         }
 386
 387         return is_headset;
 388 }
 389