1 /*-
2 * Copyright (c) 2003-2007 Tim Kientzle
3 * Copyright (c) 2010-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: head/lib/libarchive/archive_read_support_format_cpio.c 201163 2009-12-29 05:50:34Z kientzle $");
29
30 #ifdef HAVE_ERRNO_H
31 #include <errno.h>
32 #endif
33 /* #include <stdint.h> */ /* See archive_platform.h */
34 #ifdef HAVE_STDLIB_H
35 #include <stdlib.h>
36 #endif
37 #ifdef HAVE_STRING_H
38 #include <string.h>
39 #endif
40
41 #include "archive.h"
42 #include "archive_entry.h"
43 #include "archive_entry_locale.h"
44 #include "archive_private.h"
45 #include "archive_read_private.h"
46
47 #define bin_magic_offset 0
48 #define bin_magic_size 2
49 #define bin_dev_offset 2
50 #define bin_dev_size 2
51 #define bin_ino_offset 4
52 #define bin_ino_size 2
53 #define bin_mode_offset 6
54 #define bin_mode_size 2
55 #define bin_uid_offset 8
56 #define bin_uid_size 2
57 #define bin_gid_offset 10
58 #define bin_gid_size 2
59 #define bin_nlink_offset 12
60 #define bin_nlink_size 2
61 #define bin_rdev_offset 14
62 #define bin_rdev_size 2
63 #define bin_mtime_offset 16
64 #define bin_mtime_size 4
65 #define bin_namesize_offset 20
66 #define bin_namesize_size 2
67 #define bin_filesize_offset 22
68 #define bin_filesize_size 4
69 #define bin_header_size 26
70
71 #define odc_magic_offset 0
72 #define odc_magic_size 6
73 #define odc_dev_offset 6
74 #define odc_dev_size 6
75 #define odc_ino_offset 12
76 #define odc_ino_size 6
77 #define odc_mode_offset 18
78 #define odc_mode_size 6
79 #define odc_uid_offset 24
80 #define odc_uid_size 6
81 #define odc_gid_offset 30
82 #define odc_gid_size 6
83 #define odc_nlink_offset 36
84 #define odc_nlink_size 6
85 #define odc_rdev_offset 42
86 #define odc_rdev_size 6
87 #define odc_mtime_offset 48
88 #define odc_mtime_size 11
89 #define odc_namesize_offset 59
90 #define odc_namesize_size 6
91 #define odc_filesize_offset 65
92 #define odc_filesize_size 11
93 #define odc_header_size 76
94
95 #define newc_magic_offset 0
96 #define newc_magic_size 6
97 #define newc_ino_offset 6
98 #define newc_ino_size 8
99 #define newc_mode_offset 14
100 #define newc_mode_size 8
101 #define newc_uid_offset 22
102 #define newc_uid_size 8
103 #define newc_gid_offset 30
104 #define newc_gid_size 8
105 #define newc_nlink_offset 38
106 #define newc_nlink_size 8
107 #define newc_mtime_offset 46
108 #define newc_mtime_size 8
109 #define newc_filesize_offset 54
110 #define newc_filesize_size 8
111 #define newc_devmajor_offset 62
112 #define newc_devmajor_size 8
113 #define newc_devminor_offset 70
114 #define newc_devminor_size 8
115 #define newc_rdevmajor_offset 78
116 #define newc_rdevmajor_size 8
117 #define newc_rdevminor_offset 86
118 #define newc_rdevminor_size 8
119 #define newc_namesize_offset 94
120 #define newc_namesize_size 8
121 #define newc_checksum_offset 102
122 #define newc_checksum_size 8
123 #define newc_header_size 110
124
125 /*
126 * An afio large ASCII header, which they named itself.
127 * afio utility uses this header, if a file size is larger than 2G bytes
128 * or inode/uid/gid is bigger than 65535(0xFFFF) or mtime is bigger than
129 * 0x7fffffff, which we cannot record to odc header because of its limit.
130 * If not, uses odc header.
131 */
132 #define afiol_magic_offset 0
133 #define afiol_magic_size 6
134 #define afiol_dev_offset 6
135 #define afiol_dev_size 8 /* hex */
136 #define afiol_ino_offset 14
137 #define afiol_ino_size 16 /* hex */
138 #define afiol_ino_m_offset 30 /* 'm' */
139 #define afiol_mode_offset 31
140 #define afiol_mode_size 6 /* oct */
141 #define afiol_uid_offset 37
142 #define afiol_uid_size 8 /* hex */
143 #define afiol_gid_offset 45
144 #define afiol_gid_size 8 /* hex */
145 #define afiol_nlink_offset 53
146 #define afiol_nlink_size 8 /* hex */
147 #define afiol_rdev_offset 61
148 #define afiol_rdev_size 8 /* hex */
149 #define afiol_mtime_offset 69
150 #define afiol_mtime_size 16 /* hex */
151 #define afiol_mtime_n_offset 85 /* 'n' */
152 #define afiol_namesize_offset 86
153 #define afiol_namesize_size 4 /* hex */
154 #define afiol_flag_offset 90
155 #define afiol_flag_size 4 /* hex */
156 #define afiol_xsize_offset 94
157 #define afiol_xsize_size 4 /* hex */
158 #define afiol_xsize_s_offset 98 /* 's' */
159 #define afiol_filesize_offset 99
160 #define afiol_filesize_size 16 /* hex */
161 #define afiol_filesize_c_offset 115 /* ':' */
162 #define afiol_header_size 116
163
164
165 struct links_entry {
166 struct links_entry *next;
167 struct links_entry *previous;
168 unsigned int links;
169 dev_t dev;
170 int64_t ino;
171 char *name;
172 };
173
174 #define CPIO_MAGIC 0x13141516
175 struct cpio {
176 int magic;
177 int (*read_header)(struct archive_read *, struct cpio *,
178 struct archive_entry *, size_t *, size_t *);
179 struct links_entry *links_head;
180 int64_t entry_bytes_remaining;
181 int64_t entry_bytes_unconsumed;
182 int64_t entry_offset;
183 int64_t entry_padding;
184
185 struct archive_string_conv *opt_sconv;
186 struct archive_string_conv *sconv_default;
187 int init_default_conversion;
188 };
189
190 static int64_t atol16(const char *, unsigned);
191 static int64_t atol8(const char *, unsigned);
192 static int archive_read_format_cpio_bid(struct archive_read *, int);
193 static int archive_read_format_cpio_options(struct archive_read *,
194 const char *, const char *);
195 static int archive_read_format_cpio_cleanup(struct archive_read *);
196 static int archive_read_format_cpio_read_data(struct archive_read *,
197 const void **, size_t *, int64_t *);
198 static int archive_read_format_cpio_read_header(struct archive_read *,
199 struct archive_entry *);
200 static int archive_read_format_cpio_skip(struct archive_read *);
201 static int64_t be4(const unsigned char *);
202 static int find_odc_header(struct archive_read *);
203 static int find_newc_header(struct archive_read *);
204 static int header_bin_be(struct archive_read *, struct cpio *,
205 struct archive_entry *, size_t *, size_t *);
206 static int header_bin_le(struct archive_read *, struct cpio *,
207 struct archive_entry *, size_t *, size_t *);
208 static int header_newc(struct archive_read *, struct cpio *,
209 struct archive_entry *, size_t *, size_t *);
210 static int header_odc(struct archive_read *, struct cpio *,
211 struct archive_entry *, size_t *, size_t *);
212 static int header_afiol(struct archive_read *, struct cpio *,
213 struct archive_entry *, size_t *, size_t *);
214 static int is_octal(const char *, size_t);
215 static int is_hex(const char *, size_t);
216 static int64_t le4(const unsigned char *);
217 static int record_hardlink(struct archive_read *a,
218 struct cpio *cpio, struct archive_entry *entry);
219
220 int
archive_read_support_format_cpio(struct archive * _a)221 archive_read_support_format_cpio(struct archive *_a)
222 {
223 struct archive_read *a = (struct archive_read *)_a;
224 struct cpio *cpio;
225 int r;
226
227 archive_check_magic(_a, ARCHIVE_READ_MAGIC,
228 ARCHIVE_STATE_NEW, "archive_read_support_format_cpio");
229
230 cpio = (struct cpio *)calloc(1, sizeof(*cpio));
231 if (cpio == NULL) {
232 archive_set_error(&a->archive, ENOMEM, "Can't allocate cpio data");
233 return (ARCHIVE_FATAL);
234 }
235 cpio->magic = CPIO_MAGIC;
236
237 r = __archive_read_register_format(a,
238 cpio,
239 "cpio",
240 archive_read_format_cpio_bid,
241 archive_read_format_cpio_options,
242 archive_read_format_cpio_read_header,
243 archive_read_format_cpio_read_data,
244 archive_read_format_cpio_skip,
245 NULL,
246 archive_read_format_cpio_cleanup,
247 NULL,
248 NULL);
249
250 if (r != ARCHIVE_OK)
251 free(cpio);
252 return (ARCHIVE_OK);
253 }
254
255
256 static int
archive_read_format_cpio_bid(struct archive_read * a,int best_bid)257 archive_read_format_cpio_bid(struct archive_read *a, int best_bid)
258 {
259 const unsigned char *p;
260 struct cpio *cpio;
261 int bid;
262
263 (void)best_bid; /* UNUSED */
264
265 cpio = (struct cpio *)(a->format->data);
266
267 if ((p = __archive_read_ahead(a, 6, NULL)) == NULL)
268 return (-1);
269
270 bid = 0;
271 if (memcmp(p, "070707", 6) == 0) {
272 /* ASCII cpio archive (odc, POSIX.1) */
273 cpio->read_header = header_odc;
274 bid += 48;
275 /*
276 * XXX TODO: More verification; Could check that only octal
277 * digits appear in appropriate header locations. XXX
278 */
279 } else if (memcmp(p, "070727", 6) == 0) {
280 /* afio large ASCII cpio archive */
281 cpio->read_header = header_odc;
282 bid += 48;
283 /*
284 * XXX TODO: More verification; Could check that almost hex
285 * digits appear in appropriate header locations. XXX
286 */
287 } else if (memcmp(p, "070701", 6) == 0) {
288 /* ASCII cpio archive (SVR4 without CRC) */
289 cpio->read_header = header_newc;
290 bid += 48;
291 /*
292 * XXX TODO: More verification; Could check that only hex
293 * digits appear in appropriate header locations. XXX
294 */
295 } else if (memcmp(p, "070702", 6) == 0) {
296 /* ASCII cpio archive (SVR4 with CRC) */
297 /* XXX TODO: Flag that we should check the CRC. XXX */
298 cpio->read_header = header_newc;
299 bid += 48;
300 /*
301 * XXX TODO: More verification; Could check that only hex
302 * digits appear in appropriate header locations. XXX
303 */
304 } else if (p[0] * 256 + p[1] == 070707) {
305 /* big-endian binary cpio archives */
306 cpio->read_header = header_bin_be;
307 bid += 16;
308 /* Is more verification possible here? */
309 } else if (p[0] + p[1] * 256 == 070707) {
310 /* little-endian binary cpio archives */
311 cpio->read_header = header_bin_le;
312 bid += 16;
313 /* Is more verification possible here? */
314 } else
315 return (ARCHIVE_WARN);
316
317 return (bid);
318 }
319
320 static int
archive_read_format_cpio_options(struct archive_read * a,const char * key,const char * val)321 archive_read_format_cpio_options(struct archive_read *a,
322 const char *key, const char *val)
323 {
324 struct cpio *cpio;
325 int ret = ARCHIVE_FAILED;
326
327 cpio = (struct cpio *)(a->format->data);
328 if (strcmp(key, "compat-2x") == 0) {
329 /* Handle filenames as libarchive 2.x */
330 cpio->init_default_conversion = (val != NULL)?1:0;
331 return (ARCHIVE_OK);
332 } else if (strcmp(key, "hdrcharset") == 0) {
333 if (val == NULL || val[0] == 0)
334 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
335 "cpio: hdrcharset option needs a character-set name");
336 else {
337 cpio->opt_sconv =
338 archive_string_conversion_from_charset(
339 &a->archive, val, 0);
340 if (cpio->opt_sconv != NULL)
341 ret = ARCHIVE_OK;
342 else
343 ret = ARCHIVE_FATAL;
344 }
345 return (ret);
346 }
347
348 /* Note: The "warn" return is just to inform the options
349 * supervisor that we didn't handle it. It will generate
350 * a suitable error if no one used this option. */
351 return (ARCHIVE_WARN);
352 }
353
354 static int
archive_read_format_cpio_read_header(struct archive_read * a,struct archive_entry * entry)355 archive_read_format_cpio_read_header(struct archive_read *a,
356 struct archive_entry *entry)
357 {
358 struct cpio *cpio;
359 const void *h, *hl;
360 struct archive_string_conv *sconv;
361 size_t namelength;
362 size_t name_pad;
363 int r;
364
365 cpio = (struct cpio *)(a->format->data);
366 sconv = cpio->opt_sconv;
367 if (sconv == NULL) {
368 if (!cpio->init_default_conversion) {
369 cpio->sconv_default =
370 archive_string_default_conversion_for_read(
371 &(a->archive));
372 cpio->init_default_conversion = 1;
373 }
374 sconv = cpio->sconv_default;
375 }
376
377 r = (cpio->read_header(a, cpio, entry, &namelength, &name_pad));
378
379 if (r < ARCHIVE_WARN)
380 return (r);
381
382 /* Read name from buffer. */
383 h = __archive_read_ahead(a, namelength + name_pad, NULL);
384 if (h == NULL)
385 return (ARCHIVE_FATAL);
386 if (archive_entry_copy_pathname_l(entry,
387 (const char *)h, namelength, sconv) != 0) {
388 if (errno == ENOMEM) {
389 archive_set_error(&a->archive, ENOMEM,
390 "Can't allocate memory for Pathname");
391 return (ARCHIVE_FATAL);
392 }
393 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
394 "Pathname can't be converted from %s to current locale.",
395 archive_string_conversion_charset_name(sconv));
396 r = ARCHIVE_WARN;
397 }
398 cpio->entry_offset = 0;
399
400 __archive_read_consume(a, namelength + name_pad);
401
402 /* If this is a symlink, read the link contents. */
403 if (archive_entry_filetype(entry) == AE_IFLNK) {
404 if (cpio->entry_bytes_remaining > 1024 * 1024) {
405 archive_set_error(&a->archive, ENOMEM,
406 "Rejecting malformed cpio archive: symlink contents exceed 1 megabyte");
407 return (ARCHIVE_FATAL);
408 }
409 hl = __archive_read_ahead(a,
410 (size_t)cpio->entry_bytes_remaining, NULL);
411 if (hl == NULL)
412 return (ARCHIVE_FATAL);
413 if (archive_entry_copy_symlink_l(entry, (const char *)hl,
414 (size_t)cpio->entry_bytes_remaining, sconv) != 0) {
415 if (errno == ENOMEM) {
416 archive_set_error(&a->archive, ENOMEM,
417 "Can't allocate memory for Linkname");
418 return (ARCHIVE_FATAL);
419 }
420 archive_set_error(&a->archive,
421 ARCHIVE_ERRNO_FILE_FORMAT,
422 "Linkname can't be converted from %s to "
423 "current locale.",
424 archive_string_conversion_charset_name(sconv));
425 r = ARCHIVE_WARN;
426 }
427 __archive_read_consume(a, cpio->entry_bytes_remaining);
428 cpio->entry_bytes_remaining = 0;
429 }
430
431 /* XXX TODO: If the full mode is 0160200, then this is a Solaris
432 * ACL description for the following entry. Read this body
433 * and parse it as a Solaris-style ACL, then read the next
434 * header. XXX */
435
436 /* Compare name to "TRAILER!!!" to test for end-of-archive. */
437 if (namelength == 11 && strncmp((const char *)h, "TRAILER!!!",
438 11) == 0) {
439 /* TODO: Store file location of start of block. */
440 archive_clear_error(&a->archive);
441 return (ARCHIVE_EOF);
442 }
443
444 /* Detect and record hardlinks to previously-extracted entries. */
445 if (record_hardlink(a, cpio, entry) != ARCHIVE_OK) {
446 return (ARCHIVE_FATAL);
447 }
448
449 return (r);
450 }
451
452 static int
archive_read_format_cpio_read_data(struct archive_read * a,const void ** buff,size_t * size,int64_t * offset)453 archive_read_format_cpio_read_data(struct archive_read *a,
454 const void **buff, size_t *size, int64_t *offset)
455 {
456 ssize_t bytes_read;
457 struct cpio *cpio;
458
459 cpio = (struct cpio *)(a->format->data);
460
461 if (cpio->entry_bytes_unconsumed) {
462 __archive_read_consume(a, cpio->entry_bytes_unconsumed);
463 cpio->entry_bytes_unconsumed = 0;
464 }
465
466 if (cpio->entry_bytes_remaining > 0) {
467 *buff = __archive_read_ahead(a, 1, &bytes_read);
468 if (bytes_read <= 0)
469 return (ARCHIVE_FATAL);
470 if (bytes_read > cpio->entry_bytes_remaining)
471 bytes_read = (ssize_t)cpio->entry_bytes_remaining;
472 *size = bytes_read;
473 cpio->entry_bytes_unconsumed = bytes_read;
474 *offset = cpio->entry_offset;
475 cpio->entry_offset += bytes_read;
476 cpio->entry_bytes_remaining -= bytes_read;
477 return (ARCHIVE_OK);
478 } else {
479 if (cpio->entry_padding !=
480 __archive_read_consume(a, cpio->entry_padding)) {
481 return (ARCHIVE_FATAL);
482 }
483 cpio->entry_padding = 0;
484 *buff = NULL;
485 *size = 0;
486 *offset = cpio->entry_offset;
487 return (ARCHIVE_EOF);
488 }
489 }
490
491 static int
archive_read_format_cpio_skip(struct archive_read * a)492 archive_read_format_cpio_skip(struct archive_read *a)
493 {
494 struct cpio *cpio = (struct cpio *)(a->format->data);
495 int64_t to_skip = cpio->entry_bytes_remaining + cpio->entry_padding +
496 cpio->entry_bytes_unconsumed;
497
498 if (to_skip != __archive_read_consume(a, to_skip)) {
499 return (ARCHIVE_FATAL);
500 }
501 cpio->entry_bytes_remaining = 0;
502 cpio->entry_padding = 0;
503 cpio->entry_bytes_unconsumed = 0;
504 return (ARCHIVE_OK);
505 }
506
507 /*
508 * Skip forward to the next cpio newc header by searching for the
509 * 07070[12] string. This should be generalized and merged with
510 * find_odc_header below.
511 */
512 static int
is_hex(const char * p,size_t len)513 is_hex(const char *p, size_t len)
514 {
515 while (len-- > 0) {
516 if ((*p >= '0' && *p <= '9')
517 || (*p >= 'a' && *p <= 'f')
518 || (*p >= 'A' && *p <= 'F'))
519 ++p;
520 else
521 return (0);
522 }
523 return (1);
524 }
525
526 static int
find_newc_header(struct archive_read * a)527 find_newc_header(struct archive_read *a)
528 {
529 const void *h;
530 const char *p, *q;
531 size_t skip, skipped = 0;
532 ssize_t bytes;
533
534 for (;;) {
535 h = __archive_read_ahead(a, newc_header_size, &bytes);
536 if (h == NULL)
537 return (ARCHIVE_FATAL);
538 p = h;
539 q = p + bytes;
540
541 /* Try the typical case first, then go into the slow search.*/
542 if (memcmp("07070", p, 5) == 0
543 && (p[5] == '1' || p[5] == '2')
544 && is_hex(p, newc_header_size))
545 return (ARCHIVE_OK);
546
547 /*
548 * Scan ahead until we find something that looks
549 * like a newc header.
550 */
551 while (p + newc_header_size <= q) {
552 switch (p[5]) {
553 case '1':
554 case '2':
555 if (memcmp("07070", p, 5) == 0
556 && is_hex(p, newc_header_size)) {
557 skip = p - (const char *)h;
558 __archive_read_consume(a, skip);
559 skipped += skip;
560 if (skipped > 0) {
561 archive_set_error(&a->archive,
562 0,
563 "Skipped %d bytes before "
564 "finding valid header",
565 (int)skipped);
566 return (ARCHIVE_WARN);
567 }
568 return (ARCHIVE_OK);
569 }
570 p += 2;
571 break;
572 case '0':
573 p++;
574 break;
575 default:
576 p += 6;
577 break;
578 }
579 }
580 skip = p - (const char *)h;
581 __archive_read_consume(a, skip);
582 skipped += skip;
583 }
584 }
585
586 static int
header_newc(struct archive_read * a,struct cpio * cpio,struct archive_entry * entry,size_t * namelength,size_t * name_pad)587 header_newc(struct archive_read *a, struct cpio *cpio,
588 struct archive_entry *entry, size_t *namelength, size_t *name_pad)
589 {
590 const void *h;
591 const char *header;
592 int r;
593
594 r = find_newc_header(a);
595 if (r < ARCHIVE_WARN)
596 return (r);
597
598 /* Read fixed-size portion of header. */
599 h = __archive_read_ahead(a, newc_header_size, NULL);
600 if (h == NULL)
601 return (ARCHIVE_FATAL);
602
603 /* Parse out hex fields. */
604 header = (const char *)h;
605
606 if (memcmp(header + newc_magic_offset, "070701", 6) == 0) {
607 a->archive.archive_format = ARCHIVE_FORMAT_CPIO_SVR4_NOCRC;
608 a->archive.archive_format_name = "ASCII cpio (SVR4 with no CRC)";
609 } else if (memcmp(header + newc_magic_offset, "070702", 6) == 0) {
610 a->archive.archive_format = ARCHIVE_FORMAT_CPIO_SVR4_CRC;
611 a->archive.archive_format_name = "ASCII cpio (SVR4 with CRC)";
612 } else {
613 /* TODO: Abort here? */
614 }
615
616 archive_entry_set_devmajor(entry,
617 (dev_t)atol16(header + newc_devmajor_offset, newc_devmajor_size));
618 archive_entry_set_devminor(entry,
619 (dev_t)atol16(header + newc_devminor_offset, newc_devminor_size));
620 archive_entry_set_ino(entry, atol16(header + newc_ino_offset, newc_ino_size));
621 archive_entry_set_mode(entry,
622 (mode_t)atol16(header + newc_mode_offset, newc_mode_size));
623 archive_entry_set_uid(entry, atol16(header + newc_uid_offset, newc_uid_size));
624 archive_entry_set_gid(entry, atol16(header + newc_gid_offset, newc_gid_size));
625 archive_entry_set_nlink(entry,
626 (unsigned int)atol16(header + newc_nlink_offset, newc_nlink_size));
627 archive_entry_set_rdevmajor(entry,
628 (dev_t)atol16(header + newc_rdevmajor_offset, newc_rdevmajor_size));
629 archive_entry_set_rdevminor(entry,
630 (dev_t)atol16(header + newc_rdevminor_offset, newc_rdevminor_size));
631 archive_entry_set_mtime(entry, atol16(header + newc_mtime_offset, newc_mtime_size), 0);
632 *namelength = (size_t)atol16(header + newc_namesize_offset, newc_namesize_size);
633 /* Pad name to 2 more than a multiple of 4. */
634 *name_pad = (2 - *namelength) & 3;
635
636 /* Make sure that the padded name length fits into size_t. */
637 if (*name_pad > SIZE_MAX - *namelength) {
638 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT,
639 "cpio archive has invalid namelength");
640 return (ARCHIVE_FATAL);
641 }
642
643 /*
644 * Note: entry_bytes_remaining is at least 64 bits and
645 * therefore guaranteed to be big enough for a 33-bit file
646 * size.
647 */
648 cpio->entry_bytes_remaining =
649 atol16(header + newc_filesize_offset, newc_filesize_size);
650 archive_entry_set_size(entry, cpio->entry_bytes_remaining);
651 /* Pad file contents to a multiple of 4. */
652 cpio->entry_padding = 3 & -cpio->entry_bytes_remaining;
653 __archive_read_consume(a, newc_header_size);
654 return (r);
655 }
656
657 /*
658 * Skip forward to the next cpio odc header by searching for the
659 * 070707 string. This is a hand-optimized search that could
660 * probably be easily generalized to handle all character-based
661 * cpio variants.
662 */
663 static int
is_octal(const char * p,size_t len)664 is_octal(const char *p, size_t len)
665 {
666 while (len-- > 0) {
667 if (*p < '0' || *p > '7')
668 return (0);
669 ++p;
670 }
671 return (1);
672 }
673
674 static int
is_afio_large(const char * h,size_t len)675 is_afio_large(const char *h, size_t len)
676 {
677 if (len < afiol_header_size)
678 return (0);
679 if (h[afiol_ino_m_offset] != 'm'
680 || h[afiol_mtime_n_offset] != 'n'
681 || h[afiol_xsize_s_offset] != 's'
682 || h[afiol_filesize_c_offset] != ':')
683 return (0);
684 if (!is_hex(h + afiol_dev_offset, afiol_ino_m_offset - afiol_dev_offset))
685 return (0);
686 if (!is_hex(h + afiol_mode_offset, afiol_mtime_n_offset - afiol_mode_offset))
687 return (0);
688 if (!is_hex(h + afiol_namesize_offset, afiol_xsize_s_offset - afiol_namesize_offset))
689 return (0);
690 if (!is_hex(h + afiol_filesize_offset, afiol_filesize_size))
691 return (0);
692 return (1);
693 }
694
695 static int
find_odc_header(struct archive_read * a)696 find_odc_header(struct archive_read *a)
697 {
698 const void *h;
699 const char *p, *q;
700 size_t skip, skipped = 0;
701 ssize_t bytes;
702
703 for (;;) {
704 h = __archive_read_ahead(a, odc_header_size, &bytes);
705 if (h == NULL)
706 return (ARCHIVE_FATAL);
707 p = h;
708 q = p + bytes;
709
710 /* Try the typical case first, then go into the slow search.*/
711 if (memcmp("070707", p, 6) == 0 && is_octal(p, odc_header_size))
712 return (ARCHIVE_OK);
713 if (memcmp("070727", p, 6) == 0 && is_afio_large(p, bytes)) {
714 a->archive.archive_format = ARCHIVE_FORMAT_CPIO_AFIO_LARGE;
715 return (ARCHIVE_OK);
716 }
717
718 /*
719 * Scan ahead until we find something that looks
720 * like an odc header.
721 */
722 while (p + odc_header_size <= q) {
723 switch (p[5]) {
724 case '7':
725 if ((memcmp("070707", p, 6) == 0
726 && is_octal(p, odc_header_size))
727 || (memcmp("070727", p, 6) == 0
728 && is_afio_large(p, q - p))) {
729 skip = p - (const char *)h;
730 __archive_read_consume(a, skip);
731 skipped += skip;
732 if (p[4] == '2')
733 a->archive.archive_format =
734 ARCHIVE_FORMAT_CPIO_AFIO_LARGE;
735 if (skipped > 0) {
736 archive_set_error(&a->archive,
737 0,
738 "Skipped %d bytes before "
739 "finding valid header",
740 (int)skipped);
741 return (ARCHIVE_WARN);
742 }
743 return (ARCHIVE_OK);
744 }
745 p += 2;
746 break;
747 case '0':
748 p++;
749 break;
750 default:
751 p += 6;
752 break;
753 }
754 }
755 skip = p - (const char *)h;
756 __archive_read_consume(a, skip);
757 skipped += skip;
758 }
759 }
760
761 static int
header_odc(struct archive_read * a,struct cpio * cpio,struct archive_entry * entry,size_t * namelength,size_t * name_pad)762 header_odc(struct archive_read *a, struct cpio *cpio,
763 struct archive_entry *entry, size_t *namelength, size_t *name_pad)
764 {
765 const void *h;
766 int r;
767 const char *header;
768
769 a->archive.archive_format = ARCHIVE_FORMAT_CPIO_POSIX;
770 a->archive.archive_format_name = "POSIX octet-oriented cpio";
771
772 /* Find the start of the next header. */
773 r = find_odc_header(a);
774 if (r < ARCHIVE_WARN)
775 return (r);
776
777 if (a->archive.archive_format == ARCHIVE_FORMAT_CPIO_AFIO_LARGE) {
778 int r2 = (header_afiol(a, cpio, entry, namelength, name_pad));
779 if (r2 == ARCHIVE_OK)
780 return (r);
781 else
782 return (r2);
783 }
784
785 /* Read fixed-size portion of header. */
786 h = __archive_read_ahead(a, odc_header_size, NULL);
787 if (h == NULL)
788 return (ARCHIVE_FATAL);
789
790 /* Parse out octal fields. */
791 header = (const char *)h;
792
793 archive_entry_set_dev(entry,
794 (dev_t)atol8(header + odc_dev_offset, odc_dev_size));
795 archive_entry_set_ino(entry, atol8(header + odc_ino_offset, odc_ino_size));
796 archive_entry_set_mode(entry,
797 (mode_t)atol8(header + odc_mode_offset, odc_mode_size));
798 archive_entry_set_uid(entry, atol8(header + odc_uid_offset, odc_uid_size));
799 archive_entry_set_gid(entry, atol8(header + odc_gid_offset, odc_gid_size));
800 archive_entry_set_nlink(entry,
801 (unsigned int)atol8(header + odc_nlink_offset, odc_nlink_size));
802 archive_entry_set_rdev(entry,
803 (dev_t)atol8(header + odc_rdev_offset, odc_rdev_size));
804 archive_entry_set_mtime(entry, atol8(header + odc_mtime_offset, odc_mtime_size), 0);
805 *namelength = (size_t)atol8(header + odc_namesize_offset, odc_namesize_size);
806 *name_pad = 0; /* No padding of filename. */
807
808 /*
809 * Note: entry_bytes_remaining is at least 64 bits and
810 * therefore guaranteed to be big enough for a 33-bit file
811 * size.
812 */
813 cpio->entry_bytes_remaining =
814 atol8(header + odc_filesize_offset, odc_filesize_size);
815 archive_entry_set_size(entry, cpio->entry_bytes_remaining);
816 cpio->entry_padding = 0;
817 __archive_read_consume(a, odc_header_size);
818 return (r);
819 }
820
821 /*
822 * NOTE: if a filename suffix is ".z", it is the file gziped by afio.
823 * it would be nice that we can show uncompressed file size and we can
824 * uncompressed file contents automatically, unfortunately we have nothing
825 * to get a uncompressed file size while reading each header. It means
826 * we also cannot uncompress file contents under our framework.
827 */
828 static int
header_afiol(struct archive_read * a,struct cpio * cpio,struct archive_entry * entry,size_t * namelength,size_t * name_pad)829 header_afiol(struct archive_read *a, struct cpio *cpio,
830 struct archive_entry *entry, size_t *namelength, size_t *name_pad)
831 {
832 const void *h;
833 const char *header;
834
835 a->archive.archive_format = ARCHIVE_FORMAT_CPIO_AFIO_LARGE;
836 a->archive.archive_format_name = "afio large ASCII";
837
838 /* Read fixed-size portion of header. */
839 h = __archive_read_ahead(a, afiol_header_size, NULL);
840 if (h == NULL)
841 return (ARCHIVE_FATAL);
842
843 /* Parse out octal fields. */
844 header = (const char *)h;
845
846 archive_entry_set_dev(entry,
847 (dev_t)atol16(header + afiol_dev_offset, afiol_dev_size));
848 archive_entry_set_ino(entry, atol16(header + afiol_ino_offset, afiol_ino_size));
849 archive_entry_set_mode(entry,
850 (mode_t)atol8(header + afiol_mode_offset, afiol_mode_size));
851 archive_entry_set_uid(entry, atol16(header + afiol_uid_offset, afiol_uid_size));
852 archive_entry_set_gid(entry, atol16(header + afiol_gid_offset, afiol_gid_size));
853 archive_entry_set_nlink(entry,
854 (unsigned int)atol16(header + afiol_nlink_offset, afiol_nlink_size));
855 archive_entry_set_rdev(entry,
856 (dev_t)atol16(header + afiol_rdev_offset, afiol_rdev_size));
857 archive_entry_set_mtime(entry, atol16(header + afiol_mtime_offset, afiol_mtime_size), 0);
858 *namelength = (size_t)atol16(header + afiol_namesize_offset, afiol_namesize_size);
859 *name_pad = 0; /* No padding of filename. */
860
861 cpio->entry_bytes_remaining =
862 atol16(header + afiol_filesize_offset, afiol_filesize_size);
863 archive_entry_set_size(entry, cpio->entry_bytes_remaining);
864 cpio->entry_padding = 0;
865 __archive_read_consume(a, afiol_header_size);
866 return (ARCHIVE_OK);
867 }
868
869
870 static int
header_bin_le(struct archive_read * a,struct cpio * cpio,struct archive_entry * entry,size_t * namelength,size_t * name_pad)871 header_bin_le(struct archive_read *a, struct cpio *cpio,
872 struct archive_entry *entry, size_t *namelength, size_t *name_pad)
873 {
874 const void *h;
875 const unsigned char *header;
876
877 a->archive.archive_format = ARCHIVE_FORMAT_CPIO_BIN_LE;
878 a->archive.archive_format_name = "cpio (little-endian binary)";
879
880 /* Read fixed-size portion of header. */
881 h = __archive_read_ahead(a, bin_header_size, NULL);
882 if (h == NULL) {
883 archive_set_error(&a->archive, 0,
884 "End of file trying to read next cpio header");
885 return (ARCHIVE_FATAL);
886 }
887
888 /* Parse out binary fields. */
889 header = (const unsigned char *)h;
890
891 archive_entry_set_dev(entry, header[bin_dev_offset] + header[bin_dev_offset + 1] * 256);
892 archive_entry_set_ino(entry, header[bin_ino_offset] + header[bin_ino_offset + 1] * 256);
893 archive_entry_set_mode(entry, header[bin_mode_offset] + header[bin_mode_offset + 1] * 256);
894 archive_entry_set_uid(entry, header[bin_uid_offset] + header[bin_uid_offset + 1] * 256);
895 archive_entry_set_gid(entry, header[bin_gid_offset] + header[bin_gid_offset + 1] * 256);
896 archive_entry_set_nlink(entry, header[bin_nlink_offset] + header[bin_nlink_offset + 1] * 256);
897 archive_entry_set_rdev(entry, header[bin_rdev_offset] + header[bin_rdev_offset + 1] * 256);
898 archive_entry_set_mtime(entry, le4(header + bin_mtime_offset), 0);
899 *namelength = header[bin_namesize_offset] + header[bin_namesize_offset + 1] * 256;
900 *name_pad = *namelength & 1; /* Pad to even. */
901
902 cpio->entry_bytes_remaining = le4(header + bin_filesize_offset);
903 archive_entry_set_size(entry, cpio->entry_bytes_remaining);
904 cpio->entry_padding = cpio->entry_bytes_remaining & 1; /* Pad to even. */
905 __archive_read_consume(a, bin_header_size);
906 return (ARCHIVE_OK);
907 }
908
909 static int
header_bin_be(struct archive_read * a,struct cpio * cpio,struct archive_entry * entry,size_t * namelength,size_t * name_pad)910 header_bin_be(struct archive_read *a, struct cpio *cpio,
911 struct archive_entry *entry, size_t *namelength, size_t *name_pad)
912 {
913 const void *h;
914 const unsigned char *header;
915
916 a->archive.archive_format = ARCHIVE_FORMAT_CPIO_BIN_BE;
917 a->archive.archive_format_name = "cpio (big-endian binary)";
918
919 /* Read fixed-size portion of header. */
920 h = __archive_read_ahead(a, bin_header_size, NULL);
921 if (h == NULL) {
922 archive_set_error(&a->archive, 0,
923 "End of file trying to read next cpio header");
924 return (ARCHIVE_FATAL);
925 }
926
927 /* Parse out binary fields. */
928 header = (const unsigned char *)h;
929
930 archive_entry_set_dev(entry, header[bin_dev_offset] * 256 + header[bin_dev_offset + 1]);
931 archive_entry_set_ino(entry, header[bin_ino_offset] * 256 + header[bin_ino_offset + 1]);
932 archive_entry_set_mode(entry, header[bin_mode_offset] * 256 + header[bin_mode_offset + 1]);
933 archive_entry_set_uid(entry, header[bin_uid_offset] * 256 + header[bin_uid_offset + 1]);
934 archive_entry_set_gid(entry, header[bin_gid_offset] * 256 + header[bin_gid_offset + 1]);
935 archive_entry_set_nlink(entry, header[bin_nlink_offset] * 256 + header[bin_nlink_offset + 1]);
936 archive_entry_set_rdev(entry, header[bin_rdev_offset] * 256 + header[bin_rdev_offset + 1]);
937 archive_entry_set_mtime(entry, be4(header + bin_mtime_offset), 0);
938 *namelength = header[bin_namesize_offset] * 256 + header[bin_namesize_offset + 1];
939 *name_pad = *namelength & 1; /* Pad to even. */
940
941 cpio->entry_bytes_remaining = be4(header + bin_filesize_offset);
942 archive_entry_set_size(entry, cpio->entry_bytes_remaining);
943 cpio->entry_padding = cpio->entry_bytes_remaining & 1; /* Pad to even. */
944 __archive_read_consume(a, bin_header_size);
945 return (ARCHIVE_OK);
946 }
947
948 static int
archive_read_format_cpio_cleanup(struct archive_read * a)949 archive_read_format_cpio_cleanup(struct archive_read *a)
950 {
951 struct cpio *cpio;
952
953 cpio = (struct cpio *)(a->format->data);
954 /* Free inode->name map */
955 while (cpio->links_head != NULL) {
956 struct links_entry *lp = cpio->links_head->next;
957
958 if (cpio->links_head->name)
959 free(cpio->links_head->name);
960 free(cpio->links_head);
961 cpio->links_head = lp;
962 }
963 free(cpio);
964 (a->format->data) = NULL;
965 return (ARCHIVE_OK);
966 }
967
968 static int64_t
le4(const unsigned char * p)969 le4(const unsigned char *p)
970 {
971 return ((p[0] << 16) + (((int64_t)p[1]) << 24) + (p[2] << 0) + (p[3] << 8));
972 }
973
974
975 static int64_t
be4(const unsigned char * p)976 be4(const unsigned char *p)
977 {
978 return ((((int64_t)p[0]) << 24) + (p[1] << 16) + (p[2] << 8) + (p[3]));
979 }
980
981 /*
982 * Note that this implementation does not (and should not!) obey
983 * locale settings; you cannot simply substitute strtol here, since
984 * it does obey locale.
985 */
986 static int64_t
atol8(const char * p,unsigned char_cnt)987 atol8(const char *p, unsigned char_cnt)
988 {
989 int64_t l;
990 int digit;
991
992 l = 0;
993 while (char_cnt-- > 0) {
994 if (*p >= '0' && *p <= '7')
995 digit = *p - '0';
996 else
997 return (l);
998 p++;
999 l <<= 3;
1000 l |= digit;
1001 }
1002 return (l);
1003 }
1004
1005 static int64_t
atol16(const char * p,unsigned char_cnt)1006 atol16(const char *p, unsigned char_cnt)
1007 {
1008 int64_t l;
1009 int digit;
1010
1011 l = 0;
1012 while (char_cnt-- > 0) {
1013 if (*p >= 'a' && *p <= 'f')
1014 digit = *p - 'a' + 10;
1015 else if (*p >= 'A' && *p <= 'F')
1016 digit = *p - 'A' + 10;
1017 else if (*p >= '0' && *p <= '9')
1018 digit = *p - '0';
1019 else
1020 return (l);
1021 p++;
1022 l <<= 4;
1023 l |= digit;
1024 }
1025 return (l);
1026 }
1027
1028 static int
record_hardlink(struct archive_read * a,struct cpio * cpio,struct archive_entry * entry)1029 record_hardlink(struct archive_read *a,
1030 struct cpio *cpio, struct archive_entry *entry)
1031 {
1032 struct links_entry *le;
1033 dev_t dev;
1034 int64_t ino;
1035
1036 if (archive_entry_nlink(entry) <= 1)
1037 return (ARCHIVE_OK);
1038
1039 dev = archive_entry_dev(entry);
1040 ino = archive_entry_ino64(entry);
1041
1042 /*
1043 * First look in the list of multiply-linked files. If we've
1044 * already dumped it, convert this entry to a hard link entry.
1045 */
1046 for (le = cpio->links_head; le; le = le->next) {
1047 if (le->dev == dev && le->ino == ino) {
1048 archive_entry_copy_hardlink(entry, le->name);
1049
1050 if (--le->links <= 0) {
1051 if (le->previous != NULL)
1052 le->previous->next = le->next;
1053 if (le->next != NULL)
1054 le->next->previous = le->previous;
1055 if (cpio->links_head == le)
1056 cpio->links_head = le->next;
1057 free(le->name);
1058 free(le);
1059 }
1060
1061 return (ARCHIVE_OK);
1062 }
1063 }
1064
1065 le = (struct links_entry *)malloc(sizeof(struct links_entry));
1066 if (le == NULL) {
1067 archive_set_error(&a->archive,
1068 ENOMEM, "Out of memory adding file to list");
1069 return (ARCHIVE_FATAL);
1070 }
1071 if (cpio->links_head != NULL)
1072 cpio->links_head->previous = le;
1073 le->next = cpio->links_head;
1074 le->previous = NULL;
1075 cpio->links_head = le;
1076 le->dev = dev;
1077 le->ino = ino;
1078 le->links = archive_entry_nlink(entry) - 1;
1079 le->name = strdup(archive_entry_pathname(entry));
1080 if (le->name == NULL) {
1081 archive_set_error(&a->archive,
1082 ENOMEM, "Out of memory adding file to list");
1083 return (ARCHIVE_FATAL);
1084 }
1085
1086 return (ARCHIVE_OK);
1087 }
1088