X-Git-Url: https://git.dlugolecki.net.pl/?a=blobdiff_plain;f=src%2Fprocess2.c;h=861919ce8b45b606fc11579ace0f6de0de3030e3;hb=963f77561737c9098d160a4b1d308c71ab0fdef8;hp=4db50e07f72c1ad7593bbfd6f8ef7aad9a568088;hpb=a5d6603b22bfb2332b084726633f6d13abc1d484;p=wsti_so.git diff --git a/src/process2.c b/src/process2.c index 4db50e0..861919c 100644 --- a/src/process2.c +++ b/src/process2.c @@ -1,28 +1,138 @@ #include +/* exit.. */ +#include +/* strsignal... */ +#include /* open/read/write/close */ #include +/* Signals handling.. */ +#include + +#include + /** If buffer is too small to hold entire string, it is incremented by this value */ #define BUFFER_STEP 16 +/** Named pipe used to communicate with process1 */ +char * read_pipe = "/tmp/process1pipe"; + +/** Named pipe used to communicate with process3 */ +char * write_pipe = "/tmp/process2pipe"; + +/** Descriptor of input pipe */ +int read_descriptor; + +/** Descriptor of output pipe */ +int write_descriptor; + + /** - * Program grabs data from process1, calculates number of characters in each line - * and pass the value to process3. + * Shared memory variables */ -int main(void) { - /** Named pipe used to communicate with process1 */ - char * read_pipe = "/tmp/process1pipe"; - /** Named pipe used to communicate with process3 */ - char * write_pipe = "/tmp/process2pipe"; +/** + * Memory key for processes. Must be same between all processes to properly + * communicate. + */ +key_t shmkey = 18912; +/** + * Id of the shared memory + */ +int shmid; - /** Descriptor of input pipe */ - int read_descriptor; +/** + * Message shared by processes. Contains array of process IDs + */ +struct message { + pid_t pids[3]; +}; + +struct message * processes = NULL; - /** Descriptor of output pipe */ - int write_descriptor; +/** + * Message queue variables + */ +key_t qkey = 12356; +int qid; + +struct queue_message { + long mtype; + int signo[1]; +}; + +void notify_other_processes(int signo) { + int i = 0; + struct queue_message msg; + msg.signo[0] = signo; + + for (; i < 3; i++) { + pid_t pid = processes->pids[i]; + // Bleh + if (i != 1 && pid != 0) { + msg.mtype = i+1; + fprintf(stderr, "[%s] Sending message of type (%d) with value %d\n", "process1", msg.mtype, msg.signo[0]); + msgsnd(qid, &msg, sizeof(msg), 0); + fprintf(stderr, "[%s] Sending signal %s (%d) to PID: %d\n", "process2", strsignal(SIGUSR1), SIGUSR1, pid); + kill(pid, SIGUSR1); + } + } +} +/** + * Handler for signals. + */ +void sig_handler(int signo) +{ + fprintf(stderr, "[%s] Received %s!\n", "process2", strsignal(signo)); + if (signo == SIGUSR1) { + fprintf(stderr, "[%s] > Notified!\n", "process2"); + struct queue_message msg; + /* Check queues from both other processes */ + if (msgrcv(qid, &msg, sizeof(int), 2, 0) > 0) { + fprintf(stderr, "[%s] > Notified with value: %s!\n", "process2", strsignal(msg.signo[0])); + raise(msg.signo[0]); + } + else if (msgrcv(qid, &msg, sizeof(int), 2, 0) > 0) { + fprintf(stderr, "[%s] > Notified with value: %s!\n", "process2", strsignal(msg.signo[0])); + raise(msg.signo[0]); + } + } + else if (signo == SIGTERM) { + fprintf(stderr, "[%s] > Signalling other processes..\n", "process2"); + processes->pids[1] = 0; + notify_other_processes(signo); + + fprintf(stderr, "[%s] > Releasing resources\n", "process2"); + close(read_descriptor); + close(write_descriptor); + unlink(write_descriptor); + exit(0); + } + else if (signo == SIGTSTP) { + fprintf(stderr, "[%s] > Close reading pipe\n", "process2"); + close(read_descriptor); + notify_other_processes(signo); + fprintf(stderr, "[%s] > Close writing pipe\n", "process2"); + close(write_descriptor); + raise (SIGSTOP); + } + else if (signo == SIGCONT) { + fprintf(stderr, "[%s] > Signalling other processes..\n", "process2"); + notify_other_processes(signo); + + fprintf(stderr, "[%s] > Opening pipes\n", "process2"); + write_descriptor = open(write_pipe, O_WRONLY); + read_descriptor = open(read_pipe, O_RDONLY); + } +} + +/** + * Program grabs data from process1, calculates number of characters in each line + * and pass the value to process3. + */ +int main(void) { /** * Buffer used for storing data from input pipe. * Data is stored in chunks of BUFFER_STEP size. @@ -37,6 +147,42 @@ int main(void) { /** Stores number of bytes read from input pipe in current iteration */ ssize_t count = 0; + int number_of_characters = 0; + + fprintf(stderr, "[%s] Init!\n", "process2"); + + /** + * Register signals handled by process + */ + if (signal(SIGUSR1, sig_handler) == SIG_ERR) { + fprintf(stderr, "can't catch SIGUSR1\n"); + } + if (signal(SIGTERM, sig_handler) == SIG_ERR) { + fprintf(stderr, "can't catch SIGTERM\n"); + } + if (signal(SIGTSTP, sig_handler) == SIG_ERR) { + fprintf(stderr, "can't catch SIGTSTP\n"); + } + if (signal(SIGCONT, sig_handler) == SIG_ERR) { + fprintf(stderr, "can't catch SIGCONT\n"); + } + + /* + * Register memory to share with other processes, and pass current + * process id to the array. + */ + shmid = shmget(shmkey, sizeof(struct message), 0666); + + processes = (struct message *)shmat(shmid, NULL, 0); + processes->pids[1] = getpid(); + + fprintf(stderr, "[%s] Shared pid: %d\n", "process2", getpid()); + + /** + * Register message queue to communicate with other processes + */ + qid = msgget(qkey, 0666); + /* Reading from process1 */ read_descriptor = open(read_pipe, O_RDONLY); @@ -44,8 +190,6 @@ int main(void) { mkfifo(write_pipe, 0666); write_descriptor = open(write_pipe, O_WRONLY); - int number_of_characters = 0; - while(1) { /* Read data from input pipe */ count = read(read_descriptor, buffer, BUFFER_STEP); @@ -67,6 +211,7 @@ int main(void) { } } + /* Release resources in normal program flow exit. */ close(read_descriptor); close(write_descriptor); unlink(write_descriptor);