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

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