[apt.git] / apt-inst / contrib / extracttar.cc

// -*- mode: cpp; mode: fold -*-
// Description								/*{{{*/
// $Id: extracttar.cc,v 1.8.2.1 2004/01/16 18:58:50 mdz Exp $
/* ######################################################################

   Extract a Tar - Tar Extractor

   Some performance measurements showed that zlib performed quite poorly
   in comparision to a forked gzip process. This tar extractor makes use
   of the fact that dup'd file descriptors have the same seek pointer
   and that gzip will not read past the end of a compressed stream, 
   even if there is more data. We use the dup property to track extraction
   progress and the gzip feature to just feed gzip a fd in the middle
   of an AR file. 
   
   ##################################################################### */
									/*}}}*/
// Include Files							/*{{{*/
#ifdef __GNUG__
#pragma implementation "apt-pkg/extracttar.h"
#endif
#include <apt-pkg/extracttar.h>

#include <apt-pkg/error.h>
#include <apt-pkg/strutl.h>
#include <apt-pkg/configuration.h>
#include <system.h>

#include <stdlib.h>
#include <unistd.h>
#include <signal.h>
#include <fcntl.h>
#include <iostream>
#include <apti18n.h>
									/*}}}*/

using namespace std;
    
// The on disk header for a tar file.
struct ExtractTar::TarHeader
{
   char Name[100];
   char Mode[8];
   char UserID[8];
   char GroupID[8];
   char Size[12];
   char MTime[12];
   char Checksum[8];
   char LinkFlag;
   char LinkName[100];
   char MagicNumber[8];
   char UserName[32];
   char GroupName[32];
   char Major[8];
   char Minor[8];      
};
   
// ExtractTar::ExtractTar - Constructor					/*{{{*/
// ---------------------------------------------------------------------
/* */
ExtractTar::ExtractTar(FileFd &Fd,unsigned long Max,string DecompressionProgram) : File(Fd), 
                         MaxInSize(Max), DecompressProg(DecompressionProgram)

{
   GZPid = -1;
   InFd = -1;
   Eof = false;
}
									/*}}}*/
// ExtractTar::ExtractTar - Destructor					/*{{{*/
// ---------------------------------------------------------------------
/* */
ExtractTar::~ExtractTar()
{
   // Error close
   Done(true);
}
									/*}}}*/
// ExtractTar::Done - Reap the gzip sub process				/*{{{*/
// ---------------------------------------------------------------------
/* If the force flag is given then error messages are suppressed - this
   means we hit the end of the tar file but there was still gzip data. */
bool ExtractTar::Done(bool Force)
{
   InFd.Close();
   if (GZPid <= 0)
      return true;

   /* If there is a pending error then we are cleaning up gzip and are
      not interested in it's failures */
   if (_error->PendingError() == true)
      Force = true;
   
   // Make sure we clean it up!
   kill(GZPid,SIGINT);
   string confvar = string("dir::bin::") + DecompressProg;
   if (ExecWait(GZPid,_config->Find(confvar.c_str(),DecompressProg.c_str()).c_str(),
		Force) == false)
   {
      GZPid = -1;
      return Force;
   }
   
   GZPid = -1;
   return true;
}
									/*}}}*/
// ExtractTar::StartGzip - Startup gzip					/*{{{*/
// ---------------------------------------------------------------------
/* This creates a gzip sub process that has its input as the file itself.
   If this tar file is embedded into something like an ar file then 
   gzip will efficiently ignore the extra bits. */
bool ExtractTar::StartGzip()
{
   int Pipes[2];
   if (pipe(Pipes) != 0)
      return _error->Errno("pipe",_("Failed to create pipes"));
   
   // Fork off the process
   GZPid = ExecFork();

   // Spawn the subprocess
   if (GZPid == 0)
   {
      // Setup the FDs
      dup2(Pipes[1],STDOUT_FILENO);
      dup2(File.Fd(),STDIN_FILENO);
      int Fd = open("/dev/null",O_RDWR);
      if (Fd == -1)
	 _exit(101);
      dup2(Fd,STDERR_FILENO);
      close(Fd);
      SetCloseExec(STDOUT_FILENO,false);
      SetCloseExec(STDIN_FILENO,false);      
      SetCloseExec(STDERR_FILENO,false);
      
      const char *Args[3];
      string confvar = string("dir::bin::") + DecompressProg;
      Args[0] = _config->Find(confvar.c_str(),DecompressProg.c_str()).c_str();
      Args[1] = "-d";
      Args[2] = 0;
      execvp(Args[0],(char **)Args);
      cerr << _("Failed to exec gzip ") << Args[0] << endl;
      _exit(100);
   }

   // Fix up our FDs
   InFd.Fd(Pipes[0]);
   close(Pipes[1]);
   return true;
}
									/*}}}*/
// ExtractTar::Go - Perform extraction					/*{{{*/
// ---------------------------------------------------------------------
/* This reads each 512 byte block from the archive and extracts the header
   information into the Item structure. Then it resolves the UID/GID and
   invokes the correct processing function. */
bool ExtractTar::Go(pkgDirStream &Stream)
{   
   if (StartGzip() == false)
      return false;
   
   // Loop over all blocks
   string LastLongLink;
   string LastLongName;
   while (1)
   {
      bool BadRecord = false;      
      unsigned char Block[512];      
      if (InFd.Read(Block,sizeof(Block),true) == false)
	 return false;
      
      if (InFd.Eof() == true)
	 break;

      // Get the checksum
      TarHeader *Tar = (TarHeader *)Block;
      unsigned long CheckSum;
      if (StrToNum(Tar->Checksum,CheckSum,sizeof(Tar->Checksum),8) == false)
	 return _error->Error(_("Corrupted archive"));
      
      /* Compute the checksum field. The actual checksum is blanked out
         with spaces so it is not included in the computation */
      unsigned long NewSum = 0;
      memset(Tar->Checksum,' ',sizeof(Tar->Checksum));
      for (int I = 0; I != sizeof(Block); I++)
	 NewSum += Block[I];
      
      /* Check for a block of nulls - in this case we kill gzip, GNU tar
       	 does this.. */
      if (NewSum == ' '*sizeof(Tar->Checksum))
	 return Done(true);
      
      if (NewSum != CheckSum)
	 return _error->Error(_("Tar Checksum failed, archive corrupted"));
   
      // Decode all of the fields
      pkgDirStream::Item Itm;
      if (StrToNum(Tar->Mode,Itm.Mode,sizeof(Tar->Mode),8) == false ||
	  StrToNum(Tar->UserID,Itm.UID,sizeof(Tar->UserID),8) == false ||
	  StrToNum(Tar->GroupID,Itm.GID,sizeof(Tar->GroupID),8) == false ||
	  StrToNum(Tar->Size,Itm.Size,sizeof(Tar->Size),8) == false ||
	  StrToNum(Tar->MTime,Itm.MTime,sizeof(Tar->MTime),8) == false ||
	  StrToNum(Tar->Major,Itm.Major,sizeof(Tar->Major),8) == false ||
	  StrToNum(Tar->Minor,Itm.Minor,sizeof(Tar->Minor),8) == false)
	 return _error->Error(_("Corrupted archive"));
      
      // Grab the filename
      if (LastLongName.empty() == false)
	 Itm.Name = (char *)LastLongName.c_str();
      else
      {
	 Tar->Name[sizeof(Tar->Name)] = 0;
	 Itm.Name = Tar->Name;
      }      
      if (Itm.Name[0] == '.' && Itm.Name[1] == '/' && Itm.Name[2] != 0)
	 Itm.Name += 2;
      
      // Grab the link target
      Tar->Name[sizeof(Tar->LinkName)] = 0;
      Itm.LinkTarget = Tar->LinkName;

      if (LastLongLink.empty() == false)
	 Itm.LinkTarget = (char *)LastLongLink.c_str();
      
      // Convert the type over
      switch (Tar->LinkFlag)
      {
	 case NormalFile0:
	 case NormalFile:
	 Itm.Type = pkgDirStream::Item::File;
	 break;
	 
	 case HardLink:
	 Itm.Type = pkgDirStream::Item::HardLink;
	 break;
	 
	 case SymbolicLink:
	 Itm.Type = pkgDirStream::Item::SymbolicLink;
	 break;
	 
	 case CharacterDevice:
	 Itm.Type = pkgDirStream::Item::CharDevice;
	 break;
	    
	 case BlockDevice:
	 Itm.Type = pkgDirStream::Item::BlockDevice;
	 break;
	 
	 case Directory:
	 Itm.Type = pkgDirStream::Item::Directory;
	 break;
	 
	 case FIFO:
	 Itm.Type = pkgDirStream::Item::FIFO;
	 break;

	 case GNU_LongLink:
	 {
	    unsigned long Length = Itm.Size;
	    unsigned char Block[512];
	    while (Length > 0)
	    {
	       if (InFd.Read(Block,sizeof(Block),true) == false)
		  return false;
	       if (Length <= sizeof(Block))
	       {
		  LastLongLink.append(Block,Block+sizeof(Block));
		  break;
	       }	       
	       LastLongLink.append(Block,Block+sizeof(Block));
	       Length -= sizeof(Block);
	    }
	    continue;
	 }
	 
	 case GNU_LongName:
	 {
	    unsigned long Length = Itm.Size;
	    unsigned char Block[512];
	    while (Length > 0)
	    {
	       if (InFd.Read(Block,sizeof(Block),true) == false)
		  return false;
	       if (Length < sizeof(Block))
	       {
		  LastLongName.append(Block,Block+sizeof(Block));
		  break;
	       }	       
	       LastLongName.append(Block,Block+sizeof(Block));
	       Length -= sizeof(Block);
	    }
	    continue;
	 }
	 
	 default:
	 BadRecord = true;
	 _error->Warning(_("Unknown TAR header type %u, member %s"),(unsigned)Tar->LinkFlag,Tar->Name);
	 break;
      }
      
      int Fd = -1;
      if (BadRecord == false)
	 if (Stream.DoItem(Itm,Fd) == false)
	    return false;
      
      // Copy the file over the FD
      unsigned long Size = Itm.Size;
      while (Size != 0)
      {
	 unsigned char Junk[32*1024];
	 unsigned long Read = MIN(Size,sizeof(Junk));
	 if (InFd.Read(Junk,((Read+511)/512)*512) == false)
	    return false;
	 
	 if (BadRecord == false)
	 {
	    if (Fd > 0)
	    {
	       if (write(Fd,Junk,Read) != (signed)Read)
		  return Stream.Fail(Itm,Fd);
	    }
	    else
	    {
	       /* An Fd of -2 means to send to a special processing
		  function */
	       if (Fd == -2)
		  if (Stream.Process(Itm,Junk,Read,Itm.Size - Size) == false)
		     return Stream.Fail(Itm,Fd);
	    }
	 }
	 
	 Size -= Read;
      }
      
      // And finish up
      if (Itm.Size != 0 && BadRecord == false)
	 if (Stream.FinishedFile(Itm,Fd) == false)
	    return false;
      
      LastLongName.erase();
      LastLongLink.erase();
   }
   
   return Done(false);
}
									/*}}}*/
Commit	Line	Data
b2e465d6 AL	1	// -- mode: cpp; mode: fold --
b2e465d6 AL	2	// Description /{{{/
7db98ffc	3	// $Id: extracttar.cc,v 1.8.2.1 2004/01/16 18:58:50 mdz Exp $
b2e465d6 AL	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	#ifdef __GNUG__
	20	#pragma implementation "apt-pkg/extracttar.h"
	21	#endif
	22	#include <apt-pkg/extracttar.h>
	23
	24	#include <apt-pkg/error.h>
	25	#include <apt-pkg/strutl.h>
	26	#include <apt-pkg/configuration.h>
	27	#include <system.h>
	28
	29	#include <stdlib.h>
	30	#include <unistd.h>
	31	#include <signal.h>
	32	#include <fcntl.h>
90f057fd	33	#include <iostream>
d77559ac	34	#include <apti18n.h>
b2e465d6	35	/}}}/
d77559ac	36
584e4558	37	using namespace std;
4520bfdf	38
b2e465d6 AL	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	/* */
b21c0438 MZ	61	ExtractTar::ExtractTar(FileFd &Fd,unsigned long Max,string DecompressionProgram) : File(Fd),
b21c0438 MZ	62	MaxInSize(Max), DecompressProg(DecompressionProgram)
b2e465d6 AL	63
	64	{
	65	GZPid = -1;
	66	InFd = -1;
	67	Eof = false;
	68	}
	69	/}}}/
	70	// ExtractTar::ExtractTar - Destructor /{{{/
	71	// ---------------------------------------------------------------------
	72	/* */
	73	ExtractTar::~ExtractTar()
	74	{
4520bfdf AL	75	// Error close
4520bfdf AL	76	Done(true);
b2e465d6 AL	77	}
	78	/}}}/
	79	// ExtractTar::Done - Reap the gzip sub process /{{{/
	80	// ---------------------------------------------------------------------
	81	/* If the force flag is given then error messages are suppressed - this
	82	means we hit the end of the tar file but there was still gzip data. */
	83	bool ExtractTar::Done(bool Force)
	84	{
	85	InFd.Close();
	86	if (GZPid <= 0)
	87	return true;
	88
	89	/* If there is a pending error then we are cleaning up gzip and are
	90	not interested in it's failures */
	91	if (_error->PendingError() == true)
	92	Force = true;
	93
	94	// Make sure we clean it up!
	95	kill(GZPid,SIGINT);
b21c0438 MZ	96	string confvar = string("dir::bin::") + DecompressProg;
b21c0438 MZ	97	if (ExecWait(GZPid,_config->Find(confvar.c_str(),DecompressProg.c_str()).c_str(),
b2e465d6 AL	98	Force) == false)
	99	{
	100	GZPid = -1;
	101	return Force;
	102	}
	103
	104	GZPid = -1;
	105	return true;
	106	}
	107	/}}}/
	108	// ExtractTar::StartGzip - Startup gzip /{{{/
	109	// ---------------------------------------------------------------------
	110	/* This creates a gzip sub process that has its input as the file itself.
	111	If this tar file is embedded into something like an ar file then
	112	gzip will efficiently ignore the extra bits. */
	113	bool ExtractTar::StartGzip()
	114	{
	115	int Pipes[2];
	116	if (pipe(Pipes) != 0)
05eb7df0	117	return _error->Errno("pipe",_("Failed to create pipes"));
b2e465d6 AL	118
	119	// Fork off the process
	120	GZPid = ExecFork();
	121
	122	// Spawn the subprocess
	123	if (GZPid == 0)
	124	{
	125	// Setup the FDs
	126	dup2(Pipes[1],STDOUT_FILENO);
	127	dup2(File.Fd(),STDIN_FILENO);
	128	int Fd = open("/dev/null",O_RDWR);
	129	if (Fd == -1)
	130	_exit(101);
	131	dup2(Fd,STDERR_FILENO);
	132	close(Fd);
	133	SetCloseExec(STDOUT_FILENO,false);
	134	SetCloseExec(STDIN_FILENO,false);
	135	SetCloseExec(STDERR_FILENO,false);
	136
	137	const char *Args[3];
b21c0438 MZ	138	string confvar = string("dir::bin::") + DecompressProg;
b21c0438 MZ	139	Args[0] = _config->Find(confvar.c_str(),DecompressProg.c_str()).c_str();
b2e465d6 AL	140	Args[1] = "-d";
b2e465d6 AL	141	Args[2] = 0;
b21c0438	142	execvp(Args[0],(char **)Args);
05eb7df0	143	cerr << _("Failed to exec gzip ") << Args[0] << endl;
b2e465d6 AL	144	_exit(100);
	145	}
	146
	147	// Fix up our FDs
	148	InFd.Fd(Pipes[0]);
	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)
05eb7df0	180	return _error->Error(_("Corrupted archive"));
b2e465d6 AL	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)
05eb7df0	195	return _error->Error(_("Tar Checksum failed, archive corrupted"));
b2e465d6 AL	196
	197	// Decode all of the fields
	198	pkgDirStream::Item Itm;
b2e465d6	199	if (StrToNum(Tar->Mode,Itm.Mode,sizeof(Tar->Mode),8) == false \|\|
4520bfdf AL	200	StrToNum(Tar->UserID,Itm.UID,sizeof(Tar->UserID),8) == false \|\|
4520bfdf AL	201	StrToNum(Tar->GroupID,Itm.GID,sizeof(Tar->GroupID),8) == false \|\|
b2e465d6 AL	202	StrToNum(Tar->Size,Itm.Size,sizeof(Tar->Size),8) == false \|\|
	203	StrToNum(Tar->MTime,Itm.MTime,sizeof(Tar->MTime),8) == false \|\|
	204	StrToNum(Tar->Major,Itm.Major,sizeof(Tar->Major),8) == false \|\|
	205	StrToNum(Tar->Minor,Itm.Minor,sizeof(Tar->Minor),8) == false)
05eb7df0	206	return _error->Error(_("Corrupted archive"));
b2e465d6 AL	207
	208	// Grab the filename
	209	if (LastLongName.empty() == false)
	210	Itm.Name = (char *)LastLongName.c_str();
	211	else
	212	{
	213	Tar->Name[sizeof(Tar->Name)] = 0;
	214	Itm.Name = Tar->Name;
	215	}
	216	if (Itm.Name[0] == '.' && Itm.Name[1] == '/' && Itm.Name[2] != 0)
	217	Itm.Name += 2;
	218
	219	// Grab the link target
	220	Tar->Name[sizeof(Tar->LinkName)] = 0;
	221	Itm.LinkTarget = Tar->LinkName;
	222
	223	if (LastLongLink.empty() == false)
	224	Itm.LinkTarget = (char *)LastLongLink.c_str();
	225
	226	// Convert the type over
	227	switch (Tar->LinkFlag)
	228	{
	229	case NormalFile0:
	230	case NormalFile:
	231	Itm.Type = pkgDirStream::Item::File;
	232	break;
	233
	234	case HardLink:
	235	Itm.Type = pkgDirStream::Item::HardLink;
	236	break;
	237
	238	case SymbolicLink:
	239	Itm.Type = pkgDirStream::Item::SymbolicLink;
	240	break;
	241
	242	case CharacterDevice:
	243	Itm.Type = pkgDirStream::Item::CharDevice;
	244	break;
	245
	246	case BlockDevice:
	247	Itm.Type = pkgDirStream::Item::BlockDevice;
	248	break;
	249
	250	case Directory:
	251	Itm.Type = pkgDirStream::Item::Directory;
	252	break;
	253
	254	case FIFO:
	255	Itm.Type = pkgDirStream::Item::FIFO;
	256	break;
	257
	258	case GNU_LongLink:
	259	{
	260	unsigned long Length = Itm.Size;
	261	unsigned char Block[512];
	262	while (Length > 0)
	263	{
	264	if (InFd.Read(Block,sizeof(Block),true) == false)
	265	return false;
	266	if (Length <= sizeof(Block))
	267	{
	268	LastLongLink.append(Block,Block+sizeof(Block));
	269	break;
	270	}
271	LastLongLink.append(Block,Block+sizeof(Block));
272	Length -= sizeof(Block);
273	}
274	continue;
275	}
276
277	case GNU_LongName:
278	{
279	unsigned long Length = Itm.Size;
280	unsigned char Block[512];
281	while (Length > 0)
282	{
283	if (InFd.Read(Block,sizeof(Block),true) == false)
284	return false;
285	if (Length < sizeof(Block))
286	{
287	LastLongName.append(Block,Block+sizeof(Block));
288	break;
289	}
290	LastLongName.append(Block,Block+sizeof(Block));
291	Length -= sizeof(Block);
292	}
293	continue;
294	}
295
296	default:
297	BadRecord = true;
4c6a9fad	298	_error->Warning(_("Unknown TAR header type %u, member %s"),(unsigned)Tar->LinkFlag,Tar->Name);
b2e465d6 AL	299	break;
	300	}
	301
	302	int Fd = -1;
	303	if (BadRecord == false)
	304	if (Stream.DoItem(Itm,Fd) == false)
	305	return false;
	306
	307	// Copy the file over the FD
	308	unsigned long Size = Itm.Size;
	309	while (Size != 0)
	310	{
	311	unsigned char Junk[32*1024];
	312	unsigned long Read = MIN(Size,sizeof(Junk));
	313	if (InFd.Read(Junk,((Read+511)/512)*512) == false)
	314	return false;
	315
	316	if (BadRecord == false)
	317	{
	318	if (Fd > 0)
	319	{
	320	if (write(Fd,Junk,Read) != (signed)Read)
	321	return Stream.Fail(Itm,Fd);
	322	}
	323	else
	324	{
	325	/* An Fd of -2 means to send to a special processing
	326	function */
	327	if (Fd == -2)
	328	if (Stream.Process(Itm,Junk,Read,Itm.Size - Size) == false)
	329	return Stream.Fail(Itm,Fd);
	330	}
	331	}
	332
	333	Size -= Read;
	334	}
	335
	336	// And finish up
	337	if (Itm.Size != 0 && BadRecord == false)
	338	if (Stream.FinishedFile(Itm,Fd) == false)
	339	return false;
	340
	341	LastLongName.erase();
	342	LastLongLink.erase();
	343	}
	344
	345	return Done(false);
	346	}
	347	/}}}/