private static TimeSpan ReadDurationFallback(ProtoReader source, ref ProtoReader.State state)
{
long seconds = 0;
int nanos = 0;
SubItemToken token = ProtoReader.StartSubItem(source, ref state);
int fieldNumber;
while ((fieldNumber = source.ReadFieldHeader(ref state)) > 0)
{
switch (fieldNumber)
{
case 1:
seconds = source.ReadInt64(ref state);
break;
case 2:
nanos = source.ReadInt32(ref state);
break;
default:
source.SkipField(ref state);
break;
}
}
ProtoReader.EndSubItem(token, source, ref state);
return(FromDurationSeconds(seconds, nanos));
}
private static long ReadTimeSpanTicks(ProtoReader source)
{
SubItemToken token = ProtoReader.StartSubItem(source);
int fieldNumber;
TimeSpanScale scale = TimeSpanScale.Days;
long value = 0;
while ((fieldNumber = source.ReadFieldHeader()) > 0)
{
switch (fieldNumber)
{
case FieldTimeSpanScale:
scale = (TimeSpanScale)source.ReadInt32();
break;
case FieldTimeSpanValue:
source.Assert(WireType.SignedVariant);
value = source.ReadInt64();
break;
default:
source.SkipField();
break;
}
}
ProtoReader.EndSubItem(token, source);
switch (scale)
{
case TimeSpanScale.Days:
return(value * TimeSpan.TicksPerDay);
case TimeSpanScale.Hours:
return(value * TimeSpan.TicksPerHour);
case TimeSpanScale.Minutes:
return(value * TimeSpan.TicksPerMinute);
case TimeSpanScale.Seconds:
return(value * TimeSpan.TicksPerSecond);
case TimeSpanScale.Milliseconds:
return(value * TimeSpan.TicksPerMillisecond);
case TimeSpanScale.Ticks:
return(value);
case TimeSpanScale.MinMax:
switch (value)
{
case 1: return(long.MaxValue);
case -1: return(long.MinValue);
default: throw new ProtoException("Unknown min/max value: " + value.ToString());
}
default:
throw new ProtoException("Unknown timescale: " + scale.ToString());
}
}
static public int ReadInt64(IntPtr l)
{
try {
ProtoBuf.ProtoReader self = (ProtoBuf.ProtoReader)checkSelf(l);
var ret = self.ReadInt64();
pushValue(l, true);
pushValue(l, ret);
return(2);
}
catch (Exception e) {
return(error(l, e));
}
}
private static long ReadTimeSpanTicks(ProtoReader source) {
switch (source.WireType)
{
case WireType.String:
case WireType.StartGroup:
SubItemToken token = ProtoReader.StartSubItem(source);
int fieldNumber;
TimeSpanScale scale = TimeSpanScale.Days;
long value = 0;
while ((fieldNumber = source.ReadFieldHeader()) > 0)
{
switch (fieldNumber)
{
case FieldTimeSpanScale:
scale = (TimeSpanScale)source.ReadInt32();
break;
case FieldTimeSpanValue:
source.Assert(WireType.SignedVariant);
value = source.ReadInt64();
break;
default:
source.SkipField();
break;
}
}
ProtoReader.EndSubItem(token, source);
switch (scale)
{
case TimeSpanScale.Days:
return value * TimeSpan.TicksPerDay;
case TimeSpanScale.Hours:
return value * TimeSpan.TicksPerHour;
case TimeSpanScale.Minutes:
return value * TimeSpan.TicksPerMinute;
case TimeSpanScale.Seconds:
return value * TimeSpan.TicksPerSecond;
case TimeSpanScale.Milliseconds:
return value * TimeSpan.TicksPerMillisecond;
case TimeSpanScale.Ticks:
return value;
case TimeSpanScale.MinMax:
switch (value)
{
case 1: return long.MaxValue;
case -1: return long.MinValue;
default: throw new ProtoException("Unknown min/max value: " + value.ToString());
}
default:
throw new ProtoException("Unknown timescale: " + scale.ToString());
}
case WireType.Fixed64:
return source.ReadInt64();
default:
throw new ProtoException("Unexpected wire-type: " + source.WireType.ToString());
}
}
private static long ReadTimeSpanTicks(ProtoReader source, out DateTimeKind kind)
{
kind = DateTimeKind.Unspecified;
switch (source.WireType)
{
case WireType.String:
case WireType.StartGroup:
SubItemToken token = ProtoReader.StartSubItem(source);
int fieldNumber;
TimeSpanScale scale = TimeSpanScale.Days;
long value = 0;
while ((fieldNumber = source.ReadFieldHeader()) > 0)
{
switch (fieldNumber)
{
case FieldTimeSpanScale:
scale = (TimeSpanScale)source.ReadInt32();
break;
case FieldTimeSpanValue:
source.Assert(WireType.SignedVariant);
value = source.ReadInt64();
break;
case FieldTimeSpanKind:
kind = (DateTimeKind)source.ReadInt32();
switch (kind)
{
case DateTimeKind.Unspecified:
case DateTimeKind.Utc:
case DateTimeKind.Local:
break; // fine
default:
throw new ProtoException("Invalid date/time kind: " + kind.ToString());
}
break;
default:
source.SkipField();
break;
}
}
ProtoReader.EndSubItem(token, source);
switch (scale)
{
case TimeSpanScale.Days:
return(value * TimeSpan.TicksPerDay);
case TimeSpanScale.Hours:
return(value * TimeSpan.TicksPerHour);
case TimeSpanScale.Minutes:
return(value * TimeSpan.TicksPerMinute);
case TimeSpanScale.Seconds:
return(value * TimeSpan.TicksPerSecond);
case TimeSpanScale.Milliseconds:
return(value * TimeSpan.TicksPerMillisecond);
case TimeSpanScale.Ticks:
return(value);
case TimeSpanScale.MinMax:
switch (value)
{
case 1: return(long.MaxValue);
case -1: return(long.MinValue);
default: throw new ProtoException("Unknown min/max value: " + value.ToString());
}
default:
throw new ProtoException("Unknown timescale: " + scale.ToString());
}
case WireType.Fixed64:
return(source.ReadInt64());
default:
throw new ProtoException("Unexpected wire-type: " + source.WireType.ToString());
}
}
object BuildBody( uint realEMsg, Stream str )
{
EMsg eMsg = MsgUtil.GetMsg( realEMsg );
if ( eMsg == EMsg.ClientLogonGameServer )
eMsg = EMsg.ClientLogon; // temp hack for now
else if( eMsg == EMsg.ClientGamesPlayedWithDataBlob)
eMsg = EMsg.ClientGamesPlayed;
var protomsgType = typeof(CMClient).Assembly.GetTypes().ToList().Find(type =>
{
if (type.GetInterfaces().ToList().Find(inter => inter == typeof(IExtensible)) == null)
return false;
if (type.Name.EndsWith(eMsg.ToString(), StringComparison.OrdinalIgnoreCase))
return true;
return false;
});
if (protomsgType != null)
{
return RuntimeTypeModel.Default.Deserialize(str, null, protomsgType);
}
// lets first find the type by checking all EMsgs we have
var msgType = typeof( CMClient ).Assembly.GetTypes().ToList().Find( type =>
{
if ( type.GetInterfaces().ToList().Find( inter => inter == typeof( ISteamSerializableMessage ) ) == null )
return false;
var gcMsg = Activator.CreateInstance( type ) as ISteamSerializableMessage;
return gcMsg.GetEMsg() == eMsg;
} );
string eMsgName = eMsg.ToString();
eMsgName = eMsgName.Replace( "Econ", "" ).Replace( "AM", "" );
// check name
if ( msgType == null )
msgType = GetSteamKitType( string.Format( "SteamKit2.Msg{0}", eMsgName ) );
if ( msgType != null )
{
var body = Activator.CreateInstance( msgType ) as ISteamSerializableMessage;
body.Deserialize( str );
return body;
}
msgType = GetSteamKitType( string.Format( "SteamKit2.CMsg{0}", eMsgName ) );
if ( msgType != null )
{
return Deserialize( msgType, str );
}
if ( eMsg == EMsg.ClientToGC || eMsg == EMsg.ClientFromGC )
{
return Serializer.Deserialize<CMsgGCClient>( str );
}
var gcMsgName = BuildEMsg( realEMsg );
var gcMsgPossibleTypePrefixes = new[]
{
"SteamKit2.GC.Internal.CMsg",
"SteamKit2.GC.Dota.Internal.CMsg",
"SteamKit2.GC.CSGO.Internal.CMsg",
"SteamKit2.GC.TF.Internal.CMsg",
};
var typeMsgName = gcMsgName
.Replace("GC", string.Empty)
.Replace("k_", string.Empty)
.Replace("ESOMsg", string.Empty)
.TrimStart('_')
.Replace("EMsg", string.Empty);
if ( typeMsgName == "Create" || typeMsgName == "Destroy" || typeMsgName == "Update" )
typeMsgName = "SingleObject";
else if ( typeMsgName == "Multiple" )
typeMsgName = "MultipleObjects";
var possibleTypes = from type in typeof( CMClient ).Assembly.GetTypes()
from typePrefix in gcMsgPossibleTypePrefixes
where type.GetInterfaces().Contains( typeof ( IExtensible ) )
where type.FullName.StartsWith( typePrefix ) && type.FullName.EndsWith( typeMsgName )
select type;
foreach ( var type in possibleTypes )
{
var streamPos = str.Position;
try
{
return Deserialize( type, str );
}
catch ( Exception )
{
str.Position = streamPos;
}
}
if (!MsgUtil.IsProtoBuf(realEMsg))
return null;
// try reading it as a protobuf
using (ProtoReader reader = new ProtoReader(str, null, null))
{
var fields = new Dictionary<int, List<object>>();
while(true)
{
int field = reader.ReadFieldHeader();
if(field == 0)
break;
object fieldValue = null;
switch (reader.WireType)
{
case WireType.Variant:
case WireType.Fixed32:
case WireType.Fixed64:
case WireType.SignedVariant:
{
try
{
fieldValue = reader.ReadInt64();
}
catch (Exception)
{
fieldValue = "Unable to read Variant (debugme)";
}
break;
}
case WireType.String:
{
try
{
fieldValue = reader.ReadString();
}
catch (Exception)
{
fieldValue = "Unable to read String (debugme)";
}
break;
}
default:
{
fieldValue = string.Format( "{0} is not implemented", reader.WireType );
break;
}
}
if ( !fields.ContainsKey( field ) )
{
fields[ field ] = new List<object>();
}
fields[ field ].Add( fieldValue );
}
if (fields.Count > 0)
return fields;
}
return null;
}
private static long ReadTimeSpanTicks(ProtoReader source)
{
switch (source.WireType)
{
case WireType.String:
case WireType.StartGroup:
{
SubItemToken token = ProtoReader.StartSubItem(source);
TimeSpanScale timeSpanScale = TimeSpanScale.Days;
long num = 0L;
int num2;
while ((num2 = source.ReadFieldHeader()) > 0)
{
switch (num2)
{
case 2:
timeSpanScale = (TimeSpanScale)source.ReadInt32();
break;
case 1:
source.Assert(WireType.SignedVariant);
num = source.ReadInt64();
break;
default:
source.SkipField();
break;
}
}
ProtoReader.EndSubItem(token, source);
switch (timeSpanScale)
{
case TimeSpanScale.Days:
return(num * 864000000000L);
case TimeSpanScale.Hours:
return(num * 36000000000L);
case TimeSpanScale.Minutes:
return(num * 600000000);
case TimeSpanScale.Seconds:
return(num * 10000000);
case TimeSpanScale.Milliseconds:
return(num * 10000);
case TimeSpanScale.Ticks:
return(num);
case TimeSpanScale.MinMax:
switch (num)
{
case 1L:
return(long.MaxValue);
case -1L:
return(long.MinValue);
default:
throw new ProtoException("Unknown min/max value: " + num);
}
default:
throw new ProtoException("Unknown timescale: " + timeSpanScale);
}
}
case WireType.Fixed64:
return(source.ReadInt64());
default:
throw new ProtoException("Unexpected wire-type: " + source.WireType);
}
}
// Token: 0x06003269 RID: 12905 RVA: 0x001266EC File Offset: 0x00124AEC
private static long ReadTimeSpanTicks(ProtoReader source, out DateTimeKind kind)
{
kind = DateTimeKind.Unspecified;
switch (source.WireType)
{
case WireType.Fixed64:
return(source.ReadInt64());
case WireType.String:
case WireType.StartGroup:
{
SubItemToken token = ProtoReader.StartSubItem(source);
TimeSpanScale timeSpanScale = TimeSpanScale.Days;
long num = 0L;
int num2;
while ((num2 = source.ReadFieldHeader()) > 0)
{
switch (num2)
{
case 1:
source.Assert(WireType.SignedVariant);
num = source.ReadInt64();
break;
case 2:
timeSpanScale = (TimeSpanScale)source.ReadInt32();
break;
case 3:
kind = (DateTimeKind)source.ReadInt32();
switch (kind)
{
case DateTimeKind.Unspecified:
case DateTimeKind.Utc:
case DateTimeKind.Local:
break;
default:
throw new ProtoException("Invalid date/time kind: " + kind.ToString());
}
break;
default:
source.SkipField();
break;
}
}
ProtoReader.EndSubItem(token, source);
switch (timeSpanScale)
{
case TimeSpanScale.Days:
return(num * 864000000000L);
case TimeSpanScale.Hours:
return(num * 36000000000L);
case TimeSpanScale.Minutes:
return(num * 600000000L);
case TimeSpanScale.Seconds:
return(num * 10000000L);
case TimeSpanScale.Milliseconds:
return(num * 10000L);
case TimeSpanScale.Ticks:
return(num);
default:
if (timeSpanScale != TimeSpanScale.MinMax)
{
throw new ProtoException("Unknown timescale: " + timeSpanScale.ToString());
}
if (num == 1L)
{
return(long.MaxValue);
}
if (num != -1L)
{
throw new ProtoException("Unknown min/max value: " + num.ToString());
}
return(long.MinValue);
}
}
default:
throw new ProtoException("Unexpected wire-type: " + source.WireType.ToString());
}
}
private static long ReadTimeSpanTicks(ProtoReader source)
{
WireType wireType = source.WireType;
if (wireType != WireType.Fixed64)
{
if ((uint)(wireType - 2) <= 1u)
{
SubItemToken token = ProtoReader.StartSubItem(source);
TimeSpanScale timeSpanScale = TimeSpanScale.Days;
long num = 0L;
int num2;
while ((num2 = source.ReadFieldHeader()) > 0)
{
switch (num2)
{
case 2:
timeSpanScale = (TimeSpanScale)source.ReadInt32();
break;
case 1:
source.Assert(WireType.SignedVariant);
num = source.ReadInt64();
break;
default:
source.SkipField();
break;
}
}
ProtoReader.EndSubItem(token, source);
switch (timeSpanScale)
{
case TimeSpanScale.Days:
return(num * 864000000000L);
case TimeSpanScale.Hours:
return(num * 36000000000L);
case TimeSpanScale.Minutes:
return(num * 600000000);
case TimeSpanScale.Seconds:
return(num * 10000000);
case TimeSpanScale.Milliseconds:
return(num * 10000);
case TimeSpanScale.Ticks:
return(num);
case TimeSpanScale.MinMax:
switch (num)
{
case 1L:
return(9223372036854775807L);
case -1L:
return(-9223372036854775808L);
default:
throw new ProtoException("Unknown min/max value: " + num.ToString());
}
default:
throw new ProtoException("Unknown timescale: " + timeSpanScale.ToString());
}
}
wireType = source.WireType;
throw new ProtoException("Unexpected wire-type: " + wireType.ToString());
}
return(source.ReadInt64());
}
private static long ReadTimeSpanTicks(ProtoReader source)
{
switch (source.WireType)
{
case WireType.Fixed64:
return source.ReadInt64();
case WireType.String:
case WireType.StartGroup:
{
SubItemToken token = ProtoReader.StartSubItem(source);
TimeSpanScale timeSpanScale = TimeSpanScale.Days;
long num = 0L;
int num2;
while ((num2 = source.ReadFieldHeader()) > 0)
{
int num3 = num2;
if (num3 != 1)
{
if (num3 != 2)
{
source.SkipField();
}
else
{
timeSpanScale = (TimeSpanScale)source.ReadInt32();
}
}
else
{
source.Assert(WireType.SignedVariant);
num = source.ReadInt64();
}
}
ProtoReader.EndSubItem(token, source);
TimeSpanScale timeSpanScale2 = timeSpanScale;
switch (timeSpanScale2)
{
case TimeSpanScale.Days:
return num * 864000000000L;
case TimeSpanScale.Hours:
return num * 36000000000L;
case TimeSpanScale.Minutes:
return num * 600000000L;
case TimeSpanScale.Seconds:
return num * 10000000L;
case TimeSpanScale.Milliseconds:
return num * 10000L;
case TimeSpanScale.Ticks:
return num;
default:
{
if (timeSpanScale2 != TimeSpanScale.MinMax)
{
throw new ProtoException("Unknown timescale: " + timeSpanScale.ToString());
}
long num4 = num;
if (num4 >= -1L && num4 <= 1L)
{
switch ((int)(num4 - -1L))
{
case 0:
return -9223372036854775808L;
case 2:
return 9223372036854775807L;
}
}
throw new ProtoException("Unknown min/max value: " + num.ToString());
}
}
break;
}
default:
throw new ProtoException("Unexpected wire-type: " + source.WireType.ToString());
}
}
object ReadField(ProtoReader reader, Type memberT, string sClassName, CLS_Environment environment)
{
if (memberT == typeof(int))
{
return reader.ReadInt32();
}
else if (memberT == typeof(uint))
{
return reader.ReadUInt32();
}
else if (memberT == typeof(bool))
{
return reader.ReadBoolean();
}
else if (memberT == typeof(byte))
{
return reader.ReadByte();
}
else if (memberT == typeof(sbyte))
{
return reader.ReadSByte();
}
else if (memberT == typeof(float))
{
return reader.ReadSingle();
}
else if (memberT == typeof(double))
{
return reader.ReadDouble();
}
else if (memberT == typeof(short))
{
return reader.ReadInt16();
}
else if (memberT == typeof(ushort))
{
return reader.ReadUInt16();
}
else if (memberT == typeof(long))
{
return reader.ReadInt64();
}
else if (memberT == typeof(ulong))
{
return reader.ReadUInt64();
}
else if (memberT == typeof(string))
{
return reader.ReadString();
}
else if (memberT == typeof(byte[]))
{
return ProtoReader.AppendBytes(null, reader);
}
else if (memberT == typeof(SInstance))
{
SubItemToken st = ProtoReader.StartSubItem(reader);
CLS_Type_Class sClass = environment.GetTypeByKeywordQuiet(sClassName) as CLS_Type_Class;
if (!sClass.compiled)
RuntimeCompilerClass(sClassName);
CLS_Content content = CLS_Content.NewContent(environment);
CLS_Content.Value retVal = sClass.function.New(content, m_emptyParams);
CLS_Content.PoolContent(content);
SInstance sInstance = (SInstance)retVal.value;
ReadSInstance(reader, sInstance, environment);
ProtoReader.EndSubItem(st, reader);
return sInstance;
}
else
{
throw new NotImplementedException("未实现类型: " + memberT);
}
}
private static long ReadTimeSpanTicks(ProtoReader source)
{
TimeSpanScale timeSpanScale;
switch (source.WireType)
{
case WireType.Fixed64:
{
return(source.ReadInt64());
}
case WireType.String:
case WireType.StartGroup:
{
SubItemToken subItemToken = ProtoReader.StartSubItem(source);
timeSpanScale = TimeSpanScale.Days;
long num = (long)0;
while (true)
{
int num1 = source.ReadFieldHeader();
int num2 = num1;
if (num1 <= 0)
{
break;
}
switch (num2)
{
case 1:
{
source.Assert(WireType.SignedVariant);
num = source.ReadInt64();
continue;
}
case 2:
{
timeSpanScale = (TimeSpanScale)source.ReadInt32();
continue;
}
default:
{
source.SkipField();
continue;
}
}
}
ProtoReader.EndSubItem(subItemToken, source);
TimeSpanScale timeSpanScale1 = timeSpanScale;
switch (timeSpanScale1)
{
case TimeSpanScale.Days:
{
return(num * 864000000000L);
}
case TimeSpanScale.Hours:
{
return(num * 36000000000L);
}
case TimeSpanScale.Minutes:
{
return(num * (long)600000000);
}
case TimeSpanScale.Seconds:
{
return(num * (long)10000000);
}
case TimeSpanScale.Milliseconds:
{
return(num * (long)10000);
}
case TimeSpanScale.Ticks:
{
return(num);
}
default:
{
if (timeSpanScale1 == TimeSpanScale.MinMax)
{
break;
}
else
{
throw new ProtoException(string.Concat("Unknown timescale: ", timeSpanScale.ToString()));
}
}
}
long num3 = num;
if (num3 <= (long)1 && num3 >= (long)-1)
{
switch ((int)(num3 - (long)-1))
{
case 0:
{
return(-9223372036854775808L);
}
case 2:
{
return(9223372036854775807L);
}
}
}
throw new ProtoException(string.Concat("Unknown min/max value: ", num.ToString()));
}
}
throw new ProtoException(string.Concat("Unexpected wire-type: ", source.WireType.ToString()));
throw new ProtoException(string.Concat("Unknown timescale: ", timeSpanScale.ToString()));
}
object BuildBody( uint realEMsg, Stream str )
{
EMsg eMsg = MsgUtil.GetMsg( realEMsg );
if ( eMsg == EMsg.ClientLogonGameServer )
eMsg = EMsg.ClientLogon; // temp hack for now
else if( eMsg == EMsg.ClientGamesPlayedWithDataBlob)
eMsg = EMsg.ClientGamesPlayed;
var protomsgType = typeof(CMClient).Assembly.GetTypes().ToList().Find(type =>
{
if (type.GetInterfaces().ToList().Find(inter => inter == typeof(IExtensible)) == null)
return false;
if (type.Name.EndsWith(eMsg.ToString()))
return true;
return false;
});
if (protomsgType != null)
{
return RuntimeTypeModel.Default.Deserialize(str, null, protomsgType);
}
// lets first find the type by checking all EMsgs we have
var msgType = typeof( CMClient ).Assembly.GetTypes().ToList().Find( type =>
{
if ( type.GetInterfaces().ToList().Find( inter => inter == typeof( ISteamSerializableMessage ) ) == null )
return false;
var gcMsg = Activator.CreateInstance( type ) as ISteamSerializableMessage;
return gcMsg.GetEMsg() == eMsg;
} );
string eMsgName = eMsg.ToString();
eMsgName = eMsgName.Replace( "Econ", "" ).Replace( "AM", "" );
// check name
if ( msgType == null )
msgType = GetSteamKitType( string.Format( "SteamKit2.Msg{0}", eMsgName ) );
if ( msgType != null )
{
var body = Activator.CreateInstance( msgType ) as ISteamSerializableMessage;
body.Deserialize( str );
return body;
}
msgType = GetSteamKitType( string.Format( "SteamKit2.CMsg{0}", eMsgName ) );
if ( msgType != null )
{
return Deserialize( msgType, str );
}
if ( eMsg == EMsg.ClientToGC || eMsg == EMsg.ClientFromGC )
{
return Serializer.Deserialize<CMsgGCClient>( str );
}
// try reading it as a protobuf
using (ProtoReader reader = new ProtoReader(str, null, null))
{
var fields = new Dictionary<int, List<object>>();
while(true)
{
int field = reader.ReadFieldHeader();
if(field == 0)
break;
object fieldValue = null;
switch (reader.WireType)
{
case WireType.Variant:
case WireType.Fixed32:
case WireType.Fixed64:
case WireType.SignedVariant:
{
try
{
fieldValue = reader.ReadInt64();
}
catch (Exception)
{
fieldValue = "Unable to read Variant (debugme)";
}
break;
}
case WireType.String:
{
try
{
fieldValue = reader.ReadString();
}
catch (Exception)
{
fieldValue = "Unable to read String (debugme)";
}
break;
}
default:
{
fieldValue = string.Format( "{0} is not implemented", reader.WireType );
break;
}
}
if ( !fields.ContainsKey( field ) )
{
fields[ field ] = new List<object>();
}
fields[ field ].Add( fieldValue );
}
if (fields.Count > 0)
return fields;
}
return null;
}
private static long ReadTimeSpanTicks(ProtoReader source)
{
switch (source.WireType)
{
case WireType.Fixed64:
return(source.ReadInt64());
case WireType.String:
case WireType.StartGroup:
{
SubItemToken token = ProtoReader.StartSubItem(source);
TimeSpanScale timeSpanScale = TimeSpanScale.Days;
long num = 0L;
int num2;
while ((num2 = source.ReadFieldHeader()) > 0)
{
int num3 = num2;
if (num3 != 1)
{
if (num3 != 2)
{
source.SkipField();
}
else
{
timeSpanScale = (TimeSpanScale)source.ReadInt32();
}
}
else
{
source.Assert(WireType.SignedVariant);
num = source.ReadInt64();
}
}
ProtoReader.EndSubItem(token, source);
TimeSpanScale timeSpanScale2 = timeSpanScale;
switch (timeSpanScale2)
{
case TimeSpanScale.Days:
return(num * 864000000000L);
case TimeSpanScale.Hours:
return(num * 36000000000L);
case TimeSpanScale.Minutes:
return(num * 600000000L);
case TimeSpanScale.Seconds:
return(num * 10000000L);
case TimeSpanScale.Milliseconds:
return(num * 10000L);
case TimeSpanScale.Ticks:
return(num);
default:
{
if (timeSpanScale2 != TimeSpanScale.MinMax)
{
throw new ProtoException("Unknown timescale: " + timeSpanScale.ToString());
}
long num4 = num;
if (num4 >= -1L && num4 <= 1L)
{
switch ((int)(num4 - -1L))
{
case 0:
return(-9223372036854775808L);
case 2:
return(9223372036854775807L);
}
}
throw new ProtoException("Unknown min/max value: " + num.ToString());
}
}
break;
}
default:
throw new ProtoException("Unexpected wire-type: " + source.WireType.ToString());
}
}
public static Dictionary<int, List<object>> ReadProtobuf(Stream stream)
{
// try reading it as a protobuf
using (var reader = new ProtoReader(stream, null, null))
{
var fields = new Dictionary<int, List<object>>();
while (true)
{
int field = reader.ReadFieldHeader();
if (field == 0)
break;
object fieldValue = null;
switch (reader.WireType)
{
case WireType.Variant:
case WireType.Fixed32:
case WireType.Fixed64:
case WireType.SignedVariant:
{
try
{
fieldValue = reader.ReadInt64();
}
catch (Exception)
{
fieldValue = "Unable to read Variant (debugme)";
}
break;
}
case WireType.String:
{
try
{
fieldValue = reader.ReadString();
}
catch (Exception)
{
fieldValue = "Unable to read String (debugme)";
}
break;
}
default:
{
fieldValue = string.Format("{0} is not implemented", reader.WireType);
break;
}
}
if (!fields.ContainsKey(field))
{
fields[field] = new List<object>();
}
fields[field].Add(fieldValue);
}
if (fields.Count > 0)
return fields;
}
return null;
}
// Token: 0x06000039 RID: 57 RVA: 0x0000A274 File Offset: 0x00008474
private static long ReadTimeSpanTicks(ProtoReader source)
{
WireType wireType = source.WireType;
if (wireType == WireType.Fixed64)
{
return(source.ReadInt64());
}
if (wireType - WireType.String > 1)
{
throw new ProtoException("Unexpected wire-type: " + source.WireType.ToString());
}
SubItemToken token = ProtoReader.StartSubItem(source);
TimeSpanScale timeSpanScale = TimeSpanScale.Days;
long num = 0L;
int num2;
while ((num2 = source.ReadFieldHeader()) > 0)
{
if (num2 != 1)
{
if (num2 == 2)
{
timeSpanScale = (TimeSpanScale)source.ReadInt32();
}
else
{
source.SkipField();
}
}
else
{
source.Assert(WireType.SignedVariant);
num = source.ReadInt64();
}
}
ProtoReader.EndSubItem(token, source);
switch (timeSpanScale)
{
case TimeSpanScale.Days:
return(num * 864000000000L);
case TimeSpanScale.Hours:
return(num * 36000000000L);
case TimeSpanScale.Minutes:
return(num * 600000000L);
case TimeSpanScale.Seconds:
return(num * 10000000L);
case TimeSpanScale.Milliseconds:
return(num * 10000L);
case TimeSpanScale.Ticks:
return(num);
default:
if (timeSpanScale != TimeSpanScale.MinMax)
{
throw new ProtoException("Unknown timescale: " + timeSpanScale.ToString());
}
if (num == -1L)
{
return(long.MinValue);
}
if (num == 1L)
{
return(long.MaxValue);
}
throw new ProtoException("Unknown min/max value: " + num.ToString());
}
}