e_nms_connection_get_settings()

git-svn-id: svn+ssh://svn.enlightenment.org/var/svn/e/trunk/e_dbus@37642 7cbeb6ba-43b4-40fd-8cce-4c39aea84d33

diff --git a/src/bin/nm.c b/src/bin/nm.c
index cc44986..e3c5ff5 100644 (file)
--- a/src/bin/nm.c
+++ b/src/bin/nm.c
@@ -4,6 +4,70 @@
 E_NM *nm = NULL;
 E_NMS *nms = NULL;
 
+static void
+dump_prop(E_NM_Property *prop)
+{
+    if (!prop) return;
+    switch (prop->type)
+    {
+        case 'a': {
+          E_NM_Property *subprop;
+
+          printf("\n   - ");
+          ecore_list_first_goto(prop->a);
+          while ((subprop = ecore_list_next(prop->a)))
+              dump_prop(subprop);
+          break;
+        }
+        case 's':
+        case 'o':
+            printf("%s ", prop->s);
+            break;
+        case 'u':
+            printf("%d ", prop->u);
+            break;
+        case 'b':
+            printf("%d ", prop->b);
+            break;
+        case 'y':
+            printf("%d ", prop->y);
+            break;
+        case 't':
+            printf("%lld ", prop->t);
+            break;
+    }
+}
+
+static void
+dump_values(void *value, void *data)
+{
+    Ecore_Hash_Node *node;
+
+    node = value;
+    printf(" - name: %s - ", (char *)node->key);
+    dump_prop(node->value);
+    printf("\n");
+}
+ 
+static void
+dump_settings(void *value, void *data)
+{
+    Ecore_Hash_Node *node;
+
+    node = value;
+    printf("name: %s\n", (char *)node->key);
+    printf("values:\n");
+    ecore_hash_for_each_node(node->value, dump_values, NULL);
+    printf("\n");
+}
+
+static int
+cb_nms_connection_settings(void *data, Ecore_Hash *settings)
+{
+    ecore_hash_for_each_node(settings, dump_settings, NULL);
+    return 1;
+}
+
 static int
 cb_nms_connections(void *data, Ecore_List *list)
 {
@@ -13,7 +77,10 @@ cb_nms_connections(void *data, Ecore_List *list)
     {
         ecore_list_first_goto(list);
         while ((conn = ecore_list_next(list)))
+        {
             e_nms_connection_dump(conn);
+            e_nms_connection_get_settings(conn, cb_nms_connection_settings, NULL);
+        }
         ecore_list_destroy(list);
     }
     //ecore_main_loop_quit();
@@ -56,10 +123,10 @@ cb_get_devices(void *data, Ecore_List *list)
         {
             e_nm_device_dump(device);
             if (device->device_type == E_NM_DEVICE_TYPE_WIRELESS)
-           {
+            {
                 e_nm_access_point_get(nm, device->wireless.active_access_point, cb_access_point, NULL);
                 e_nm_ip4_config_get(nm, device->ip4_config, cb_ip4_config, NULL);
-           }
+            }
         }
         ecore_list_destroy(list);
     }
@@ -84,19 +151,23 @@ cb_nms(void *data, E_NMS *reply)
 static int
 cb_nm(void *data, E_NM *reply)
 {
-    const char *conn;
-
     if (!reply)
     {
         ecore_main_loop_quit();
         return 1;
     }
     nm = reply;
+    /*
     e_nm_dump(nm);
-    ecore_list_first_goto(nm->active_connections);
-    while ((conn = ecore_list_next(nm->active_connections)))
-        e_nm_active_connection_get(nm, conn, cb_active_connection, NULL);
+    if (nm->active_connections)
+    {
+        const char *conn;
+        ecore_list_first_goto(nm->active_connections);
+        while ((conn = ecore_list_next(nm->active_connections)))
+            e_nm_active_connection_get(nm, conn, cb_active_connection, NULL);
+    }
     e_nm_get_devices(nm, cb_get_devices, nm);
+    */
     e_nms_get(nm, cb_nms, nm);
     return 1;
 }

diff --git a/src/lib/nm/E_Nm.h b/src/lib/nm/E_Nm.h
index 384a3f1..fbbfac8 100644 (file)
--- a/src/lib/nm/E_Nm.h
+++ b/src/lib/nm/E_Nm.h
@@ -185,10 +185,10 @@ struct E_NM_Access_Point
   E_NM_802_11_Ap_Sec    wpa_flags;
   E_NM_802_11_Ap_Sec    rsn_flags;
   Ecore_List           *ssid; /* unsigned char */
-  uint                  frequency;
+  unsigned int          frequency;
   char                 *hw_address;
   E_NM_802_11_Mode      mode;
-  uint                  max_bitrate;
+  unsigned int          max_bitrate;
   unsigned char         strength;
 };
 
@@ -208,14 +208,14 @@ struct E_NM_Device
   union
   {
     struct {
-      char *hw_address;
-      uint  speed;
-      int   carrier;
+      char         *hw_address;
+      unsigned int  speed;
+      int           carrier;
     } wired;
     struct {
       char                   *hw_address;
       E_NM_802_11_Mode        mode;
-      uint                    bitrate;
+      unsigned int            bitrate;
       char                   *active_access_point; /* object_path */
       E_NM_802_11_Device_Cap  wireless_capabilities;
     } wireless;
@@ -228,10 +228,10 @@ struct E_NM_Device
 typedef struct E_NM_IP4_Config E_NM_IP4_Config;
 struct E_NM_IP4_Config
 {
-  Ecore_List *addresses;  /* list uint */
-  Ecore_List *nameservers;/* uint */
+  Ecore_List *addresses;  /* list unsigned int */
+  Ecore_List *nameservers;/* unsigned int */
   Ecore_List *domains;    /* char* */
-  Ecore_List *routes;     /* list uint */
+  Ecore_List *routes;     /* list unsigned int */
 };
 
 /* TODO typedef struct E_NM_DHCP4_Config E_NM_DHCP4_Config; */
@@ -256,6 +256,21 @@ struct E_NM_Active_Connection
 /* TODO typedef struct E_NM_VPN_Connection E_NM_VPN_Connection */
 /* TODO typedef struct E_NM_VPN_Plugin E_NM_VPN_Plugin */
 
+typedef struct E_NM_Property E_NM_Property;
+struct E_NM_Property
+{
+  union
+  {
+    unsigned char       y;
+    unsigned int        u;
+    char               *s;
+    unsigned long long  t;
+    int                 b;
+    Ecore_List         *a;
+  };
+  char type;
+};
+
 #ifdef __cplusplus
 extern "C" {
 #endif
@@ -331,7 +346,7 @@ extern "C" {
 
    /* TODO: e_nms_connection_update */
    /* TODO: e_nms_connection_delete */
-   /* TODO: e_nms_connection_get_settings */
+   EAPI int  e_nms_connection_get_settings(E_NMS_Connection *conn, int (*cb_func)(void *data, Ecore_Hash *settings), void *data);
    /* TODO: e_nms_connection_secrets_get_secrets */
 
    /* TODO: e_nms_connection_callback_updated_set */

diff --git a/src/lib/nm/e_nm.c b/src/lib/nm/e_nm.c
index 7125f72..59ffb3f 100644 (file)
--- a/src/lib/nm/e_nm.c
+++ b/src/lib/nm/e_nm.c
@@ -15,8 +15,8 @@ static void
 cb_state_changed(void *data, DBusMessage *msg)
 {
   E_NM_Internal *nmi;
-  dbus_uint32_t state;
-  DBusError err;
+  unsigned int   state;
+  DBusError      err;
   if (!msg || !data) return;
 
   nmi = data;
@@ -151,9 +151,12 @@ e_nm_dump(E_NM *nm)
   printf("wireless_enabled         : %d\n", nm->wireless_enabled);
   printf("wireless_hardware_enabled: %d\n", nm->wireless_hardware_enabled);
   printf("active_connections       :\n");
-  ecore_list_first_goto(nm->active_connections);
-  while ((conn = ecore_list_next(nm->active_connections)))
-    printf(" - %s\n", conn);
+  if (nm->active_connections)
+  {
+    ecore_list_first_goto(nm->active_connections);
+    while ((conn = ecore_list_next(nm->active_connections)))
+      printf(" - %s\n", conn);
+  }
   printf("state                    : ");
   switch (nm->state)
   {

diff --git a/src/lib/nm/e_nm_access_point.c b/src/lib/nm/e_nm_access_point.c
index b518f42..bb19213 100644 (file)
--- a/src/lib/nm/e_nm_access_point.c
+++ b/src/lib/nm/e_nm_access_point.c
@@ -38,6 +38,8 @@ e_nm_access_point_get(E_NM *nm, const char *access_point,
   E_NM_Access_Point_Internal *ap;
   Property_Data     *d;
 
+  if (!access_point) return 0;
+
   nmi = (E_NM_Internal *)nm;
   ap = calloc(1, sizeof(E_NM_Access_Point_Internal));
   ap->nmi = nmi;
@@ -137,10 +139,13 @@ e_nm_access_point_dump(E_NM_Access_Point *ap)
     printf(" E_NM_802_11_AP_SEC_NONE");
   printf("\n");
   printf("ssid       : ");
-  ecore_list_first_goto(ap->ssid);
-  while ((c = ecore_list_next(ap->ssid)))
-    printf("%u", *c);
-  printf("\n");
+  if (ap->ssid)
+  {
+    ecore_list_first_goto(ap->ssid);
+    while ((c = ecore_list_next(ap->ssid)))
+      printf("%u", *c);
+    printf("\n");
+  }
   printf("frequency  : %u\n", ap->frequency);
   printf("hw_address : %s\n", ap->hw_address);
   printf("mode       : ");

diff --git a/src/lib/nm/e_nm_device.c b/src/lib/nm/e_nm_device.c
index 53feaa4..e5f5734 100644 (file)
--- a/src/lib/nm/e_nm_device.c
+++ b/src/lib/nm/e_nm_device.c
@@ -44,7 +44,7 @@ static void
 cb_state_changed(void *data, DBusMessage *msg)
 {
   E_NM_Device_Internal *dev;
-  dbus_uint32_t new_state, old_state, reason;
+  unsigned int new_state, old_state, reason;
   DBusError err;
   if (!msg || !data) return;
 

diff --git a/src/lib/nm/e_nm_ip4_config.c b/src/lib/nm/e_nm_ip4_config.c
index dbca2c2..098cac3 100644 (file)
--- a/src/lib/nm/e_nm_ip4_config.c
+++ b/src/lib/nm/e_nm_ip4_config.c
@@ -20,6 +20,8 @@ e_nm_ip4_config_get(E_NM *nm, const char *ip4_config,
   E_NM_IP4_Config_Internal *config;
   Property_Data            *d;
 
+  if (!ip4_config) return 0;
+
   nmi = (E_NM_Internal *)nm;
   config = calloc(1, sizeof(E_NM_IP4_Config_Internal));
   config->nmi = nmi;
@@ -48,9 +50,9 @@ e_nm_ip4_config_free(E_NM_IP4_Config *config)
 EAPI void
 e_nm_ip4_config_dump(E_NM_IP4_Config *config)
 {
-  uint       *u;
-  const char *domain;
-  Ecore_List *list;
+  unsigned int *u;
+  const char   *domain;
+  Ecore_List   *list;
 
   if (!config) return;
   printf("E_NM_IP4_Config:\n");

diff --git a/src/lib/nm/e_nm_private.h b/src/lib/nm/e_nm_private.h
index b26bc95..60a321c 100644 (file)
--- a/src/lib/nm/e_nm_private.h
+++ b/src/lib/nm/e_nm_private.h
@@ -18,6 +18,7 @@
 
 #define e_nm_call_new(member) dbus_message_new_method_call(_E_NM_SERVICE, E_NM_PATH, _E_NM_INTERFACE, member)
 #define e_nms_call_new(service, member) dbus_message_new_method_call(service, _E_NMS_PATH, _E_NMS_INTERFACE, member)
+#define e_nms_connection_call_new(service, conn, member) dbus_message_new_method_call(service, conn, _E_NMS_INTERFACE_CONNECTION, member)
 
 #define e_nm_properties_get(con, prop, cb, data) e_dbus_properties_get(con, _E_NM_SERVICE, E_NM_PATH, _E_NM_INTERFACE, prop, (E_DBus_Method_Return_Cb) cb, data)
 #define e_nm_access_point_properties_get(con, dev, prop, cb, data) e_dbus_properties_get(con, _E_NM_SERVICE, dev, _E_NM_INTERFACE_ACCESSPOINT, prop, (E_DBus_Method_Return_Cb) cb, data)
@@ -152,6 +153,8 @@ void  parse_properties(void *data, Property *properties, DBusMessage *msg);
 
 void *cb_nm_object_path_list(DBusMessage *msg, DBusError *err);
 void  free_nm_object_path_list(void *data);
+void *cb_nm_settings(DBusMessage *msg, DBusError *err);
+void  free_nm_settings(void *data);
 
 int   check_arg_type(DBusMessageIter *iter, char type);
 

diff --git a/src/lib/nm/e_nm_util.c b/src/lib/nm/e_nm_util.c
index b6e2c75..e126789 100644 (file)
--- a/src/lib/nm/e_nm_util.c
+++ b/src/lib/nm/e_nm_util.c
@@ -17,18 +17,13 @@
     return NULL;                                             \
   }
 
-static void property_string(DBusMessageIter *iter, void *value);
-static void property_object_path(DBusMessageIter *iter, void *value);
-static void property_uint32(DBusMessageIter *iter, void *value);
-static void property_bool(DBusMessageIter *iter, void *value);
-static void property_uchar(DBusMessageIter *iter, void *value);
-static void property_string_list(DBusMessageIter *iter, void *value);
-static void property_object_path_list(DBusMessageIter *iter, void *value);
-static void property_uchar_list(DBusMessageIter *iter, void *value);
-static void property_uint_list(DBusMessageIter *iter, void *value);
-static void property_uint_list_list(DBusMessageIter *iter, void *value);
-
-typedef void (*Property_Cb)(DBusMessageIter *iter, void *value);
+static E_NM_Property *property_string(DBusMessageIter *iter, const char *sig, void *value);
+static E_NM_Property *property_basic(DBusMessageIter *iter, const char *sig, void *value);
+static E_NM_Property *property_variant(DBusMessageIter *iter, const char *sig, void *value);
+static E_NM_Property *property_array(DBusMessageIter *iter, const char *sig, void *value);
+static void           property_free(E_NM_Property *prop);
+
+typedef E_NM_Property *(*Property_Cb)(DBusMessageIter *iter, const char *sig, void *value);
 
 typedef struct Sig_Property Sig_Property;
 struct Sig_Property
@@ -39,15 +34,18 @@ struct Sig_Property
 
 static Sig_Property sigs[] = {
   { .sig = "s", property_string },
-  { .sig = "o", property_object_path },
-  { .sig = "u", property_uint32 },
-  { .sig = "b", property_bool },
-  { .sig = "y", property_uchar },
-  { .sig = "as", property_string_list },
-  { .sig = "ao", property_object_path_list },
-  { .sig = "ay", property_uchar_list },
-  { .sig = "au", property_uint_list },
-  { .sig = "aau", property_uint_list_list },
+  { .sig = "o", property_string },
+  { .sig = "u", property_basic },
+  { .sig = "b", property_basic },
+  { .sig = "y", property_basic },
+  { .sig = "t", property_basic },
+  { .sig = "v", property_variant },
+  { .sig = "a", property_array },
+  { .sig = "as", property_array },
+  { .sig = "ao", property_array },
+  { .sig = "ay", property_array },
+  { .sig = "au", property_array },
+  { .sig = "aau", property_array },
   { .sig = NULL }
 };
 
@@ -82,186 +80,154 @@ find_property(const char *name, Property *properties)
   return NULL;
 }
 
-static void
-property_string(DBusMessageIter *iter, void *value)
+static E_NM_Property *
+property_string(DBusMessageIter *iter, const char *sig, void *value)
 {
-  const char *str;
-
-  if (!check_arg_type(iter, 's')) return;
+  const char    *str;
+  E_NM_Property *prop = NULL;
 
+  if ((value) && (!sig))
+  {
+    printf("Error: Can't have value and no sig\n");
+    return NULL;
+  }
   dbus_message_iter_get_basic(iter, &str);
+  if (sig)
+  {
+    if (!check_arg_type(iter, sig[0])) return NULL;
+    if (!value) value = ∝
+  }
+  else
+  {
+    prop = malloc(sizeof(E_NM_Property));
+    prop->type = dbus_message_iter_get_arg_type(iter);
+    value = &prop->s;
+  }
   *((char **)value) = strdup(str);
-}
-
-static void
-property_object_path(DBusMessageIter *iter, void *value)
-{
-  const char *str;
-
-  if (!check_arg_type(iter, 'o')) return;
 
-  dbus_message_iter_get_basic(iter, &str);
-  *((char **)value) = strdup(str);
+  return prop;
 }
 
-static void
-property_uint32(DBusMessageIter *iter, void *value)
+static E_NM_Property *
+property_basic(DBusMessageIter *iter, const char *sig, void *value)
 {
-  if (!check_arg_type(iter, 'u')) return;
+  E_NM_Property *prop = NULL;
 
+  if ((value) && (!sig))
+  {
+    printf("Error: Can't have value and no sig\n");
+    return NULL;
+  }
+  if (sig)
+  {
+    if (!check_arg_type(iter, sig[0])) return NULL;
+    if (!value)
+    {
+      // TODO: Only alloc right size
+      prop = malloc(sizeof(long long));
+      value = prop;
+    }
+  }
+  else
+  {
+    prop = malloc(sizeof(E_NM_Property));
+    prop->type = dbus_message_iter_get_arg_type(iter);
+    value = prop;
+  }
   dbus_message_iter_get_basic(iter, value);
-}
 
-static void
-property_bool(DBusMessageIter *iter, void *value)
-{
-  if (!check_arg_type(iter, 'b')) return;
-
-  dbus_message_iter_get_basic(iter, value);
+  return prop;
 }
 
-static void
-property_uchar(DBusMessageIter *iter, void *value)
+static E_NM_Property *
+property_variant(DBusMessageIter *iter, const char *sig, void *value)
 {
-  if (!check_arg_type(iter, 'y')) return;
-
-  dbus_message_iter_get_basic(iter, value);
+  DBusMessageIter v_iter;
+  Property_Cb     func;
+  char            tmp[2];
+
+  if (!check_arg_type(iter, 'v')) return NULL;
+  dbus_message_iter_recurse(iter, &v_iter);
+  tmp[0] = dbus_message_iter_get_arg_type(&v_iter);
+  tmp[1] = 0;
+  func = find_property_cb(tmp);
+  if (!func) return NULL;
+  return (*func)(&v_iter, NULL, NULL);
 }
 
-static void
-property_string_list(DBusMessageIter *iter, void *value)
+static E_NM_Property *
+property_array(DBusMessageIter *iter, const char *sig, void *value)
 {
-  DBusMessageIter a_iter;
-  Ecore_List **list;
+  DBusMessageIter   a_iter;
+  Ecore_List      **list;
+  Property_Cb       func;
+  E_NM_Property    *prop = NULL;
+  const char       *subsig = NULL;
 
-  if (!check_arg_type(iter, 'a')) return;
-  dbus_message_iter_recurse(iter, &a_iter);
-  if (!check_arg_type(&a_iter, 's')) return;
-
-  list = (Ecore_List **)value;
-  *list = ecore_list_new();
-  ecore_list_free_cb_set(*list, free);
-  while (dbus_message_iter_get_arg_type(&a_iter) != DBUS_TYPE_INVALID)
+  if ((value) && (!sig))
   {
-    const char *str;
-
-    dbus_message_iter_get_basic(&a_iter, &str);
-    if (str) ecore_list_append(*list, strdup(str));
-    dbus_message_iter_next(&a_iter);
+    printf("Error: Can't have value and no sig\n");
+    return NULL;
   }
-}
-
-static void
-property_object_path_list(DBusMessageIter *iter, void *value)
-{
-  DBusMessageIter a_iter;
-  Ecore_List **list;
 
-  if (!check_arg_type(iter, 'a')) return;
   dbus_message_iter_recurse(iter, &a_iter);
-  if (!check_arg_type(&a_iter, 'o')) return;
-
-  list = (Ecore_List **)value;
-  *list = ecore_list_new();
-  ecore_list_free_cb_set(*list, free);
-  while (dbus_message_iter_get_arg_type(&a_iter) != DBUS_TYPE_INVALID)
+  if (sig)
   {
-    const char *str;
 
-    dbus_message_iter_get_basic(&a_iter, &str);
-    if (str) ecore_list_append(*list, strdup(str));
-    dbus_message_iter_next(&a_iter);
+    if (!check_arg_type(iter, sig[0])) return NULL;
+    subsig = (sig + 1);
+    func = find_property_cb(subsig);
+    if (!func) return NULL;
+    if (!value) value = ∝
+    list = (Ecore_List **)value;
+    *list = ecore_list_new();
+    if (subsig[0] == 'a') 
+      ecore_list_free_cb_set(*list, ECORE_FREE_CB(ecore_list_destroy));
+    else
+      ecore_list_free_cb_set(*list, free);
   }
-}
-
-static void
-property_uchar_list(DBusMessageIter *iter, void *value)
-{
-  DBusMessageIter a_iter;
-  Ecore_List **list;
-
-  if (!check_arg_type(iter, 'a')) return;
-  dbus_message_iter_recurse(iter, &a_iter);
-  if (!check_arg_type(&a_iter, 'y')) return;
-
-  list = (Ecore_List **)value;
-  *list = ecore_list_new();
-  ecore_list_free_cb_set(*list, free);
-  while (dbus_message_iter_get_arg_type(&a_iter) != DBUS_TYPE_INVALID)
+  else
   {
-    unsigned char *c;
-
-    c = malloc(sizeof(unsigned char));
-    dbus_message_iter_get_basic(&a_iter, c);
-    if (c) ecore_list_append(*list, c);
-    dbus_message_iter_next(&a_iter);
+    char tmp[] = { dbus_message_iter_get_arg_type(&a_iter), 0 };
+    func = find_property_cb(tmp);
+    if (!func) return NULL;
+    prop = malloc(sizeof(E_NM_Property));
+    prop->type = dbus_message_iter_get_arg_type(iter);
+    list = (Ecore_List **)&prop->a;
+    *list = ecore_list_new();
+    ecore_list_free_cb_set(*list, ECORE_FREE_CB(property_free));
   }
-}
-
-static void
-property_uint_list(DBusMessageIter *iter, void *value)
-{
-  DBusMessageIter a_iter;
-  Ecore_List **list;
-
-  if (!check_arg_type(iter, 'a')) return;
-  dbus_message_iter_recurse(iter, &a_iter);
-  if (!check_arg_type(&a_iter, 'u')) return;
 
-  list = (Ecore_List **)value;
-  *list = ecore_list_new();
-  ecore_list_free_cb_set(*list, free);
   while (dbus_message_iter_get_arg_type(&a_iter) != DBUS_TYPE_INVALID)
   {
-    unsigned int *c;
+    void *subprop;
 
-    c = malloc(sizeof(unsigned int));
-    dbus_message_iter_get_basic(&a_iter, c);
-    if (c) ecore_list_append(*list, c);
+    subprop = (*func)(&a_iter, subsig, NULL);
+    if (subprop) ecore_list_append(*list, subprop);
     dbus_message_iter_next(&a_iter);
   }
+
+  return prop;
 }
 
 static void
-property_uint_list_list(DBusMessageIter *iter, void *value)
+property_free(E_NM_Property *prop)
 {
-  DBusMessageIter a_iter, a2_iter;
-  Ecore_List **list, *list2;
-
-  if (!check_arg_type(iter, 'a')) return;
-  dbus_message_iter_recurse(iter, &a_iter);
-  if (!check_arg_type(&a_iter, 'a')) return;
-
-  list = (Ecore_List **)value;
-  *list = ecore_list_new();
-  ecore_list_free_cb_set(*list, ECORE_FREE_CB(ecore_list_destroy));
-  while (dbus_message_iter_get_arg_type(&a_iter) != DBUS_TYPE_INVALID)
-  {
-    dbus_message_iter_recurse(&a_iter, &a2_iter);
-    if (!check_arg_type(&a2_iter, 'u')) return;
-    list2 = ecore_list_new();
-    ecore_list_free_cb_set(list2, free);
-    ecore_list_append(*list, list2);
-    while (dbus_message_iter_get_arg_type(&a2_iter) != DBUS_TYPE_INVALID)
-    {
-      unsigned int *c;
-
-      c = malloc(sizeof(unsigned int));
-      dbus_message_iter_get_basic(&a2_iter, c);
-      if (c) ecore_list_append(list2, c);
-      dbus_message_iter_next(&a2_iter);
-    }
-    dbus_message_iter_next(&a_iter);
-  }
+  if (!prop) return;
+  if ((prop->type == 's') || (prop->type == 'o'))
+    free(prop->s);
+  else if (prop->type == 'a')
+    ecore_list_destroy(prop->a);
+  free(prop);
 }
 
 void
 property(void *data, DBusMessage *msg, DBusError *err)
 {
-  DBusMessageIter iter, v_iter;
-  Property_Data *d;
-  void *value;
-  void (*func)(DBusMessageIter *iter, void *value) = NULL;
+  DBusMessageIter  iter, v_iter;
+  Property_Data   *d;
+  void            *value;
+  Property_Cb      func = NULL;
 
   d = data;
   if (dbus_error_is_set(err))
@@ -280,7 +246,7 @@ property(void *data, DBusMessage *msg, DBusError *err)
 
   value = ((char *)d->reply + d->property->offset);
   func = find_property_cb(d->property->sig);
-  if (func) (*func)(&v_iter, value);
+  if (func) (*func)(&v_iter, d->property->sig, value);
 
   d->property++;
   if (d->property->name)
@@ -317,9 +283,11 @@ parse_properties(void *data, Property *properties, DBusMessage *msg)
     void *value;
 
     dbus_message_iter_recurse(&a_iter, &d_iter);
+    if (!check_arg_type(&d_iter, 's')) return;
     dbus_message_iter_get_basic(&d_iter, &name);
 
     dbus_message_iter_next(&d_iter);
+    if (!check_arg_type(&d_iter, 'v')) return;
     dbus_message_iter_recurse(&d_iter, &v_iter);
 
     p = find_property(name, properties);
@@ -327,7 +295,7 @@ parse_properties(void *data, Property *properties, DBusMessage *msg)
     value = ((char *)data + p->offset);
     func = find_property_cb(p->sig);
     if (!func) goto next;
-    func(&v_iter, value);
+    func(&v_iter, p->sig, value);
 
 next:
     dbus_message_iter_next(&a_iter);
@@ -455,12 +423,16 @@ cb_nm_object_path_list(DBusMessage *msg, DBusError *err)
   {
     char *dev = NULL;
 
+    if (!check_arg_type(&sub, 'o')) goto error;
     dbus_message_iter_get_basic(&sub, &dev);
     if (dev) ecore_list_append(devices, dev);
     dbus_message_iter_next(&sub);
   }
 
   return devices;
+error:
+  ecore_list_destroy(devices);
+  return NULL;
 }
 
 void
@@ -471,6 +443,68 @@ free_nm_object_path_list(void *data)
   if (list) ecore_list_destroy(list);
 }
 
+void *
+cb_nm_settings(DBusMessage *msg, DBusError *err)
+{
+  Ecore_Hash *settings;
+  DBusMessageIter iter, a_iter;
+
+  CHECK_SIGNATURE(msg, err, "a{sa{sv}}");
+
+  dbus_message_iter_init(msg, &iter);
+
+  settings = ecore_hash_new(ecore_str_hash, ecore_str_compare);
+  ecore_hash_free_key_cb_set(settings, free);
+  ecore_hash_free_value_cb_set(settings, ECORE_FREE_CB(ecore_hash_destroy));
+  dbus_message_iter_recurse(&iter, &a_iter);
+  while (dbus_message_iter_get_arg_type(&a_iter) != DBUS_TYPE_INVALID)
+  {
+    DBusMessageIter  d_iter, a2_iter;
+    E_NM_Property   *prop;
+    const char      *name;
+    Ecore_Hash      *value;
+
+    dbus_message_iter_recurse(&a_iter, &d_iter);
+    if (!check_arg_type(&d_iter, 's')) goto error;
+    dbus_message_iter_get_basic(&d_iter, &name);
+
+    dbus_message_iter_next(&d_iter);
+    if (!check_arg_type(&d_iter, 'a')) goto error;
+    dbus_message_iter_recurse(&d_iter, &a2_iter);
+
+    value = ecore_hash_new(ecore_str_hash, ecore_str_compare);
+    ecore_hash_free_key_cb_set(value, free);
+    ecore_hash_free_value_cb_set(value, ECORE_FREE_CB(property_free));
+    ecore_hash_set(settings, strdup(name), value);
+    while (dbus_message_iter_get_arg_type(&a2_iter) != DBUS_TYPE_INVALID)
+    {
+      dbus_message_iter_recurse(&a2_iter, &d_iter);
+      if (!check_arg_type(&d_iter, 's')) goto error;
+      dbus_message_iter_get_basic(&d_iter, &name);
+      dbus_message_iter_next(&d_iter);
+      if (!check_arg_type(&d_iter, 'v')) goto error;
+      prop = property_variant(&d_iter, NULL, NULL);
+      if (prop) ecore_hash_set(value, strdup(name), prop);
+      dbus_message_iter_next(&a2_iter);
+    }
+
+    dbus_message_iter_next(&a_iter);
+  }
+
+  return settings;
+error:
+  ecore_hash_destroy(settings);
+  return NULL;
+}
+
+void
+free_nm_settings(void *data)
+{
+  Ecore_Hash *hash = data;
+
+  if (hash) ecore_hash_destroy(hash);
+}
+
 int
 check_arg_type(DBusMessageIter *iter, char type)
 {

diff --git a/src/lib/nm/e_nms_connection.c b/src/lib/nm/e_nms_connection.c
index e5c3f23..5a8a88d 100644 (file)
--- a/src/lib/nm/e_nms_connection.c
+++ b/src/lib/nm/e_nms_connection.c
@@ -3,12 +3,33 @@
 
 #include <string.h>
 
+static void
+cb_nms_settings(void *data, void *reply, DBusError *err)
+{
+  Reply_Data  *d;
+
+  d = data;
+  if (dbus_error_is_set(err))
+  {
+    printf("Error: %s - %s\n", err->name, err->message);
+    d->cb_func(d->data, NULL);
+    free(d);
+    return;
+  }
+
+  d->cb_func(d->data, reply);
+  free(d);
+}
+
 EAPI int
 e_nms_connection_get(E_NMS *nms, E_NMS_Context context, const char *connection, int (*cb_func)(void *data, E_NMS_Connection *conn), void *data)
 {
+  E_NMS_Internal            *nmsi;
   E_NMS_Connection_Internal *conn;
 
+  nmsi = (E_NMS_Internal *)nms;
   conn = calloc(1, sizeof(E_NMS_Connection_Internal));
+  conn->nmi = nmsi->nmi;
   conn->path = strdup(connection);
   conn->context = context;
   (*cb_func)(data, (E_NMS_Connection *)conn);
@@ -48,3 +69,33 @@ e_nms_connection_dump(E_NMS_Connection *connection)
   printf("\n");
 }
 
+EAPI int
+e_nms_connection_get_settings(E_NMS_Connection *connection, int (*cb_func)(void *data, Ecore_Hash *settings), void *data)
+{
+  DBusMessage *msg;
+  Reply_Data   *d;
+  E_NMS_Connection_Internal *conn;
+  int ret;
+
+  conn = (E_NMS_Connection_Internal *)connection;
+  d = calloc(1, sizeof(Reply_Data));
+  d->object = conn;
+  d->cb_func = OBJECT_CB(cb_func);
+  d->data = data;
+
+  switch (conn->context)
+  {
+    case E_NMS_CONTEXT_USER:
+      msg = e_nms_connection_call_new(E_NMS_SERVICE_USER, conn->path, "GetSettings");
+      break;
+    case E_NMS_CONTEXT_SYSTEM:
+    default:
+      msg = e_nms_connection_call_new(E_NMS_SERVICE_SYSTEM, conn->path, "GetSettings");
+      break;
+  }
+
+  ret = e_dbus_method_call_send(conn->nmi->conn, msg, cb_nm_settings, cb_nms_settings, free_nm_settings, -1, d) ? 1 : 0;
+  dbus_message_unref(msg);
+  return ret;
+}
+