archive_tar.cc

   1 /*
   2  * Copyright (c) 2000, 2001, Red Hat, Inc.
   3  *
   4  *     This program is free software; you can redistribute it and/or modify
   5  *     it under the terms of the GNU General Public License as published by
   6  *     the Free Software Foundation; either version 2 of the License, or
   7  *     (at your option) any later version.
   8  *
   9  *     A copy of the GNU General Public License can be found at
  10  *     http://www.gnu.org/
  11  *
  12  * Written by DJ Delorie <dj@cygnus.com>
  13  *
  14  */
  15
  16 /* Built-in tar functionality.  See tar.h for usage. */
  17
  18 #include <stdio.h>
  19 #include <stdlib.h>
  20 #include <sys/types.h>
  21 #include <sys/fcntl.h>
  22 #include <errno.h>
  23
  24 #include "io_stream.h"
  25 #include "win32.h"
  26 #include "archive.h"
  27 #include "archive_tar.h"
  28 #include "mkdir.h"
  29 #include "LogFile.h"
  30 #include "filemanip.h"
  31
  32 static int err;
  33 static char buf[512];
  34
  35 int _tar_verbose = 0;
  36
  37 archive_tar::archive_tar (io_stream * original)
  38 {
  39   archive_children = 0;
  40
  41   if (_tar_verbose)
  42     LogBabblePrintf("tar: open `%p'\n", original);
  43
  44   if (!original)
  45     {
  46       state.lasterr = EBADF;
  47       return;
  48     }
  49   state.parent = original;
  50
  51   if (sizeof (state.tar_header) != 512)
  52     {
  53       /* drastic, but important */
  54       Log (LOG_TIMESTAMP) << "compilation error: tar header struct not 512"
  55                           << " bytes (it's " << sizeof (state.tar_header)
  56                           << ")" << endLog;
  57       Logger ().exit (1);
  58     }
  59 }
  60
  61 ssize_t
  62 archive_tar::read (void *buffer, size_t len)
  63 {
  64   return -1;
  65 }
  66
  67 ssize_t
  68 archive_tar::write (const void *buffer, size_t len)
  69 {
  70   return 0;
  71 }
  72
  73 ssize_t
  74 archive_tar::peek (void *buffer, size_t len)
  75 {
  76   return 0;
  77 }
  78
  79 int
  80 archive_tar::error ()
  81 {
  82   return state.lasterr;
  83 }
  84
  85 off_t
  86 archive_tar::tell ()
  87 {
  88   return state.file_offset;
  89 }
  90
  91 off_t
  92 archive_tar::seek (off_t where, io_stream_seek_t whence)
  93 {
  94   /* Because the parent stream is compressed, we can only easily support
  95      seek()-ing to rewind to the start */
  96   if ((whence == IO_SEEK_SET) && (where == 0))
  97     {
  98       state.header_read = 0;
  99       return state.parent->seek(where, whence);
 100     }
 101
 102   return -1;
 103 }
 104
 105 int
 106 archive_tar::skip_file ()
 107 {
 108   while (state.file_length > state.file_offset)
 109     {
 110       int len = state.parent->read (buf, 512);
 111       state.file_offset += 512;
 112       if (len != 512)
 113         return 1;
 114     }
 115   state.file_length = 0;
 116   state.file_offset = 0;
 117   state.header_read = 0;
 118   return 0;
 119 }
 120
 121 const std::string
 122 archive_tar::next_file_name ()
 123 {
 124   char *c;
 125
 126   if (state.header_read)
 127     {
 128       if (strlen (state.filename))
 129         return state.filename;
 130       else
 131         /* End of tar */
 132         return std::string();
 133     }
 134
 135   int r = state.parent->read (&state.tar_header, 512);
 136
 137   /* See if we're at end of file */
 138   if (r != 512)
 139     return std::string();
 140
 141   /* See if the header is all zeros (i.e. last block) */
 142   int n = 0;
 143   for (r = 512 / sizeof (int); r; r--)
 144     n |= ((int *) &state.tar_header)[r - 1];
 145   if (n == 0)
 146     return std::string();
 147
 148   if (!state.have_longname)
 149     {
 150       memcpy (state.filename, state.tar_header.name, 100);
 151       state.filename[100] = 0;
 152     }
 153
 154   if (!state.have_longlink)
 155     {
 156       memcpy (state.linkname, state.tar_header.linkname, 100);
 157       state.linkname[100] = 0;
 158     }
 159
 160   /* typeflag for any 'real' file consumes the longname/longlink state from
 161      previous blocks */
 162   if ((state.tar_header.typeflag != 'K') &&
 163       (state.tar_header.typeflag != 'L'))
 164     {
 165       state.have_longname = 0;
 166       state.have_longlink = 0;
 167     }
 168
 169   state.file_length = strtoll (state.tar_header.size, NULL, 8);
 170   state.file_offset = 0;
 171
 172   if (_tar_verbose)
 173     LogBabblePrintf ("%c %9d %s\n", state.tar_header.typeflag,
 174                      state.file_length, state.filename);
 175
 176   switch (state.tar_header.typeflag)
 177     {
 178     case 'K':                   /* GNU tar long link extension */
 179     case 'L':                   /* GNU tar long name extension */
 180       if (strcmp(state.tar_header.name, "././@LongLink") != 0)
 181         LogBabblePrintf("tar: unexpected filename %s in file type %c header\n", state.tar_header.name, state.tar_header.typeflag);
 182
 183       /* we read the 'file' into the long filename/linkname, then recursively
 184        * call ourselves to handle the following block.
 185        */
 186       if (state.file_length > CYG_PATH_MAX)
 187         {
 188           skip_file ();
 189           LogPlainPrintf( "error: long file name exceeds %d characters\n",
 190                           CYG_PATH_MAX);
 191           err++;
 192           state.parent->read (&state.tar_header, 512);
 193           state.file_length = strtoll (state.tar_header.size, NULL, 8);
 194           state.file_offset = 0;
 195           skip_file ();
 196           return next_file_name ();
 197         }
 198
 199       if (state.tar_header.typeflag == 'L')
 200         {
 201           c = state.filename;
 202           state.have_longname = 1;
 203         }
 204       else
 205         {
 206           c = state.linkname;
 207           state.have_longlink = 1;
 208         }
 209
 210       /* FIXME: this should be a single read() call */
 211       while (state.file_length > state.file_offset)
 212         {
 213           int need =
 214             state.file_length - state.file_offset >
 215             512 ? 512 : state.file_length - state.file_offset;
 216           if (state.parent->read (buf, 512) < 512)
 217             {
 218               LogPlainPrintf( "error: error reading long name\n");
 219               return "";
 220             }
 221           memcpy (c, buf, need);
 222           c += need;
 223           state.file_offset += need;
 224         }
 225       *c = 0;
 226
 227       return next_file_name ();
 228
 229     case '3':                   /* char */
 230     case '4':                   /* block */
 231     case '6':                   /* fifo */
 232       LogPlainPrintf ("warning: not extracting special file %s\n",
 233                       state.filename);
 234       err++;
 235       return next_file_name ();
 236
 237     case '0':                   /* regular file */
 238     case 0:                     /* regular file also */
 239     case '2':                   /* symbolic link */
 240     case '5':                   /* directory */
 241     case '7':                   /* contiguous file */
 242       state.header_read = 1;
 243       return state.filename;
 244
 245     case '1':                   /* hard link, we just copy */
 246       state.header_read = 1;
 247       return state.filename;
 248
 249     default:
 250       LogPlainPrintf ("error: unknown (or unsupported) file type `%c'\n",
 251                       state.tar_header.typeflag);
 252       err++;
 253       /* fall through */
 254     case 'g':                   /* POSIX.1-2001 global extended header */
 255     case 'x':                   /* POSIX.1-2001 extended header */
 256       skip_file ();
 257       return next_file_name ();
 258     }
 259   return std::string();
 260 }
 261
 262 archive_tar::~archive_tar ()
 263 {
 264   if (state.parent)
 265     delete state.parent;
 266 }
 267
 268 # if 0
 269 static void
 270 fix_time_stamp (char *path)
 271 {
 272   int mtime;
 273   long long ftimev;
 274   FILETIME ftime;
 275   HANDLE h;
 276
 277   sscanf (tar_header.mtime, "%o", &mtime);
 278   ftimev = mtime * NSPERSEC + FACTOR;
 279   ftime.dwHighDateTime = ftimev >> 32;
 280   ftime.dwLowDateTime = ftimev;
 281   h = CreateFileA (path, GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE,
 282                    0, OPEN_EXISTING,
 283                    FILE_ATTRIBUTE_NORMAL | FILE_FLAG_BACKUP_SEMANTICS, 0);
 284   if (h)
 285     {
 286       SetFileTime (h, 0, 0, &ftime);
 287       CloseHandle (h);
 288     }
 289 }
 290 #endif
 291 archive_file_t
 292 archive_tar::next_file_type ()
 293 {
 294   switch (state.tar_header.typeflag)
 295     {
 296       /* regular files */
 297     case '0':
 298     case 0:
 299     case '7':
 300       return ARCHIVE_FILE_REGULAR;
 301     case '1':
 302       return ARCHIVE_FILE_HARDLINK;
 303     case '5':
 304       return ARCHIVE_FILE_DIRECTORY;
 305     case '2':
 306       return ARCHIVE_FILE_SYMLINK;
 307     default:
 308       return ARCHIVE_FILE_INVALID;
 309     }
 310 }
 311
 312 const std::string
 313 archive_tar::linktarget ()
 314 {
 315   /* TODO: consider .. path traversal issues */
 316   if (next_file_type () == ARCHIVE_FILE_SYMLINK ||
 317       next_file_type () == ARCHIVE_FILE_HARDLINK)
 318     return state.linkname;
 319   return std::string();
 320 }
 321
 322 io_stream *
 323 archive_tar::extract_file ()
 324 {
 325   if (archive_children)
 326     return NULL;
 327   archive_tar_file *rv = new archive_tar_file (state);
 328   return rv;
 329 }
 330
 331 time_t
 332 archive_tar::get_mtime ()
 333 {
 334   if (state.parent)
 335     return state.parent->get_mtime ();
 336   return 0;
 337 }
 338
 339 mode_t
 340 archive_tar::get_mode ()
 341 {
 342   if (state.parent)
 343     return state.parent->get_mode ();
 344   return 0;
 345 }