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