internal void HandleTcpReceived(uint sequenceNumber, ArraySegment<byte> data)
{
var dataPosition = SequenceNumberToBytesReceived(sequenceNumber);
if (dataPosition == BytesReceived)
{
OnDataReceived(data);
BytesReceived += data.Count;
}
else
{
var dataArray = new byte[data.Count];
Array.Copy(data.Array, data.Offset, dataArray, 0, data.Count);
if (!_bufferedPackets.ContainsKey(dataPosition) || _bufferedPackets[dataPosition].Length < dataArray.Length)
{
_bufferedPackets[dataPosition] = dataArray;
}
}
long firstBufferedPosition;
while (_bufferedPackets.Any() && ((firstBufferedPosition = _bufferedPackets.Keys.First()) <= BytesReceived))
{
var dataArray = _bufferedPackets[firstBufferedPosition];
_bufferedPackets.Remove(firstBufferedPosition);
var alreadyReceivedBytes = BytesReceived - firstBufferedPosition;
Debug.Assert(alreadyReceivedBytes >= 0);
if (alreadyReceivedBytes < dataArray.Length)
{
var count = dataArray.Length - alreadyReceivedBytes;
OnDataReceived(new ArraySegment<byte>(dataArray, (int)alreadyReceivedBytes, (int)count));
BytesReceived += count;
}
}
}
/// <summary>
/// constructor of SecsMessage
/// </summary>
/// <param name="stream">message stream number</param>
/// <param name="function">message function number</param>
/// <param name="replyExpected">expect reply message</param>
/// <param name="name"></param>
/// <param name="item">root item</param>
public SecsMessage(byte stream, byte function, bool replyExpected = true, string name = null, Item item = null)
{
if (stream > 0x7F)
throw new ArgumentOutOfRangeException(nameof(stream), stream, "Stream number must be less than 127");
S = stream;
F = function;
Name = name;
ReplyExpected = replyExpected;
SecsItem = item;
RawDatas = new Lazy<List<ArraySegment<byte>>>(() =>
{
if (SecsItem == null)
return emptyMsgDatas;
var result = new List<ArraySegment<byte>> {
default(ArraySegment<byte>), // total length
new ArraySegment<byte>(Array.Empty<byte>()) // header
// item
};
uint length = 10 + SecsItem.EncodeTo(result); // total length = item + header
byte[] msgLengthByte = BitConverter.GetBytes(length);
Array.Reverse(msgLengthByte);
result[0] = new ArraySegment<byte>(msgLengthByte);
return result;
});
}
public virtual Task SendAsync(ArraySegment<byte> message, WebSocketMessageType messageType, bool endOfMessage = true)
{
if (WebSocket.State != WebSocketState.Open)
{
return TaskAsyncHelper.Empty;
}
var sendContext = new SendContext(this, message, messageType, endOfMessage);
return _sendQueue.Enqueue(async state =>
{
var context = (SendContext)state;
if (context.Handler.WebSocket.State != WebSocketState.Open)
{
return;
}
try
{
await context.Handler.WebSocket.SendAsync(context.Message, context.MessageType, context.EndOfMessage, CancellationToken.None);
}
catch (Exception ex)
{
// Swallow exceptions on send
Trace.TraceError("Error while sending: " + ex);
}
},
sendContext);
}
public DnsHeader (ArraySegment<byte> segment)
{
if (segment.Count != DnsHeaderLength)
throw new ArgumentException ("Count must be 12", "segment");
bytes = segment;
}
protected override object DeserializeObject(ArraySegment<byte> value)
{
var ds = new NetDataContractSerializer();
using (var ms = new MemoryStream(value.Array, value.Offset, value.Count))
return ds.Deserialize(ms);
}
public void Encrypt_KnownKey()
{
// Arrange
Secret kdk = new Secret(Encoding.UTF8.GetBytes("master key"));
GcmAuthenticatedEncryptor encryptor = new GcmAuthenticatedEncryptor(kdk, CachedAlgorithmHandles.AES_GCM, symmetricAlgorithmKeySizeInBytes: 128 / 8, genRandom: new SequentialGenRandom());
ArraySegment<byte> plaintext = new ArraySegment<byte>(new byte[] { 0, 1, 2, 3, 4, 5, 6, 7 }, 2, 3);
ArraySegment<byte> aad = new ArraySegment<byte>(new byte[] { 7, 6, 5, 4, 3, 2, 1, 0 }, 1, 4);
// Act
byte[] retVal = encryptor.Encrypt(
plaintext: plaintext,
additionalAuthenticatedData: aad,
preBufferSize: 3,
postBufferSize: 4);
// Assert
// retVal := 00 00 00 (preBuffer)
// | 00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F (keyModifier)
// | 10 11 12 13 14 15 16 17 18 19 1A 1B (nonce)
// | 43 B6 91 (encryptedData)
// | 8D 0D 66 D9 A1 D9 44 2D 5D 8E 41 DA 39 60 9C E8 (authTag)
// | 00 00 00 00 (postBuffer)
string retValAsString = Convert.ToBase64String(retVal);
Assert.Equal("AAAAAAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaG0O2kY0NZtmh2UQtXY5B2jlgnOgAAAAA", retValAsString);
}
/// <summary>
/// Creates a new Secret from the provided input value, where the input value
/// is specified as an array segment.
/// </summary>
public Secret(ArraySegment<byte> value)
{
value.Validate();
_localAllocHandle = Protect(value);
_plaintextLength = (uint)value.Count;
}
static int MinimumSubsequenceProduct(ArraySegment<int> Sequence)
{
if (Sequence.Count == 1)
return Sequence.Array[Sequence.Offset];
int Middle = Sequence.Count / 2;
int LeftProduct = MinimumSubsequenceProduct(new ArraySegment<int>(Sequence.Array, Sequence.Offset, Middle));
int RightProduct = MinimumSubsequenceProduct(new ArraySegment<int>(Sequence.Array, Sequence.Offset + Middle, Middle));
int MiddleProduct = 1;
int MiddleLeftProduct = 1;
int TempLeftProduct = 1;
for (int i = Middle; i >= Sequence.Offset; i--) {
TempLeftProduct *= Sequence.Array[i];
if (TempLeftProduct < MiddleLeftProduct)
MiddleLeftProduct = TempLeftProduct;
}
int MiddleRightProduct = 1;
int TempRightProduct = 1;
for (int i = Middle + 1; i < Sequence.Offset + Sequence.Count; i++) {
TempRightProduct *= Sequence.Array[i];
if (TempRightProduct < MiddleRightProduct)
MiddleRightProduct = TempRightProduct;
}
MiddleProduct = MiddleLeftProduct * MiddleRightProduct;
return Math.Min(Math.Min(LeftProduct, MiddleProduct), RightProduct);
}
public ArraySegment<byte> CopyToNextSegment(SocketAsyncEventArgs sourceEventArgs)
{
Byte[] array;
int offset;
int count = sourceEventArgs.BytesTransferred;
Locate(count, out array, out offset);
var data = new ArraySegment<byte>(array, offset, count);
if (sourceEventArgs.Buffer != null)
{
Buffer.BlockCopy(sourceEventArgs.Buffer, sourceEventArgs.Offset, array, offset, count);
}
else if (sourceEventArgs.BufferList != null)
{
int currentOffset = offset;
int copiedCount = 0;
foreach (var item in sourceEventArgs.BufferList)
{
int willcopyCount = count - copiedCount;
int copyingCount = willcopyCount > item.Count ? item.Count : willcopyCount;
Buffer.BlockCopy(item.Array, item.Offset, array, currentOffset, copyingCount);
copiedCount = copiedCount + copiedCount;
currentOffset = copiedCount + offset;
}
}
return data;
}
// Outgoing
public SettingsPair(SettingsFlags flags, SettingsIds id, int value)
{
_bufferSegment = new ArraySegment<byte>(new byte[PairSize], 0, PairSize);
Flags = flags;
Id = id;
Value = value;
}
private static async Task HandleWebSocketsAsync(HttpContext context, Func<Task> next)
{
if (!context.WebSockets.IsWebSocketRequest)
{
await next();
return;
}
var hub = context.RequestServices.GetRequiredService<MessageHub>();
using (var webSocket = await context.WebSockets.AcceptWebSocketAsync())
{
try
{
await hub.SubscribeAsync(webSocket);
var buffer = new ArraySegment<byte>(new byte[4096]);
while (webSocket?.State == WebSocketState.Open)
{
await webSocket.ReceiveAsync(buffer, CancellationToken.None);
}
}
finally
{
await hub.UnsubscribeAsync(webSocket);
}
}
}
/// <inheritdoc />
public override Message ReadMessage(ArraySegment<byte> buffer, BufferManager bufferManager, string contentType)
{
// Treat the alternate as native
if (IsAlternateContent(contentType))
{
// HACK: Should see if we have a declr or some xml
contentType = this.contentType;
}
var msgContents = new byte[buffer.Count];
Array.Copy(buffer.Array, buffer.Offset, msgContents, 0, msgContents.Length);
bufferManager.ReturnBuffer(buffer.Array);
// Most interoperable to include the xml declaration
writerSettings.OmitXmlDeclaration = false;
// Save the encoding for when we write the response
writerSettings.Encoding = msgContents.GetEncoding(contentType);
var xmlDeclEncoding = msgContents.GetXmlDeclEncoding(writerSettings.Encoding);
// Check if the two encodings align
if (xmlDeclEncoding != null && xmlDeclEncoding.WebName == writerSettings.Encoding.WebName)
{
// Need to recode
msgContents = Encoding.Convert(writerSettings.Encoding, xmlDeclEncoding, msgContents);
}
var stream = new MemoryStream(msgContents);
return ReadMessage(stream, int.MaxValue);
}
internal void SetUnmanagedStructures(IList<ArraySegment<byte>> buffers)
{
// Fill in Buffer Array structure that will be used for our send/recv Buffer.
// Make sure we don't let the app mess up the buffer array enough to cause
// corruption.
int count = buffers.Count;
ArraySegment<byte>[] buffersCopy = new ArraySegment<byte>[count];
for (int i = 0; i < count; i++)
{
buffersCopy[i] = buffers[i];
RangeValidationHelpers.ValidateSegment(buffersCopy[i]);
}
_wsaBuffers = new WSABuffer[count];
object[] objectsToPin = new object[count];
for (int i = 0; i < count; i++)
{
objectsToPin[i] = buffersCopy[i].Array;
}
base.SetUnmanagedStructures(objectsToPin);
for (int i = 0; i < count; i++)
{
_wsaBuffers[i].Length = buffersCopy[i].Count;
_wsaBuffers[i].Pointer = Marshal.UnsafeAddrOfPinnedArrayElement(buffersCopy[i].Array, buffersCopy[i].Offset);
}
}
public static byte[] Handshake(WebSocketHttpRequest request)
{
FleckLog.Debug("Building Draft76 Response");
var builder = new StringBuilder();
builder.Append("HTTP/1.1 101 WebSocket Protocol Handshake\r\n");
builder.Append("Upgrade: WebSocket\r\n");
builder.Append("Connection: Upgrade\r\n");
builder.AppendFormat("Sec-WebSocket-Origin: {0}\r\n", request["Origin"]);
builder.AppendFormat("Sec-WebSocket-Location: {0}://{1}{2}\r\n", request.Scheme, request["Host"], request.Path);
if (request.Headers.ContainsKey("Sec-WebSocket-Protocol"))
builder.AppendFormat("Sec-WebSocket-Protocol: {0}\r\n", request["Sec-WebSocket-Protocol"]);
builder.Append("\r\n");
var key1 = request["Sec-WebSocket-Key1"];
var key2 = request["Sec-WebSocket-Key2"];
var challenge = new ArraySegment<byte>(request.Bytes, request.Bytes.Length - 8, 8);
var answerBytes = CalculateAnswerBytes(key1, key2, challenge);
byte[] byteResponse = Encoding.ASCII.GetBytes(builder.ToString());
int byteResponseLength = byteResponse.Length;
Array.Resize(ref byteResponse, byteResponseLength + answerBytes.Length);
Array.Copy(answerBytes, 0, byteResponse, byteResponseLength, answerBytes.Length);
return byteResponse;
}
public static ReliableDataHeader FromSegment(ArraySegment<byte> segment)
{
ushort sequenceNumber = segment.ReadSequenceNumber(SystemHeader.Size);
ushort payloadSize = (ushort)BitConverter.ToInt16(segment.Array, segment.Offset + SystemHeader.Size + 2);
return new ReliableDataHeader(sequenceNumber, payloadSize);
}
protected override object DeserializeObject(ArraySegment<byte> value) {
Byte[] buffer;
if (value.Offset != 0) {
buffer = new Byte[value.Count];
Array.Copy(value.Array, value.Offset, buffer, 0, value.Count);
}
else {
buffer = value.Array;
}
Boolean isJson = false;
if (buffer[0] == 123 && buffer[buffer.Length - 1] == 125) {
isJson = true;
}
if (!isJson) {
var isOrignalObjectByte = buffer.Take(10).Distinct().All(_donetBytes.Contains);
isJson = !isOrignalObjectByte;
}
if (isJson) {
return JsonDeserialize(buffer);
}
else {
try {
return base.DeserializeObject(value);
}
catch (SerializationException) {
// Log or something
return JsonDeserialize(buffer);
}
}
}
public HeadTailWriteStream(ArraySegment<byte> head, int tailSize = 0)
{
_head = head;
if (tailSize > 0)
_tail = new ArraySegment<byte>(new byte[tailSize]);
_size = head.Count + tailSize;
}
public unsafe bool Read(PooledSocket socket)
{
this.StatusCode = -1;
if (!socket.IsAlive)
return false;
var header = new byte[HeaderLength];
socket.Read(header, 0, header.Length);
int dataLength, extraLength;
DeserializeHeader(header, out dataLength, out extraLength);
if (dataLength > 0)
{
var data = new byte[dataLength];
socket.Read(data, 0, dataLength);
this.Extra = new ArraySegment<byte>(data, 0, extraLength);
this.Data = new ArraySegment<byte>(data, extraLength, data.Length - extraLength);
}
return this.StatusCode == 0;
}
public static async Task<WebSocketMessage> ReadMessageAsync(WebSocket webSocket, byte[] buffer, int maxMessageSize)
{
ArraySegment<byte> arraySegment = new ArraySegment<byte>(buffer);
WebSocketReceiveResult receiveResult = await webSocket.ReceiveAsync(arraySegment, CancellationToken.None).ConfigureAwait(continueOnCapturedContext: false);
// special-case close messages since they might not have the EOF flag set
if (receiveResult.MessageType == WebSocketMessageType.Close)
{
return new WebSocketMessage(null, WebSocketMessageType.Close);
}
if (receiveResult.EndOfMessage)
{
// we anticipate that single-fragment messages will be common, so we optimize for them
switch (receiveResult.MessageType)
{
case WebSocketMessageType.Binary:
return new WebSocketMessage(BufferSliceToByteArray(buffer, receiveResult.Count), WebSocketMessageType.Binary);
case WebSocketMessageType.Text:
return new WebSocketMessage(BufferSliceToString(buffer, receiveResult.Count), WebSocketMessageType.Text);
default:
throw new Exception("This code path should never be hit.");
}
}
else
{
// for multi-fragment messages, we need to coalesce
ByteBuffer bytebuffer = new ByteBuffer(maxMessageSize);
bytebuffer.Append(BufferSliceToByteArray(buffer, receiveResult.Count));
WebSocketMessageType originalMessageType = receiveResult.MessageType;
while (true)
{
// loop until an error occurs or we see EOF
receiveResult = await webSocket.ReceiveAsync(arraySegment, CancellationToken.None).ConfigureAwait(continueOnCapturedContext: false);
if (receiveResult.MessageType != originalMessageType)
{
throw new InvalidOperationException("Incorrect message type");
}
bytebuffer.Append(BufferSliceToByteArray(buffer, receiveResult.Count));
if (receiveResult.EndOfMessage)
{
switch (receiveResult.MessageType)
{
case WebSocketMessageType.Binary:
return new WebSocketMessage(bytebuffer.GetByteArray(), WebSocketMessageType.Binary);
case WebSocketMessageType.Text:
return new WebSocketMessage(bytebuffer.GetString(), WebSocketMessageType.Text);
default:
throw new Exception("This code path should never be hit.");
}
}
}
}
}
public void BulkReply()
{
string reply = "#############$7\r\nmyvalue\r\n~~~~~~~~~~~";
var buffer = new ArraySegment<byte>(Encoding.UTF8.GetBytes(reply), 13, 13);
int readed;
var objResponse = new Redis.Driver.RedisProtocol().FindResponse(null, buffer, out readed);
Assert.IsNotNull(objResponse);
Assert.AreEqual(readed, 13);
Assert.IsTrue(objResponse.Reply is Redis.Driver.BulkReplies);
Assert.AreEqual("myvalue", Encoding.UTF8.GetString((objResponse.Reply as Redis.Driver.BulkReplies).Payload));
reply = "!!!$-1\r\n^^^^^^^^^^^^^^^";
buffer = new ArraySegment<byte>(Encoding.UTF8.GetBytes(reply), 3, 5);
objResponse = new Redis.Driver.RedisProtocol().FindResponse(null, buffer, out readed);
Assert.IsNotNull(objResponse);
Assert.AreEqual(readed, 5);
Assert.IsTrue(objResponse.Reply is Redis.Driver.BulkReplies);
Assert.IsNull((objResponse.Reply as Redis.Driver.BulkReplies).Payload);
reply = "$5\r\nabc";
buffer = new ArraySegment<byte>(Encoding.UTF8.GetBytes(reply), 0, 7);
objResponse = new Redis.Driver.RedisProtocol().FindResponse(null, buffer, out readed);
Assert.IsNull(objResponse);
Assert.AreEqual(readed, 0);
}
public static void GetPublicKey(ArraySegment<byte> publicKey, ArraySegment<byte> privateKey)
{
if (publicKey.Array == null)
throw new ArgumentNullException("publicKey.Array");
if (privateKey.Array == null)
throw new ArgumentNullException("privateKey.Array");
if (publicKey.Count != PublicKeySizeInBytes)
throw new ArgumentException("privateKey.Count must be 32");
if (privateKey.Count != PrivateKeySizeInBytes)
throw new ArgumentException("privateKey.Count must be 32");
// hack: abusing publicKey as temporary storage
// todo: remove hack
for (int i = 0; i < 32; i++)
{
publicKey.Array[publicKey.Offset + i] = privateKey.Array[privateKey.Offset + i];
}
ScalarOperations.sc_clamp(publicKey.Array, publicKey.Offset);
GroupElementP3 A;
GroupOperations.ge_scalarmult_base(out A, publicKey.Array, publicKey.Offset);
FieldElement publicKeyFE;
EdwardsToMontgomeryX(out publicKeyFE, ref A.Y, ref A.Z);
FieldOperations.fe_tobytes(publicKey.Array, publicKey.Offset, ref publicKeyFE);
}
public byte[] Encrypt(ArraySegment<byte> plaintext, ArraySegment<byte> additionalAuthenticatedData, uint preBufferSize, uint postBufferSize)
{
// This wrapper simply converts ArraySegment<byte> to byte* and calls the impl method.
// Input validation
plaintext.Validate();
additionalAuthenticatedData.Validate();
byte dummy; // used only if plaintext or AAD is empty, since otherwise 'fixed' returns null pointer
fixed (byte* pbPlaintextArray = plaintext.Array)
{
fixed (byte* pbAdditionalAuthenticatedDataArray = additionalAuthenticatedData.Array)
{
try
{
return EncryptImpl(
pbPlaintext: (pbPlaintextArray != null) ? &pbPlaintextArray[plaintext.Offset] : &dummy,
cbPlaintext: (uint)plaintext.Count,
pbAdditionalAuthenticatedData: (pbAdditionalAuthenticatedDataArray != null) ? &pbAdditionalAuthenticatedDataArray[additionalAuthenticatedData.Offset] : &dummy,
cbAdditionalAuthenticatedData: (uint)additionalAuthenticatedData.Count,
cbPreBuffer: preBufferSize,
cbPostBuffer: postBufferSize);
}
catch (Exception ex) when (ex.RequiresHomogenization())
{
// Homogenize to CryptographicException.
throw Error.CryptCommon_GenericError(ex);
}
}
}
}
private static async Task Listen(Tuple<int, WebSocket> connection)
{
const int maxMsgSize = 1024;
var webSocket = connection.Item2;
var buffer = new ArraySegment<byte>(new byte[maxMsgSize]);
WebSocketReceiveResult result = null;
do
{
logger.LogVerbose("Listen");
try {
result = await webSocket.ReceiveAsync(buffer, CancellationToken.None);
}
catch(Exception ex)
{
logger.LogVerbose("ReceiveAsync error: {0}", ex.Message);
await webSocket.CloseAsync(WebSocketCloseStatus.ProtocolError, "webSocket.ReceiveAsync error", CancellationToken.None);
return;
}
GetMessage(connection, result, buffer);
} while (!result.CloseStatus.HasValue);
await webSocket.CloseAsync(result.CloseStatus.Value, result.CloseStatusDescription, CancellationToken.None);
}
internal ConcateOperation(ConcatenationMode mode, string key, ArraySegment<byte> data)
: base(mode == ConcatenationMode.Append
? StoreCommand.Append
: StoreCommand.Prepend, key, new CacheItem() { Data = data, Flags = 0 }, 0, 0)
{
this.mode = mode;
}
public void ProcessRequest(HttpContext context)
{
context.AcceptWebSocketRequest(async sc =>
{
var socket = sc.WebSocket;
while(true)
{
var buffer = new ArraySegment<byte>(new byte[1024]);
await socket.ReceiveAsync(buffer, CancellationToken.None);
if (socket.State == WebSocketState.Open)
{
var message = Encoding.UTF8.GetString(buffer.Array, 0, buffer.Count);
var response = "Hello from WebSockets, " + message + ". The time is: " + DateTime.Now.ToShortTimeString();
var responseBuffer = new ArraySegment<byte>(Encoding.UTF8.GetBytes(response));
for (var i = 0; i < 5; i++)
{
var q = new ArraySegment<byte>(Encoding.UTF8.GetBytes("Hello " + i));
await socket.SendAsync(q, WebSocketMessageType.Text, true, CancellationToken.None);
Thread.Sleep(2000);
}
await socket.SendAsync(responseBuffer, WebSocketMessageType.Text, true, CancellationToken.None);
}
else
{
break;
}
}
});
}
private WebSocketBuffer(ArraySegment<byte> internalBuffer, int receiveBufferSize, int sendBufferSize)
{
Contract.Assert(internalBuffer != null, "'internalBuffer' MUST NOT be NULL.");
Contract.Assert(receiveBufferSize >= MinReceiveBufferSize,
"'receiveBufferSize' MUST be at least " + MinReceiveBufferSize.ToString(NumberFormatInfo.InvariantInfo) + ".");
Contract.Assert(sendBufferSize >= MinSendBufferSize,
"'sendBufferSize' MUST be at least " + MinSendBufferSize.ToString(NumberFormatInfo.InvariantInfo) + ".");
Contract.Assert(receiveBufferSize <= MaxBufferSize,
"'receiveBufferSize' MUST NOT exceed " + MaxBufferSize.ToString(NumberFormatInfo.InvariantInfo) + ".");
Contract.Assert(sendBufferSize <= MaxBufferSize,
"'sendBufferSize' MUST NOT exceed " + MaxBufferSize.ToString(NumberFormatInfo.InvariantInfo) + ".");
m_ReceiveBufferSize = receiveBufferSize;
m_SendBufferSize = sendBufferSize;
m_InternalBuffer = internalBuffer;
m_GCHandle = GCHandle.Alloc(internalBuffer.Array, GCHandleType.Pinned);
// Size of the internal buffer owned exclusively by the WSPC.
int nativeBufferSize = m_ReceiveBufferSize + m_SendBufferSize + NativeOverheadBufferSize;
m_StartAddress = Marshal.UnsafeAddrOfPinnedArrayElement(internalBuffer.Array, internalBuffer.Offset).ToInt64();
m_EndAddress = m_StartAddress + nativeBufferSize;
m_NativeBuffer = new ArraySegment<byte>(internalBuffer.Array, internalBuffer.Offset, nativeBufferSize);
m_PayloadBuffer = new ArraySegment<byte>(internalBuffer.Array,
m_NativeBuffer.Offset + m_NativeBuffer.Count,
m_ReceiveBufferSize);
m_PropertyBuffer = new ArraySegment<byte>(internalBuffer.Array,
m_PayloadBuffer.Offset + m_PayloadBuffer.Count,
s_PropertyBufferSize);
m_SendBufferState = SendBufferState.None;
}
public void Send(ArraySegment<byte> segment)
{
if (!m_Connected || m_Session == null)
throw new Exception("The socket is not connected.");
m_Session.Send(segment);
}
protected override void OnDecode(ByteBuffer buffer, int count)
{
if (count-- > 0)
{
this.Response = AmqpCodec.DecodeBinary(buffer);
}
}
public static void DeriveKeysWithContextHeader(byte[] kdk, ArraySegment<byte> label, byte[] contextHeader, ArraySegment<byte> context, Func<byte[], HashAlgorithm> prfFactory, ArraySegment<byte> output)
{
byte[] combinedContext = new byte[checked(contextHeader.Length + context.Count)];
Buffer.BlockCopy(contextHeader, 0, combinedContext, 0, contextHeader.Length);
Buffer.BlockCopy(context.Array, context.Offset, combinedContext, contextHeader.Length, context.Count);
DeriveKeys(kdk, label, new ArraySegment<byte>(combinedContext), prfFactory, output);
}
private static void GetMessage(Tuple<int, WebSocket> connection, WebSocketReceiveResult result, ArraySegment<byte> bytes)
{
var connectionId = connection.Item1;
var webSocket = connection.Item2;
var message = Encoding.UTF8.GetString(bytes.Array, 0, result.Count);
Broadcast(message, connectionId, result.EndOfMessage);
}
private void RenderTriangles(ref Paint paint,
ref Scissor scissor,
float width, float fringe, float strokeThr,
RenderingType renderingType,
ArraySegment <Vertex> verts,
PrimitiveType primitiveType,
bool indexed)
{
if (verts.Count <= 0 ||
indexed && _indexesCount <= 0)
{
return;
}
var innerColor = premultiplyColor(paint.InnerColor);
var outerColor = premultiplyColor(paint.OuterColor);
_strokeMult = (width * 0.5f + fringe * 0.5f) / fringe;
if (scissor.Extent.X < -0.5f || scissor.Extent.Y < -0.5f)
{
_scissorTransform.Zero();
_scissorExt.X = 1.0f;
_scissorExt.Y = 1.0f;
_scissorScale.X = 1.0f;
_scissorScale.Y = 1.0f;
}
else
{
_scissorTransform = scissor.Transform.BuildInverse();
_scissorExt.X = scissor.Extent.X;
_scissorExt.Y = scissor.Extent.Y;
_scissorScale.X =
(float)Math.Sqrt(scissor.Transform.T1 * scissor.Transform.T1 +
scissor.Transform.T3 * scissor.Transform.T3) / fringe;
_scissorScale.Y =
(float)Math.Sqrt(scissor.Transform.T2 * scissor.Transform.T2 +
scissor.Transform.T4 * scissor.Transform.T4) / fringe;
}
var transform = paint.Transform.BuildInverse();
var transformMatrix = transform.ToMatrix();
_viewSizeParam.SetValue(new Vector2(_device.PresentationParameters.Bounds.Width,
_device.PresentationParameters.Bounds.Height));
_scissorMatParam.SetValue(_scissorTransform.ToMatrix());
_scissorExtParam.SetValue(_scissorExt);
_scissorScaleParam.SetValue(_scissorScale);
_paintMatParam.SetValue(transformMatrix);
_extentParam.SetValue(new Vector4(paint.Extent.X, paint.Extent.Y, 0.0f, 0.0f));
_radiusParam.SetValue(new Vector4(paint.Radius, 0.0f, 0.0f, 0.0f));
_featherParam.SetValue(new Vector4(paint.Feather, 0.0f, 0.0f, 0.0f));
_innerColParam.SetValue(innerColor.ToVector4());
_outerColParam.SetValue(outerColor.ToVector4());
// _effect.Parameters["strokeMult"].SetValue(new Vector4(_strokeMult, 0.0f, 0.0f, 0.0f));
if (paint.Image > 0)
{
var texture = GetTextureById(paint.Image);
_textureParam.SetValue(texture);
}
var technique = _techniques[(int)renderingType];
_effect.CurrentTechnique = technique;
foreach (var pass in _effect.CurrentTechnique.Passes)
{
pass.Apply();
if (indexed)
{
_device.DrawUserIndexedPrimitives(primitiveType, verts.Array, verts.Offset, verts.Count,
_indexes, 0, _indexesCount / 3);
}
else
{
var primitiveCount =
primitiveType == PrimitiveType.TriangleList ? verts.Count / 3 : verts.Count - 2;
_device.DrawUserPrimitives(primitiveType, verts.Array, verts.Offset, primitiveCount);
}
}
_vertexes.Clear();
}
public void SelectHexBoxRange(ArraySegment <byte> segment)
{
SelectHexBoxRange(segment.Offset - hexBoxBytes.Offset, segment.Count);
}
private async Task SendMessage(ArraySegment <byte> message)
{
await _webSocket.SendAsync(message, WebSocketMessageType.Text, true, _cancellationTokenSource.Token);
}
/// <summary>Constructs an incoming request frame.</summary>
/// <param name="protocol">The Ice protocol.</param>
/// <param name="data">The frame data as an array segment.</param>
/// <param name="maxSize">The maximum payload size, checked during decompression.</param>
public IncomingRequestFrame(Protocol protocol, ArraySegment <byte> data, int maxSize)
: this(protocol, data, maxSize, null)
{
}
public override Task SendAsync(ArraySegment <byte> buffer, WebSocketMessageType messageType, bool endOfMessage, CancellationToken cancellationToken)
{
throw new NotImplementedException();
}
public override Task <WebSocketReceiveResult> ReceiveAsync(ArraySegment <byte> buffer, CancellationToken cancellationToken)
{
throw new NotImplementedException();
}
public void ClearHexBox()
{
hexBoxBytes = default;
mHex.ByteProvider = null;
}
public void SelectMaplePacket(MaplePacket packet)
{
hexBoxBytes = packet.GetSegment(packet.Offset, packet.Length);
mHex.ByteProvider = new DynamicByteProvider(hexBoxBytes.ToList());
}
/// <summary> /// Send data to the server /// </summary> /// <param name="channelId">The channel to use. 0 is the default channel, /// but some transports might want to provide unreliable, encrypted, compressed, or any other feature /// as new channels</param> /// <param name="segment">The data to send to the server. Will be recycled after returning, so either use it directly or copy it internally. This allows for allocation-free sends!</param> public abstract void ClientSend(int channelId, ArraySegment <byte> segment);
/// <summary> /// Send data to a client. /// </summary> /// <param name="connectionId">The client connection id to send the data to</param> /// <param name="channelId">The channel to be used. Transports can use channels to implement /// other features such as unreliable, encryption, compression, etc...</param> /// <param name="segment"></param> public abstract void ServerSend(int connectionId, int channelId, ArraySegment <byte> segment);
public void SetVertexData <T>(ArraySegment <T> vertexData, VertexDescriptor descriptor, int destinationOffsetInVertices) where T : struct
{
_stride = descriptor.VertexSizeInBytes;
SetData(vertexData, destinationOffsetInVertices * descriptor.VertexSizeInBytes);
}
/// <summary>
/// Handle the player connection.
/// </summary>
/// <param name="request">The <see cref="ConnectionRequest"/> instance.</param>
private static void HandleConnection(ConnectionRequest request)
{
try
{
int position = request.Data.Position;
if (!request.Data.TryGetByte(out byte result1) || !request.Data.TryGetByte(out byte result2) || !request.Data.TryGetByte(out byte result3) || result1 != CustomNetworkManager.Major || result2 != CustomNetworkManager.Minor || result3 != CustomNetworkManager.SyncedRevision)
{
CustomLiteNetLib4MirrorTransport.RequestWriter.Reset();
CustomLiteNetLib4MirrorTransport.RequestWriter.Put((byte)3);
request.RejectForce(CustomLiteNetLib4MirrorTransport.RequestWriter);
}
else
{
bool flag = request.Data.TryGetInt(out int result4);
if (!request.Data.TryGetBytesWithLength(out byte[] result5))
{
flag = false;
}
if (!flag)
{
CustomLiteNetLib4MirrorTransport.RequestWriter.Reset();
CustomLiteNetLib4MirrorTransport.RequestWriter.Put((byte)15);
request.RejectForce(CustomLiteNetLib4MirrorTransport.RequestWriter);
}
else if (CustomLiteNetLib4MirrorTransport.DelayConnections)
{
CustomLiteNetLib4MirrorTransport.PreauthDisableIdleMode();
CustomLiteNetLib4MirrorTransport.RequestWriter.Reset();
CustomLiteNetLib4MirrorTransport.RequestWriter.Put((byte)17);
CustomLiteNetLib4MirrorTransport.RequestWriter.Put(CustomLiteNetLib4MirrorTransport.DelayTime);
if (CustomLiteNetLib4MirrorTransport.DelayVolume < byte.MaxValue)
{
++CustomLiteNetLib4MirrorTransport.DelayVolume;
}
if (CustomLiteNetLib4MirrorTransport.DelayVolume < CustomLiteNetLib4MirrorTransport.DelayVolumeThreshold)
{
ServerConsole.AddLog(
$"Delayed connection incoming from endpoint {request.RemoteEndPoint} by {CustomLiteNetLib4MirrorTransport.DelayTime} seconds.");
request.Reject(CustomLiteNetLib4MirrorTransport.RequestWriter);
}
else
{
ServerConsole.AddLog(
$"Force delayed connection incoming from endpoint {request.RemoteEndPoint} by {CustomLiteNetLib4MirrorTransport.DelayTime} seconds.");
request.RejectForce(CustomLiteNetLib4MirrorTransport.RequestWriter);
}
}
else
{
if (CustomLiteNetLib4MirrorTransport.UseChallenge)
{
if (result4 == 0 || result5 == null || result5.Length == 0)
{
if (!CustomLiteNetLib4MirrorTransport.CheckIpRateLimit(request))
{
return;
}
int num = 0;
string key = string.Empty;
for (byte index = 0; index < 3; ++index)
{
num = RandomGenerator.GetInt32();
if (num == 0)
{
num = 1;
}
key = request.RemoteEndPoint.Address + "-" + num;
if (CustomLiteNetLib4MirrorTransport.Challenges.ContainsKey(key))
{
if (index == 2)
{
CustomLiteNetLib4MirrorTransport.RequestWriter.Reset();
CustomLiteNetLib4MirrorTransport.RequestWriter.Put((byte)4);
request.RejectForce(CustomLiteNetLib4MirrorTransport.RequestWriter);
ServerConsole.AddLog(
$"Failed to generate ID for challenge for incoming connection from endpoint {request.RemoteEndPoint}.");
return;
}
}
else
{
break;
}
}
byte[] bytes = RandomGenerator.GetBytes(CustomLiteNetLib4MirrorTransport.ChallengeInitLen + CustomLiteNetLib4MirrorTransport.ChallengeSecretLen, true);
ServerConsole.AddLog(
$"Requested challenge for incoming connection from endpoint {request.RemoteEndPoint}.");
CustomLiteNetLib4MirrorTransport.RequestWriter.Reset();
CustomLiteNetLib4MirrorTransport.RequestWriter.Put((byte)13);
CustomLiteNetLib4MirrorTransport.RequestWriter.Put((byte)CustomLiteNetLib4MirrorTransport.ChallengeMode);
CustomLiteNetLib4MirrorTransport.RequestWriter.Put(num);
switch (CustomLiteNetLib4MirrorTransport.ChallengeMode)
{
case ChallengeType.MD5:
CustomLiteNetLib4MirrorTransport.RequestWriter.PutBytesWithLength(bytes, 0, CustomLiteNetLib4MirrorTransport.ChallengeInitLen);
CustomLiteNetLib4MirrorTransport.RequestWriter.Put(CustomLiteNetLib4MirrorTransport.ChallengeSecretLen);
CustomLiteNetLib4MirrorTransport.RequestWriter.PutBytesWithLength(Md.Md5(bytes));
CustomLiteNetLib4MirrorTransport.Challenges.Add(key, new PreauthChallengeItem(new ArraySegment <byte>(bytes, CustomLiteNetLib4MirrorTransport.ChallengeInitLen, CustomLiteNetLib4MirrorTransport.ChallengeSecretLen)));
break;
case ChallengeType.SHA1:
CustomLiteNetLib4MirrorTransport.RequestWriter.PutBytesWithLength(bytes, 0, CustomLiteNetLib4MirrorTransport.ChallengeInitLen);
CustomLiteNetLib4MirrorTransport.RequestWriter.Put(CustomLiteNetLib4MirrorTransport.ChallengeSecretLen);
CustomLiteNetLib4MirrorTransport.RequestWriter.PutBytesWithLength(Sha.Sha1(bytes));
CustomLiteNetLib4MirrorTransport.Challenges.Add(key, new PreauthChallengeItem(new ArraySegment <byte>(bytes, CustomLiteNetLib4MirrorTransport.ChallengeInitLen, CustomLiteNetLib4MirrorTransport.ChallengeSecretLen)));
break;
default:
CustomLiteNetLib4MirrorTransport.RequestWriter.PutBytesWithLength(bytes);
CustomLiteNetLib4MirrorTransport.Challenges.Add(key, new PreauthChallengeItem(new ArraySegment <byte>(bytes)));
break;
}
request.Reject(CustomLiteNetLib4MirrorTransport.RequestWriter);
CustomLiteNetLib4MirrorTransport.PreauthDisableIdleMode();
return;
}
string key1 = request.RemoteEndPoint.Address + "-" + result4;
if (!CustomLiteNetLib4MirrorTransport.Challenges.ContainsKey(key1))
{
ServerConsole.AddLog(
$"Security challenge response of incoming connection from endpoint {request.RemoteEndPoint} has been REJECTED (invalid Challenge ID).");
CustomLiteNetLib4MirrorTransport.RequestWriter.Reset();
CustomLiteNetLib4MirrorTransport.RequestWriter.Put((byte)14);
request.RejectForce(CustomLiteNetLib4MirrorTransport.RequestWriter);
return;
}
ArraySegment <byte> validResponse = CustomLiteNetLib4MirrorTransport.Challenges[key1].ValidResponse;
if (!result5.SequenceEqual(validResponse))
{
ServerConsole.AddLog(
$"Security challenge response of incoming connection from endpoint {request.RemoteEndPoint} has been REJECTED (invalid response).");
CustomLiteNetLib4MirrorTransport.RequestWriter.Reset();
CustomLiteNetLib4MirrorTransport.RequestWriter.Put((byte)15);
request.RejectForce(CustomLiteNetLib4MirrorTransport.RequestWriter);
return;
}
CustomLiteNetLib4MirrorTransport.Challenges.Remove(key1);
CustomLiteNetLib4MirrorTransport.PreauthDisableIdleMode();
ServerConsole.AddLog(
$"Security challenge response of incoming connection from endpoint {request.RemoteEndPoint} has been accepted.");
}
else if (!CustomLiteNetLib4MirrorTransport.CheckIpRateLimit(request))
{
return;
}
if (!CharacterClassManager.OnlineMode)
{
KeyValuePair <BanDetails, BanDetails> keyValuePair = BanHandler.QueryBan(null, request.RemoteEndPoint.Address.ToString());
if (keyValuePair.Value != null)
{
ServerConsole.AddLog($"Player tried to connect from banned endpoint {request.RemoteEndPoint}.");
CustomLiteNetLib4MirrorTransport.RequestWriter.Reset();
CustomLiteNetLib4MirrorTransport.RequestWriter.Put((byte)6);
CustomLiteNetLib4MirrorTransport.RequestWriter.Put(keyValuePair.Value.Expires);
CustomLiteNetLib4MirrorTransport.RequestWriter.Put(keyValuePair.Value?.Reason ?? string.Empty);
request.RejectForce(CustomLiteNetLib4MirrorTransport.RequestWriter);
}
else
{
request.Accept();
CustomLiteNetLib4MirrorTransport.PreauthDisableIdleMode();
}
}
else
{
if (!request.Data.TryGetString(out string result6) || result6 == string.Empty)
{
CustomLiteNetLib4MirrorTransport.RequestWriter.Reset();
CustomLiteNetLib4MirrorTransport.RequestWriter.Put((byte)5);
request.RejectForce(CustomLiteNetLib4MirrorTransport.RequestWriter);
}
private FieldNameNode(ArraySegment<byte> bufferedToken)
: base(bufferedToken, false)
{
}
static void WebServerOnData(int id, ArraySegment <byte> data)
{
_bitBuffer.Clear();
_bitBuffer.FromArray(data.Array, data.Count);
byte messageId = _bitBuffer.ReadByte();
switch (messageId)
{
case 1:
{
uint qX = _bitBuffer.ReadUInt();
uint qY = _bitBuffer.ReadUInt();
PlayerData playerData = _playerDatas[id];
playerData.qX = qX;
playerData.qY = qY;
// Send this position to everyone next state packet
_dataToSend.Enqueue(playerData);
break;
}
case 8:
{
string name = _bitBuffer.ReadString();
_playerDatas[id].name = name;
_playerDatas[id].handshaked = true;
_handshakenClientCount += 1;
// Tell all the players this new client's name
_bitBuffer.Clear();
_bitBuffer.AddByte(9);
_bitBuffer.AddUShort(_playerDatas[id].id);
_bitBuffer.AddString(_playerDatas[id].name);
_bitBuffer.ToArray(_buffer);
_webServer.SendAll(_connectedIds, new ArraySegment <byte>(_buffer, 0, 23));
break;
}
case 10:
{
ushort objectId = _bitBuffer.ReadUShort();
ushort newX = _bitBuffer.ReadUShort();
ushort newY = _bitBuffer.ReadUShort();
_movedObjects[objectId] = new Tuple <ushort, ushort>(newX, newY);
break;
}
case 11:
{
short pointChange = _bitBuffer.ReadShort();
_playerDatas[id].points += pointChange;
// If points are 0 or less, give builder a point
if (pointChange <= 0)
{
_playerDatas[_builderId].points += 1;
}
break;
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="Bitfield"/> class.
/// </summary>
/// <param name="buffer">Sequence of bits to initialize the bitfield from.</param>
public Bitfield(ArraySegment <byte> buffer)
{
FromBytesInternal(buffer.Array, buffer.Offset, buffer.Count);
}
protected override ProtobufRequestInfo ResolveRequestInfo(ArraySegment<byte> header, byte[] bodyBuffer, int offset, int length)
{
info.Body = bodyBuffer.CloneRange(offset, length);
return info;
}
public int Initialize(ref ArraySegment <byte> readBuffer, IList <ArraySegment <byte> > writeBuffer)
{
if (!_isConnected)
{
int status = _delegate.Initialize(ref readBuffer, writeBuffer);
if (status != SocketOperation.None)
{
return(status);
}
_isConnected = true;
}
Socket?fd = _delegate.Fd();
Debug.Assert(fd != null);
Network.SetBlock(fd, true); // SSL requires a blocking socket
//
// For timeouts to work properly, we need to receive/send
// the data in several chunks. Otherwise, we would only be
// notified when all the data is received/written. The
// connection timeout could easily be triggered when
// receiving/sending large messages.
//
_maxSendPacketSize = Math.Max(512, Network.GetSendBufferSize(fd));
_maxRecvPacketSize = Math.Max(512, Network.GetRecvBufferSize(fd));
if (_sslStream == null)
{
try
{
_sslStream = new SslStream(
new NetworkStream(fd, false),
false,
_engine.RemoteCertificateValidationCallback ?? RemoteCertificateValidationCallback,
_engine.CertificateSelectionCallback ?? CertificateSelectionCallback);
}
catch (IOException ex)
{
if (Network.ConnectionLost(ex))
{
throw new ConnectionLostException(ex);
}
else
{
throw new TransportException(ex);
}
}
return(SocketOperation.Connect);
}
Debug.Assert(_sslStream.IsAuthenticated);
_authenticated = true;
_cipher = _sslStream.CipherAlgorithm.ToString();
_engine.VerifyPeer((SslConnectionInfo)GetInfo(), ToString());
if (_engine.SecurityTraceLevel >= 1)
{
_engine.TraceStream(_sslStream, ToString());
}
return(SocketOperation.None);
}
/// <summary>
/// Convert Bond byte arraysegment to Grpc ByteString
/// </summary>
public static ByteString ToByteString(this ArraySegment <byte> bytes)
{
return(ByteString.CopyFrom(bytes.Array, bytes.Offset, bytes.Count));
}
Task <int> ReadFromSslStreamAsync(IByteBuffer outputBuffer, int outputBufferLength)
{
ArraySegment <byte> outlet = outputBuffer.GetIoBuffer(outputBuffer.WriterIndex, outputBufferLength);
return(this.sslStream.ReadAsync(outlet.Array, outlet.Offset, outlet.Count));
}
public async Task Connect()
{
int origin = Interlocked.Exchange(ref _state, _connecting);
if (!(origin == _none || origin == _closed))
{
await Close(false);
throw new InvalidOperationException("This tcp socket client is in invalid state when connecting.");
}
try
{
Clean();
_tcpClient = _localEndPoint != null ?
new TcpClient(_localEndPoint) :
new TcpClient(_remoteEndPoint.Address.AddressFamily);
SetSocketOptions();
var awaiter = _tcpClient.ConnectAsync(_remoteEndPoint.Address, _remoteEndPoint.Port);
if (!awaiter.Wait(ConnectTimeout))
{
await Close(false);
throw new TimeoutException(string.Format(
"Connect to [{0}] timeout [{1}].", _remoteEndPoint, ConnectTimeout));
}
var negotiator = NegotiateStream(_tcpClient.GetStream());
if (!negotiator.Wait(ConnectTimeout))
{
await Close(false);
throw new TimeoutException(string.Format(
"Negotiate SSL/TSL with remote [{0}] timeout [{1}].", _remoteEndPoint, ConnectTimeout));
}
_stream = negotiator.Result;
if (_receiveBuffer == default(ArraySegment <byte>))
{
_receiveBuffer = _configuration.BufferManager.BorrowBuffer();
}
_receiveBufferOffset = 0;
if (Interlocked.CompareExchange(ref _state, _connected, _connecting) != _connecting)
{
await Close(false);
throw new InvalidOperationException("This tcp socket client is in invalid state when connected.");
}
_log.DebugFormat("Connected to server [{0}] with dispatcher [{1}] on [{2}].",
this.RemoteEndPoint,
_dispatcher.GetType().Name,
DateTime.UtcNow.ToString(@"yyyy-MM-dd HH:mm:ss.fffffff"));
bool isErrorOccurredInUserSide = false;
try
{
await _dispatcher.OnServerConnected(this);
}
catch (Exception ex)
{
isErrorOccurredInUserSide = true;
await HandleUserSideError(ex);
}
if (!isErrorOccurredInUserSide)
{
Task.Factory.StartNew(async() =>
{
await Process();
},
TaskCreationOptions.LongRunning)
.Forget();
}
else
{
await Close();
}
}
catch (Exception ex)
{
_log.Error(ex.Message, ex);
throw;
}
}
public async void Connect(System.Threading.CancellationToken?token = null)
{
var _token = token ?? GetDefaultCancellationToken();
if (ReceivedMessageFunc == null)
{
throw (new ArgumentNullException(nameof(ReceivedMessageFunc)));
}
Log(LogType.Info, "开始连接服务器");
if (!this._isConnect)
{
clientWebSocket = new System.Net.WebSockets.ClientWebSocket();
}
else
{
throw new Exception("已经建立链接，请断开链接后再试");
}
await clientWebSocket.ConnectAsync(new Uri("ws://message.1688.com/websocket"), _token);
var rr = System.Threading.Tasks.Task.Run(async() =>
{
while (_isConnect)
{
try
{
var buffer = new ArraySegment <byte>(new byte[4096]);
var result = await clientWebSocket.ReceiveAsync(buffer, _token);
if (result.MessageType == System.Net.WebSockets.WebSocketMessageType.Text)
{
if (result.EndOfMessage)
{
var json = System.Text.Encoding.UTF8.GetString(buffer.Array, 0, result.Count);
var receivedMessage = Newtonsoft.Json.JsonConvert.DeserializeObject <ReceivedMessage>(json, serializerSettings);
Log(LogType.Info, "接收到消息，类型:" + receivedMessage.Type);
if (receivedMessage.Type == WebSocketMessageType.CONNECT_ACK)
{
IsConnect = true;
sendHeartbeat(_token);
}
else if (receivedMessage.Type == WebSocketMessageType.SERVER_PUSH)
{
var dd = System.Threading.Tasks.Task.Run(() =>
{
try
{
var b = Newtonsoft.Json.JsonConvert.DeserializeObject <ReceivedMessageDataBaseType>(receivedMessage.Content, serializerSettings);
var ss = GetReceivedMessageData(b.Type, receivedMessage.Content);
var r = ReceivedMessageFunc?.Invoke(receivedMessage.MsgSource, ss);
if (r == true)
{
sendConfirm(receivedMessage, _token);
}
}
catch (Exception ex)
{
Log(LogType.Error, "处理消息异常", ex);
}
});
}
else if (receivedMessage.Type == WebSocketMessageType.SYSTEM)
{
SystemInfoFunc?.Invoke(receivedMessage.MsgSource, receivedMessage.Content);
}
else
{
Log(LogType.Error, "接收到其他消息，--------------------------------------------------类型:" + receivedMessage.Type);
//throw new Exception("异常");
}
}
else
{
throw new Exception("异常");
}
}
else if (result.MessageType == System.Net.WebSockets.WebSocketMessageType.Binary)
{
throw new Exception("异常");
}
else if (result.MessageType == System.Net.WebSockets.WebSocketMessageType.Close)
{
throw new Exception("异常");
}
else
{
throw new Exception("异常");
}
}
catch (Exception ex)
{
Log(LogType.Error, "接收数据异常", ex);
//throw new Exception("异常", ex);
}
}
});
sendConnect(_token);
//sendHeartbeat();
}
// Force caller to use asynchronous read. public int Read(ref ArraySegment <byte> buffer, ref int offset) => offset < buffer.Count ? SocketOperation.Read : SocketOperation.None;
public void ExecuteCommand(GameSession session, ProtobufRequestInfo requestInfo)
{
if (!Gongyong.userlist.Any(w => w.session.SessionID.Equals(session.SessionID)))
{
session.Logger.Debug("DayToL : 非法连接");
session.Close();
return;
}
var getMsg = SendBT.ParseFrom(requestInfo.Body);
List <mjuser> listuser = Gongyong.mulist.FindAll(u => u.RoomID == getMsg.RoomID);
mjuser mjuser = Gongyong.mulist.Find(u => u.Openid == getMsg.Openid && u.RoomID == getMsg.RoomID);
var room = Gongyong.roomlist.Find(w => w.RoomID == getMsg.RoomID);
if (room == null)
{
return;
}
if (mjuser == null)
{
return;
}
if (getMsg.Type == 1 && mjuser.majiangs.Count != 14)//天听，报听时手牌还未扣除，因此为14张
{
return;
}
if ((getMsg.Type == 2 && !mjuser.Is_tiant))
{
return;
}
int fw = mjuser.ZS_Fw;
if (mjuser.ByteData == requestInfo.Key)
{
return;
}
else
{
mjuser.ByteData = requestInfo.Key;
}
Ting t = new Ting();
List <model.ServerMaJiang> Returnmj = new List <model.ServerMaJiang>();
Returnmj.AddRange(mjuser.majiangs.ToArray());
if (getMsg.Type == 1 && !mjuser.Is_tianHu)
{
List <model.ServerMaJiang> Ruturnjsmj = new List <model.ServerMaJiang>();
Ruturnjsmj = t.ReturnJMJ(Returnmj);
Returnmj.Remove(Returnmj.Find(w => w.PaiHs == getMsg.Mj.PaiHS && w.PaiId == getMsg.Mj.PaiID));
if (!Ruturnjsmj.Any(w => w.PaiHs == getMsg.Mj.PaiHS))
{
return;//出的牌必须是打出听牌的集合中的一张
}
}
if (getMsg.Type == 2 && t.GetTing(Returnmj) == "MJ")
{
mjuser.Is_tiant = false;
return;
}
bool isShenTianHu = false;
List <mjuser> list = new List <mjuser>();
foreach (var item in listuser)
{
list.Add(item);
if (!isShenTianHu)
{
item.SendData.Clear();
}
if (item.Openid.Equals(getMsg.Openid))
{
switch (getMsg.Type)
{
case 1:
if (mjuser.Is_tianHu)
{
mjuser.Is_tianHu = false;
}
var roomInfo = Gongyong.roomlist.FirstOrDefault(w => w.RoomID.Equals(getMsg.RoomID));
if (roomInfo != null)
{
roomInfo.LastMoMJ = new model.ServerMaJiang {
PaiHs = getMsg.Mj.PaiHS, PaiId = getMsg.Mj.PaiID
}
}
;
item.Is_baotin = true;
break;
case 2:
item.Is_tiant = true;
CardUser cu = Gongyong.FKUser.Find(u => u.roomid == getMsg.RoomID);
item.Is_tiantX = 1;
byte[] startHY = ReturnHyUser.CreateBuilder().SetCz("3001").SetFw(cu.win).Build().ToByteArray();
if (!listuser.Any(w => w.Is_tiantX == -1))
{
if (room != null)
{
room.DQHY = cu.win;
room.DQcz = "3001";
}
List <mjuser> listmjuserstart = Gongyong.mulist.FindAll(u => u.RoomID == getMsg.RoomID);
foreach (var items in listmjuserstart)
{
UserInfo users = Gongyong.userlist.Find(u => u.openid == items.Openid);
users.IsActive = true;
users.session.TrySend(new ArraySegment <byte>(CreateHead.CreateMessage(GameInformationBase.BASEAGREEMENTNUMBER + 7004, startHY.Length, requestInfo.MessageNum, startHY)));
}
var msglist = Gongyong.roommsg.FindAll(u => u.roomid == getMsg.RoomID);
if (msglist.Count > 0)
{
Room r = Gongyong.roomlist.Find(u => u.RoomID == getMsg.RoomID);
foreach (var msgitem in msglist)
{
var userInfo = Gongyong.userlist.Find(u => u.openid == msgitem.openid);
if (userInfo != null)
{
isShenTianHu = true;
var mjUser = listmjuserstart.Find(u => u.Openid.Equals(msgitem.openid));
r.DQHY = mjUser.ZS_Fw;
if (!list.Any(w => w.Openid.Equals(msgitem.openid))) //如果外面的遍历已经遍历过当前用户 则不需要清理集合
{
mjUser.SendData.Clear();
}
var data = new ArraySegment <byte>(CreateHead.CreateMessage(GameInformationBase.BASEAGREEMENTNUMBER + msgitem.xiaoxihao, msgitem.ArrList.Length, requestInfo.MessageNum, msgitem.ArrList));
mjUser.SendData.Add(data);
userInfo.session.TrySend(data);
//session.Logger.Debug("过牌后根据之前的消息分配活跃用户" + r.DQHY);
}
}
Gongyong.roommsg.RemoveAll(u => u.roomid == r.RoomID);
}
}
break;
default:
break;
}
}
UserInfo user = Gongyong.userlist.Find(u => u.openid == item.Openid);
if (getMsg.Type == 1)
{
var renturnmsg = ReturnBTMsg.CreateBuilder().SetFw(fw).Build();
byte[] r = renturnmsg.ToByteArray();
var data = new ArraySegment <byte>(CreateHead.CreateMessage(GameInformationBase.BASEAGREEMENTNUMBER + 5002, r.Length, requestInfo.MessageNum, r));
item.SendData.Add(data);
user.session.TrySend(data);
}
else
{
var renturnmsg = ReturnTT.CreateBuilder().SetFw(fw).Build();
byte[] r = renturnmsg.ToByteArray();
var data = new ArraySegment <byte>(CreateHead.CreateMessage(GameInformationBase.BASEAGREEMENTNUMBER + 5013, r.Length, requestInfo.MessageNum, r));
item.SendData.Add(data);
user.session.TrySend(data);
}
}
//牌局回放 摸牌
room.gameOperationProcess.AddGameOperationInfo(
GameOperationInfo.CreateBuilder()
.SetSerialNumber(room.gameOperationProcess.GameOperationInfoCount)
.SetOperationFW(mjuser.ZS_Fw)
.SetOperationType(6)
.SetTingHuType(getMsg.Type + 1)
);
}
/// <summary>Unwraps inbound SSL records.</summary>
void Unwrap(IChannelHandlerContext ctx, IByteBuffer packet, int offset, int length, List <int> packetLengths, List <object> output)
{
Contract.Requires(packetLengths.Count > 0);
//bool notifyClosure = false; // todo: netty/issues/137
bool pending = false;
IByteBuffer outputBuffer = null;
try
{
ArraySegment <byte> inputIoBuffer = packet.GetIoBuffer(offset, length);
this.mediationStream.SetSource(inputIoBuffer.Array, inputIoBuffer.Offset);
int packetIndex = 0;
while (!this.EnsureAuthenticated())
{
this.mediationStream.ExpandSource(packetLengths[packetIndex]);
if (++packetIndex == packetLengths.Count)
{
return;
}
}
Task <int> currentReadFuture = this.pendingSslStreamReadFuture;
int outputBufferLength;
if (currentReadFuture != null)
{
// restoring context from previous read
Contract.Assert(this.pendingSslStreamReadBuffer != null);
outputBuffer = this.pendingSslStreamReadBuffer;
outputBufferLength = outputBuffer.WritableBytes;
}
else
{
outputBufferLength = 0;
}
// go through packets one by one (because SslStream does not consume more than 1 packet at a time)
for (; packetIndex < packetLengths.Count; packetIndex++)
{
int currentPacketLength = packetLengths[packetIndex];
this.mediationStream.ExpandSource(currentPacketLength);
if (currentReadFuture != null)
{
// there was a read pending already, so we make sure we completed that first
if (!currentReadFuture.IsCompleted)
{
// we did feed the whole current packet to SslStream yet it did not produce any result -> move to the next packet in input
Contract.Assert(this.mediationStream.SourceReadableBytes == 0);
continue;
}
int read = currentReadFuture.Result;
// Now output the result of previous read and decide whether to do an extra read on the same source or move forward
AddBufferToOutput(outputBuffer, read, output);
currentReadFuture = null;
if (this.mediationStream.SourceReadableBytes == 0)
{
// we just made a frame available for reading but there was already pending read so SslStream read it out to make further progress there
if (read < outputBufferLength)
{
// SslStream returned non-full buffer and there's no more input to go through ->
// typically it means SslStream is done reading current frame so we skip
continue;
}
// we've read out `read` bytes out of current packet to fulfil previously outstanding read
outputBufferLength = currentPacketLength - read;
if (outputBufferLength <= 0)
{
// after feeding to SslStream current frame it read out more bytes than current packet size
outputBufferLength = FallbackReadBufferSize;
}
}
else
{
// SslStream did not get to reading current frame so it completed previous read sync
// and the next read will likely read out the new frame
outputBufferLength = currentPacketLength;
}
}
else
{
// there was no pending read before so we estimate buffer of `currentPacketLength` bytes to be sufficient
outputBufferLength = currentPacketLength;
}
outputBuffer = ctx.Allocator.Buffer(outputBufferLength);
currentReadFuture = this.ReadFromSslStreamAsync(outputBuffer, outputBufferLength);
}
// read out the rest of SslStream's output (if any) at risk of going async
// using FallbackReadBufferSize - buffer size we're ok to have pinned with the SslStream until it's done reading
while (true)
{
if (currentReadFuture != null)
{
if (!currentReadFuture.IsCompleted)
{
break;
}
int read = currentReadFuture.Result;
AddBufferToOutput(outputBuffer, read, output);
}
outputBuffer = ctx.Allocator.Buffer(FallbackReadBufferSize);
currentReadFuture = this.ReadFromSslStreamAsync(outputBuffer, FallbackReadBufferSize);
}
pending = true;
this.pendingSslStreamReadBuffer = outputBuffer;
this.pendingSslStreamReadFuture = currentReadFuture;
}
catch (Exception ex)
{
this.HandleFailure(ex);
throw;
}
finally
{
this.mediationStream.ResetSource();
if (!pending && outputBuffer != null)
{
if (outputBuffer.IsReadable())
{
output.Add(outputBuffer);
}
else
{
outputBuffer.SafeRelease();
}
}
}
}
private StringNode(ArraySegment<byte> bufferedToken)
: base(bufferedToken, true)
{
}
public override IFuzzyQuery Deserialize(ref JsonReader reader, IJsonFormatterResolver formatterResolver)
{
if (reader.GetCurrentJsonToken() == JsonToken.Null)
{
reader.ReadNext();
return(null);
}
var count = 0;
IFuzzyQuery query = null;
string name = null;
double? boost = null;
MultiTermQueryRewrite multiTermQueryRewrite = null;
int? prefixLength = null;
int? maxExpansions = null;
bool? transpositions = null;
while (reader.ReadIsInObject(ref count))
{
var field = reader.ReadPropertyName();
// ReSharper disable once TooWideLocalVariableScope
ArraySegment <byte> fuzzinessSegment = default;
var valueCount = 0;
while (reader.ReadIsInObject(ref valueCount))
{
var property = reader.ReadPropertyNameSegmentRaw();
if (Fields.TryGetValue(property, out var value))
{
switch (value)
{
case 0:
{
var token = reader.GetCurrentJsonToken();
switch (token)
{
case JsonToken.String:
var valueSegment = reader.ReadStringSegmentUnsafe();
if (valueSegment.IsDateTime(formatterResolver, out var dateTime))
{
query = new FuzzyDateQuery
{
Field = field,
Value = dateTime
}
}
;
else
{
query = new FuzzyQuery
{
Field = field,
Value = valueSegment.Utf8String()
}
};
break;
case JsonToken.Number:
query = new FuzzyNumericQuery
{
Field = field,
Value = reader.ReadDouble()
};
break;
}
if (fuzzinessSegment != default)
{
var fuzzinessReader = new JsonReader(fuzzinessSegment.Array, fuzzinessSegment.Offset);
SetFuzziness(ref fuzzinessReader, query, formatterResolver);
}
break;
}
case 1:
{
if (query != null)
{
SetFuzziness(ref reader, query, formatterResolver);
}
else
{
fuzzinessSegment = reader.ReadNextBlockSegment();
}
break;
}
case 2:
prefixLength = reader.ReadInt32();
break;
case 3:
maxExpansions = reader.ReadInt32();
break;
case 4:
transpositions = reader.ReadBoolean();
break;
case 5:
var rewriteFormatter = formatterResolver.GetFormatter <MultiTermQueryRewrite>();
multiTermQueryRewrite = rewriteFormatter.Deserialize(ref reader, formatterResolver);
break;
case 6:
name = reader.ReadString();
break;
case 7:
boost = reader.ReadDouble();
break;
}
}
}
}
query.PrefixLength = prefixLength;
query.MaxExpansions = maxExpansions;
query.Transpositions = transpositions;
query.Rewrite = multiTermQueryRewrite;
query.Name = name;
query.Boost = boost;
return(query);
}
public virtual void SendResponse(ArraySegment <byte> segment)
{
InternalSend(segment);
}
protected StringNodeBase(ArraySegment<byte> bufferedToken, bool isStringNode)
: base(isStringNode ? JsonNodeType.String : JsonNodeType.FieldName)
{
this.value = new Lazy<string>(() => JsonTextUtil.GetStringValue(bufferedToken));
}
public BufferedProducer(ArraySegment<byte> data)
{
this.data = data;
}
private NumberNode(ArraySegment<byte> bufferedToken)
: base(JsonNodeType.Number)
{
this.value = new Lazy<double>(() => JsonTextUtil.GetNumberValue(bufferedToken));
}