1 /*-
2 * Copyright (c) 2007 Joerg Sonnenberger
3 * Copyright (c) 2012 Michihiro NAKAJIMA
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 * 1. Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * 2. Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 *
15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
16 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
17 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
18 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
19 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
20 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
21 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
22 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
23 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
24 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
25 */
26
27 #include "archive_platform.h"
28 __FBSDID("$FreeBSD$");
29
30 #ifdef HAVE_SYS_WAIT_H
31 # include <sys/wait.h>
32 #endif
33 #ifdef HAVE_ERRNO_H
34 # include <errno.h>
35 #endif
36 #ifdef HAVE_FCNTL_H
37 # include <fcntl.h>
38 #endif
39 #ifdef HAVE_LIMITS_H
40 # include <limits.h>
41 #endif
42 #ifdef HAVE_SIGNAL_H
43 # include <signal.h>
44 #endif
45 #ifdef HAVE_STDLIB_H
46 # include <stdlib.h>
47 #endif
48 #ifdef HAVE_STRING_H
49 # include <string.h>
50 #endif
51 #ifdef HAVE_UNISTD_H
52 # include <unistd.h>
53 #endif
54
55 #include "archive.h"
56 #include "archive_private.h"
57 #include "archive_string.h"
58 #include "archive_read_private.h"
59 #include "filter_fork.h"
60
61
62 #if ARCHIVE_VERSION_NUMBER < 4000000
63 /* Deprecated; remove in libarchive 4.0 */
64 int
archive_read_support_compression_program(struct archive * a,const char * cmd)65 archive_read_support_compression_program(struct archive *a, const char *cmd)
66 {
67 return archive_read_support_filter_program(a, cmd);
68 }
69
70 int
archive_read_support_compression_program_signature(struct archive * a,const char * cmd,const void * signature,size_t signature_len)71 archive_read_support_compression_program_signature(struct archive *a,
72 const char *cmd, const void *signature, size_t signature_len)
73 {
74 return archive_read_support_filter_program_signature(a,
75 cmd, signature, signature_len);
76 }
77 #endif
78
79 int
archive_read_support_filter_program(struct archive * a,const char * cmd)80 archive_read_support_filter_program(struct archive *a, const char *cmd)
81 {
82 return (archive_read_support_filter_program_signature(a, cmd, NULL, 0));
83 }
84
85 /*
86 * The bidder object stores the command and the signature to watch for.
87 * The 'inhibit' entry here is used to ensure that unchecked filters never
88 * bid twice in the same pipeline.
89 */
90 struct program_bidder {
91 char *description;
92 char *cmd;
93 void *signature;
94 size_t signature_len;
95 int inhibit;
96 };
97
98 static int program_bidder_bid(struct archive_read_filter_bidder *,
99 struct archive_read_filter *upstream);
100 static int program_bidder_init(struct archive_read_filter *);
101 static void program_bidder_free(struct archive_read_filter_bidder *);
102
103 /*
104 * The actual filter needs to track input and output data.
105 */
106 struct program_filter {
107 struct archive_string description;
108 #if defined(_WIN32) && !defined(__CYGWIN__)
109 HANDLE child;
110 #else
111 pid_t child;
112 #endif
113 int exit_status;
114 int waitpid_return;
115 int child_stdin, child_stdout;
116
117 char *out_buf;
118 size_t out_buf_len;
119 };
120
121 static ssize_t program_filter_read(struct archive_read_filter *,
122 const void **);
123 static int program_filter_close(struct archive_read_filter *);
124 static void free_state(struct program_bidder *);
125
126 static const struct archive_read_filter_bidder_vtable
127 program_bidder_vtable = {
128 .bid = program_bidder_bid,
129 .init = program_bidder_init,
130 .free = program_bidder_free,
131 };
132
133 int
archive_read_support_filter_program_signature(struct archive * _a,const char * cmd,const void * signature,size_t signature_len)134 archive_read_support_filter_program_signature(struct archive *_a,
135 const char *cmd, const void *signature, size_t signature_len)
136 {
137 struct archive_read *a = (struct archive_read *)_a;
138 struct program_bidder *state;
139
140 /*
141 * Allocate our private state.
142 */
143 state = (struct program_bidder *)calloc(1, sizeof (*state));
144 if (state == NULL)
145 goto memerr;
146 state->cmd = strdup(cmd);
147 if (state->cmd == NULL)
148 goto memerr;
149
150 if (signature != NULL && signature_len > 0) {
151 state->signature_len = signature_len;
152 state->signature = malloc(signature_len);
153 memcpy(state->signature, signature, signature_len);
154 }
155
156 if (__archive_read_register_bidder(a, state, NULL,
157 &program_bidder_vtable) != ARCHIVE_OK) {
158 free_state(state);
159 return (ARCHIVE_FATAL);
160 }
161 return (ARCHIVE_OK);
162
163 memerr:
164 free_state(state);
165 archive_set_error(_a, ENOMEM, "Can't allocate memory");
166 return (ARCHIVE_FATAL);
167 }
168
169 static void
program_bidder_free(struct archive_read_filter_bidder * self)170 program_bidder_free(struct archive_read_filter_bidder *self)
171 {
172 struct program_bidder *state = (struct program_bidder *)self->data;
173
174 free_state(state);
175 }
176
177 static void
free_state(struct program_bidder * state)178 free_state(struct program_bidder *state)
179 {
180
181 if (state) {
182 free(state->cmd);
183 free(state->signature);
184 free(state);
185 }
186 }
187
188 /*
189 * If we do have a signature, bid only if that matches.
190 *
191 * If there's no signature, we bid INT_MAX the first time
192 * we're called, then never bid again.
193 */
194 static int
program_bidder_bid(struct archive_read_filter_bidder * self,struct archive_read_filter * upstream)195 program_bidder_bid(struct archive_read_filter_bidder *self,
196 struct archive_read_filter *upstream)
197 {
198 struct program_bidder *state = self->data;
199 const char *p;
200
201 /* If we have a signature, use that to match. */
202 if (state->signature_len > 0) {
203 p = __archive_read_filter_ahead(upstream,
204 state->signature_len, NULL);
205 if (p == NULL)
206 return (0);
207 /* No match, so don't bid. */
208 if (memcmp(p, state->signature, state->signature_len) != 0)
209 return (0);
210 return ((int)state->signature_len * 8);
211 }
212
213 /* Otherwise, bid once and then never bid again. */
214 if (state->inhibit)
215 return (0);
216 state->inhibit = 1;
217 return (INT_MAX);
218 }
219
220 /*
221 * Shut down the child, return ARCHIVE_OK if it exited normally.
222 *
223 * Note that the return value is sticky; if we're called again,
224 * we won't reap the child again, but we will return the same status
225 * (including error message if the child came to a bad end).
226 */
227 static int
child_stop(struct archive_read_filter * self,struct program_filter * state)228 child_stop(struct archive_read_filter *self, struct program_filter *state)
229 {
230 /* Close our side of the I/O with the child. */
231 if (state->child_stdin != -1) {
232 close(state->child_stdin);
233 state->child_stdin = -1;
234 }
235 if (state->child_stdout != -1) {
236 close(state->child_stdout);
237 state->child_stdout = -1;
238 }
239
240 if (state->child != 0) {
241 /* Reap the child. */
242 do {
243 state->waitpid_return
244 = waitpid(state->child, &state->exit_status, 0);
245 } while (state->waitpid_return == -1 && errno == EINTR);
246 #if defined(_WIN32) && !defined(__CYGWIN__)
247 CloseHandle(state->child);
248 #endif
249 state->child = 0;
250 }
251
252 if (state->waitpid_return < 0) {
253 /* waitpid() failed? This is ugly. */
254 archive_set_error(&self->archive->archive, ARCHIVE_ERRNO_MISC,
255 "Child process exited badly");
256 return (ARCHIVE_WARN);
257 }
258
259 #if !defined(_WIN32) || defined(__CYGWIN__)
260 if (WIFSIGNALED(state->exit_status)) {
261 #ifdef SIGPIPE
262 /* If the child died because we stopped reading before
263 * it was done, that's okay. Some archive formats
264 * have padding at the end that we routinely ignore. */
265 /* The alternative to this would be to add a step
266 * before close(child_stdout) above to read from the
267 * child until the child has no more to write. */
268 if (WTERMSIG(state->exit_status) == SIGPIPE)
269 return (ARCHIVE_OK);
270 #endif
271 archive_set_error(&self->archive->archive, ARCHIVE_ERRNO_MISC,
272 "Child process exited with signal %d",
273 WTERMSIG(state->exit_status));
274 return (ARCHIVE_WARN);
275 }
276 #endif /* !_WIN32 || __CYGWIN__ */
277
278 if (WIFEXITED(state->exit_status)) {
279 if (WEXITSTATUS(state->exit_status) == 0)
280 return (ARCHIVE_OK);
281
282 archive_set_error(&self->archive->archive,
283 ARCHIVE_ERRNO_MISC,
284 "Child process exited with status %d",
285 WEXITSTATUS(state->exit_status));
286 return (ARCHIVE_WARN);
287 }
288
289 return (ARCHIVE_WARN);
290 }
291
292 /*
293 * Use select() to decide whether the child is ready for read or write.
294 */
295 static ssize_t
child_read(struct archive_read_filter * self,char * buf,size_t buf_len)296 child_read(struct archive_read_filter *self, char *buf, size_t buf_len)
297 {
298 struct program_filter *state = self->data;
299 ssize_t ret, requested, avail;
300 const char *p;
301 #if defined(_WIN32) && !defined(__CYGWIN__)
302 HANDLE handle = (HANDLE)_get_osfhandle(state->child_stdout);
303 #endif
304
305 requested = buf_len > SSIZE_MAX ? SSIZE_MAX : buf_len;
306
307 for (;;) {
308 do {
309 #if defined(_WIN32) && !defined(__CYGWIN__)
310 /* Avoid infinity wait.
311 * Note: If there is no data in the pipe, ReadFile()
312 * called in read() never returns and so we won't
313 * write remaining encoded data to the pipe.
314 * Note: This way may cause performance problem.
315 * we are looking forward to great code to resolve
316 * this. */
317 DWORD pipe_avail = -1;
318 int cnt = 2;
319
320 while (PeekNamedPipe(handle, NULL, 0, NULL,
321 &pipe_avail, NULL) != 0 && pipe_avail == 0 &&
322 cnt--)
323 Sleep(5);
324 if (pipe_avail == 0) {
325 ret = -1;
326 errno = EAGAIN;
327 break;
328 }
329 #endif
330 ret = read(state->child_stdout, buf, requested);
331 } while (ret == -1 && errno == EINTR);
332
333 if (ret > 0)
334 return (ret);
335 if (ret == 0 || (ret == -1 && errno == EPIPE))
336 /* Child has closed its output; reap the child
337 * and return the status. */
338 return (child_stop(self, state));
339 if (ret == -1 && errno != EAGAIN)
340 return (-1);
341
342 if (state->child_stdin == -1) {
343 /* Block until child has some I/O ready. */
344 __archive_check_child(state->child_stdin,
345 state->child_stdout);
346 continue;
347 }
348
349 /* Get some more data from upstream. */
350 p = __archive_read_filter_ahead(self->upstream, 1, &avail);
351 if (p == NULL) {
352 close(state->child_stdin);
353 state->child_stdin = -1;
354 fcntl(state->child_stdout, F_SETFL, 0);
355 if (avail < 0)
356 return (avail);
357 continue;
358 }
359
360 do {
361 ret = write(state->child_stdin, p, avail);
362 } while (ret == -1 && errno == EINTR);
363
364 if (ret > 0) {
365 /* Consume whatever we managed to write. */
366 __archive_read_filter_consume(self->upstream, ret);
367 } else if (ret == -1 && errno == EAGAIN) {
368 /* Block until child has some I/O ready. */
369 __archive_check_child(state->child_stdin,
370 state->child_stdout);
371 } else {
372 /* Write failed. */
373 close(state->child_stdin);
374 state->child_stdin = -1;
375 fcntl(state->child_stdout, F_SETFL, 0);
376 /* If it was a bad error, we're done; otherwise
377 * it was EPIPE or EOF, and we can still read
378 * from the child. */
379 if (ret == -1 && errno != EPIPE)
380 return (-1);
381 }
382 }
383 }
384
385 static const struct archive_read_filter_vtable
386 program_reader_vtable = {
387 .read = program_filter_read,
388 .close = program_filter_close,
389 };
390
391 int
__archive_read_program(struct archive_read_filter * self,const char * cmd)392 __archive_read_program(struct archive_read_filter *self, const char *cmd)
393 {
394 struct program_filter *state;
395 static const size_t out_buf_len = 65536;
396 char *out_buf;
397 const char *prefix = "Program: ";
398 int ret;
399 size_t l;
400
401 l = strlen(prefix) + strlen(cmd) + 1;
402 state = (struct program_filter *)calloc(1, sizeof(*state));
403 out_buf = (char *)malloc(out_buf_len);
404 if (state == NULL || out_buf == NULL ||
405 archive_string_ensure(&state->description, l) == NULL) {
406 archive_set_error(&self->archive->archive, ENOMEM,
407 "Can't allocate input data");
408 if (state != NULL) {
409 archive_string_free(&state->description);
410 free(state);
411 }
412 free(out_buf);
413 return (ARCHIVE_FATAL);
414 }
415 archive_strcpy(&state->description, prefix);
416 archive_strcat(&state->description, cmd);
417
418 self->code = ARCHIVE_FILTER_PROGRAM;
419 self->name = state->description.s;
420
421 state->out_buf = out_buf;
422 state->out_buf_len = out_buf_len;
423
424 ret = __archive_create_child(cmd, &state->child_stdin,
425 &state->child_stdout, &state->child);
426 if (ret != ARCHIVE_OK) {
427 free(state->out_buf);
428 archive_string_free(&state->description);
429 free(state);
430 archive_set_error(&self->archive->archive, EINVAL,
431 "Can't initialize filter; unable to run program \"%s\"",
432 cmd);
433 return (ARCHIVE_FATAL);
434 }
435
436 self->data = state;
437 self->vtable = &program_reader_vtable;
438
439 /* XXX Check that we can read at least one byte? */
440 return (ARCHIVE_OK);
441 }
442
443 static int
program_bidder_init(struct archive_read_filter * self)444 program_bidder_init(struct archive_read_filter *self)
445 {
446 struct program_bidder *bidder_state;
447
448 bidder_state = (struct program_bidder *)self->bidder->data;
449 return (__archive_read_program(self, bidder_state->cmd));
450 }
451
452 static ssize_t
program_filter_read(struct archive_read_filter * self,const void ** buff)453 program_filter_read(struct archive_read_filter *self, const void **buff)
454 {
455 struct program_filter *state;
456 ssize_t bytes;
457 size_t total;
458 char *p;
459
460 state = (struct program_filter *)self->data;
461
462 total = 0;
463 p = state->out_buf;
464 while (state->child_stdout != -1 && total < state->out_buf_len) {
465 bytes = child_read(self, p, state->out_buf_len - total);
466 if (bytes < 0)
467 /* No recovery is possible if we can no longer
468 * read from the child. */
469 return (ARCHIVE_FATAL);
470 if (bytes == 0)
471 /* We got EOF from the child. */
472 break;
473 total += bytes;
474 p += bytes;
475 }
476
477 *buff = state->out_buf;
478 return (total);
479 }
480
481 static int
program_filter_close(struct archive_read_filter * self)482 program_filter_close(struct archive_read_filter *self)
483 {
484 struct program_filter *state;
485 int e;
486
487 state = (struct program_filter *)self->data;
488 e = child_stop(self, state);
489
490 /* Release our private data. */
491 free(state->out_buf);
492 archive_string_free(&state->description);
493 free(state);
494
495 return (e);
496 }
497