src/dbus.c

   1 /*
   2  *
   3  *  neard - Near Field Communication manager
   4  *
   5  *  Copyright (C) 2011  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 "near.h"
  30
  31 static DBusConnection *connection;
  32
  33 dbus_bool_t near_dbus_validate_ident(const char *ident)
  34 {
  35         unsigned int i;
  36
  37         if (!ident)
  38                 return FALSE;
  39
  40         for (i = 0; i < strlen(ident); i++) {
  41                 if (ident[i] >= '0' && ident[i] <= '9')
  42                         continue;
  43                 if (ident[i] >= 'a' && ident[i] <= 'z')
  44                         continue;
  45                 if (ident[i] >= 'A' && ident[i] <= 'Z')
  46                         continue;
  47                 return FALSE;
  48         }
  49
  50         return TRUE;
  51 }
  52
  53 char *near_dbus_encode_string(const char *value)
  54 {
  55         GString *str;
  56         unsigned int i, size;
  57
  58         if (!value)
  59                 return NULL;
  60
  61         size = strlen(value);
  62
  63         str = g_string_new(NULL);
  64         if (!str)
  65                 return NULL;
  66
  67         for (i = 0; i < size; i++) {
  68                 const char tmp = value[i];
  69                 if ((tmp < '0' || tmp > '9') && (tmp < 'A' || tmp > 'Z') &&
  70                                                 (tmp < 'a' || tmp > 'z'))
  71                         g_string_append_printf(str, "_%02x", tmp);
  72                 else
  73                         str = g_string_append_c(str, tmp);
  74         }
  75
  76         return g_string_free(str, FALSE);
  77 }
  78
  79 void near_dbus_property_append_basic(DBusMessageIter *iter,
  80                                         const char *key, int type, void *val)
  81 {
  82         DBusMessageIter value;
  83         const char *signature;
  84
  85         dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &key);
  86
  87         switch (type) {
  88         case DBUS_TYPE_BOOLEAN:
  89                 signature = DBUS_TYPE_BOOLEAN_AS_STRING;
  90                 break;
  91         case DBUS_TYPE_STRING:
  92                 signature = DBUS_TYPE_STRING_AS_STRING;
  93                 break;
  94         case DBUS_TYPE_BYTE:
  95                 signature = DBUS_TYPE_BYTE_AS_STRING;
  96                 break;
  97         case DBUS_TYPE_UINT16:
  98                 signature = DBUS_TYPE_UINT16_AS_STRING;
  99                 break;
 100         case DBUS_TYPE_INT16:
 101                 signature = DBUS_TYPE_INT16_AS_STRING;
 102                 break;
 103         case DBUS_TYPE_UINT32:
 104                 signature = DBUS_TYPE_UINT32_AS_STRING;
 105                 break;
 106         case DBUS_TYPE_INT32:
 107                 signature = DBUS_TYPE_INT32_AS_STRING;
 108                 break;
 109         case DBUS_TYPE_OBJECT_PATH:
 110                 signature = DBUS_TYPE_OBJECT_PATH_AS_STRING;
 111                 break;
 112         default:
 113                 signature = DBUS_TYPE_VARIANT_AS_STRING;
 114                 break;
 115         }
 116
 117         dbus_message_iter_open_container(iter, DBUS_TYPE_VARIANT,
 118                                                         signature, &value);
 119         dbus_message_iter_append_basic(&value, type, val);
 120         dbus_message_iter_close_container(iter, &value);
 121 }
 122
 123 void near_dbus_property_append_dict(DBusMessageIter *iter, const char *key,
 124                         near_dbus_append_cb_t function, void *user_data)
 125 {
 126         DBusMessageIter value, dict;
 127
 128         dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &key);
 129
 130         dbus_message_iter_open_container(iter, DBUS_TYPE_VARIANT,
 131                         DBUS_TYPE_ARRAY_AS_STRING
 132                         DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
 133                         DBUS_TYPE_STRING_AS_STRING DBUS_TYPE_VARIANT_AS_STRING
 134                         DBUS_DICT_ENTRY_END_CHAR_AS_STRING, &value);
 135
 136         near_dbus_dict_open(&value, &dict);
 137         if (function)
 138                 function(&dict, user_data);
 139         near_dbus_dict_close(&value, &dict);
 140
 141         dbus_message_iter_close_container(iter, &value);
 142 }
 143
 144 void near_dbus_property_append_fixed_array(DBusMessageIter *iter,
 145                                 const char *key, int type, void *val, int len)
 146 {
 147         DBusMessageIter value, array;
 148         const char *variant_sig, *array_sig;
 149
 150         switch (type) {
 151         case DBUS_TYPE_BYTE:
 152                 variant_sig = DBUS_TYPE_ARRAY_AS_STRING DBUS_TYPE_BYTE_AS_STRING;
 153                 array_sig = DBUS_TYPE_BYTE_AS_STRING;
 154                 break;
 155         default:
 156                 return;
 157         }
 158
 159         dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &key);
 160
 161         dbus_message_iter_open_container(iter, DBUS_TYPE_VARIANT,
 162                                                         variant_sig, &value);
 163
 164         dbus_message_iter_open_container(&value, DBUS_TYPE_ARRAY,
 165                                                         array_sig, &array);
 166         dbus_message_iter_append_fixed_array(&array, type, val, len);
 167         dbus_message_iter_close_container(&value, &array);
 168
 169         dbus_message_iter_close_container(iter, &value);
 170 }
 171
 172 void near_dbus_property_append_array(DBusMessageIter *iter,
 173                                                 const char *key, int type,
 174                         near_dbus_append_cb_t function, void *user_data)
 175 {
 176         DBusMessageIter value, array;
 177         const char *variant_sig, *array_sig;
 178
 179         switch (type) {
 180         case DBUS_TYPE_STRING:
 181                 variant_sig = DBUS_TYPE_ARRAY_AS_STRING DBUS_TYPE_STRING_AS_STRING;
 182                 array_sig = DBUS_TYPE_STRING_AS_STRING;
 183                 break;
 184         case DBUS_TYPE_OBJECT_PATH:
 185                 variant_sig = DBUS_TYPE_ARRAY_AS_STRING DBUS_TYPE_OBJECT_PATH_AS_STRING;
 186                 array_sig = DBUS_TYPE_OBJECT_PATH_AS_STRING;
 187                 break;
 188         case DBUS_TYPE_BYTE:
 189                 variant_sig = DBUS_TYPE_ARRAY_AS_STRING DBUS_TYPE_BYTE_AS_STRING;
 190                 array_sig = DBUS_TYPE_BYTE_AS_STRING;
 191                 break;
 192         default:
 193                 return;
 194         }
 195
 196         dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &key);
 197
 198         dbus_message_iter_open_container(iter, DBUS_TYPE_VARIANT,
 199                                                         variant_sig, &value);
 200
 201         dbus_message_iter_open_container(&value, DBUS_TYPE_ARRAY,
 202                                                         array_sig, &array);
 203         if (function)
 204                 function(&array, user_data);
 205         dbus_message_iter_close_container(&value, &array);
 206
 207         dbus_message_iter_close_container(iter, &value);
 208 }
 209
 210 static DBusConnection *connection = NULL;
 211
 212 dbus_bool_t near_dbus_property_changed_basic(const char *path,
 213                                 const char *interface, const char *key,
 214                                                         int type, void *val)
 215 {
 216         DBusMessage *signal;
 217         DBusMessageIter iter;
 218
 219         if (!path)
 220                 return FALSE;
 221
 222         signal = dbus_message_new_signal(path, interface, "PropertyChanged");
 223         if (!signal)
 224                 return FALSE;
 225
 226         dbus_message_iter_init_append(signal, &iter);
 227         near_dbus_property_append_basic(&iter, key, type, val);
 228
 229         g_dbus_send_message(connection, signal);
 230
 231         return TRUE;
 232 }
 233
 234 dbus_bool_t near_dbus_property_changed_dict(const char *path,
 235                                 const char *interface, const char *key,
 236                         near_dbus_append_cb_t function, void *user_data)
 237 {
 238         DBusMessage *signal;
 239         DBusMessageIter iter;
 240
 241         if (!path)
 242                 return FALSE;
 243
 244         signal = dbus_message_new_signal(path, interface, "PropertyChanged");
 245         if (!signal)
 246                 return FALSE;
 247
 248         dbus_message_iter_init_append(signal, &iter);
 249         near_dbus_property_append_dict(&iter, key, function, user_data);
 250
 251         g_dbus_send_message(connection, signal);
 252
 253         return TRUE;
 254 }
 255
 256 dbus_bool_t near_dbus_property_changed_array(const char *path,
 257                         const char *interface, const char *key, int type,
 258                         near_dbus_append_cb_t function, void *user_data)
 259 {
 260         DBusMessage *signal;
 261         DBusMessageIter iter;
 262
 263         if (!path)
 264                 return FALSE;
 265
 266         signal = dbus_message_new_signal(path, interface, "PropertyChanged");
 267         if (!signal)
 268                 return FALSE;
 269
 270         dbus_message_iter_init_append(signal, &iter);
 271         near_dbus_property_append_array(&iter, key, type,
 272                                                 function, user_data);
 273
 274         g_dbus_send_message(connection, signal);
 275
 276         return TRUE;
 277 }
 278
 279 DBusConnection *near_dbus_get_connection(void)
 280 {
 281         return connection;
 282 }
 283
 284 int __near_dbus_init(DBusConnection *conn)
 285 {
 286         DBG("");
 287
 288         connection = conn;
 289
 290         return 0;
 291 }
 292
 293 void __near_dbus_cleanup(void)
 294 {
 295         DBG("");
 296
 297         connection = NULL;
 298 }