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