static BinaryStreamWriter GetMails_2(object __serviceObj, Session __client, BinaryStreamReader __reader)
{
var __timer = TimeCounter.BeginNew();
IAgentServerImpl __service = (IAgentServerImpl)__serviceObj;
int __reqId;
__reader.Read(out __reqId);
#if (DEBUG || LOG_PROTOCOL)
Log.Debug("GetMails reqId: {0}", __reqId);
#endif
var reply = new IAgentServer_GetMailsCallback(__reqId, __client.Connection);
try
{
__service.GetMails(__client, reply);
}
catch(ServiceException e)
{
reply.Error(e.ErrCode, e.Message);
}
catch(Exception e)
{
Log.Error("Generic Service Invoke Failed, clientId:{0} error message:{1}\nCall Stack: {2}", __client.ID, e.Message, e.StackTrace);
reply.Error((int)ServiceErrorCode.Generic, "generic service error.");
}
PerfStatistic.AddItem("IAgentServer.GetMails", (int)__timer.End());
return null;
}
static BinaryStreamWriter Login_1(object __serviceObj, Session __client, BinaryStreamReader __reader)
{
var __timer = TimeCounter.BeginNew();
IAgentServerImpl __service = (IAgentServerImpl)__serviceObj;
string userId;
__reader.Read(out userId);
#if (DEBUG || LOG_PROTOCOL)
Log.Debug("Login userId: {0}", userId);
#endif
__service.Login(__client, userId);
PerfStatistic.AddItem("IAgentServer.Login", (int)__timer.End());
return null;
}
public void Read(BinaryStreamReader signatureBlobReader)
{
}
/// <summary>
/// Reads a single field pointer row from an input stream.
/// </summary>
/// <param name="reader">The input stream.</param>
/// <param name="layout">The layout of the field pointer table.</param>
/// <returns>The row.</returns>
public static MethodPointerRow FromReader(ref BinaryStreamReader reader, TableLayout layout)
{
return(new MethodPointerRow(reader.ReadIndex((IndexSize)layout.Columns[0].Size)));
}
public IMetadataStream ReadStream(PEReaderContext context, MetadataStreamHeader header, ref BinaryStreamReader reader)
{
return(header.Name == KoiStreamName
? new KoiStream(KoiStreamName, new DataSegment(reader.ReadToEnd()), Logger)
: _reader.ReadStream(context, header, ref reader));
}
/// <summary>
/// Reads a single interface implementation row from an input stream.
/// </summary>
/// <param name="reader">The input stream.</param>
/// <param name="layout">The layout of the interface implementation table.</param>
/// <returns>The row.</returns>
public static InterfaceImplementationRow FromReader(ref BinaryStreamReader reader, TableLayout layout)
{
return(new InterfaceImplementationRow(
reader.ReadIndex((IndexSize)layout.Columns[0].Size),
reader.ReadIndex((IndexSize)layout.Columns[1].Size)));
}
/// <summary>
/// Reads a single module reference row from an input stream.
/// </summary>
/// <param name="reader">The input stream.</param>
/// <param name="layout">The layout of the module reference table.</param>
/// <returns>The row.</returns>
public static ModuleReferenceRow FromReader(ref BinaryStreamReader reader, TableLayout layout)
{
return(new ModuleReferenceRow(reader.ReadIndex((IndexSize)layout.Columns[0].Size)));
}
private void ReadAndInitializeRowCounts(BinaryStreamReader reader, ulong validMask)
{
var tables = new Array[45];
if ((validMask & ((ulong)1 << (int)TableKind.Module)) != 0)
{
uint rowCount = reader.ReadUInt32();
var table = new ModuleEntry[rowCount];
tables[(int)TableKind.Module] = table;
}
if ((validMask & ((ulong)1 << (int)TableKind.TypeRef)) != 0)
{
uint rowCount = reader.ReadUInt32();
var table = new TypeRefEntry[rowCount];
tables[(int)TableKind.TypeRef] = table;
}
if ((validMask & ((ulong)1 << (int)TableKind.TypeDef)) != 0)
{
uint rowCount = reader.ReadUInt32();
var table = new TypeDefEntry[rowCount];
tables[(int)TableKind.TypeDef] = table;
}
if ((validMask & ((ulong)1 << 0x03)) != 0)
{
throw new BadImageFormatException("Non-standard metadata table 0x" + validMask.ToString("X2") + ".");
}
if ((validMask & ((ulong)1 << (int)TableKind.Field)) != 0)
{
uint rowCount = reader.ReadUInt32();
var table = new FieldEntry[rowCount];
tables[(int)TableKind.Field] = table;
}
if ((validMask & ((ulong)1 << 0x05)) != 0)
{
throw new BadImageFormatException("Non-standard metadata table 0x" + validMask.ToString("X2") + ".");
}
if ((validMask & ((ulong)1 << (int)TableKind.MethodDef)) != 0)
{
uint rowCount = reader.ReadUInt32();
var table = new MethodDefEntry[rowCount];
tables[(int)TableKind.MethodDef] = table;
}
if ((validMask & ((ulong)1 << 0x07)) != 0)
{
throw new BadImageFormatException("Non-standard metadata table 0x" + validMask.ToString("X2") + ".");
}
if ((validMask & ((ulong)1 << (int)TableKind.Param)) != 0)
{
uint rowCount = reader.ReadUInt32();
var table = new ParamEntry[rowCount];
tables[(int)TableKind.Param] = table;
}
if ((validMask & ((ulong)1 << (int)TableKind.InterfaceImpl)) != 0)
{
uint rowCount = reader.ReadUInt32();
var table = new InterfaceImplEntry[rowCount];
tables[(int)TableKind.InterfaceImpl] = table;
}
if ((validMask & ((ulong)1 << (int)TableKind.MemberRef)) != 0)
{
uint rowCount = reader.ReadUInt32();
var table = new MemberRefEntry[rowCount];
tables[(int)TableKind.MemberRef] = table;
}
if ((validMask & ((ulong)1 << (int)TableKind.Constant)) != 0)
{
uint rowCount = reader.ReadUInt32();
var table = new ConstantEntry[rowCount];
tables[(int)TableKind.Constant] = table;
}
if ((validMask & ((ulong)1 << (int)TableKind.CustomAttribute)) != 0)
{
uint rowCount = reader.ReadUInt32();
var table = new CustomAttributeEntry[rowCount];
tables[(int)TableKind.CustomAttribute] = table;
}
if ((validMask & ((ulong)1 << (int)TableKind.FieldMarshal)) != 0)
{
uint rowCount = reader.ReadUInt32();
var table = new FieldMarshalEntry[rowCount];
tables[(int)TableKind.FieldMarshal] = table;
}
if ((validMask & ((ulong)1 << (int)TableKind.DeclSecurity)) != 0)
{
uint rowCount = reader.ReadUInt32();
var table = new DeclSecurityEntry[rowCount];
tables[(int)TableKind.DeclSecurity] = table;
}
if ((validMask & ((ulong)1 << (int)TableKind.ClassLayout)) != 0)
{
uint rowCount = reader.ReadUInt32();
var table = new ClassLayoutEntry[rowCount];
tables[(int)TableKind.ClassLayout] = table;
}
if ((validMask & ((ulong)1 << (int)TableKind.FieldLayout)) != 0)
{
uint rowCount = reader.ReadUInt32();
var table = new FieldLayoutEntry[rowCount];
tables[(int)TableKind.FieldLayout] = table;
}
if ((validMask & ((ulong)1 << (int)TableKind.StandAloneSig)) != 0)
{
uint rowCount = reader.ReadUInt32();
var table = new StandAloneSigEntry[rowCount];
tables[(int)TableKind.StandAloneSig] = table;
}
if ((validMask & ((ulong)1 << (int)TableKind.EventMap)) != 0)
{
uint rowCount = reader.ReadUInt32();
var table = new EventMapEntry[rowCount];
tables[(int)TableKind.EventMap] = table;
}
if ((validMask & ((ulong)1 << 0x13)) != 0)
{
throw new BadImageFormatException("Non-standard metadata table 0x" + validMask.ToString("X2") + ".");
}
if ((validMask & ((ulong)1 << (int)TableKind.Event)) != 0)
{
uint rowCount = reader.ReadUInt32();
var table = new EventEntry[rowCount];
tables[(int)TableKind.Event] = table;
}
if ((validMask & ((ulong)1 << (int)TableKind.PropertyMap)) != 0)
{
uint rowCount = reader.ReadUInt32();
var table = new PropertyMapEntry[rowCount];
tables[(int)TableKind.PropertyMap] = table;
}
if ((validMask & ((ulong)1 << 0x16)) != 0)
{
throw new BadImageFormatException("Non-standard metadata table 0x" + validMask.ToString("X2") + ".");
}
if ((validMask & ((ulong)1 << (int)TableKind.Property)) != 0)
{
uint rowCount = reader.ReadUInt32();
var table = new PropertyEntry[rowCount];
tables[(int)TableKind.Property] = table;
}
if ((validMask & ((ulong)1 << (int)TableKind.MethodSemantics)) != 0)
{
uint rowCount = reader.ReadUInt32();
var table = new MethodSemanticsEntry[rowCount];
tables[(int)TableKind.MethodSemantics] = table;
}
if ((validMask & ((ulong)1 << (int)TableKind.MethodImpl)) != 0)
{
uint rowCount = reader.ReadUInt32();
var table = new MethodImplEntry[rowCount];
tables[(int)TableKind.MethodImpl] = table;
}
if ((validMask & ((ulong)1 << (int)TableKind.ModuleRef)) != 0)
{
uint rowCount = reader.ReadUInt32();
var table = new ModuleRefEntry[rowCount];
tables[(int)TableKind.ModuleRef] = table;
}
if ((validMask & ((ulong)1 << (int)TableKind.TypeSpec)) != 0)
{
uint rowCount = reader.ReadUInt32();
var table = new TypeSpecEntry[rowCount];
tables[(int)TableKind.TypeSpec] = table;
}
if ((validMask & ((ulong)1 << (int)TableKind.ImplMap)) != 0)
{
uint rowCount = reader.ReadUInt32();
var table = new ImplMapEntry[rowCount];
tables[(int)TableKind.ImplMap] = table;
}
if ((validMask & ((ulong)1 << (int)TableKind.FieldRVA)) != 0)
{
uint rowCount = reader.ReadUInt32();
var table = new FieldRVAEntry[rowCount];
tables[(int)TableKind.FieldRVA] = table;
}
if ((validMask & ((ulong)1 << 0x1E)) != 0)
{
throw new BadImageFormatException("Non-standard metadata table 0x" + validMask.ToString("X2") + ".");
}
if ((validMask & ((ulong)1 << 0x1F)) != 0)
{
throw new BadImageFormatException("Non-standard metadata table 0x" + validMask.ToString("X2") + ".");
}
if ((validMask & ((ulong)1 << (int)TableKind.Assembly)) != 0)
{
uint rowCount = reader.ReadUInt32();
var table = new AssemblyEntry[rowCount];
tables[(int)TableKind.Assembly] = table;
}
if ((validMask & ((ulong)1 << (int)TableKind.AssemblyProcessor)) != 0)
{
uint rowCount = reader.ReadUInt32();
var table = new AssemblyProcessorEntry[rowCount];
tables[(int)TableKind.AssemblyProcessor] = table;
}
if ((validMask & ((ulong)1 << (int)TableKind.AssemblyOS)) != 0)
{
uint rowCount = reader.ReadUInt32();
var table = new AssemblyOSEntry[rowCount];
tables[(int)TableKind.AssemblyOS] = table;
}
if ((validMask & ((ulong)1 << (int)TableKind.AssemblyRef)) != 0)
{
uint rowCount = reader.ReadUInt32();
var table = new AssemblyRefEntry[rowCount];
tables[(int)TableKind.AssemblyRef] = table;
}
if ((validMask & ((ulong)1 << (int)TableKind.AssemblyRefProcessor)) != 0)
{
uint rowCount = reader.ReadUInt32();
var table = new AssemblyRefProcessorEntry[rowCount];
tables[(int)TableKind.AssemblyRefProcessor] = table;
}
if ((validMask & ((ulong)1 << (int)TableKind.AssemblyRefOS)) != 0)
{
uint rowCount = reader.ReadUInt32();
var table = new AssemblyRefOSEntry[rowCount];
tables[(int)TableKind.AssemblyRefOS] = table;
}
if ((validMask & ((ulong)1 << (int)TableKind.File)) != 0)
{
uint rowCount = reader.ReadUInt32();
var table = new FileEntry[rowCount];
tables[(int)TableKind.File] = table;
}
if ((validMask & ((ulong)1 << (int)TableKind.ExportedType)) != 0)
{
uint rowCount = reader.ReadUInt32();
var table = new ExportedTypeEntry[rowCount];
tables[(int)TableKind.ExportedType] = table;
}
if ((validMask & ((ulong)1 << (int)TableKind.ManifestResource)) != 0)
{
uint rowCount = reader.ReadUInt32();
var table = new ManifestResourceEntry[rowCount];
tables[(int)TableKind.ManifestResource] = table;
}
if ((validMask & ((ulong)1 << (int)TableKind.NestedClass)) != 0)
{
uint rowCount = reader.ReadUInt32();
var table = new NestedClassEntry[rowCount];
tables[(int)TableKind.NestedClass] = table;
}
if ((validMask & ((ulong)1 << (int)TableKind.GenericParam)) != 0)
{
uint rowCount = reader.ReadUInt32();
var table = new GenericParamEntry[rowCount];
tables[(int)TableKind.GenericParam] = table;
}
if ((validMask & ((ulong)1 << (int)TableKind.MethodSpec)) != 0)
{
uint rowCount = reader.ReadUInt32();
var table = new MethodSpecEntry[rowCount];
tables[(int)TableKind.MethodSpec] = table;
}
if ((validMask & ((ulong)1 << (int)TableKind.GenericParamConstraint)) != 0)
{
uint rowCount = reader.ReadUInt32();
var table = new GenericParamConstraintEntry[rowCount];
tables[(int)TableKind.GenericParamConstraint] = table;
}
ulong trailingZeroesMask = ulong.MaxValue << 45;
if ((validMask & trailingZeroesMask) != 0)
{
throw new BadImageFormatException("Non-standard metadata table bits.");
}
this.Tables = tables;
}
public InstructionDecoder(VMConstants constants, BinaryStreamReader reader)
: this(constants, reader, 0)
{
}
/// <summary>
/// Puts the remaining data of the provided input stream into a new data segment.
/// </summary>
/// <param name="reader">The input stream to read from.</param>
/// <returns>The data segment containing the remaining data.</returns>
public static DataSegment FromReader(ref BinaryStreamReader reader)
{
return(FromReader(ref reader, (int)(reader.StartOffset + reader.Length - reader.Offset)));
}
/// <summary>
/// Reads a single safe array marshal descriptor from the provided input stream.
/// </summary>
/// <param name="parentModule">The module defining the descriptor.</param>
/// <param name="reader">The input stream.</param>
/// <returns>The descriptor.</returns>
public new static SafeArrayMarshalDescriptor FromReader(ModuleDefinition parentModule, ref BinaryStreamReader reader)
{
if (!reader.TryReadCompressedUInt32(out uint type))
{
return(new SafeArrayMarshalDescriptor(SafeArrayVariantType.NotSet));
}
var variantType = (SafeArrayVariantType)type & SafeArrayVariantType.TypeMask;
var flags = (SafeArrayTypeFlags)type & ~SafeArrayTypeFlags.Mask;
var result = new SafeArrayMarshalDescriptor(variantType, flags);
if (reader.CanRead(1))
{
string typeName = reader.ReadSerString();
if (typeName != null)
{
result.UserDefinedSubType = TypeNameParser.Parse(parentModule, typeName);
}
}
return(result);
}
/// <summary>
/// Reads a raw method body from the given binary input stream using the tiny method body format.
/// </summary>
/// <param name="errorListener">The object responsible for recording parser errors.</param>
/// <param name="reader">The binary input stream to read from.</param>
/// <returns>The raw method body.</returns>
/// <exception cref="FormatException">Occurs when the method header indicates an method body that is not in the
/// tiny format.</exception>
public new static CilRawTinyMethodBody FromReader(IErrorListener errorListener, ref BinaryStreamReader reader)
{
ulong fileOffset = reader.Offset;
uint rva = reader.Rva;
var flag = (CilMethodBodyAttributes)reader.ReadByte();
if ((flag & CilMethodBodyAttributes.Tiny) != CilMethodBodyAttributes.Tiny)
{
errorListener.BadImage("Invalid tiny CIL method body header.");
return(null);
}
int codeSize = (byte)flag >> 2;
var code = new byte[codeSize];
reader.ReadBytes(code, 0, codeSize);
var methodBody = new CilRawTinyMethodBody(code);
methodBody.UpdateOffsets(fileOffset, rva);
return(methodBody);
}
internal void ReadDetails(BinaryStreamReader reader)
{
this.GenParamCount = reader.ReadCompressedUInt32() ?? 0;
}
void PopulateSimpleSig(BinaryStreamReader signatureBlobReader, CallingConventions callingConvention)
{
PopulateInstanceAndExplicit(callingConvention);
throw new NotImplementedException();
}
/// <summary>
/// Reads a single edit-and-continue remap row from an input stream.
/// </summary>
/// <param name="reader">The input stream.</param>
/// <param name="layout">The layout of the edit-and-continue remap table.</param>
/// <returns>The row.</returns>
public static EncMapRow FromReader(ref BinaryStreamReader reader, TableLayout layout)
{
return(new EncMapRow(reader.ReadUInt32()));
}
public void Read(BinaryStreamReader reader)
{
this.Offset = reader.ReadUInt32();
this.Size = reader.ReadUInt32();
this.Name = ReadAlignedNameString(reader);
}
/// <summary>
/// Reads a single assembly reference processor row from an input stream.
/// </summary>
/// <param name="reader">The input stream.</param>
/// <param name="layout">The layout of the assembly reference processor table.</param>
/// <returns>The row.</returns>
public static AssemblyRefProcessorRow FromReader(ref BinaryStreamReader reader, TableLayout layout)
{
return(new AssemblyRefProcessorRow(
reader.ReadUInt32(),
reader.ReadIndex((IndexSize)layout.Columns[1].Size)));
}
public InstructionDecoder(VMConstants constants, BinaryStreamReader reader, uint key)
{
_constants = constants;
_reader = reader;
CurrentKey = key;
}
/// <summary>
/// Reads a single data blob signature from the provided input stream.
/// </summary>
/// <param name="reader">The input stream.</param>
/// <returns>The blob signature.</returns>
public static DataBlobSignature FromReader(ref BinaryStreamReader reader)
{
return(new DataBlobSignature(reader.ReadToEnd()));
}
/// <summary>
/// Reads a single method specification row from an input stream.
/// </summary>
/// <param name="reader">The input stream.</param>
/// <param name="layout">The layout of the method specification table.</param>
/// <returns>The row.</returns>
public static MethodSpecificationRow FromReader(ref BinaryStreamReader reader, TableLayout layout)
{
return(new MethodSpecificationRow(
reader.ReadIndex((IndexSize)layout.Columns[0].Size),
reader.ReadIndex((IndexSize)layout.Columns[1].Size)));
}
public ISymbolReader GetSymbolReader(ModuleDefinition module, Stream symbolStream)
{
if (module.Image.HasDebugTables())
{
return(null);
}
if (module.HasDebugHeader)
{
var header = module.GetDebugHeader();
var entry = header.GetEmbeddedPortablePdbEntry();
if (entry != null)
{
return(new EmbeddedPortablePdbReaderProvider().GetSymbolReader(module, ""));
}
}
Mixin.CheckStream(symbolStream);
Mixin.CheckReadSeek(symbolStream);
var position = symbolStream.Position;
const int portablePdbHeader = 0x424a5342;
var reader = new BinaryStreamReader(symbolStream);
var intHeader = reader.ReadInt32();
symbolStream.Position = position;
if (intHeader == portablePdbHeader)
{
return(new PortablePdbReaderProvider().GetSymbolReader(module, symbolStream));
}
const string nativePdbHeader = "Microsoft C/C++ MSF 7.00";
var bytesHeader = reader.ReadBytes(nativePdbHeader.Length);
symbolStream.Position = position;
var isNativePdb = true;
for (var i = 0; i < bytesHeader.Length; i++)
{
if (bytesHeader [i] != (byte)nativePdbHeader [i])
{
isNativePdb = false;
break;
}
}
if (isNativePdb)
{
try {
return(SymbolProvider.GetReaderProvider(SymbolKind.NativePdb).GetSymbolReader(module, symbolStream));
} catch (Exception) {
// We might not include support for native pdbs.
}
}
const long mdbHeader = 0x45e82623fd7fa614;
var longHeader = reader.ReadInt64();
symbolStream.Position = position;
if (longHeader == mdbHeader)
{
try {
return(SymbolProvider.GetReaderProvider(SymbolKind.Mdb).GetSymbolReader(module, symbolStream));
} catch (Exception) {
// We might not include support for mdbs.
}
}
if (throw_if_no_symbol)
{
throw new SymbolsNotFoundException(string.Format("No symbols found in stream"));
}
return(null);
}
/// <summary>
/// Reads a single field RVA row from an input stream.
/// </summary>
/// <param name="context">The reader context.</param>
/// <param name="reader">The input stream.</param>
/// <param name="layout">The layout of the field RVA table.</param>
/// <returns>The row.</returns>
public static FieldRvaRow FromReader(PEReaderContext context, ref BinaryStreamReader reader, TableLayout layout)
{
return(new FieldRvaRow(
context.File.GetReferenceToRva(reader.ReadUInt32()),
reader.ReadIndex((IndexSize)layout.Columns[1].Size)));
}
/// <summary>
/// Reads a single module import entry from an input stream.
/// </summary>
/// <param name="context">The reader context.</param>
/// <param name="reader">The input stream to read from.</param>
/// <returns></returns>
public static IImportedModule FromReader(PEReaderContext context, ref BinaryStreamReader reader)
{
var entry = new SerializedImportedModule(context, ref reader);
return(entry.IsEmpty ? null : entry);
}
/// <summary>
/// Reads a single assembly processor row from an input stream.
/// </summary>
/// <param name="reader">The input stream.</param>
/// <param name="layout">The layout of the assembly processor table.</param>
/// <returns>The row.</returns>
public static AssemblyProcessorRow FromReader(ref BinaryStreamReader reader, TableLayout layout)
{
return(new AssemblyProcessorRow(reader.ReadUInt32()));
}
