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