git.maemo.org Git - connman/blob - 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
  28 #include "connman.h"
  29
  30 char *connman_dbus_encode_string(const char *value)
  31 {
  32         GString *str;
  33         unsigned int i, size;
  34
  35         if (value == NULL)
  36                 return NULL;
  37
  38         size = strlen(value);
  39
  40         str = g_string_new(NULL);
  41         if (str == NULL)
  42                 return NULL;
  43
  44         for (i = 0; i < size; i++) {
  45                 const char tmp = value[i];
  46                 if ((tmp < '0' || tmp > '9') && (tmp < 'A' || tmp > 'Z') &&
  47                                                 (tmp < 'a' || tmp > 'z'))
  48                         g_string_append_printf(str, "_%02x", tmp);
  49                 else
  50                         str = g_string_append_c(str, tmp);
  51         }
  52
  53         return g_string_free(str, FALSE);
  54 }
  55
  56 void connman_dbus_property_append_variant(DBusMessageIter *iter,
  57                                         const char *key, int type, void *val)
  58 {
  59         DBusMessageIter value;
  60         const char *signature;
  61
  62         dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &key);
  63
  64         switch (type) {
  65         case DBUS_TYPE_BOOLEAN:
  66                 signature = DBUS_TYPE_BOOLEAN_AS_STRING;
  67                 break;
  68         case DBUS_TYPE_STRING:
  69                 signature = DBUS_TYPE_STRING_AS_STRING;
  70                 break;
  71         case DBUS_TYPE_BYTE:
  72                 signature = DBUS_TYPE_BYTE_AS_STRING;
  73                 break;
  74         case DBUS_TYPE_UINT16:
  75                 signature = DBUS_TYPE_UINT16_AS_STRING;
  76                 break;
  77         case DBUS_TYPE_INT16:
  78                 signature = DBUS_TYPE_INT16_AS_STRING;
  79                 break;
  80         case DBUS_TYPE_UINT32:
  81                 signature = DBUS_TYPE_UINT32_AS_STRING;
  82                 break;
  83         case DBUS_TYPE_INT32:
  84                 signature = DBUS_TYPE_INT32_AS_STRING;
  85                 break;
  86         case DBUS_TYPE_OBJECT_PATH:
  87                 signature = DBUS_TYPE_OBJECT_PATH_AS_STRING;
  88                 break;
  89         default:
  90                 signature = DBUS_TYPE_VARIANT_AS_STRING;
  91                 break;
  92         }
  93
  94         dbus_message_iter_open_container(iter, DBUS_TYPE_VARIANT,
  95                                                         signature, &value);
  96         dbus_message_iter_append_basic(&value, type, val);
  97         dbus_message_iter_close_container(iter, &value);
  98 }
  99
 100 void connman_dbus_dict_append_array(DBusMessageIter *dict,
 101                                 const char *key, int type, void *val, int len)
 102 {
 103         DBusMessageIter entry, value, array;
 104         const char *variant_sig, *array_sig;
 105
 106         switch (type) {
 107         case DBUS_TYPE_BYTE:
 108                 variant_sig = DBUS_TYPE_ARRAY_AS_STRING DBUS_TYPE_BYTE_AS_STRING;
 109                 array_sig = DBUS_TYPE_BYTE_AS_STRING;
 110                 break;
 111         default:
 112                 return;
 113         }
 114
 115         dbus_message_iter_open_container(dict, DBUS_TYPE_DICT_ENTRY,
 116                                                                 NULL, &entry);
 117
 118         dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &key);
 119
 120         dbus_message_iter_open_container(&entry, DBUS_TYPE_VARIANT,
 121                                                         variant_sig, &value);
 122
 123         dbus_message_iter_open_container(&value, DBUS_TYPE_ARRAY,
 124                                                         array_sig, &array);
 125         dbus_message_iter_append_fixed_array(&array, type, val, len);
 126         dbus_message_iter_close_container(&value, &array);
 127
 128         dbus_message_iter_close_container(&entry, &value);
 129
 130         dbus_message_iter_close_container(dict, &entry);
 131 }
 132
 133 void connman_dbus_dict_append_variant(DBusMessageIter *dict,
 134                                         const char *key, int type, void *val)
 135 {
 136         DBusMessageIter entry;
 137
 138         dbus_message_iter_open_container(dict, DBUS_TYPE_DICT_ENTRY,
 139                                                                 NULL, &entry);
 140
 141         connman_dbus_property_append_variant(&entry, key, type, val);
 142
 143         dbus_message_iter_close_container(dict, &entry);
 144 }
 145
 146 static DBusConnection *connection = NULL;
 147
 148 DBusConnection *connman_dbus_get_connection(void)
 149 {
 150         if (connection == NULL)
 151                 return NULL;
 152
 153         return dbus_connection_ref(connection);
 154 }
 155
 156 int __connman_dbus_init(DBusConnection *conn)
 157 {
 158         connection = conn;
 159
 160         return 0;
 161 }
 162
 163 void __connman_dbus_cleanup(void)
 164 {
 165         connection = NULL;
 166 }