/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: 2019-08-02 22:16:53 UTC
  • mto: This revision was merged to the branch mainline in revision 386.
  • Revision ID: teddy@recompile.se-20190802221653-ic1iko9hbefzwsk7
Fix bug in server Debian package: Fails to start on first install

There has been a very long-standing bug where installation of the
server (the "mandos" Debian package) would fail to start the server
properly right after installation.  It would work on manual (re)start
after installation, or after reboot, and even after package purge and
reinstall, it would then work the first time.  The problem, it turns
out, is when the new "_mandos" user (and corresponding group) is
created, the D-Bus server is not reloaded, and is therefore not aware
of that user, and does not recognize the user and group name in the
/etc/dbus-1/system.d/mandos.conf file.  The Mandos server, when it
tries to start and access the D-Bus, is then not permitted to connect
to its D-Bus bus name, and disables D-Bus use as a fallback measure;
i.e. the server works, but it is not controllable via D-Bus commands
(via mandos-ctl or mandos-monitor).  The next time the D-Bus daemon is
reloaded for any reason, the new user & group would become visible to
the D-Bus daemon and after that, any restart of the Mandos server
would succeed and it would bind to its D-Bus name properly, and
thereby be visible and controllable by mandos-ctl & mandos-monitor.
This was mostly invisible when using sysvinit, but systemd makes the
problem visible since the systemd service file for the Mandos server
is configured to not consider the Mandos server "started" until the
D-Bus name has been bound; this makes the starting of the service wait
for 90 seconds and then fail with a timeout error.

Fixing this should also make the Debian CI autopkgtest tests work.

* debian/mandos.postinst (configure): After creating (or renaming)
                                      user & group, reload D-Bus
                                      daemon (if present).

Show diffs side-by-side

added added

removed removed

Lines of Context:
dracut-module/password-agent.c
1
 
/* -*- coding: utf-8; lexical-binding: t -*- */
 
1
/* -*- mode: c; coding: utf-8; after-save-hook: (lambda () (let* ((find-build-directory (lambda (try-directory &optional base-directory) (let ((base-directory (or base-directory try-directory))) (cond ((equal try-directory "/") base-directory) ((file-readable-p (concat (file-name-as-directory try-directory) "Makefile")) try-directory) ((funcall find-build-directory (directory-file-name (file-name-directory try-directory)) base-directory)))))) (build-directory (funcall find-build-directory (buffer-file-name))) (local-build-directory (if (fboundp 'file-local-name) (file-local-name build-directory) (or (file-remote-p build-directory 'localname) build-directory))) (command (file-relative-name (file-name-sans-extension (buffer-file-name)) build-directory))) (pcase (progn (if (get-buffer "*Test*") (kill-buffer "*Test*")) (process-file-shell-command (let ((qbdir (shell-quote-argument local-build-directory)) (qcmd (shell-quote-argument command))) (format "cd %s && CFLAGS=-Werror make --silent %s && %s --test --verbose" qbdir qcmd qcmd)) nil "*Test*")) (0 (let ((w (get-buffer-window "*Test*"))) (if w (delete-window w)))) (_ (with-current-buffer "*Test*" (compilation-mode) (cd-absolute build-directory)) (display-buffer "*Test*" '(display-buffer-in-side-window)))))); -*- */
2
2
/*
3
3
 * Mandos password agent - Simple password agent to run Mandos client
4
4
 *
5
 
 * Copyright © 2019-2022 Teddy Hogeborn
6
 
 * Copyright © 2019-2022 Björn Påhlsson
 
5
 * Copyright © 2019 Teddy Hogeborn
 
6
 * Copyright © 2019 Björn Påhlsson
7
7
 * 
8
8
 * This file is part of Mandos.
9
9
 * 
23
23
 * Contact the authors at <mandos@recompile.se>.
24
24
 */
25
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 */
 
26
#define _GNU_SOURCE
 
27
#include <inttypes.h>           /* uintmax_t, PRIuMAX, PRIdMAX,
 
28
                                   intmax_t, uint32_t, SCNx32,
 
29
                                   SCNuMAX, SCNxMAX */
 
30
#include <stddef.h>             /* size_t */
33
31
#include <sys/types.h>          /* pid_t, uid_t, gid_t, getuid(),
34
32
                                   getpid() */
35
33
#include <stdbool.h>            /* bool, true, false */
42
40
                                   NSIG, sigismember(), SA_ONSTACK,
43
41
                                   SIG_DFL, SIG_IGN, SIGINT, SIGQUIT,
44
42
                                   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
43
#include <stdlib.h>             /* EXIT_SUCCESS, EXIT_FAILURE,
53
 
                                   malloc(), free(), realloc(),
54
 
                                   setenv(), calloc(), mkdtemp(),
55
 
                                   mkostemp() */
 
44
                                   malloc(), free(), strtoumax(),
 
45
                                   realloc(), setenv(), calloc(),
 
46
                                   mkdtemp(), mkostemp() */
56
47
#include <iso646.h>             /* not, or, and, xor */
57
48
#include <error.h>              /* error() */
58
49
#include <sysexits.h>           /* EX_USAGE, EX_OSERR, EX_OSFILE */
59
50
#include <errno.h>              /* errno, error_t, EACCES,
60
 
                                   ENAMETOOLONG, ENOENT, ENOTDIR,
61
 
                                   ENOMEM, EEXIST, ECHILD, EPERM,
62
 
                                   EAGAIN, EINTR, ENOBUFS, EADDRINUSE,
 
51
                                   ENAMETOOLONG, ENOENT, EEXIST,
 
52
                                   ECHILD, EPERM, ENOMEM, EAGAIN,
 
53
                                   EINTR, ENOBUFS, EADDRINUSE,
63
54
                                   ECONNREFUSED, ECONNRESET,
64
55
                                   ETOOMANYREFS, EMSGSIZE, EBADF,
65
56
                                   EINVAL */
66
57
#include <string.h>             /* strdup(), memcpy(),
67
58
                                   explicit_bzero(), memset(),
68
59
                                   strcmp(), strlen(), strncpy(),
69
 
                                   memcmp(), basename(), strerror() */
 
60
                                   memcmp(), basename() */
70
61
#include <argz.h>               /* argz_create(), argz_count(),
71
62
                                   argz_extract(), argz_next(),
72
63
                                   argz_add() */
82
73
                                   ARGP_ERR_UNKNOWN, ARGP_KEY_ARGS,
83
74
                                   struct argp, argp_parse(),
84
75
                                   ARGP_NO_EXIT */
85
 
#include <stdint.h>             /* SIZE_MAX, uint32_t */
 
76
#include <unistd.h>             /* uid_t, gid_t, close(), pipe2(),
 
77
                                   fork(), _exit(), dup2(),
 
78
                                   STDOUT_FILENO, setresgid(),
 
79
                                   setresuid(), execv(), ssize_t,
 
80
                                   read(), dup3(), getuid(), dup(),
 
81
                                   STDERR_FILENO, pause(), write(),
 
82
                                   rmdir(), unlink(), getpid() */
86
83
#include <sys/mman.h>           /* munlock(), mlock() */
87
84
#include <fcntl.h>              /* O_CLOEXEC, O_NONBLOCK, fcntl(),
88
85
                                   F_GETFD, F_GETFL, FD_CLOEXEC,
89
 
                                   open(), O_WRONLY, O_NOCTTY,
90
 
                                   O_RDONLY, O_NOFOLLOW */
 
86
                                   open(), O_WRONLY, O_RDONLY */
91
87
#include <sys/wait.h>           /* waitpid(), WNOHANG, WIFEXITED(),
92
88
                                   WEXITSTATUS() */
93
89
#include <limits.h>             /* PIPE_BUF, NAME_MAX, INT_MAX */
94
90
#include <sys/inotify.h>        /* inotify_init1(), IN_NONBLOCK,
95
91
                                   IN_CLOEXEC, inotify_add_watch(),
96
92
                                   IN_CLOSE_WRITE, IN_MOVED_TO,
97
 
                                   IN_MOVED_FROM, IN_DELETE,
98
 
                                   IN_EXCL_UNLINK, IN_ONLYDIR,
99
 
                                   struct inotify_event */
 
93
                                   IN_DELETE, struct inotify_event */
100
94
#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() */
 
95
#include <stdio.h>              /* asprintf(), FILE, fopen(),
 
96
                                   getline(), sscanf(), feof(),
 
97
                                   ferror(), fclose(), stderr,
 
98
                                   rename(), fdopen(), fprintf(),
 
99
                                   fscanf() */
105
100
#include <glib.h>    /* GKeyFile, g_key_file_free(), g_key_file_new(),
106
101
                        GError, g_key_file_load_from_file(),
107
102
                        G_KEY_FILE_NONE, TRUE, G_FILE_ERROR_NOENT,
112
107
                        g_assert_null(), g_assert_false(),
113
108
                        g_assert_cmpint(), g_assert_cmpuint(),
114
109
                        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(),
 
110
                        g_test_init(), g_test_add(), g_test_run(),
 
111
                        GOptionContext, g_option_context_new(),
118
112
                        g_option_context_set_help_enabled(), FALSE,
119
113
                        g_option_context_set_ignore_unknown_options(),
120
114
                        gboolean, GOptionEntry, G_OPTION_ARG_NONE,
151
145
  mono_microsecs next_run;
152
146
} __attribute__((designated_init)) task_queue;
153
147
 
154
 
/* "task_func" - A function type for task functions
 
148
/* "func_type" - A function type for task functions
155
149
 
156
150
   I.e. functions for the code which runs when a task is run, all have
157
151
   this type */
437
431
    case EACCES:
438
432
    case ENAMETOOLONG:
439
433
    case ENOENT:
440
 
    case ENOTDIR:
441
434
      return EX_OSFILE;
442
435
    default:
443
436
      return EX_OSERR;
654
647
 
655
648
__attribute__((nonnull, warn_unused_result))
656
649
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
650
  const size_t needed_size = sizeof(task_context)*(queue->length + 1);
665
651
  if(needed_size > (queue->allocated)){
666
652
    task_context *const new_tasks = realloc(queue->tasks,
871
857
  }
872
858
  close(pipefds[1]);
873
859
 
874
 
  if(pid == -1){
875
 
    error(0, errno, "Failed to fork()");
876
 
    close(pipefds[0]);
877
 
    return false;
878
 
  }
879
 
 
880
860
  if(not add_to_queue(queue, (task_context){
881
861
        .func=wait_for_mandos_client_exit,
882
862
        .pid=pid,
1037
1017
    return false;
1038
1018
  }
1039
1019
 
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)
 
1020
  if(inotify_add_watch(fd, dir, IN_CLOSE_WRITE
 
1021
                       | IN_MOVED_TO | IN_DELETE)
1043
1022
     == -1){
1044
1023
    error(0, errno, "Failed to create inotify watch on %s", dir);
1045
1024
    return false;
1098
1077
  } ievent_buffer;
1099
1078
  struct inotify_event *const ievent = &ievent_buffer.event;
1100
1079
 
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
1080
  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
1081
  if(read_length == 0){ /* EOF */
1111
1082
    error(0, 0, "Got EOF from inotify fd for directory %s", filename);
1112
1083
    *quit_now = true;
1148
1119
             immediately */
1149
1120
          queue->next_run = 1;
1150
1121
        }
1151
 
      } else if(ievent->mask & (IN_MOVED_FROM | IN_DELETE)){
 
1122
      } else if(ievent->mask & IN_DELETE){
1152
1123
        if(not string_set_add(cancelled_filenames,
1153
1124
                              question_filename)){
1154
1125
          error(0, errno, "Could not add question %s to"
1204
1175
  bool *const password_is_read = task.password_is_read;
1205
1176
 
1206
1177
  /* 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 */
 
1178
     question file.  See <https://www.freedesktop.org/wiki/Software
 
1179
     /systemd/PasswordAgents/> for specification of contents */
1209
1180
  __attribute__((nonnull))
1210
1181
    void cleanup_g_key_file(GKeyFile **key_file){
1211
1182
    if(*key_file != NULL){
1501
1472
         not. You may but don't have to include a final NUL byte in
1502
1473
         your message.
1503
1474
 
1504
 
         — <https://systemd.io/PASSWORD_AGENTS/> (Tue, 15 Sep 2020
1505
 
         14:24:20 GMT)
 
1475
         — <https://www.freedesktop.org/wiki/Software/systemd/
 
1476
         PasswordAgents/> (Wed 08 Oct 2014 02:14:28 AM UTC)
1506
1477
      */
1507
1478
      send_buffer[0] = '+';     /* Prefix with "+" */
1508
1479
      /* Always add an extra NUL */
1513
1484
      errno = 0;
1514
1485
      ssize_t ssret = send(fd, send_buffer, send_buffer_length,
1515
1486
                           MSG_NOSIGNAL);
1516
 
      const error_t saved_errno = (ssret < 0) ? errno : 0;
 
1487
      const error_t saved_errno = errno;
1517
1488
#if defined(__GLIBC_PREREQ) and __GLIBC_PREREQ(2, 25)
1518
1489
      explicit_bzero(send_buffer, send_buffer_length);
1519
1490
#else
1537
1508
          /* Retry, below */
1538
1509
          break;
1539
1510
        case EMSGSIZE:
1540
 
          error(0, saved_errno, "Password of size %" PRIuMAX
1541
 
                " is too big", (uintmax_t)password->length);
 
1511
          error(0, 0, "Password of size %" PRIuMAX " is too big",
 
1512
                (uintmax_t)password->length);
1542
1513
#if __GNUC__ < 7
1543
1514
          /* FALLTHROUGH */
1544
1515
#else
1546
1517
#endif
1547
1518
        case 0:
1548
1519
          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);
 
1520
            error(0, 0, "Password only partially sent to socket");
1552
1521
          }
1553
1522
#if __GNUC__ < 7
1554
1523
          /* FALLTHROUGH */
1910
1879
  g_assert_true(queue->tasks[0].func == dummy_func);
1911
1880
}
1912
1881
 
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
1882
static void dummy_func(__attribute__((unused))
1937
1883
                       const task_context task,
1938
1884
                       __attribute__((unused))
2209
2155
    }
2210
2156
    exit(EXIT_SUCCESS);
2211
2157
  }
2212
 
  if(pid == -1){
2213
 
    error(EXIT_FAILURE, errno, "Failed to fork()");
2214
 
  }
2215
 
 
2216
2158
  int status;
2217
2159
  waitpid(pid, &status, 0);
2218
2160
  if(WIFEXITED(status) and (WEXITSTATUS(status) == EXIT_SUCCESS)){
2280
2222
 
2281
2223
  {
2282
2224
    __attribute__((cleanup(cleanup_close)))
2283
 
      const int devnull_fd = open("/dev/null",
2284
 
                                  O_WRONLY | O_CLOEXEC | O_NOCTTY);
 
2225
      const int devnull_fd = open("/dev/null", O_WRONLY | O_CLOEXEC);
2285
2226
    g_assert_cmpint(devnull_fd, >=, 0);
2286
2227
    __attribute__((cleanup(cleanup_close)))
2287
2228
      const int real_stderr_fd = dup(STDERR_FILENO);
2311
2252
    {
2312
2253
      __attribute__((cleanup(cleanup_close)))
2313
2254
        const int devnull_fd = open("/dev/null",
2314
 
                                    O_WRONLY | O_CLOEXEC | O_NOCTTY);
 
2255
                                    O_WRONLY | O_CLOEXEC);
2315
2256
      g_assert_cmpint(devnull_fd, >=, 0);
2316
2257
      __attribute__((cleanup(cleanup_close)))
2317
2258
        const int real_stderr_fd = dup(STDERR_FILENO);
2661
2602
  bool password_is_read = false;
2662
2603
  const char helper_directory[] = "/nonexistent";
2663
2604
  const char *const argv[] = { "/bin/sh", "-c",
2664
 
    "printf %s \"${MANDOSPLUGINHELPERDIR}\"", NULL };
 
2605
    "echo -n ${MANDOSPLUGINHELPERDIR}", NULL };
2665
2606
 
2666
2607
  const bool success = start_mandos_client(queue, epoll_fd,
2667
2608
                                           &mandos_client_exited,
2962
2903
 
2963
2904
  __attribute__((cleanup(cleanup_close)))
2964
2905
    const int devnull_fd = open("/dev/null",
2965
 
                                O_WRONLY | O_CLOEXEC | O_NOCTTY);
 
2906
                                O_WRONLY | O_CLOEXEC);
2966
2907
  g_assert_cmpint(devnull_fd, >=, 0);
2967
2908
  __attribute__((cleanup(cleanup_close)))
2968
2909
    const int real_stderr_fd = dup(STDERR_FILENO);
3033
2974
 
3034
2975
  __attribute__((cleanup(cleanup_close)))
3035
2976
    const int devnull_fd = open("/dev/null",
3036
 
                                O_WRONLY | O_CLOEXEC, O_NOCTTY);
 
2977
                                O_WRONLY | O_CLOEXEC);
3037
2978
  g_assert_cmpint(devnull_fd, >=, 0);
3038
2979
  __attribute__((cleanup(cleanup_close)))
3039
2980
    const int real_stderr_fd = dup(STDERR_FILENO);
3077
3018
    buffer password = {};
3078
3019
 
3079
3020
  /* 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);
 
3021
  const int fd = open("/proc/self/mem", O_RDONLY | O_CLOEXEC);
3082
3022
 
3083
3023
  bool password_is_read = false;
3084
3024
  bool quit_now = false;
3512
3452
  g_assert_cmpuint((unsigned int)queue->length, ==, 0);
3513
3453
}
3514
3454
 
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
3455
static void test_add_inotify_dir_watch_EAGAIN(__attribute__((unused))
3554
3456
                                              test_fixture *fixture,
3555
3457
                                              __attribute__((unused))
3770
3672
}
3771
3673
 
3772
3674
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
3675
void test_add_inotify_dir_watch_IN_DELETE(__attribute__((unused))
3846
3676
                                          test_fixture *fixture,
3847
3677
                                          __attribute__((unused))
3905
3735
  g_assert_cmpint(rmdir(tempdir), ==, 0);
3906
3736
}
3907
3737
 
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
3738
static void test_read_inotify_event_readerror(__attribute__((unused))
3985
3739
                                              test_fixture *fixture,
3986
3740
                                              __attribute__((unused))
3992
3746
  const mono_microsecs current_time = 0;
3993
3747
 
3994
3748
  /* 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);
 
3749
  const int fd = open("/proc/self/mem", O_RDONLY | O_CLOEXEC);
3997
3750
 
3998
3751
  bool quit_now = false;
3999
3752
  __attribute__((cleanup(cleanup_queue)))
4190
3943
  memcpy(ievent->name, dummy_file_name, sizeof(dummy_file_name));
4191
3944
  const size_t ievent_size = (sizeof(struct inotify_event)
4192
3945
                              + 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
3946
  g_assert_cmpint(write(pipefds[1], (char *)ievent, ievent_size),
4199
3947
                  ==, ievent_size);
4200
 
#if defined(__GNUC__) and __GNUC__ >= 11
4201
 
#pragma GCC diagnostic pop
4202
 
#endif
4203
3948
  g_assert_cmpint(close(pipefds[1]), ==, 0);
4204
3949
 
4205
3950
  bool quit_now = false;
4293
4038
  memcpy(ievent->name, dummy_file_name, sizeof(dummy_file_name));
4294
4039
  const size_t ievent_size = (sizeof(struct inotify_event)
4295
4040
                              + 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
4041
  g_assert_cmpint(write(pipefds[1], (char *)ievent, ievent_size),
4302
4042
                  ==, ievent_size);
4303
 
#if defined(__GNUC__) and __GNUC__ >= 11
4304
 
#pragma GCC diagnostic pop
4305
 
#endif
4306
4043
  g_assert_cmpint(close(pipefds[1]), ==, 0);
4307
4044
 
4308
4045
  bool quit_now = false;
4367
4104
      }));
4368
4105
}
4369
4106
 
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
4107
static void test_read_inotify_event_IN_DELETE(__attribute__((unused))
4464
4108
                                              test_fixture *fixture,
4465
4109
                                              __attribute__((unused))
4491
4135
  memcpy(ievent->name, dummy_file_name, sizeof(dummy_file_name));
4492
4136
  const size_t ievent_size = (sizeof(struct inotify_event)
4493
4137
                              + 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
4138
  g_assert_cmpint(write(pipefds[1], (char *)ievent, ievent_size),
4500
4139
                  ==, ievent_size);
4501
 
#if defined(__GNUC__) and __GNUC__ >= 11
4502
 
#pragma GCC diagnostic pop
4503
 
#endif
4504
4140
  g_assert_cmpint(close(pipefds[1]), ==, 0);
4505
4141
 
4506
4142
  bool quit_now = false;
4583
4219
  memcpy(ievent->name, dummy_file_name, sizeof(dummy_file_name));
4584
4220
  const size_t ievent_size = (sizeof(struct inotify_event)
4585
4221
                              + 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
4222
  g_assert_cmpint(write(pipefds[1], (char *)ievent, ievent_size),
4592
4223
                  ==, ievent_size);
4593
 
#if defined(__GNUC__) and __GNUC__ >= 11
4594
 
#pragma GCC diagnostic pop
4595
 
#endif
4596
4224
  g_assert_cmpint(close(pipefds[1]), ==, 0);
4597
4225
 
4598
4226
  bool quit_now = false;
4667
4295
  memcpy(ievent->name, dummy_file_name, sizeof(dummy_file_name));
4668
4296
  const size_t ievent_size = (sizeof(struct inotify_event)
4669
4297
                              + 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
4298
  g_assert_cmpint(write(pipefds[1], (char *)ievent, ievent_size),
4676
4299
                  ==, ievent_size);
4677
 
#if defined(__GNUC__) and __GNUC__ >= 11
4678
 
#pragma GCC diagnostic pop
4679
 
#endif
4680
4300
  g_assert_cmpint(close(pipefds[1]), ==, 0);
4681
4301
 
4682
4302
  bool quit_now = false;
4722
4342
                                   EPOLLIN | EPOLLRDHUP));
4723
4343
}
4724
4344
 
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
4345
static
4819
4346
void test_read_inotify_event_IN_DELETE_badname(__attribute__((unused))
4820
4347
                                               test_fixture *fixture,
5740
5267
                                            __attribute__((unused))
5741
5268
                                            gconstpointer user_data){
5742
5269
  __attribute__((cleanup(cleanup_close)))
5743
 
    const int epoll_fd = open("/dev/null",
5744
 
                              O_WRONLY | O_CLOEXEC | O_NOCTTY);
 
5270
    const int epoll_fd = open("/dev/null", O_WRONLY | O_CLOEXEC);
5745
5271
  __attribute__((cleanup(cleanup_string)))
5746
5272
    char *const question_filename = strdup("/nonexistent/question");
5747
5273
  g_assert_nonnull(question_filename);
5876
5402
  char write_data[PIPE_BUF];
5877
5403
  {
5878
5404
    /* Construct test password buffer */
5879
 
    /* Start with + since that is what the real protocol uses */
 
5405
    /* Start with + since that is what the real procotol uses */
5880
5406
    write_data[0] = '+';
5881
5407
    /* Set a special character at string end just to mark the end */
5882
5408
    write_data[sizeof(write_data)-2] = 'y';
6034
5560
  char *const filename = strdup("/nonexistent/socket");
6035
5561
  __attribute__((cleanup(string_set_clear)))
6036
5562
    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,
 
5563
  const size_t oversized = 1024*1024; /* Limit seems to be 212960 */
 
5564
  __attribute__((cleanup(cleanup_buffer)))
 
5565
    buffer password = {
 
5566
    .data=malloc(oversized),
 
5567
    .length=oversized,
 
5568
    .allocated=oversized,
6093
5569
  };
 
5570
  g_assert_nonnull(password.data);
6094
5571
  if(mlock(password.data, password.allocated) != 0){
6095
5572
    g_assert_true(errno == EPERM or errno == ENOMEM);
6096
5573
  }
 
5574
  /* Construct test password buffer */
 
5575
  /* Start with + since that is what the real procotol uses */
 
5576
  password.data[0] = '+';
 
5577
  /* Set a special character at string end just to mark the end */
 
5578
  password.data[oversized-3] = 'y';
 
5579
  /* Set NUL at buffer end, as suggested by the protocol */
 
5580
  password.data[oversized-2] = '\0';
 
5581
  /* Fill rest of password with 'x' */
 
5582
  memset(password.data+1, 'x', oversized-3);
6097
5583
 
6098
5584
  __attribute__((cleanup(cleanup_queue)))
6099
5585
    task_queue *queue = create_queue();
6100
5586
  g_assert_nonnull(queue);
 
5587
  int socketfds[2];
6101
5588
  g_assert_cmpint(socketpair(PF_LOCAL, SOCK_DGRAM
6102
5589
                             | SOCK_NONBLOCK | SOCK_CLOEXEC, 0,
6103
5590
                             socketfds), ==, 0);
6190
5677
                                            __attribute__((unused))
6191
5678
                                            gconstpointer user_data){
6192
5679
  __attribute__((cleanup(cleanup_close)))
6193
 
    const int epoll_fd = open("/dev/null",
6194
 
                              O_WRONLY | O_CLOEXEC | O_NOCTTY);
 
5680
    const int epoll_fd = open("/dev/null", O_WRONLY | O_CLOEXEC);
6195
5681
  __attribute__((cleanup(cleanup_string)))
6196
5682
    char *const question_filename = strdup("/nonexistent/question");
6197
5683
  g_assert_nonnull(question_filename);
6460
5946
                                              const char *const
6461
5947
                                              dirname){
6462
5948
  __attribute__((cleanup(cleanup_close)))
6463
 
    const int devnull_fd = open("/dev/null",
6464
 
                                O_WRONLY | O_CLOEXEC | O_NOCTTY);
 
5949
    const int devnull_fd = open("/dev/null", O_WRONLY | O_CLOEXEC);
6465
5950
  g_assert_cmpint(devnull_fd, >=, 0);
6466
5951
  __attribute__((cleanup(cleanup_close)))
6467
5952
    const int real_stderr_fd = dup(STDERR_FILENO);
8010
7495
  test_add("/parse_arguments/mixed", test_parse_arguments_mixed);
8011
7496
  test_add("/queue/create", test_create_queue);
8012
7497
  test_add("/queue/add", test_add_to_queue);
8013
 
  test_add("/queue/add/overflow", test_add_to_queue_overflow);
8014
7498
  test_add("/queue/has_question/empty",
8015
7499
           test_queue_has_question_empty);
8016
7500
  test_add("/queue/has_question/false",
8103
7587
              test_add_inotify_dir_watch);
8104
7588
  test_add_st("/task-creators/add_inotify_dir_watch/fail",
8105
7589
              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
7590
  test_add_st("/task-creators/add_inotify_dir_watch/EAGAIN",
8109
7591
              test_add_inotify_dir_watch_EAGAIN);
8110
7592
  test_add_st("/task-creators/add_inotify_dir_watch/IN_CLOSE_WRITE",
8111
7593
              test_add_inotify_dir_watch_IN_CLOSE_WRITE);
8112
7594
  test_add_st("/task-creators/add_inotify_dir_watch/IN_MOVED_TO",
8113
7595
              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
7596
  test_add_st("/task-creators/add_inotify_dir_watch/IN_DELETE",
8119
7597
              test_add_inotify_dir_watch_IN_DELETE);
8120
7598
  test_add_st("/task/read_inotify_event/readerror",
8129
7607
              test_read_inotify_event_IN_CLOSE_WRITE);
8130
7608
  test_add_st("/task/read_inotify_event/IN_MOVED_TO",
8131
7609
              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
7610
  test_add_st("/task/read_inotify_event/IN_DELETE",
8135
7611
              test_read_inotify_event_IN_DELETE);
8136
7612
  test_add_st("/task/read_inotify_event/IN_CLOSE_WRITE/badname",
8137
7613
              test_read_inotify_event_IN_CLOSE_WRITE_badname);
8138
7614
  test_add_st("/task/read_inotify_event/IN_MOVED_TO/badname",
8139
7615
              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
7616
  test_add_st("/task/read_inotify_event/IN_DELETE/badname",
8143
7617
              test_read_inotify_event_IN_DELETE_badname);
8144
7618
  test_add_st("/task/open_and_parse_question/ENOENT",
8241
7715
  g_option_context_set_help_enabled(context, FALSE);
8242
7716
  g_option_context_set_ignore_unknown_options(context, TRUE);
8243
7717
 
8244
 
  gboolean should_run_tests = FALSE;
 
7718
  gboolean run_tests = FALSE;
8245
7719
  GOptionEntry entries[] = {
8246
7720
    { "test", 0, 0, G_OPTION_ARG_NONE,
8247
 
      &should_run_tests, "Run tests", NULL },
 
7721
      &run_tests, "Run tests", NULL },
8248
7722
    { NULL }
8249
7723
  };
8250
7724
  g_option_context_add_main_entries(context, entries, NULL);
8257
7731
  }
8258
7732
 
8259
7733
  g_option_context_free(context);
8260
 
  return should_run_tests != FALSE;
 
7734
  return run_tests != FALSE;
8261
7735
}
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
 
*/