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 #include <sys/shm.h>
  12 #include <sys/msg.h>
  13
  14
  15 /** If buffer is too small to hold entire string, it is incremented by this value */
  16 #define BUFFER_STEP 16
  17
  18 /** Buffer used to store line of characters */
  19 char * buffer = NULL;
  20
  21 /** Named pipe used to communnicate with process2 */
  22 char * write_pipe = "/tmp/process1pipe";
  23
  24 /** File descriptor of pipe */
  25 int file_descriptor;
  26
  27
  28 /**
  29  * Shared memory variables
  30  */
  31 /**
  32  * Memory key for processes. Must be same between all processes to properly
  33  * communicate.
  34  */
  35 key_t shmkey = 18912;
  36 /**
  37  * Id of the shared memory
  38  */
  39 int shmid;
  40
  41 /**
  42  * Message shared by processes. Contains array of process IDs
  43  */
  44 struct message {
  45         pid_t pids[3];
  46 };
  47
  48 struct message * processes = NULL;
  49
  50 /**
  51  * Message queue variables
  52  */
  53 key_t qkey = 12356;
  54 int qid;
  55
  56 struct queue_message {
  57         long mtype;
  58         int signo[1];
  59 };
  60
  61 void notify_other_processes(int signo) {
  62         int i = 0;
  63         struct queue_message msg;
  64         msg.signo[0] = signo;
  65
  66         for (; i < 3; i++) {
  67                 pid_t pid = processes->pids[i];
  68                 // Bleh
  69                 if (i != 0 && pid != 0) {
  70                         msg.mtype = i+1;
  71                         fprintf(stderr, "[%s] Sending message of type (%d) with value %d\n", "process1", msg.mtype, msg.signo[0]);
  72                         msgsnd(qid, &msg, sizeof(int), 0);
  73                         fprintf(stderr, "[%s] Sending signal %s (%d) to PID: %d\n", "process1", strsignal(SIGUSR1), SIGUSR1, pid);
  74                         kill(pid, SIGUSR1);
  75                 }
  76         }
  77 }
  78
  79 /**
  80  * Handler for signals.
  81  */
  82 void sig_handler(int signo)
  83 {
  84         fprintf(stderr, "[%s] Received %s!\n", "process1", strsignal(signo));
  85
  86         if (signo == SIGUSR1) {
  87                 fprintf(stderr, "[%s] > Notified!\n", "process1");
  88                 struct queue_message msg;
  89                 /* Check queues from both other processes */
  90                 if (msgrcv(qid, &msg, sizeof(int), 1, 0) > 0) {
  91                         fprintf(stderr, "[%s] > Notified with value: %s!\n", "process1", strsignal(msg.signo[0]));
  92                         raise(msg.signo[0]);
  93                 }
  94                 else if (msgrcv(qid, &msg, sizeof(int), 1, 0) > 0) {
  95                         fprintf(stderr, "[%s] > Notified with value: %s!\n", "process1", strsignal(msg.signo[0]));
  96                         raise(msg.signo[0]);
  97                 }
  98         }
  99         else if (signo == SIGTERM) {
 100                 fprintf(stderr, "[%s] > Signalling other processes..\n", "process1");
 101                 processes->pids[1] = 0;
 102                 notify_other_processes(signo);
 103
 104                 fprintf(stderr, "[%s] > Releasing resources\n", "process1");
 105                 close(write_pipe);
 106                 unlink(write_pipe);
 107
 108                 if (buffer) {
 109                         free(buffer);
 110                         buffer = NULL;
 111                 }
 112                 exit(0);
 113         }
 114         else if (signo == SIGTSTP) {
 115                 fprintf(stderr, "[%s] > Closing pipe\n", "process1");
 116                 close(write_pipe);
 117                 raise (SIGSTOP);
 118         }
 119         else if (signo == SIGCONT) {
 120                 fprintf(stderr, "[%s] > Opening pipe\n", "process1");
 121                 file_descriptor = open(write_pipe, O_WRONLY);
 122         }
 123 }
 124
 125 /**
 126  * Program reads entire lines of text from the standard input and pass them
 127  * to the process2 using created pipe.
 128  */
 129 int main(void) {
 130         /** Currently fetched from stdin character */
 131         int c;
 132
 133         /** Current buffer length*/
 134         int buffer_length = 0;
 135
 136         /** Index of the current character */
 137         int i = 0;
 138
 139         /**
 140          * Temporary buffer used as a proxy between
 141          * checking memory allocation and copying data to real buffer
 142          */
 143         char * tmp = NULL;
 144
 145         fprintf(stderr, "[%s] Init!\n", "process1");
 146
 147         /**
 148          * Register signals handled by process
 149          */
 150         if (signal(SIGUSR1, sig_handler) == SIG_ERR) {
 151                 fprintf(stderr, "can't catch SIGUSR1\n");
 152         }
 153         if (signal(SIGTERM, sig_handler) == SIG_ERR) {
 154                 fprintf(stderr, "can't catch SIGTERM\n");
 155         }
 156         if (signal(SIGTSTP, sig_handler) == SIG_ERR) {
 157                 fprintf(stderr, "can't catch SIGTSTP\n");
 158         }
 159         if (signal(SIGCONT, sig_handler) == SIG_ERR) {
 160                 fprintf(stderr, "can't catch SIGCONT\n");
 161         }
 162
 163         /*
 164          * Register memory to share with other processes, and pass current
 165          * process id to the array.
 166          */
 167         shmid = shmget(shmkey, sizeof(struct message), IPC_CREAT | 0666);
 168
 169         processes = (struct message *)shmat(shmid, NULL, 0);
 170         processes->pids[0] = getpid();
 171
 172         fprintf(stderr, "[%s] Shared pid: %d\n", "process1", getpid());
 173
 174         /**
 175          * Register message queue to communicate with other processes
 176          */
 177         qid = msgget(qkey, IPC_CREAT | 0666);
 178
 179         mkfifo(write_pipe, 0666);
 180
 181         file_descriptor = open(write_pipe, O_WRONLY);
 182
 183         do {
 184                 c = fgetc(stdin);
 185
 186                 /*
 187                  * Check if current index is bigger than current buffer size.
 188                  * If so increment buffer size. On error release memory, and set
 189                  * appropriate flags.
 190                  */
 191                 if (i >= buffer_length) {
 192                         tmp = NULL;
 193                         buffer_length += BUFFER_STEP;
 194                         tmp = (char*) realloc(buffer, buffer_length);
 195                         if (tmp == NULL) {
 196                                 fprintf(stderr, "[%s] Memory allocation problem on read!\n", "process1");
 197                                 free(buffer);
 198                                 buffer = NULL;
 199                                 c = EOF;
 200                         }
 201                 }
 202
 203                 /*
 204                  * If there were no errors or it was not just an empty newline:
 205                  * parse data.
 206                  */
 207                 if (c != EOF || ((i == 0) && (c == 10))) {
 208                         /* If newline has been found
 209                          * return entire string and release the memory
 210                          */
 211                         if (c == 10 && (i != 0)) {
 212                                 buffer[i] = '\n';
 213                                 write(file_descriptor, buffer, strlen(buffer));
 214                                 fprintf(stderr, "[%s] buffer: %s/%d\n", "process1", buffer, strlen(buffer));
 215
 216                                 buffer_length = 0;
 217                                 i = 0;
 218
 219                                 free(buffer);
 220                                 buffer = NULL;
 221                                 tmp = NULL;
 222                         }
 223                         /*
 224                          * Normal character, add it to the buffer
 225                          */
 226                         else {
 227                                 buffer = tmp;
 228                                 buffer[i] = c;
 229
 230                                 /* Used only for debugging..*/
 231                                 /*
 232                                 printf("c: %c/%d, i: %d, bl: %d\n", c, c, i, buffer_length);
 233                                 */
 234                                 i++;
 235                         }
 236                 }
 237         } while(c != EOF);
 238
 239         /* Release resources in normal program flow exit. */
 240         close(write_pipe);
 241         unlink(write_pipe);
 242
 243         if (buffer) {
 244                 free(buffer);
 245                 buffer = NULL;
 246         }
 247
 248         return 0;
 249 }