/mandos/trunk

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

  • Committer: Teddy Hogeborn
  • Date: 2013-06-23 15:30:34 UTC
  • Revision ID: teddy@recompile.se-20130623153034-u8oty17y51oc0xnl
TODO change only

Show diffs side-by-side

added added

removed removed

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