/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: 2009-02-07 04:50:39 UTC
  • Revision ID: teddy@fukt.bsnet.se-20090207045039-xkr6b80vtqwqrq8l
* Makefile (install-client-nokey): Move "initramfs-tools-script" from
                                   "/scripts/local-top/mandos" to
                                   "/scripts/init-premount/mandos".
  (uninstall-client): - '' -
* debian/mandos-client.dirs: - '' -
* initramfs-tools-script (PREREQ): Added "udev".

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