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