/// <summary>
/// Encodes a byte array to a Socket.IO binary encoded message
/// </summary>
private byte[] EncodeData(byte[] data, PayloadTypes type, byte[] afterHeaderData)
{
// Packet binary encoding:
// [ 0|1 ][ length of data ][ FF ][data]
// <1 = binary, 0 = string><number from 0-9><number from 0-9>[...]<number 255><data>
// Get the length of the payload. Socket.IO uses a wasteful encoding to send the length of the data.
// If the data is 16 bytes we have to send the length as two bytes: byte value of the character '1' and byte value of the character '6'.
// Instead of just one byte: 0xF. If the payload is 123 bytes, we can't send as 0x7B...
int afterHeaderLength = (afterHeaderData != null ? afterHeaderData.Length : 0);
string lenStr = (data.Length + afterHeaderLength).ToString();
byte[] len = new byte[lenStr.Length];
for (int cv = 0; cv < lenStr.Length; ++cv)
{
len[cv] = (byte)char.GetNumericValue(lenStr[cv]);
}
// We need another buffer to store the final data
byte[] buffer = new byte[data.Length + len.Length + 2 + afterHeaderLength];
// The payload is textual -> 0
buffer[0] = (byte)type;
// Copy the length of the data
for (int cv = 0; cv < len.Length; ++cv)
{
buffer[1 + cv] = len[cv];
}
int idx = 1 + len.Length;
// End of the header data
buffer[idx++] = 0xFF;
if (afterHeaderData != null && afterHeaderData.Length > 0)
{
Array.Copy(afterHeaderData, 0, buffer, idx, afterHeaderData.Length);
idx += afterHeaderData.Length;
}
// Copy our payload data to the buffer
Array.Copy(data, 0, buffer, idx, data.Length);
return(buffer);
}
public void GivenValidInputs_WhenContructAcceptHeaderDescriptor_ShouldSucceed()
{
PayloadTypes payloadType = PayloadTypes.MultipartRelated;
string mediaType = KnownContentTypes.ApplicationDicom;
bool isTransferSyntaxMandatory = false;
string transferSyntaxWhenMissing = DicomTransferSyntaxUids.ExplicitVRLittleEndian;
ISet <string> acceptableTransferSyntaxes = new HashSet <string>()
{
transferSyntaxWhenMissing
};
AcceptHeaderDescriptor descriptor = new AcceptHeaderDescriptor(payloadType, mediaType, isTransferSyntaxMandatory, transferSyntaxWhenMissing, acceptableTransferSyntaxes);
Assert.Equal(payloadType, descriptor.PayloadType);
Assert.Equal(mediaType, descriptor.MediaType);
Assert.Equal(isTransferSyntaxMandatory, descriptor.IsTransferSyntaxMandatory);
Assert.Equal(transferSyntaxWhenMissing, descriptor.TransferSyntaxWhenMissing);
Assert.Equal(acceptableTransferSyntaxes, descriptor.AcceptableTransferSyntaxes);
}
public AcceptHeaderDescriptor(PayloadTypes payloadType, string mediaType, bool isTransferSyntaxMandatory, string transferSyntaxWhenMissing, ISet <string> acceptableTransferSyntaxes)
{
EnsureArg.IsNotEmptyOrWhiteSpace(mediaType, nameof(mediaType));
// When transfersyntax is not mandatory, transferSyntaxWhenMissing has to be presented
if (!isTransferSyntaxMandatory)
{
EnsureArg.IsNotEmptyOrWhiteSpace(transferSyntaxWhenMissing, nameof(transferSyntaxWhenMissing));
}
EnsureArg.IsNotNull(acceptableTransferSyntaxes, nameof(acceptableTransferSyntaxes));
PayloadType = payloadType;
MediaType = mediaType;
IsTransferSyntaxMandatory = isTransferSyntaxMandatory;
TransferSyntaxWhenMissing = transferSyntaxWhenMissing;
AcceptableTransferSyntaxes = acceptableTransferSyntaxes;
}
/// <summary>
/// Parameterized constructor
/// </summary>
public payload_type(PayloadTypes type) : base(TlvTag)
{
this.Value = type;
}
private (AcceptHeader, AcceptHeaderDescriptor) CreateAcceptHeaderAndDescriptorForPayloadType(PayloadTypes descriptorPayloadType, PayloadTypes acceptHeaderPayloadType)
{
AcceptHeader acceptHeader = AcceptHeaderHelpers.CreateAcceptHeader(payloadType: acceptHeaderPayloadType);
AcceptHeaderDescriptor descriptor = new AcceptHeaderDescriptor(
payloadType: descriptorPayloadType,
mediaType: acceptHeader.MediaType.Value,
isTransferSyntaxMandatory: true,
transferSyntaxWhenMissing: string.Empty,
acceptableTransferSyntaxes: new HashSet <string>()
{
acceptHeader.TransferSyntax.Value
});
return(acceptHeader, descriptor);
}
/// <summary>
/// Will parse the response, and send out the parsed packets.
/// </summary>
private void ParseResponse(HTTPResponse resp)
{
try
{
if (resp != null && resp.Data != null && resp.Data.Length >= 1)
{
int idx = 0;
while (idx < resp.Data.Length)
{
PayloadTypes type = PayloadTypes.Text;
int length = 0;
if (resp.Data[idx] < '0')
{
type = (PayloadTypes)resp.Data[idx++];
byte num = resp.Data[idx++];
while (num != 0xFF)
{
length = (length * 10) + num;
num = resp.Data[idx++];
}
}
else
{
byte next = resp.Data[idx++];
while (next != ':')
{
length = (length * 10) + (next - '0');
next = resp.Data[idx++];
}
// Because length can be different from the byte length, we have to do a little post-processing to support unicode characters.
int brackets = 0;
int tmpIdx = idx;
while (tmpIdx < idx + length)
{
if (resp.Data[tmpIdx] == '[')
{
brackets++;
}
else if (resp.Data[tmpIdx] == ']')
{
brackets--;
}
tmpIdx++;
}
if (brackets > 0)
{
while (brackets > 0)
{
if (resp.Data[tmpIdx] == '[')
{
brackets++;
}
else if (resp.Data[tmpIdx] == ']')
{
brackets--;
}
tmpIdx++;
}
length = tmpIdx - idx;
}
}
Packet packet = null;
switch (type)
{
case PayloadTypes.Text:
packet = new Packet(Encoding.UTF8.GetString(resp.Data, idx, length));
break;
case PayloadTypes.Binary:
if (PacketWithAttachment != null)
{
// First byte is the packet type. We can skip it, so we advance our idx and we also have
// to decrease length
idx++;
length--;
byte[] buffer = new byte[length];
Array.Copy(resp.Data, idx, buffer, 0, length);
PacketWithAttachment.AddAttachmentFromServer(buffer, true);
if (PacketWithAttachment.HasAllAttachment)
{
packet = PacketWithAttachment;
PacketWithAttachment = null;
}
}
break;
} // switch
if (packet != null)
{
try
{
OnPacket(packet);
}
catch (Exception ex)
{
HTTPManager.Logger.Exception("PollingTransport", "ParseResponse - OnPacket", ex);
(Manager as IManager).EmitError(SocketIOErrors.Internal, ex.Message + " " + ex.StackTrace);
}
}
idx += length;
}// while
}
}
catch (Exception ex)
{
(Manager as IManager).EmitError(SocketIOErrors.Internal, ex.Message + " " + ex.StackTrace);
HTTPManager.Logger.Exception("PollingTransport", "ParseResponse", ex);
}
}
static ZoneServerMetadataMarker()
{
PayloadTypes = typeof(ClientSessionClaimRequestPayload)
.Assembly
.GetExportedTypes()
.Where(t => typeof(GameClientPacketPayload).IsAssignableFrom(t) || typeof(GameServerPacketPayload).IsAssignableFrom(t))
.Distinct()
.ToArray();
_ServerPayloadTypesByOpcode = new Lazy <IReadOnlyDictionary <GamePayloadOperationCode, Type> >(() => PayloadTypes
.Where(t => typeof(GameServerPacketPayload).IsAssignableFrom(t))
.ToDictionary(type => type.GetCustomAttribute <GamePayloadAttribute>().OperationCode), true);
_ClientPayloadTypesByOpcode = new Lazy <IReadOnlyDictionary <GamePayloadOperationCode, Type> >(() => PayloadTypes
.Where(t => typeof(GameClientPacketPayload).IsAssignableFrom(t))
.ToDictionary(type => type.GetCustomAttribute <GamePayloadAttribute>().OperationCode), true);
AllProtobufModels = typeof(ClientSessionClaimRequestPayload)
.Assembly
.GetTypes()
.Where(t => t.GetCustomAttribute <ProtoContractAttribute>() != null)
.Concat(new Type[] { typeof(GameClientPacketPayload), typeof(GameServerPacketPayload) })
.Distinct()
.ToArray();
}
/// <summary>
/// Will parse the response, and send out the parsed packets.
/// </summary>
private void ParseResponse(HTTPResponse resp)
{
try
{
if (resp != null && resp.Data != null && resp.Data.Length >= 1)
{
// 1.x
//00000000 00 09 07 ff 30 7b 22 73 69 64 22 3a 22 6f 69 48 0{"sid":"oiH
//00000010 34 31 33 73 61 49 4e 52 53 67 37 41 4b 41 41 41 413saINRSg7AKAAA
//00000020 41 22 2c 22 75 70 67 72 61 64 65 73 22 3a 5b 22 A","upgrades":["
//00000030 77 65 62 73 6f 63 6b 65 74 22 5d 2c 22 70 69 6e websocket"],"pin
//00000040 67 49 6e 74 65 72 76 61 6c 22 3a 32 35 30 30 30 gInterval":25000
//00000050 2c 22 70 69 6e 67 54 69 6d 65 6f 75 74 22 3a 36 ,"pingTimeout":6
//00000060 30 30 30 30 7d 0000}
// 2.x
//00000000 39 37 3a 30 7b 22 73 69 64 22 3a 22 73 36 62 5a 97:0{"sid":"s6bZ
//00000010 6c 43 37 66 51 59 6b 4f 46 4f 62 35 41 41 41 41 lC7fQYkOFOb5AAAA
//00000020 22 2c 22 75 70 67 72 61 64 65 73 22 3a 5b 22 77 ","upgrades":["w
//00000030 65 62 73 6f 63 6b 65 74 22 5d 2c 22 70 69 6e 67 ebsocket"],"ping
//00000040 49 6e 74 65 72 76 61 6c 22 3a 32 35 30 30 30 2c Interval":25000,
//00000050 22 70 69 6e 67 54 69 6d 65 6f 75 74 22 3a 36 30 "pingTimeout":60
//00000060 30 30 30 7d 32 3a 34 30 000}2:40
int idx = 0;
while (idx < resp.Data.Length)
{
PayloadTypes type = PayloadTypes.Text;
int length = 0;
if (resp.Data[idx] < '0')
{
type = (PayloadTypes)resp.Data[idx++];
byte num = resp.Data[idx++];
while (num != 0xFF)
{
length = (length * 10) + num;
num = resp.Data[idx++];
}
}
else
{
byte next = resp.Data[idx++];
while (next != ':')
{
length = (length * 10) + (next - '0');
next = resp.Data[idx++];
}
}
Packet packet = null;
switch (type)
{
case PayloadTypes.Text:
packet = new Packet(Encoding.UTF8.GetString(resp.Data, idx, length));
break;
case PayloadTypes.Binary:
if (PacketWithAttachment != null)
{
// First byte is the packet type. We can skip it, so we advance our idx and we also have
// to decrease length
idx++;
length--;
byte[] buffer = new byte[length];
Array.Copy(resp.Data, idx, buffer, 0, length);
PacketWithAttachment.AddAttachmentFromServer(buffer, true);
if (PacketWithAttachment.HasAllAttachment)
{
packet = PacketWithAttachment;
PacketWithAttachment = null;
}
}
break;
} // switch
if (packet != null)
{
try
{
OnPacket(packet);
}
catch (Exception ex)
{
HTTPManager.Logger.Exception("PollingTransport", "ParseResponse - OnPacket", ex);
(Manager as IManager).EmitError(SocketIOErrors.Internal, ex.Message + " " + ex.StackTrace);
}
}
idx += length;
}// while
}
}
catch (Exception ex)
{
(Manager as IManager).EmitError(SocketIOErrors.Internal, ex.Message + " " + ex.StackTrace);
HTTPManager.Logger.Exception("PollingTransport", "ParseResponse", ex);
}
}
public async Task GivenStoredInstances_WhenRetrieveRequestForInstance_ThenInstanceIsRetrievedSuccessfully(PayloadTypes payloadTypes)
{
// Add multiple instances to validate that we return the requested instance and ignore the other(s).
List <VersionedInstanceIdentifier> versionedInstanceIdentifiers = SetupInstanceIdentifiersList(ResourceType.Instance);
// For the first instance identifier, set up the fileStore to return a stream containing a file associated with the identifier.
KeyValuePair <DicomFile, Stream> streamAndStoredFile = StreamAndStoredFileFromDataset(GenerateDatasetsFromIdentifiers(versionedInstanceIdentifiers.First())).Result;
_fileStore.GetFileAsync(streamAndStoredFile.Key.Dataset.ToVersionedInstanceIdentifier(0), DefaultCancellationToken).Returns(streamAndStoredFile.Value);
RetrieveResourceResponse response = await _retrieveResourceService.GetInstanceResourceAsync(
new RetrieveResourceRequest(
_studyInstanceUid,
_firstSeriesInstanceUid,
_sopInstanceUid,
new[] { AcceptHeaderHelpers.CreateAcceptHeaderForGetInstance(payloadTypes: payloadTypes) }),
DefaultCancellationToken);
// Validate response status code and ensure response stream has expected file - it should be equivalent to what the store was set up to return.
ValidateResponseStreams(new List <DicomFile>()
{
streamAndStoredFile.Key
}, response.ResponseStreams);
// Validate content type
Assert.Equal(KnownContentTypes.ApplicationDicom, response.ContentType);
// Dispose created streams.
streamAndStoredFile.Value.Dispose();
}
IFluentLogObject IFluentLogObject.WithExtraPayload(IPayload payload)
{
if (payload == null)
throw new ArgumentNullException("payload");
PayloadTypes pldt;
try
{
pldt = payload.GetType().GetPayloadType();
}
catch (ArgumentException x)
{
throw new ArgumentException("Given payload is of unkown type.", x);
}
if ((this.PayloadTypes & pldt) == 0)
this.PayloadTypes |= pldt;
else
throw new InvalidOperationException("The object already contains a payload of the same type." + Environment.NewLine + "Duplicated type: " + pldt);
this.payloads.Add(payload);
return this;
}
private async Task ReceivePacketsAsync()
{
bool isClosed = false;
int length;
DisconnectedEventArgs disconnectArgs = null;
while (_receiver != null && _receiver.IsConnected && !isClosed)
{
// receive a single packet
try
{
// read the header
int headerOffset = 0;
while (headerOffset < TransportConstants.MaxHeaderLength)
{
length = await _receiver.ReceiveAsync(_receiveHeaderBuffer, headerOffset, TransportConstants.MaxHeaderLength - headerOffset).ConfigureAwait(false);
if (length == 0)
{
throw new TransportDisconnectedException("Stream closed while reading header bytes");
}
headerOffset += length;
}
// deserialize the bytes into a header
var header = HeaderSerializer.Deserialize(_receiveHeaderBuffer, 0, TransportConstants.MaxHeaderLength);
// read the payload
var contentStream = _getStream(header);
var buffer = PayloadTypes.IsStream(header) ?
new byte[header.PayloadLength] :
_receiveContentBuffer;
int offset = 0;
if (header.PayloadLength > 0)
{
do
{
// read in chunks
int count = Math.Min(header.PayloadLength - offset, TransportConstants.MaxPayloadLength);
// read the content
length = await _receiver.ReceiveAsync(buffer, offset, count).ConfigureAwait(false);
if (length == 0)
{
throw new TransportDisconnectedException("Stream closed while reading payload bytes");
}
if (contentStream != null)
{
// write chunks to the contentStream if it's not a stream type
if (!PayloadTypes.IsStream(header))
{
await contentStream.WriteAsync(buffer, offset, length).ConfigureAwait(false);
}
}
offset += length;
}while (offset < header.PayloadLength);
// give the full payload buffer to the contentStream if it's a stream
if (contentStream != null && PayloadTypes.IsStream(header))
{
((PayloadStream)contentStream).GiveBuffer(buffer, length);
}
}
_receiveAction(header, contentStream, offset);
}
catch (TransportDisconnectedException de)
{
isClosed = true;
disconnectArgs = new DisconnectedEventArgs()
{
Reason = de.Reason,
};
}
catch (Exception e)
{
isClosed = true;
disconnectArgs = new DisconnectedEventArgs()
{
Reason = e.Message,
};
}
}
Disconnect(disconnectArgs);
}
public void GivenPayloadType_WhenCheckIsAcceptable_ShouldSucceed(PayloadTypes descriptorPayloadType, PayloadTypes acceptHeaderPayloadType, bool isAcceptable)
{
(AcceptHeader, AcceptHeaderDescriptor)testData = CreateAcceptHeaderAndDescriptorForPayloadType(descriptorPayloadType, acceptHeaderPayloadType);
string transferSyntax;
AcceptHeader acceptHeader = testData.Item1;
AcceptHeaderDescriptor descriptor = testData.Item2;
Assert.Equal(isAcceptable, descriptor.IsAcceptable(acceptHeader, out transferSyntax));
}
/// <summary>
/// Will parse the response, and send out the parsed packets.
/// </summary>
private void ParseResponse(HTTPResponse resp)
{
try
{
if (resp != null && resp.Data != null && resp.Data.Length >= 1)
{
int idx = 0;
while (idx < resp.Data.Length)
{
PayloadTypes type = (PayloadTypes)resp.Data[idx++];
int length = 0;
byte num = resp.Data[idx++];
while (num != 0xFF)
{
length = (length * 10) + num;
num = resp.Data[idx++];
}
Packet packet = null;
switch (type)
{
case PayloadTypes.Text:
packet = new Packet(Encoding.UTF8.GetString(resp.Data, idx, length));
break;
case PayloadTypes.Binary:
if (PacketWithAttachment != null)
{
// First byte is the packet type. We can skip it, so we advance our idx and we also have
// to decrease length
idx++;
length--;
byte[] buffer = new byte[length];
Array.Copy(resp.Data, idx, buffer, 0, length);
PacketWithAttachment.AddAttachmentFromServer(buffer, true);
if (PacketWithAttachment.HasAllAttachment)
{
packet = PacketWithAttachment;
PacketWithAttachment = null;
}
}
break;
} // switch
if (packet != null)
{
try
{
OnPacket(packet);
}
catch (Exception ex)
{
HTTPManager.Logger.Exception("PollingTransport", "ParseResponse - OnPacket", ex);
(Manager as IManager).EmitError(SocketIOErrors.Internal, ex.Message + " " + ex.StackTrace);
}
}
idx += length;
}// while
}
}
catch (Exception ex)
{
(Manager as IManager).EmitError(SocketIOErrors.Internal, ex.Message + " " + ex.StackTrace);
HTTPManager.Logger.Exception("PollingTransport", "ParseResponse", ex);
}
}
/// <summary>
/// Will parse the response, and send out the parsed packets.
/// </summary>
private void ParseResponse(HTTPResponse resp)
{
try
{
if (resp != null && resp.Data != null && resp.Data.Length >= 1)
{
// 1.x
//00000000 00 09 07 ff 30 7b 22 73 69 64 22 3a 22 6f 69 48 0{"sid":"oiH
//00000010 34 31 33 73 61 49 4e 52 53 67 37 41 4b 41 41 41 413saINRSg7AKAAA
//00000020 41 22 2c 22 75 70 67 72 61 64 65 73 22 3a 5b 22 A","upgrades":["
//00000030 77 65 62 73 6f 63 6b 65 74 22 5d 2c 22 70 69 6e websocket"],"pin
//00000040 67 49 6e 74 65 72 76 61 6c 22 3a 32 35 30 30 30 gInterval":25000
//00000050 2c 22 70 69 6e 67 54 69 6d 65 6f 75 74 22 3a 36 ,"pingTimeout":6
//00000060 30 30 30 30 7d 0000}
// 2.x
//00000000 39 37 3a 30 7b 22 73 69 64 22 3a 22 73 36 62 5a 97:0{"sid":"s6bZ
//00000010 6c 43 37 66 51 59 6b 4f 46 4f 62 35 41 41 41 41 lC7fQYkOFOb5AAAA
//00000020 22 2c 22 75 70 67 72 61 64 65 73 22 3a 5b 22 77 ","upgrades":["w
//00000030 65 62 73 6f 63 6b 65 74 22 5d 2c 22 70 69 6e 67 ebsocket"],"ping
//00000040 49 6e 74 65 72 76 61 6c 22 3a 32 35 30 30 30 2c Interval":25000,
//00000050 22 70 69 6e 67 54 69 6d 65 6f 75 74 22 3a 36 30 "pingTimeout":60
//00000060 30 30 30 7d 32 3a 34 30 000}2:40
//00000000 38 30 3a 34 32 5b 22 50 6f 6c 6c 69 6e 67 20 69 80:42["Polling i
//00000010 73 20 77 6f 72 6b 69 6e 67 20 6e 6f 72 6d 61 6c s working normal
//00000020 6c 79 20 62 75 74 20 63 72 61 73 68 65 73 20 6f ly but crashes o
//00000030 6e 20 72 65 63 65 69 76 69 6e 67 20 6d 75 74 61 n receiving muta
//00000040 74 65 64 20 76 6f 77 65 6c 73 20 c3 bc 20 c3 b6 ted vowels
//00000050 20 c3 a4 2e 22 5d ."]
int idx = 0;
while (idx < resp.Data.Length)
{
PayloadTypes type = PayloadTypes.Text;
int length = 0;
if (resp.Data[idx] < '0')
{
type = (PayloadTypes)resp.Data[idx++];
byte num = resp.Data[idx++];
while (num != 0xFF)
{
length = (length * 10) + num;
num = resp.Data[idx++];
}
}
else
{
byte next = resp.Data[idx++];
while (next != ':')
{
length = (length * 10) + (next - '0');
next = resp.Data[idx++];
}
}
Packet packet = null;
switch (type)
{
case PayloadTypes.Text:
// While we already received a length for the packet, it contains the character count of the packet not the byte count.
// So, when the packet contains UTF8 characters, length will contain less than the actual byte count.
// To fix this, we have to find the last square or curly bracket and if the sent and calculated lengths are different
// we will use the larger one.
int customLength = 1;
byte next = resp.Data[idx];
while (next != SquareBrackets[0] && next != CurlyBrackets[0] && idx + customLength < resp.Data.Length)
{
next = resp.Data[idx + customLength++];
}
if (idx + customLength < resp.Data.Length)
{
byte[] brackets = SquareBrackets;
if (next == CurlyBrackets[0])
{
brackets = CurlyBrackets;
}
int bracketCount = 1;
while (bracketCount != 0 && idx + customLength < resp.Data.Length)
{
next = resp.Data[idx + customLength++];
if (next == brackets[0])
{
bracketCount++;
}
else if (next == brackets[1])
{
bracketCount--;
}
}
}
packet = new Packet(Encoding.UTF8.GetString(resp.Data, idx, Math.Max(length, customLength)));
break;
case PayloadTypes.Binary:
if (PacketWithAttachment != null)
{
// First byte is the packet type. We can skip it, so we advance our idx and we also have
// to decrease length
idx++;
length--;
byte[] buffer = new byte[length];
Array.Copy(resp.Data, idx, buffer, 0, length);
PacketWithAttachment.AddAttachmentFromServer(buffer, true);
if (PacketWithAttachment.HasAllAttachment)
{
packet = PacketWithAttachment;
PacketWithAttachment = null;
}
}
break;
} // switch
if (packet != null)
{
try
{
OnPacket(packet);
}
catch (Exception ex)
{
HTTPManager.Logger.Exception("PollingTransport", "ParseResponse - OnPacket", ex);
(Manager as IManager).EmitError(SocketIOErrors.Internal, ex.Message + " " + ex.StackTrace);
}
}
idx += length;
}// while
}
}
catch (Exception ex)
{
(Manager as IManager).EmitError(SocketIOErrors.Internal, ex.Message + " " + ex.StackTrace);
HTTPManager.Logger.Exception("PollingTransport", "ParseResponse", ex);
}
}
/// <summary>
/// Encodes a byte array to a Socket.IO binary encoded message
/// </summary>
private byte[] EncodeData(byte[] data, PayloadTypes type, byte[] afterHeaderData)
{
// Packet binary encoding:
// [ 0|1 ][ length of data ][ FF ][data]
// <1 = binary, 0 = string><number from 0-9><number from 0-9>[...]<number 255><data>
// Get the length of the payload. Socket.IO uses a wasteful encoding to send the length of the data.
// If the data is 16 bytes we have to send the length as two bytes: byte value of the character '1' and byte value of the character '6'.
// Instead of just one byte: 0xF. If the payload is 123 bytes, we can't send as 0x7B...
int afterHeaderLength = (afterHeaderData != null ? afterHeaderData.Length : 0);
string lenStr = (data.Length + afterHeaderLength).ToString();
byte[] len = new byte[lenStr.Length];
for (int cv = 0; cv < lenStr.Length; ++cv)
len[cv] = (byte)char.GetNumericValue(lenStr[cv]);
// We need another buffer to store the final data
byte[] buffer = new byte[data.Length + len.Length + 2 + afterHeaderLength];
// The payload is textual -> 0
buffer[0] = (byte)type;
// Copy the length of the data
for (int cv = 0; cv < len.Length; ++cv)
buffer[1 + cv] = len[cv];
int idx = 1 + len.Length;
// End of the header data
buffer[idx++] = 0xFF;
if (afterHeaderData != null && afterHeaderData.Length > 0)
{
Array.Copy(afterHeaderData, 0, buffer, idx, afterHeaderData.Length);
idx += afterHeaderData.Length;
}
// Copy our payload data to the buffer
Array.Copy(data, 0, buffer, idx, data.Length);
return buffer;
}
/// <summary>
/// Initializes the object with the given property values.
/// </summary>
/// <param name="manager">The manager which owns the object; must be non-null.</param>
/// <param name="timestamp">The creation timestamp.</param>
/// <param name="flags">Flags for logging the object.</param>
/// <param name="priority">Relative priority of the object.</param>
/// <param name="indent">Logical indentation of the object.</param>
/// <param name="sources">An enumeration of sources of the object.</param>
/// <param name="payloads">An enumeration of payloads of the object.</param>
/// <exception cref="System.ArgumentNullException">Thrown when the given manager object is null.</exception>
/// <exception cref="System.ArgumentException">Thrown when an enumerated source is null -or- an enumerated payload is null -or- a given payload is of unknown type -or- two payloads are of the same type.</exception>
protected FluentLogObject(IFluentManager manager, DateTime timestamp, LogFlags flags = Defaults.LogFlags, sbyte priority = Defaults.Priority, byte indent = Defaults.Indent, IEnumerable<string> sources = null, IEnumerable<IPayload> payloads = null)
{
if (manager == null)
throw new ArgumentNullException("manager");
this.Manager = manager;
this.Timestamp = timestamp;
this.Flags = flags;
this.Priority = priority;
this.Indent = indent;
if (sources == null)
{
this.sources = new List<string>();
}
else
{
this.sources = new List<string>(sources);
for (int i = 0; i < this.sources.Count; i++)
if (this.sources[i] == null)
throw new ArgumentException("The enumeration of sources contains a null element.", "sources");
}
this.Sources = new ReadOnlyCollection<string>(this.sources);
if (payloads == null)
{
this.payloads = new List<IPayload>();
}
else
{
var plds = payloads.ToArray();
for (int i = 0; i < plds.Length; i++)
{
PayloadTypes pldt;
try
{
pldt = plds[i].GetType().GetPayloadType();
}
catch (ArgumentException x)
{
throw new ArgumentException("Payloads enumeration contains a payload of unkown type.", x);
}
catch (NullReferenceException x)
{
throw new ArgumentException("Payloads enumeration contains a null payload.", x);
}
if ((this.PayloadTypes & pldt) == 0)
this.PayloadTypes |= pldt;
else
throw new ArgumentException("Payloads enumerations may not contain two payloads of the same type." + Environment.NewLine + "Duplicated type: " + pldt);
}
this.payloads = new List<IPayload>(plds);
}
this.Payloads = new ReadOnlyCollection<IPayload>(this.payloads);
}
IFluentLogObject IFluentLogObject.WithPayloads(IEnumerable<IPayload> payloads)
{
if (payloads == null)
throw new ArgumentNullException("payloads");
this.payloads.Clear();
this.PayloadTypes = 0;
this.payloads.AddRange(payloads);
for (int i = 0; i < this.payloads.Count; i++)
{
PayloadTypes pldt;
try
{
pldt = this.payloads[i].GetType().GetPayloadType();
}
catch (ArgumentException x)
{
throw new ArgumentException("Payloads enumeration contains a payload of unkown type.", x);
}
catch (NullReferenceException x)
{
throw new ArgumentException("Payloads enumeration contains a null payload.", x);
}
if ((this.PayloadTypes & pldt) == 0)
this.PayloadTypes |= pldt;
else
throw new ArgumentException("Payloads enumerations may not contain two payloads of the same type." + Environment.NewLine + "Duplicated type: " + pldt);
}
return this;
}
IFluentLogObject IFluentLogObject.WithExtraPayloads(IEnumerable<IPayload> payloads)
{
if (payloads == null)
throw new ArgumentNullException("payloads");
var start = this.payloads.Count;
this.payloads.AddRange(payloads);
for (int i = start; i < this.payloads.Count; i++)
{
PayloadTypes pldt;
try
{
pldt = this.payloads[i].GetType().GetPayloadType();
}
catch (ArgumentException x)
{
throw new ArgumentException("Extra payloads enumeration contains a payload of unkown type.", x);
}
catch (NullReferenceException x)
{
throw new ArgumentException("Extra payloads enumeration contains a null payload.", x);
}
if ((this.PayloadTypes & pldt) == 0)
this.PayloadTypes |= pldt;
else
throw new InvalidOperationException("An attempt was made to add a payload of a type that was already added to the object." + Environment.NewLine + "Duplicated type: " + pldt);
}
return this;
}
public OutgoingPayloadHandler(byte[] rawData, PayloadTypes pType)
{
Header = new byte[Properties.TS3SRV_WEBLIST_PROTOCOL_HEADERLEN];
Payload = rawData;
PayloadType = pType;
}
public static AcceptHeader CreateAcceptHeaderForGetInstance(string transferSyntax = "*", string mediaType = KnownContentTypes.ApplicationDicom, double?quality = null, PayloadTypes payloadTypes = PayloadTypes.SinglePart)
{
return(CreateAcceptHeader(
transferSyntax: transferSyntax,
payloadType: payloadTypes,
mediaType: mediaType,
quality: quality));
}
public static AcceptHeader CreateAcceptHeader(string transferSyntax = "*", PayloadTypes payloadType = PayloadTypes.MultipartRelated, string mediaType = KnownContentTypes.ApplicationOctetStream, double?quality = null)
{
return(new AcceptHeader(mediaType, payloadType, transferSyntax, quality));
}
private void ParseResponse(HTTPResponse resp)
{
try
{
if (((resp != null) && (resp.Data != null)) && (resp.Data.Length >= 1))
{
int num2;
for (int i = 0; i < resp.Data.Length; i += num2)
{
PayloadTypes text = PayloadTypes.Text;
num2 = 0;
if (resp.Data[i] < 0x30)
{
text = (PayloadTypes)resp.Data[i++];
for (byte j = resp.Data[i++]; j != 0xff; j = resp.Data[i++])
{
num2 = (num2 * 10) + j;
}
}
else
{
for (byte j = resp.Data[i++]; j != 0x3a; j = resp.Data[i++])
{
num2 = (num2 * 10) + (j - 0x30);
}
}
Packet packetWithAttachment = null;
switch (text)
{
case PayloadTypes.Text:
packetWithAttachment = new Packet(Encoding.UTF8.GetString(resp.Data, i, num2));
break;
case PayloadTypes.Binary:
if (this.PacketWithAttachment != null)
{
i++;
num2--;
byte[] destinationArray = new byte[num2];
Array.Copy(resp.Data, i, destinationArray, 0, num2);
this.PacketWithAttachment.AddAttachmentFromServer(destinationArray, true);
if (this.PacketWithAttachment.HasAllAttachment)
{
packetWithAttachment = this.PacketWithAttachment;
this.PacketWithAttachment = null;
}
}
break;
}
if (packetWithAttachment != null)
{
try
{
this.OnPacket(packetWithAttachment);
}
catch (Exception exception)
{
HTTPManager.Logger.Exception("PollingTransport", "ParseResponse - OnPacket", exception);
((IManager)this.Manager).EmitError(SocketIOErrors.Internal, exception.Message + " " + exception.StackTrace);
}
}
}
}
}
catch (Exception exception2)
{
((IManager)this.Manager).EmitError(SocketIOErrors.Internal, exception2.Message + " " + exception2.StackTrace);
HTTPManager.Logger.Exception("PollingTransport", "ParseResponse", exception2);
}
}
