/mandos/release : revision 237.7.754

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;

1119

1131

immediately */

1120

1132

queue->next_run = 1;

1121

1133

}

1122

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

1134

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

1123

1135

if(not string_set_add(cancelled_filenames,

1124

1136

question_filename)){

1125

1137

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

1879

1891

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

1880

1892

}

1881

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

1882

1917

static void dummy_func(__attribute__((unused))

1883

1918

const task_context task,

1884

1919

__attribute__((unused))

2222

2257

2223

2258

{

2224

2259

__attribute__((cleanup(cleanup_close)))

2225

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

2226

2262

g_assert_cmpint(devnull_fd, >=, 0);

2227

2263

__attribute__((cleanup(cleanup_close)))

2228

2264

const int real_stderr_fd = dup(STDERR_FILENO);

2252

2288

{

2253

2289

__attribute__((cleanup(cleanup_close)))

2254

2290

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

2255

O_WRONLY | O_CLOEXEC);

2291

O_WRONLY | O_CLOEXEC | O_NOCTTY);

2256

2292

g_assert_cmpint(devnull_fd, >=, 0);

2257

2293

__attribute__((cleanup(cleanup_close)))

2258

2294

const int real_stderr_fd = dup(STDERR_FILENO);

2903

2939

2904

2940

__attribute__((cleanup(cleanup_close)))

2905

2941

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

2906

O_WRONLY | O_CLOEXEC);

2942

O_WRONLY | O_CLOEXEC | O_NOCTTY);

2907

2943

g_assert_cmpint(devnull_fd, >=, 0);

2908

2944

__attribute__((cleanup(cleanup_close)))

2909

2945

const int real_stderr_fd = dup(STDERR_FILENO);

2974

3010

2975

3011

__attribute__((cleanup(cleanup_close)))

2976

3012

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

2977

O_WRONLY | O_CLOEXEC);

3013

O_WRONLY | O_CLOEXEC, O_NOCTTY);

2978

3014

g_assert_cmpint(devnull_fd, >=, 0);

2979

3015

__attribute__((cleanup(cleanup_close)))

2980

3016

const int real_stderr_fd = dup(STDERR_FILENO);

3018

3054

buffer password = {};

3019

3055

3020

3056

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

3021

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

3022

3059

3023

3060

bool password_is_read = false;

3024

3061

bool quit_now = false;

3452

3489

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

3453

3490

}

3454

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

3455

3530

static void test_add_inotify_dir_watch_EAGAIN(__attribute__((unused))

3456

3531

test_fixture *fixture,

3457

3532

__attribute__((unused))

3672

3747

}

3673

3748

3674

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

3675

3822

void test_add_inotify_dir_watch_IN_DELETE(__attribute__((unused))

3676

3823

test_fixture *fixture,

3677

3824

__attribute__((unused))

3735

3882

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

3736

3883

}

3737

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

3738

3961

static void test_read_inotify_event_readerror(__attribute__((unused))

3739

3962

test_fixture *fixture,

3740

3963

__attribute__((unused))

3746

3969

const mono_microsecs current_time = 0;

3747

3970

3748

3971

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

3749

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

3750

3974

3751

3975

bool quit_now = false;

3752

3976

__attribute__((cleanup(cleanup_queue)))

4104

4328

}));

4105

4329

}

4106

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

4107

4416

static void test_read_inotify_event_IN_DELETE(__attribute__((unused))

4108

4417

test_fixture *fixture,

4109

4418

__attribute__((unused))

4342

4651

EPOLLIN | EPOLLRDHUP));

4343

4652

}

4344

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

4345

4739

static

4346

4740

void test_read_inotify_event_IN_DELETE_badname(__attribute__((unused))

4347

4741

test_fixture *fixture,

5267

5661

__attribute__((unused))

5268

5662

gconstpointer user_data){

5269

5663

__attribute__((cleanup(cleanup_close)))

5270

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

5271

5666

__attribute__((cleanup(cleanup_string)))

5272

5667

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

5273

5668

g_assert_nonnull(question_filename);

5677

6072

__attribute__((unused))

5678

6073

gconstpointer user_data){

5679

6074

__attribute__((cleanup(cleanup_close)))

5680

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

5681

6077

__attribute__((cleanup(cleanup_string)))

5682

6078

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

5683

6079

g_assert_nonnull(question_filename);

5946

6342

const char *const

5947

6343

dirname){

5948

6344

__attribute__((cleanup(cleanup_close)))

5949

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

5950

6347

g_assert_cmpint(devnull_fd, >=, 0);

5951

6348

__attribute__((cleanup(cleanup_close)))

5952

6349

const int real_stderr_fd = dup(STDERR_FILENO);

7495

7892

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

7496

7893

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

7497

7894

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

7895

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

7498

7896

test_add("/queue/has_question/empty",

7499

7897

test_queue_has_question_empty);

7500

7898

test_add("/queue/has_question/false",

7587

7985

test_add_inotify_dir_watch);

7588

7986

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

7589

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

7590

7990

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

7591

7991

test_add_inotify_dir_watch_EAGAIN);

7592

7992

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

7593

7993

test_add_inotify_dir_watch_IN_CLOSE_WRITE);

7594

7994

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

7595

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

7596

8000

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

7597

8001

test_add_inotify_dir_watch_IN_DELETE);

7598

8002

test_add_st("/task/read_inotify_event/readerror",

7607

8011

test_read_inotify_event_IN_CLOSE_WRITE);

7608

8012

test_add_st("/task/read_inotify_event/IN_MOVED_TO",

7609

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

7610

8016

test_add_st("/task/read_inotify_event/IN_DELETE",

7611

8017

test_read_inotify_event_IN_DELETE);

7612

8018

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

7613

8019

test_read_inotify_event_IN_CLOSE_WRITE_badname);

7614

8020

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

7615

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

7616

8024

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

7617

8025

test_read_inotify_event_IN_DELETE_badname);

7618

8026

test_add_st("/task/open_and_parse_question/ENOENT",

7715

8123

g_option_context_set_help_enabled(context, FALSE);

7716

8124

g_option_context_set_ignore_unknown_options(context, TRUE);

7717

8125

7718

gboolean run_tests = FALSE;

8126

gboolean should_run_tests = FALSE;

7719

8127

GOptionEntry entries[] = {

7720

8128

{ "test", 0, 0, G_OPTION_ARG_NONE,

7721

&run_tests, "Run tests", NULL },

8129

&should_run_tests, "Run tests", NULL },

7722

8130

{ NULL }

7723

8131

};

7724

8132

g_option_context_add_main_entries(context, entries, NULL);

7731

8139

}

7732

8140

7733

8141

g_option_context_free(context);

7734

return run_tests != FALSE;

8142

return should_run_tests != FALSE;

7735

8143

}