Dogcows Code - chaz/tar/blob - src/update.c

   1 /* Update a tar archive.
   2    Copyright 1988, 1992, 1994, 1996, 1997, 1999 Free Software Foundation, Inc.
   3
   4    This program is free software; you can redistribute it and/or modify it
   5    under the terms of the GNU General Public License as published by the
   6    Free Software Foundation; either version 2, or (at your option) any later
   7    version.
   8
   9    This program is distributed in the hope that it will be useful, but
  10    WITHOUT ANY WARRANTY; without even the implied warranty of
  11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General
  12    Public License for more details.
  13
  14    You should have received a copy of the GNU General Public License along
  15    with this program; if not, write to the Free Software Foundation, Inc.,
  16    59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  17
  18 /* Implement the 'r', 'u' and 'A' options for tar.  'A' means that the
  19    file names are tar files, and they should simply be appended to the end
  20    of the archive.  No attempt is made to record the reads from the args; if
  21    they're on raw tape or something like that, it'll probably lose...  */
  22
  23 #include "system.h"
  24 #include <quotearg.h>
  25 #include "common.h"
  26
  27 /* FIXME: This module should not directly handle the following variable,
  28    instead, this should be done in buffer.c only.  */
  29 extern union block *current_block;
  30
  31 /* We've hit the end of the old stuff, and its time to start writing new
  32    stuff to the tape.  This involves seeking back one record and
  33    re-writing the current record (which has been changed).  */
  34 int time_to_start_writing;
  35
  36 /* Pointer to where we started to write in the first record we write out.
  37    This is used if we can't backspace the output and have to null out the
  38    first part of the record.  */
  39 char *output_start;
  40
  41 /*------------------------------------------------------------------------.
  42 | Catenate file PATH to the archive without creating a header for it.  It |
  43 | had better be a tar file or the archive is screwed.                     |
  44 `------------------------------------------------------------------------*/
  45
  46 static void
  47 append_file (char *path)
  48 {
  49   int handle = open (path, O_RDONLY | O_BINARY);
  50   struct stat stat_data;
  51
  52   if (handle < 0)
  53     {
  54       open_error (path);
  55       return;
  56     }
  57
  58   if (fstat (handle, &stat_data) != 0)
  59     stat_error (path);
  60   else
  61     {
  62       off_t bytes_left = stat_data.st_size;
  63
  64       while (bytes_left > 0)
  65         {
  66           union block *start = find_next_block ();
  67           size_t buffer_size = available_space_after (start);
  68           ssize_t status;
  69           char buf[UINTMAX_STRSIZE_BOUND];
  70
  71           if (bytes_left < buffer_size)
  72             {
  73               buffer_size = bytes_left;
  74               status = buffer_size % BLOCKSIZE;
  75               if (status)
  76                 memset (start->buffer + bytes_left, 0, BLOCKSIZE - status);
  77             }
  78
  79           status = safe_read (handle, start->buffer, buffer_size);
  80           if (status < 0)
  81             {
  82               int e = errno;
  83               FATAL_ERROR ((0, e,
  84                             _("Read error at byte %s reading %lu bytes in file %s"),
  85                             STRINGIFY_BIGINT (stat_data.st_size - bytes_left,
  86                                               buf),
  87                             (unsigned long) buffer_size, quote (path)));
  88             }
  89           if (status == 0)
  90             FATAL_ERROR ((0, 0, _("%s: File shrunk by %s bytes, (yark!)"),
  91                           quotearg_colon (path),
  92                           STRINGIFY_BIGINT (bytes_left, buf)));
  93
  94           bytes_left -= status;
  95
  96           set_next_block_after (start + (status - 1) / BLOCKSIZE);
  97         }
  98     }
  99
 100   if (close (handle) != 0)
 101     close_error (path);
 102 }
 103
 104 /*-----------------------------------------------------------------------.
 105 | Implement the 'r' (add files to end of archive), and 'u' (add files to |
 106 | end of archive if they arent there, or are more up to date than the    |
 107 | version in the archive.) commands.                                     |
 108 `-----------------------------------------------------------------------*/
 109
 110 void
 111 update_archive (void)
 112 {
 113   enum read_header previous_status = HEADER_STILL_UNREAD;
 114   int found_end = 0;
 115
 116   name_gather ();
 117   open_archive (ACCESS_UPDATE);
 118
 119   while (!found_end)
 120     {
 121       enum read_header status = read_header ();
 122
 123       switch (status)
 124         {
 125         case HEADER_STILL_UNREAD:
 126           abort ();
 127
 128         case HEADER_SUCCESS:
 129           {
 130             struct name *name;
 131
 132             if (subcommand_option == UPDATE_SUBCOMMAND
 133                 && (name = name_scan (current_file_name), name))
 134               {
 135                 struct stat s;
 136                 enum archive_format unused;
 137
 138                 decode_header (current_header, &current_stat, &unused, 0);
 139                 chdir_do (name->change_dir);
 140                 if (deref_stat (dereference_option, current_file_name, &s) == 0
 141                     && s.st_mtime <= current_stat.st_mtime)
 142                   add_avoided_name (current_file_name);
 143               }
 144             set_next_block_after (current_header);
 145             if (current_header->oldgnu_header.isextended)
 146               skip_extended_headers ();
 147             skip_file (current_stat.st_size);
 148             break;
 149           }
 150
 151         case HEADER_ZERO_BLOCK:
 152           current_block = current_header;
 153           found_end = 1;
 154           break;
 155
 156         case HEADER_END_OF_FILE:
 157           found_end = 1;
 158           break;
 159
 160         case HEADER_FAILURE:
 161           set_next_block_after (current_header);
 162           switch (previous_status)
 163             {
 164             case HEADER_STILL_UNREAD:
 165               WARN ((0, 0, _("This does not look like a tar archive")));
 166               /* Fall through.  */
 167
 168             case HEADER_SUCCESS:
 169             case HEADER_ZERO_BLOCK:
 170               ERROR ((0, 0, _("Skipping to next header")));
 171               /* Fall through.  */
 172
 173             case HEADER_FAILURE:
 174               break;
 175
 176             case HEADER_END_OF_FILE:
 177               abort ();
 178             }
 179           break;
 180         }
 181
 182       previous_status = status;
 183     }
 184
 185   reset_eof ();
 186   time_to_start_writing = 1;
 187   output_start = current_block->buffer;
 188
 189   {
 190     char *path;
 191
 192     while (path = name_from_list (), path)
 193       {
 194         if (excluded_name (path))
 195           continue;
 196         if (interactive_option && !confirm ("add", path))
 197           continue;
 198         if (subcommand_option == CAT_SUBCOMMAND)
 199           append_file (path);
 200         else
 201           dump_file (path, 1, (dev_t) 0);
 202       }
 203   }
 204
 205   write_eot ();
 206   close_archive ();
 207   names_notfound ();
 208 }