/mandos/trunk

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

« back to all changes in this revision

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

  • Committer: Teddy Hogeborn
  • Date: 2024-09-08 02:14:29 UTC
  • Revision ID: teddy@recompile.se-20240908021429-z4m1vfuaqbs0q3ry
Fix file permissions when installing a new kernel, with dracut

* debian/mandos-client.postinst (update_initramfs): When using dracut,
  but the initramfs image file does not yet exist (due to the kernel
  package not having been configured), create a new empty file with
  the correct permissions, so that dracut will use the correct
  permissions when creating the initramfs image file.

Show diffs side-by-side

added added

removed removed

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