/mandos/release

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

« back to all changes in this revision

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

  • Committer: Teddy Hogeborn
  • Date: 2009-01-10 05:41:16 UTC
  • mfrom: (237.2.23 mandos)
  • Revision ID: teddy@fukt.bsnet.se-20090110054116-uu1tbhe33sl5zg31
Merge from trunk; fix compilation error on AMD64.

Show diffs side-by-side

added added

removed removed

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