internal virtual int CabOpenStreamEx(string path, int openFlags, int shareMode, out int err, IntPtr pv)
{
path = path.Trim();
var stream = CabStream;
CabStream = new DuplicateStream(stream);
var streamHandle = StreamHandles.AllocHandle(stream);
err = 0;
return(streamHandle);
}
internal override int CabOpenStreamEx(string path, int openFlags, int shareMode, out int err, IntPtr pv)
{
if (CabNumbers.ContainsKey(path))
{
Stream stream = CabStream;
if (stream == null)
{
short cabNumber = CabNumbers[path];
currentFolderTotalBytes = 0;
stream = context.OpenArchiveWriteStream(cabNumber, path, true, CabEngine);
if (stream == null)
{
throw new FileNotFoundException(
String.Format(CultureInfo.InvariantCulture, "Cabinet {0} not provided.", cabNumber));
}
currentArchiveName = path;
currentArchiveTotalBytes = Math.Min(
totalFolderBytesProcessedInCurrentCab, maxCabBytes);
currentArchiveBytesProcessed = 0;
OnProgress(ArchiveProgressType.StartArchive);
CabStream = stream;
}
path = CabStreamName;
}
else if (path == TempStreamName)
{
// Opening memory stream for a temp file.
Stream stream = new MemoryStream();
tempStreams.Add(stream);
int streamHandle = StreamHandles.AllocHandle(stream);
err = 0;
return(streamHandle);
}
else if (path != CabStreamName)
{
// Opening a file on disk for a temp file.
path = Path.Combine(Path.GetTempPath(), path);
Stream stream = new FileStream(path, FileMode.Open, FileAccess.ReadWrite);
tempStreams.Add(stream);
stream = new DuplicateStream(stream);
int streamHandle = StreamHandles.AllocHandle(stream);
err = 0;
return(streamHandle);
}
return(base.CabOpenStreamEx(path, openFlags, shareMode, out err, pv));
}
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));
}
public async Task HappyFlow()
{
Stream inputStream = FixedTestData.CreateStream();
IPipe <Packet <byte> > duplicateBuffer = new BatchingPipe <Packet <byte> >();
DuplicateStream sut = new DuplicateStream(inputStream, duplicateBuffer.ToWriteOnlyStream());
// As sut is read for assertion, in the process it should start to write data to duplication destination
Task assertSutStream = Task.Run(() => FixedTestData.AssertStream(sut));
// Thus with next task we should be able to assert both streams at the same time.
Task assertDuplicatedStream = Task.Run(() => FixedTestData.AssertStream(duplicateBuffer.ToReadOnlyStream()));
await assertSutStream;
await assertDuplicatedStream;
}
protected virtual Handle CabOpenStreamEx(string path, int openFlags, int shareMode, out int err, Pointer pv)
{
try
{
Stream stream = null;
path = path.Trim();
if (path == CabBase.STREAM_CAB)
{
stream = this.cabStream;
this.cabStream = new DuplicateStream(stream);
}
else if (path == CabBase.STREAM_FILE)
{
stream = this.fileStream;
this.fileStream = new DuplicateStream(stream);
}
#if !CABEXTRACTONLY
else if (path == CabBase.STREAM_TEMP)
{
// Opening memory stream for a temp file.
stream = new MemoryStream();
this.tempStreams.Add(stream);
}
else
{
// Opening a file on disk for a temp file.
path = Path.Combine(Path.GetTempPath(), path);
stream = new FileStream(path, FileMode.Open, FileAccess.ReadWrite);
this.tempStreams.Add(stream);
//
stream = new DuplicateStream(stream);
}
#endif
Handle hStream = streamHandles.AllocHandle(stream);
err = 0;
return(hStream);
}
catch (Exception ex)
{
if (this.abortException == null)
{
this.abortException = ex;
}
err = Marshal.GetHRForException(ex);
return((Handle)0);
}
}
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 CabOpenStreamEx(string path, int openFlags, int shareMode, out int err, IntPtr pv)
{
if (base.CabNumbers.ContainsKey(path))
{
Stream cabStream = base.CabStream;
if (cabStream == null)
{
short num = base.CabNumbers[path];
currentFolderTotalBytes = 0L;
cabStream = context.OpenArchiveWriteStream(num, path, truncate: true, base.CabEngine);
if (cabStream == null)
{
throw new FileNotFoundException(string.Format(CultureInfo.InvariantCulture, "Cabinet {0} not provided.", num));
}
currentArchiveName = path;
currentArchiveTotalBytes = Math.Min(totalFolderBytesProcessedInCurrentCab, maxCabBytes);
currentArchiveBytesProcessed = 0L;
OnProgress(ArchiveProgressType.StartArchive);
base.CabStream = cabStream;
}
path = "%%CAB%%";
}
else
{
if (path == "%%TEMP%%")
{
Stream stream = new MemoryStream();
tempStreams.Add(stream);
int result = base.StreamHandles.AllocHandle(stream);
err = 0;
return(result);
}
if (path != "%%CAB%%")
{
path = Path.Combine(Path.GetTempPath(), path);
Stream stream2 = new FileStream(path, FileMode.Open, FileAccess.ReadWrite);
tempStreams.Add(stream2);
stream2 = new DuplicateStream(stream2);
int result2 = base.StreamHandles.AllocHandle(stream2);
err = 0;
return(result2);
}
}
return(base.CabOpenStreamEx(path, openFlags, shareMode, out err, pv));
}
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);
}
private int CabGetOpenInfo(
string path,
out short date,
out short time,
out short attribs,
out int err,
IntPtr pv)
{
CompressionEngine.DateTimeToDOSDateAndTime(_fileLastWriteTime, out date, out time);
attribs = (short)_fileAttributes;
var stream = FileStream;
FileStream = new DuplicateStream(stream);
var streamHandle = StreamHandles.AllocHandle(stream);
err = 0;
return(streamHandle);
}
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);
}
internal override int CabOpenStreamEx(string path, int openFlags, int shareMode, out int err, IntPtr pv)
{
if (this.CabNumbers.ContainsKey(path))
{
Stream stream = this.CabStream;
if (stream == null)
{
short cabNumber = this.CabNumbers[path];
this.currentFolderTotalBytes = 0;
stream = this.context.OpenArchiveWriteStream(cabNumber, path, true, this.CabEngine);
if (stream == null)
{
throw new FileNotFoundException(
String.Format(CultureInfo.InvariantCulture, "Cabinet {0} not provided.", cabNumber));
}
this.currentArchiveName = path;
this.currentArchiveTotalBytes = Math.Min(
this.totalFolderBytesProcessedInCurrentCab, this.maxCabBytes);
this.currentArchiveBytesProcessed = 0;
this.OnProgress(ArchiveProgressType.StartArchive);
this.CabStream = stream;
}
path = CabWorker.CabStreamName;
}
else if (path == CabPacker.TempStreamName)
{
// Opening memory stream for a temp file.
Stream stream = new MemoryStream();
this.tempStreams.Add(stream);
int streamHandle = this.StreamHandles.AllocHandle(stream);
err = 0;
return streamHandle;
}
else if (path != CabWorker.CabStreamName)
{
// Opening a file on disk for a temp file.
path = Path.Combine(Path.GetTempPath(), path);
Stream stream = new FileStream(path, FileMode.Open, FileAccess.ReadWrite);
this.tempStreams.Add(stream);
stream = new DuplicateStream(stream);
int streamHandle = this.StreamHandles.AllocHandle(stream);
err = 0;
return streamHandle;
}
return base.CabOpenStreamEx(path, openFlags, shareMode, out err, pv);
}
