/mandos/trunk

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

« back to all changes in this revision

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

  • Committer: Teddy Hogeborn
  • Date: 2022-04-25 20:09:43 UTC
  • mfrom: (237.4.138 release)
  • Revision ID: teddy@recompile.se-20220425200943-e154ee7jf6df1uso
Merge from release branch

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