fixed memory leaks

shell.c

@@ -18,95 +18,59 @@ void cleanup(command_t* p_cmd) {
         free(p_cmd->argv[i]);
         p_cmd->argv[i] = NULL;
     }
-}
 
-/**
- * Parses line (input from user) into command_t* p_cmd.
- *
- * Determine the number of arguments via string parsing.
- * Then, set p_cmd->argc to the correct value,
- * and allocate memory for p_cmd->argv.
- * Finally, ***copy*** the arguments from line into p_cmd->argv.
- *
- * When copying the arguments, do not simply assign pointers. You must
- * use str(n)cpy (or reimplement its logic) to copy the arguments.
- *
- * p_cmd is NULL when this function is called (see main.c).
- *
- * Example 1: If line is "cd /mnt/cdrom", then the fields in p_cmd should be
- * {argc = 2, argv = {"cd", "mnt/cdrom", NULL}}
- *
- * Example 2: If line is "ls -la", then the fields in p_cmd should be
- * {argc = 2, argv = {"ls, "-la", NULL}}
- *
- * Example 3: If line is NULL, then the fields in p_cmd should be {argc =
- * 0, argv = {NULL}}
- *
- * Example 4: If line is "   ls   -la   ", then the fields in p_cmd should be
- * the same as in example 2. Note the additional whitespace in the input.
- *
- * We recommend using strtok to handle this parsing.
- * https://systems-encyclopedia.cs.illinois.edu/articles/c-strtok/
- *
- * strtok's functionality is similar to that of split in Python or Java.
- * For example, in Python, we can do
- *
- * >>> "cd /mnt/cdrom".split(" ")
- * ['cd', '/mnt/cdrom']
- *
- * When used correctly, strtok will handle all of the above cases correctly.
- * Alternatively, you may reimplement tokenizing logic yourself, but be sure to
- * handle example 4 (extra whitespace) correctly.
- *
- * NOTE: strtok mutates the input char* (by inserting null terminators). So, to
- * be safe, you should use strtok on a clone of the input char*. You can create
- * a clone using strdup.
- *
- * @param line string input from user
- * @param p_cmd pointer to struct that will store the parsed command
- * @return void
- */
+    free(p_cmd->argv);
+    p_cmd->argv = NULL;
+}
 
 void parse(char* line, command_t* p_cmd) {
     char* line_copy = strdup(line);
-    char* argc_token = strtok(line_copy, " ");
+    char* token = strtok(line_copy, " ");
     p_cmd->argc = 0;
 
-    while (argc_token != NULL) {
+    while (token != NULL) {
         p_cmd->argc++;
-        argc_token = strtok(NULL, " ");
+        token = strtok(NULL, " ");
     }
 
+    free(line_copy);
+
     alloc_mem_for_argv(p_cmd);
 
     line_copy = strdup(line);
-    char* argv_token = strtok(line_copy, " ");
+    token = strtok(line_copy, " ");
 
     for (int i = 0; i < p_cmd->argc; i++) {
-        strcpy(p_cmd->argv[i], argv_token);
-        argv_token = strtok(NULL, " ");
+        strcpy(p_cmd->argv[i], token);
+        token = strtok(NULL, " ");
     }
+
+    free(line_copy);
 }
 
 bool find_full_path(command_t* p_cmd) {
-    char* path_tokens = strtok(getenv("PATH"), ":");
+    char* path = strdup(getenv("PATH"));
+    char* token = strtok(path, ":");
 
-    while (path_tokens != NULL) {
+    while (token != NULL) {
         char* full_path = (char*)malloc(MAX_ARG_LEN * sizeof(char));
-        strcpy(full_path, path_tokens);
+        strcpy(full_path, token);
         strcat(full_path, "/");
         strcat(full_path, p_cmd->argv[0]);
 
         if (access(full_path, F_OK) == 0) {
             strcpy(p_cmd->argv[0], full_path);
+            free(path);
             free(full_path);
             return true;
         }
 
         free(full_path);
-        path_tokens = strtok(NULL, ":");
+        token = strtok(NULL, ":");
     }
 
+    free(path);
+
     return false;
 }