1 /*
2 * This application is Copyright 2012 Red Hat, Inc.
3 * Doug Ledford <dledford@redhat.com>
4 *
5 * mq_open_tests is free software: you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation, version 3.
8 *
9 * mq_open_tests is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
13 *
14 * For the full text of the license, see <http://www.gnu.org/licenses/>.
15 *
16 * mq_open_tests.c
17 * Tests the various situations that should either succeed or fail to
18 * open a posix message queue and then reports whether or not they
19 * did as they were supposed to.
20 *
21 */
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <unistd.h>
25 #include <fcntl.h>
26 #include <string.h>
27 #include <limits.h>
28 #include <errno.h>
29 #include <sys/types.h>
30 #include <sys/time.h>
31 #include <sys/resource.h>
32 #include <sys/stat.h>
33 #include <mqueue.h>
34 #include <error.h>
35
36 static char *usage =
37 "Usage:\n"
38 " %s path\n"
39 "\n"
40 " path Path name of the message queue to create\n"
41 "\n"
42 " Note: this program must be run as root in order to enable all tests\n"
43 "\n";
44
45 char *DEF_MSGS = "/proc/sys/fs/mqueue/msg_default";
46 char *DEF_MSGSIZE = "/proc/sys/fs/mqueue/msgsize_default";
47 char *MAX_MSGS = "/proc/sys/fs/mqueue/msg_max";
48 char *MAX_MSGSIZE = "/proc/sys/fs/mqueue/msgsize_max";
49
50 int default_settings;
51 struct rlimit saved_limits, cur_limits;
52 int saved_def_msgs, saved_def_msgsize, saved_max_msgs, saved_max_msgsize;
53 int cur_def_msgs, cur_def_msgsize, cur_max_msgs, cur_max_msgsize;
54 FILE *def_msgs, *def_msgsize, *max_msgs, *max_msgsize;
55 char *queue_path;
56 mqd_t queue = -1;
57
58 static inline void __set(FILE *stream, int value, char *err_msg);
59 void shutdown(int exit_val, char *err_cause, int line_no);
60 static inline int get(FILE *stream);
61 static inline void set(FILE *stream, int value);
62 static inline void getr(int type, struct rlimit *rlim);
63 static inline void setr(int type, struct rlimit *rlim);
64 void validate_current_settings();
65 static inline void test_queue(struct mq_attr *attr, struct mq_attr *result);
66 static inline int test_queue_fail(struct mq_attr *attr, struct mq_attr *result);
67
__set(FILE * stream,int value,char * err_msg)68 static inline void __set(FILE *stream, int value, char *err_msg)
69 {
70 rewind(stream);
71 if (fprintf(stream, "%d", value) < 0)
72 perror(err_msg);
73 }
74
75
shutdown(int exit_val,char * err_cause,int line_no)76 void shutdown(int exit_val, char *err_cause, int line_no)
77 {
78 static int in_shutdown = 0;
79
80 /* In case we get called recursively by a set() call below */
81 if (in_shutdown++)
82 return;
83
84 if (seteuid(0) == -1)
85 perror("seteuid() failed");
86
87 if (queue != -1)
88 if (mq_close(queue))
89 perror("mq_close() during shutdown");
90 if (queue_path)
91 /*
92 * Be silent if this fails, if we cleaned up already it's
93 * expected to fail
94 */
95 mq_unlink(queue_path);
96 if (default_settings) {
97 if (saved_def_msgs)
98 __set(def_msgs, saved_def_msgs,
99 "failed to restore saved_def_msgs");
100 if (saved_def_msgsize)
101 __set(def_msgsize, saved_def_msgsize,
102 "failed to restore saved_def_msgsize");
103 }
104 if (saved_max_msgs)
105 __set(max_msgs, saved_max_msgs,
106 "failed to restore saved_max_msgs");
107 if (saved_max_msgsize)
108 __set(max_msgsize, saved_max_msgsize,
109 "failed to restore saved_max_msgsize");
110 if (exit_val)
111 error(exit_val, errno, "%s at %d", err_cause, line_no);
112 exit(0);
113 }
114
get(FILE * stream)115 static inline int get(FILE *stream)
116 {
117 int value;
118 rewind(stream);
119 if (fscanf(stream, "%d", &value) != 1)
120 shutdown(4, "Error reading /proc entry", __LINE__ - 1);
121 return value;
122 }
123
set(FILE * stream,int value)124 static inline void set(FILE *stream, int value)
125 {
126 int new_value;
127
128 rewind(stream);
129 if (fprintf(stream, "%d", value) < 0)
130 return shutdown(5, "Failed writing to /proc file",
131 __LINE__ - 1);
132 new_value = get(stream);
133 if (new_value != value)
134 return shutdown(5, "We didn't get what we wrote to /proc back",
135 __LINE__ - 1);
136 }
137
getr(int type,struct rlimit * rlim)138 static inline void getr(int type, struct rlimit *rlim)
139 {
140 if (getrlimit(type, rlim))
141 shutdown(6, "getrlimit()", __LINE__ - 1);
142 }
143
setr(int type,struct rlimit * rlim)144 static inline void setr(int type, struct rlimit *rlim)
145 {
146 if (setrlimit(type, rlim))
147 shutdown(7, "setrlimit()", __LINE__ - 1);
148 }
149
validate_current_settings()150 void validate_current_settings()
151 {
152 int rlim_needed;
153
154 if (cur_limits.rlim_cur < 4096) {
155 printf("Current rlimit value for POSIX message queue bytes is "
156 "unreasonably low,\nincreasing.\n\n");
157 cur_limits.rlim_cur = 8192;
158 cur_limits.rlim_max = 16384;
159 setr(RLIMIT_MSGQUEUE, &cur_limits);
160 }
161
162 if (default_settings) {
163 rlim_needed = (cur_def_msgs + 1) * (cur_def_msgsize + 1 +
164 2 * sizeof(void *));
165 if (rlim_needed > cur_limits.rlim_cur) {
166 printf("Temporarily lowering default queue parameters "
167 "to something that will work\n"
168 "with the current rlimit values.\n\n");
169 set(def_msgs, 10);
170 cur_def_msgs = 10;
171 set(def_msgsize, 128);
172 cur_def_msgsize = 128;
173 }
174 } else {
175 rlim_needed = (cur_max_msgs + 1) * (cur_max_msgsize + 1 +
176 2 * sizeof(void *));
177 if (rlim_needed > cur_limits.rlim_cur) {
178 printf("Temporarily lowering maximum queue parameters "
179 "to something that will work\n"
180 "with the current rlimit values in case this is "
181 "a kernel that ties the default\n"
182 "queue parameters to the maximum queue "
183 "parameters.\n\n");
184 set(max_msgs, 10);
185 cur_max_msgs = 10;
186 set(max_msgsize, 128);
187 cur_max_msgsize = 128;
188 }
189 }
190 }
191
192 /*
193 * test_queue - Test opening a queue, shutdown if we fail. This should
194 * only be called in situations that should never fail. We clean up
195 * after ourselves and return the queue attributes in *result.
196 */
test_queue(struct mq_attr * attr,struct mq_attr * result)197 static inline void test_queue(struct mq_attr *attr, struct mq_attr *result)
198 {
199 int flags = O_RDWR | O_EXCL | O_CREAT;
200 int perms = DEFFILEMODE;
201
202 if ((queue = mq_open(queue_path, flags, perms, attr)) == -1)
203 shutdown(1, "mq_open()", __LINE__);
204 if (mq_getattr(queue, result))
205 shutdown(1, "mq_getattr()", __LINE__);
206 if (mq_close(queue))
207 shutdown(1, "mq_close()", __LINE__);
208 queue = -1;
209 if (mq_unlink(queue_path))
210 shutdown(1, "mq_unlink()", __LINE__);
211 }
212
213 /*
214 * Same as test_queue above, but failure is not fatal.
215 * Returns:
216 * 0 - Failed to create a queue
217 * 1 - Created a queue, attributes in *result
218 */
test_queue_fail(struct mq_attr * attr,struct mq_attr * result)219 static inline int test_queue_fail(struct mq_attr *attr, struct mq_attr *result)
220 {
221 int flags = O_RDWR | O_EXCL | O_CREAT;
222 int perms = DEFFILEMODE;
223
224 if ((queue = mq_open(queue_path, flags, perms, attr)) == -1)
225 return 0;
226 if (mq_getattr(queue, result))
227 shutdown(1, "mq_getattr()", __LINE__);
228 if (mq_close(queue))
229 shutdown(1, "mq_close()", __LINE__);
230 queue = -1;
231 if (mq_unlink(queue_path))
232 shutdown(1, "mq_unlink()", __LINE__);
233 return 1;
234 }
235
main(int argc,char * argv[])236 int main(int argc, char *argv[])
237 {
238 struct mq_attr attr, result;
239
240 if (argc != 2) {
241 fprintf(stderr, "Must pass a valid queue name\n\n");
242 fprintf(stderr, usage, argv[0]);
243 exit(1);
244 }
245
246 /*
247 * Although we can create a msg queue with a non-absolute path name,
248 * unlink will fail. So, if the name doesn't start with a /, add one
249 * when we save it.
250 */
251 if (*argv[1] == '/')
252 queue_path = strdup(argv[1]);
253 else {
254 queue_path = malloc(strlen(argv[1]) + 2);
255 if (!queue_path) {
256 perror("malloc()");
257 exit(1);
258 }
259 queue_path[0] = '/';
260 queue_path[1] = 0;
261 strcat(queue_path, argv[1]);
262 }
263
264 if (getuid() != 0) {
265 fprintf(stderr, "Not running as root, but almost all tests "
266 "require root in order to modify\nsystem settings. "
267 "Exiting.\n");
268 exit(1);
269 }
270
271 /* Find out what files there are for us to make tweaks in */
272 def_msgs = fopen(DEF_MSGS, "r+");
273 def_msgsize = fopen(DEF_MSGSIZE, "r+");
274 max_msgs = fopen(MAX_MSGS, "r+");
275 max_msgsize = fopen(MAX_MSGSIZE, "r+");
276
277 if (!max_msgs)
278 shutdown(2, "Failed to open msg_max", __LINE__);
279 if (!max_msgsize)
280 shutdown(2, "Failed to open msgsize_max", __LINE__);
281 if (def_msgs || def_msgsize)
282 default_settings = 1;
283
284 /* Load up the current system values for everything we can */
285 getr(RLIMIT_MSGQUEUE, &saved_limits);
286 cur_limits = saved_limits;
287 if (default_settings) {
288 saved_def_msgs = cur_def_msgs = get(def_msgs);
289 saved_def_msgsize = cur_def_msgsize = get(def_msgsize);
290 }
291 saved_max_msgs = cur_max_msgs = get(max_msgs);
292 saved_max_msgsize = cur_max_msgsize = get(max_msgsize);
293
294 /* Tell the user our initial state */
295 printf("\nInitial system state:\n");
296 printf("\tUsing queue path:\t\t%s\n", queue_path);
297 printf("\tRLIMIT_MSGQUEUE(soft):\t\t%ld\n",
298 (long) saved_limits.rlim_cur);
299 printf("\tRLIMIT_MSGQUEUE(hard):\t\t%ld\n",
300 (long) saved_limits.rlim_max);
301 printf("\tMaximum Message Size:\t\t%d\n", saved_max_msgsize);
302 printf("\tMaximum Queue Size:\t\t%d\n", saved_max_msgs);
303 if (default_settings) {
304 printf("\tDefault Message Size:\t\t%d\n", saved_def_msgsize);
305 printf("\tDefault Queue Size:\t\t%d\n", saved_def_msgs);
306 } else {
307 printf("\tDefault Message Size:\t\tNot Supported\n");
308 printf("\tDefault Queue Size:\t\tNot Supported\n");
309 }
310 printf("\n");
311
312 validate_current_settings();
313
314 printf("Adjusted system state for testing:\n");
315 printf("\tRLIMIT_MSGQUEUE(soft):\t\t%ld\n", (long) cur_limits.rlim_cur);
316 printf("\tRLIMIT_MSGQUEUE(hard):\t\t%ld\n", (long) cur_limits.rlim_max);
317 printf("\tMaximum Message Size:\t\t%d\n", cur_max_msgsize);
318 printf("\tMaximum Queue Size:\t\t%d\n", cur_max_msgs);
319 if (default_settings) {
320 printf("\tDefault Message Size:\t\t%d\n", cur_def_msgsize);
321 printf("\tDefault Queue Size:\t\t%d\n", cur_def_msgs);
322 }
323
324 printf("\n\nTest series 1, behavior when no attr struct "
325 "passed to mq_open:\n");
326 if (!default_settings) {
327 test_queue(NULL, &result);
328 printf("Given sane system settings, mq_open without an attr "
329 "struct succeeds:\tPASS\n");
330 if (result.mq_maxmsg != cur_max_msgs ||
331 result.mq_msgsize != cur_max_msgsize) {
332 printf("Kernel does not support setting the default "
333 "mq attributes,\nbut also doesn't tie the "
334 "defaults to the maximums:\t\t\tPASS\n");
335 } else {
336 set(max_msgs, ++cur_max_msgs);
337 set(max_msgsize, ++cur_max_msgsize);
338 test_queue(NULL, &result);
339 if (result.mq_maxmsg == cur_max_msgs &&
340 result.mq_msgsize == cur_max_msgsize)
341 printf("Kernel does not support setting the "
342 "default mq attributes and\n"
343 "also ties system wide defaults to "
344 "the system wide maximums:\t\t"
345 "FAIL\n");
346 else
347 printf("Kernel does not support setting the "
348 "default mq attributes,\n"
349 "but also doesn't tie the defaults to "
350 "the maximums:\t\t\tPASS\n");
351 }
352 } else {
353 printf("Kernel supports setting defaults separately from "
354 "maximums:\t\tPASS\n");
355 /*
356 * While we are here, go ahead and test that the kernel
357 * properly follows the default settings
358 */
359 test_queue(NULL, &result);
360 printf("Given sane values, mq_open without an attr struct "
361 "succeeds:\t\tPASS\n");
362 if (result.mq_maxmsg != cur_def_msgs ||
363 result.mq_msgsize != cur_def_msgsize)
364 printf("Kernel supports setting defaults, but does "
365 "not actually honor them:\tFAIL\n\n");
366 else {
367 set(def_msgs, ++cur_def_msgs);
368 set(def_msgsize, ++cur_def_msgsize);
369 /* In case max was the same as the default */
370 set(max_msgs, ++cur_max_msgs);
371 set(max_msgsize, ++cur_max_msgsize);
372 test_queue(NULL, &result);
373 if (result.mq_maxmsg != cur_def_msgs ||
374 result.mq_msgsize != cur_def_msgsize)
375 printf("Kernel supports setting defaults, but "
376 "does not actually honor them:\t"
377 "FAIL\n");
378 else
379 printf("Kernel properly honors default setting "
380 "knobs:\t\t\t\tPASS\n");
381 }
382 set(def_msgs, cur_max_msgs + 1);
383 cur_def_msgs = cur_max_msgs + 1;
384 set(def_msgsize, cur_max_msgsize + 1);
385 cur_def_msgsize = cur_max_msgsize + 1;
386 if (cur_def_msgs * (cur_def_msgsize + 2 * sizeof(void *)) >=
387 cur_limits.rlim_cur) {
388 cur_limits.rlim_cur = (cur_def_msgs + 2) *
389 (cur_def_msgsize + 2 * sizeof(void *));
390 cur_limits.rlim_max = 2 * cur_limits.rlim_cur;
391 setr(RLIMIT_MSGQUEUE, &cur_limits);
392 }
393 if (test_queue_fail(NULL, &result)) {
394 if (result.mq_maxmsg == cur_max_msgs &&
395 result.mq_msgsize == cur_max_msgsize)
396 printf("Kernel properly limits default values "
397 "to lesser of default/max:\t\tPASS\n");
398 else
399 printf("Kernel does not properly set default "
400 "queue parameters when\ndefaults > "
401 "max:\t\t\t\t\t\t\t\tFAIL\n");
402 } else
403 printf("Kernel fails to open mq because defaults are "
404 "greater than maximums:\tFAIL\n");
405 set(def_msgs, --cur_def_msgs);
406 set(def_msgsize, --cur_def_msgsize);
407 cur_limits.rlim_cur = cur_limits.rlim_max = cur_def_msgs *
408 cur_def_msgsize;
409 setr(RLIMIT_MSGQUEUE, &cur_limits);
410 if (test_queue_fail(NULL, &result))
411 printf("Kernel creates queue even though defaults "
412 "would exceed\nrlimit setting:"
413 "\t\t\t\t\t\t\t\tFAIL\n");
414 else
415 printf("Kernel properly fails to create queue when "
416 "defaults would\nexceed rlimit:"
417 "\t\t\t\t\t\t\t\tPASS\n");
418 }
419
420 /*
421 * Test #2 - open with an attr struct that exceeds rlimit
422 */
423 printf("\n\nTest series 2, behavior when attr struct is "
424 "passed to mq_open:\n");
425 cur_max_msgs = 32;
426 cur_max_msgsize = cur_limits.rlim_max >> 4;
427 set(max_msgs, cur_max_msgs);
428 set(max_msgsize, cur_max_msgsize);
429 attr.mq_maxmsg = cur_max_msgs;
430 attr.mq_msgsize = cur_max_msgsize;
431 if (test_queue_fail(&attr, &result))
432 printf("Queue open in excess of rlimit max when euid = 0 "
433 "succeeded:\t\tFAIL\n");
434 else
435 printf("Queue open in excess of rlimit max when euid = 0 "
436 "failed:\t\tPASS\n");
437 attr.mq_maxmsg = cur_max_msgs + 1;
438 attr.mq_msgsize = 10;
439 if (test_queue_fail(&attr, &result))
440 printf("Queue open with mq_maxmsg > limit when euid = 0 "
441 "succeeded:\t\tPASS\n");
442 else
443 printf("Queue open with mq_maxmsg > limit when euid = 0 "
444 "failed:\t\tFAIL\n");
445 attr.mq_maxmsg = 1;
446 attr.mq_msgsize = cur_max_msgsize + 1;
447 if (test_queue_fail(&attr, &result))
448 printf("Queue open with mq_msgsize > limit when euid = 0 "
449 "succeeded:\t\tPASS\n");
450 else
451 printf("Queue open with mq_msgsize > limit when euid = 0 "
452 "failed:\t\tFAIL\n");
453 attr.mq_maxmsg = 65536;
454 attr.mq_msgsize = 65536;
455 if (test_queue_fail(&attr, &result))
456 printf("Queue open with total size > 2GB when euid = 0 "
457 "succeeded:\t\tFAIL\n");
458 else
459 printf("Queue open with total size > 2GB when euid = 0 "
460 "failed:\t\t\tPASS\n");
461
462 if (seteuid(99) == -1) {
463 perror("seteuid() failed");
464 exit(1);
465 }
466
467 attr.mq_maxmsg = cur_max_msgs;
468 attr.mq_msgsize = cur_max_msgsize;
469 if (test_queue_fail(&attr, &result))
470 printf("Queue open in excess of rlimit max when euid = 99 "
471 "succeeded:\t\tFAIL\n");
472 else
473 printf("Queue open in excess of rlimit max when euid = 99 "
474 "failed:\t\tPASS\n");
475 attr.mq_maxmsg = cur_max_msgs + 1;
476 attr.mq_msgsize = 10;
477 if (test_queue_fail(&attr, &result))
478 printf("Queue open with mq_maxmsg > limit when euid = 99 "
479 "succeeded:\t\tFAIL\n");
480 else
481 printf("Queue open with mq_maxmsg > limit when euid = 99 "
482 "failed:\t\tPASS\n");
483 attr.mq_maxmsg = 1;
484 attr.mq_msgsize = cur_max_msgsize + 1;
485 if (test_queue_fail(&attr, &result))
486 printf("Queue open with mq_msgsize > limit when euid = 99 "
487 "succeeded:\t\tFAIL\n");
488 else
489 printf("Queue open with mq_msgsize > limit when euid = 99 "
490 "failed:\t\tPASS\n");
491 attr.mq_maxmsg = 65536;
492 attr.mq_msgsize = 65536;
493 if (test_queue_fail(&attr, &result))
494 printf("Queue open with total size > 2GB when euid = 99 "
495 "succeeded:\t\tFAIL\n");
496 else
497 printf("Queue open with total size > 2GB when euid = 99 "
498 "failed:\t\t\tPASS\n");
499
500 shutdown(0,"",0);
501 }
502