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 = open (path, O_RDONLY | O_BINARY);
  49   struct stat stat_data;
  50
  51   if (handle < 0)
  52     {
  53       ERROR ((0, errno, _("Cannot open file %s"), path));
  54       return;
  55     }
  56
  57   if (fstat (handle, &stat_data) != 0)
  58     ERROR ((0, errno, "%s", 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,
  76                         (size_t) (BLOCKSIZE - status));
  77             }
  78
  79           status = safe_read (handle, start->buffer, buffer_size);
  80           if (status < 0)
  81             FATAL_ERROR ((0, errno,
  82                           _("Read error at byte %s reading %lu bytes in file %s"),
  83                           STRINGIFY_BIGINT (stat_data.st_size - bytes_left,
  84                                             buf),
  85                           (unsigned long) buffer_size, path));
  86           if (status == 0)
  87             FATAL_ERROR ((0, 0, _("%s: File shrunk by %s bytes, (yark!)"),
  88                           path, STRINGIFY_BIGINT (bytes_left, buf)));
  89
  90           bytes_left -= status;
  91
  92           set_next_block_after (start + (status - 1) / BLOCKSIZE);
  93         }
  94     }
  95
  96   close (handle);
  97 }
  98
  99 /*-----------------------------------------------------------------------.
 100 | Implement the 'r' (add files to end of archive), and 'u' (add files to |
 101 | end of archive if they arent there, or are more up to date than the    |
 102 | version in the archive.) commands.                                     |
 103 `-----------------------------------------------------------------------*/
 104
 105 void
 106 update_archive (void)
 107 {
 108   enum read_header previous_status = HEADER_STILL_UNREAD;
 109   int found_end = 0;
 110
 111   name_gather ();
 112   if (subcommand_option == UPDATE_SUBCOMMAND)
 113     name_expand ();
 114   open_archive (ACCESS_UPDATE);
 115
 116   while (!found_end)
 117     {
 118       enum read_header status = read_header ();
 119
 120       switch (status)
 121         {
 122         case HEADER_STILL_UNREAD:
 123           abort ();
 124
 125         case HEADER_SUCCESS:
 126           {
 127             struct name *name;
 128
 129             if (subcommand_option == UPDATE_SUBCOMMAND
 130                 && (name = name_scan (current_file_name), name))
 131               {
 132                 struct stat stat_data;
 133                 enum archive_format unused;
 134
 135                 decode_header (current_header, &current_stat, &unused, 0);
 136                 if (stat (current_file_name, &stat_data) < 0)
 137                   ERROR ((0, errno, _("Cannot stat %s"), current_file_name));
 138                 else if (current_stat.st_mtime >= stat_data.st_mtime)
 139                   name->found = 1;
 140               }
 141             set_next_block_after (current_header);
 142             if (current_header->oldgnu_header.isextended)
 143               skip_extended_headers ();
 144             skip_file (current_stat.st_size);
 145             break;
 146           }
 147
 148         case HEADER_ZERO_BLOCK:
 149           current_block = current_header;
 150           found_end = 1;
 151           break;
 152
 153         case HEADER_END_OF_FILE:
 154           found_end = 1;
 155           break;
 156
 157         case HEADER_FAILURE:
 158           set_next_block_after (current_header);
 159           switch (previous_status)
 160             {
 161             case HEADER_STILL_UNREAD:
 162               WARN ((0, 0, _("This does not look like a tar archive")));
 163               /* Fall through.  */
 164
 165             case HEADER_SUCCESS:
 166             case HEADER_ZERO_BLOCK:
 167               ERROR ((0, 0, _("Skipping to next header")));
 168               /* Fall through.  */
 169
 170             case HEADER_FAILURE:
 171               break;
 172
 173             case HEADER_END_OF_FILE:
 174               abort ();
 175             }
 176           break;
 177         }
 178
 179       previous_status = status;
 180     }
 181
 182   reset_eof ();
 183   time_to_start_writing = 1;
 184   output_start = current_block->buffer;
 185
 186   {
 187     char *path;
 188
 189     while (path = name_from_list (), path)
 190       {
 191         if (interactive_option && !confirm ("add", path))
 192           continue;
 193         if (subcommand_option == CAT_SUBCOMMAND)
 194           append_file (path);
 195         else
 196           dump_file (path, (dev_t) -1, 1);
 197       }
 198   }
 199
 200   write_eot ();
 201   close_archive ();
 202   names_notfound ();
 203 }