private Task <Request> HandleRequest(TcSocketConnection client)
{
var inputStream = new CodedInputStream(client.Connection.GetStream());
var outputStream = new CodedOutputStream(client.Connection.GetStream());
while (client.Connection.Connected)
{
Int32 varintLength = inputStream.ReadLength();
Console.WriteLine("message length: {0}", varintLength);
if (varintLength > 4)
{
throw new System.ArgumentOutOfRangeException("varint");
}
try
{
var request = Request.Parser.ParseFrom(inputStream.ReadBytes());
Console.WriteLine("message: {0} type {1}", request.CalculateSize(), request.ValueCase);
outputStream.WriteBytes(inputStream.ReadBytes());
}
catch (Exception ex)
{
}
}
return(null);
}
public Request HandleRequest()
{
var inputStream = new CodedInputStream(Connection.GetStream());
var outputStream = new CodedOutputStream(Connection.GetStream());
while (Connection.Connected)
{
Int32 varintLength = inputStream.ReadLength();
Console.WriteLine("message length: {0}", varintLength);
// if (varintLength > 4)
// {
// throw new System.ArgumentOutOfRangeException("varint");
// }
//try
//{
var request = Request.Parser.ParseFrom(inputStream.ReadBytes());
//Console.WriteLine("New client message: {0} type {1}", request.CalculateSize(), request.ValueCase);
outputStream.WriteBytes(inputStream.ReadBytes());
UpdateConnectionName(request);
return request;
//return request;
//}
//catch (Exception ex)
//{
// throw ex;
//}
}
return null;
}
private Task <Request> HandleRequest(TcSocketConnection client)
{
var inputStream = new CodedInputStream(client.Connection.GetStream());
var outputStream = new CodedOutputStream(client.Connection.GetStream());
//while(client.Connected)
//{
Int32 varintLength = inputStream.ReadLength();
Console.WriteLine("message length: {0}", varintLength);
if (varintLength > 4)
{
throw new System.ArgumentOutOfRangeException("varint");
}
try
{
var request = Request.Parser.ParseFrom(inputStream.ReadBytes());
Console.WriteLine("message: {0} type {1}", request.CalculateSize(), request.ValueCase);
outputStream.WriteBytes(inputStream.ReadBytes());
}
catch (Exception ex)
{
}
//byte[] msgLengthField = new byte[varintLength];
//stream.ReadAsync(msgLengthField, 1, varintLength);
//Int64 msgLengthLong = BitConverter.ToInt64(msgLengthField, 0);
//if (msgLengthLong > Int32.MaxValue)
//{
// throw new System.ArgumentOutOfRangeException("messageLength");
//}
//Int32 messageLength = (Int32)msgLengthLong;
//CodedInputStream.
//Request request = Request.Parser.ParseFrom()
//}
//if(varintLength)
return(null);
}
public static Frame Deserialize(FrameMessage frameMessage, TypeRegistry typeRegistry, Frame previousFrame)
{
var frame = new Frame(
(int)frameMessage.ListId,
frameMessage.ObjectsDestroyed.ToList());
using (var stream = new MemoryStream())
{
frameMessage.ObjectUpdates.WriteTo(stream);
stream.Position = 0;
using (var codedStream = new CodedInputStream(stream))
{
var updateCount = codedStream.ReadInt32();
for (var i = 0; i < updateCount; ++i)
{
var update = codedStream.ReadBytes();
frame.DeserializeUpdate(update, typeRegistry, previousFrame);
}
return(frame);
}
}
}
/// <summary>
/// Reads an unknown field, either parsing it and storing it or skipping it.
/// </summary>
/// <remarks>
/// If the current set of options is empty and we manage to read a field, a new set of options
/// will be created and returned. Otherwise, the return value is <c>this</c>. This allows
/// us to start with a singleton empty set of options and just create new ones where necessary.
/// </remarks>
/// <param name="input">Input stream to read from. </param>
/// <returns>The resulting set of custom options, either <c>this</c> or a new set.</returns>
internal CustomOptions ReadOrSkipUnknownField(CodedInputStream input)
{
var tag = input.LastTag;
var field = WireFormat.GetTagFieldNumber(tag);
switch (WireFormat.GetTagWireType(tag))
{
case WireFormat.WireType.LengthDelimited:
return(AddValue(field, new FieldValue(input.ReadBytes())));
case WireFormat.WireType.Fixed32:
return(AddValue(field, new FieldValue(input.ReadFixed32())));
case WireFormat.WireType.Fixed64:
return(AddValue(field, new FieldValue(input.ReadFixed64())));
case WireFormat.WireType.Varint:
return(AddValue(field, new FieldValue(input.ReadRawVarint64())));
// For StartGroup, EndGroup or any wire format we don't understand,
// just use the normal behavior (call SkipLastField).
default:
input.SkipLastField();
return(this);
}
}
public ProtoBufPackageInfo Filter(BufferList data, out int rest)
{
rest = 0;
var buffStream = new BufferStream();
buffStream.Initialize(data);
var stream = new CodedInputStream(buffStream);
var varint32 = (int)stream.ReadLength();
if (varint32 <= 0)
{
return(default(ProtoBufPackageInfo));
}
var total = data.Total;
var packageLen = varint32 + (int)stream.Position;
if (total >= packageLen)
{
rest = total - packageLen;
stream = new CodedInputStream(buffStream);
var body = stream.ReadBytes();
var message = MessageWrapper.Parser.ParseFrom(body);
var requestInfo = new ProtoBufPackageInfo(message);
return(requestInfo);
}
return(default(ProtoBufPackageInfo));
}
public IEnumerable <byte> ReadBytes()
{
var networkStream = TcpClientWrapper.GetStream();
var codedInputStream = new CodedInputStream(networkStream);
return(codedInputStream.ReadBytes());
}
/// <summary>
/// Read value from <see cref="System.Protobuf.Object"/>
/// </summary>
/// <param name="obj"><see cref="System.Protobuf.Object"/> to read from</param>
/// <returns>Value in the correct type - null if not capable of converting</returns>
public static object ToCLR(this System.Protobuf.Object obj)
{
var type = (Types)obj.Type;
object value = null;
using (var stream = new CodedInputStream(obj.Content.ToByteArray()))
{
switch (type)
{
case Types.String: value = stream.ReadString(); break;
case Types.Int32: value = stream.ReadInt32(); break;
case Types.Int64: value = stream.ReadInt64(); break;
case Types.UInt32: value = stream.ReadUInt32(); break;
case Types.UInt64: value = stream.ReadUInt64(); break;
case Types.Float: value = stream.ReadFloat(); break;
case Types.Double: value = stream.ReadDouble(); break;
case Types.Boolean: value = stream.ReadBool(); break;
case Types.DateTime: value = stream.ReadInt64().ToDateTime(); break;
case Types.DateTimeOffset: value = stream.ReadInt64().ToDateTimeOffset(); break;
case Types.Guid: value = new Guid(stream.ReadBytes().ToByteArray()); break;
}
}
return(value);
}
public async Task <IEnumerable <string> > GetResources(Transaction transaction)
{
//var hashes = ECParameters.Parser.ParseFrom(transaction.Params).Params.Select(p => p.HashVal);
List <Address> addresses = new List <Address>();
using (MemoryStream mm = new MemoryStream(transaction.Params.ToByteArray()))
using (CodedInputStream input = new CodedInputStream(mm))
{
uint tag;
while ((tag = input.ReadTag()) != 0)
{
switch (WireFormat.GetTagWireType(tag))
{
case WireFormat.WireType.Varint:
input.ReadUInt64();
break;
case WireFormat.WireType.LengthDelimited:
var bytes = input.ReadBytes();
if (bytes.Length == 18 + 2) // todo what leength should this be ?
{
var h = new Address();
h.MergeFrom(bytes);
addresses.Add(h);
}
break;
}
}
}
addresses.Add(transaction.From);
return(await Task.FromResult(addresses.Select(a => a.GetFormatted())));
}
private List <Address> GetRelatedAccount(Transaction transaction)
{
//var hashes = ECParameters.Parser.ParseFrom(transaction.Params).Params.Select(p => p.HashVal);
List <Address> addresses = new List <Address>();
using (MemoryStream mm = new MemoryStream(transaction.Params.ToByteArray()))
using (CodedInputStream input = new CodedInputStream(mm))
{
uint tag;
while ((tag = input.ReadTag()) != 0)
{
switch (WireFormat.GetTagWireType(tag))
{
case WireFormat.WireType.Varint:
input.ReadUInt64();
break;
case WireFormat.WireType.LengthDelimited:
var bytes = input.ReadBytes();
if (bytes.Length == 18 + 2) // todo what leength should this be ?
{
// TODO: Ignore if parsing failed, which means our guess is wrong - the bytes is not an address
var h = new Address();
h.MergeFrom(bytes);
addresses.Add(h);
}
break;
}
}
}
addresses.Add(transaction.From);
return(addresses);
}
public override void DecodeSnapshot(ulong rid, bool isNew, CodedInputStream reader)
{
base.DecodeSnapshot(rid, isNew, reader);
this.team = reader.ReadInt32();
this.name = reader.ReadString();
this.hp = reader.ReadInt32();
this.mhp = reader.ReadInt32();
this.mp = ( Fix64 )reader.ReadDouble();
this.mmp = reader.ReadInt32();
this.mpRecover = reader.ReadInt32();
this.atk = reader.ReadInt32();
this.def = reader.ReadInt32();
this.disableMove = reader.ReadInt32();
this.disableTurn = reader.ReadInt32();
this.disableSkill = reader.ReadInt32();
this.disableCollision = reader.ReadInt32();
this.supperArmor = reader.ReadInt32();
this.invulnerAbility = reader.ReadInt32();
this.moveDirection = new FVec2(( Fix64 )reader.ReadDouble(), ( Fix64 )reader.ReadDouble());
this.intersectVector = new FVec2(( Fix64 )reader.ReadDouble(), ( Fix64 )reader.ReadDouble());
this.phyxSpeed = new FVec2(( Fix64 )reader.ReadDouble(), ( Fix64 )reader.ReadDouble());
this.velocity = ( Fix64 )reader.ReadDouble();
this.isDead = reader.ReadBool();
this.t_hp_add = reader.ReadInt32();
this.t_mp_add = reader.ReadInt32();
this.t_atk_add = reader.ReadInt32();
this.t_def_add = reader.ReadInt32();
this.t_speed_add = reader.ReadInt32();
this.fsm.DecodeSnapshot(reader);
reader.ReadBytes();
}
object ReadValue(CodedInputStream inputStream, object value, Type type, Type targetType, IValueConverter converter)
{
if (type == typeof(Guid))
{
_ = inputStream.ReadLength();
var guidAsBytes = inputStream.ReadBytes();
value = new Guid(guidAsBytes.ToByteArray());
}
else if (type == typeof(string))
{
_ = inputStream.ReadLength();
value = inputStream.ReadString();
}
else if (type == typeof(int))
{
value = inputStream.ReadInt32();
}
else if (type == typeof(long))
{
value = inputStream.ReadInt64();
}
else if (type == typeof(uint))
{
value = inputStream.ReadUInt32();
}
else if (type == typeof(ulong))
{
value = inputStream.ReadUInt64();
}
else if (type == typeof(float))
{
value = inputStream.ReadFloat();
}
else if (type == typeof(double))
{
value = inputStream.ReadDouble();
}
else if (type == typeof(bool))
{
value = inputStream.ReadBool();
}
else if (type == typeof(DateTimeOffset) || type == typeof(DateTime))
{
value = DateTimeOffset.FromUnixTimeMilliseconds(inputStream.ReadInt64());
if (type == typeof(DateTime))
{
value = ((DateTimeOffset)value).UtcDateTime;
}
}
if (converter != null)
{
value = converter.ConvertFrom(targetType, value);
}
return(value);
}
public int ParseBytes_CodedInputStream(int encodedSize)
{
CodedInputStream cis = new CodedInputStream(stringInputBuffers[encodedSize]);
int sum = 0;
for (int i = 0; i < BytesToParse / encodedSize; i++)
{
sum += cis.ReadBytes().Length;
}
return(sum);
}
public void MergeFrom(CodedInputStream input)
{
uint tag;
while ((tag = input.ReadTag()) != 0)
{
switch (tag)
{
default:
_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
break;
case 10:
{
KeyData = input.ReadBytes();
break;
}
case 16:
{
TransmissionRiskLevel = input.ReadInt32();
break;
}
case 24:
{
RollingStartIntervalNumber = input.ReadInt32();
break;
}
case 32:
{
RollingPeriod = input.ReadInt32();
break;
}
case 40:
{
ReportType = (Types.ReportType)input.ReadEnum();
break;
}
case 48:
{
DaysSinceOnsetOfSymptoms = input.ReadSInt32();
break;
}
}
}
}
public void DecodeSnapshot(CodedInputStream reader)
{
reader.ReadBytes();
if (reader.ReadBool())
{
this.currentState = this.GetState(reader.ReadInt32());
}
if (reader.ReadBool())
{
this.previousState = this.GetState(reader.ReadInt32());
}
this.context.DecodeSnapshot(reader);
}
/// <summary>
/// Convert a Protocol Buffer value type, encoded as a byte string, to a C# value.
/// </summary>
public static object ReadValue(ByteString value, Type type)
{
if (value.Length == 0)
{
throw new ArgumentException("Value is empty");
}
var stream = new CodedInputStream(value.ToByteArray());
if (type == typeof(double))
{
return(stream.ReadDouble());
}
else if (type == typeof(float))
{
return(stream.ReadFloat());
}
else if (type == typeof(int))
{
return(stream.ReadInt32());
}
else if (type == typeof(long))
{
return(stream.ReadInt64());
}
else if (type == typeof(uint))
{
return(stream.ReadUInt32());
}
else if (type == typeof(ulong))
{
return(stream.ReadUInt64());
}
else if (type == typeof(bool))
{
return(stream.ReadBool());
}
else if (type == typeof(string))
{
return(stream.ReadString());
}
else if (type == typeof(byte[]))
{
return(stream.ReadBytes().ToByteArray());
}
throw new ArgumentException(type + " is not a Protocol Buffer value type");
}
public void MergeFrom(CodedInputStream input) {
#if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
input.ReadRawMessage(this);
#else
uint tag;
while ((tag = input.ReadTag()) != 0) {
switch(tag) {
default:
_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
break;
case 10: {
KeyData = input.ReadBytes();
break;
}
case 16: {
RollingStartIntervalNumber = input.ReadUInt32();
break;
}
case 24: {
RollingPeriod = input.ReadUInt32();
break;
}
case 32: {
TransmissionRiskLevel = input.ReadInt32();
break;
}
case 42: {
visitedCountries_.AddEntriesFrom(input, _repeated_visitedCountries_codec);
break;
}
case 50: {
Origin = input.ReadString();
break;
}
case 56: {
ReportType = (global::Iks.Protobuf.EfgsReportType) input.ReadEnum();
break;
}
case 64: {
DaysSinceOnsetOfSymptoms = input.ReadSInt32();
break;
}
}
}
#endif
}
public void MergeFrom(CodedInputStream input)
{
uint tag;
while ((tag = input.ReadTag()) != 0)
{
switch (tag)
{
default:
_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
break;
case 10: {
KeyData = input.ReadBytes();
break;
}
case 16: {
TransmissionRiskLevel = input.ReadInt32();
break;
}
case 24: {
RollingStartIntervalNumber = input.ReadInt32();
break;
}
case 32: {
RollingPeriod = input.ReadInt32();
break;
}
case 40: {
ReportType = (global::NL.Rijksoverheid.ExposureNotification.BackEnd.GeneratedGaenFormat.TemporaryExposureKey.Types.ReportType)input.ReadEnum();
break;
}
case 48: {
DaysSinceOnsetOfSymptoms = input.ReadSInt32();
break;
}
}
}
}
public void MergeFrom(CodedInputStream input)
{
uint tag;
while ((tag = input.ReadTag()) != 0)
{
switch (tag)
{
default:
_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
break;
case 10:
{
if (signatureInfo_ == null)
{
SignatureInfo = new SignatureInfo();
}
input.ReadMessage(SignatureInfo);
break;
}
case 16:
{
BatchNum = input.ReadInt32();
break;
}
case 24:
{
BatchSize = input.ReadInt32();
break;
}
case 34:
{
Signature = input.ReadBytes();
break;
}
}
}
}
public static uint ReadProtoInt(byte[] buffer, int tags)
{
uint tag = 0;
string fieldName = "";
CodedInputStream input = CodedInputStream.CreateInstance(buffer);
while (input.ReadTag(out tag, out fieldName))
{
int Field = WireFormat.GetTagFieldNumber(tag);
WireFormat.WireType WireType = WireFormat.GetTagWireType(tag);
switch (WireType)
{
case WireFormat.WireType.LengthDelimited:
ByteString tmps = ByteString.Empty;
input.ReadBytes(ref tmps);
break;
case WireFormat.WireType.Fixed32:
break;
case WireFormat.WireType.Fixed64:
break;
case WireFormat.WireType.Varint:
uint val = 0;
input.ReadUInt32(ref val);
if (tags == tag >> 3)
{
return(val);
}
break;
}
}
return(0);
}
public void MergeFrom(CodedInputStream input)
{
uint tag;
while ((tag = input.ReadTag()) != 0)
{
switch (tag)
{
default:
_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
break;
case 10:
{
KeyData = input.ReadBytes();
break;
}
case 16:
{
TransmissionRiskLevel = input.ReadInt32();
break;
}
case 24:
{
RollingStartIntervalNumber = input.ReadInt32();
break;
}
case 32:
{
RollingPeriod = input.ReadInt32();
break;
}
}
}
}
public void MergeFrom(CodedInputStream input)
{
uint tag;
while ((tag = input.ReadTag()) != 0)
{
switch (tag)
{
default:
_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
break;
case 10: {
if (signatureInfo_ == null)
{
SignatureInfo = new global::NL.Rijksoverheid.ExposureNotification.BackEnd.GeneratedGaenFormat.SignatureInfo();
}
input.ReadMessage(SignatureInfo);
break;
}
case 16: {
BatchNum = input.ReadInt32();
break;
}
case 24: {
BatchSize = input.ReadInt32();
break;
}
case 34: {
Signature = input.ReadBytes();
break;
}
}
}
}
public async Task <IEnumerable <string> > GetResources(Hash chainId, Transaction transaction)
{
//var hashes = ECParameters.Parser.ParseFrom(transaction.Params).Params.Select(p => p.HashVal);
List <Address> hashes = new List <Address>();
using (MemoryStream mm = new MemoryStream(transaction.Params.ToByteArray()))
using (CodedInputStream input = new CodedInputStream(mm))
{
uint tag;
while ((tag = input.ReadTag()) != 0)
{
switch (WireFormat.GetTagWireType(tag))
{
case WireFormat.WireType.Varint:
input.ReadUInt64();
break;
case WireFormat.WireType.LengthDelimited:
var bytes = input.ReadBytes();
// Address used to be 32 bytes long and was reduced to 18
// accept both so that we don't have to fix tests
if (bytes.Length == 34 || bytes.Length == 20)
{
var h = new Address();
((IMessage)h).MergeFrom(bytes);
hashes.Add(h);
}
break;
}
}
}
hashes.Add(transaction.From);
return(await Task.FromResult(hashes.Select(a => a.DumpHex()).ToList()));
}
public static void ReadProtoRawDataS(List <object> list, byte[] buffer, int tags)
{
uint tag = 0;
string fieldName = "";
CodedInputStream input = CodedInputStream.CreateInstance(buffer);
while (input.ReadTag(out tag, out fieldName))
{
int Field = WireFormat.GetTagFieldNumber(tag);
WireFormat.WireType WireType = WireFormat.GetTagWireType(tag);
switch (WireType)
{
case WireFormat.WireType.LengthDelimited:
ByteString tmps = ByteString.Empty;
input.ReadBytes(ref tmps);
if (tags == tag >> 3)
{
//return tmps.ToByteArray();
list.Add(tmps.ToByteArray());
}
break;
case WireFormat.WireType.Fixed32:
break;
case WireFormat.WireType.Fixed64:
break;
case WireFormat.WireType.Varint:
int val = 0;
input.ReadInt32(ref val);
break;
}
}
}
public override ByteString Read(CodedInputStream stream)
{
return(stream.ReadBytes());
}
private static InternalKey ReadInternalKey(CodedInputStream pb)
{
return(new InternalKey(pb.ReadBytes()));
}
/// <summary>
/// Decode a value of the given type.
/// Should not be called directly. This interface is used by service client stubs.
/// </summary>
public static object Decode(ByteString value, Type type, Connection client)
{
var stream = new CodedInputStream(value.ToByteArray());
if (type == typeof(double))
{
return(stream.ReadDouble());
}
else if (type == typeof(float))
{
return(stream.ReadFloat());
}
else if (type == typeof(int))
{
return(stream.ReadInt32());
}
else if (type == typeof(long))
{
return(stream.ReadInt64());
}
else if (type == typeof(uint))
{
return(stream.ReadUInt32());
}
else if (type == typeof(ulong))
{
return(stream.ReadUInt64());
}
else if (type == typeof(bool))
{
return(stream.ReadBool());
}
else if (type == typeof(string))
{
return(stream.ReadString());
}
else if (type == typeof(byte[]))
{
return(stream.ReadBytes().ToByteArray());
}
else if (type.IsEnum)
{
return(stream.ReadInt32());
}
else if (typeof(RemoteObject).IsAssignableFrom(type))
{
if (client == null)
{
throw new ArgumentException("Client not passed when decoding remote object");
}
var id = stream.ReadUInt64();
if (id == 0)
{
return(null);
}
return((RemoteObject)Activator.CreateInstance(type, client, id));
}
else if (typeof(IMessage).IsAssignableFrom(type))
{
IMessage message = (IMessage)Activator.CreateInstance(type);
message.MergeFrom(stream);
return(message);
}
else if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(IList <>))
{
return(DecodeList(value, type, client));
}
else if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(IDictionary <,>))
{
return(DecodeDictionary(value, type, client));
}
else if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(ISet <>))
{
return(DecodeSet(value, type, client));
}
else if (type.IsGenericType &&
(type.GetGenericTypeDefinition() == typeof(Tuple <>) ||
type.GetGenericTypeDefinition() == typeof(Tuple <,>) ||
type.GetGenericTypeDefinition() == typeof(Tuple <, ,>) ||
type.GetGenericTypeDefinition() == typeof(Tuple <, , ,>) ||
type.GetGenericTypeDefinition() == typeof(Tuple <, , , ,>) ||
type.GetGenericTypeDefinition() == typeof(Tuple <, , , , ,>)))
{
return(DecodeTuple(value, type, client)); // TODO: ugly handing of tuple types
}
throw new ArgumentException(type + " is not a serializable type");
}
