[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							/*{{{*/
#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;
      string argv0 = _config->Find(confvar.c_str(),DecompressProg.c_str());
      Args[0] = argv0.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,(unsigned long)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 /{{{/
b2e465d6 AL	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>
90f057fd	30	#include <iostream>
d77559ac	31	#include <apti18n.h>
b2e465d6	32	/}}}/
d77559ac	33
584e4558	34	using namespace std;
4520bfdf	35
b2e465d6 AL	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	/* */
b21c0438 MZ	58	ExtractTar::ExtractTar(FileFd &Fd,unsigned long Max,string DecompressionProgram) : File(Fd),
b21c0438 MZ	59	MaxInSize(Max), DecompressProg(DecompressionProgram)
b2e465d6 AL	60
	61	{
	62	GZPid = -1;
	63	InFd = -1;
	64	Eof = false;
	65	}
	66	/}}}/
	67	// ExtractTar::ExtractTar - Destructor /{{{/
	68	// ---------------------------------------------------------------------
	69	/* */
	70	ExtractTar::~ExtractTar()
	71	{
4520bfdf AL	72	// Error close
4520bfdf AL	73	Done(true);
b2e465d6 AL	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);
b21c0438 MZ	93	string confvar = string("dir::bin::") + DecompressProg;
b21c0438 MZ	94	if (ExecWait(GZPid,_config->Find(confvar.c_str(),DecompressProg.c_str()).c_str(),
b2e465d6 AL	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)
05eb7df0	114	return _error->Errno("pipe",_("Failed to create pipes"));
b2e465d6 AL	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];
b21c0438	135	string confvar = string("dir::bin::") + DecompressProg;
a9be43ff MV	136	string argv0 = _config->Find(confvar.c_str(),DecompressProg.c_str());
a9be43ff MV	137	Args[0] = argv0.c_str();
b2e465d6 AL	138	Args[1] = "-d";
b2e465d6 AL	139	Args[2] = 0;
b21c0438	140	execvp(Args[0],(char **)Args);
05eb7df0	141	cerr << _("Failed to exec gzip ") << Args[0] << endl;
b2e465d6 AL	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)
05eb7df0	178	return _error->Error(_("Corrupted archive"));
b2e465d6 AL	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)
db0db9fe	193	return _error->Error(_("Tar checksum failed, archive corrupted"));
b2e465d6 AL	194
	195	// Decode all of the fields
	196	pkgDirStream::Item Itm;
b2e465d6	197	if (StrToNum(Tar->Mode,Itm.Mode,sizeof(Tar->Mode),8) == false \|\|
4520bfdf AL	198	StrToNum(Tar->UserID,Itm.UID,sizeof(Tar->UserID),8) == false \|\|
4520bfdf AL	199	StrToNum(Tar->GroupID,Itm.GID,sizeof(Tar->GroupID),8) == false \|\|
b2e465d6 AL	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)
05eb7df0	204	return _error->Error(_("Corrupted archive"));
b2e465d6 AL	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;
4c6a9fad	296	_error->Warning(_("Unknown TAR header type %u, member %s"),(unsigned)Tar->LinkFlag,Tar->Name);
b2e465d6 AL	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];
42ab8223	310	unsigned long Read = min(Size,(unsigned long)sizeof(Junk));
b2e465d6 AL	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	/}}}/