/mandos/release

To get this branch, use:
bzr branch http://bzr.recompile.se/loggerhead/mandos/release

« back to all changes in this revision

Viewing changes to dracut-module/password-agent.c

  • Committer: teddy at recompile
  • Date: 2020-07-04 12:46:00 UTC
  • mfrom: (237.7.766 trunk)
  • Revision ID: teddy@recompile.se-20200704124600-1w34wbcah16i3dgf
Merge from trunk

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-2020 Teddy Hogeborn
 
6
 * Copyright © 2019-2020 Björn Påhlsson
 
7
 * 
 
8
 * This file is part of Mandos.
 
9
 * 
 
10
 * Mandos is free software: you can redistribute it and/or modify it
 
11
 * under the terms of the GNU General Public License as published by
 
12
 * the Free Software Foundation, either version 3 of the License, or
 
13
 * (at your option) any later version.
 
14
 * 
 
15
 * Mandos is distributed in the hope that it will be useful, but
 
16
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 
17
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 
18
 * General Public License for more details.
 
19
 * 
 
20
 * You should have received a copy of the GNU General Public License
 
21
 * along with Mandos.  If not, see <http://www.gnu.org/licenses/>.
 
22
 * 
 
23
 * Contact the authors at <mandos@recompile.se>.
 
24
 */
 
25
 
 
26
#define _GNU_SOURCE
 
27
#include <inttypes.h>           /* uintmax_t, PRIuMAX, PRIdMAX,
 
28
                                   intmax_t, uint32_t, SCNx32,
 
29
                                   SCNuMAX, SCNxMAX */
 
30
#include <stddef.h>             /* size_t */
 
31
#include <sys/types.h>          /* pid_t, uid_t, gid_t, getuid(),
 
32
                                   getpid() */
 
33
#include <stdbool.h>            /* bool, true, false */
 
34
#include <signal.h>             /* struct sigaction, sigset_t,
 
35
                                   sigemptyset(), sigaddset(),
 
36
                                   SIGCHLD, pthread_sigmask(),
 
37
                                   SIG_BLOCK, SIG_SETMASK, SA_RESTART,
 
38
                                   SA_NOCLDSTOP, sigfillset(), kill(),
 
39
                                   SIGTERM, sigdelset(), SIGKILL,
 
40
                                   NSIG, sigismember(), SA_ONSTACK,
 
41
                                   SIG_DFL, SIG_IGN, SIGINT, SIGQUIT,
 
42
                                   SIGHUP, SIGSTOP, SIG_UNBLOCK */
 
43
#include <stdlib.h>             /* EXIT_SUCCESS, EXIT_FAILURE,
 
44
                                   malloc(), free(), strtoumax(),
 
45
                                   realloc(), setenv(), calloc(),
 
46
                                   mkdtemp(), mkostemp() */
 
47
#include <iso646.h>             /* not, or, and, xor */
 
48
#include <error.h>              /* error() */
 
49
#include <sysexits.h>           /* EX_USAGE, EX_OSERR, EX_OSFILE */
 
50
#include <errno.h>              /* errno, error_t, EACCES,
 
51
                                   ENAMETOOLONG, ENOENT, ENOTDIR,
 
52
                                   ENOMEM, EEXIST, ECHILD, EPERM,
 
53
                                   EAGAIN, EINTR, ENOBUFS, EADDRINUSE,
 
54
                                   ECONNREFUSED, ECONNRESET,
 
55
                                   ETOOMANYREFS, EMSGSIZE, EBADF,
 
56
                                   EINVAL */
 
57
#include <string.h>             /* strdup(), memcpy(),
 
58
                                   explicit_bzero(), memset(),
 
59
                                   strcmp(), strlen(), strncpy(),
 
60
                                   memcmp(), basename() */
 
61
#include <argz.h>               /* argz_create(), argz_count(),
 
62
                                   argz_extract(), argz_next(),
 
63
                                   argz_add() */
 
64
#include <sys/epoll.h>          /* epoll_create1(), EPOLL_CLOEXEC,
 
65
                                   epoll_ctl(), EPOLL_CTL_ADD,
 
66
                                   struct epoll_event, EPOLLIN,
 
67
                                   EPOLLRDHUP, EPOLLOUT,
 
68
                                   epoll_pwait() */
 
69
#include <time.h>               /* struct timespec, clock_gettime(),
 
70
                                   CLOCK_MONOTONIC */
 
71
#include <argp.h>               /* struct argp_option, OPTION_HIDDEN,
 
72
                                   OPTION_ALIAS, struct argp_state,
 
73
                                   ARGP_ERR_UNKNOWN, ARGP_KEY_ARGS,
 
74
                                   struct argp, argp_parse(),
 
75
                                   ARGP_NO_EXIT */
 
76
#include <stdint.h>             /* SIZE_MAX */
 
77
#include <unistd.h>             /* uid_t, gid_t, close(), pipe2(),
 
78
                                   fork(), _exit(), dup2(),
 
79
                                   STDOUT_FILENO, setresgid(),
 
80
                                   setresuid(), execv(), ssize_t,
 
81
                                   read(), dup3(), getuid(), dup(),
 
82
                                   STDERR_FILENO, pause(), write(),
 
83
                                   rmdir(), unlink(), getpid() */
 
84
#include <sys/mman.h>           /* munlock(), mlock() */
 
85
#include <fcntl.h>              /* O_CLOEXEC, O_NONBLOCK, fcntl(),
 
86
                                   F_GETFD, F_GETFL, FD_CLOEXEC,
 
87
                                   open(), O_WRONLY, O_NOCTTY,
 
88
                                   O_RDONLY, O_NOFOLLOW */
 
89
#include <sys/wait.h>           /* waitpid(), WNOHANG, WIFEXITED(),
 
90
                                   WEXITSTATUS() */
 
91
#include <limits.h>             /* PIPE_BUF, NAME_MAX, INT_MAX */
 
92
#include <sys/inotify.h>        /* inotify_init1(), IN_NONBLOCK,
 
93
                                   IN_CLOEXEC, inotify_add_watch(),
 
94
                                   IN_CLOSE_WRITE, IN_MOVED_TO,
 
95
                                   IN_MOVED_FROM, IN_DELETE,
 
96
                                   IN_EXCL_UNLINK, IN_ONLYDIR,
 
97
                                   struct inotify_event */
 
98
#include <fnmatch.h>            /* fnmatch(), FNM_FILE_NAME */
 
99
#include <stdio.h>              /* asprintf(), FILE, stderr, fopen(),
 
100
                                   fclose(), getline(), sscanf(),
 
101
                                   feof(), ferror(), rename(),
 
102
                                   fdopen(), fprintf(), fscanf() */
 
103
#include <glib.h>    /* GKeyFile, g_key_file_free(), g_key_file_new(),
 
104
                        GError, g_key_file_load_from_file(),
 
105
                        G_KEY_FILE_NONE, TRUE, G_FILE_ERROR_NOENT,
 
106
                        g_key_file_get_string(), guint64,
 
107
                        g_key_file_get_uint64(),
 
108
                        G_KEY_FILE_ERROR_KEY_NOT_FOUND, gconstpointer,
 
109
                        g_assert_true(), g_assert_nonnull(),
 
110
                        g_assert_null(), g_assert_false(),
 
111
                        g_assert_cmpint(), g_assert_cmpuint(),
 
112
                        g_test_skip(), g_assert_cmpstr(),
 
113
                        g_test_init(), g_test_add(), g_test_run(),
 
114
                        GOptionContext, g_option_context_new(),
 
115
                        g_option_context_set_help_enabled(), FALSE,
 
116
                        g_option_context_set_ignore_unknown_options(),
 
117
                        gboolean, GOptionEntry, G_OPTION_ARG_NONE,
 
118
                        g_option_context_add_main_entries(),
 
119
                        g_option_context_parse(),
 
120
                        g_option_context_free(), g_error() */
 
121
#include <sys/un.h>             /* struct sockaddr_un, SUN_LEN */
 
122
#include <sys/socket.h>         /* AF_LOCAL, socket(), PF_LOCAL,
 
123
                                   SOCK_DGRAM, SOCK_NONBLOCK,
 
124
                                   SOCK_CLOEXEC, connect(),
 
125
                                   struct sockaddr, socklen_t,
 
126
                                   shutdown(), SHUT_RD, send(),
 
127
                                   MSG_NOSIGNAL, bind(), recv(),
 
128
                                   socketpair() */
 
129
#include <glob.h>               /* globfree(), glob_t, glob(),
 
130
                                   GLOB_ERR, GLOB_NOSORT, GLOB_MARK,
 
131
                                   GLOB_ABORTED, GLOB_NOMATCH,
 
132
                                   GLOB_NOSPACE */
 
133
 
 
134
/* End of includes */
 
135
 
 
136
/* Start of declarations of private types and functions */
 
137
 
 
138
/* microseconds of CLOCK_MONOTONIC absolute time; 0 means unset */
 
139
typedef uintmax_t mono_microsecs;
 
140
 
 
141
/* "task_queue" - A queue of tasks to be run */
 
142
typedef struct {
 
143
  struct task_struct *tasks;    /* Tasks in this queue */
 
144
  size_t length;                /* Number of tasks */
 
145
  /* Memory allocated for "tasks", in bytes */
 
146
  size_t allocated;             
 
147
  /* Time when this queue should be run, at the latest */
 
148
  mono_microsecs next_run;
 
149
} __attribute__((designated_init)) task_queue;
 
150
 
 
151
/* "task_func" - A function type for task functions
 
152
 
 
153
   I.e. functions for the code which runs when a task is run, all have
 
154
   this type */
 
155
typedef void (task_func) (const struct task_struct,
 
156
                          task_queue *const)
 
157
  __attribute__((nonnull));
 
158
 
 
159
/* "buffer" - A data buffer for a growing array of bytes
 
160
 
 
161
   Used for the "password" variable */
 
162
typedef struct {
 
163
  char *data;
 
164
  size_t length;
 
165
  size_t allocated;
 
166
} __attribute__((designated_init)) buffer;
 
167
 
 
168
/* "string_set" - A set type which can contain strings
 
169
 
 
170
   Used by the "cancelled_filenames" variable */
 
171
typedef struct {
 
172
  char *argz;                   /* Do not access these except in */
 
173
  size_t argz_len;              /* the string_set_* functions */
 
174
} __attribute__((designated_init)) string_set;
 
175
 
 
176
/* "task_context" - local variables for tasks
 
177
 
 
178
   This data structure distinguishes between different tasks which are
 
179
   using the same function.  This data structure is passed to every
 
180
   task function when each task is run.
 
181
 
 
182
   Note that not every task uses every struct member. */
 
183
typedef struct task_struct {
 
184
  task_func *const func;         /* The function run by this task */
 
185
  char *const question_filename; /* The question file */
 
186
  const pid_t pid;               /* Mandos client process ID */
 
187
  const int epoll_fd;            /* The epoll set file descriptor */
 
188
  bool *const quit_now;          /* Set to true on fatal errors */
 
189
  const int fd;                  /* General purpose file descriptor */
 
190
  bool *const mandos_client_exited; /* Set true when client exits */
 
191
  buffer *const password;           /* As read from client process */
 
192
  bool *const password_is_read;     /* "password" is done growing */
 
193
  char *filename;                   /* General purpose file name */
 
194
  /* A set of strings of all the file names of questions which have
 
195
     been cancelled for any reason; tasks pertaining to these question
 
196
     files should not be run */
 
197
  string_set *const cancelled_filenames;
 
198
  const mono_microsecs notafter; /* "NotAfter" from question file */
 
199
  /* Updated before each queue run; is compared with queue.next_run */
 
200
  const mono_microsecs *const current_time;
 
201
} __attribute__((designated_init)) task_context;
 
202
 
 
203
/* Declare all our functions here so we can define them in any order
 
204
   below.  Note: test functions are *not* declared here, they are
 
205
   declared in the test section. */
 
206
__attribute__((warn_unused_result))
 
207
static bool should_only_run_tests(int *, char **[]);
 
208
__attribute__((warn_unused_result, cold))
 
209
static bool run_tests(int, char *[]);
 
210
static void handle_sigchld(__attribute__((unused)) int sig){}
 
211
__attribute__((warn_unused_result, malloc))
 
212
task_queue *create_queue(void);
 
213
__attribute__((nonnull, warn_unused_result))
 
214
bool add_to_queue(task_queue *const, const task_context);
 
215
__attribute__((nonnull))
 
216
void cleanup_task(const task_context *const);
 
217
__attribute__((nonnull))
 
218
void cleanup_queue(task_queue *const *const);
 
219
__attribute__((pure, nonnull, warn_unused_result))
 
220
bool queue_has_question(const task_queue *const);
 
221
__attribute__((nonnull))
 
222
void cleanup_close(const int *const);
 
223
__attribute__((nonnull))
 
224
void cleanup_string(char *const *const);
 
225
__attribute__((nonnull))
 
226
void cleanup_buffer(buffer *const);
 
227
__attribute__((pure, nonnull, warn_unused_result))
 
228
bool string_set_contains(const string_set, const char *const);
 
229
__attribute__((nonnull, warn_unused_result))
 
230
bool string_set_add(string_set *const, const char *const);
 
231
__attribute__((nonnull))
 
232
void string_set_clear(string_set *);
 
233
void string_set_swap(string_set *const, string_set *const);
 
234
__attribute__((nonnull, warn_unused_result))
 
235
bool start_mandos_client(task_queue *const, const int, bool *const,
 
236
                         bool *const, buffer *const, bool *const,
 
237
                         const struct sigaction *const,
 
238
                         const sigset_t, const char *const,
 
239
                         const uid_t, const gid_t,
 
240
                         const char *const *const);
 
241
__attribute__((nonnull))
 
242
task_func wait_for_mandos_client_exit;
 
243
__attribute__((nonnull))
 
244
task_func read_mandos_client_output;
 
245
__attribute__((warn_unused_result))
 
246
bool add_inotify_dir_watch(task_queue *const, const int, bool *const,
 
247
                           buffer *const, const char *const,
 
248
                           string_set *, const mono_microsecs *const,
 
249
                           bool *const, bool *const);
 
250
__attribute__((nonnull))
 
251
task_func read_inotify_event;
 
252
__attribute__((nonnull))
 
253
task_func open_and_parse_question;
 
254
__attribute__((nonnull))
 
255
task_func cancel_old_question;
 
256
__attribute__((nonnull))
 
257
task_func connect_question_socket;
 
258
__attribute__((nonnull))
 
259
task_func send_password_to_socket;
 
260
__attribute__((warn_unused_result))
 
261
bool add_existing_questions(task_queue *const, const int,
 
262
                            buffer *const, string_set *,
 
263
                            const mono_microsecs *const,
 
264
                            bool *const, bool *const,
 
265
                            const char *const);
 
266
__attribute__((nonnull, warn_unused_result))
 
267
bool wait_for_event(const int, const mono_microsecs,
 
268
                    const mono_microsecs);
 
269
bool run_queue(task_queue **const, string_set *const, bool *const);
 
270
bool clear_all_fds_from_epoll_set(const int);
 
271
mono_microsecs get_current_time(void);
 
272
__attribute__((nonnull, warn_unused_result))
 
273
bool setup_signal_handler(struct sigaction *const);
 
274
__attribute__((nonnull))
 
275
bool restore_signal_handler(const struct sigaction *const);
 
276
__attribute__((nonnull, warn_unused_result))
 
277
bool block_sigchld(sigset_t *const);
 
278
__attribute__((nonnull))
 
279
bool restore_sigmask(const sigset_t *const);
 
280
__attribute__((nonnull))
 
281
bool parse_arguments(int, char *[], const bool, char **, char **,
 
282
                     uid_t *const , gid_t *const, char **, size_t *);
 
283
 
 
284
/* End of declarations of private types and functions */
 
285
 
 
286
/* Start of "main" section; this section LACKS TESTS!
 
287
 
 
288
   Code here should be as simple as possible. */
 
289
 
 
290
/* These are required to be global by Argp */
 
291
const char *argp_program_version = "password-agent " VERSION;
 
292
const char *argp_program_bug_address = "<mandos@recompile.se>";
 
293
 
 
294
int main(int argc, char *argv[]){
 
295
 
 
296
  /* If the --test option is passed, skip all normal operations and
 
297
     instead only run the run_tests() function, which also does all
 
298
     its own option parsing, so we don't have to do anything here. */
 
299
  if(should_only_run_tests(&argc, &argv)){
 
300
    if(run_tests(argc, argv)){
 
301
      return EXIT_SUCCESS;      /* All tests successful */
 
302
    }
 
303
    return EXIT_FAILURE;        /* Some test(s) failed */
 
304
  }
 
305
 
 
306
  __attribute__((cleanup(cleanup_string)))
 
307
    char *agent_directory = NULL;
 
308
 
 
309
  __attribute__((cleanup(cleanup_string)))
 
310
    char *helper_directory = NULL;
 
311
 
 
312
  uid_t user = 0;
 
313
  gid_t group = 0;
 
314
 
 
315
  __attribute__((cleanup(cleanup_string)))
 
316
    char *mandos_argz = NULL;
 
317
  size_t mandos_argz_length = 0;
 
318
 
 
319
  if(not parse_arguments(argc, argv, true, &agent_directory,
 
320
                         &helper_directory, &user, &group,
 
321
                         &mandos_argz, &mandos_argz_length)){
 
322
    /* This should never happen, since "true" is passed as the third
 
323
       argument to parse_arguments() above, which should make
 
324
       argp_parse() call exit() if any parsing error occurs. */
 
325
    error(EX_USAGE, errno, "Failed to parse arguments");
 
326
  }
 
327
 
 
328
  const char default_agent_directory[] = "/run/systemd/ask-password";
 
329
  const char default_helper_directory[]
 
330
    = "/lib/mandos/plugin-helpers";
 
331
  const char *const default_argv[]
 
332
    = {"/lib/mandos/plugins.d/mandos-client", NULL };
 
333
 
 
334
  /* Set variables to default values if unset */
 
335
  if(agent_directory == NULL){
 
336
    agent_directory = strdup(default_agent_directory);
 
337
    if(agent_directory == NULL){
 
338
      error(EX_OSERR, errno, "Failed strdup()");
 
339
    }
 
340
  }
 
341
  if(helper_directory == NULL){
 
342
    helper_directory = strdup(default_helper_directory);
 
343
    if(helper_directory == NULL){
 
344
      error(EX_OSERR, errno, "Failed strdup()");
 
345
    }
 
346
  }
 
347
  if(user == 0){
 
348
    user = 65534;               /* nobody */
 
349
  }
 
350
  if(group == 0){
 
351
    group = 65534;              /* nogroup */
 
352
  }
 
353
  /* If parse_opt did not create an argz vector, create one with
 
354
     default values */
 
355
  if(mandos_argz == NULL){
 
356
#ifdef __GNUC__
 
357
#pragma GCC diagnostic push
 
358
    /* argz_create() takes a non-const argv for some unknown reason -
 
359
       argz_create() isn't modifying the strings, just copying them.
 
360
       Therefore, this cast to non-const should be safe. */
 
361
#pragma GCC diagnostic ignored "-Wcast-qual"
 
362
#endif
 
363
    errno = argz_create((char *const *)default_argv, &mandos_argz,
 
364
                        &mandos_argz_length);
 
365
#ifdef __GNUC__
 
366
#pragma GCC diagnostic pop
 
367
#endif
 
368
    if(errno != 0){
 
369
      error(EX_OSERR, errno, "Failed argz_create()");
 
370
    }
 
371
  }
 
372
  /* Use argz vector to create a normal argv, usable by execv() */
 
373
 
 
374
  char **mandos_argv = malloc((argz_count(mandos_argz,
 
375
                                          mandos_argz_length)
 
376
                               + 1) * sizeof(char *));
 
377
  if(mandos_argv == NULL){
 
378
    error_t saved_errno = errno;
 
379
    free(mandos_argz);
 
380
    error(EX_OSERR, saved_errno, "Failed malloc()");
 
381
  }
 
382
  argz_extract(mandos_argz, mandos_argz_length, mandos_argv);
 
383
 
 
384
  sigset_t orig_sigmask;
 
385
  if(not block_sigchld(&orig_sigmask)){
 
386
    return EX_OSERR;
 
387
  }
 
388
 
 
389
  struct sigaction old_sigchld_action;
 
390
  if(not setup_signal_handler(&old_sigchld_action)){
 
391
    return EX_OSERR;
 
392
  }
 
393
 
 
394
  mono_microsecs current_time = 0;
 
395
 
 
396
  bool mandos_client_exited = false;
 
397
  bool quit_now = false;
 
398
  __attribute__((cleanup(cleanup_close)))
 
399
    const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);
 
400
  if(epoll_fd < 0){
 
401
    error(EX_OSERR, errno, "Failed to create epoll set fd");
 
402
  }
 
403
  __attribute__((cleanup(cleanup_queue)))
 
404
    task_queue *queue = create_queue();
 
405
  if(queue == NULL){
 
406
    error(EX_OSERR, errno, "Failed to create task queue");
 
407
  }
 
408
 
 
409
  __attribute__((cleanup(cleanup_buffer)))
 
410
    buffer password = {};
 
411
  bool password_is_read = false;
 
412
 
 
413
  __attribute__((cleanup(string_set_clear)))
 
414
    string_set cancelled_filenames = {};
 
415
 
 
416
  /* Add tasks to queue */
 
417
  if(not start_mandos_client(queue, epoll_fd, &mandos_client_exited,
 
418
                             &quit_now, &password, &password_is_read,
 
419
                             &old_sigchld_action, orig_sigmask,
 
420
                             helper_directory, user, group,
 
421
                             (const char *const *)mandos_argv)){
 
422
    return EX_OSERR;            /* Error has already been printed */
 
423
  }
 
424
  /* These variables were only for start_mandos_client() and are not
 
425
     needed anymore */
 
426
  free(mandos_argv);
 
427
  free(mandos_argz);
 
428
  mandos_argz = NULL;
 
429
  if(not add_inotify_dir_watch(queue, epoll_fd, &quit_now, &password,
 
430
                               agent_directory, &cancelled_filenames,
 
431
                               &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
}