tools/testing/selftests/mqueue/mq_open_tests.c - maze/linux - Git at Google

 /*
  * 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);
 }
	/*
	* 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);
	}