Import libarchive and bsdtar. The default tar (/usr/bin/tar) can be choosen
[dragonfly.git] / contrib / libarchive / archive_write_set_format_ustar.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_write_set_format_ustar.c,v 1.12 2004/11/05 05:26:30 kientzle Exp $");
29
30 #include <sys/stat.h>
31 #include <errno.h>
32 #include <stdio.h>
33 #include <stdlib.h>
34 #include <string.h>
35
36 #include "archive.h"
37 #include "archive_entry.h"
38 #include "archive_private.h"
39
40 struct ustar {
41         uint64_t        entry_bytes_remaining;
42         uint64_t        entry_padding;
43         char            written;
44 };
45
46 /*
47  * Define structure of POSIX 'ustar' tar header.
48  */
49 struct archive_entry_header_ustar {
50         char    name[100];
51         char    mode[6];
52         char    mode_padding[2];
53         char    uid[6];
54         char    uid_padding[2];
55         char    gid[6];
56         char    gid_padding[2];
57         char    size[11];
58         char    size_padding[1];
59         char    mtime[11];
60         char    mtime_padding[1];
61         char    checksum[8];
62         char    typeflag[1];
63         char    linkname[100];
64         char    magic[6]; /* For POSIX: "ustar\0" */
65         char    version[2]; /* For POSIX: "00" */
66         char    uname[32];
67         char    gname[32];
68         char    rdevmajor[6];
69         char    rdevmajor_padding[2];
70         char    rdevminor[6];
71         char    rdevminor_padding[2];
72         char    prefix[155];
73         char    padding[12];
74 };
75
76 /*
77  * A filled-in copy of the header for initialization.
78  */
79 static const struct archive_entry_header_ustar template_header = {
80         { "" },                         /* name */
81         { "000000" }, { ' ', '\0' },    /* mode, space-null termination. */
82         { "000000" }, { ' ', '\0' },    /* uid, space-null termination. */
83         { "000000" }, { ' ', '\0' },    /* gid, space-null termination. */
84         { "00000000000" }, { ' ' },     /* size, space termination. */
85         { "00000000000" }, { ' ' },     /* mtime, space termination. */
86         { "        " },                 /* Initial checksum value. */
87         { '0' },                        /* default: regular file */
88         { "" },                         /* linkname */
89         { "ustar" },                    /* magic */
90         { '0', '0' },                   /* version */
91         { "" },                         /* uname */
92         { "" },                         /* gname */
93         { "000000" }, { ' ', '\0' },    /* rdevmajor, space-null termination */
94         { "000000" }, { ' ', '\0' },    /* rdevminor, space-null termination */
95         { "" },                         /* prefix */
96         { "" }                          /* padding */
97 };
98
99 static int      archive_write_ustar_data(struct archive *a, const void *buff,
100                     size_t s);
101 static int      archive_write_ustar_finish(struct archive *);
102 static int      archive_write_ustar_finish_entry(struct archive *);
103 static int      archive_write_ustar_header(struct archive *,
104                     struct archive_entry *entry);
105 static int      format_256(int64_t, char *, int);
106 static int      format_number(int64_t, char *, int size, int max, int strict);
107 static int      format_octal(int64_t, char *, int);
108 static int      write_nulls(struct archive *a, size_t);
109
110 /*
111  * Set output format to 'ustar' format.
112  */
113 int
114 archive_write_set_format_ustar(struct archive *a)
115 {
116         struct ustar *ustar;
117
118         /* If someone else was already registered, unregister them. */
119         if (a->format_finish != NULL)
120                 (a->format_finish)(a);
121
122         ustar = malloc(sizeof(*ustar));
123         if (ustar == NULL) {
124                 archive_set_error(a, ENOMEM, "Can't allocate ustar data");
125                 return (ARCHIVE_FATAL);
126         }
127         memset(ustar, 0, sizeof(*ustar));
128         a->format_data = ustar;
129
130         a->pad_uncompressed = 1;        /* Mimic gtar in this respect. */
131         a->format_write_header = archive_write_ustar_header;
132         a->format_write_data = archive_write_ustar_data;
133         a->format_finish = archive_write_ustar_finish;
134         a->format_finish_entry = archive_write_ustar_finish_entry;
135         a->archive_format = ARCHIVE_FORMAT_TAR_USTAR;
136         a->archive_format_name = "POSIX ustar";
137         return (ARCHIVE_OK);
138 }
139
140 static int
141 archive_write_ustar_header(struct archive *a, struct archive_entry *entry)
142 {
143         char buff[512];
144         int ret;
145         struct ustar *ustar;
146
147         ustar = a->format_data;
148         ustar->written = 1;
149
150         /* Only regular files (not hardlinks) have data. */
151         if (archive_entry_hardlink(entry) != NULL ||
152             archive_entry_symlink(entry) != NULL ||
153             !S_ISREG(archive_entry_mode(entry)))
154                 archive_entry_set_size(entry, 0);
155
156         ret = __archive_write_format_header_ustar(a, buff, entry, -1, 1);
157         if (ret != ARCHIVE_OK)
158                 return (ret);
159         ret = (a->compression_write)(a, buff, 512);
160         if (ret != ARCHIVE_OK)
161                 return (ret);
162
163         ustar->entry_bytes_remaining = archive_entry_size(entry);
164         ustar->entry_padding = 0x1ff & (- ustar->entry_bytes_remaining);
165         return (ARCHIVE_OK);
166 }
167
168 /*
169  * Format a basic 512-byte "ustar" header.
170  *
171  * Returns -1 if format failed (due to field overflow).
172  * Note that this always formats as much of the header as possible.
173  * If "strict" is set to zero, it will extend numeric fields as
174  * necessary (overwriting terminators or using base-256 extensions).
175  *
176  * This is exported so that other 'tar' formats can use it.
177  */
178 int
179 __archive_write_format_header_ustar(struct archive *a, char buff[512],
180     struct archive_entry *entry, int tartype, int strict)
181 {
182         unsigned int checksum;
183         struct archive_entry_header_ustar *h;
184         int i, ret;
185         size_t copy_length;
186         const char *p, *pp;
187         const struct stat *st;
188         int mytartype;
189
190         ret = 0;
191         mytartype = -1;
192         /*
193          * The "template header" already includes the "ustar"
194          * signature, various end-of-field markers and other required
195          * elements.
196          */
197         memcpy(buff, &template_header, 512);
198
199         h = (struct archive_entry_header_ustar *)buff;
200
201         /*
202          * Because the block is already null-filled, and strings
203          * are allowed to exactly fill their destination (without null),
204          * I use memcpy(dest, src, strlen()) here a lot to copy strings.
205          */
206
207         pp = archive_entry_pathname(entry);
208         if (strlen(pp) <= sizeof(h->name))
209                 memcpy(h->name, pp, strlen(pp));
210         else {
211                 /* Store in two pieces, splitting at a '/'. */
212                 p = strchr(pp + strlen(pp) - sizeof(h->name) - 1, '/');
213                 /*
214                  * If there is no path separator, or the prefix or
215                  * remaining name are too large, return an error.
216                  */
217                 if (!p) {
218                         archive_set_error(a, ENAMETOOLONG,
219                             "Pathname too long");
220                         ret = ARCHIVE_WARN;
221                 } else if (p  > pp + sizeof(h->prefix)) {
222                         archive_set_error(a, ENAMETOOLONG,
223                             "Pathname too long");
224                         ret = ARCHIVE_WARN;
225                 } else {
226                         /* Copy prefix and remainder to appropriate places */
227                         memcpy(h->prefix, pp, p - pp);
228                         memcpy(h->name, p + 1, pp + strlen(pp) - p - 1);
229                 }
230         }
231
232         p = archive_entry_hardlink(entry);
233         if(p != NULL)
234                 mytartype = '1';
235         else
236                 p = archive_entry_symlink(entry);
237         if (p != NULL && p[0] != '\0') {
238                 copy_length = strlen(p);
239                 if (copy_length > sizeof(h->linkname)) {
240                         archive_set_error(a, ENAMETOOLONG,
241                             "Link contents too long");
242                         ret = ARCHIVE_WARN;
243                         copy_length = sizeof(h->linkname);
244                 }
245                 memcpy(h->linkname, p, copy_length);
246         }
247
248         p = archive_entry_uname(entry);
249         if (p != NULL && p[0] != '\0') {
250                 copy_length = strlen(p);
251                 if (copy_length > sizeof(h->uname)) {
252                         archive_set_error(a, ARCHIVE_ERRNO_MISC,
253                             "Username too long");
254                         ret = ARCHIVE_WARN;
255                         copy_length = sizeof(h->uname);
256                 }
257                 memcpy(h->uname, p, copy_length);
258         }
259
260         p = archive_entry_gname(entry);
261         if (p != NULL && p[0] != '\0') {
262                 copy_length = strlen(p);
263                 if (strlen(p) > sizeof(h->gname)) {
264                         archive_set_error(a, ARCHIVE_ERRNO_MISC,
265                             "Group name too long");
266                         ret = ARCHIVE_WARN;
267                         copy_length = sizeof(h->gname);
268                 }
269                 memcpy(h->gname, p, copy_length);
270         }
271
272         st = archive_entry_stat(entry);
273
274         if (format_number(st->st_mode & 07777, h->mode, sizeof(h->mode), 8, strict)) {
275                 archive_set_error(a, ERANGE, "Numeric mode too large");
276                 ret = ARCHIVE_WARN;
277         }
278
279         if (format_number(st->st_uid, h->uid, sizeof(h->uid), 8, strict)) {
280                 archive_set_error(a, ERANGE, "Numeric user ID too large");
281                 ret = ARCHIVE_WARN;
282         }
283
284         if (format_number(st->st_gid, h->gid, sizeof(h->gid), 8, strict)) {
285                 archive_set_error(a, ERANGE, "Numeric group ID too large");
286                 ret = ARCHIVE_WARN;
287         }
288
289         if (format_number(st->st_size, h->size, sizeof(h->size), 12, strict)) {
290                 archive_set_error(a, ERANGE, "File size out of range");
291                 ret = ARCHIVE_WARN;
292         }
293
294         if (format_number(st->st_mtime, h->mtime, sizeof(h->mtime), 12, strict)) {
295                 archive_set_error(a, ERANGE,
296                     "File modification time too large");
297                 ret = ARCHIVE_WARN;
298         }
299
300         if (S_ISBLK(st->st_mode) || S_ISCHR(st->st_mode)) {
301                 if (format_number(major(st->st_rdev), h->rdevmajor,
302                         sizeof(h->rdevmajor), 8, strict)) {
303                         archive_set_error(a, ERANGE,
304                             "Major device number too large");
305                         ret = ARCHIVE_WARN;
306                 }
307
308                 if (format_number(minor(st->st_rdev), h->rdevminor,
309                         sizeof(h->rdevminor), 8, strict)) {
310                         archive_set_error(a, ERANGE,
311                             "Minor device number too large");
312                         ret = ARCHIVE_WARN;
313                 }
314         }
315
316         if (tartype >= 0) {
317                 h->typeflag[0] = tartype;
318         } else if (mytartype >= 0) {
319                 h->typeflag[0] = mytartype;
320         } else {
321                 switch (st->st_mode & S_IFMT) {
322                 case S_IFREG: h->typeflag[0] = '0' ; break;
323                 case S_IFLNK: h->typeflag[0] = '2' ; break;
324                 case S_IFCHR: h->typeflag[0] = '3' ; break;
325                 case S_IFBLK: h->typeflag[0] = '4' ; break;
326                 case S_IFDIR: h->typeflag[0] = '5' ; break;
327                 case S_IFIFO: h->typeflag[0] = '6' ; break;
328                 case S_IFSOCK:
329                         archive_set_error(a, ARCHIVE_ERRNO_FILE_FORMAT,
330                             "tar format cannot archive socket");
331                         ret = ARCHIVE_WARN;
332                         break;
333                 default:
334                         archive_set_error(a, ARCHIVE_ERRNO_FILE_FORMAT,
335                             "tar format cannot archive this (mode=0%lo)",
336                             (unsigned long)st->st_mode);
337                         ret = ARCHIVE_WARN;
338                 }
339         }
340
341         checksum = 0;
342         for (i = 0; i < 512; i++)
343                 checksum += 255 & (unsigned int)buff[i];
344         h->checksum[6] = '\0'; /* Can't be pre-set in the template. */
345         /* h->checksum[7] = ' '; */ /* This is pre-set in the template. */
346         format_octal(checksum, h->checksum, 6);
347         return (ret);
348 }
349
350 /*
351  * Format a number into a field, with some intelligence.
352  */
353 static int
354 format_number(int64_t v, char *p, int s, int maxsize, int strict)
355 {
356         int64_t limit;
357
358         limit = ((int64_t)1 << (s*3));
359
360         /* "Strict" only permits octal values with proper termination. */
361         if (strict)
362                 return (format_octal(v, p, s));
363
364         /*
365          * In non-strict mode, we allow the number to overwrite one or
366          * more bytes of the field termination.  Even old tar
367          * implementations should be able to handle this with no
368          * problem.
369          */
370         if (v >= 0) {
371                 while (s <= maxsize) {
372                         if (v < limit)
373                                 return (format_octal(v, p, s));
374                         s++;
375                         limit <<= 3;
376                 }
377         }
378
379         /* Base-256 can handle any number, positive or negative. */
380         return (format_256(v, p, maxsize));
381 }
382
383 /*
384  * Format a number into the specified field using base-256.
385  */
386 static int
387 format_256(int64_t v, char *p, int s)
388 {
389         p += s;
390         while (s-- > 0) {
391                 *--p = (char)(v & 0xff);
392                 v >>= 8;
393         }
394         *p |= 0x80; /* Set the base-256 marker bit. */
395         return (0);
396 }
397
398 /*
399  * Format a number into the specified field.
400  */
401 static int
402 format_octal(int64_t v, char *p, int s)
403 {
404         int len;
405
406         len = s;
407
408         /* Octal values can't be negative, so use 0. */
409         if (v < 0) {
410                 while (len-- > 0)
411                         *p++ = '0';
412                 return (-1);
413         }
414
415         p += s;         /* Start at the end and work backwards. */
416         while (s-- > 0) {
417                 *--p = '0' + (v & 7);
418                 v >>= 3;
419         }
420
421         if (v == 0)
422                 return (0);
423
424         /* If it overflowed, fill field with max value. */
425         while (len-- > 0)
426                 *p++ = '7';
427
428         return (-1);
429 }
430
431 static int
432 archive_write_ustar_finish(struct archive *a)
433 {
434         struct ustar *ustar;
435         int r;
436
437         r = ARCHIVE_OK;
438         ustar = a->format_data;
439         /*
440          * Suppress end-of-archive if nothing else was ever written.
441          * This fixes a problem where setting one format, then another
442          * ends up writing a gratuitous end-of-archive marker.
443          */
444         if (ustar->written && a->compression_write != NULL)
445                 r = write_nulls(a, 512*2);
446         free(ustar);
447         a->format_data = NULL;
448         return (r);
449 }
450
451 static int
452 archive_write_ustar_finish_entry(struct archive *a)
453 {
454         struct ustar *ustar;
455         int ret;
456
457         ustar = a->format_data;
458         ret = write_nulls(a,
459             ustar->entry_bytes_remaining + ustar->entry_padding);
460         ustar->entry_bytes_remaining = ustar->entry_padding = 0;
461         return (ret);
462 }
463
464 static int
465 write_nulls(struct archive *a, size_t padding)
466 {
467         int ret, to_write;
468
469         while (padding > 0) {
470                 to_write = padding < a->null_length ? padding : a->null_length;
471                 ret = (a->compression_write)(a, a->nulls, to_write);
472                 if (ret != ARCHIVE_OK)
473                         return (ret);
474                 padding -= to_write;
475         }
476         return (ARCHIVE_OK);
477 }
478
479 static int
480 archive_write_ustar_data(struct archive *a, const void *buff, size_t s)
481 {
482         struct ustar *ustar;
483         int ret;
484
485         ustar = a->format_data;
486         if (s > ustar->entry_bytes_remaining)
487                 s = ustar->entry_bytes_remaining;
488         ret = (a->compression_write)(a, buff, s);
489         ustar->entry_bytes_remaining -= s;
490         return (ret);
491 }