#include <sys/socket.h>
#include <sys/types.h> /* included for portability */
#include <sys/un.h>
 
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
#define IPC_SOCK_PATH "/tmp/ipc001"
 
void client_mode(int sock_fd, struct sockaddr_un my_addr, const char* message);
void server_mode(int sock_fd);
void write_text (int sock_fd, const char* text);
 
void write_text (int sock_fd, const char* text) {
    /* Write the number of bytes in the string, including
     *      NUL-termination.  */
    int length = strlen(text) + 1;
    write(sock_fd, &length, sizeof(length));
    /* Write the string.  */
    write(sock_fd, text, length);
}
 
void client_mode(int sock_fd, struct sockaddr_un my_addr, const char* message) {
    printf("Client mode!\n");
 
    /* Connect the socket.  */
    if (connect(sock_fd, (struct sockaddr *) &my_addr, sizeof(struct sockaddr_un) ) == -1) {
        perror("Client connect failed");
        exit(200);
    }
 
    /* Write the text on the command line to the socket.  */
    write_text(sock_fd, message);
    close(sock_fd);
}
 
int get_message(int client_socket) {
    while (1) {
        int length;
        char * text;
        /* First, read the length of the text message from the socket. If
         * read returns zero, the client closed the connection. */
        if (read(client_socket, &length, sizeof(length)) == 0)
            return 0;
        /* Allocate a buffer to hold the text. */
        text = (char*) malloc(length);
        /* Read the text itself, and print it. */
        read(client_socket, text, length);
        printf ("%s\n", text);
        /* If the client sent the message “quit,” we’re all done. */
        printf("comparing - '%s' with 'quit'\n", text);
        if (!strcmp(text, "quit")) {
            /* Free the buffer. */
            free(text);
            return 1;
        }
        free(text);
    }
}
 
void server_mode(int sock_fd) {
    struct sockaddr_un client_name;
    socklen_t client_name_len;
    int client_socket_fd;
    int client_sent_quit_message;
 
    printf("Server waiting for connections ...\n");
    printf("Socket location : %s\n", IPC_SOCK_PATH);
 
    do {
        /* Accept a connection. */
        client_socket_fd = accept(sock_fd, (struct sockaddr *) &client_name, &client_name_len);
        /* Handle the connection. */
        client_sent_quit_message = get_message(client_socket_fd);
        /* Close our end of the connection. */
        close (client_socket_fd);
    } while (!client_sent_quit_message);
}
 
int main(int argc, char* argv[]) {
    int sock_fd;
    struct sockaddr_un my_addr;
 
    if ((sock_fd = socket(PF_UNIX, SOCK_STREAM, 0)) == -1) {
        perror("Socket creation failed");
        exit(255);
    }
 
    /* use bind to determine if we use server mode or client */
    memset(&my_addr, 0, sizeof(struct sockaddr_un));
    my_addr.sun_family = AF_UNIX;
    strncpy(my_addr.sun_path, IPC_SOCK_PATH, sizeof(my_addr.sun_path) -1);
 
    if ( bind(sock_fd,(struct sockaddr *) &my_addr, sizeof(struct sockaddr_un)) == -1) {
        if (errno == EADDRINUSE) {
            if ( argc < 2 ) {
                printf("Insufficient arguments for client mode\n");
                exit(200);
            }
            client_mode(sock_fd, my_addr, argv[1]);
            close(sock_fd);
        } else {
            perror("Socket bind failed");
            exit(255);
        }
    } else {
        if (listen(sock_fd, 5) == -1) {
            perror("Listen failed");
            exit(255);
        }
        server_mode(sock_fd);
 
        /* Remove the socket file. */
        close(sock_fd);
        unlink(IPC_SOCK_PATH);
    }
 
    return(0);
}