TP SE 3: Communication inter processus

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
void handler(int sig) {
    // Do something
}

int main() {
    struct sigaction new_action =  {};
    new_action.sa_handler = handler;

    struct sigaction old_action =  {};
    if (sigaction(SIGINT, &new_action, &old_action) == -1) {
        perror("Failed to call sigaction system call");
        return 0;
    }

}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
#include <signal.h>
#include <stdio.h>

void handler(int sig) { (2)
    printf("Received Signal: %d\n", sig);

    struct sigaction new_action =  {};
    new_action.sa_handler = SIG_DFL; (3)

    if (sigaction(SIGINT, &new_action, NULL) == -1) { (1)
        perror("Failed to call sigaction system call in handler");
    }
}

int main() {
    struct sigaction new_action =  {};
    new_action.sa_handler = handler;

    struct sigaction old_action =  {};
    if (sigaction(SIGINT, &new_action, &old_action) == -1) { (1)
        perror("Failed to call sigaction system call");
        return 0;
    }

    while (1);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
#include <errno.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[]) {

    int file_descriptors[2] = {}; (1)
    int result = pipe(file_descriptors); (2)
    if (result == -1) { (3)
        perror("Unable to open text.txt file: "); (3)
        exit(errno); (3)
    }

    return EXIT_SUCCESS;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
void read_from_pipe(const int *pipe, char buffer[200]) {
    char character = 0;
    int index = 0;
    do {
        ssize_t result = read(pipe[STDIN_FILENO], &character, 1); (1)
        if (result == -1) {
            perror("Unable to read from pipe:");
            return;
        } else if (result == 1) {
            buffer[index] = character; (2)
            index++;
        } else {
            printf("Nothing to read...");
        }
    } while (character != '\0'); (3)
    buffer[index] = 0;
}

1
2
3
static void write_to_pipe(int pipe[], const char *message) {
    write(pipe[1], message, strlen(message) + 1); (1)
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <wait.h>

static void child_process(const int *pipe_fd) {
    char character = 0;
    char buffer[200];
    int index = 0;
    printf("Child process attempts to read from pipe...\n");
    do {
        if (read(pipe_fd[0], &character, 1) == 1) {
            buffer[index] = character;
            index++;
            printf("Read character: %c\n", character);
        }
    } while (character != '\0');
    buffer[index] = 0;
    printf("Read message: %s\n", buffer);

}

static void parent_process(const int *pipe_fd) {
    char *message = "I am your father!";
    write(pipe_fd[1], message, strlen(message) + 1);
    printf("Parent process sent message to child process...\n");

    wait(NULL);
}

int main(int argc, char *argv[]) {

    int pipe_fd[2];
    pipe(pipe_fd);

    int pid = fork();
    if (pid > 0) {
        parent_process(pipe_fd);
    } else if (pid == 0) {
        child_process(pipe_fd);
    } else {
        perror("Unable to fork process...");
    }

    return EXIT_SUCCESS;
}