/mandos/release : revision 409

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)))))); -*- */

1

/* -*- coding: utf-8; lexical-binding: t -*- */

2

/*

3

* Mandos password agent - Simple password agent to run Mandos client

4

*

5

6

5

6

7

*

8

* This file is part of Mandos.

9

*

23

* Contact the authors at <mandos@recompile.se>.

24

*/

25

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 */

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 */

31

33

#include <sys/types.h> /* pid_t, uid_t, gid_t, getuid(),

32

34

getpid() */

33

35

#include <stdbool.h> /* bool, true, false */

40

42

NSIG, sigismember(), SA_ONSTACK,

41

43

SIG_DFL, SIG_IGN, SIGINT, SIGQUIT,

42

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() */

43

52

#include <stdlib.h> /* EXIT_SUCCESS, EXIT_FAILURE,

44

malloc(), free(), strtoumax(),

45

realloc(), setenv(), calloc(),

46

mkdtemp(), mkostemp() */

53

malloc(), free(), realloc(),

54

setenv(), calloc(), mkdtemp(),

55

mkostemp() */

47

56

#include <iso646.h> /* not, or, and, xor */

48

57

#include <error.h> /* error() */

49

58

#include <sysexits.h> /* EX_USAGE, EX_OSERR, EX_OSFILE */

50

59

#include <errno.h> /* errno, error_t, EACCES,

51

ENAMETOOLONG, ENOENT, EEXIST,

52

ECHILD, EPERM, ENOMEM, EAGAIN,

53

EINTR, ENOBUFS, EADDRINUSE,

60

ENAMETOOLONG, ENOENT, ENOTDIR,

61

ENOMEM, EEXIST, ECHILD, EPERM,

62

EAGAIN, EINTR, ENOBUFS, EADDRINUSE,

54

63

ECONNREFUSED, ECONNRESET,

55

64

ETOOMANYREFS, EMSGSIZE, EBADF,

56

65

EINVAL */

57

66

#include <string.h> /* strdup(), memcpy(),

58

67

explicit_bzero(), memset(),

59

68

strcmp(), strlen(), strncpy(),

60

memcmp(), basename() */

69

memcmp(), basename(), strerror() */

61

70

#include <argz.h> /* argz_create(), argz_count(),

62

71

argz_extract(), argz_next(),

63

72

argz_add() */

73

82

ARGP_ERR_UNKNOWN, ARGP_KEY_ARGS,

74

83

struct argp, argp_parse(),

75

84

ARGP_NO_EXIT */

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() */

85

#include <stdint.h> /* SIZE_MAX, uint32_t */

83

86

#include <sys/mman.h> /* munlock(), mlock() */

84

87

#include <fcntl.h> /* O_CLOEXEC, O_NONBLOCK, fcntl(),

85

88

F_GETFD, F_GETFL, FD_CLOEXEC,

86

open(), O_WRONLY, O_RDONLY */

89

open(), O_WRONLY, O_NOCTTY,

90

O_RDONLY, O_NOFOLLOW */

87

91

#include <sys/wait.h> /* waitpid(), WNOHANG, WIFEXITED(),

88

92

WEXITSTATUS() */

89

93

#include <limits.h> /* PIPE_BUF, NAME_MAX, INT_MAX */

90

94

#include <sys/inotify.h> /* inotify_init1(), IN_NONBLOCK,

91

95

IN_CLOEXEC, inotify_add_watch(),

92

96

IN_CLOSE_WRITE, IN_MOVED_TO,

93

IN_DELETE, struct inotify_event */

97

IN_MOVED_FROM, IN_DELETE,

98

IN_EXCL_UNLINK, IN_ONLYDIR,

99

struct inotify_event */

94

100

#include <fnmatch.h> /* fnmatch(), FNM_FILE_NAME */

95

#include <stdio.h> /* asprintf(), FILE, fopen(),

96

getline(), sscanf(), feof(),

97

ferror(), fclose(), stderr,

98

rename(), fdopen(), fprintf(),

99

fscanf() */

101

#include <stdio.h> /* asprintf(), FILE, stderr, fopen(),

102

fclose(), getline(), sscanf(),

103

feof(), ferror(), rename(),

104

fdopen(), fprintf(), fscanf() */

100

105

#include <glib.h> /* GKeyFile, g_key_file_free(), g_key_file_new(),

101

106

GError, g_key_file_load_from_file(),

102

107

G_KEY_FILE_NONE, TRUE, G_FILE_ERROR_NOENT,

107

112

g_assert_null(), g_assert_false(),

108

113

g_assert_cmpint(), g_assert_cmpuint(),

109

114

g_test_skip(), g_assert_cmpstr(),

110

g_test_init(), g_test_add(), g_test_run(),

111

GOptionContext, g_option_context_new(),

115

g_test_message(), g_test_init(), g_test_add(),

116

g_test_run(), GOptionContext,

117

g_option_context_new(),

112

118

g_option_context_set_help_enabled(), FALSE,

113

119

g_option_context_set_ignore_unknown_options(),

114

120

gboolean, GOptionEntry, G_OPTION_ARG_NONE,

145

151

mono_microsecs next_run;

146

152

} __attribute__((designated_init)) task_queue;

147

153

148

/* "func_type" - A function type for task functions

154

/* "task_func" - A function type for task functions

149

155

150

156

I.e. functions for the code which runs when a task is run, all have

151

157

this type */

431

437

case EACCES:

432

438

case ENAMETOOLONG:

433

439

case ENOENT:

440

case ENOTDIR:

434

441

return EX_OSFILE;

435

442

default:

436

443

return EX_OSERR;

647

654

648

655

__attribute__((nonnull, warn_unused_result))

649

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

}

650

664

const size_t needed_size = sizeof(task_context)*(queue->length + 1);

651

665

if(needed_size > (queue->allocated)){

652

666

task_context *const new_tasks = realloc(queue->tasks,

857

871

}

858

872

close(pipefds[1]);

859

873

874

if(pid == -1){

875

error(0, errno, "Failed to fork()");

876

close(pipefds[0]);

877

return false;

878

}

879

860

880

if(not add_to_queue(queue, (task_context){

861

881

.func=wait_for_mandos_client_exit,

862

882

.pid=pid,

1017

1037

return false;

1018

1038

}

1019

1039

1020

if(inotify_add_watch(fd, dir, IN_CLOSE_WRITE

1021

| IN_MOVED_TO | IN_DELETE)

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)

1022

1043

== -1){

1023

1044

error(0, errno, "Failed to create inotify watch on %s", dir);

1024

1045

return false;

1077

1098

} ievent_buffer;

1078

1099

struct inotify_event *const ievent = &ievent_buffer.event;

1079

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

1080

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

1081

1110

if(read_length == 0){ /* EOF */

1082

1111

error(0, 0, "Got EOF from inotify fd for directory %s", filename);

1083

1112

*quit_now = true;

1119

1148

immediately */

1120

1149

queue->next_run = 1;

1121

1150

}

1122

} else if(ievent->mask & IN_DELETE){

1151

} else if(ievent->mask & (IN_MOVED_FROM | IN_DELETE)){

1123

1152

if(not string_set_add(cancelled_filenames,

1124

1153

question_filename)){

1125

1154

error(0, errno, "Could not add question %s to"

1175

1204

bool *const password_is_read = task.password_is_read;

1176

1205

1177

1206

/* We use the GLib "Key-value file parser" functions to parse the

1178

question file. See <https://www.freedesktop.org/wiki/Software

1179

/systemd/PasswordAgents/> for specification of contents */

1207

question file. See <https://systemd.io/PASSWORD_AGENTS/> for

1208

specification of contents */

1180

1209

__attribute__((nonnull))

1181

1210

void cleanup_g_key_file(GKeyFile **key_file){

1182

1211

if(*key_file != NULL){

1472

1501

not. You may but don't have to include a final NUL byte in

1473

1502

your message.

1474

1503

1475

— <https://www.freedesktop.org/wiki/Software/systemd/

1476

PasswordAgents/> (Wed 08 Oct 2014 02:14:28 AM UTC)

1504

— <https://systemd.io/PASSWORD_AGENTS/> (Tue, 15 Sep 2020

1505

14:24:20 GMT)

1477

1506

*/

1478

1507

send_buffer[0] = '+'; /* Prefix with "+" */

1479

1508

/* Always add an extra NUL */

1484

1513

errno = 0;

1485

1514

ssize_t ssret = send(fd, send_buffer, send_buffer_length,

1486

1515

MSG_NOSIGNAL);

1487

const error_t saved_errno = errno;

1516

const error_t saved_errno = (ssret < 0) ? errno : 0;

1488

1517

#if defined(__GLIBC_PREREQ) and __GLIBC_PREREQ(2, 25)

1489

1518

explicit_bzero(send_buffer, send_buffer_length);

1490

1519

#else

1508

1537

/* Retry, below */

1509

1538

break;

1510

1539

case EMSGSIZE:

1511

error(0, 0, "Password of size %" PRIuMAX " is too big",

1512

(uintmax_t)password->length);

1540

error(0, saved_errno, "Password of size %" PRIuMAX

1541

" is too big", (uintmax_t)password->length);

1513

1542

#if __GNUC__ < 7

1514

1543

/* FALLTHROUGH */

1515

1544

#else

1517

1546

#endif

1518

1547

case 0:

1519

1548

if(ssret >= 0 and ssret < (ssize_t)send_buffer_length){

1520

error(0, 0, "Password only partially sent to socket");

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);

1521

1552

}

1522

1553

#if __GNUC__ < 7

1523

1554

/* FALLTHROUGH */

1879

1910

g_assert_true(queue->tasks[0].func == dummy_func);

1880

1911

}

1881

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

1882

1936

static void dummy_func(__attribute__((unused))

1883

1937

const task_context task,

1884

1938

__attribute__((unused))

2155

2209

}

2156

2210

exit(EXIT_SUCCESS);

2157

2211

}

2212

if(pid == -1){

2213

error(EXIT_FAILURE, errno, "Failed to fork()");

2214

}

2215

2158

2216

int status;

2159

2217

waitpid(pid, &status, 0);

2160

2218

if(WIFEXITED(status) and (WEXITSTATUS(status) == EXIT_SUCCESS)){

2222

2280

2223

2281

{

2224

2282

__attribute__((cleanup(cleanup_close)))

2225

const int devnull_fd = open("/dev/null", O_WRONLY | O_CLOEXEC);

2283

const int devnull_fd = open("/dev/null",

2284

O_WRONLY | O_CLOEXEC | O_NOCTTY);

2226

2285

g_assert_cmpint(devnull_fd, >=, 0);

2227

2286

__attribute__((cleanup(cleanup_close)))

2228

2287

const int real_stderr_fd = dup(STDERR_FILENO);

2252

2311

{

2253

2312

__attribute__((cleanup(cleanup_close)))

2254

2313

const int devnull_fd = open("/dev/null",

2255

O_WRONLY | O_CLOEXEC);

2314

O_WRONLY | O_CLOEXEC | O_NOCTTY);

2256

2315

g_assert_cmpint(devnull_fd, >=, 0);

2257

2316

__attribute__((cleanup(cleanup_close)))

2258

2317

const int real_stderr_fd = dup(STDERR_FILENO);

2602

2661

bool password_is_read = false;

2603

2662

const char helper_directory[] = "/nonexistent";

2604

2663

const char *const argv[] = { "/bin/sh", "-c",

2605

"echo -n ${MANDOSPLUGINHELPERDIR}", NULL };

2664

"printf %s \"${MANDOSPLUGINHELPERDIR}\"", NULL };

2606

2665

2607

2666

const bool success = start_mandos_client(queue, epoll_fd,

2608

2667

&mandos_client_exited,

2903

2962

2904

2963

__attribute__((cleanup(cleanup_close)))

2905

2964

const int devnull_fd = open("/dev/null",

2906

O_WRONLY | O_CLOEXEC);

2965

O_WRONLY | O_CLOEXEC | O_NOCTTY);

2907

2966

g_assert_cmpint(devnull_fd, >=, 0);

2908

2967

__attribute__((cleanup(cleanup_close)))

2909

2968

const int real_stderr_fd = dup(STDERR_FILENO);

2974

3033

2975

3034

__attribute__((cleanup(cleanup_close)))

2976

3035

const int devnull_fd = open("/dev/null",

2977

O_WRONLY | O_CLOEXEC);

3036

O_WRONLY | O_CLOEXEC, O_NOCTTY);

2978

3037

g_assert_cmpint(devnull_fd, >=, 0);

2979

3038

__attribute__((cleanup(cleanup_close)))

2980

3039

const int real_stderr_fd = dup(STDERR_FILENO);

3018

3077

buffer password = {};

3019

3078

3020

3079

/* Reading /proc/self/mem from offset 0 will always give EIO */

3021

const int fd = open("/proc/self/mem", O_RDONLY | O_CLOEXEC);

3080

const int fd = open("/proc/self/mem",

3081

O_RDONLY | O_CLOEXEC | O_NOCTTY);

3022

3082

3023

3083

bool password_is_read = false;

3024

3084

bool quit_now = false;

3452

3512

g_assert_cmpuint((unsigned int)queue->length, ==, 0);

3453

3513

}

3454

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

3455

3553

static void test_add_inotify_dir_watch_EAGAIN(__attribute__((unused))

3456

3554

test_fixture *fixture,

3457

3555

__attribute__((unused))

3672

3770

}

3673

3771

3674

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

3675

3845

void test_add_inotify_dir_watch_IN_DELETE(__attribute__((unused))

3676

3846

test_fixture *fixture,

3677

3847

__attribute__((unused))

3735

3905

g_assert_cmpint(rmdir(tempdir), ==, 0);

3736

3906

}

3737

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

3738

3984

static void test_read_inotify_event_readerror(__attribute__((unused))

3739

3985

test_fixture *fixture,

3740

3986

__attribute__((unused))

3746

3992

const mono_microsecs current_time = 0;

3747

3993

3748

3994

/* Reading /proc/self/mem from offset 0 will always result in EIO */

3749

const int fd = open("/proc/self/mem", O_RDONLY | O_CLOEXEC);

3995

const int fd = open("/proc/self/mem",

3996

O_RDONLY | O_CLOEXEC | O_NOCTTY);

3750

3997

3751

3998

bool quit_now = false;

3752

3999

__attribute__((cleanup(cleanup_queue)))

3943

4190

memcpy(ievent->name, dummy_file_name, sizeof(dummy_file_name));

3944

4191

const size_t ievent_size = (sizeof(struct inotify_event)

3945

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

3946

4198

g_assert_cmpint(write(pipefds[1], (char *)ievent, ievent_size),

3947

4199

==, ievent_size);

4200

#if defined(__GNUC__) and __GNUC__ >= 11

4201

#pragma GCC diagnostic pop

4202

#endif

3948

4203

g_assert_cmpint(close(pipefds[1]), ==, 0);

3949

4204

3950

4205

bool quit_now = false;

4038

4293

memcpy(ievent->name, dummy_file_name, sizeof(dummy_file_name));

4039

4294

const size_t ievent_size = (sizeof(struct inotify_event)

4040

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

4041

4301

g_assert_cmpint(write(pipefds[1], (char *)ievent, ievent_size),

4042

4302

==, ievent_size);

4303

#if defined(__GNUC__) and __GNUC__ >= 11

4304

#pragma GCC diagnostic pop

4305

#endif

4043

4306

g_assert_cmpint(close(pipefds[1]), ==, 0);

4044

4307

4045

4308

bool quit_now = false;

4104

4367

}));

4105

4368

}

4106

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

4107

4463

static void test_read_inotify_event_IN_DELETE(__attribute__((unused))

4108

4464

test_fixture *fixture,

4109

4465

__attribute__((unused))

4135

4491

memcpy(ievent->name, dummy_file_name, sizeof(dummy_file_name));

4136

4492

const size_t ievent_size = (sizeof(struct inotify_event)

4137

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

4138

4499

g_assert_cmpint(write(pipefds[1], (char *)ievent, ievent_size),

4139

4500

==, ievent_size);

4501

#if defined(__GNUC__) and __GNUC__ >= 11

4502

#pragma GCC diagnostic pop

4503

#endif

4140

4504

g_assert_cmpint(close(pipefds[1]), ==, 0);

4141

4505

4142

4506

bool quit_now = false;

4219

4583

memcpy(ievent->name, dummy_file_name, sizeof(dummy_file_name));

4220

4584

const size_t ievent_size = (sizeof(struct inotify_event)

4221

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

4222

4591

g_assert_cmpint(write(pipefds[1], (char *)ievent, ievent_size),

4223

4592

==, ievent_size);

4593

#if defined(__GNUC__) and __GNUC__ >= 11

4594

#pragma GCC diagnostic pop

4595

#endif

4224

4596

g_assert_cmpint(close(pipefds[1]), ==, 0);

4225

4597

4226

4598

bool quit_now = false;

4295

4667

memcpy(ievent->name, dummy_file_name, sizeof(dummy_file_name));

4296

4668

const size_t ievent_size = (sizeof(struct inotify_event)

4297

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

4298

4675

g_assert_cmpint(write(pipefds[1], (char *)ievent, ievent_size),

4299

4676

==, ievent_size);

4677

#if defined(__GNUC__) and __GNUC__ >= 11

4678

#pragma GCC diagnostic pop

4679

#endif

4300

4680

g_assert_cmpint(close(pipefds[1]), ==, 0);

4301

4681

4302

4682

bool quit_now = false;

4342

4722

EPOLLIN | EPOLLRDHUP));

4343

4723

}

4344

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

4345

4818

static

4346

4819

void test_read_inotify_event_IN_DELETE_badname(__attribute__((unused))

4347

4820

test_fixture *fixture,

5267

5740

__attribute__((unused))

5268

5741

gconstpointer user_data){

5269

5742

__attribute__((cleanup(cleanup_close)))

5270

const int epoll_fd = open("/dev/null", O_WRONLY | O_CLOEXEC);

5743

const int epoll_fd = open("/dev/null",

5744

O_WRONLY | O_CLOEXEC | O_NOCTTY);

5271

5745

__attribute__((cleanup(cleanup_string)))

5272

5746

char *const question_filename = strdup("/nonexistent/question");

5273

5747

g_assert_nonnull(question_filename);

5402

5876

char write_data[PIPE_BUF];

5403

5877

{

5404

5878

/* Construct test password buffer */

5405

/* Start with + since that is what the real procotol uses */

5879

/* Start with + since that is what the real protocol uses */

5406

5880

write_data[0] = '+';

5407

5881

/* Set a special character at string end just to mark the end */

5408

5882

write_data[sizeof(write_data)-2] = 'y';

5560

6034

char *const filename = strdup("/nonexistent/socket");

5561

6035

__attribute__((cleanup(string_set_clear)))

5562

6036

string_set cancelled_filenames = {};

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,

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,

5569

6093

};

5570

g_assert_nonnull(password.data);

5571

6094

if(mlock(password.data, password.allocated) != 0){

5572

6095

g_assert_true(errno == EPERM or errno == ENOMEM);

5573

6096

}

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);

5583

6097

5584

6098

__attribute__((cleanup(cleanup_queue)))

5585

6099

task_queue *queue = create_queue();

5586

6100

g_assert_nonnull(queue);

5587

int socketfds[2];

5588

6101

g_assert_cmpint(socketpair(PF_LOCAL, SOCK_DGRAM

5589

6102

| SOCK_NONBLOCK | SOCK_CLOEXEC, 0,

5590

6103

socketfds), ==, 0);

5677

6190

__attribute__((unused))

5678

6191

gconstpointer user_data){

5679

6192

__attribute__((cleanup(cleanup_close)))

5680

const int epoll_fd = open("/dev/null", O_WRONLY | O_CLOEXEC);

6193

const int epoll_fd = open("/dev/null",

6194

O_WRONLY | O_CLOEXEC | O_NOCTTY);

5681

6195

__attribute__((cleanup(cleanup_string)))

5682

6196

char *const question_filename = strdup("/nonexistent/question");

5683

6197

g_assert_nonnull(question_filename);

5946

6460

const char *const

5947

6461

dirname){

5948

6462

__attribute__((cleanup(cleanup_close)))

5949

const int devnull_fd = open("/dev/null", O_WRONLY | O_CLOEXEC);

6463

const int devnull_fd = open("/dev/null",

6464

O_WRONLY | O_CLOEXEC | O_NOCTTY);

5950

6465

g_assert_cmpint(devnull_fd, >=, 0);

5951

6466

__attribute__((cleanup(cleanup_close)))

5952

6467

const int real_stderr_fd = dup(STDERR_FILENO);

7495

8010

test_add("/parse_arguments/mixed", test_parse_arguments_mixed);

7496

8011

test_add("/queue/create", test_create_queue);

7497

8012

test_add("/queue/add", test_add_to_queue);

8013

test_add("/queue/add/overflow", test_add_to_queue_overflow);

7498

8014

test_add("/queue/has_question/empty",

7499

8015

test_queue_has_question_empty);

7500

8016

test_add("/queue/has_question/false",

7587

8103

test_add_inotify_dir_watch);

7588

8104

test_add_st("/task-creators/add_inotify_dir_watch/fail",

7589

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);

7590

8108

test_add_st("/task-creators/add_inotify_dir_watch/EAGAIN",

7591

8109

test_add_inotify_dir_watch_EAGAIN);

7592

8110

test_add_st("/task-creators/add_inotify_dir_watch/IN_CLOSE_WRITE",

7593

8111

test_add_inotify_dir_watch_IN_CLOSE_WRITE);

7594

8112

test_add_st("/task-creators/add_inotify_dir_watch/IN_MOVED_TO",

7595

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);

7596

8118

test_add_st("/task-creators/add_inotify_dir_watch/IN_DELETE",

7597

8119

test_add_inotify_dir_watch_IN_DELETE);

7598

8120

test_add_st("/task/read_inotify_event/readerror",

7607

8129

test_read_inotify_event_IN_CLOSE_WRITE);

7608

8130

test_add_st("/task/read_inotify_event/IN_MOVED_TO",

7609

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);

7610

8134

test_add_st("/task/read_inotify_event/IN_DELETE",

7611

8135

test_read_inotify_event_IN_DELETE);

7612

8136

test_add_st("/task/read_inotify_event/IN_CLOSE_WRITE/badname",

7613

8137

test_read_inotify_event_IN_CLOSE_WRITE_badname);

7614

8138

test_add_st("/task/read_inotify_event/IN_MOVED_TO/badname",

7615

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);

7616

8142

test_add_st("/task/read_inotify_event/IN_DELETE/badname",

7617

8143

test_read_inotify_event_IN_DELETE_badname);

7618

8144

test_add_st("/task/open_and_parse_question/ENOENT",

7715

8241

g_option_context_set_help_enabled(context, FALSE);

7716

8242

g_option_context_set_ignore_unknown_options(context, TRUE);

7717

8243

7718

gboolean run_tests = FALSE;

8244

gboolean should_run_tests = FALSE;

7719

8245

GOptionEntry entries[] = {

7720

8246

{ "test", 0, 0, G_OPTION_ARG_NONE,

7721

&run_tests, "Run tests", NULL },

8247

&should_run_tests, "Run tests", NULL },

7722

8248

{ NULL }

7723

8249

};

7724

8250

g_option_context_add_main_entries(context, entries, NULL);

7731

8257

}

7732

8258

7733

8259

g_option_context_free(context);

7734

return run_tests != FALSE;

8260

return should_run_tests != FALSE;

7735

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

*/