apt-inst/contrib/extracttar.cc

   1 // -*- mode: cpp; mode: fold -*-
   2 // Description                                                          /*{{{*/
   3 // $Id: extracttar.cc,v 1.8.2.1 2004/01/16 18:58:50 mdz Exp $
   4 /* ######################################################################
   5
   6    Extract a Tar - Tar Extractor
   7
   8    Some performance measurements showed that zlib performed quite poorly
   9    in comparision to a forked gzip process. This tar extractor makes use
  10    of the fact that dup'd file descriptors have the same seek pointer
  11    and that gzip will not read past the end of a compressed stream,
  12    even if there is more data. We use the dup property to track extraction
  13    progress and the gzip feature to just feed gzip a fd in the middle
  14    of an AR file.
  15
  16    ##################################################################### */
  17                                                                         /*}}}*/
  18 // Include Files                                                        /*{{{*/
  19 #include<config.h>
  20
  21 #include <apt-pkg/dirstream.h>
  22 #include <apt-pkg/extracttar.h>
  23 #include <apt-pkg/error.h>
  24 #include <apt-pkg/strutl.h>
  25 #include <apt-pkg/configuration.h>
  26 #include <apt-pkg/macros.h>
  27
  28 #include <stdlib.h>
  29 #include <unistd.h>
  30 #include <signal.h>
  31 #include <fcntl.h>
  32 #include <iostream>
  33
  34 #include <apti18n.h>
  35                                                                         /*}}}*/
  36
  37 using namespace std;
  38
  39 // The on disk header for a tar file.
  40 struct ExtractTar::TarHeader
  41 {
  42    char Name[100];
  43    char Mode[8];
  44    char UserID[8];
  45    char GroupID[8];
  46    char Size[12];
  47    char MTime[12];
  48    char Checksum[8];
  49    char LinkFlag;
  50    char LinkName[100];
  51    char MagicNumber[8];
  52    char UserName[32];
  53    char GroupName[32];
  54    char Major[8];
  55    char Minor[8];
  56 };
  57
  58 // ExtractTar::ExtractTar - Constructor                                 /*{{{*/
  59 // ---------------------------------------------------------------------
  60 /* */
  61 ExtractTar::ExtractTar(FileFd &Fd,unsigned long Max,string DecompressionProgram) : File(Fd),
  62                          MaxInSize(Max), DecompressProg(DecompressionProgram)
  63
  64 {
  65    GZPid = -1;
  66    Eof = false;
  67 }
  68                                                                         /*}}}*/
  69 // ExtractTar::ExtractTar - Destructor                                  /*{{{*/
  70 // ---------------------------------------------------------------------
  71 /* */
  72 ExtractTar::~ExtractTar()
  73 {
  74    // Error close
  75    Done(true);
  76 }
  77                                                                         /*}}}*/
  78 // ExtractTar::Done - Reap the gzip sub process                         /*{{{*/
  79 // ---------------------------------------------------------------------
  80 /* If the force flag is given then error messages are suppressed - this
  81    means we hit the end of the tar file but there was still gzip data. */
  82 bool ExtractTar::Done(bool Force)
  83 {
  84    InFd.Close();
  85    if (GZPid <= 0)
  86       return true;
  87
  88    /* If there is a pending error then we are cleaning up gzip and are
  89       not interested in it's failures */
  90    if (_error->PendingError() == true)
  91       Force = true;
  92
  93    // Make sure we clean it up!
  94    kill(GZPid,SIGINT);
  95    string confvar = string("dir::bin::") + DecompressProg;
  96    if (ExecWait(GZPid,_config->Find(confvar.c_str(),DecompressProg.c_str()).c_str(),
  97                 Force) == false)
  98    {
  99       GZPid = -1;
 100       return Force;
 101    }
 102
 103    GZPid = -1;
 104    return true;
 105 }
 106                                                                         /*}}}*/
 107 // ExtractTar::StartGzip - Startup gzip                                 /*{{{*/
 108 // ---------------------------------------------------------------------
 109 /* This creates a gzip sub process that has its input as the file itself.
 110    If this tar file is embedded into something like an ar file then
 111    gzip will efficiently ignore the extra bits. */
 112 bool ExtractTar::StartGzip()
 113 {
 114    int Pipes[2];
 115    if (pipe(Pipes) != 0)
 116       return _error->Errno("pipe",_("Failed to create pipes"));
 117
 118    // Fork off the process
 119    GZPid = ExecFork();
 120
 121    // Spawn the subprocess
 122    if (GZPid == 0)
 123    {
 124       // Setup the FDs
 125       dup2(Pipes[1],STDOUT_FILENO);
 126       dup2(File.Fd(),STDIN_FILENO);
 127       int Fd = open("/dev/null",O_RDWR);
 128       if (Fd == -1)
 129          _exit(101);
 130       dup2(Fd,STDERR_FILENO);
 131       close(Fd);
 132       SetCloseExec(STDOUT_FILENO,false);
 133       SetCloseExec(STDIN_FILENO,false);
 134       SetCloseExec(STDERR_FILENO,false);
 135
 136       const char *Args[3];
 137       string confvar = string("dir::bin::") + DecompressProg;
 138       string argv0 = _config->Find(confvar.c_str(),DecompressProg.c_str());
 139       Args[0] = argv0.c_str();
 140       Args[1] = "-d";
 141       Args[2] = 0;
 142       execvp(Args[0],(char **)Args);
 143       cerr << _("Failed to exec gzip ") << Args[0] << endl;
 144       _exit(100);
 145    }
 146
 147    // Fix up our FDs
 148    InFd.OpenDescriptor(Pipes[0], FileFd::ReadOnly, FileFd::None, true);
 149    close(Pipes[1]);
 150    return true;
 151 }
 152                                                                         /*}}}*/
 153 // ExtractTar::Go - Perform extraction                                  /*{{{*/
 154 // ---------------------------------------------------------------------
 155 /* This reads each 512 byte block from the archive and extracts the header
 156    information into the Item structure. Then it resolves the UID/GID and
 157    invokes the correct processing function. */
 158 bool ExtractTar::Go(pkgDirStream &Stream)
 159 {
 160    if (StartGzip() == false)
 161       return false;
 162
 163    // Loop over all blocks
 164    string LastLongLink;
 165    string LastLongName;
 166    while (1)
 167    {
 168       bool BadRecord = false;
 169       unsigned char Block[512];
 170       if (InFd.Read(Block,sizeof(Block),true) == false)
 171          return false;
 172
 173       if (InFd.Eof() == true)
 174          break;
 175
 176       // Get the checksum
 177       TarHeader *Tar = (TarHeader *)Block;
 178       unsigned long CheckSum;
 179       if (StrToNum(Tar->Checksum,CheckSum,sizeof(Tar->Checksum),8) == false)
 180          return _error->Error(_("Corrupted archive"));
 181
 182       /* Compute the checksum field. The actual checksum is blanked out
 183          with spaces so it is not included in the computation */
 184       unsigned long NewSum = 0;
 185       memset(Tar->Checksum,' ',sizeof(Tar->Checksum));
 186       for (int I = 0; I != sizeof(Block); I++)
 187          NewSum += Block[I];
 188
 189       /* Check for a block of nulls - in this case we kill gzip, GNU tar
 190          does this.. */
 191       if (NewSum == ' '*sizeof(Tar->Checksum))
 192          return Done(true);
 193
 194       if (NewSum != CheckSum)
 195          return _error->Error(_("Tar checksum failed, archive corrupted"));
 196
 197       // Decode all of the fields
 198       pkgDirStream::Item Itm;
 199       if (StrToNum(Tar->Mode,Itm.Mode,sizeof(Tar->Mode),8) == false ||
 200           (Base256ToNum(Tar->UserID,Itm.UID,8) == false &&
 201              StrToNum(Tar->UserID,Itm.UID,sizeof(Tar->UserID),8) == false) ||
 202           (Base256ToNum(Tar->GroupID,Itm.GID,8) == false &&
 203              StrToNum(Tar->GroupID,Itm.GID,sizeof(Tar->GroupID),8) == false) ||
 204           (Base256ToNum(Tar->Size,Itm.Size,12) == false &&
 205              StrToNum(Tar->Size,Itm.Size,sizeof(Tar->Size),8) == false) ||
 206           (Base256ToNum(Tar->MTime,Itm.MTime,12) == false &&
 207              StrToNum(Tar->MTime,Itm.MTime,sizeof(Tar->MTime),8) == false) ||
 208           StrToNum(Tar->Major,Itm.Major,sizeof(Tar->Major),8) == false ||
 209           StrToNum(Tar->Minor,Itm.Minor,sizeof(Tar->Minor),8) == false)
 210          return _error->Error(_("Corrupted archive"));
 211
 212       // Grab the filename
 213       if (LastLongName.empty() == false)
 214          Itm.Name = (char *)LastLongName.c_str();
 215       else
 216       {
 217          Tar->Name[sizeof(Tar->Name)-1] = 0;
 218          Itm.Name = Tar->Name;
 219       }
 220       if (Itm.Name[0] == '.' && Itm.Name[1] == '/' && Itm.Name[2] != 0)
 221          Itm.Name += 2;
 222
 223       // Grab the link target
 224       Tar->Name[sizeof(Tar->LinkName)-1] = 0;
 225       Itm.LinkTarget = Tar->LinkName;
 226
 227       if (LastLongLink.empty() == false)
 228          Itm.LinkTarget = (char *)LastLongLink.c_str();
 229
 230       // Convert the type over
 231       switch (Tar->LinkFlag)
 232       {
 233          case NormalFile0:
 234          case NormalFile:
 235          Itm.Type = pkgDirStream::Item::File;
 236          break;
 237
 238          case HardLink:
 239          Itm.Type = pkgDirStream::Item::HardLink;
 240          break;
 241
 242          case SymbolicLink:
 243          Itm.Type = pkgDirStream::Item::SymbolicLink;
 244          break;
 245
 246          case CharacterDevice:
 247          Itm.Type = pkgDirStream::Item::CharDevice;
 248          break;
 249
 250          case BlockDevice:
 251          Itm.Type = pkgDirStream::Item::BlockDevice;
 252          break;
 253
 254          case Directory:
 255          Itm.Type = pkgDirStream::Item::Directory;
 256          break;
 257
 258          case FIFO:
 259          Itm.Type = pkgDirStream::Item::FIFO;
 260          break;
 261
 262          case GNU_LongLink:
 263          {
 264             unsigned long Length = Itm.Size;
 265             unsigned char Block[512];
 266             while (Length > 0)
 267             {
 268                if (InFd.Read(Block,sizeof(Block),true) == false)
 269                   return false;
 270                if (Length <= sizeof(Block))
 271                {
 272                   LastLongLink.append(Block,Block+sizeof(Block));
 273                   break;
 274                }
 275                LastLongLink.append(Block,Block+sizeof(Block));
 276                Length -= sizeof(Block);
 277             }
 278             continue;
 279          }
 280
 281          case GNU_LongName:
 282          {
 283             unsigned long Length = Itm.Size;
 284             unsigned char Block[512];
 285             while (Length > 0)
 286             {
 287                if (InFd.Read(Block,sizeof(Block),true) == false)
 288                   return false;
 289                if (Length < sizeof(Block))
 290                {
 291                   LastLongName.append(Block,Block+sizeof(Block));
 292                   break;
 293                }
 294                LastLongName.append(Block,Block+sizeof(Block));
 295                Length -= sizeof(Block);
 296             }
 297             continue;
 298          }
 299
 300          default:
 301          BadRecord = true;
 302          _error->Warning(_("Unknown TAR header type %u, member %s"),(unsigned)Tar->LinkFlag,Tar->Name);
 303          break;
 304       }
 305
 306       int Fd = -1;
 307       if (BadRecord == false)
 308          if (Stream.DoItem(Itm,Fd) == false)
 309             return false;
 310
 311       // Copy the file over the FD
 312       unsigned long Size = Itm.Size;
 313       while (Size != 0)
 314       {
 315          unsigned char Junk[32*1024];
 316          unsigned long Read = min(Size,(unsigned long)sizeof(Junk));
 317          if (InFd.Read(Junk,((Read+511)/512)*512) == false)
 318             return false;
 319
 320          if (BadRecord == false)
 321          {
 322             if (Fd > 0)
 323             {
 324                if (write(Fd,Junk,Read) != (signed)Read)
 325                   return Stream.Fail(Itm,Fd);
 326             }
 327             else
 328             {
 329                /* An Fd of -2 means to send to a special processing
 330                   function */
 331                if (Fd == -2)
 332                   if (Stream.Process(Itm,Junk,Read,Itm.Size - Size) == false)
 333                      return Stream.Fail(Itm,Fd);
 334             }
 335          }
 336
 337          Size -= Read;
 338       }
 339
 340       // And finish up
 341       if (BadRecord == false)
 342          if (Stream.FinishedFile(Itm,Fd) == false)
 343             return false;
 344
 345       LastLongName.erase();
 346       LastLongLink.erase();
 347    }
 348
 349    return Done(false);
 350 }
 351                                                                         /*}}}*/