/mandos/release : revision 237.7.688

To get this branch, use:

bzr branch
http://bzr.recompile.se/loggerhead/mandos/release

« back to all changes in this revision

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

Committer: Teddy Hogeborn
Date: 2019-08-03 10:45:18 UTC
mto: This revision was merged to the branch mainline in revision 386.
Revision ID: teddy@recompile.se-20190803104518-0jljs59cdw352atv

dracut-module/password-agent.c: Bug fix: Handle IN_MOVED_FROM

If a question file ("ask.*") is moved away from the question directory
or is renamed in it, treat this the same as IN_DELETE.  If it was a
simple rename within the question directory from, say, "ask.foo" to
"ask.bar", the separate IN_MOVED_TO ievent will get the "ask.bar" name
and add it, so we don't need to consider this as a special case.

* dracut-module/password-agent.c (add_inotify_dir_watch): Add
  "IN_MOVED_FROM" to flags.
  (read_inotify_event): Treat IN_MOVED_FROM the same as IN_DELETE.
  (test_add_inotify_dir_watch_IN_MOVED_FROM): New test.
  (test_read_inotify_event_IN_MOVED_FROM): - '' -
  (test_read_inotify_event_IN_MOVED_FROM_badname): - '' -
  (run_tests): Add new tests.

Show diffs side-by-side

added added

removed removed

dracut-module/password-agent.c

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

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

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

ENAMETOOLONG, ENOENT, ENOTDIR,

EEXIST, ECHILD, EPERM, ENOMEM,

EAGAIN, EINTR, ENOBUFS, EADDRINUSE,

ENAMETOOLONG, ENOENT, EEXIST,

ECHILD, EPERM, ENOMEM, EAGAIN,

EINTR, ENOBUFS, EADDRINUSE,

ECONNREFUSED, ECONNRESET,

ETOOMANYREFS, EMSGSIZE, EBADF,

EINVAL */

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

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

F_GETFD, F_GETFL, FD_CLOEXEC,

open(), O_WRONLY, O_NOCTTY,

O_RDONLY, O_NOFOLLOW */

open(), O_WRONLY, O_RDONLY */

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

WEXITSTATUS() */

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

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

IN_CLOEXEC, inotify_add_watch(),

IN_CLOSE_WRITE, IN_MOVED_TO,

IN_MOVED_FROM, IN_DELETE,

IN_EXCL_UNLINK, IN_ONLYDIR,

struct inotify_event */

IN_DELETE, struct inotify_event */

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

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

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

434

431

case EACCES:

435

432

case ENAMETOOLONG:

436

433

case ENOENT:

437

case ENOTDIR:

438

434

return EX_OSFILE;

439

435

default:

440

436

return EX_OSERR;

1022

1018

}

1023

1019

1024

1020

if(inotify_add_watch(fd, dir, IN_CLOSE_WRITE | IN_MOVED_TO

1025

| IN_MOVED_FROM| IN_DELETE | IN_EXCL_UNLINK

1026

| IN_ONLYDIR)

1021

| IN_MOVED_FROM| IN_DELETE)

1027

1022

== -1){

1028

1023

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

1029

1024

return false;

2227

2222

2228

2223

{

2229

2224

__attribute__((cleanup(cleanup_close)))

2230

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

2231

O_WRONLY | O_CLOEXEC | O_NOCTTY);

2225

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

2232

2226

g_assert_cmpint(devnull_fd, >=, 0);

2233

2227

__attribute__((cleanup(cleanup_close)))

2234

2228

const int real_stderr_fd = dup(STDERR_FILENO);

2258

2252

{

2259

2253

__attribute__((cleanup(cleanup_close)))

2260

2254

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

2261

O_WRONLY | O_CLOEXEC | O_NOCTTY);

2255

O_WRONLY | O_CLOEXEC);

2262

2256

g_assert_cmpint(devnull_fd, >=, 0);

2263

2257

__attribute__((cleanup(cleanup_close)))

2264

2258

const int real_stderr_fd = dup(STDERR_FILENO);

2909

2903

2910

2904

__attribute__((cleanup(cleanup_close)))

2911

2905

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

2912

O_WRONLY | O_CLOEXEC | O_NOCTTY);

2906

O_WRONLY | O_CLOEXEC);

2913

2907

g_assert_cmpint(devnull_fd, >=, 0);

2914

2908

__attribute__((cleanup(cleanup_close)))

2915

2909

const int real_stderr_fd = dup(STDERR_FILENO);

2980

2974

2981

2975

__attribute__((cleanup(cleanup_close)))

2982

2976

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

2983

O_WRONLY | O_CLOEXEC, O_NOCTTY);

2977

O_WRONLY | O_CLOEXEC);

2984

2978

g_assert_cmpint(devnull_fd, >=, 0);

2985

2979

__attribute__((cleanup(cleanup_close)))

2986

2980

const int real_stderr_fd = dup(STDERR_FILENO);

3024

3018

buffer password = {};

3025

3019

3026

3020

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

3027

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

3028

O_RDONLY | O_CLOEXEC | O_NOCTTY);

3021

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

3029

3022

3030

3023

bool password_is_read = false;

3031

3024

bool quit_now = false;

3459

3452

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

3460

3453

}

3461

3454

3462

static void test_add_inotify_dir_watch_nondir(__attribute__((unused))

3463

test_fixture *fixture,

3464

__attribute__((unused))

3465

gconstpointer

3466

user_data){

3467

__attribute__((cleanup(cleanup_close)))

3468

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

3469

g_assert_cmpint(epoll_fd, >=, 0);

3470

__attribute__((cleanup(cleanup_queue)))

3471

task_queue *queue = create_queue();

3472

g_assert_nonnull(queue);

3473

__attribute__((cleanup(string_set_clear)))

3474

string_set cancelled_filenames = {};

3475

const mono_microsecs current_time = 0;

3476

3477

bool quit_now = false;

3478

buffer password = {};

3479

bool mandos_client_exited = false;

3480

bool password_is_read = false;

3481

3482

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

3483

3484

FILE *real_stderr = stderr;

3485

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

3486

g_assert_nonnull(devnull);

3487

stderr = devnull;

3488

g_assert_false(add_inotify_dir_watch(queue, epoll_fd, &quit_now,

3489

&password, not_a_directory,

3490

&cancelled_filenames,

3491

&current_time,

3492

&mandos_client_exited,

3493

&password_is_read));

3494

stderr = real_stderr;

3495

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

3496

3497

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

3498

}

3499

3500

3455

static void test_add_inotify_dir_watch_EAGAIN(__attribute__((unused))

3501

3456

test_fixture *fixture,

3502

3457

__attribute__((unused))

3852

3807

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

3853

3808

}

3854

3809

3855

static

3856

void test_add_inotify_dir_watch_IN_EXCL_UNLINK(__attribute__((unused))

3857

test_fixture *fixture,

3858

__attribute__((unused))

3859

gconstpointer

3860

user_data){

3861

__attribute__((cleanup(cleanup_close)))

3862

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

3863

g_assert_cmpint(epoll_fd, >=, 0);

3864

__attribute__((cleanup(cleanup_queue)))

3865

task_queue *queue = create_queue();

3866

g_assert_nonnull(queue);

3867

__attribute__((cleanup(string_set_clear)))

3868

string_set cancelled_filenames = {};

3869

const mono_microsecs current_time = 0;

3870

3871

bool quit_now = false;

3872

buffer password = {};

3873

bool mandos_client_exited = false;

3874

bool password_is_read = false;

3875

3876

__attribute__((cleanup(cleanup_string)))

3877

char *tempdir = make_temporary_directory();

3878

g_assert_nonnull(tempdir);

3879

3880

__attribute__((cleanup(cleanup_string)))

3881

char *tempfile = make_temporary_file_in_directory(tempdir);

3882

g_assert_nonnull(tempfile);

3883

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

3884

| O_NOFOLLOW);

3885

g_assert_cmpint(tempfile_fd, >, 2);

3886

3887

g_assert_true(add_inotify_dir_watch(queue, epoll_fd, &quit_now,

3888

&password, tempdir,

3889

&cancelled_filenames,

3890

&current_time,

3891

&mandos_client_exited,

3892

&password_is_read));

3893

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

3894

3895

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

3896

3897

const task_context *const added_read_task

3898

= find_matching_task(queue,

3899

(task_context){ .func=read_inotify_event });

3900

g_assert_nonnull(added_read_task);

3901

3902

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

3903

g_assert_true(fd_has_cloexec_and_nonblock(added_read_task->fd));

3904

3905

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

3906

const size_t ievent_size = (sizeof(struct inotify_event)

3907

+ NAME_MAX + 1);

3908

struct inotify_event *ievent = malloc(ievent_size);

3909

g_assert_nonnull(ievent);

3910

3911

ssize_t read_size = 0;

3912

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

3913

3914

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

3915

g_assert_true(ievent->mask & IN_DELETE);

3916

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

3917

3918

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

3919

3920

/* IN_EXCL_UNLINK should make the closing of the previously unlinked

3921

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

3922

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

3923

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

3924

g_assert_true(errno == EAGAIN);

3925

3926

free(ievent);

3927

3928

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

3929

}

3930

3931

3810

static void test_read_inotify_event_readerror(__attribute__((unused))

3932

3811

test_fixture *fixture,

3933

3812

__attribute__((unused))

3939

3818

const mono_microsecs current_time = 0;

3940

3819

3941

3820

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

3942

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

3943

O_RDONLY | O_CLOEXEC | O_NOCTTY);

3821

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

3944

3822

3945

3823

bool quit_now = false;

3946

3824

__attribute__((cleanup(cleanup_queue)))

5631

5509

__attribute__((unused))

5632

5510

gconstpointer user_data){

5633

5511

__attribute__((cleanup(cleanup_close)))

5634

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

5635

O_WRONLY | O_CLOEXEC | O_NOCTTY);

5512

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

5636

5513

__attribute__((cleanup(cleanup_string)))

5637

5514

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

5638

5515

g_assert_nonnull(question_filename);

6042

5919

__attribute__((unused))

6043

5920

gconstpointer user_data){

6044

5921

__attribute__((cleanup(cleanup_close)))

6045

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

6046

O_WRONLY | O_CLOEXEC | O_NOCTTY);

5922

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

6047

5923

__attribute__((cleanup(cleanup_string)))

6048

5924

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

6049

5925

g_assert_nonnull(question_filename);

6312

6188

const char *const

6313

6189

dirname){

6314

6190

__attribute__((cleanup(cleanup_close)))

6315

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

6316

O_WRONLY | O_CLOEXEC | O_NOCTTY);

6191

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

6317

6192

g_assert_cmpint(devnull_fd, >=, 0);

6318

6193

__attribute__((cleanup(cleanup_close)))

6319

6194

const int real_stderr_fd = dup(STDERR_FILENO);

7954

7829

test_add_inotify_dir_watch);

7955

7830

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

7956

7831

test_add_inotify_dir_watch_fail);

7957

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

7958

test_add_inotify_dir_watch_nondir);

7959

7832

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

7960

7833

test_add_inotify_dir_watch_EAGAIN);

7961

7834

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

7964

7837

test_add_inotify_dir_watch_IN_MOVED_TO);

7965

7838

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

7966

7839

test_add_inotify_dir_watch_IN_MOVED_FROM);

7967

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

7968

test_add_inotify_dir_watch_IN_EXCL_UNLINK);

7969

7840

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

7970

7841

test_add_inotify_dir_watch_IN_DELETE);

7971

7842

test_add_st("/task/read_inotify_event/readerror",

Older »