public static bool IsZipMulti(Stream stream, string password = null)
{
StreamingZipHeaderFactory headerFactory = new StreamingZipHeaderFactory(password, new ArchiveEncoding());
try
{
ZipHeader header = headerFactory.ReadStreamHeader(stream).FirstOrDefault(x => x.ZipHeaderType != ZipHeaderType.Split);
if (header is null)
{
if (stream.CanSeek) //could be multipart. Test for central directory - might not be z64 safe
{
SeekableZipHeaderFactory z = new SeekableZipHeaderFactory(password, new ArchiveEncoding());
var x = z.ReadSeekableHeader(stream).FirstOrDefault();
return(x?.ZipHeaderType == ZipHeaderType.DirectoryEntry);
}
else
{
return(false);
}
}
return(Enum.IsDefined(typeof(ZipHeaderType), header.ZipHeaderType));
}
catch (CryptographicException)
{
return(true);
}
catch
{
return(false);
}
}
internal IEnumerable <ZipHeader> ReadStreamHeader(Stream stream)
{
RewindableStream rewindableStream;
if (stream is RewindableStream)
{
rewindableStream = stream as RewindableStream;
}
else
{
rewindableStream = new RewindableStream(stream);
}
while (true)
{
ZipHeader header = null;
BinaryReader reader = new BinaryReader(rewindableStream);
if (_lastEntryHeader != null &&
(FlagUtility.HasFlag(_lastEntryHeader.Flags, HeaderFlags.UsePostDataDescriptor) || _lastEntryHeader.IsZip64))
{
reader = (_lastEntryHeader.Part as StreamingZipFilePart).FixStreamedFileLocation(ref rewindableStream);
long?pos = rewindableStream.CanSeek ? (long?)rewindableStream.Position : null;
uint crc = reader.ReadUInt32();
if (crc == POST_DATA_DESCRIPTOR)
{
crc = reader.ReadUInt32();
}
_lastEntryHeader.Crc = crc;
_lastEntryHeader.CompressedSize = reader.ReadUInt32();
_lastEntryHeader.UncompressedSize = reader.ReadUInt32();
if (pos.HasValue)
{
_lastEntryHeader.DataStartPosition = pos - _lastEntryHeader.CompressedSize;
}
}
_lastEntryHeader = null;
uint headerBytes = reader.ReadUInt32();
header = ReadHeader(headerBytes, reader);
if (header == null)
{
yield break;
}
//entry could be zero bytes so we need to know that.
if (header.ZipHeaderType == ZipHeaderType.LocalEntry)
{
bool isRecording = rewindableStream.IsRecording;
if (!isRecording)
{
rewindableStream.StartRecording();
}
uint nextHeaderBytes = reader.ReadUInt32();
header.HasData = !IsHeader(nextHeaderBytes);
rewindableStream.Rewind(!isRecording);
}
yield return(header);
}
}
internal static IEnumerable <ZipHeader> ReadHeaderNonseekable(Stream stream)
{
while (true)
{
ZipHeader header = null;
try
{
MarkingBinaryReader reader = new MarkingBinaryReader(stream);
uint headerBytes = reader.ReadUInt32();
switch (headerBytes)
{
case ENTRY_HEADER_BYTES:
{
var entry = new LocalEntryHeader();
entry.Read(reader);
if (entry.CompressedSize > 0)
{
entry.PackedStream = new ReadOnlySubStream(stream, entry.CompressedSize, true);
}
header = entry;
}
break;
case DIRECTORY_START_HEADER_BYTES:
{
var entry = new DirectoryEntryHeader();
entry.Read(reader);
header = entry;
}
break;
case POST_DATA_DESCRIPTOR:
case DIGITAL_SIGNATURE:
break;
case DIRECTORY_END_HEADER_BYTES:
{
var entry = new DirectoryEndHeader();
entry.Read(reader);
header = entry;
}
break;
case ZIP64_END_OF_CENTRAL_DIRECTORY:
default:
break;
}
}
catch
{
header = null;
}
yield return(header);
}
}
public static bool IsZipFile(Stream stream)
{
try
{
ZipHeader header = ZipHeaderFactory.ReadHeaderNonseekable(stream).FirstOrDefault();
if (header == null)
{
return(false);
}
return(Enum.IsDefined(typeof(ZipHeaderType), header.ZipHeaderType));
}
catch
{
return(false);
}
}
internal IEnumerable <ZipHeader> ReadStreamHeader(Stream stream)
{
RewindableStream iteratorVariable0;
if (stream is RewindableStream)
{
iteratorVariable0 = stream as RewindableStream;
}
else
{
iteratorVariable0 = new RewindableStream(stream);
}
while (true)
{
ZipHeader iteratorVariable1 = null;
BinaryReader reader = new BinaryReader(iteratorVariable0);
if ((this.lastEntryHeader != null) && FlagUtility.HasFlag <HeaderFlags>(this.lastEntryHeader.Flags, HeaderFlags.UsePostDataDescriptor))
{
reader = (this.lastEntryHeader.Part as StreamingZipFilePart).FixStreamedFileLocation(ref iteratorVariable0);
long position = iteratorVariable0.Position;
uint num2 = reader.ReadUInt32();
if (num2 == 0x8074b50)
{
num2 = reader.ReadUInt32();
}
this.lastEntryHeader.Crc = num2;
this.lastEntryHeader.CompressedSize = reader.ReadUInt32();
this.lastEntryHeader.UncompressedSize = reader.ReadUInt32();
this.lastEntryHeader.DataStartPosition = new long?(position - this.lastEntryHeader.CompressedSize);
}
this.lastEntryHeader = null;
uint iteratorVariable3 = reader.ReadUInt32();
iteratorVariable1 = this.ReadHeader(iteratorVariable3, reader);
if (iteratorVariable1.ZipHeaderType == ZipHeaderType.LocalEntry)
{
bool isRecording = iteratorVariable0.IsRecording;
if (!isRecording)
{
iteratorVariable0.StartRecording();
}
uint headerBytes = reader.ReadUInt32();
iteratorVariable1.HasData = !ZipHeaderFactory.IsHeader(headerBytes);
iteratorVariable0.Rewind(!isRecording);
}
yield return(iteratorVariable1);
}
}
public static bool IsZipFile(Stream stream, string password = null)
{
StreamingZipHeaderFactory headerFactory = new StreamingZipHeaderFactory(password, new ArchiveEncoding());
try
{
ZipHeader header = headerFactory.ReadStreamHeader(stream).FirstOrDefault(x => x.ZipHeaderType != ZipHeaderType.Split);
if (header is null)
{
return(false);
}
return(Enum.IsDefined(typeof(ZipHeaderType), header.ZipHeaderType));
}
catch (CryptographicException)
{
return(true);
}
catch
{
return(false);
}
}
public static bool IsZipFile(Stream stream, string password)
{
StreamingZipHeaderFactory factory = new StreamingZipHeaderFactory(password);
try
{
ZipHeader header = Enumerable.FirstOrDefault <ZipHeader>(factory.ReadStreamHeader(stream), delegate(ZipHeader x) {
return(x.ZipHeaderType != ZipHeaderType.Split);
});
if (header == null)
{
return(false);
}
return(Enum.IsDefined(typeof(ZipHeaderType), header.ZipHeaderType));
}
catch (CryptographicException)
{
return(true);
}
catch
{
return(false);
}
}
public ZipDirHeader(BinaryReader br)
{
Version = br.ReadUInt16();
Header = new ZipHeader(br);
FileCommentLength = br.ReadUInt16();
DiskNumberStart = br.ReadUInt16();
InternalFileAttrs = br.ReadUInt16();
Attrs = br.ReadUInt32();
Position = br.ReadUInt32();
Filename = br.ReadBytes(Header.FilenameLength);
var exlen = Header.ExtraFieldLength + FileCommentLength;
br.BaseStream.Seek(exlen, SeekOrigin.Current);
}
public SubStream GetSubStream(BinaryReader br)
{
var fs = br.BaseStream;
fs.Position = Position;
if (br.ReadInt32() != 0x04034b50)
throw new Exception("ファイルが壊れています。");
var ziph = new ZipHeader(br);
fs.Position += ziph.FilenameLength + ziph.ExtraFieldLength;
return new SubStream(fs, Header.CompressedSize);
}
internal IEnumerable <ZipHeader> ReadStreamHeader(Stream stream)
{
RewindableStream rewindableStream;
if (stream is RewindableStream)
{
rewindableStream = stream as RewindableStream;
}
else
{
rewindableStream = new RewindableStream(stream);
}
while (true)
{
ZipHeader header = null;
BinaryReader reader = new BinaryReader(rewindableStream);
if (_lastEntryHeader != null &&
(FlagUtility.HasFlag(_lastEntryHeader.Flags, HeaderFlags.UsePostDataDescriptor) || _lastEntryHeader.IsZip64))
{
reader = (_lastEntryHeader.Part as StreamingZipFilePart).FixStreamedFileLocation(ref rewindableStream);
long?pos = rewindableStream.CanSeek ? (long?)rewindableStream.Position : null;
uint crc = reader.ReadUInt32();
if (crc == POST_DATA_DESCRIPTOR)
{
crc = reader.ReadUInt32();
}
_lastEntryHeader.Crc = crc;
_lastEntryHeader.CompressedSize = reader.ReadUInt32();
_lastEntryHeader.UncompressedSize = reader.ReadUInt32();
if (pos.HasValue)
{
_lastEntryHeader.DataStartPosition = pos - _lastEntryHeader.CompressedSize;
}
}
_lastEntryHeader = null;
uint headerBytes = reader.ReadUInt32();
header = ReadHeader(headerBytes, reader);
if (header == null)
{
yield break;
}
//entry could be zero bytes so we need to know that.
if (header.ZipHeaderType == ZipHeaderType.LocalEntry)
{
var local_header = ((LocalEntryHeader)header);
// If we have CompressedSize, there is data to be read
if (local_header.CompressedSize > 0)
{
header.HasData = true;
} // Check if zip is streaming ( Length is 0 and is declared in PostDataDescriptor )
else if (local_header.Flags.HasFlag(HeaderFlags.UsePostDataDescriptor))
{
bool isRecording = rewindableStream.IsRecording;
if (!isRecording)
{
rewindableStream.StartRecording();
}
uint nextHeaderBytes = reader.ReadUInt32();
// Check if next data is PostDataDescriptor, streamed file with 0 length
header.HasData = !IsHeader(nextHeaderBytes);
rewindableStream.Rewind(!isRecording);
}
else // We are not streaming and compressed size is 0, we have no data
{
header.HasData = false;
}
}
yield return(header);
}
}
