API tools faq
paste
Guest User

Untitled

a guest
May 1st, 2024
73
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 15.08 KB | None | 0 0
raw download clone embed print report
  1. #include <csse2310a3.h>
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. #include <string.h>
  5. #include <dirent.h>
  6. #include <errno.h>
  7. #include <fcntl.h>
  8. #include <sys/stat.h>
  9. #include <unistd.h>
  10. #include <sys/wait.h>
  11. #include <locale.h>
  12. #include <time.h>
  13. #include <assert.h>
  14. #include <stdbool.h>
  15. #include <signal.h>
  16.  
  17. #define READ_END 0
  18. #define WRITE_END 1
  19. #define NOT_ACTIVE 0
  20. #define ACTIVE 1
  21. #define NOT_GIVEN NULL
  22. #define PIPE_ENDS 2
  23. #define ZERO 0;
  24.  
  25. typedef struct {
  26.     int attempts;
  27.     int successes;
  28.     int nonZeros;
  29.     int sigterms;
  30.     int nonExecs;
  31. } Statistics;
  32.  
  33. typedef struct {
  34.     int** pipes;
  35.     int pipeCount;
  36.     int stdoutfp;
  37. } PipeManager;
  38.  
  39. typedef struct {
  40.     struct dirent** entries;
  41.     int entryCount;
  42. } DirectoryManager;
  43.  
  44. typedef struct {
  45.     struct stat sbuf;
  46.     char* path;
  47.     char* absolutePath;
  48. } AbsPath;
  49.  
  50. typedef struct {
  51.     int descend;
  52.     int parallel;
  53.     int statistics;
  54.     int allfiles;
  55.     int directoryGiven;
  56.     int everyFile;
  57.     char* cmd;
  58.     CommandPipeline* cm;
  59.     char* directory;
  60.     Statistics* stats;
  61.     PipeManager* pm;
  62. } Params;
  63.  
  64. typedef enum {
  65.     STANDARD = 0,
  66.     USAGE = 8,
  67.     DIRECTORY = 2,
  68.     COMMAND = 12,
  69.     FAILURE = 17,
  70.     INTERRUPTED = 20,
  71.     DNE = 99
  72. } ExitStatus;
  73.  
  74. const char* const directoryArg = "--directory";
  75. const char* const statisticsArg = "--statistics";
  76. const char* const parallelArg = "--parallel";
  77. const char* const allfilesArg = "--allfiles";
  78. const char* const descendArg = "--descend";
  79. static bool sigint = false;
  80.  
  81. const char* const filePlaceHolder = "{}";
  82.  
  83. const char* const errorUsage
  84.         = "Usage: uqfindexec [--directory dirname] [--statistics] [--parallel] "
  85.           "[--allfiles] [--descend] [cmd]\n";
  86. const char* const errorCannotRead
  87.         = "uqfindexec: cannot read directory \"%s\"\n";
  88. const char* const errorInvalidCmd = "uqfindexec: command is invalid\n";
  89. const char* const errorBadInputFile
  90.         = "uqfindexec: unable to read \"%s\" while processing \"%s\"\n";
  91. const char* const errorBadOutFile = "uqfindexec: unable to open \"%s\" for "
  92.                                     "writing while processing \"%s\"\n";
  93. const char* const errorBadCmd
  94.         = "uqfindexec: unable to execute \"%s\" while processing \"%s\"\n";
  95. const char* const statistics
  96.         = "Attempted to operate on a total of %s files\n-  operations "
  97.           "succeeded for %s files\n-  non-zero exit status detected when "
  98.           "processing %s files\n- processing was terminated by signal for %s "
  99.           "files\n- operations unable to be executed for %s files\n";
  100. /////////////////////////////////////////////////////////
  101. void usage_error(void);
  102. void directory_error(const char* directoryName);
  103. void cmd_error(void);
  104. void input_file_error(const char* f1, const char* f2, int errv);
  105. void output_file_error(const char* f1, const char* f2, int errv);
  106. void run_cmd_error(const char* f, const char* cmd, int errv);
  107. void statistics_exit(Statistics* stats);
  108. void free_directory(DirectoryManager dm);
  109. int hidden_filter(const struct dirent* directory);
  110. Params directory_parser(Params params);
  111. Params cmd_parser(Params params);
  112. DirectoryManager directory_manager_initialiser(Params params);
  113. void execute_command(Params params, char* path);
  114. Params prepare_command(Params params);
  115. void sigint_handler(int sig);
  116. AbsPath sbuf_initialiser(char* directory, char* path);
  117. Params validate_arguments(Params params);
  118. void exiter(Statistics* stats);
  119. Params process_command_line(int argc, char** argv);
  120. Params path_adder(Params params, char* path);
  121. void redirect_io(Params params, char* path, char* basePath, int cmd);
  122. void execute_commands(Params params, char* path, char* basePath, int cmd);
  123.  
  124. /////////////////////////////////////////////////////////
  125.  
  126. Params process_command_line(int argc, char** argv)
  127. {
  128.     Params params = {NOT_ACTIVE, NOT_ACTIVE, NOT_ACTIVE, NOT_ACTIVE, NOT_ACTIVE,
  129.             NOT_ACTIVE, NOT_GIVEN, NOT_GIVEN, NOT_GIVEN, NOT_GIVEN, NOT_GIVEN};
  130.  
  131.     argc--;
  132.     argv++;
  133.  
  134.     while (argc && strncmp(argv[0], "--", 2) == 0) {
  135.         if (!strcmp(argv[0], directoryArg) && argc != 1 && strlen(argv[1]) > 0
  136.                 && strncmp(argv[1], "--", 2) && !params.directoryGiven) {
  137.             params.directoryGiven = ACTIVE;
  138.             params.directory = argv[1];
  139.             argc -= 2;
  140.             argv += 2;
  141.         } else if (!strcmp(argv[0], allfilesArg) && !params.allfiles) {
  142.             params.allfiles = ACTIVE;
  143.             argc--;
  144.             argv++;
  145.         } else if (!strcmp(argv[0], descendArg) && !params.descend) {
  146.             params.descend = ACTIVE;
  147.             argc--;
  148.             argv++;
  149.         } else if (!strcmp(argv[0], statisticsArg) && !params.statistics) {
  150.             params.statistics = ACTIVE;
  151.             argc--;
  152.             argv++;
  153.         } else if (!strcmp(argv[0], parallelArg) && !params.parallel) {
  154.             params.parallel = ACTIVE;
  155.             argc--;
  156.             argv++;
  157.         } else {
  158.             usage_error();
  159.         }
  160.     }
  161.     if (argc == 1 && strncmp(argv[argc - 1], "--", 2) != 0
  162.             && strcmp(argv[argc - 1], "")) {
  163.         params.cmd = argv[argc - 1];
  164.         argc--;
  165.         argv++;
  166.     }
  167.     if (argc) {
  168.         usage_error();
  169.     }
  170.     params = cmd_parser(params);
  171.     return params;
  172. }
  173.  
  174. Params validate_arguments(Params params)
  175. {
  176.     if (params.directoryGiven) {
  177.         struct stat sbuf;
  178.         if (stat(params.directory, &sbuf)) {
  179.             directory_error(params.directory);
  180.         }
  181.         if (!S_ISDIR(sbuf.st_mode)) {
  182.             directory_error(params.directory);
  183.         }
  184.     } else {
  185.         params.directory = ".";
  186.     }
  187.     params = directory_parser(params);
  188.     return params;
  189. }
  190.  
  191. Params path_adder(Params params, char* path)
  192. {
  193.     for (int i = 0; i < params.cm->numCmds; i++) {
  194.         int j = 0;
  195.         while (params.cm->cmdArray[i][j] != NULL) {
  196.             if (!strcmp(params.cm->cmdArray[i][j], "{}")) {
  197.                 params.cm->cmdArray[i][j] = path;
  198.             }
  199.             j++;
  200.         }
  201.     }
  202.     return params;
  203. }
  204.  
  205. void redirect_io(Params params, char* path, char* basePath, int cmd)
  206. {
  207.     int inputFile;
  208.     int outputFile;
  209.     if (params.cm->stdinFileName && cmd == 0) {
  210.         if (!strcmp(params.cm->stdinFileName, "{}")) {
  211.             params.cm->stdinFileName = path;
  212.         }
  213.         inputFile = open(params.cm->stdinFileName, O_RDONLY, S_IWUSR | S_IRUSR);
  214.         if (inputFile < 0) {
  215.             if (params.directoryGiven) {
  216.                 input_file_error(params.cm->stdinFileName, path, DNE);
  217.             } else {
  218.                 input_file_error(params.cm->stdinFileName, basePath, DNE);
  219.             }
  220.         } else {
  221.             dup2(inputFile, STDIN_FILENO);
  222.             close(inputFile);
  223.         }
  224.     }
  225.     if (params.cm->stdoutFileName && (cmd + 1) == params.cm->numCmds) {
  226.         if (strstr(params.cm->stdoutFileName, "{}")) {
  227.             char* brackets = strtok(params.cm->stdoutFileName, "{}");
  228.             path = strcat(path, brackets);
  229.             params.cm->stdoutFileName = path;
  230.         }
  231.         outputFile = open(params.cm->stdoutFileName,
  232.                 O_WRONLY | O_CREAT | O_TRUNC, S_IRWXU);
  233.         if (outputFile < 0) {
  234.             if (params.directoryGiven) {
  235.                 output_file_error(params.cm->stdoutFileName, path, DNE);
  236.             } else {
  237.                 output_file_error(params.cm->stdoutFileName, basePath, DNE);
  238.             }
  239.         } else {
  240.             dup2(outputFile, STDOUT_FILENO);
  241.             close(outputFile);
  242.         }
  243.     }
  244. }
  245.  
  246. PipeManager* pipe_manager(Params params) {
  247.     PipeManager* pm = malloc(sizeof(PipeManager));
  248.     pm->pipeCount = params.cm->numCmds - 1;
  249.     pm->pipes = malloc(sizeof(int*) * pm->pipeCount);
  250.     for (int i = 0; i < pm->pipeCount; i++) {
  251.         int fp[PIPE_ENDS];
  252.         pipe(fp);
  253.         pm->pipes[i] = fp;
  254.     }
  255.     return pm;
  256. }
  257.  
  258. void cmd_pipeliner(Params params, int cmd) {
  259.     if (params.cm->numCmds == 1) {
  260.         return;
  261.     } else if (!params.pm) {
  262.         params.pm = pipe_manager(params);
  263.     }
  264.     if (cmd == 0) {
  265.         close(params.pm->pipes[cmd][READ_END]);
  266.         params.pm->stdoutfp = dup(STDOUT_FILENO);
  267.         dup2(params.pm->pipes[cmd][WRITE_END], STDOUT_FILENO);
  268.         fflush(stdout);
  269.         close(params.pm->pipes[cmd][WRITE_END]);
  270.     }
  271.     else if (cmd + 1 == params.cm->numCmds) {
  272.         close(params.pm->pipes[cmd - 1][WRITE_END]);
  273.         dup2(params.pm->pipes[cmd - 1][READ_END], STDIN_FILENO);
  274.         close(params.pm->pipes[cmd - 1][READ_END]);
  275.         dup2(params.pm->stdoutfp, STDOUT_FILENO);
  276.         fflush(stdout);
  277.     } else {
  278.         close(params.pm->pipes[cmd - 1][WRITE_END]);
  279.         dup2(params.pm->pipes[cmd - 1][READ_END], params.pm->pipes[cmd][WRITE_END]);
  280.         close(params.pm->pipes[cmd - 1][READ_END]);
  281.     }
  282. }
  283.  
  284. void execute_commands(Params params, char* path, char* basePath, int cmd)
  285. {
  286.     redirect_io(params, path, basePath, cmd);
  287.     cmd_pipeliner(params, cmd);
  288.     execvp(params.cm->cmdArray[cmd][0], params.cm->cmdArray[cmd]);
  289.     run_cmd_error(params.cm->cmdArray[cmd][0], basePath, DNE);
  290.  
  291. }
  292.  
  293. Statistics* stats_initialiser(void)
  294. {
  295.     Statistics* stats = malloc(sizeof(Statistics));
  296.     stats->attempts = 0;
  297.     stats->successes = 0;
  298.     stats->nonZeros = 0;
  299.     stats->sigterms = 0;
  300.     stats->nonExecs = 0;
  301.     return stats;
  302. }
  303.  
  304. void update_statistics(Statistics* stats, int wstatus)
  305. {
  306.     int rval;
  307.     stats->attempts++;
  308.     if (WIFEXITED(wstatus)) {
  309.         rval = WEXITSTATUS(wstatus);
  310.         if (rval == STANDARD) {
  311.             stats->successes++;
  312.         } else if (rval == DNE) {
  313.             stats->nonExecs++;
  314.         } else {
  315.             stats->nonZeros++;
  316.         }
  317.     }
  318.     if (WIFSIGNALED(wstatus)) {
  319.         rval = WTERMSIG(wstatus);
  320.         stats->sigterms++;
  321.     }
  322. }
  323.  
  324. Params every_file_handler(Params params, AbsPath path)
  325. {
  326.     if (params.everyFile) {
  327.         if (params.directoryGiven) {
  328.             params = path_adder(params, path.absolutePath);
  329.         } else {
  330.             params = path_adder(params, path.path);
  331.         }
  332.     }
  333.     return params;
  334. }
  335.  
  336. Params prepare_command(Params params)
  337. {
  338.     DirectoryManager dm = directory_manager_initialiser(params);
  339.     params.stats = stats_initialiser();
  340.     int childrenCount = 1;
  341.     pid_t* children = malloc(sizeof(pid_t) * childrenCount);
  342.     for (int i = 0; i < dm.entryCount; i++) {
  343.         int wstatus;
  344.         pid_t child;
  345.         AbsPath path
  346.                 = sbuf_initialiser(params.directory, dm.entries[i]->d_name);
  347.         for (int j = 0; j < params.cm->numCmds; j++) {
  348.             if (!S_ISDIR(path.sbuf.st_mode) && !(child = fork())) {
  349.                 params = every_file_handler(params, path);
  350.                 execute_commands(params, path.absolutePath, path.path, j);
  351.             }
  352.             children[childrenCount - 1] = child;
  353.             childrenCount++;
  354.             waitpid(child, &wstatus, 0);
  355.             update_statistics(params.stats, wstatus);
  356.         }
  357.     }
  358.     free_directory(dm);
  359.     return params;
  360. }
  361.  
  362. void exiter(Statistics* stats)
  363. {
  364.     if (sigint) {
  365.         exit(INTERRUPTED);
  366.     }
  367.     if (stats->nonExecs) {
  368.         exit(FAILURE);
  369.     } else if (sigint) {
  370.         exit(INTERRUPTED);
  371.     }
  372.     exit(STANDARD);
  373. }
  374.  
  375. int main(int argc, char** argv)
  376. {
  377.     struct sigaction sa;
  378.     sa.sa_handler = sigint_handler;
  379.     sigaction(SIGINT, &sa, NULL);
  380.     while (!sigint) {
  381.         setlocale(LC_COLLATE, "en_AU");
  382.         Params params = process_command_line(argc, argv);
  383.         /// printf("%s and %s and %s\n",
  384.         /// params.cm->cmdArray[0][0],params.cm->cmdArray[0][1],
  385.         /// params.cm->cmdArray[0][1]);
  386.         params = validate_arguments(params);
  387.         params = prepare_command(params);
  388.         free_pipeline(params.cm);
  389.         exiter(params.stats);
  390.     }
  391. }
  392.  
  393. /////////////////////////////////////////////////////////////////
  394. // Error Handling Functions
  395. /////////////////////////////////////////////////////////////////
  396. void usage_error(void)
  397. {
  398.     fprintf(stderr, errorUsage);
  399.     exit(USAGE);
  400. }
  401.  
  402. void directory_error(const char* directoryName)
  403. {
  404.     fprintf(stderr, errorCannotRead, directoryName);
  405.     exit(DIRECTORY);
  406. }
  407.  
  408. void cmd_error(void)
  409. {
  410.     fprintf(stderr, errorInvalidCmd);
  411.     exit(COMMAND);
  412. }
  413.  
  414. void input_file_error(const char* f1, const char* f2, int errv)
  415. {
  416.     fprintf(stderr, errorBadInputFile, f1, f2);
  417.     exit(errv);
  418. }
  419.  
  420. void output_file_error(const char* f1, const char* f2, int errv)
  421. {
  422.     fprintf(stderr, errorBadOutFile, f1, f2);
  423.     exit(errv);
  424. }
  425.  
  426. void run_cmd_error(const char* f, const char* cmd, int errv)
  427. {
  428.     fprintf(stderr, errorBadCmd, f, cmd);
  429.     exit(errv);
  430. }
  431.  
  432. void statistics_exit(Statistics* stats)
  433. {
  434.     fprintf(stderr, statistics, stats->attempts, stats->successes,
  435.             stats->nonZeros, stats->sigterms, stats->nonExecs);
  436.     exiter(stats);
  437. }
  438.  
  439. void sigint_handler(int sig)
  440. {
  441.     if (sig == SIGINT) {
  442.         sigint = true;
  443.     }
  444.     exit(INTERRUPTED);
  445. }
  446.  
  447. /////////////////////////////////////////////////////////////////
  448. // Parser, Manager and Filter Functions
  449. /////////////////////////////////////////////////////////////////
  450. int hidden_filter(const struct dirent* directory)
  451. {
  452.     return !(directory->d_name[0] == '.');
  453. }
  454.  
  455. Params cmd_parser(Params params)
  456. {
  457.     if (params.cmd) {
  458.         params.cm = parse_pipeline_string(params.cmd);
  459.     } else {
  460.         params.cm = parse_pipeline_string("echo {}");
  461.     }
  462.     if (params.cm == NOT_GIVEN) {
  463.         cmd_error();
  464.     } else {
  465.         int j = 0;
  466.         while (params.cm->cmdArray[0][j] != NULL) {
  467.             if (!strcmp(params.cm->cmdArray[0][j], "{}")) {
  468.                 params.everyFile = ACTIVE;
  469.                 return params;
  470.             }
  471.             j++;
  472.         }
  473.     }
  474.     return params;
  475. }
  476.  
  477. Params directory_parser(Params params)
  478. {
  479.     if (params.directoryGiven
  480.             && params.directory[strlen(params.directory) - 1] != '/') {
  481.         strcat(params.directory, "/");
  482.     } else if (!strcmp(params.directory, ".")) {
  483.         params.directory = "./";
  484.     }
  485.     return params;
  486. }
  487.  
  488. DirectoryManager directory_manager_initialiser(Params params)
  489. {
  490.     struct dirent** entries;
  491.     int entryCount;
  492.     if (params.allfiles) {
  493.         entryCount = scandir(params.directory, &entries, NULL, alphasort);
  494.     } else {
  495.         entryCount
  496.                 = scandir(params.directory, &entries, hidden_filter, alphasort);
  497.     }
  498.     DirectoryManager dm = {entries, entryCount};
  499.     return dm;
  500. }
  501.  
  502. AbsPath sbuf_initialiser(char* directory, char* path)
  503. {
  504.     struct stat sbuf;
  505.     char absolutePath[PATH_MAX];
  506.     strcpy(absolutePath, directory);
  507.     strcat(absolutePath, path);
  508.     stat(absolutePath, &sbuf);
  509.     AbsPath abs = {sbuf, path, absolutePath};
  510.     return abs;
  511. }
  512.  
  513. /////////////////////////////////////////////////////////////////
  514. // Memory Freeing Functions
  515. /////////////////////////////////////////////////////////////////
  516. void free_directory(DirectoryManager dm)
  517. {
  518.     for (int i = 0; i < dm.entryCount; i++) {
  519.         free(dm.entries[i]);
  520.     }
  521.     free(dm.entries);
  522. }
Advertisement
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!