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

// -*- mode: cpp; mode: fold -*-
// Description								/*{{{*/
// $Id: extracttar.cc,v 1.5 2002/03/26 07:38:58 jgg 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>
									/*}}}*/
    
// 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) : File(Fd), 
                         MaxInSize(Max)

{
   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);
   if (ExecWait(GZPid,_config->Find("dir::bin::gzip","/bin/gzip").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];
      Args[0] = _config->Find("dir::bin::gzip","/bin/gzip").c_str();
      Args[1] = "-d";
      Args[2] = 0;
      execv(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("Unkown 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 /{{{/
90f057fd	3	// $Id: extracttar.cc,v 1.5 2002/03/26 07:38:58 jgg 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>
b2e465d6	34	/}}}/
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	/* */
	58	ExtractTar::ExtractTar(FileFd &Fd,unsigned long Max) : File(Fd),
	59	MaxInSize(Max)
	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);
	93	if (ExecWait(GZPid,_config->Find("dir::bin::gzip","/bin/gzip").c_str(),
	94	Force) == false)
	95	{
	96	GZPid = -1;
	97	return Force;
	98	}
	99
	100	GZPid = -1;
	101	return true;
	102	}
	103	/}}}/
	104	// ExtractTar::StartGzip - Startup gzip /{{{/
	105	// ---------------------------------------------------------------------
	106	/* This creates a gzip sub process that has its input as the file itself.
	107	If this tar file is embedded into something like an ar file then
	108	gzip will efficiently ignore the extra bits. */
	109	bool ExtractTar::StartGzip()
	110	{
	111	int Pipes[2];
	112	if (pipe(Pipes) != 0)
	113	return _error->Errno("pipe","Failed to create pipes");
	114
	115	// Fork off the process
	116	GZPid = ExecFork();
	117
	118	// Spawn the subprocess
	119	if (GZPid == 0)
	120	{
	121	// Setup the FDs
	122	dup2(Pipes[1],STDOUT_FILENO);
	123	dup2(File.Fd(),STDIN_FILENO);
	124	int Fd = open("/dev/null",O_RDWR);
	125	if (Fd == -1)
	126	_exit(101);
	127	dup2(Fd,STDERR_FILENO);
	128	close(Fd);
	129	SetCloseExec(STDOUT_FILENO,false);
	130	SetCloseExec(STDIN_FILENO,false);
	131	SetCloseExec(STDERR_FILENO,false);
	132
	133	const char *Args[3];
	134	Args[0] = _config->Find("dir::bin::gzip","/bin/gzip").c_str();
	135	Args[1] = "-d";
	136	Args[2] = 0;
	137	execv(Args[0],(char **)Args);
138	cerr << "Failed to exec gzip " << Args[0] << endl;
139	_exit(100);
140	}
141
142	// Fix up our FDs
143	InFd.Fd(Pipes[0]);
144	close(Pipes[1]);
145	return true;
146	}
147	/}}}/
148	// ExtractTar::Go - Perform extraction /{{{/
149	// ---------------------------------------------------------------------
150	/* This reads each 512 byte block from the archive and extracts the header
151	information into the Item structure. Then it resolves the UID/GID and
152	invokes the correct processing function. */
153	bool ExtractTar::Go(pkgDirStream &Stream)
154	{
155	if (StartGzip() == false)
156	return false;
157
158	// Loop over all blocks
159	string LastLongLink;
160	string LastLongName;
161	while (1)
162	{
163	bool BadRecord = false;
164	unsigned char Block[512];
165	if (InFd.Read(Block,sizeof(Block),true) == false)
166	return false;
167
168	if (InFd.Eof() == true)
169	break;
170
171	// Get the checksum
172	TarHeader Tar = (TarHeader )Block;
173	unsigned long CheckSum;
174	if (StrToNum(Tar->Checksum,CheckSum,sizeof(Tar->Checksum),8) == false)
175	return _error->Error("Corrupted archive");
176
177	/* Compute the checksum field. The actual checksum is blanked out
178	with spaces so it is not included in the computation */
179	unsigned long NewSum = 0;
180	memset(Tar->Checksum,' ',sizeof(Tar->Checksum));
181	for (int I = 0; I != sizeof(Block); I++)
182	NewSum += Block[I];
183
184	/* Check for a block of nulls - in this case we kill gzip, GNU tar
185	does this.. */
186	if (NewSum == ' '*sizeof(Tar->Checksum))
187	return Done(true);
188
189	if (NewSum != CheckSum)
190	return _error->Error("Tar Checksum failed, archive corrupted");
191
192	// Decode all of the fields
193	pkgDirStream::Item Itm;
b2e465d6	194	if (StrToNum(Tar->Mode,Itm.Mode,sizeof(Tar->Mode),8) == false \|\|
4520bfdf AL	195	StrToNum(Tar->UserID,Itm.UID,sizeof(Tar->UserID),8) == false \|\|
4520bfdf AL	196	StrToNum(Tar->GroupID,Itm.GID,sizeof(Tar->GroupID),8) == false \|\|
b2e465d6 AL	197	StrToNum(Tar->Size,Itm.Size,sizeof(Tar->Size),8) == false \|\|
	198	StrToNum(Tar->MTime,Itm.MTime,sizeof(Tar->MTime),8) == false \|\|
	199	StrToNum(Tar->Major,Itm.Major,sizeof(Tar->Major),8) == false \|\|
	200	StrToNum(Tar->Minor,Itm.Minor,sizeof(Tar->Minor),8) == false)
	201	return _error->Error("Corrupted archive");
	202
	203	// Grab the filename
	204	if (LastLongName.empty() == false)
	205	Itm.Name = (char *)LastLongName.c_str();
	206	else
	207	{
	208	Tar->Name[sizeof(Tar->Name)] = 0;
	209	Itm.Name = Tar->Name;
	210	}
	211	if (Itm.Name[0] == '.' && Itm.Name[1] == '/' && Itm.Name[2] != 0)
	212	Itm.Name += 2;
	213
	214	// Grab the link target
	215	Tar->Name[sizeof(Tar->LinkName)] = 0;
	216	Itm.LinkTarget = Tar->LinkName;
	217
	218	if (LastLongLink.empty() == false)
	219	Itm.LinkTarget = (char *)LastLongLink.c_str();
	220
	221	// Convert the type over
	222	switch (Tar->LinkFlag)
	223	{
	224	case NormalFile0:
	225	case NormalFile:
	226	Itm.Type = pkgDirStream::Item::File;
	227	break;
	228
	229	case HardLink:
	230	Itm.Type = pkgDirStream::Item::HardLink;
	231	break;
	232
	233	case SymbolicLink:
	234	Itm.Type = pkgDirStream::Item::SymbolicLink;
	235	break;
	236
	237	case CharacterDevice:
	238	Itm.Type = pkgDirStream::Item::CharDevice;
	239	break;
	240
	241	case BlockDevice:
	242	Itm.Type = pkgDirStream::Item::BlockDevice;
	243	break;
	244
	245	case Directory:
	246	Itm.Type = pkgDirStream::Item::Directory;
	247	break;
	248
	249	case FIFO:
	250	Itm.Type = pkgDirStream::Item::FIFO;
	251	break;
	252
	253	case GNU_LongLink:
	254	{
	255	unsigned long Length = Itm.Size;
	256	unsigned char Block[512];
	257	while (Length > 0)
	258	{
	259	if (InFd.Read(Block,sizeof(Block),true) == false)
	260	return false;
261	if (Length <= sizeof(Block))
262	{
263	LastLongLink.append(Block,Block+sizeof(Block));
264	break;
265	}
266	LastLongLink.append(Block,Block+sizeof(Block));
267	Length -= sizeof(Block);
268	}
269	continue;
270	}
271
272	case GNU_LongName:
273	{
274	unsigned long Length = Itm.Size;
275	unsigned char Block[512];
276	while (Length > 0)
277	{
278	if (InFd.Read(Block,sizeof(Block),true) == false)
279	return false;
280	if (Length < sizeof(Block))
281	{
282	LastLongName.append(Block,Block+sizeof(Block));
283	break;
284	}
285	LastLongName.append(Block,Block+sizeof(Block));
286	Length -= sizeof(Block);
287	}
288	continue;
289	}
290
291	default:
292	BadRecord = true;
293	_error->Warning("Unkown TAR header type %u, member %s",(unsigned)Tar->LinkFlag,Tar->Name);
294	break;
295	}
296
297	int Fd = -1;
298	if (BadRecord == false)
299	if (Stream.DoItem(Itm,Fd) == false)
300	return false;
301
302	// Copy the file over the FD
303	unsigned long Size = Itm.Size;
304	while (Size != 0)
305	{
306	unsigned char Junk[32*1024];
307	unsigned long Read = MIN(Size,sizeof(Junk));
308	if (InFd.Read(Junk,((Read+511)/512)*512) == false)
309	return false;
310
311	if (BadRecord == false)
312	{
313	if (Fd > 0)
314	{
315	if (write(Fd,Junk,Read) != (signed)Read)
316	return Stream.Fail(Itm,Fd);
317	}
318	else
319	{
320	/* An Fd of -2 means to send to a special processing
321	function */
322	if (Fd == -2)
323	if (Stream.Process(Itm,Junk,Read,Itm.Size - Size) == false)
324	return Stream.Fail(Itm,Fd);
325	}
326	}
327
328	Size -= Read;
329	}
330
331	// And finish up
332	if (Itm.Size != 0 && BadRecord == false)
333	if (Stream.FinishedFile(Itm,Fd) == false)
334	return false;
335
336	LastLongName.erase();
337	LastLongLink.erase();
338	}
339
340	return Done(false);
341	}
342	/}}}/