/*
 * Copyright 2008, Salvatore Benedetto, salvatore.benedetto@gmail.com.
 * Distributed under the terms of the MIT License.
 */

#include <errno.h>
#include <fcntl.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/mman.h>
#include <sys/msg.h>
#include <sys/stat.h>
#include <sys/time.h>
#include <sys/wait.h>

#include <OS.h>

#include "TestUnitUtils.h"

#define KEY                     ((key_t)12345)

static status_t
remove_msg_queue(int msgID)
{
        return msgctl(msgID, IPC_RMID, 0);
}

struct message {
        long type;
        char text[20];
};


static void
test_msgget()
{
        TEST_SET("msgget({IPC_PRIVATE, key})");

        const char* currentTest = NULL;

        // Open private set with IPC_PRIVATE
        TEST("msgget(IPC_PRIVATE) - private");
        int msgID = msgget(IPC_PRIVATE, S_IRUSR | S_IWUSR);
        assert_posix_bool_success(msgID != -1);

        // Destroy private msg_queue
        TEST("msgctl(IPC_RMID) - private");
        status_t status = remove_msg_queue(msgID);
        assert_posix_bool_success(status != -1);

        // Open non-private non-existing set with IPC_CREAT
        TEST("msgget(KEY, IPC_CREAT) non-existing");
        msgID = msgget(KEY, IPC_CREAT | IPC_EXCL | S_IRUSR | S_IWUSR
                | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH);
        assert_posix_bool_success(status != -1);

        // Re-open non-private existing without IPC_CREAT
        TEST("msgget(KEY) re-open existing without IPC_CREAT");
        int returnID = msgget(KEY, 0);
        assert_equals(msgID, returnID);

        // Re-open non-private existing with IPC_CREAT
        TEST("msgget(IPC_CREATE) re-open existing with IPC_CREAT");
        returnID = msgget(KEY, IPC_CREAT | IPC_EXCL);
        assert_posix_bool_success(errno == EEXIST);

        // Destroy non-private msg_queue
        TEST("msgctl(IPC_RMID)");
        status = remove_msg_queue(msgID);
        assert_posix_bool_success(status != -1);

        // Open non-private non-existing without IPC_CREAT
        TEST("msgget(IPC_CREATE) non-existing without IPC_CREAT");
        msgID = msgget(KEY, IPC_EXCL | S_IRUSR | S_IWUSR
                | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH);
        assert_posix_bool_success(errno == ENOENT);

        // Destroy non-existing msg_queue
        TEST("msgctl()");
        status = remove_msg_queue(msgID);
        assert_posix_bool_success(errno == EINVAL);

        TEST("done");
}


static void
test_msgctl()
{
        TEST_SET("msgctl({IPC_STAT, IPC_SET, IPC_RMID})");

        const char* currentTest = NULL;

        // Open non-private non-existing set with IPC_CREAT
        TEST("msgget(IPC_CREATE) non-existing");
        int msgID = msgget(KEY, IPC_CREAT | IPC_EXCL | S_IRUSR | S_IWUSR
                | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH);
        assert_posix_bool_success(msgID != -1);

        // IPC_SET
        TEST("msgctl(IPC_SET)");
        struct msqid_ds msg_queue;
        memset(&msg_queue, 0, sizeof(struct msqid_ds));
        msg_queue.msg_perm.uid = getuid() + 3;
        msg_queue.msg_perm.gid = getgid() + 3;
        msg_queue.msg_perm.mode = 0666;
        msg_queue.msg_qbytes = 512;
        status_t status = msgctl(msgID, IPC_SET, &msg_queue);
        assert_posix_bool_success(status != 1);

        // IPC_STAT set
        TEST("msgctl(IPC_STAT)");
        memset(&msg_queue, 0, sizeof(struct msqid_ds));
        status = msgctl(msgID, IPC_STAT, &msg_queue);
        assert_posix_bool_success(status != 1);
        TEST("msgctl(IPC_STAT): number of bytes");
        assert_equals((msglen_t)msg_queue.msg_qbytes, (msglen_t)512);
        TEST("msgctl(IPC_STAT): uid");
        assert_equals(msg_queue.msg_perm.uid, getuid() + 3);
        TEST("msgctl(IPC_STAT): gid");
        assert_equals(msg_queue.msg_perm.gid, getgid() + 3);

        // Destroy non-private msg_queue
        TEST("msgctl(IPC_RMID)");
        status = remove_msg_queue(msgID);
        assert_posix_bool_success(status != 1);

        TEST("done");
}


static void
test_msgsnd()
{
        TEST_SET("msgsnd({EAGAIN, send})");

        const char* currentTest = NULL;

        // Open non-private non-existing set with IPC_CREAT
        TEST("msgget(IPC_CREATE) non-existing");
        int msgID = msgget(KEY, IPC_CREAT | IPC_EXCL | S_IRUSR | S_IWUSR
                | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH);
        assert_posix_bool_success(msgID != -1);

        // Send simple message
        TEST("msgsnd(simple message)");
        struct message msg;
        msg.type = 0;
        strcpy(msg.text, "Message to send\n");
        status_t status = msgsnd((key_t)msgID, (void *)&msg, 20, 0);
        assert_posix_bool_success(status != 1);

        // IPC_SET
        TEST("msgctl(IPC_SET) - set limit to 512");
        struct msqid_ds msg_queue;
        memset(&msg_queue, 0, sizeof(struct msqid_ds));
        msg_queue.msg_perm.uid = getuid() + 3;
        msg_queue.msg_perm.gid = getgid() + 3;
        msg_queue.msg_perm.mode = 0666;
        msg_queue.msg_qbytes = 512;
        status = msgctl(msgID, IPC_SET, &msg_queue);
        assert_posix_bool_success(status != 1);

        // Send big message IPC_NOWAIT
        TEST("msgsnd(IPC_NOWAIT)");
        msgsnd((key_t)msgID, (void *)&msg, 500, IPC_NOWAIT);
        assert_posix_bool_success(errno == EAGAIN);

        // Destroy non-private msg_queue
        TEST("msgctl(IPC_RMID)");
        status = remove_msg_queue(msgID);
        assert_posix_bool_success(status != 1);

        TEST("done");
}


static void
test_msgrcv()
{
        TEST_SET("msgrcv({IPC_STAT, IPC_SET, IPC_RMID})");

        const char* currentTest = NULL;

        // Open non-private non-existing set with IPC_CREAT
        TEST("msgget(IPC_CREATE) non-existing");
        int msgID = msgget(KEY, IPC_CREAT | IPC_EXCL | S_IRUSR | S_IWUSR
                | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH);
        assert_posix_bool_success(msgID != -1);

        // Receive simple message
        TEST("msgrcv(IPC_NOWAIT)");
        struct message msg;
        memset(&msg, 0, sizeof(struct message));
        msgrcv((key_t)msgID, (void *)&msg, 20, 0, IPC_NOWAIT);
        assert_posix_bool_success(errno == ENOMSG);

        pid_t child = fork();
        if (child == 0) {
                // Send a simple message
                TEST("msgsnd(simple message)");
                struct message smsg;
                msg.type = 0;
                strcpy(msg.text, "Message to send\n");
                status_t status = msgsnd((key_t)msgID, (void *)&smsg, 20, 0);
                assert_posix_bool_success(status != 1);
                exit(0);
        }

        wait_for_child(child);
        TEST("msgrcv(E2BIG)");
        msgrcv((key_t)msgID, (void *)&msg, 10, 0, IPC_NOWAIT);
        assert_posix_bool_success(errno == E2BIG);

        TEST("msgrcv(MSG_NOERROR)");
        status_t status
                = msgrcv((key_t)msgID, (void *)&msg, 10, 0, IPC_NOWAIT | MSG_NOERROR);
        assert_posix_bool_success(status != -1);

        // Destroy non-private msg_queue
        TEST("msgctl(IPC_RMID)");
        status = remove_msg_queue(msgID);
        assert_posix_bool_success(status != 1);

        TEST("done");
}


int
main()
{
        test_msgget();
        test_msgctl();
        test_msgsnd();
        test_msgrcv();

        printf("\nAll tests OK\n");
}