src/process1.c

   1 #include <stdio.h>
   2 #include <stdlib.h>
   3 #include <string.h>
   4
   5 /* open/read/write/close */
   6 #include <fcntl.h>
   7
   8 /* Signals handling.. */
   9 #include <signal.h>
  10
  11 /** If buffer is too small to hold entire string, it is incremented by this value */
  12 #define BUFFER_STEP 16
  13
  14 /** Buffer used to store line of characters */
  15 char * buffer = NULL;
  16
  17 /** Named pipe used to communnicate with process2 */
  18 char * write_pipe = "/tmp/process1pipe";
  19
  20 /** File descriptor of pipe */
  21 int file_descriptor;
  22
  23 /**
  24  * Handler for signals.
  25  */
  26 void sig_handler(int signo)
  27 {
  28         fprintf(stderr, "[%s] Received %s!\n", "process1", strsignal(signo));
  29         if (signo == SIGUSR1) {
  30         }
  31         else if (signo == SIGTERM) {
  32                 fprintf(stderr, "[%s] > Releasing resources\n", "process1");
  33                 close(write_pipe);
  34                 unlink(write_pipe);
  35
  36                 if (buffer) {
  37                         free(buffer);
  38                         buffer = NULL;
  39                 }
  40                 exit(0);
  41         }
  42         else if (signo == SIGTSTP) {
  43                 fprintf(stderr, "[%s] > Closing pipe\n", "process1");
  44                 close(write_pipe);
  45         }
  46         else if (signo == SIGCONT) {
  47                 fprintf(stderr, "[%s] > Opening pipe\n", "process1");
  48                 file_descriptor = open(write_pipe, O_WRONLY);
  49         }
  50 }
  51
  52 /**
  53  * Program reads entire lines of text from the standard input and pass them
  54  * to the process2 using created pipe.
  55  */
  56 int main(void) {
  57         /** Currently fetched from stdin character */
  58         int c;
  59
  60         /** Current buffer length*/
  61         int buffer_length = 0;
  62
  63         /** Index of the current character */
  64         int i = 0;
  65
  66         /**
  67          * Temporary buffer used as a proxy between
  68          * checking memory allocation and copying data to real buffer
  69          */
  70         char * tmp = NULL;
  71
  72         fprintf(stderr, "[%s] Init!\n", "process1");
  73
  74         /**
  75          * Register signals handled by process
  76          */
  77         if (signal(SIGUSR1, sig_handler) == SIG_ERR) {
  78                 fprintf(stderr, "can't catch SIGUSR1\n");
  79         }
  80         if (signal(SIGTERM, sig_handler) == SIG_ERR) {
  81                 fprintf(stderr, "can't catch SIGTERM\n");
  82         }
  83         if (signal(SIGTSTP, sig_handler) == SIG_ERR) {
  84                 fprintf(stderr, "can't catch SIGTSTP\n");
  85         }
  86         if (signal(SIGCONT, sig_handler) == SIG_ERR) {
  87                 fprintf(stderr, "can't catch SIGCONT\n");
  88         }
  89
  90         mkfifo(write_pipe, 0666);
  91
  92         file_descriptor = open(write_pipe, O_WRONLY);
  93
  94         do {
  95                 c = fgetc(stdin);
  96
  97                 /*
  98                  * Check if current index is bigger than current buffer size.
  99                  * If so increment buffer size. On error release memory, and set
 100                  * appropriate flags.
 101                  */
 102                 if (i >= buffer_length) {
 103                         tmp = NULL;
 104                         buffer_length += BUFFER_STEP;
 105                         tmp = (char*) realloc(buffer, buffer_length);
 106                         if (tmp == NULL) {
 107                                 fprintf(stderr, "[%s] Memory allocation problem on read!\n", "process1");
 108                                 free(buffer);
 109                                 buffer = NULL;
 110                                 c = EOF;
 111                         }
 112                 }
 113
 114                 /*
 115                  * If there were no errors or it was not just an empty newline:
 116                  * parse data.
 117                  */
 118                 if (c != EOF || ((i == 0) && (c == 10))) {
 119                         /* If newline has been found
 120                          * return entire string and release the memory
 121                          */
 122                         if (c == 10 && (i != 0)) {
 123                                 buffer[i] = '\n';
 124                                 write(file_descriptor, buffer, strlen(buffer));
 125                                 fprintf(stderr, "[%s] buffer: %s/%d\n", "process1", buffer, strlen(buffer));
 126
 127                                 buffer_length = 0;
 128                                 i = 0;
 129
 130                                 free(buffer);
 131                                 buffer = NULL;
 132                                 tmp = NULL;
 133                         }
 134                         /*
 135                          * Normal character, add it to the buffer
 136                          */
 137                         else {
 138                                 buffer = tmp;
 139                                 buffer[i] = c;
 140
 141                                 /* Used only for debugging..*/
 142                                 /*
 143                                 printf("c: %c/%d, i: %d, bl: %d\n", c, c, i, buffer_length);
 144                                 */
 145                                 i++;
 146                         }
 147                 }
 148         } while(c != EOF);
 149
 150         /* Release resources in normal program flow exit. */
 151         close(write_pipe);
 152         unlink(write_pipe);
 153
 154         if (buffer) {
 155                 free(buffer);
 156                 buffer = NULL;
 157         }
 158
 159         return 0;
 160 }