src/dbus.c

   1 /*
   2  *
   3  *  Connection Manager
   4  *
   5  *  Copyright (C) 2007-2009  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_OBJECT_PATH:
 108                 signature = DBUS_TYPE_OBJECT_PATH_AS_STRING;
 109                 break;
 110         default:
 111                 signature = DBUS_TYPE_VARIANT_AS_STRING;
 112                 break;
 113         }
 114
 115         dbus_message_iter_open_container(iter, DBUS_TYPE_VARIANT,
 116                                                         signature, &value);
 117         dbus_message_iter_append_basic(&value, type, val);
 118         dbus_message_iter_close_container(iter, &value);
 119 }
 120
 121 void connman_dbus_property_append_dict(DBusMessageIter *iter, const char *key,
 122                         connman_dbus_append_cb_t function, void *user_data)
 123 {
 124         DBusMessageIter value, dict;
 125
 126         dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &key);
 127
 128         dbus_message_iter_open_container(iter, DBUS_TYPE_VARIANT,
 129                         DBUS_TYPE_ARRAY_AS_STRING
 130                         DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
 131                         DBUS_TYPE_STRING_AS_STRING DBUS_TYPE_VARIANT_AS_STRING
 132                         DBUS_DICT_ENTRY_END_CHAR_AS_STRING, &value);
 133
 134         connman_dbus_dict_open(&value, &dict);
 135         if (function)
 136                 function(&dict, user_data);
 137         connman_dbus_dict_close(&value, &dict);
 138
 139         dbus_message_iter_close_container(iter, &value);
 140 }
 141
 142 void connman_dbus_property_append_fixed_array(DBusMessageIter *iter,
 143                                 const char *key, int type, void *val, int len)
 144 {
 145         DBusMessageIter value, array;
 146         const char *variant_sig, *array_sig;
 147
 148         switch (type) {
 149         case DBUS_TYPE_BYTE:
 150                 variant_sig = DBUS_TYPE_ARRAY_AS_STRING DBUS_TYPE_BYTE_AS_STRING;
 151                 array_sig = DBUS_TYPE_BYTE_AS_STRING;
 152                 break;
 153         default:
 154                 return;
 155         }
 156
 157         dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &key);
 158
 159         dbus_message_iter_open_container(iter, DBUS_TYPE_VARIANT,
 160                                                         variant_sig, &value);
 161
 162         dbus_message_iter_open_container(&value, DBUS_TYPE_ARRAY,
 163                                                         array_sig, &array);
 164         dbus_message_iter_append_fixed_array(&array, type, val, len);
 165         dbus_message_iter_close_container(&value, &array);
 166
 167         dbus_message_iter_close_container(iter, &value);
 168 }
 169
 170 void connman_dbus_property_append_variable_array(DBusMessageIter *iter,
 171                                                 const char *key, int type,
 172                         connman_dbus_append_cb_t function, void *user_data)
 173 {
 174         DBusMessageIter value, array;
 175         const char *variant_sig, *array_sig;
 176
 177         switch (type) {
 178         case DBUS_TYPE_STRING:
 179                 variant_sig = DBUS_TYPE_ARRAY_AS_STRING DBUS_TYPE_STRING_AS_STRING;
 180                 array_sig = DBUS_TYPE_STRING_AS_STRING;
 181                 break;
 182         case DBUS_TYPE_OBJECT_PATH:
 183                 variant_sig = DBUS_TYPE_ARRAY_AS_STRING DBUS_TYPE_OBJECT_PATH_AS_STRING;
 184                 array_sig = DBUS_TYPE_OBJECT_PATH_AS_STRING;
 185                 break;
 186         default:
 187                 return;
 188         }
 189
 190         dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &key);
 191
 192         dbus_message_iter_open_container(iter, DBUS_TYPE_VARIANT,
 193                                                         variant_sig, &value);
 194
 195         dbus_message_iter_open_container(&value, DBUS_TYPE_ARRAY,
 196                                                         array_sig, &array);
 197         if (function)
 198                 function(&array, user_data);
 199         dbus_message_iter_close_container(&value, &array);
 200
 201         dbus_message_iter_close_container(iter, &value);
 202 }
 203
 204 static DBusConnection *connection = NULL;
 205
 206 dbus_bool_t connman_dbus_property_changed_basic(const char *path,
 207                                 const char *interface, const char *key,
 208                                                         int type, void *val)
 209 {
 210         DBusMessage *signal;
 211         DBusMessageIter iter;
 212
 213         if (path == NULL)
 214                 return FALSE;
 215
 216         signal = dbus_message_new_signal(path, interface, "PropertyChanged");
 217         if (signal == NULL)
 218                 return FALSE;
 219
 220         dbus_message_iter_init_append(signal, &iter);
 221         connman_dbus_property_append_basic(&iter, key, type, val);
 222
 223         g_dbus_send_message(connection, signal);
 224
 225         return TRUE;
 226 }
 227
 228 dbus_bool_t connman_dbus_property_changed_dict(const char *path,
 229                                 const char *interface, const char *key,
 230                         connman_dbus_append_cb_t function, void *user_data)
 231 {
 232         DBusMessage *signal;
 233         DBusMessageIter iter;
 234
 235         if (path == NULL)
 236                 return FALSE;
 237
 238         signal = dbus_message_new_signal(path, interface, "PropertyChanged");
 239         if (signal == NULL)
 240                 return FALSE;
 241
 242         dbus_message_iter_init_append(signal, &iter);
 243         connman_dbus_property_append_dict(&iter, key, function, user_data);
 244
 245         g_dbus_send_message(connection, signal);
 246
 247         return TRUE;
 248 }
 249
 250 dbus_bool_t connman_dbus_property_changed_array(const char *path,
 251                         const char *interface, const char *key, int type,
 252                         connman_dbus_append_cb_t function, void *user_data)
 253 {
 254         DBusMessage *signal;
 255         DBusMessageIter iter;
 256
 257         if (path == NULL)
 258                 return FALSE;
 259
 260         signal = dbus_message_new_signal(path, interface, "PropertyChanged");
 261         if (signal == NULL)
 262                 return FALSE;
 263
 264         dbus_message_iter_init_append(signal, &iter);
 265         connman_dbus_property_append_variable_array(&iter, key, type,
 266                                                         function, user_data);
 267
 268         g_dbus_send_message(connection, signal);
 269
 270         return TRUE;
 271 }
 272
 273 DBusConnection *connman_dbus_get_connection(void)
 274 {
 275         if (connection == NULL)
 276                 return NULL;
 277
 278         return dbus_connection_ref(connection);
 279 }
 280
 281 int __connman_dbus_init(DBusConnection *conn)
 282 {
 283         connection = conn;
 284
 285         return 0;
 286 }
 287
 288 void __connman_dbus_cleanup(void)
 289 {
 290         connection = NULL;
 291 }