]> Dogcows Code - chaz/tar/blob - src/create.c
(check_time): Use volume_start_time when checking
[chaz/tar] / src / create.c
1 /* Create a tar archive.
2
3 Copyright (C) 1985, 1992, 1993, 1994, 1996, 1997, 1999, 2000, 2001,
4 2003, 2004, 2005, 2006 Free Software Foundation, Inc.
5
6 Written by John Gilmore, on 1985-08-25.
7
8 This program is free software; you can redistribute it and/or modify it
9 under the terms of the GNU General Public License as published by the
10 Free Software Foundation; either version 2, or (at your option) any later
11 version.
12
13 This program is distributed in the hope that it will be useful, but
14 WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
16 Public License for more details.
17
18 You should have received a copy of the GNU General Public License along
19 with this program; if not, write to the Free Software Foundation, Inc.,
20 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */
21
22 #include <system.h>
23
24 #include <quotearg.h>
25
26 #include "common.h"
27 #include <hash.h>
28
29 struct link
30 {
31 dev_t dev;
32 ino_t ino;
33 size_t nlink;
34 char name[1];
35 };
36 \f
37 /* The maximum uintmax_t value that can be represented with DIGITS digits,
38 assuming that each digit is BITS_PER_DIGIT wide. */
39 #define MAX_VAL_WITH_DIGITS(digits, bits_per_digit) \
40 ((digits) * (bits_per_digit) < sizeof (uintmax_t) * CHAR_BIT \
41 ? ((uintmax_t) 1 << ((digits) * (bits_per_digit))) - 1 \
42 : (uintmax_t) -1)
43
44 /* The maximum uintmax_t value that can be represented with octal
45 digits and a trailing NUL in BUFFER. */
46 #define MAX_OCTAL_VAL(buffer) MAX_VAL_WITH_DIGITS (sizeof (buffer) - 1, LG_8)
47
48 /* Convert VALUE to an octal representation suitable for tar headers.
49 Output to buffer WHERE with size SIZE.
50 The result is undefined if SIZE is 0 or if VALUE is too large to fit. */
51
52 static void
53 to_octal (uintmax_t value, char *where, size_t size)
54 {
55 uintmax_t v = value;
56 size_t i = size;
57
58 do
59 {
60 where[--i] = '0' + (v & ((1 << LG_8) - 1));
61 v >>= LG_8;
62 }
63 while (i);
64 }
65
66 /* Copy at most LEN bytes from the string SRC to DST. Terminate with
67 NUL unless SRC is LEN or more bytes long. */
68
69 static void
70 tar_copy_str (char *dst, const char *src, size_t len)
71 {
72 size_t i;
73 for (i = 0; i < len; i++)
74 if (! (dst[i] = src[i]))
75 break;
76 }
77
78 /* Same as tar_copy_str, but always terminate with NUL if using
79 is OLDGNU format */
80
81 static void
82 tar_name_copy_str (char *dst, const char *src, size_t len)
83 {
84 tar_copy_str (dst, src, len);
85 if (archive_format == OLDGNU_FORMAT)
86 dst[len-1] = 0;
87 }
88
89 /* Convert NEGATIVE VALUE to a base-256 representation suitable for
90 tar headers. NEGATIVE is 1 if VALUE was negative before being cast
91 to uintmax_t, 0 otherwise. Output to buffer WHERE with size SIZE.
92 The result is undefined if SIZE is 0 or if VALUE is too large to
93 fit. */
94
95 static void
96 to_base256 (int negative, uintmax_t value, char *where, size_t size)
97 {
98 uintmax_t v = value;
99 uintmax_t propagated_sign_bits =
100 ((uintmax_t) - negative << (CHAR_BIT * sizeof v - LG_256));
101 size_t i = size;
102
103 do
104 {
105 where[--i] = v & ((1 << LG_256) - 1);
106 v = propagated_sign_bits | (v >> LG_256);
107 }
108 while (i);
109 }
110
111
112 static bool
113 to_chars (int negative, uintmax_t value, size_t valsize,
114 uintmax_t (*substitute) (int *),
115 char *where, size_t size, const char *type);
116
117 static bool
118 to_chars_subst (int negative, int gnu_format, uintmax_t value, size_t valsize,
119 uintmax_t (*substitute) (int *),
120 char *where, size_t size, const char *type)
121 {
122 uintmax_t maxval = (gnu_format
123 ? MAX_VAL_WITH_DIGITS (size - 1, LG_256)
124 : MAX_VAL_WITH_DIGITS (size - 1, LG_8));
125 char valbuf[UINTMAX_STRSIZE_BOUND + 1];
126 char maxbuf[UINTMAX_STRSIZE_BOUND];
127 char minbuf[UINTMAX_STRSIZE_BOUND + 1];
128 char const *minval_string;
129 char const *maxval_string = STRINGIFY_BIGINT (maxval, maxbuf);
130 char const *value_string;
131
132 if (gnu_format)
133 {
134 uintmax_t m = maxval + 1 ? maxval + 1 : maxval / 2 + 1;
135 char *p = STRINGIFY_BIGINT (m, minbuf + 1);
136 *--p = '-';
137 minval_string = p;
138 }
139 else
140 minval_string = "0";
141
142 if (negative)
143 {
144 char *p = STRINGIFY_BIGINT (- value, valbuf + 1);
145 *--p = '-';
146 value_string = p;
147 }
148 else
149 value_string = STRINGIFY_BIGINT (value, valbuf);
150
151 if (substitute)
152 {
153 int negsub;
154 uintmax_t sub = substitute (&negsub) & maxval;
155 /* FIXME: This is the only place where GNU_FORMAT differs from
156 OLDGNU_FORMAT. Apart from this they are completely identical. */
157 uintmax_t s = (negsub &= archive_format == GNU_FORMAT) ? - sub : sub;
158 char subbuf[UINTMAX_STRSIZE_BOUND + 1];
159 char *sub_string = STRINGIFY_BIGINT (s, subbuf + 1);
160 if (negsub)
161 *--sub_string = '-';
162 WARN ((0, 0, _("value %s out of %s range %s..%s; substituting %s"),
163 value_string, type, minval_string, maxval_string,
164 sub_string));
165 return to_chars (negsub, s, valsize, 0, where, size, type);
166 }
167 else
168 ERROR ((0, 0, _("value %s out of %s range %s..%s"),
169 value_string, type, minval_string, maxval_string));
170 return false;
171 }
172
173 /* Convert NEGATIVE VALUE (which was originally of size VALSIZE) to
174 external form, using SUBSTITUTE (...) if VALUE won't fit. Output
175 to buffer WHERE with size SIZE. NEGATIVE is 1 iff VALUE was
176 negative before being cast to uintmax_t; its original bitpattern
177 can be deduced from VALSIZE, its original size before casting.
178 TYPE is the kind of value being output (useful for diagnostics).
179 Prefer the POSIX format of SIZE - 1 octal digits (with leading zero
180 digits), followed by '\0'. If this won't work, and if GNU or
181 OLDGNU format is allowed, use '\200' followed by base-256, or (if
182 NEGATIVE is nonzero) '\377' followed by two's complement base-256.
183 If neither format works, use SUBSTITUTE (...) instead. Pass to
184 SUBSTITUTE the address of an 0-or-1 flag recording whether the
185 substitute value is negative. */
186
187 static bool
188 to_chars (int negative, uintmax_t value, size_t valsize,
189 uintmax_t (*substitute) (int *),
190 char *where, size_t size, const char *type)
191 {
192 int gnu_format = (archive_format == GNU_FORMAT
193 || archive_format == OLDGNU_FORMAT);
194
195 /* Generate the POSIX octal representation if the number fits. */
196 if (! negative && value <= MAX_VAL_WITH_DIGITS (size - 1, LG_8))
197 {
198 where[size - 1] = '\0';
199 to_octal (value, where, size - 1);
200 return true;
201 }
202 else if (gnu_format)
203 {
204 /* Try to cope with the number by using traditional GNU format
205 methods */
206
207 /* Generate the base-256 representation if the number fits. */
208 if (((negative ? -1 - value : value)
209 <= MAX_VAL_WITH_DIGITS (size - 1, LG_256)))
210 {
211 where[0] = negative ? -1 : 1 << (LG_256 - 1);
212 to_base256 (negative, value, where + 1, size - 1);
213 return true;
214 }
215
216 /* Otherwise, if the number is negative, and if it would not cause
217 ambiguity on this host by confusing positive with negative
218 values, then generate the POSIX octal representation of the value
219 modulo 2**(field bits). The resulting tar file is
220 machine-dependent, since it depends on the host word size. Yuck!
221 But this is the traditional behavior. */
222 else if (negative && valsize * CHAR_BIT <= (size - 1) * LG_8)
223 {
224 static int warned_once;
225 if (! warned_once)
226 {
227 warned_once = 1;
228 WARN ((0, 0, _("Generating negative octal headers")));
229 }
230 where[size - 1] = '\0';
231 to_octal (value & MAX_VAL_WITH_DIGITS (valsize * CHAR_BIT, 1),
232 where, size - 1);
233 return true;
234 }
235 /* Otherwise fall back to substitution, if possible: */
236 }
237 else
238 substitute = NULL; /* No substitution for formats, other than GNU */
239
240 return to_chars_subst (negative, gnu_format, value, valsize, substitute,
241 where, size, type);
242 }
243
244 static uintmax_t
245 gid_substitute (int *negative)
246 {
247 gid_t r;
248 #ifdef GID_NOBODY
249 r = GID_NOBODY;
250 #else
251 static gid_t gid_nobody;
252 if (!gid_nobody && !gname_to_gid ("nobody", &gid_nobody))
253 gid_nobody = -2;
254 r = gid_nobody;
255 #endif
256 *negative = r < 0;
257 return r;
258 }
259
260 bool
261 gid_to_chars (gid_t v, char *p, size_t s)
262 {
263 return to_chars (v < 0, (uintmax_t) v, sizeof v, gid_substitute, p, s, "gid_t");
264 }
265
266 bool
267 major_to_chars (major_t v, char *p, size_t s)
268 {
269 return to_chars (v < 0, (uintmax_t) v, sizeof v, 0, p, s, "major_t");
270 }
271
272 bool
273 minor_to_chars (minor_t v, char *p, size_t s)
274 {
275 return to_chars (v < 0, (uintmax_t) v, sizeof v, 0, p, s, "minor_t");
276 }
277
278 bool
279 mode_to_chars (mode_t v, char *p, size_t s)
280 {
281 /* In the common case where the internal and external mode bits are the same,
282 and we are not using POSIX or GNU format,
283 propagate all unknown bits to the external mode.
284 This matches historical practice.
285 Otherwise, just copy the bits we know about. */
286 int negative;
287 uintmax_t u;
288 if (S_ISUID == TSUID && S_ISGID == TSGID && S_ISVTX == TSVTX
289 && S_IRUSR == TUREAD && S_IWUSR == TUWRITE && S_IXUSR == TUEXEC
290 && S_IRGRP == TGREAD && S_IWGRP == TGWRITE && S_IXGRP == TGEXEC
291 && S_IROTH == TOREAD && S_IWOTH == TOWRITE && S_IXOTH == TOEXEC
292 && archive_format != POSIX_FORMAT
293 && archive_format != USTAR_FORMAT
294 && archive_format != GNU_FORMAT)
295 {
296 negative = v < 0;
297 u = v;
298 }
299 else
300 {
301 negative = 0;
302 u = ((v & S_ISUID ? TSUID : 0)
303 | (v & S_ISGID ? TSGID : 0)
304 | (v & S_ISVTX ? TSVTX : 0)
305 | (v & S_IRUSR ? TUREAD : 0)
306 | (v & S_IWUSR ? TUWRITE : 0)
307 | (v & S_IXUSR ? TUEXEC : 0)
308 | (v & S_IRGRP ? TGREAD : 0)
309 | (v & S_IWGRP ? TGWRITE : 0)
310 | (v & S_IXGRP ? TGEXEC : 0)
311 | (v & S_IROTH ? TOREAD : 0)
312 | (v & S_IWOTH ? TOWRITE : 0)
313 | (v & S_IXOTH ? TOEXEC : 0));
314 }
315 return to_chars (negative, u, sizeof v, 0, p, s, "mode_t");
316 }
317
318 bool
319 off_to_chars (off_t v, char *p, size_t s)
320 {
321 return to_chars (v < 0, (uintmax_t) v, sizeof v, 0, p, s, "off_t");
322 }
323
324 bool
325 size_to_chars (size_t v, char *p, size_t s)
326 {
327 return to_chars (0, (uintmax_t) v, sizeof v, 0, p, s, "size_t");
328 }
329
330 bool
331 time_to_chars (time_t v, char *p, size_t s)
332 {
333 return to_chars (v < 0, (uintmax_t) v, sizeof v, 0, p, s, "time_t");
334 }
335
336 static uintmax_t
337 uid_substitute (int *negative)
338 {
339 uid_t r;
340 #ifdef UID_NOBODY
341 r = UID_NOBODY;
342 #else
343 static uid_t uid_nobody;
344 if (!uid_nobody && !uname_to_uid ("nobody", &uid_nobody))
345 uid_nobody = -2;
346 r = uid_nobody;
347 #endif
348 *negative = r < 0;
349 return r;
350 }
351
352 bool
353 uid_to_chars (uid_t v, char *p, size_t s)
354 {
355 return to_chars (v < 0, (uintmax_t) v, sizeof v, uid_substitute, p, s, "uid_t");
356 }
357
358 bool
359 uintmax_to_chars (uintmax_t v, char *p, size_t s)
360 {
361 return to_chars (0, v, sizeof v, 0, p, s, "uintmax_t");
362 }
363
364 void
365 string_to_chars (char const *str, char *p, size_t s)
366 {
367 tar_copy_str (p, str, s);
368 p[s - 1] = '\0';
369 }
370
371 \f
372 /* A file is considered dumpable if it is sparse and both --sparse and --totals
373 are specified.
374 Otherwise, it is dumpable unless any of the following conditions occur:
375
376 a) it is empty *and* world-readable, or
377 b) current archive is /dev/null */
378
379 bool
380 file_dumpable_p (struct tar_stat_info *st)
381 {
382 if (dev_null_output)
383 return totals_option && sparse_option && sparse_file_p (st);
384 return !(st->archive_file_size == 0
385 && (st->stat.st_mode & MODE_R) == MODE_R);
386 }
387
388 \f
389 /* Writing routines. */
390
391 /* Write the EOT block(s). Zero at least two blocks, through the end
392 of the record. Old tar, as previous versions of GNU tar, writes
393 garbage after two zeroed blocks. */
394 void
395 write_eot (void)
396 {
397 union block *pointer = find_next_block ();
398 memset (pointer->buffer, 0, BLOCKSIZE);
399 set_next_block_after (pointer);
400 pointer = find_next_block ();
401 memset (pointer->buffer, 0, available_space_after (pointer));
402 set_next_block_after (pointer);
403 }
404
405 /* Write a "private" header */
406 union block *
407 start_private_header (const char *name, size_t size)
408 {
409 time_t t;
410 union block *header = find_next_block ();
411
412 memset (header->buffer, 0, sizeof (union block));
413
414 tar_name_copy_str (header->header.name, name, NAME_FIELD_SIZE);
415 OFF_TO_CHARS (size, header->header.size);
416
417 time (&t);
418 TIME_TO_CHARS (t, header->header.mtime);
419 MODE_TO_CHARS (S_IFREG|S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH, header->header.mode);
420 UID_TO_CHARS (getuid (), header->header.uid);
421 GID_TO_CHARS (getgid (), header->header.gid);
422 MAJOR_TO_CHARS (0, header->header.devmajor);
423 MINOR_TO_CHARS (0, header->header.devminor);
424 strncpy (header->header.magic, TMAGIC, TMAGLEN);
425 strncpy (header->header.version, TVERSION, TVERSLEN);
426 return header;
427 }
428
429 /* Create a new header and store there at most NAME_FIELD_SIZE bytes of
430 the file name */
431
432 static union block *
433 write_short_name (struct tar_stat_info *st)
434 {
435 union block *header = find_next_block ();
436 memset (header->buffer, 0, sizeof (union block));
437 tar_name_copy_str (header->header.name, st->file_name, NAME_FIELD_SIZE);
438 return header;
439 }
440
441 #define FILL(field,byte) do { \
442 memset(field, byte, sizeof(field)-1); \
443 (field)[sizeof(field)-1] = 0; \
444 } while (0)
445
446 /* Write a GNUTYPE_LONGLINK or GNUTYPE_LONGNAME block. */
447 static void
448 write_gnu_long_link (struct tar_stat_info *st, const char *p, char type)
449 {
450 size_t size = strlen (p) + 1;
451 size_t bufsize;
452 union block *header;
453 char *tmpname;
454
455 header = start_private_header ("././@LongLink", size);
456 FILL(header->header.mtime, '0');
457 FILL(header->header.mode, '0');
458 FILL(header->header.uid, '0');
459 FILL(header->header.gid, '0');
460 FILL(header->header.devmajor, 0);
461 FILL(header->header.devminor, 0);
462 uid_to_uname (0, &tmpname);
463 UNAME_TO_CHARS (tmpname, header->header.uname);
464 free (tmpname);
465 gid_to_gname (0, &tmpname);
466 GNAME_TO_CHARS (tmpname, header->header.gname);
467 free (tmpname);
468
469 strcpy (header->header.magic, OLDGNU_MAGIC);
470 header->header.typeflag = type;
471 finish_header (st, header, -1);
472
473 header = find_next_block ();
474
475 bufsize = available_space_after (header);
476
477 while (bufsize < size)
478 {
479 memcpy (header->buffer, p, bufsize);
480 p += bufsize;
481 size -= bufsize;
482 set_next_block_after (header + (bufsize - 1) / BLOCKSIZE);
483 header = find_next_block ();
484 bufsize = available_space_after (header);
485 }
486 memcpy (header->buffer, p, size);
487 memset (header->buffer + size, 0, bufsize - size);
488 set_next_block_after (header + (size - 1) / BLOCKSIZE);
489 }
490
491 static size_t
492 split_long_name (const char *name, size_t length)
493 {
494 size_t i;
495
496 if (length > PREFIX_FIELD_SIZE)
497 length = PREFIX_FIELD_SIZE + 1;
498 for (i = length - 1; i > 0; i--)
499 if (ISSLASH (name[i]))
500 break;
501 return i;
502 }
503
504 static union block *
505 write_ustar_long_name (const char *name)
506 {
507 size_t length = strlen (name);
508 size_t i;
509 union block *header;
510
511 if (length > PREFIX_FIELD_SIZE + NAME_FIELD_SIZE + 1)
512 {
513 ERROR ((0, 0, _("%s: file name is too long (max %d); not dumped"),
514 quotearg_colon (name),
515 PREFIX_FIELD_SIZE + NAME_FIELD_SIZE + 1));
516 return NULL;
517 }
518
519 i = split_long_name (name, length);
520 if (i == 0 || length - i - 1 > NAME_FIELD_SIZE)
521 {
522 ERROR ((0, 0,
523 _("%s: file name is too long (cannot be split); not dumped"),
524 quotearg_colon (name)));
525 return NULL;
526 }
527
528 header = find_next_block ();
529 memset (header->buffer, 0, sizeof (header->buffer));
530 memcpy (header->header.prefix, name, i);
531 memcpy (header->header.name, name + i + 1, length - i - 1);
532
533 return header;
534 }
535
536 /* Write a long link name, depending on the current archive format */
537 static void
538 write_long_link (struct tar_stat_info *st)
539 {
540 switch (archive_format)
541 {
542 case POSIX_FORMAT:
543 xheader_store ("linkpath", st, NULL);
544 break;
545
546 case V7_FORMAT: /* old V7 tar format */
547 case USTAR_FORMAT:
548 case STAR_FORMAT:
549 ERROR ((0, 0,
550 _("%s: link name is too long; not dumped"),
551 quotearg_colon (st->link_name)));
552 break;
553
554 case OLDGNU_FORMAT:
555 case GNU_FORMAT:
556 write_gnu_long_link (st, st->link_name, GNUTYPE_LONGLINK);
557 break;
558
559 default:
560 abort(); /*FIXME*/
561 }
562 }
563
564 static union block *
565 write_long_name (struct tar_stat_info *st)
566 {
567 switch (archive_format)
568 {
569 case POSIX_FORMAT:
570 xheader_store ("path", st, NULL);
571 break;
572
573 case V7_FORMAT:
574 if (strlen (st->file_name) > NAME_FIELD_SIZE-1)
575 {
576 ERROR ((0, 0, _("%s: file name is too long (max %d); not dumped"),
577 quotearg_colon (st->file_name),
578 NAME_FIELD_SIZE - 1));
579 return NULL;
580 }
581 break;
582
583 case USTAR_FORMAT:
584 case STAR_FORMAT:
585 return write_ustar_long_name (st->file_name);
586
587 case OLDGNU_FORMAT:
588 case GNU_FORMAT:
589 write_gnu_long_link (st, st->file_name, GNUTYPE_LONGNAME);
590 break;
591
592 default:
593 abort(); /*FIXME*/
594 }
595 return write_short_name (st);
596 }
597
598 union block *
599 write_extended (bool global, struct tar_stat_info *st, union block *old_header)
600 {
601 union block *header, hp;
602 char *p;
603 int type;
604
605 if (extended_header.buffer || extended_header.stk == NULL)
606 return old_header;
607
608 xheader_finish (&extended_header);
609 memcpy (hp.buffer, old_header, sizeof (hp));
610 if (global)
611 {
612 type = XGLTYPE;
613 p = xheader_ghdr_name ();
614 }
615 else
616 {
617 type = XHDTYPE;
618 p = xheader_xhdr_name (st);
619 }
620 xheader_write (type, p, &extended_header);
621 free (p);
622 header = find_next_block ();
623 memcpy (header, &hp.buffer, sizeof (hp.buffer));
624 return header;
625 }
626
627 static union block *
628 write_header_name (struct tar_stat_info *st)
629 {
630 if (archive_format == POSIX_FORMAT && !string_ascii_p (st->file_name))
631 {
632 xheader_store ("path", st, NULL);
633 return write_short_name (st);
634 }
635 else if (NAME_FIELD_SIZE - (archive_format == OLDGNU_FORMAT)
636 < strlen (st->file_name))
637 return write_long_name (st);
638 else
639 return write_short_name (st);
640 }
641
642 \f
643 /* Header handling. */
644
645 /* Make a header block for the file whose stat info is st,
646 and return its address. */
647
648 union block *
649 start_header (struct tar_stat_info *st)
650 {
651 union block *header;
652
653 header = write_header_name (st);
654 if (!header)
655 return NULL;
656
657 /* Override some stat fields, if requested to do so. */
658
659 if (owner_option != (uid_t) -1)
660 st->stat.st_uid = owner_option;
661 if (group_option != (gid_t) -1)
662 st->stat.st_gid = group_option;
663 if (mode_option)
664 st->stat.st_mode =
665 ((st->stat.st_mode & ~MODE_ALL)
666 | mode_adjust (st->stat.st_mode, mode_option, initial_umask));
667
668 /* Paul Eggert tried the trivial test ($WRITER cf a b; $READER tvf a)
669 for a few tars and came up with the following interoperability
670 matrix:
671
672 WRITER
673 1 2 3 4 5 6 7 8 9 READER
674 . . . . . . . . . 1 = SunOS 4.2 tar
675 # . . # # . . # # 2 = NEC SVR4.0.2 tar
676 . . . # # . . # . 3 = Solaris 2.1 tar
677 . . . . . . . . . 4 = GNU tar 1.11.1
678 . . . . . . . . . 5 = HP-UX 8.07 tar
679 . . . . . . . . . 6 = Ultrix 4.1
680 . . . . . . . . . 7 = AIX 3.2
681 . . . . . . . . . 8 = Hitachi HI-UX 1.03
682 . . . . . . . . . 9 = Omron UNIOS-B 4.3BSD 1.60Beta
683
684 . = works
685 # = ``impossible file type''
686
687 The following mask for old archive removes the `#'s in column 4
688 above, thus making GNU tar both a universal donor and a universal
689 acceptor for Paul's test. */
690
691 if (archive_format == V7_FORMAT || archive_format == USTAR_FORMAT)
692 MODE_TO_CHARS (st->stat.st_mode & MODE_ALL, header->header.mode);
693 else
694 MODE_TO_CHARS (st->stat.st_mode, header->header.mode);
695
696 {
697 uid_t uid = st->stat.st_uid;
698 if (archive_format == POSIX_FORMAT
699 && MAX_OCTAL_VAL (header->header.uid) < uid)
700 {
701 xheader_store ("uid", st, NULL);
702 uid = 0;
703 }
704 if (!UID_TO_CHARS (uid, header->header.uid))
705 return NULL;
706 }
707
708 {
709 gid_t gid = st->stat.st_gid;
710 if (archive_format == POSIX_FORMAT
711 && MAX_OCTAL_VAL (header->header.gid) < gid)
712 {
713 xheader_store ("gid", st, NULL);
714 gid = 0;
715 }
716 if (!GID_TO_CHARS (gid, header->header.gid))
717 return NULL;
718 }
719
720 {
721 off_t size = st->stat.st_size;
722 if (archive_format == POSIX_FORMAT
723 && MAX_OCTAL_VAL (header->header.size) < size)
724 {
725 xheader_store ("size", st, NULL);
726 size = 0;
727 }
728 if (!OFF_TO_CHARS (size, header->header.size))
729 return NULL;
730 }
731
732 {
733 struct timespec mtime = st->mtime;
734 if (archive_format == POSIX_FORMAT)
735 {
736 if (MAX_OCTAL_VAL (header->header.mtime) < mtime.tv_sec
737 || mtime.tv_nsec != 0)
738 xheader_store ("mtime", st, NULL);
739 if (MAX_OCTAL_VAL (header->header.mtime) < mtime.tv_sec)
740 mtime.tv_sec = 0;
741 }
742 if (!TIME_TO_CHARS (mtime.tv_sec, header->header.mtime))
743 return NULL;
744 }
745
746 /* FIXME */
747 if (S_ISCHR (st->stat.st_mode)
748 || S_ISBLK (st->stat.st_mode))
749 {
750 major_t devmajor = major (st->stat.st_rdev);
751 minor_t devminor = minor (st->stat.st_rdev);
752
753 if (archive_format == POSIX_FORMAT
754 && MAX_OCTAL_VAL (header->header.devmajor) < devmajor)
755 {
756 xheader_store ("devmajor", st, NULL);
757 devmajor = 0;
758 }
759 if (!MAJOR_TO_CHARS (devmajor, header->header.devmajor))
760 return NULL;
761
762 if (archive_format == POSIX_FORMAT
763 && MAX_OCTAL_VAL (header->header.devminor) < devminor)
764 {
765 xheader_store ("devminor", st, NULL);
766 devminor = 0;
767 }
768 if (!MINOR_TO_CHARS (devminor, header->header.devminor))
769 return NULL;
770 }
771 else if (archive_format != GNU_FORMAT && archive_format != OLDGNU_FORMAT)
772 {
773 if (!(MAJOR_TO_CHARS (0, header->header.devmajor)
774 && MINOR_TO_CHARS (0, header->header.devminor)))
775 return NULL;
776 }
777
778 if (archive_format == POSIX_FORMAT)
779 {
780 xheader_store ("atime", st, NULL);
781 xheader_store ("ctime", st, NULL);
782 }
783 else if (incremental_option)
784 if (archive_format == OLDGNU_FORMAT || archive_format == GNU_FORMAT)
785 {
786 TIME_TO_CHARS (st->atime.tv_sec, header->oldgnu_header.atime);
787 TIME_TO_CHARS (st->ctime.tv_sec, header->oldgnu_header.ctime);
788 }
789
790 header->header.typeflag = archive_format == V7_FORMAT ? AREGTYPE : REGTYPE;
791
792 switch (archive_format)
793 {
794 case V7_FORMAT:
795 break;
796
797 case OLDGNU_FORMAT:
798 case GNU_FORMAT: /*FIXME?*/
799 /* Overwrite header->header.magic and header.version in one blow. */
800 strcpy (header->header.magic, OLDGNU_MAGIC);
801 break;
802
803 case POSIX_FORMAT:
804 case USTAR_FORMAT:
805 strncpy (header->header.magic, TMAGIC, TMAGLEN);
806 strncpy (header->header.version, TVERSION, TVERSLEN);
807 break;
808
809 default:
810 abort ();
811 }
812
813 if (archive_format == V7_FORMAT || numeric_owner_option)
814 {
815 /* header->header.[ug]name are left as the empty string. */
816 }
817 else
818 {
819 uid_to_uname (st->stat.st_uid, &st->uname);
820 gid_to_gname (st->stat.st_gid, &st->gname);
821
822 if (archive_format == POSIX_FORMAT
823 && (strlen (st->uname) > UNAME_FIELD_SIZE
824 || !string_ascii_p (st->uname)))
825 xheader_store ("uname", st, NULL);
826 UNAME_TO_CHARS (st->uname, header->header.uname);
827
828 if (archive_format == POSIX_FORMAT
829 && (strlen (st->gname) > GNAME_FIELD_SIZE
830 || !string_ascii_p (st->gname)))
831 xheader_store ("gname", st, NULL);
832 GNAME_TO_CHARS (st->gname, header->header.gname);
833 }
834
835 return header;
836 }
837
838 void
839 simple_finish_header (union block *header)
840 {
841 size_t i;
842 int sum;
843 char *p;
844
845 memcpy (header->header.chksum, CHKBLANKS, sizeof header->header.chksum);
846
847 sum = 0;
848 p = header->buffer;
849 for (i = sizeof *header; i-- != 0; )
850 /* We can't use unsigned char here because of old compilers, e.g. V7. */
851 sum += 0xFF & *p++;
852
853 /* Fill in the checksum field. It's formatted differently from the
854 other fields: it has [6] digits, a null, then a space -- rather than
855 digits, then a null. We use to_chars.
856 The final space is already there, from
857 checksumming, and to_chars doesn't modify it.
858
859 This is a fast way to do:
860
861 sprintf(header->header.chksum, "%6o", sum); */
862
863 uintmax_to_chars ((uintmax_t) sum, header->header.chksum, 7);
864
865 set_next_block_after (header);
866 }
867
868 /* Finish off a filled-in header block and write it out. We also
869 print the file name and/or full info if verbose is on. If BLOCK_ORDINAL
870 is not negative, is the block ordinal of the first record for this
871 file, which may be a preceding long name or long link record. */
872 void
873 finish_header (struct tar_stat_info *st,
874 union block *header, off_t block_ordinal)
875 {
876 /* Note: It is important to do this before the call to write_extended(),
877 so that the actual ustar header is printed */
878 if (verbose_option
879 && header->header.typeflag != GNUTYPE_LONGLINK
880 && header->header.typeflag != GNUTYPE_LONGNAME
881 && header->header.typeflag != XHDTYPE
882 && header->header.typeflag != XGLTYPE)
883 {
884 /* These globals are parameters to print_header, sigh. */
885
886 current_header = header;
887 current_format = archive_format;
888 print_header (st, block_ordinal);
889 }
890
891 header = write_extended (false, st, header);
892 simple_finish_header (header);
893 }
894 \f
895
896 void
897 pad_archive (off_t size_left)
898 {
899 union block *blk;
900 while (size_left > 0)
901 {
902 mv_size_left (size_left);
903 blk = find_next_block ();
904 memset (blk->buffer, 0, BLOCKSIZE);
905 set_next_block_after (blk);
906 size_left -= BLOCKSIZE;
907 }
908 }
909
910 static enum dump_status
911 dump_regular_file (int fd, struct tar_stat_info *st)
912 {
913 off_t size_left = st->stat.st_size;
914 off_t block_ordinal;
915 union block *blk;
916
917 block_ordinal = current_block_ordinal ();
918 blk = start_header (st);
919 if (!blk)
920 return dump_status_fail;
921
922 /* Mark contiguous files, if we support them. */
923 if (archive_format != V7_FORMAT && S_ISCTG (st->stat.st_mode))
924 blk->header.typeflag = CONTTYPE;
925
926 finish_header (st, blk, block_ordinal);
927
928 mv_begin (st);
929 while (size_left > 0)
930 {
931 size_t bufsize, count;
932
933 mv_size_left (size_left);
934
935 blk = find_next_block ();
936
937 bufsize = available_space_after (blk);
938
939 if (size_left < bufsize)
940 {
941 /* Last read -- zero out area beyond. */
942 bufsize = size_left;
943 count = bufsize % BLOCKSIZE;
944 if (count)
945 memset (blk->buffer + size_left, 0, BLOCKSIZE - count);
946 }
947
948 count = (fd < 0) ? bufsize : safe_read (fd, blk->buffer, bufsize);
949 if (count == SAFE_READ_ERROR)
950 {
951 read_diag_details (st->orig_file_name,
952 st->stat.st_size - size_left, bufsize);
953 pad_archive (size_left);
954 return dump_status_short;
955 }
956 size_left -= count;
957 if (count)
958 set_next_block_after (blk + (bufsize - 1) / BLOCKSIZE);
959
960 if (count != bufsize)
961 {
962 char buf[UINTMAX_STRSIZE_BOUND];
963 memset (blk->buffer + count, 0, bufsize - count);
964 WARN ((0, 0,
965 ngettext ("%s: File shrank by %s byte; padding with zeros",
966 "%s: File shrank by %s bytes; padding with zeros",
967 size_left),
968 quotearg_colon (st->orig_file_name),
969 STRINGIFY_BIGINT (size_left, buf)));
970 if (! ignore_failed_read_option)
971 exit_status = TAREXIT_FAILURE;
972 pad_archive (size_left - (bufsize-count));
973 return dump_status_short;
974 }
975 }
976 return dump_status_ok;
977 }
978
979 /* Look in directory DIRNAME for a cache directory tag file
980 with the magic name "CACHEDIR.TAG" and a standard header,
981 as described at:
982 http://www.brynosaurus.com/cachedir
983 Applications can write this file into directories they create
984 for use as caches containing purely regenerable, non-precious data,
985 allowing us to avoid archiving them if --exclude-caches is specified. */
986
987 #define CACHEDIR_SIGNATURE "Signature: 8a477f597d28d172789f06886806bc55"
988 #define CACHEDIR_SIGNATURE_SIZE (sizeof CACHEDIR_SIGNATURE - 1)
989
990 static bool
991 check_cache_directory (char *dirname)
992 {
993 static char tagname[] = "CACHEDIR.TAG";
994 char *tagpath;
995 int fd;
996 int tag_present = false;
997
998 tagpath = xmalloc (strlen (dirname) + strlen (tagname) + 1);
999 strcpy (tagpath, dirname);
1000 strcat (tagpath, tagname);
1001
1002 fd = open (tagpath, O_RDONLY);
1003 if (fd >= 0)
1004 {
1005 static char tagbuf[CACHEDIR_SIGNATURE_SIZE];
1006
1007 if (read (fd, tagbuf, CACHEDIR_SIGNATURE_SIZE)
1008 == CACHEDIR_SIGNATURE_SIZE
1009 && memcmp (tagbuf, CACHEDIR_SIGNATURE, CACHEDIR_SIGNATURE_SIZE) == 0)
1010 tag_present = true;
1011
1012 close (fd);
1013 }
1014
1015 free (tagpath);
1016
1017 return tag_present;
1018 }
1019
1020 static void
1021 dump_dir0 (char *directory,
1022 struct tar_stat_info *st, int top_level, dev_t parent_device)
1023 {
1024 dev_t our_device = st->stat.st_dev;
1025
1026 if (!is_avoided_name (st->orig_file_name))
1027 {
1028 union block *blk = NULL;
1029 off_t block_ordinal = current_block_ordinal ();
1030 st->stat.st_size = 0; /* force 0 size on dir */
1031
1032 blk = start_header (st);
1033 if (!blk)
1034 return;
1035
1036 if (incremental_option && archive_format != POSIX_FORMAT)
1037 blk->header.typeflag = GNUTYPE_DUMPDIR;
1038 else /* if (standard_option) */
1039 blk->header.typeflag = DIRTYPE;
1040
1041 /* If we're gnudumping, we aren't done yet so don't close it. */
1042
1043 if (!incremental_option)
1044 finish_header (st, blk, block_ordinal);
1045 else if (gnu_list_name->dir_contents)
1046 {
1047 if (archive_format == POSIX_FORMAT)
1048 {
1049 xheader_store ("GNU.dumpdir", st, gnu_list_name->dir_contents);
1050 finish_header (st, blk, block_ordinal);
1051 }
1052 else
1053 {
1054 off_t size_left;
1055 off_t totsize;
1056 size_t bufsize;
1057 ssize_t count;
1058 const char *buffer, *p_buffer;
1059
1060 block_ordinal = current_block_ordinal ();
1061 buffer = gnu_list_name->dir_contents;
1062 if (buffer)
1063 totsize = dumpdir_size (buffer);
1064 else
1065 totsize = 0;
1066 OFF_TO_CHARS (totsize, blk->header.size);
1067 finish_header (st, blk, block_ordinal);
1068 p_buffer = buffer;
1069 size_left = totsize;
1070
1071 mv_begin (st);
1072 mv_total_size (totsize);
1073 while (size_left > 0)
1074 {
1075 mv_size_left (size_left);
1076 blk = find_next_block ();
1077 bufsize = available_space_after (blk);
1078 if (size_left < bufsize)
1079 {
1080 bufsize = size_left;
1081 count = bufsize % BLOCKSIZE;
1082 if (count)
1083 memset (blk->buffer + size_left, 0, BLOCKSIZE - count);
1084 }
1085 memcpy (blk->buffer, p_buffer, bufsize);
1086 size_left -= bufsize;
1087 p_buffer += bufsize;
1088 set_next_block_after (blk + (bufsize - 1) / BLOCKSIZE);
1089 }
1090 mv_end ();
1091 }
1092 return;
1093 }
1094 }
1095
1096 if (!recursion_option)
1097 return;
1098
1099 if (one_file_system_option
1100 && !top_level
1101 && parent_device != st->stat.st_dev)
1102 {
1103 if (verbose_option)
1104 WARN ((0, 0,
1105 _("%s: file is on a different filesystem; not dumped"),
1106 quotearg_colon (st->orig_file_name)));
1107 return;
1108 }
1109
1110 if (exclude_caches_option
1111 && check_cache_directory(st->orig_file_name))
1112 {
1113 if (verbose_option)
1114 WARN ((0, 0,
1115 _("%s: contains a cache directory tag; not dumped"),
1116 quotearg_colon (st->orig_file_name)));
1117 return;
1118 }
1119
1120 {
1121 char const *entry;
1122 size_t entry_len;
1123 char *name_buf = xstrdup (st->orig_file_name);
1124 size_t name_size = strlen (name_buf);
1125 size_t name_len = name_size;
1126
1127 /* Now output all the files in the directory. */
1128 /* FIXME: Should speed this up by cd-ing into the dir. */
1129
1130 for (entry = directory; (entry_len = strlen (entry)) != 0;
1131 entry += entry_len + 1)
1132 {
1133 if (name_size < name_len + entry_len)
1134 {
1135 name_size = name_len + entry_len;
1136 name_buf = xrealloc (name_buf, name_size + 1);
1137 }
1138 strcpy (name_buf + name_len, entry);
1139 if (!excluded_name (name_buf))
1140 dump_file (name_buf, 0, our_device);
1141 }
1142
1143 free (name_buf);
1144 }
1145 }
1146
1147 /* Ensure exactly one trailing slash. */
1148 static void
1149 ensure_slash (char **pstr)
1150 {
1151 size_t len = strlen (*pstr);
1152 while (len >= 1 && ISSLASH ((*pstr)[len - 1]))
1153 len--;
1154 if (!ISSLASH ((*pstr)[len]))
1155 *pstr = xrealloc (*pstr, len + 2);
1156 (*pstr)[len++] = '/';
1157 (*pstr)[len] = '\0';
1158 }
1159
1160 static bool
1161 dump_dir (int fd, struct tar_stat_info *st, int top_level, dev_t parent_device)
1162 {
1163 char *directory = fdsavedir (fd);
1164 if (!directory)
1165 {
1166 savedir_diag (st->orig_file_name);
1167 return false;
1168 }
1169
1170 ensure_slash (&st->orig_file_name);
1171 ensure_slash (&st->file_name);
1172
1173 dump_dir0 (directory, st, top_level, parent_device);
1174
1175 free (directory);
1176 return true;
1177 }
1178
1179 \f
1180 /* Main functions of this module. */
1181
1182 void
1183 create_archive (void)
1184 {
1185 const char *p;
1186
1187 open_archive (ACCESS_WRITE);
1188 xheader_write_global ();
1189
1190 if (incremental_option)
1191 {
1192 size_t buffer_size = 1000;
1193 char *buffer = xmalloc (buffer_size);
1194 const char *q;
1195
1196 collect_and_sort_names ();
1197
1198 while ((p = name_from_list ()) != NULL)
1199 if (!excluded_name (p))
1200 dump_file (p, -1, (dev_t) 0);
1201
1202 blank_name_list ();
1203 while ((p = name_from_list ()) != NULL)
1204 if (!excluded_name (p))
1205 {
1206 size_t plen = strlen (p);
1207 if (buffer_size <= plen)
1208 {
1209 while ((buffer_size *= 2) <= plen)
1210 continue;
1211 buffer = xrealloc (buffer, buffer_size);
1212 }
1213 memcpy (buffer, p, plen);
1214 if (! ISSLASH (buffer[plen - 1]))
1215 buffer[plen++] = '/';
1216 q = gnu_list_name->dir_contents;
1217 if (q)
1218 while (*q)
1219 {
1220 size_t qlen = strlen (q);
1221 if (*q == 'Y')
1222 {
1223 if (buffer_size < plen + qlen)
1224 {
1225 while ((buffer_size *=2 ) < plen + qlen)
1226 continue;
1227 buffer = xrealloc (buffer, buffer_size);
1228 }
1229 strcpy (buffer + plen, q + 1);
1230 dump_file (buffer, -1, (dev_t) 0);
1231 }
1232 q += qlen + 1;
1233 }
1234 }
1235 free (buffer);
1236 }
1237 else
1238 {
1239 while ((p = name_next (1)) != NULL)
1240 if (!excluded_name (p))
1241 dump_file (p, 1, (dev_t) 0);
1242 }
1243
1244 write_eot ();
1245 close_archive ();
1246
1247 if (listed_incremental_option)
1248 write_directory_file ();
1249 }
1250
1251
1252 /* Calculate the hash of a link. */
1253 static size_t
1254 hash_link (void const *entry, size_t n_buckets)
1255 {
1256 struct link const *l = entry;
1257 uintmax_t num = l->dev ^ l->ino;
1258 return num % n_buckets;
1259 }
1260
1261 /* Compare two links for equality. */
1262 static bool
1263 compare_links (void const *entry1, void const *entry2)
1264 {
1265 struct link const *link1 = entry1;
1266 struct link const *link2 = entry2;
1267 return ((link1->dev ^ link2->dev) | (link1->ino ^ link2->ino)) == 0;
1268 }
1269
1270 static void
1271 unknown_file_error (char const *p)
1272 {
1273 WARN ((0, 0, _("%s: Unknown file type; file ignored"),
1274 quotearg_colon (p)));
1275 if (!ignore_failed_read_option)
1276 exit_status = TAREXIT_FAILURE;
1277 }
1278
1279 \f
1280 /* Handling of hard links */
1281
1282 /* Table of all non-directories that we've written so far. Any time
1283 we see another, we check the table and avoid dumping the data
1284 again if we've done it once already. */
1285 static Hash_table *link_table;
1286
1287 /* Try to dump stat as a hard link to another file in the archive.
1288 Return true if successful. */
1289 static bool
1290 dump_hard_link (struct tar_stat_info *st)
1291 {
1292 if (link_table && st->stat.st_nlink > 1)
1293 {
1294 struct link lp;
1295 struct link *duplicate;
1296 off_t block_ordinal;
1297 union block *blk;
1298
1299 lp.ino = st->stat.st_ino;
1300 lp.dev = st->stat.st_dev;
1301
1302 if ((duplicate = hash_lookup (link_table, &lp)))
1303 {
1304 /* We found a link. */
1305 char const *link_name = safer_name_suffix (duplicate->name, true,
1306 absolute_names_option);
1307
1308 duplicate->nlink--;
1309
1310 block_ordinal = current_block_ordinal ();
1311 assign_string (&st->link_name, link_name);
1312 if (NAME_FIELD_SIZE - (archive_format == OLDGNU_FORMAT)
1313 < strlen (link_name))
1314 write_long_link (st);
1315
1316 st->stat.st_size = 0;
1317 blk = start_header (st);
1318 if (!blk)
1319 return false;
1320 tar_copy_str (blk->header.linkname, link_name, NAME_FIELD_SIZE);
1321
1322 blk->header.typeflag = LNKTYPE;
1323 finish_header (st, blk, block_ordinal);
1324
1325 if (remove_files_option && unlink (st->orig_file_name) != 0)
1326 unlink_error (st->orig_file_name);
1327
1328 return true;
1329 }
1330 }
1331 return false;
1332 }
1333
1334 static void
1335 file_count_links (struct tar_stat_info *st)
1336 {
1337 if (st->stat.st_nlink > 1)
1338 {
1339 struct link *duplicate;
1340 struct link *lp = xmalloc (offsetof (struct link, name)
1341 + strlen (st->orig_file_name) + 1);
1342 lp->ino = st->stat.st_ino;
1343 lp->dev = st->stat.st_dev;
1344 lp->nlink = st->stat.st_nlink;
1345 strcpy (lp->name, st->orig_file_name);
1346
1347 if (! ((link_table
1348 || (link_table = hash_initialize (0, 0, hash_link,
1349 compare_links, 0)))
1350 && (duplicate = hash_insert (link_table, lp))))
1351 xalloc_die ();
1352
1353 if (duplicate != lp)
1354 abort ();
1355 lp->nlink--;
1356 }
1357 }
1358
1359 /* For each dumped file, check if all its links were dumped. Emit
1360 warnings if it is not so. */
1361 void
1362 check_links (void)
1363 {
1364 struct link *lp;
1365
1366 if (!link_table)
1367 return;
1368
1369 for (lp = hash_get_first (link_table); lp;
1370 lp = hash_get_next (link_table, lp))
1371 {
1372 if (lp->nlink)
1373 {
1374 WARN ((0, 0, _("Missing links to %s.\n"), quote (lp->name)));
1375 }
1376 }
1377 }
1378
1379
1380 /* Dump a single file, recursing on directories. P is the file name
1381 to dump. TOP_LEVEL tells whether this is a top-level call; zero
1382 means no, positive means yes, and negative means the top level
1383 of an incremental dump. PARENT_DEVICE is the device of P's
1384 parent directory; it is examined only if TOP_LEVEL is zero. */
1385
1386 /* FIXME: One should make sure that for *every* path leading to setting
1387 exit_status to failure, a clear diagnostic has been issued. */
1388
1389 static void
1390 dump_file0 (struct tar_stat_info *st, const char *p,
1391 int top_level, dev_t parent_device)
1392 {
1393 union block *header;
1394 char type;
1395 struct timespec original_ctime;
1396 struct timespec restore_times[2];
1397 off_t block_ordinal = -1;
1398 bool is_dir;
1399
1400 if (interactive_option && !confirm ("add", p))
1401 return;
1402
1403 assign_string (&st->orig_file_name, p);
1404 assign_string (&st->file_name,
1405 safer_name_suffix (p, false, absolute_names_option));
1406
1407 transform_name (&st->file_name);
1408
1409 if (deref_stat (dereference_option, p, &st->stat) != 0)
1410 {
1411 stat_diag (p);
1412 return;
1413 }
1414 st->archive_file_size = st->stat.st_size;
1415 st->atime = restore_times[0] = get_stat_atime (&st->stat);
1416 st->mtime = restore_times[1] = get_stat_mtime (&st->stat);
1417 st->ctime = original_ctime = get_stat_ctime (&st->stat);
1418
1419 #ifdef S_ISHIDDEN
1420 if (S_ISHIDDEN (st->stat.st_mode))
1421 {
1422 char *new = (char *) alloca (strlen (p) + 2);
1423 if (new)
1424 {
1425 strcpy (new, p);
1426 strcat (new, "@");
1427 p = new;
1428 }
1429 }
1430 #endif
1431
1432 /* See if we want only new files, and check if this one is too old to
1433 put in the archive.
1434
1435 This check is omitted if incremental_option is set *and* the
1436 requested file is not explicitely listed in the command line. */
1437
1438 if (!(incremental_option && !is_individual_file (p))
1439 && !S_ISDIR (st->stat.st_mode)
1440 && OLDER_TAR_STAT_TIME (*st, m)
1441 && (!after_date_option || OLDER_TAR_STAT_TIME (*st, c)))
1442 {
1443 if (!incremental_option && verbose_option)
1444 WARN ((0, 0, _("%s: file is unchanged; not dumped"),
1445 quotearg_colon (p)));
1446 return;
1447 }
1448
1449 /* See if we are trying to dump the archive. */
1450 if (sys_file_is_archive (st))
1451 {
1452 WARN ((0, 0, _("%s: file is the archive; not dumped"),
1453 quotearg_colon (p)));
1454 return;
1455 }
1456
1457 if (is_avoided_name (p))
1458 return;
1459
1460 is_dir = S_ISDIR (st->stat.st_mode) != 0;
1461
1462 if (!is_dir && dump_hard_link (st))
1463 return;
1464
1465 if (is_dir || S_ISREG (st->stat.st_mode) || S_ISCTG (st->stat.st_mode))
1466 {
1467 bool ok;
1468 int fd = -1;
1469 struct stat final_stat;
1470
1471 if (is_dir || file_dumpable_p (st))
1472 {
1473 fd = open (p,
1474 (O_RDONLY | O_BINARY
1475 | (is_dir ? O_DIRECTORY | O_NONBLOCK : 0)
1476 | (atime_preserve_option == system_atime_preserve
1477 ? O_NOATIME
1478 : 0)));
1479 if (fd < 0)
1480 {
1481 if (!top_level && errno == ENOENT)
1482 WARN ((0, 0, _("%s: File removed before we read it"),
1483 quotearg_colon (p)));
1484 else
1485 open_diag (p);
1486 return;
1487 }
1488 }
1489
1490 if (is_dir)
1491 {
1492 ok = dump_dir (fd, st, top_level, parent_device);
1493
1494 /* dump_dir consumes FD if successful. */
1495 if (ok)
1496 fd = -1;
1497 }
1498 else
1499 {
1500 enum dump_status status;
1501
1502 if (fd != -1 && sparse_option && sparse_file_p (st))
1503 {
1504 status = sparse_dump_file (fd, st);
1505 if (status == dump_status_not_implemented)
1506 status = dump_regular_file (fd, st);
1507 }
1508 else
1509 status = dump_regular_file (fd, st);
1510
1511 switch (status)
1512 {
1513 case dump_status_ok:
1514 case dump_status_short:
1515 mv_end ();
1516 break;
1517
1518 case dump_status_fail:
1519 break;
1520
1521 case dump_status_not_implemented:
1522 abort ();
1523 }
1524
1525 file_count_links (st);
1526
1527 ok = status == dump_status_ok;
1528 }
1529
1530 if (ok)
1531 {
1532 /* If possible, reopen a directory if we are preserving
1533 atimes, so that we can set just the atime on systems with
1534 _FIOSATIME. */
1535 if (fd < 0 && is_dir
1536 && atime_preserve_option == replace_atime_preserve)
1537 fd = open (p, O_RDONLY | O_BINARY | O_DIRECTORY | O_NONBLOCK);
1538
1539 if ((fd < 0
1540 ? deref_stat (dereference_option, p, &final_stat)
1541 : fstat (fd, &final_stat))
1542 != 0)
1543 {
1544 stat_diag (p);
1545 ok = false;
1546 }
1547 }
1548
1549 if (ok)
1550 {
1551 if (timespec_cmp (get_stat_ctime (&final_stat), original_ctime) != 0)
1552 WARN ((0, 0, _("%s: file changed as we read it"),
1553 quotearg_colon (p)));
1554 else if (atime_preserve_option == replace_atime_preserve
1555 && set_file_atime (fd, p, restore_times) != 0)
1556 utime_error (p);
1557 }
1558
1559 if (0 <= fd && close (fd) != 0)
1560 {
1561 close_diag (p);
1562 ok = false;
1563 }
1564
1565 if (ok && remove_files_option)
1566 {
1567 if (is_dir)
1568 {
1569 if (rmdir (p) != 0 && errno != ENOTEMPTY)
1570 rmdir_error (p);
1571 }
1572 else
1573 {
1574 if (unlink (p) != 0)
1575 unlink_error (p);
1576 }
1577 }
1578
1579 return;
1580 }
1581 #ifdef HAVE_READLINK
1582 else if (S_ISLNK (st->stat.st_mode))
1583 {
1584 char *buffer;
1585 int size;
1586 size_t linklen = st->stat.st_size;
1587 if (linklen != st->stat.st_size || linklen + 1 == 0)
1588 xalloc_die ();
1589 buffer = (char *) alloca (linklen + 1);
1590 size = readlink (p, buffer, linklen + 1);
1591 if (size < 0)
1592 {
1593 readlink_diag (p);
1594 return;
1595 }
1596 buffer[size] = '\0';
1597 assign_string (&st->link_name, buffer);
1598 if (NAME_FIELD_SIZE - (archive_format == OLDGNU_FORMAT) < size)
1599 write_long_link (st);
1600
1601 block_ordinal = current_block_ordinal ();
1602 st->stat.st_size = 0; /* force 0 size on symlink */
1603 header = start_header (st);
1604 if (!header)
1605 return;
1606 tar_copy_str (header->header.linkname, buffer, NAME_FIELD_SIZE);
1607 header->header.typeflag = SYMTYPE;
1608 finish_header (st, header, block_ordinal);
1609 /* nothing more to do to it */
1610
1611 if (remove_files_option)
1612 {
1613 if (unlink (p) == -1)
1614 unlink_error (p);
1615 }
1616 file_count_links (st);
1617 return;
1618 }
1619 #endif
1620 else if (S_ISCHR (st->stat.st_mode))
1621 type = CHRTYPE;
1622 else if (S_ISBLK (st->stat.st_mode))
1623 type = BLKTYPE;
1624 else if (S_ISFIFO (st->stat.st_mode))
1625 type = FIFOTYPE;
1626 else if (S_ISSOCK (st->stat.st_mode))
1627 {
1628 WARN ((0, 0, _("%s: socket ignored"), quotearg_colon (p)));
1629 return;
1630 }
1631 else if (S_ISDOOR (st->stat.st_mode))
1632 {
1633 WARN ((0, 0, _("%s: door ignored"), quotearg_colon (p)));
1634 return;
1635 }
1636 else
1637 {
1638 unknown_file_error (p);
1639 return;
1640 }
1641
1642 if (archive_format == V7_FORMAT)
1643 {
1644 unknown_file_error (p);
1645 return;
1646 }
1647
1648 block_ordinal = current_block_ordinal ();
1649 st->stat.st_size = 0; /* force 0 size */
1650 header = start_header (st);
1651 if (!header)
1652 return;
1653 header->header.typeflag = type;
1654
1655 if (type != FIFOTYPE)
1656 {
1657 MAJOR_TO_CHARS (major (st->stat.st_rdev),
1658 header->header.devmajor);
1659 MINOR_TO_CHARS (minor (st->stat.st_rdev),
1660 header->header.devminor);
1661 }
1662
1663 finish_header (st, header, block_ordinal);
1664 if (remove_files_option)
1665 {
1666 if (unlink (p) == -1)
1667 unlink_error (p);
1668 }
1669 }
1670
1671 void
1672 dump_file (const char *p, int top_level, dev_t parent_device)
1673 {
1674 struct tar_stat_info st;
1675 tar_stat_init (&st);
1676 dump_file0 (&st, p, top_level, parent_device);
1677 if (listed_incremental_option)
1678 update_parent_directory (p);
1679 tar_stat_destroy (&st);
1680 }
This page took 0.143128 seconds and 4 git commands to generate.