Import libarchive and bsdtar. The default tar (/usr/bin/tar) can be choosen
[dragonfly.git] / contrib / libarchive / archive_read_support_format_tar.c
1 /*-
2  * Copyright (c) 2003-2004 Tim Kientzle
3  * All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer
10  *    in this position and unchanged.
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: src/lib/libarchive/archive_read_support_format_tar.c,v 1.28 2004/10/27 05:15:23 kientzle Exp $");
29
30 #include <sys/stat.h>
31 #include <errno.h>
32 /* #include <stdint.h> */ /* See archive_platform.h */
33 #include <stdlib.h>
34 #include <string.h>
35 #include <unistd.h>
36
37 #include "archive.h"
38 #include "archive_entry.h"
39 #include "archive_private.h"
40
41 /*
42  * Layout of POSIX 'ustar' tar header.
43  */
44 struct archive_entry_header_ustar {
45         char    name[100];
46         char    mode[8];
47         char    uid[8];
48         char    gid[8];
49         char    size[12];
50         char    mtime[12];
51         char    checksum[8];
52         char    typeflag[1];
53         char    linkname[100];  /* "old format" header ends here */
54         char    magic[6];       /* For POSIX: "ustar\0" */
55         char    version[2];     /* For POSIX: "00" */
56         char    uname[32];
57         char    gname[32];
58         char    rdevmajor[8];
59         char    rdevminor[8];
60         char    prefix[155];
61 };
62
63 /*
64  * Structure of GNU tar header
65  */
66 struct gnu_sparse {
67         char    offset[12];
68         char    numbytes[12];
69 };
70
71 struct archive_entry_header_gnutar {
72         char    name[100];
73         char    mode[8];
74         char    uid[8];
75         char    gid[8];
76         char    size[12];
77         char    mtime[12];
78         char    checksum[8];
79         char    typeflag[1];
80         char    linkname[100];
81         char    magic[8];  /* "ustar  \0" (note blank/blank/null at end) */
82         char    uname[32];
83         char    gname[32];
84         char    rdevmajor[8];
85         char    rdevminor[8];
86         char    atime[12];
87         char    ctime[12];
88         char    offset[12];
89         char    longnames[4];
90         char    unused[1];
91         struct gnu_sparse sparse[4];
92         char    isextended[1];
93         char    realsize[12];
94         /*
95          * GNU doesn't use POSIX 'prefix' field; they use the 'L' (longname)
96          * entry instead.
97          */
98 };
99
100 /*
101  * Data specific to this format.
102  */
103 struct sparse_block {
104         struct sparse_block     *next;
105         off_t   offset;
106         off_t   remaining;
107 };
108
109 struct tar {
110         struct archive_string    acl_text;
111         struct archive_string    entry_name;
112         struct archive_string    entry_linkname;
113         struct archive_string    entry_uname;
114         struct archive_string    entry_gname;
115         struct archive_string    longlink;
116         struct archive_string    longname;
117         struct archive_string    pax_header;
118         struct archive_string    pax_global;
119         wchar_t                 *pax_entry;
120         size_t                   pax_entry_length;
121         int                      header_recursion_depth;
122         off_t                    entry_bytes_remaining;
123         off_t                    entry_offset;
124         off_t                    entry_padding;
125         struct sparse_block     *sparse_list;
126 };
127
128 static size_t   UTF8_mbrtowc(wchar_t *pwc, const char *s, size_t n);
129 static int      archive_block_is_null(const unsigned char *p);
130 int             gnu_read_sparse_data(struct archive *, struct tar *,
131                     const struct archive_entry_header_gnutar *header);
132 void            gnu_parse_sparse_data(struct archive *, struct tar *,
133                     const struct gnu_sparse *sparse, int length);
134 static int      header_Solaris_ACL(struct archive *,  struct tar *,
135                     struct archive_entry *, struct stat *, const void *);
136 static int      header_common(struct archive *,  struct tar *,
137                     struct archive_entry *, struct stat *, const void *);
138 static int      header_old_tar(struct archive *, struct tar *,
139                     struct archive_entry *, struct stat *, const void *);
140 static int      header_pax_extensions(struct archive *, struct tar *,
141                     struct archive_entry *, struct stat *, const void *);
142 static int      header_pax_global(struct archive *, struct tar *,
143                     struct archive_entry *, struct stat *, const void *h);
144 static int      header_longlink(struct archive *, struct tar *,
145                     struct archive_entry *, struct stat *, const void *h);
146 static int      header_longname(struct archive *, struct tar *,
147                     struct archive_entry *, struct stat *, const void *h);
148 static int      header_volume(struct archive *, struct tar *,
149                     struct archive_entry *, struct stat *, const void *h);
150 static int      header_ustar(struct archive *, struct tar *,
151                     struct archive_entry *, struct stat *, const void *h);
152 static int      header_gnutar(struct archive *, struct tar *,
153                     struct archive_entry *, struct stat *, const void *h);
154 static int      archive_read_format_tar_bid(struct archive *);
155 static int      archive_read_format_tar_cleanup(struct archive *);
156 static int      archive_read_format_tar_read_data(struct archive *a,
157                     const void **buff, size_t *size, off_t *offset);
158 static int      archive_read_format_tar_read_header(struct archive *,
159                     struct archive_entry *);
160 static int      checksum(struct archive *, const void *);
161 static int      pax_attribute(struct archive_entry *, struct stat *,
162                     wchar_t *key, wchar_t *value);
163 static int      pax_header(struct archive *, struct tar *,
164                     struct archive_entry *, struct stat *, char *attr);
165 static void     pax_time(const wchar_t *, int64_t *sec, long *nanos);
166 static int      read_body_to_string(struct archive *, struct tar *,
167                     struct archive_string *, const void *h);
168 static int64_t  tar_atol(const char *, unsigned);
169 static int64_t  tar_atol10(const wchar_t *, unsigned);
170 static int64_t  tar_atol256(const char *, unsigned);
171 static int64_t  tar_atol8(const char *, unsigned);
172 static int      tar_read_header(struct archive *, struct tar *,
173                     struct archive_entry *, struct stat *);
174 static int      utf8_decode(wchar_t *, const char *, size_t length);
175
176 /*
177  * ANSI C99 defines constants for these, but not everyone supports
178  * those constants, so I define a couple of static variables here and
179  * compute the values.  These calculations should be portable to any
180  * 2s-complement architecture.
181  */
182 #ifdef UINT64_MAX
183 static const uint64_t max_uint64 = UINT64_MAX;
184 #else
185 static const uint64_t max_uint64 = ~(uint64_t)0;
186 #endif
187 #ifdef INT64_MAX
188 static const int64_t max_int64 = INT64_MAX;
189 #else
190 static const int64_t max_int64 = (int64_t)((~(uint64_t)0) >> 1);
191 #endif
192 #ifdef INT64_MIN
193 static const int64_t min_int64 = INT64_MIN;
194 #else
195 static const int64_t min_int64 = (int64_t)(~((~(uint64_t)0) >> 1));
196 #endif
197
198 int
199 archive_read_support_format_gnutar(struct archive *a)
200 {
201         return (archive_read_support_format_tar(a));
202 }
203
204
205 int
206 archive_read_support_format_tar(struct archive *a)
207 {
208         struct tar *tar;
209         int r;
210
211         tar = malloc(sizeof(*tar));
212         memset(tar, 0, sizeof(*tar));
213
214         r = __archive_read_register_format(a, tar,
215             archive_read_format_tar_bid,
216             archive_read_format_tar_read_header,
217             archive_read_format_tar_read_data,
218             archive_read_format_tar_cleanup);
219
220         if (r != ARCHIVE_OK)
221                 free(tar);
222         return (ARCHIVE_OK);
223 }
224
225 static int
226 archive_read_format_tar_cleanup(struct archive *a)
227 {
228         struct tar *tar;
229
230         tar = *(a->pformat_data);
231         archive_string_free(&tar->acl_text);
232         archive_string_free(&tar->entry_name);
233         archive_string_free(&tar->entry_linkname);
234         archive_string_free(&tar->entry_uname);
235         archive_string_free(&tar->entry_gname);
236         archive_string_free(&tar->pax_global);
237         archive_string_free(&tar->pax_header);
238         if (tar->pax_entry != NULL)
239                 free(tar->pax_entry);
240         free(tar);
241         *(a->pformat_data) = NULL;
242         return (ARCHIVE_OK);
243 }
244
245
246 static int
247 archive_read_format_tar_bid(struct archive *a)
248 {
249         int bid;
250         ssize_t bytes_read;
251         const void *h;
252         const struct archive_entry_header_ustar *header;
253
254         /*
255          * If we're already reading a non-tar file, don't
256          * bother to bid.
257          */
258         if (a->archive_format != 0 &&
259             (a->archive_format & ARCHIVE_FORMAT_BASE_MASK) !=
260             ARCHIVE_FORMAT_TAR)
261                 return (0);
262         bid = 0;
263
264         /*
265          * If we're already reading a tar format, start the bid at 1 as
266          * a failsafe.
267          */
268         if ((a->archive_format & ARCHIVE_FORMAT_BASE_MASK) ==
269             ARCHIVE_FORMAT_TAR)
270                 bid++;
271
272         /* Now let's look at the actual header and see if it matches. */
273         if (a->compression_read_ahead != NULL)
274                 bytes_read = (a->compression_read_ahead)(a, &h, 512);
275         else
276                 bytes_read = 0; /* Empty file. */
277         if (bytes_read < 0)
278                 return (ARCHIVE_FATAL);
279         if (bytes_read == 0  &&  bid > 0) {
280                 /* An archive without a proper end-of-archive marker. */
281                 /* Hold our nose and bid 1 anyway. */
282                 return (1);
283         }
284         if (bytes_read < 512) {
285                 /* If it's a new archive, then just return a zero bid. */
286                 if (bid == 0)
287                         return (0);
288                 /*
289                  * If we already know this is a tar archive,
290                  * then we have a problem.
291                  */
292                 archive_set_error(a, ARCHIVE_ERRNO_FILE_FORMAT,
293                     "Truncated tar archive");
294                 return (ARCHIVE_FATAL);
295         }
296
297         /* If it's an end-of-archive mark, we can handle it. */
298         if ((*(const char *)h) == 0 && archive_block_is_null(h))
299                 return (bid + 1);
300
301         /* If it's not an end-of-archive mark, it must have a valid checksum.*/
302         if (!checksum(a, h))
303                 return (0);
304         bid += 48;  /* Checksum is usually 6 octal digits. */
305
306         header = h;
307
308         /* Recognize POSIX formats. */
309         if ((memcmp(header->magic, "ustar\0", 6) == 0)
310             &&(memcmp(header->version, "00", 2)==0))
311                 bid += 56;
312
313         /* Recognize GNU tar format. */
314         if ((memcmp(header->magic, "ustar ", 6) == 0)
315             &&(memcmp(header->version, " \0", 2)==0))
316                 bid += 56;
317
318         /* Type flag must be null, digit or A-Z, a-z. */
319         if (header->typeflag[0] != 0 &&
320             !( header->typeflag[0] >= '0' && header->typeflag[0] <= '9') &&
321             !( header->typeflag[0] >= 'A' && header->typeflag[0] <= 'Z') &&
322             !( header->typeflag[0] >= 'a' && header->typeflag[0] <= 'z') )
323                 return (0);
324
325         /* Sanity check: Look at first byte of mode field. */
326         switch (255 & (unsigned)header->mode[0]) {
327         case 0: case 255:
328                 /* Base-256 value: No further verification possible! */
329                 break;
330         case ' ': /* Not recommended, but not illegal, either. */
331                 break;
332         case '0': case '1': case '2': case '3':
333         case '4': case '5': case '6': case '7':
334                 /* Octal Value. */
335                 /* TODO: Check format of remainder of this field. */
336                 break;
337         default:
338                 /* Not a valid mode; bail out here. */
339                 return (0);
340         }
341         /* TODO: Sanity test uid/gid/size/mtime/rdevmajor/rdevminor fields. */
342
343         return (bid);
344 }
345
346 /*
347  * The function invoked by archive_read_header().  This
348  * just sets up a few things and then calls the internal
349  * tar_read_header() function below.
350  */
351 static int
352 archive_read_format_tar_read_header(struct archive *a,
353     struct archive_entry *entry)
354 {
355         struct stat st;
356         struct tar *tar;
357         const char *p;
358         int r;
359         size_t l;
360
361         memset(&st, 0, sizeof(st));
362         tar = *(a->pformat_data);
363         tar->entry_offset = 0;
364
365         r = tar_read_header(a, tar, entry, &st);
366
367         if (r == ARCHIVE_OK) {
368                 /*
369                  * "Regular" entry with trailing '/' is really
370                  * directory: This is needed for certain old tar
371                  * variants and even for some broken newer ones.
372                  */
373                 p = archive_entry_pathname(entry);
374                 l = strlen(p);
375                 if (S_ISREG(st.st_mode) && p[l-1] == '/') {
376                         st.st_mode &= ~S_IFMT;
377                         st.st_mode |= S_IFDIR;
378                 }
379
380                 /* Copy the final stat data into the entry. */
381                 archive_entry_copy_stat(entry, &st);
382         }
383         return (r);
384 }
385
386 static int
387 archive_read_format_tar_read_data(struct archive *a,
388     const void **buff, size_t *size, off_t *offset)
389 {
390         ssize_t bytes_read;
391         struct tar *tar;
392         struct sparse_block *p;
393
394         tar = *(a->pformat_data);
395         if (tar->entry_bytes_remaining > 0) {
396                 bytes_read = (a->compression_read_ahead)(a, buff, 1);
397                 if (bytes_read <= 0)
398                         return (ARCHIVE_FATAL);
399                 if (bytes_read > tar->entry_bytes_remaining)
400                         bytes_read = tar->entry_bytes_remaining;
401                 while (tar->sparse_list != NULL &&
402                     tar->sparse_list->remaining == 0) {
403                         p = tar->sparse_list;
404                         tar->sparse_list = p->next;
405                         free(p);
406                         if (tar->sparse_list != NULL)
407                                 tar->entry_offset = tar->sparse_list->offset;
408                 }
409                 if (tar->sparse_list != NULL) {
410                         if (tar->sparse_list->remaining < bytes_read)
411                                 bytes_read = tar->sparse_list->remaining;
412                         tar->sparse_list->remaining -= bytes_read;
413                 }
414                 *size = bytes_read;
415                 *offset = tar->entry_offset;
416                 tar->entry_offset += bytes_read;
417                 tar->entry_bytes_remaining -= bytes_read;
418                 (a->compression_read_consume)(a, bytes_read);
419                 return (ARCHIVE_OK);
420         } else {
421                 while (tar->entry_padding > 0) {
422                         bytes_read = (a->compression_read_ahead)(a, buff, 1);
423                         if (bytes_read <= 0)
424                                 return (ARCHIVE_FATAL);
425                         if (bytes_read > tar->entry_padding)
426                                 bytes_read = tar->entry_padding;
427                         (a->compression_read_consume)(a, bytes_read);
428                         tar->entry_padding -= bytes_read;
429                 }
430                 *buff = NULL;
431                 *size = 0;
432                 *offset = tar->entry_offset;
433                 return (ARCHIVE_EOF);
434         }
435 }
436
437 /*
438  * This function recursively interprets all of the headers associated
439  * with a single entry.
440  */
441 static int
442 tar_read_header(struct archive *a, struct tar *tar,
443     struct archive_entry *entry, struct stat *st)
444 {
445         ssize_t bytes;
446         int err;
447         const void *h;
448         const struct archive_entry_header_ustar *header;
449
450         /* Read 512-byte header record */
451         bytes = (a->compression_read_ahead)(a, &h, 512);
452         if (bytes < 512) {
453                 /*
454                  * If we're here, it's becase the _bid function accepted
455                  * this file.  So just call a short read end-of-archive
456                  * and be done with it.
457                  */
458                 return (ARCHIVE_EOF);
459         }
460         (a->compression_read_consume)(a, 512);
461
462         /* Check for end-of-archive mark. */
463         if (((*(const char *)h)==0) && archive_block_is_null(h)) {
464                 /* Try to consume a second all-null record, as well. */
465                 bytes = (a->compression_read_ahead)(a, &h, 512);
466                 if (bytes > 0)
467                         (a->compression_read_consume)(a, bytes);
468                 archive_set_error(a, 0, NULL);
469                 return (ARCHIVE_EOF);
470         }
471
472         /*
473          * Note: If the checksum fails and we return ARCHIVE_RETRY,
474          * then the client is likely to just retry.  This is a very
475          * crude way to search for the next valid header!
476          *
477          * TODO: Improve this by implementing a real header scan.
478          */
479         if (!checksum(a, h)) {
480                 archive_set_error(a, EINVAL, "Damaged tar archive");
481                 return (ARCHIVE_RETRY); /* Retryable: Invalid header */
482         }
483
484         if (++tar->header_recursion_depth > 32) {
485                 archive_set_error(a, EINVAL, "Too many special headers");
486                 return (ARCHIVE_WARN);
487         }
488
489         /* Determine the format variant. */
490         header = h;
491         switch(header->typeflag[0]) {
492         case 'A': /* Solaris tar ACL */
493                 a->archive_format = ARCHIVE_FORMAT_TAR_PAX_INTERCHANGE;
494                 a->archive_format_name = "Solaris tar";
495                 err = header_Solaris_ACL(a, tar, entry, st, h);
496                 break;
497         case 'g': /* POSIX-standard 'g' header. */
498                 a->archive_format = ARCHIVE_FORMAT_TAR_PAX_INTERCHANGE;
499                 a->archive_format_name = "POSIX pax interchange format";
500                 err = header_pax_global(a, tar, entry, st, h);
501                 break;
502         case 'K': /* Long link name (GNU tar, others) */
503                 err = header_longlink(a, tar, entry, st, h);
504                 break;
505         case 'L': /* Long filename (GNU tar, others) */
506                 err = header_longname(a, tar, entry, st, h);
507                 break;
508         case 'V': /* GNU volume header */
509                 err = header_volume(a, tar, entry, st, h);
510                 break;
511         case 'X': /* Used by SUN tar; same as 'x'. */
512                 a->archive_format = ARCHIVE_FORMAT_TAR_PAX_INTERCHANGE;
513                 a->archive_format_name =
514                     "POSIX pax interchange format (Sun variant)";
515                 err = header_pax_extensions(a, tar, entry, st, h);
516                 break;
517         case 'x': /* POSIX-standard 'x' header. */
518                 a->archive_format = ARCHIVE_FORMAT_TAR_PAX_INTERCHANGE;
519                 a->archive_format_name = "POSIX pax interchange format";
520                 err = header_pax_extensions(a, tar, entry, st, h);
521                 break;
522         default:
523                 if (memcmp(header->magic, "ustar  \0", 8) == 0) {
524                         a->archive_format = ARCHIVE_FORMAT_TAR_GNUTAR;
525                         a->archive_format_name = "GNU tar format";
526                         err = header_gnutar(a, tar, entry, st, h);
527                 } else if (memcmp(header->magic, "ustar", 5) == 0) {
528                         if (a->archive_format != ARCHIVE_FORMAT_TAR_PAX_INTERCHANGE) {
529                                 a->archive_format = ARCHIVE_FORMAT_TAR_USTAR;
530                                 a->archive_format_name = "POSIX ustar format";
531                         }
532                         err = header_ustar(a, tar, entry, st, h);
533                 } else {
534                         a->archive_format = ARCHIVE_FORMAT_TAR;
535                         a->archive_format_name = "tar (non-POSIX)";
536                         err = header_old_tar(a, tar, entry, st, h);
537                 }
538         }
539         --tar->header_recursion_depth;
540         return (err);
541 }
542
543 /*
544  * Return true if block checksum is correct.
545  */
546 static int
547 checksum(struct archive *a, const void *h)
548 {
549         const unsigned char *bytes;
550         const struct archive_entry_header_ustar *header;
551         int check, i, sum;
552
553         (void)a; /* UNUSED */
554         bytes = h;
555         header = h;
556
557         /*
558          * Test the checksum.  Note that POSIX specifies _unsigned_
559          * bytes for this calculation.
560          */
561         sum = tar_atol(header->checksum, sizeof(header->checksum));
562         check = 0;
563         for (i = 0; i < 148; i++)
564                 check += (unsigned char)bytes[i];
565         for (; i < 156; i++)
566                 check += 32;
567         for (; i < 512; i++)
568                 check += (unsigned char)bytes[i];
569         if (sum == check)
570                 return (1);
571
572         /*
573          * Repeat test with _signed_ bytes, just in case this archive
574          * was created by an old BSD, Solaris, or HP-UX tar with a
575          * broken checksum calculation.
576          */
577         check = 0;
578         for (i = 0; i < 148; i++)
579                 check += (signed char)bytes[i];
580         for (; i < 156; i++)
581                 check += 32;
582         for (; i < 512; i++)
583                 check += (signed char)bytes[i];
584         if (sum == check)
585                 return (1);
586
587         return (0);
588 }
589
590 /*
591  * Return true if this block contains only nulls.
592  */
593 static int
594 archive_block_is_null(const unsigned char *p)
595 {
596         unsigned i;
597
598         for (i = 0; i < ARCHIVE_BYTES_PER_RECORD / sizeof(*p); i++)
599                 if (*p++)
600                         return (0);
601         return (1);
602 }
603
604 /*
605  * Interpret 'A' Solaris ACL header
606  */
607 static int
608 header_Solaris_ACL(struct archive *a, struct tar *tar,
609     struct archive_entry *entry, struct stat *st, const void *h)
610 {
611         int err, err2;
612         char *p;
613         wchar_t *wp;
614
615         err = read_body_to_string(a, tar, &(tar->acl_text), h);
616         err2 = tar_read_header(a, tar, entry, st);
617         err = err_combine(err, err2);
618
619         /* XXX Ensure p doesn't overrun acl_text */
620
621         /* Skip leading octal number. */
622         /* XXX TODO: Parse the octal number and sanity-check it. */
623         p = tar->acl_text.s;
624         while (*p != '\0')
625                 p++;
626         p++;
627
628         wp = malloc((strlen(p) + 1) * sizeof(wchar_t));
629         if (wp != NULL) {
630                 utf8_decode(wp, p, strlen(p));
631                 err2 = __archive_entry_acl_parse_w(entry, wp,
632                     ARCHIVE_ENTRY_ACL_TYPE_ACCESS);
633                 err = err_combine(err, err2);
634                 free(wp);
635         }
636
637         return (err);
638 }
639
640 /*
641  * Interpret 'K' long linkname header.
642  */
643 static int
644 header_longlink(struct archive *a, struct tar *tar,
645     struct archive_entry *entry, struct stat *st, const void *h)
646 {
647         int err, err2;
648
649         err = read_body_to_string(a, tar, &(tar->longlink), h);
650         err2 = tar_read_header(a, tar, entry, st);
651         if (err == ARCHIVE_OK && err2 == ARCHIVE_OK) {
652                 /* Set symlink if symlink already set, else hardlink. */
653                 archive_entry_set_link(entry, tar->longlink.s);
654         }
655         return (err_combine(err, err2));
656 }
657
658 /*
659  * Interpret 'L' long filename header.
660  */
661 static int
662 header_longname(struct archive *a, struct tar *tar,
663     struct archive_entry *entry, struct stat *st, const void *h)
664 {
665         int err, err2;
666
667         err = read_body_to_string(a, tar, &(tar->longname), h);
668         /* Read and parse "real" header, then override name. */
669         err2 = tar_read_header(a, tar, entry, st);
670         if (err == ARCHIVE_OK && err2 == ARCHIVE_OK)
671                 archive_entry_set_pathname(entry, tar->longname.s);
672         return (err_combine(err, err2));
673 }
674
675
676 /*
677  * Interpret 'V' GNU tar volume header.
678  */
679 static int
680 header_volume(struct archive *a, struct tar *tar,
681     struct archive_entry *entry, struct stat *st, const void *h)
682 {
683         (void)h;
684
685         /* Just skip this and read the next header. */
686         return (tar_read_header(a, tar, entry, st));
687 }
688
689 /*
690  * Read body of an archive entry into an archive_string object.
691  */
692 static int
693 read_body_to_string(struct archive *a, struct tar *tar,
694     struct archive_string *as, const void *h)
695 {
696         off_t size, padded_size;
697         ssize_t bytes_read, bytes_to_copy;
698         const struct archive_entry_header_ustar *header;
699         const void *src;
700         char *dest;
701
702         (void)tar; /* UNUSED */
703         header = h;
704         size  = tar_atol(header->size, sizeof(header->size));
705
706         /* Read the body into the string. */
707         archive_string_ensure(as, size+1);
708         padded_size = (size + 511) & ~ 511;
709         dest = as->s;
710         while (padded_size > 0) {
711                 bytes_read = (a->compression_read_ahead)(a, &src, padded_size);
712                 if (bytes_read < 0)
713                         return (ARCHIVE_FATAL);
714                 if (bytes_read > padded_size)
715                         bytes_read = padded_size;
716                 (a->compression_read_consume)(a, bytes_read);
717                 bytes_to_copy = bytes_read;
718                 if ((off_t)bytes_to_copy > size)
719                         bytes_to_copy = (ssize_t)size;
720                 memcpy(dest, src, bytes_to_copy);
721                 dest += bytes_to_copy;
722                 size -= bytes_to_copy;
723                 padded_size -= bytes_read;
724         }
725         *dest = '\0';
726         return (ARCHIVE_OK);
727 }
728
729 /*
730  * Parse out common header elements.
731  *
732  * This would be the same as header_old_tar, except that the
733  * filename is handled slightly differently for old and POSIX
734  * entries  (POSIX entries support a 'prefix').  This factoring
735  * allows header_old_tar and header_ustar
736  * to handle filenames differently, while still putting most of the
737  * common parsing into one place.
738  */
739 static int
740 header_common(struct archive *a, struct tar *tar, struct archive_entry *entry,
741     struct stat *st, const void *h)
742 {
743         const struct archive_entry_header_ustar *header;
744         char    tartype;
745
746         (void)a; /* UNUSED */
747
748         header = h;
749         if (header->linkname[0])
750                 archive_strncpy(&(tar->entry_linkname), header->linkname,
751                     sizeof(header->linkname));
752         else
753                 archive_string_empty(&(tar->entry_linkname));
754
755         /* Parse out the numeric fields (all are octal) */
756         st->st_mode  = tar_atol(header->mode, sizeof(header->mode));
757         st->st_uid   = tar_atol(header->uid, sizeof(header->uid));
758         st->st_gid   = tar_atol(header->gid, sizeof(header->gid));
759         st->st_size  = tar_atol(header->size, sizeof(header->size));
760         st->st_mtime = tar_atol(header->mtime, sizeof(header->mtime));
761
762         /* Handle the tar type flag appropriately. */
763         tartype = header->typeflag[0];
764         st->st_mode &= ~S_IFMT;
765
766         switch (tartype) {
767         case '1': /* Hard link */
768                 archive_entry_set_hardlink(entry, tar->entry_linkname.s);
769                 /*
770                  * The following may seem odd, but: Technically, tar
771                  * does not store the file type for a "hard link"
772                  * entry, only the fact that it is a hard link.  So, I
773                  * leave the type zero normally.  But, pax interchange
774                  * format allows hard links to have data, which
775                  * implies that the underlying entry is a regular
776                  * file.
777                  */
778                 if (st->st_size > 0)
779                         st->st_mode |= S_IFREG;
780
781                 /*
782                  * A tricky point: Traditionally, tar readers have
783                  * ignored the size field when reading hardlink
784                  * entries, and some writers put non-zero sizes even
785                  * though the body is empty.  POSIX.1-2001 broke with
786                  * this tradition by permitting hardlink entries to
787                  * store valid bodies in pax interchange format, but
788                  * not in ustar format.  Since there is no hard and
789                  * fast way to distinguish pax interchange from
790                  * earlier archives (the 'x' and 'g' entries are
791                  * optional, after all), we need a heuristic.  Here, I
792                  * use the bid function to test whether or not there's
793                  * a valid header following.  Of course, if we know
794                  * this is pax interchange format, then we must obey
795                  * the size.
796                  *
797                  * This heuristic will only fail for a pax interchange
798                  * archive that is storing hardlink bodies, no pax
799                  * extended attribute entries have yet occurred, and
800                  * we encounter a hardlink entry for a file that is
801                  * itself an uncompressed tar archive.
802                  */
803                 if (st->st_size > 0  &&
804                     a->archive_format != ARCHIVE_FORMAT_TAR_PAX_INTERCHANGE  &&
805                     archive_read_format_tar_bid(a) > 50)
806                         st->st_size = 0;
807                 break;
808         case '2': /* Symlink */
809                 st->st_mode |= S_IFLNK;
810                 st->st_size = 0;
811                 archive_entry_set_symlink(entry, tar->entry_linkname.s);
812                 break;
813         case '3': /* Character device */
814                 st->st_mode |= S_IFCHR;
815                 st->st_size = 0;
816                 break;
817         case '4': /* Block device */
818                 st->st_mode |= S_IFBLK;
819                 st->st_size = 0;
820                 break;
821         case '5': /* Dir */
822                 st->st_mode |= S_IFDIR;
823                 st->st_size = 0;
824                 break;
825         case '6': /* FIFO device */
826                 st->st_mode |= S_IFIFO;
827                 st->st_size = 0;
828                 break;
829         case 'D': /* GNU incremental directory type */
830                 /*
831                  * No special handling is actually required here.
832                  * It might be nice someday to preprocess the file list and
833                  * provide it to the client, though.
834                  */
835                 st->st_mode |= S_IFDIR;
836                 break;
837         case 'M': /* GNU "Multi-volume" (remainder of file from last archive)*/
838                 /*
839                  * As far as I can tell, this is just like a regular file
840                  * entry, except that the contents should be _appended_ to
841                  * the indicated file at the indicated offset.  This may
842                  * require some API work to fully support.
843                  */
844                 break;
845         case 'N': /* Old GNU "long filename" entry. */
846                 /* The body of this entry is a script for renaming
847                  * previously-extracted entries.  Ugh.  It will never
848                  * be supported by libarchive. */
849                 st->st_mode |= S_IFREG;
850                 break;
851         case 'S': /* GNU sparse files */
852                 /*
853                  * Sparse files are really just regular files with
854                  * sparse information in the extended area.
855                  */
856                 /* FALL THROUGH */
857         default: /* Regular file  and non-standard types */
858                 /*
859                  * Per POSIX: non-recognized types should always be
860                  * treated as regular files.
861                  */
862                 st->st_mode |= S_IFREG;
863                 break;
864         }
865         return (0);
866 }
867
868 /*
869  * Parse out header elements for "old-style" tar archives.
870  */
871 static int
872 header_old_tar(struct archive *a, struct tar *tar, struct archive_entry *entry,
873     struct stat *st, const void *h)
874 {
875         const struct archive_entry_header_ustar *header;
876
877         /* Copy filename over (to ensure null termination). */
878         header = h;
879         archive_strncpy(&(tar->entry_name), header->name, sizeof(header->name));
880         archive_entry_set_pathname(entry, tar->entry_name.s);
881
882         /* Grab rest of common fields */
883         header_common(a, tar, entry, st, h);
884
885         tar->entry_bytes_remaining = st->st_size;
886         tar->entry_padding = 0x1ff & (-tar->entry_bytes_remaining);
887         return (0);
888 }
889
890 /*
891  * Parse a file header for a pax extended archive entry.
892  */
893 static int
894 header_pax_global(struct archive *a, struct tar *tar,
895     struct archive_entry *entry, struct stat *st, const void *h)
896 {
897         int err, err2;
898
899         err = read_body_to_string(a, tar, &(tar->pax_global), h);
900         err2 = tar_read_header(a, tar, entry, st);
901         return (err_combine(err, err2));
902 }
903
904 static int
905 header_pax_extensions(struct archive *a, struct tar *tar,
906     struct archive_entry *entry, struct stat *st, const void *h)
907 {
908         int err, err2;
909
910         read_body_to_string(a, tar, &(tar->pax_header), h);
911
912         /* Parse the next header. */
913         err = tar_read_header(a, tar, entry, st);
914
915         /*
916          * TODO: Parse global/default options into 'entry' struct here
917          * before handling file-specific options.
918          *
919          * This design (parse standard header, then overwrite with pax
920          * extended attribute data) usually works well, but isn't ideal;
921          * it would be better to parse the pax extended attributes first
922          * and then skip any fields in the standard header that were
923          * defined in the pax header.
924          */
925         err2 = pax_header(a, tar, entry, st, tar->pax_header.s);
926         err =  err_combine(err, err2);
927         tar->entry_bytes_remaining = st->st_size;
928         tar->entry_padding = 0x1ff & (-tar->entry_bytes_remaining);
929         return (err);
930 }
931
932
933 /*
934  * Parse a file header for a Posix "ustar" archive entry.  This also
935  * handles "pax" or "extended ustar" entries.
936  */
937 static int
938 header_ustar(struct archive *a, struct tar *tar, struct archive_entry *entry,
939     struct stat *st, const void *h)
940 {
941         const struct archive_entry_header_ustar *header;
942         struct archive_string *as;
943
944         header = h;
945
946         /* Copy name into an internal buffer to ensure null-termination. */
947         as = &(tar->entry_name);
948         if (header->prefix[0]) {
949                 archive_strncpy(as, header->prefix, sizeof(header->prefix));
950                 if (as->s[archive_strlen(as) - 1] != '/')
951                         archive_strappend_char(as, '/');
952                 archive_strncat(as, header->name, sizeof(header->name));
953         } else
954                 archive_strncpy(as, header->name, sizeof(header->name));
955
956         archive_entry_set_pathname(entry, as->s);
957
958         /* Handle rest of common fields. */
959         header_common(a, tar, entry, st, h);
960
961         /* Handle POSIX ustar fields. */
962         archive_strncpy(&(tar->entry_uname), header->uname,
963             sizeof(header->uname));
964         archive_entry_set_uname(entry, tar->entry_uname.s);
965
966         archive_strncpy(&(tar->entry_gname), header->gname,
967             sizeof(header->gname));
968         archive_entry_set_gname(entry, tar->entry_gname.s);
969
970         /* Parse out device numbers only for char and block specials. */
971         if (header->typeflag[0] == '3' || header->typeflag[0] == '4') {
972                 st->st_rdev = makedev(
973                     tar_atol(header->rdevmajor, sizeof(header->rdevmajor)),
974                     tar_atol(header->rdevminor, sizeof(header->rdevminor)));
975         }
976
977         tar->entry_bytes_remaining = st->st_size;
978         tar->entry_padding = 0x1ff & (-tar->entry_bytes_remaining);
979
980         return (0);
981 }
982
983
984 /*
985  * Parse the pax extended attributes record.
986  *
987  * Returns non-zero if there's an error in the data.
988  */
989 static int
990 pax_header(struct archive *a, struct tar *tar, struct archive_entry *entry,
991     struct stat *st, char *attr)
992 {
993         size_t attr_length, l, line_length;
994         char *line, *p;
995         wchar_t *key, *wp, *value;
996         int err, err2;
997
998         attr_length = strlen(attr);
999         err = ARCHIVE_OK;
1000         while (attr_length > 0) {
1001                 /* Parse decimal length field at start of line. */
1002                 line_length = 0;
1003                 l = attr_length;
1004                 line = p = attr; /* Record start of line. */
1005                 while (l>0) {
1006                         if (*p == ' ') {
1007                                 p++;
1008                                 l--;
1009                                 break;
1010                         }
1011                         if (*p < '0' || *p > '9')
1012                                 return (-1);
1013                         line_length *= 10;
1014                         line_length += *p - '0';
1015                         if (line_length > 999999)
1016                                 return (-1);
1017                         p++;
1018                         l--;
1019                 }
1020
1021                 if (line_length > attr_length)
1022                         return (0);
1023
1024                 /* Ensure pax_entry buffer is big enough. */
1025                 if (tar->pax_entry_length <= line_length) {
1026                         if (tar->pax_entry_length <= 0)
1027                                 tar->pax_entry_length = 1024;
1028                         while (tar->pax_entry_length <= line_length + 1)
1029                                 tar->pax_entry_length *= 2;
1030
1031                         /* XXX Error handling here */
1032                         tar->pax_entry = realloc(tar->pax_entry,
1033                             tar->pax_entry_length * sizeof(wchar_t));
1034                 }
1035
1036                 /* Decode UTF-8 to wchar_t, null-terminate result. */
1037                 if (utf8_decode(tar->pax_entry, p,
1038                         line_length - (p - attr) - 1)) {
1039                         archive_set_error(a, ARCHIVE_ERRNO_MISC,
1040                            "Invalid UTF8 character in pax extended attribute");
1041                         err = err_combine(err, ARCHIVE_WARN);
1042                 }
1043
1044                 /* Null-terminate 'key' value. */
1045                 key = tar->pax_entry;
1046                 if (key[0] == L'=')
1047                         return (-1);
1048                 wp = wcschr(key, L'=');
1049                 if (wp == NULL) {
1050                         archive_set_error(a, ARCHIVE_ERRNO_MISC,
1051                             "Invalid pax extended attributes");
1052                         return (ARCHIVE_WARN);
1053                 }
1054                 *wp = 0;
1055
1056                 /* Identify null-terminated 'value' portion. */
1057                 value = wp + 1;
1058
1059                 /* Identify this attribute and set it in the entry. */
1060                 err2 = pax_attribute(entry, st, key, value);
1061                 err = err_combine(err, err2);
1062
1063                 /* Skip to next line */
1064                 attr += line_length;
1065                 attr_length -= line_length;
1066         }
1067         return (err);
1068 }
1069
1070
1071
1072 /*
1073  * Parse a single key=value attribute.  key/value pointers are
1074  * assumed to point into reasonably long-lived storage.
1075  *
1076  * Note that POSIX reserves all-lowercase keywords.  Vendor-specific
1077  * extensions should always have keywords of the form "VENDOR.attribute"
1078  * In particular, it's quite feasible to support many different
1079  * vendor extensions here.  I'm using "LIBARCHIVE" for extensions
1080  * unique to this library (currently, there are none).
1081  *
1082  * Investigate other vendor-specific extensions, as well and see if
1083  * any of them look useful.
1084  */
1085 static int
1086 pax_attribute(struct archive_entry *entry, struct stat *st,
1087     wchar_t *key, wchar_t *value)
1088 {
1089         int64_t s;
1090         long n;
1091
1092         switch (key[0]) {
1093         case 'L':
1094                 /* Our extensions */
1095 /* TODO: Handle arbitrary extended attributes... */
1096 /*
1097                 if (strcmp(key, "LIBARCHIVE.xxxxxxx")==0)
1098                         archive_entry_set_xxxxxx(entry, value);
1099 */
1100                 break;
1101         case 'S':
1102                 /* We support some keys used by the "star" archiver */
1103                 if (wcscmp(key, L"SCHILY.acl.access")==0)
1104                         __archive_entry_acl_parse_w(entry, value,
1105                             ARCHIVE_ENTRY_ACL_TYPE_ACCESS);
1106                 else if (wcscmp(key, L"SCHILY.acl.default")==0)
1107                         __archive_entry_acl_parse_w(entry, value,
1108                             ARCHIVE_ENTRY_ACL_TYPE_DEFAULT);
1109                 else if (wcscmp(key, L"SCHILY.devmajor")==0)
1110                         st->st_rdev = makedev(tar_atol10(value, wcslen(value)),
1111                             minor(st->st_rdev));
1112                 else if (wcscmp(key, L"SCHILY.devminor")==0)
1113                         st->st_rdev = makedev(major(st->st_rdev),
1114                             tar_atol10(value, wcslen(value)));
1115                 else if (wcscmp(key, L"SCHILY.fflags")==0)
1116                         archive_entry_copy_fflags_text_w(entry, value);
1117                 else if (wcscmp(key, L"SCHILY.nlink")==0)
1118                         st->st_nlink = tar_atol10(value, wcslen(value));
1119                 break;
1120         case 'a':
1121                 if (wcscmp(key, L"atime")==0) {
1122                         pax_time(value, &s, &n);
1123                         st->st_atime = s;
1124                         ARCHIVE_STAT_SET_ATIME_NANOS(st, n);
1125                 }
1126                 break;
1127         case 'c':
1128                 if (wcscmp(key, L"ctime")==0) {
1129                         pax_time(value, &s, &n);
1130                         st->st_ctime = s;
1131                         ARCHIVE_STAT_SET_CTIME_NANOS(st, n);
1132                 } else if (wcscmp(key, L"charset")==0) {
1133                         /* TODO: Publish charset information in entry. */
1134                 } else if (wcscmp(key, L"comment")==0) {
1135                         /* TODO: Publish comment in entry. */
1136                 }
1137                 break;
1138         case 'g':
1139                 if (wcscmp(key, L"gid")==0)
1140                         st->st_gid = tar_atol10(value, wcslen(value));
1141                 else if (wcscmp(key, L"gname")==0)
1142                         archive_entry_copy_gname_w(entry, value);
1143                 break;
1144         case 'l':
1145                 /* pax interchange doesn't distinguish hardlink vs. symlink. */
1146                 if (wcscmp(key, L"linkpath")==0) {
1147                         if (archive_entry_hardlink(entry))
1148                                 archive_entry_copy_hardlink_w(entry, value);
1149                         else
1150                                 archive_entry_copy_symlink_w(entry, value);
1151                 }
1152                 break;
1153         case 'm':
1154                 if (wcscmp(key, L"mtime")==0) {
1155                         pax_time(value, &s, &n);
1156                         st->st_mtime = s;
1157                         ARCHIVE_STAT_SET_MTIME_NANOS(st, n);
1158                 }
1159                 break;
1160         case 'p':
1161                 if (wcscmp(key, L"path")==0)
1162                         archive_entry_copy_pathname_w(entry, value);
1163                 break;
1164         case 'r':
1165                 /* POSIX has reserved 'realtime.*' */
1166                 break;
1167         case 's':
1168                 /* POSIX has reserved 'security.*' */
1169                 /* Someday: if (wcscmp(key, L"security.acl")==0) { ... } */
1170                 if (wcscmp(key, L"size")==0)
1171                         st->st_size = tar_atol10(value, wcslen(value));
1172                 break;
1173         case 'u':
1174                 if (wcscmp(key, L"uid")==0)
1175                         st->st_uid = tar_atol10(value, wcslen(value));
1176                 else if (wcscmp(key, L"uname")==0)
1177                         archive_entry_copy_uname_w(entry, value);
1178                 break;
1179         }
1180         return (0);
1181 }
1182
1183
1184
1185 /*
1186  * parse a decimal time value, which may include a fractional portion
1187  */
1188 static void
1189 pax_time(const wchar_t *p, int64_t *ps, long *pn)
1190 {
1191         char digit;
1192         int64_t s;
1193         unsigned long l;
1194         int sign;
1195         int64_t limit, last_digit_limit;
1196
1197         limit = max_int64 / 10;
1198         last_digit_limit = max_int64 % 10;
1199
1200         s = 0;
1201         sign = 1;
1202         if (*p == '-') {
1203                 sign = -1;
1204                 p++;
1205         }
1206         while (*p >= '0' && *p <= '9') {
1207                 digit = *p - '0';
1208                 if (s > limit ||
1209                     (s == limit && digit > last_digit_limit)) {
1210                         s = max_uint64;
1211                         break;
1212                 }
1213                 s = (s * 10) + digit;
1214                 ++p;
1215         }
1216
1217         *ps = s * sign;
1218
1219         /* Calculate nanoseconds. */
1220         *pn = 0;
1221
1222         if (*p != '.')
1223                 return;
1224
1225         l = 100000000UL;
1226         do {
1227                 ++p;
1228                 if (*p >= '0' && *p <= '9')
1229                         *pn += (*p - '0') * l;
1230                 else
1231                         break;
1232         } while (l /= 10);
1233 }
1234
1235 /*
1236  * Parse GNU tar header
1237  */
1238 static int
1239 header_gnutar(struct archive *a, struct tar *tar, struct archive_entry *entry,
1240     struct stat *st, const void *h)
1241 {
1242         const struct archive_entry_header_gnutar *header;
1243
1244         (void)a;
1245
1246         /*
1247          * GNU header is like POSIX ustar, except 'prefix' is
1248          * replaced with some other fields. This also means the
1249          * filename is stored as in old-style archives.
1250          */
1251
1252         /* Grab fields common to all tar variants. */
1253         header_common(a, tar, entry, st, h);
1254
1255         /* Copy filename over (to ensure null termination). */
1256         header = h;
1257         archive_strncpy(&(tar->entry_name), header->name,
1258             sizeof(header->name));
1259         archive_entry_set_pathname(entry, tar->entry_name.s);
1260
1261         /* Fields common to ustar and GNU */
1262         /* XXX Can the following be factored out since it's common
1263          * to ustar and gnu tar?  Is it okay to move it down into
1264          * header_common, perhaps?  */
1265         archive_strncpy(&(tar->entry_uname),
1266             header->uname, sizeof(header->uname));
1267         archive_entry_set_uname(entry, tar->entry_uname.s);
1268
1269         archive_strncpy(&(tar->entry_gname),
1270             header->gname, sizeof(header->gname));
1271         archive_entry_set_gname(entry, tar->entry_gname.s);
1272
1273         /* Parse out device numbers only for char and block specials */
1274         if (header->typeflag[0] == '3' || header->typeflag[0] == '4')
1275                 st->st_rdev = makedev (
1276                     tar_atol(header->rdevmajor, sizeof(header->rdevmajor)),
1277                     tar_atol(header->rdevminor, sizeof(header->rdevminor)));
1278         else
1279                 st->st_rdev = 0;
1280
1281         tar->entry_bytes_remaining = st->st_size;
1282         tar->entry_padding = 0x1ff & (-tar->entry_bytes_remaining);
1283
1284         /* Grab GNU-specific fields. */
1285         st->st_atime = tar_atol(header->atime, sizeof(header->atime));
1286         st->st_ctime = tar_atol(header->ctime, sizeof(header->ctime));
1287         if (header->realsize[0] != 0) {
1288                 st->st_size = tar_atol(header->realsize,
1289                     sizeof(header->realsize));
1290         }
1291
1292         if (header->sparse[0].offset[0] != 0) {
1293                 gnu_read_sparse_data(a, tar, header);
1294         } else {
1295                 if (header->isextended[0] != 0) {
1296                         /* XXX WTF? XXX */
1297                 }
1298         }
1299
1300         return (0);
1301 }
1302
1303 int
1304 gnu_read_sparse_data(struct archive *a, struct tar *tar,
1305     const struct archive_entry_header_gnutar *header)
1306 {
1307         ssize_t bytes_read;
1308         const void *data;
1309         struct extended {
1310                 struct gnu_sparse sparse[21];
1311                 char    isextended[1];
1312                 char    padding[7];
1313         };
1314         const struct extended *ext;
1315
1316         gnu_parse_sparse_data(a, tar, header->sparse, 4);
1317         if (header->isextended[0] == 0)
1318                 return (ARCHIVE_OK);
1319
1320         do {
1321                 bytes_read = (a->compression_read_ahead)(a, &data, 512);
1322                 if (bytes_read < 0)
1323                         return (ARCHIVE_FATAL);
1324                 if (bytes_read < 512) {
1325                         archive_set_error(a, ARCHIVE_ERRNO_FILE_FORMAT,
1326                             "Truncated tar archive "
1327                             "detected while reading sparse file data");
1328                         return (ARCHIVE_FATAL);
1329                 }
1330                 (a->compression_read_consume)(a, 512);
1331                 ext = (const struct extended *)data;
1332                 gnu_parse_sparse_data(a, tar, ext->sparse, 21);
1333         } while (ext->isextended[0] != 0);
1334         if (tar->sparse_list != NULL)
1335                 tar->entry_offset = tar->sparse_list->offset;
1336         return (ARCHIVE_OK);
1337 }
1338
1339 void
1340 gnu_parse_sparse_data(struct archive *a, struct tar *tar,
1341     const struct gnu_sparse *sparse, int length)
1342 {
1343         struct sparse_block *last;
1344         struct sparse_block *p;
1345
1346         (void)a; /* UNUSED */
1347
1348         last = tar->sparse_list;
1349         while (last != NULL && last->next != NULL)
1350                 last = last->next;
1351
1352         while (length > 0 && sparse->offset[0] != 0) {
1353                 p = malloc(sizeof(*p));
1354                 memset(p, 0, sizeof(*p));
1355                 if (last != NULL)
1356                         last->next = p;
1357                 else
1358                         tar->sparse_list = p;
1359                 last = p;
1360                 p->offset = tar_atol(sparse->offset, sizeof(sparse->offset));
1361                 p->remaining =
1362                     tar_atol(sparse->numbytes, sizeof(sparse->numbytes));
1363                 sparse++;
1364                 length--;
1365         }
1366 }
1367
1368 /*-
1369  * Convert text->integer.
1370  *
1371  * Traditional tar formats (including POSIX) specify base-8 for
1372  * all of the standard numeric fields.  This is a significant limitation
1373  * in practice:
1374  *   = file size is limited to 8GB
1375  *   = rdevmajor and rdevminor are limited to 21 bits
1376  *   = uid/gid are limited to 21 bits
1377  *
1378  * There are two workarounds for this:
1379  *   = pax extended headers, which use variable-length string fields
1380  *   = GNU tar and STAR both allow either base-8 or base-256 in
1381  *      most fields.  The high bit is set to indicate base-256.
1382  *
1383  * On read, this implementation supports both extensions.
1384  */
1385 static int64_t
1386 tar_atol(const char *p, unsigned char_cnt)
1387 {
1388         /*
1389          * Technically, GNU tar considers a field to be in base-256
1390          * only if the first byte is 0xff or 0x80.
1391          */
1392         if (*p & 0x80)
1393                 return (tar_atol256(p, char_cnt));
1394         return (tar_atol8(p, char_cnt));
1395 }
1396
1397 /*
1398  * Note that this implementation does not (and should not!) obey
1399  * locale settings; you cannot simply substitute strtol here, since
1400  * it does obey locale.
1401  */
1402 static int64_t
1403 tar_atol8(const char *p, unsigned char_cnt)
1404 {
1405         int64_t l, limit, last_digit_limit;
1406         int digit, sign, base;
1407
1408         base = 8;
1409         limit = max_int64 / base;
1410         last_digit_limit = max_int64 % base;
1411
1412         while (*p == ' ' || *p == '\t')
1413                 p++;
1414         if (*p == '-') {
1415                 sign = -1;
1416                 p++;
1417         } else
1418                 sign = 1;
1419
1420         l = 0;
1421         digit = *p - '0';
1422         while (digit >= 0 && digit < base  && char_cnt-- > 0) {
1423                 if (l>limit || (l == limit && digit > last_digit_limit)) {
1424                         l = max_uint64; /* Truncate on overflow. */
1425                         break;
1426                 }
1427                 l = (l * base) + digit;
1428                 digit = *++p - '0';
1429         }
1430         return (sign < 0) ? -l : l;
1431 }
1432
1433
1434 /*
1435  * Note that this implementation does not (and should not!) obey
1436  * locale settings; you cannot simply substitute strtol here, since
1437  * it does obey locale.
1438  */
1439 static int64_t
1440 tar_atol10(const wchar_t *p, unsigned char_cnt)
1441 {
1442         int64_t l, limit, last_digit_limit;
1443         int base, digit, sign;
1444
1445         base = 10;
1446         limit = max_int64 / base;
1447         last_digit_limit = max_int64 % base;
1448
1449         while (*p == ' ' || *p == '\t')
1450                 p++;
1451         if (*p == '-') {
1452                 sign = -1;
1453                 p++;
1454         } else
1455                 sign = 1;
1456
1457         l = 0;
1458         digit = *p - '0';
1459         while (digit >= 0 && digit < base  && char_cnt-- > 0) {
1460                 if (l > limit || (l == limit && digit > last_digit_limit)) {
1461                         l = max_uint64; /* Truncate on overflow. */
1462                         break;
1463                 }
1464                 l = (l * base) + digit;
1465                 digit = *++p - '0';
1466         }
1467         return (sign < 0) ? -l : l;
1468 }
1469
1470 /*
1471  * Parse a base-256 integer.  This is just a straight signed binary
1472  * value in big-endian order, except that the high-order bit is
1473  * ignored.  Remember that "int64_t" may or may not be exactly 64
1474  * bits; the implementation here tries to avoid making any assumptions
1475  * about the actual size of an int64_t.  It does assume we're using
1476  * twos-complement arithmetic, though.
1477  */
1478 static int64_t
1479 tar_atol256(const char *_p, unsigned char_cnt)
1480 {
1481         int64_t l, upper_limit, lower_limit;
1482         const unsigned char *p = _p;
1483
1484         upper_limit = max_int64 / 256;
1485         lower_limit = min_int64 / 256;
1486
1487         /* Pad with 1 or 0 bits, depending on sign. */
1488         if ((0x40 & *p) == 0x40)
1489                 l = (int64_t)-1;
1490         else
1491                 l = 0;
1492         l = (l << 6) | (0x3f & *p++);
1493         while (--char_cnt > 0) {
1494                 if (l > upper_limit) {
1495                         l = max_int64; /* Truncate on overflow */
1496                         break;
1497                 } else if (l < lower_limit) {
1498                         l = min_int64;
1499                         break;
1500                 }
1501                 l = (l << 8) | (0xff & (int64_t)*p++);
1502         }
1503         return (l);
1504 }
1505
1506 static int
1507 utf8_decode(wchar_t *dest, const char *src, size_t length)
1508 {
1509         size_t n;
1510         int err;
1511
1512         err = 0;
1513         while(length > 0) {
1514                 n = UTF8_mbrtowc(dest, src, length);
1515                 if (n == 0)
1516                         break;
1517                 if (n > 8) {
1518                         /* Invalid byte encountered; try to keep going. */
1519                         *dest = L'?';
1520                         n = 1;
1521                         err = 1;
1522                 }
1523                 dest++;
1524                 src += n;
1525                 length -= n;
1526         }
1527         *dest++ = L'\0';
1528         return (err);
1529 }
1530
1531 /*
1532  * Copied from FreeBSD libc/locale.
1533  */
1534 static size_t
1535 UTF8_mbrtowc(wchar_t *pwc, const char *s, size_t n)
1536 {
1537         int ch, i, len, mask;
1538         unsigned long lbound, wch;
1539
1540         if (s == NULL)
1541                 /* Reset to initial shift state (no-op) */
1542                 return (0);
1543         if (n == 0)
1544                 /* Incomplete multibyte sequence */
1545                 return ((size_t)-2);
1546
1547         /*
1548          * Determine the number of octets that make up this character from
1549          * the first octet, and a mask that extracts the interesting bits of
1550          * the first octet.
1551          *
1552          * We also specify a lower bound for the character code to detect
1553          * redundant, non-"shortest form" encodings. For example, the
1554          * sequence C0 80 is _not_ a legal representation of the null
1555          * character. This enforces a 1-to-1 mapping between character
1556          * codes and their multibyte representations.
1557          */
1558         ch = (unsigned char)*s;
1559         if ((ch & 0x80) == 0) {
1560                 mask = 0x7f;
1561                 len = 1;
1562                 lbound = 0;
1563         } else if ((ch & 0xe0) == 0xc0) {
1564                 mask = 0x1f;
1565                 len = 2;
1566                 lbound = 0x80;
1567         } else if ((ch & 0xf0) == 0xe0) {
1568                 mask = 0x0f;
1569                 len = 3;
1570                 lbound = 0x800;
1571         } else if ((ch & 0xf8) == 0xf0) {
1572                 mask = 0x07;
1573                 len = 4;
1574                 lbound = 0x10000;
1575         } else if ((ch & 0xfc) == 0xf8) {
1576                 mask = 0x03;
1577                 len = 5;
1578                 lbound = 0x200000;
1579         } else if ((ch & 0xfc) == 0xfc) {
1580                 mask = 0x01;
1581                 len = 6;
1582                 lbound = 0x4000000;
1583         } else {
1584                 /*
1585                  * Malformed input; input is not UTF-8.
1586                  */
1587                 errno = EILSEQ;
1588                 return ((size_t)-1);
1589         }
1590
1591         if (n < (size_t)len)
1592                 /* Incomplete multibyte sequence */
1593                 return ((size_t)-2);
1594
1595         /*
1596          * Decode the octet sequence representing the character in chunks
1597          * of 6 bits, most significant first.
1598          */
1599         wch = (unsigned char)*s++ & mask;
1600         i = len;
1601         while (--i != 0) {
1602                 if ((*s & 0xc0) != 0x80) {
1603                         /*
1604                          * Malformed input; bad characters in the middle
1605                          * of a character.
1606                          */
1607                         errno = EILSEQ;
1608                         return ((size_t)-1);
1609                 }
1610                 wch <<= 6;
1611                 wch |= *s++ & 0x3f;
1612         }
1613         if (wch < lbound) {
1614                 /*
1615                  * Malformed input; redundant encoding.
1616                  */
1617                 errno = EILSEQ;
1618                 return ((size_t)-1);
1619         }
1620         if (pwc != NULL) {
1621                 /* Assign the value to the output; out-of-range values
1622                  * just get truncated. */
1623                 *pwc = (wchar_t)wch;
1624 #ifdef WCHAR_MAX
1625                 /*
1626                  * If platform has WCHAR_MAX, we can do something
1627                  * more sensible with out-of-range values.
1628                  */
1629                 if (wch >= WCHAR_MAX)
1630                         *pwc = '?';
1631 #endif
1632         }
1633         return (wch == L'\0' ? 0 : len);
1634 }