plugin-responder communication is finished through dhash table conversion- Need to format the reply message

7 files changed, 483 insertions, 637 deletions

diff --git a/Makefile.am b/Makefile.am
index 788a1a59..565ae2b4 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -353,6 +353,7 @@ libsss_util_la_SOURCES = \
     src/sbus/sssd_dbus_common.c \
     src/sbus/sssd_dbus_connection.c \
     src/sbus/sssd_dbus_server.c \
+    src/sbus/sssd_dbus_messages_helpers.c \
     src/util/util.c \
     src/util/memory.c \
     src/util/server.c \
@@ -406,9 +407,11 @@ sssd_sudo_SOURCES = \
 sssd_sudo_LDADD = \
     $(TDB_LIBS) \
     $(SSSD_LIBS) \
-    libsss_util.la
+    libsss_util.la \
+    $(DBUS_LIBS) \
+    $(DHASH_LIBS)
 sssd_sudo_LDFLAGS = \
-	-g
+    -g
 
 sssd_be_SOURCES = \
     src/providers/data_provider_be.c \
@@ -781,15 +784,15 @@ libsss_sudoplugin_la_LDFLAGS = \
     -module \
     -lpam \
     -lpam_misc \
+    -g \
     $(DBUS_LIBS) \
-    $(DHASH_LIBS)
-    
+    $(DHASH_LIBS) \
+    libsss_util.la
+
 libsss_sudoplugin_la_CPPFLAGS = \
      $(AM_CPPFLAGS) \
      -D_GNU_SOURCE \
-     -g
-     
-    
+     -ldbus-1
     
 ####################
 # Plugin Libraries #
diff --git a/src/responder/sudo/sudosrv.c b/src/responder/sudo/sudosrv.c
index 6f8935cb..ed3fe4d2 100644
--- a/src/responder/sudo/sudosrv.c
+++ b/src/responder/sudo/sudosrv.c
@@ -31,10 +31,13 @@
 #include <errno.h>
 
 #include <popt.h>
+#include "dhash.h"
 #include "util/util.h"
 #include "sbus/sbus_client.h"
+#include "sbus/sssd_dbus_messages_helpers.h"
 
 #include "sudosrv.h"
+#include "sss_client/sudo_plugin/sss_sudo_cli.h"
 
 
 
@@ -48,6 +51,13 @@ static int sudo_client_destructor(void *ctx)
     return 0;
 }
 
+struct test {
+  uid_t userid;
+  char * cwd;
+  char * tty;
+};
+struct sss_sudo_msg_contents * msg;
+
 
 static int sudo_query_validation(DBusMessage *message, struct sbus_connection *conn)
 {
@@ -56,63 +66,151 @@ static int sudo_query_validation(DBusMessage *message, struct sbus_connection *c
     struct sudo_client *sudocli;
     DBusMessage *reply;
     DBusError dbus_error;
-    char *str;
+    DBusMessageIter msg_iter;
+    DBusMessageIter subItem;
+    char *tmp;
     dbus_bool_t dbret;
     void *data;
+    hash_table_t *settings_table;
+    hash_table_t *env_table;
 
     data = sbus_conn_get_private_data(conn);
     sudocli = talloc_get_type(data, struct sudo_client);
     if (!sudocli) {
         DEBUG(0, ("Connection holds no valid init data\n"));
-        return EINVAL;
+        return SSS_SUDO_RESPONDER_CONNECTION_ERR;
     }
 
+    msg = talloc((TALLOC_CTX *)sudocli,struct sss_sudo_msg_contents);
+    
     /* First thing, cancel the timeout */
     DEBUG(4, ("Cancel SUDO client timeout [%p]\n", sudocli->timeout));
     talloc_zfree(sudocli->timeout);
 
     dbus_error_init(&dbus_error);
+    
+    if (!dbus_message_iter_init(message, &msg_iter)) {
+      fprintf(stderr, "Message received as empty!\n");
+      return SSS_SUDO_RESPONDER_MESSAGE_ERR;
+   }
+
+        if(DBUS_TYPE_STRUCT != dbus_message_iter_get_arg_type(&msg_iter)) {
+            fprintf(stderr, "Argument is not struct!\n");
+            return SSS_SUDO_RESPONDER_MESSAGE_ERR;
+        }
+        else{
+            dbus_message_iter_recurse(&msg_iter,&subItem);
+        }
+
+            if(DBUS_TYPE_UINT32 != dbus_message_iter_get_arg_type(&subItem)) {
+                fprintf(stderr,"UID failed");
+                return SSS_SUDO_RESPONDER_MESSAGE_ERR;
+            }
+            else {
+                dbus_message_iter_get_basic(&subItem, &msg->userid);
+                dbus_message_iter_next (&subItem);
+            }
+
+            if(DBUS_TYPE_STRING != dbus_message_iter_get_arg_type(&subItem)) {
+                fprintf(stderr,"CWD failed");
+                return SSS_SUDO_RESPONDER_MESSAGE_ERR;
+            }
+            else {
+                dbus_message_iter_get_basic(&subItem, &msg->cwd);
+                dbus_message_iter_next (&subItem);
+            }
+     
+            if(DBUS_TYPE_STRING != dbus_message_iter_get_arg_type(&subItem)) {
+                fprintf(stderr,"TTY failed");
+                return SSS_SUDO_RESPONDER_MESSAGE_ERR;
+            }
+            else {
+                dbus_message_iter_get_basic(&subItem, &msg->tty);
+            }
+
+            fprintf(stderr," The message is:  UID: %d\nCWD: %s\nTTY: %s\n",msg->userid,msg->cwd,msg->tty);
+
+        dbus_message_iter_next (&msg_iter);
+
+        if( DBUS_TYPE_ARRAY != dbus_message_iter_get_arg_type(&msg_iter)) {
+            fprintf(stderr, "Command array failed!\n");
+            return SSS_SUDO_RESPONDER_MESSAGE_ERR;
+        }
+        else{
+            dbus_message_iter_recurse(&msg_iter,&subItem);
+        }
+   
+        while(1)
+        {
+            if(DBUS_TYPE_STRING != dbus_message_iter_get_arg_type(&subItem)) {
+                printf("string array content failed");
+                return SSS_SUDO_RESPONDER_MESSAGE_ERR;
+
+            }
+            else {
+                dbus_message_iter_get_basic(&subItem, &tmp);
+                fprintf(stderr," ARRAY: %s \n",tmp);
+                    if(!dbus_message_iter_next (&subItem)) {
+                        /*"Array ended. */
+                        break;
+                    }
+	
+            }
+          
+        }
+    
+        dbus_message_iter_next(&msg_iter);
+    
+        if( dbus_msg_iter_to_dhash(&msg_iter, &settings_table)!= SSS_SBUS_CONV_SUCCESS){
+            fprintf(stderr, "settings table corrupted!\n");
+            return SSS_SUDO_RESPONDER_MESSAGE_ERR;
+        }
+
+        dbus_message_iter_next(&msg_iter);
 
-    dbret = dbus_message_get_args(message, &dbus_error,
-                                  DBUS_TYPE_STRING, &str,
-                                  DBUS_TYPE_INVALID);
-    if (!dbret) {
+        if( dbus_msg_iter_to_dhash(&msg_iter, &env_table)!= SSS_SBUS_CONV_SUCCESS){
+            fprintf(stderr, "environment table corrupted!\n");
+            return SSS_SUDO_RESPONDER_MESSAGE_ERR;
+
+        }
+    
+    
+    /*if (!dbret) {
         DEBUG(1, ("Failed to parse message, killing connection\n"));
         if (dbus_error_is_set(&dbus_error)) dbus_error_free(&dbus_error);
         sbus_disconnect(conn);
-        return EIO;
-    }
 
-   fprintf(stderr," The string message is : %s\n ",str);
-    talloc_set_destructor((TALLOC_CTX *)sudocli, sudo_client_destructor);
+    }*/
 
-    DEBUG(4, ("Got string [%s]\n", str));
 
-    /* reply that all is ok */
-    reply = dbus_message_new_method_return(message);
-    if (!reply) {
-        DEBUG(0, ("Dbus Out of memory!\n"));
-        return ENOMEM;
-    }
+  
+        talloc_set_destructor((TALLOC_CTX *)sudocli, sudo_client_destructor);
 
-    dbret = dbus_message_append_args(reply,
-                                     DBUS_TYPE_UINT16, &version,
-                                     DBUS_TYPE_INVALID);
-    if (!dbret) {
-        DEBUG(0, ("Failed to build sudo dbus reply\n"));
-        dbus_message_unref(reply);
-        sbus_disconnect(conn);
-        return EIO;
-    }
+        DEBUG(4, ("Got string [%s]\n", msg->cwd));
 
-    /* send reply back */
-    sbus_conn_send_reply(conn, reply);
-    dbus_message_unref(reply);
+            /* reply that all is ok */
+        reply = dbus_message_new_method_return(message);
+        if (!reply) {
+            DEBUG(0, ("Dbus Out of memory!\n"));
+            return ENOMEM;
+        }
 
-    sudocli->initialized = true;
-    return EOK;
+        dbret = dbus_message_append_args(reply,
+                                         DBUS_TYPE_UINT16, &version,
+                                         DBUS_TYPE_INVALID);
+        if (!dbret) {
+            DEBUG(0, ("Failed to build sudo dbus reply\n"));
+            dbus_message_unref(reply);
+            sbus_disconnect(conn);
+            return EIO;
+        }
 
-  
+            /* send reply back */
+        sbus_conn_send_reply(conn, reply);
+        dbus_message_unref(reply);
+
+        sudocli->initialized = true;
+        return EOK;
 }
 
 static void init_timeout(struct tevent_context *ev,
diff --git a/src/responder/sudo/sudosrv.h b/src/responder/sudo/sudosrv.h
index 3da03bd0..985499d1 100644
--- a/src/responder/sudo/sudosrv.h
+++ b/src/responder/sudo/sudosrv.h
@@ -74,4 +74,18 @@ struct sudo_client {
     bool initialized;
 };
 
-#endif
\ No newline at end of file
+
+enum error_types_sudo_responder{
+
+  SSS_SUDO_RESPONDER_SUCCESS = 0x01,
+  SSS_SUDO_RESPONDER_FAILED,
+  SSS_SUDO_RESPONDER_BUF_ERR,
+  SSS_SUDO_RESPONDER_CONNECTION_ERR,
+  SSS_SUDO_RESPONDER_SYSTEM_ERR,
+  SSS_SUDO_RESPONDER_LOG_ERR,
+  SSS_SUDO_RESPONDER_MESSAGE_ERR,
+  SSS_SUDO_RESPONDER_REPLY_ERR,
+  SSS_SUDO_RESPONDER_DHASH_ERR
+
+};
+#endif
diff --git a/src/sbus/sssd_dbus_messages_helpers.c b/src/sbus/sssd_dbus_messages_helpers.c
new file mode 100644
index 00000000..bc51ecdc
--- /dev/null
+++ b/src/sbus/sssd_dbus_messages_helpers.c
@@ -0,0 +1,176 @@
+/*
+ * sssd_dbus_messages_helpers.c
+ *
+ *  Created on: Jul 9, 2011
+ *      Author: r00tkit
+ */
+
+#include <sys/time.h>
+#include <errno.h>
+#include "util/util.h"
+#include "dbus/dbus.h"
+#include "sbus/sssd_dbus.h"
+#include "sbus/sssd_dbus_private.h"
+#include <dhash.h>
+#include "sbus/sssd_dbus_messages_helpers.h"
+
+
+void callback_delete(hash_entry_t *entry, hash_destroy_enum type, void *pvt)
+{
+    if (entry->value.type == HASH_VALUE_PTR)
+        free(entry->value.ptr);
+}
+
+int dbus_dhash_to_msg_iter(hash_table_t **table_in,
+                           DBusMessageIter *msg_iter_start)
+{
+
+    hash_table_t *  local_table = NULL;
+    hash_entry_t *entry;
+    struct hash_iter_context_t *iter;
+
+    char * str_value,*str_key;
+
+    DBusMessageIter *msg_iter;
+    DBusMessageIter sub_iter;
+    DBusMessageIter dict_iter;
+
+    msg_iter = msg_iter_start;
+
+    if( !table_in && !*table_in) {
+        fprintf(stderr,"Table is not valid.");
+        return SSS_SBUS_DHASH_NULL;
+    }
+    local_table =  *table_in;
+
+    if(!dbus_message_iter_open_container(msg_iter,
+                                        DBUS_TYPE_ARRAY,
+                                        "{ss}",
+                                        &sub_iter)) {
+           fprintf(stderr, "Out Of Memory!\n");
+           return SSS_SBUS_ITER_MESSAGE_ERR;
+       }
+    printf("Iterate using iterator\n");
+       iter = new_hash_iter_context(local_table);
+       while ((entry = iter->next(iter)) != NULL) {
+
+           if(entry->key.type != HASH_KEY_STRING && entry->value.type != HASH_VALUE_PTR) {
+               fprintf(stderr,"fatal: Unexpected hashtable");
+               return SSS_SBUS_DHASH_INVALID;
+           }
+
+           str_key   = strdup((char *) entry->key.str);
+           str_value = strdup((char *) entry->value.ptr);
+
+           if(!dbus_message_iter_open_container(&sub_iter,
+                                                DBUS_TYPE_DICT_ENTRY,
+                                                NULL,
+                                                &dict_iter)) {
+               fprintf(stderr, "Out Of Memory!\n");
+               return SSS_SBUS_ITER_MESSAGE_ERR;
+           }
+
+                 if (!dbus_message_iter_append_basic(&dict_iter, DBUS_TYPE_STRING, &str_key)) {
+                     fprintf(stderr, "Out Of Memory!\n");
+                     return SSS_SBUS_ITER_MESSAGE_ERR;
+                 }
+                 if (!dbus_message_iter_append_basic(&dict_iter, DBUS_TYPE_STRING, &str_value)) {
+                     fprintf(stderr, "Out Of Memory!\n");
+                     return SSS_SBUS_ITER_MESSAGE_ERR;
+                 }
+
+                 free(str_key);
+                 free(str_value);
+           if (!dbus_message_iter_close_container(&sub_iter,&dict_iter)) {
+               fprintf(stderr, "Out Of Memory!\n");
+               return SSS_SBUS_ITER_MESSAGE_ERR;
+           }
+
+
+
+       }
+       free(iter);
+       if (!dbus_message_iter_close_container(msg_iter,&sub_iter)) {
+              fprintf(stderr, "Out Of Memory!\n");
+              return SSS_SBUS_ITER_MESSAGE_ERR;
+       }
+
+    return SSS_SBUS_CONV_SUCCESS;
+
+}
+
+int dbus_msg_iter_to_dhash(DBusMessageIter *iter, hash_table_t **table_out)
+{
+    DBusMessageIter msg_iter;
+    DBusMessageIter sub_iter;
+    DBusMessageIter dict_iter;
+    hash_table_t *local_table = NULL;
+    hash_key_t   key;
+    hash_value_t value;
+    int err_h;
+    char * tmp;
+
+    msg_iter = *iter;
+
+    err_h =  hash_create((unsigned long)INIT_TABLE_SIZE,
+                                        &local_table,
+                                        callback_delete,
+                                        NULL);
+        if (err_h != HASH_SUCCESS) {
+                fprintf(stderr, "couldn't create hash table (%s)\n", hash_error_string(err_h));
+                return err_h;
+        }
+
+        if(DBUS_TYPE_ARRAY != dbus_message_iter_get_arg_type(&msg_iter)) {
+            fprintf(stderr,"dictionary is invalid");
+            return SSS_SBUS_ITER_INVALID_ERR;
+
+        }
+        else {
+            fprintf(stdout,"Signature of dict : %s \n",dbus_message_iter_get_signature(&msg_iter));
+                dbus_message_iter_recurse(&msg_iter, &sub_iter);
+            }
+
+            while(1){
+
+                if(DBUS_TYPE_DICT_ENTRY != dbus_message_iter_get_arg_type(&sub_iter)) {
+                    fprintf(stderr,"dict content failed");
+                }
+                else {
+                    dbus_message_iter_recurse(&sub_iter, &dict_iter);
+                }
+
+                    if(DBUS_TYPE_STRING != dbus_message_iter_get_arg_type(&dict_iter)) {
+                        printf("string array content failed");
+                        return SSS_SBUS_ITER_MESSAGE_ERR;
+                    }
+                    else {
+                        key.type = HASH_KEY_STRING;
+                        value.type = HASH_VALUE_PTR;
+                        dbus_message_iter_get_basic(&dict_iter, &tmp);
+                        key.str = tmp;
+                        fprintf(stderr," %s ",key.str);
+                        dbus_message_iter_next (&dict_iter);
+                        if(DBUS_TYPE_STRING != dbus_message_iter_get_arg_type(&dict_iter)) {
+                            printf("string array content failed");
+                            return SSS_SBUS_ITER_MESSAGE_ERR;
+                        }
+                        dbus_message_iter_get_basic(&dict_iter, &tmp);
+                        value.ptr = tmp;
+                        fprintf(stderr,": %s \n",(char *)value.ptr);
+
+                        if ((err_h = hash_enter(local_table, &key, &value)) != HASH_SUCCESS) {
+                            fprintf(stderr, "couldn't add to table \"%s\" (%s)\n", key.str, hash_error_string(err_h));
+                            return err_h;
+                        }
+                        if(!dbus_message_iter_next (&sub_iter)) {
+                                 fprintf(stderr,"struct ended.");
+                                 break;
+                             }
+                    }
+
+            }
+
+            *table_out = local_table;
+            return SSS_SBUS_CONV_SUCCESS;
+}
diff --git a/src/sbus/sssd_dbus_messages_helpers.h b/src/sbus/sssd_dbus_messages_helpers.h
new file mode 100644
index 00000000..97152c26
--- /dev/null
+++ b/src/sbus/sssd_dbus_messages_helpers.h
@@ -0,0 +1,28 @@
+/*
+ * sssd_dbus_messages_helpers.h
+ *
+ *  Created on: Jul 9, 2011
+ *      Author: r00tkit
+ */
+
+#ifndef SSSD_DBUS_MESSAGES_HELPERS_H_
+#define SSSD_DBUS_MESSAGES_HELPERS_H_
+
+enum dhash_msgiter_conversion_status {
+    SSS_SBUS_CONV_SUCCESS = 0x00,
+    SSS_SBUS_DHASH_INVALID,
+    SSS_SBUS_DHASH_NULL,
+    SSS_SBUS_ITER_MESSAGE_ERR,
+    SSS_SBUS_ITER_INVALID_ERR
+
+};
+
+#define INIT_TABLE_SIZE 14
+
+void callback_delete(hash_entry_t *entry, hash_destroy_enum type, void *pvt);
+
+int dbus_dhash_to_msg_iter(hash_table_t **table_in, DBusMessageIter *msg_iter_start);
+
+int dbus_msg_iter_to_dhash(DBusMessageIter *iter, hash_table_t **table_out);
+
+#endif /* SSSD_DBUS_MESSAGES_HELPERS_H_ */
diff --git a/src/sss_client/sudo_plugin/sss_sudo_cli.h b/src/sss_client/sudo_plugin/sss_sudo_cli.h
index 7f4377bd..1c3ba6e2 100644
--- a/src/sss_client/sudo_plugin/sss_sudo_cli.h
+++ b/src/sss_client/sudo_plugin/sss_sudo_cli.h
@@ -114,7 +114,7 @@ struct sss_sudo_msg_contents
   int debug_level; 
 
   /*from user_env*/
-  char * * user_env;
+  char * const * user_env;
  
   /* command with arguments */
   char ** command;
@@ -140,7 +140,6 @@ struct sss_sudo_msg_contents
 #define  SSS_SUDO_ITEM_DEBUG_LEVEL          "use_debug_level"
 #define  SSS_SUDO_ITEM_CLI_PID              "client_pid"
 
-void print_sudo_items(void);
 
 
 #endif  /* _SSS_SUDO_CLI_H_ */
diff --git a/src/sss_client/sudo_plugin/sss_sudoplugin.c b/src/sss_client/sudo_plugin/sss_sudoplugin.c
index 7ae9168b..5cde318f 100644
--- a/src/sss_client/sudo_plugin/sss_sudoplugin.c
+++ b/src/sss_client/sudo_plugin/sss_sudoplugin.c
@@ -91,6 +91,8 @@
 
 #include "sss_sudo_cli.h"
 
+#include "sbus/sssd_dbus_messages_helpers.h"
+
 
 #ifdef __TANDEM
 /* If it is a tandem system */
@@ -118,10 +120,10 @@
 #define SSS_SUDO_PAM_SERVICE "sudo"
 
 
-#define CHECK_AND_RETURN_BOOL_STRING(obj)  ((obj)?"FALSE":"TRUE")
+#define CHECK_AND_RETURN_BOOL_STRING(obj)  ((obj)?"TRUE":"FALSE")
 
 struct plugin_state {
-    char **envp;
+    char * const *envp;
     char * const *settings;
     char * const *user_info;
 } plugin_state;
@@ -159,6 +161,9 @@ static struct pam_conv conv = {
 };
 
 
+#define GET_BOOL_STRING(x) ((x)? strdup("TRUE") : strdup("FALSE"))
+
+
 void print_sudo_items(void)
 {
 
@@ -438,8 +443,8 @@ int policy_open(unsigned int version,
     }
 
     /* fill Plugin state. */
-    plugin_state.envp = (char **)user_env;
-    msg.user_env = (char **)user_env;
+    plugin_state.envp = user_env;
+    msg.user_env = user_env;
     /* FIXME: Set a mechanism to handle environment */
     plugin_state.settings = settings;
     plugin_state.user_info = user_info;
@@ -623,7 +628,7 @@ int create_env_hash_table(char ** env, hash_table_t ** table_out) {
     hash_value_t value;
 
     char * tmp;
-    char ** ui;
+    char **ui;
 
     int err_h;
 
@@ -650,6 +655,7 @@ int create_env_hash_table(char ** env, hash_table_t ** table_out) {
             }
             *tmp = '=' ;
     }
+
     *table_out = local_table;
 
     return HASH_SUCCESS;
@@ -661,8 +667,8 @@ int create_settings_hash_table(hash_table_t ** table_out) {
     hash_key_t   key;
     hash_value_t value;
 
-    char * tmp;
-    char ** ui;
+    const char * truth = strdup("TRUE");
+    const char * fallacy = strdup("FALSE");
 
     int err_h;
 
@@ -676,66 +682,108 @@ int create_settings_hash_table(hash_table_t ** table_out) {
     }
             key.type = HASH_KEY_STRING;
             value.type = HASH_VALUE_PTR;
-            key.str = strdup(SSS_SUDO_ITEM_RUSER);
-                value.ptr = msg.runas_user;
+            if(msg.runas_user && *msg.runas_user ){
+                key.str = strdup(SSS_SUDO_ITEM_RUSER);
+                    value.ptr = msg.runas_user;
+                    if ((err_h = hash_enter(local_table, &key, &value)) != HASH_SUCCESS) {
+                        fprintf(stderr, "cannot add to table \"%s\" (%s)\n", key.str, hash_error_string(err_h));
+                        return err_h;
+                    }
+                    free(key.str);
+            }
+
+            if(msg.runas_group && *msg.runas_group ){
+                key.str = strdup(SSS_SUDO_ITEM_RGROUP);
+                    value.ptr = msg.runas_group;
+                    if ((err_h = hash_enter(local_table, &key, &value)) != HASH_SUCCESS) {
+                        fprintf(stderr, "cannot add to table \"%s\" (%s)\n", key.str, hash_error_string(err_h));
+                        return err_h;
+                    }
+                free(key.str);
+            }
+
+            if(msg.prompt && *msg.prompt ){
+                key.str = strdup(SSS_SUDO_ITEM_PROMPT);
+                    value.ptr = msg.prompt;
+                    if ((err_h = hash_enter(local_table, &key, &value)) != HASH_SUCCESS) {
+                        fprintf(stderr, "cannot add to table \"%s\" (%s)\n", key.str, hash_error_string(err_h));
+                        return err_h;
+                    }
+                free(key.str);
+            }
+
+            if(msg.network_addrs && *msg.network_addrs ){
+                key.str = strdup(SSS_SUDO_ITEM_NETADDR);
+                    value.ptr = msg.network_addrs;
+                    if ((err_h = hash_enter(local_table, &key, &value)) != HASH_SUCCESS) {
+                        fprintf(stderr, "cannot add to table \"%s\" (%s)\n", key.str, hash_error_string(err_h));
+                        return err_h;
+                    }
+                    free(key.str);
+            }
+
+            key.str = strdup(SSS_SUDO_ITEM_USE_SUDOEDIT);
+                value.ptr = GET_BOOL_STRING(msg.use_sudoedit);
                 if ((err_h = hash_enter(local_table, &key, &value)) != HASH_SUCCESS) {
                     fprintf(stderr, "cannot add to table \"%s\" (%s)\n", key.str, hash_error_string(err_h));
                     return err_h;
                 }
             free(key.str);
 
-            key.str = strdup(SSS_SUDO_ITEM_RGROUP);
-                value.ptr = msg.runas_group;
+            key.str = strdup(SSS_SUDO_ITEM_USE_SETHOME);
+                value.ptr = GET_BOOL_STRING(msg.use_set_home);
                 if ((err_h = hash_enter(local_table, &key, &value)) != HASH_SUCCESS) {
                     fprintf(stderr, "cannot add to table \"%s\" (%s)\n", key.str, hash_error_string(err_h));
                     return err_h;
                 }
             free(key.str);
-
-            key.str = strdup(SSS_SUDO_ITEM_PROMPT);
-                value.ptr = msg.prompt;
+	    
+            key.str = strdup(SSS_SUDO_ITEM_USE_PRESERV_ENV);
+                value.ptr = GET_BOOL_STRING(msg.use_preserve_environment);
                 if ((err_h = hash_enter(local_table, &key, &value)) != HASH_SUCCESS) {
                     fprintf(stderr, "cannot add to table \"%s\" (%s)\n", key.str, hash_error_string(err_h));
                     return err_h;
                 }
             free(key.str);
 
-            key.str = strdup(SSS_SUDO_ITEM_NETADDR);
-                value.ptr = msg.network_addrs;
+            key.str = strdup(SSS_SUDO_ITEM_USE_IMPLIED_SHELL);
+                value.ptr  = GET_BOOL_STRING(msg.use_implied_shell);
                 if ((err_h = hash_enter(local_table, &key, &value)) != HASH_SUCCESS) {
                     fprintf(stderr, "cannot add to table \"%s\" (%s)\n", key.str, hash_error_string(err_h));
                     return err_h;
                 }
             free(key.str);
-
-            value.type = HASH_VALUE_INT;
-
-            key.str = strdup(SSS_SUDO_ITEM_USE_SUDOEDIT);
-                value.i = msg.use_sudoedit;
+	    
+	    
+            key.str = strdup(SSS_SUDO_ITEM_USE_LOGIN_SHELL);
+                value.ptr = GET_BOOL_STRING(msg.use_login_shell);
                 if ((err_h = hash_enter(local_table, &key, &value)) != HASH_SUCCESS) {
                     fprintf(stderr, "cannot add to table \"%s\" (%s)\n", key.str, hash_error_string(err_h));
                     return err_h;
                 }
             free(key.str);
-
-            key.str = strdup(SSS_SUDO_ITEM_USE_SETHOME);
-                value.i = msg.use_set_home;
+	    
+	    
+            key.str = strdup(SSS_SUDO_ITEM_USE_RUN_SHELL);
+                value.ptr = GET_BOOL_STRING(msg.use_run_shell);
                 if ((err_h = hash_enter(local_table, &key, &value)) != HASH_SUCCESS) {
                     fprintf(stderr, "cannot add to table \"%s\" (%s)\n", key.str, hash_error_string(err_h));
                     return err_h;
                 }
             free(key.str);
 	    
-            key.str = strdup(SSS_SUDO_ITEM_USE_PRESERV_ENV);
-                value.i = msg.use_preserve_environment;
+	    
+            key.str = strdup(SSS_SUDO_ITEM_USE_PRE_GROUPS);
+                value.i = GET_BOOL_STRING(msg.use_preserve_groups);
                 if ((err_h = hash_enter(local_table, &key, &value)) != HASH_SUCCESS) {
                     fprintf(stderr, "cannot add to table \"%s\" (%s)\n", key.str, hash_error_string(err_h));
                     return err_h;
                 }
             free(key.str);
-
-            key.str = strdup(SSS_SUDO_ITEM_USE_IMPLIED_SHELL);
-                value.i = msg.use_implied_shell;
+	    
+	    
+            key.str = strdup(SSS_SUDO_ITEM_USE_IGNORE_TICKET);
+                value.ptr = GET_BOOL_STRING(msg.use_ignore_ticket);
                 if ((err_h = hash_enter(local_table, &key, &value)) != HASH_SUCCESS) {
                     fprintf(stderr, "cannot add to table \"%s\" (%s)\n", key.str, hash_error_string(err_h));
                     return err_h;
@@ -743,65 +791,29 @@ int create_settings_hash_table(hash_table_t ** table_out) {
             free(key.str);
 	    
 	    
-            key.str = strdup(SSS_SUDO_ITEM_USE_LOGIN_SHELL);
-                value.i = msg.use_login_shell;
+            key.str = strdup(SSS_SUDO_ITEM_USE_NON_INTERACTIVE);
+                value.ptr =GET_BOOL_STRING(msg.use_noninteractive);
                 if ((err_h = hash_enter(local_table, &key, &value)) != HASH_SUCCESS) {
                     fprintf(stderr, "cannot add to table \"%s\" (%s)\n", key.str, hash_error_string(err_h));
                     return err_h;
                 }
             free(key.str);
 	    
+            key.str = strdup(SSS_SUDO_ITEM_DEBUG_LEVEL);
+                value.ptr = GET_BOOL_STRING(msg.debug_level);
+                if ((err_h = hash_enter(local_table, &key, &value)) != HASH_SUCCESS) {
+                    fprintf(stderr, "cannot add to table \"%s\" (%s)\n", key.str, hash_error_string(err_h));
+                    return err_h;
+                }
+            free(key.str);
 	    
-	    key.str = strdup(SSS_SUDO_ITEM_USE_RUN_SHELL);
-            value.i = msg.use_run_shell;
-            if ((err_h = hash_enter(local_table, &key, &value)) != HASH_SUCCESS) {
-                fprintf(stderr, "cannot add to table \"%s\" (%s)\n", key.str, hash_error_string(err_h));
-                return err_h;
-            }
-        free(key.str);
-	    
-	    
-	    key.str = strdup(SSS_SUDO_ITEM_USE_PRE_GROUPS);
-            value.i = msg.use_preserve_groups;
-            if ((err_h = hash_enter(local_table, &key, &value)) != HASH_SUCCESS) {
-                fprintf(stderr, "cannot add to table \"%s\" (%s)\n", key.str, hash_error_string(err_h));
-                return err_h;
-            }
-        free(key.str);
-	    
-	    
-	    key.str = strdup(SSS_SUDO_ITEM_USE_IGNORE_TICKET);
-            value.i = msg.use_ignore_ticket;
-            if ((err_h = hash_enter(local_table, &key, &value)) != HASH_SUCCESS) {
-                fprintf(stderr, "cannot add to table \"%s\" (%s)\n", key.str, hash_error_string(err_h));
-                return err_h;
-            }
-       free(key.str);
-	    
-	    
-	    key.str = strdup(SSS_SUDO_ITEM_USE_NON_INTERACTIVE);
-            value.i = msg.use_noninteractive;
-            if ((err_h = hash_enter(local_table, &key, &value)) != HASH_SUCCESS) {
-                fprintf(stderr, "cannot add to table \"%s\" (%s)\n", key.str, hash_error_string(err_h));
-                return err_h;
-            }
-      free(key.str);
-	    
-	    key.str = strdup(SSS_SUDO_ITEM_DEBUG_LEVEL);
-            value.i = msg.debug_level;
-            if ((err_h = hash_enter(local_table, &key, &value)) != HASH_SUCCESS) {
-                fprintf(stderr, "cannot add to table \"%s\" (%s)\n", key.str, hash_error_string(err_h));
-                return err_h;
-            }
-       free(key.str);
-	    
-	    key.str = strdup(SSS_SUDO_ITEM_CLI_PID);
-            value.i = msg.cli_pid;
-            if ((err_h = hash_enter(local_table, &key, &value)) != HASH_SUCCESS) {
-                fprintf(stderr, "cannot add to table \"%s\" (%s)\n", key.str, hash_error_string(err_h));
-                return err_h;
-            }
-       free(key.str);
+            key.str = strdup(SSS_SUDO_ITEM_CLI_PID);
+                 asprintf(&value.ptr,"%u",msg.cli_pid);
+                if ((err_h = hash_enter(local_table, &key, &value)) != HASH_SUCCESS) {
+                    fprintf(stderr, "cannot add to table \"%s\" (%s)\n", key.str, hash_error_string(err_h));
+                    return err_h;
+                }
+            free(key.str);
 	    
 
     *table_out = local_table;
@@ -841,15 +853,11 @@ int sss_sudo_make_request(struct sss_cli_req_data *rd,
                           int *errnop)
 {
 
-   const char * truth = "TRUE";
-   const char * fallacy = "FALSE";
+
    char ** command_array;
-   int count;
-   char *tmp;
    int err_status;
-   
-#define GET_BOOL_STRING(x) ((x)? &truth : &fallacy)
-   
+   int status;
+
    DBusConnection* conn;
    DBusError err;
    
@@ -857,15 +865,11 @@ int sss_sudo_make_request(struct sss_cli_req_data *rd,
    DBusMessage* dbus_reply;
    DBusMessageIter msg_iter;
    DBusMessageIter sub_iter;
-   DBusMessageIter dict_iter;
-   
-   dbus_uint32_t status=0;
+
    dbus_bool_t ret=FALSE;
    
-
-   hash_table_t **settings_table;
-   hash_table_t **env_table;
-
+   hash_table_t *env_table;
+   hash_table_t *settings_table;
 
    fprintf(stdout,"Calling remote method to pack message\n");
    
@@ -873,18 +877,20 @@ int sss_sudo_make_request(struct sss_cli_req_data *rd,
        return SSS_SUDO_VALIDATION_ERR;
    }
 
-   err_status = create_env_hash_table(msg.user_env,env_table);
+
+   err_status = create_env_hash_table(msg.user_env,&env_table);
        if(err_status != HASH_SUCCESS) {
           fprintf(stderr, "ccouldn't create table: %s\n", hash_error_string(err_status));
           return SSS_SUDO_MESSAGE_ERR;
        }
 
 
-   err_status = create_settings_hash_table(msg.user_env,env_table);
+   err_status = create_settings_hash_table(&settings_table);
        if(err_status != HASH_SUCCESS) {
           fprintf(stderr, "ccouldn't create table: %s\n", hash_error_string(err_status));
           return SSS_SUDO_MESSAGE_ERR;
        }
+
    /* initialise the errors */
    dbus_error_init(&err);
 
@@ -902,7 +908,7 @@ int sss_sudo_make_request(struct sss_cli_req_data *rd,
 
 
    /* create a new method call and check for errors */
-   dbus_msg = dbus_message_new_method_call( NULL, 		/*    target    */
+   dbus_msg = dbus_message_new_method_call( NULL, 		        /*    target    */
                                       SUDO_SERVER_PATH,        /*    object    */
                                       SUDO_SERVER_INTERFACE,  /*   interface  */
                                       SUDO_METHOD_QUERY);    /*  method name */              
@@ -944,8 +950,8 @@ int sss_sudo_make_request(struct sss_cli_req_data *rd,
    
 
      if (!dbus_message_iter_append_basic(&sub_iter,
-                                               DBUS_TYPE_STRING,
-                                               &msg.tty)) {
+                                         DBUS_TYPE_STRING,
+                                         &msg.tty)) {
          fprintf(stderr, "Out Of Memory!\n");
          return SSS_SUDO_MESSAGE_ERR;
      }
@@ -955,14 +961,7 @@ int sss_sudo_make_request(struct sss_cli_req_data *rd,
       return SSS_SUDO_MESSAGE_ERR;
    }
    
-   command_array = (char **) malloc(msg.command_count* sizeof (char*));
-   
-   for(count = 0;count<msg.command_count;count++) {
-     command_array[count] = msg.command[count];
-   }
-   
-   
-      
+
    if(!dbus_message_iter_open_container(&msg_iter,
                                         DBUS_TYPE_ARRAY,
                                         "s",
@@ -971,511 +970,38 @@ int sss_sudo_make_request(struct sss_cli_req_data *rd,
        return SSS_SUDO_MESSAGE_ERR;
    }
    
-        for(count =0 ; count < msg.command_count ; count++) {
+   for(command_array = msg.command ; *command_array != NULL ; command_array++) {
      
                    if (!dbus_message_iter_append_basic(&sub_iter,
                                                        DBUS_TYPE_STRING,
-                                                       &command_array[count])) {
+                                                       command_array)) {
                            fprintf(stderr, "Out Of Memory!\n");
                            return SSS_SUDO_MESSAGE_ERR;
                    }
      
-        }
+    }
    
     if (!dbus_message_iter_close_container(&msg_iter,&sub_iter)) {
         fprintf(stderr, "Out Of Memory!\n");
         return SSS_SUDO_MESSAGE_ERR;
     }
    ////////
-   
-   if(!dbus_message_iter_open_container(&msg_iter,
-                                        DBUS_TYPE_ARRAY,
-                                        "{ss}",
-                                        &sub_iter)) {
-       fprintf(stderr, "Out Of Memory!\n");
-       return SSS_SUDO_MESSAGE_ERR;
-   }
-   
-        if(msg.runas_user && *msg.runas_user ){
-            tmp = strdup("runasuser");
-   
-            if(!dbus_message_iter_open_container(&sub_iter,
-                                                 DBUS_TYPE_DICT_ENTRY,
-                                                 NULL,
-                                                 &dict_iter)) {
-                    fprintf(stderr, "Out Of Memory!\n");
-                    return SSS_SUDO_MESSAGE_ERR;
-            }
-    
-                if (!dbus_message_iter_append_basic(&dict_iter,
-                                                    DBUS_TYPE_STRING,
-                                                    &tmp)) {
-                    fprintf(stderr, "Out Of Memory!\n");
-                    return SSS_SUDO_MESSAGE_ERR;
-                }
-                if (!dbus_message_iter_append_basic(&dict_iter,
-                                                    DBUS_TYPE_STRING,
-                                                    &msg.runas_user)) {
-                    fprintf(stderr, "Out Of Memory!\n");
-                    return SSS_SUDO_MESSAGE_ERR;
-                }
-                free(tmp);
-   
-           if (!dbus_message_iter_close_container(&sub_iter,&dict_iter)) {
-                fprintf(stderr, "Out Of Memory!\n");
-                return SSS_SUDO_MESSAGE_ERR;
-           }
-   
-        }
-    
-    
-        if(msg.runas_group && *msg.runas_group){
-            tmp = strdup("runasgroup");
-            if(!dbus_message_iter_open_container(&sub_iter,
-                                                 DBUS_TYPE_DICT_ENTRY,
-                                                 NULL,
-                                                 &dict_iter)) {
-                fprintf(stderr, "Out Of Memory!\n");
-                return SSS_SUDO_MESSAGE_ERR;
-            }
-                if (!dbus_message_iter_append_basic(&dict_iter,
-                                                    DBUS_TYPE_STRING,
-                                                    &tmp)) {
-                    fprintf(stderr, "Out Of Memory!\n");
-                    return SSS_SUDO_MESSAGE_ERR;
-                }
-                if (!dbus_message_iter_append_basic(&dict_iter,
-                                                    DBUS_TYPE_STRING,
-                                                    &msg.runas_group)) {
-                    fprintf(stderr, "Out Of Memory!\n");
-                    return SSS_SUDO_MESSAGE_ERR;
-                }
-                free(tmp);
-   
-            if (!dbus_message_iter_close_container(&sub_iter,&dict_iter)) {
-                fprintf(stderr, "Out Of Memory!\n");
-                return SSS_SUDO_MESSAGE_ERR;
-            }
-   
-        }
-    
-    
-        if(msg.prompt && *msg.prompt){
-            if(!dbus_message_iter_open_container(&sub_iter,
-                                                 DBUS_TYPE_DICT_ENTRY,
-                                                 NULL,
-                                                 &dict_iter)) {
-                fprintf(stderr, "Out Of Memory!\n");
-                return SSS_SUDO_MESSAGE_ERR;
-            }
-            tmp = strdup("prompt");
-  
-                if (!dbus_message_iter_append_basic(&dict_iter,
-                                                    DBUS_TYPE_STRING,
-                                                    &tmp)) {
-                    fprintf(stderr, "Out Of Memory!\n");
-                    return SSS_SUDO_MESSAGE_ERR;
-                }
-                if (!dbus_message_iter_append_basic(&dict_iter,
-                                                    DBUS_TYPE_STRING,
-                                                    &msg.prompt)) {
-                    fprintf(stderr, "Out Of Memory!\n");
-                    return SSS_SUDO_MESSAGE_ERR;
-                }
-                free(tmp);
-   
-           if (!dbus_message_iter_close_container(&sub_iter,&dict_iter)) {
-               fprintf(stderr, "Out Of Memory!\n");
-               return SSS_SUDO_MESSAGE_ERR;
-           }
-  
-        }
-    
-    
-    
-        if(msg.network_addrs && *msg.network_addrs){
-            if(!dbus_message_iter_open_container(&sub_iter,
-                                                 DBUS_TYPE_DICT_ENTRY,
-                                                 NULL,
-                                                 &dict_iter)) {
-                fprintf(stderr, "Out Of Memory!\n");
-                return SSS_SUDO_MESSAGE_ERR;
-            }
-            tmp = strdup("networkaddress");
-     
-                if (!dbus_message_iter_append_basic(&dict_iter,
-                                                    DBUS_TYPE_STRING,
-                                                    &tmp)) {
-                    fprintf(stderr, "Out Of Memory!\n");
-                    return SSS_SUDO_MESSAGE_ERR;
-                }
-                if (!dbus_message_iter_append_basic(&dict_iter,
-                                                    DBUS_TYPE_STRING,
-                                                    &msg.network_addrs)) {
-                    fprintf(stderr, "Out Of Memory!\n");
-                    return SSS_SUDO_MESSAGE_ERR;
-                }
-                free(tmp);
-   
-           if (!dbus_message_iter_close_container(&sub_iter,&dict_iter)) {
-                fprintf(stderr, "Out Of Memory!\n");
-                return SSS_SUDO_MESSAGE_ERR;
-           }
-   
-        }
-    
-    
-    
-   
-        tmp = strdup("use_sudoedit");
-        if(!dbus_message_iter_open_container(&sub_iter,
-                                             DBUS_TYPE_DICT_ENTRY,
-                                             NULL,
-                                             &dict_iter)) {
-            fprintf(stderr, "Out Of Memory!\n");
-            return SSS_SUDO_MESSAGE_ERR;
-        }
-    
-            if (!dbus_message_iter_append_basic(&dict_iter,
-                                                DBUS_TYPE_STRING,
-                                                &tmp)) {
-                fprintf(stderr, "Out Of Memory!\n");
-                return SSS_SUDO_MESSAGE_ERR;
-            }
-            if (!dbus_message_iter_append_basic(&dict_iter,
-                                                DBUS_TYPE_STRING,
-                                                GET_BOOL_STRING(msg.use_sudoedit))) {
-                fprintf(stderr, "Out Of Memory!\n");
-                return SSS_SUDO_MESSAGE_ERR;
-            }
-            free(tmp);
-   
-        if (!dbus_message_iter_close_container(&sub_iter,&dict_iter)) {
-            fprintf(stderr, "Out Of Memory!\n");
-            return SSS_SUDO_MESSAGE_ERR;
-        }
-
-
-        if(!dbus_message_iter_open_container(&sub_iter,
-                                             DBUS_TYPE_DICT_ENTRY,
-                                             NULL,
-                                             &dict_iter)) {
-            fprintf(stderr, "Out Of Memory!\n");
-            return SSS_SUDO_MESSAGE_ERR;
-        }
-        tmp = strdup("use_set_home");
-     
-            if (!dbus_message_iter_append_basic(&dict_iter,
-                                                DBUS_TYPE_STRING,
-                                                &tmp)) {
-                fprintf(stderr, "Out Of Memory!\n");
-                return SSS_SUDO_MESSAGE_ERR;
-            }
-            if (!dbus_message_iter_append_basic(&dict_iter,
-                                                DBUS_TYPE_STRING,
-                                                GET_BOOL_STRING(msg.use_set_home))) {
-                fprintf(stderr, "Out Of Memory!\n");
-                return SSS_SUDO_MESSAGE_ERR;
-            }
-            free(tmp);
-   
-        if (!dbus_message_iter_close_container(&sub_iter,&dict_iter)) {
-            fprintf(stderr, "Out Of Memory!\n");
-            return SSS_SUDO_MESSAGE_ERR;
-        }
-   
-
-   
-        if(!dbus_message_iter_open_container(&sub_iter,
-                                             DBUS_TYPE_DICT_ENTRY,
-                                             NULL,
-                                             &dict_iter)) {
-            fprintf(stderr, "Out Of Memory!\n");
-            return SSS_SUDO_MESSAGE_ERR;
-        }
-        tmp = strdup("use_preserve_environment");
-     
-            if (!dbus_message_iter_append_basic(&dict_iter,
-                                                DBUS_TYPE_STRING,
-                                                &tmp)) {
-                fprintf(stderr, "Out Of Memory!\n");
-                return SSS_SUDO_MESSAGE_ERR;
-            }
-            if (!dbus_message_iter_append_basic(&dict_iter,
-                                                DBUS_TYPE_STRING,
-                                                GET_BOOL_STRING(msg.use_preserve_environment))) {
-                fprintf(stderr, "Out Of Memory!\n");
-                return SSS_SUDO_MESSAGE_ERR;
-            }
-            free(tmp);
-   
-        if (!dbus_message_iter_close_container(&sub_iter,&dict_iter)) {
-            fprintf(stderr, "Out Of Memory!\n");
-            return SSS_SUDO_MESSAGE_ERR;
-        }
-
-
-        if(!dbus_message_iter_open_container(&sub_iter,
-                                             DBUS_TYPE_DICT_ENTRY,
-                                             NULL,
-                                             &dict_iter)) {
-            fprintf(stderr, "Out Of Memory!\n");
-            return SSS_SUDO_MESSAGE_ERR;
-        }
-        tmp = strdup("use_implied_shell");
-    
-            if (!dbus_message_iter_append_basic(&dict_iter,
-                                                DBUS_TYPE_STRING,
-                                                &tmp)) {
-                fprintf(stderr, "Out Of Memory!\n");
-                return SSS_SUDO_MESSAGE_ERR;
-            }
-            if (!dbus_message_iter_append_basic(&dict_iter,
-                                                DBUS_TYPE_STRING,
-                                                GET_BOOL_STRING(msg.use_implied_shell))) {
-                fprintf(stderr, "Out Of Memory!\n");
-                return SSS_SUDO_MESSAGE_ERR;
-            }
-            free(tmp);
-   
-       if (!dbus_message_iter_close_container(&sub_iter,&dict_iter)) {
-           fprintf(stderr, "Out Of Memory!\n");
-           return SSS_SUDO_MESSAGE_ERR;
-       }
-
-
-       if(!dbus_message_iter_open_container(&sub_iter,
-                                            DBUS_TYPE_DICT_ENTRY,
-                                            NULL,
-                                            &dict_iter)) {
-           fprintf(stderr, "Out Of Memory!\n");
-           return SSS_SUDO_MESSAGE_ERR;
-       }
-       tmp = strdup("use_login_shell");
-     
-            if (!dbus_message_iter_append_basic(&dict_iter,
-                                                DBUS_TYPE_STRING,
-                                                &tmp)) {
-                fprintf(stderr, "Out Of Memory!\n");
-                return SSS_SUDO_MESSAGE_ERR;
-            }
-            if (!dbus_message_iter_append_basic(&dict_iter,
-                                                DBUS_TYPE_STRING,
-                                                GET_BOOL_STRING(msg.use_login_shell))) {
-                fprintf(stderr, "Out Of Memory!\n");
-                return SSS_SUDO_MESSAGE_ERR;
-            }
-            free(tmp);
-   
-       if (!dbus_message_iter_close_container(&sub_iter,&dict_iter)) {
-           fprintf(stderr, "Out Of Memory!\n");
-           return SSS_SUDO_MESSAGE_ERR;
-       }
-
-
-       if(!dbus_message_iter_open_container(&sub_iter,
-                                            DBUS_TYPE_DICT_ENTRY,
-                                            NULL,
-                                            &dict_iter)) {
-           fprintf(stderr, "Out Of Memory!\n");
-           return SSS_SUDO_MESSAGE_ERR;
-       }
-       tmp = strdup("use_run_shell");
-     
-           if (!dbus_message_iter_append_basic(&dict_iter,
-                                               DBUS_TYPE_STRING,
-                                               &tmp)) {
-               fprintf(stderr, "Out Of Memory!\n");
-               return SSS_SUDO_MESSAGE_ERR;
-           }
-           if (!dbus_message_iter_append_basic(&dict_iter,
-                                               DBUS_TYPE_STRING,
-                                               GET_BOOL_STRING(msg.use_run_shell))) {
-               fprintf(stderr, "Out Of Memory!\n");
-               return SSS_SUDO_MESSAGE_ERR;
-           }
-           free(tmp);
-
-      if (!dbus_message_iter_close_container(&sub_iter,&dict_iter)) {
-           fprintf(stderr, "Out Of Memory!\n");
-           return SSS_SUDO_MESSAGE_ERR;
-      }
-
-
 
-        if(!dbus_message_iter_open_container(&sub_iter,
-                                             DBUS_TYPE_DICT_ENTRY,
-                                             NULL,
-                                             &dict_iter)) {
-            fprintf(stderr, "Out Of Memory!\n");
-            return SSS_SUDO_MESSAGE_ERR;
-        }
-        tmp = strdup("use_preserve_groups");
-     
-              if (!dbus_message_iter_append_basic(&dict_iter,
-                                                  DBUS_TYPE_STRING,
-                                                  &tmp)) {
-                  fprintf(stderr, "Out Of Memory!\n");
-                  return SSS_SUDO_MESSAGE_ERR;
-              }
-             if (!dbus_message_iter_append_basic(&dict_iter,
-                                                 DBUS_TYPE_STRING,
-                                                 GET_BOOL_STRING(msg.use_preserve_groups))) {
-                 fprintf(stderr, "Out Of Memory!\n");
-                 return SSS_SUDO_MESSAGE_ERR;
-             }
-             free(tmp);
-   
-        if (!dbus_message_iter_close_container(&sub_iter,&dict_iter)) {
-            fprintf(stderr, "Out Of Memory!\n");
-            return SSS_SUDO_MESSAGE_ERR;
-        }
-
-
-
-        if(!dbus_message_iter_open_container(&sub_iter,
-                                             DBUS_TYPE_DICT_ENTRY,
-                                             NULL,
-                                             &dict_iter)) {
-            fprintf(stderr, "Out Of Memory!\n");
-            return SSS_SUDO_MESSAGE_ERR;
-        }
-        tmp = strdup("use_ignore_ticket");
-     
-            if (!dbus_message_iter_append_basic(&dict_iter,
-                                                DBUS_TYPE_STRING,
-                                                &tmp)) {
-                fprintf(stderr, "Out Of Memory!\n");
-                return SSS_SUDO_MESSAGE_ERR;
-            }
-            if (!dbus_message_iter_append_basic(&dict_iter,
-                                                DBUS_TYPE_STRING,
-                                                GET_BOOL_STRING(msg.use_ignore_ticket))) {
-                fprintf(stderr, "Out Of Memory!\n");
-                return SSS_SUDO_MESSAGE_ERR;
-            }
-            free(tmp);
-   
-        if (!dbus_message_iter_close_container(&sub_iter,&dict_iter)) {
-            fprintf(stderr, "Out Of Memory!\n");
-            return SSS_SUDO_MESSAGE_ERR;
-        }
-
-        if(!dbus_message_iter_open_container(&sub_iter,
-                                             DBUS_TYPE_DICT_ENTRY,
-                                             NULL,
-                                             &dict_iter)) {
-            fprintf(stderr, "Out Of Memory!\n");
-            return SSS_SUDO_MESSAGE_ERR;
-        }
-        tmp = strdup("use_noninteractive");
-     
-            if (!dbus_message_iter_append_basic(&dict_iter,
-                                                DBUS_TYPE_STRING,
-                                                &tmp)) {
-                fprintf(stderr, "Out Of Memory!\n");
-                return SSS_SUDO_MESSAGE_ERR;
-            }
-            if (!dbus_message_iter_append_basic(&dict_iter,
-                                                DBUS_TYPE_STRING,
-                                                GET_BOOL_STRING(msg.use_noninteractive))) {
-                fprintf(stderr, "Out Of Memory!\n");
-                return SSS_SUDO_MESSAGE_ERR;
-            }
-            free(tmp);
-   
-        if (!dbus_message_iter_close_container(&sub_iter,&dict_iter)) {
-            fprintf(stderr, "Out Of Memory!\n");
-            return SSS_SUDO_MESSAGE_ERR;
-        }
-
-
-        if(!dbus_message_iter_open_container(&sub_iter,
-                                             DBUS_TYPE_DICT_ENTRY,
-                                             NULL,
-                                             &dict_iter)) {
-            fprintf(stderr, "Out Of Memory!\n");
-            return SSS_SUDO_MESSAGE_ERR;
-        }
-        tmp = strdup("use_debug_level");
-     
-            if (!dbus_message_iter_append_basic(&dict_iter,
-                                                DBUS_TYPE_STRING,
-                                                &tmp)) {
-                fprintf(stderr, "Out Of Memory!\n");
-                return SSS_SUDO_MESSAGE_ERR;
-            }
-            if (!dbus_message_iter_append_basic(&dict_iter,
-                                                DBUS_TYPE_STRING,
-                                                GET_BOOL_STRING(msg.debug_level))) {
-                fprintf(stderr, "Out Of Memory!\n");
-                return SSS_SUDO_MESSAGE_ERR;
-            }
-            free(tmp);
+    if(dbus_dhash_to_msg_iter(&settings_table,&msg_iter) != SSS_SBUS_CONV_SUCCESS){
+        fprintf(stderr,"fatal: message framing failed.");
+        return SSS_SUDO_MESSAGE_ERR;
+    }
    
-        if (!dbus_message_iter_close_container(&sub_iter,&dict_iter)) {
-            fprintf(stderr, "Out Of Memory!\n");
+    if(dbus_dhash_to_msg_iter(&env_table,&msg_iter) != SSS_SBUS_CONV_SUCCESS){
+            fprintf(stderr,"fatal: message framing failed.");
             return SSS_SUDO_MESSAGE_ERR;
-        }
-   
-   if (!dbus_message_iter_close_container(&msg_iter,&sub_iter)) {
-       fprintf(stderr, "Out Of Memory!\n");
-       return SSS_SUDO_MESSAGE_ERR;
-   }
-
-
-  /////
-  
-  
-  
-   if(!dbus_message_iter_open_container(&msg_iter,
-                                        DBUS_TYPE_ARRAY,
-                                        "{ss}",
-                                        &sub_iter)) {
-       fprintf(stderr, "Out Of Memory!\n");
-       return SSS_SUDO_MESSAGE_ERR;
-   }
-   
-     // DO the dhash to Iter for env
-
-
-     /* for(ui = msg.user_env; *ui!=NULL;ui++) {
-          tmp = strchr(*ui,'=');
-          *tmp = '\0';
-          if(!dbus_message_iter_open_container(&sub_iter,
-                                               DBUS_TYPE_DICT_ENTRY,
-                                               NULL,
-                                               &dict_iter)) {
-              fprintf(stderr, "Out Of Memory!\n");
-              return SSS_SUDO_MESSAGE_ERR;
-          }
-     
-              if (!dbus_message_iter_append_basic(&dict_iter, DBUS_TYPE_STRING, ui)) {
-                  fprintf(stderr, "Out Of Memory!\n");
-                  return SSS_SUDO_MESSAGE_ERR;
-              }
-              if (!dbus_message_iter_append_basic(&dict_iter, DBUS_TYPE_STRING, &tmp+1)) {
-                  fprintf(stderr, "Out Of Memory!\n");
-                  return SSS_SUDO_MESSAGE_ERR;
-              }
-              *tmp = '=' ;
-
-         if (!dbus_message_iter_close_container(&sub_iter,&dict_iter)) {
-             fprintf(stderr, "Out Of Memory!\n");
-             return SSS_SUDO_MESSAGE_ERR;
-         }
-   
-      }*/
-
-   if (!dbus_message_iter_close_container(&msg_iter,&sub_iter)) {
-       fprintf(stderr, "Out Of Memory!\n");
-       return SSS_SUDO_MESSAGE_ERR;
-   }
+    }
 
+    hash_destroy(settings_table);
    
    /* send message and get a handle for a reply */
    dbus_reply = dbus_connection_send_with_reply_and_block (conn,dbus_msg,
-                                                           600,
+                                                           -1,
                                                            &err);
    fprintf(stdout,"Request Sent\n");
    if (dbus_error_is_set(&err)) { 
@@ -1495,7 +1021,9 @@ int sss_sudo_make_request(struct sss_cli_req_data *rd,
                                DBUS_TYPE_INVALID);
     if (!ret) {
         fprintf (stderr,"Failed to parse reply, killing connection\n");
-        if (dbus_error_is_set(&err)) dbus_error_free(&err);
+        if (dbus_error_is_set(&err))
+            dbus_error_free(&err);
+
         dbus_connection_close(conn);
         return SSS_SUDO_REPLY_ERR;
     }
@@ -1508,7 +1036,7 @@ int sss_sudo_make_request(struct sss_cli_req_data *rd,
    dbus_message_unref(dbus_reply);
    dbus_connection_close(conn);
 
-   free(command_array);
+
 
 return SSS_STATUS_SUCCESS;