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 /** If buffer is too small to hold entire string, it is incremented by this value */
   9 #define BUFFER_STEP 16
  10
  11 /**
  12  * Program reads entire lines of text from the standard input and pass them
  13  * to the process2 using created pipe.
  14  */
  15 int main(void) {
  16         /** Currently fetched from stdin character */
  17         int c;
  18
  19         /** Buffer used to store line of characters */
  20         char * buffer = NULL;
  21
  22         /** Current buffer length*/
  23         int buffer_length = 0;
  24
  25         /** Index of the current character */
  26         int i = 0;
  27
  28         /**
  29          * Temporary buffer used as a proxy between
  30          * checking memory allocation and copying data to real buffer
  31          */
  32         char * tmp = NULL;
  33
  34         /** Named pipe used to communnicate with process2 */
  35         char * write_pipe = "/tmp/process1pipe";
  36
  37         /** File descriptor of pipe */
  38         int file_descriptor;
  39
  40         mkfifo(write_pipe, 0666);
  41
  42         file_descriptor = open(write_pipe, O_WRONLY);
  43
  44         do {
  45                 c = fgetc(stdin);
  46
  47                 /*
  48                  * Check if current index is bigger than current buffer size.
  49                  * If so increment buffer size. On error release memory, and set
  50                  * appropriate flags.
  51                  */
  52                 if (i >= buffer_length) {
  53                         tmp = NULL;
  54                         buffer_length += BUFFER_STEP;
  55                         tmp = (char*) realloc(buffer, buffer_length);
  56                         if (tmp == NULL) {
  57                                 fprintf(stderr, "[%s] Memory allocation problem on read!\n", "process1");
  58                                 free(buffer);
  59                                 buffer = NULL;
  60                                 c = EOF;
  61                         }
  62                 }
  63
  64                 /*
  65                  * If there were no errors or it was not just an empty newline:
  66                  * parse data.
  67                  */
  68                 if (c != EOF || ((i == 0) && (c == 10))) {
  69                         /* If newline has been found
  70                          * return entire string and release the memory
  71                          */
  72                         if (c == 10 && (i != 0)) {
  73                                 buffer[i] = '\n';
  74                                 write(file_descriptor, buffer, strlen(buffer));
  75                                 fprintf(stderr, "[%s] buffer: %s/%d\n", "process1", buffer, strlen(buffer));
  76
  77                                 buffer_length = 0;
  78                                 i = 0;
  79
  80                                 free(buffer);
  81                                 buffer = NULL;
  82                                 tmp = NULL;
  83                         }
  84                         /*
  85                          * Normal character, add it to the buffer
  86                          */
  87                         else {
  88                                 buffer = tmp;
  89                                 buffer[i] = c;
  90
  91                                 /* Used for debug..*/
  92                                 /*
  93                                 printf("c: %c/%d, i: %d, bl: %d\n", c, c, i, buffer_length);
  94                                 */
  95                                 i++;
  96                         }
  97                 }
  98         } while(c != EOF);
  99
 100         close(write_pipe);
 101         unlink(write_pipe);
 102
 103         if (buffer) {
 104                 free(buffer);
 105                 buffer = NULL;
 106         }
 107
 108         return 0;
 109 }