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