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