To get this branch, use:
bzr branch
http://bzr.recompile.se/loggerhead/mandos/trunk
« back to all changes in this revision
Viewing changes to dracut-module/password-agent.c
- browse files at revision 1193
- compare with another revision
- download diff
- download tarball
- view history from revision 1193
- Committer: teddy at recompile
- Date: 2019-12-04 23:52:20 UTC
- Revision ID: teddy@recompile.se-20191204235220-yn88brp0scmqwy2t
Remove non-project-specific pattern from .bzrignore
Only project-specific patterns should be in the .bzrignore file.
Other generic patterns should be in the ~/.config/breezy/ignore and
~/.bazaar/ignore files.
* .bzrignore (.tramp_history): Remove.
Only project-specific patterns should be in the .bzrignore file.
Other generic patterns should be in the ~/.config/breezy/ignore and
~/.bazaar/ignore files.
* .bzrignore (.tramp_history): Remove.
- files added:
- debian/po/de.po
- files modified:
- .bzrignore
added
removed
dracut-module/password-agent.c
48
48
#include <error.h> /* error() */
49
49
#include <sysexits.h> /* EX_USAGE, EX_OSERR, EX_OSFILE */
50
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
EEXIST, ECHILD, EPERM, ENOMEM,
53
EAGAIN, EINTR, ENOBUFS, EADDRINUSE,
54
54
ECONNREFUSED, ECONNRESET,
55
55
ETOOMANYREFS, EMSGSIZE, EBADF,
56
56
EINVAL */
83
83
#include <sys/mman.h> /* munlock(), mlock() */
84
84
#include <fcntl.h> /* O_CLOEXEC, O_NONBLOCK, fcntl(),
85
85
F_GETFD, F_GETFL, FD_CLOEXEC,
86
open(), O_WRONLY, O_RDONLY */
86
open(), O_WRONLY, O_NOCTTY,
87
O_RDONLY, O_NOFOLLOW */
87
88
#include <sys/wait.h> /* waitpid(), WNOHANG, WIFEXITED(),
88
89
WEXITSTATUS() */
89
90
#include <limits.h> /* PIPE_BUF, NAME_MAX, INT_MAX */
90
91
#include <sys/inotify.h> /* inotify_init1(), IN_NONBLOCK,
91
92
IN_CLOEXEC, inotify_add_watch(),
92
93
IN_CLOSE_WRITE, IN_MOVED_TO,
93
IN_DELETE, struct inotify_event */
94
IN_MOVED_FROM, IN_DELETE,
95
IN_EXCL_UNLINK, IN_ONLYDIR,
96
struct inotify_event */
94
97
#include <fnmatch.h> /* fnmatch(), FNM_FILE_NAME */
95
98
#include <stdio.h> /* asprintf(), FILE, fopen(),
96
99
getline(), sscanf(), feof(),
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;
1017
1021
return false;
1018
1022
}
1019
1023
1020
if(inotify_add_watch(fd, dir, IN_CLOSE_WRITE
1021
| IN_MOVED_TO | IN_DELETE)
1024
if(inotify_add_watch(fd, dir, IN_CLOSE_WRITE | IN_MOVED_TO
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;
1071
1076
/* "sufficient to read at least one event." - inotify(7) */
1072
1077
const size_t ievent_size = (sizeof(struct inotify_event)
1073
1078
+ 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);
1079
struct {
1080
struct inotify_event event;
1081
char name_buffer[NAME_MAX + 1];
1082
} ievent_buffer;
1083
struct inotify_event *const ievent = &ievent_buffer.event;
1077
1084
1078
1085
const ssize_t read_length = read(fd, ievent, ievent_size);
1079
1086
if(read_length == 0){ /* EOF */
1117
1124
immediately */
1118
1125
queue->next_run = 1;
1119
1126
}
1120
} else if(ievent->mask & IN_DELETE){
1127
} else if(ievent->mask & (IN_MOVED_FROM | IN_DELETE)){
1121
1128
if(not string_set_add(cancelled_filenames,
1122
1129
question_filename)){
1123
1130
error(0, errno, "Could not add question %s to"
2220
2227
2221
2228
{
2222
2229
__attribute__((cleanup(cleanup_close)))
2223
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);
2224
2232
g_assert_cmpint(devnull_fd, >=, 0);
2225
2233
__attribute__((cleanup(cleanup_close)))
2226
2234
const int real_stderr_fd = dup(STDERR_FILENO);
2250
2258
{
2251
2259
__attribute__((cleanup(cleanup_close)))
2252
2260
const int devnull_fd = open("/dev/null",
2253
O_WRONLY | O_CLOEXEC);
2261
O_WRONLY | O_CLOEXEC | O_NOCTTY);
2254
2262
g_assert_cmpint(devnull_fd, >=, 0);
2255
2263
__attribute__((cleanup(cleanup_close)))
2256
2264
const int real_stderr_fd = dup(STDERR_FILENO);
2901
2909
2902
2910
__attribute__((cleanup(cleanup_close)))
2903
2911
const int devnull_fd = open("/dev/null",
2904
O_WRONLY | O_CLOEXEC);
2912
O_WRONLY | O_CLOEXEC | O_NOCTTY);
2905
2913
g_assert_cmpint(devnull_fd, >=, 0);
2906
2914
__attribute__((cleanup(cleanup_close)))
2907
2915
const int real_stderr_fd = dup(STDERR_FILENO);
2972
2980
2973
2981
__attribute__((cleanup(cleanup_close)))
2974
2982
const int devnull_fd = open("/dev/null",
2975
O_WRONLY | O_CLOEXEC);
2983
O_WRONLY | O_CLOEXEC, O_NOCTTY);
2976
2984
g_assert_cmpint(devnull_fd, >=, 0);
2977
2985
__attribute__((cleanup(cleanup_close)))
2978
2986
const int real_stderr_fd = dup(STDERR_FILENO);
3016
3024
buffer password = {};
3017
3025
3018
3026
/* Reading /proc/self/mem from offset 0 will always give EIO */
3019
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);
3020
3029
3021
3030
bool password_is_read = false;
3022
3031
bool quit_now = false;
3450
3459
g_assert_cmpuint((unsigned int)queue->length, ==, 0);
3451
3460
}
3452
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
¤t_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
3453
3500
static void test_add_inotify_dir_watch_EAGAIN(__attribute__((unused))
3454
3501
test_fixture *fixture,
3455
3502
__attribute__((unused))
3670
3717
}
3671
3718
3672
3719
static
3720
void test_add_inotify_dir_watch_IN_MOVED_FROM(__attribute__((unused))
3721
test_fixture *fixture,
3722
__attribute__((unused))
3723
gconstpointer
3724
user_data){
3725
__attribute__((cleanup(cleanup_close)))
3726
const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);
3727
g_assert_cmpint(epoll_fd, >=, 0);
3728
__attribute__((cleanup(cleanup_queue)))
3729
task_queue *queue = create_queue();
3730
g_assert_nonnull(queue);
3731
__attribute__((cleanup(string_set_clear)))
3732
string_set cancelled_filenames = {};
3733
const mono_microsecs current_time = 0;
3734
3735
bool quit_now = false;
3736
buffer password = {};
3737
bool mandos_client_exited = false;
3738
bool password_is_read = false;
3739
3740
__attribute__((cleanup(cleanup_string)))
3741
char *tempdir = make_temporary_directory();
3742
g_assert_nonnull(tempdir);
3743
3744
__attribute__((cleanup(cleanup_string)))
3745
char *tempfilename = make_temporary_file_in_directory(tempdir);
3746
g_assert_nonnull(tempfilename);
3747
3748
__attribute__((cleanup(cleanup_string)))
3749
char *targetdir = make_temporary_directory();
3750
g_assert_nonnull(targetdir);
3751
3752
__attribute__((cleanup(cleanup_string)))
3753
char *targetfilename = NULL;
3754
g_assert_cmpint(asprintf(&targetfilename, "%s/%s", targetdir,
3755
basename(tempfilename)), >, 0);
3756
g_assert_nonnull(targetfilename);
3757
3758
g_assert_true(add_inotify_dir_watch(queue, epoll_fd, &quit_now,
3759
&password, tempdir,
3760
&cancelled_filenames,
3761
¤t_time,
3762
&mandos_client_exited,
3763
&password_is_read));
3764
3765
g_assert_cmpint(rename(tempfilename, targetfilename), ==, 0);
3766
3767
const task_context *const added_read_task
3768
= find_matching_task(queue,
3769
(task_context){ .func=read_inotify_event });
3770
g_assert_nonnull(added_read_task);
3771
3772
/* "sufficient to read at least one event." - inotify(7) */
3773
const size_t ievent_size = (sizeof(struct inotify_event)
3774
+ NAME_MAX + 1);
3775
struct inotify_event *ievent = malloc(ievent_size);
3776
g_assert_nonnull(ievent);
3777
3778
ssize_t read_size = read(added_read_task->fd, ievent, ievent_size);
3779
3780
g_assert_cmpint((int)read_size, >, 0);
3781
g_assert_true(ievent->mask & IN_MOVED_FROM);
3782
g_assert_cmpstr(ievent->name, ==, basename(tempfilename));
3783
3784
free(ievent);
3785
3786
g_assert_cmpint(unlink(targetfilename), ==, 0);
3787
g_assert_cmpint(rmdir(targetdir), ==, 0);
3788
g_assert_cmpint(rmdir(tempdir), ==, 0);
3789
}
3790
3791
static
3673
3792
void test_add_inotify_dir_watch_IN_DELETE(__attribute__((unused))
3674
3793
test_fixture *fixture,
3675
3794
__attribute__((unused))
3733
3852
g_assert_cmpint(rmdir(tempdir), ==, 0);
3734
3853
}
3735
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
¤t_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
3736
3931
static void test_read_inotify_event_readerror(__attribute__((unused))
3737
3932
test_fixture *fixture,
3738
3933
__attribute__((unused))
3744
3939
const mono_microsecs current_time = 0;
3745
3940
3746
3941
/* Reading /proc/self/mem from offset 0 will always result in EIO */
3747
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);
3748
3944
3749
3945
bool quit_now = false;
3750
3946
__attribute__((cleanup(cleanup_queue)))
3929
4125
const size_t ievent_max_size = (sizeof(struct inotify_event)
3930
4126
+ NAME_MAX + 1);
3931
4127
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);
4128
struct {
4129
struct inotify_event event;
4130
char name_buffer[NAME_MAX + 1];
4131
} ievent_buffer;
4132
struct inotify_event *const ievent = &ievent_buffer.event;
3935
4133
3936
4134
const char dummy_file_name[] = "ask.dummy_file_name";
3937
4135
ievent->mask = IN_CLOSE_WRITE;
3939
4137
memcpy(ievent->name, dummy_file_name, sizeof(dummy_file_name));
3940
4138
const size_t ievent_size = (sizeof(struct inotify_event)
3941
4139
+ sizeof(dummy_file_name));
3942
g_assert_cmpint(write(pipefds[1], ievent_buffer, ievent_size),
4140
g_assert_cmpint(write(pipefds[1], (char *)ievent, ievent_size),
3943
4141
==, ievent_size);
3944
4142
g_assert_cmpint(close(pipefds[1]), ==, 0);
3945
4143
4022
4220
const size_t ievent_max_size = (sizeof(struct inotify_event)
4023
4221
+ NAME_MAX + 1);
4024
4222
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);
4223
struct {
4224
struct inotify_event event;
4225
char name_buffer[NAME_MAX + 1];
4226
} ievent_buffer;
4227
struct inotify_event *const ievent = &ievent_buffer.event;
4028
4228
4029
4229
const char dummy_file_name[] = "ask.dummy_file_name";
4030
4230
ievent->mask = IN_MOVED_TO;
4032
4232
memcpy(ievent->name, dummy_file_name, sizeof(dummy_file_name));
4033
4233
const size_t ievent_size = (sizeof(struct inotify_event)
4034
4234
+ sizeof(dummy_file_name));
4035
g_assert_cmpint(write(pipefds[1], ievent_buffer, ievent_size),
4235
g_assert_cmpint(write(pipefds[1], (char *)ievent, ievent_size),
4036
4236
==, ievent_size);
4037
4237
g_assert_cmpint(close(pipefds[1]), ==, 0);
4038
4238
4098
4298
}));
4099
4299
}
4100
4300
4301
static
4302
void test_read_inotify_event_IN_MOVED_FROM(__attribute__((unused))
4303
test_fixture *fixture,
4304
__attribute__((unused))
4305
gconstpointer user_data){
4306
__attribute__((cleanup(cleanup_close)))
4307
const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);
4308
g_assert_cmpint(epoll_fd, >=, 0);
4309
__attribute__((cleanup(string_set_clear)))
4310
string_set cancelled_filenames = {};
4311
const mono_microsecs current_time = 0;
4312
4313
int pipefds[2];
4314
g_assert_cmpint(pipe2(pipefds, O_CLOEXEC | O_NONBLOCK), ==, 0);
4315
4316
/* "sufficient to read at least one event." - inotify(7) */
4317
const size_t ievent_max_size = (sizeof(struct inotify_event)
4318
+ NAME_MAX + 1);
4319
g_assert_cmpint(ievent_max_size, <=, PIPE_BUF);
4320
struct {
4321
struct inotify_event event;
4322
char name_buffer[NAME_MAX + 1];
4323
} ievent_buffer;
4324
struct inotify_event *const ievent = &ievent_buffer.event;
4325
4326
const char dummy_file_name[] = "ask.dummy_file_name";
4327
ievent->mask = IN_MOVED_FROM;
4328
ievent->len = sizeof(dummy_file_name);
4329
memcpy(ievent->name, dummy_file_name, sizeof(dummy_file_name));
4330
const size_t ievent_size = (sizeof(struct inotify_event)
4331
+ sizeof(dummy_file_name));
4332
g_assert_cmpint(write(pipefds[1], (char *)ievent, ievent_size),
4333
==, ievent_size);
4334
g_assert_cmpint(close(pipefds[1]), ==, 0);
4335
4336
bool quit_now = false;
4337
buffer password = {};
4338
bool mandos_client_exited = false;
4339
bool password_is_read = false;
4340
__attribute__((cleanup(cleanup_queue)))
4341
task_queue *queue = create_queue();
4342
g_assert_nonnull(queue);
4343
4344
task_context task = {
4345
.func=read_inotify_event,
4346
.epoll_fd=epoll_fd,
4347
.fd=pipefds[0],
4348
.quit_now=&quit_now,
4349
.password=&password,
4350
.filename=strdup("/nonexistent"),
4351
.cancelled_filenames=&cancelled_filenames,
4352
.current_time=¤t_time,
4353
.mandos_client_exited=&mandos_client_exited,
4354
.password_is_read=&password_is_read,
4355
};
4356
task.func(task, queue);
4357
g_assert_false(quit_now);
4358
g_assert_true(queue->next_run == 0);
4359
g_assert_cmpuint((unsigned int)queue->length, ==, 1);
4360
4361
g_assert_nonnull(find_matching_task(queue, (task_context){
4362
.func=read_inotify_event,
4363
.epoll_fd=epoll_fd,
4364
.fd=pipefds[0],
4365
.quit_now=&quit_now,
4366
.password=&password,
4367
.filename=task.filename,
4368
.cancelled_filenames=&cancelled_filenames,
4369
.current_time=¤t_time,
4370
.mandos_client_exited=&mandos_client_exited,
4371
.password_is_read=&password_is_read,
4372
}));
4373
4374
g_assert_true(epoll_set_contains(epoll_fd, pipefds[0],
4375
EPOLLIN | EPOLLRDHUP));
4376
4377
__attribute__((cleanup(cleanup_string)))
4378
char *filename = NULL;
4379
g_assert_cmpint(asprintf(&filename, "%s/%s", task.filename,
4380
dummy_file_name), >, 0);
4381
g_assert_nonnull(filename);
4382
g_assert_true(string_set_contains(*task.cancelled_filenames,
4383
filename));
4384
}
4385
4101
4386
static void test_read_inotify_event_IN_DELETE(__attribute__((unused))
4102
4387
test_fixture *fixture,
4103
4388
__attribute__((unused))
4117
4402
const size_t ievent_max_size = (sizeof(struct inotify_event)
4118
4403
+ NAME_MAX + 1);
4119
4404
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);
4405
struct {
4406
struct inotify_event event;
4407
char name_buffer[NAME_MAX + 1];
4408
} ievent_buffer;
4409
struct inotify_event *const ievent = &ievent_buffer.event;
4123
4410
4124
4411
const char dummy_file_name[] = "ask.dummy_file_name";
4125
4412
ievent->mask = IN_DELETE;
4127
4414
memcpy(ievent->name, dummy_file_name, sizeof(dummy_file_name));
4128
4415
const size_t ievent_size = (sizeof(struct inotify_event)
4129
4416
+ sizeof(dummy_file_name));
4130
g_assert_cmpint(write(pipefds[1], ievent_buffer, ievent_size),
4417
g_assert_cmpint(write(pipefds[1], (char *)ievent, ievent_size),
4131
4418
==, ievent_size);
4132
4419
g_assert_cmpint(close(pipefds[1]), ==, 0);
4133
4420
4199
4486
const size_t ievent_max_size = (sizeof(struct inotify_event)
4200
4487
+ NAME_MAX + 1);
4201
4488
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);
4489
struct {
4490
struct inotify_event event;
4491
char name_buffer[NAME_MAX + 1];
4492
} ievent_buffer;
4493
struct inotify_event *const ievent = &ievent_buffer.event;
4205
4494
4206
4495
const char dummy_file_name[] = "ignored.dummy_file_name";
4207
4496
ievent->mask = IN_CLOSE_WRITE;
4209
4498
memcpy(ievent->name, dummy_file_name, sizeof(dummy_file_name));
4210
4499
const size_t ievent_size = (sizeof(struct inotify_event)
4211
4500
+ sizeof(dummy_file_name));
4212
g_assert_cmpint(write(pipefds[1], ievent_buffer, ievent_size),
4501
g_assert_cmpint(write(pipefds[1], (char *)ievent, ievent_size),
4213
4502
==, ievent_size);
4214
4503
g_assert_cmpint(close(pipefds[1]), ==, 0);
4215
4504
4273
4562
const size_t ievent_max_size = (sizeof(struct inotify_event)
4274
4563
+ NAME_MAX + 1);
4275
4564
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);
4565
struct {
4566
struct inotify_event event;
4567
char name_buffer[NAME_MAX + 1];
4568
} ievent_buffer;
4569
struct inotify_event *const ievent = &ievent_buffer.event;
4279
4570
4280
4571
const char dummy_file_name[] = "ignored.dummy_file_name";
4281
4572
ievent->mask = IN_MOVED_TO;
4283
4574
memcpy(ievent->name, dummy_file_name, sizeof(dummy_file_name));
4284
4575
const size_t ievent_size = (sizeof(struct inotify_event)
4285
4576
+ sizeof(dummy_file_name));
4286
g_assert_cmpint(write(pipefds[1], ievent_buffer, ievent_size),
4577
g_assert_cmpint(write(pipefds[1], (char *)ievent, ievent_size),
4287
4578
==, ievent_size);
4288
4579
g_assert_cmpint(close(pipefds[1]), ==, 0);
4289
4580
4330
4621
EPOLLIN | EPOLLRDHUP));
4331
4622
}
4332
4623
4624
static void
4625
test_read_inotify_event_IN_MOVED_FROM_badname(__attribute__((unused))
4626
test_fixture *fixture,
4627
__attribute__((unused))
4628
gconstpointer
4629
user_data){
4630
__attribute__((cleanup(cleanup_close)))
4631
const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);
4632
g_assert_cmpint(epoll_fd, >=, 0);
4633
__attribute__((cleanup(string_set_clear)))
4634
string_set cancelled_filenames = {};
4635
const mono_microsecs current_time = 0;
4636
4637
int pipefds[2];
4638
g_assert_cmpint(pipe2(pipefds, O_CLOEXEC | O_NONBLOCK), ==, 0);
4639
4640
/* "sufficient to read at least one event." - inotify(7) */
4641
const size_t ievent_max_size = (sizeof(struct inotify_event)
4642
+ NAME_MAX + 1);
4643
g_assert_cmpint(ievent_max_size, <=, PIPE_BUF);
4644
struct {
4645
struct inotify_event event;
4646
char name_buffer[NAME_MAX + 1];
4647
} ievent_buffer;
4648
struct inotify_event *const ievent = &ievent_buffer.event;
4649
4650
const char dummy_file_name[] = "ignored.dummy_file_name";
4651
ievent->mask = IN_MOVED_FROM;
4652
ievent->len = sizeof(dummy_file_name);
4653
memcpy(ievent->name, dummy_file_name, sizeof(dummy_file_name));
4654
const size_t ievent_size = (sizeof(struct inotify_event)
4655
+ sizeof(dummy_file_name));
4656
g_assert_cmpint(write(pipefds[1], (char *)ievent, ievent_size),
4657
==, ievent_size);
4658
g_assert_cmpint(close(pipefds[1]), ==, 0);
4659
4660
bool quit_now = false;
4661
buffer password = {};
4662
bool mandos_client_exited = false;
4663
bool password_is_read = false;
4664
__attribute__((cleanup(cleanup_queue)))
4665
task_queue *queue = create_queue();
4666
g_assert_nonnull(queue);
4667
4668
task_context task = {
4669
.func=read_inotify_event,
4670
.epoll_fd=epoll_fd,
4671
.fd=pipefds[0],
4672
.quit_now=&quit_now,
4673
.password=&password,
4674
.filename=strdup("/nonexistent"),
4675
.cancelled_filenames=&cancelled_filenames,
4676
.current_time=¤t_time,
4677
.mandos_client_exited=&mandos_client_exited,
4678
.password_is_read=&password_is_read,
4679
};
4680
task.func(task, queue);
4681
g_assert_false(quit_now);
4682
g_assert_true(queue->next_run == 0);
4683
g_assert_cmpuint((unsigned int)queue->length, ==, 1);
4684
4685
g_assert_nonnull(find_matching_task(queue, (task_context){
4686
.func=read_inotify_event,
4687
.epoll_fd=epoll_fd,
4688
.fd=pipefds[0],
4689
.quit_now=&quit_now,
4690
.password=&password,
4691
.filename=task.filename,
4692
.cancelled_filenames=&cancelled_filenames,
4693
.current_time=¤t_time,
4694
.mandos_client_exited=&mandos_client_exited,
4695
.password_is_read=&password_is_read,
4696
}));
4697
4698
g_assert_true(epoll_set_contains(epoll_fd, pipefds[0],
4699
EPOLLIN | EPOLLRDHUP));
4700
4701
__attribute__((cleanup(cleanup_string)))
4702
char *filename = NULL;
4703
g_assert_cmpint(asprintf(&filename, "%s/%s", task.filename,
4704
dummy_file_name), >, 0);
4705
g_assert_nonnull(filename);
4706
g_assert_false(string_set_contains(cancelled_filenames, filename));
4707
}
4708
4333
4709
static
4334
4710
void test_read_inotify_event_IN_DELETE_badname(__attribute__((unused))
4335
4711
test_fixture *fixture,
4350
4726
const size_t ievent_max_size = (sizeof(struct inotify_event)
4351
4727
+ NAME_MAX + 1);
4352
4728
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);
4729
struct {
4730
struct inotify_event event;
4731
char name_buffer[NAME_MAX + 1];
4732
} ievent_buffer;
4733
struct inotify_event *const ievent = &ievent_buffer.event;
4356
4734
4357
4735
const char dummy_file_name[] = "ignored.dummy_file_name";
4358
4736
ievent->mask = IN_DELETE;
4360
4738
memcpy(ievent->name, dummy_file_name, sizeof(dummy_file_name));
4361
4739
const size_t ievent_size = (sizeof(struct inotify_event)
4362
4740
+ sizeof(dummy_file_name));
4363
g_assert_cmpint(write(pipefds[1], ievent_buffer, ievent_size),
4741
g_assert_cmpint(write(pipefds[1], (char *)ievent, ievent_size),
4364
4742
==, ievent_size);
4365
4743
g_assert_cmpint(close(pipefds[1]), ==, 0);
4366
4744
5253
5631
__attribute__((unused))
5254
5632
gconstpointer user_data){
5255
5633
__attribute__((cleanup(cleanup_close)))
5256
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);
5257
5636
__attribute__((cleanup(cleanup_string)))
5258
5637
char *const question_filename = strdup("/nonexistent/question");
5259
5638
g_assert_nonnull(question_filename);
5663
6042
__attribute__((unused))
5664
6043
gconstpointer user_data){
5665
6044
__attribute__((cleanup(cleanup_close)))
5666
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);
5667
6047
__attribute__((cleanup(cleanup_string)))
5668
6048
char *const question_filename = strdup("/nonexistent/question");
5669
6049
g_assert_nonnull(question_filename);
5932
6312
const char *const
5933
6313
dirname){
5934
6314
__attribute__((cleanup(cleanup_close)))
5935
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);
5936
6317
g_assert_cmpint(devnull_fd, >=, 0);
5937
6318
__attribute__((cleanup(cleanup_close)))
5938
6319
const int real_stderr_fd = dup(STDERR_FILENO);
7573
7954
test_add_inotify_dir_watch);
7574
7955
test_add_st("/task-creators/add_inotify_dir_watch/fail",
7575
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);
7576
7959
test_add_st("/task-creators/add_inotify_dir_watch/EAGAIN",
7577
7960
test_add_inotify_dir_watch_EAGAIN);
7578
7961
test_add_st("/task-creators/add_inotify_dir_watch/IN_CLOSE_WRITE",
7579
7962
test_add_inotify_dir_watch_IN_CLOSE_WRITE);
7580
7963
test_add_st("/task-creators/add_inotify_dir_watch/IN_MOVED_TO",
7581
7964
test_add_inotify_dir_watch_IN_MOVED_TO);
7965
test_add_st("/task-creators/add_inotify_dir_watch/IN_MOVED_FROM",
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);
7582
7969
test_add_st("/task-creators/add_inotify_dir_watch/IN_DELETE",
7583
7970
test_add_inotify_dir_watch_IN_DELETE);
7584
7971
test_add_st("/task/read_inotify_event/readerror",
7593
7980
test_read_inotify_event_IN_CLOSE_WRITE);
7594
7981
test_add_st("/task/read_inotify_event/IN_MOVED_TO",
7595
7982
test_read_inotify_event_IN_MOVED_TO);
7983
test_add_st("/task/read_inotify_event/IN_MOVED_FROM",
7984
test_read_inotify_event_IN_MOVED_FROM);
7596
7985
test_add_st("/task/read_inotify_event/IN_DELETE",
7597
7986
test_read_inotify_event_IN_DELETE);
7598
7987
test_add_st("/task/read_inotify_event/IN_CLOSE_WRITE/badname",
7599
7988
test_read_inotify_event_IN_CLOSE_WRITE_badname);
7600
7989
test_add_st("/task/read_inotify_event/IN_MOVED_TO/badname",
7601
7990
test_read_inotify_event_IN_MOVED_TO_badname);
7991
test_add_st("/task/read_inotify_event/IN_MOVED_FROM/badname",
7992
test_read_inotify_event_IN_MOVED_FROM_badname);
7602
7993
test_add_st("/task/read_inotify_event/IN_DELETE/badname",
7603
7994
test_read_inotify_event_IN_DELETE_badname);
7604
7995
test_add_st("/task/open_and_parse_question/ENOENT",
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0