/*
 * This application is Copyright 2012 Red Hat, Inc.
 *      Doug Ledford <dledford@redhat.com>
 *
 * mq_open_tests is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.
 *
 * mq_open_tests is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * For the full text of the license, see <http://www.gnu.org/licenses/>.
 *
 * mq_open_tests.c
 *   Tests the various situations that should either succeed or fail to
 *   open a posix message queue and then reports whether or not they
 *   did as they were supposed to.
 *
 */
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <string.h>
#include <limits.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/time.h>
#include <sys/resource.h>
#include <sys/stat.h>
#include <mqueue.h>

static char *usage =
"Usage:\n"
"  %s path\n"
"\n"
"       path    Path name of the message queue to create\n"
"\n"
"       Note: this program must be run as root in order to enable all tests\n"
"\n";

char *DEF_MSGS = "/proc/sys/fs/mqueue/msg_default";
char *DEF_MSGSIZE = "/proc/sys/fs/mqueue/msgsize_default";
char *MAX_MSGS = "/proc/sys/fs/mqueue/msg_max";
char *MAX_MSGSIZE = "/proc/sys/fs/mqueue/msgsize_max";

int default_settings;
struct rlimit saved_limits, cur_limits;
int saved_def_msgs, saved_def_msgsize, saved_max_msgs, saved_max_msgsize;
int cur_def_msgs, cur_def_msgsize, cur_max_msgs, cur_max_msgsize;
FILE *def_msgs, *def_msgsize, *max_msgs, *max_msgsize;
char *queue_path;
mqd_t queue = -1;

static inline void __set(FILE *stream, int value, char *err_msg);
void shutdown(int exit_val, char *err_cause, int line_no);
static inline int get(FILE *stream);
static inline void set(FILE *stream, int value);
static inline void getr(int type, struct rlimit *rlim);
static inline void setr(int type, struct rlimit *rlim);
void validate_current_settings();
static inline void test_queue(struct mq_attr *attr, struct mq_attr *result);
static inline int test_queue_fail(struct mq_attr *attr, struct mq_attr *result);

static inline void __set(FILE *stream, int value, char *err_msg)
{
        rewind(stream);
        if (fprintf(stream, "%d", value) < 0)
                perror(err_msg);
}


void shutdown(int exit_val, char *err_cause, int line_no)
{
        static int in_shutdown = 0;

        /* In case we get called recursively by a set() call below */
        if (in_shutdown++)
                return;

        seteuid(0);

        if (queue != -1)
                if (mq_close(queue))
                        perror("mq_close() during shutdown");
        if (queue_path)
                /*
                 * Be silent if this fails, if we cleaned up already it's
                 * expected to fail
                 */
                mq_unlink(queue_path);
        if (default_settings) {
                if (saved_def_msgs)
                        __set(def_msgs, saved_def_msgs,
                              "failed to restore saved_def_msgs");
                if (saved_def_msgsize)
                        __set(def_msgsize, saved_def_msgsize,
                              "failed to restore saved_def_msgsize");
        }
        if (saved_max_msgs)
                __set(max_msgs, saved_max_msgs,
                      "failed to restore saved_max_msgs");
        if (saved_max_msgsize)
                __set(max_msgsize, saved_max_msgsize,
                      "failed to restore saved_max_msgsize");
        if (exit_val)
                error(exit_val, errno, "%s at %d", err_cause, line_no);
        exit(0);
}

static inline int get(FILE *stream)
{
        int value;
        rewind(stream);
        if (fscanf(stream, "%d", &value) != 1)
                shutdown(4, "Error reading /proc entry", __LINE__ - 1);
        return value;
}

static inline void set(FILE *stream, int value)
{
        int new_value;

        rewind(stream);
        if (fprintf(stream, "%d", value) < 0)
                return shutdown(5, "Failed writing to /proc file",
                                __LINE__ - 1);
        new_value = get(stream);
        if (new_value != value)
                return shutdown(5, "We didn't get what we wrote to /proc back",
                                __LINE__ - 1);
}

static inline void getr(int type, struct rlimit *rlim)
{
        if (getrlimit(type, rlim))
                shutdown(6, "getrlimit()", __LINE__ - 1);
}

static inline void setr(int type, struct rlimit *rlim)
{
        if (setrlimit(type, rlim))
                shutdown(7, "setrlimit()", __LINE__ - 1);
}

void validate_current_settings()
{
        int rlim_needed;

        if (cur_limits.rlim_cur < 4096) {
                printf("Current rlimit value for POSIX message queue bytes is "
                       "unreasonably low,\nincreasing.\n\n");
                cur_limits.rlim_cur = 8192;
                cur_limits.rlim_max = 16384;
                setr(RLIMIT_MSGQUEUE, &cur_limits);
        }

        if (default_settings) {
                rlim_needed = (cur_def_msgs + 1) * (cur_def_msgsize + 1 +
                                                    2 * sizeof(void *));
                if (rlim_needed > cur_limits.rlim_cur) {
                        printf("Temporarily lowering default queue parameters "
                               "to something that will work\n"
                               "with the current rlimit values.\n\n");
                        set(def_msgs, 10);
                        cur_def_msgs = 10;
                        set(def_msgsize, 128);
                        cur_def_msgsize = 128;
                }
        } else {
                rlim_needed = (cur_max_msgs + 1) * (cur_max_msgsize + 1 +
                                                    2 * sizeof(void *));
                if (rlim_needed > cur_limits.rlim_cur) {
                        printf("Temporarily lowering maximum queue parameters "
                               "to something that will work\n"
                               "with the current rlimit values in case this is "
                               "a kernel that ties the default\n"
                               "queue parameters to the maximum queue "
                               "parameters.\n\n");
                        set(max_msgs, 10);
                        cur_max_msgs = 10;
                        set(max_msgsize, 128);
                        cur_max_msgsize = 128;
                }
        }
}

/*
 * test_queue - Test opening a queue, shutdown if we fail.  This should
 * only be called in situations that should never fail.  We clean up
 * after ourselves and return the queue attributes in *result.
 */
static inline void test_queue(struct mq_attr *attr, struct mq_attr *result)
{
        int flags = O_RDWR | O_EXCL | O_CREAT;
        int perms = DEFFILEMODE;

        if ((queue = mq_open(queue_path, flags, perms, attr)) == -1)
                shutdown(1, "mq_open()", __LINE__);
        if (mq_getattr(queue, result))
                shutdown(1, "mq_getattr()", __LINE__);
        if (mq_close(queue))
                shutdown(1, "mq_close()", __LINE__);
        queue = -1;
        if (mq_unlink(queue_path))
                shutdown(1, "mq_unlink()", __LINE__);
}

/*
 * Same as test_queue above, but failure is not fatal.
 * Returns:
 * 0 - Failed to create a queue
 * 1 - Created a queue, attributes in *result
 */
static inline int test_queue_fail(struct mq_attr *attr, struct mq_attr *result)
{
        int flags = O_RDWR | O_EXCL | O_CREAT;
        int perms = DEFFILEMODE;

        if ((queue = mq_open(queue_path, flags, perms, attr)) == -1)
                return 0;
        if (mq_getattr(queue, result))
                shutdown(1, "mq_getattr()", __LINE__);
        if (mq_close(queue))
                shutdown(1, "mq_close()", __LINE__);
        queue = -1;
        if (mq_unlink(queue_path))
                shutdown(1, "mq_unlink()", __LINE__);
        return 1;
}

int main(int argc, char *argv[])
{
        struct mq_attr attr, result;

        if (argc != 2) {
                fprintf(stderr, "Must pass a valid queue name\n\n");
                fprintf(stderr, usage, argv[0]);
                exit(1);
        }

        /*
         * Although we can create a msg queue with a non-absolute path name,
         * unlink will fail.  So, if the name doesn't start with a /, add one
         * when we save it.
         */
        if (*argv[1] == '/')
                queue_path = strdup(argv[1]);
        else {
                queue_path = malloc(strlen(argv[1]) + 2);
                if (!queue_path) {
                        perror("malloc()");
                        exit(1);
                }
                queue_path[0] = '/';
                queue_path[1] = 0;
                strcat(queue_path, argv[1]);
        }

        if (getuid() != 0) {
                fprintf(stderr, "Not running as root, but almost all tests "
                        "require root in order to modify\nsystem settings.  "
                        "Exiting.\n");
                exit(1);
        }

        /* Find out what files there are for us to make tweaks in */
        def_msgs = fopen(DEF_MSGS, "r+");
        def_msgsize = fopen(DEF_MSGSIZE, "r+");
        max_msgs = fopen(MAX_MSGS, "r+");
        max_msgsize = fopen(MAX_MSGSIZE, "r+");

        if (!max_msgs)
                shutdown(2, "Failed to open msg_max", __LINE__);
        if (!max_msgsize)
                shutdown(2, "Failed to open msgsize_max", __LINE__);
        if (def_msgs || def_msgsize)
                default_settings = 1;

        /* Load up the current system values for everything we can */
        getr(RLIMIT_MSGQUEUE, &saved_limits);
        cur_limits = saved_limits;
        if (default_settings) {
                saved_def_msgs = cur_def_msgs = get(def_msgs);
                saved_def_msgsize = cur_def_msgsize = get(def_msgsize);
        }
        saved_max_msgs = cur_max_msgs = get(max_msgs);
        saved_max_msgsize = cur_max_msgsize = get(max_msgsize);

        /* Tell the user our initial state */
        printf("\nInitial system state:\n");
        printf("\tUsing queue path:\t\t%s\n", queue_path);
        printf("\tRLIMIT_MSGQUEUE(soft):\t\t%d\n", saved_limits.rlim_cur);
        printf("\tRLIMIT_MSGQUEUE(hard):\t\t%d\n", saved_limits.rlim_max);
        printf("\tMaximum Message Size:\t\t%d\n", saved_max_msgsize);
        printf("\tMaximum Queue Size:\t\t%d\n", saved_max_msgs);
        if (default_settings) {
                printf("\tDefault Message Size:\t\t%d\n", saved_def_msgsize);
                printf("\tDefault Queue Size:\t\t%d\n", saved_def_msgs);
        } else {
                printf("\tDefault Message Size:\t\tNot Supported\n");
                printf("\tDefault Queue Size:\t\tNot Supported\n");
        }
        printf("\n");

        validate_current_settings();

        printf("Adjusted system state for testing:\n");
        printf("\tRLIMIT_MSGQUEUE(soft):\t\t%d\n", cur_limits.rlim_cur);
        printf("\tRLIMIT_MSGQUEUE(hard):\t\t%d\n", cur_limits.rlim_max);
        printf("\tMaximum Message Size:\t\t%d\n", cur_max_msgsize);
        printf("\tMaximum Queue Size:\t\t%d\n", cur_max_msgs);
        if (default_settings) {
                printf("\tDefault Message Size:\t\t%d\n", cur_def_msgsize);
                printf("\tDefault Queue Size:\t\t%d\n", cur_def_msgs);
        }

        printf("\n\nTest series 1, behavior when no attr struct "
               "passed to mq_open:\n");
        if (!default_settings) {
                test_queue(NULL, &result);
                printf("Given sane system settings, mq_open without an attr "
                       "struct succeeds:\tPASS\n");
                if (result.mq_maxmsg != cur_max_msgs ||
                    result.mq_msgsize != cur_max_msgsize) {
                        printf("Kernel does not support setting the default "
                               "mq attributes,\nbut also doesn't tie the "
                               "defaults to the maximums:\t\t\tPASS\n");
                } else {
                        set(max_msgs, ++cur_max_msgs);
                        set(max_msgsize, ++cur_max_msgsize);
                        test_queue(NULL, &result);
                        if (result.mq_maxmsg == cur_max_msgs &&
                            result.mq_msgsize == cur_max_msgsize)
                                printf("Kernel does not support setting the "
                                       "default mq attributes and\n"
                                       "also ties system wide defaults to "
                                       "the system wide maximums:\t\t"
                                       "FAIL\n");
                        else
                                printf("Kernel does not support setting the "
                                       "default mq attributes,\n"
                                       "but also doesn't tie the defaults to "
                                       "the maximums:\t\t\tPASS\n");
                }
        } else {
                printf("Kernel supports setting defaults separately from "
                       "maximums:\t\tPASS\n");
                /*
                 * While we are here, go ahead and test that the kernel
                 * properly follows the default settings
                 */
                test_queue(NULL, &result);
                printf("Given sane values, mq_open without an attr struct "
                       "succeeds:\t\tPASS\n");
                if (result.mq_maxmsg != cur_def_msgs ||
                    result.mq_msgsize != cur_def_msgsize)
                        printf("Kernel supports setting defaults, but does "
                               "not actually honor them:\tFAIL\n\n");
                else {
                        set(def_msgs, ++cur_def_msgs);
                        set(def_msgsize, ++cur_def_msgsize);
                        /* In case max was the same as the default */
                        set(max_msgs, ++cur_max_msgs);
                        set(max_msgsize, ++cur_max_msgsize);
                        test_queue(NULL, &result);
                        if (result.mq_maxmsg != cur_def_msgs ||
                            result.mq_msgsize != cur_def_msgsize)
                                printf("Kernel supports setting defaults, but "
                                       "does not actually honor them:\t"
                                       "FAIL\n");
                        else
                                printf("Kernel properly honors default setting "
                                       "knobs:\t\t\t\tPASS\n");
                }
                set(def_msgs, cur_max_msgs + 1);
                cur_def_msgs = cur_max_msgs + 1;
                set(def_msgsize, cur_max_msgsize + 1);
                cur_def_msgsize = cur_max_msgsize + 1;
                if (cur_def_msgs * (cur_def_msgsize + 2 * sizeof(void *)) >=
                    cur_limits.rlim_cur) {
                        cur_limits.rlim_cur = (cur_def_msgs + 2) *
                                (cur_def_msgsize + 2 * sizeof(void *));
                        cur_limits.rlim_max = 2 * cur_limits.rlim_cur;
                        setr(RLIMIT_MSGQUEUE, &cur_limits);
                }
                if (test_queue_fail(NULL, &result)) {
                        if (result.mq_maxmsg == cur_max_msgs &&
                            result.mq_msgsize == cur_max_msgsize)
                                printf("Kernel properly limits default values "
                                       "to lesser of default/max:\t\tPASS\n");
                        else
                                printf("Kernel does not properly set default "
                                       "queue parameters when\ndefaults > "
                                       "max:\t\t\t\t\t\t\t\tFAIL\n");
                } else
                        printf("Kernel fails to open mq because defaults are "
                               "greater than maximums:\tFAIL\n");
                set(def_msgs, --cur_def_msgs);
                set(def_msgsize, --cur_def_msgsize);
                cur_limits.rlim_cur = cur_limits.rlim_max = cur_def_msgs *
                        cur_def_msgsize;
                setr(RLIMIT_MSGQUEUE, &cur_limits);
                if (test_queue_fail(NULL, &result))
                        printf("Kernel creates queue even though defaults "
                               "would exceed\nrlimit setting:"
                               "\t\t\t\t\t\t\t\tFAIL\n");
                else
                        printf("Kernel properly fails to create queue when "
                               "defaults would\nexceed rlimit:"
                               "\t\t\t\t\t\t\t\tPASS\n");
        }

        /*
         * Test #2 - open with an attr struct that exceeds rlimit
         */
        printf("\n\nTest series 2, behavior when attr struct is "
               "passed to mq_open:\n");
        cur_max_msgs = 32;
        cur_max_msgsize = cur_limits.rlim_max >> 4;
        set(max_msgs, cur_max_msgs);
        set(max_msgsize, cur_max_msgsize);
        attr.mq_maxmsg = cur_max_msgs;
        attr.mq_msgsize = cur_max_msgsize;
        if (test_queue_fail(&attr, &result))
                printf("Queue open in excess of rlimit max when euid = 0 "
                       "succeeded:\t\tFAIL\n");
        else
                printf("Queue open in excess of rlimit max when euid = 0 "
                       "failed:\t\tPASS\n");
        attr.mq_maxmsg = cur_max_msgs + 1;
        attr.mq_msgsize = 10;
        if (test_queue_fail(&attr, &result))
                printf("Queue open with mq_maxmsg > limit when euid = 0 "
                       "succeeded:\t\tPASS\n");
        else
                printf("Queue open with mq_maxmsg > limit when euid = 0 "
                       "failed:\t\tFAIL\n");
        attr.mq_maxmsg = 1;
        attr.mq_msgsize = cur_max_msgsize + 1;
        if (test_queue_fail(&attr, &result))
                printf("Queue open with mq_msgsize > limit when euid = 0 "
                       "succeeded:\t\tPASS\n");
        else
                printf("Queue open with mq_msgsize > limit when euid = 0 "
                       "failed:\t\tFAIL\n");
        attr.mq_maxmsg = 65536;
        attr.mq_msgsize = 65536;
        if (test_queue_fail(&attr, &result))
                printf("Queue open with total size > 2GB when euid = 0 "
                       "succeeded:\t\tFAIL\n");
        else
                printf("Queue open with total size > 2GB when euid = 0 "
                       "failed:\t\t\tPASS\n");
        seteuid(99);
        attr.mq_maxmsg = cur_max_msgs;
        attr.mq_msgsize = cur_max_msgsize;
        if (test_queue_fail(&attr, &result))
                printf("Queue open in excess of rlimit max when euid = 99 "
                       "succeeded:\t\tFAIL\n");
        else
                printf("Queue open in excess of rlimit max when euid = 99 "
                       "failed:\t\tPASS\n");
        attr.mq_maxmsg = cur_max_msgs + 1;
        attr.mq_msgsize = 10;
        if (test_queue_fail(&attr, &result))
                printf("Queue open with mq_maxmsg > limit when euid = 99 "
                       "succeeded:\t\tFAIL\n");
        else
                printf("Queue open with mq_maxmsg > limit when euid = 99 "
                       "failed:\t\tPASS\n");
        attr.mq_maxmsg = 1;
        attr.mq_msgsize = cur_max_msgsize + 1;
        if (test_queue_fail(&attr, &result))
                printf("Queue open with mq_msgsize > limit when euid = 99 "
                       "succeeded:\t\tFAIL\n");
        else
                printf("Queue open with mq_msgsize > limit when euid = 99 "
                       "failed:\t\tPASS\n");
        attr.mq_maxmsg = 65536;
        attr.mq_msgsize = 65536;
        if (test_queue_fail(&attr, &result))
                printf("Queue open with total size > 2GB when euid = 99 "
                       "succeeded:\t\tFAIL\n");
        else
                printf("Queue open with total size > 2GB when euid = 99 "
                       "failed:\t\t\tPASS\n");

        shutdown(0,"",0);
}