1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
|
#include <errno.h>
#include <fcntl.h>
#include <poll.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/inotify.h>
#include <unistd.h>
#include "Clean.h"
/**
* Cast a CleanString to a char*
* The result should be freed.
*/
char* clstocs(CleanString* cs) {
char* s = calloc(CleanStringLength(cs) + 1, 1);
uint8_t i;
for (i = 0; i < CleanStringLength(cs); i++)
s[i] = CleanStringCharacters(cs)[i];
s[i] = 0;
return s;
}
/** The empty string, as a CleanString */
static struct {int length; char chars[1]; } empty_string = {0,""};
/**
* Get the errno. The parameter is ignored, it is just there because ccalls
* need to have an argument.
*/
int clean_errno(int ignored) {
return errno;
}
/**
* Initialise an inotify file descriptor and change to NONBLOCK mode.
*/
int clean_inotify_init(int ignored) {
int fd;
fd = inotify_init();
if (fd < 0)
return 0;
fcntl(fd, IN_NONBLOCK);
return fd;
}
/**
* Add a watch on some file.
*
* fd The inotify file descriptor
* fname The file to watch
* mask A mask of events to watch on
* re_watch Will be set to the resulting watch descriptor
* re_fd Will be set to fd (needed for uniqueness)
*/
void clean_inotify_add_watch(int fd, CleanString* fname_, int mask,
int *re_watch, int *re_fd) {
char* fname = clstocs(fname_);
*re_watch = inotify_add_watch(fd, fname, mask);
free(fname);
*re_fd = fd;
}
/**
* Remove a watch descriptor.
*
* fd The inotify file descriptor
* watch The watch descriptor to remove
* re_code Will be set to the return code of inotify_rm_watch
* re_fd Will be set to fd (needed for uniqueness)
*/
void clean_inotify_rm_watch(int fd, int watch, int *re_code, int *re_fd) {
*re_fd = fd;
*re_code = inotify_rm_watch(fd, watch);
}
/**
* Poll an inotify file descriptor
*
* fd The inotify file descriptor to poll
* timeout The timeout (negative for no timeout)
* re_nrevents Will be set to the number of polled events
* re_fd Will be set to fd (needed for uniqueness)
*/
void clean_poll(int fd, int timeout, int *re_nrevents, int *re_fd) {
struct pollfd pfd = {fd, POLLIN, 0};
*re_nrevents = poll(&pfd, 1, timeout);
*re_fd = fd;
}
/**
* CleanStrings that are returned from clean_inotify_check (so that we don't
* have to malloc all the time.)
*/
static CleanStringVariable(wds_string, 1024);
static CleanStringVariable(masks_string, 1024);
static CleanStringVariable(names_string, 4096);
/**
* Check for events on an inotify file descriptor.
*
* fd The inotify file descriptor
* re_ok Will be set to 1 on success, 0 on failure
* re_wds An array of ints, the watch descriptors that had events
* re_masks An array of ints, the events
* re_fnames A list of strings, the filenames of the events (may be empty)
* re_fd Will be set to fd (needed for uniqueness)
*
* re_wds, re_masks and re_fnames are hacks because ccall doesn't allow
* returning {#Int} or {#String}. The int arrays can be read by taking 4 chars
* at a time and casting that to an int. The string array can be read by
* splitting on \0 (since they are filenames, \0 cannot occur).
*/
void clean_inotify_check(int fd,
int *re_ok, CleanString* re_wds, CleanString* re_masks,
CleanString* re_fnames, int *re_fd) {
char buf[4096] __attribute__((aligned(__alignof__(struct inotify_event))));
const struct inotify_event *ev;
ssize_t len;
char *ptr;
struct pollfd pfd = {fd, POLLIN, 0};
int poll_n;
char *wds_ptr = CleanStringCharacters(wds_string);
char *masks_ptr = CleanStringCharacters(masks_string);
char *names_ptr = CleanStringCharacters(names_string);
CleanStringLength(wds_string) = 0;
CleanStringLength(masks_string) = 0;
CleanStringLength(names_string) = 0;
*re_ok = 0;
*re_fd = fd;
*re_wds = (CleanString) &empty_string;
*re_masks = (CleanString) &empty_string;
*re_fnames = (CleanString) &empty_string;
for (;;) {
poll_n = poll(&pfd, 1, 0);
if (poll_n < 0) {
return;
} else if (poll_n == 0) {
break;
}
len = read(fd, buf, sizeof buf);
if (len == -1 && errno != EAGAIN) {
return;
}
if (len <= 0) {
break;
}
for (ptr = buf; ptr < buf + len;
ptr += sizeof(struct inotify_event) + ev->len) {
ev = (const struct inotify_event*) ptr;
memcpy(masks_ptr, &ev->mask, 4);
masks_ptr += 4;
CleanStringLength(masks_string) += 4;
memcpy(wds_ptr, &ev->wd, sizeof(int));
wds_ptr += sizeof(int);
CleanStringLength(wds_string) += sizeof(int);
int len = strlen(ev->name);
memcpy(names_ptr, &ev->name, len);
names_ptr += len + 1;
*(names_ptr - 1) = '\00';
CleanStringLength(names_string) += len + 1;
}
}
*re_wds = (CleanString) wds_string;
*re_masks = (CleanString) masks_string;
*re_fnames = (CleanString) names_string;
*re_ok = 1;
}
|
