[apt-legacy.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 <apt-pkg/macros.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)-1] = 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)-1] = 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
da6ee469 JF	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 /{{{/
da6ee469 JF	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>
0e5943eb	24	#include <apt-pkg/macros.h>
da6ee469 JF	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	{
00ec24d0	211	Tar->Name[sizeof(Tar->Name)-1] = 0;
da6ee469 JF	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
00ec24d0	218	Tar->Name[sizeof(Tar->LinkName)-1] = 0;
da6ee469 JF	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
00ec24d0	335	if (Itm.Size >= 0 && BadRecord == false)
da6ee469 JF	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	/}}}/