diff options
author | Arun Scaria <arunscaria91@gmail.com> | 2011-07-11 19:38:45 +0530 |
---|---|---|
committer | Arun Scaria <arunscaria91@gmail.com> | 2011-07-11 19:38:45 +0530 |
commit | e6942f3a9bd31d5b29364b56bfcdb980a1f08c27 (patch) | |
tree | 696aba8aac442ff3c7756398c967cd39c7ecaf0b /src | |
parent | afc975dbb0f48756ac7949887628c7e4b11c5d1d (diff) | |
download | sssd_unused-e6942f3a9bd31d5b29364b56bfcdb980a1f08c27.tar.gz sssd_unused-e6942f3a9bd31d5b29364b56bfcdb980a1f08c27.tar.xz sssd_unused-e6942f3a9bd31d5b29364b56bfcdb980a1f08c27.zip |
plugin-responder communication is finished through dhash table conversion- Need to format the reply message
Diffstat (limited to 'src')
-rw-r--r-- | src/responder/sudo/sudosrv.c | 162 | ||||
-rw-r--r-- | src/responder/sudo/sudosrv.h | 16 | ||||
-rw-r--r-- | src/sbus/sssd_dbus_messages_helpers.c | 176 | ||||
-rw-r--r-- | src/sbus/sssd_dbus_messages_helpers.h | 28 | ||||
-rw-r--r-- | src/sss_client/sudo_plugin/sss_sudo_cli.h | 3 | ||||
-rw-r--r-- | src/sss_client/sudo_plugin/sss_sudoplugin.c | 718 |
6 files changed, 473 insertions, 630 deletions
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; |