/mandos/trunk : revision 1208

48

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

49

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

50

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

51

ENAMETOOLONG, ENOENT, EEXIST,

52

ECHILD, EPERM, ENOMEM, EAGAIN,

53

EINTR, ENOBUFS, EADDRINUSE,

51

ENAMETOOLONG, ENOENT, ENOTDIR,

52

ENOMEM, EEXIST, ECHILD, EPERM,

53

EAGAIN, EINTR, ENOBUFS, EADDRINUSE,

54

ECONNREFUSED, ECONNRESET,

55

ETOOMANYREFS, EMSGSIZE, EBADF,

56

EINVAL */

73

ARGP_ERR_UNKNOWN, ARGP_KEY_ARGS,

74

struct argp, argp_parse(),

75

ARGP_NO_EXIT */

76

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

76

77

#include <unistd.h> /* uid_t, gid_t, close(), pipe2(),

77

78

fork(), _exit(), dup2(),

78

79

STDOUT_FILENO, setresgid(),

83

84

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

84

85

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

85

86

F_GETFD, F_GETFL, FD_CLOEXEC,

86

open(), O_WRONLY, O_RDONLY */

87

open(), O_WRONLY, O_NOCTTY,

88

O_RDONLY, O_NOFOLLOW */

87

89

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

88

90

WEXITSTATUS() */

89

91

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

90

92

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

91

93

IN_CLOEXEC, inotify_add_watch(),

92

94

IN_CLOSE_WRITE, IN_MOVED_TO,

93

IN_DELETE, struct inotify_event */

95

IN_MOVED_FROM, IN_DELETE,

96

IN_EXCL_UNLINK, IN_ONLYDIR,

97

struct inotify_event */

94

98

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

99

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

100

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

101

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

102

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

100

103

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

101

104

GError, g_key_file_load_from_file(),

102

105

G_KEY_FILE_NONE, TRUE, G_FILE_ERROR_NOENT,

145

148

mono_microsecs next_run;

146

149

} __attribute__((designated_init)) task_queue;

147

150

148

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

151

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

149

152

150

153

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

151

154

this type */

431

434

case EACCES:

432

435

case ENAMETOOLONG:

433

436

case ENOENT:

437

case ENOTDIR:

434

438

return EX_OSFILE;

435

439

default:

436

440

return EX_OSERR;

647

651

648

652

__attribute__((nonnull, warn_unused_result))

649

653

bool add_to_queue(task_queue *const queue, const task_context task){

654

if((queue->length + 1) > (SIZE_MAX / sizeof(task_context))){

655

/* overflow */

656

error(0, ENOMEM, "Failed to allocate %" PRIuMAX

657

" tasks for queue->tasks", (uintmax_t)(queue->length + 1));

658

errno = ENOMEM;

659

return false;

660

}

650

661

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

651

662

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

652

663

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

1017

1028

return false;

1018

1029

}

1019

1030

1020

if(inotify_add_watch(fd, dir, IN_CLOSE_WRITE

1021

| IN_MOVED_TO | IN_DELETE)

1031

if(inotify_add_watch(fd, dir, IN_CLOSE_WRITE | IN_MOVED_TO

1032

| IN_MOVED_FROM| IN_DELETE | IN_EXCL_UNLINK

1033

| IN_ONLYDIR)

1022

1034

== -1){

1023

1035

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

1024

1036

return false;

1071

1083

/* "sufficient to read at least one event." - inotify(7) */

1072

1084

const size_t ievent_size = (sizeof(struct inotify_event)

1073

1085

+ NAME_MAX + 1);

1074

char ievent_buffer[sizeof(struct inotify_event) + NAME_MAX + 1];

1075

struct inotify_event *ievent = ((struct inotify_event *)

1076

ievent_buffer);

1086

struct {

1087

struct inotify_event event;

1088

char name_buffer[NAME_MAX + 1];

1089

} ievent_buffer;

1090

struct inotify_event *const ievent = &ievent_buffer.event;

1077

1091

1078

1092

const ssize_t read_length = read(fd, ievent, ievent_size);

1079

1093

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

1117

1131

immediately */

1118

1132

queue->next_run = 1;

1119

1133

}

1120

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

1134

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

1121

1135

if(not string_set_add(cancelled_filenames,

1122

1136

question_filename)){

1123

1137

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

1877

1891

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

1878

1892

}

1879

1893

1894

static void test_add_to_queue_overflow(__attribute__((unused))

1895

test_fixture *fixture,

1896

__attribute__((unused))

1897

gconstpointer user_data){

1898

__attribute__((cleanup(cleanup_queue)))

1899

task_queue *queue = create_queue();

1900

g_assert_nonnull(queue);

1901

g_assert_true(queue->length == 0);

1902

queue->length = SIZE_MAX / sizeof(task_context); /* fake max size */

1903

1904

FILE *real_stderr = stderr;

1905

FILE *devnull = fopen("/dev/null", "we");

1906

g_assert_nonnull(devnull);

1907

stderr = devnull;

1908

const bool ret = add_to_queue(queue,

1909

(task_context){ .func=dummy_func });

1910

g_assert_true(errno == ENOMEM);

1911

g_assert_false(ret);

1912

stderr = real_stderr;

1913

g_assert_cmpint(fclose(devnull), ==, 0);

1914

queue->length = 0; /* Restore real size */

1915

}

1916

1880

1917

static void dummy_func(__attribute__((unused))

1881

1918

const task_context task,

1882

1919

__attribute__((unused))

2220

2257

2221

2258

{

2222

2259

__attribute__((cleanup(cleanup_close)))

2223

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

2260

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

2261

O_WRONLY | O_CLOEXEC | O_NOCTTY);

2224

2262

g_assert_cmpint(devnull_fd, >=, 0);

2225

2263

__attribute__((cleanup(cleanup_close)))

2226

2264

const int real_stderr_fd = dup(STDERR_FILENO);

2250

2288

{

2251

2289

__attribute__((cleanup(cleanup_close)))

2252

2290

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

2253

O_WRONLY | O_CLOEXEC);

2291

O_WRONLY | O_CLOEXEC | O_NOCTTY);

2254

2292

g_assert_cmpint(devnull_fd, >=, 0);

2255

2293

__attribute__((cleanup(cleanup_close)))

2256

2294

const int real_stderr_fd = dup(STDERR_FILENO);

2901

2939

2902

2940

__attribute__((cleanup(cleanup_close)))

2903

2941

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

2904

O_WRONLY | O_CLOEXEC);

2942

O_WRONLY | O_CLOEXEC | O_NOCTTY);

2905

2943

g_assert_cmpint(devnull_fd, >=, 0);

2906

2944

__attribute__((cleanup(cleanup_close)))

2907

2945

const int real_stderr_fd = dup(STDERR_FILENO);

2972

3010

2973

3011

__attribute__((cleanup(cleanup_close)))

2974

3012

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

2975

O_WRONLY | O_CLOEXEC);

3013

O_WRONLY | O_CLOEXEC, O_NOCTTY);

2976

3014

g_assert_cmpint(devnull_fd, >=, 0);

2977

3015

__attribute__((cleanup(cleanup_close)))

2978

3016

const int real_stderr_fd = dup(STDERR_FILENO);

3016

3054

buffer password = {};

3017

3055

3018

3056

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

3019

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

3057

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

3058

O_RDONLY | O_CLOEXEC | O_NOCTTY);

3020

3059

3021

3060

bool password_is_read = false;

3022

3061

bool quit_now = false;

3450

3489

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

3451

3490

}

3452

3491

3492

static void test_add_inotify_dir_watch_nondir(__attribute__((unused))

3493

test_fixture *fixture,

3494

__attribute__((unused))

3495

gconstpointer

3496

user_data){

3497

__attribute__((cleanup(cleanup_close)))

3498

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

3499

g_assert_cmpint(epoll_fd, >=, 0);

3500

__attribute__((cleanup(cleanup_queue)))

3501

task_queue *queue = create_queue();

3502

g_assert_nonnull(queue);

3503

__attribute__((cleanup(string_set_clear)))

3504

string_set cancelled_filenames = {};

3505

const mono_microsecs current_time = 0;

3506

3507

bool quit_now = false;

3508

buffer password = {};

3509

bool mandos_client_exited = false;

3510

bool password_is_read = false;

3511

3512

const char not_a_directory[] = "/dev/tty";

3513

3514

FILE *real_stderr = stderr;

3515

FILE *devnull = fopen("/dev/null", "we");

3516

g_assert_nonnull(devnull);

3517

stderr = devnull;

3518

g_assert_false(add_inotify_dir_watch(queue, epoll_fd, &quit_now,

3519

&password, not_a_directory,

3520

&cancelled_filenames,

3521

&current_time,

3522

&mandos_client_exited,

3523

&password_is_read));

3524

stderr = real_stderr;

3525

g_assert_cmpint(fclose(devnull), ==, 0);

3526

3527

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

3528

}

3529

3453

3530

static void test_add_inotify_dir_watch_EAGAIN(__attribute__((unused))

3454

3531

test_fixture *fixture,

3455

3532

__attribute__((unused))

3670

3747

}

3671

3748

3672

3749

static

3750

void test_add_inotify_dir_watch_IN_MOVED_FROM(__attribute__((unused))

3751

test_fixture *fixture,

3752

__attribute__((unused))

3753

gconstpointer

3754

user_data){

3755

__attribute__((cleanup(cleanup_close)))

3756

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

3757

g_assert_cmpint(epoll_fd, >=, 0);

3758

__attribute__((cleanup(cleanup_queue)))

3759

task_queue *queue = create_queue();

3760

g_assert_nonnull(queue);

3761

__attribute__((cleanup(string_set_clear)))

3762

string_set cancelled_filenames = {};

3763

const mono_microsecs current_time = 0;

3764

3765

bool quit_now = false;

3766

buffer password = {};

3767

bool mandos_client_exited = false;

3768

bool password_is_read = false;

3769

3770

__attribute__((cleanup(cleanup_string)))

3771

char *tempdir = make_temporary_directory();

3772

g_assert_nonnull(tempdir);

3773

3774

__attribute__((cleanup(cleanup_string)))

3775

char *tempfilename = make_temporary_file_in_directory(tempdir);

3776

g_assert_nonnull(tempfilename);

3777

3778

__attribute__((cleanup(cleanup_string)))

3779

char *targetdir = make_temporary_directory();

3780

g_assert_nonnull(targetdir);

3781

3782

__attribute__((cleanup(cleanup_string)))

3783

char *targetfilename = NULL;

3784

g_assert_cmpint(asprintf(&targetfilename, "%s/%s", targetdir,

3785

basename(tempfilename)), >, 0);

3786

g_assert_nonnull(targetfilename);

3787

3788

g_assert_true(add_inotify_dir_watch(queue, epoll_fd, &quit_now,

3789

&password, tempdir,

3790

&cancelled_filenames,

3791

&current_time,

3792

&mandos_client_exited,

3793

&password_is_read));

3794

3795

g_assert_cmpint(rename(tempfilename, targetfilename), ==, 0);

3796

3797

const task_context *const added_read_task

3798

= find_matching_task(queue,

3799

(task_context){ .func=read_inotify_event });

3800

g_assert_nonnull(added_read_task);

3801

3802

/* "sufficient to read at least one event." - inotify(7) */

3803

const size_t ievent_size = (sizeof(struct inotify_event)

3804

+ NAME_MAX + 1);

3805

struct inotify_event *ievent = malloc(ievent_size);

3806

g_assert_nonnull(ievent);

3807

3808

ssize_t read_size = read(added_read_task->fd, ievent, ievent_size);

3809

3810

g_assert_cmpint((int)read_size, >, 0);

3811

g_assert_true(ievent->mask & IN_MOVED_FROM);

3812

g_assert_cmpstr(ievent->name, ==, basename(tempfilename));

3813

3814

free(ievent);

3815

3816

g_assert_cmpint(unlink(targetfilename), ==, 0);

3817

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

3818

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

3819

}

3820

3821

static

3673

3822

void test_add_inotify_dir_watch_IN_DELETE(__attribute__((unused))

3674

3823

test_fixture *fixture,

3675

3824

__attribute__((unused))

3733

3882

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

3734

3883

}

3735

3884

3885

static

3886

void test_add_inotify_dir_watch_IN_EXCL_UNLINK(__attribute__((unused))

3887

test_fixture *fixture,

3888

__attribute__((unused))

3889

gconstpointer

3890

user_data){

3891

__attribute__((cleanup(cleanup_close)))

3892

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

3893

g_assert_cmpint(epoll_fd, >=, 0);

3894

__attribute__((cleanup(cleanup_queue)))

3895

task_queue *queue = create_queue();

3896

g_assert_nonnull(queue);

3897

__attribute__((cleanup(string_set_clear)))

3898

string_set cancelled_filenames = {};

3899

const mono_microsecs current_time = 0;

3900

3901

bool quit_now = false;

3902

buffer password = {};

3903

bool mandos_client_exited = false;

3904

bool password_is_read = false;

3905

3906

__attribute__((cleanup(cleanup_string)))

3907

char *tempdir = make_temporary_directory();

3908

g_assert_nonnull(tempdir);

3909

3910

__attribute__((cleanup(cleanup_string)))

3911

char *tempfile = make_temporary_file_in_directory(tempdir);

3912

g_assert_nonnull(tempfile);

3913

int tempfile_fd = open(tempfile, O_WRONLY | O_CLOEXEC | O_NOCTTY

3914

| O_NOFOLLOW);

3915

g_assert_cmpint(tempfile_fd, >, 2);

3916

3917

g_assert_true(add_inotify_dir_watch(queue, epoll_fd, &quit_now,

3918

&password, tempdir,

3919

&cancelled_filenames,

3920

&current_time,

3921

&mandos_client_exited,

3922

&password_is_read));

3923

g_assert_cmpint(unlink(tempfile), ==, 0);

3924

3925

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

3926

3927

const task_context *const added_read_task

3928

= find_matching_task(queue,

3929

(task_context){ .func=read_inotify_event });

3930

g_assert_nonnull(added_read_task);

3931

3932

g_assert_cmpint(added_read_task->fd, >, 2);

3933

g_assert_true(fd_has_cloexec_and_nonblock(added_read_task->fd));

3934

3935

/* "sufficient to read at least one event." - inotify(7) */

3936

const size_t ievent_size = (sizeof(struct inotify_event)

3937

+ NAME_MAX + 1);

3938

struct inotify_event *ievent = malloc(ievent_size);

3939

g_assert_nonnull(ievent);

3940

3941

ssize_t read_size = 0;

3942

read_size = read(added_read_task->fd, ievent, ievent_size);

3943

3944

g_assert_cmpint((int)read_size, >, 0);

3945

g_assert_true(ievent->mask & IN_DELETE);

3946

g_assert_cmpstr(ievent->name, ==, basename(tempfile));

3947

3948

g_assert_cmpint(close(tempfile_fd), ==, 0);

3949

3950

/* IN_EXCL_UNLINK should make the closing of the previously unlinked

3951

file not appear as an ievent, so we should not see it now. */

3952

read_size = read(added_read_task->fd, ievent, ievent_size);

3953

g_assert_cmpint((int)read_size, ==, -1);

3954

g_assert_true(errno == EAGAIN);

3955

3956

free(ievent);

3957

3958

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

3959

}

3960

3736

3961

static void test_read_inotify_event_readerror(__attribute__((unused))

3737

3962

test_fixture *fixture,

3738

3963

__attribute__((unused))

3744

3969

const mono_microsecs current_time = 0;

3745

3970

3746

3971

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

3747

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

3972

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

3973

O_RDONLY | O_CLOEXEC | O_NOCTTY);

3748

3974

3749

3975

bool quit_now = false;

3750

3976

__attribute__((cleanup(cleanup_queue)))

3929

4155

const size_t ievent_max_size = (sizeof(struct inotify_event)

3930

4156

+ NAME_MAX + 1);

3931

4157

g_assert_cmpint(ievent_max_size, <=, PIPE_BUF);

3932

char ievent_buffer[sizeof(struct inotify_event) + NAME_MAX + 1];

3933

struct inotify_event *ievent = ((struct inotify_event *)

3934

ievent_buffer);

4158

struct {

4159

struct inotify_event event;

4160

char name_buffer[NAME_MAX + 1];

4161

} ievent_buffer;

4162

struct inotify_event *const ievent = &ievent_buffer.event;

3935

4163

3936

4164

const char dummy_file_name[] = "ask.dummy_file_name";

3937

4165

ievent->mask = IN_CLOSE_WRITE;

3939

4167

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

3940

4168

const size_t ievent_size = (sizeof(struct inotify_event)

3941

4169

+ sizeof(dummy_file_name));

3942

g_assert_cmpint(write(pipefds[1], ievent_buffer, ievent_size),

4170

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

3943

4171

==, ievent_size);

3944

4172

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

3945

4173

4022

4250

const size_t ievent_max_size = (sizeof(struct inotify_event)

4023

4251

+ NAME_MAX + 1);

4024

4252

g_assert_cmpint(ievent_max_size, <=, PIPE_BUF);

4025

char ievent_buffer[sizeof(struct inotify_event) + NAME_MAX + 1];

4026

struct inotify_event *ievent = ((struct inotify_event *)

4027

ievent_buffer);

4253

struct {

4254

struct inotify_event event;

4255

char name_buffer[NAME_MAX + 1];

4256

} ievent_buffer;

4257

struct inotify_event *const ievent = &ievent_buffer.event;

4028

4258

4029

4259

const char dummy_file_name[] = "ask.dummy_file_name";

4030

4260

ievent->mask = IN_MOVED_TO;

4032

4262

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

4033

4263

const size_t ievent_size = (sizeof(struct inotify_event)

4034

4264

+ sizeof(dummy_file_name));

4035

g_assert_cmpint(write(pipefds[1], ievent_buffer, ievent_size),

4265

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

4036

4266

==, ievent_size);

4037

4267

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

4038

4268

4098

4328

}));

4099

4329

}

4100

4330

4331

static

4332

void test_read_inotify_event_IN_MOVED_FROM(__attribute__((unused))

4333

test_fixture *fixture,

4334

__attribute__((unused))

4335

gconstpointer user_data){

4336

__attribute__((cleanup(cleanup_close)))

4337

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

4338

g_assert_cmpint(epoll_fd, >=, 0);

4339

__attribute__((cleanup(string_set_clear)))

4340

string_set cancelled_filenames = {};

4341

const mono_microsecs current_time = 0;

4342

4343

int pipefds[2];

4344

g_assert_cmpint(pipe2(pipefds, O_CLOEXEC | O_NONBLOCK), ==, 0);

4345

4346

/* "sufficient to read at least one event." - inotify(7) */

4347

const size_t ievent_max_size = (sizeof(struct inotify_event)

4348

+ NAME_MAX + 1);

4349

g_assert_cmpint(ievent_max_size, <=, PIPE_BUF);

4350

struct {

4351

struct inotify_event event;

4352

char name_buffer[NAME_MAX + 1];

4353

} ievent_buffer;

4354

struct inotify_event *const ievent = &ievent_buffer.event;

4355

4356

const char dummy_file_name[] = "ask.dummy_file_name";

4357

ievent->mask = IN_MOVED_FROM;

4358

ievent->len = sizeof(dummy_file_name);

4359

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

4360

const size_t ievent_size = (sizeof(struct inotify_event)

4361

+ sizeof(dummy_file_name));

4362

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

4363

==, ievent_size);

4364

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

4365

4366

bool quit_now = false;

4367

buffer password = {};

4368

bool mandos_client_exited = false;

4369

bool password_is_read = false;

4370

__attribute__((cleanup(cleanup_queue)))

4371

task_queue *queue = create_queue();

4372

g_assert_nonnull(queue);

4373

4374

task_context task = {

4375

.func=read_inotify_event,

4376

.epoll_fd=epoll_fd,

4377

.fd=pipefds[0],

4378

.quit_now=&quit_now,

4379

.password=&password,

4380

.filename=strdup("/nonexistent"),

4381

.cancelled_filenames=&cancelled_filenames,

4382

.current_time=&current_time,

4383

.mandos_client_exited=&mandos_client_exited,

4384

.password_is_read=&password_is_read,

4385

};

4386

task.func(task, queue);

4387

g_assert_false(quit_now);

4388

g_assert_true(queue->next_run == 0);

4389

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

4390

4391

g_assert_nonnull(find_matching_task(queue, (task_context){

4392

.func=read_inotify_event,

4393

.epoll_fd=epoll_fd,

4394

.fd=pipefds[0],

4395

.quit_now=&quit_now,

4396

.password=&password,

4397

.filename=task.filename,

4398

.cancelled_filenames=&cancelled_filenames,

4399

.current_time=&current_time,

4400

.mandos_client_exited=&mandos_client_exited,

4401

.password_is_read=&password_is_read,

4402

}));

4403

4404

g_assert_true(epoll_set_contains(epoll_fd, pipefds[0],

4405

EPOLLIN | EPOLLRDHUP));

4406

4407

__attribute__((cleanup(cleanup_string)))

4408

char *filename = NULL;

4409

g_assert_cmpint(asprintf(&filename, "%s/%s", task.filename,

4410

dummy_file_name), >, 0);

4411

g_assert_nonnull(filename);

4412

g_assert_true(string_set_contains(*task.cancelled_filenames,

4413

filename));

4414

}

4415

4101

4416

static void test_read_inotify_event_IN_DELETE(__attribute__((unused))

4102

4417

test_fixture *fixture,

4103

4418

__attribute__((unused))

4117

4432

const size_t ievent_max_size = (sizeof(struct inotify_event)

4118

4433

+ NAME_MAX + 1);

4119

4434

g_assert_cmpint(ievent_max_size, <=, PIPE_BUF);

4120

char ievent_buffer[sizeof(struct inotify_event) + NAME_MAX + 1];

4121

struct inotify_event *ievent = ((struct inotify_event *)

4122

ievent_buffer);

4435

struct {

4436

struct inotify_event event;

4437

char name_buffer[NAME_MAX + 1];

4438

} ievent_buffer;

4439

struct inotify_event *const ievent = &ievent_buffer.event;

4123

4440

4124

4441

const char dummy_file_name[] = "ask.dummy_file_name";

4125

4442

ievent->mask = IN_DELETE;

4127

4444

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

4128

4445

const size_t ievent_size = (sizeof(struct inotify_event)

4129

4446

+ sizeof(dummy_file_name));

4130

g_assert_cmpint(write(pipefds[1], ievent_buffer, ievent_size),

4447

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

4131

4448

==, ievent_size);

4132

4449

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

4133

4450

4199

4516

const size_t ievent_max_size = (sizeof(struct inotify_event)

4200

4517

+ NAME_MAX + 1);

4201

4518

g_assert_cmpint(ievent_max_size, <=, PIPE_BUF);

4202

char ievent_buffer[sizeof(struct inotify_event) + NAME_MAX + 1];

4203

struct inotify_event *ievent = ((struct inotify_event *)

4204

ievent_buffer);

4519

struct {

4520

struct inotify_event event;

4521

char name_buffer[NAME_MAX + 1];

4522

} ievent_buffer;

4523

struct inotify_event *const ievent = &ievent_buffer.event;

4205

4524

4206

4525

const char dummy_file_name[] = "ignored.dummy_file_name";

4207

4526

ievent->mask = IN_CLOSE_WRITE;

4209

4528

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

4210

4529

const size_t ievent_size = (sizeof(struct inotify_event)

4211

4530

+ sizeof(dummy_file_name));

4212

g_assert_cmpint(write(pipefds[1], ievent_buffer, ievent_size),

4531

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

4213

4532

==, ievent_size);

4214

4533

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

4215

4534

4273

4592

const size_t ievent_max_size = (sizeof(struct inotify_event)

4274

4593

+ NAME_MAX + 1);

4275

4594

g_assert_cmpint(ievent_max_size, <=, PIPE_BUF);

4276

char ievent_buffer[sizeof(struct inotify_event) + NAME_MAX + 1];

4277

struct inotify_event *ievent = ((struct inotify_event *)

4278

ievent_buffer);

4595

struct {

4596

struct inotify_event event;

4597

char name_buffer[NAME_MAX + 1];

4598

} ievent_buffer;

4599

struct inotify_event *const ievent = &ievent_buffer.event;

4279

4600

4280

4601

const char dummy_file_name[] = "ignored.dummy_file_name";

4281

4602

ievent->mask = IN_MOVED_TO;

4283

4604

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

4284

4605

const size_t ievent_size = (sizeof(struct inotify_event)

4285

4606

+ sizeof(dummy_file_name));

4286

g_assert_cmpint(write(pipefds[1], ievent_buffer, ievent_size),

4607

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

4287

4608

==, ievent_size);

4288

4609

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

4289

4610

4330

4651

EPOLLIN | EPOLLRDHUP));

4331

4652

}

4332

4653

4654

static void

4655

test_read_inotify_event_IN_MOVED_FROM_badname(__attribute__((unused))

4656

test_fixture *fixture,

4657

__attribute__((unused))

4658

gconstpointer

4659

user_data){

4660

__attribute__((cleanup(cleanup_close)))

4661

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

4662

g_assert_cmpint(epoll_fd, >=, 0);

4663

__attribute__((cleanup(string_set_clear)))

4664

string_set cancelled_filenames = {};

4665

const mono_microsecs current_time = 0;

4666

4667

int pipefds[2];

4668

g_assert_cmpint(pipe2(pipefds, O_CLOEXEC | O_NONBLOCK), ==, 0);

4669

4670

/* "sufficient to read at least one event." - inotify(7) */

4671

const size_t ievent_max_size = (sizeof(struct inotify_event)

4672

+ NAME_MAX + 1);

4673

g_assert_cmpint(ievent_max_size, <=, PIPE_BUF);

4674

struct {

4675

struct inotify_event event;

4676

char name_buffer[NAME_MAX + 1];

4677

} ievent_buffer;

4678

struct inotify_event *const ievent = &ievent_buffer.event;

4679

4680

const char dummy_file_name[] = "ignored.dummy_file_name";

4681

ievent->mask = IN_MOVED_FROM;

4682

ievent->len = sizeof(dummy_file_name);

4683

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

4684

const size_t ievent_size = (sizeof(struct inotify_event)

4685

+ sizeof(dummy_file_name));

4686

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

4687

==, ievent_size);

4688

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

4689

4690

bool quit_now = false;

4691

buffer password = {};

4692

bool mandos_client_exited = false;

4693

bool password_is_read = false;

4694

__attribute__((cleanup(cleanup_queue)))

4695

task_queue *queue = create_queue();

4696

g_assert_nonnull(queue);

4697

4698

task_context task = {

4699

.func=read_inotify_event,

4700

.epoll_fd=epoll_fd,

4701

.fd=pipefds[0],

4702

.quit_now=&quit_now,

4703

.password=&password,

4704

.filename=strdup("/nonexistent"),

4705

.cancelled_filenames=&cancelled_filenames,

4706

.current_time=&current_time,

4707

.mandos_client_exited=&mandos_client_exited,

4708

.password_is_read=&password_is_read,

4709

};

4710

task.func(task, queue);

4711

g_assert_false(quit_now);

4712

g_assert_true(queue->next_run == 0);

4713

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

4714

4715

g_assert_nonnull(find_matching_task(queue, (task_context){

4716

.func=read_inotify_event,

4717

.epoll_fd=epoll_fd,

4718

.fd=pipefds[0],

4719

.quit_now=&quit_now,

4720

.password=&password,

4721

.filename=task.filename,

4722

.cancelled_filenames=&cancelled_filenames,

4723

.current_time=&current_time,

4724

.mandos_client_exited=&mandos_client_exited,

4725

.password_is_read=&password_is_read,

4726

}));

4727

4728

g_assert_true(epoll_set_contains(epoll_fd, pipefds[0],

4729

EPOLLIN | EPOLLRDHUP));

4730

4731

__attribute__((cleanup(cleanup_string)))

4732

char *filename = NULL;

4733

g_assert_cmpint(asprintf(&filename, "%s/%s", task.filename,

4734

dummy_file_name), >, 0);

4735

g_assert_nonnull(filename);

4736

g_assert_false(string_set_contains(cancelled_filenames, filename));

4737

}

4738

4333

4739

static

4334

4740

void test_read_inotify_event_IN_DELETE_badname(__attribute__((unused))

4335

4741

test_fixture *fixture,

4350

4756

const size_t ievent_max_size = (sizeof(struct inotify_event)

4351

4757

+ NAME_MAX + 1);

4352

4758

g_assert_cmpint(ievent_max_size, <=, PIPE_BUF);

4353

char ievent_buffer[sizeof(struct inotify_event) + NAME_MAX + 1];

4354

struct inotify_event *ievent = ((struct inotify_event *)

4355

ievent_buffer);

4759

struct {

4760

struct inotify_event event;

4761

char name_buffer[NAME_MAX + 1];

4762

} ievent_buffer;

4763

struct inotify_event *const ievent = &ievent_buffer.event;

4356

4764

4357

4765

const char dummy_file_name[] = "ignored.dummy_file_name";

4358

4766

ievent->mask = IN_DELETE;

4360

4768

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

4361

4769

const size_t ievent_size = (sizeof(struct inotify_event)

4362

4770

+ sizeof(dummy_file_name));

4363

g_assert_cmpint(write(pipefds[1], ievent_buffer, ievent_size),

4771

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

4364

4772

==, ievent_size);

4365

4773

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

4366

4774

5253

5661

__attribute__((unused))

5254

5662

gconstpointer user_data){

5255

5663

__attribute__((cleanup(cleanup_close)))

5256

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

5664

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

5665

O_WRONLY | O_CLOEXEC | O_NOCTTY);

5257

5666

__attribute__((cleanup(cleanup_string)))

5258

5667

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

5259

5668

g_assert_nonnull(question_filename);

5663

6072

__attribute__((unused))

5664

6073

gconstpointer user_data){

5665

6074

__attribute__((cleanup(cleanup_close)))

5666

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

6075

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

6076

O_WRONLY | O_CLOEXEC | O_NOCTTY);

5667

6077

__attribute__((cleanup(cleanup_string)))

5668

6078

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

5669

6079

g_assert_nonnull(question_filename);

5932

6342

const char *const

5933

6343

dirname){

5934

6344

__attribute__((cleanup(cleanup_close)))

5935

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

6345

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

6346

O_WRONLY | O_CLOEXEC | O_NOCTTY);

5936

6347

g_assert_cmpint(devnull_fd, >=, 0);

5937

6348

__attribute__((cleanup(cleanup_close)))

5938

6349

const int real_stderr_fd = dup(STDERR_FILENO);

7481

7892

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

7482

7893

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

7483

7894

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

7895

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

7484

7896

test_add("/queue/has_question/empty",

7485

7897

test_queue_has_question_empty);

7486

7898

test_add("/queue/has_question/false",

7573

7985

test_add_inotify_dir_watch);

7574

7986

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

7575

7987

test_add_inotify_dir_watch_fail);

7988

test_add_st("/task-creators/add_inotify_dir_watch/not-a-directory",

7989

test_add_inotify_dir_watch_nondir);

7576

7990

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

7577

7991

test_add_inotify_dir_watch_EAGAIN);

7578

7992

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

7579

7993

test_add_inotify_dir_watch_IN_CLOSE_WRITE);

7580

7994

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

7581

7995

test_add_inotify_dir_watch_IN_MOVED_TO);

7996

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

7997

test_add_inotify_dir_watch_IN_MOVED_FROM);

7998

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

7999

test_add_inotify_dir_watch_IN_EXCL_UNLINK);

7582

8000

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

7583

8001

test_add_inotify_dir_watch_IN_DELETE);

7584

8002

test_add_st("/task/read_inotify_event/readerror",

7593

8011

test_read_inotify_event_IN_CLOSE_WRITE);

7594

8012

test_add_st("/task/read_inotify_event/IN_MOVED_TO",

7595

8013

test_read_inotify_event_IN_MOVED_TO);

8014

test_add_st("/task/read_inotify_event/IN_MOVED_FROM",

8015

test_read_inotify_event_IN_MOVED_FROM);

7596

8016

test_add_st("/task/read_inotify_event/IN_DELETE",

7597

8017

test_read_inotify_event_IN_DELETE);

7598

8018

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

7599

8019

test_read_inotify_event_IN_CLOSE_WRITE_badname);

7600

8020

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

7601

8021

test_read_inotify_event_IN_MOVED_TO_badname);

8022

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

8023

test_read_inotify_event_IN_MOVED_FROM_badname);

7602

8024

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

7603

8025

test_read_inotify_event_IN_DELETE_badname);

7604

8026

test_add_st("/task/open_and_parse_question/ENOENT",

7701

8123

g_option_context_set_help_enabled(context, FALSE);

7702

8124

g_option_context_set_ignore_unknown_options(context, TRUE);

7703

8125

7704

gboolean run_tests = FALSE;

8126

gboolean should_run_tests = FALSE;

7705

8127

GOptionEntry entries[] = {

7706

8128

{ "test", 0, 0, G_OPTION_ARG_NONE,

7707

&run_tests, "Run tests", NULL },

8129

&should_run_tests, "Run tests", NULL },

7708

8130

{ NULL }

7709

8131

};

7710

8132

g_option_context_add_main_entries(context, entries, NULL);

7717

8139

}

7718

8140

7719

8141

g_option_context_free(context);

7720

return run_tests != FALSE;

8142

return should_run_tests != FALSE;

7721

8143

}