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