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