the plugin-responder communication is complete. Reply module is working. Need to fix some memory leaks

5 files changed, 152 insertions, 65 deletions

diff --git a/src/responder/sudo/sudosrv.c b/src/responder/sudo/sudosrv.c
index ed3fe4d2..be93954b 100644
--- a/src/responder/sudo/sudosrv.c
+++ b/src/responder/sudo/sudosrv.c
@@ -62,17 +62,22 @@ struct sss_sudo_msg_contents * msg;
 static int sudo_query_validation(DBusMessage *message, struct sbus_connection *conn)
 {
   
-    dbus_uint16_t version = 45674;
+    dbus_uint32_t header = SSS_SUDO_RESPONDER_HEADER,command_size;
     struct sudo_client *sudocli;
     DBusMessage *reply;
     DBusError dbus_error;
     DBusMessageIter msg_iter;
     DBusMessageIter subItem;
-    char *tmp;
+    char *tmp,**ui;
+    char **command_array;
     dbus_bool_t dbret;
     void *data;
+    int count = 0;
     hash_table_t *settings_table;
     hash_table_t *env_table;
+    char * result;
+
+    result = strdup("PASS");
 
     data = sbus_conn_get_private_data(conn);
     sudocli = talloc_get_type(data, struct sudo_client);
@@ -92,7 +97,7 @@ static int sudo_query_validation(DBusMessage *message, struct sbus_connection *c
     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");
@@ -128,52 +133,66 @@ static int sudo_query_validation(DBusMessage *message, struct sbus_connection *c
                 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);
+            fprintf(stdout,"-----------Message---------\n"
+                    "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");
+            if(DBUS_TYPE_UINT32 != dbus_message_iter_get_arg_type(&msg_iter)) {
+                fprintf(stderr,"array size 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)) {
+                dbus_message_iter_get_basic(&msg_iter, &msg->command_count);
+                fprintf(stdout,"Command array size: %d\n",msg->command_count);
+            }
+            dbus_message_iter_next (&msg_iter);
+
+                command_array = (char**)malloc(msg->command_count*sizeof(char *));
+                fprintf(stdout,"command : ");
+
+                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);
+                }
+   
+                for(ui = command_array,count = msg->command_count; count--; ui++)
+                {
+                    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, ui);
+                        fprintf(stdout,"%s ",*ui);
+                        if(!dbus_message_iter_next (&subItem)) {
                         /*"Array ended. */
-                        break;
+                            break;
+                        }
                     }
-	
-            }
-          
-        }
+                }
+                fprintf(stdout,"\n");
     
+                msg->command = command_array;
         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;
-        }
+            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);
 
-        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( 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;
+            }
     
+        fprintf(stdout,"-----------Message END---------\n");
     
     /*if (!dbret) {
         DEBUG(1, ("Failed to parse message, killing connection\n"));
@@ -190,26 +209,59 @@ static int sudo_query_validation(DBusMessage *message, struct sbus_connection *c
 
             /* reply that all is ok */
         reply = dbus_message_new_method_return(message);
-        if (!reply) {
-            DEBUG(0, ("Dbus Out of memory!\n"));
-            return ENOMEM;
-        }
+            if (!reply) {
+                DEBUG(0, ("Dbus Out of memory!\n"));
+                return SSS_SUDO_RESPONDER_REPLY_ERR;
+            }
 
-        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;
-        }
+            command_size = msg->command_count;
+            dbret = dbus_message_append_args(reply,
+                                             DBUS_TYPE_UINT32, &header,
+                                             DBUS_TYPE_STRING,&result,
+                                             DBUS_TYPE_INVALID);
+                if (!dbret) {
+                    DEBUG(0, ("Failed to build sudo dbus reply\n"));
+                    dbus_message_unref(reply);
+                    sbus_disconnect(conn);
+                    return SSS_SUDO_RESPONDER_REPLY_ERR;
+                }
+
+                dbus_message_iter_init_append(reply, &msg_iter);
+
+                if(!dbus_message_iter_open_container(&msg_iter,
+                                                     DBUS_TYPE_ARRAY,
+                                                     "s",
+                                                     &subItem)) {
+                    fprintf(stderr, "Out Of Memory!\n");
+                    return SSS_SUDO_RESPONDER_REPLY_ERR;
+                }
+
+                    for(command_array = msg->command ; command_size-- ; command_array++) {
+
+                        if (!dbus_message_iter_append_basic(&subItem,
+                                                            DBUS_TYPE_STRING,
+                                                            command_array)) {
+                            fprintf(stderr, "Out Of Memory!\n");
+                            return SSS_SUDO_RESPONDER_REPLY_ERR;
+                        }
+                    }
+
+               if (!dbus_message_iter_close_container(&msg_iter,&subItem)) {
+                   fprintf(stderr, "Out Of Memory!\n");
+                   return SSS_SUDO_RESPONDER_REPLY_ERR;
+               }
+
+               if(dbus_dhash_to_msg_iter(&env_table,&msg_iter) != SSS_SBUS_CONV_SUCCESS){
+                   fprintf(stderr,"fatal: env message framing failed.");
+                   return SSS_SUDO_RESPONDER_DHASH_ERR;
+               }
 
             /* send reply back */
         sbus_conn_send_reply(conn, reply);
         dbus_message_unref(reply);
 
         sudocli->initialized = true;
+        free(result);
         return EOK;
 }
 
diff --git a/src/responder/sudo/sudosrv.h b/src/responder/sudo/sudosrv.h
index 985499d1..c5db6a15 100644
--- a/src/responder/sudo/sudosrv.h
+++ b/src/responder/sudo/sudosrv.h
@@ -41,6 +41,7 @@
 #define SUDO_METHOD_QUERY "queryService"
 #endif
 
+#define SSS_SUDO_RESPONDER_HEADER 0x43256
 
 static int sudo_query_validation(DBusMessage *message, struct sbus_connection *conn);
 struct sbus_method sudo_methods[] = {
diff --git a/src/sbus/sssd_dbus_messages_helpers.c b/src/sbus/sssd_dbus_messages_helpers.c
index bc51ecdc..bbcee7e3 100644
--- a/src/sbus/sssd_dbus_messages_helpers.c
+++ b/src/sbus/sssd_dbus_messages_helpers.c
@@ -50,7 +50,7 @@ int dbus_dhash_to_msg_iter(hash_table_t **table_in,
            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) {
 
@@ -122,12 +122,11 @@ int dbus_msg_iter_to_dhash(DBusMessageIter *iter, hash_table_t **table_out)
         }
 
         if(DBUS_TYPE_ARRAY != dbus_message_iter_get_arg_type(&msg_iter)) {
-            fprintf(stderr,"dictionary is invalid");
+            fprintf(stderr,"message Iter is invalid\n");
             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);
             }
 
@@ -149,7 +148,7 @@ int dbus_msg_iter_to_dhash(DBusMessageIter *iter, hash_table_t **table_out)
                         value.type = HASH_VALUE_PTR;
                         dbus_message_iter_get_basic(&dict_iter, &tmp);
                         key.str = tmp;
-                        fprintf(stderr," %s ",key.str);
+                        fprintf(stdout,"%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");
@@ -157,14 +156,14 @@ int dbus_msg_iter_to_dhash(DBusMessageIter *iter, hash_table_t **table_out)
                         }
                         dbus_message_iter_get_basic(&dict_iter, &tmp);
                         value.ptr = tmp;
-                        fprintf(stderr,": %s \n",(char *)value.ptr);
+                        fprintf(stdout,"%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.");
+                                 /* struct ended. */
                                  break;
                              }
                     }
diff --git a/src/sss_client/sudo_plugin/sss_sudo_cli.h b/src/sss_client/sudo_plugin/sss_sudo_cli.h
index 1c3ba6e2..cebaec7d 100644
--- a/src/sss_client/sudo_plugin/sss_sudo_cli.h
+++ b/src/sss_client/sudo_plugin/sss_sudo_cli.h
@@ -62,9 +62,11 @@ struct sss_cli_req_data {
 };
 
 enum sss_status {
+    SSS_STATUS_SUCCESS,
+    SSS_STATUS_FAILED,
     SSS_STATUS_TRYAGAIN,
-    SSS_STATUS_UNAVAIL,
-    SSS_STATUS_SUCCESS
+    SSS_STATUS_UNAVAIL
+
 };
 
 #endif 
diff --git a/src/sss_client/sudo_plugin/sss_sudoplugin.c b/src/sss_client/sudo_plugin/sss_sudoplugin.c
index 5cde318f..00838165 100644
--- a/src/sss_client/sudo_plugin/sss_sudoplugin.c
+++ b/src/sss_client/sudo_plugin/sss_sudoplugin.c
@@ -854,9 +854,10 @@ int sss_sudo_make_request(struct sss_cli_req_data *rd,
 {
 
 
-   char ** command_array;
-   int err_status;
-   int status;
+   char ** command_array,**ui;
+   char * result_str;
+   int err_status,count;
+   dbus_uint32_t status,command_array_out_size;
 
    DBusConnection* conn;
    DBusError err;
@@ -870,6 +871,7 @@ int sss_sudo_make_request(struct sss_cli_req_data *rd,
    
    hash_table_t *env_table;
    hash_table_t *settings_table;
+   hash_table_t *env_table_out;
 
    fprintf(stdout,"Calling remote method to pack message\n");
    
@@ -961,6 +963,12 @@ int sss_sudo_make_request(struct sss_cli_req_data *rd,
       return SSS_SUDO_MESSAGE_ERR;
    }
    
+       if (!dbus_message_iter_append_basic(&msg_iter,
+                                            DBUS_TYPE_UINT32,
+                                            &msg.command_count)) {
+            fprintf(stderr, "Out Of Memory!\n");
+            return SSS_SUDO_MESSAGE_ERR;
+        }
 
    if(!dbus_message_iter_open_container(&msg_iter,
                                         DBUS_TYPE_ARRAY,
@@ -1016,8 +1024,10 @@ int sss_sudo_make_request(struct sss_cli_req_data *rd,
 
    ret = dbus_message_get_args(dbus_reply,
                                &err,
-                               DBUS_TYPE_UINT16,
-                               &status,
+                               DBUS_TYPE_UINT32,&status,
+                               DBUS_TYPE_STRING,&result_str,
+                               DBUS_TYPE_ARRAY,DBUS_TYPE_STRING,&command_array,
+                               &command_array_out_size,
                                DBUS_TYPE_INVALID);
     if (!ret) {
         fprintf (stderr,"Failed to parse reply, killing connection\n");
@@ -1028,8 +1038,29 @@ int sss_sudo_make_request(struct sss_cli_req_data *rd,
         return SSS_SUDO_REPLY_ERR;
     }
     
-   fprintf(stdout,"Got Reply: %d\n", status);
-   
+    fprintf(stdout,"----------Reply--------:\n"
+            "Header : %d \nResult status : %s\n"
+            "Command : ", status,result_str);
+
+   for(count =0;count< command_array_out_size;count++){
+       printf("%s ", command_array[count]);
+   }
+   if (!dbus_message_iter_init(dbus_reply, &msg_iter)) {
+         fprintf(stderr, "Reply iterator failed!\n");
+         return SSS_SUDO_REPLY_ERR;
+   }
+
+   dbus_message_iter_next(&msg_iter);
+   dbus_message_iter_next(&msg_iter);
+   dbus_message_iter_next(&msg_iter);
+
+   if(dbus_msg_iter_to_dhash(&msg_iter, &env_table_out) != SSS_SBUS_CONV_SUCCESS){
+               fprintf(stderr, "env message iterator corrupted!\n");
+               return SSS_SUDO_REPLY_ERR;
+
+           }
+   printf("---------Reply End----------");
+
    // free reply and close connection
    /* free message */
    dbus_message_unref(dbus_msg);
@@ -1037,8 +1068,10 @@ int sss_sudo_make_request(struct sss_cli_req_data *rd,
    dbus_connection_close(conn);
 
 
-
-return SSS_STATUS_SUCCESS;
+if(strncmp(result_str,"PASS",4)==0)
+    return SSS_STATUS_SUCCESS;
+else
+    return SSS_STATUS_FAILED;
 
 }
 
@@ -1049,7 +1082,7 @@ void free_all( void )
   free(msg.prompt);
   free(msg.runas_user);
   free(msg.runas_group);
-  free(msg.network_addrs);
+  //free(msg.network_addrs);
   free(user_information.username);
   
 }