Inter-Process Communication

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <unistd.h>

// Define message structure
struct message {
    long msg_type;
    char msg_text[100];
};

int main() {
    key_t key;
    int msgid;
    struct message msg;
    
    // Generate a unique key for message queue
    if ((key = ftok(".", 'b')) == -1) {
        perror("ftok");
        exit(1);
    }
    
    // Create the message queue
    if ((msgid = msgget(key, IPC_CREAT | 0666)) == -1) {
        perror("msgget");
        exit(1);
    }
    
    printf("Message queue created: %d\n", msgid);
    
    pid_t pid = fork();
    
    if (pid == -1) {
        perror("fork");
        exit(1);
    }
    
    if (pid == 0) {
        // Child process: receive message
        printf("Child waiting for message...\n");
        
        // Receive message
        if (msgrcv(msgid, &msg, sizeof(msg.msg_text), 1, 0) == -1) {
            perror("msgrcv");
            exit(1);
        }
        
        printf("Child received: %s\n", msg.msg_text);
        
        // Send a response back to parent
        msg.msg_type = 2;  // Different message type for parent
        strcpy(msg.msg_text, "Hello from the child process!");
        
        if (msgsnd(msgid, &msg, strlen(msg.msg_text) + 1, 0) == -1) {
            perror("msgsnd");
            exit(1);
        }
        
        exit(0);
    } else {
        // Parent process: send message
        msg.msg_type = 1;  // Message type for child
        strcpy(msg.msg_text, "Hello from the parent process!");
        
        // Send the message
        if (msgsnd(msgid, &msg, strlen(msg.msg_text) + 1, 0) == -1) {
            perror("msgsnd");
            exit(1);
        }
        
        printf("Parent sent message\n");
        
        // Receive response from child
        if (msgrcv(msgid, &msg, sizeof(msg.msg_text), 2, 0) == -1) {
            perror("msgrcv");
            exit(1);
        }
        
        printf("Parent received: %s\n", msg.msg_text);
        
        // Wait for child to finish
        wait(NULL);
        
        // Remove the message queue
        if (msgctl(msgid, IPC_RMID, NULL) == -1) {
            perror("msgctl");
            exit(1);
        }
        
        printf("Message queue removed\n");
    }
    
    return 0;
}

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <sys/un.h>

#define SOCKET_PATH "/tmp/ipc_socket"
#define BUFFER_SIZE 100

int main() {
    pid_t pid;
    
    // Create child process
    pid = fork();
    
    if (pid == -1) {
        perror("fork");
        exit(EXIT_FAILURE);
    }
    
    if (pid == 0) {
        // Child process: client
        sleep(1);  // Wait for server to set up
        
        int client_sock;
        struct sockaddr_un server_addr;
        char buffer[BUFFER_SIZE];
        
        // Create socket
        if ((client_sock = socket(AF_UNIX, SOCK_STREAM, 0)) == -1) {
            perror("socket");
            exit(EXIT_FAILURE);
        }
        
        memset(&server_addr, 0, sizeof(server_addr));
        server_addr.sun_family = AF_UNIX;
        strncpy(server_addr.sun_path, SOCKET_PATH, sizeof(server_addr.sun_path) - 1);
        
        // Connect to server
        if (connect(client_sock, (struct sockaddr*)&server_addr, sizeof(server_addr)) == -1) {
            perror("connect");
            exit(EXIT_FAILURE);
        }
        
        printf("Client connected to server\n");
        
        // Send message to server
        const char *message = "Hello from the client!";
        if (send(client_sock, message, strlen(message), 0) == -1) {
            perror("send");
            exit(EXIT_FAILURE);
        }
        
        // Receive response
        int bytes_received = recv(client_sock, buffer, BUFFER_SIZE - 1, 0);
        if (bytes_received == -1) {
            perror("recv");
            exit(EXIT_FAILURE);
        }
        
        buffer[bytes_received] = '\0';
        printf("Client received: %s\n", buffer);
        
        // Close connection
        close(client_sock);
        exit(EXIT_SUCCESS);
    } else {
        // Parent process: server
        int server_sock, client_sock;
        struct sockaddr_un server_addr, client_addr;
        socklen_t client_len;
        char buffer[BUFFER_SIZE];
        
        // Create socket
        if ((server_sock = socket(AF_UNIX, SOCK_STREAM, 0)) == -1) {
            perror("socket");
            exit(EXIT_FAILURE);
        }
        
        // Remove socket file if it already exists
        unlink(SOCKET_PATH);
        
        // Setup address structure
        memset(&server_addr, 0, sizeof(server_addr));
        server_addr.sun_family = AF_UNIX;
        strncpy(server_addr.sun_path, SOCKET_PATH, sizeof(server_addr.sun_path) - 1);
        
        // Bind socket
        if (bind(server_sock, (struct sockaddr*)&server_addr, sizeof(server_addr)) == -1) {
            perror("bind");
            exit(EXIT_FAILURE);
        }
        
        // Listen for connections
        if (listen(server_sock, 5) == -1) {
            perror("listen");
            exit(EXIT_FAILURE);
        }
        
        printf("Server waiting for connection...\n");
        
        // Accept connection
        client_len = sizeof(client_addr);
        if ((client_sock = accept(server_sock, (struct sockaddr*)&client_addr, &client_len)) == -1) {
            perror("accept");
            exit(EXIT_FAILURE);
        }
        
        printf("Server accepted connection\n");
        
        // Receive message
        int bytes_received = recv(client_sock, buffer, BUFFER_SIZE - 1, 0);
        if (bytes_received == -1) {
            perror("recv");
            exit(EXIT_FAILURE);
        }
        
        buffer[bytes_received] = '\0';
        printf("Server received: %s\n", buffer);
        
        // Send response
        const char *response = "Hello from the server!";
        if (send(client_sock, response, strlen(response), 0) == -1) {
            perror("send");
            exit(EXIT_FAILURE);
        }
        
        // Clean up
        close(client_sock);
        close(server_sock);
        unlink(SOCKET_PATH);
        
        // Wait for child to finish
        wait(NULL);
    }
    
    return 0;
}