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

   1 /* Update a tar archive.
   2    Copyright (C) 1988, 1992, 1994, 1996, 1997 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 "common.h"
  25
  26 /* FIXME: This module should not directly handle the following variable,
  27    instead, this should be done in buffer.c only.  */
  28 extern union block *current_block;
  29
  30 /* We've hit the end of the old stuff, and its time to start writing new
  31    stuff to the tape.  This involves seeking back one record and
  32    re-writing the current record (which has been changed).  */
  33 int time_to_start_writing = 0;
  34
  35 /* Pointer to where we started to write in the first record we write out.
  36    This is used if we can't backspace the output and have to null out the
  37    first part of the record.  */
  38 char *output_start;
  39
  40 /*------------------------------------------------------------------------.
  41 | Catenate file PATH to the archive without creating a header for it.  It |
  42 | had better be a tar file or the archive is screwed.                     |
  43 `------------------------------------------------------------------------*/
  44
  45 static void
  46 append_file (char *path)
  47 {
  48   int handle;
  49   struct stat stat_data;
  50   off_t bytes_left;
  51
  52   if (stat (path, &stat_data) != 0
  53       || (handle = open (path, O_RDONLY | O_BINARY), handle < 0))
  54     {
  55       ERROR ((0, errno, _("Cannot open file %s"), path));
  56       return;
  57     }
  58
  59   bytes_left = stat_data.st_size;
  60
  61   while (bytes_left > 0)
  62     {
  63       union block *start = find_next_block ();
  64       size_t buffer_size = available_space_after (start);
  65       ssize_t status;
  66
  67       if (bytes_left < buffer_size)
  68         {
  69           buffer_size = bytes_left;
  70           status = buffer_size % BLOCKSIZE;
  71           if (status)
  72             memset (start->buffer + bytes_left, 0,
  73                     (size_t) (BLOCKSIZE - status));
  74         }
  75
  76       status = full_read (handle, start->buffer, buffer_size);
  77       if (status < 0)
  78         {
  79           char buf[UINTMAX_STRSIZE_BOUND];
  80           FATAL_ERROR ((0, errno,
  81                         _("Read error at byte %s reading %lu bytes in file %s"),
  82                         STRINGIFY_BIGINT (stat_data.st_size - bytes_left, buf),
  83                         (unsigned long) buffer_size, path));
  84         }
  85       bytes_left -= status;
  86
  87       set_next_block_after (start + (status - 1) / BLOCKSIZE);
  88
  89       if (status != buffer_size)
  90         {
  91           char buf[UINTMAX_STRSIZE_BOUND];
  92           FATAL_ERROR ((0, 0, _("%s: File shrunk by %s bytes, (yark!)"),
  93                         path, STRINGIFY_BIGINT (bytes_left, buf)));
  94         }
  95     }
  96
  97   close (handle);
  98 }
  99
 100 /*-----------------------------------------------------------------------.
 101 | Implement the 'r' (add files to end of archive), and 'u' (add files to |
 102 | end of archive if they arent there, or are more up to date than the    |
 103 | version in the archive.) commands.                                     |
 104 `-----------------------------------------------------------------------*/
 105
 106 void
 107 update_archive (void)
 108 {
 109   enum read_header previous_status = HEADER_STILL_UNREAD;
 110   int found_end = 0;
 111
 112   name_gather ();
 113   if (subcommand_option == UPDATE_SUBCOMMAND)
 114     name_expand ();
 115   open_archive (ACCESS_UPDATE);
 116
 117   while (!found_end)
 118     {
 119       enum read_header status = read_header ();
 120
 121       switch (status)
 122         {
 123         case HEADER_STILL_UNREAD:
 124           abort ();
 125
 126         case HEADER_SUCCESS:
 127           {
 128             struct name *name;
 129
 130             if (subcommand_option == UPDATE_SUBCOMMAND
 131                 && (name = name_scan (current_file_name), name))
 132               {
 133                 struct stat stat_data;
 134                 enum archive_format unused;
 135
 136                 decode_header (current_header, &current_stat, &unused, 0);
 137                 if (stat (current_file_name, &stat_data) < 0)
 138                   ERROR ((0, errno, _("Cannot stat %s"), current_file_name));
 139                 else if (current_stat.st_mtime >= stat_data.st_mtime)
 140                   name->found = 1;
 141               }
 142             set_next_block_after (current_header);
 143             if (current_header->oldgnu_header.isextended)
 144               skip_extended_headers ();
 145             skip_file (current_stat.st_size);
 146             break;
 147           }
 148
 149         case HEADER_ZERO_BLOCK:
 150           current_block = current_header;
 151           found_end = 1;
 152           break;
 153
 154         case HEADER_END_OF_FILE:
 155           found_end = 1;
 156           break;
 157
 158         case HEADER_FAILURE:
 159           set_next_block_after (current_header);
 160           switch (previous_status)
 161             {
 162             case HEADER_STILL_UNREAD:
 163               WARN ((0, 0, _("This does not look like a tar archive")));
 164               /* Fall through.  */
 165
 166             case HEADER_SUCCESS:
 167             case HEADER_ZERO_BLOCK:
 168               ERROR ((0, 0, _("Skipping to next header")));
 169               /* Fall through.  */
 170
 171             case HEADER_FAILURE:
 172               break;
 173
 174             case HEADER_END_OF_FILE:
 175               abort ();
 176             }
 177           break;
 178         }
 179
 180       previous_status = status;
 181     }
 182
 183   reset_eof ();
 184   time_to_start_writing = 1;
 185   output_start = current_block->buffer;
 186
 187   {
 188     char *path;
 189
 190     while (path = name_from_list (), path)
 191       {
 192         if (interactive_option && !confirm ("add", path))
 193           continue;
 194         if (subcommand_option == CAT_SUBCOMMAND)
 195           append_file (path);
 196         else
 197           dump_file (path, (dev_t) -1, 1);
 198       }
 199   }
 200
 201   write_eot ();
 202   close_archive ();
 203   names_notfound ();
 204 }