Exemplo n.º 1
0
 private void PopulateReferencePointers(
     List <XDRPCStructArgumentInfo <T> .StructBufferData> bufferDataList,
     ulong bufferAddress)
 {
     for (int index = 0; index < bufferDataList.Count; ++index)
     {
         XDRPCStructArgumentInfo <T> .StructBufferData bufferData = bufferDataList[index];
         if (bufferData.Info == null)
         {
             if (bufferData.ReferenceIndex != -1)
             {
                 uint v = (uint)((ulong)this._referenceBufferDataList[bufferData.ReferenceIndex].BufferOffset + bufferAddress);
                 bufferData.Info       = (XDRPCArgumentInfo) new XDRPCArgumentInfo <uint>(v, ArgumentType.ByRef);
                 bufferDataList[index] = bufferData;
             }
         }
         else if (bufferData.Info.GetRequiredReferenceSize() > 0)
         {
             XDRPCStructArgumentInfo <T> .StructBufferData referenceBufferData = this._referenceBufferDataList[bufferData.ReferenceIndex];
             ulong bufferAddress1 = (ulong)referenceBufferData.BufferOffset + bufferAddress;
             bufferData.Info.SetReferenceAddress(bufferAddress1);
             referenceBufferData.Info = (XDRPCArgumentInfo) new XDRPCArrayArgumentInfo <byte[]>(bufferData.Info.PackReferenceData(), ArgumentType.ByRef);
             this._referenceBufferDataList[bufferData.ReferenceIndex] = referenceBufferData;
         }
     }
 }
Exemplo n.º 2
0
        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;
        }
Exemplo n.º 3
0
        private void SetNextOffset(
            List <XDRPCStructArgumentInfo <T> .StructBufferData> bufferDataList,
            int nextOffset)
        {
            if (bufferDataList.Count <= 0)
            {
                return;
            }
            int index = bufferDataList.Count - 1;

            XDRPCStructArgumentInfo <T> .StructBufferData bufferData = bufferDataList[index];
            bufferData.NextOffset = nextOffset;
            bufferDataList[index] = bufferData;
        }
Exemplo n.º 4
0
 private object UnpackValuesRecursive(
     Type structType,
     object structToMarshal,
     ref List <XDRPCStructArgumentInfo <T> .StructBufferData> .Enumerator bufferEnum)
 {
     foreach (FieldInfo field in structType.GetFields(BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic))
     {
         Type fieldType = field.FieldType;
         XDRPCStructArgumentInfo <T> .StructBufferData structBufferData = bufferEnum.Current;
         if (fieldType == typeof(string) || fieldType.IsArray || fieldType.IsPrimitive)
         {
             if (structBufferData.ReferenceIndex != -1)
             {
                 if (structBufferData.Info.GetRequiredReferenceSize() == 0)
                 {
                     structBufferData = this._referenceBufferDataList[structBufferData.ReferenceIndex];
                 }
                 if (structBufferData.Info.GetRequiredReferenceSize() > 0)
                 {
                     XDRPCArrayArgumentInfo <byte[]> info = (XDRPCArrayArgumentInfo <byte[]>) this._referenceBufferDataList[structBufferData.ReferenceIndex].Info;
                     structBufferData.Info.UnpackReferenceData(info.Value);
                 }
             }
             object obj = this.ValidateArgInfoNullValue(fieldType, structBufferData.Info);
             field.SetValue(structToMarshal, obj);
             bufferEnum.MoveNext();
         }
         else if (fieldType.IsValueType)
         {
             object obj;
             if (structBufferData.ReferenceIndex != -1)
             {
                 List <XDRPCStructArgumentInfo <T> .StructBufferData> .Enumerator enumerator = this._referenceBufferDataList.GetEnumerator();
                 do
                 {
                     enumerator.MoveNext();
                 }while (enumerator.Current.Info != this._referenceBufferDataList[structBufferData.ReferenceIndex].Info);
                 obj = this.UnpackValuesRecursive(fieldType, field.GetValue(structToMarshal), ref enumerator);
                 bufferEnum.MoveNext();
             }
             else
             {
                 obj = this.UnpackValuesRecursive(fieldType, field.GetValue(structToMarshal), ref bufferEnum);
             }
             field.SetValue(structToMarshal, obj);
         }
     }
     return(structToMarshal);
 }
Exemplo n.º 5
0
        private int GetCurrentOffset(
            List <XDRPCStructArgumentInfo <T> .StructBufferData> bufferDataList,
            int packAlignment)
        {
            int num = 0;

            if (bufferDataList.Count > 0)
            {
                XDRPCStructArgumentInfo <T> .StructBufferData bufferData = bufferDataList[bufferDataList.Count - 1];
                int currOffset = bufferData.NextOffset;
                if (currOffset == 0)
                {
                    currOffset = bufferData.BufferOffset + bufferData.BufferSize;
                }
                num = this.AlignOffset(currOffset, packAlignment);
            }
            return(num);
        }
Exemplo n.º 6
0
        public static T ExecuteRPC <T>(
            this IXboxConsole console,
            XDRPCExecutionOptions options,
            out ulong postMethodCallReturn,
            params XDRPCArgumentInfo[] args)
            where T : struct
        {
            Type t = typeof(T);

            postMethodCallReturn = 0UL;
            if (!XDRPCMarshaler.IsValidReturnType(t))
            {
                if (!t.IsValueType)
                {
                    throw new XDRPCInvalidReturnTypeException(t);
                }
                XDRPCStructArgumentInfo <T> structArgumentInfo     = new XDRPCStructArgumentInfo <T>(default(T), ArgumentType.Out);
                XDRPCArgumentInfo[]         xdrpcArgumentInfoArray = new XDRPCArgumentInfo[args.Length + 1];
                xdrpcArgumentInfoArray[0] = (XDRPCArgumentInfo)structArgumentInfo;
                Array.Copy((Array)args, 0, (Array)xdrpcArgumentInfoArray, 1, args.Length);
                int num = (int)XDRPCMarshaler.ExecuteRPC <uint>(console, options, xdrpcArgumentInfoArray);
                return(structArgumentInfo.Value);
            }
            XDRPCExecutionState.XDRPCCallFlags flags = XDRPCExecutionState.XDRPCCallFlags.IntegerReturn;
            if (t == typeof(float) || t == typeof(double))
            {
                flags = XDRPCExecutionState.XDRPCCallFlags.FloatingPointReturn;
            }
            XDRPCExecutionState xdrpcExecutionState = new XDRPCExecutionState(console, options, args, flags);

            xdrpcExecutionState.NoDevkit = XDRPCMarshaler.NoDevkit;
            xdrpcExecutionState.Invoke();
            if (options.PostMethodCall != XDRPCPostMethodCall.None)
            {
                postMethodCallReturn = xdrpcExecutionState.PostMethodCallReturnValue;
            }
            object obj = XDRPCMarshaler.UnpackReturnType(t, xdrpcExecutionState.ReturnValue);

            if (obj == null)
            {
                return(default(T));
            }
            return((T)obj);
        }
Exemplo n.º 7
0
        private void CalculateNextOffset(
            List <XDRPCStructArgumentInfo <T> .StructBufferData> bufferDataList,
            int packAlignment)
        {
            if (bufferDataList.Count <= 0)
            {
                return;
            }
            int index = bufferDataList.Count - 1;

            XDRPCStructArgumentInfo <T> .StructBufferData bufferData = bufferDataList[index];
            int currOffset = bufferData.NextOffset;

            if (currOffset == 0)
            {
                currOffset = bufferData.BufferOffset + bufferData.BufferSize;
            }
            bufferData.NextOffset = this.AlignOffset(currOffset, packAlignment);
            bufferDataList[index] = bufferData;
        }
Exemplo n.º 8
0
        private bool FillUnionBufferData(
            ref XDRPCStructArgumentInfo <T> .StructBufferData data,
            FieldInfo fieldInfo,
            string unionWritingField)
        {
            bool flag = false;

            if (!string.IsNullOrEmpty(unionWritingField))
            {
                data.BufferOffset = 0;
                if (unionWritingField != fieldInfo.Name)
                {
                    data.Ignore = true;
                }
                else
                {
                    flag = true;
                }
            }
            return(flag);
        }
Exemplo n.º 9
0
        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);
        }