[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 comparison 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<config.h>

#include <apt-pkg/dirstream.h>
#include <apt-pkg/extracttar.h>
#include <apt-pkg/error.h>
#include <apt-pkg/strutl.h>
#include <apt-pkg/configuration.h>
#include <apt-pkg/fileutl.h>

#include <string.h>
#include <algorithm>
#include <string>
#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 long Max,string DecompressionProgram)
	: File(Fd), MaxInSize(Max), DecompressProg(DecompressionProgram)
{
   GZPid = -1;
   Eof = false;
}
									/*}}}*/
// ExtractTar::ExtractTar - Destructor					/*{{{*/
// ---------------------------------------------------------------------
/* */
ExtractTar::~ExtractTar()
{
   // Error close
   Done();
}
									/*}}}*/
// ExtractTar::Done - Reap the gzip sub process				/*{{{*/
bool ExtractTar::Done(bool)
{
   return Done();
}
bool ExtractTar::Done()
{
   return InFd.Close();
}
									/*}}}*/
// 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()
{
   if (DecompressProg.empty())
   {
      InFd.OpenDescriptor(File.Fd(), FileFd::ReadOnly, FileFd::None, false);
      return true;
   }

   std::vector<APT::Configuration::Compressor> const compressors = APT::Configuration::getCompressors();
   std::vector<APT::Configuration::Compressor>::const_iterator compressor = compressors.begin();
   for (; compressor != compressors.end(); compressor++) {
      if (compressor->Name == DecompressProg) {
	 return InFd.OpenDescriptor(File.Fd(), FileFd::ReadOnly, *compressor, false);
      }
   }

   return _error->Error(_("Cannot find a configured compressor for '%s'"),
			DecompressProg.c_str());

}
									/*}}}*/
// 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, ItemLink;
   string LastLongName, ItemName;
   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();
      
      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 ||
          (Base256ToNum(Tar->UserID,Itm.UID,8) == false &&
	     StrToNum(Tar->UserID,Itm.UID,sizeof(Tar->UserID),8) == false) ||
          (Base256ToNum(Tar->GroupID,Itm.GID,8) == false &&
	     StrToNum(Tar->GroupID,Itm.GID,sizeof(Tar->GroupID),8) == false) ||
          (Base256ToNum(Tar->Size,Itm.Size,12) == false &&
	     StrToNum(Tar->Size,Itm.Size,sizeof(Tar->Size),8) == false) ||
          (Base256ToNum(Tar->MTime,Itm.MTime,12) == 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 and link target: use last long name if one was
      // set, otherwise use the header value as-is, but remember that it may
      // fill the entire 100-byte block and needs to be zero-terminated.
      // See Debian Bug #689582.
      if (LastLongName.empty() == false)
	 Itm.Name = (char *)LastLongName.c_str();
      else
	 Itm.Name = (char *)ItemName.assign(Tar->Name, sizeof(Tar->Name)).c_str();
      if (Itm.Name[0] == '.' && Itm.Name[1] == '/' && Itm.Name[2] != 0)
	 Itm.Name += 2;

      if (LastLongLink.empty() == false)
	 Itm.LinkTarget = (char *)LastLongLink.c_str();
      else
	 Itm.LinkTarget = (char *)ItemLink.assign(Tar->LinkName, sizeof(Tar->LinkName)).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 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 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 long Size = Itm.Size;
      while (Size != 0)
      {
	 unsigned char Junk[32*1024];
	 unsigned long Read = min(Size, (unsigned long 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 (BadRecord == false)
	 if (Stream.FinishedFile(Itm,Fd) == false)
	    return false;
      
      LastLongName.erase();
      LastLongLink.erase();
   }
   
   return Done();
}
									/*}}}*/
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
1e3f4083	9	in comparison to a forked gzip process. This tar extractor makes use
b2e465d6 AL	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 /{{{/
ea542140	19	#include<config.h>
b2e465d6	20
472ff00e	21	#include <apt-pkg/dirstream.h>
ea542140	22	#include <apt-pkg/extracttar.h>
b2e465d6 AL	23	#include <apt-pkg/error.h>
	24	#include <apt-pkg/strutl.h>
	25	#include <apt-pkg/configuration.h>
453b82a3	26	#include <apt-pkg/fileutl.h>
b2e465d6	27
453b82a3 DK	28	#include <string.h>
	29	#include <algorithm>
	30	#include <string>
b2e465d6 AL	31	#include <unistd.h>
	32	#include <signal.h>
	33	#include <fcntl.h>
90f057fd	34	#include <iostream>
ea542140	35
d77559ac	36	#include <apti18n.h>
b2e465d6	37	/}}}/
d77559ac	38
584e4558	39	using namespace std;
4520bfdf	40
b2e465d6 AL	41	// The on disk header for a tar file.
	42	struct ExtractTar::TarHeader
	43	{
	44	char Name[100];
	45	char Mode[8];
	46	char UserID[8];
	47	char GroupID[8];
	48	char Size[12];
	49	char MTime[12];
	50	char Checksum[8];
	51	char LinkFlag;
	52	char LinkName[100];
	53	char MagicNumber[8];
	54	char UserName[32];
	55	char GroupName[32];
	56	char Major[8];
	57	char Minor[8];
	58	};
	59
	60	// ExtractTar::ExtractTar - Constructor /{{{/
	61	// ---------------------------------------------------------------------
	62	/* */
3621b1c7 GJ	63	ExtractTar::ExtractTar(FileFd &Fd,unsigned long long Max,string DecompressionProgram)
3621b1c7 GJ	64	: File(Fd), MaxInSize(Max), DecompressProg(DecompressionProgram)
b2e465d6 AL	65	{
b2e465d6 AL	66	GZPid = -1;
b2e465d6 AL	67	Eof = false;
	68	}
	69	/}}}/
	70	// ExtractTar::ExtractTar - Destructor /{{{/
	71	// ---------------------------------------------------------------------
	72	/* */
	73	ExtractTar::~ExtractTar()
	74	{
4520bfdf	75	// Error close
b830f576	76	Done();
b2e465d6 AL	77	}
	78	/}}}/
	79	// ExtractTar::Done - Reap the gzip sub process /{{{/
b830f576 DK	80	bool ExtractTar::Done(bool)
	81	{
	82	return Done();
	83	}
	84	bool ExtractTar::Done()
b2e465d6	85	{
3564c2f4	86	return InFd.Close();
b2e465d6 AL	87	}
	88	/}}}/
	89	// ExtractTar::StartGzip - Startup gzip /{{{/
	90	// ---------------------------------------------------------------------
	91	/* This creates a gzip sub process that has its input as the file itself.
	92	If this tar file is embedded into something like an ar file then
	93	gzip will efficiently ignore the extra bits. */
	94	bool ExtractTar::StartGzip()
	95	{
3255db2d GJ	96	if (DecompressProg.empty())
	97	{
	98	InFd.OpenDescriptor(File.Fd(), FileFd::ReadOnly, FileFd::None, false);
	99	return true;
	100	}
	101
3564c2f4 JAK	102	std::vector<APT::Configuration::Compressor> const compressors = APT::Configuration::getCompressors();
	103	std::vector<APT::Configuration::Compressor>::const_iterator compressor = compressors.begin();
	104	for (; compressor != compressors.end(); compressor++) {
	105	if (compressor->Name == DecompressProg) {
	106	return InFd.OpenDescriptor(File.Fd(), FileFd::ReadOnly, *compressor, false);
	107	}
b2e465d6 AL	108	}
b2e465d6 AL	109
3564c2f4 JAK	110	return _error->Error(_("Cannot find a configured compressor for '%s'"),
	111	DecompressProg.c_str());
	112
b2e465d6 AL	113	}
	114	/}}}/
	115	// ExtractTar::Go - Perform extraction /{{{/
	116	// ---------------------------------------------------------------------
	117	/* This reads each 512 byte block from the archive and extracts the header
	118	information into the Item structure. Then it resolves the UID/GID and
	119	invokes the correct processing function. */
	120	bool ExtractTar::Go(pkgDirStream &Stream)
	121	{
	122	if (StartGzip() == false)
	123	return false;
	124
	125	// Loop over all blocks
a07b81e8 OS	126	string LastLongLink, ItemLink;
a07b81e8 OS	127	string LastLongName, ItemName;
b2e465d6 AL	128	while (1)
	129	{
	130	bool BadRecord = false;
	131	unsigned char Block[512];
	132	if (InFd.Read(Block,sizeof(Block),true) == false)
	133	return false;
	134
	135	if (InFd.Eof() == true)
	136	break;
	137
	138	// Get the checksum
	139	TarHeader Tar = (TarHeader )Block;
	140	unsigned long CheckSum;
	141	if (StrToNum(Tar->Checksum,CheckSum,sizeof(Tar->Checksum),8) == false)
05eb7df0	142	return _error->Error(_("Corrupted archive"));
b2e465d6 AL	143
	144	/* Compute the checksum field. The actual checksum is blanked out
	145	with spaces so it is not included in the computation */
	146	unsigned long NewSum = 0;
	147	memset(Tar->Checksum,' ',sizeof(Tar->Checksum));
	148	for (int I = 0; I != sizeof(Block); I++)
	149	NewSum += Block[I];
	150
	151	/* Check for a block of nulls - in this case we kill gzip, GNU tar
	152	does this.. */
	153	if (NewSum == ' '*sizeof(Tar->Checksum))
b830f576	154	return Done();
b2e465d6 AL	155
b2e465d6 AL	156	if (NewSum != CheckSum)
db0db9fe	157	return _error->Error(_("Tar checksum failed, archive corrupted"));
b2e465d6 AL	158
	159	// Decode all of the fields
	160	pkgDirStream::Item Itm;
b2e465d6	161	if (StrToNum(Tar->Mode,Itm.Mode,sizeof(Tar->Mode),8) == false \|\|
54f2f0a3 NH	162	(Base256ToNum(Tar->UserID,Itm.UID,8) == false &&
	163	StrToNum(Tar->UserID,Itm.UID,sizeof(Tar->UserID),8) == false) \|\|
	164	(Base256ToNum(Tar->GroupID,Itm.GID,8) == false &&
	165	StrToNum(Tar->GroupID,Itm.GID,sizeof(Tar->GroupID),8) == false) \|\|
	166	(Base256ToNum(Tar->Size,Itm.Size,12) == false &&
	167	StrToNum(Tar->Size,Itm.Size,sizeof(Tar->Size),8) == false) \|\|
	168	(Base256ToNum(Tar->MTime,Itm.MTime,12) == false &&
	169	StrToNum(Tar->MTime,Itm.MTime,sizeof(Tar->MTime),8) == false) \|\|
b2e465d6 AL	170	StrToNum(Tar->Major,Itm.Major,sizeof(Tar->Major),8) == false \|\|
b2e465d6 AL	171	StrToNum(Tar->Minor,Itm.Minor,sizeof(Tar->Minor),8) == false)
05eb7df0	172	return _error->Error(_("Corrupted archive"));
a07b81e8 OS	173
	174	// Grab the filename and link target: use last long name if one was
	175	// set, otherwise use the header value as-is, but remember that it may
	176	// fill the entire 100-byte block and needs to be zero-terminated.
	177	// See Debian Bug #689582.
b2e465d6 AL	178	if (LastLongName.empty() == false)
	179	Itm.Name = (char *)LastLongName.c_str();
	180	else
a07b81e8	181	Itm.Name = (char *)ItemName.assign(Tar->Name, sizeof(Tar->Name)).c_str();
b2e465d6 AL	182	if (Itm.Name[0] == '.' && Itm.Name[1] == '/' && Itm.Name[2] != 0)
b2e465d6 AL	183	Itm.Name += 2;
b2e465d6 AL	184
	185	if (LastLongLink.empty() == false)
	186	Itm.LinkTarget = (char *)LastLongLink.c_str();
a07b81e8 OS	187	else
	188	Itm.LinkTarget = (char *)ItemLink.assign(Tar->LinkName, sizeof(Tar->LinkName)).c_str();
	189
b2e465d6 AL	190	// Convert the type over
	191	switch (Tar->LinkFlag)
	192	{
	193	case NormalFile0:
	194	case NormalFile:
	195	Itm.Type = pkgDirStream::Item::File;
	196	break;
	197
	198	case HardLink:
	199	Itm.Type = pkgDirStream::Item::HardLink;
	200	break;
	201
	202	case SymbolicLink:
	203	Itm.Type = pkgDirStream::Item::SymbolicLink;
	204	break;
	205
	206	case CharacterDevice:
	207	Itm.Type = pkgDirStream::Item::CharDevice;
	208	break;
	209
	210	case BlockDevice:
	211	Itm.Type = pkgDirStream::Item::BlockDevice;
	212	break;
	213
	214	case Directory:
	215	Itm.Type = pkgDirStream::Item::Directory;
	216	break;
	217
	218	case FIFO:
	219	Itm.Type = pkgDirStream::Item::FIFO;
	220	break;
	221
	222	case GNU_LongLink:
	223	{
3621b1c7	224	unsigned long long Length = Itm.Size;
b2e465d6 AL	225	unsigned char Block[512];
	226	while (Length > 0)
	227	{
	228	if (InFd.Read(Block,sizeof(Block),true) == false)
	229	return false;
	230	if (Length <= sizeof(Block))
	231	{
	232	LastLongLink.append(Block,Block+sizeof(Block));
	233	break;
	234	}
	235	LastLongLink.append(Block,Block+sizeof(Block));
	236	Length -= sizeof(Block);
	237	}
	238	continue;
	239	}
	240
	241	case GNU_LongName:
	242	{
3621b1c7	243	unsigned long long Length = Itm.Size;
b2e465d6 AL	244	unsigned char Block[512];
	245	while (Length > 0)
	246	{
	247	if (InFd.Read(Block,sizeof(Block),true) == false)
	248	return false;
	249	if (Length < sizeof(Block))
	250	{
	251	LastLongName.append(Block,Block+sizeof(Block));
	252	break;
	253	}
	254	LastLongName.append(Block,Block+sizeof(Block));
	255	Length -= sizeof(Block);
	256	}
	257	continue;
	258	}
	259
	260	default:
	261	BadRecord = true;
4c6a9fad	262	_error->Warning(_("Unknown TAR header type %u, member %s"),(unsigned)Tar->LinkFlag,Tar->Name);
b2e465d6 AL	263	break;
	264	}
	265
	266	int Fd = -1;
	267	if (BadRecord == false)
	268	if (Stream.DoItem(Itm,Fd) == false)
	269	return false;
	270
	271	// Copy the file over the FD
3621b1c7	272	unsigned long long Size = Itm.Size;
b2e465d6 AL	273	while (Size != 0)
	274	{
	275	unsigned char Junk[32*1024];
3621b1c7	276	unsigned long Read = min(Size, (unsigned long long)sizeof(Junk));
b2e465d6 AL	277	if (InFd.Read(Junk,((Read+511)/512)*512) == false)
	278	return false;
	279
	280	if (BadRecord == false)
	281	{
	282	if (Fd > 0)
	283	{
	284	if (write(Fd,Junk,Read) != (signed)Read)
	285	return Stream.Fail(Itm,Fd);
	286	}
	287	else
	288	{
	289	/* An Fd of -2 means to send to a special processing
	290	function */
	291	if (Fd == -2)
	292	if (Stream.Process(Itm,Junk,Read,Itm.Size - Size) == false)
	293	return Stream.Fail(Itm,Fd);
	294	}
	295	}
	296
	297	Size -= Read;
	298	}
	299
	300	// And finish up
59152cdb	301	if (BadRecord == false)
b2e465d6 AL	302	if (Stream.FinishedFile(Itm,Fd) == false)
	303	return false;
	304
	305	LastLongName.erase();
	306	LastLongLink.erase();
	307	}
	308
b830f576	309	return Done();
b2e465d6 AL	310	}
b2e465d6 AL	311	/}}}/