private void UnpackCallData()
{
this.callResult = MarshalingUtils.GetUInt64FromBigEndianBytes(this.callData, 0);
this.ReturnValue = MarshalingUtils.GetUInt64FromBigEndianBytes(this.callData, MarshalingUtils.SizeOf(typeof(ulong)));
if (this.Options.PostMethodCall != XDRPCPostMethodCall.None)
{
this.PostMethodCallReturnValue = MarshalingUtils.GetUInt64FromBigEndianBytes(this.callData, 2 * MarshalingUtils.SizeOf(typeof(ulong)));
}
for (int index1 = 0; index1 < this.IntegerArguments.Length; ++index1)
{
int index2 = index1 + 2;
if (this.bufferData[index2].BufferSize > 0)
{
byte[] data = new byte[this.bufferData[index2].BufferSize];
Array.Copy((Array)this.callData, this.bufferData[index2].BufferOffset, (Array)data, 0, data.Length);
this.IntegerArguments[index1].UnpackBufferData(data);
}
}
for (int index = 0; index < this.IntegerArguments.Length; ++index)
{
if (this.referenceData[index].BufferSize > 0)
{
byte[] data = new byte[this.referenceData[index].BufferSize];
Array.Copy((Array)this.callData, this.referenceData[index].BufferOffset, (Array)data, 0, data.Length);
this.IntegerArguments[index].UnpackReferenceData(data);
}
}
}
private void WaitForCallCompletion(TimeSpan timeout)
{
if (this.NoDevkit)
{
return;
}
byte[] numArray = new byte[XDRPCExecutionState.ArgumentSize];
DateTime now1 = DateTime.Now;
ulong fromBigEndianBytes;
do
{
uint BytesReceived;
this.Console.ReceiveBinary(this.connectionId, numArray, (uint)numArray.Length, out BytesReceived);
if ((long)BytesReceived != (long)XDRPCExecutionState.ArgumentSize)
{
throw new XDRPCInvalidResponseException("Unexpected binary chunk size received from console");
}
fromBigEndianBytes = MarshalingUtils.GetUInt64FromBigEndianBytes(numArray, 0);
if (fromBigEndianBytes == 997UL)
{
DateTime now2 = DateTime.Now;
if (now2.Subtract(now1) > timeout)
{
throw new XDRPCTimeoutException("Timed out while waiting for function to execute, try setting a longer executionTimeoutPeriod in XDRPCExecutionOptions if longer timeout period is needed", now1, now2, timeout);
}
}
}while (fromBigEndianBytes == 997UL);
if (fromBigEndianBytes != 0UL)
{
throw new XDRPCInvalidResponseException(string.Format("Received invalid status from console: {0}", (object)fromBigEndianBytes));
}
}
internal static byte[] GetBigEndianBytes(ulong v)
{
byte[] bytes = BitConverter.GetBytes(v);
if (BitConverter.IsLittleEndian)
{
MarshalingUtils.ReverseBytes(bytes);
}
return(bytes);
}
public void UnpackBufferData(byte[] data)
{
if (this.PassBy != ArgumentType.ByRef && this.PassBy != ArgumentType.Out)
{
return;
}
if (BitConverter.IsLittleEndian)
{
MarshalingUtils.ReverseBytes(data);
}
this.Value = (T)(XDRPCArgumentInfo <T> .GetValue(data) ?? (object)default(T));
}
public void UnpackBufferData(byte[] data)
{
if (this.PassBy != ArgumentType.ByRef && this.PassBy != ArgumentType.Out)
{
return;
}
if (BitConverter.IsLittleEndian && this.Encoding == Encoding.Unicode)
{
MarshalingUtils.ReverseBytes(data, 2);
}
this.Value = this.Encoding.GetString(data, 0, this.GetReturnedStringLength(data));
}
public int GetRequiredBufferSize()
{
switch (this.PassBy)
{
case ArgumentType.ByRef:
case ArgumentType.Out:
return(MarshalingUtils.SizeOf(typeof(T)));
default:
return(0);
}
}
public byte[] PackBufferData()
{
if (this.PassBy != ArgumentType.ByRef && this.PassBy != ArgumentType.Out)
{
return((byte[])null);
}
byte[] bytes = XDRPCArgumentInfo <T> .GetBytes((object)this.Value);
if (BitConverter.IsLittleEndian)
{
MarshalingUtils.ReverseBytes(bytes);
}
return(bytes);
}
private void FillPointerBufferData(
out XDRPCStructArgumentInfo <T> .StructBufferData data,
List <XDRPCStructArgumentInfo <T> .StructBufferData> bufferDataList,
int packAttribute)
{
data = new XDRPCStructArgumentInfo <T> .StructBufferData();
data.BufferSize = MarshalingUtils.SizeOf(typeof(uint));
int packAlignment = this.CalculatePackAlignment(packAttribute, data.BufferSize);
data.BufferOffset = this.GetCurrentOffset(bufferDataList, packAlignment);
data.ReferenceIndex = this._referenceBufferDataList.Count;
data.Info = (XDRPCArgumentInfo)null;
}
private int GetArrayElementCount(Type type)
{
int num1 = 0;
if (type.IsArray)
{
int num2 = MarshalingUtils.SizeOf(type.GetElementType());
if (num2 != 0)
{
num1 = this.BufferSize / num2;
}
}
return(num1);
}
public byte[] PackBufferData()
{
byte[] buffer = (byte[])null;
if (this.MaxArrayLength > 0)
{
int offset = 0;
buffer = new byte[this._elementSize * this.MaxArrayLength];
for (int index = 0; index < this.MaxArrayLength; ++index)
{
MarshalingUtils.PushBufferData(this._arrayElementData[index].Info.PackBufferData(), buffer, ref offset);
}
}
return(buffer);
}
public ulong GetArgumentValue(ulong bufferAddress)
{
switch (this.PassBy)
{
case ArgumentType.ByValue:
return(MarshalingUtils.ConvertToUInt64((object)this.Value));
case ArgumentType.ByRef:
case ArgumentType.Out:
return(bufferAddress);
default:
return(0);
}
}
internal static int SizeOf(Type type)
{
int num = 0;
if (MarshalingUtils.ValueTypeSizeMap.ContainsKey(type))
{
num = MarshalingUtils.ValueTypeSizeMap[type];
}
else if (XDRPCMarshaler.IsValidStructType(type))
{
MarshalingUtils.GetStructSizes(type);
num = MarshalingUtils.ValueTypeSizeMap[type];
}
return(num);
}
internal static ulong GetUInt64FromBigEndianBytes(byte[] buffer, int start)
{
int length = MarshalingUtils.SizeOf(typeof(ulong));
if (start + length > buffer.Length)
{
throw new XDRPCException("Error de-serializing UInt64 from buffer");
}
byte[] buffer1 = new byte[length];
Array.Copy((Array)buffer, start, (Array)buffer1, 0, length);
if (BitConverter.IsLittleEndian)
{
MarshalingUtils.ReverseBytes(buffer1);
}
return(BitConverter.ToUInt64(buffer1, 0));
}
public byte[] PackReferenceData()
{
byte[] buffer = (byte[])null;
if (this._referenceSize > 0)
{
buffer = new byte[this._referenceSize];
for (int index = 0; index < this.MaxArrayLength; ++index)
{
byte[] numArray = this._arrayElementData[index].Info.PackReferenceData();
if (numArray != null)
{
int referenceOffset = this._arrayElementData[index].ReferenceOffset;
MarshalingUtils.PushBufferData(numArray, buffer, ref referenceOffset);
}
}
}
return(buffer);
}
internal static int AlignmentOf(Type type)
{
int num = 0;
if (MarshalingUtils.StructPrimitiveSizeMap.ContainsKey(type))
{
num = MarshalingUtils.StructPrimitiveSizeMap[type];
}
else if (XDRPCMarshaler.IsValidStructType(type))
{
MarshalingUtils.GetStructSizes(type);
num = MarshalingUtils.StructPrimitiveSizeMap[type];
}
else if (type.IsPrimitive)
{
num = MarshalingUtils.SizeOf(type);
}
return(num);
}
public byte[] PackBufferData()
{
byte[] buffer = (byte[])null;
if (this._maxBufferSize > 0)
{
if (this.Value != null)
{
buffer = this.Encoding.GetBytes(this.Value);
if (BitConverter.IsLittleEndian && this.Encoding == Encoding.Unicode)
{
MarshalingUtils.ReverseBytes(buffer, 2);
}
}
else
{
buffer = new byte[this._maxBufferSize];
}
}
return(buffer);
}
public XDRPCArrayArgumentInfo(T v, ArgumentType t, int maxArrayLength)
{
Type t1 = typeof(T);
if (!t1.IsArray)
{
throw new XDRPCInvalidTypeException(t1, "Array type must be provided for XDRPCArrayArgumentInfo.");
}
if (!XDRPCMarshaler.IsValidArrayType(t1))
{
throw new XDRPCInvalidTypeException(t1, string.Format("Array type {0} is not supported by XDRPC.", (object)t1.Name));
}
this.Value = v;
this._arrayLength = (object)this.Value == null ? 0 : ((object)this.Value as Array).Length;
if (t == ArgumentType.Out && maxArrayLength <= 0)
{
throw new XDRPCException("The max array length must be specified for an Out type array.");
}
this.PassBy = t;
this._elementSize = MarshalingUtils.SizeOf(t1.GetElementType());
this.MaxArrayLength = this.PassBy != ArgumentType.ByRef ? (this.PassBy != ArgumentType.Out ? this._arrayLength : maxArrayLength) : Math.Max(this._arrayLength, maxArrayLength);
this.ConstructArgumentInfoArray();
}
internal static void PushCallData(ulong value, byte[] buffer, ref int offset)
{
byte[] bigEndianBytes = MarshalingUtils.GetBigEndianBytes(value);
Array.Copy((Array)bigEndianBytes, 0, (Array)buffer, offset, bigEndianBytes.Length);
offset += bigEndianBytes.Length;
}
private int PopulateStructBufferRecursive(
Type structType,
object structToMarshal,
List <XDRPCStructArgumentInfo <T> .StructBufferData> bufferDataList,
int depth,
string unionWritingField)
{
if (depth > 3)
{
throw new XDRPCInvalidTypeException(structType, string.Format("Struct of type {0} has too many nested structs (more than {1} deep) which is not supported.", (object)typeof(T).Name, (object)3));
}
if (!((IEnumerable <Type>)XDRPCStructArgumentInfo <T> .builtInStructAllowlist).Contains <Type>(structType))
{
object[] customAttributes = structType.GetCustomAttributes(typeof(XDRPCStructAttribute), false);
if (customAttributes == null || customAttributes.Length == 0)
{
throw new XDRPCInvalidTypeException(structType, string.Format("Struct of type {0} doesn't have the XDRPCStruct attribute.", (object)structType.Name));
}
}
FieldInfo[] fields = structType.GetFields(BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
int packAttribute = structType.StructLayoutAttribute.Value == LayoutKind.Sequential ? 8 : structType.StructLayoutAttribute.Pack;
int num1 = 0;
int num2 = 0;
bool flag1 = false;
foreach (FieldInfo fieldInfo in fields)
{
Type fieldType = fieldInfo.FieldType;
MarshalAsAttribute marshalAsAttribute = (MarshalAsAttribute)null;
XDRPCStructArgumentInfo <T> .StructBufferData data = new XDRPCStructArgumentInfo <T> .StructBufferData();
object[] customAttributes1 = fieldInfo.GetCustomAttributes(typeof(MarshalAsAttribute), false);
if (customAttributes1 != null && customAttributes1.Length != 0)
{
marshalAsAttribute = (MarshalAsAttribute)customAttributes1[0];
}
if (fieldType == typeof(string) || fieldType.IsArray)
{
if (marshalAsAttribute == null)
{
throw new XDRPCInvalidTypeException(fieldType, string.Format("Field {0} of type {1} in struct type {2} doesn't have the required MarshalAsAttribute.", (object)fieldInfo.Name, (object)fieldType.Name, (object)structType.Name));
}
if (marshalAsAttribute.Value != UnmanagedType.ByValArray && marshalAsAttribute.Value != UnmanagedType.LPArray)
{
throw new XDRPCInvalidTypeException(fieldType, string.Format("Field {0} of type {1} in struct type {2} with its MarshalAs attribute not using the required UnmanagedType.ByValArray or UnmanagedType.LPArray.", (object)fieldInfo.Name, (object)fieldType.Name, (object)structType.Name));
}
bool flag2 = marshalAsAttribute.Value == UnmanagedType.LPArray;
int size = marshalAsAttribute.SizeConst;
int num3;
int cMax;
if (fieldType.IsArray)
{
if (fieldType.GetArrayRank() > 1)
{
throw new XDRPCInvalidTypeException(fieldType, string.Format("Field {0} in struct type {1} is a multidimensional array which is not supported by XDRPCStructArgumentInfo.", (object)fieldInfo.Name, (object)structType.Name));
}
Type elementType = fieldType.GetElementType();
if (!XDRPCMarshaler.IsValidValueType(elementType))
{
throw new XDRPCInvalidTypeException(fieldType, string.Format("Field {0} in struct type {1} is an array of type {2} which is not supported by XDRPCStructArgumentInfo.", (object)fieldInfo.Name, (object)structType.Name, (object)elementType.Name));
}
int num4 = MarshalingUtils.SizeOf(elementType);
if (num4 == 0)
{
throw new XDRPCInvalidTypeException(fieldType, string.Format("Field {0} in struct type {1} is an array of type {2} which is not supported by XDRPCStructArgumentInfo.", (object)fieldInfo.Name, (object)structType.Name, (object)elementType.Name));
}
num3 = num4;
if (XDRPCMarshaler.IsValidStructType(elementType))
{
num3 = MarshalingUtils.AlignmentOf(elementType);
}
Array array = (Array)fieldInfo.GetValue(structToMarshal);
if (flag2)
{
if (array != null && size < array.Length)
{
size = array.Length;
}
}
else if (size == 0)
{
throw new XDRPCInvalidTypeException(fieldType, string.Format("Field {0} in struct type {1} is an array being passed by value that doesn't have the required SizeConst part of the attribute defined.", (object)fieldInfo.Name, (object)structType.Name));
}
cMax = num4 * size;
data.Info = XDRPCMarshaler.GenerateArgumentInfo(fieldType, (object)array, ArgumentType.ByRef, size);
}
else
{
if (!XDRPCStructArgumentInfo <T> .EncodingMap.ContainsKey(marshalAsAttribute.ArraySubType))
{
throw new XDRPCInvalidTypeException(fieldType, string.Format("Field {0} in struct type {1} is a string with a MarshalAs attribute without a string UnmanagedType for its ArraySubType.", (object)fieldInfo.Name, (object)structType.Name));
}
Encoding encoding = XDRPCStructArgumentInfo <T> .EncodingMap[marshalAsAttribute.ArraySubType];
int num4 = encoding == Encoding.Unicode ? 2 : 1;
num3 = num4;
cMax = size * num4;
string v = (string)fieldInfo.GetValue(structToMarshal);
if (flag2)
{
int num5 = 0;
if (v != null)
{
num5 = encoding.GetByteCount(v + "\0");
}
if (cMax < num5)
{
cMax = num5;
}
}
else if (cMax == 0)
{
throw new XDRPCInvalidTypeException(fieldType, string.Format("Field {0} in struct type {1} is a string being passed by value that doesn't have the required SizeConst part of the attribute defined.", (object)fieldInfo.Name, (object)structType.Name));
}
data.Info = (XDRPCArgumentInfo) new XDRPCStringArgumentInfo(v, encoding, ArgumentType.ByRef, cMax, CountType.Byte);
}
int requiredReferenceSize = data.Info.GetRequiredReferenceSize();
if (requiredReferenceSize > 0)
{
XDRPCStructArgumentInfo <T> .StructBufferData structBufferData = new XDRPCStructArgumentInfo <T> .StructBufferData();
structBufferData.BufferOffset = this.GetCurrentOffset(this._referenceBufferDataList, 8);
structBufferData.BufferSize = requiredReferenceSize;
structBufferData.ReferenceIndex = -1;
structBufferData.Info = (XDRPCArgumentInfo)null;
data.ReferenceIndex = this._referenceBufferDataList.Count;
this._referenceBufferDataList.Add(structBufferData);
}
else
{
data.ReferenceIndex = -1;
}
data.BufferSize = cMax;
if (flag2)
{
if (cMax > 0)
{
XDRPCStructArgumentInfo <T> .StructBufferData structBufferData = data;
structBufferData.BufferOffset = this.GetCurrentOffset(this._referenceBufferDataList, num3);
this.FillPointerBufferData(out data, bufferDataList, packAttribute);
this._referenceBufferDataList.Add(structBufferData);
}
else
{
this.FillPointerBufferData(out data, bufferDataList, packAttribute);
data.Info = (XDRPCArgumentInfo) new XDRPCArgumentInfo <uint>(0U, ArgumentType.ByRef);
data.ReferenceIndex = -1;
}
num3 = data.BufferSize;
}
else
{
int packAlignment = this.CalculatePackAlignment(packAttribute, num3);
data.BufferOffset = this.GetCurrentOffset(bufferDataList, packAlignment);
}
num1 = Math.Max(num1, num3);
num2 = Math.Max(num2, data.BufferSize);
if (this.FillUnionBufferData(ref data, fieldInfo, unionWritingField))
{
flag1 = true;
}
bufferDataList.Add(data);
}
else if (fieldType.IsPrimitive)
{
int num3 = MarshalingUtils.SizeOf(fieldType);
if (num3 == 0)
{
throw new XDRPCInvalidTypeException(fieldType, string.Format("Field {0} in struct type {1} is primitive type {2} which is not supported by XDRPCStructArgumentInfo.", (object)fieldInfo.Name, (object)structType.Name, (object)fieldType.Name));
}
data.Info = XDRPCMarshaler.GenerateArgumentInfo(fieldType, fieldInfo.GetValue(structToMarshal), ArgumentType.ByRef);
if (marshalAsAttribute != null && marshalAsAttribute.Value == UnmanagedType.LPStruct)
{
XDRPCStructArgumentInfo <T> .StructBufferData structBufferData = new XDRPCStructArgumentInfo <T> .StructBufferData();
structBufferData.Info = data.Info;
structBufferData.BufferOffset = this.GetCurrentOffset(this._referenceBufferDataList, num3);
structBufferData.BufferSize = num3;
structBufferData.ReferenceIndex = -1;
this.FillPointerBufferData(out data, bufferDataList, packAttribute);
this._referenceBufferDataList.Add(structBufferData);
}
else
{
int packAlignment = this.CalculatePackAlignment(packAttribute, num3);
data.BufferOffset = this.GetCurrentOffset(bufferDataList, packAlignment);
data.BufferSize = num3;
data.ReferenceIndex = -1;
}
num1 = Math.Max(num1, data.BufferSize);
num2 = Math.Max(num2, data.BufferSize);
if (this.FillUnionBufferData(ref data, fieldInfo, unionWritingField))
{
flag1 = true;
}
bufferDataList.Add(data);
}
else
{
if (!fieldType.IsValueType)
{
throw new XDRPCInvalidTypeException(fieldType, string.Format("Type {0} found in struct type {1} is not supported by XDRPCStructArgumentInfo.", (object)fieldType.Name, (object)structType.Name));
}
List <XDRPCStructArgumentInfo <T> .StructBufferData> bufferDataList1 = new List <XDRPCStructArgumentInfo <T> .StructBufferData>();
string empty = string.Empty;
object[] customAttributes2 = fieldInfo.GetCustomAttributes(typeof(XDRPCUnionAttribute), false);
if (customAttributes2 != null && customAttributes2.Length != 0)
{
empty = ((XDRPCUnionAttribute)customAttributes2[0]).Value;
}
int num3 = this.PopulateStructBufferRecursive(fieldType, fieldInfo.GetValue(structToMarshal), bufferDataList1, depth + 1, empty);
if (marshalAsAttribute != null && marshalAsAttribute.Value == UnmanagedType.LPStruct)
{
this.FillPointerBufferData(out data, bufferDataList, packAttribute);
if (this.FillUnionBufferData(ref data, fieldInfo, unionWritingField))
{
flag1 = true;
}
bufferDataList.Add(data);
int currentOffset = this.GetCurrentOffset(this._referenceBufferDataList, 8);
for (int index = 0; index < bufferDataList1.Count; ++index)
{
XDRPCStructArgumentInfo <T> .StructBufferData structBufferData = bufferDataList1[index];
structBufferData.BufferOffset += currentOffset;
if (structBufferData.NextOffset != 0)
{
structBufferData.NextOffset += currentOffset;
}
this._referenceBufferDataList.Add(structBufferData);
}
num1 = data.BufferSize;
}
else
{
data.BufferOffset = this.GetCurrentOffset(bufferDataList, this.CalculatePackAlignment(packAttribute, num3));
if (this.FillUnionBufferData(ref data, fieldInfo, unionWritingField))
{
flag1 = true;
}
for (int index = 0; index < bufferDataList1.Count; ++index)
{
XDRPCStructArgumentInfo <T> .StructBufferData structBufferData = bufferDataList1[index];
structBufferData.BufferOffset += data.BufferOffset;
if (structBufferData.NextOffset != 0)
{
data.BufferSize = structBufferData.NextOffset;
structBufferData.NextOffset += data.BufferOffset;
}
if (data.Ignore)
{
structBufferData.Ignore = true;
}
bufferDataList.Add(structBufferData);
}
}
num1 = Math.Max(num1, num3);
num2 = Math.Max(num2, data.BufferSize);
}
}
if (!string.IsNullOrEmpty(unionWritingField))
{
if (!flag1)
{
throw new XDRPCInvalidTypeException(structType, string.Format("Struct of type {0} has the XDRPCUnion attribute with the non-existant field {1} specified, please provide a correct field name.", (object)structType.Name, (object)unionWritingField));
}
this.SetNextOffset(bufferDataList, num2);
}
int packAlignment1 = this.CalculatePackAlignment(packAttribute, num1);
this.CalculateNextOffset(bufferDataList, packAlignment1);
return(packAlignment1);
}
private void CreateArgumentBufferData()
{
int offset = 0;
int num = 2;
this.callData = new byte[this.totalBufferSize];
MarshalingUtils.PushCallData(0UL, this.callData, ref offset);
MarshalingUtils.PushCallData(0UL, this.callData, ref offset);
MarshalingUtils.PushCallData((ulong)this.Options.PostMethodCall, this.callData, ref offset);
MarshalingUtils.PushCallData((ulong)this.callFlags, this.callData, ref offset);
MarshalingUtils.PushCallData((ulong)this.totalArgumentCount, this.callData, ref offset);
MarshalingUtils.PushCallData((ulong)this.FloatingPointArguments.Length, this.callData, ref offset);
for (int index1 = 0; index1 < this.IntegerArguments.Length + num; ++index1)
{
ulong bufferAddress1 = (ulong)this.bufferBaseAddress + (ulong)this.bufferData[index1].BufferOffset;
if (index1 < num)
{
MarshalingUtils.PushCallData(this.Options.GetArgumentValue(index1, bufferAddress1), this.callData, ref offset);
}
else
{
int index2 = index1 - num;
ulong bufferAddress2 = (ulong)this.bufferBaseAddress + (ulong)this.referenceData[index2].BufferOffset;
this.IntegerArguments[index2].SetReferenceAddress(bufferAddress2);
if (this.IntegerArguments[index2].GetArgumentCount() == 1)
{
MarshalingUtils.PushCallData(this.IntegerArguments[index2].GetArgumentValue(bufferAddress1), this.callData, ref offset);
}
else
{
foreach (ulong argumentValue in this.IntegerArguments[index2].GetArgumentValues(bufferAddress1))
{
MarshalingUtils.PushCallData(argumentValue, this.callData, ref offset);
}
}
}
}
for (int index = 0; index < this.FloatingPointArguments.Length; ++index)
{
ulong bufferAddress = (ulong)this.bufferBaseAddress + (ulong)this.bufferData[index].BufferOffset;
MarshalingUtils.PushCallData(this.FloatingPointArguments[index].GetArgumentValue(bufferAddress), this.callData, ref offset);
}
for (int index = 0; index < this.IntegerArguments.Length + num; ++index)
{
if (this.bufferData[index].BufferSize > 0)
{
byte[] numArray = index >= num ? this.IntegerArguments[index - num].PackBufferData() : this.Options.PackBufferData(index);
if (numArray != null)
{
offset = this.bufferData[index].BufferOffset;
MarshalingUtils.PushBufferData(numArray, this.callData, ref offset);
}
}
}
for (int index = 0; index < this.IntegerArguments.Length; ++index)
{
if (this.referenceData[index].BufferSize > 0)
{
byte[] numArray = this.IntegerArguments[index].PackReferenceData();
if (numArray != null)
{
offset = this.referenceData[index].BufferOffset;
MarshalingUtils.PushBufferData(numArray, this.callData, ref offset);
}
}
}
}
