internal override int CabCloseStreamEx(int streamHandle, out int err, IntPtr pv)
{
Stream stream = DuplicateStream.OriginalStream(this.StreamHandles[streamHandle]);
if (stream == DuplicateStream.OriginalStream(this.FileStream))
{
this.context.CloseFileReadStream(this.currentFileName, stream);
this.FileStream = null;
long remainder = this.currentFileTotalBytes - this.currentFileBytesProcessed;
this.currentFileBytesProcessed += remainder;
this.fileBytesProcessed += remainder;
this.OnProgress(ArchiveProgressType.FinishFile);
this.currentFileTotalBytes = 0;
this.currentFileBytesProcessed = 0;
this.currentFileName = null;
}
else if (stream == DuplicateStream.OriginalStream(this.CabStream))
{
if (stream.CanWrite)
{
stream.Flush();
}
this.currentArchiveBytesProcessed = this.currentArchiveTotalBytes;
this.OnProgress(ArchiveProgressType.FinishArchive);
this.currentArchiveNumber++;
this.totalArchives++;
this.context.CloseArchiveWriteStream(
this.currentArchiveNumber,
this.currentArchiveName,
stream);
this.currentArchiveName = this.NextCabinetName;
this.currentArchiveBytesProcessed = this.currentArchiveTotalBytes = 0;
this.totalFolderBytesProcessedInCurrentCab = 0;
this.CabStream = null;
}
else // Must be a temp stream
{
#if CORECLR
stream.Dispose();
#else
stream.Close();
#endif
this.tempStreams.Remove(stream);
}
return(base.CabCloseStreamEx(streamHandle, out err, pv));
}
internal override int CabCloseStreamEx(int streamHandle, out int err, IntPtr pv)
{
Stream stream = DuplicateStream.OriginalStream(StreamHandles[streamHandle]);
if (stream == DuplicateStream.OriginalStream(FileStream))
{
context.CloseFileReadStream(currentFileName, stream);
FileStream = null;
long remainder = currentFileTotalBytes - currentFileBytesProcessed;
currentFileBytesProcessed += remainder;
fileBytesProcessed += remainder;
OnProgress(ArchiveProgressType.FinishFile);
currentFileTotalBytes = 0;
currentFileBytesProcessed = 0;
currentFileName = null;
}
else if (stream == DuplicateStream.OriginalStream(CabStream))
{
if (stream.CanWrite)
{
stream.Flush();
}
currentArchiveBytesProcessed = currentArchiveTotalBytes;
OnProgress(ArchiveProgressType.FinishArchive);
currentArchiveNumber++;
totalArchives++;
context.CloseArchiveWriteStream(
currentArchiveNumber,
currentArchiveName,
stream);
currentArchiveName = NextCabinetName;
currentArchiveBytesProcessed = currentArchiveTotalBytes = 0;
totalFolderBytesProcessedInCurrentCab = 0;
CabStream = null;
}
else // Must be a temp stream
{
stream.Close();
tempStreams.Remove(stream);
}
return(base.CabCloseStreamEx(streamHandle, out err, pv));
}
internal override int CabCloseStreamEx(int streamHandle, out int err, IntPtr pv)
{
Stream stream = DuplicateStream.OriginalStream(base.StreamHandles[streamHandle]);
if (stream == DuplicateStream.OriginalStream(base.CabStream))
{
if (folderId != -3)
{
OnProgress(ArchiveProgressType.FinishArchive);
}
context.CloseArchiveReadStream(currentArchiveNumber, currentArchiveName, stream);
currentArchiveName = base.NextCabinetName;
currentArchiveBytesProcessed = (currentArchiveTotalBytes = 0L);
base.CabStream = null;
}
return(base.CabCloseStreamEx(streamHandle, out err, pv));
}
internal override int CabReadStreamEx(int streamHandle, IntPtr memory, int cb, out int err, IntPtr pv)
{
int result = base.CabReadStreamEx(streamHandle, memory, cb, out err, pv);
checked
{
if (err == 0 && base.CabStream != null && fileList == null && DuplicateStream.OriginalStream(base.StreamHandles[streamHandle]) == DuplicateStream.OriginalStream(base.CabStream))
{
currentArchiveBytesProcessed += cb;
if (currentArchiveBytesProcessed > currentArchiveTotalBytes)
{
currentArchiveBytesProcessed = currentArchiveTotalBytes;
}
}
return(result);
}
}
internal override int CabWriteStreamEx(int streamHandle, IntPtr memory, int cb, out int err, IntPtr pv)
{
int num = base.CabWriteStreamEx(streamHandle, memory, cb, out err, pv);
checked
{
if (num > 0 && err == 0 && DuplicateStream.OriginalStream(base.StreamHandles[streamHandle]) == DuplicateStream.OriginalStream(base.CabStream))
{
currentArchiveBytesProcessed += cb;
if (currentArchiveBytesProcessed > currentArchiveTotalBytes)
{
currentArchiveBytesProcessed = currentArchiveTotalBytes;
}
}
return(num);
}
}
internal override int CabWriteStreamEx(int streamHandle, IntPtr memory, int cb, out int err, IntPtr pv)
{
int count = base.CabWriteStreamEx(streamHandle, memory, cb, out err, pv);
if (count > 0 && err == 0)
{
Stream stream = this.StreamHandles[streamHandle];
if (DuplicateStream.OriginalStream(stream) ==
DuplicateStream.OriginalStream(this.CabStream))
{
this.currentArchiveBytesProcessed += cb;
if (this.currentArchiveBytesProcessed > this.currentArchiveTotalBytes)
{
this.currentArchiveBytesProcessed = this.currentArchiveTotalBytes;
}
}
}
return(count);
}
internal override int CabCloseStreamEx(int streamHandle, out int err, IntPtr pv)
{
Stream stream = DuplicateStream.OriginalStream(this.StreamHandles[streamHandle]);
if (stream == DuplicateStream.OriginalStream(this.CabStream))
{
if (this.folderId != -3) // -3 is a special folderId that requires re-opening the same cab
{
this.OnProgress(ArchiveProgressType.FinishArchive);
}
this.context.CloseArchiveReadStream(this.currentArchiveNumber, this.currentArchiveName, stream);
this.currentArchiveName = this.NextCabinetName;
this.currentArchiveBytesProcessed = this.currentArchiveTotalBytes = 0;
this.CabStream = null;
}
return(base.CabCloseStreamEx(streamHandle, out err, pv));
}
internal override int CabReadStreamEx(int streamHandle, IntPtr memory, int cb, out int err, IntPtr pv)
{
int count = base.CabReadStreamEx(streamHandle, memory, cb, out err, pv);
if (err == 0 && CabStream != null)
{
if (fileList == null)
{
Stream stream = StreamHandles[streamHandle];
if (DuplicateStream.OriginalStream(stream) ==
DuplicateStream.OriginalStream(CabStream))
{
currentArchiveBytesProcessed += cb;
if (currentArchiveBytesProcessed > currentArchiveTotalBytes)
{
currentArchiveBytesProcessed = currentArchiveTotalBytes;
}
}
}
}
return(count);
}
