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