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