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