public WebSocketMessageWriteRfc6455Stream(WebSocketRfc6455 client, WebSocketMessageType messageType, WebSocketExtensionFlags extensionFlags)
: this(client, messageType)
{
ExtensionFlags.Rsv1 = extensionFlags.Rsv1;
ExtensionFlags.Rsv2 = extensionFlags.Rsv2;
ExtensionFlags.Rsv3 = extensionFlags.Rsv3;
}
public WebSocketFrameHeaderFlags(bool isComplete, WebSocketFrameOption option, WebSocketExtensionFlags extensionFlags)
{
this.Option = option;
_byte1 = new Byte();
_byte2 = new Byte();
SetBit(ref _byte1, 7, isComplete);
this.RSV1 = extensionFlags.Rsv1;
this.RSV2 = extensionFlags.Rsv2;
this.RSV3 = extensionFlags.Rsv3;
switch (option)
{
case WebSocketFrameOption.Text:
this.OPT1 = true;
break;
case WebSocketFrameOption.Binary:
this.OPT2 = true;
break;
case WebSocketFrameOption.ConnectionClose:
this.OPT4 = true;
break;
case WebSocketFrameOption.Ping:
this.OPT1 = this.OPT4 = true;
break;
case WebSocketFrameOption.Pong:
this.OPT4 = this.OPT2 = true;
break;
case WebSocketFrameOption.Continuation:
this.RSV1 = this.RSV2 = this.RSV3 = false;
break;
}
}
private WebSocketExtensionFlags GetExtensionFlags(WebSocketFrameHeaderFlags webSocketFrameHeaderFlags)
{
var flags = new WebSocketExtensionFlags();
flags.Rsv1 = webSocketFrameHeaderFlags.RSV1;
flags.Rsv2 = webSocketFrameHeaderFlags.RSV2;
flags.Rsv3 = webSocketFrameHeaderFlags.RSV3;
return flags;
}
private WebSocketExtensionFlags GetExtensionFlags(WebSocketFrameHeaderFlags webSocketFrameHeaderFlags)
{
var flags = new WebSocketExtensionFlags();
flags.Rsv1 = webSocketFrameHeaderFlags.RSV1;
flags.Rsv2 = webSocketFrameHeaderFlags.RSV2;
flags.Rsv3 = webSocketFrameHeaderFlags.RSV3;
return(flags);
}
public WebSocketMessageReadRfc6455Stream(WebSocketRfc6455 webSocket)
{
Guard.ParameterCannotBeNull(webSocket, "webSocket");
_webSocket = webSocket;
_messageType = (WebSocketMessageType)_webSocket.Connection.CurrentHeader.Flags.Option;
_flags = GetExtensionFlags(_webSocket.Connection.CurrentHeader.Flags);
_hasPendingFrames = !_webSocket.Connection.CurrentHeader.Flags.FIN;
if (_webSocket.Connection.CurrentHeader.Flags.Option != WebSocketFrameOption.Binary && _webSocket.Connection.CurrentHeader.Flags.Option != WebSocketFrameOption.Text)
throw new WebSocketException("WebSocketMessageReadNetworkStream can only start with a Text or Binary frame, not " + _webSocket.Connection.CurrentHeader.Flags.Option.ToString());
}
public WebSocketMessageReadRfc6455Stream(WebSocketRfc6455 webSocket)
{
Guard.ParameterCannotBeNull(webSocket, "webSocket");
_webSocket = webSocket;
_messageType = (WebSocketMessageType)_webSocket.Connection.CurrentHeader.Flags.Option;
_flags = GetExtensionFlags(_webSocket.Connection.CurrentHeader.Flags);
_hasPendingFrames = !_webSocket.Connection.CurrentHeader.Flags.FIN;
if (_webSocket.Connection.CurrentHeader.Flags.Option != WebSocketFrameOption.Binary && _webSocket.Connection.CurrentHeader.Flags.Option != WebSocketFrameOption.Text)
{
throw new WebSocketException("WebSocketMessageReadNetworkStream can only start with a Text or Binary frame, not " + _webSocket.Connection.CurrentHeader.Flags.Option.ToString());
}
}
public WebSocketMessageReadRfc6455Stream(WebSocketRfc6455 webSocket)
{
if (webSocket == null)
{
throw new ArgumentNullException(nameof(webSocket));
}
_webSocket = webSocket;
this.MessageType = (WebSocketMessageType)_webSocket.Connection.CurrentHeader.Flags.Option;
this.Flags = GetExtensionFlags(_webSocket.Connection.CurrentHeader.Flags);
_hasPendingFrames = !_webSocket.Connection.CurrentHeader.Flags.FIN;
if (_webSocket.Connection.CurrentHeader.Flags.Option != WebSocketFrameOption.Binary && _webSocket.Connection.CurrentHeader.Flags.Option != WebSocketFrameOption.Text)
{
throw new WebSocketException($"WebSocketMessageReadNetworkStream can only start with a Text or Binary frame, not {_webSocket.Connection.CurrentHeader.Flags.Option}.");
}
}
public static WebSocketFrameHeader Create(Int32 count, Boolean isComplete, Boolean headerSent, WebSocketFrameOption option, WebSocketExtensionFlags extensionFlags)
{
var flags = new WebSocketFrameHeaderFlags(isComplete, headerSent ? WebSocketFrameOption.Continuation : option, extensionFlags);
Int32 headerLength;
if (count <= 125)
headerLength = 2;
else if (count < UInt16.MaxValue)
headerLength = 4;
else if ((UInt64)count < UInt64.MaxValue)
headerLength = 10;
else
throw new WebSocketException("Cannot create a header with a length of " + count);
return new WebSocketFrameHeader()
{
HeaderLength = headerLength,
ContentLength = (UInt64)count,
Flags = flags,
RemainingBytes = (UInt64)count
};
}
public WebSocketMessageReadRfc6455Stream([NotNull] WebSocketRfc6455 webSocket)
{
if (webSocket == null)
{
throw new ArgumentNullException(nameof(webSocket));
}
_webSocket = webSocket;
var headerOptions = this._webSocket.Connection.CurrentHeader.Flags.Option;
this.MessageType = (WebSocketMessageType)headerOptions;
this.Flags = GetExtensionFlags(_webSocket.Connection.CurrentHeader.Flags);
_hasPendingFrames = !_webSocket.Connection.CurrentHeader.Flags.FIN;
if (headerOptions != WebSocketFrameOption.Binary &&
headerOptions != WebSocketFrameOption.Text)
{
var headerIntValue = (int)headerOptions;
throw new WebSocketException(
$"WebSocketMessageReadNetworkStream can only start with a Text or Binary frame, not {headerOptions} ({headerIntValue}).");
}
}
internal async Task WriteInternalAsync(ArraySegment <byte> buffer, int count, bool isCompleted, bool headerSent, WebSocketFrameOption option, WebSocketExtensionFlags extensionFlags, CancellationToken cancel)
{
try
{
var header = WebSocketFrameHeader.Create(count, isCompleted, headerSent, option, extensionFlags);
header.ToBytes(buffer.Array, buffer.Offset - header.HeaderLength);
if (!await _writeSemaphore.WaitAsync(_options.WebSocketSendTimeout, cancel).ConfigureAwait(false))
{
throw new WebSocketException("Write timeout");
}
await _clientStream.WriteAsync(buffer.Array, buffer.Offset - header.HeaderLength, count + header.HeaderLength, cancel).ConfigureAwait(false);
}
catch (OperationCanceledException)
{
Close(WebSocketCloseReasons.GoingAway);
}
catch (InvalidOperationException)
{
Close(WebSocketCloseReasons.UnexpectedCondition);
}
catch (IOException)
{
Close(WebSocketCloseReasons.UnexpectedCondition);
}
catch (Exception ex)
{
Close(WebSocketCloseReasons.UnexpectedCondition);
throw new WebSocketException("Cannot write on WebSocket", ex);
}
finally
{
SafeEnd.ReleaseSemaphore(_writeSemaphore);
}
}
public WebSocketMessageWriteRfc6455Stream(WebSocketRfc6455 webSocket, WebSocketMessageType messageType, WebSocketExtensionFlags extensionFlags)
: this(webSocket, messageType)
{
this.ExtensionFlags.Rsv1 = extensionFlags.Rsv1;
this.ExtensionFlags.Rsv2 = extensionFlags.Rsv2;
this.ExtensionFlags.Rsv3 = extensionFlags.Rsv3;
}
internal void WriteInternal(ArraySegment <Byte> buffer, Int32 count, Boolean isCompleted, Boolean headerSent, WebSocketFrameOption option, WebSocketExtensionFlags extensionFlags)
{
try
{
var header = WebSocketFrameHeader.Create(count, isCompleted, headerSent, option, extensionFlags);
header.ToBytes(buffer.Array, buffer.Offset - header.HeaderLength);
if (!_writeSemaphore.Wait(_options.WebSocketSendTimeout))
{
throw new WebSocketException("Write timeout");
}
_clientStream.Write(buffer.Array, buffer.Offset - header.HeaderLength, count + header.HeaderLength);
}
catch (InvalidOperationException)
{
Close(WebSocketCloseReasons.UnexpectedCondition);
}
catch (IOException)
{
Close(WebSocketCloseReasons.UnexpectedCondition);
}
catch (Exception ex)
{
Close(WebSocketCloseReasons.UnexpectedCondition);
throw new WebSocketException("Cannot write on WebSocket", ex);
}
finally
{
if (_isClosed == 0)
{
SafeEnd.ReleaseSemaphore(_writeSemaphore);
}
}
}
public ArraySegment <byte> PrepareFrame(ArraySegment <byte> payload, int length, bool isCompleted, bool headerSent, WebSocketMessageType type, WebSocketExtensionFlags extensionFlags)
{
var mask = 0U;
if (this.maskData)
{
mask = unchecked ((uint)ThreadStaticRandom.NextNotZero());
}
var header = WebSocketFrameHeader.Create(length, isCompleted, headerSent, mask, (WebSocketFrameOption)type, extensionFlags);
if (header.WriteTo(payload.Array, payload.Offset - header.HeaderLength) != header.HeaderLength)
{
throw new WebSocketException("Wrong frame header written.");
}
if (this.log.IsDebugEnabled)
{
this.log.Debug($"({this.GetHashCode():X}) [FRAME->] {header}");
}
header.EncodeBytes(payload.Array, payload.Offset, length);
return(new ArraySegment <byte>(payload.Array, payload.Offset - header.HeaderLength, length + header.HeaderLength));
}
internal void WriteInternal(ArraySegment <byte> buffer, int count, bool isCompleted, bool headerSent, WebSocketMessageType type, WebSocketExtensionFlags extensionFlags)
{
WriteInternal(buffer, count, isCompleted, headerSent, (WebSocketFrameOption)type, extensionFlags);
}
internal void WriteInternal(ArraySegment <Byte> buffer, Int32 count, Boolean isCompleted, Boolean headerSent, WebSocketMessageType type, WebSocketExtensionFlags extensionFlags)
{
WriteInternal(buffer, count, isCompleted, headerSent, (WebSocketFrameOption)type, extensionFlags);
}
private async Task WriteInternalAsync(ArraySegment<Byte> buffer, Int32 count, Boolean isCompleted, Boolean headerSent, WebSocketFrameOption option, WebSocketExtensionFlags extensionFlags, CancellationToken cancellation)
{
CancellationTokenRegistration reg = cancellation.Register(this.Close, false);
try
{
var header = WebSocketFrameHeader.Create(count, isCompleted, headerSent, option, extensionFlags);
header.ToBytes(buffer.Array, buffer.Offset - header.HeaderLength);
if (!_writeSemaphore.Wait(_options.WebSocketSendTimeout))
throw new WebSocketException("Write timeout");
await _clientStream.WriteAsync(buffer.Array, buffer.Offset - header.HeaderLength, count + header.HeaderLength, cancellation).ConfigureAwait(false);
}
catch (InvalidOperationException)
{
Close(WebSocketCloseReasons.UnexpectedCondition);
}
catch (IOException)
{
Close(WebSocketCloseReasons.UnexpectedCondition);
}
catch (Exception ex)
{
Close(WebSocketCloseReasons.UnexpectedCondition);
throw new WebSocketException("Cannot write on WebSocket",ex);
}
finally
{
reg.Dispose();
_writeSemaphore.Release();
}
}
public static WebSocketFrameHeader Create(Int64 count, Boolean isComplete, Boolean headerSent, WebSocketFrameOption option, WebSocketExtensionFlags extensionFlags)
{
var flags = new WebSocketFrameHeaderFlags(isComplete, headerSent ? WebSocketFrameOption.Continuation : option, extensionFlags);
Int32 headerLength;
if (count <= 125)
{
headerLength = 2;
}
else if (count < UInt16.MaxValue)
{
headerLength = 4;
}
else if ((UInt64)count < UInt64.MaxValue)
{
headerLength = 10;
}
else
{
throw new WebSocketException("Cannot create a header with a length of " + count);
}
return(new WebSocketFrameHeader()
{
HeaderLength = headerLength,
ContentLength = (Int64)count,
Flags = flags,
RemainingBytes = (Int64)count
});
}
private void WriteInternal(ArraySegment<Byte> buffer, Int32 count, Boolean isCompleted, Boolean headerSent, WebSocketFrameOption option, WebSocketExtensionFlags extensionFlags)
{
try
{
var header = WebSocketFrameHeader.Create(count, isCompleted, headerSent, option, extensionFlags);
header.ToBytes(buffer.Array,buffer.Offset - header.HeaderLength);
if (!_writeSemaphore.Wait(_options.WebSocketSendTimeout))
throw new WebSocketException("Write timeout");
_clientStream.Write(buffer.Array, buffer.Offset - header.HeaderLength, count + header.HeaderLength);
}
catch (InvalidOperationException)
{
Close(WebSocketCloseReasons.UnexpectedCondition);
}
catch (IOException)
{
Close(WebSocketCloseReasons.UnexpectedCondition);
}
catch(Exception ex)
{
Close(WebSocketCloseReasons.UnexpectedCondition);
throw new WebSocketException("Cannot write on WebSocket", ex);
}
finally
{
_writeSemaphore.Release();
}
}
internal Task WriteInternalAsync(ArraySegment<Byte> buffer, Int32 count, Boolean isCompleted, Boolean headerSent, WebSocketMessageType type, WebSocketExtensionFlags extensionFlags, CancellationToken cancellation)
{
return WriteInternalAsync(buffer, count, isCompleted, headerSent, (WebSocketFrameOption)type, extensionFlags, cancellation);
}
internal void WriteInternal(ArraySegment<Byte> buffer, Int32 count, Boolean isCompleted, Boolean headerSent, WebSocketMessageType type, WebSocketExtensionFlags extensionFlags)
{
WriteInternal(buffer, count, isCompleted, headerSent, (WebSocketFrameOption)type, extensionFlags);
}
public static WebSocketFrameHeader Create(long contentLength, bool isComplete, bool headerSent, uint maskKey, WebSocketFrameOption option, WebSocketExtensionFlags extensionFlags)
{
if (extensionFlags == null)
{
throw new ArgumentNullException(nameof(extensionFlags));
}
var isMasked = maskKey != 0;
var flags = new WebSocketFrameHeaderFlags(isComplete, isMasked, headerSent ? WebSocketFrameOption.Continuation : option, extensionFlags);
int headerLength;
if (contentLength <= 125)
{
headerLength = 2;
}
else if (contentLength <= ushort.MaxValue)
{
headerLength = 4;
}
else
{
headerLength = 10;
}
if (isMasked)
{
headerLength += 4;
}
return(new WebSocketFrameHeader
{
HeaderLength = headerLength,
ContentLength = contentLength,
Flags = flags,
RemainingBytes = contentLength,
MaskKey = maskKey
});
}
public WebSocketMessageWriteRfc6455Stream(WebSocketRfc6455 webSocket, WebSocketMessageType messageType, WebSocketExtensionFlags extensionFlags)
: this(webSocket, messageType)
{
this.ExtensionFlags.Rsv1 = extensionFlags.Rsv1;
this.ExtensionFlags.Rsv2 = extensionFlags.Rsv2;
this.ExtensionFlags.Rsv3 = extensionFlags.Rsv3;
this.sendBuffer = this.webSocket.Connection.SendBuffer;
}
public WebSocketMessageWriteRfc6455Stream(WebSocketRfc6455 client, WebSocketMessageType messageType, WebSocketExtensionFlags extensionFlags)
: this(client, messageType)
{
ExtensionFlags.Rsv1 = extensionFlags.Rsv1;
ExtensionFlags.Rsv2 = extensionFlags.Rsv2;
ExtensionFlags.Rsv3 = extensionFlags.Rsv3;
}
public WebSocketFrameHeaderFlags(bool isComplete, WebSocketFrameOption option, WebSocketExtensionFlags extensionFlags)
{
this.Option = option;
_byte1 = new byte();
_byte2 = new byte();
SetBit(ref _byte1, 7, isComplete);
RSV1 = extensionFlags.Rsv1;
RSV2 = extensionFlags.Rsv2;
RSV3 = extensionFlags.Rsv3;
switch (option)
{
case WebSocketFrameOption.Text:
OPT1 = true;
break;
case WebSocketFrameOption.Binary:
OPT2 = true;
break;
case WebSocketFrameOption.ConnectionClose:
OPT4 = true;
break;
case WebSocketFrameOption.Ping:
OPT1 = OPT4 = true;
break;
case WebSocketFrameOption.Pong:
OPT4 = OPT2 = true;
break;
case WebSocketFrameOption.Continuation:
RSV1 = RSV2 = RSV3 = false;
break;
}
}
internal Task WriteInternalAsync(ArraySegment <Byte> buffer, Int32 count, Boolean isCompleted, Boolean headerSent, WebSocketMessageType type, WebSocketExtensionFlags extensionFlags, CancellationToken cancellation)
{
return(WriteInternalAsync(buffer, count, isCompleted, headerSent, (WebSocketFrameOption)type, extensionFlags, cancellation));
}
public static WebSocketFrameHeader Create(long count, bool isComplete, bool headerSent, WebSocketFrameOption option, WebSocketExtensionFlags extensionFlags)
{
var flags = new WebSocketFrameHeaderFlags(isComplete, headerSent ? WebSocketFrameOption.Continuation : option, extensionFlags);
int headerLength;
if (count <= 125)
{
headerLength = 2;
}
else if (count <= ushort.MaxValue)
{
headerLength = 4;
}
else if ((ulong)count < ulong.MaxValue)
{
headerLength = 10;
}
else
{
throw new WebSocketException("Cannot create a header with a length of " + count);
}
return(new WebSocketFrameHeader()
{
HeaderLength = headerLength,
ContentLength = count,
Flags = flags,
RemainingBytes = count
});
}
private async Task WriteInternalAsync(ArraySegment <Byte> buffer, Int32 count, Boolean isCompleted, Boolean headerSent, WebSocketFrameOption option, WebSocketExtensionFlags extensionFlags, CancellationToken cancellation)
{
CancellationTokenRegistration reg = cancellation.Register(this.Close, false);
try
{
var header = WebSocketFrameHeader.Create(count, isCompleted, headerSent, option, extensionFlags);
header.ToBytes(buffer.Array, buffer.Offset - header.HeaderLength);
if (!_writeSemaphore.Wait(_options.WebSocketSendTimeout))
{
throw new WebSocketException("Write timeout");
}
await _clientStream.WriteAsync(buffer.Array, buffer.Offset - header.HeaderLength, count + header.HeaderLength, cancellation).ConfigureAwait(false);
}
catch (InvalidOperationException)
{
Close(WebSocketCloseReasons.UnexpectedCondition);
}
catch (IOException)
{
Close(WebSocketCloseReasons.UnexpectedCondition);
}
catch (Exception ex)
{
Close(WebSocketCloseReasons.UnexpectedCondition);
throw new WebSocketException("Cannot write on WebSocket", ex);
}
finally
{
reg.Dispose();
if (_isClosed == 0)
{
SafeEnd.ReleaseSemaphore(_writeSemaphore);
}
}
}
public WebSocketMessageReadStreamStub(MemoryStream stream, WebSocketMessageType messageType, WebSocketExtensionFlags flags)
{
_stream = stream;
MessageType = messageType;
Flags = flags;
}
