/// <summary>
/// Flushes the underlying stream if an edit was performed (i.e., difference was detected).
/// </summary>
public override void Flush()
{
if (DifferenceDetected)
{
BaseStream.Flush();
}
}
private void Compile(bool end)
{
if (IsDisposed)
{
return;
}
WriteStart();
if (CurrentNode.Count > 0)
{
var json = Json.Encode(CurrentNode);
if (_ObjectID++ > 0)
{
json = ", " + json;
}
var buffer = Encoding.GetBytes(json);
BaseStream.Write(buffer, 0, buffer.Length);
CurrentNode.Clear();
}
if (end)
{
WriteEnd();
}
BaseStream.Flush();
}
public void SendMessage(int messageType, string message)
{
byte[] messageArray = Encoding.UTF8.GetBytes(message);
int dataLength = messageArray.Length + 16;
MemoryStream buffer = new MemoryStream(dataLength);
// Data length (4)
buffer.Write(ToBE(BitConverter.GetBytes(dataLength)), 0, 4);
// Header length and Data type (4)
buffer.Write(new byte[] { 0x00, 0x10, 0x00, 0x01 }, 0, 4);
// Message type (4)
buffer.Write(ToBE(BitConverter.GetBytes(messageType)), 0, 4);
// Split (4)
buffer.Write(ToBE(BitConverter.GetBytes(1)), 0, 4);
// Message
buffer.Write(messageArray, 0, messageArray.Length);
BaseStream.Write(buffer.GetBuffer(), 0, dataLength);
BaseStream.Flush();
if (BaseWebSocket != null)
{
byte[] b = new byte[dataLength];
BaseStream.Position = 0;
BaseStream.Read(b, 0, dataLength);
BaseWebSocket.SendAsync(new ArraySegment <byte>(b), WebSocketMessageType.Binary, true, CancellationToken.None).GetAwaiter().GetResult();
BaseStream.Position = 0;
}
}
/// <summary>
/// Clears all buffers for this stream and causes any buffered data to be written
/// to the underlying device.
/// </summary>
/// <remarks>
/// Flushes the <see cref="BaseStream"/>.
/// </remarks>
/// <exception cref="System.ObjectDisposedException">
/// The stream has been disposed.
/// </exception>
/// <exception cref="System.NotSupportedException">
/// The stream does not support writing.
/// </exception>
/// <exception cref="System.IO.IOException">
/// An I/O error occurred.
/// </exception>
public override void Flush()
{
CheckDisposed();
CheckCanWrite();
BaseStream.Flush();
}
public override void Flush()
{
if (BaseStream != null)
{
BaseStream.Flush();
}
}
public void Flush()
{
lock (Locker)
{
BaseStream.Flush();
}
}
public override void Flush()
{
lock (Locker)
{
BaseStream.Flush();
}
}
public override void Write(MessageDelivery delivery)
{
Message message = Converter.ToMessage(delivery);
Encoder.WriteMessage(message, BaseStream);
BaseStream.Flush();
}
/// <summary> Shrink file to the new size. </summary>
/// <param name="newCount">Number of items the file should contain after this operation</param>
protected void PerformTruncateFile(long newCount)
{
ThrowOnNotInitialized();
long fileCount = GetCount();
if (newCount < 0 || newCount > fileCount)
{
throw new ArgumentOutOfRangeException("newCount", newCount, "Must be >= 0 and <= Count");
}
// Optimize empty requests
if (fileCount == newCount)
{
return;
}
BaseStream.SetLength(ItemIdxToOffset(newCount));
BaseStream.Flush();
// Just in case, hope this will never happen
fileCount = GetCount();
if (newCount != fileCount)
{
throw new BinaryFileException(
"Internal error: the new file should have had {0} items, but was calculated to have {1}",
newCount, fileCount);
}
}
public override void Flush()
{
BaseStream.Flush();
foreach (var writer in CopyWriters)
{
writer.Flush();
}
}
/// <summary>
/// This method is not proxied to the underlying stream; instead, the wrapper
/// is marked as unusable for other (non-close/Dispose) operations. The underlying
/// stream is flushed if the wrapper wasn't closed before this call.
/// </summary>
public override void Close()
{
if (!closed)
{
BaseStream.Flush();
}
closed = true;
}
/// <summary>
/// Flushes the underlying stream.
/// </summary>
public void Flush()
{
if (BaseStream == null)
{
throw new NullReferenceException("Base stream is null");
}
BaseStream.Flush();
}
public void Dispose()
{
BaseStream.Dispose();
BaseStream.Flush();
m_writer.Flush();
m_writer.Dispose();
m_writer = null;
}
protected override Result FlushImpl()
{
lock (Locker)
{
BaseStream.Flush();
return(Result.Success);
}
}
/// <summary>
/// Flushes the underlying stream.
/// </summary>
public void Flush()
{
if (BaseStream is null)
{
throw new NullReferenceException(Properties.Resources.BaseStreamCurrentlyNullError);
}
BaseStream.Flush();
}
/// <summary>
/// When overridden in a derived class, clears all buffers for this stream and causes any buffered data to be written to the underlying device.
/// </summary>
/// <exception cref="T:System.IO.IOException">An I/O error occurs. </exception>
public override void Flush()
{
if (_disposed)
{
throw new ObjectDisposedException(GetType().Name);
}
BaseStream.Flush();
}
/// <summary>
/// Clears all buffers for this stream and causes any buffered data to be written to the underlying device
/// </summary>
/// <exception cref="T:System.IO.IOException">An I/O error occurs. </exception>
public override void Flush()
{
if (_closed)
{
throw new InvalidOperationException();
}
BaseStream.Flush();
}
/// <inheritdoc cref="SerialPort.Close"/>
public new void Close()
{
if (IsOpen)
{
BaseStream.Flush();
DiscardInBuffer();
base.Close();
}
}
public void Negotiate()
{
RSAKeys rsaKeys = new RSAKeys();
BaseStream.Write(rsaKeys.PublicKey);
RSAParameters localPrivateKey = rsaKeys.PrivateKey;
BaseStream.Flush();
RSAParameters remotePublicKey = BaseStream.ReadRSAParameters();
Random rnd = Processor.CreateRandom();
int nbTries = 0;
byte[] id;
do
{
if (nbTries > 100)
{
throw new IOException("Can't find a different ID to use.");
}
this.LocalID = rnd.Next();
id = this.LocalID.GetBytes();
BaseStream.WriteWrapped(RSA.Encrypt(id, remotePublicKey));
this.RemoteID = RSA.Decrypt(BaseStream.ReadWrapped(), localPrivateKey).ToInt32();
++nbTries;
} while(this.LocalID == this.RemoteID);
byte[] key;
byte[] iv;
if (this.RemoteID < LocalID)
{
AES.ProduceKeyIV(out key, out iv);
BaseStream.WriteWrapped(RSA.Encrypt(key, remotePublicKey));
BaseStream.WriteWrapped(RSA.Encrypt(iv, remotePublicKey));
BaseStream.Flush();
}
else
{
key = RSA.Decrypt(BaseStream.ReadWrapped(), localPrivateKey);
iv = RSA.Decrypt(BaseStream.ReadWrapped(), localPrivateKey);
}
this.EncryptedStream = new OverAESStream(BaseStream, key, iv, NbIterations);
this.WriteWrapped(id);
this.Flush();
if (this.ReadWrapped().ToInt32() != RemoteID)
{
throw new IOException("Can't connect to remote point.");
}
}
public void Flush()
{
lock (streamWriterLock)
{
if (BaseStream != null)
{
BaseStream.Flush();
}
}
}
/// <summary>
/// Write segment stream to internal stream, optionally truncating the file so that <paramref name="firstItemIdx"/> would be the first written item.
/// </summary>
/// <param name="streamEnmr">The stream of array segments to write, with a single MoveNext() already performed (returned true)</param>
/// <param name="firstItemIdx">The index of the first element in the stream. The file will be truncated if the value is less than or equal to Count</param>
protected void PerformWriteStreaming(
[NotNull] IEnumerator <ArraySegment <T> > streamEnmr, long firstItemIdx = long.MaxValue)
{
if (streamEnmr == null)
{
throw new ArgumentNullException("streamEnmr");
}
ThrowOnNotInitialized();
if (firstItemIdx < long.MaxValue)
{
PerformTruncateFile(firstItemIdx);
}
bool canSeek = BaseStream.CanSeek;
long fileSize = 0, itemIdx = 0;
if (canSeek)
{
fileSize = BaseStream.Length;
bool isAligned;
itemIdx = CalculateItemCountFromFilePosition(fileSize, out isAligned);
}
bool?useMemMappedAccess = null;
// Have to call Count on every access
do
{
ArraySegment <T> seg = streamEnmr.Current;
if (seg.Count == 0)
{
continue;
}
if (useMemMappedAccess == null)
{
useMemMappedAccess = UseMemoryMappedAccess(seg.Count, true);
}
int read = PerformUnsafeBlockAccess(itemIdx, true, seg, fileSize, useMemMappedAccess.Value);
if (canSeek)
{
itemIdx += read;
fileSize += read * ItemSize;
}
} while (streamEnmr.MoveNext());
if (useMemMappedAccess == false)
{
BaseStream.Flush();
}
}
/// <summary>
/// Flushes the stream
/// </summary>
public override void Flush()
{
if (!IsConnected)
{
throw new InvalidOperationException("The FtpSocketStream object is not connected.");
}
if (BaseStream == null)
{
throw new InvalidOperationException("The base stream of the FtpSocketStream object is null.");
}
BaseStream.Flush();
}
public override void Flush()
{
if (isAdjacent)
{
var transformed =
encoding.GetBytes(responseTransformer.Transform(encoding.GetString(transformBuffer.ToArray())));
BaseStream.Write(transformed, 0, transformed.Length);
transformBuffer.Clear();
}
BaseStream.Flush();
RRTracer.Trace("Flushing Filter");
}
/// <inheritdoc cref="SerialPort.Close"/>
public new void Close()
{
if (!IsOpen)
{
return;
}
Thread.Sleep(250);
BaseStream.Flush();
DiscardInBuffer();
BaseStream.Close();
base.Close();
}
/// <summary>
/// Write a raw network message
/// </summary>
/// <param name="buffer">byte buffer</param>
protected void WriteBytes(byte[] buffer)
{
int length = buffer.Length;
if (length > UInt16.MaxValue)
{
throw new InvalidOperationException("Message is too long");
}
// write message length
BaseStream.Write(new byte[] { (byte)(length / 256), (byte)(length & 255) }, 0, 2);
// write message
BaseStream.Write(buffer, 0, length);
BaseStream.Flush();
}
public void Write(IDataChunk chunk)
{
if (chunk is Packet packet)
{
Write(packet);
}
else if (chunk is MessageData message)
{
Write(message);
}
else
{
throw new InvalidOperationException("Unsupported data type: " + chunk.GetType());
}
BaseStream.Flush();
}
/// <summary>
/// Sends all the buffered data.
/// </summary>
public override void Flush()
{
if (fWriteBuffer != null)
{
if (fWriteBuffer.Length > 0)
{
var encryptedBuffer = Encryptor.TransformFinalBlock(fWriteBuffer.GetBuffer(), 0, (int)fWriteBuffer.Length);
var size = BitConverter.GetBytes(encryptedBuffer.Length);
BaseStream.Write(size, 0, size.Length);
BaseStream.Write(encryptedBuffer, 0, encryptedBuffer.Length);
BaseStream.Flush();
fWriteBuffer.SetLength(0);
fWriteBuffer.Capacity = 32 * 1024;
}
}
}
/// <inheritdoc />
public override unsafe void Flush()
{
if (_mode == Mode.Decompress)
{
BaseStream.Flush();
return;
}
fixed(byte *writePtr = _workBuf)
{
_lzmaStream.NextIn = (byte *)0;
_lzmaStream.AvailIn = 0;
_lzmaStream.NextOut = writePtr + _workBufPos;
_lzmaStream.AvailOut = (uint)(_workBuf.Length - _workBufPos);
LzmaRet ret = LzmaRet.Ok;
while (ret != LzmaRet.StreamEnd)
{
int writeSize = 0;
if (_lzmaStream.AvailOut != 0)
{
ulong bakAvailOut = _lzmaStream.AvailOut;
ret = XZInit.Lib.LzmaCode(_lzmaStream, LzmaAction.FullFlush);
writeSize += (int)(bakAvailOut - _lzmaStream.AvailOut);
}
_workBufPos += writeSize;
BaseStream.Write(_workBuf, 0, _workBufPos);
TotalOut += _workBufPos;
// Reset NextOut and AvailOut
_workBufPos = 0;
_lzmaStream.NextOut = writePtr;
_lzmaStream.AvailOut = (uint)_workBuf.Length;
// Once everything has been encoded successfully, the return value of lzma_code() will be LZMA_STREAM_END.
if (ret != LzmaRet.Ok && ret != LzmaRet.StreamEnd)
{
throw new XZException(ret);
}
}
}
BaseStream.Flush();
}
public override void Close()
{
byte[] buffer = _stream.ToArray();
if (_threshold <= 0 || _stream.Length > _threshold)
{
BaseStream.Write(buffer, 0, buffer.Length);
BaseStream.Flush();
BaseStream.Close();
}
else
{
_baseStream.Write(buffer, 0, buffer.Length);
_baseStream.Flush();
_baseStream.Close();
}
_stream.Close();
}
protected internal int PerformFileAccess(long firstItemIdx, ArraySegment <T> buffer, bool isWriting)
{
ThrowOnNotInitialized();
bool canSeek = BaseStream.CanSeek;
if (!canSeek && firstItemIdx != 0)
{
throw new ArgumentOutOfRangeException(
"firstItemIdx", firstItemIdx,
"Must be 0 when the base stream is not seekable");
}
if (canSeek && (firstItemIdx < 0 || firstItemIdx > GetCount()))
{
throw new ArgumentOutOfRangeException("firstItemIdx", firstItemIdx, "Must be >= 0 and <= Count");
}
// Optimize empty requests
if (buffer.Count == 0)
{
return(0);
}
int ret;
if (IsFileStream &&
((isWriting && EnableMemMappedAccessOnWrite) || (!isWriting && EnableMemMappedAccessOnRead)) &&
ItemIdxToOffset(buffer.Count) > MinReqSizeToUseMapView)
{
ret = ProcessMemoryMappedFile(firstItemIdx, buffer, isWriting, BaseStream.Length);
}
else
{
ret = ProcessStream(firstItemIdx, buffer, isWriting);
if (isWriting)
{
BaseStream.Flush();
}
}
return(ret);
}