To get this branch, use:
bzr branch
http://bzr.recompile.se/loggerhead/mandos/trunk
« back to all changes in this revision
Viewing changes to dracut-module/password-agent.c
- browse files at revision 823
- compare with another revision
- download diff
- download tarball
- view history from revision 823
- Committer: Teddy Hogeborn
- Date: 2016-03-05 22:43:39 UTC
- mfrom: (237.4.67 release)
- Revision ID: teddy@recompile.se-20160305224339-a3kklul7we8jozno
Merge from release branch.
- files added:
- initramfs-tools-hook-conf
- files removed:
- debian/mandos-client.templates
- debian/tests
- dracut-module
- files modified:
- .bzrignore
added
removed
dracut-module/password-agent.c
1
/* -*- mode: c; coding: utf-8; after-save-hook: (lambda () (let* ((find-build-directory (lambda (try-directory &optional base-directory) (let ((base-directory (or base-directory try-directory))) (cond ((equal try-directory "/") base-directory) ((file-readable-p (concat (file-name-as-directory try-directory) "Makefile")) try-directory) ((funcall find-build-directory (directory-file-name (file-name-directory try-directory)) base-directory)))))) (build-directory (funcall find-build-directory (buffer-file-name))) (local-build-directory (if (fboundp 'file-local-name) (file-local-name build-directory) (or (file-remote-p build-directory 'localname) build-directory))) (command (file-relative-name (file-name-sans-extension (buffer-file-name)) build-directory))) (pcase (progn (if (get-buffer "*Test*") (kill-buffer "*Test*")) (process-file-shell-command (let ((qbdir (shell-quote-argument local-build-directory)) (qcmd (shell-quote-argument command))) (format "cd %s && CFLAGS=-Werror make --silent %s && %s --test --verbose" qbdir qcmd qcmd)) nil "*Test*")) (0 (let ((w (get-buffer-window "*Test*"))) (if w (delete-window w)))) (_ (with-current-buffer "*Test*" (compilation-mode) (cd-absolute build-directory)) (display-buffer "*Test*" '(display-buffer-in-side-window)))))); -*- */
2
/*
3
* Mandos password agent - Simple password agent to run Mandos client
4
*
5
* Copyright © 2019 Teddy Hogeborn
6
* Copyright © 2019 Björn Påhlsson
7
*
8
* This file is part of Mandos.
9
*
10
* Mandos is free software: you can redistribute it and/or modify it
11
* under the terms of the GNU General Public License as published by
12
* the Free Software Foundation, either version 3 of the License, or
13
* (at your option) any later version.
14
*
15
* Mandos is distributed in the hope that it will be useful, but
16
* WITHOUT ANY WARRANTY; without even the implied warranty of
17
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18
* General Public License for more details.
19
*
20
* You should have received a copy of the GNU General Public License
21
* along with Mandos. If not, see <http://www.gnu.org/licenses/>.
22
*
23
* Contact the authors at <mandos@recompile.se>.
24
*/
25
26
#define _GNU_SOURCE
27
#include <inttypes.h> /* uintmax_t, PRIuMAX, PRIdMAX,
28
intmax_t, uint32_t, SCNx32,
29
SCNuMAX, SCNxMAX */
30
#include <stddef.h> /* size_t */
31
#include <sys/types.h> /* pid_t, uid_t, gid_t, getuid(),
32
getpid() */
33
#include <stdbool.h> /* bool, true, false */
34
#include <signal.h> /* struct sigaction, sigset_t,
35
sigemptyset(), sigaddset(),
36
SIGCHLD, pthread_sigmask(),
37
SIG_BLOCK, SIG_SETMASK, SA_RESTART,
38
SA_NOCLDSTOP, sigfillset(), kill(),
39
SIGTERM, sigdelset(), SIGKILL,
40
NSIG, sigismember(), SA_ONSTACK,
41
SIG_DFL, SIG_IGN, SIGINT, SIGQUIT,
42
SIGHUP, SIGSTOP, SIG_UNBLOCK */
43
#include <stdlib.h> /* EXIT_SUCCESS, EXIT_FAILURE,
44
malloc(), free(), strtoumax(),
45
realloc(), setenv(), calloc(),
46
mkdtemp(), mkostemp() */
47
#include <iso646.h> /* not, or, and, xor */
48
#include <error.h> /* error() */
49
#include <sysexits.h> /* EX_USAGE, EX_OSERR, EX_OSFILE */
50
#include <errno.h> /* errno, error_t, EACCES,
51
ENAMETOOLONG, ENOENT, ENOTDIR,
52
EEXIST, ECHILD, EPERM, ENOMEM,
53
EAGAIN, EINTR, ENOBUFS, EADDRINUSE,
54
ECONNREFUSED, ECONNRESET,
55
ETOOMANYREFS, EMSGSIZE, EBADF,
56
EINVAL */
57
#include <string.h> /* strdup(), memcpy(),
58
explicit_bzero(), memset(),
59
strcmp(), strlen(), strncpy(),
60
memcmp(), basename() */
61
#include <argz.h> /* argz_create(), argz_count(),
62
argz_extract(), argz_next(),
63
argz_add() */
64
#include <sys/epoll.h> /* epoll_create1(), EPOLL_CLOEXEC,
65
epoll_ctl(), EPOLL_CTL_ADD,
66
struct epoll_event, EPOLLIN,
67
EPOLLRDHUP, EPOLLOUT,
68
epoll_pwait() */
69
#include <time.h> /* struct timespec, clock_gettime(),
70
CLOCK_MONOTONIC */
71
#include <argp.h> /* struct argp_option, OPTION_HIDDEN,
72
OPTION_ALIAS, struct argp_state,
73
ARGP_ERR_UNKNOWN, ARGP_KEY_ARGS,
74
struct argp, argp_parse(),
75
ARGP_NO_EXIT */
76
#include <unistd.h> /* uid_t, gid_t, close(), pipe2(),
77
fork(), _exit(), dup2(),
78
STDOUT_FILENO, setresgid(),
79
setresuid(), execv(), ssize_t,
80
read(), dup3(), getuid(), dup(),
81
STDERR_FILENO, pause(), write(),
82
rmdir(), unlink(), getpid() */
83
#include <sys/mman.h> /* munlock(), mlock() */
84
#include <fcntl.h> /* O_CLOEXEC, O_NONBLOCK, fcntl(),
85
F_GETFD, F_GETFL, FD_CLOEXEC,
86
open(), O_WRONLY, O_NOCTTY,
87
O_RDONLY, O_NOFOLLOW */
88
#include <sys/wait.h> /* waitpid(), WNOHANG, WIFEXITED(),
89
WEXITSTATUS() */
90
#include <limits.h> /* PIPE_BUF, NAME_MAX, INT_MAX */
91
#include <sys/inotify.h> /* inotify_init1(), IN_NONBLOCK,
92
IN_CLOEXEC, inotify_add_watch(),
93
IN_CLOSE_WRITE, IN_MOVED_TO,
94
IN_MOVED_FROM, IN_DELETE,
95
IN_EXCL_UNLINK, IN_ONLYDIR,
96
struct inotify_event */
97
#include <fnmatch.h> /* fnmatch(), FNM_FILE_NAME */
98
#include <stdio.h> /* asprintf(), FILE, fopen(),
99
getline(), sscanf(), feof(),
100
ferror(), fclose(), stderr,
101
rename(), fdopen(), fprintf(),
102
fscanf() */
103
#include <glib.h> /* GKeyFile, g_key_file_free(), g_key_file_new(),
104
GError, g_key_file_load_from_file(),
105
G_KEY_FILE_NONE, TRUE, G_FILE_ERROR_NOENT,
106
g_key_file_get_string(), guint64,
107
g_key_file_get_uint64(),
108
G_KEY_FILE_ERROR_KEY_NOT_FOUND, gconstpointer,
109
g_assert_true(), g_assert_nonnull(),
110
g_assert_null(), g_assert_false(),
111
g_assert_cmpint(), g_assert_cmpuint(),
112
g_test_skip(), g_assert_cmpstr(),
113
g_test_init(), g_test_add(), g_test_run(),
114
GOptionContext, g_option_context_new(),
115
g_option_context_set_help_enabled(), FALSE,
116
g_option_context_set_ignore_unknown_options(),
117
gboolean, GOptionEntry, G_OPTION_ARG_NONE,
118
g_option_context_add_main_entries(),
119
g_option_context_parse(),
120
g_option_context_free(), g_error() */
121
#include <sys/un.h> /* struct sockaddr_un, SUN_LEN */
122
#include <sys/socket.h> /* AF_LOCAL, socket(), PF_LOCAL,
123
SOCK_DGRAM, SOCK_NONBLOCK,
124
SOCK_CLOEXEC, connect(),
125
struct sockaddr, socklen_t,
126
shutdown(), SHUT_RD, send(),
127
MSG_NOSIGNAL, bind(), recv(),
128
socketpair() */
129
#include <glob.h> /* globfree(), glob_t, glob(),
130
GLOB_ERR, GLOB_NOSORT, GLOB_MARK,
131
GLOB_ABORTED, GLOB_NOMATCH,
132
GLOB_NOSPACE */
133
134
/* End of includes */
135
136
/* Start of declarations of private types and functions */
137
138
/* microseconds of CLOCK_MONOTONIC absolute time; 0 means unset */
139
typedef uintmax_t mono_microsecs;
140
141
/* "task_queue" - A queue of tasks to be run */
142
typedef struct {
143
struct task_struct *tasks; /* Tasks in this queue */
144
size_t length; /* Number of tasks */
145
/* Memory allocated for "tasks", in bytes */
146
size_t allocated;
147
/* Time when this queue should be run, at the latest */
148
mono_microsecs next_run;
149
} __attribute__((designated_init)) task_queue;
150
151
/* "func_type" - A function type for task functions
152
153
I.e. functions for the code which runs when a task is run, all have
154
this type */
155
typedef void (task_func) (const struct task_struct,
156
task_queue *const)
157
__attribute__((nonnull));
158
159
/* "buffer" - A data buffer for a growing array of bytes
160
161
Used for the "password" variable */
162
typedef struct {
163
char *data;
164
size_t length;
165
size_t allocated;
166
} __attribute__((designated_init)) buffer;
167
168
/* "string_set" - A set type which can contain strings
169
170
Used by the "cancelled_filenames" variable */
171
typedef struct {
172
char *argz; /* Do not access these except in */
173
size_t argz_len; /* the string_set_* functions */
174
} __attribute__((designated_init)) string_set;
175
176
/* "task_context" - local variables for tasks
177
178
This data structure distinguishes between different tasks which are
179
using the same function. This data structure is passed to every
180
task function when each task is run.
181
182
Note that not every task uses every struct member. */
183
typedef struct task_struct {
184
task_func *const func; /* The function run by this task */
185
char *const question_filename; /* The question file */
186
const pid_t pid; /* Mandos client process ID */
187
const int epoll_fd; /* The epoll set file descriptor */
188
bool *const quit_now; /* Set to true on fatal errors */
189
const int fd; /* General purpose file descriptor */
190
bool *const mandos_client_exited; /* Set true when client exits */
191
buffer *const password; /* As read from client process */
192
bool *const password_is_read; /* "password" is done growing */
193
char *filename; /* General purpose file name */
194
/* A set of strings of all the file names of questions which have
195
been cancelled for any reason; tasks pertaining to these question
196
files should not be run */
197
string_set *const cancelled_filenames;
198
const mono_microsecs notafter; /* "NotAfter" from question file */
199
/* Updated before each queue run; is compared with queue.next_run */
200
const mono_microsecs *const current_time;
201
} __attribute__((designated_init)) task_context;
202
203
/* Declare all our functions here so we can define them in any order
204
below. Note: test functions are *not* declared here, they are
205
declared in the test section. */
206
__attribute__((warn_unused_result))
207
static bool should_only_run_tests(int *, char **[]);
208
__attribute__((warn_unused_result, cold))
209
static bool run_tests(int, char *[]);
210
static void handle_sigchld(__attribute__((unused)) int sig){}
211
__attribute__((warn_unused_result, malloc))
212
task_queue *create_queue(void);
213
__attribute__((nonnull, warn_unused_result))
214
bool add_to_queue(task_queue *const, const task_context);
215
__attribute__((nonnull))
216
void cleanup_task(const task_context *const);
217
__attribute__((nonnull))
218
void cleanup_queue(task_queue *const *const);
219
__attribute__((pure, nonnull, warn_unused_result))
220
bool queue_has_question(const task_queue *const);
221
__attribute__((nonnull))
222
void cleanup_close(const int *const);
223
__attribute__((nonnull))
224
void cleanup_string(char *const *const);
225
__attribute__((nonnull))
226
void cleanup_buffer(buffer *const);
227
__attribute__((pure, nonnull, warn_unused_result))
228
bool string_set_contains(const string_set, const char *const);
229
__attribute__((nonnull, warn_unused_result))
230
bool string_set_add(string_set *const, const char *const);
231
__attribute__((nonnull))
232
void string_set_clear(string_set *);
233
void string_set_swap(string_set *const, string_set *const);
234
__attribute__((nonnull, warn_unused_result))
235
bool start_mandos_client(task_queue *const, const int, bool *const,
236
bool *const, buffer *const, bool *const,
237
const struct sigaction *const,
238
const sigset_t, const char *const,
239
const uid_t, const gid_t,
240
const char *const *const);
241
__attribute__((nonnull))
242
task_func wait_for_mandos_client_exit;
243
__attribute__((nonnull))
244
task_func read_mandos_client_output;
245
__attribute__((warn_unused_result))
246
bool add_inotify_dir_watch(task_queue *const, const int, bool *const,
247
buffer *const, const char *const,
248
string_set *, const mono_microsecs *const,
249
bool *const, bool *const);
250
__attribute__((nonnull))
251
task_func read_inotify_event;
252
__attribute__((nonnull))
253
task_func open_and_parse_question;
254
__attribute__((nonnull))
255
task_func cancel_old_question;
256
__attribute__((nonnull))
257
task_func connect_question_socket;
258
__attribute__((nonnull))
259
task_func send_password_to_socket;
260
__attribute__((warn_unused_result))
261
bool add_existing_questions(task_queue *const, const int,
262
buffer *const, string_set *,
263
const mono_microsecs *const,
264
bool *const, bool *const,
265
const char *const);
266
__attribute__((nonnull, warn_unused_result))
267
bool wait_for_event(const int, const mono_microsecs,
268
const mono_microsecs);
269
bool run_queue(task_queue **const, string_set *const, bool *const);
270
bool clear_all_fds_from_epoll_set(const int);
271
mono_microsecs get_current_time(void);
272
__attribute__((nonnull, warn_unused_result))
273
bool setup_signal_handler(struct sigaction *const);
274
__attribute__((nonnull))
275
bool restore_signal_handler(const struct sigaction *const);
276
__attribute__((nonnull, warn_unused_result))
277
bool block_sigchld(sigset_t *const);
278
__attribute__((nonnull))
279
bool restore_sigmask(const sigset_t *const);
280
__attribute__((nonnull))
281
bool parse_arguments(int, char *[], const bool, char **, char **,
282
uid_t *const , gid_t *const, char **, size_t *);
283
284
/* End of declarations of private types and functions */
285
286
/* Start of "main" section; this section LACKS TESTS!
287
288
Code here should be as simple as possible. */
289
290
/* These are required to be global by Argp */
291
const char *argp_program_version = "password-agent " VERSION;
292
const char *argp_program_bug_address = "<mandos@recompile.se>";
293
294
int main(int argc, char *argv[]){
295
296
/* If the --test option is passed, skip all normal operations and
297
instead only run the run_tests() function, which also does all
298
its own option parsing, so we don't have to do anything here. */
299
if(should_only_run_tests(&argc, &argv)){
300
if(run_tests(argc, argv)){
301
return EXIT_SUCCESS; /* All tests successful */
302
}
303
return EXIT_FAILURE; /* Some test(s) failed */
304
}
305
306
__attribute__((cleanup(cleanup_string)))
307
char *agent_directory = NULL;
308
309
__attribute__((cleanup(cleanup_string)))
310
char *helper_directory = NULL;
311
312
uid_t user = 0;
313
gid_t group = 0;
314
315
__attribute__((cleanup(cleanup_string)))
316
char *mandos_argz = NULL;
317
size_t mandos_argz_length = 0;
318
319
if(not parse_arguments(argc, argv, true, &agent_directory,
320
&helper_directory, &user, &group,
321
&mandos_argz, &mandos_argz_length)){
322
/* This should never happen, since "true" is passed as the third
323
argument to parse_arguments() above, which should make
324
argp_parse() call exit() if any parsing error occurs. */
325
error(EX_USAGE, errno, "Failed to parse arguments");
326
}
327
328
const char default_agent_directory[] = "/run/systemd/ask-password";
329
const char default_helper_directory[]
330
= "/lib/mandos/plugin-helpers";
331
const char *const default_argv[]
332
= {"/lib/mandos/plugins.d/mandos-client", NULL };
333
334
/* Set variables to default values if unset */
335
if(agent_directory == NULL){
336
agent_directory = strdup(default_agent_directory);
337
if(agent_directory == NULL){
338
error(EX_OSERR, errno, "Failed strdup()");
339
}
340
}
341
if(helper_directory == NULL){
342
helper_directory = strdup(default_helper_directory);
343
if(helper_directory == NULL){
344
error(EX_OSERR, errno, "Failed strdup()");
345
}
346
}
347
if(user == 0){
348
user = 65534; /* nobody */
349
}
350
if(group == 0){
351
group = 65534; /* nogroup */
352
}
353
/* If parse_opt did not create an argz vector, create one with
354
default values */
355
if(mandos_argz == NULL){
356
#ifdef __GNUC__
357
#pragma GCC diagnostic push
358
/* argz_create() takes a non-const argv for some unknown reason -
359
argz_create() isn't modifying the strings, just copying them.
360
Therefore, this cast to non-const should be safe. */
361
#pragma GCC diagnostic ignored "-Wcast-qual"
362
#endif
363
errno = argz_create((char *const *)default_argv, &mandos_argz,
364
&mandos_argz_length);
365
#ifdef __GNUC__
366
#pragma GCC diagnostic pop
367
#endif
368
if(errno != 0){
369
error(EX_OSERR, errno, "Failed argz_create()");
370
}
371
}
372
/* Use argz vector to create a normal argv, usable by execv() */
373
374
char **mandos_argv = malloc((argz_count(mandos_argz,
375
mandos_argz_length)
376
+ 1) * sizeof(char *));
377
if(mandos_argv == NULL){
378
error_t saved_errno = errno;
379
free(mandos_argz);
380
error(EX_OSERR, saved_errno, "Failed malloc()");
381
}
382
argz_extract(mandos_argz, mandos_argz_length, mandos_argv);
383
384
sigset_t orig_sigmask;
385
if(not block_sigchld(&orig_sigmask)){
386
return EX_OSERR;
387
}
388
389
struct sigaction old_sigchld_action;
390
if(not setup_signal_handler(&old_sigchld_action)){
391
return EX_OSERR;
392
}
393
394
mono_microsecs current_time = 0;
395
396
bool mandos_client_exited = false;
397
bool quit_now = false;
398
__attribute__((cleanup(cleanup_close)))
399
const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);
400
if(epoll_fd < 0){
401
error(EX_OSERR, errno, "Failed to create epoll set fd");
402
}
403
__attribute__((cleanup(cleanup_queue)))
404
task_queue *queue = create_queue();
405
if(queue == NULL){
406
error(EX_OSERR, errno, "Failed to create task queue");
407
}
408
409
__attribute__((cleanup(cleanup_buffer)))
410
buffer password = {};
411
bool password_is_read = false;
412
413
__attribute__((cleanup(string_set_clear)))
414
string_set cancelled_filenames = {};
415
416
/* Add tasks to queue */
417
if(not start_mandos_client(queue, epoll_fd, &mandos_client_exited,
418
&quit_now, &password, &password_is_read,
419
&old_sigchld_action, orig_sigmask,
420
helper_directory, user, group,
421
(const char *const *)mandos_argv)){
422
return EX_OSERR; /* Error has already been printed */
423
}
424
/* These variables were only for start_mandos_client() and are not
425
needed anymore */
426
free(mandos_argv);
427
free(mandos_argz);
428
mandos_argz = NULL;
429
if(not add_inotify_dir_watch(queue, epoll_fd, &quit_now, &password,
430
agent_directory, &cancelled_filenames,
431
¤t_time, &mandos_client_exited,
432
&password_is_read)){
433
switch(errno){ /* Error has already been printed */
434
case EACCES:
435
case ENAMETOOLONG:
436
case ENOENT:
437
case ENOTDIR:
438
return EX_OSFILE;
439
default:
440
return EX_OSERR;
441
}
442
}
443
if(not add_existing_questions(queue, epoll_fd, &password,
444
&cancelled_filenames, ¤t_time,
445
&mandos_client_exited,
446
&password_is_read, agent_directory)){
447
return EXIT_FAILURE; /* Error has already been printed */
448
}
449
450
/* Run queue */
451
do {
452
current_time = get_current_time();
453
if(not wait_for_event(epoll_fd, queue->next_run, current_time)){
454
const error_t saved_errno = errno;
455
error(EXIT_FAILURE, saved_errno, "Failure while waiting for"
456
" events");
457
}
458
459
current_time = get_current_time();
460
if(not run_queue(&queue, &cancelled_filenames, &quit_now)){
461
const error_t saved_errno = errno;
462
error(EXIT_FAILURE, saved_errno, "Failure while running queue");
463
}
464
465
/* When no tasks about questions are left in the queue, break out
466
of the loop (and implicitly exit the program) */
467
} while(queue_has_question(queue));
468
469
restore_signal_handler(&old_sigchld_action);
470
restore_sigmask(&orig_sigmask);
471
472
return EXIT_SUCCESS;
473
}
474
475
__attribute__((warn_unused_result))
476
mono_microsecs get_current_time(void){
477
struct timespec currtime;
478
if(clock_gettime(CLOCK_MONOTONIC, &currtime) != 0){
479
error(0, errno, "Failed to get current time");
480
return 0;
481
}
482
return ((mono_microsecs)currtime.tv_sec * 1000000) /* seconds */
483
+ ((mono_microsecs)currtime.tv_nsec / 1000); /* nanoseconds */
484
}
485
486
/* End of "main" section */
487
488
/* Start of regular code section; ALL this code has tests */
489
490
__attribute__((nonnull))
491
bool parse_arguments(int argc, char *argv[], const bool exit_failure,
492
char **agent_directory, char **helper_directory,
493
uid_t *const user, gid_t *const group,
494
char **mandos_argz, size_t *mandos_argz_length){
495
496
const struct argp_option options[] = {
497
{ .name="agent-directory",.key='d', .arg="DIRECTORY",
498
.doc="Systemd password agent directory" },
499
{ .name="helper-directory",.key=128, .arg="DIRECTORY",
500
.doc="Mandos Client password helper directory" },
501
{ .name="plugin-helper-dir", .key=129, /* From plugin-runner */
502
.flags=OPTION_HIDDEN | OPTION_ALIAS },
503
{ .name="user", .key='u', .arg="USERID",
504
.doc="User ID the Mandos Client will use as its unprivileged"
505
" user" },
506
{ .name="userid", .key=130, /* From plugin--runner */
507
.flags=OPTION_HIDDEN | OPTION_ALIAS },
508
{ .name="group", .key='g', .arg="GROUPID",
509
.doc="Group ID the Mandos Client will use as its unprivileged"
510
" group" },
511
{ .name="groupid", .key=131, /* From plugin--runner */
512
.flags=OPTION_HIDDEN | OPTION_ALIAS },
513
{ .name="test", .key=255, /* See should_only_run_tests() */
514
.doc="Skip normal operation, and only run self-tests. See"
515
" --test --help.", .group=10, },
516
{ NULL },
517
};
518
519
__attribute__((nonnull(3)))
520
error_t parse_opt(int key, char *arg, struct argp_state *state){
521
errno = 0;
522
switch(key){
523
case 'd': /* --agent-directory */
524
*agent_directory = strdup(arg);
525
break;
526
case 128: /* --helper-directory */
527
case 129: /* --plugin-helper-dir */
528
*helper_directory = strdup(arg);
529
break;
530
case 'u': /* --user */
531
case 130: /* --userid */
532
{
533
char *tmp;
534
uintmax_t tmp_id = 0;
535
errno = 0;
536
tmp_id = (uid_t)strtoumax(arg, &tmp, 10);
537
if(errno != 0 or tmp == arg or *tmp != '\0'
538
or tmp_id != (uid_t)tmp_id or (uid_t)tmp_id == 0){
539
return ARGP_ERR_UNKNOWN;
540
}
541
*user = (uid_t)tmp_id;
542
errno = 0;
543
break;
544
}
545
case 'g': /* --group */
546
case 131: /* --groupid */
547
{
548
char *tmp;
549
uintmax_t tmp_id = 0;
550
errno = 0;
551
tmp_id = (uid_t)strtoumax(arg, &tmp, 10);
552
if(errno != 0 or tmp == arg or *tmp != '\0'
553
or tmp_id != (gid_t)tmp_id or (gid_t)tmp_id == 0){
554
return ARGP_ERR_UNKNOWN;
555
}
556
*group = (gid_t)tmp_id;
557
errno = 0;
558
break;
559
}
560
case ARGP_KEY_ARGS:
561
/* Copy arguments into argz vector */
562
return argz_create(state->argv + state->next, mandos_argz,
563
mandos_argz_length);
564
default:
565
return ARGP_ERR_UNKNOWN;
566
}
567
return errno;
568
}
569
570
const struct argp argp = {
571
.options=options,
572
.parser=parse_opt,
573
.args_doc="[MANDOS_CLIENT [OPTION...]]\n--test",
574
.doc = "Mandos password agent -- runs Mandos client as a"
575
" systemd password agent",
576
};
577
578
errno = argp_parse(&argp, argc, argv,
579
exit_failure ? 0 : ARGP_NO_EXIT, NULL, NULL);
580
581
return errno == 0;
582
}
583
584
__attribute__((nonnull, warn_unused_result))
585
bool block_sigchld(sigset_t *const orig_sigmask){
586
sigset_t sigchld_sigmask;
587
if(sigemptyset(&sigchld_sigmask) < 0){
588
error(0, errno, "Failed to empty signal set");
589
return false;
590
}
591
if(sigaddset(&sigchld_sigmask, SIGCHLD) < 0){
592
error(0, errno, "Failed to add SIGCHLD to signal set");
593
return false;
594
}
595
if(pthread_sigmask(SIG_BLOCK, &sigchld_sigmask, orig_sigmask) != 0){
596
error(0, errno, "Failed to block SIGCHLD signal");
597
return false;
598
}
599
return true;
600
}
601
602
__attribute__((nonnull, warn_unused_result, const))
603
bool restore_sigmask(const sigset_t *const orig_sigmask){
604
if(pthread_sigmask(SIG_SETMASK, orig_sigmask, NULL) != 0){
605
error(0, errno, "Failed to restore blocked signals");
606
return false;
607
}
608
return true;
609
}
610
611
__attribute__((nonnull, warn_unused_result))
612
bool setup_signal_handler(struct sigaction *const old_sigchld_action){
613
struct sigaction sigchld_action = {
614
.sa_handler=handle_sigchld,
615
.sa_flags=SA_RESTART | SA_NOCLDSTOP,
616
};
617
/* Set all signals in "sa_mask" struct member; this makes all
618
signals automatically blocked during signal handler */
619
if(sigfillset(&sigchld_action.sa_mask) != 0){
620
error(0, errno, "Failed to do sigfillset()");
621
return false;
622
}
623
if(sigaction(SIGCHLD, &sigchld_action, old_sigchld_action) != 0){
624
error(0, errno, "Failed to set SIGCHLD signal handler");
625
return false;
626
}
627
return true;
628
}
629
630
__attribute__((nonnull, warn_unused_result))
631
bool restore_signal_handler(const struct sigaction *const
632
old_sigchld_action){
633
if(sigaction(SIGCHLD, old_sigchld_action, NULL) != 0){
634
error(0, errno, "Failed to restore signal handler");
635
return false;
636
}
637
return true;
638
}
639
640
__attribute__((warn_unused_result, malloc))
641
task_queue *create_queue(void){
642
task_queue *queue = malloc(sizeof(task_queue));
643
if(queue){
644
queue->tasks = NULL;
645
queue->length = 0;
646
queue->allocated = 0;
647
queue->next_run = 0;
648
}
649
return queue;
650
}
651
652
__attribute__((nonnull, warn_unused_result))
653
bool add_to_queue(task_queue *const queue, const task_context task){
654
const size_t needed_size = sizeof(task_context)*(queue->length + 1);
655
if(needed_size > (queue->allocated)){
656
task_context *const new_tasks = realloc(queue->tasks,
657
needed_size);
658
if(new_tasks == NULL){
659
error(0, errno, "Failed to allocate %" PRIuMAX
660
" bytes for queue->tasks", (uintmax_t)needed_size);
661
return false;
662
}
663
queue->tasks = new_tasks;
664
queue->allocated = needed_size;
665
}
666
/* Using memcpy here is necessary because doing */
667
/* queue->tasks[queue->length++] = task; */
668
/* would violate const-ness of task members */
669
memcpy(&(queue->tasks[queue->length++]), &task,
670
sizeof(task_context));
671
return true;
672
}
673
674
__attribute__((nonnull))
675
void cleanup_task(const task_context *const task){
676
const error_t saved_errno = errno;
677
/* free and close all task data */
678
free(task->question_filename);
679
if(task->filename != task->question_filename){
680
free(task->filename);
681
}
682
if(task->pid > 0){
683
kill(task->pid, SIGTERM);
684
}
685
if(task->fd > 0){
686
close(task->fd);
687
}
688
errno = saved_errno;
689
}
690
691
__attribute__((nonnull))
692
void free_queue(task_queue *const queue){
693
free(queue->tasks);
694
free(queue);
695
}
696
697
__attribute__((nonnull))
698
void cleanup_queue(task_queue *const *const queue){
699
if(*queue == NULL){
700
return;
701
}
702
for(size_t i = 0; i < (*queue)->length; i++){
703
const task_context *const task = ((*queue)->tasks)+i;
704
cleanup_task(task);
705
}
706
free_queue(*queue);
707
}
708
709
__attribute__((pure, nonnull, warn_unused_result))
710
bool queue_has_question(const task_queue *const queue){
711
for(size_t i=0; i < queue->length; i++){
712
if(queue->tasks[i].question_filename != NULL){
713
return true;
714
}
715
}
716
return false;
717
}
718
719
__attribute__((nonnull))
720
void cleanup_close(const int *const fd){
721
const error_t saved_errno = errno;
722
close(*fd);
723
errno = saved_errno;
724
}
725
726
__attribute__((nonnull))
727
void cleanup_string(char *const *const ptr){
728
free(*ptr);
729
}
730
731
__attribute__((nonnull))
732
void cleanup_buffer(buffer *buf){
733
if(buf->allocated > 0){
734
#if defined(__GLIBC_PREREQ) and __GLIBC_PREREQ(2, 25)
735
explicit_bzero(buf->data, buf->allocated);
736
#else
737
memset(buf->data, '\0', buf->allocated);
738
#endif
739
}
740
if(buf->data != NULL){
741
if(munlock(buf->data, buf->allocated) != 0){
742
error(0, errno, "Failed to unlock memory of old buffer");
743
}
744
free(buf->data);
745
buf->data = NULL;
746
}
747
buf->length = 0;
748
buf->allocated = 0;
749
}
750
751
__attribute__((pure, nonnull, warn_unused_result))
752
bool string_set_contains(const string_set set, const char *const str){
753
for(const char *s = set.argz; s != NULL and set.argz_len > 0;
754
s = argz_next(set.argz, set.argz_len, s)){
755
if(strcmp(s, str) == 0){
756
return true;
757
}
758
}
759
return false;
760
}
761
762
__attribute__((nonnull, warn_unused_result))
763
bool string_set_add(string_set *const set, const char *const str){
764
if(string_set_contains(*set, str)){
765
return true;
766
}
767
error_t error = argz_add(&set->argz, &set->argz_len, str);
768
if(error == 0){
769
return true;
770
}
771
errno = error;
772
return false;
773
}
774
775
__attribute__((nonnull))
776
void string_set_clear(string_set *set){
777
free(set->argz);
778
set->argz = NULL;
779
set->argz_len = 0;
780
}
781
782
__attribute__((nonnull))
783
void string_set_swap(string_set *const set1, string_set *const set2){
784
/* Swap contents of two string sets */
785
{
786
char *const tmp_argz = set1->argz;
787
set1->argz = set2->argz;
788
set2->argz = tmp_argz;
789
}
790
{
791
const size_t tmp_argz_len = set1->argz_len;
792
set1->argz_len = set2->argz_len;
793
set2->argz_len = tmp_argz_len;
794
}
795
}
796
797
__attribute__((nonnull, warn_unused_result))
798
bool start_mandos_client(task_queue *const queue,
799
const int epoll_fd,
800
bool *const mandos_client_exited,
801
bool *const quit_now, buffer *const password,
802
bool *const password_is_read,
803
const struct sigaction *const
804
old_sigchld_action, const sigset_t sigmask,
805
const char *const helper_directory,
806
const uid_t user, const gid_t group,
807
const char *const *const argv){
808
int pipefds[2];
809
if(pipe2(pipefds, O_CLOEXEC | O_NONBLOCK) != 0){
810
error(0, errno, "Failed to pipe2(..., O_CLOEXEC | O_NONBLOCK)");
811
return false;
812
}
813
814
const pid_t pid = fork();
815
if(pid == 0){
816
if(not restore_signal_handler(old_sigchld_action)){
817
_exit(EXIT_FAILURE);
818
}
819
if(not restore_sigmask(&sigmask)){
820
_exit(EXIT_FAILURE);
821
}
822
if(close(pipefds[0]) != 0){
823
error(0, errno, "Failed to close() parent pipe fd");
824
_exit(EXIT_FAILURE);
825
}
826
if(dup2(pipefds[1], STDOUT_FILENO) == -1){
827
error(0, errno, "Failed to dup2() pipe fd to stdout");
828
_exit(EXIT_FAILURE);
829
}
830
if(close(pipefds[1]) != 0){
831
error(0, errno, "Failed to close() old child pipe fd");
832
_exit(EXIT_FAILURE);
833
}
834
if(setenv("MANDOSPLUGINHELPERDIR", helper_directory, 1) != 0){
835
error(0, errno, "Failed to setenv(\"MANDOSPLUGINHELPERDIR\","
836
" \"%s\", 1)", helper_directory);
837
_exit(EXIT_FAILURE);
838
}
839
if(group != 0 and setresgid(group, 0, 0) == -1){
840
error(0, errno, "Failed to setresgid(-1, %" PRIuMAX ", %"
841
PRIuMAX")", (uintmax_t)group, (uintmax_t)group);
842
_exit(EXIT_FAILURE);
843
}
844
if(user != 0 and setresuid(user, 0, 0) == -1){
845
error(0, errno, "Failed to setresuid(-1, %" PRIuMAX ", %"
846
PRIuMAX")", (uintmax_t)user, (uintmax_t)user);
847
_exit(EXIT_FAILURE);
848
}
849
#ifdef __GNUC__
850
#pragma GCC diagnostic push
851
/* For historical reasons, the "argv" argument to execv() is not
852
const, but it is safe to override this. */
853
#pragma GCC diagnostic ignored "-Wcast-qual"
854
#endif
855
execv(argv[0], (char **)argv);
856
#ifdef __GNUC__
857
#pragma GCC diagnostic pop
858
#endif
859
error(0, errno, "execv(\"%s\", ...) failed", argv[0]);
860
_exit(EXIT_FAILURE);
861
}
862
close(pipefds[1]);
863
864
if(not add_to_queue(queue, (task_context){
865
.func=wait_for_mandos_client_exit,
866
.pid=pid,
867
.mandos_client_exited=mandos_client_exited,
868
.quit_now=quit_now,
869
})){
870
error(0, errno, "Failed to add wait_for_mandos_client to queue");
871
close(pipefds[0]);
872
return false;
873
}
874
875
const int ret = epoll_ctl(epoll_fd, EPOLL_CTL_ADD, pipefds[0],
876
&(struct epoll_event)
877
{ .events=EPOLLIN | EPOLLRDHUP });
878
if(ret != 0 and errno != EEXIST){
879
error(0, errno, "Failed to add file descriptor to epoll set");
880
close(pipefds[0]);
881
return false;
882
}
883
884
return add_to_queue(queue, (task_context){
885
.func=read_mandos_client_output,
886
.epoll_fd=epoll_fd,
887
.fd=pipefds[0],
888
.quit_now=quit_now,
889
.password=password,
890
.password_is_read=password_is_read,
891
});
892
}
893
894
__attribute__((nonnull))
895
void wait_for_mandos_client_exit(const task_context task,
896
task_queue *const queue){
897
const pid_t pid = task.pid;
898
bool *const mandos_client_exited = task.mandos_client_exited;
899
bool *const quit_now = task.quit_now;
900
901
int status;
902
switch(waitpid(pid, &status, WNOHANG)){
903
case 0: /* Not exited yet */
904
if(not add_to_queue(queue, task)){
905
error(0, errno, "Failed to add myself to queue");
906
*quit_now = true;
907
}
908
break;
909
case -1: /* Error */
910
error(0, errno, "waitpid(%" PRIdMAX ") failed", (intmax_t)pid);
911
if(errno != ECHILD){
912
kill(pid, SIGTERM);
913
}
914
*quit_now = true;
915
break;
916
default: /* Has exited */
917
*mandos_client_exited = true;
918
if((not WIFEXITED(status))
919
or (WEXITSTATUS(status) != EXIT_SUCCESS)){
920
error(0, 0, "Mandos client failed or was killed");
921
*quit_now = true;
922
}
923
}
924
}
925
926
__attribute__((nonnull))
927
void read_mandos_client_output(const task_context task,
928
task_queue *const queue){
929
buffer *const password = task.password;
930
bool *const quit_now = task.quit_now;
931
bool *const password_is_read = task.password_is_read;
932
const int fd = task.fd;
933
const int epoll_fd = task.epoll_fd;
934
935
const size_t new_potential_size = (password->length + PIPE_BUF);
936
if(password->allocated < new_potential_size){
937
char *const new_buffer = calloc(new_potential_size, 1);
938
if(new_buffer == NULL){
939
error(0, errno, "Failed to allocate %" PRIuMAX
940
" bytes for password", (uintmax_t)new_potential_size);
941
*quit_now = true;
942
close(fd);
943
return;
944
}
945
if(mlock(new_buffer, new_potential_size) != 0){
946
/* Warn but do not treat as fatal error */
947
if(errno != EPERM and errno != ENOMEM){
948
error(0, errno, "Failed to lock memory for password");
949
}
950
}
951
if(password->length > 0){
952
memcpy(new_buffer, password->data, password->length);
953
#if defined(__GLIBC_PREREQ) and __GLIBC_PREREQ(2, 25)
954
explicit_bzero(password->data, password->allocated);
955
#else
956
memset(password->data, '\0', password->allocated);
957
#endif
958
}
959
if(password->data != NULL){
960
if(munlock(password->data, password->allocated) != 0){
961
error(0, errno, "Failed to unlock memory of old buffer");
962
}
963
free(password->data);
964
}
965
password->data = new_buffer;
966
password->allocated = new_potential_size;
967
}
968
969
const ssize_t read_length = read(fd, password->data
970
+ password->length, PIPE_BUF);
971
972
if(read_length == 0){ /* EOF */
973
*password_is_read = true;
974
close(fd);
975
return;
976
}
977
if(read_length < 0 and errno != EAGAIN){ /* Actual error */
978
error(0, errno, "Failed to read password from Mandos client");
979
*quit_now = true;
980
close(fd);
981
return;
982
}
983
if(read_length > 0){ /* Data has been read */
984
password->length += (size_t)read_length;
985
}
986
987
/* Either data was read, or EAGAIN was indicated, meaning no data
988
available yet */
989
990
/* Re-add the fd to the epoll set */
991
const int ret = epoll_ctl(epoll_fd, EPOLL_CTL_ADD, fd,
992
&(struct epoll_event)
993
{ .events=EPOLLIN | EPOLLRDHUP });
994
if(ret != 0 and errno != EEXIST){
995
error(0, errno, "Failed to re-add file descriptor to epoll set");
996
*quit_now = true;
997
close(fd);
998
return;
999
}
1000
1001
/* Re-add myself to the queue */
1002
if(not add_to_queue(queue, task)){
1003
error(0, errno, "Failed to add myself to queue");
1004
*quit_now = true;
1005
close(fd);
1006
}
1007
}
1008
1009
__attribute__((nonnull, warn_unused_result))
1010
bool add_inotify_dir_watch(task_queue *const queue,
1011
const int epoll_fd, bool *const quit_now,
1012
buffer *const password,
1013
const char *const dir,
1014
string_set *cancelled_filenames,
1015
const mono_microsecs *const current_time,
1016
bool *const mandos_client_exited,
1017
bool *const password_is_read){
1018
const int fd = inotify_init1(IN_NONBLOCK | IN_CLOEXEC);
1019
if(fd == -1){
1020
error(0, errno, "Failed to create inotify instance");
1021
return false;
1022
}
1023
1024
if(inotify_add_watch(fd, dir, IN_CLOSE_WRITE | IN_MOVED_TO
1025
| IN_MOVED_FROM| IN_DELETE | IN_EXCL_UNLINK
1026
| IN_ONLYDIR)
1027
== -1){
1028
error(0, errno, "Failed to create inotify watch on %s", dir);
1029
return false;
1030
}
1031
1032
/* Add the inotify fd to the epoll set */
1033
const int ret = epoll_ctl(epoll_fd, EPOLL_CTL_ADD, fd,
1034
&(struct epoll_event)
1035
{ .events=EPOLLIN | EPOLLRDHUP });
1036
if(ret != 0 and errno != EEXIST){
1037
error(0, errno, "Failed to add file descriptor to epoll set");
1038
close(fd);
1039
return false;
1040
}
1041
1042
const task_context read_inotify_event_task = {
1043
.func=read_inotify_event,
1044
.epoll_fd=epoll_fd,
1045
.quit_now=quit_now,
1046
.password=password,
1047
.fd=fd,
1048
.filename=strdup(dir),
1049
.cancelled_filenames=cancelled_filenames,
1050
.current_time=current_time,
1051
.mandos_client_exited=mandos_client_exited,
1052
.password_is_read=password_is_read,
1053
};
1054
if(read_inotify_event_task.filename == NULL){
1055
error(0, errno, "Failed to strdup(\"%s\")", dir);
1056
close(fd);
1057
return false;
1058
}
1059
1060
return add_to_queue(queue, read_inotify_event_task);
1061
}
1062
1063
__attribute__((nonnull))
1064
void read_inotify_event(const task_context task,
1065
task_queue *const queue){
1066
const int fd = task.fd;
1067
const int epoll_fd = task.epoll_fd;
1068
char *const filename = task.filename;
1069
bool *quit_now = task.quit_now;
1070
buffer *const password = task.password;
1071
string_set *const cancelled_filenames = task.cancelled_filenames;
1072
const mono_microsecs *const current_time = task.current_time;
1073
bool *const mandos_client_exited = task.mandos_client_exited;
1074
bool *const password_is_read = task.password_is_read;
1075
1076
/* "sufficient to read at least one event." - inotify(7) */
1077
const size_t ievent_size = (sizeof(struct inotify_event)
1078
+ NAME_MAX + 1);
1079
struct {
1080
struct inotify_event event;
1081
char name_buffer[NAME_MAX + 1];
1082
} ievent_buffer;
1083
struct inotify_event *const ievent = &ievent_buffer.event;
1084
1085
const ssize_t read_length = read(fd, ievent, ievent_size);
1086
if(read_length == 0){ /* EOF */
1087
error(0, 0, "Got EOF from inotify fd for directory %s", filename);
1088
*quit_now = true;
1089
cleanup_task(&task);
1090
return;
1091
}
1092
if(read_length < 0 and errno != EAGAIN){ /* Actual error */
1093
error(0, errno, "Failed to read from inotify fd for directory %s",
1094
filename);
1095
*quit_now = true;
1096
cleanup_task(&task);
1097
return;
1098
}
1099
if(read_length > 0 /* Data has been read */
1100
and fnmatch("ask.*", ievent->name, FNM_FILE_NAME) == 0){
1101
char *question_filename = NULL;
1102
const ssize_t question_filename_length
1103
= asprintf(&question_filename, "%s/%s", filename, ievent->name);
1104
if(question_filename_length < 0){
1105
error(0, errno, "Failed to create file name from directory name"
1106
" %s and file name %s", filename, ievent->name);
1107
} else {
1108
if(ievent->mask & (IN_CLOSE_WRITE | IN_MOVED_TO)){
1109
if(not add_to_queue(queue, (task_context){
1110
.func=open_and_parse_question,
1111
.epoll_fd=epoll_fd,
1112
.question_filename=question_filename,
1113
.filename=question_filename,
1114
.password=password,
1115
.cancelled_filenames=cancelled_filenames,
1116
.current_time=current_time,
1117
.mandos_client_exited=mandos_client_exited,
1118
.password_is_read=password_is_read,
1119
})){
1120
error(0, errno, "Failed to add open_and_parse_question task"
1121
" for file name %s to queue", filename);
1122
} else {
1123
/* Force the added task (open_and_parse_question) to run
1124
immediately */
1125
queue->next_run = 1;
1126
}
1127
} else if(ievent->mask & (IN_MOVED_FROM | IN_DELETE)){
1128
if(not string_set_add(cancelled_filenames,
1129
question_filename)){
1130
error(0, errno, "Could not add question %s to"
1131
" cancelled_questions", question_filename);
1132
*quit_now = true;
1133
free(question_filename);
1134
cleanup_task(&task);
1135
return;
1136
}
1137
free(question_filename);
1138
}
1139
}
1140
}
1141
1142
/* Either data was read, or EAGAIN was indicated, meaning no data
1143
available yet */
1144
1145
/* Re-add myself to the queue */
1146
if(not add_to_queue(queue, task)){
1147
error(0, errno, "Failed to re-add read_inotify_event(%s) to"
1148
" queue", filename);
1149
*quit_now = true;
1150
cleanup_task(&task);
1151
return;
1152
}
1153
1154
/* Re-add the fd to the epoll set */
1155
const int ret = epoll_ctl(epoll_fd, EPOLL_CTL_ADD, fd,
1156
&(struct epoll_event)
1157
{ .events=EPOLLIN | EPOLLRDHUP });
1158
if(ret != 0 and errno != EEXIST){
1159
error(0, errno, "Failed to re-add inotify file descriptor %d for"
1160
" directory %s to epoll set", fd, filename);
1161
/* Force the added task (read_inotify_event) to run again, at most
1162
one second from now */
1163
if((queue->next_run == 0)
1164
or (queue->next_run > (*current_time + 1000000))){
1165
queue->next_run = *current_time + 1000000;
1166
}
1167
}
1168
}
1169
1170
__attribute__((nonnull))
1171
void open_and_parse_question(const task_context task,
1172
task_queue *const queue){
1173
__attribute__((cleanup(cleanup_string)))
1174
char *question_filename = task.question_filename;
1175
const int epoll_fd = task.epoll_fd;
1176
buffer *const password = task.password;
1177
string_set *const cancelled_filenames = task.cancelled_filenames;
1178
const mono_microsecs *const current_time = task.current_time;
1179
bool *const mandos_client_exited = task.mandos_client_exited;
1180
bool *const password_is_read = task.password_is_read;
1181
1182
/* We use the GLib "Key-value file parser" functions to parse the
1183
question file. See <https://www.freedesktop.org/wiki/Software
1184
/systemd/PasswordAgents/> for specification of contents */
1185
__attribute__((nonnull))
1186
void cleanup_g_key_file(GKeyFile **key_file){
1187
if(*key_file != NULL){
1188
g_key_file_free(*key_file);
1189
}
1190
}
1191
1192
__attribute__((cleanup(cleanup_g_key_file)))
1193
GKeyFile *key_file = g_key_file_new();
1194
if(key_file == NULL){
1195
error(0, errno, "Failed g_key_file_new() for \"%s\"",
1196
question_filename);
1197
return;
1198
}
1199
GError *glib_error = NULL;
1200
if(g_key_file_load_from_file(key_file, question_filename,
1201
G_KEY_FILE_NONE, &glib_error) != TRUE){
1202
/* If a file was removed, we should ignore it, so */
1203
/* only show error message if file actually existed */
1204
if(glib_error->code != G_FILE_ERROR_NOENT){
1205
error(0, 0, "Failed to load question data from file \"%s\": %s",
1206
question_filename, glib_error->message);
1207
}
1208
return;
1209
}
1210
1211
__attribute__((cleanup(cleanup_string)))
1212
char *socket_name = g_key_file_get_string(key_file, "Ask",
1213
"Socket",
1214
&glib_error);
1215
if(socket_name == NULL){
1216
error(0, 0, "Question file \"%s\" did not contain \"Socket\": %s",
1217
question_filename, glib_error->message);
1218
return;
1219
}
1220
1221
if(strlen(socket_name) == 0){
1222
error(0, 0, "Question file \"%s\" had empty \"Socket\" value",
1223
question_filename);
1224
return;
1225
}
1226
1227
const guint64 pid = g_key_file_get_uint64(key_file, "Ask", "PID",
1228
&glib_error);
1229
if(glib_error != NULL){
1230
error(0, 0, "Question file \"%s\" contained bad \"PID\": %s",
1231
question_filename, glib_error->message);
1232
return;
1233
}
1234
1235
if((pid != (guint64)((pid_t)pid))
1236
or (kill((pid_t)pid, 0) != 0)){
1237
error(0, 0, "PID %" PRIuMAX " in question file \"%s\" is bad or"
1238
" does not exist", (uintmax_t)pid, question_filename);
1239
return;
1240
}
1241
1242
guint64 notafter = g_key_file_get_uint64(key_file, "Ask",
1243
"NotAfter", &glib_error);
1244
if(glib_error != NULL){
1245
if(glib_error->code != G_KEY_FILE_ERROR_KEY_NOT_FOUND){
1246
error(0, 0, "Question file \"%s\" contained bad \"NotAfter\":"
1247
" %s", question_filename, glib_error->message);
1248
}
1249
notafter = 0;
1250
}
1251
if(notafter != 0){
1252
if(queue->next_run == 0 or (queue->next_run > notafter)){
1253
queue->next_run = notafter;
1254
}
1255
if(*current_time >= notafter){
1256
return;
1257
}
1258
}
1259
1260
const task_context connect_question_socket_task = {
1261
.func=connect_question_socket,
1262
.question_filename=strdup(question_filename),
1263
.epoll_fd=epoll_fd,
1264
.password=password,
1265
.filename=strdup(socket_name),
1266
.cancelled_filenames=task.cancelled_filenames,
1267
.mandos_client_exited=mandos_client_exited,
1268
.password_is_read=password_is_read,
1269
.current_time=current_time,
1270
};
1271
if(connect_question_socket_task.question_filename == NULL
1272
or connect_question_socket_task.filename == NULL
1273
or not add_to_queue(queue, connect_question_socket_task)){
1274
error(0, errno, "Failed to add connect_question_socket for socket"
1275
" %s (from \"%s\") to queue", socket_name,
1276
question_filename);
1277
cleanup_task(&connect_question_socket_task);
1278
return;
1279
}
1280
/* Force the added task (connect_question_socket) to run
1281
immediately */
1282
queue->next_run = 1;
1283
1284
if(notafter > 0){
1285
char *const dup_filename = strdup(question_filename);
1286
const task_context cancel_old_question_task = {
1287
.func=cancel_old_question,
1288
.question_filename=dup_filename,
1289
.notafter=notafter,
1290
.filename=dup_filename,
1291
.cancelled_filenames=cancelled_filenames,
1292
.current_time=current_time,
1293
};
1294
if(cancel_old_question_task.question_filename == NULL
1295
or not add_to_queue(queue, cancel_old_question_task)){
1296
error(0, errno, "Failed to add cancel_old_question for file "
1297
"\"%s\" to queue", question_filename);
1298
cleanup_task(&cancel_old_question_task);
1299
return;
1300
}
1301
}
1302
}
1303
1304
__attribute__((nonnull))
1305
void cancel_old_question(const task_context task,
1306
task_queue *const queue){
1307
char *const question_filename = task.question_filename;
1308
string_set *const cancelled_filenames = task.cancelled_filenames;
1309
const mono_microsecs notafter = task.notafter;
1310
const mono_microsecs *const current_time = task.current_time;
1311
1312
if(*current_time >= notafter){
1313
if(not string_set_add(cancelled_filenames, question_filename)){
1314
error(0, errno, "Failed to cancel question for file %s",
1315
question_filename);
1316
}
1317
cleanup_task(&task);
1318
return;
1319
}
1320
1321
if(not add_to_queue(queue, task)){
1322
error(0, errno, "Failed to add cancel_old_question for file "
1323
"%s to queue", question_filename);
1324
cleanup_task(&task);
1325
return;
1326
}
1327
1328
if((queue->next_run == 0) or (queue->next_run > notafter)){
1329
queue->next_run = notafter;
1330
}
1331
}
1332
1333
__attribute__((nonnull))
1334
void connect_question_socket(const task_context task,
1335
task_queue *const queue){
1336
char *const question_filename = task.question_filename;
1337
char *const filename = task.filename;
1338
const int epoll_fd = task.epoll_fd;
1339
buffer *const password = task.password;
1340
string_set *const cancelled_filenames = task.cancelled_filenames;
1341
bool *const mandos_client_exited = task.mandos_client_exited;
1342
bool *const password_is_read = task.password_is_read;
1343
const mono_microsecs *const current_time = task.current_time;
1344
1345
struct sockaddr_un sock_name = { .sun_family=AF_LOCAL };
1346
1347
if(sizeof(sock_name.sun_path) <= strlen(filename)){
1348
error(0, 0, "Socket filename is larger than"
1349
" sizeof(sockaddr_un.sun_path); %" PRIuMAX ": \"%s\"",
1350
(uintmax_t)sizeof(sock_name.sun_path), filename);
1351
if(not string_set_add(cancelled_filenames, question_filename)){
1352
error(0, errno, "Failed to cancel question for file %s",
1353
question_filename);
1354
}
1355
cleanup_task(&task);
1356
return;
1357
}
1358
1359
const int fd = socket(PF_LOCAL, SOCK_DGRAM
1360
| SOCK_NONBLOCK | SOCK_CLOEXEC, 0);
1361
if(fd < 0){
1362
error(0, errno,
1363
"Failed to create socket(PF_LOCAL, SOCK_DGRAM, 0)");
1364
if(not add_to_queue(queue, task)){
1365
error(0, errno, "Failed to add connect_question_socket for file"
1366
" \"%s\" and socket \"%s\" to queue", question_filename,
1367
filename);
1368
cleanup_task(&task);
1369
} else {
1370
/* Force the added task (connect_question_socket) to run
1371
immediately */
1372
queue->next_run = 1;
1373
}
1374
return;
1375
}
1376
1377
strncpy(sock_name.sun_path, filename, sizeof(sock_name.sun_path));
1378
if(connect(fd, (struct sockaddr *)&sock_name,
1379
(socklen_t)SUN_LEN(&sock_name)) != 0){
1380
error(0, errno, "Failed to connect socket to \"%s\"", filename);
1381
if(not add_to_queue(queue, task)){
1382
error(0, errno, "Failed to add connect_question_socket for file"
1383
" \"%s\" and socket \"%s\" to queue", question_filename,
1384
filename);
1385
cleanup_task(&task);
1386
} else {
1387
/* Force the added task (connect_question_socket) to run again,
1388
at most one second from now */
1389
if((queue->next_run == 0)
1390
or (queue->next_run > (*current_time + 1000000))){
1391
queue->next_run = *current_time + 1000000;
1392
}
1393
}
1394
return;
1395
}
1396
1397
/* Not necessary, but we can try, and merely warn on failure */
1398
if(shutdown(fd, SHUT_RD) != 0){
1399
error(0, errno, "Failed to shutdown reading from socket \"%s\"",
1400
filename);
1401
}
1402
1403
/* Add the fd to the epoll set */
1404
if(epoll_ctl(epoll_fd, EPOLL_CTL_ADD, fd,
1405
&(struct epoll_event){ .events=EPOLLOUT })
1406
!= 0){
1407
error(0, errno, "Failed to add inotify file descriptor %d for"
1408
" socket %s to epoll set", fd, filename);
1409
if(not add_to_queue(queue, task)){
1410
error(0, errno, "Failed to add connect_question_socket for file"
1411
" \"%s\" and socket \"%s\" to queue", question_filename,
1412
filename);
1413
cleanup_task(&task);
1414
} else {
1415
/* Force the added task (connect_question_socket) to run again,
1416
at most one second from now */
1417
if((queue->next_run == 0)
1418
or (queue->next_run > (*current_time + 1000000))){
1419
queue->next_run = *current_time + 1000000;
1420
}
1421
}
1422
return;
1423
}
1424
1425
/* add task send_password_to_socket to queue */
1426
const task_context send_password_to_socket_task = {
1427
.func=send_password_to_socket,
1428
.question_filename=question_filename,
1429
.filename=filename,
1430
.epoll_fd=epoll_fd,
1431
.fd=fd,
1432
.password=password,
1433
.cancelled_filenames=cancelled_filenames,
1434
.mandos_client_exited=mandos_client_exited,
1435
.password_is_read=password_is_read,
1436
.current_time=current_time,
1437
};
1438
1439
if(not add_to_queue(queue, send_password_to_socket_task)){
1440
error(0, errno, "Failed to add send_password_to_socket for"
1441
" file \"%s\" and socket \"%s\" to queue",
1442
question_filename, filename);
1443
cleanup_task(&send_password_to_socket_task);
1444
}
1445
}
1446
1447
__attribute__((nonnull))
1448
void send_password_to_socket(const task_context task,
1449
task_queue *const queue){
1450
char *const question_filename=task.question_filename;
1451
char *const filename=task.filename;
1452
const int epoll_fd=task.epoll_fd;
1453
const int fd=task.fd;
1454
buffer *const password=task.password;
1455
string_set *const cancelled_filenames=task.cancelled_filenames;
1456
bool *const mandos_client_exited = task.mandos_client_exited;
1457
bool *const password_is_read = task.password_is_read;
1458
const mono_microsecs *const current_time = task.current_time;
1459
1460
if(*mandos_client_exited and *password_is_read){
1461
1462
const size_t send_buffer_length = password->length + 2;
1463
char *send_buffer = malloc(send_buffer_length);
1464
if(send_buffer == NULL){
1465
error(0, errno, "Failed to allocate send_buffer");
1466
} else {
1467
if(mlock(send_buffer, send_buffer_length) != 0){
1468
/* Warn but do not treat as fatal error */
1469
if(errno != EPERM and errno != ENOMEM){
1470
error(0, errno, "Failed to lock memory for password"
1471
" buffer");
1472
}
1473
}
1474
/* “[…] send a single datagram to the socket consisting of the
1475
password string either prefixed with "+" or with "-"
1476
depending on whether the password entry was successful or
1477
not. You may but don't have to include a final NUL byte in
1478
your message.
1479
1480
— <https://www.freedesktop.org/wiki/Software/systemd/
1481
PasswordAgents/> (Wed 08 Oct 2014 02:14:28 AM UTC)
1482
*/
1483
send_buffer[0] = '+'; /* Prefix with "+" */
1484
/* Always add an extra NUL */
1485
send_buffer[password->length + 1] = '\0';
1486
if(password->length > 0){
1487
memcpy(send_buffer + 1, password->data, password->length);
1488
}
1489
errno = 0;
1490
ssize_t ssret = send(fd, send_buffer, send_buffer_length,
1491
MSG_NOSIGNAL);
1492
const error_t saved_errno = errno;
1493
#if defined(__GLIBC_PREREQ) and __GLIBC_PREREQ(2, 25)
1494
explicit_bzero(send_buffer, send_buffer_length);
1495
#else
1496
memset(send_buffer, '\0', send_buffer_length);
1497
#endif
1498
if(munlock(send_buffer, send_buffer_length) != 0){
1499
error(0, errno, "Failed to unlock memory of send buffer");
1500
}
1501
free(send_buffer);
1502
if(ssret < 0 or ssret < (ssize_t)send_buffer_length){
1503
switch(saved_errno){
1504
case EINTR:
1505
case ENOBUFS:
1506
case ENOMEM:
1507
case EADDRINUSE:
1508
case ECONNREFUSED:
1509
case ECONNRESET:
1510
case ENOENT:
1511
case ETOOMANYREFS:
1512
case EAGAIN:
1513
/* Retry, below */
1514
break;
1515
case EMSGSIZE:
1516
error(0, 0, "Password of size %" PRIuMAX " is too big",
1517
(uintmax_t)password->length);
1518
#if __GNUC__ < 7
1519
/* FALLTHROUGH */
1520
#else
1521
__attribute__((fallthrough));
1522
#endif
1523
case 0:
1524
if(ssret >= 0 and ssret < (ssize_t)send_buffer_length){
1525
error(0, 0, "Password only partially sent to socket");
1526
}
1527
#if __GNUC__ < 7
1528
/* FALLTHROUGH */
1529
#else
1530
__attribute__((fallthrough));
1531
#endif
1532
default:
1533
error(0, saved_errno, "Failed to send() to socket %s",
1534
filename);
1535
if(not string_set_add(cancelled_filenames,
1536
question_filename)){
1537
error(0, errno, "Failed to cancel question for file %s",
1538
question_filename);
1539
}
1540
cleanup_task(&task);
1541
return;
1542
}
1543
} else {
1544
/* Success */
1545
cleanup_task(&task);
1546
return;
1547
}
1548
}
1549
}
1550
1551
/* We failed or are not ready yet; retry later */
1552
1553
if(not add_to_queue(queue, task)){
1554
error(0, errno, "Failed to add send_password_to_socket for"
1555
" file %s and socket %s to queue", question_filename,
1556
filename);
1557
cleanup_task(&task);
1558
}
1559
1560
/* Add the fd to the epoll set */
1561
if(epoll_ctl(epoll_fd, EPOLL_CTL_ADD, fd,
1562
&(struct epoll_event){ .events=EPOLLOUT })
1563
!= 0){
1564
error(0, errno, "Failed to add socket file descriptor %d for"
1565
" socket %s to epoll set", fd, filename);
1566
/* Force the added task (send_password_to_socket) to run again, at
1567
most one second from now */
1568
if((queue->next_run == 0)
1569
or (queue->next_run > (*current_time + 1000000))){
1570
queue->next_run = *current_time + 1000000;
1571
}
1572
}
1573
}
1574
1575
__attribute__((warn_unused_result))
1576
bool add_existing_questions(task_queue *const queue,
1577
const int epoll_fd,
1578
buffer *const password,
1579
string_set *cancelled_filenames,
1580
const mono_microsecs *const current_time,
1581
bool *const mandos_client_exited,
1582
bool *const password_is_read,
1583
const char *const dirname){
1584
__attribute__((cleanup(cleanup_string)))
1585
char *dir_pattern = NULL;
1586
const int ret = asprintf(&dir_pattern, "%s/ask.*", dirname);
1587
if(ret < 0 or dir_pattern == NULL){
1588
error(0, errno, "Could not create glob pattern for directory %s",
1589
dirname);
1590
return false;
1591
}
1592
__attribute__((cleanup(globfree)))
1593
glob_t question_filenames = {};
1594
switch(glob(dir_pattern, GLOB_ERR | GLOB_NOSORT | GLOB_MARK,
1595
NULL, &question_filenames)){
1596
case GLOB_ABORTED:
1597
default:
1598
error(0, errno, "Failed to open directory %s", dirname);
1599
return false;
1600
case GLOB_NOMATCH:
1601
error(0, errno, "There are no question files in %s", dirname);
1602
return false;
1603
case GLOB_NOSPACE:
1604
error(0, errno, "Could not allocate memory for question file"
1605
" names in %s", dirname);
1606
#if __GNUC__ < 7
1607
/* FALLTHROUGH */
1608
#else
1609
__attribute__((fallthrough));
1610
#endif
1611
case 0:
1612
for(size_t i = 0; i < question_filenames.gl_pathc; i++){
1613
char *const question_filename = strdup(question_filenames
1614
.gl_pathv[i]);
1615
const task_context task = {
1616
.func=open_and_parse_question,
1617
.epoll_fd=epoll_fd,
1618
.question_filename=question_filename,
1619
.filename=question_filename,
1620
.password=password,
1621
.cancelled_filenames=cancelled_filenames,
1622
.current_time=current_time,
1623
.mandos_client_exited=mandos_client_exited,
1624
.password_is_read=password_is_read,
1625
};
1626
1627
if(question_filename == NULL
1628
or not add_to_queue(queue, task)){
1629
error(0, errno, "Failed to add open_and_parse_question for"
1630
" file %s to queue",
1631
question_filenames.gl_pathv[i]);
1632
free(question_filename);
1633
} else {
1634
queue->next_run = 1;
1635
}
1636
}
1637
return true;
1638
}
1639
}
1640
1641
__attribute__((nonnull, warn_unused_result))
1642
bool wait_for_event(const int epoll_fd,
1643
const mono_microsecs queue_next_run,
1644
const mono_microsecs current_time){
1645
__attribute__((const))
1646
int milliseconds_to_wait(const mono_microsecs currtime,
1647
const mono_microsecs nextrun){
1648
if(currtime >= nextrun){
1649
return 0;
1650
}
1651
const uintmax_t wait_time_ms = (nextrun - currtime) / 1000;
1652
if(wait_time_ms > (uintmax_t)INT_MAX){
1653
return INT_MAX;
1654
}
1655
return (int)wait_time_ms;
1656
}
1657
1658
const int wait_time_ms = milliseconds_to_wait(current_time,
1659
queue_next_run);
1660
1661
/* Prepare unblocking of SIGCHLD during epoll_pwait */
1662
sigset_t temporary_unblocked_sigmask;
1663
/* Get current signal mask */
1664
if(pthread_sigmask(-1, NULL, &temporary_unblocked_sigmask) != 0){
1665
return false;
1666
}
1667
/* Remove SIGCHLD from the signal mask */
1668
if(sigdelset(&temporary_unblocked_sigmask, SIGCHLD) != 0){
1669
return false;
1670
}
1671
struct epoll_event events[8]; /* Ignored */
1672
int ret = epoll_pwait(epoll_fd, events,
1673
sizeof(events) / sizeof(struct epoll_event),
1674
queue_next_run == 0 ? -1 : (int)wait_time_ms,
1675
&temporary_unblocked_sigmask);
1676
if(ret < 0 and errno != EINTR){
1677
error(0, errno, "Failed epoll_pwait(epfd=%d, ..., timeout=%d,"
1678
" ...", epoll_fd,
1679
queue_next_run == 0 ? -1 : (int)wait_time_ms);
1680
return false;
1681
}
1682
return clear_all_fds_from_epoll_set(epoll_fd);
1683
}
1684
1685
bool clear_all_fds_from_epoll_set(const int epoll_fd){
1686
/* Create a new empty epoll set */
1687
__attribute__((cleanup(cleanup_close)))
1688
const int new_epoll_fd = epoll_create1(EPOLL_CLOEXEC);
1689
if(new_epoll_fd < 0){
1690
return false;
1691
}
1692
/* dup3() the new epoll set fd over the old one, replacing it */
1693
if(dup3(new_epoll_fd, epoll_fd, O_CLOEXEC) < 0){
1694
return false;
1695
}
1696
return true;
1697
}
1698
1699
__attribute__((nonnull, warn_unused_result))
1700
bool run_queue(task_queue **const queue,
1701
string_set *const cancelled_filenames,
1702
bool *const quit_now){
1703
1704
task_queue *new_queue = create_queue();
1705
if(new_queue == NULL){
1706
return false;
1707
}
1708
1709
__attribute__((cleanup(string_set_clear)))
1710
string_set old_cancelled_filenames = {};
1711
string_set_swap(cancelled_filenames, &old_cancelled_filenames);
1712
1713
/* Declare i outside the for loop, since we might need i after the
1714
loop in case we aborted in the middle */
1715
size_t i;
1716
for(i=0; i < (*queue)->length and not *quit_now; i++){
1717
task_context *const task = &((*queue)->tasks[i]);
1718
const char *const question_filename = task->question_filename;
1719
/* Skip any task referencing a cancelled question filename */
1720
if(question_filename != NULL
1721
and string_set_contains(old_cancelled_filenames,
1722
question_filename)){
1723
cleanup_task(task);
1724
continue;
1725
}
1726
task->func(*task, new_queue);
1727
}
1728
1729
if(*quit_now){
1730
/* we might be in the middle of the queue, so clean up any
1731
remaining tasks in the current queue */
1732
for(; i < (*queue)->length; i++){
1733
cleanup_task(&((*queue)->tasks[i]));
1734
}
1735
free_queue(*queue);
1736
*queue = new_queue;
1737
new_queue = NULL;
1738
return false;
1739
}
1740
free_queue(*queue);
1741
*queue = new_queue;
1742
new_queue = NULL;
1743
1744
return true;
1745
}
1746
1747
/* End of regular code section */
1748
1749
/* Start of tests section; here are the tests for the above code */
1750
1751
/* This "fixture" data structure is used by the test setup and
1752
teardown functions */
1753
typedef struct {
1754
struct sigaction orig_sigaction;
1755
sigset_t orig_sigmask;
1756
} test_fixture;
1757
1758
static void test_setup(test_fixture *fixture,
1759
__attribute__((unused))
1760
gconstpointer user_data){
1761
g_assert_true(setup_signal_handler(&fixture->orig_sigaction));
1762
g_assert_true(block_sigchld(&fixture->orig_sigmask));
1763
}
1764
1765
static void test_teardown(test_fixture *fixture,
1766
__attribute__((unused))
1767
gconstpointer user_data){
1768
g_assert_true(restore_signal_handler(&fixture->orig_sigaction));
1769
g_assert_true(restore_sigmask(&fixture->orig_sigmask));
1770
}
1771
1772
/* Utility function used by tests to search queue for matching task */
1773
__attribute__((pure, nonnull, warn_unused_result))
1774
static task_context *find_matching_task(const task_queue *const queue,
1775
const task_context task){
1776
/* The argument "task" structure is a pattern to match; 0 in any
1777
member means any value matches, otherwise the value must match.
1778
The filename strings are compared by strcmp(), not by pointer. */
1779
for(size_t i = 0; i < queue->length; i++){
1780
task_context *const current_task = queue->tasks+i;
1781
/* Check all members of task_context, if set to a non-zero value.
1782
If a member does not match, continue to next task in queue */
1783
1784
/* task_func *const func */
1785
if(task.func != NULL and current_task->func != task.func){
1786
continue;
1787
}
1788
/* char *const question_filename; */
1789
if(task.question_filename != NULL
1790
and (current_task->question_filename == NULL
1791
or strcmp(current_task->question_filename,
1792
task.question_filename) != 0)){
1793
continue;
1794
}
1795
/* const pid_t pid; */
1796
if(task.pid != 0 and current_task->pid != task.pid){
1797
continue;
1798
}
1799
/* const int epoll_fd; */
1800
if(task.epoll_fd != 0
1801
and current_task->epoll_fd != task.epoll_fd){
1802
continue;
1803
}
1804
/* bool *const quit_now; */
1805
if(task.quit_now != NULL
1806
and current_task->quit_now != task.quit_now){
1807
continue;
1808
}
1809
/* const int fd; */
1810
if(task.fd != 0 and current_task->fd != task.fd){
1811
continue;
1812
}
1813
/* bool *const mandos_client_exited; */
1814
if(task.mandos_client_exited != NULL
1815
and current_task->mandos_client_exited
1816
!= task.mandos_client_exited){
1817
continue;
1818
}
1819
/* buffer *const password; */
1820
if(task.password != NULL
1821
and current_task->password != task.password){
1822
continue;
1823
}
1824
/* bool *const password_is_read; */
1825
if(task.password_is_read != NULL
1826
and current_task->password_is_read != task.password_is_read){
1827
continue;
1828
}
1829
/* char *filename; */
1830
if(task.filename != NULL
1831
and (current_task->filename == NULL
1832
or strcmp(current_task->filename, task.filename) != 0)){
1833
continue;
1834
}
1835
/* string_set *const cancelled_filenames; */
1836
if(task.cancelled_filenames != NULL
1837
and current_task->cancelled_filenames
1838
!= task.cancelled_filenames){
1839
continue;
1840
}
1841
/* const mono_microsecs notafter; */
1842
if(task.notafter != 0
1843
and current_task->notafter != task.notafter){
1844
continue;
1845
}
1846
/* const mono_microsecs *const current_time; */
1847
if(task.current_time != NULL
1848
and current_task->current_time != task.current_time){
1849
continue;
1850
}
1851
/* Current task matches all members; return it */
1852
return current_task;
1853
}
1854
/* No task in queue matches passed pattern task */
1855
return NULL;
1856
}
1857
1858
static void test_create_queue(__attribute__((unused))
1859
test_fixture *fixture,
1860
__attribute__((unused))
1861
gconstpointer user_data){
1862
__attribute__((cleanup(cleanup_queue)))
1863
task_queue *const queue = create_queue();
1864
g_assert_nonnull(queue);
1865
g_assert_null(queue->tasks);
1866
g_assert_true(queue->length == 0);
1867
g_assert_true(queue->next_run == 0);
1868
}
1869
1870
static task_func dummy_func;
1871
1872
static void test_add_to_queue(__attribute__((unused))
1873
test_fixture *fixture,
1874
__attribute__((unused))
1875
gconstpointer user_data){
1876
__attribute__((cleanup(cleanup_queue)))
1877
task_queue *queue = create_queue();
1878
g_assert_nonnull(queue);
1879
1880
g_assert_true(add_to_queue(queue,
1881
(task_context){ .func=dummy_func }));
1882
g_assert_true(queue->length == 1);
1883
g_assert_nonnull(queue->tasks);
1884
g_assert_true(queue->tasks[0].func == dummy_func);
1885
}
1886
1887
static void dummy_func(__attribute__((unused))
1888
const task_context task,
1889
__attribute__((unused))
1890
task_queue *const queue){
1891
}
1892
1893
static void test_queue_has_question_empty(__attribute__((unused))
1894
test_fixture *fixture,
1895
__attribute__((unused))
1896
gconstpointer user_data){
1897
__attribute__((cleanup(cleanup_queue)))
1898
task_queue *queue = create_queue();
1899
g_assert_nonnull(queue);
1900
g_assert_false(queue_has_question(queue));
1901
}
1902
1903
static void test_queue_has_question_false(__attribute__((unused))
1904
test_fixture *fixture,
1905
__attribute__((unused))
1906
gconstpointer user_data){
1907
__attribute__((cleanup(cleanup_queue)))
1908
task_queue *queue = create_queue();
1909
g_assert_nonnull(queue);
1910
g_assert_true(add_to_queue(queue,
1911
(task_context){ .func=dummy_func }));
1912
g_assert_false(queue_has_question(queue));
1913
}
1914
1915
static void test_queue_has_question_true(__attribute__((unused))
1916
test_fixture *fixture,
1917
__attribute__((unused))
1918
gconstpointer user_data){
1919
__attribute__((cleanup(cleanup_queue)))
1920
task_queue *queue = create_queue();
1921
g_assert_nonnull(queue);
1922
char *const question_filename
1923
= strdup("/nonexistent/question_filename");
1924
g_assert_nonnull(question_filename);
1925
task_context task = {
1926
.func=dummy_func,
1927
.question_filename=question_filename,
1928
};
1929
g_assert_true(add_to_queue(queue, task));
1930
g_assert_true(queue_has_question(queue));
1931
}
1932
1933
static void test_queue_has_question_false2(__attribute__((unused))
1934
test_fixture *fixture,
1935
__attribute__((unused))
1936
gconstpointer user_data){
1937
__attribute__((cleanup(cleanup_queue)))
1938
task_queue *queue = create_queue();
1939
g_assert_nonnull(queue);
1940
task_context task = { .func=dummy_func };
1941
g_assert_true(add_to_queue(queue, task));
1942
g_assert_true(add_to_queue(queue, task));
1943
g_assert_cmpint((int)queue->length, ==, 2);
1944
g_assert_false(queue_has_question(queue));
1945
}
1946
1947
static void test_queue_has_question_true2(__attribute__((unused))
1948
test_fixture *fixture,
1949
__attribute__((unused))
1950
gconstpointer user_data){
1951
__attribute__((cleanup(cleanup_queue)))
1952
task_queue *queue = create_queue();
1953
g_assert_nonnull(queue);
1954
task_context task1 = { .func=dummy_func };
1955
g_assert_true(add_to_queue(queue, task1));
1956
char *const question_filename
1957
= strdup("/nonexistent/question_filename");
1958
g_assert_nonnull(question_filename);
1959
task_context task2 = {
1960
.func=dummy_func,
1961
.question_filename=question_filename,
1962
};
1963
g_assert_true(add_to_queue(queue, task2));
1964
g_assert_cmpint((int)queue->length, ==, 2);
1965
g_assert_true(queue_has_question(queue));
1966
}
1967
1968
static void test_cleanup_buffer(__attribute__((unused))
1969
test_fixture *fixture,
1970
__attribute__((unused))
1971
gconstpointer user_data){
1972
buffer buf = {};
1973
1974
const size_t buffersize = 10;
1975
1976
buf.data = malloc(buffersize);
1977
g_assert_nonnull(buf.data);
1978
if(mlock(buf.data, buffersize) != 0){
1979
g_assert_true(errno == EPERM or errno == ENOMEM);
1980
}
1981
1982
cleanup_buffer(&buf);
1983
g_assert_null(buf.data);
1984
}
1985
1986
static
1987
void test_string_set_new_set_contains_nothing(__attribute__((unused))
1988
test_fixture *fixture,
1989
__attribute__((unused))
1990
gconstpointer
1991
user_data){
1992
__attribute__((cleanup(string_set_clear)))
1993
string_set set = {};
1994
g_assert_false(string_set_contains(set, "")); /* Empty string */
1995
g_assert_false(string_set_contains(set, "test_string"));
1996
}
1997
1998
static void
1999
test_string_set_with_added_string_contains_it(__attribute__((unused))
2000
test_fixture *fixture,
2001
__attribute__((unused))
2002
gconstpointer
2003
user_data){
2004
__attribute__((cleanup(string_set_clear)))
2005
string_set set = {};
2006
g_assert_true(string_set_add(&set, "test_string"));
2007
g_assert_true(string_set_contains(set, "test_string"));
2008
}
2009
2010
static void
2011
test_string_set_cleared_does_not_contain_str(__attribute__((unused))
2012
test_fixture *fixture,
2013
__attribute__((unused))
2014
gconstpointer user_data){
2015
__attribute__((cleanup(string_set_clear)))
2016
string_set set = {};
2017
g_assert_true(string_set_add(&set, "test_string"));
2018
string_set_clear(&set);
2019
g_assert_false(string_set_contains(set, "test_string"));
2020
}
2021
2022
static
2023
void test_string_set_swap_one_with_empty(__attribute__((unused))
2024
test_fixture *fixture,
2025
__attribute__((unused))
2026
gconstpointer user_data){
2027
__attribute__((cleanup(string_set_clear)))
2028
string_set set1 = {};
2029
__attribute__((cleanup(string_set_clear)))
2030
string_set set2 = {};
2031
g_assert_true(string_set_add(&set1, "test_string1"));
2032
string_set_swap(&set1, &set2);
2033
g_assert_false(string_set_contains(set1, "test_string1"));
2034
g_assert_true(string_set_contains(set2, "test_string1"));
2035
}
2036
2037
static
2038
void test_string_set_swap_empty_with_one(__attribute__((unused))
2039
test_fixture *fixture,
2040
__attribute__((unused))
2041
gconstpointer user_data){
2042
__attribute__((cleanup(string_set_clear)))
2043
string_set set1 = {};
2044
__attribute__((cleanup(string_set_clear)))
2045
string_set set2 = {};
2046
g_assert_true(string_set_add(&set2, "test_string2"));
2047
string_set_swap(&set1, &set2);
2048
g_assert_true(string_set_contains(set1, "test_string2"));
2049
g_assert_false(string_set_contains(set2, "test_string2"));
2050
}
2051
2052
static void test_string_set_swap_one_with_one(__attribute__((unused))
2053
test_fixture *fixture,
2054
__attribute__((unused))
2055
gconstpointer
2056
user_data){
2057
__attribute__((cleanup(string_set_clear)))
2058
string_set set1 = {};
2059
__attribute__((cleanup(string_set_clear)))
2060
string_set set2 = {};
2061
g_assert_true(string_set_add(&set1, "test_string1"));
2062
g_assert_true(string_set_add(&set2, "test_string2"));
2063
string_set_swap(&set1, &set2);
2064
g_assert_false(string_set_contains(set1, "test_string1"));
2065
g_assert_true(string_set_contains(set1, "test_string2"));
2066
g_assert_false(string_set_contains(set2, "test_string2"));
2067
g_assert_true(string_set_contains(set2, "test_string1"));
2068
}
2069
2070
static bool fd_has_cloexec_and_nonblock(const int);
2071
2072
static bool epoll_set_contains(int, int, uint32_t);
2073
2074
static void test_start_mandos_client(test_fixture *fixture,
2075
__attribute__((unused))
2076
gconstpointer user_data){
2077
2078
bool mandos_client_exited = false;
2079
bool quit_now = false;
2080
__attribute__((cleanup(cleanup_close)))
2081
const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);
2082
g_assert_cmpint(epoll_fd, >=, 0);
2083
__attribute__((cleanup(cleanup_queue)))
2084
task_queue *queue = create_queue();
2085
g_assert_nonnull(queue);
2086
buffer password = {};
2087
bool password_is_read = false;
2088
const char helper_directory[] = "/nonexistent";
2089
const char *const argv[] = { "/bin/true", NULL };
2090
2091
g_assert_true(start_mandos_client(queue, epoll_fd,
2092
&mandos_client_exited, &quit_now,
2093
&password, &password_is_read,
2094
&fixture->orig_sigaction,
2095
fixture->orig_sigmask,
2096
helper_directory, 0, 0, argv));
2097
2098
g_assert_cmpuint((unsigned int)queue->length, >=, 2);
2099
2100
const task_context *const added_wait_task
2101
= find_matching_task(queue, (task_context){
2102
.func=wait_for_mandos_client_exit,
2103
.mandos_client_exited=&mandos_client_exited,
2104
.quit_now=&quit_now,
2105
});
2106
g_assert_nonnull(added_wait_task);
2107
g_assert_cmpint(added_wait_task->pid, >, 0);
2108
g_assert_cmpint(kill(added_wait_task->pid, SIGKILL), ==, 0);
2109
waitpid(added_wait_task->pid, NULL, 0);
2110
2111
const task_context *const added_read_task
2112
= find_matching_task(queue, (task_context){
2113
.func=read_mandos_client_output,
2114
.epoll_fd=epoll_fd,
2115
.password=&password,
2116
.password_is_read=&password_is_read,
2117
.quit_now=&quit_now,
2118
});
2119
g_assert_nonnull(added_read_task);
2120
g_assert_cmpint(added_read_task->fd, >, 2);
2121
g_assert_true(fd_has_cloexec_and_nonblock(added_read_task->fd));
2122
g_assert_true(epoll_set_contains(epoll_fd, added_read_task->fd,
2123
EPOLLIN | EPOLLRDHUP));
2124
}
2125
2126
static bool fd_has_cloexec_and_nonblock(const int fd){
2127
const int socket_fd_flags = fcntl(fd, F_GETFD, 0);
2128
const int socket_file_flags = fcntl(fd, F_GETFL, 0);
2129
return ((socket_fd_flags >= 0)
2130
and (socket_fd_flags & FD_CLOEXEC)
2131
and (socket_file_flags >= 0)
2132
and (socket_file_flags & O_NONBLOCK));
2133
}
2134
2135
__attribute__((const))
2136
bool is_privileged(void){
2137
uid_t user = getuid() + 1;
2138
if(user == 0){ /* Overflow check */
2139
user++;
2140
}
2141
gid_t group = getuid() + 1;
2142
if(group == 0){ /* Overflow check */
2143
group++;
2144
}
2145
const pid_t pid = fork();
2146
if(pid == 0){ /* Child */
2147
if(setresgid((uid_t)-1, group, group) == -1){
2148
if(errno != EPERM){
2149
error(EXIT_FAILURE, errno, "Failed to setresgid(-1, %" PRIuMAX
2150
", %" PRIuMAX")", (uintmax_t)group, (uintmax_t)group);
2151
}
2152
exit(EXIT_FAILURE);
2153
}
2154
if(setresuid((uid_t)-1, user, user) == -1){
2155
if(errno != EPERM){
2156
error(EXIT_FAILURE, errno, "Failed to setresuid(-1, %" PRIuMAX
2157
", %" PRIuMAX")", (uintmax_t)user, (uintmax_t)user);
2158
}
2159
exit(EXIT_FAILURE);
2160
}
2161
exit(EXIT_SUCCESS);
2162
}
2163
int status;
2164
waitpid(pid, &status, 0);
2165
if(WIFEXITED(status) and (WEXITSTATUS(status) == EXIT_SUCCESS)){
2166
return true;
2167
}
2168
return false;
2169
}
2170
2171
static bool epoll_set_contains(int epoll_fd, int fd, uint32_t events){
2172
/* Only scan for events in this eventmask */
2173
const uint32_t eventmask = EPOLLIN | EPOLLOUT | EPOLLRDHUP;
2174
__attribute__((cleanup(cleanup_string)))
2175
char *fdinfo_name = NULL;
2176
int ret = asprintf(&fdinfo_name, "/proc/self/fdinfo/%d", epoll_fd);
2177
g_assert_cmpint(ret, >, 0);
2178
g_assert_nonnull(fdinfo_name);
2179
2180
FILE *fdinfo = fopen(fdinfo_name, "r");
2181
g_assert_nonnull(fdinfo);
2182
uint32_t reported_events;
2183
buffer line = {};
2184
int found_fd = -1;
2185
2186
do {
2187
if(getline(&line.data, &line.allocated, fdinfo) < 0){
2188
break;
2189
}
2190
/* See proc(5) for format of /proc/PID/fdinfo/FD for epoll fd's */
2191
if(sscanf(line.data, "tfd: %d events: %" SCNx32 " ",
2192
&found_fd, &reported_events) == 2){
2193
if(found_fd == fd){
2194
break;
2195
}
2196
}
2197
} while(not feof(fdinfo) and not ferror(fdinfo));
2198
g_assert_cmpint(fclose(fdinfo), ==, 0);
2199
free(line.data);
2200
if(found_fd != fd){
2201
return false;
2202
}
2203
2204
if(events == 0){
2205
/* Don't check events if none are given */
2206
return true;
2207
}
2208
return (reported_events & eventmask) == (events & eventmask);
2209
}
2210
2211
static void test_start_mandos_client_execv(test_fixture *fixture,
2212
__attribute__((unused))
2213
gconstpointer user_data){
2214
bool mandos_client_exited = false;
2215
bool quit_now = false;
2216
__attribute__((cleanup(cleanup_close)))
2217
const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);
2218
g_assert_cmpint(epoll_fd, >=, 0);
2219
__attribute__((cleanup(cleanup_queue)))
2220
task_queue *queue = create_queue();
2221
g_assert_nonnull(queue);
2222
__attribute__((cleanup(cleanup_buffer)))
2223
buffer password = {};
2224
const char helper_directory[] = "/nonexistent";
2225
/* Can't execv("/", ...), so this should fail */
2226
const char *const argv[] = { "/", NULL };
2227
2228
{
2229
__attribute__((cleanup(cleanup_close)))
2230
const int devnull_fd = open("/dev/null",
2231
O_WRONLY | O_CLOEXEC | O_NOCTTY);
2232
g_assert_cmpint(devnull_fd, >=, 0);
2233
__attribute__((cleanup(cleanup_close)))
2234
const int real_stderr_fd = dup(STDERR_FILENO);
2235
g_assert_cmpint(real_stderr_fd, >=, 0);
2236
dup2(devnull_fd, STDERR_FILENO);
2237
2238
const bool success = start_mandos_client(queue, epoll_fd,
2239
&mandos_client_exited,
2240
&quit_now,
2241
&password,
2242
(bool[]){false},
2243
&fixture->orig_sigaction,
2244
fixture->orig_sigmask,
2245
helper_directory, 0, 0,
2246
argv);
2247
dup2(real_stderr_fd, STDERR_FILENO);
2248
g_assert_true(success);
2249
}
2250
g_assert_cmpuint((unsigned int)queue->length, ==, 2);
2251
2252
struct timespec starttime, currtime;
2253
g_assert_true(clock_gettime(CLOCK_MONOTONIC, &starttime) == 0);
2254
do {
2255
queue->next_run = 0;
2256
string_set cancelled_filenames = {};
2257
2258
{
2259
__attribute__((cleanup(cleanup_close)))
2260
const int devnull_fd = open("/dev/null",
2261
O_WRONLY | O_CLOEXEC | O_NOCTTY);
2262
g_assert_cmpint(devnull_fd, >=, 0);
2263
__attribute__((cleanup(cleanup_close)))
2264
const int real_stderr_fd = dup(STDERR_FILENO);
2265
g_assert_cmpint(real_stderr_fd, >=, 0);
2266
g_assert_true(wait_for_event(epoll_fd, queue->next_run, 0));
2267
dup2(devnull_fd, STDERR_FILENO);
2268
const bool success = run_queue(&queue, &cancelled_filenames,
2269
&quit_now);
2270
dup2(real_stderr_fd, STDERR_FILENO);
2271
if(not success){
2272
break;
2273
}
2274
}
2275
g_assert_true(clock_gettime(CLOCK_MONOTONIC, &currtime) == 0);
2276
} while(((queue->length) > 0)
2277
and (not quit_now)
2278
and ((currtime.tv_sec - starttime.tv_sec) < 10));
2279
2280
g_assert_true(quit_now);
2281
g_assert_cmpuint((unsigned int)queue->length, ==, 0);
2282
g_assert_true(mandos_client_exited);
2283
}
2284
2285
static void test_start_mandos_client_suid_euid(test_fixture *fixture,
2286
__attribute__((unused))
2287
gconstpointer
2288
user_data){
2289
if(not is_privileged()){
2290
g_test_skip("Not privileged");
2291
return;
2292
}
2293
2294
bool mandos_client_exited = false;
2295
bool quit_now = false;
2296
__attribute__((cleanup(cleanup_close)))
2297
const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);
2298
g_assert_cmpint(epoll_fd, >=, 0);
2299
__attribute__((cleanup(cleanup_queue)))
2300
task_queue *queue = create_queue();
2301
g_assert_nonnull(queue);
2302
__attribute__((cleanup(cleanup_buffer)))
2303
buffer password = {};
2304
bool password_is_read = false;
2305
const char helper_directory[] = "/nonexistent";
2306
const char *const argv[] = { "/usr/bin/id", "--user", NULL };
2307
uid_t user = 1000;
2308
gid_t group = 1001;
2309
2310
const bool success = start_mandos_client(queue, epoll_fd,
2311
&mandos_client_exited,
2312
&quit_now, &password,
2313
&password_is_read,
2314
&fixture->orig_sigaction,
2315
fixture->orig_sigmask,
2316
helper_directory, user,
2317
group, argv);
2318
g_assert_true(success);
2319
g_assert_cmpuint((unsigned int)queue->length, >, 0);
2320
2321
struct timespec starttime, currtime;
2322
g_assert_true(clock_gettime(CLOCK_MONOTONIC, &starttime) == 0);
2323
do {
2324
queue->next_run = 0;
2325
string_set cancelled_filenames = {};
2326
g_assert_true(wait_for_event(epoll_fd, queue->next_run, 0));
2327
g_assert_true(run_queue(&queue, &cancelled_filenames, &quit_now));
2328
g_assert_true(clock_gettime(CLOCK_MONOTONIC, &currtime) == 0);
2329
} while(((queue->length) > 0)
2330
and (not quit_now)
2331
and ((currtime.tv_sec - starttime.tv_sec) < 10));
2332
2333
g_assert_false(quit_now);
2334
g_assert_cmpuint((unsigned int)queue->length, ==, 0);
2335
g_assert_true(mandos_client_exited);
2336
2337
g_assert_true(password_is_read);
2338
g_assert_nonnull(password.data);
2339
2340
uintmax_t id;
2341
g_assert_cmpint(sscanf(password.data, "%" SCNuMAX "\n", &id),
2342
==, 1);
2343
g_assert_true((uid_t)id == id);
2344
2345
g_assert_cmpuint((unsigned int)id, ==, 0);
2346
}
2347
2348
static void test_start_mandos_client_suid_egid(test_fixture *fixture,
2349
__attribute__((unused))
2350
gconstpointer
2351
user_data){
2352
if(not is_privileged()){
2353
g_test_skip("Not privileged");
2354
return;
2355
}
2356
2357
bool mandos_client_exited = false;
2358
bool quit_now = false;
2359
__attribute__((cleanup(cleanup_close)))
2360
const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);
2361
g_assert_cmpint(epoll_fd, >=, 0);
2362
__attribute__((cleanup(cleanup_queue)))
2363
task_queue *queue = create_queue();
2364
g_assert_nonnull(queue);
2365
__attribute__((cleanup(cleanup_buffer)))
2366
buffer password = {};
2367
bool password_is_read = false;
2368
const char helper_directory[] = "/nonexistent";
2369
const char *const argv[] = { "/usr/bin/id", "--group", NULL };
2370
uid_t user = 1000;
2371
gid_t group = 1001;
2372
2373
const bool success = start_mandos_client(queue, epoll_fd,
2374
&mandos_client_exited,
2375
&quit_now, &password,
2376
&password_is_read,
2377
&fixture->orig_sigaction,
2378
fixture->orig_sigmask,
2379
helper_directory, user,
2380
group, argv);
2381
g_assert_true(success);
2382
g_assert_cmpuint((unsigned int)queue->length, >, 0);
2383
2384
struct timespec starttime, currtime;
2385
g_assert_true(clock_gettime(CLOCK_MONOTONIC, &starttime) == 0);
2386
do {
2387
queue->next_run = 0;
2388
string_set cancelled_filenames = {};
2389
g_assert_true(wait_for_event(epoll_fd, queue->next_run, 0));
2390
g_assert_true(run_queue(&queue, &cancelled_filenames, &quit_now));
2391
g_assert_true(clock_gettime(CLOCK_MONOTONIC, &currtime) == 0);
2392
} while(((queue->length) > 0)
2393
and (not quit_now)
2394
and ((currtime.tv_sec - starttime.tv_sec) < 10));
2395
2396
g_assert_false(quit_now);
2397
g_assert_cmpuint((unsigned int)queue->length, ==, 0);
2398
g_assert_true(mandos_client_exited);
2399
2400
g_assert_true(password_is_read);
2401
g_assert_nonnull(password.data);
2402
2403
uintmax_t id;
2404
g_assert_cmpint(sscanf(password.data, "%" SCNuMAX "\n", &id),
2405
==, 1);
2406
g_assert_true((gid_t)id == id);
2407
2408
g_assert_cmpuint((unsigned int)id, ==, 0);
2409
}
2410
2411
static void test_start_mandos_client_suid_ruid(test_fixture *fixture,
2412
__attribute__((unused))
2413
gconstpointer
2414
user_data){
2415
if(not is_privileged()){
2416
g_test_skip("Not privileged");
2417
return;
2418
}
2419
2420
bool mandos_client_exited = false;
2421
bool quit_now = false;
2422
__attribute__((cleanup(cleanup_close)))
2423
const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);
2424
g_assert_cmpint(epoll_fd, >=, 0);
2425
__attribute__((cleanup(cleanup_queue)))
2426
task_queue *queue = create_queue();
2427
g_assert_nonnull(queue);
2428
__attribute__((cleanup(cleanup_buffer)))
2429
buffer password = {};
2430
bool password_is_read = false;
2431
const char helper_directory[] = "/nonexistent";
2432
const char *const argv[] = { "/usr/bin/id", "--user", "--real",
2433
NULL };
2434
uid_t user = 1000;
2435
gid_t group = 1001;
2436
2437
const bool success = start_mandos_client(queue, epoll_fd,
2438
&mandos_client_exited,
2439
&quit_now, &password,
2440
&password_is_read,
2441
&fixture->orig_sigaction,
2442
fixture->orig_sigmask,
2443
helper_directory, user,
2444
group, argv);
2445
g_assert_true(success);
2446
g_assert_cmpuint((unsigned int)queue->length, >, 0);
2447
2448
struct timespec starttime, currtime;
2449
g_assert_true(clock_gettime(CLOCK_MONOTONIC, &starttime) == 0);
2450
do {
2451
queue->next_run = 0;
2452
string_set cancelled_filenames = {};
2453
g_assert_true(wait_for_event(epoll_fd, queue->next_run, 0));
2454
g_assert_true(run_queue(&queue, &cancelled_filenames, &quit_now));
2455
g_assert_true(clock_gettime(CLOCK_MONOTONIC, &currtime) == 0);
2456
} while(((queue->length) > 0)
2457
and (not quit_now)
2458
and ((currtime.tv_sec - starttime.tv_sec) < 10));
2459
2460
g_assert_false(quit_now);
2461
g_assert_cmpuint((unsigned int)queue->length, ==, 0);
2462
g_assert_true(mandos_client_exited);
2463
2464
g_assert_true(password_is_read);
2465
g_assert_nonnull(password.data);
2466
2467
uintmax_t id;
2468
g_assert_cmpint(sscanf(password.data, "%" SCNuMAX "\n", &id),
2469
==, 1);
2470
g_assert_true((uid_t)id == id);
2471
2472
g_assert_cmpuint((unsigned int)id, ==, user);
2473
}
2474
2475
static void test_start_mandos_client_suid_rgid(test_fixture *fixture,
2476
__attribute__((unused))
2477
gconstpointer
2478
user_data){
2479
if(not is_privileged()){
2480
g_test_skip("Not privileged");
2481
return;
2482
}
2483
2484
bool mandos_client_exited = false;
2485
bool quit_now = false;
2486
__attribute__((cleanup(cleanup_close)))
2487
const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);
2488
g_assert_cmpint(epoll_fd, >=, 0);
2489
__attribute__((cleanup(cleanup_queue)))
2490
task_queue *queue = create_queue();
2491
g_assert_nonnull(queue);
2492
__attribute__((cleanup(cleanup_buffer)))
2493
buffer password = {};
2494
bool password_is_read = false;
2495
const char helper_directory[] = "/nonexistent";
2496
const char *const argv[] = { "/usr/bin/id", "--group", "--real",
2497
NULL };
2498
uid_t user = 1000;
2499
gid_t group = 1001;
2500
2501
const bool success = start_mandos_client(queue, epoll_fd,
2502
&mandos_client_exited,
2503
&quit_now, &password,
2504
&password_is_read,
2505
&fixture->orig_sigaction,
2506
fixture->orig_sigmask,
2507
helper_directory, user,
2508
group, argv);
2509
g_assert_true(success);
2510
g_assert_cmpuint((unsigned int)queue->length, >, 0);
2511
2512
struct timespec starttime, currtime;
2513
g_assert_true(clock_gettime(CLOCK_MONOTONIC, &starttime) == 0);
2514
do {
2515
queue->next_run = 0;
2516
string_set cancelled_filenames = {};
2517
g_assert_true(wait_for_event(epoll_fd, queue->next_run, 0));
2518
g_assert_true(run_queue(&queue, &cancelled_filenames, &quit_now));
2519
g_assert_true(clock_gettime(CLOCK_MONOTONIC, &currtime) == 0);
2520
} while(((queue->length) > 0)
2521
and (not quit_now)
2522
and ((currtime.tv_sec - starttime.tv_sec) < 10));
2523
2524
g_assert_false(quit_now);
2525
g_assert_cmpuint((unsigned int)queue->length, ==, 0);
2526
g_assert_true(mandos_client_exited);
2527
2528
g_assert_true(password_is_read);
2529
g_assert_nonnull(password.data);
2530
2531
uintmax_t id;
2532
g_assert_cmpint(sscanf(password.data, "%" SCNuMAX "\n", &id),
2533
==, 1);
2534
g_assert_true((gid_t)id == id);
2535
2536
g_assert_cmpuint((unsigned int)id, ==, group);
2537
}
2538
2539
static void test_start_mandos_client_read(test_fixture *fixture,
2540
__attribute__((unused))
2541
gconstpointer user_data){
2542
bool mandos_client_exited = false;
2543
bool quit_now = false;
2544
__attribute__((cleanup(cleanup_close)))
2545
const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);
2546
g_assert_cmpint(epoll_fd, >=, 0);
2547
__attribute__((cleanup(cleanup_queue)))
2548
task_queue *queue = create_queue();
2549
g_assert_nonnull(queue);
2550
__attribute__((cleanup(cleanup_buffer)))
2551
buffer password = {};
2552
bool password_is_read = false;
2553
const char dummy_test_password[] = "dummy test password";
2554
const char helper_directory[] = "/nonexistent";
2555
const char *const argv[] = { "/bin/echo", "-n", dummy_test_password,
2556
NULL };
2557
2558
const bool success = start_mandos_client(queue, epoll_fd,
2559
&mandos_client_exited,
2560
&quit_now, &password,
2561
&password_is_read,
2562
&fixture->orig_sigaction,
2563
fixture->orig_sigmask,
2564
helper_directory, 0, 0,
2565
argv);
2566
g_assert_true(success);
2567
g_assert_cmpuint((unsigned int)queue->length, >, 0);
2568
2569
struct timespec starttime, currtime;
2570
g_assert_true(clock_gettime(CLOCK_MONOTONIC, &starttime) == 0);
2571
do {
2572
queue->next_run = 0;
2573
string_set cancelled_filenames = {};
2574
g_assert_true(wait_for_event(epoll_fd, queue->next_run, 0));
2575
g_assert_true(run_queue(&queue, &cancelled_filenames, &quit_now));
2576
g_assert_true(clock_gettime(CLOCK_MONOTONIC, &currtime) == 0);
2577
} while(((queue->length) > 0)
2578
and (not quit_now)
2579
and ((currtime.tv_sec - starttime.tv_sec) < 10));
2580
2581
g_assert_false(quit_now);
2582
g_assert_cmpuint((unsigned int)queue->length, ==, 0);
2583
g_assert_true(mandos_client_exited);
2584
2585
g_assert_true(password_is_read);
2586
g_assert_cmpint((int)password.length, ==,
2587
sizeof(dummy_test_password)-1);
2588
g_assert_nonnull(password.data);
2589
g_assert_cmpint(memcmp(dummy_test_password, password.data,
2590
sizeof(dummy_test_password)-1), ==, 0);
2591
}
2592
2593
static
2594
void test_start_mandos_client_helper_directory(test_fixture *fixture,
2595
__attribute__((unused))
2596
gconstpointer
2597
user_data){
2598
bool mandos_client_exited = false;
2599
bool quit_now = false;
2600
__attribute__((cleanup(cleanup_close)))
2601
const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);
2602
g_assert_cmpint(epoll_fd, >=, 0);
2603
__attribute__((cleanup(cleanup_queue)))
2604
task_queue *queue = create_queue();
2605
g_assert_nonnull(queue);
2606
__attribute__((cleanup(cleanup_buffer)))
2607
buffer password = {};
2608
bool password_is_read = false;
2609
const char helper_directory[] = "/nonexistent";
2610
const char *const argv[] = { "/bin/sh", "-c",
2611
"echo -n ${MANDOSPLUGINHELPERDIR}", NULL };
2612
2613
const bool success = start_mandos_client(queue, epoll_fd,
2614
&mandos_client_exited,
2615
&quit_now, &password,
2616
&password_is_read,
2617
&fixture->orig_sigaction,
2618
fixture->orig_sigmask,
2619
helper_directory, 0, 0,
2620
argv);
2621
g_assert_true(success);
2622
g_assert_cmpuint((unsigned int)queue->length, >, 0);
2623
2624
struct timespec starttime, currtime;
2625
g_assert_true(clock_gettime(CLOCK_MONOTONIC, &starttime) == 0);
2626
do {
2627
queue->next_run = 0;
2628
string_set cancelled_filenames = {};
2629
g_assert_true(wait_for_event(epoll_fd, queue->next_run, 0));
2630
g_assert_true(run_queue(&queue, &cancelled_filenames, &quit_now));
2631
g_assert_true(clock_gettime(CLOCK_MONOTONIC, &currtime) == 0);
2632
} while(((queue->length) > 0)
2633
and (not quit_now)
2634
and ((currtime.tv_sec - starttime.tv_sec) < 10));
2635
2636
g_assert_false(quit_now);
2637
g_assert_cmpuint((unsigned int)queue->length, ==, 0);
2638
g_assert_true(mandos_client_exited);
2639
2640
g_assert_true(password_is_read);
2641
g_assert_cmpint((int)password.length, ==,
2642
sizeof(helper_directory)-1);
2643
g_assert_nonnull(password.data);
2644
g_assert_cmpint(memcmp(helper_directory, password.data,
2645
sizeof(helper_directory)-1), ==, 0);
2646
}
2647
2648
__attribute__((nonnull, warn_unused_result))
2649
static bool proc_status_sigblk_to_sigset(const char *const,
2650
sigset_t *const);
2651
2652
static void test_start_mandos_client_sigmask(test_fixture *fixture,
2653
__attribute__((unused))
2654
gconstpointer user_data){
2655
bool mandos_client_exited = false;
2656
bool quit_now = false;
2657
__attribute__((cleanup(cleanup_close)))
2658
const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);
2659
g_assert_cmpint(epoll_fd, >=, 0);
2660
__attribute__((cleanup(cleanup_queue)))
2661
task_queue *queue = create_queue();
2662
g_assert_nonnull(queue);
2663
__attribute__((cleanup(cleanup_buffer)))
2664
buffer password = {};
2665
bool password_is_read = false;
2666
const char helper_directory[] = "/nonexistent";
2667
/* see proc(5) for format of /proc/self/status */
2668
const char *const argv[] = { "/usr/bin/awk",
2669
"$1==\"SigBlk:\"{ print $2 }", "/proc/self/status", NULL };
2670
2671
g_assert_true(start_mandos_client(queue, epoll_fd,
2672
&mandos_client_exited, &quit_now,
2673
&password, &password_is_read,
2674
&fixture->orig_sigaction,
2675
fixture->orig_sigmask,
2676
helper_directory, 0, 0, argv));
2677
2678
struct timespec starttime, currtime;
2679
g_assert_true(clock_gettime(CLOCK_MONOTONIC, &starttime) == 0);
2680
do {
2681
queue->next_run = 0;
2682
string_set cancelled_filenames = {};
2683
g_assert_true(wait_for_event(epoll_fd, queue->next_run, 0));
2684
g_assert_true(run_queue(&queue, &cancelled_filenames, &quit_now));
2685
g_assert_true(clock_gettime(CLOCK_MONOTONIC, &currtime) == 0);
2686
} while((not (mandos_client_exited and password_is_read))
2687
and (not quit_now)
2688
and ((currtime.tv_sec - starttime.tv_sec) < 10));
2689
g_assert_true(mandos_client_exited);
2690
g_assert_true(password_is_read);
2691
2692
sigset_t parsed_sigmask;
2693
g_assert_true(proc_status_sigblk_to_sigset(password.data,
2694
&parsed_sigmask));
2695
2696
for(int signum = 1; signum < NSIG; signum++){
2697
const bool has_signal = sigismember(&parsed_sigmask, signum);
2698
if(sigismember(&fixture->orig_sigmask, signum)){
2699
g_assert_true(has_signal);
2700
} else {
2701
g_assert_false(has_signal);
2702
}
2703
}
2704
}
2705
2706
__attribute__((nonnull, warn_unused_result))
2707
static bool proc_status_sigblk_to_sigset(const char *const sigblk,
2708
sigset_t *const sigmask){
2709
/* parse /proc/PID/status SigBlk value and convert to a sigset_t */
2710
uintmax_t scanned_sigmask;
2711
if(sscanf(sigblk, "%" SCNxMAX " ", &scanned_sigmask) != 1){
2712
return false;
2713
}
2714
if(sigemptyset(sigmask) != 0){
2715
return false;
2716
}
2717
for(int signum = 1; signum < NSIG; signum++){
2718
if(scanned_sigmask & ((uintmax_t)1 << (signum-1))){
2719
if(sigaddset(sigmask, signum) != 0){
2720
return false;
2721
}
2722
}
2723
}
2724
return true;
2725
}
2726
2727
static void run_task_with_stderr_to_dev_null(const task_context task,
2728
task_queue *const queue);
2729
2730
static
2731
void test_wait_for_mandos_client_exit_badpid(__attribute__((unused))
2732
test_fixture *fixture,
2733
__attribute__((unused))
2734
gconstpointer user_data){
2735
2736
bool mandos_client_exited = false;
2737
bool quit_now = false;
2738
2739
__attribute__((cleanup(cleanup_queue)))
2740
task_queue *queue = create_queue();
2741
g_assert_nonnull(queue);
2742
const task_context task = {
2743
.func=wait_for_mandos_client_exit,
2744
.pid=1,
2745
.mandos_client_exited=&mandos_client_exited,
2746
.quit_now=&quit_now,
2747
};
2748
run_task_with_stderr_to_dev_null(task, queue);
2749
2750
g_assert_false(mandos_client_exited);
2751
g_assert_true(quit_now);
2752
g_assert_cmpuint((unsigned int)queue->length, ==, 0);
2753
}
2754
2755
static void run_task_with_stderr_to_dev_null(const task_context task,
2756
task_queue *const queue){
2757
FILE *real_stderr = stderr;
2758
FILE *devnull = fopen("/dev/null", "we");
2759
g_assert_nonnull(devnull);
2760
2761
stderr = devnull;
2762
task.func(task, queue);
2763
stderr = real_stderr;
2764
2765
g_assert_cmpint(fclose(devnull), ==, 0);
2766
}
2767
2768
static
2769
void test_wait_for_mandos_client_exit_noexit(test_fixture *fixture,
2770
__attribute__((unused))
2771
gconstpointer user_data){
2772
bool mandos_client_exited = false;
2773
bool quit_now = false;
2774
2775
pid_t create_eternal_process(void){
2776
const pid_t pid = fork();
2777
if(pid == 0){ /* Child */
2778
if(not restore_signal_handler(&fixture->orig_sigaction)){
2779
_exit(EXIT_FAILURE);
2780
}
2781
if(not restore_sigmask(&fixture->orig_sigmask)){
2782
_exit(EXIT_FAILURE);
2783
}
2784
while(true){
2785
pause();
2786
}
2787
}
2788
return pid;
2789
}
2790
pid_t pid = create_eternal_process();
2791
g_assert_true(pid != -1);
2792
2793
__attribute__((cleanup(cleanup_queue)))
2794
task_queue *queue = create_queue();
2795
g_assert_nonnull(queue);
2796
const task_context task = {
2797
.func=wait_for_mandos_client_exit,
2798
.pid=pid,
2799
.mandos_client_exited=&mandos_client_exited,
2800
.quit_now=&quit_now,
2801
};
2802
task.func(task, queue);
2803
2804
g_assert_false(mandos_client_exited);
2805
g_assert_false(quit_now);
2806
g_assert_cmpuint((unsigned int)queue->length, ==, 1);
2807
2808
g_assert_nonnull(find_matching_task(queue, (task_context){
2809
.func=wait_for_mandos_client_exit,
2810
.pid=task.pid,
2811
.mandos_client_exited=&mandos_client_exited,
2812
.quit_now=&quit_now,
2813
}));
2814
}
2815
2816
static
2817
void test_wait_for_mandos_client_exit_success(test_fixture *fixture,
2818
__attribute__((unused))
2819
gconstpointer
2820
user_data){
2821
bool mandos_client_exited = false;
2822
bool quit_now = false;
2823
2824
pid_t create_successful_process(void){
2825
const pid_t pid = fork();
2826
if(pid == 0){ /* Child */
2827
if(not restore_signal_handler(&fixture->orig_sigaction)){
2828
_exit(EXIT_FAILURE);
2829
}
2830
if(not restore_sigmask(&fixture->orig_sigmask)){
2831
_exit(EXIT_FAILURE);
2832
}
2833
exit(EXIT_SUCCESS);
2834
}
2835
return pid;
2836
}
2837
const pid_t pid = create_successful_process();
2838
g_assert_true(pid != -1);
2839
2840
__attribute__((cleanup(cleanup_queue)))
2841
task_queue *queue = create_queue();
2842
g_assert_nonnull(queue);
2843
const task_context initial_task = {
2844
.func=wait_for_mandos_client_exit,
2845
.pid=pid,
2846
.mandos_client_exited=&mandos_client_exited,
2847
.quit_now=&quit_now,
2848
};
2849
g_assert_true(add_to_queue(queue, initial_task));
2850
2851
struct timespec starttime, currtime;
2852
g_assert_true(clock_gettime(CLOCK_MONOTONIC, &starttime) == 0);
2853
__attribute__((cleanup(cleanup_close)))
2854
const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);
2855
do {
2856
queue->next_run = 0;
2857
g_assert_true(wait_for_event(epoll_fd, queue->next_run, 0));
2858
g_assert_true(run_queue(&queue, (string_set[]){{}}, &quit_now));
2859
g_assert_true(clock_gettime(CLOCK_MONOTONIC, &currtime) == 0);
2860
} while((not mandos_client_exited)
2861
and (not quit_now)
2862
and ((currtime.tv_sec - starttime.tv_sec) < 10));
2863
2864
g_assert_true(mandos_client_exited);
2865
g_assert_false(quit_now);
2866
g_assert_cmpuint((unsigned int)queue->length, ==, 0);
2867
}
2868
2869
static
2870
void test_wait_for_mandos_client_exit_failure(test_fixture *fixture,
2871
__attribute__((unused))
2872
gconstpointer
2873
user_data){
2874
bool mandos_client_exited = false;
2875
bool quit_now = false;
2876
2877
pid_t create_failing_process(void){
2878
const pid_t pid = fork();
2879
if(pid == 0){ /* Child */
2880
if(not restore_signal_handler(&fixture->orig_sigaction)){
2881
_exit(EXIT_FAILURE);
2882
}
2883
if(not restore_sigmask(&fixture->orig_sigmask)){
2884
_exit(EXIT_FAILURE);
2885
}
2886
exit(EXIT_FAILURE);
2887
}
2888
return pid;
2889
}
2890
const pid_t pid = create_failing_process();
2891
g_assert_true(pid != -1);
2892
2893
__attribute__((cleanup(string_set_clear)))
2894
string_set cancelled_filenames = {};
2895
__attribute__((cleanup(cleanup_close)))
2896
const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);
2897
g_assert_cmpint(epoll_fd, >=, 0);
2898
__attribute__((cleanup(cleanup_queue)))
2899
task_queue *queue = create_queue();
2900
g_assert_nonnull(queue);
2901
g_assert_true(add_to_queue(queue, (task_context){
2902
.func=wait_for_mandos_client_exit,
2903
.pid=pid,
2904
.mandos_client_exited=&mandos_client_exited,
2905
.quit_now=&quit_now,
2906
}));
2907
2908
g_assert_true(sigismember(&fixture->orig_sigmask, SIGCHLD) == 0);
2909
2910
__attribute__((cleanup(cleanup_close)))
2911
const int devnull_fd = open("/dev/null",
2912
O_WRONLY | O_CLOEXEC | O_NOCTTY);
2913
g_assert_cmpint(devnull_fd, >=, 0);
2914
__attribute__((cleanup(cleanup_close)))
2915
const int real_stderr_fd = dup(STDERR_FILENO);
2916
g_assert_cmpint(real_stderr_fd, >=, 0);
2917
2918
struct timespec starttime, currtime;
2919
g_assert_true(clock_gettime(CLOCK_MONOTONIC, &starttime) == 0);
2920
do {
2921
g_assert_true(wait_for_event(epoll_fd, queue->next_run, 0));
2922
dup2(devnull_fd, STDERR_FILENO);
2923
const bool success = run_queue(&queue, &cancelled_filenames,
2924
&quit_now);
2925
dup2(real_stderr_fd, STDERR_FILENO);
2926
if(not success){
2927
break;
2928
}
2929
2930
g_assert_true(clock_gettime(CLOCK_MONOTONIC, &currtime) == 0);
2931
} while((not mandos_client_exited)
2932
and (not quit_now)
2933
and ((currtime.tv_sec - starttime.tv_sec) < 10));
2934
2935
g_assert_true(quit_now);
2936
g_assert_true(mandos_client_exited);
2937
g_assert_cmpuint((unsigned int)queue->length, ==, 0);
2938
}
2939
2940
static
2941
void test_wait_for_mandos_client_exit_killed(test_fixture *fixture,
2942
__attribute__((unused))
2943
gconstpointer user_data){
2944
bool mandos_client_exited = false;
2945
bool quit_now = false;
2946
2947
pid_t create_killed_process(void){
2948
const pid_t pid = fork();
2949
if(pid == 0){ /* Child */
2950
if(not restore_signal_handler(&fixture->orig_sigaction)){
2951
_exit(EXIT_FAILURE);
2952
}
2953
if(not restore_sigmask(&fixture->orig_sigmask)){
2954
_exit(EXIT_FAILURE);
2955
}
2956
while(true){
2957
pause();
2958
}
2959
}
2960
kill(pid, SIGKILL);
2961
return pid;
2962
}
2963
const pid_t pid = create_killed_process();
2964
g_assert_true(pid != -1);
2965
2966
__attribute__((cleanup(string_set_clear)))
2967
string_set cancelled_filenames = {};
2968
__attribute__((cleanup(cleanup_close)))
2969
const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);
2970
g_assert_cmpint(epoll_fd, >=, 0);
2971
__attribute__((cleanup(cleanup_queue)))
2972
task_queue *queue = create_queue();
2973
g_assert_nonnull(queue);
2974
g_assert_true(add_to_queue(queue, (task_context){
2975
.func=wait_for_mandos_client_exit,
2976
.pid=pid,
2977
.mandos_client_exited=&mandos_client_exited,
2978
.quit_now=&quit_now,
2979
}));
2980
2981
__attribute__((cleanup(cleanup_close)))
2982
const int devnull_fd = open("/dev/null",
2983
O_WRONLY | O_CLOEXEC, O_NOCTTY);
2984
g_assert_cmpint(devnull_fd, >=, 0);
2985
__attribute__((cleanup(cleanup_close)))
2986
const int real_stderr_fd = dup(STDERR_FILENO);
2987
g_assert_cmpint(real_stderr_fd, >=, 0);
2988
2989
struct timespec starttime, currtime;
2990
g_assert_true(clock_gettime(CLOCK_MONOTONIC, &starttime) == 0);
2991
do {
2992
g_assert_true(wait_for_event(epoll_fd, queue->next_run, 0));
2993
dup2(devnull_fd, STDERR_FILENO);
2994
const bool success = run_queue(&queue, &cancelled_filenames,
2995
&quit_now);
2996
dup2(real_stderr_fd, STDERR_FILENO);
2997
if(not success){
2998
break;
2999
}
3000
3001
g_assert_true(clock_gettime(CLOCK_MONOTONIC, &currtime) == 0);
3002
} while((not mandos_client_exited)
3003
and (not quit_now)
3004
and ((currtime.tv_sec - starttime.tv_sec) < 10));
3005
3006
g_assert_true(mandos_client_exited);
3007
g_assert_true(quit_now);
3008
g_assert_cmpuint((unsigned int)queue->length, ==, 0);
3009
}
3010
3011
static bool epoll_set_does_not_contain(int, int);
3012
3013
static
3014
void test_read_mandos_client_output_readerror(__attribute__((unused))
3015
test_fixture *fixture,
3016
__attribute__((unused))
3017
gconstpointer
3018
user_data){
3019
__attribute__((cleanup(cleanup_close)))
3020
const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);
3021
g_assert_cmpint(epoll_fd, >=, 0);
3022
3023
__attribute__((cleanup(cleanup_buffer)))
3024
buffer password = {};
3025
3026
/* Reading /proc/self/mem from offset 0 will always give EIO */
3027
const int fd = open("/proc/self/mem",
3028
O_RDONLY | O_CLOEXEC | O_NOCTTY);
3029
3030
bool password_is_read = false;
3031
bool quit_now = false;
3032
__attribute__((cleanup(cleanup_queue)))
3033
task_queue *queue = create_queue();
3034
g_assert_nonnull(queue);
3035
3036
task_context task = {
3037
.func=read_mandos_client_output,
3038
.epoll_fd=epoll_fd,
3039
.fd=fd,
3040
.password=&password,
3041
.password_is_read=&password_is_read,
3042
.quit_now=&quit_now,
3043
};
3044
run_task_with_stderr_to_dev_null(task, queue);
3045
g_assert_false(password_is_read);
3046
g_assert_cmpint((int)password.length, ==, 0);
3047
g_assert_true(quit_now);
3048
g_assert_cmpuint((unsigned int)queue->length, ==, 0);
3049
3050
g_assert_true(epoll_set_does_not_contain(epoll_fd, fd));
3051
3052
g_assert_cmpint(close(fd), ==, -1);
3053
}
3054
3055
static bool epoll_set_does_not_contain(int epoll_fd, int fd){
3056
return not epoll_set_contains(epoll_fd, fd, 0);
3057
}
3058
3059
static
3060
void test_read_mandos_client_output_nodata(__attribute__((unused))
3061
test_fixture *fixture,
3062
__attribute__((unused))
3063
gconstpointer user_data){
3064
__attribute__((cleanup(cleanup_close)))
3065
const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);
3066
g_assert_cmpint(epoll_fd, >=, 0);
3067
3068
int pipefds[2];
3069
g_assert_cmpint(pipe2(pipefds, O_CLOEXEC | O_NONBLOCK), ==, 0);
3070
3071
__attribute__((cleanup(cleanup_buffer)))
3072
buffer password = {};
3073
3074
bool password_is_read = false;
3075
bool quit_now = false;
3076
__attribute__((cleanup(cleanup_queue)))
3077
task_queue *queue = create_queue();
3078
g_assert_nonnull(queue);
3079
3080
task_context task = {
3081
.func=read_mandos_client_output,
3082
.epoll_fd=epoll_fd,
3083
.fd=pipefds[0],
3084
.password=&password,
3085
.password_is_read=&password_is_read,
3086
.quit_now=&quit_now,
3087
};
3088
task.func(task, queue);
3089
g_assert_false(password_is_read);
3090
g_assert_cmpint((int)password.length, ==, 0);
3091
g_assert_false(quit_now);
3092
g_assert_cmpuint((unsigned int)queue->length, ==, 1);
3093
3094
g_assert_nonnull(find_matching_task(queue, (task_context){
3095
.func=read_mandos_client_output,
3096
.epoll_fd=epoll_fd,
3097
.fd=pipefds[0],
3098
.password=&password,
3099
.password_is_read=&password_is_read,
3100
.quit_now=&quit_now,
3101
}));
3102
3103
g_assert_true(epoll_set_contains(epoll_fd, pipefds[0],
3104
EPOLLIN | EPOLLRDHUP));
3105
3106
g_assert_cmpint(close(pipefds[1]), ==, 0);
3107
}
3108
3109
static void test_read_mandos_client_output_eof(__attribute__((unused))
3110
test_fixture *fixture,
3111
__attribute__((unused))
3112
gconstpointer
3113
user_data){
3114
__attribute__((cleanup(cleanup_close)))
3115
const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);
3116
g_assert_cmpint(epoll_fd, >=, 0);
3117
3118
int pipefds[2];
3119
g_assert_cmpint(pipe2(pipefds, O_CLOEXEC | O_NONBLOCK), ==, 0);
3120
g_assert_cmpint(close(pipefds[1]), ==, 0);
3121
3122
__attribute__((cleanup(cleanup_buffer)))
3123
buffer password = {};
3124
3125
bool password_is_read = false;
3126
bool quit_now = false;
3127
__attribute__((cleanup(cleanup_queue)))
3128
task_queue *queue = create_queue();
3129
g_assert_nonnull(queue);
3130
3131
task_context task = {
3132
.func=read_mandos_client_output,
3133
.epoll_fd=epoll_fd,
3134
.fd=pipefds[0],
3135
.password=&password,
3136
.password_is_read=&password_is_read,
3137
.quit_now=&quit_now,
3138
};
3139
task.func(task, queue);
3140
g_assert_true(password_is_read);
3141
g_assert_cmpint((int)password.length, ==, 0);
3142
g_assert_false(quit_now);
3143
g_assert_cmpuint((unsigned int)queue->length, ==, 0);
3144
3145
g_assert_true(epoll_set_does_not_contain(epoll_fd, pipefds[0]));
3146
3147
g_assert_cmpint(close(pipefds[0]), ==, -1);
3148
}
3149
3150
static
3151
void test_read_mandos_client_output_once(__attribute__((unused))
3152
test_fixture *fixture,
3153
__attribute__((unused))
3154
gconstpointer user_data){
3155
__attribute__((cleanup(cleanup_close)))
3156
const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);
3157
g_assert_cmpint(epoll_fd, >=, 0);
3158
3159
int pipefds[2];
3160
g_assert_cmpint(pipe2(pipefds, O_CLOEXEC | O_NONBLOCK), ==, 0);
3161
3162
const char dummy_test_password[] = "dummy test password";
3163
/* Start with a pre-allocated buffer */
3164
__attribute__((cleanup(cleanup_buffer)))
3165
buffer password = {
3166
.data=malloc(sizeof(dummy_test_password)),
3167
.length=0,
3168
.allocated=sizeof(dummy_test_password),
3169
};
3170
g_assert_nonnull(password.data);
3171
if(mlock(password.data, password.allocated) != 0){
3172
g_assert_true(errno == EPERM or errno == ENOMEM);
3173
}
3174
3175
bool password_is_read = false;
3176
bool quit_now = false;
3177
__attribute__((cleanup(cleanup_queue)))
3178
task_queue *queue = create_queue();
3179
g_assert_nonnull(queue);
3180
3181
g_assert_true(sizeof(dummy_test_password) <= PIPE_BUF);
3182
g_assert_cmpint((int)write(pipefds[1], dummy_test_password,
3183
sizeof(dummy_test_password)),
3184
==, (int)sizeof(dummy_test_password));
3185
3186
task_context task = {
3187
.func=read_mandos_client_output,
3188
.epoll_fd=epoll_fd,
3189
.fd=pipefds[0],
3190
.password=&password,
3191
.password_is_read=&password_is_read,
3192
.quit_now=&quit_now,
3193
};
3194
task.func(task, queue);
3195
3196
g_assert_false(password_is_read);
3197
g_assert_cmpint((int)password.length, ==,
3198
(int)sizeof(dummy_test_password));
3199
g_assert_nonnull(password.data);
3200
g_assert_cmpint(memcmp(password.data, dummy_test_password,
3201
sizeof(dummy_test_password)), ==, 0);
3202
3203
g_assert_false(quit_now);
3204
g_assert_cmpuint((unsigned int)queue->length, ==, 1);
3205
3206
g_assert_nonnull(find_matching_task(queue, (task_context){
3207
.func=read_mandos_client_output,
3208
.epoll_fd=epoll_fd,
3209
.fd=pipefds[0],
3210
.password=&password,
3211
.password_is_read=&password_is_read,
3212
.quit_now=&quit_now,
3213
}));
3214
3215
g_assert_true(epoll_set_contains(epoll_fd, pipefds[0],
3216
EPOLLIN | EPOLLRDHUP));
3217
3218
g_assert_cmpint(close(pipefds[1]), ==, 0);
3219
}
3220
3221
static
3222
void test_read_mandos_client_output_malloc(__attribute__((unused))
3223
test_fixture *fixture,
3224
__attribute__((unused))
3225
gconstpointer user_data){
3226
__attribute__((cleanup(cleanup_close)))
3227
const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);
3228
g_assert_cmpint(epoll_fd, >=, 0);
3229
3230
int pipefds[2];
3231
g_assert_cmpint(pipe2(pipefds, O_CLOEXEC | O_NONBLOCK), ==, 0);
3232
3233
const char dummy_test_password[] = "dummy test password";
3234
/* Start with an empty buffer */
3235
__attribute__((cleanup(cleanup_buffer)))
3236
buffer password = {};
3237
3238
bool password_is_read = false;
3239
bool quit_now = false;
3240
__attribute__((cleanup(cleanup_queue)))
3241
task_queue *queue = create_queue();
3242
g_assert_nonnull(queue);
3243
3244
g_assert_true(sizeof(dummy_test_password) <= PIPE_BUF);
3245
g_assert_cmpint((int)write(pipefds[1], dummy_test_password,
3246
sizeof(dummy_test_password)),
3247
==, (int)sizeof(dummy_test_password));
3248
3249
task_context task = {
3250
.func=read_mandos_client_output,
3251
.epoll_fd=epoll_fd,
3252
.fd=pipefds[0],
3253
.password=&password,
3254
.password_is_read=&password_is_read,
3255
.quit_now=&quit_now,
3256
};
3257
task.func(task, queue);
3258
3259
g_assert_false(password_is_read);
3260
g_assert_cmpint((int)password.length, ==,
3261
(int)sizeof(dummy_test_password));
3262
g_assert_nonnull(password.data);
3263
g_assert_cmpint(memcmp(password.data, dummy_test_password,
3264
sizeof(dummy_test_password)), ==, 0);
3265
3266
g_assert_false(quit_now);
3267
g_assert_cmpuint((unsigned int)queue->length, ==, 1);
3268
3269
g_assert_nonnull(find_matching_task(queue, (task_context){
3270
.func=read_mandos_client_output,
3271
.epoll_fd=epoll_fd,
3272
.fd=pipefds[0],
3273
.password=&password,
3274
.password_is_read=&password_is_read,
3275
.quit_now=&quit_now,
3276
}));
3277
3278
g_assert_true(epoll_set_contains(epoll_fd, pipefds[0],
3279
EPOLLIN | EPOLLRDHUP));
3280
3281
g_assert_cmpint(close(pipefds[1]), ==, 0);
3282
}
3283
3284
static
3285
void test_read_mandos_client_output_append(__attribute__((unused))
3286
test_fixture *fixture,
3287
__attribute__((unused))
3288
gconstpointer user_data){
3289
__attribute__((cleanup(cleanup_close)))
3290
const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);
3291
g_assert_cmpint(epoll_fd, >=, 0);
3292
3293
int pipefds[2];
3294
g_assert_cmpint(pipe2(pipefds, O_CLOEXEC | O_NONBLOCK), ==, 0);
3295
3296
const char dummy_test_password[] = "dummy test password";
3297
__attribute__((cleanup(cleanup_buffer)))
3298
buffer password = {
3299
.data=malloc(PIPE_BUF),
3300
.length=PIPE_BUF,
3301
.allocated=PIPE_BUF,
3302
};
3303
g_assert_nonnull(password.data);
3304
if(mlock(password.data, password.allocated) != 0){
3305
g_assert_true(errno == EPERM or errno == ENOMEM);
3306
}
3307
3308
memset(password.data, 'x', PIPE_BUF);
3309
char password_expected[PIPE_BUF];
3310
memcpy(password_expected, password.data, PIPE_BUF);
3311
3312
bool password_is_read = false;
3313
bool quit_now = false;
3314
__attribute__((cleanup(cleanup_queue)))
3315
task_queue *queue = create_queue();
3316
g_assert_nonnull(queue);
3317
3318
g_assert_true(sizeof(dummy_test_password) <= PIPE_BUF);
3319
g_assert_cmpint((int)write(pipefds[1], dummy_test_password,
3320
sizeof(dummy_test_password)),
3321
==, (int)sizeof(dummy_test_password));
3322
3323
task_context task = {
3324
.func=read_mandos_client_output,
3325
.epoll_fd=epoll_fd,
3326
.fd=pipefds[0],
3327
.password=&password,
3328
.password_is_read=&password_is_read,
3329
.quit_now=&quit_now,
3330
};
3331
task.func(task, queue);
3332
3333
g_assert_false(password_is_read);
3334
g_assert_cmpint((int)password.length, ==,
3335
PIPE_BUF + sizeof(dummy_test_password));
3336
g_assert_nonnull(password.data);
3337
g_assert_cmpint(memcmp(password_expected, password.data, PIPE_BUF),
3338
==, 0);
3339
g_assert_cmpint(memcmp(password.data + PIPE_BUF,
3340
dummy_test_password,
3341
sizeof(dummy_test_password)), ==, 0);
3342
g_assert_false(quit_now);
3343
g_assert_cmpuint((unsigned int)queue->length, ==, 1);
3344
3345
g_assert_nonnull(find_matching_task(queue, (task_context){
3346
.func=read_mandos_client_output,
3347
.epoll_fd=epoll_fd,
3348
.fd=pipefds[0],
3349
.password=&password,
3350
.password_is_read=&password_is_read,
3351
.quit_now=&quit_now,
3352
}));
3353
3354
g_assert_true(epoll_set_contains(epoll_fd, pipefds[0],
3355
EPOLLIN | EPOLLRDHUP));
3356
}
3357
3358
static char *make_temporary_directory(void);
3359
3360
static void test_add_inotify_dir_watch(__attribute__((unused))
3361
test_fixture *fixture,
3362
__attribute__((unused))
3363
gconstpointer user_data){
3364
__attribute__((cleanup(cleanup_close)))
3365
const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);
3366
g_assert_cmpint(epoll_fd, >=, 0);
3367
__attribute__((cleanup(cleanup_queue)))
3368
task_queue *queue = create_queue();
3369
g_assert_nonnull(queue);
3370
__attribute__((cleanup(string_set_clear)))
3371
string_set cancelled_filenames = {};
3372
const mono_microsecs current_time = 0;
3373
3374
bool quit_now = false;
3375
buffer password = {};
3376
bool mandos_client_exited = false;
3377
bool password_is_read = false;
3378
3379
__attribute__((cleanup(cleanup_string)))
3380
char *tempdir = make_temporary_directory();
3381
g_assert_nonnull(tempdir);
3382
3383
g_assert_true(add_inotify_dir_watch(queue, epoll_fd, &quit_now,
3384
&password, tempdir,
3385
&cancelled_filenames,
3386
¤t_time,
3387
&mandos_client_exited,
3388
&password_is_read));
3389
3390
g_assert_cmpuint((unsigned int)queue->length, >, 0);
3391
3392
const task_context *const added_read_task
3393
= find_matching_task(queue, (task_context){
3394
.func=read_inotify_event,
3395
.epoll_fd=epoll_fd,
3396
.quit_now=&quit_now,
3397
.password=&password,
3398
.filename=tempdir,
3399
.cancelled_filenames=&cancelled_filenames,
3400
.current_time=¤t_time,
3401
.mandos_client_exited=&mandos_client_exited,
3402
.password_is_read=&password_is_read,
3403
});
3404
g_assert_nonnull(added_read_task);
3405
3406
g_assert_cmpint(added_read_task->fd, >, 2);
3407
g_assert_true(fd_has_cloexec_and_nonblock(added_read_task->fd));
3408
g_assert_true(epoll_set_contains(added_read_task->epoll_fd,
3409
added_read_task->fd,
3410
EPOLLIN | EPOLLRDHUP));
3411
3412
g_assert_cmpint(rmdir(tempdir), ==, 0);
3413
}
3414
3415
static char *make_temporary_directory(void){
3416
char *name = strdup("/tmp/mandosXXXXXX");
3417
g_assert_nonnull(name);
3418
char *result = mkdtemp(name);
3419
if(result == NULL){
3420
free(name);
3421
}
3422
return result;
3423
}
3424
3425
static void test_add_inotify_dir_watch_fail(__attribute__((unused))
3426
test_fixture *fixture,
3427
__attribute__((unused))
3428
gconstpointer user_data){
3429
__attribute__((cleanup(cleanup_close)))
3430
const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);
3431
g_assert_cmpint(epoll_fd, >=, 0);
3432
__attribute__((cleanup(cleanup_queue)))
3433
task_queue *queue = create_queue();
3434
g_assert_nonnull(queue);
3435
__attribute__((cleanup(string_set_clear)))
3436
string_set cancelled_filenames = {};
3437
const mono_microsecs current_time = 0;
3438
3439
bool quit_now = false;
3440
buffer password = {};
3441
bool mandos_client_exited = false;
3442
bool password_is_read = false;
3443
3444
const char nonexistent_dir[] = "/nonexistent";
3445
3446
FILE *real_stderr = stderr;
3447
FILE *devnull = fopen("/dev/null", "we");
3448
g_assert_nonnull(devnull);
3449
stderr = devnull;
3450
g_assert_false(add_inotify_dir_watch(queue, epoll_fd, &quit_now,
3451
&password, nonexistent_dir,
3452
&cancelled_filenames,
3453
¤t_time,
3454
&mandos_client_exited,
3455
&password_is_read));
3456
stderr = real_stderr;
3457
g_assert_cmpint(fclose(devnull), ==, 0);
3458
3459
g_assert_cmpuint((unsigned int)queue->length, ==, 0);
3460
}
3461
3462
static void test_add_inotify_dir_watch_nondir(__attribute__((unused))
3463
test_fixture *fixture,
3464
__attribute__((unused))
3465
gconstpointer
3466
user_data){
3467
__attribute__((cleanup(cleanup_close)))
3468
const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);
3469
g_assert_cmpint(epoll_fd, >=, 0);
3470
__attribute__((cleanup(cleanup_queue)))
3471
task_queue *queue = create_queue();
3472
g_assert_nonnull(queue);
3473
__attribute__((cleanup(string_set_clear)))
3474
string_set cancelled_filenames = {};
3475
const mono_microsecs current_time = 0;
3476
3477
bool quit_now = false;
3478
buffer password = {};
3479
bool mandos_client_exited = false;
3480
bool password_is_read = false;
3481
3482
const char not_a_directory[] = "/dev/tty";
3483
3484
FILE *real_stderr = stderr;
3485
FILE *devnull = fopen("/dev/null", "we");
3486
g_assert_nonnull(devnull);
3487
stderr = devnull;
3488
g_assert_false(add_inotify_dir_watch(queue, epoll_fd, &quit_now,
3489
&password, not_a_directory,
3490
&cancelled_filenames,
3491
¤t_time,
3492
&mandos_client_exited,
3493
&password_is_read));
3494
stderr = real_stderr;
3495
g_assert_cmpint(fclose(devnull), ==, 0);
3496
3497
g_assert_cmpuint((unsigned int)queue->length, ==, 0);
3498
}
3499
3500
static void test_add_inotify_dir_watch_EAGAIN(__attribute__((unused))
3501
test_fixture *fixture,
3502
__attribute__((unused))
3503
gconstpointer
3504
user_data){
3505
__attribute__((cleanup(cleanup_close)))
3506
const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);
3507
g_assert_cmpint(epoll_fd, >=, 0);
3508
__attribute__((cleanup(cleanup_queue)))
3509
task_queue *queue = create_queue();
3510
g_assert_nonnull(queue);
3511
__attribute__((cleanup(string_set_clear)))
3512
string_set cancelled_filenames = {};
3513
const mono_microsecs current_time = 0;
3514
3515
bool quit_now = false;
3516
buffer password = {};
3517
bool mandos_client_exited = false;
3518
bool password_is_read = false;
3519
3520
__attribute__((cleanup(cleanup_string)))
3521
char *tempdir = make_temporary_directory();
3522
g_assert_nonnull(tempdir);
3523
3524
g_assert_true(add_inotify_dir_watch(queue, epoll_fd, &quit_now,
3525
&password, tempdir,
3526
&cancelled_filenames,
3527
¤t_time,
3528
&mandos_client_exited,
3529
&password_is_read));
3530
3531
g_assert_cmpuint((unsigned int)queue->length, >, 0);
3532
3533
const task_context *const added_read_task
3534
= find_matching_task(queue,
3535
(task_context){ .func=read_inotify_event });
3536
g_assert_nonnull(added_read_task);
3537
3538
g_assert_cmpint(added_read_task->fd, >, 2);
3539
g_assert_true(fd_has_cloexec_and_nonblock(added_read_task->fd));
3540
3541
/* "sufficient to read at least one event." - inotify(7) */
3542
const size_t ievent_size = (sizeof(struct inotify_event)
3543
+ NAME_MAX + 1);
3544
struct inotify_event *ievent = malloc(ievent_size);
3545
g_assert_nonnull(ievent);
3546
3547
g_assert_cmpint(read(added_read_task->fd, ievent, ievent_size), ==,
3548
-1);
3549
g_assert_cmpint(errno, ==, EAGAIN);
3550
3551
free(ievent);
3552
3553
g_assert_cmpint(rmdir(tempdir), ==, 0);
3554
}
3555
3556
static char *make_temporary_file_in_directory(const char
3557
*const dir);
3558
3559
static
3560
void test_add_inotify_dir_watch_IN_CLOSE_WRITE(__attribute__((unused))
3561
test_fixture *fixture,
3562
__attribute__((unused))
3563
gconstpointer
3564
user_data){
3565
__attribute__((cleanup(cleanup_close)))
3566
const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);
3567
g_assert_cmpint(epoll_fd, >=, 0);
3568
__attribute__((cleanup(cleanup_queue)))
3569
task_queue *queue = create_queue();
3570
g_assert_nonnull(queue);
3571
__attribute__((cleanup(string_set_clear)))
3572
string_set cancelled_filenames = {};
3573
const mono_microsecs current_time = 0;
3574
3575
bool quit_now = false;
3576
buffer password = {};
3577
bool mandos_client_exited = false;
3578
bool password_is_read = false;
3579
3580
__attribute__((cleanup(cleanup_string)))
3581
char *tempdir = make_temporary_directory();
3582
g_assert_nonnull(tempdir);
3583
3584
g_assert_true(add_inotify_dir_watch(queue, epoll_fd, &quit_now,
3585
&password, tempdir,
3586
&cancelled_filenames,
3587
¤t_time,
3588
&mandos_client_exited,
3589
&password_is_read));
3590
3591
g_assert_cmpuint((unsigned int)queue->length, >, 0);
3592
3593
const task_context *const added_read_task
3594
= find_matching_task(queue,
3595
(task_context){ .func=read_inotify_event });
3596
g_assert_nonnull(added_read_task);
3597
3598
g_assert_cmpint(added_read_task->fd, >, 2);
3599
g_assert_true(fd_has_cloexec_and_nonblock(added_read_task->fd));
3600
3601
__attribute__((cleanup(cleanup_string)))
3602
char *filename = make_temporary_file_in_directory(tempdir);
3603
g_assert_nonnull(filename);
3604
3605
/* "sufficient to read at least one event." - inotify(7) */
3606
const size_t ievent_size = (sizeof(struct inotify_event)
3607
+ NAME_MAX + 1);
3608
struct inotify_event *ievent = malloc(ievent_size);
3609
g_assert_nonnull(ievent);
3610
3611
ssize_t read_size = 0;
3612
read_size = read(added_read_task->fd, ievent, ievent_size);
3613
3614
g_assert_cmpint((int)read_size, >, 0);
3615
g_assert_true(ievent->mask & IN_CLOSE_WRITE);
3616
g_assert_cmpstr(ievent->name, ==, basename(filename));
3617
3618
free(ievent);
3619
3620
g_assert_cmpint(unlink(filename), ==, 0);
3621
g_assert_cmpint(rmdir(tempdir), ==, 0);
3622
}
3623
3624
static char *make_temporary_prefixed_file_in_directory(const char
3625
*const prefix,
3626
const char
3627
*const dir){
3628
char *filename = NULL;
3629
g_assert_cmpint(asprintf(&filename, "%s/%sXXXXXX", dir, prefix),
3630
>, 0);
3631
g_assert_nonnull(filename);
3632
const int fd = mkostemp(filename, O_CLOEXEC);
3633
g_assert_cmpint(fd, >=, 0);
3634
g_assert_cmpint(close(fd), ==, 0);
3635
return filename;
3636
}
3637
3638
static char *make_temporary_file_in_directory(const char
3639
*const dir){
3640
return make_temporary_prefixed_file_in_directory("temp", dir);
3641
}
3642
3643
static
3644
void test_add_inotify_dir_watch_IN_MOVED_TO(__attribute__((unused))
3645
test_fixture *fixture,
3646
__attribute__((unused))
3647
gconstpointer user_data){
3648
__attribute__((cleanup(cleanup_close)))
3649
const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);
3650
g_assert_cmpint(epoll_fd, >=, 0);
3651
__attribute__((cleanup(cleanup_queue)))
3652
task_queue *queue = create_queue();
3653
g_assert_nonnull(queue);
3654
__attribute__((cleanup(string_set_clear)))
3655
string_set cancelled_filenames = {};
3656
const mono_microsecs current_time = 0;
3657
3658
bool quit_now = false;
3659
buffer password = {};
3660
bool mandos_client_exited = false;
3661
bool password_is_read = false;
3662
3663
__attribute__((cleanup(cleanup_string)))
3664
char *watchdir = make_temporary_directory();
3665
g_assert_nonnull(watchdir);
3666
3667
g_assert_true(add_inotify_dir_watch(queue, epoll_fd, &quit_now,
3668
&password, watchdir,
3669
&cancelled_filenames,
3670
¤t_time,
3671
&mandos_client_exited,
3672
&password_is_read));
3673
3674
g_assert_cmpuint((unsigned int)queue->length, >, 0);
3675
3676
const task_context *const added_read_task
3677
= find_matching_task(queue,
3678
(task_context){ .func=read_inotify_event });
3679
g_assert_nonnull(added_read_task);
3680
3681
g_assert_cmpint(added_read_task->fd, >, 2);
3682
g_assert_true(fd_has_cloexec_and_nonblock(added_read_task->fd));
3683
3684
char *sourcedir = make_temporary_directory();
3685
g_assert_nonnull(sourcedir);
3686
3687
__attribute__((cleanup(cleanup_string)))
3688
char *filename = make_temporary_file_in_directory(sourcedir);
3689
g_assert_nonnull(filename);
3690
3691
__attribute__((cleanup(cleanup_string)))
3692
char *targetfilename = NULL;
3693
g_assert_cmpint(asprintf(&targetfilename, "%s/%s", watchdir,
3694
basename(filename)), >, 0);
3695
g_assert_nonnull(targetfilename);
3696
3697
g_assert_cmpint(rename(filename, targetfilename), ==, 0);
3698
g_assert_cmpint(rmdir(sourcedir), ==, 0);
3699
free(sourcedir);
3700
3701
/* "sufficient to read at least one event." - inotify(7) */
3702
const size_t ievent_size = (sizeof(struct inotify_event)
3703
+ NAME_MAX + 1);
3704
struct inotify_event *ievent = malloc(ievent_size);
3705
g_assert_nonnull(ievent);
3706
3707
ssize_t read_size = read(added_read_task->fd, ievent, ievent_size);
3708
3709
g_assert_cmpint((int)read_size, >, 0);
3710
g_assert_true(ievent->mask & IN_MOVED_TO);
3711
g_assert_cmpstr(ievent->name, ==, basename(targetfilename));
3712
3713
free(ievent);
3714
3715
g_assert_cmpint(unlink(targetfilename), ==, 0);
3716
g_assert_cmpint(rmdir(watchdir), ==, 0);
3717
}
3718
3719
static
3720
void test_add_inotify_dir_watch_IN_MOVED_FROM(__attribute__((unused))
3721
test_fixture *fixture,
3722
__attribute__((unused))
3723
gconstpointer
3724
user_data){
3725
__attribute__((cleanup(cleanup_close)))
3726
const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);
3727
g_assert_cmpint(epoll_fd, >=, 0);
3728
__attribute__((cleanup(cleanup_queue)))
3729
task_queue *queue = create_queue();
3730
g_assert_nonnull(queue);
3731
__attribute__((cleanup(string_set_clear)))
3732
string_set cancelled_filenames = {};
3733
const mono_microsecs current_time = 0;
3734
3735
bool quit_now = false;
3736
buffer password = {};
3737
bool mandos_client_exited = false;
3738
bool password_is_read = false;
3739
3740
__attribute__((cleanup(cleanup_string)))
3741
char *tempdir = make_temporary_directory();
3742
g_assert_nonnull(tempdir);
3743
3744
__attribute__((cleanup(cleanup_string)))
3745
char *tempfilename = make_temporary_file_in_directory(tempdir);
3746
g_assert_nonnull(tempfilename);
3747
3748
__attribute__((cleanup(cleanup_string)))
3749
char *targetdir = make_temporary_directory();
3750
g_assert_nonnull(targetdir);
3751
3752
__attribute__((cleanup(cleanup_string)))
3753
char *targetfilename = NULL;
3754
g_assert_cmpint(asprintf(&targetfilename, "%s/%s", targetdir,
3755
basename(tempfilename)), >, 0);
3756
g_assert_nonnull(targetfilename);
3757
3758
g_assert_true(add_inotify_dir_watch(queue, epoll_fd, &quit_now,
3759
&password, tempdir,
3760
&cancelled_filenames,
3761
¤t_time,
3762
&mandos_client_exited,
3763
&password_is_read));
3764
3765
g_assert_cmpint(rename(tempfilename, targetfilename), ==, 0);
3766
3767
const task_context *const added_read_task
3768
= find_matching_task(queue,
3769
(task_context){ .func=read_inotify_event });
3770
g_assert_nonnull(added_read_task);
3771
3772
/* "sufficient to read at least one event." - inotify(7) */
3773
const size_t ievent_size = (sizeof(struct inotify_event)
3774
+ NAME_MAX + 1);
3775
struct inotify_event *ievent = malloc(ievent_size);
3776
g_assert_nonnull(ievent);
3777
3778
ssize_t read_size = read(added_read_task->fd, ievent, ievent_size);
3779
3780
g_assert_cmpint((int)read_size, >, 0);
3781
g_assert_true(ievent->mask & IN_MOVED_FROM);
3782
g_assert_cmpstr(ievent->name, ==, basename(tempfilename));
3783
3784
free(ievent);
3785
3786
g_assert_cmpint(unlink(targetfilename), ==, 0);
3787
g_assert_cmpint(rmdir(targetdir), ==, 0);
3788
g_assert_cmpint(rmdir(tempdir), ==, 0);
3789
}
3790
3791
static
3792
void test_add_inotify_dir_watch_IN_DELETE(__attribute__((unused))
3793
test_fixture *fixture,
3794
__attribute__((unused))
3795
gconstpointer user_data){
3796
__attribute__((cleanup(cleanup_close)))
3797
const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);
3798
g_assert_cmpint(epoll_fd, >=, 0);
3799
__attribute__((cleanup(cleanup_queue)))
3800
task_queue *queue = create_queue();
3801
g_assert_nonnull(queue);
3802
__attribute__((cleanup(string_set_clear)))
3803
string_set cancelled_filenames = {};
3804
const mono_microsecs current_time = 0;
3805
3806
bool quit_now = false;
3807
buffer password = {};
3808
bool mandos_client_exited = false;
3809
bool password_is_read = false;
3810
3811
__attribute__((cleanup(cleanup_string)))
3812
char *tempdir = make_temporary_directory();
3813
g_assert_nonnull(tempdir);
3814
3815
__attribute__((cleanup(cleanup_string)))
3816
char *tempfile = make_temporary_file_in_directory(tempdir);
3817
g_assert_nonnull(tempfile);
3818
3819
g_assert_true(add_inotify_dir_watch(queue, epoll_fd, &quit_now,
3820
&password, tempdir,
3821
&cancelled_filenames,
3822
¤t_time,
3823
&mandos_client_exited,
3824
&password_is_read));
3825
g_assert_cmpint(unlink(tempfile), ==, 0);
3826
3827
g_assert_cmpuint((unsigned int)queue->length, >, 0);
3828
3829
const task_context *const added_read_task
3830
= find_matching_task(queue,
3831
(task_context){ .func=read_inotify_event });
3832
g_assert_nonnull(added_read_task);
3833
3834
g_assert_cmpint(added_read_task->fd, >, 2);
3835
g_assert_true(fd_has_cloexec_and_nonblock(added_read_task->fd));
3836
3837
/* "sufficient to read at least one event." - inotify(7) */
3838
const size_t ievent_size = (sizeof(struct inotify_event)
3839
+ NAME_MAX + 1);
3840
struct inotify_event *ievent = malloc(ievent_size);
3841
g_assert_nonnull(ievent);
3842
3843
ssize_t read_size = 0;
3844
read_size = read(added_read_task->fd, ievent, ievent_size);
3845
3846
g_assert_cmpint((int)read_size, >, 0);
3847
g_assert_true(ievent->mask & IN_DELETE);
3848
g_assert_cmpstr(ievent->name, ==, basename(tempfile));
3849
3850
free(ievent);
3851
3852
g_assert_cmpint(rmdir(tempdir), ==, 0);
3853
}
3854
3855
static
3856
void test_add_inotify_dir_watch_IN_EXCL_UNLINK(__attribute__((unused))
3857
test_fixture *fixture,
3858
__attribute__((unused))
3859
gconstpointer
3860
user_data){
3861
__attribute__((cleanup(cleanup_close)))
3862
const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);
3863
g_assert_cmpint(epoll_fd, >=, 0);
3864
__attribute__((cleanup(cleanup_queue)))
3865
task_queue *queue = create_queue();
3866
g_assert_nonnull(queue);
3867
__attribute__((cleanup(string_set_clear)))
3868
string_set cancelled_filenames = {};
3869
const mono_microsecs current_time = 0;
3870
3871
bool quit_now = false;
3872
buffer password = {};
3873
bool mandos_client_exited = false;
3874
bool password_is_read = false;
3875
3876
__attribute__((cleanup(cleanup_string)))
3877
char *tempdir = make_temporary_directory();
3878
g_assert_nonnull(tempdir);
3879
3880
__attribute__((cleanup(cleanup_string)))
3881
char *tempfile = make_temporary_file_in_directory(tempdir);
3882
g_assert_nonnull(tempfile);
3883
int tempfile_fd = open(tempfile, O_WRONLY | O_CLOEXEC | O_NOCTTY
3884
| O_NOFOLLOW);
3885
g_assert_cmpint(tempfile_fd, >, 2);
3886
3887
g_assert_true(add_inotify_dir_watch(queue, epoll_fd, &quit_now,
3888
&password, tempdir,
3889
&cancelled_filenames,
3890
¤t_time,
3891
&mandos_client_exited,
3892
&password_is_read));
3893
g_assert_cmpint(unlink(tempfile), ==, 0);
3894
3895
g_assert_cmpuint((unsigned int)queue->length, >, 0);
3896
3897
const task_context *const added_read_task
3898
= find_matching_task(queue,
3899
(task_context){ .func=read_inotify_event });
3900
g_assert_nonnull(added_read_task);
3901
3902
g_assert_cmpint(added_read_task->fd, >, 2);
3903
g_assert_true(fd_has_cloexec_and_nonblock(added_read_task->fd));
3904
3905
/* "sufficient to read at least one event." - inotify(7) */
3906
const size_t ievent_size = (sizeof(struct inotify_event)
3907
+ NAME_MAX + 1);
3908
struct inotify_event *ievent = malloc(ievent_size);
3909
g_assert_nonnull(ievent);
3910
3911
ssize_t read_size = 0;
3912
read_size = read(added_read_task->fd, ievent, ievent_size);
3913
3914
g_assert_cmpint((int)read_size, >, 0);
3915
g_assert_true(ievent->mask & IN_DELETE);
3916
g_assert_cmpstr(ievent->name, ==, basename(tempfile));
3917
3918
g_assert_cmpint(close(tempfile_fd), ==, 0);
3919
3920
/* IN_EXCL_UNLINK should make the closing of the previously unlinked
3921
file not appear as an ievent, so we should not see it now. */
3922
read_size = read(added_read_task->fd, ievent, ievent_size);
3923
g_assert_cmpint((int)read_size, ==, -1);
3924
g_assert_true(errno == EAGAIN);
3925
3926
free(ievent);
3927
3928
g_assert_cmpint(rmdir(tempdir), ==, 0);
3929
}
3930
3931
static void test_read_inotify_event_readerror(__attribute__((unused))
3932
test_fixture *fixture,
3933
__attribute__((unused))
3934
gconstpointer
3935
user_data){
3936
__attribute__((cleanup(cleanup_close)))
3937
const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);
3938
g_assert_cmpint(epoll_fd, >=, 0);
3939
const mono_microsecs current_time = 0;
3940
3941
/* Reading /proc/self/mem from offset 0 will always result in EIO */
3942
const int fd = open("/proc/self/mem",
3943
O_RDONLY | O_CLOEXEC | O_NOCTTY);
3944
3945
bool quit_now = false;
3946
__attribute__((cleanup(cleanup_queue)))
3947
task_queue *queue = create_queue();
3948
g_assert_nonnull(queue);
3949
3950
task_context task = {
3951
.func=read_inotify_event,
3952
.epoll_fd=epoll_fd,
3953
.fd=fd,
3954
.quit_now=&quit_now,
3955
.filename=strdup("/nonexistent"),
3956
.cancelled_filenames = &(string_set){},
3957
.notafter=0,
3958
.current_time=¤t_time,
3959
};
3960
g_assert_nonnull(task.filename);
3961
run_task_with_stderr_to_dev_null(task, queue);
3962
g_assert_true(quit_now);
3963
g_assert_true(queue->next_run == 0);
3964
g_assert_cmpuint((unsigned int)queue->length, ==, 0);
3965
3966
g_assert_true(epoll_set_does_not_contain(epoll_fd, fd));
3967
3968
g_assert_cmpint(close(fd), ==, -1);
3969
}
3970
3971
static void test_read_inotify_event_bad_epoll(__attribute__((unused))
3972
test_fixture *fixture,
3973
__attribute__((unused))
3974
gconstpointer
3975
user_data){
3976
const mono_microsecs current_time = 17;
3977
3978
int pipefds[2];
3979
g_assert_cmpint(pipe2(pipefds, O_CLOEXEC | O_NONBLOCK), ==, 0);
3980
const int epoll_fd = pipefds[0]; /* This will obviously fail */
3981
3982
bool quit_now = false;
3983
buffer password = {};
3984
bool mandos_client_exited = false;
3985
bool password_is_read = false;
3986
__attribute__((cleanup(cleanup_queue)))
3987
task_queue *queue = create_queue();
3988
g_assert_nonnull(queue);
3989
3990
task_context task = {
3991
.func=read_inotify_event,
3992
.epoll_fd=epoll_fd,
3993
.fd=pipefds[0],
3994
.quit_now=&quit_now,
3995
.password=&password,
3996
.filename=strdup("/nonexistent"),
3997
.cancelled_filenames = &(string_set){},
3998
.notafter=0,
3999
.current_time=¤t_time,
4000
.mandos_client_exited=&mandos_client_exited,
4001
.password_is_read=&password_is_read,
4002
};
4003
g_assert_nonnull(task.filename);
4004
run_task_with_stderr_to_dev_null(task, queue);
4005
4006
g_assert_nonnull(find_matching_task(queue, task));
4007
g_assert_true(queue->next_run == 1000000 + current_time);
4008
4009
g_assert_cmpint(close(pipefds[0]), ==, 0);
4010
g_assert_cmpint(close(pipefds[1]), ==, 0);
4011
}
4012
4013
static void test_read_inotify_event_nodata(__attribute__((unused))
4014
test_fixture *fixture,
4015
__attribute__((unused))
4016
gconstpointer user_data){
4017
__attribute__((cleanup(cleanup_close)))
4018
const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);
4019
g_assert_cmpint(epoll_fd, >=, 0);
4020
const mono_microsecs current_time = 0;
4021
4022
int pipefds[2];
4023
g_assert_cmpint(pipe2(pipefds, O_CLOEXEC | O_NONBLOCK), ==, 0);
4024
4025
bool quit_now = false;
4026
buffer password = {};
4027
bool mandos_client_exited = false;
4028
bool password_is_read = false;
4029
__attribute__((cleanup(cleanup_queue)))
4030
task_queue *queue = create_queue();
4031
g_assert_nonnull(queue);
4032
4033
task_context task = {
4034
.func=read_inotify_event,
4035
.epoll_fd=epoll_fd,
4036
.fd=pipefds[0],
4037
.quit_now=&quit_now,
4038
.password=&password,
4039
.filename=strdup("/nonexistent"),
4040
.cancelled_filenames = &(string_set){},
4041
.notafter=0,
4042
.current_time=¤t_time,
4043
.mandos_client_exited=&mandos_client_exited,
4044
.password_is_read=&password_is_read,
4045
};
4046
g_assert_nonnull(task.filename);
4047
task.func(task, queue);
4048
g_assert_false(quit_now);
4049
g_assert_true(queue->next_run == 0);
4050
g_assert_cmpuint((unsigned int)queue->length, ==, 1);
4051
4052
g_assert_nonnull(find_matching_task(queue, (task_context){
4053
.func=read_inotify_event,
4054
.epoll_fd=epoll_fd,
4055
.fd=pipefds[0],
4056
.quit_now=&quit_now,
4057
.password=&password,
4058
.filename=task.filename,
4059
.cancelled_filenames=task.cancelled_filenames,
4060
.current_time=¤t_time,
4061
.mandos_client_exited=&mandos_client_exited,
4062
.password_is_read=&password_is_read,
4063
}));
4064
4065
g_assert_true(epoll_set_contains(epoll_fd, pipefds[0],
4066
EPOLLIN | EPOLLRDHUP));
4067
4068
g_assert_cmpint(close(pipefds[1]), ==, 0);
4069
}
4070
4071
static void test_read_inotify_event_eof(__attribute__((unused))
4072
test_fixture *fixture,
4073
__attribute__((unused))
4074
gconstpointer user_data){
4075
__attribute__((cleanup(cleanup_close)))
4076
const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);
4077
g_assert_cmpint(epoll_fd, >=, 0);
4078
const mono_microsecs current_time = 0;
4079
4080
int pipefds[2];
4081
g_assert_cmpint(pipe2(pipefds, O_CLOEXEC | O_NONBLOCK), ==, 0);
4082
g_assert_cmpint(close(pipefds[1]), ==, 0);
4083
4084
bool quit_now = false;
4085
buffer password = {};
4086
__attribute__((cleanup(cleanup_queue)))
4087
task_queue *queue = create_queue();
4088
g_assert_nonnull(queue);
4089
4090
task_context task = {
4091
.func=read_inotify_event,
4092
.epoll_fd=epoll_fd,
4093
.fd=pipefds[0],
4094
.quit_now=&quit_now,
4095
.password=&password,
4096
.filename=strdup("/nonexistent"),
4097
.cancelled_filenames = &(string_set){},
4098
.notafter=0,
4099
.current_time=¤t_time,
4100
};
4101
run_task_with_stderr_to_dev_null(task, queue);
4102
g_assert_true(quit_now);
4103
g_assert_true(queue->next_run == 0);
4104
g_assert_cmpuint((unsigned int)queue->length, ==, 0);
4105
4106
g_assert_true(epoll_set_does_not_contain(epoll_fd, pipefds[0]));
4107
4108
g_assert_cmpint(close(pipefds[0]), ==, -1);
4109
}
4110
4111
static
4112
void test_read_inotify_event_IN_CLOSE_WRITE(__attribute__((unused))
4113
test_fixture *fixture,
4114
__attribute__((unused))
4115
gconstpointer user_data){
4116
__attribute__((cleanup(cleanup_close)))
4117
const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);
4118
g_assert_cmpint(epoll_fd, >=, 0);
4119
const mono_microsecs current_time = 0;
4120
4121
int pipefds[2];
4122
g_assert_cmpint(pipe2(pipefds, O_CLOEXEC | O_NONBLOCK), ==, 0);
4123
4124
/* "sufficient to read at least one event." - inotify(7) */
4125
const size_t ievent_max_size = (sizeof(struct inotify_event)
4126
+ NAME_MAX + 1);
4127
g_assert_cmpint(ievent_max_size, <=, PIPE_BUF);
4128
struct {
4129
struct inotify_event event;
4130
char name_buffer[NAME_MAX + 1];
4131
} ievent_buffer;
4132
struct inotify_event *const ievent = &ievent_buffer.event;
4133
4134
const char dummy_file_name[] = "ask.dummy_file_name";
4135
ievent->mask = IN_CLOSE_WRITE;
4136
ievent->len = sizeof(dummy_file_name);
4137
memcpy(ievent->name, dummy_file_name, sizeof(dummy_file_name));
4138
const size_t ievent_size = (sizeof(struct inotify_event)
4139
+ sizeof(dummy_file_name));
4140
g_assert_cmpint(write(pipefds[1], (char *)ievent, ievent_size),
4141
==, ievent_size);
4142
g_assert_cmpint(close(pipefds[1]), ==, 0);
4143
4144
bool quit_now = false;
4145
buffer password = {};
4146
bool mandos_client_exited = false;
4147
bool password_is_read = false;
4148
__attribute__((cleanup(cleanup_queue)))
4149
task_queue *queue = create_queue();
4150
g_assert_nonnull(queue);
4151
4152
task_context task = {
4153
.func=read_inotify_event,
4154
.epoll_fd=epoll_fd,
4155
.fd=pipefds[0],
4156
.quit_now=&quit_now,
4157
.password=&password,
4158
.filename=strdup("/nonexistent"),
4159
.cancelled_filenames = &(string_set){},
4160
.notafter=0,
4161
.current_time=¤t_time,
4162
.mandos_client_exited=&mandos_client_exited,
4163
.password_is_read=&password_is_read,
4164
};
4165
task.func(task, queue);
4166
g_assert_false(quit_now);
4167
g_assert_true(queue->next_run != 0);
4168
g_assert_cmpuint((unsigned int)queue->length, >=, 1);
4169
4170
g_assert_nonnull(find_matching_task(queue, (task_context){
4171
.func=read_inotify_event,
4172
.epoll_fd=epoll_fd,
4173
.fd=pipefds[0],
4174
.quit_now=&quit_now,
4175
.password=&password,
4176
.filename=task.filename,
4177
.cancelled_filenames=task.cancelled_filenames,
4178
.current_time=¤t_time,
4179
.mandos_client_exited=&mandos_client_exited,
4180
.password_is_read=&password_is_read,
4181
}));
4182
4183
g_assert_true(epoll_set_contains(epoll_fd, pipefds[0],
4184
EPOLLIN | EPOLLRDHUP));
4185
4186
g_assert_cmpuint((unsigned int)queue->length, >=, 2);
4187
4188
__attribute__((cleanup(cleanup_string)))
4189
char *filename = NULL;
4190
g_assert_cmpint(asprintf(&filename, "%s/%s", task.filename,
4191
dummy_file_name), >, 0);
4192
g_assert_nonnull(filename);
4193
g_assert_nonnull(find_matching_task(queue, (task_context){
4194
.func=open_and_parse_question,
4195
.epoll_fd=epoll_fd,
4196
.filename=filename,
4197
.question_filename=filename,
4198
.password=&password,
4199
.cancelled_filenames=task.cancelled_filenames,
4200
.current_time=¤t_time,
4201
.mandos_client_exited=&mandos_client_exited,
4202
.password_is_read=&password_is_read,
4203
}));
4204
}
4205
4206
static
4207
void test_read_inotify_event_IN_MOVED_TO(__attribute__((unused))
4208
test_fixture *fixture,
4209
__attribute__((unused))
4210
gconstpointer user_data){
4211
__attribute__((cleanup(cleanup_close)))
4212
const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);
4213
g_assert_cmpint(epoll_fd, >=, 0);
4214
const mono_microsecs current_time = 0;
4215
4216
int pipefds[2];
4217
g_assert_cmpint(pipe2(pipefds, O_CLOEXEC | O_NONBLOCK), ==, 0);
4218
4219
/* "sufficient to read at least one event." - inotify(7) */
4220
const size_t ievent_max_size = (sizeof(struct inotify_event)
4221
+ NAME_MAX + 1);
4222
g_assert_cmpint(ievent_max_size, <=, PIPE_BUF);
4223
struct {
4224
struct inotify_event event;
4225
char name_buffer[NAME_MAX + 1];
4226
} ievent_buffer;
4227
struct inotify_event *const ievent = &ievent_buffer.event;
4228
4229
const char dummy_file_name[] = "ask.dummy_file_name";
4230
ievent->mask = IN_MOVED_TO;
4231
ievent->len = sizeof(dummy_file_name);
4232
memcpy(ievent->name, dummy_file_name, sizeof(dummy_file_name));
4233
const size_t ievent_size = (sizeof(struct inotify_event)
4234
+ sizeof(dummy_file_name));
4235
g_assert_cmpint(write(pipefds[1], (char *)ievent, ievent_size),
4236
==, ievent_size);
4237
g_assert_cmpint(close(pipefds[1]), ==, 0);
4238
4239
bool quit_now = false;
4240
buffer password = {};
4241
bool mandos_client_exited = false;
4242
bool password_is_read = false;
4243
__attribute__((cleanup(cleanup_queue)))
4244
task_queue *queue = create_queue();
4245
g_assert_nonnull(queue);
4246
4247
task_context task = {
4248
.func=read_inotify_event,
4249
.epoll_fd=epoll_fd,
4250
.fd=pipefds[0],
4251
.quit_now=&quit_now,
4252
.password=&password,
4253
.filename=strdup("/nonexistent"),
4254
.cancelled_filenames = &(string_set){},
4255
.notafter=0,
4256
.current_time=¤t_time,
4257
.mandos_client_exited=&mandos_client_exited,
4258
.password_is_read=&password_is_read,
4259
};
4260
task.func(task, queue);
4261
g_assert_false(quit_now);
4262
g_assert_true(queue->next_run != 0);
4263
g_assert_cmpuint((unsigned int)queue->length, >=, 1);
4264
4265
g_assert_nonnull(find_matching_task(queue, (task_context){
4266
.func=read_inotify_event,
4267
.epoll_fd=epoll_fd,
4268
.fd=pipefds[0],
4269
.quit_now=&quit_now,
4270
.password=&password,
4271
.filename=task.filename,
4272
.cancelled_filenames=task.cancelled_filenames,
4273
.current_time=¤t_time,
4274
.mandos_client_exited=&mandos_client_exited,
4275
.password_is_read=&password_is_read,
4276
}));
4277
4278
g_assert_true(epoll_set_contains(epoll_fd, pipefds[0],
4279
EPOLLIN | EPOLLRDHUP));
4280
4281
g_assert_cmpuint((unsigned int)queue->length, >=, 2);
4282
4283
__attribute__((cleanup(cleanup_string)))
4284
char *filename = NULL;
4285
g_assert_cmpint(asprintf(&filename, "%s/%s", task.filename,
4286
dummy_file_name), >, 0);
4287
g_assert_nonnull(filename);
4288
g_assert_nonnull(find_matching_task(queue, (task_context){
4289
.func=open_and_parse_question,
4290
.epoll_fd=epoll_fd,
4291
.filename=filename,
4292
.question_filename=filename,
4293
.password=&password,
4294
.cancelled_filenames=task.cancelled_filenames,
4295
.current_time=¤t_time,
4296
.mandos_client_exited=&mandos_client_exited,
4297
.password_is_read=&password_is_read,
4298
}));
4299
}
4300
4301
static
4302
void test_read_inotify_event_IN_MOVED_FROM(__attribute__((unused))
4303
test_fixture *fixture,
4304
__attribute__((unused))
4305
gconstpointer user_data){
4306
__attribute__((cleanup(cleanup_close)))
4307
const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);
4308
g_assert_cmpint(epoll_fd, >=, 0);
4309
__attribute__((cleanup(string_set_clear)))
4310
string_set cancelled_filenames = {};
4311
const mono_microsecs current_time = 0;
4312
4313
int pipefds[2];
4314
g_assert_cmpint(pipe2(pipefds, O_CLOEXEC | O_NONBLOCK), ==, 0);
4315
4316
/* "sufficient to read at least one event." - inotify(7) */
4317
const size_t ievent_max_size = (sizeof(struct inotify_event)
4318
+ NAME_MAX + 1);
4319
g_assert_cmpint(ievent_max_size, <=, PIPE_BUF);
4320
struct {
4321
struct inotify_event event;
4322
char name_buffer[NAME_MAX + 1];
4323
} ievent_buffer;
4324
struct inotify_event *const ievent = &ievent_buffer.event;
4325
4326
const char dummy_file_name[] = "ask.dummy_file_name";
4327
ievent->mask = IN_MOVED_FROM;
4328
ievent->len = sizeof(dummy_file_name);
4329
memcpy(ievent->name, dummy_file_name, sizeof(dummy_file_name));
4330
const size_t ievent_size = (sizeof(struct inotify_event)
4331
+ sizeof(dummy_file_name));
4332
g_assert_cmpint(write(pipefds[1], (char *)ievent, ievent_size),
4333
==, ievent_size);
4334
g_assert_cmpint(close(pipefds[1]), ==, 0);
4335
4336
bool quit_now = false;
4337
buffer password = {};
4338
bool mandos_client_exited = false;
4339
bool password_is_read = false;
4340
__attribute__((cleanup(cleanup_queue)))
4341
task_queue *queue = create_queue();
4342
g_assert_nonnull(queue);
4343
4344
task_context task = {
4345
.func=read_inotify_event,
4346
.epoll_fd=epoll_fd,
4347
.fd=pipefds[0],
4348
.quit_now=&quit_now,
4349
.password=&password,
4350
.filename=strdup("/nonexistent"),
4351
.cancelled_filenames=&cancelled_filenames,
4352
.current_time=¤t_time,
4353
.mandos_client_exited=&mandos_client_exited,
4354
.password_is_read=&password_is_read,
4355
};
4356
task.func(task, queue);
4357
g_assert_false(quit_now);
4358
g_assert_true(queue->next_run == 0);
4359
g_assert_cmpuint((unsigned int)queue->length, ==, 1);
4360
4361
g_assert_nonnull(find_matching_task(queue, (task_context){
4362
.func=read_inotify_event,
4363
.epoll_fd=epoll_fd,
4364
.fd=pipefds[0],
4365
.quit_now=&quit_now,
4366
.password=&password,
4367
.filename=task.filename,
4368
.cancelled_filenames=&cancelled_filenames,
4369
.current_time=¤t_time,
4370
.mandos_client_exited=&mandos_client_exited,
4371
.password_is_read=&password_is_read,
4372
}));
4373
4374
g_assert_true(epoll_set_contains(epoll_fd, pipefds[0],
4375
EPOLLIN | EPOLLRDHUP));
4376
4377
__attribute__((cleanup(cleanup_string)))
4378
char *filename = NULL;
4379
g_assert_cmpint(asprintf(&filename, "%s/%s", task.filename,
4380
dummy_file_name), >, 0);
4381
g_assert_nonnull(filename);
4382
g_assert_true(string_set_contains(*task.cancelled_filenames,
4383
filename));
4384
}
4385
4386
static void test_read_inotify_event_IN_DELETE(__attribute__((unused))
4387
test_fixture *fixture,
4388
__attribute__((unused))
4389
gconstpointer
4390
user_data){
4391
__attribute__((cleanup(cleanup_close)))
4392
const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);
4393
g_assert_cmpint(epoll_fd, >=, 0);
4394
__attribute__((cleanup(string_set_clear)))
4395
string_set cancelled_filenames = {};
4396
const mono_microsecs current_time = 0;
4397
4398
int pipefds[2];
4399
g_assert_cmpint(pipe2(pipefds, O_CLOEXEC | O_NONBLOCK), ==, 0);
4400
4401
/* "sufficient to read at least one event." - inotify(7) */
4402
const size_t ievent_max_size = (sizeof(struct inotify_event)
4403
+ NAME_MAX + 1);
4404
g_assert_cmpint(ievent_max_size, <=, PIPE_BUF);
4405
struct {
4406
struct inotify_event event;
4407
char name_buffer[NAME_MAX + 1];
4408
} ievent_buffer;
4409
struct inotify_event *const ievent = &ievent_buffer.event;
4410
4411
const char dummy_file_name[] = "ask.dummy_file_name";
4412
ievent->mask = IN_DELETE;
4413
ievent->len = sizeof(dummy_file_name);
4414
memcpy(ievent->name, dummy_file_name, sizeof(dummy_file_name));
4415
const size_t ievent_size = (sizeof(struct inotify_event)
4416
+ sizeof(dummy_file_name));
4417
g_assert_cmpint(write(pipefds[1], (char *)ievent, ievent_size),
4418
==, ievent_size);
4419
g_assert_cmpint(close(pipefds[1]), ==, 0);
4420
4421
bool quit_now = false;
4422
buffer password = {};
4423
bool mandos_client_exited = false;
4424
bool password_is_read = false;
4425
__attribute__((cleanup(cleanup_queue)))
4426
task_queue *queue = create_queue();
4427
g_assert_nonnull(queue);
4428
4429
task_context task = {
4430
.func=read_inotify_event,
4431
.epoll_fd=epoll_fd,
4432
.fd=pipefds[0],
4433
.quit_now=&quit_now,
4434
.password=&password,
4435
.filename=strdup("/nonexistent"),
4436
.cancelled_filenames=&cancelled_filenames,
4437
.current_time=¤t_time,
4438
.mandos_client_exited=&mandos_client_exited,
4439
.password_is_read=&password_is_read,
4440
};
4441
task.func(task, queue);
4442
g_assert_false(quit_now);
4443
g_assert_true(queue->next_run == 0);
4444
g_assert_cmpuint((unsigned int)queue->length, ==, 1);
4445
4446
g_assert_nonnull(find_matching_task(queue, (task_context){
4447
.func=read_inotify_event,
4448
.epoll_fd=epoll_fd,
4449
.fd=pipefds[0],
4450
.quit_now=&quit_now,
4451
.password=&password,
4452
.filename=task.filename,
4453
.cancelled_filenames=&cancelled_filenames,
4454
.current_time=¤t_time,
4455
.mandos_client_exited=&mandos_client_exited,
4456
.password_is_read=&password_is_read,
4457
}));
4458
4459
g_assert_true(epoll_set_contains(epoll_fd, pipefds[0],
4460
EPOLLIN | EPOLLRDHUP));
4461
4462
__attribute__((cleanup(cleanup_string)))
4463
char *filename = NULL;
4464
g_assert_cmpint(asprintf(&filename, "%s/%s", task.filename,
4465
dummy_file_name), >, 0);
4466
g_assert_nonnull(filename);
4467
g_assert_true(string_set_contains(*task.cancelled_filenames,
4468
filename));
4469
}
4470
4471
static void
4472
test_read_inotify_event_IN_CLOSE_WRITE_badname(__attribute__((unused))
4473
test_fixture *fixture,
4474
__attribute__((unused))
4475
gconstpointer
4476
user_data){
4477
__attribute__((cleanup(cleanup_close)))
4478
const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);
4479
g_assert_cmpint(epoll_fd, >=, 0);
4480
const mono_microsecs current_time = 0;
4481
4482
int pipefds[2];
4483
g_assert_cmpint(pipe2(pipefds, O_CLOEXEC | O_NONBLOCK), ==, 0);
4484
4485
/* "sufficient to read at least one event." - inotify(7) */
4486
const size_t ievent_max_size = (sizeof(struct inotify_event)
4487
+ NAME_MAX + 1);
4488
g_assert_cmpint(ievent_max_size, <=, PIPE_BUF);
4489
struct {
4490
struct inotify_event event;
4491
char name_buffer[NAME_MAX + 1];
4492
} ievent_buffer;
4493
struct inotify_event *const ievent = &ievent_buffer.event;
4494
4495
const char dummy_file_name[] = "ignored.dummy_file_name";
4496
ievent->mask = IN_CLOSE_WRITE;
4497
ievent->len = sizeof(dummy_file_name);
4498
memcpy(ievent->name, dummy_file_name, sizeof(dummy_file_name));
4499
const size_t ievent_size = (sizeof(struct inotify_event)
4500
+ sizeof(dummy_file_name));
4501
g_assert_cmpint(write(pipefds[1], (char *)ievent, ievent_size),
4502
==, ievent_size);
4503
g_assert_cmpint(close(pipefds[1]), ==, 0);
4504
4505
bool quit_now = false;
4506
buffer password = {};
4507
bool mandos_client_exited = false;
4508
bool password_is_read = false;
4509
__attribute__((cleanup(cleanup_queue)))
4510
task_queue *queue = create_queue();
4511
g_assert_nonnull(queue);
4512
4513
task_context task = {
4514
.func=read_inotify_event,
4515
.epoll_fd=epoll_fd,
4516
.fd=pipefds[0],
4517
.quit_now=&quit_now,
4518
.password=&password,
4519
.filename=strdup("/nonexistent"),
4520
.cancelled_filenames = &(string_set){},
4521
.notafter=0,
4522
.current_time=¤t_time,
4523
.mandos_client_exited=&mandos_client_exited,
4524
.password_is_read=&password_is_read,
4525
};
4526
task.func(task, queue);
4527
g_assert_false(quit_now);
4528
g_assert_true(queue->next_run == 0);
4529
g_assert_cmpuint((unsigned int)queue->length, ==, 1);
4530
4531
g_assert_nonnull(find_matching_task(queue, (task_context){
4532
.func=read_inotify_event,
4533
.epoll_fd=epoll_fd,
4534
.fd=pipefds[0],
4535
.quit_now=&quit_now,
4536
.password=&password,
4537
.filename=task.filename,
4538
.cancelled_filenames=task.cancelled_filenames,
4539
.current_time=¤t_time,
4540
.mandos_client_exited=&mandos_client_exited,
4541
.password_is_read=&password_is_read,
4542
}));
4543
4544
g_assert_true(epoll_set_contains(epoll_fd, pipefds[0],
4545
EPOLLIN | EPOLLRDHUP));
4546
}
4547
4548
static void
4549
test_read_inotify_event_IN_MOVED_TO_badname(__attribute__((unused))
4550
test_fixture *fixture,
4551
__attribute__((unused))
4552
gconstpointer user_data){
4553
__attribute__((cleanup(cleanup_close)))
4554
const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);
4555
g_assert_cmpint(epoll_fd, >=, 0);
4556
const mono_microsecs current_time = 0;
4557
4558
int pipefds[2];
4559
g_assert_cmpint(pipe2(pipefds, O_CLOEXEC | O_NONBLOCK), ==, 0);
4560
4561
/* "sufficient to read at least one event." - inotify(7) */
4562
const size_t ievent_max_size = (sizeof(struct inotify_event)
4563
+ NAME_MAX + 1);
4564
g_assert_cmpint(ievent_max_size, <=, PIPE_BUF);
4565
struct {
4566
struct inotify_event event;
4567
char name_buffer[NAME_MAX + 1];
4568
} ievent_buffer;
4569
struct inotify_event *const ievent = &ievent_buffer.event;
4570
4571
const char dummy_file_name[] = "ignored.dummy_file_name";
4572
ievent->mask = IN_MOVED_TO;
4573
ievent->len = sizeof(dummy_file_name);
4574
memcpy(ievent->name, dummy_file_name, sizeof(dummy_file_name));
4575
const size_t ievent_size = (sizeof(struct inotify_event)
4576
+ sizeof(dummy_file_name));
4577
g_assert_cmpint(write(pipefds[1], (char *)ievent, ievent_size),
4578
==, ievent_size);
4579
g_assert_cmpint(close(pipefds[1]), ==, 0);
4580
4581
bool quit_now = false;
4582
buffer password = {};
4583
bool mandos_client_exited = false;
4584
bool password_is_read = false;
4585
__attribute__((cleanup(cleanup_queue)))
4586
task_queue *queue = create_queue();
4587
g_assert_nonnull(queue);
4588
4589
task_context task = {
4590
.func=read_inotify_event,
4591
.epoll_fd=epoll_fd,
4592
.fd=pipefds[0],
4593
.quit_now=&quit_now,
4594
.password=&password,
4595
.filename=strdup("/nonexistent"),
4596
.cancelled_filenames = &(string_set){},
4597
.notafter=0,
4598
.current_time=¤t_time,
4599
.mandos_client_exited=&mandos_client_exited,
4600
.password_is_read=&password_is_read,
4601
};
4602
task.func(task, queue);
4603
g_assert_false(quit_now);
4604
g_assert_true(queue->next_run == 0);
4605
g_assert_cmpuint((unsigned int)queue->length, ==, 1);
4606
4607
g_assert_nonnull(find_matching_task(queue, (task_context){
4608
.func=read_inotify_event,
4609
.epoll_fd=epoll_fd,
4610
.fd=pipefds[0],
4611
.quit_now=&quit_now,
4612
.password=&password,
4613
.filename=task.filename,
4614
.cancelled_filenames=task.cancelled_filenames,
4615
.current_time=¤t_time,
4616
.mandos_client_exited=&mandos_client_exited,
4617
.password_is_read=&password_is_read,
4618
}));
4619
4620
g_assert_true(epoll_set_contains(epoll_fd, pipefds[0],
4621
EPOLLIN | EPOLLRDHUP));
4622
}
4623
4624
static void
4625
test_read_inotify_event_IN_MOVED_FROM_badname(__attribute__((unused))
4626
test_fixture *fixture,
4627
__attribute__((unused))
4628
gconstpointer
4629
user_data){
4630
__attribute__((cleanup(cleanup_close)))
4631
const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);
4632
g_assert_cmpint(epoll_fd, >=, 0);
4633
__attribute__((cleanup(string_set_clear)))
4634
string_set cancelled_filenames = {};
4635
const mono_microsecs current_time = 0;
4636
4637
int pipefds[2];
4638
g_assert_cmpint(pipe2(pipefds, O_CLOEXEC | O_NONBLOCK), ==, 0);
4639
4640
/* "sufficient to read at least one event." - inotify(7) */
4641
const size_t ievent_max_size = (sizeof(struct inotify_event)
4642
+ NAME_MAX + 1);
4643
g_assert_cmpint(ievent_max_size, <=, PIPE_BUF);
4644
struct {
4645
struct inotify_event event;
4646
char name_buffer[NAME_MAX + 1];
4647
} ievent_buffer;
4648
struct inotify_event *const ievent = &ievent_buffer.event;
4649
4650
const char dummy_file_name[] = "ignored.dummy_file_name";
4651
ievent->mask = IN_MOVED_FROM;
4652
ievent->len = sizeof(dummy_file_name);
4653
memcpy(ievent->name, dummy_file_name, sizeof(dummy_file_name));
4654
const size_t ievent_size = (sizeof(struct inotify_event)
4655
+ sizeof(dummy_file_name));
4656
g_assert_cmpint(write(pipefds[1], (char *)ievent, ievent_size),
4657
==, ievent_size);
4658
g_assert_cmpint(close(pipefds[1]), ==, 0);
4659
4660
bool quit_now = false;
4661
buffer password = {};
4662
bool mandos_client_exited = false;
4663
bool password_is_read = false;
4664
__attribute__((cleanup(cleanup_queue)))
4665
task_queue *queue = create_queue();
4666
g_assert_nonnull(queue);
4667
4668
task_context task = {
4669
.func=read_inotify_event,
4670
.epoll_fd=epoll_fd,
4671
.fd=pipefds[0],
4672
.quit_now=&quit_now,
4673
.password=&password,
4674
.filename=strdup("/nonexistent"),
4675
.cancelled_filenames=&cancelled_filenames,
4676
.current_time=¤t_time,
4677
.mandos_client_exited=&mandos_client_exited,
4678
.password_is_read=&password_is_read,
4679
};
4680
task.func(task, queue);
4681
g_assert_false(quit_now);
4682
g_assert_true(queue->next_run == 0);
4683
g_assert_cmpuint((unsigned int)queue->length, ==, 1);
4684
4685
g_assert_nonnull(find_matching_task(queue, (task_context){
4686
.func=read_inotify_event,
4687
.epoll_fd=epoll_fd,
4688
.fd=pipefds[0],
4689
.quit_now=&quit_now,
4690
.password=&password,
4691
.filename=task.filename,
4692
.cancelled_filenames=&cancelled_filenames,
4693
.current_time=¤t_time,
4694
.mandos_client_exited=&mandos_client_exited,
4695
.password_is_read=&password_is_read,
4696
}));
4697
4698
g_assert_true(epoll_set_contains(epoll_fd, pipefds[0],
4699
EPOLLIN | EPOLLRDHUP));
4700
4701
__attribute__((cleanup(cleanup_string)))
4702
char *filename = NULL;
4703
g_assert_cmpint(asprintf(&filename, "%s/%s", task.filename,
4704
dummy_file_name), >, 0);
4705
g_assert_nonnull(filename);
4706
g_assert_false(string_set_contains(cancelled_filenames, filename));
4707
}
4708
4709
static
4710
void test_read_inotify_event_IN_DELETE_badname(__attribute__((unused))
4711
test_fixture *fixture,
4712
__attribute__((unused))
4713
gconstpointer
4714
user_data){
4715
__attribute__((cleanup(cleanup_close)))
4716
const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);
4717
g_assert_cmpint(epoll_fd, >=, 0);
4718
__attribute__((cleanup(string_set_clear)))
4719
string_set cancelled_filenames = {};
4720
const mono_microsecs current_time = 0;
4721
4722
int pipefds[2];
4723
g_assert_cmpint(pipe2(pipefds, O_CLOEXEC | O_NONBLOCK), ==, 0);
4724
4725
/* "sufficient to read at least one event." - inotify(7) */
4726
const size_t ievent_max_size = (sizeof(struct inotify_event)
4727
+ NAME_MAX + 1);
4728
g_assert_cmpint(ievent_max_size, <=, PIPE_BUF);
4729
struct {
4730
struct inotify_event event;
4731
char name_buffer[NAME_MAX + 1];
4732
} ievent_buffer;
4733
struct inotify_event *const ievent = &ievent_buffer.event;
4734
4735
const char dummy_file_name[] = "ignored.dummy_file_name";
4736
ievent->mask = IN_DELETE;
4737
ievent->len = sizeof(dummy_file_name);
4738
memcpy(ievent->name, dummy_file_name, sizeof(dummy_file_name));
4739
const size_t ievent_size = (sizeof(struct inotify_event)
4740
+ sizeof(dummy_file_name));
4741
g_assert_cmpint(write(pipefds[1], (char *)ievent, ievent_size),
4742
==, ievent_size);
4743
g_assert_cmpint(close(pipefds[1]), ==, 0);
4744
4745
bool quit_now = false;
4746
buffer password = {};
4747
bool mandos_client_exited = false;
4748
bool password_is_read = false;
4749
__attribute__((cleanup(cleanup_queue)))
4750
task_queue *queue = create_queue();
4751
g_assert_nonnull(queue);
4752
4753
task_context task = {
4754
.func=read_inotify_event,
4755
.epoll_fd=epoll_fd,
4756
.fd=pipefds[0],
4757
.quit_now=&quit_now,
4758
.password=&password,
4759
.filename=strdup("/nonexistent"),
4760
.cancelled_filenames=&cancelled_filenames,
4761
.current_time=¤t_time,
4762
.mandos_client_exited=&mandos_client_exited,
4763
.password_is_read=&password_is_read,
4764
};
4765
task.func(task, queue);
4766
g_assert_false(quit_now);
4767
g_assert_true(queue->next_run == 0);
4768
g_assert_cmpuint((unsigned int)queue->length, ==, 1);
4769
4770
g_assert_nonnull(find_matching_task(queue, (task_context){
4771
.func=read_inotify_event,
4772
.epoll_fd=epoll_fd,
4773
.fd=pipefds[0],
4774
.quit_now=&quit_now,
4775
.password=&password,
4776
.filename=task.filename,
4777
.cancelled_filenames=&cancelled_filenames,
4778
.current_time=¤t_time,
4779
.mandos_client_exited=&mandos_client_exited,
4780
.password_is_read=&password_is_read,
4781
}));
4782
4783
g_assert_true(epoll_set_contains(epoll_fd, pipefds[0],
4784
EPOLLIN | EPOLLRDHUP));
4785
4786
__attribute__((cleanup(cleanup_string)))
4787
char *filename = NULL;
4788
g_assert_cmpint(asprintf(&filename, "%s/%s", task.filename,
4789
dummy_file_name), >, 0);
4790
g_assert_nonnull(filename);
4791
g_assert_false(string_set_contains(cancelled_filenames, filename));
4792
}
4793
4794
static
4795
void test_open_and_parse_question_ENOENT(__attribute__((unused))
4796
test_fixture *fixture,
4797
__attribute__((unused))
4798
gconstpointer user_data){
4799
__attribute__((cleanup(cleanup_close)))
4800
const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);
4801
g_assert_cmpint(epoll_fd, >=, 0);
4802
__attribute__((cleanup(string_set_clear)))
4803
string_set cancelled_filenames = {};
4804
bool mandos_client_exited = false;
4805
bool password_is_read = false;
4806
__attribute__((cleanup(cleanup_queue)))
4807
task_queue *queue = create_queue();
4808
g_assert_nonnull(queue);
4809
4810
char *const filename = strdup("/nonexistent");
4811
g_assert_nonnull(filename);
4812
task_context task = {
4813
.func=open_and_parse_question,
4814
.question_filename=filename,
4815
.epoll_fd=epoll_fd,
4816
.password=(buffer[]){{}},
4817
.filename=filename,
4818
.cancelled_filenames=&cancelled_filenames,
4819
.current_time=(mono_microsecs[]){0},
4820
.mandos_client_exited=&mandos_client_exited,
4821
.password_is_read=&password_is_read,
4822
};
4823
task.func(task, queue);
4824
g_assert_cmpuint((unsigned int)queue->length, ==, 0);
4825
}
4826
4827
static void test_open_and_parse_question_EIO(__attribute__((unused))
4828
test_fixture *fixture,
4829
__attribute__((unused))
4830
gconstpointer user_data){
4831
__attribute__((cleanup(cleanup_close)))
4832
const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);
4833
g_assert_cmpint(epoll_fd, >=, 0);
4834
__attribute__((cleanup(string_set_clear)))
4835
string_set cancelled_filenames = {};
4836
buffer password = {};
4837
bool mandos_client_exited = false;
4838
bool password_is_read = false;
4839
__attribute__((cleanup(cleanup_queue)))
4840
task_queue *queue = create_queue();
4841
g_assert_nonnull(queue);
4842
const mono_microsecs current_time = 0;
4843
4844
char *filename = strdup("/proc/self/mem");
4845
task_context task = {
4846
.func=open_and_parse_question,
4847
.question_filename=filename,
4848
.epoll_fd=epoll_fd,
4849
.password=&password,
4850
.filename=filename,
4851
.cancelled_filenames=&cancelled_filenames,
4852
.current_time=¤t_time,
4853
.mandos_client_exited=&mandos_client_exited,
4854
.password_is_read=&password_is_read,
4855
};
4856
run_task_with_stderr_to_dev_null(task, queue);
4857
g_assert_cmpuint((unsigned int)queue->length, ==, 0);
4858
}
4859
4860
static void
4861
test_open_and_parse_question_parse_error(__attribute__((unused))
4862
test_fixture *fixture,
4863
__attribute__((unused))
4864
gconstpointer user_data){
4865
__attribute__((cleanup(cleanup_close)))
4866
const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);
4867
g_assert_cmpint(epoll_fd, >=, 0);
4868
__attribute__((cleanup(string_set_clear)))
4869
string_set cancelled_filenames = {};
4870
__attribute__((cleanup(cleanup_queue)))
4871
task_queue *queue = create_queue();
4872
g_assert_nonnull(queue);
4873
4874
__attribute__((cleanup(cleanup_string)))
4875
char *tempfilename = strdup("/tmp/mandosXXXXXX");
4876
g_assert_nonnull(tempfilename);
4877
int tempfile = mkostemp(tempfilename, O_CLOEXEC);
4878
g_assert_cmpint(tempfile, >, 0);
4879
const char bad_data[] = "this is bad syntax\n";
4880
g_assert_cmpint(write(tempfile, bad_data, sizeof(bad_data)),
4881
==, sizeof(bad_data));
4882
g_assert_cmpint(close(tempfile), ==, 0);
4883
4884
char *const filename = strdup(tempfilename);
4885
g_assert_nonnull(filename);
4886
task_context task = {
4887
.func=open_and_parse_question,
4888
.question_filename=filename,
4889
.epoll_fd=epoll_fd,
4890
.password=(buffer[]){{}},
4891
.filename=filename,
4892
.cancelled_filenames=&cancelled_filenames,
4893
.current_time=(mono_microsecs[]){0},
4894
.mandos_client_exited=(bool[]){false},
4895
.password_is_read=(bool[]){false},
4896
};
4897
run_task_with_stderr_to_dev_null(task, queue);
4898
4899
g_assert_cmpuint((unsigned int)queue->length, ==, 0);
4900
4901
g_assert_cmpint(unlink(tempfilename), ==, 0);
4902
}
4903
4904
static
4905
void test_open_and_parse_question_nosocket(__attribute__((unused))
4906
test_fixture *fixture,
4907
__attribute__((unused))
4908
gconstpointer user_data){
4909
__attribute__((cleanup(cleanup_close)))
4910
const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);
4911
g_assert_cmpint(epoll_fd, >=, 0);
4912
__attribute__((cleanup(string_set_clear)))
4913
string_set cancelled_filenames = {};
4914
__attribute__((cleanup(cleanup_queue)))
4915
task_queue *queue = create_queue();
4916
g_assert_nonnull(queue);
4917
4918
__attribute__((cleanup(cleanup_string)))
4919
char *tempfilename = strdup("/tmp/mandosXXXXXX");
4920
g_assert_nonnull(tempfilename);
4921
int questionfile = mkostemp(tempfilename, O_CLOEXEC);
4922
g_assert_cmpint(questionfile, >, 0);
4923
FILE *qf = fdopen(questionfile, "w");
4924
g_assert_cmpint(fprintf(qf, "[Ask]\nPID=1\n"), >, 0);
4925
g_assert_cmpint(fclose(qf), ==, 0);
4926
4927
char *const filename = strdup(tempfilename);
4928
g_assert_nonnull(filename);
4929
task_context task = {
4930
.func=open_and_parse_question,
4931
.question_filename=filename,
4932
.epoll_fd=epoll_fd,
4933
.password=(buffer[]){{}},
4934
.filename=filename,
4935
.cancelled_filenames=&cancelled_filenames,
4936
.current_time=(mono_microsecs[]){0},
4937
.mandos_client_exited=(bool[]){false},
4938
.password_is_read=(bool[]){false},
4939
};
4940
run_task_with_stderr_to_dev_null(task, queue);
4941
g_assert_cmpuint((unsigned int)queue->length, ==, 0);
4942
4943
g_assert_cmpint(unlink(tempfilename), ==, 0);
4944
}
4945
4946
static
4947
void test_open_and_parse_question_badsocket(__attribute__((unused))
4948
test_fixture *fixture,
4949
__attribute__((unused))
4950
gconstpointer user_data){
4951
__attribute__((cleanup(cleanup_close)))
4952
const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);
4953
g_assert_cmpint(epoll_fd, >=, 0);
4954
__attribute__((cleanup(string_set_clear)))
4955
string_set cancelled_filenames = {};
4956
__attribute__((cleanup(cleanup_queue)))
4957
task_queue *queue = create_queue();
4958
g_assert_nonnull(queue);
4959
4960
__attribute__((cleanup(cleanup_string)))
4961
char *tempfilename = strdup("/tmp/mandosXXXXXX");
4962
g_assert_nonnull(tempfilename);
4963
int questionfile = mkostemp(tempfilename, O_CLOEXEC);
4964
g_assert_cmpint(questionfile, >, 0);
4965
FILE *qf = fdopen(questionfile, "w");
4966
g_assert_cmpint(fprintf(qf, "[Ask]\nSocket=\nPID=1\n"), >, 0);
4967
g_assert_cmpint(fclose(qf), ==, 0);
4968
4969
char *const filename = strdup(tempfilename);
4970
g_assert_nonnull(filename);
4971
task_context task = {
4972
.func=open_and_parse_question,
4973
.question_filename=filename,
4974
.epoll_fd=epoll_fd,
4975
.password=(buffer[]){{}},
4976
.filename=filename,
4977
.cancelled_filenames=&cancelled_filenames,
4978
.current_time=(mono_microsecs[]){0},
4979
.mandos_client_exited=(bool[]){false},
4980
.password_is_read=(bool[]){false},
4981
};
4982
run_task_with_stderr_to_dev_null(task, queue);
4983
g_assert_cmpuint((unsigned int)queue->length, ==, 0);
4984
4985
g_assert_cmpint(unlink(tempfilename), ==, 0);
4986
}
4987
4988
static
4989
void test_open_and_parse_question_nopid(__attribute__((unused))
4990
test_fixture *fixture,
4991
__attribute__((unused))
4992
gconstpointer user_data){
4993
__attribute__((cleanup(cleanup_close)))
4994
const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);
4995
g_assert_cmpint(epoll_fd, >=, 0);
4996
__attribute__((cleanup(string_set_clear)))
4997
string_set cancelled_filenames = {};
4998
__attribute__((cleanup(cleanup_queue)))
4999
task_queue *queue = create_queue();
5000
g_assert_nonnull(queue);
5001
5002
__attribute__((cleanup(cleanup_string)))
5003
char *tempfilename = strdup("/tmp/mandosXXXXXX");
5004
g_assert_nonnull(tempfilename);
5005
int questionfile = mkostemp(tempfilename, O_CLOEXEC);
5006
g_assert_cmpint(questionfile, >, 0);
5007
FILE *qf = fdopen(questionfile, "w");
5008
g_assert_cmpint(fprintf(qf, "[Ask]\nSocket=/nonexistent\n"), >, 0);
5009
g_assert_cmpint(fclose(qf), ==, 0);
5010
5011
char *const filename = strdup(tempfilename);
5012
g_assert_nonnull(filename);
5013
task_context task = {
5014
.func=open_and_parse_question,
5015
.question_filename=filename,
5016
.epoll_fd=epoll_fd,
5017
.password=(buffer[]){{}},
5018
.filename=filename,
5019
.cancelled_filenames=&cancelled_filenames,
5020
.current_time=(mono_microsecs[]){0},
5021
.mandos_client_exited=(bool[]){false},
5022
.password_is_read=(bool[]){false},
5023
};
5024
run_task_with_stderr_to_dev_null(task, queue);
5025
g_assert_cmpuint((unsigned int)queue->length, ==, 0);
5026
5027
g_assert_cmpint(unlink(tempfilename), ==, 0);
5028
}
5029
5030
static
5031
void test_open_and_parse_question_badpid(__attribute__((unused))
5032
test_fixture *fixture,
5033
__attribute__((unused))
5034
gconstpointer user_data){
5035
__attribute__((cleanup(cleanup_close)))
5036
const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);
5037
g_assert_cmpint(epoll_fd, >=, 0);
5038
__attribute__((cleanup(string_set_clear)))
5039
string_set cancelled_filenames = {};
5040
__attribute__((cleanup(cleanup_queue)))
5041
task_queue *queue = create_queue();
5042
g_assert_nonnull(queue);
5043
5044
__attribute__((cleanup(cleanup_string)))
5045
char *tempfilename = strdup("/tmp/mandosXXXXXX");
5046
g_assert_nonnull(tempfilename);
5047
int questionfile = mkostemp(tempfilename, O_CLOEXEC);
5048
g_assert_cmpint(questionfile, >, 0);
5049
FILE *qf = fdopen(questionfile, "w");
5050
g_assert_cmpint(fprintf(qf, "[Ask]\nSocket=/nonexistent\nPID=\n"),
5051
>, 0);
5052
g_assert_cmpint(fclose(qf), ==, 0);
5053
5054
char *const filename = strdup(tempfilename);
5055
g_assert_nonnull(filename);
5056
task_context task = {
5057
.func=open_and_parse_question,
5058
.question_filename=filename,
5059
.epoll_fd=epoll_fd,
5060
.password=(buffer[]){{}},
5061
.filename=filename,
5062
.cancelled_filenames=&cancelled_filenames,
5063
.current_time=(mono_microsecs[]){0},
5064
.mandos_client_exited=(bool[]){false},
5065
.password_is_read=(bool[]){false},
5066
};
5067
run_task_with_stderr_to_dev_null(task, queue);
5068
g_assert_cmpuint((unsigned int)queue->length, ==, 0);
5069
5070
g_assert_cmpint(unlink(tempfilename), ==, 0);
5071
}
5072
5073
static void
5074
test_open_and_parse_question_noexist_pid(__attribute__((unused))
5075
test_fixture *fixture,
5076
__attribute__((unused))
5077
gconstpointer user_data){
5078
__attribute__((cleanup(cleanup_close)))
5079
const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);
5080
g_assert_cmpint(epoll_fd, >=, 0);
5081
__attribute__((cleanup(string_set_clear)))
5082
string_set cancelled_filenames = {};
5083
buffer password = {};
5084
bool mandos_client_exited = false;
5085
bool password_is_read = false;
5086
__attribute__((cleanup(cleanup_queue)))
5087
task_queue *queue = create_queue();
5088
g_assert_nonnull(queue);
5089
const mono_microsecs current_time = 0;
5090
5091
/* Find value of sysctl kernel.pid_max */
5092
uintmax_t pid_max = 0;
5093
FILE *sysctl_pid_max = fopen("/proc/sys/kernel/pid_max", "r");
5094
g_assert_nonnull(sysctl_pid_max);
5095
g_assert_cmpint(fscanf(sysctl_pid_max, "%" PRIuMAX, &pid_max),
5096
==, 1);
5097
g_assert_cmpint(fclose(sysctl_pid_max), ==, 0);
5098
5099
pid_t nonexisting_pid = ((pid_t)pid_max)+1;
5100
g_assert_true(nonexisting_pid > 0); /* Overflow check */
5101
5102
__attribute__((cleanup(cleanup_string)))
5103
char *tempfilename = strdup("/tmp/mandosXXXXXX");
5104
g_assert_nonnull(tempfilename);
5105
int questionfile = mkostemp(tempfilename, O_CLOEXEC);
5106
g_assert_cmpint(questionfile, >, 0);
5107
FILE *qf = fdopen(questionfile, "w");
5108
g_assert_cmpint(fprintf(qf, "[Ask]\nSocket=/nonexistent\nPID=%"
5109
PRIuMAX"\n", (uintmax_t)nonexisting_pid),
5110
>, 0);
5111
g_assert_cmpint(fclose(qf), ==, 0);
5112
5113
char *const question_filename = strdup(tempfilename);
5114
g_assert_nonnull(question_filename);
5115
task_context task = {
5116
.func=open_and_parse_question,
5117
.question_filename=question_filename,
5118
.epoll_fd=epoll_fd,
5119
.password=&password,
5120
.filename=question_filename,
5121
.cancelled_filenames=&cancelled_filenames,
5122
.current_time=¤t_time,
5123
.mandos_client_exited=&mandos_client_exited,
5124
.password_is_read=&password_is_read,
5125
};
5126
run_task_with_stderr_to_dev_null(task, queue);
5127
g_assert_cmpuint((unsigned int)queue->length, ==, 0);
5128
5129
g_assert_cmpint(unlink(tempfilename), ==, 0);
5130
}
5131
5132
static void
5133
test_open_and_parse_question_no_notafter(__attribute__((unused))
5134
test_fixture *fixture,
5135
__attribute__((unused))
5136
gconstpointer user_data){
5137
__attribute__((cleanup(cleanup_close)))
5138
const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);
5139
g_assert_cmpint(epoll_fd, >=, 0);
5140
__attribute__((cleanup(string_set_clear)))
5141
string_set cancelled_filenames = {};
5142
buffer password = {};
5143
bool mandos_client_exited = false;
5144
bool password_is_read = false;
5145
__attribute__((cleanup(cleanup_queue)))
5146
task_queue *queue = create_queue();
5147
g_assert_nonnull(queue);
5148
const mono_microsecs current_time = 0;
5149
5150
__attribute__((cleanup(cleanup_string)))
5151
char *tempfilename = strdup("/tmp/mandosXXXXXX");
5152
g_assert_nonnull(tempfilename);
5153
int questionfile = mkostemp(tempfilename, O_CLOEXEC);
5154
g_assert_cmpint(questionfile, >, 0);
5155
FILE *qf = fdopen(questionfile, "w");
5156
g_assert_cmpint(fprintf(qf, "[Ask]\nSocket=/nonexistent\nPID=%"
5157
PRIuMAX "\n", (uintmax_t)getpid()), >, 0);
5158
g_assert_cmpint(fclose(qf), ==, 0);
5159
5160
char *const filename = strdup(tempfilename);
5161
g_assert_nonnull(filename);
5162
task_context task = {
5163
.func=open_and_parse_question,
5164
.question_filename=filename,
5165
.epoll_fd=epoll_fd,
5166
.password=&password,
5167
.filename=filename,
5168
.cancelled_filenames=&cancelled_filenames,
5169
.current_time=¤t_time,
5170
.mandos_client_exited=&mandos_client_exited,
5171
.password_is_read=&password_is_read,
5172
};
5173
task.func(task, queue);
5174
g_assert_cmpuint((unsigned int)queue->length, ==, 1);
5175
5176
__attribute__((cleanup(cleanup_string)))
5177
char *socket_filename = strdup("/nonexistent");
5178
g_assert_nonnull(socket_filename);
5179
g_assert_nonnull(find_matching_task(queue, (task_context){
5180
.func=connect_question_socket,
5181
.question_filename=tempfilename,
5182
.filename=socket_filename,
5183
.epoll_fd=epoll_fd,
5184
.password=&password,
5185
.current_time=¤t_time,
5186
.mandos_client_exited=&mandos_client_exited,
5187
.password_is_read=&password_is_read,
5188
}));
5189
5190
g_assert_true(queue->next_run != 0);
5191
5192
g_assert_cmpint(unlink(tempfilename), ==, 0);
5193
}
5194
5195
static void
5196
test_open_and_parse_question_bad_notafter(__attribute__((unused))
5197
test_fixture *fixture,
5198
__attribute__((unused))
5199
gconstpointer user_data){
5200
__attribute__((cleanup(cleanup_close)))
5201
const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);
5202
g_assert_cmpint(epoll_fd, >=, 0);
5203
__attribute__((cleanup(string_set_clear)))
5204
string_set cancelled_filenames = {};
5205
buffer password = {};
5206
bool mandos_client_exited = false;
5207
bool password_is_read = false;
5208
__attribute__((cleanup(cleanup_queue)))
5209
task_queue *queue = create_queue();
5210
g_assert_nonnull(queue);
5211
const mono_microsecs current_time = 0;
5212
5213
__attribute__((cleanup(cleanup_string)))
5214
char *tempfilename = strdup("/tmp/mandosXXXXXX");
5215
g_assert_nonnull(tempfilename);
5216
int questionfile = mkostemp(tempfilename, O_CLOEXEC);
5217
g_assert_cmpint(questionfile, >, 0);
5218
FILE *qf = fdopen(questionfile, "w");
5219
g_assert_cmpint(fprintf(qf, "[Ask]\nSocket=/nonexistent\nPID=%"
5220
PRIuMAX "\nNotAfter=\n",
5221
(uintmax_t)getpid()), >, 0);
5222
g_assert_cmpint(fclose(qf), ==, 0);
5223
5224
char *const filename = strdup(tempfilename);
5225
g_assert_nonnull(filename);
5226
task_context task = {
5227
.func=open_and_parse_question,
5228
.question_filename=filename,
5229
.epoll_fd=epoll_fd,
5230
.password=&password,
5231
.filename=filename,
5232
.cancelled_filenames=&cancelled_filenames,
5233
.current_time=¤t_time,
5234
.mandos_client_exited=&mandos_client_exited,
5235
.password_is_read=&password_is_read,
5236
};
5237
run_task_with_stderr_to_dev_null(task, queue);
5238
g_assert_cmpuint((unsigned int)queue->length, ==, 1);
5239
5240
__attribute__((cleanup(cleanup_string)))
5241
char *socket_filename = strdup("/nonexistent");
5242
g_assert_nonnull(find_matching_task(queue, (task_context){
5243
.func=connect_question_socket,
5244
.question_filename=tempfilename,
5245
.filename=socket_filename,
5246
.epoll_fd=epoll_fd,
5247
.password=&password,
5248
.current_time=¤t_time,
5249
.mandos_client_exited=&mandos_client_exited,
5250
.password_is_read=&password_is_read,
5251
}));
5252
g_assert_true(queue->next_run != 0);
5253
5254
g_assert_cmpint(unlink(tempfilename), ==, 0);
5255
}
5256
5257
static
5258
void assert_open_and_parse_question_with_notafter(const mono_microsecs
5259
current_time,
5260
const mono_microsecs
5261
notafter,
5262
const mono_microsecs
5263
next_queue_run){
5264
__attribute__((cleanup(cleanup_close)))
5265
const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);
5266
g_assert_cmpint(epoll_fd, >=, 0);
5267
__attribute__((cleanup(string_set_clear)))
5268
string_set cancelled_filenames = {};
5269
buffer password = {};
5270
bool mandos_client_exited = false;
5271
bool password_is_read = false;
5272
__attribute__((cleanup(cleanup_queue)))
5273
task_queue *queue = create_queue();
5274
g_assert_nonnull(queue);
5275
queue->next_run = next_queue_run;
5276
5277
__attribute__((cleanup(cleanup_string)))
5278
char *tempfilename = strdup("/tmp/mandosXXXXXX");
5279
g_assert_nonnull(tempfilename);
5280
int questionfile = mkostemp(tempfilename, O_CLOEXEC);
5281
g_assert_cmpint(questionfile, >, 0);
5282
FILE *qf = fdopen(questionfile, "w");
5283
g_assert_cmpint(fprintf(qf, "[Ask]\nSocket=/nonexistent\nPID=%"
5284
PRIuMAX "\nNotAfter=%" PRIuMAX "\n",
5285
(uintmax_t)getpid(), notafter), >, 0);
5286
g_assert_cmpint(fclose(qf), ==, 0);
5287
5288
char *const filename = strdup(tempfilename);
5289
g_assert_nonnull(filename);
5290
task_context task = {
5291
.func=open_and_parse_question,
5292
.question_filename=filename,
5293
.epoll_fd=epoll_fd,
5294
.password=&password,
5295
.filename=filename,
5296
.cancelled_filenames=&cancelled_filenames,
5297
.current_time=¤t_time,
5298
.mandos_client_exited=&mandos_client_exited,
5299
.password_is_read=&password_is_read,
5300
};
5301
task.func(task, queue);
5302
5303
if(queue->length >= 1){
5304
__attribute__((cleanup(cleanup_string)))
5305
char *socket_filename = strdup("/nonexistent");
5306
g_assert_nonnull(find_matching_task(queue, (task_context){
5307
.func=connect_question_socket,
5308
.filename=socket_filename,
5309
.epoll_fd=epoll_fd,
5310
.password=&password,
5311
.current_time=¤t_time,
5312
.cancelled_filenames=&cancelled_filenames,
5313
.mandos_client_exited=&mandos_client_exited,
5314
.password_is_read=&password_is_read,
5315
}));
5316
g_assert_true(queue->next_run != 0);
5317
}
5318
5319
if(notafter == 0){
5320
g_assert_cmpuint((unsigned int)queue->length, ==, 1);
5321
} else if(current_time >= notafter) {
5322
g_assert_cmpuint((unsigned int)queue->length, ==, 0);
5323
} else {
5324
g_assert_nonnull(find_matching_task(queue, (task_context){
5325
.func=cancel_old_question,
5326
.question_filename=tempfilename,
5327
.filename=tempfilename,
5328
.notafter=notafter,
5329
.cancelled_filenames=&cancelled_filenames,
5330
.current_time=¤t_time,
5331
}));
5332
}
5333
g_assert_true(queue->next_run == 1);
5334
5335
g_assert_cmpint(unlink(tempfilename), ==, 0);
5336
}
5337
5338
static void
5339
test_open_and_parse_question_notafter_0(__attribute__((unused))
5340
test_fixture *fixture,
5341
__attribute__((unused))
5342
gconstpointer user_data){
5343
/* current_time, notafter, next_queue_run */
5344
assert_open_and_parse_question_with_notafter(0, 0, 0);
5345
}
5346
5347
static void
5348
test_open_and_parse_question_notafter_1(__attribute__((unused))
5349
test_fixture *fixture,
5350
__attribute__((unused))
5351
gconstpointer user_data){
5352
/* current_time, notafter, next_queue_run */
5353
assert_open_and_parse_question_with_notafter(0, 1, 0);
5354
}
5355
5356
static void
5357
test_open_and_parse_question_notafter_1_1(__attribute__((unused))
5358
test_fixture *fixture,
5359
__attribute__((unused))
5360
gconstpointer user_data){
5361
/* current_time, notafter, next_queue_run */
5362
assert_open_and_parse_question_with_notafter(0, 1, 1);
5363
}
5364
5365
static void
5366
test_open_and_parse_question_notafter_1_2(__attribute__((unused))
5367
test_fixture *fixture,
5368
__attribute__((unused))
5369
gconstpointer user_data){
5370
/* current_time, notafter, next_queue_run */
5371
assert_open_and_parse_question_with_notafter(0, 1, 2);
5372
}
5373
5374
static void
5375
test_open_and_parse_question_equal_notafter(__attribute__((unused))
5376
test_fixture *fixture,
5377
__attribute__((unused))
5378
gconstpointer user_data){
5379
/* current_time, notafter, next_queue_run */
5380
assert_open_and_parse_question_with_notafter(1, 1, 0);
5381
}
5382
5383
static void
5384
test_open_and_parse_question_late_notafter(__attribute__((unused))
5385
test_fixture *fixture,
5386
__attribute__((unused))
5387
gconstpointer user_data){
5388
/* current_time, notafter, next_queue_run */
5389
assert_open_and_parse_question_with_notafter(2, 1, 0);
5390
}
5391
5392
static void assert_cancel_old_question_param(const mono_microsecs
5393
next_queue_run,
5394
const mono_microsecs
5395
notafter,
5396
const mono_microsecs
5397
current_time,
5398
const mono_microsecs
5399
next_set_to){
5400
__attribute__((cleanup(string_set_clear)))
5401
string_set cancelled_filenames = {};
5402
__attribute__((cleanup(cleanup_queue)))
5403
task_queue *queue = create_queue();
5404
g_assert_nonnull(queue);
5405
queue->next_run = next_queue_run;
5406
5407
char *const question_filename = strdup("/nonexistent");
5408
g_assert_nonnull(question_filename);
5409
task_context task = {
5410
.func=cancel_old_question,
5411
.question_filename=question_filename,
5412
.filename=question_filename,
5413
.notafter=notafter,
5414
.cancelled_filenames=&cancelled_filenames,
5415
.current_time=¤t_time,
5416
};
5417
task.func(task, queue);
5418
5419
if(current_time >= notafter){
5420
g_assert_cmpuint((unsigned int)queue->length, ==, 0);
5421
g_assert_true(string_set_contains(cancelled_filenames,
5422
"/nonexistent"));
5423
} else {
5424
g_assert_nonnull(find_matching_task(queue, (task_context){
5425
.func=cancel_old_question,
5426
.question_filename=question_filename,
5427
.filename=question_filename,
5428
.notafter=notafter,
5429
.cancelled_filenames=&cancelled_filenames,
5430
.current_time=¤t_time,
5431
}));
5432
5433
g_assert_false(string_set_contains(cancelled_filenames,
5434
question_filename));
5435
}
5436
g_assert_cmpuint((unsigned int)queue->next_run, ==,
5437
(unsigned int)next_set_to);
5438
}
5439
5440
static void test_cancel_old_question_0_1_2(__attribute__((unused))
5441
test_fixture *fixture,
5442
__attribute__((unused))
5443
gconstpointer user_data){
5444
/* next_queue_run unset,
5445
cancellation should happen because time has come,
5446
next_queue_run should be unchanged */
5447
/* next_queue_run, notafter, current_time, next_set_to */
5448
assert_cancel_old_question_param(0, 1, 2, 0);
5449
}
5450
5451
static void test_cancel_old_question_0_2_1(__attribute__((unused))
5452
test_fixture *fixture,
5453
__attribute__((unused))
5454
gconstpointer user_data){
5455
/* If next_queue_run is 0, meaning unset, and notafter is 2,
5456
and current_time is not yet notafter or greater,
5457
update value of next_queue_run to value of notafter */
5458
/* next_queue_run, notafter, current_time, next_set_to */
5459
assert_cancel_old_question_param(0, 2, 1, 2);
5460
}
5461
5462
static void test_cancel_old_question_1_2_3(__attribute__((unused))
5463
test_fixture *fixture,
5464
__attribute__((unused))
5465
gconstpointer user_data){
5466
/* next_queue_run 1,
5467
cancellation should happen because time has come,
5468
next_queue_run should be unchanged */
5469
/* next_queue_run, notafter, current_time, next_set_to */
5470
assert_cancel_old_question_param(1, 2, 3, 1);
5471
}
5472
5473
static void test_cancel_old_question_1_3_2(__attribute__((unused))
5474
test_fixture *fixture,
5475
__attribute__((unused))
5476
gconstpointer user_data){
5477
/* If next_queue_run is set,
5478
and current_time is not yet notafter or greater,
5479
and notafter is larger than next_queue_run
5480
next_queue_run should be unchanged */
5481
/* next_queue_run, notafter, current_time, next_set_to */
5482
assert_cancel_old_question_param(1, 3, 2, 1);
5483
}
5484
5485
static void test_cancel_old_question_2_1_3(__attribute__((unused))
5486
test_fixture *fixture,
5487
__attribute__((unused))
5488
gconstpointer user_data){
5489
/* next_queue_run 2,
5490
cancellation should happen because time has come,
5491
next_queue_run should be unchanged */
5492
/* next_queue_run, notafter, current_time, next_set_to */
5493
assert_cancel_old_question_param(2, 1, 3, 2);
5494
}
5495
5496
static void test_cancel_old_question_2_3_1(__attribute__((unused))
5497
test_fixture *fixture,
5498
__attribute__((unused))
5499
gconstpointer user_data){
5500
/* If next_queue_run is set,
5501
and current_time is not yet notafter or greater,
5502
and notafter is larger than next_queue_run
5503
next_queue_run should be unchanged */
5504
/* next_queue_run, notafter, current_time, next_set_to */
5505
assert_cancel_old_question_param(2, 3, 1, 2);
5506
}
5507
5508
static void test_cancel_old_question_3_1_2(__attribute__((unused))
5509
test_fixture *fixture,
5510
__attribute__((unused))
5511
gconstpointer user_data){
5512
/* next_queue_run 3,
5513
cancellation should happen because time has come,
5514
next_queue_run should be unchanged */
5515
/* next_queue_run, notafter, current_time, next_set_to */
5516
assert_cancel_old_question_param(3, 1, 2, 3);
5517
}
5518
5519
static void test_cancel_old_question_3_2_1(__attribute__((unused))
5520
test_fixture *fixture,
5521
__attribute__((unused))
5522
gconstpointer user_data){
5523
/* If next_queue_run is set,
5524
and current_time is not yet notafter or greater,
5525
and notafter is smaller than next_queue_run
5526
update value of next_queue_run to value of notafter */
5527
/* next_queue_run, notafter, current_time, next_set_to */
5528
assert_cancel_old_question_param(3, 2, 1, 2);
5529
}
5530
5531
static void
5532
test_connect_question_socket_name_too_long(__attribute__((unused))
5533
test_fixture *fixture,
5534
__attribute__((unused))
5535
gconstpointer user_data){
5536
__attribute__((cleanup(cleanup_close)))
5537
const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);
5538
g_assert_cmpint(epoll_fd, >=, 0);
5539
const char question_filename[] = "/nonexistent/question";
5540
__attribute__((cleanup(string_set_clear)))
5541
string_set cancelled_filenames = {};
5542
__attribute__((cleanup(cleanup_queue)))
5543
task_queue *queue = create_queue();
5544
g_assert_nonnull(queue);
5545
__attribute__((cleanup(cleanup_string)))
5546
char *tempdir = make_temporary_directory();
5547
g_assert_nonnull(tempdir);
5548
struct sockaddr_un unix_socket = { .sun_family=AF_LOCAL };
5549
char socket_name[sizeof(unix_socket.sun_path)];
5550
memset(socket_name, 'x', sizeof(socket_name));
5551
socket_name[sizeof(socket_name)-1] = '\0';
5552
char *filename = NULL;
5553
g_assert_cmpint(asprintf(&filename, "%s/%s", tempdir, socket_name),
5554
>, 0);
5555
g_assert_nonnull(filename);
5556
5557
task_context task = {
5558
.func=connect_question_socket,
5559
.question_filename=strdup(question_filename),
5560
.epoll_fd=epoll_fd,
5561
.password=(buffer[]){{}},
5562
.filename=filename,
5563
.cancelled_filenames=&cancelled_filenames,
5564
.mandos_client_exited=(bool[]){false},
5565
.password_is_read=(bool[]){false},
5566
.current_time=(mono_microsecs[]){0},
5567
};
5568
g_assert_nonnull(task.question_filename);
5569
run_task_with_stderr_to_dev_null(task, queue);
5570
5571
g_assert_true(string_set_contains(cancelled_filenames,
5572
question_filename));
5573
g_assert_cmpuint((unsigned int)queue->length, ==, 0);
5574
g_assert_true(queue->next_run == 0);
5575
5576
g_assert_cmpint(rmdir(tempdir), ==, 0);
5577
}
5578
5579
static
5580
void test_connect_question_socket_connect_fail(__attribute__((unused))
5581
test_fixture *fixture,
5582
__attribute__((unused))
5583
gconstpointer
5584
user_data){
5585
__attribute__((cleanup(cleanup_close)))
5586
const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);
5587
g_assert_cmpint(epoll_fd, >=, 0);
5588
const char question_filename[] = "/nonexistent/question";
5589
__attribute__((cleanup(string_set_clear)))
5590
string_set cancelled_filenames = {};
5591
const mono_microsecs current_time = 3;
5592
__attribute__((cleanup(cleanup_queue)))
5593
task_queue *queue = create_queue();
5594
g_assert_nonnull(queue);
5595
__attribute__((cleanup(cleanup_string)))
5596
char *tempdir = make_temporary_directory();
5597
g_assert_nonnull(tempdir);
5598
char socket_name[] = "nonexistent";
5599
char *filename = NULL;
5600
g_assert_cmpint(asprintf(&filename, "%s/%s", tempdir, socket_name),
5601
>, 0);
5602
g_assert_nonnull(filename);
5603
5604
task_context task = {
5605
.func=connect_question_socket,
5606
.question_filename=strdup(question_filename),
5607
.epoll_fd=epoll_fd,
5608
.password=(buffer[]){{}},
5609
.filename=filename,
5610
.cancelled_filenames=&cancelled_filenames,
5611
.mandos_client_exited=(bool[]){false},
5612
.password_is_read=(bool[]){false},
5613
.current_time=¤t_time,
5614
};
5615
g_assert_nonnull(task.question_filename);
5616
run_task_with_stderr_to_dev_null(task, queue);
5617
5618
g_assert_nonnull(find_matching_task(queue, task));
5619
5620
g_assert_false(string_set_contains(cancelled_filenames,
5621
question_filename));
5622
g_assert_cmpuint((unsigned int)queue->length, ==, 1);
5623
g_assert_true(queue->next_run == 1000000 + current_time);
5624
5625
g_assert_cmpint(rmdir(tempdir), ==, 0);
5626
}
5627
5628
static
5629
void test_connect_question_socket_bad_epoll(__attribute__((unused))
5630
test_fixture *fixture,
5631
__attribute__((unused))
5632
gconstpointer user_data){
5633
__attribute__((cleanup(cleanup_close)))
5634
const int epoll_fd = open("/dev/null",
5635
O_WRONLY | O_CLOEXEC | O_NOCTTY);
5636
__attribute__((cleanup(cleanup_string)))
5637
char *const question_filename = strdup("/nonexistent/question");
5638
g_assert_nonnull(question_filename);
5639
__attribute__((cleanup(string_set_clear)))
5640
string_set cancelled_filenames = {};
5641
const mono_microsecs current_time = 5;
5642
__attribute__((cleanup(cleanup_queue)))
5643
task_queue *queue = create_queue();
5644
g_assert_nonnull(queue);
5645
__attribute__((cleanup(cleanup_string)))
5646
char *tempdir = make_temporary_directory();
5647
g_assert_nonnull(tempdir);
5648
__attribute__((cleanup(cleanup_close)))
5649
const int sock_fd = socket(PF_LOCAL, SOCK_DGRAM
5650
| SOCK_NONBLOCK | SOCK_CLOEXEC, 0);
5651
g_assert_cmpint(sock_fd, >=, 0);
5652
struct sockaddr_un sock_name = { .sun_family=AF_LOCAL };
5653
const char socket_name[] = "socket_name";
5654
__attribute__((cleanup(cleanup_string)))
5655
char *filename = NULL;
5656
g_assert_cmpint(asprintf(&filename, "%s/%s", tempdir, socket_name),
5657
>, 0);
5658
g_assert_nonnull(filename);
5659
g_assert_cmpint((int)strlen(filename), <,
5660
(int)sizeof(sock_name.sun_path));
5661
strncpy(sock_name.sun_path, filename, sizeof(sock_name.sun_path));
5662
sock_name.sun_path[sizeof(sock_name.sun_path)-1] = '\0';
5663
g_assert_cmpint((int)bind(sock_fd, (struct sockaddr *)&sock_name,
5664
(socklen_t)SUN_LEN(&sock_name)), >=, 0);
5665
task_context task = {
5666
.func=connect_question_socket,
5667
.question_filename=strdup(question_filename),
5668
.epoll_fd=epoll_fd,
5669
.password=(buffer[]){{}},
5670
.filename=strdup(filename),
5671
.cancelled_filenames=&cancelled_filenames,
5672
.mandos_client_exited=(bool[]){false},
5673
.password_is_read=(bool[]){false},
5674
.current_time=¤t_time,
5675
};
5676
g_assert_nonnull(task.question_filename);
5677
run_task_with_stderr_to_dev_null(task, queue);
5678
5679
g_assert_cmpuint((unsigned int)queue->length, ==, 1);
5680
const task_context *const added_task
5681
= find_matching_task(queue, task);
5682
g_assert_nonnull(added_task);
5683
g_assert_true(queue->next_run == 1000000 + current_time);
5684
5685
g_assert_cmpint(unlink(filename), ==, 0);
5686
g_assert_cmpint(rmdir(tempdir), ==, 0);
5687
}
5688
5689
static
5690
void test_connect_question_socket_usable(__attribute__((unused))
5691
test_fixture *fixture,
5692
__attribute__((unused))
5693
gconstpointer user_data){
5694
__attribute__((cleanup(cleanup_close)))
5695
const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);
5696
g_assert_cmpint(epoll_fd, >=, 0);
5697
__attribute__((cleanup(cleanup_string)))
5698
char *const question_filename = strdup("/nonexistent/question");
5699
g_assert_nonnull(question_filename);
5700
__attribute__((cleanup(string_set_clear)))
5701
string_set cancelled_filenames = {};
5702
buffer password = {};
5703
bool mandos_client_exited = false;
5704
bool password_is_read = false;
5705
const mono_microsecs current_time = 0;
5706
__attribute__((cleanup(cleanup_queue)))
5707
task_queue *queue = create_queue();
5708
g_assert_nonnull(queue);
5709
__attribute__((cleanup(cleanup_string)))
5710
char *tempdir = make_temporary_directory();
5711
g_assert_nonnull(tempdir);
5712
__attribute__((cleanup(cleanup_close)))
5713
const int sock_fd = socket(PF_LOCAL, SOCK_DGRAM
5714
| SOCK_NONBLOCK | SOCK_CLOEXEC, 0);
5715
g_assert_cmpint(sock_fd, >=, 0);
5716
struct sockaddr_un sock_name = { .sun_family=AF_LOCAL };
5717
const char socket_name[] = "socket_name";
5718
__attribute__((cleanup(cleanup_string)))
5719
char *filename = NULL;
5720
g_assert_cmpint(asprintf(&filename, "%s/%s", tempdir, socket_name),
5721
>, 0);
5722
g_assert_nonnull(filename);
5723
g_assert_cmpint((int)strlen(filename), <,
5724
(int)sizeof(sock_name.sun_path));
5725
strncpy(sock_name.sun_path, filename, sizeof(sock_name.sun_path));
5726
sock_name.sun_path[sizeof(sock_name.sun_path)-1] = '\0';
5727
g_assert_cmpint((int)bind(sock_fd, (struct sockaddr *)&sock_name,
5728
(socklen_t)SUN_LEN(&sock_name)), >=, 0);
5729
task_context task = {
5730
.func=connect_question_socket,
5731
.question_filename=strdup(question_filename),
5732
.epoll_fd=epoll_fd,
5733
.password=&password,
5734
.filename=strdup(filename),
5735
.cancelled_filenames=&cancelled_filenames,
5736
.mandos_client_exited=&mandos_client_exited,
5737
.password_is_read=&password_is_read,
5738
.current_time=¤t_time,
5739
};
5740
g_assert_nonnull(task.question_filename);
5741
task.func(task, queue);
5742
5743
g_assert_cmpuint((unsigned int)queue->length, ==, 1);
5744
const task_context *const added_task
5745
= find_matching_task(queue, (task_context){
5746
.func=send_password_to_socket,
5747
.question_filename=question_filename,
5748
.filename=filename,
5749
.epoll_fd=epoll_fd,
5750
.password=&password,
5751
.cancelled_filenames=&cancelled_filenames,
5752
.mandos_client_exited=&mandos_client_exited,
5753
.password_is_read=&password_is_read,
5754
.current_time=¤t_time,
5755
});
5756
g_assert_nonnull(added_task);
5757
g_assert_cmpint(added_task->fd, >, 0);
5758
5759
g_assert_true(epoll_set_contains(epoll_fd, added_task->fd,
5760
EPOLLOUT));
5761
5762
const int fd = added_task->fd;
5763
g_assert_cmpint(fd, >, 0);
5764
g_assert_true(fd_has_cloexec_and_nonblock(fd));
5765
5766
/* write to fd */
5767
char write_data[PIPE_BUF];
5768
{
5769
/* Construct test password buffer */
5770
/* Start with + since that is what the real procotol uses */
5771
write_data[0] = '+';
5772
/* Set a special character at string end just to mark the end */
5773
write_data[sizeof(write_data)-2] = 'y';
5774
/* Set NUL at buffer end, as suggested by the protocol */
5775
write_data[sizeof(write_data)-1] = '\0';
5776
/* Fill rest of password with 'x' */
5777
memset(write_data+1, 'x', sizeof(write_data)-3);
5778
g_assert_cmpint((int)send(fd, write_data, sizeof(write_data),
5779
MSG_NOSIGNAL), ==, sizeof(write_data));
5780
}
5781
5782
/* read from sock_fd */
5783
char read_data[sizeof(write_data)];
5784
g_assert_cmpint((int)read(sock_fd, read_data, sizeof(read_data)),
5785
==, sizeof(read_data));
5786
5787
g_assert_true(memcmp(write_data, read_data, sizeof(write_data))
5788
== 0);
5789
5790
/* writing to sock_fd should fail */
5791
g_assert_cmpint(send(sock_fd, write_data, sizeof(write_data),
5792
MSG_NOSIGNAL), <, 0);
5793
5794
/* reading from fd should fail */
5795
g_assert_cmpint((int)recv(fd, read_data, sizeof(read_data),
5796
MSG_NOSIGNAL), <, 0);
5797
5798
g_assert_cmpint(unlink(filename), ==, 0);
5799
g_assert_cmpint(rmdir(tempdir), ==, 0);
5800
}
5801
5802
static void
5803
test_send_password_to_socket_client_not_exited(__attribute__((unused))
5804
test_fixture *fixture,
5805
__attribute__((unused))
5806
gconstpointer
5807
user_data){
5808
__attribute__((cleanup(cleanup_close)))
5809
const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);
5810
g_assert_cmpint(epoll_fd, >=, 0);
5811
__attribute__((cleanup(cleanup_string)))
5812
char *const question_filename = strdup("/nonexistent/question");
5813
g_assert_nonnull(question_filename);
5814
__attribute__((cleanup(cleanup_string)))
5815
char *const filename = strdup("/nonexistent/socket");
5816
g_assert_nonnull(filename);
5817
__attribute__((cleanup(string_set_clear)))
5818
string_set cancelled_filenames = {};
5819
buffer password = {};
5820
bool password_is_read = true;
5821
__attribute__((cleanup(cleanup_queue)))
5822
task_queue *queue = create_queue();
5823
g_assert_nonnull(queue);
5824
int socketfds[2];
5825
g_assert_cmpint(socketpair(PF_LOCAL, SOCK_DGRAM
5826
| SOCK_NONBLOCK | SOCK_CLOEXEC, 0,
5827
socketfds), ==, 0);
5828
__attribute__((cleanup(cleanup_close)))
5829
const int read_socket = socketfds[0];
5830
const int write_socket = socketfds[1];
5831
task_context task = {
5832
.func=send_password_to_socket,
5833
.question_filename=strdup(question_filename),
5834
.filename=strdup(filename),
5835
.epoll_fd=epoll_fd,
5836
.fd=write_socket,
5837
.password=&password,
5838
.cancelled_filenames=&cancelled_filenames,
5839
.mandos_client_exited=(bool[]){false},
5840
.password_is_read=&password_is_read,
5841
.current_time=(mono_microsecs[]){0},
5842
};
5843
g_assert_nonnull(task.question_filename);
5844
5845
task.func(task, queue);
5846
5847
g_assert_cmpuint((unsigned int)queue->length, ==, 1);
5848
5849
const task_context *const added_task
5850
= find_matching_task(queue, task);
5851
g_assert_nonnull(added_task);
5852
g_assert_cmpuint((unsigned int)password.length, ==, 0);
5853
g_assert_true(password_is_read);
5854
5855
g_assert_cmpint(added_task->fd, >, 0);
5856
g_assert_true(epoll_set_contains(epoll_fd, added_task->fd,
5857
EPOLLOUT));
5858
}
5859
5860
static void
5861
test_send_password_to_socket_password_not_read(__attribute__((unused))
5862
test_fixture *fixture,
5863
__attribute__((unused))
5864
gconstpointer
5865
user_data){
5866
__attribute__((cleanup(cleanup_close)))
5867
const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);
5868
g_assert_cmpint(epoll_fd, >=, 0);
5869
__attribute__((cleanup(cleanup_string)))
5870
char *const question_filename = strdup("/nonexistent/question");
5871
g_assert_nonnull(question_filename);
5872
__attribute__((cleanup(cleanup_string)))
5873
char *const filename = strdup("/nonexistent/socket");
5874
__attribute__((cleanup(string_set_clear)))
5875
string_set cancelled_filenames = {};
5876
buffer password = {};
5877
__attribute__((cleanup(cleanup_queue)))
5878
task_queue *queue = create_queue();
5879
g_assert_nonnull(queue);
5880
int socketfds[2];
5881
g_assert_cmpint(socketpair(PF_LOCAL, SOCK_DGRAM
5882
| SOCK_NONBLOCK | SOCK_CLOEXEC, 0,
5883
socketfds), ==, 0);
5884
__attribute__((cleanup(cleanup_close)))
5885
const int read_socket = socketfds[0];
5886
const int write_socket = socketfds[1];
5887
task_context task = {
5888
.func=send_password_to_socket,
5889
.question_filename=strdup(question_filename),
5890
.filename=strdup(filename),
5891
.epoll_fd=epoll_fd,
5892
.fd=write_socket,
5893
.password=&password,
5894
.cancelled_filenames=&cancelled_filenames,
5895
.mandos_client_exited=(bool[]){false},
5896
.password_is_read=(bool[]){false},
5897
.current_time=(mono_microsecs[]){0},
5898
};
5899
g_assert_nonnull(task.question_filename);
5900
5901
task.func(task, queue);
5902
5903
g_assert_cmpuint((unsigned int)queue->length, ==, 1);
5904
5905
const task_context *const added_task = find_matching_task(queue,
5906
task);
5907
g_assert_nonnull(added_task);
5908
g_assert_cmpuint((unsigned int)password.length, ==, 0);
5909
g_assert_true(queue->next_run == 0);
5910
5911
g_assert_cmpint(added_task->fd, >, 0);
5912
g_assert_true(epoll_set_contains(epoll_fd, added_task->fd,
5913
EPOLLOUT));
5914
}
5915
5916
static
5917
void test_send_password_to_socket_EMSGSIZE(__attribute__((unused))
5918
test_fixture *fixture,
5919
__attribute__((unused))
5920
gconstpointer user_data){
5921
__attribute__((cleanup(cleanup_close)))
5922
const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);
5923
g_assert_cmpint(epoll_fd, >=, 0);
5924
const char question_filename[] = "/nonexistent/question";
5925
char *const filename = strdup("/nonexistent/socket");
5926
__attribute__((cleanup(string_set_clear)))
5927
string_set cancelled_filenames = {};
5928
const size_t oversized = 1024*1024; /* Limit seems to be 212960 */
5929
__attribute__((cleanup(cleanup_buffer)))
5930
buffer password = {
5931
.data=malloc(oversized),
5932
.length=oversized,
5933
.allocated=oversized,
5934
};
5935
g_assert_nonnull(password.data);
5936
if(mlock(password.data, password.allocated) != 0){
5937
g_assert_true(errno == EPERM or errno == ENOMEM);
5938
}
5939
/* Construct test password buffer */
5940
/* Start with + since that is what the real procotol uses */
5941
password.data[0] = '+';
5942
/* Set a special character at string end just to mark the end */
5943
password.data[oversized-3] = 'y';
5944
/* Set NUL at buffer end, as suggested by the protocol */
5945
password.data[oversized-2] = '\0';
5946
/* Fill rest of password with 'x' */
5947
memset(password.data+1, 'x', oversized-3);
5948
5949
__attribute__((cleanup(cleanup_queue)))
5950
task_queue *queue = create_queue();
5951
g_assert_nonnull(queue);
5952
int socketfds[2];
5953
g_assert_cmpint(socketpair(PF_LOCAL, SOCK_DGRAM
5954
| SOCK_NONBLOCK | SOCK_CLOEXEC, 0,
5955
socketfds), ==, 0);
5956
__attribute__((cleanup(cleanup_close)))
5957
const int read_socket = socketfds[0];
5958
__attribute__((cleanup(cleanup_close)))
5959
const int write_socket = socketfds[1];
5960
task_context task = {
5961
.func=send_password_to_socket,
5962
.question_filename=strdup(question_filename),
5963
.filename=filename,
5964
.epoll_fd=epoll_fd,
5965
.fd=write_socket,
5966
.password=&password,
5967
.cancelled_filenames=&cancelled_filenames,
5968
.mandos_client_exited=(bool[]){true},
5969
.password_is_read=(bool[]){true},
5970
.current_time=(mono_microsecs[]){0},
5971
};
5972
g_assert_nonnull(task.question_filename);
5973
5974
run_task_with_stderr_to_dev_null(task, queue);
5975
5976
g_assert_cmpuint((unsigned int)queue->length, ==, 0);
5977
g_assert_true(string_set_contains(cancelled_filenames,
5978
question_filename));
5979
}
5980
5981
static void test_send_password_to_socket_retry(__attribute__((unused))
5982
test_fixture *fixture,
5983
__attribute__((unused))
5984
gconstpointer
5985
user_data){
5986
__attribute__((cleanup(cleanup_close)))
5987
const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);
5988
g_assert_cmpint(epoll_fd, >=, 0);
5989
__attribute__((cleanup(cleanup_string)))
5990
char *const question_filename = strdup("/nonexistent/question");
5991
g_assert_nonnull(question_filename);
5992
__attribute__((cleanup(cleanup_string)))
5993
char *const filename = strdup("/nonexistent/socket");
5994
g_assert_nonnull(filename);
5995
__attribute__((cleanup(string_set_clear)))
5996
string_set cancelled_filenames = {};
5997
__attribute__((cleanup(cleanup_buffer)))
5998
buffer password = {};
5999
6000
__attribute__((cleanup(cleanup_queue)))
6001
task_queue *queue = create_queue();
6002
g_assert_nonnull(queue);
6003
int socketfds[2];
6004
g_assert_cmpint(socketpair(PF_LOCAL, SOCK_DGRAM
6005
| SOCK_NONBLOCK | SOCK_CLOEXEC, 0,
6006
socketfds), ==, 0);
6007
__attribute__((cleanup(cleanup_close)))
6008
const int read_socket = socketfds[0];
6009
const int write_socket = socketfds[1];
6010
/* Close the server side socket to force ECONNRESET on client */
6011
g_assert_cmpint(close(read_socket), ==, 0);
6012
task_context task = {
6013
.func=send_password_to_socket,
6014
.question_filename=strdup(question_filename),
6015
.filename=strdup(filename),
6016
.epoll_fd=epoll_fd,
6017
.fd=write_socket,
6018
.password=&password,
6019
.cancelled_filenames=&cancelled_filenames,
6020
.mandos_client_exited=(bool[]){true},
6021
.password_is_read=(bool[]){true},
6022
.current_time=(mono_microsecs[]){0},
6023
};
6024
g_assert_nonnull(task.question_filename);
6025
6026
task.func(task, queue);
6027
6028
g_assert_cmpuint((unsigned int)queue->length, ==, 1);
6029
6030
const task_context *const added_task = find_matching_task(queue,
6031
task);
6032
g_assert_nonnull(added_task);
6033
g_assert_cmpuint((unsigned int)password.length, ==, 0);
6034
6035
g_assert_true(epoll_set_contains(epoll_fd, added_task->fd,
6036
EPOLLOUT));
6037
}
6038
6039
static
6040
void test_send_password_to_socket_bad_epoll(__attribute__((unused))
6041
test_fixture *fixture,
6042
__attribute__((unused))
6043
gconstpointer user_data){
6044
__attribute__((cleanup(cleanup_close)))
6045
const int epoll_fd = open("/dev/null",
6046
O_WRONLY | O_CLOEXEC | O_NOCTTY);
6047
__attribute__((cleanup(cleanup_string)))
6048
char *const question_filename = strdup("/nonexistent/question");
6049
g_assert_nonnull(question_filename);
6050
__attribute__((cleanup(cleanup_string)))
6051
char *const filename = strdup("/nonexistent/socket");
6052
g_assert_nonnull(filename);
6053
__attribute__((cleanup(string_set_clear)))
6054
string_set cancelled_filenames = {};
6055
__attribute__((cleanup(cleanup_buffer)))
6056
buffer password = {};
6057
6058
const mono_microsecs current_time = 11;
6059
__attribute__((cleanup(cleanup_queue)))
6060
task_queue *queue = create_queue();
6061
g_assert_nonnull(queue);
6062
int socketfds[2];
6063
g_assert_cmpint(socketpair(PF_LOCAL, SOCK_DGRAM
6064
| SOCK_NONBLOCK | SOCK_CLOEXEC, 0,
6065
socketfds), ==, 0);
6066
__attribute__((cleanup(cleanup_close)))
6067
const int read_socket = socketfds[0];
6068
const int write_socket = socketfds[1];
6069
/* Close the server side socket to force ECONNRESET on client */
6070
g_assert_cmpint(close(read_socket), ==, 0);
6071
task_context task = {
6072
.func=send_password_to_socket,
6073
.question_filename=strdup(question_filename),
6074
.filename=strdup(filename),
6075
.epoll_fd=epoll_fd,
6076
.fd=write_socket,
6077
.password=&password,
6078
.cancelled_filenames=&cancelled_filenames,
6079
.mandos_client_exited=(bool[]){true},
6080
.password_is_read=(bool[]){true},
6081
.current_time=¤t_time,
6082
};
6083
g_assert_nonnull(task.question_filename);
6084
6085
run_task_with_stderr_to_dev_null(task, queue);
6086
6087
g_assert_cmpuint((unsigned int)queue->length, ==, 1);
6088
6089
const task_context *const added_task = find_matching_task(queue,
6090
task);
6091
g_assert_nonnull(added_task);
6092
g_assert_true(queue->next_run == current_time + 1000000);
6093
g_assert_cmpuint((unsigned int)password.length, ==, 0);
6094
}
6095
6096
static void assert_send_password_to_socket_password(buffer password){
6097
__attribute__((cleanup(cleanup_close)))
6098
const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);
6099
g_assert_cmpint(epoll_fd, >=, 0);
6100
char *const question_filename = strdup("/nonexistent/question");
6101
g_assert_nonnull(question_filename);
6102
char *const filename = strdup("/nonexistent/socket");
6103
g_assert_nonnull(filename);
6104
__attribute__((cleanup(string_set_clear)))
6105
string_set cancelled_filenames = {};
6106
6107
__attribute__((cleanup(cleanup_queue)))
6108
task_queue *queue = create_queue();
6109
g_assert_nonnull(queue);
6110
int socketfds[2];
6111
g_assert_cmpint(socketpair(PF_LOCAL, SOCK_DGRAM
6112
| SOCK_NONBLOCK | SOCK_CLOEXEC, 0,
6113
socketfds), ==, 0);
6114
__attribute__((cleanup(cleanup_close)))
6115
const int read_socket = socketfds[0];
6116
const int write_socket = socketfds[1];
6117
task_context task = {
6118
.func=send_password_to_socket,
6119
.question_filename=question_filename,
6120
.filename=filename,
6121
.epoll_fd=epoll_fd,
6122
.fd=write_socket,
6123
.password=&password,
6124
.cancelled_filenames=&cancelled_filenames,
6125
.mandos_client_exited=(bool[]){true},
6126
.password_is_read=(bool[]){true},
6127
.current_time=(mono_microsecs[]){0},
6128
};
6129
6130
char *expected_written_data = malloc(password.length + 2);
6131
g_assert_nonnull(expected_written_data);
6132
expected_written_data[0] = '+';
6133
expected_written_data[password.length + 1] = '\0';
6134
if(password.length > 0){
6135
g_assert_nonnull(password.data);
6136
memcpy(expected_written_data + 1, password.data, password.length);
6137
}
6138
6139
task.func(task, queue);
6140
6141
char buf[PIPE_BUF];
6142
g_assert_cmpint((int)read(read_socket, buf, PIPE_BUF), ==,
6143
(int)(password.length + 2));
6144
g_assert_cmpuint((unsigned int)queue->length, ==, 0);
6145
6146
g_assert_true(memcmp(expected_written_data, buf,
6147
password.length + 2) == 0);
6148
6149
g_assert_true(epoll_set_does_not_contain(epoll_fd, write_socket));
6150
6151
free(expected_written_data);
6152
}
6153
6154
static void
6155
test_send_password_to_socket_null_password(__attribute__((unused))
6156
test_fixture *fixture,
6157
__attribute__((unused))
6158
gconstpointer user_data){
6159
__attribute__((cleanup(cleanup_buffer)))
6160
buffer password = {};
6161
assert_send_password_to_socket_password(password);
6162
}
6163
6164
static void
6165
test_send_password_to_socket_empty_password(__attribute__((unused))
6166
test_fixture *fixture,
6167
__attribute__((unused))
6168
gconstpointer user_data){
6169
__attribute__((cleanup(cleanup_buffer)))
6170
buffer password = {
6171
.data=malloc(1), /* because malloc(0) may return NULL */
6172
.length=0,
6173
.allocated=0, /* deliberate lie */
6174
};
6175
g_assert_nonnull(password.data);
6176
assert_send_password_to_socket_password(password);
6177
}
6178
6179
static void
6180
test_send_password_to_socket_empty_str_pass(__attribute__((unused))
6181
test_fixture *fixture,
6182
__attribute__((unused))
6183
gconstpointer user_data){
6184
__attribute__((cleanup(cleanup_buffer)))
6185
buffer password = {
6186
.data=strdup(""),
6187
.length=0,
6188
.allocated=1,
6189
};
6190
if(mlock(password.data, password.allocated) != 0){
6191
g_assert_true(errno == EPERM or errno == ENOMEM);
6192
}
6193
assert_send_password_to_socket_password(password);
6194
}
6195
6196
static void
6197
test_send_password_to_socket_text_password(__attribute__((unused))
6198
test_fixture *fixture,
6199
__attribute__((unused))
6200
gconstpointer user_data){
6201
const char dummy_test_password[] = "dummy test password";
6202
__attribute__((cleanup(cleanup_buffer)))
6203
buffer password = {
6204
.data = strdup(dummy_test_password),
6205
.length = strlen(dummy_test_password),
6206
.allocated = sizeof(dummy_test_password),
6207
};
6208
if(mlock(password.data, password.allocated) != 0){
6209
g_assert_true(errno == EPERM or errno == ENOMEM);
6210
}
6211
assert_send_password_to_socket_password(password);
6212
}
6213
6214
static void
6215
test_send_password_to_socket_binary_password(__attribute__((unused))
6216
test_fixture *fixture,
6217
__attribute__((unused))
6218
gconstpointer user_data){
6219
__attribute__((cleanup(cleanup_buffer)))
6220
buffer password = {
6221
.data=malloc(255),
6222
.length=255,
6223
.allocated=255,
6224
};
6225
g_assert_nonnull(password.data);
6226
if(mlock(password.data, password.allocated) != 0){
6227
g_assert_true(errno == EPERM or errno == ENOMEM);
6228
}
6229
char c = 1; /* Start at 1, avoiding NUL */
6230
for(int i=0; i < 255; i++){
6231
password.data[i] = c++;
6232
}
6233
assert_send_password_to_socket_password(password);
6234
}
6235
6236
static void
6237
test_send_password_to_socket_nuls_in_password(__attribute__((unused))
6238
test_fixture *fixture,
6239
__attribute__((unused))
6240
gconstpointer
6241
user_data){
6242
char test_password[] = {'\0', 'a', '\0', 'b', '\0', 'c', '\0'};
6243
__attribute__((cleanup(cleanup_buffer)))
6244
buffer password = {
6245
.data=malloc(sizeof(test_password)),
6246
.length=sizeof(test_password),
6247
.allocated=sizeof(test_password),
6248
};
6249
g_assert_nonnull(password.data);
6250
if(mlock(password.data, password.allocated) !=0){
6251
g_assert_true(errno == EPERM or errno == ENOMEM);
6252
}
6253
memcpy(password.data, test_password, password.allocated);
6254
assert_send_password_to_socket_password(password);
6255
}
6256
6257
static bool assert_add_existing_questions_to_devnull(task_queue
6258
*const,
6259
const int,
6260
buffer *const,
6261
string_set *,
6262
const
6263
mono_microsecs
6264
*const,
6265
bool *const,
6266
bool *const,
6267
const char
6268
*const);
6269
6270
static void test_add_existing_questions_ENOENT(__attribute__((unused))
6271
test_fixture *fixture,
6272
__attribute__((unused))
6273
gconstpointer
6274
user_data){
6275
__attribute__((cleanup(cleanup_queue)))
6276
task_queue *queue = create_queue();
6277
g_assert_nonnull(queue);
6278
__attribute__((cleanup(cleanup_close)))
6279
const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);
6280
g_assert_cmpint(epoll_fd, >=, 0);
6281
__attribute__((cleanup(string_set_clear)))
6282
string_set cancelled_filenames = {};
6283
6284
g_assert_false(assert_add_existing_questions_to_devnull
6285
(queue,
6286
epoll_fd,
6287
(buffer[]){{}}, /* password */
6288
&cancelled_filenames,
6289
(mono_microsecs[]){0}, /* current_time */
6290
(bool[]){false}, /* mandos_client_exited */
6291
(bool[]){false}, /* password_is_read */
6292
"/nonexistent")); /* dirname */
6293
6294
g_assert_cmpuint((unsigned int)queue->length, ==, 0);
6295
}
6296
6297
static
6298
bool assert_add_existing_questions_to_devnull(task_queue
6299
*const queue,
6300
const int
6301
epoll_fd,
6302
buffer *const
6303
password,
6304
string_set
6305
*cancelled_filenames,
6306
const mono_microsecs
6307
*const current_time,
6308
bool *const
6309
mandos_client_exited,
6310
bool *const
6311
password_is_read,
6312
const char *const
6313
dirname){
6314
__attribute__((cleanup(cleanup_close)))
6315
const int devnull_fd = open("/dev/null",
6316
O_WRONLY | O_CLOEXEC | O_NOCTTY);
6317
g_assert_cmpint(devnull_fd, >=, 0);
6318
__attribute__((cleanup(cleanup_close)))
6319
const int real_stderr_fd = dup(STDERR_FILENO);
6320
g_assert_cmpint(real_stderr_fd, >=, 0);
6321
dup2(devnull_fd, STDERR_FILENO);
6322
const bool ret = add_existing_questions(queue, epoll_fd, password,
6323
cancelled_filenames,
6324
current_time,
6325
mandos_client_exited,
6326
password_is_read, dirname);
6327
dup2(real_stderr_fd, STDERR_FILENO);
6328
return ret;
6329
}
6330
6331
static
6332
void test_add_existing_questions_no_questions(__attribute__((unused))
6333
test_fixture *fixture,
6334
__attribute__((unused))
6335
gconstpointer
6336
user_data){
6337
__attribute__((cleanup(cleanup_queue)))
6338
task_queue *queue = create_queue();
6339
g_assert_nonnull(queue);
6340
__attribute__((cleanup(cleanup_close)))
6341
const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);
6342
g_assert_cmpint(epoll_fd, >=, 0);
6343
__attribute__((cleanup(string_set_clear)))
6344
string_set cancelled_filenames = {};
6345
__attribute__((cleanup(cleanup_string)))
6346
char *tempdir = make_temporary_directory();
6347
g_assert_nonnull(tempdir);
6348
6349
g_assert_false(assert_add_existing_questions_to_devnull
6350
(queue,
6351
epoll_fd,
6352
(buffer[]){{}}, /* password */
6353
&cancelled_filenames,
6354
(mono_microsecs[]){0}, /* current_time */
6355
(bool[]){false}, /* mandos_client_exited */
6356
(bool[]){false}, /* password_is_read */
6357
tempdir));
6358
6359
g_assert_cmpuint((unsigned int)queue->length, ==, 0);
6360
6361
g_assert_cmpint(rmdir(tempdir), ==, 0);
6362
}
6363
6364
static char *make_question_file_in_directory(const char *const);
6365
6366
static
6367
void test_add_existing_questions_one_question(__attribute__((unused))
6368
test_fixture *fixture,
6369
__attribute__((unused))
6370
gconstpointer
6371
user_data){
6372
__attribute__((cleanup(cleanup_queue)))
6373
task_queue *queue = create_queue();
6374
g_assert_nonnull(queue);
6375
__attribute__((cleanup(cleanup_close)))
6376
const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);
6377
g_assert_cmpint(epoll_fd, >=, 0);
6378
__attribute__((cleanup(cleanup_buffer)))
6379
buffer password = {};
6380
__attribute__((cleanup(string_set_clear)))
6381
string_set cancelled_filenames = {};
6382
const mono_microsecs current_time = 0;
6383
bool mandos_client_exited = false;
6384
bool password_is_read = false;
6385
__attribute__((cleanup(cleanup_string)))
6386
char *tempdir = make_temporary_directory();
6387
g_assert_nonnull(tempdir);
6388
__attribute__((cleanup(cleanup_string)))
6389
char *question_filename
6390
= make_question_file_in_directory(tempdir);
6391
g_assert_nonnull(question_filename);
6392
6393
g_assert_true(assert_add_existing_questions_to_devnull
6394
(queue,
6395
epoll_fd,
6396
&password,
6397
&cancelled_filenames,
6398
¤t_time,
6399
&mandos_client_exited,
6400
&password_is_read,
6401
tempdir));
6402
6403
g_assert_cmpuint((unsigned int)queue->length, ==, 1);
6404
6405
g_assert_nonnull(find_matching_task(queue, (task_context){
6406
.func=open_and_parse_question,
6407
.epoll_fd=epoll_fd,
6408
.filename=question_filename,
6409
.question_filename=question_filename,
6410
.password=&password,
6411
.cancelled_filenames=&cancelled_filenames,
6412
.current_time=¤t_time,
6413
.mandos_client_exited=&mandos_client_exited,
6414
.password_is_read=&password_is_read,
6415
}));
6416
6417
g_assert_true(queue->next_run == 1);
6418
6419
g_assert_cmpint(unlink(question_filename), ==, 0);
6420
g_assert_cmpint(rmdir(tempdir), ==, 0);
6421
}
6422
6423
static char *make_question_file_in_directory(const char
6424
*const dir){
6425
return make_temporary_prefixed_file_in_directory("ask.", dir);
6426
}
6427
6428
static
6429
void test_add_existing_questions_two_questions(__attribute__((unused))
6430
test_fixture *fixture,
6431
__attribute__((unused))
6432
gconstpointer
6433
user_data){
6434
__attribute__((cleanup(cleanup_queue)))
6435
task_queue *queue = create_queue();
6436
g_assert_nonnull(queue);
6437
__attribute__((cleanup(cleanup_close)))
6438
const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);
6439
g_assert_cmpint(epoll_fd, >=, 0);
6440
__attribute__((cleanup(cleanup_buffer)))
6441
buffer password = {};
6442
__attribute__((cleanup(string_set_clear)))
6443
string_set cancelled_filenames = {};
6444
const mono_microsecs current_time = 0;
6445
bool mandos_client_exited = false;
6446
bool password_is_read = false;
6447
__attribute__((cleanup(cleanup_string)))
6448
char *tempdir = make_temporary_directory();
6449
g_assert_nonnull(tempdir);
6450
__attribute__((cleanup(cleanup_string)))
6451
char *question_filename1
6452
= make_question_file_in_directory(tempdir);
6453
g_assert_nonnull(question_filename1);
6454
__attribute__((cleanup(cleanup_string)))
6455
char *question_filename2
6456
= make_question_file_in_directory(tempdir);
6457
g_assert_nonnull(question_filename2);
6458
6459
g_assert_true(assert_add_existing_questions_to_devnull
6460
(queue,
6461
epoll_fd,
6462
&password,
6463
&cancelled_filenames,
6464
¤t_time,
6465
&mandos_client_exited,
6466
&password_is_read,
6467
tempdir));
6468
6469
g_assert_cmpuint((unsigned int)queue->length, ==, 2);
6470
6471
g_assert_true(queue->next_run == 1);
6472
6473
__attribute__((cleanup(string_set_clear)))
6474
string_set seen_questions = {};
6475
6476
bool queue_contains_question_opener(char *const question_filename){
6477
return(find_matching_task(queue, (task_context){
6478
.func=open_and_parse_question,
6479
.epoll_fd=epoll_fd,
6480
.question_filename=question_filename,
6481
.password=&password,
6482
.cancelled_filenames=&cancelled_filenames,
6483
.current_time=¤t_time,
6484
.mandos_client_exited=&mandos_client_exited,
6485
.password_is_read=&password_is_read,
6486
}) != NULL);
6487
}
6488
6489
g_assert_true(queue_contains_question_opener(question_filename1));
6490
g_assert_true(queue_contains_question_opener(question_filename2));
6491
6492
g_assert_true(queue->next_run == 1);
6493
6494
g_assert_cmpint(unlink(question_filename1), ==, 0);
6495
g_assert_cmpint(unlink(question_filename2), ==, 0);
6496
g_assert_cmpint(rmdir(tempdir), ==, 0);
6497
}
6498
6499
static void
6500
test_add_existing_questions_non_questions(__attribute__((unused))
6501
test_fixture *fixture,
6502
__attribute__((unused))
6503
gconstpointer user_data){
6504
__attribute__((cleanup(cleanup_queue)))
6505
task_queue *queue = create_queue();
6506
g_assert_nonnull(queue);
6507
__attribute__((cleanup(cleanup_close)))
6508
const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);
6509
g_assert_cmpint(epoll_fd, >=, 0);
6510
__attribute__((cleanup(string_set_clear)))
6511
string_set cancelled_filenames = {};
6512
__attribute__((cleanup(cleanup_string)))
6513
char *tempdir = make_temporary_directory();
6514
g_assert_nonnull(tempdir);
6515
__attribute__((cleanup(cleanup_string)))
6516
char *question_filename1
6517
= make_temporary_file_in_directory(tempdir);
6518
g_assert_nonnull(question_filename1);
6519
__attribute__((cleanup(cleanup_string)))
6520
char *question_filename2
6521
= make_temporary_file_in_directory(tempdir);
6522
g_assert_nonnull(question_filename2);
6523
6524
g_assert_false(assert_add_existing_questions_to_devnull
6525
(queue,
6526
epoll_fd,
6527
(buffer[]){{}}, /* password */
6528
&cancelled_filenames,
6529
(mono_microsecs[]){0}, /* current_time */
6530
(bool[]){false}, /* mandos_client_exited */
6531
(bool[]){false}, /* password_is_read */
6532
tempdir));
6533
6534
g_assert_cmpuint((unsigned int)queue->length, ==, 0);
6535
6536
g_assert_cmpint(unlink(question_filename1), ==, 0);
6537
g_assert_cmpint(unlink(question_filename2), ==, 0);
6538
g_assert_cmpint(rmdir(tempdir), ==, 0);
6539
}
6540
6541
static void
6542
test_add_existing_questions_both_types(__attribute__((unused))
6543
test_fixture *fixture,
6544
__attribute__((unused))
6545
gconstpointer user_data){
6546
__attribute__((cleanup(cleanup_queue)))
6547
task_queue *queue = create_queue();
6548
g_assert_nonnull(queue);
6549
__attribute__((cleanup(cleanup_close)))
6550
const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);
6551
g_assert_cmpint(epoll_fd, >=, 0);
6552
__attribute__((cleanup(cleanup_buffer)))
6553
buffer password = {};
6554
__attribute__((cleanup(string_set_clear)))
6555
string_set cancelled_filenames = {};
6556
const mono_microsecs current_time = 0;
6557
bool mandos_client_exited = false;
6558
bool password_is_read = false;
6559
__attribute__((cleanup(cleanup_string)))
6560
char *tempdir = make_temporary_directory();
6561
g_assert_nonnull(tempdir);
6562
__attribute__((cleanup(cleanup_string)))
6563
char *tempfilename1 = make_temporary_file_in_directory(tempdir);
6564
g_assert_nonnull(tempfilename1);
6565
__attribute__((cleanup(cleanup_string)))
6566
char *tempfilename2 = make_temporary_file_in_directory(tempdir);
6567
g_assert_nonnull(tempfilename2);
6568
__attribute__((cleanup(cleanup_string)))
6569
char *question_filename
6570
= make_question_file_in_directory(tempdir);
6571
g_assert_nonnull(question_filename);
6572
6573
g_assert_true(assert_add_existing_questions_to_devnull
6574
(queue,
6575
epoll_fd,
6576
&password,
6577
&cancelled_filenames,
6578
¤t_time,
6579
&mandos_client_exited,
6580
&password_is_read,
6581
tempdir));
6582
6583
g_assert_cmpuint((unsigned int)queue->length, ==, 1);
6584
6585
g_assert_nonnull(find_matching_task(queue, (task_context){
6586
.func=open_and_parse_question,
6587
.epoll_fd=epoll_fd,
6588
.filename=question_filename,
6589
.question_filename=question_filename,
6590
.password=&password,
6591
.cancelled_filenames=&cancelled_filenames,
6592
.current_time=¤t_time,
6593
.mandos_client_exited=&mandos_client_exited,
6594
.password_is_read=&password_is_read,
6595
}));
6596
6597
g_assert_true(queue->next_run == 1);
6598
6599
g_assert_cmpint(unlink(tempfilename1), ==, 0);
6600
g_assert_cmpint(unlink(tempfilename2), ==, 0);
6601
g_assert_cmpint(unlink(question_filename), ==, 0);
6602
g_assert_cmpint(rmdir(tempdir), ==, 0);
6603
}
6604
6605
static void test_wait_for_event_timeout(__attribute__((unused))
6606
test_fixture *fixture,
6607
__attribute__((unused))
6608
gconstpointer user_data){
6609
__attribute__((cleanup(cleanup_close)))
6610
const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);
6611
g_assert_cmpint(epoll_fd, >=, 0);
6612
6613
g_assert_true(wait_for_event(epoll_fd, 1, 0));
6614
}
6615
6616
static void test_wait_for_event_event(__attribute__((unused))
6617
test_fixture *fixture,
6618
__attribute__((unused))
6619
gconstpointer user_data){
6620
__attribute__((cleanup(cleanup_close)))
6621
const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);
6622
g_assert_cmpint(epoll_fd, >=, 0);
6623
int pipefds[2];
6624
g_assert_cmpint(pipe2(pipefds, O_CLOEXEC | O_NONBLOCK), ==, 0);
6625
__attribute__((cleanup(cleanup_close)))
6626
const int read_pipe = pipefds[0];
6627
__attribute__((cleanup(cleanup_close)))
6628
const int write_pipe = pipefds[1];
6629
g_assert_cmpint(epoll_ctl(epoll_fd, EPOLL_CTL_ADD, read_pipe,
6630
&(struct epoll_event)
6631
{ .events=EPOLLIN | EPOLLRDHUP }), ==, 0);
6632
g_assert_cmpint((int)write(write_pipe, "x", 1), ==, 1);
6633
6634
g_assert_true(wait_for_event(epoll_fd, 0, 0));
6635
}
6636
6637
static void test_wait_for_event_sigchld(test_fixture *fixture,
6638
__attribute__((unused))
6639
gconstpointer user_data){
6640
const pid_t pid = fork();
6641
if(pid == 0){ /* Child */
6642
if(not restore_signal_handler(&fixture->orig_sigaction)){
6643
_exit(EXIT_FAILURE);
6644
}
6645
if(not restore_sigmask(&fixture->orig_sigmask)){
6646
_exit(EXIT_FAILURE);
6647
}
6648
exit(EXIT_SUCCESS);
6649
}
6650
g_assert_true(pid != -1);
6651
__attribute__((cleanup(cleanup_close)))
6652
const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);
6653
g_assert_cmpint(epoll_fd, >=, 0);
6654
6655
g_assert_true(wait_for_event(epoll_fd, 0, 0));
6656
6657
int status;
6658
g_assert_true(waitpid(pid, &status, 0) == pid);
6659
g_assert_true(WIFEXITED(status));
6660
g_assert_cmpint(WEXITSTATUS(status), ==, EXIT_SUCCESS);
6661
}
6662
6663
static void test_run_queue_zeroes_next_run(__attribute__((unused))
6664
test_fixture *fixture,
6665
__attribute__((unused))
6666
gconstpointer user_data){
6667
__attribute__((cleanup(cleanup_queue)))
6668
task_queue *queue = create_queue();
6669
g_assert_nonnull(queue);
6670
queue->next_run = 1;
6671
__attribute__((cleanup(cleanup_close)))
6672
const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);
6673
__attribute__((cleanup(string_set_clear)))
6674
string_set cancelled_filenames = {};
6675
bool quit_now = false;
6676
6677
g_assert_true(run_queue(&queue, &cancelled_filenames, &quit_now));
6678
g_assert_false(quit_now);
6679
g_assert_cmpuint((unsigned int)queue->next_run, ==, 0);
6680
}
6681
6682
static
6683
void test_run_queue_clears_cancelled_filenames(__attribute__((unused))
6684
test_fixture *fixture,
6685
__attribute__((unused))
6686
gconstpointer
6687
user_data){
6688
__attribute__((cleanup(cleanup_queue)))
6689
task_queue *queue = create_queue();
6690
g_assert_nonnull(queue);
6691
__attribute__((cleanup(string_set_clear)))
6692
string_set cancelled_filenames = {};
6693
bool quit_now = false;
6694
const char question_filename[] = "/nonexistent/question_filename";
6695
g_assert_true(string_set_add(&cancelled_filenames,
6696
question_filename));
6697
6698
g_assert_true(add_to_queue(queue,
6699
(task_context){ .func=dummy_func }));
6700
6701
g_assert_true(run_queue(&queue, &cancelled_filenames, &quit_now));
6702
g_assert_false(quit_now);
6703
g_assert_cmpuint((unsigned int)(queue->length), ==, 0);
6704
g_assert_false(string_set_contains(cancelled_filenames,
6705
question_filename));
6706
}
6707
6708
static
6709
void test_run_queue_skips_cancelled_filenames(__attribute__((unused))
6710
test_fixture *fixture,
6711
__attribute__((unused))
6712
gconstpointer
6713
user_data){
6714
__attribute__((cleanup(cleanup_queue)))
6715
task_queue *queue = create_queue();
6716
g_assert_nonnull(queue);
6717
__attribute__((cleanup(string_set_clear)))
6718
string_set cancelled_filenames = {};
6719
bool quit_now = false;
6720
int pipefds[2];
6721
g_assert_cmpint(pipe2(pipefds, O_CLOEXEC | O_NONBLOCK), ==, 0);
6722
__attribute__((cleanup(cleanup_close)))
6723
const int read_pipe = pipefds[0];
6724
g_assert_cmpint(close(pipefds[1]), ==, 0);
6725
const char question_filename[] = "/nonexistent/question_filename";
6726
g_assert_true(string_set_add(&cancelled_filenames,
6727
question_filename));
6728
__attribute__((nonnull))
6729
void quit_func(const task_context task,
6730
__attribute__((unused)) task_queue *const q){
6731
g_assert_nonnull(task.quit_now);
6732
*task.quit_now = true;
6733
}
6734
task_context task = {
6735
.func=quit_func,
6736
.question_filename=strdup(question_filename),
6737
.quit_now=&quit_now,
6738
.fd=read_pipe,
6739
};
6740
g_assert_nonnull(task.question_filename);
6741
6742
g_assert_true(add_to_queue(queue, task));
6743
6744
g_assert_true(run_queue(&queue, &cancelled_filenames, &quit_now));
6745
g_assert_false(quit_now);
6746
6747
/* read_pipe should be closed already */
6748
errno = 0;
6749
bool read_pipe_closed = (close(read_pipe) == -1);
6750
read_pipe_closed &= (errno == EBADF);
6751
g_assert_true(read_pipe_closed);
6752
}
6753
6754
static void test_run_queue_one_task(__attribute__((unused))
6755
test_fixture *fixture,
6756
__attribute__((unused))
6757
gconstpointer user_data){
6758
__attribute__((cleanup(cleanup_queue)))
6759
task_queue *queue = create_queue();
6760
g_assert_nonnull(queue);
6761
__attribute__((cleanup(string_set_clear)))
6762
string_set cancelled_filenames = {};
6763
bool quit_now = false;
6764
6765
__attribute__((nonnull))
6766
void next_run_func(__attribute__((unused))
6767
const task_context task,
6768
task_queue *const q){
6769
q->next_run = 1;
6770
}
6771
6772
task_context task = {
6773
.func=next_run_func,
6774
};
6775
g_assert_true(add_to_queue(queue, task));
6776
6777
g_assert_true(run_queue(&queue, &cancelled_filenames, &quit_now));
6778
g_assert_cmpuint((unsigned int)(queue->next_run), ==, 1);
6779
g_assert_cmpuint((unsigned int)(queue->length), ==, 0);
6780
}
6781
6782
static void test_run_queue_two_tasks(__attribute__((unused))
6783
test_fixture *fixture,
6784
__attribute__((unused))
6785
gconstpointer user_data){
6786
__attribute__((cleanup(cleanup_queue)))
6787
task_queue *queue = create_queue();
6788
g_assert_nonnull(queue);
6789
queue->next_run = 1;
6790
__attribute__((cleanup(string_set_clear)))
6791
string_set cancelled_filenames = {};
6792
bool quit_now = false;
6793
bool mandos_client_exited = false;
6794
6795
__attribute__((nonnull))
6796
void next_run_func(__attribute__((unused))
6797
const task_context task,
6798
task_queue *const q){
6799
q->next_run = 1;
6800
}
6801
6802
__attribute__((nonnull))
6803
void exited_func(const task_context task,
6804
__attribute__((unused)) task_queue *const q){
6805
*task.mandos_client_exited = true;
6806
}
6807
6808
task_context task1 = {
6809
.func=next_run_func,
6810
};
6811
g_assert_true(add_to_queue(queue, task1));
6812
6813
task_context task2 = {
6814
.func=exited_func,
6815
.mandos_client_exited=&mandos_client_exited,
6816
};
6817
g_assert_true(add_to_queue(queue, task2));
6818
6819
g_assert_true(run_queue(&queue, &cancelled_filenames, &quit_now));
6820
g_assert_false(quit_now);
6821
g_assert_cmpuint((unsigned int)(queue->next_run), ==, 1);
6822
g_assert_true(mandos_client_exited);
6823
g_assert_cmpuint((unsigned int)(queue->length), ==, 0);
6824
}
6825
6826
static void test_run_queue_two_tasks_quit(__attribute__((unused))
6827
test_fixture *fixture,
6828
__attribute__((unused))
6829
gconstpointer user_data){
6830
__attribute__((cleanup(cleanup_queue)))
6831
task_queue *queue = create_queue();
6832
g_assert_nonnull(queue);
6833
__attribute__((cleanup(string_set_clear)))
6834
string_set cancelled_filenames = {};
6835
bool quit_now = false;
6836
bool mandos_client_exited = false;
6837
bool password_is_read = false;
6838
6839
__attribute__((nonnull))
6840
void set_exited_func(const task_context task,
6841
__attribute__((unused)) task_queue *const q){
6842
*task.mandos_client_exited = true;
6843
*task.quit_now = true;
6844
}
6845
task_context task1 = {
6846
.func=set_exited_func,
6847
.quit_now=&quit_now,
6848
.mandos_client_exited=&mandos_client_exited,
6849
};
6850
g_assert_true(add_to_queue(queue, task1));
6851
6852
__attribute__((nonnull))
6853
void set_read_func(const task_context task,
6854
__attribute__((unused)) task_queue *const q){
6855
*task.quit_now = true;
6856
*task.password_is_read = true;
6857
}
6858
task_context task2 = {
6859
.func=set_read_func,
6860
.quit_now=&quit_now,
6861
.password_is_read=&password_is_read,
6862
};
6863
g_assert_true(add_to_queue(queue, task2));
6864
6865
g_assert_false(run_queue(&queue, &cancelled_filenames, &quit_now));
6866
g_assert_true(quit_now);
6867
g_assert_true(mandos_client_exited xor password_is_read);
6868
g_assert_cmpuint((unsigned int)(queue->length), ==, 0);
6869
}
6870
6871
static void test_run_queue_two_tasks_cleanup(__attribute__((unused))
6872
test_fixture *fixture,
6873
__attribute__((unused))
6874
gconstpointer user_data){
6875
__attribute__((cleanup(cleanup_queue)))
6876
task_queue *queue = create_queue();
6877
g_assert_nonnull(queue);
6878
__attribute__((cleanup(string_set_clear)))
6879
string_set cancelled_filenames = {};
6880
int pipefds[2];
6881
g_assert_cmpint(pipe2(pipefds, O_CLOEXEC | O_NONBLOCK), ==, 0);
6882
__attribute__((cleanup(cleanup_close)))
6883
const int read_pipe = pipefds[0];
6884
__attribute__((cleanup(cleanup_close)))
6885
const int write_pipe = pipefds[1];
6886
bool quit_now = false;
6887
6888
__attribute__((nonnull))
6889
void read_func(const task_context task,
6890
__attribute__((unused)) task_queue *const q){
6891
*task.quit_now = true;
6892
}
6893
task_context task1 = {
6894
.func=read_func,
6895
.quit_now=&quit_now,
6896
.fd=read_pipe,
6897
};
6898
g_assert_true(add_to_queue(queue, task1));
6899
6900
__attribute__((nonnull))
6901
void write_func(const task_context task,
6902
__attribute__((unused)) task_queue *const q){
6903
*task.quit_now = true;
6904
}
6905
task_context task2 = {
6906
.func=write_func,
6907
.quit_now=&quit_now,
6908
.fd=write_pipe,
6909
};
6910
g_assert_true(add_to_queue(queue, task2));
6911
6912
g_assert_false(run_queue(&queue, &cancelled_filenames, &quit_now));
6913
g_assert_true(quit_now);
6914
6915
/* Either read_pipe or write_pipe should be closed already */
6916
errno = 0;
6917
bool close_read_pipe = (close(read_pipe) == -1);
6918
close_read_pipe &= (errno == EBADF);
6919
errno = 0;
6920
bool close_write_pipe = (close(write_pipe) == -1);
6921
close_write_pipe &= (errno == EBADF);
6922
g_assert_true(close_read_pipe xor close_write_pipe);
6923
g_assert_cmpuint((unsigned int)(queue->length), ==, 0);
6924
}
6925
6926
static void test_setup_signal_handler(__attribute__((unused))
6927
test_fixture *fixture,
6928
__attribute__((unused))
6929
gconstpointer user_data){
6930
/* Save current SIGCHLD action, whatever it is */
6931
struct sigaction expected_sigchld_action;
6932
g_assert_cmpint(sigaction(SIGCHLD, NULL, &expected_sigchld_action),
6933
==, 0);
6934
6935
/* Act; i.e. run the setup_signal_handler() function */
6936
struct sigaction actual_old_sigchld_action;
6937
g_assert_true(setup_signal_handler(&actual_old_sigchld_action));
6938
6939
/* Check that the function correctly set "actual_old_sigchld_action"
6940
to the same values as the previously saved
6941
"expected_sigchld_action" */
6942
/* Check member sa_handler */
6943
g_assert_true(actual_old_sigchld_action.sa_handler
6944
== expected_sigchld_action.sa_handler);
6945
/* Check member sa_mask */
6946
for(int signum = 1; signum < NSIG; signum++){
6947
const int expected_old_block_state
6948
= sigismember(&expected_sigchld_action.sa_mask, signum);
6949
g_assert_cmpint(expected_old_block_state, >=, 0);
6950
const int actual_old_block_state
6951
= sigismember(&actual_old_sigchld_action.sa_mask, signum);
6952
g_assert_cmpint(actual_old_block_state, >=, 0);
6953
g_assert_cmpint(actual_old_block_state,
6954
==, expected_old_block_state);
6955
}
6956
/* Check member sa_flags */
6957
g_assert_true((actual_old_sigchld_action.sa_flags
6958
& (SA_NOCLDSTOP | SA_ONSTACK | SA_RESTART))
6959
== (expected_sigchld_action.sa_flags
6960
& (SA_NOCLDSTOP | SA_ONSTACK | SA_RESTART)));
6961
6962
/* Retrieve the current signal handler for SIGCHLD as set by
6963
setup_signal_handler() */
6964
struct sigaction actual_new_sigchld_action;
6965
g_assert_cmpint(sigaction(SIGCHLD, NULL,
6966
&actual_new_sigchld_action), ==, 0);
6967
/* Check that the signal handler (member sa_handler) is correctly
6968
set to the "handle_sigchld" function */
6969
g_assert_true(actual_new_sigchld_action.sa_handler != SIG_DFL);
6970
g_assert_true(actual_new_sigchld_action.sa_handler != SIG_IGN);
6971
g_assert_true(actual_new_sigchld_action.sa_handler
6972
== handle_sigchld);
6973
/* Check (in member sa_mask) that at least a handful of signals are
6974
actually blocked during the signal handler */
6975
for(int signum = 1; signum < NSIG; signum++){
6976
int actual_new_block_state;
6977
switch(signum){
6978
case SIGTERM:
6979
case SIGINT:
6980
case SIGQUIT:
6981
case SIGHUP:
6982
actual_new_block_state
6983
= sigismember(&actual_new_sigchld_action.sa_mask, signum);
6984
g_assert_cmpint(actual_new_block_state, ==, 1);
6985
continue;
6986
case SIGKILL: /* non-blockable */
6987
case SIGSTOP: /* non-blockable */
6988
case SIGCHLD: /* always blocked */
6989
default:
6990
continue;
6991
}
6992
}
6993
/* Check member sa_flags */
6994
g_assert_true((actual_new_sigchld_action.sa_flags
6995
& (SA_NOCLDSTOP | SA_ONSTACK | SA_RESTART))
6996
== (SA_NOCLDSTOP | SA_RESTART));
6997
6998
/* Restore signal handler */
6999
g_assert_cmpint(sigaction(SIGCHLD, &expected_sigchld_action, NULL),
7000
==, 0);
7001
}
7002
7003
static void test_restore_signal_handler(__attribute__((unused))
7004
test_fixture *fixture,
7005
__attribute__((unused))
7006
gconstpointer user_data){
7007
/* Save current SIGCHLD action, whatever it is */
7008
struct sigaction expected_sigchld_action;
7009
g_assert_cmpint(sigaction(SIGCHLD, NULL, &expected_sigchld_action),
7010
==, 0);
7011
/* Since we haven't established a signal handler yet, there should
7012
not be one established. But another test may have relied on
7013
restore_signal_handler() to restore the signal handler, and if
7014
restore_signal_handler() is buggy (which we should be prepared
7015
for in this test) the signal handler may not have been restored
7016
properly; check for this: */
7017
g_assert_true(expected_sigchld_action.sa_handler != handle_sigchld);
7018
7019
/* Establish a signal handler */
7020
struct sigaction sigchld_action = {
7021
.sa_handler=handle_sigchld,
7022
.sa_flags=SA_RESTART | SA_NOCLDSTOP,
7023
};
7024
g_assert_cmpint(sigfillset(&sigchld_action.sa_mask), ==, 0);
7025
g_assert_cmpint(sigaction(SIGCHLD, &sigchld_action, NULL), ==, 0);
7026
7027
/* Act; i.e. run the restore_signal_handler() function */
7028
g_assert_true(restore_signal_handler(&expected_sigchld_action));
7029
7030
/* Retrieve the restored signal handler data */
7031
struct sigaction actual_restored_sigchld_action;
7032
g_assert_cmpint(sigaction(SIGCHLD, NULL,
7033
&actual_restored_sigchld_action), ==, 0);
7034
7035
/* Check that the function correctly restored the signal action, as
7036
saved in "actual_restored_sigchld_action", to the same values as
7037
the previously saved "expected_sigchld_action" */
7038
/* Check member sa_handler */
7039
g_assert_true(actual_restored_sigchld_action.sa_handler
7040
== expected_sigchld_action.sa_handler);
7041
/* Check member sa_mask */
7042
for(int signum = 1; signum < NSIG; signum++){
7043
const int expected_old_block_state
7044
= sigismember(&expected_sigchld_action.sa_mask, signum);
7045
g_assert_cmpint(expected_old_block_state, >=, 0);
7046
const int actual_restored_block_state
7047
= sigismember(&actual_restored_sigchld_action.sa_mask, signum);
7048
g_assert_cmpint(actual_restored_block_state, >=, 0);
7049
g_assert_cmpint(actual_restored_block_state,
7050
==, expected_old_block_state);
7051
}
7052
/* Check member sa_flags */
7053
g_assert_true((actual_restored_sigchld_action.sa_flags
7054
& (SA_NOCLDSTOP | SA_ONSTACK | SA_RESTART))
7055
== (expected_sigchld_action.sa_flags
7056
& (SA_NOCLDSTOP | SA_ONSTACK | SA_RESTART)));
7057
}
7058
7059
static void test_block_sigchld(__attribute__((unused))
7060
test_fixture *fixture,
7061
__attribute__((unused))
7062
gconstpointer user_data){
7063
/* Save original signal mask */
7064
sigset_t expected_sigmask;
7065
g_assert_cmpint(pthread_sigmask(-1, NULL, &expected_sigmask),
7066
==, 0);
7067
7068
/* Make sure SIGCHLD is unblocked for this test */
7069
sigset_t sigchld_sigmask;
7070
g_assert_cmpint(sigemptyset(&sigchld_sigmask), ==, 0);
7071
g_assert_cmpint(sigaddset(&sigchld_sigmask, SIGCHLD), ==, 0);
7072
g_assert_cmpint(pthread_sigmask(SIG_UNBLOCK, &sigchld_sigmask,
7073
NULL), ==, 0);
7074
7075
/* Act; i.e. run the block_sigchld() function */
7076
sigset_t actual_old_sigmask;
7077
g_assert_true(block_sigchld(&actual_old_sigmask));
7078
7079
/* Check the actual_old_sigmask; it should be the same as the
7080
previously saved signal mask "expected_sigmask". */
7081
for(int signum = 1; signum < NSIG; signum++){
7082
const int expected_old_block_state
7083
= sigismember(&expected_sigmask, signum);
7084
g_assert_cmpint(expected_old_block_state, >=, 0);
7085
const int actual_old_block_state
7086
= sigismember(&actual_old_sigmask, signum);
7087
g_assert_cmpint(actual_old_block_state, >=, 0);
7088
g_assert_cmpint(actual_old_block_state,
7089
==, expected_old_block_state);
7090
}
7091
7092
/* Retrieve the newly set signal mask */
7093
sigset_t actual_sigmask;
7094
g_assert_cmpint(pthread_sigmask(-1, NULL, &actual_sigmask), ==, 0);
7095
7096
/* SIGCHLD should be blocked */
7097
g_assert_cmpint(sigismember(&actual_sigmask, SIGCHLD), ==, 1);
7098
7099
/* Restore signal mask */
7100
g_assert_cmpint(pthread_sigmask(SIG_SETMASK, &expected_sigmask,
7101
NULL), ==, 0);
7102
}
7103
7104
static void test_restore_sigmask(__attribute__((unused))
7105
test_fixture *fixture,
7106
__attribute__((unused))
7107
gconstpointer user_data){
7108
/* Save original signal mask */
7109
sigset_t orig_sigmask;
7110
g_assert_cmpint(pthread_sigmask(-1, NULL, &orig_sigmask), ==, 0);
7111
7112
/* Make sure SIGCHLD is blocked for this test */
7113
sigset_t sigchld_sigmask;
7114
g_assert_cmpint(sigemptyset(&sigchld_sigmask), ==, 0);
7115
g_assert_cmpint(sigaddset(&sigchld_sigmask, SIGCHLD), ==, 0);
7116
g_assert_cmpint(pthread_sigmask(SIG_BLOCK, &sigchld_sigmask,
7117
NULL), ==, 0);
7118
7119
/* Act; i.e. run the restore_sigmask() function */
7120
g_assert_true(restore_sigmask(&orig_sigmask));
7121
7122
/* Retrieve the newly restored signal mask */
7123
sigset_t restored_sigmask;
7124
g_assert_cmpint(pthread_sigmask(-1, NULL, &restored_sigmask),
7125
==, 0);
7126
7127
/* Check the restored_sigmask; it should be the same as the
7128
previously saved signal mask "orig_sigmask". */
7129
for(int signum = 1; signum < NSIG; signum++){
7130
const int orig_block_state = sigismember(&orig_sigmask, signum);
7131
g_assert_cmpint(orig_block_state, >=, 0);
7132
const int restored_block_state = sigismember(&restored_sigmask,
7133
signum);
7134
g_assert_cmpint(restored_block_state, >=, 0);
7135
g_assert_cmpint(restored_block_state, ==, orig_block_state);
7136
}
7137
7138
/* Restore signal mask */
7139
g_assert_cmpint(pthread_sigmask(SIG_SETMASK, &orig_sigmask,
7140
NULL), ==, 0);
7141
}
7142
7143
static void test_parse_arguments_noargs(__attribute__((unused))
7144
test_fixture *fixture,
7145
__attribute__((unused))
7146
gconstpointer user_data){
7147
char *argv[] = {
7148
strdup("prgname"),
7149
NULL };
7150
const int argc = (sizeof(argv) / sizeof(char *)) - 1;
7151
7152
char *agent_directory = NULL;
7153
char *helper_directory = NULL;
7154
uid_t user = 0;
7155
gid_t group = 0;
7156
char *mandos_argz = NULL;
7157
size_t mandos_argz_length = 0;
7158
7159
g_assert_true(parse_arguments(argc, argv, false, &agent_directory,
7160
&helper_directory, &user, &group,
7161
&mandos_argz, &mandos_argz_length));
7162
g_assert_null(agent_directory);
7163
g_assert_null(helper_directory);
7164
g_assert_true(user == 0);
7165
g_assert_true(group == 0);
7166
g_assert_null(mandos_argz);
7167
g_assert_true(mandos_argz_length == 0);
7168
7169
for(char **arg = argv; *arg != NULL; arg++){
7170
free(*arg);
7171
}
7172
}
7173
7174
__attribute__((nonnull))
7175
static bool parse_arguments_devnull(int argc, char *argv[],
7176
const bool exit_failure,
7177
char **agent_directory,
7178
char **helper_directory,
7179
uid_t *const user,
7180
gid_t *const group,
7181
char **mandos_argz,
7182
size_t *mandos_argz_length){
7183
7184
FILE *real_stderr = stderr;
7185
FILE *devnull = fopen("/dev/null", "we");
7186
g_assert_nonnull(devnull);
7187
stderr = devnull;
7188
7189
const bool ret = parse_arguments(argc, argv, exit_failure,
7190
agent_directory,
7191
helper_directory, user, group,
7192
mandos_argz, mandos_argz_length);
7193
const error_t saved_errno = errno;
7194
7195
stderr = real_stderr;
7196
g_assert_cmpint(fclose(devnull), ==, 0);
7197
7198
errno = saved_errno;
7199
7200
return ret;
7201
}
7202
7203
static void test_parse_arguments_invalid(__attribute__((unused))
7204
test_fixture *fixture,
7205
__attribute__((unused))
7206
gconstpointer user_data){
7207
char *argv[] = {
7208
strdup("prgname"),
7209
strdup("--invalid"),
7210
NULL };
7211
const int argc = (sizeof(argv) / sizeof(char *)) - 1;
7212
7213
char *agent_directory = NULL;
7214
char *helper_directory = NULL;
7215
uid_t user = 0;
7216
gid_t group = 0;
7217
char *mandos_argz = NULL;
7218
size_t mandos_argz_length = 0;
7219
7220
g_assert_false(parse_arguments_devnull(argc, argv, false,
7221
&agent_directory,
7222
&helper_directory, &user,
7223
&group, &mandos_argz,
7224
&mandos_argz_length));
7225
7226
g_assert_true(errno == EINVAL);
7227
g_assert_null(agent_directory);
7228
g_assert_null(helper_directory);
7229
g_assert_null(mandos_argz);
7230
g_assert_true(mandos_argz_length == 0);
7231
7232
for(char **arg = argv; *arg != NULL; arg++){
7233
free(*arg);
7234
}
7235
}
7236
7237
static void test_parse_arguments_long_dir(__attribute__((unused))
7238
test_fixture *fixture,
7239
__attribute__((unused))
7240
gconstpointer user_data){
7241
char *argv[] = {
7242
strdup("prgname"),
7243
strdup("--agent-directory"),
7244
strdup("/tmp"),
7245
NULL };
7246
const int argc = (sizeof(argv) / sizeof(char *)) - 1;
7247
7248
__attribute__((cleanup(cleanup_string)))
7249
char *agent_directory = NULL;
7250
char *helper_directory = NULL;
7251
uid_t user = 0;
7252
gid_t group = 0;
7253
__attribute__((cleanup(cleanup_string)))
7254
char *mandos_argz = NULL;
7255
size_t mandos_argz_length = 0;
7256
7257
g_assert_true(parse_arguments(argc, argv, false, &agent_directory,
7258
&helper_directory, &user, &group,
7259
&mandos_argz, &mandos_argz_length));
7260
7261
g_assert_cmpstr(agent_directory, ==, "/tmp");
7262
g_assert_null(helper_directory);
7263
g_assert_true(user == 0);
7264
g_assert_true(group == 0);
7265
g_assert_null(mandos_argz);
7266
g_assert_true(mandos_argz_length == 0);
7267
7268
for(char **arg = argv; *arg != NULL; arg++){
7269
free(*arg);
7270
}
7271
}
7272
7273
static void test_parse_arguments_short_dir(__attribute__((unused))
7274
test_fixture *fixture,
7275
__attribute__((unused))
7276
gconstpointer user_data){
7277
char *argv[] = {
7278
strdup("prgname"),
7279
strdup("-d"),
7280
strdup("/tmp"),
7281
NULL };
7282
const int argc = (sizeof(argv) / sizeof(char *)) - 1;
7283
7284
__attribute__((cleanup(cleanup_string)))
7285
char *agent_directory = NULL;
7286
char *helper_directory = NULL;
7287
uid_t user = 0;
7288
gid_t group = 0;
7289
__attribute__((cleanup(cleanup_string)))
7290
char *mandos_argz = NULL;
7291
size_t mandos_argz_length = 0;
7292
7293
g_assert_true(parse_arguments(argc, argv, false, &agent_directory,
7294
&helper_directory, &user, &group,
7295
&mandos_argz, &mandos_argz_length));
7296
7297
g_assert_cmpstr(agent_directory, ==, "/tmp");
7298
g_assert_null(helper_directory);
7299
g_assert_true(user == 0);
7300
g_assert_true(group == 0);
7301
g_assert_null(mandos_argz);
7302
g_assert_true(mandos_argz_length == 0);
7303
7304
for(char **arg = argv; *arg != NULL; arg++){
7305
free(*arg);
7306
}
7307
}
7308
7309
static
7310
void test_parse_arguments_helper_directory(__attribute__((unused))
7311
test_fixture *fixture,
7312
__attribute__((unused))
7313
gconstpointer user_data){
7314
char *argv[] = {
7315
strdup("prgname"),
7316
strdup("--helper-directory"),
7317
strdup("/tmp"),
7318
NULL };
7319
const int argc = (sizeof(argv) / sizeof(char *)) - 1;
7320
7321
char *agent_directory = NULL;
7322
__attribute__((cleanup(cleanup_string)))
7323
char *helper_directory = NULL;
7324
uid_t user = 0;
7325
gid_t group = 0;
7326
__attribute__((cleanup(cleanup_string)))
7327
char *mandos_argz = NULL;
7328
size_t mandos_argz_length = 0;
7329
7330
g_assert_true(parse_arguments(argc, argv, false, &agent_directory,
7331
&helper_directory, &user, &group,
7332
&mandos_argz, &mandos_argz_length));
7333
7334
g_assert_cmpstr(helper_directory, ==, "/tmp");
7335
g_assert_null(agent_directory);
7336
g_assert_true(user == 0);
7337
g_assert_true(group == 0);
7338
g_assert_null(mandos_argz);
7339
g_assert_true(mandos_argz_length == 0);
7340
7341
for(char **arg = argv; *arg != NULL; arg++){
7342
free(*arg);
7343
}
7344
}
7345
7346
static
7347
void test_parse_arguments_plugin_helper_dir(__attribute__((unused))
7348
test_fixture *fixture,
7349
__attribute__((unused))
7350
gconstpointer user_data){
7351
char *argv[] = {
7352
strdup("prgname"),
7353
strdup("--plugin-helper-dir"),
7354
strdup("/tmp"),
7355
NULL };
7356
const int argc = (sizeof(argv) / sizeof(char *)) - 1;
7357
7358
char *agent_directory = NULL;
7359
__attribute__((cleanup(cleanup_string)))
7360
char *helper_directory = NULL;
7361
uid_t user = 0;
7362
gid_t group = 0;
7363
__attribute__((cleanup(cleanup_string)))
7364
char *mandos_argz = NULL;
7365
size_t mandos_argz_length = 0;
7366
7367
g_assert_true(parse_arguments(argc, argv, false, &agent_directory,
7368
&helper_directory, &user, &group,
7369
&mandos_argz, &mandos_argz_length));
7370
7371
g_assert_cmpstr(helper_directory, ==, "/tmp");
7372
g_assert_null(agent_directory);
7373
g_assert_true(user == 0);
7374
g_assert_true(group == 0);
7375
g_assert_null(mandos_argz);
7376
g_assert_true(mandos_argz_length == 0);
7377
7378
for(char **arg = argv; *arg != NULL; arg++){
7379
free(*arg);
7380
}
7381
}
7382
7383
static void test_parse_arguments_user(__attribute__((unused))
7384
test_fixture *fixture,
7385
__attribute__((unused))
7386
gconstpointer user_data){
7387
char *argv[] = {
7388
strdup("prgname"),
7389
strdup("--user"),
7390
strdup("1000"),
7391
NULL };
7392
const int argc = (sizeof(argv) / sizeof(char *)) - 1;
7393
7394
char *agent_directory = NULL;
7395
__attribute__((cleanup(cleanup_string)))
7396
char *helper_directory = NULL;
7397
uid_t user = 0;
7398
gid_t group = 0;
7399
__attribute__((cleanup(cleanup_string)))
7400
char *mandos_argz = NULL;
7401
size_t mandos_argz_length = 0;
7402
7403
g_assert_true(parse_arguments(argc, argv, false, &agent_directory,
7404
&helper_directory, &user, &group,
7405
&mandos_argz, &mandos_argz_length));
7406
7407
g_assert_null(helper_directory);
7408
g_assert_null(agent_directory);
7409
g_assert_cmpuint((unsigned int)user, ==, 1000);
7410
g_assert_true(group == 0);
7411
g_assert_null(mandos_argz);
7412
g_assert_true(mandos_argz_length == 0);
7413
7414
for(char **arg = argv; *arg != NULL; arg++){
7415
free(*arg);
7416
}
7417
}
7418
7419
static void test_parse_arguments_user_invalid(__attribute__((unused))
7420
test_fixture *fixture,
7421
__attribute__((unused))
7422
gconstpointer
7423
user_data){
7424
char *argv[] = {
7425
strdup("prgname"),
7426
strdup("--user"),
7427
strdup("invalid"),
7428
NULL };
7429
const int argc = (sizeof(argv) / sizeof(char *)) - 1;
7430
7431
char *agent_directory = NULL;
7432
__attribute__((cleanup(cleanup_string)))
7433
char *helper_directory = NULL;
7434
uid_t user = 0;
7435
gid_t group = 0;
7436
__attribute__((cleanup(cleanup_string)))
7437
char *mandos_argz = NULL;
7438
size_t mandos_argz_length = 0;
7439
7440
g_assert_false(parse_arguments_devnull(argc, argv, false,
7441
&agent_directory,
7442
&helper_directory, &user,
7443
&group, &mandos_argz,
7444
&mandos_argz_length));
7445
7446
g_assert_null(helper_directory);
7447
g_assert_null(agent_directory);
7448
g_assert_cmpuint((unsigned int)user, ==, 0);
7449
g_assert_true(group == 0);
7450
g_assert_null(mandos_argz);
7451
g_assert_true(mandos_argz_length == 0);
7452
7453
for(char **arg = argv; *arg != NULL; arg++){
7454
free(*arg);
7455
}
7456
}
7457
7458
static
7459
void test_parse_arguments_user_zero_invalid(__attribute__((unused))
7460
test_fixture *fixture,
7461
__attribute__((unused))
7462
gconstpointer user_data){
7463
char *argv[] = {
7464
strdup("prgname"),
7465
strdup("--user"),
7466
strdup("0"),
7467
NULL };
7468
const int argc = (sizeof(argv) / sizeof(char *)) - 1;
7469
7470
char *agent_directory = NULL;
7471
__attribute__((cleanup(cleanup_string)))
7472
char *helper_directory = NULL;
7473
uid_t user = 0;
7474
gid_t group = 0;
7475
__attribute__((cleanup(cleanup_string)))
7476
char *mandos_argz = NULL;
7477
size_t mandos_argz_length = 0;
7478
7479
g_assert_false(parse_arguments_devnull(argc, argv, false,
7480
&agent_directory,
7481
&helper_directory, &user,
7482
&group, &mandos_argz,
7483
&mandos_argz_length));
7484
7485
g_assert_null(helper_directory);
7486
g_assert_null(agent_directory);
7487
g_assert_cmpuint((unsigned int)user, ==, 0);
7488
g_assert_true(group == 0);
7489
g_assert_null(mandos_argz);
7490
g_assert_true(mandos_argz_length == 0);
7491
7492
for(char **arg = argv; *arg != NULL; arg++){
7493
free(*arg);
7494
}
7495
}
7496
7497
static void test_parse_arguments_group(__attribute__((unused))
7498
test_fixture *fixture,
7499
__attribute__((unused))
7500
gconstpointer user_data){
7501
char *argv[] = {
7502
strdup("prgname"),
7503
strdup("--group"),
7504
strdup("1000"),
7505
NULL };
7506
const int argc = (sizeof(argv) / sizeof(char *)) - 1;
7507
7508
char *agent_directory = NULL;
7509
__attribute__((cleanup(cleanup_string)))
7510
char *helper_directory = NULL;
7511
uid_t user = 0;
7512
gid_t group = 0;
7513
__attribute__((cleanup(cleanup_string)))
7514
char *mandos_argz = NULL;
7515
size_t mandos_argz_length = 0;
7516
7517
g_assert_true(parse_arguments(argc, argv, false, &agent_directory,
7518
&helper_directory, &user, &group,
7519
&mandos_argz, &mandos_argz_length));
7520
7521
g_assert_null(helper_directory);
7522
g_assert_null(agent_directory);
7523
g_assert_true(user == 0);
7524
g_assert_cmpuint((unsigned int)group, ==, 1000);
7525
g_assert_null(mandos_argz);
7526
g_assert_true(mandos_argz_length == 0);
7527
7528
for(char **arg = argv; *arg != NULL; arg++){
7529
free(*arg);
7530
}
7531
}
7532
7533
static void test_parse_arguments_group_invalid(__attribute__((unused))
7534
test_fixture *fixture,
7535
__attribute__((unused))
7536
gconstpointer
7537
user_data){
7538
char *argv[] = {
7539
strdup("prgname"),
7540
strdup("--group"),
7541
strdup("invalid"),
7542
NULL };
7543
const int argc = (sizeof(argv) / sizeof(char *)) - 1;
7544
7545
char *agent_directory = NULL;
7546
__attribute__((cleanup(cleanup_string)))
7547
char *helper_directory = NULL;
7548
uid_t user = 0;
7549
gid_t group = 0;
7550
__attribute__((cleanup(cleanup_string)))
7551
char *mandos_argz = NULL;
7552
size_t mandos_argz_length = 0;
7553
7554
g_assert_false(parse_arguments_devnull(argc, argv, false,
7555
&agent_directory,
7556
&helper_directory, &user,
7557
&group, &mandos_argz,
7558
&mandos_argz_length));
7559
7560
g_assert_null(helper_directory);
7561
g_assert_null(agent_directory);
7562
g_assert_true(user == 0);
7563
g_assert_true(group == 0);
7564
g_assert_null(mandos_argz);
7565
g_assert_true(mandos_argz_length == 0);
7566
7567
for(char **arg = argv; *arg != NULL; arg++){
7568
free(*arg);
7569
}
7570
}
7571
7572
static
7573
void test_parse_arguments_group_zero_invalid(__attribute__((unused))
7574
test_fixture *fixture,
7575
__attribute__((unused))
7576
gconstpointer user_data){
7577
char *argv[] = {
7578
strdup("prgname"),
7579
strdup("--group"),
7580
strdup("0"),
7581
NULL };
7582
const int argc = (sizeof(argv) / sizeof(char *)) - 1;
7583
7584
char *agent_directory = NULL;
7585
__attribute__((cleanup(cleanup_string)))
7586
char *helper_directory = NULL;
7587
uid_t user = 0;
7588
gid_t group = 0;
7589
__attribute__((cleanup(cleanup_string)))
7590
char *mandos_argz = NULL;
7591
size_t mandos_argz_length = 0;
7592
7593
g_assert_false(parse_arguments_devnull(argc, argv, false,
7594
&agent_directory,
7595
&helper_directory, &user,
7596
&group, &mandos_argz,
7597
&mandos_argz_length));
7598
7599
g_assert_null(helper_directory);
7600
g_assert_null(agent_directory);
7601
g_assert_cmpuint((unsigned int)group, ==, 0);
7602
g_assert_true(group == 0);
7603
g_assert_null(mandos_argz);
7604
g_assert_true(mandos_argz_length == 0);
7605
7606
for(char **arg = argv; *arg != NULL; arg++){
7607
free(*arg);
7608
}
7609
}
7610
7611
static void test_parse_arguments_mandos_noargs(__attribute__((unused))
7612
test_fixture *fixture,
7613
__attribute__((unused))
7614
gconstpointer
7615
user_data){
7616
char *argv[] = {
7617
strdup("prgname"),
7618
strdup("mandos-client"),
7619
NULL };
7620
const int argc = (sizeof(argv) / sizeof(char *)) - 1;
7621
7622
__attribute__((cleanup(cleanup_string)))
7623
char *agent_directory = NULL;
7624
__attribute__((cleanup(cleanup_string)))
7625
char *helper_directory = NULL;
7626
uid_t user = 0;
7627
gid_t group = 0;
7628
__attribute__((cleanup(cleanup_string)))
7629
char *mandos_argz = NULL;
7630
size_t mandos_argz_length = 0;
7631
7632
g_assert_true(parse_arguments(argc, argv, false, &agent_directory,
7633
&helper_directory, &user, &group,
7634
&mandos_argz, &mandos_argz_length));
7635
7636
g_assert_null(agent_directory);
7637
g_assert_null(helper_directory);
7638
g_assert_true(user == 0);
7639
g_assert_true(group == 0);
7640
g_assert_cmpstr(mandos_argz, ==, "mandos-client");
7641
g_assert_cmpuint((unsigned int)argz_count(mandos_argz,
7642
mandos_argz_length),
7643
==, 1);
7644
7645
for(char **arg = argv; *arg != NULL; arg++){
7646
free(*arg);
7647
}
7648
}
7649
7650
static void test_parse_arguments_mandos_args(__attribute__((unused))
7651
test_fixture *fixture,
7652
__attribute__((unused))
7653
gconstpointer user_data){
7654
char *argv[] = {
7655
strdup("prgname"),
7656
strdup("mandos-client"),
7657
strdup("one"),
7658
strdup("two"),
7659
strdup("three"),
7660
NULL };
7661
const int argc = (sizeof(argv) / sizeof(char *)) - 1;
7662
7663
__attribute__((cleanup(cleanup_string)))
7664
char *agent_directory = NULL;
7665
__attribute__((cleanup(cleanup_string)))
7666
char *helper_directory = NULL;
7667
uid_t user = 0;
7668
gid_t group = 0;
7669
__attribute__((cleanup(cleanup_string)))
7670
char *mandos_argz = NULL;
7671
size_t mandos_argz_length = 0;
7672
7673
g_assert_true(parse_arguments(argc, argv, false, &agent_directory,
7674
&helper_directory, &user, &group,
7675
&mandos_argz, &mandos_argz_length));
7676
7677
g_assert_null(agent_directory);
7678
g_assert_null(helper_directory);
7679
g_assert_true(user == 0);
7680
g_assert_true(group == 0);
7681
char *marg = mandos_argz;
7682
g_assert_cmpstr(marg, ==, "mandos-client");
7683
marg = argz_next(mandos_argz, mandos_argz_length, marg);
7684
g_assert_cmpstr(marg, ==, "one");
7685
marg = argz_next(mandos_argz, mandos_argz_length, marg);
7686
g_assert_cmpstr(marg, ==, "two");
7687
marg = argz_next(mandos_argz, mandos_argz_length, marg);
7688
g_assert_cmpstr(marg, ==, "three");
7689
g_assert_cmpuint((unsigned int)argz_count(mandos_argz,
7690
mandos_argz_length),
7691
==, 4);
7692
7693
for(char **arg = argv; *arg != NULL; arg++){
7694
free(*arg);
7695
}
7696
}
7697
7698
static void test_parse_arguments_all_args(__attribute__((unused))
7699
test_fixture *fixture,
7700
__attribute__((unused))
7701
gconstpointer user_data){
7702
char *argv[] = {
7703
strdup("prgname"),
7704
strdup("--agent-directory"),
7705
strdup("/tmp"),
7706
strdup("--helper-directory"),
7707
strdup("/var/tmp"),
7708
strdup("--user"),
7709
strdup("1"),
7710
strdup("--group"),
7711
strdup("2"),
7712
strdup("mandos-client"),
7713
strdup("one"),
7714
strdup("two"),
7715
strdup("three"),
7716
NULL };
7717
const int argc = (sizeof(argv) / sizeof(char *)) - 1;
7718
7719
__attribute__((cleanup(cleanup_string)))
7720
char *agent_directory = NULL;
7721
__attribute__((cleanup(cleanup_string)))
7722
char *helper_directory = NULL;
7723
uid_t user = 0;
7724
gid_t group = 0;
7725
__attribute__((cleanup(cleanup_string)))
7726
char *mandos_argz = NULL;
7727
size_t mandos_argz_length = 0;
7728
7729
g_assert_true(parse_arguments(argc, argv, false, &agent_directory,
7730
&helper_directory, &user, &group,
7731
&mandos_argz, &mandos_argz_length));
7732
7733
g_assert_cmpstr(agent_directory, ==, "/tmp");
7734
g_assert_cmpstr(helper_directory, ==, "/var/tmp");
7735
g_assert_true(user == 1);
7736
g_assert_true(group == 2);
7737
char *marg = mandos_argz;
7738
g_assert_cmpstr(marg, ==, "mandos-client");
7739
marg = argz_next(mandos_argz, mandos_argz_length, marg);
7740
g_assert_cmpstr(marg, ==, "one");
7741
marg = argz_next(mandos_argz, mandos_argz_length, marg);
7742
g_assert_cmpstr(marg, ==, "two");
7743
marg = argz_next(mandos_argz, mandos_argz_length, marg);
7744
g_assert_cmpstr(marg, ==, "three");
7745
g_assert_cmpuint((unsigned int)argz_count(mandos_argz,
7746
mandos_argz_length),
7747
==, 4);
7748
7749
for(char **arg = argv; *arg != NULL; arg++){
7750
free(*arg);
7751
}
7752
}
7753
7754
static void test_parse_arguments_mixed(__attribute__((unused))
7755
test_fixture *fixture,
7756
__attribute__((unused))
7757
gconstpointer user_data){
7758
char *argv[] = {
7759
strdup("prgname"),
7760
strdup("mandos-client"),
7761
strdup("--user"),
7762
strdup("1"),
7763
strdup("one"),
7764
strdup("--agent-directory"),
7765
strdup("/tmp"),
7766
strdup("two"),
7767
strdup("three"),
7768
strdup("--helper-directory=/var/tmp"),
7769
NULL };
7770
const int argc = (sizeof(argv) / sizeof(char *)) - 1;
7771
7772
__attribute__((cleanup(cleanup_string)))
7773
char *agent_directory = NULL;
7774
__attribute__((cleanup(cleanup_string)))
7775
char *helper_directory = NULL;
7776
uid_t user = 0;
7777
gid_t group = 0;
7778
__attribute__((cleanup(cleanup_string)))
7779
char *mandos_argz = NULL;
7780
size_t mandos_argz_length = 0;
7781
7782
g_assert_true(parse_arguments(argc, argv, false, &agent_directory,
7783
&helper_directory, &user, &group,
7784
&mandos_argz, &mandos_argz_length));
7785
7786
g_assert_cmpstr(agent_directory, ==, "/tmp");
7787
g_assert_cmpstr(helper_directory, ==, "/var/tmp");
7788
g_assert_true(user == 1);
7789
g_assert_true(group == 0);
7790
char *marg = mandos_argz;
7791
g_assert_cmpstr(marg, ==, "mandos-client");
7792
marg = argz_next(mandos_argz, mandos_argz_length, marg);
7793
g_assert_cmpstr(marg, ==, "one");
7794
marg = argz_next(mandos_argz, mandos_argz_length, marg);
7795
g_assert_cmpstr(marg, ==, "two");
7796
marg = argz_next(mandos_argz, mandos_argz_length, marg);
7797
g_assert_cmpstr(marg, ==, "three");
7798
g_assert_cmpuint((unsigned int)argz_count(mandos_argz,
7799
mandos_argz_length),
7800
==, 4);
7801
7802
for(char **arg = argv; *arg != NULL; arg++){
7803
free(*arg);
7804
}
7805
}
7806
7807
/* End of tests section */
7808
7809
/* Test boilerplate section; New tests should be added to the test
7810
suite definition here, in the "run_tests" function.
7811
7812
Finally, this section also contains the should_only_run_tests()
7813
function used by main() for deciding if tests should be run or to
7814
start normally. */
7815
7816
__attribute__((cold))
7817
static bool run_tests(int argc, char *argv[]){
7818
g_test_init(&argc, &argv, NULL);
7819
7820
/* A macro to add a test with no setup or teardown functions */
7821
#define test_add(testpath, testfunc) \
7822
do { \
7823
g_test_add((testpath), test_fixture, NULL, NULL, \
7824
(testfunc), NULL); \
7825
} while(false)
7826
7827
/* Test the signal-related functions first, since some other tests
7828
depend on these functions in their setups and teardowns */
7829
test_add("/signal-handling/setup", test_setup_signal_handler);
7830
test_add("/signal-handling/restore", test_restore_signal_handler);
7831
test_add("/signal-handling/block", test_block_sigchld);
7832
test_add("/signal-handling/restore-sigmask", test_restore_sigmask);
7833
7834
/* Regular non-signal-related tests; these use no setups or
7835
teardowns */
7836
test_add("/parse_arguments/noargs", test_parse_arguments_noargs);
7837
test_add("/parse_arguments/invalid", test_parse_arguments_invalid);
7838
test_add("/parse_arguments/long-dir",
7839
test_parse_arguments_long_dir);
7840
test_add("/parse_arguments/short-dir",
7841
test_parse_arguments_short_dir);
7842
test_add("/parse_arguments/helper-directory",
7843
test_parse_arguments_helper_directory);
7844
test_add("/parse_arguments/plugin-helper-dir",
7845
test_parse_arguments_plugin_helper_dir);
7846
test_add("/parse_arguments/user", test_parse_arguments_user);
7847
test_add("/parse_arguments/user-invalid",
7848
test_parse_arguments_user_invalid);
7849
test_add("/parse_arguments/user-zero-invalid",
7850
test_parse_arguments_user_zero_invalid);
7851
test_add("/parse_arguments/group", test_parse_arguments_group);
7852
test_add("/parse_arguments/group-invalid",
7853
test_parse_arguments_group_invalid);
7854
test_add("/parse_arguments/group-zero-invalid",
7855
test_parse_arguments_group_zero_invalid);
7856
test_add("/parse_arguments/mandos-noargs",
7857
test_parse_arguments_mandos_noargs);
7858
test_add("/parse_arguments/mandos-args",
7859
test_parse_arguments_mandos_args);
7860
test_add("/parse_arguments/all-args",
7861
test_parse_arguments_all_args);
7862
test_add("/parse_arguments/mixed", test_parse_arguments_mixed);
7863
test_add("/queue/create", test_create_queue);
7864
test_add("/queue/add", test_add_to_queue);
7865
test_add("/queue/has_question/empty",
7866
test_queue_has_question_empty);
7867
test_add("/queue/has_question/false",
7868
test_queue_has_question_false);
7869
test_add("/queue/has_question/true", test_queue_has_question_true);
7870
test_add("/queue/has_question/false2",
7871
test_queue_has_question_false2);
7872
test_add("/queue/has_question/true2",
7873
test_queue_has_question_true2);
7874
test_add("/buffer/cleanup", test_cleanup_buffer);
7875
test_add("/string_set/net-set-contains-nothing",
7876
test_string_set_new_set_contains_nothing);
7877
test_add("/string_set/with-added-string-contains-it",
7878
test_string_set_with_added_string_contains_it);
7879
test_add("/string_set/cleared-does-not-contain-string",
7880
test_string_set_cleared_does_not_contain_str);
7881
test_add("/string_set/swap/one-with-empty",
7882
test_string_set_swap_one_with_empty);
7883
test_add("/string_set/swap/empty-with-one",
7884
test_string_set_swap_empty_with_one);
7885
test_add("/string_set/swap/one-with-one",
7886
test_string_set_swap_one_with_one);
7887
7888
/* A macro to add a test using the setup and teardown functions */
7889
#define test_add_st(path, func) \
7890
do { \
7891
g_test_add((path), test_fixture, NULL, test_setup, (func), \
7892
test_teardown); \
7893
} while(false)
7894
7895
/* Signal-related tests; these use setups and teardowns which
7896
establish, during each test run, a signal handler for, and a
7897
signal mask blocking, the SIGCHLD signal, just like main() */
7898
test_add_st("/wait_for_event/timeout", test_wait_for_event_timeout);
7899
test_add_st("/wait_for_event/event", test_wait_for_event_event);
7900
test_add_st("/wait_for_event/sigchld", test_wait_for_event_sigchld);
7901
test_add_st("/run_queue/zeroes-next-run",
7902
test_run_queue_zeroes_next_run);
7903
test_add_st("/run_queue/clears-cancelled_filenames",
7904
test_run_queue_clears_cancelled_filenames);
7905
test_add_st("/run_queue/skips-cancelled-filenames",
7906
test_run_queue_skips_cancelled_filenames);
7907
test_add_st("/run_queue/one-task", test_run_queue_one_task);
7908
test_add_st("/run_queue/two-tasks", test_run_queue_two_tasks);
7909
test_add_st("/run_queue/two-tasks/quit",
7910
test_run_queue_two_tasks_quit);
7911
test_add_st("/run_queue/two-tasks-cleanup",
7912
test_run_queue_two_tasks_cleanup);
7913
test_add_st("/task-creators/start_mandos_client",
7914
test_start_mandos_client);
7915
test_add_st("/task-creators/start_mandos_client/execv",
7916
test_start_mandos_client_execv);
7917
test_add_st("/task-creators/start_mandos_client/suid/euid",
7918
test_start_mandos_client_suid_euid);
7919
test_add_st("/task-creators/start_mandos_client/suid/egid",
7920
test_start_mandos_client_suid_egid);
7921
test_add_st("/task-creators/start_mandos_client/suid/ruid",
7922
test_start_mandos_client_suid_ruid);
7923
test_add_st("/task-creators/start_mandos_client/suid/rgid",
7924
test_start_mandos_client_suid_rgid);
7925
test_add_st("/task-creators/start_mandos_client/read",
7926
test_start_mandos_client_read);
7927
test_add_st("/task-creators/start_mandos_client/helper-directory",
7928
test_start_mandos_client_helper_directory);
7929
test_add_st("/task-creators/start_mandos_client/sigmask",
7930
test_start_mandos_client_sigmask);
7931
test_add_st("/task/wait_for_mandos_client_exit/badpid",
7932
test_wait_for_mandos_client_exit_badpid);
7933
test_add_st("/task/wait_for_mandos_client_exit/noexit",
7934
test_wait_for_mandos_client_exit_noexit);
7935
test_add_st("/task/wait_for_mandos_client_exit/success",
7936
test_wait_for_mandos_client_exit_success);
7937
test_add_st("/task/wait_for_mandos_client_exit/failure",
7938
test_wait_for_mandos_client_exit_failure);
7939
test_add_st("/task/wait_for_mandos_client_exit/killed",
7940
test_wait_for_mandos_client_exit_killed);
7941
test_add_st("/task/read_mandos_client_output/readerror",
7942
test_read_mandos_client_output_readerror);
7943
test_add_st("/task/read_mandos_client_output/nodata",
7944
test_read_mandos_client_output_nodata);
7945
test_add_st("/task/read_mandos_client_output/eof",
7946
test_read_mandos_client_output_eof);
7947
test_add_st("/task/read_mandos_client_output/once",
7948
test_read_mandos_client_output_once);
7949
test_add_st("/task/read_mandos_client_output/malloc",
7950
test_read_mandos_client_output_malloc);
7951
test_add_st("/task/read_mandos_client_output/append",
7952
test_read_mandos_client_output_append);
7953
test_add_st("/task-creators/add_inotify_dir_watch",
7954
test_add_inotify_dir_watch);
7955
test_add_st("/task-creators/add_inotify_dir_watch/fail",
7956
test_add_inotify_dir_watch_fail);
7957
test_add_st("/task-creators/add_inotify_dir_watch/not-a-directory",
7958
test_add_inotify_dir_watch_nondir);
7959
test_add_st("/task-creators/add_inotify_dir_watch/EAGAIN",
7960
test_add_inotify_dir_watch_EAGAIN);
7961
test_add_st("/task-creators/add_inotify_dir_watch/IN_CLOSE_WRITE",
7962
test_add_inotify_dir_watch_IN_CLOSE_WRITE);
7963
test_add_st("/task-creators/add_inotify_dir_watch/IN_MOVED_TO",
7964
test_add_inotify_dir_watch_IN_MOVED_TO);
7965
test_add_st("/task-creators/add_inotify_dir_watch/IN_MOVED_FROM",
7966
test_add_inotify_dir_watch_IN_MOVED_FROM);
7967
test_add_st("/task-creators/add_inotify_dir_watch/IN_EXCL_UNLINK",
7968
test_add_inotify_dir_watch_IN_EXCL_UNLINK);
7969
test_add_st("/task-creators/add_inotify_dir_watch/IN_DELETE",
7970
test_add_inotify_dir_watch_IN_DELETE);
7971
test_add_st("/task/read_inotify_event/readerror",
7972
test_read_inotify_event_readerror);
7973
test_add_st("/task/read_inotify_event/bad-epoll",
7974
test_read_inotify_event_bad_epoll);
7975
test_add_st("/task/read_inotify_event/nodata",
7976
test_read_inotify_event_nodata);
7977
test_add_st("/task/read_inotify_event/eof",
7978
test_read_inotify_event_eof);
7979
test_add_st("/task/read_inotify_event/IN_CLOSE_WRITE",
7980
test_read_inotify_event_IN_CLOSE_WRITE);
7981
test_add_st("/task/read_inotify_event/IN_MOVED_TO",
7982
test_read_inotify_event_IN_MOVED_TO);
7983
test_add_st("/task/read_inotify_event/IN_MOVED_FROM",
7984
test_read_inotify_event_IN_MOVED_FROM);
7985
test_add_st("/task/read_inotify_event/IN_DELETE",
7986
test_read_inotify_event_IN_DELETE);
7987
test_add_st("/task/read_inotify_event/IN_CLOSE_WRITE/badname",
7988
test_read_inotify_event_IN_CLOSE_WRITE_badname);
7989
test_add_st("/task/read_inotify_event/IN_MOVED_TO/badname",
7990
test_read_inotify_event_IN_MOVED_TO_badname);
7991
test_add_st("/task/read_inotify_event/IN_MOVED_FROM/badname",
7992
test_read_inotify_event_IN_MOVED_FROM_badname);
7993
test_add_st("/task/read_inotify_event/IN_DELETE/badname",
7994
test_read_inotify_event_IN_DELETE_badname);
7995
test_add_st("/task/open_and_parse_question/ENOENT",
7996
test_open_and_parse_question_ENOENT);
7997
test_add_st("/task/open_and_parse_question/EIO",
7998
test_open_and_parse_question_EIO);
7999
test_add_st("/task/open_and_parse_question/parse-error",
8000
test_open_and_parse_question_parse_error);
8001
test_add_st("/task/open_and_parse_question/nosocket",
8002
test_open_and_parse_question_nosocket);
8003
test_add_st("/task/open_and_parse_question/badsocket",
8004
test_open_and_parse_question_badsocket);
8005
test_add_st("/task/open_and_parse_question/nopid",
8006
test_open_and_parse_question_nopid);
8007
test_add_st("/task/open_and_parse_question/badpid",
8008
test_open_and_parse_question_badpid);
8009
test_add_st("/task/open_and_parse_question/noexist_pid",
8010
test_open_and_parse_question_noexist_pid);
8011
test_add_st("/task/open_and_parse_question/no-notafter",
8012
test_open_and_parse_question_no_notafter);
8013
test_add_st("/task/open_and_parse_question/bad-notafter",
8014
test_open_and_parse_question_bad_notafter);
8015
test_add_st("/task/open_and_parse_question/notafter-0",
8016
test_open_and_parse_question_notafter_0);
8017
test_add_st("/task/open_and_parse_question/notafter-1",
8018
test_open_and_parse_question_notafter_1);
8019
test_add_st("/task/open_and_parse_question/notafter-1-1",
8020
test_open_and_parse_question_notafter_1_1);
8021
test_add_st("/task/open_and_parse_question/notafter-1-2",
8022
test_open_and_parse_question_notafter_1_2);
8023
test_add_st("/task/open_and_parse_question/equal-notafter",
8024
test_open_and_parse_question_equal_notafter);
8025
test_add_st("/task/open_and_parse_question/late-notafter",
8026
test_open_and_parse_question_late_notafter);
8027
test_add_st("/task/cancel_old_question/0-1-2",
8028
test_cancel_old_question_0_1_2);
8029
test_add_st("/task/cancel_old_question/0-2-1",
8030
test_cancel_old_question_0_2_1);
8031
test_add_st("/task/cancel_old_question/1-2-3",
8032
test_cancel_old_question_1_2_3);
8033
test_add_st("/task/cancel_old_question/1-3-2",
8034
test_cancel_old_question_1_3_2);
8035
test_add_st("/task/cancel_old_question/2-1-3",
8036
test_cancel_old_question_2_1_3);
8037
test_add_st("/task/cancel_old_question/2-3-1",
8038
test_cancel_old_question_2_3_1);
8039
test_add_st("/task/cancel_old_question/3-1-2",
8040
test_cancel_old_question_3_1_2);
8041
test_add_st("/task/cancel_old_question/3-2-1",
8042
test_cancel_old_question_3_2_1);
8043
test_add_st("/task/connect_question_socket/name-too-long",
8044
test_connect_question_socket_name_too_long);
8045
test_add_st("/task/connect_question_socket/connect-fail",
8046
test_connect_question_socket_connect_fail);
8047
test_add_st("/task/connect_question_socket/bad-epoll",
8048
test_connect_question_socket_bad_epoll);
8049
test_add_st("/task/connect_question_socket/usable",
8050
test_connect_question_socket_usable);
8051
test_add_st("/task/send_password_to_socket/client-not-exited",
8052
test_send_password_to_socket_client_not_exited);
8053
test_add_st("/task/send_password_to_socket/password-not-read",
8054
test_send_password_to_socket_password_not_read);
8055
test_add_st("/task/send_password_to_socket/EMSGSIZE",
8056
test_send_password_to_socket_EMSGSIZE);
8057
test_add_st("/task/send_password_to_socket/retry",
8058
test_send_password_to_socket_retry);
8059
test_add_st("/task/send_password_to_socket/bad-epoll",
8060
test_send_password_to_socket_bad_epoll);
8061
test_add_st("/task/send_password_to_socket/null-password",
8062
test_send_password_to_socket_null_password);
8063
test_add_st("/task/send_password_to_socket/empty-password",
8064
test_send_password_to_socket_empty_password);
8065
test_add_st("/task/send_password_to_socket/empty-str-password",
8066
test_send_password_to_socket_empty_str_pass);
8067
test_add_st("/task/send_password_to_socket/text-password",
8068
test_send_password_to_socket_text_password);
8069
test_add_st("/task/send_password_to_socket/binary-password",
8070
test_send_password_to_socket_binary_password);
8071
test_add_st("/task/send_password_to_socket/nuls-in-password",
8072
test_send_password_to_socket_nuls_in_password);
8073
test_add_st("/task-creators/add_existing_questions/ENOENT",
8074
test_add_existing_questions_ENOENT);
8075
test_add_st("/task-creators/add_existing_questions/no-questions",
8076
test_add_existing_questions_no_questions);
8077
test_add_st("/task-creators/add_existing_questions/one-question",
8078
test_add_existing_questions_one_question);
8079
test_add_st("/task-creators/add_existing_questions/two-questions",
8080
test_add_existing_questions_two_questions);
8081
test_add_st("/task-creators/add_existing_questions/non-questions",
8082
test_add_existing_questions_non_questions);
8083
test_add_st("/task-creators/add_existing_questions/both-types",
8084
test_add_existing_questions_both_types);
8085
8086
return g_test_run() == 0;
8087
}
8088
8089
static bool should_only_run_tests(int *argc_p, char **argv_p[]){
8090
GOptionContext *context = g_option_context_new("");
8091
8092
g_option_context_set_help_enabled(context, FALSE);
8093
g_option_context_set_ignore_unknown_options(context, TRUE);
8094
8095
gboolean run_tests = FALSE;
8096
GOptionEntry entries[] = {
8097
{ "test", 0, 0, G_OPTION_ARG_NONE,
8098
&run_tests, "Run tests", NULL },
8099
{ NULL }
8100
};
8101
g_option_context_add_main_entries(context, entries, NULL);
8102
8103
GError *error = NULL;
8104
8105
if(g_option_context_parse(context, argc_p, argv_p, &error) != TRUE){
8106
g_option_context_free(context);
8107
g_error("Failed to parse options: %s", error->message);
8108
}
8109
8110
g_option_context_free(context);
8111
return run_tests != FALSE;
8112
}
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0