always try to detect parameters for session

Treat the parameters passed in via OpenSessionWithParameters
as overrides.

1 files changed, 117 insertions, 3 deletions

diff --git a/src/ck-session-leader.c b/src/ck-session-leader.c
index 48df0b8..b0faf89 100644
--- a/src/ck-session-leader.c
+++ b/src/ck-session-leader.c
@@ -58,6 +58,7 @@ struct CkSessionLeaderPrivate
         char       *cookie;
         GList      *pending_jobs;
         gboolean    cancelled;
+        GHashTable *override_parameters;
 };
 
 enum {
@@ -190,6 +191,33 @@ add_param_string (GPtrArray  *parameters,
         g_ptr_array_add (parameters, g_value_get_boxed (&param_val));
 }
 
+static gboolean
+maybe_add_override_parameter (CkSessionLeader *leader,
+                              const char      *prop_name,
+                              GPtrArray       *parameters)
+{
+        gpointer data;
+        gpointer data_copy;
+
+        if (leader->priv->override_parameters == NULL) {
+                return FALSE;
+        }
+
+        if (prop_name == NULL) {
+                return FALSE;
+        }
+
+        data = g_hash_table_lookup (leader->priv->override_parameters, prop_name);
+        if (data == NULL) {
+                return FALSE;
+        }
+
+        data_copy = g_boxed_copy (CK_TYPE_PARAMETER_STRUCT, data);
+        g_ptr_array_add (parameters, data_copy);
+
+        return TRUE;
+}
+
 typedef void (* CkAddParamFunc) (GPtrArray  *arr,
                                  const char *key,
                                  const char *value);
@@ -209,7 +237,8 @@ static struct {
 };
 
 static GPtrArray *
-parse_output (const char *output)
+parse_output (CkSessionLeader *leader,
+              const char      *output)
 {
         GPtrArray *parameters;
         char     **lines;
@@ -232,6 +261,11 @@ parse_output (const char *output)
                         continue;
                 }
 
+                if (maybe_add_override_parameter (leader, vals[0], parameters)) {
+                        g_strfreev (vals);
+                        continue;
+                }
+
                 for (j = 0; j < G_N_ELEMENTS (parse_ops); j++) {
                         if (strcmp (vals[0], parse_ops[j].key) == 0) {
                                 parse_ops[j].func (parameters, vals[0], vals[1]);
@@ -246,7 +280,6 @@ parse_output (const char *output)
         return parameters;
 }
 
-
 static void
 parameters_free (GPtrArray *parameters)
 {
@@ -263,6 +296,59 @@ parameters_free (GPtrArray *parameters)
         g_ptr_array_free (parameters, TRUE);
 }
 
+static void
+save_parameters (CkSessionLeader *leader,
+                 const GPtrArray *parameters)
+{
+        int i;
+
+        for (i = 0; i < parameters->len; i++) {
+                gpointer data;
+                data = g_ptr_array_index (parameters, i);
+
+                /* filter out the nulls? - sure why not */
+
+                if (data != NULL) {
+                        gpointer data_copy;
+                        GValue   val_struct = { 0, };
+                        char    *prop_name;
+                        gboolean res;
+
+                        g_value_init (&val_struct, CK_TYPE_PARAMETER_STRUCT);
+                        g_value_set_static_boxed (&val_struct, g_ptr_array_index (parameters, i));
+
+                        res = dbus_g_type_struct_get (&val_struct,
+                                                      0, &prop_name,
+                                                      G_MAXUINT);
+                        if (! res) {
+                                g_debug ("Unable to extract parameter input");
+                                g_free (prop_name);
+                                continue;
+                        }
+
+                        if (prop_name == NULL) {
+                                g_debug ("Skipping NULL parameter");
+                                g_free (prop_name);
+                                continue;
+                        }
+
+                        if (strcmp (prop_name, "id") == 0
+                            || strcmp (prop_name, "cookie") == 0) {
+                                g_debug ("Skipping restricted parameter: %s", prop_name);
+                                g_free (prop_name);
+                                continue;
+                        }
+
+                        data_copy = g_boxed_copy (CK_TYPE_PARAMETER_STRUCT, data);
+
+                        /* takes ownership */
+                        g_hash_table_insert (leader->priv->override_parameters,
+                                             prop_name,
+                                             data_copy);
+                }
+        }
+}
+
 typedef struct {
         CkSessionLeader        *leader;
         CkSessionLeaderDoneFunc done_cb;
@@ -284,7 +370,7 @@ job_completed (CkJob     *job,
                 ck_job_get_stdout (job, &output);
                 g_debug ("Job output: %s", output);
 
-                parameters = parse_output (output);
+                parameters = parse_output (data->leader, output);
                 g_free (output);
 
                 data->done_cb (data->leader,
@@ -448,6 +534,21 @@ ck_session_leader_set_service_name (CkSessionLeader       *session_leader,
         session_leader->priv->service_name = g_strdup (service_name);
 }
 
+void
+ck_session_leader_set_override_parameters (CkSessionLeader       *session_leader,
+                                           const GPtrArray       *parameters)
+{
+        g_return_if_fail (CK_IS_SESSION_LEADER (session_leader));
+
+        if (session_leader->priv->override_parameters != NULL) {
+                g_hash_table_remove_all (session_leader->priv->override_parameters);
+        }
+
+        if (parameters != NULL) {
+                save_parameters (session_leader, parameters);
+        }
+}
+
 static void
 ck_session_leader_set_property (GObject            *object,
                                 guint               prop_id,
@@ -513,9 +614,20 @@ ck_session_leader_class_init (CkSessionLeaderClass *klass)
 }
 
 static void
+parameter_free (gpointer data)
+{
+        g_boxed_free (CK_TYPE_PARAMETER_STRUCT, data);
+}
+
+static void
 ck_session_leader_init (CkSessionLeader *session_leader)
 {
         session_leader->priv = CK_SESSION_LEADER_GET_PRIVATE (session_leader);
+
+        session_leader->priv->override_parameters = g_hash_table_new_full (g_str_hash,
+                                                                           g_str_equal,
+                                                                           g_free,
+                                                                           (GDestroyNotify)parameter_free);
 }
 
 static void
@@ -537,6 +649,8 @@ ck_session_leader_finalize (GObject *object)
         g_free (session_leader->priv->service_name);
         session_leader->priv->service_name = NULL;
 
+        g_hash_table_destroy (session_leader->priv->override_parameters);
+
         G_OBJECT_CLASS (ck_session_leader_parent_class)->finalize (object);
 }