dc61dd27cbc1fbd46a06e73ad25d4c1bb6fb9848
[ccan] / ccan / ptr_valid / ptr_valid.c
1 // Licensed under BSD-MIT: See LICENSE.
2 #include "ptr_valid.h"
3 #include <sys/types.h>
4 #include <sys/wait.h>
5 #include <sys/stat.h>
6 #include <fcntl.h>
7 #include <ccan/noerr/noerr.h>
8 #include <unistd.h>
9 #include <errno.h>
10 #include <assert.h>
11 #include <string.h>
12
13 #if HAVE_PROC_SELF_MAPS
14 static char *grab(const char *filename)
15 {
16         int ret, fd;
17         size_t max = 16384, s = 0;
18         char *buffer;
19
20         fd = open(filename, O_RDONLY);
21         if (fd < 0)
22                 return NULL;
23
24         buffer = malloc(max+1);
25         if (!buffer)
26                 goto close;
27
28         while ((ret = read(fd, buffer + s, max - s)) > 0) {
29                 s += ret;
30                 if (s == max) {
31                         buffer = realloc(buffer, max*2+1);
32                         if (!buffer)
33                                 goto close;
34                         max *= 2;
35                 }
36         }
37         if (ret < 0)
38                 goto free;
39
40         close(fd);
41         buffer[s] = '\0';
42         return buffer;
43
44 free:
45         free(buffer);
46 close:
47         close_noerr(fd);
48         return NULL;
49 }
50
51 static char *skip_line(char *p)
52 {
53         char *nl = strchr(p, '\n');
54         if (!nl)
55                 return NULL;
56         return nl + 1;
57 }
58
59 static struct ptr_valid_map *add_map(struct ptr_valid_map *map,
60                                      unsigned int *num,
61                                      unsigned int *max,
62                                      unsigned long start, unsigned long end, bool is_write)
63 {
64         if (*num == *max) {
65                 *max *= 2;
66                 map = realloc(map, sizeof(*map) * *max);
67                 if (!map)
68                         return NULL;
69         }
70         map[*num].start = (void *)start;
71         map[*num].end = (void *)end;
72         map[*num].is_write = is_write;
73         (*num)++;
74         return map;
75 }
76
77 static struct ptr_valid_map *get_proc_maps(unsigned int *num)
78 {
79         char *buf, *p;
80         struct ptr_valid_map *map;
81         unsigned int max = 16;
82
83         buf = grab("/proc/self/maps");
84         if (!buf) {
85                 *num = 0;
86                 return NULL;
87         }
88
89         map = malloc(sizeof(*map) * max);
90         if (!map)
91                 goto free_buf;
92
93         *num = 0;
94         for (p = buf; p && *p; p = skip_line(p)) {
95                 unsigned long start, end;
96                 char *endp;
97
98                 /* Expect '<start-in-hex>-<end-in-hex> rw... */
99                 start = strtoul(p, &endp, 16);
100                 if (*endp != '-')
101                         goto malformed;
102                 end = strtoul(endp+1, &endp, 16);
103                 if (*endp != ' ')
104                         goto malformed;
105
106                 endp++;
107                 if (endp[0] != 'r' && endp[0] != '-')
108                         goto malformed;
109                 if (endp[1] != 'w' && endp[1] != '-')
110                         goto malformed;
111
112                 /* We only add readable mappings. */
113                 if (endp[0] == 'r') {
114                         map = add_map(map, num, &max, start, end,
115                                       endp[1] == 'w');
116                         if (!map)
117                                 goto free_buf;
118                 }
119         }
120
121         free(buf);
122         return map;
123
124
125 malformed:
126         free(map);
127 free_buf:
128         free(buf);
129         *num = 0;
130         return NULL;
131 }
132 #else
133 static struct ptr_valid_map *get_proc_maps(unsigned int *num)
134 {
135         *num = 0;
136         return NULL;
137 }
138 #endif
139
140 static bool check_with_maps(struct ptr_valid_batch *batch,
141                             const char *p, size_t size, bool is_write)
142 {
143         unsigned int i;
144
145         for (i = 0; i < batch->num_maps; i++) {
146                 if (p >= batch->maps[i].start && p < batch->maps[i].end) {
147                         /* Overlap into other maps?  Recurse with remainder. */
148                         if (p + size > batch->maps[i].end) {
149                                 size_t len = p + size - batch->maps[i].end;
150                                 if (!check_with_maps(batch, batch->maps[i].end,
151                                                      len, is_write))
152                                         return false;
153                         }
154                         return !is_write || batch->maps[i].is_write;
155                 }
156         }
157         return false;
158 }
159
160 static void finish_child(struct ptr_valid_batch *batch)
161 {
162         close(batch->to_child);
163         close(batch->from_child);
164         waitpid(batch->child_pid, NULL, 0);
165         batch->child_pid = 0;
166 }
167
168 static bool child_alive(struct ptr_valid_batch *batch)
169 {
170         return batch->child_pid != 0;
171 }
172
173 static void run_child(int infd, int outfd)
174 {
175         volatile char *p;
176
177         /* This is how we expect to exit. */
178         while (read(infd, &p, sizeof(p)) == sizeof(p)) {
179                 size_t i, size;
180                 bool is_write;
181                 char ret = 0;
182
183                 /* This is weird. */
184                 if (read(infd, &size, sizeof(size)) != sizeof(size))
185                         exit(1);
186                 if (read(infd, &is_write, sizeof(is_write)) != sizeof(is_write))
187                         exit(2);
188
189                 for (i = 0; i < size; i++) {
190                         ret = p[i];
191                         if (is_write)
192                                 p[i] = ret;
193                 }
194
195                 /* If we're still here, the answer is "yes". */
196                 if (write(outfd, &ret, 1) != 1)
197                         exit(3);
198         }
199         exit(0);
200 }
201
202 static bool create_child(struct ptr_valid_batch *batch)
203 {
204         int outpipe[2], inpipe[2];
205
206         if (pipe(outpipe) != 0)
207                 return false;
208         if (pipe(inpipe) != 0)
209                 goto close_outpipe;
210
211         fflush(stdout);
212         batch->child_pid = fork();
213         if (batch->child_pid == 0) {
214                 close(outpipe[1]);
215                 close(inpipe[0]);
216                 run_child(outpipe[0], inpipe[1]);
217         }
218
219         if (batch->child_pid == -1)
220                 goto cleanup_pid;
221
222         close(outpipe[0]);
223         close(inpipe[1]);
224
225         batch->to_child = outpipe[1];
226         batch->from_child = inpipe[0];
227         return true;
228
229 cleanup_pid:
230         batch->child_pid = 0;
231         close_noerr(inpipe[0]);
232         close_noerr(inpipe[1]);
233 close_outpipe:
234         close_noerr(outpipe[0]);
235         close_noerr(outpipe[1]);
236         return false;
237 }
238
239 static bool check_with_child(struct ptr_valid_batch *batch,
240                              const void *p, size_t size, bool is_write)
241 {
242         char ret;
243
244         if (!child_alive(batch)) {
245                 if (!create_child(batch))
246                         return false;
247         }
248
249         if (write(batch->to_child, &p, sizeof(p))
250             + write(batch->to_child, &size, sizeof(size))
251             + write(batch->to_child, &is_write, sizeof(is_write))
252             != sizeof(p) + sizeof(size) + sizeof(is_write)) {
253                 finish_child(batch);
254                 errno = EFAULT;
255                 return false;
256         }
257
258         if (read(batch->from_child, &ret, sizeof(ret)) != sizeof(ret)) {
259                 finish_child(batch);
260                 errno = EFAULT;
261                 return false;
262         }
263         return true;
264 }
265
266 /* msync seems most well-defined test, but page could be mapped with
267  * no permissions, and can't distiguish readonly from writable. */
268 bool ptr_valid_batch(struct ptr_valid_batch *batch,
269                      const void *p, size_t alignment, size_t size, bool write)
270 {
271         char *start, *end;
272         bool ret;
273
274         if ((intptr_t)p & (alignment - 1))
275                 return false;
276
277         start = (void *)((intptr_t)p & ~(getpagesize() - 1));
278         end = (void *)(((intptr_t)p + size - 1) & ~(getpagesize() - 1));
279
280         /* We cache single page hits. */
281         if (start == end) {
282                 if (batch->last && batch->last == start)
283                         return batch->last_ok;
284         }
285
286         if (batch->num_maps)
287                 ret = check_with_maps(batch, p, size, write);
288         else
289                 ret = check_with_child(batch, p, size, write);
290
291         if (start == end) {
292                 batch->last = start;
293                 batch->last_ok = ret;
294         }
295
296         return ret;
297 }
298
299 bool ptr_valid_batch_string(struct ptr_valid_batch *batch, const char *p)
300 {
301         while (ptr_valid_batch(batch, p, 1, 1, false)) {
302                 if (*p == '\0')
303                         return true;
304                 p++;
305         }
306         return false;
307 }
308
309 bool ptr_valid(const void *p, size_t alignment, size_t size, bool write)
310 {
311         bool ret;
312         struct ptr_valid_batch batch;
313         if (!ptr_valid_batch_start(&batch))
314                 return false;
315         ret = ptr_valid_batch(&batch, p, alignment, size, write);
316         ptr_valid_batch_end(&batch);
317         return ret;
318 }
319
320 bool ptr_valid_string(const char *p)
321 {
322         bool ret;
323         struct ptr_valid_batch batch;
324         if (!ptr_valid_batch_start(&batch))
325                 return false;
326         ret = ptr_valid_batch_string(&batch, p);
327         ptr_valid_batch_end(&batch);
328         return ret;
329 }
330
331 bool ptr_valid_batch_start(struct ptr_valid_batch *batch)
332 {
333         batch->child_pid = 0;
334         batch->maps = get_proc_maps(&batch->num_maps);
335         batch->last = NULL;
336         return true;
337 }
338
339 void ptr_valid_batch_end(struct ptr_valid_batch *batch)
340 {
341         if (child_alive(batch))
342                 finish_child(batch);
343         free(batch->maps);
344 }