/mandos/release : revision 237.7.718

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-30 21:10:13 UTC
mto: This revision was merged to the branch mainline in revision 392.
Revision ID: teddy@recompile.se-20190830211013-7bt0qseq97dpt7oy

Update Python 3 compatibility

* mandos (rfc3339_duration_to_delta): Change doctest string to not
                                      depend on exact repr() string
                                      representation of values and
                                      instead do value comparisons.
  (string_to_delta): - '' -

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, EEXIST,

ECHILD, EPERM, ENOMEM, EAGAIN,

EINTR, ENOBUFS, EADDRINUSE,

ENAMETOOLONG, ENOENT, ENOTDIR,

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

open(), O_WRONLY, O_NOCTTY,

O_RDONLY, O_NOFOLLOW */

#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_DELETE, struct inotify_event */

IN_MOVED_FROM, IN_DELETE,

IN_EXCL_UNLINK, IN_ONLYDIR,

struct inotify_event */

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

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

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

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;

1018

1022

}

1019

1023

1020

1024

if(inotify_add_watch(fd, dir, IN_CLOSE_WRITE | IN_MOVED_TO

1021

| IN_MOVED_FROM| IN_DELETE)

1025

| IN_MOVED_FROM| IN_DELETE | IN_EXCL_UNLINK

1026

| IN_ONLYDIR)

1022

1027

== -1){

1023

1028

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

1024

1029

return false;

2222

2227

2223

2228

{

2224

2229

__attribute__((cleanup(cleanup_close)))

2225

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

2230

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

2231

O_WRONLY | O_CLOEXEC | O_NOCTTY);

2226

2232

g_assert_cmpint(devnull_fd, >=, 0);

2227

2233

__attribute__((cleanup(cleanup_close)))

2228

2234

const int real_stderr_fd = dup(STDERR_FILENO);

2252

2258

{

2253

2259

__attribute__((cleanup(cleanup_close)))

2254

2260

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

2255

O_WRONLY | O_CLOEXEC);

2261

O_WRONLY | O_CLOEXEC | O_NOCTTY);

2256

2262

g_assert_cmpint(devnull_fd, >=, 0);

2257

2263

__attribute__((cleanup(cleanup_close)))

2258

2264

const int real_stderr_fd = dup(STDERR_FILENO);

2903

2909

2904

2910

__attribute__((cleanup(cleanup_close)))

2905

2911

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

2906

O_WRONLY | O_CLOEXEC);

2912

O_WRONLY | O_CLOEXEC | O_NOCTTY);

2907

2913

g_assert_cmpint(devnull_fd, >=, 0);

2908

2914

__attribute__((cleanup(cleanup_close)))

2909

2915

const int real_stderr_fd = dup(STDERR_FILENO);

2974

2980

2975

2981

__attribute__((cleanup(cleanup_close)))

2976

2982

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

2977

O_WRONLY | O_CLOEXEC);

2983

O_WRONLY | O_CLOEXEC, O_NOCTTY);

2978

2984

g_assert_cmpint(devnull_fd, >=, 0);

2979

2985

__attribute__((cleanup(cleanup_close)))

2980

2986

const int real_stderr_fd = dup(STDERR_FILENO);

3018

3024

buffer password = {};

3019

3025

3020

3026

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

3021

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

3027

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

3028

O_RDONLY | O_CLOEXEC | O_NOCTTY);

3022

3029

3023

3030

bool password_is_read = false;

3024

3031

bool quit_now = false;

3452

3459

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

3453

3460

}

3454

3461

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

3455

3500

static void test_add_inotify_dir_watch_EAGAIN(__attribute__((unused))

3456

3501

test_fixture *fixture,

3457

3502

__attribute__((unused))

3807

3852

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

3808

3853

}

3809

3854

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

3810

3931

static void test_read_inotify_event_readerror(__attribute__((unused))

3811

3932

test_fixture *fixture,

3812

3933

__attribute__((unused))

3818

3939

const mono_microsecs current_time = 0;

3819

3940

3820

3941

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

3821

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

3942

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

3943

O_RDONLY | O_CLOEXEC | O_NOCTTY);

3822

3944

3823

3945

bool quit_now = false;

3824

3946

__attribute__((cleanup(cleanup_queue)))

5509

5631

__attribute__((unused))

5510

5632

gconstpointer user_data){

5511

5633

__attribute__((cleanup(cleanup_close)))

5512

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

5634

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

5635

O_WRONLY | O_CLOEXEC | O_NOCTTY);

5513

5636

__attribute__((cleanup(cleanup_string)))

5514

5637

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

5515

5638

g_assert_nonnull(question_filename);

5919

6042

__attribute__((unused))

5920

6043

gconstpointer user_data){

5921

6044

__attribute__((cleanup(cleanup_close)))

5922

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

6045

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

6046

O_WRONLY | O_CLOEXEC | O_NOCTTY);

5923

6047

__attribute__((cleanup(cleanup_string)))

5924

6048

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

5925

6049

g_assert_nonnull(question_filename);

6188

6312

const char *const

6189

6313

dirname){

6190

6314

__attribute__((cleanup(cleanup_close)))

6191

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

6315

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

6316

O_WRONLY | O_CLOEXEC | O_NOCTTY);

6192

6317

g_assert_cmpint(devnull_fd, >=, 0);

6193

6318

__attribute__((cleanup(cleanup_close)))

6194

6319

const int real_stderr_fd = dup(STDERR_FILENO);

7829

7954

test_add_inotify_dir_watch);

7830

7955

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

7831

7956

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

7832

7959

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

7833

7960

test_add_inotify_dir_watch_EAGAIN);

7834

7961

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

7837

7964

test_add_inotify_dir_watch_IN_MOVED_TO);

7838

7965

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

7839

7966

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

7840

7969

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

7841

7970

test_add_inotify_dir_watch_IN_DELETE);

7842

7971

test_add_st("/task/read_inotify_event/readerror",

Older »