src/dbus.c

   1 /*
   2  *
   3  *  Connection Manager
   4  *
   5  *  Copyright (C) 2007-2012  Intel Corporation. All rights reserved.
   6  *
   7  *  This program is free software; you can redistribute it and/or modify
   8  *  it under the terms of the GNU General Public License version 2 as
   9  *  published by the Free Software Foundation.
  10  *
  11  *  This program is distributed in the hope that it will be useful,
  12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  *  GNU General Public License for more details.
  15  *
  16  *  You should have received a copy of the GNU General Public License
  17  *  along with this program; if not, write to the Free Software
  18  *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  19  *
  20  */
  21
  22 #ifdef HAVE_CONFIG_H
  23 #include <config.h>
  24 #endif
  25
  26 #include <string.h>
  27 #include <gdbus.h>
  28
  29 #include "connman.h"
  30
  31 dbus_bool_t connman_dbus_validate_ident(const char *ident)
  32 {
  33         unsigned int i;
  34
  35         if (ident == NULL)
  36                 return FALSE;
  37
  38         for (i = 0; i < strlen(ident); i++) {
  39                 if (ident[i] >= '0' && ident[i] <= '9')
  40                         continue;
  41                 if (ident[i] >= 'a' && ident[i] <= 'z')
  42                         continue;
  43                 if (ident[i] >= 'A' && ident[i] <= 'Z')
  44                         continue;
  45                 return FALSE;
  46         }
  47
  48         return TRUE;
  49 }
  50
  51 char *connman_dbus_encode_string(const char *value)
  52 {
  53         GString *str;
  54         unsigned int i, size;
  55
  56         if (value == NULL)
  57                 return NULL;
  58
  59         size = strlen(value);
  60
  61         str = g_string_new(NULL);
  62         if (str == NULL)
  63                 return NULL;
  64
  65         for (i = 0; i < size; i++) {
  66                 const char tmp = value[i];
  67                 if ((tmp < '0' || tmp > '9') && (tmp < 'A' || tmp > 'Z') &&
  68                                                 (tmp < 'a' || tmp > 'z'))
  69                         g_string_append_printf(str, "_%02x", tmp);
  70                 else
  71                         str = g_string_append_c(str, tmp);
  72         }
  73
  74         return g_string_free(str, FALSE);
  75 }
  76
  77 void connman_dbus_property_append_basic(DBusMessageIter *iter,
  78                                         const char *key, int type, void *val)
  79 {
  80         DBusMessageIter value;
  81         const char *signature;
  82
  83         dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &key);
  84
  85         switch (type) {
  86         case DBUS_TYPE_BOOLEAN:
  87                 signature = DBUS_TYPE_BOOLEAN_AS_STRING;
  88                 break;
  89         case DBUS_TYPE_STRING:
  90                 signature = DBUS_TYPE_STRING_AS_STRING;
  91                 break;
  92         case DBUS_TYPE_BYTE:
  93                 signature = DBUS_TYPE_BYTE_AS_STRING;
  94                 break;
  95         case DBUS_TYPE_UINT16:
  96                 signature = DBUS_TYPE_UINT16_AS_STRING;
  97                 break;
  98         case DBUS_TYPE_INT16:
  99                 signature = DBUS_TYPE_INT16_AS_STRING;
 100                 break;
 101         case DBUS_TYPE_UINT32:
 102                 signature = DBUS_TYPE_UINT32_AS_STRING;
 103                 break;
 104         case DBUS_TYPE_INT32:
 105                 signature = DBUS_TYPE_INT32_AS_STRING;
 106                 break;
 107         case DBUS_TYPE_UINT64:
 108                 signature = DBUS_TYPE_UINT64_AS_STRING;
 109                 break;
 110         case DBUS_TYPE_INT64:
 111                 signature = DBUS_TYPE_INT64_AS_STRING;
 112                 break;
 113         case DBUS_TYPE_OBJECT_PATH:
 114                 signature = DBUS_TYPE_OBJECT_PATH_AS_STRING;
 115                 break;
 116         default:
 117                 signature = DBUS_TYPE_VARIANT_AS_STRING;
 118                 break;
 119         }
 120
 121         dbus_message_iter_open_container(iter, DBUS_TYPE_VARIANT,
 122                                                         signature, &value);
 123         dbus_message_iter_append_basic(&value, type, val);
 124         dbus_message_iter_close_container(iter, &value);
 125 }
 126
 127 void connman_dbus_property_append_dict(DBusMessageIter *iter, const char *key,
 128                         connman_dbus_append_cb_t function, void *user_data)
 129 {
 130         DBusMessageIter value, dict;
 131
 132         dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &key);
 133
 134         dbus_message_iter_open_container(iter, DBUS_TYPE_VARIANT,
 135                         DBUS_TYPE_ARRAY_AS_STRING
 136                         DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
 137                         DBUS_TYPE_STRING_AS_STRING DBUS_TYPE_VARIANT_AS_STRING
 138                         DBUS_DICT_ENTRY_END_CHAR_AS_STRING, &value);
 139
 140         connman_dbus_dict_open(&value, &dict);
 141         if (function)
 142                 function(&dict, user_data);
 143         connman_dbus_dict_close(&value, &dict);
 144
 145         dbus_message_iter_close_container(iter, &value);
 146 }
 147
 148 void connman_dbus_property_append_fixed_array(DBusMessageIter *iter,
 149                                 const char *key, int type, void *val, int len)
 150 {
 151         DBusMessageIter value, array;
 152         const char *variant_sig, *array_sig;
 153
 154         switch (type) {
 155         case DBUS_TYPE_BYTE:
 156                 variant_sig = DBUS_TYPE_ARRAY_AS_STRING DBUS_TYPE_BYTE_AS_STRING;
 157                 array_sig = DBUS_TYPE_BYTE_AS_STRING;
 158                 break;
 159         default:
 160                 return;
 161         }
 162
 163         dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &key);
 164
 165         dbus_message_iter_open_container(iter, DBUS_TYPE_VARIANT,
 166                                                         variant_sig, &value);
 167
 168         dbus_message_iter_open_container(&value, DBUS_TYPE_ARRAY,
 169                                                         array_sig, &array);
 170         dbus_message_iter_append_fixed_array(&array, type, val, len);
 171         dbus_message_iter_close_container(&value, &array);
 172
 173         dbus_message_iter_close_container(iter, &value);
 174 }
 175
 176 void connman_dbus_property_append_array(DBusMessageIter *iter,
 177                                                 const char *key, int type,
 178                         connman_dbus_append_cb_t function, void *user_data)
 179 {
 180         DBusMessageIter value, array;
 181         const char *variant_sig, *array_sig;
 182
 183         switch (type) {
 184         case DBUS_TYPE_STRING:
 185                 variant_sig = DBUS_TYPE_ARRAY_AS_STRING DBUS_TYPE_STRING_AS_STRING;
 186                 array_sig = DBUS_TYPE_STRING_AS_STRING;
 187                 break;
 188         case DBUS_TYPE_OBJECT_PATH:
 189                 variant_sig = DBUS_TYPE_ARRAY_AS_STRING DBUS_TYPE_OBJECT_PATH_AS_STRING;
 190                 array_sig = DBUS_TYPE_OBJECT_PATH_AS_STRING;
 191                 break;
 192         case DBUS_TYPE_DICT_ENTRY:
 193                 variant_sig = DBUS_TYPE_ARRAY_AS_STRING
 194                                 DBUS_STRUCT_BEGIN_CHAR_AS_STRING
 195                                 DBUS_TYPE_ARRAY_AS_STRING
 196                                         DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
 197                                                 DBUS_TYPE_STRING_AS_STRING
 198                                                 DBUS_TYPE_VARIANT_AS_STRING
 199                                         DBUS_DICT_ENTRY_END_CHAR_AS_STRING
 200                                 DBUS_STRUCT_END_CHAR_AS_STRING;
 201                 array_sig = DBUS_STRUCT_BEGIN_CHAR_AS_STRING
 202                                 DBUS_TYPE_ARRAY_AS_STRING
 203                                         DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
 204                                                 DBUS_TYPE_STRING_AS_STRING
 205                                                 DBUS_TYPE_VARIANT_AS_STRING
 206                                         DBUS_DICT_ENTRY_END_CHAR_AS_STRING
 207                                 DBUS_STRUCT_END_CHAR_AS_STRING;
 208                 break;
 209         default:
 210                 return;
 211         }
 212
 213         dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &key);
 214
 215         dbus_message_iter_open_container(iter, DBUS_TYPE_VARIANT,
 216                                                         variant_sig, &value);
 217
 218         dbus_message_iter_open_container(&value, DBUS_TYPE_ARRAY,
 219                                                         array_sig, &array);
 220         if (function)
 221                 function(&array, user_data);
 222         dbus_message_iter_close_container(&value, &array);
 223
 224         dbus_message_iter_close_container(iter, &value);
 225 }
 226
 227 static DBusConnection *connection = NULL;
 228
 229 dbus_bool_t connman_dbus_property_changed_basic(const char *path,
 230                                 const char *interface, const char *key,
 231                                                         int type, void *val)
 232 {
 233         DBusMessage *signal;
 234         DBusMessageIter iter;
 235
 236         if (path == NULL)
 237                 return FALSE;
 238
 239         signal = dbus_message_new_signal(path, interface, "PropertyChanged");
 240         if (signal == NULL)
 241                 return FALSE;
 242
 243         dbus_message_iter_init_append(signal, &iter);
 244         connman_dbus_property_append_basic(&iter, key, type, val);
 245
 246         g_dbus_send_message(connection, signal);
 247
 248         return TRUE;
 249 }
 250
 251 dbus_bool_t connman_dbus_property_changed_dict(const char *path,
 252                                 const char *interface, const char *key,
 253                         connman_dbus_append_cb_t function, void *user_data)
 254 {
 255         DBusMessage *signal;
 256         DBusMessageIter iter;
 257
 258         if (path == NULL)
 259                 return FALSE;
 260
 261         signal = dbus_message_new_signal(path, interface, "PropertyChanged");
 262         if (signal == NULL)
 263                 return FALSE;
 264
 265         dbus_message_iter_init_append(signal, &iter);
 266         connman_dbus_property_append_dict(&iter, key, function, user_data);
 267
 268         g_dbus_send_message(connection, signal);
 269
 270         return TRUE;
 271 }
 272
 273 dbus_bool_t connman_dbus_property_changed_array(const char *path,
 274                         const char *interface, const char *key, int type,
 275                         connman_dbus_append_cb_t function, void *user_data)
 276 {
 277         DBusMessage *signal;
 278         DBusMessageIter iter;
 279
 280         if (path == NULL)
 281                 return FALSE;
 282
 283         signal = dbus_message_new_signal(path, interface, "PropertyChanged");
 284         if (signal == NULL)
 285                 return FALSE;
 286
 287         dbus_message_iter_init_append(signal, &iter);
 288         connman_dbus_property_append_array(&iter, key, type,
 289                                                 function, user_data);
 290
 291         g_dbus_send_message(connection, signal);
 292
 293         return TRUE;
 294 }
 295
 296 dbus_bool_t connman_dbus_setting_changed_basic(const char *owner,
 297                                 const char *path, const char *key,
 298                                 int type, void *val)
 299 {
 300         DBusMessage *msg;
 301         DBusMessageIter array, dict;
 302
 303         if (owner == NULL || path == NULL)
 304                 return FALSE;
 305
 306         msg = dbus_message_new_method_call(owner, path,
 307                                                 CONNMAN_NOTIFICATION_INTERFACE,
 308                                                 "Update");
 309         if (msg == NULL)
 310                 return FALSE;
 311
 312         dbus_message_iter_init_append(msg, &array);
 313         connman_dbus_dict_open(&array, &dict);
 314
 315         connman_dbus_dict_append_basic(&dict, key, type, val);
 316
 317         connman_dbus_dict_close(&array, &dict);
 318
 319         g_dbus_send_message(connection, msg);
 320
 321         return TRUE;
 322 }
 323
 324 dbus_bool_t connman_dbus_setting_changed_dict(const char *owner,
 325                                 const char *path, const char *key,
 326                                 connman_dbus_append_cb_t function,
 327                                 void *user_data)
 328 {
 329         DBusMessage *msg;
 330         DBusMessageIter array, dict;
 331
 332         if (owner == NULL || path == NULL)
 333                 return FALSE;
 334
 335         msg = dbus_message_new_method_call(owner, path,
 336                                                 CONNMAN_NOTIFICATION_INTERFACE,
 337                                                 "Update");
 338         if (msg == NULL)
 339                 return FALSE;
 340
 341         dbus_message_iter_init_append(msg, &array);
 342         connman_dbus_dict_open(&array, &dict);
 343
 344         connman_dbus_dict_append_dict(&dict, key, function, user_data);
 345
 346         connman_dbus_dict_close(&array, &dict);
 347
 348         g_dbus_send_message(connection, msg);
 349
 350         return TRUE;
 351 }
 352
 353 dbus_bool_t connman_dbus_setting_changed_array(const char *owner,
 354                                 const char *path, const char *key, int type,
 355                                 connman_dbus_append_cb_t function,
 356                                 void *user_data)
 357 {
 358         DBusMessage *msg;
 359         DBusMessageIter array, dict;
 360
 361         if (owner == NULL || path == NULL)
 362                 return FALSE;
 363
 364         msg = dbus_message_new_method_call(owner, path,
 365                                                 CONNMAN_NOTIFICATION_INTERFACE,
 366                                                 "Update");
 367         if (msg == NULL)
 368                 return FALSE;
 369
 370         dbus_message_iter_init_append(msg, &array);
 371         connman_dbus_dict_open(&array, &dict);
 372
 373         connman_dbus_dict_append_array(&dict, key, type, function, user_data);
 374
 375         connman_dbus_dict_close(&array, &dict);
 376
 377         g_dbus_send_message(connection, msg);
 378
 379         return TRUE;
 380 }
 381
 382 dbus_bool_t __connman_dbus_append_objpath_dict_array(DBusMessage *msg,
 383                 connman_dbus_append_cb_t function, void *user_data)
 384 {
 385         DBusMessageIter iter, array;
 386
 387         if (msg == NULL || function == NULL)
 388                 return FALSE;
 389
 390         dbus_message_iter_init_append(msg, &iter);
 391         dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY,
 392                         DBUS_STRUCT_BEGIN_CHAR_AS_STRING
 393                         DBUS_TYPE_OBJECT_PATH_AS_STRING
 394                         DBUS_TYPE_ARRAY_AS_STRING
 395                                 DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
 396                                         DBUS_TYPE_STRING_AS_STRING
 397                                         DBUS_TYPE_VARIANT_AS_STRING
 398                                 DBUS_DICT_ENTRY_END_CHAR_AS_STRING
 399                         DBUS_STRUCT_END_CHAR_AS_STRING, &array);
 400
 401         function(&array, user_data);
 402
 403         dbus_message_iter_close_container(&iter, &array);
 404
 405         return TRUE;
 406 }
 407
 408 DBusConnection *connman_dbus_get_connection(void)
 409 {
 410         if (connection == NULL)
 411                 return NULL;
 412
 413         return dbus_connection_ref(connection);
 414 }
 415
 416 int __connman_dbus_init(DBusConnection *conn)
 417 {
 418         DBG("");
 419
 420         connection = conn;
 421
 422         return 0;
 423 }
 424
 425 void __connman_dbus_cleanup(void)
 426 {
 427         DBG("");
 428
 429         connection = NULL;
 430 }