/// <summary>
/// Read the next entry from the zip file.
/// </summary>
///
/// <remarks>
/// <para>
/// Call this method just before calling <see cref="Read(byte[], int, int)"/>,
/// to position the pointer in the zip file to the next entry that can be
/// read. Subsequent calls to <c>Read()</c>, will decrypt and decompress the
/// data in the zip file, until <c>Read()</c> returns 0.
/// </para>
///
/// <para>
/// Each time you call <c>GetNextEntry()</c>, the pointer in the wrapped
/// stream is moved to the next entry in the zip file. If you call <see
/// cref="Seek(long, SeekOrigin)"/>, and thus re-position the pointer within
/// the file, you will need to call <c>GetNextEntry()</c> again, to insure
/// that the file pointer is positioned at the beginning of a zip entry.
/// </para>
///
/// <para>
/// This method returns the <c>ZipEntry</c>. Using a stream approach, you will
/// read the raw bytes for an entry in a zip file via calls to <c>Read()</c>.
/// Alternatively, you can extract an entry into a file, or a stream, by
/// calling <see cref="ZipEntry.Extract()"/>, or one of its siblings.
/// </para>
///
/// </remarks>
///
/// <returns>
/// The <c>ZipEntry</c> read. Returns null (or Nothing in VB) if there are no more
/// entries in the zip file.
/// </returns>
///
public ZipEntry GetNextEntry()
{
if (_findRequired)
{
// find the next signature
long d = SharedUtilities.FindSignature(_inputStream, ZipConstants.ZipEntrySignature);
if (d == -1)
{
return(null);
}
// back up 4 bytes: ReadEntry assumes the file pointer is positioned before the entry signature
_inputStream.Seek(-4, SeekOrigin.Current);
// workitem 10178
Chama.Utils.Ionic.Zip.SharedUtilities.Workaround_Ladybug318918(_inputStream);
}
// workitem 10923
else if (_firstEntry)
{
// we've already read one entry.
// Seek to the end of it.
_inputStream.Seek(_endOfEntry, SeekOrigin.Begin);
Chama.Utils.Ionic.Zip.SharedUtilities.Workaround_Ladybug318918(_inputStream);
}
_currentEntry = ZipEntry.ReadEntry(_container, !_firstEntry);
// ReadEntry leaves the file position after all the entry
// data and the optional bit-3 data descriptpr. This is
// where the next entry would normally start.
_endOfEntry = _inputStream.Position;
_firstEntry = true;
_needSetup = true;
_findRequired = false;
return(_currentEntry);
}
private static void ReadIntoInstance(ZipFile zf)
{
Stream s = zf.ReadStream;
try
{
zf._readName = zf._name; // workitem 13915
if (!s.CanSeek)
{
ReadIntoInstance_Orig(zf);
return;
}
zf.OnReadStarted();
// change for workitem 8098
//zf._originPosition = s.Position;
// Try reading the central directory, rather than scanning the file.
uint datum = ReadFirstFourBytes(s);
if (datum == ZipConstants.EndOfCentralDirectorySignature)
{
return;
}
// start at the end of the file...
// seek backwards a bit, then look for the EoCD signature.
int nTries = 0;
bool success = false;
// The size of the end-of-central-directory-footer plus 2 bytes is 18.
// This implies an archive comment length of 0. We'll add a margin of
// safety and start "in front" of that, when looking for the
// EndOfCentralDirectorySignature
long posn = s.Length - 64;
long maxSeekback = Math.Max(s.Length - 0x4000, 10);
do
{
if (posn < 0)
{
posn = 0; // BOF
}
s.Seek(posn, SeekOrigin.Begin);
long bytesRead = SharedUtilities.FindSignature(s, (int)ZipConstants.EndOfCentralDirectorySignature);
if (bytesRead != -1)
{
success = true;
}
else
{
if (posn == 0)
{
break; // started at the BOF and found nothing
}
nTries++;
// Weird: with NETCF, negative offsets from SeekOrigin.End DO
// NOT WORK. So rather than seek a negative offset, we seek
// from SeekOrigin.Begin using a smaller number.
posn -= (32 * (nTries + 1) * nTries);
}
}while (!success && posn > maxSeekback);
if (success)
{
// workitem 8299
zf._locEndOfCDS = s.Position - 4;
byte[] block = new byte[16];
s.Read(block, 0, block.Length);
zf._diskNumberWithCd = BitConverter.ToUInt16(block, 2);
if (zf._diskNumberWithCd == 0xFFFF)
{
throw new ZipException("Spanned archives with more than 65534 segments are not supported at this time.");
}
zf._diskNumberWithCd++; // I think the number in the file differs from reality by 1
int i = 12;
uint offset32 = (uint)BitConverter.ToUInt32(block, i);
if (offset32 == 0xFFFFFFFF)
{
Zip64SeekToCentralDirectory(zf);
}
else
{
zf._OffsetOfCentralDirectory = offset32;
// change for workitem 8098
s.Seek(offset32, SeekOrigin.Begin);
}
ReadCentralDirectory(zf);
}
else
{
// Could not find the central directory.
// Fallback to the old method.
// workitem 8098: ok
//s.Seek(zf._originPosition, SeekOrigin.Begin);
s.Seek(0L, SeekOrigin.Begin);
ReadIntoInstance_Orig(zf);
}
}
catch (Exception ex1)
{
if (zf._ReadStreamIsOurs && zf._readstream != null)
{
try
{
#if NETCF
zf._readstream.Close();
#else
zf._readstream.Dispose();
#endif
zf._readstream = null;
}
finally { }
}
throw new ZipException("Cannot read that as a ZipFile", ex1);
}
// the instance has been read in
zf._contentsChanged = false;
}
