src/lib/ukit/e_ukit_private_util.c

   1 #ifdef HAVE_CONFIG_H
   2 #include "config.h"
   3 #endif
   4
   5 #include <stdlib.h>
   6
   7 #include <E_Ukit.h>
   8 #include "e_ukit_private.h"
   9
  10 void *
  11 unmarshal_property(DBusMessage *msg, DBusError *err)
  12 {
  13    E_Ukit_Get_Property_Return *ret = NULL;
  14    DBusMessageIter iter, a_iter;
  15    int type;
  16    char *tmp;
  17
  18    if (!dbus_message_iter_init(msg, &iter)) return NULL; /* no params in message */
  19
  20    ret = calloc(1, sizeof(E_Ukit_Get_Property_Return));
  21    if (!ret)
  22      {
  23         dbus_set_error(err, DBUS_ERROR_NO_MEMORY, "");
  24         return NULL;
  25      }
  26
  27    dbus_message_iter_recurse(&iter, &a_iter);
  28    if (dbus_message_iter_get_arg_type(&a_iter) != DBUS_TYPE_INVALID)
  29      {
  30         type = dbus_message_iter_get_arg_type(&a_iter);
  31
  32         switch(type)
  33           {
  34              case DBUS_TYPE_STRING:
  35                ret->type = E_UKIT_PROPERTY_TYPE_STRING;
  36                dbus_message_iter_get_basic(&a_iter, &tmp);
  37                ret->val.s = eina_stringshare_add(tmp);
  38                break;
  39              case DBUS_TYPE_INT32:
  40                ret->type = E_UKIT_PROPERTY_TYPE_INT;
  41                dbus_message_iter_get_basic(&a_iter, &(ret->val.i));
  42                break;
  43              case DBUS_TYPE_UINT32:
  44                ret->type = E_UKIT_PROPERTY_TYPE_UINT32;
  45                dbus_message_iter_get_basic(&a_iter, &(ret->val.u));
  46                break;
  47              case DBUS_TYPE_UINT64:
  48                ret->type = E_UKIT_PROPERTY_TYPE_UINT64;
  49                dbus_message_iter_get_basic(&a_iter, &(ret->val.t));
  50                break;
  51              case DBUS_TYPE_INT64:
  52                ret->type = E_UKIT_PROPERTY_TYPE_INT64;
  53                dbus_message_iter_get_basic(&a_iter, &(ret->val.x));
  54                break;
  55              case DBUS_TYPE_BOOLEAN:
  56                ret->type = E_UKIT_PROPERTY_TYPE_BOOL;
  57                dbus_message_iter_get_basic(&a_iter, &(ret->val.b));
  58                break;
  59              case DBUS_TYPE_DOUBLE:
  60                ret->type = E_UKIT_PROPERTY_TYPE_DOUBLE;
  61                dbus_message_iter_get_basic(&a_iter, &(ret->val.d));
  62                break;
  63              case DBUS_TYPE_ARRAY:
  64                ret->type = E_UKIT_PROPERTY_TYPE_STRLIST;
  65                {
  66                   DBusMessageIter list_iter;
  67                   ret->val.strlist = NULL;
  68                   dbus_message_iter_recurse(&a_iter, &list_iter);
  69                   while (dbus_message_iter_get_arg_type(&list_iter) != DBUS_TYPE_INVALID)
  70                     {
  71                        char *str;
  72                        dbus_message_iter_get_basic(&list_iter, &str);
  73                        tmp = (char*)eina_stringshare_add(str);
  74                        ret->val.strlist = eina_list_append(ret->val.strlist, tmp);
  75                        dbus_message_iter_next(&list_iter);
  76                     }
  77                 }
  78                 break;
  79              default:
  80                break;
  81           }
  82      }
  83
  84    return ret;
  85 }
  86
  87 void
  88 free_property(void *data)
  89 {
  90    E_Ukit_Get_Property_Return *ret = data;
  91
  92    if (!ret) return;
  93    if (ret->type == E_UKIT_PROPERTY_TYPE_STRLIST)
  94      {
  95         const char *s;
  96         EINA_LIST_FREE(ret->val.strlist, s)
  97           eina_stringshare_del(s);
  98      }
  99    else if (ret->type == E_UKIT_PROPERTY_TYPE_STRING)
 100      eina_stringshare_del(ret->val.s);
 101    free(ret);
 102 }
 103
 104 void *
 105 unmarshal_device_get_all_properties(DBusMessage *msg, DBusError *err)
 106 {
 107    E_Ukit_Get_All_Properties_Return *ret = NULL;
 108    DBusMessageIter iter, a_iter, s_iter, v_iter;
 109    int type;
 110    char *tmp;
 111
 112    /* a{sv} = array of string+variants */
 113    if (!dbus_message_has_signature(msg, "a{sv}"))
 114      {
 115         dbus_set_error(err, DBUS_ERROR_INVALID_SIGNATURE, "");
 116         return NULL;
 117      }
 118
 119    ret = calloc(1, sizeof(E_Ukit_Get_All_Properties_Return));
 120    if (!ret)
 121      {
 122          dbus_set_error(err, DBUS_ERROR_NO_MEMORY, "");
 123          return NULL;
 124      }
 125
 126    ret->properties = eina_hash_string_small_new(EINA_FREE_CB(e_ukit_property_free));
 127
 128    dbus_message_iter_init(msg, &iter);
 129    dbus_message_iter_recurse(&iter, &a_iter);
 130    while (dbus_message_iter_get_arg_type(&a_iter) != DBUS_TYPE_INVALID)
 131    {
 132       const char *name;
 133       E_Ukit_Property *prop = calloc(1, sizeof(E_Ukit_Property));
 134       dbus_message_iter_recurse(&a_iter, &s_iter);
 135       dbus_message_iter_get_basic(&s_iter, &name);
 136       dbus_message_iter_next(&s_iter);
 137       dbus_message_iter_recurse(&s_iter, &v_iter);
 138
 139       type = dbus_message_iter_get_arg_type(&v_iter);
 140       switch(type)
 141         {
 142            case DBUS_TYPE_STRING:
 143              prop->type = E_UKIT_PROPERTY_TYPE_STRING;
 144              dbus_message_iter_get_basic(&v_iter, &tmp);
 145              prop->val.s = eina_stringshare_add(tmp);
 146              break;
 147            case DBUS_TYPE_INT32:
 148              prop->type = E_UKIT_PROPERTY_TYPE_INT;
 149              dbus_message_iter_get_basic(&v_iter, &(prop->val.i));
 150              break;
 151            case DBUS_TYPE_UINT32:
 152              prop->type = E_UKIT_PROPERTY_TYPE_UINT32;
 153              dbus_message_iter_get_basic(&v_iter, &(prop->val.u));
 154              break;
 155            case DBUS_TYPE_UINT64:
 156              prop->type = E_UKIT_PROPERTY_TYPE_UINT64;
 157              dbus_message_iter_get_basic(&v_iter, &(prop->val.t));
 158              break;
 159            case DBUS_TYPE_INT64:
 160              prop->type = E_UKIT_PROPERTY_TYPE_INT64;
 161              dbus_message_iter_get_basic(&v_iter, &(prop->val.x));
 162              break;
 163            case DBUS_TYPE_BOOLEAN:
 164              prop->type = E_UKIT_PROPERTY_TYPE_BOOL;
 165              dbus_message_iter_get_basic(&v_iter, &(prop->val.b));
 166              break;
 167            case DBUS_TYPE_DOUBLE:
 168              prop->type = E_UKIT_PROPERTY_TYPE_DOUBLE;
 169              dbus_message_iter_get_basic(&v_iter, &(prop->val.d));
 170              break;
 171            case DBUS_TYPE_ARRAY:
 172              prop->type = E_UKIT_PROPERTY_TYPE_STRLIST;
 173              {
 174                 DBusMessageIter list_iter;
 175                 prop->val.strlist = NULL;
 176                 dbus_message_iter_recurse(&v_iter, &list_iter);
 177                 while (dbus_message_iter_get_arg_type(&list_iter) != DBUS_TYPE_INVALID)
 178                 {
 179                    char *str;
 180                    dbus_message_iter_get_basic(&list_iter, &str);
 181                    tmp = (char*)eina_stringshare_add(str);
 182                    prop->val.strlist = eina_list_append(prop->val.strlist, tmp);
 183                    dbus_message_iter_next(&list_iter);
 184                 }
 185              }
 186              break;
 187            default:
 188              WARN("EUkit Error: unexpected property type (%s): %c", name, dbus_message_iter_get_arg_type(&v_iter));
 189              break;
 190         }
 191       eina_hash_add(ret->properties, name, prop);
 192
 193       dbus_message_iter_next(&a_iter);
 194    }
 195
 196    return ret;
 197 }
 198
 199 void
 200 free_device_get_all_properties(void *data)
 201 {
 202    E_Ukit_Get_All_Properties_Return *ret = data;
 203
 204    if (!ret) return;
 205    eina_hash_free(ret->properties);
 206    free(ret);
 207 }
 208
 209 void *
 210 unmarshal_string_list(DBusMessage *msg, DBusError *err)
 211 {
 212    E_Ukit_String_List_Return *ret = NULL;
 213    DBusMessageIter iter, sub;
 214    char *tmp;
 215
 216    /* ao = array of object strings */
 217    if (!dbus_message_has_signature(msg, "ao"))
 218      {
 219         dbus_set_error(err, DBUS_ERROR_INVALID_SIGNATURE, "");
 220         return NULL;
 221      }
 222
 223    ret = calloc(1, sizeof(E_Ukit_String_List_Return));
 224    if (!ret)
 225      {
 226         dbus_set_error(err, DBUS_ERROR_NO_MEMORY, "");
 227         return NULL;
 228      }
 229
 230    ret->strings = NULL;
 231
 232    dbus_message_iter_init(msg, &iter);
 233    dbus_message_iter_recurse(&iter, &sub);
 234    while (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_INVALID)
 235      {
 236         char *dev = NULL;
 237
 238         dbus_message_iter_get_basic(&sub, &dev);
 239         tmp = (char*)eina_stringshare_add(dev);
 240         if (dev) ret->strings = eina_list_append(ret->strings, tmp);
 241         dbus_message_iter_next(&sub);
 242      }
 243
 244    return ret;
 245 }
 246
 247 void
 248 free_string_list(void *data)
 249 {
 250    E_Ukit_String_List_Return *ret = data;
 251    const char *x;
 252
 253    if (!ret) return;
 254    EINA_LIST_FREE(ret->strings, x)
 255      eina_stringshare_del(x);
 256    free(ret);
 257 }