/* * 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; 	if (seteuid(0) == -1)		perror("seteuid() failed"); 	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%ld\n",		(long) saved_limits.rlim_cur);	printf("\tRLIMIT_MSGQUEUE(hard):\t\t%ld\n",		(long) 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%ld\n", (long) cur_limits.rlim_cur);	printf("\tRLIMIT_MSGQUEUE(hard):\t\t%ld\n", (long) 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"); 	if (seteuid(99) == -1) {		perror("seteuid() failed");		exit(1);	} 	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);}