[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<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/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;
   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.OpenDescriptor(Pipes[0], FileFd::ReadOnly, FileFd::None, true);
   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, 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(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 ||
          (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 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 (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 /{{{/
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>
aea7f4c8	26	#include <apt-pkg/macros.h>
b2e465d6 AL	27
	28	#include <stdlib.h>
	29	#include <unistd.h>
	30	#include <signal.h>
	31	#include <fcntl.h>
90f057fd	32	#include <iostream>
ea542140	33
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;
b2e465d6 AL	66	Eof = false;
	67	}
	68	/}}}/
	69	// ExtractTar::ExtractTar - Destructor /{{{/
	70	// ---------------------------------------------------------------------
	71	/* */
	72	ExtractTar::~ExtractTar()
	73	{
4520bfdf AL	74	// Error close
4520bfdf AL	75	Done(true);
b2e465d6 AL	76	}
	77	/}}}/
	78	// ExtractTar::Done - Reap the gzip sub process /{{{/
	79	// ---------------------------------------------------------------------
	80	/* If the force flag is given then error messages are suppressed - this
	81	means we hit the end of the tar file but there was still gzip data. */
	82	bool ExtractTar::Done(bool Force)
	83	{
	84	InFd.Close();
	85	if (GZPid <= 0)
	86	return true;
	87
	88	/* If there is a pending error then we are cleaning up gzip and are
	89	not interested in it's failures */
	90	if (_error->PendingError() == true)
	91	Force = true;
	92
	93	// Make sure we clean it up!
	94	kill(GZPid,SIGINT);
b21c0438 MZ	95	string confvar = string("dir::bin::") + DecompressProg;
b21c0438 MZ	96	if (ExecWait(GZPid,_config->Find(confvar.c_str(),DecompressProg.c_str()).c_str(),
b2e465d6 AL	97	Force) == false)
	98	{
	99	GZPid = -1;
	100	return Force;
	101	}
	102
	103	GZPid = -1;
	104	return true;
	105	}
	106	/}}}/
	107	// ExtractTar::StartGzip - Startup gzip /{{{/
	108	// ---------------------------------------------------------------------
	109	/* This creates a gzip sub process that has its input as the file itself.
	110	If this tar file is embedded into something like an ar file then
	111	gzip will efficiently ignore the extra bits. */
	112	bool ExtractTar::StartGzip()
	113	{
	114	int Pipes[2];
	115	if (pipe(Pipes) != 0)
05eb7df0	116	return _error->Errno("pipe",_("Failed to create pipes"));
b2e465d6 AL	117
	118	// Fork off the process
	119	GZPid = ExecFork();
	120
	121	// Spawn the subprocess
	122	if (GZPid == 0)
	123	{
	124	// Setup the FDs
	125	dup2(Pipes[1],STDOUT_FILENO);
	126	dup2(File.Fd(),STDIN_FILENO);
	127	int Fd = open("/dev/null",O_RDWR);
	128	if (Fd == -1)
	129	_exit(101);
	130	dup2(Fd,STDERR_FILENO);
	131	close(Fd);
	132	SetCloseExec(STDOUT_FILENO,false);
	133	SetCloseExec(STDIN_FILENO,false);
	134	SetCloseExec(STDERR_FILENO,false);
	135
	136	const char *Args[3];
b21c0438	137	string confvar = string("dir::bin::") + DecompressProg;
a9be43ff MV	138	string argv0 = _config->Find(confvar.c_str(),DecompressProg.c_str());
a9be43ff MV	139	Args[0] = argv0.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
2448a064	148	InFd.OpenDescriptor(Pipes[0], FileFd::ReadOnly, FileFd::None, true);
b2e465d6 AL	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
a07b81e8 OS	164	string LastLongLink, ItemLink;
a07b81e8 OS	165	string LastLongName, ItemName;
b2e465d6 AL	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)
db0db9fe	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 \|\|
54f2f0a3 NH	200	(Base256ToNum(Tar->UserID,Itm.UID,8) == false &&
	201	StrToNum(Tar->UserID,Itm.UID,sizeof(Tar->UserID),8) == false) \|\|
	202	(Base256ToNum(Tar->GroupID,Itm.GID,8) == false &&
	203	StrToNum(Tar->GroupID,Itm.GID,sizeof(Tar->GroupID),8) == false) \|\|
	204	(Base256ToNum(Tar->Size,Itm.Size,12) == false &&
	205	StrToNum(Tar->Size,Itm.Size,sizeof(Tar->Size),8) == false) \|\|
	206	(Base256ToNum(Tar->MTime,Itm.MTime,12) == false &&
	207	StrToNum(Tar->MTime,Itm.MTime,sizeof(Tar->MTime),8) == false) \|\|
b2e465d6 AL	208	StrToNum(Tar->Major,Itm.Major,sizeof(Tar->Major),8) == false \|\|
b2e465d6 AL	209	StrToNum(Tar->Minor,Itm.Minor,sizeof(Tar->Minor),8) == false)
05eb7df0	210	return _error->Error(_("Corrupted archive"));
a07b81e8 OS	211
	212	// Grab the filename and link target: use last long name if one was
	213	// set, otherwise use the header value as-is, but remember that it may
	214	// fill the entire 100-byte block and needs to be zero-terminated.
	215	// See Debian Bug #689582.
b2e465d6 AL	216	if (LastLongName.empty() == false)
	217	Itm.Name = (char *)LastLongName.c_str();
	218	else
a07b81e8	219	Itm.Name = (char *)ItemName.assign(Tar->Name, sizeof(Tar->Name)).c_str();
b2e465d6 AL	220	if (Itm.Name[0] == '.' && Itm.Name[1] == '/' && Itm.Name[2] != 0)
b2e465d6 AL	221	Itm.Name += 2;
b2e465d6 AL	222
	223	if (LastLongLink.empty() == false)
	224	Itm.LinkTarget = (char *)LastLongLink.c_str();
a07b81e8 OS	225	else
	226	Itm.LinkTarget = (char *)ItemLink.assign(Tar->LinkName, sizeof(Tar->LinkName)).c_str();
	227
b2e465d6 AL	228	// Convert the type over
	229	switch (Tar->LinkFlag)
	230	{
	231	case NormalFile0:
	232	case NormalFile:
	233	Itm.Type = pkgDirStream::Item::File;
	234	break;
	235
	236	case HardLink:
	237	Itm.Type = pkgDirStream::Item::HardLink;
	238	break;
	239
	240	case SymbolicLink:
	241	Itm.Type = pkgDirStream::Item::SymbolicLink;
	242	break;
	243
	244	case CharacterDevice:
	245	Itm.Type = pkgDirStream::Item::CharDevice;
	246	break;
	247
	248	case BlockDevice:
	249	Itm.Type = pkgDirStream::Item::BlockDevice;
	250	break;
	251
	252	case Directory:
	253	Itm.Type = pkgDirStream::Item::Directory;
	254	break;
	255
	256	case FIFO:
	257	Itm.Type = pkgDirStream::Item::FIFO;
	258	break;
	259
	260	case GNU_LongLink:
	261	{
	262	unsigned long Length = Itm.Size;
	263	unsigned char Block[512];
	264	while (Length > 0)
	265	{
	266	if (InFd.Read(Block,sizeof(Block),true) == false)
	267	return false;
	268	if (Length <= sizeof(Block))
	269	{
	270	LastLongLink.append(Block,Block+sizeof(Block));
	271	break;
	272	}
	273	LastLongLink.append(Block,Block+sizeof(Block));
	274	Length -= sizeof(Block);
	275	}
	276	continue;
	277	}
	278
	279	case GNU_LongName:
	280	{
	281	unsigned long Length = Itm.Size;
	282	unsigned char Block[512];
	283	while (Length > 0)
	284	{
	285	if (InFd.Read(Block,sizeof(Block),true) == false)
	286	return false;
	287	if (Length < sizeof(Block))
	288	{
	289	LastLongName.append(Block,Block+sizeof(Block));
	290	break;
	291	}
292	LastLongName.append(Block,Block+sizeof(Block));
293	Length -= sizeof(Block);
294	}
295	continue;
296	}
297
298	default:
299	BadRecord = true;
4c6a9fad	300	_error->Warning(_("Unknown TAR header type %u, member %s"),(unsigned)Tar->LinkFlag,Tar->Name);
b2e465d6 AL	301	break;
	302	}
	303
	304	int Fd = -1;
	305	if (BadRecord == false)
	306	if (Stream.DoItem(Itm,Fd) == false)
	307	return false;
	308
	309	// Copy the file over the FD
	310	unsigned long Size = Itm.Size;
	311	while (Size != 0)
	312	{
	313	unsigned char Junk[32*1024];
42ab8223	314	unsigned long Read = min(Size,(unsigned long)sizeof(Junk));
b2e465d6 AL	315	if (InFd.Read(Junk,((Read+511)/512)*512) == false)
	316	return false;
	317
	318	if (BadRecord == false)
	319	{
	320	if (Fd > 0)
	321	{
	322	if (write(Fd,Junk,Read) != (signed)Read)
	323	return Stream.Fail(Itm,Fd);
	324	}
	325	else
	326	{
	327	/* An Fd of -2 means to send to a special processing
	328	function */
	329	if (Fd == -2)
	330	if (Stream.Process(Itm,Junk,Read,Itm.Size - Size) == false)
	331	return Stream.Fail(Itm,Fd);
	332	}
	333	}
	334
	335	Size -= Read;
	336	}
	337
	338	// And finish up
59152cdb	339	if (BadRecord == false)
b2e465d6 AL	340	if (Stream.FinishedFile(Itm,Fd) == false)
	341	return false;
	342
	343	LastLongName.erase();
	344	LastLongLink.erase();
	345	}
	346
	347	return Done(false);
	348	}
	349	/}}}/