/mandos/release

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

« back to all changes in this revision

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

  • Committer: Teddy Hogeborn
  • Date: 2023-02-07 23:29:39 UTC
  • mto: This revision was merged to the branch mainline in revision 408.
  • Revision ID: teddy@recompile.se-20230207232939-7qxu3keq5gvx6a9b
Fix issue with french translation

Initial white space was missing in both msgid and msgstr of the french
translation, leading to checking tools reporing an incomplete
translation.

* debian/po/fr.po: Add missing whitespace to the id and translation
  for msgid " key_id = <HEXSTRING>".

Show diffs side-by-side

added added

removed removed

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