mirror of
https://github.com/BepInEx/mono.git
synced 2026-11-18 12:31:30 -10:00
* SoapMessageFormatter.cs (BuildMethodCallFromSoapMessage): Validate DecodeXmlNamespaceForClrTypeNamespace's result. Don't use RemotingServices.GetServerTypeForUri's result to lookup the method from, because it returns the concrete server type. We need the type that was used to make the call, which we can compute from DecodeXmlNamespaceForClrTypeNamespace's output. Fixes the last part of bug #77191. svn path=/trunk/mcs/; revision=76841
467 lines
16 KiB
C#
467 lines
16 KiB
C#
// created on 03/04/2003 at 14:09
|
|
//
|
|
// System.Runtime.Remoting.Channels.SoapMessageFormatter
|
|
//
|
|
// Author: Jean-Marc Andre ([email protected])
|
|
//
|
|
//
|
|
|
|
//
|
|
// Permission is hereby granted, free of charge, to any person obtaining
|
|
// a copy of this software and associated documentation files (the
|
|
// "Software"), to deal in the Software without restriction, including
|
|
// without limitation the rights to use, copy, modify, merge, publish,
|
|
// distribute, sublicense, and/or sell copies of the Software, and to
|
|
// permit persons to whom the Software is furnished to do so, subject to
|
|
// the following conditions:
|
|
//
|
|
// The above copyright notice and this permission notice shall be
|
|
// included in all copies or substantial portions of the Software.
|
|
//
|
|
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
|
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
|
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
|
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
|
|
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
|
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
|
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
//
|
|
|
|
using System;
|
|
using System.Collections;
|
|
using System.Reflection;
|
|
using System.Runtime.Remoting.Messaging;
|
|
using System.Runtime.Serialization;
|
|
using System.Runtime.Serialization.Formatters;
|
|
|
|
|
|
|
|
namespace System.Runtime.Remoting.Channels {
|
|
enum RemMessageType {
|
|
MethodCall, MethodResponse, ServerFault, NotRecognize
|
|
}
|
|
|
|
internal class SoapMessageFormatter {
|
|
private static FieldInfo _serverFaultExceptionField;
|
|
private Type _serverType;
|
|
private MethodInfo _methodCallInfo;
|
|
private ParameterInfo[] _methodCallParameters;
|
|
private string _xmlNamespace;
|
|
|
|
static SoapMessageFormatter() {
|
|
// Get the ServerFault exception field FieldInfo that
|
|
// will be used later if an exception occurs on the server
|
|
MemberInfo[] mi = FormatterServices.GetSerializableMembers(typeof(ServerFault), new StreamingContext(StreamingContextStates.All));
|
|
FieldInfo fi;
|
|
for(int i = 0; i < mi.Length; i++){
|
|
fi = mi[i] as FieldInfo;
|
|
if(fi != null && fi.FieldType == typeof(Exception)){
|
|
_serverFaultExceptionField = fi;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
internal SoapMessageFormatter() {
|
|
|
|
}
|
|
|
|
internal IMessage FormatFault (SoapFault fault, IMethodCallMessage mcm)
|
|
{
|
|
ServerFault sf = fault.Detail as ServerFault;
|
|
Exception e = null;
|
|
|
|
if (sf != null) {
|
|
if(_serverFaultExceptionField != null)
|
|
e = (Exception) _serverFaultExceptionField.GetValue(sf);
|
|
#if TARGET_JVM
|
|
if (e == null && sf.ExceptionType != null)
|
|
{
|
|
try
|
|
{
|
|
Type te = Type.GetType(sf.ExceptionType);
|
|
if (te != null)
|
|
{
|
|
ConstructorInfo ce = te.GetConstructor(
|
|
BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.CreateInstance,
|
|
null, new Type[] {typeof(string)}, null);
|
|
|
|
if (ce != null)
|
|
{
|
|
e = (Exception) ce.Invoke(new object[] {sf.ExceptionMessage});
|
|
}
|
|
else
|
|
{
|
|
e = (Exception) Activator.CreateInstance(te);
|
|
}
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
e = null;
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
if (e == null)
|
|
e = new RemotingException (fault.FaultString);
|
|
|
|
return new ReturnMessage((System.Exception)e, mcm);
|
|
}
|
|
|
|
// used by the client
|
|
internal IMessage FormatResponse(ISoapMessage soapMsg, IMethodCallMessage mcm)
|
|
{
|
|
IMessage rtnMsg;
|
|
|
|
if(soapMsg.MethodName == "Fault") {
|
|
// an exception was thrown by the server
|
|
Exception e = new SerializationException();
|
|
int i = Array.IndexOf(soapMsg.ParamNames, "detail");
|
|
if(_serverFaultExceptionField != null)
|
|
// todo: revue this 'cause it's not safe
|
|
e = (Exception) _serverFaultExceptionField.GetValue(
|
|
soapMsg.ParamValues[i]);
|
|
|
|
rtnMsg = new ReturnMessage((System.Exception)e, mcm);
|
|
}
|
|
else {
|
|
object rtnObject = null;
|
|
//RemMessageType messageType;
|
|
|
|
// Get the output of the function if it is not *void*
|
|
if(_methodCallInfo.ReturnType != typeof(void)){
|
|
int index = Array.IndexOf(soapMsg.ParamNames, "return");
|
|
rtnObject = soapMsg.ParamValues[index];
|
|
if(rtnObject is IConvertible)
|
|
rtnObject = Convert.ChangeType(
|
|
rtnObject,
|
|
_methodCallInfo.ReturnType);
|
|
}
|
|
|
|
object[] outParams = new object [_methodCallParameters.Length];
|
|
int n=0;
|
|
|
|
// check if there are *out* parameters
|
|
foreach(ParameterInfo paramInfo in _methodCallParameters) {
|
|
|
|
if(paramInfo.ParameterType.IsByRef || paramInfo.IsOut) {
|
|
int index = Array.IndexOf(soapMsg.ParamNames, paramInfo.Name);
|
|
object outParam = soapMsg.ParamValues[index];
|
|
if(outParam is IConvertible)
|
|
outParam = Convert.ChangeType (outParam, paramInfo.ParameterType.GetElementType());
|
|
outParams[n] = outParam;
|
|
}
|
|
else
|
|
outParams [n] = null;
|
|
n++;
|
|
}
|
|
|
|
Header[] headers = new Header [2 + (soapMsg.Headers != null ? soapMsg.Headers.Length : 0)];
|
|
headers [0] = new Header ("__Return", rtnObject);
|
|
headers [1] = new Header ("__OutArgs", outParams);
|
|
|
|
if (soapMsg.Headers != null)
|
|
soapMsg.Headers.CopyTo (headers, 2);
|
|
|
|
rtnMsg = new MethodResponse (headers, mcm);
|
|
}
|
|
return rtnMsg;
|
|
}
|
|
|
|
// used by the client
|
|
internal SoapMessage BuildSoapMessageFromMethodCall(
|
|
IMethodCallMessage mcm,
|
|
out ITransportHeaders requestHeaders)
|
|
{
|
|
|
|
requestHeaders = new TransportHeaders();
|
|
SoapMessage soapMsg = new SoapMessage();
|
|
|
|
GetInfoFromMethodCallMessage(mcm);
|
|
|
|
// Format the SoapMessage that will be used to create the RPC
|
|
soapMsg.MethodName = mcm.MethodName;
|
|
//int count = mcm.ArgCount;
|
|
ArrayList paramNames = new ArrayList(_methodCallParameters.Length);
|
|
ArrayList paramTypes = new ArrayList(_methodCallParameters.Length);
|
|
ArrayList paramValues = new ArrayList(_methodCallParameters.Length);
|
|
|
|
// Add the function parameters to the SoapMessage class
|
|
foreach(ParameterInfo paramInfo in _methodCallParameters) {
|
|
if (!(paramInfo.IsOut && paramInfo.ParameterType.IsByRef)) {
|
|
Type t = paramInfo.ParameterType;
|
|
if (t.IsByRef) t = t.GetElementType ();
|
|
paramNames.Add(paramInfo.Name);
|
|
paramTypes.Add(t);
|
|
paramValues.Add(mcm.Args[paramInfo.Position]);
|
|
}
|
|
}
|
|
soapMsg.ParamNames = (string[]) paramNames.ToArray(typeof(string));
|
|
soapMsg.ParamTypes = (Type[]) paramTypes.ToArray(typeof(Type));
|
|
soapMsg.ParamValues = (object[]) paramValues.ToArray(typeof(object));
|
|
soapMsg.XmlNameSpace = SoapServices.GetXmlNamespaceForMethodCall(_methodCallInfo);
|
|
soapMsg.Headers = BuildMessageHeaders (mcm);
|
|
|
|
// Format the transport headers
|
|
requestHeaders["Content-Type"] = "text/xml; charset=\"utf-8\"";
|
|
requestHeaders["SOAPAction"] = "\""+
|
|
SoapServices.GetSoapActionFromMethodBase(_methodCallInfo)+"\"";
|
|
requestHeaders[CommonTransportKeys.RequestUri] = mcm.Uri;
|
|
|
|
return soapMsg;
|
|
|
|
}
|
|
|
|
// used by the server
|
|
internal IMessage BuildMethodCallFromSoapMessage(SoapMessage soapMessage, string uri)
|
|
{
|
|
ArrayList headersList = new ArrayList();
|
|
Type[] signature = null;
|
|
|
|
headersList.Add(new Header("__Uri", uri));
|
|
headersList.Add(new Header("__MethodName", soapMessage.MethodName));
|
|
string typeNamespace, assemblyName;
|
|
|
|
if (!SoapServices.DecodeXmlNamespaceForClrTypeNamespace(soapMessage.XmlNameSpace, out typeNamespace, out assemblyName))
|
|
throw new RemotingException ("Could not decode SoapMessage");
|
|
|
|
// Note that we don't need to validate the type in
|
|
// this place because MethodCall will do it anyway.
|
|
|
|
if (assemblyName == null) // corlib
|
|
_serverType = Type.GetType (typeNamespace, true);
|
|
else
|
|
_serverType = Type.GetType (typeNamespace + ", " + assemblyName, true);
|
|
|
|
headersList.Add(new Header("__TypeName", _serverType.FullName, false));
|
|
|
|
if (soapMessage.Headers != null) {
|
|
foreach (Header h in soapMessage.Headers) {
|
|
headersList.Add (h);
|
|
if (h.Name == "__MethodSignature")
|
|
signature = (Type[]) h.Value;
|
|
}
|
|
}
|
|
|
|
_xmlNamespace = soapMessage.XmlNameSpace;
|
|
//RemMessageType messageType;
|
|
|
|
BindingFlags bflags = BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;
|
|
|
|
if (signature == null)
|
|
_methodCallInfo = _serverType.GetMethod(soapMessage.MethodName, bflags);
|
|
else
|
|
_methodCallInfo = _serverType.GetMethod(soapMessage.MethodName, bflags, null, signature, null);
|
|
|
|
if (_methodCallInfo == null && (soapMessage.MethodName == "FieldSetter" || soapMessage.MethodName == "FieldGetter"))
|
|
_methodCallInfo = typeof(object).GetMethod (soapMessage.MethodName, bflags);
|
|
|
|
// the *out* parameters aren't serialized
|
|
// have to add them here
|
|
_methodCallParameters = _methodCallInfo.GetParameters();
|
|
object[] args = new object[_methodCallParameters.Length];
|
|
int sn = 0;
|
|
for (int n=0; n<_methodCallParameters.Length; n++)
|
|
{
|
|
ParameterInfo paramInfo = _methodCallParameters [n];
|
|
Type paramType = (paramInfo.ParameterType.IsByRef ? paramInfo.ParameterType.GetElementType() : paramInfo.ParameterType);
|
|
|
|
if (paramInfo.IsOut && paramInfo.ParameterType.IsByRef) {
|
|
args [n] = GetNullValue (paramType);
|
|
}
|
|
else{
|
|
object val = soapMessage.ParamValues[sn++];
|
|
if(val is IConvertible)
|
|
args [n] = Convert.ChangeType (val, paramType);
|
|
else
|
|
args [n] = val;
|
|
}
|
|
}
|
|
|
|
headersList.Add(new Header("__Args", args, false));
|
|
|
|
Header[] headers = (Header[])headersList.ToArray(typeof(Header));
|
|
|
|
// build the MethodCall from the headers
|
|
MethodCall mthCall = new MethodCall(headers);
|
|
return (IMessage)mthCall;
|
|
}
|
|
|
|
// used by the server
|
|
internal object BuildSoapMessageFromMethodResponse(IMethodReturnMessage mrm, out ITransportHeaders responseHeaders)
|
|
{
|
|
responseHeaders = new TransportHeaders();
|
|
|
|
if(mrm.Exception == null) {
|
|
// *normal* function return
|
|
|
|
SoapMessage soapMessage = new SoapMessage();
|
|
|
|
// fill the transport headers
|
|
responseHeaders["Content-Type"] = "text/xml; charset=\"utf-8\"";
|
|
|
|
// build the SoapMessage
|
|
ArrayList paramNames = new ArrayList();
|
|
ArrayList paramValues = new ArrayList();
|
|
ArrayList paramTypes = new ArrayList();
|
|
soapMessage.MethodName = mrm.MethodName+"Response";
|
|
|
|
Type retType = ((MethodInfo)mrm.MethodBase).ReturnType;
|
|
|
|
if(retType != typeof(void)) {
|
|
paramNames.Add("return");
|
|
paramValues.Add(mrm.ReturnValue);
|
|
if (mrm.ReturnValue != null)
|
|
paramTypes.Add(mrm.ReturnValue.GetType());
|
|
else
|
|
paramTypes.Add(retType);
|
|
}
|
|
|
|
for(int i = 0; i < mrm.OutArgCount; i++){
|
|
paramNames.Add(mrm.GetOutArgName(i));
|
|
paramValues.Add(mrm.GetOutArg(i));
|
|
if(mrm.GetOutArg(i) != null) paramTypes.Add(mrm.GetOutArg(i).GetType());
|
|
}
|
|
soapMessage.ParamNames = (string[]) paramNames.ToArray(typeof(string));
|
|
soapMessage.ParamValues = (object[]) paramValues.ToArray(typeof(object));
|
|
soapMessage.ParamTypes = (Type[]) paramTypes.ToArray(typeof(Type));
|
|
soapMessage.XmlNameSpace = _xmlNamespace;
|
|
soapMessage.Headers = BuildMessageHeaders (mrm);
|
|
return soapMessage;
|
|
}
|
|
else {
|
|
// an Exception was thrown while executing the function
|
|
responseHeaders["__HttpStatusCode"] = "500";
|
|
responseHeaders["__HttpReasonPhrase"] = "Bad Request";
|
|
// fill the transport headers
|
|
responseHeaders["Content-Type"] = "text/xml; charset=\"utf-8\"";
|
|
ServerFault serverFault = CreateServerFault(mrm.Exception);
|
|
return new SoapFault("Server", String.Format(" **** {0} - {1}", mrm.Exception.GetType().ToString(), mrm.Exception.Message), null, serverFault);
|
|
}
|
|
}
|
|
|
|
internal SoapMessage CreateSoapMessage (bool isRequest)
|
|
{
|
|
if (isRequest) return new SoapMessage ();
|
|
|
|
int n = 0;
|
|
Type[] types = new Type [_methodCallParameters.Length + 1];
|
|
|
|
if (_methodCallInfo.ReturnType != typeof(void)) {
|
|
types[0] = _methodCallInfo.ReturnType;
|
|
n++;
|
|
}
|
|
|
|
foreach(ParameterInfo paramInfo in _methodCallParameters)
|
|
{
|
|
if (paramInfo.ParameterType.IsByRef || paramInfo.IsOut)
|
|
{
|
|
Type t = paramInfo.ParameterType;
|
|
if (t.IsByRef) t = t.GetElementType();
|
|
types [n++] = t;
|
|
}
|
|
}
|
|
SoapMessage sm = new SoapMessage ();
|
|
sm.ParamTypes = types;
|
|
return sm;
|
|
}
|
|
|
|
// used by the server when an exception is thrown
|
|
// by the called function
|
|
internal ServerFault CreateServerFault(Exception e) {
|
|
// it's really strange here
|
|
// a ServerFault object has a private System.Exception member called *exception*
|
|
// (have a look at a MS Soap message when an exception occurs on the server)
|
|
// but there is not public .ctor with an Exception as parameter...????....
|
|
// (maybe an internal one). So I searched another way...
|
|
ServerFault sf = (ServerFault) FormatterServices.GetUninitializedObject(typeof(ServerFault));
|
|
MemberInfo[] mi = FormatterServices.GetSerializableMembers(typeof(ServerFault), new StreamingContext(StreamingContextStates.All));
|
|
|
|
FieldInfo fi;
|
|
object[] mv = new object[mi.Length];
|
|
for(int i = 0; i < mi.Length; i++) {
|
|
fi = mi[i] as FieldInfo;
|
|
if(fi != null && fi.FieldType == typeof(Exception)) mv[i] = e;
|
|
}
|
|
sf = (ServerFault) FormatterServices.PopulateObjectMembers(sf, mi, mv);
|
|
|
|
return sf;
|
|
}
|
|
|
|
internal void GetInfoFromMethodCallMessage (IMethodMessage mcm) {
|
|
_serverType = Type.GetType(mcm.TypeName, true);
|
|
_methodCallInfo = RemotingServices.GetMethodBaseFromMethodMessage (mcm) as MethodInfo;
|
|
_methodCallParameters = _methodCallInfo.GetParameters();
|
|
}
|
|
|
|
Header[] BuildMessageHeaders (IMethodMessage msg)
|
|
{
|
|
ArrayList headers = new ArrayList (1);
|
|
foreach (string key in msg.Properties.Keys)
|
|
{
|
|
switch (key) {
|
|
case "__Uri":
|
|
case "__MethodName":
|
|
case "__TypeName":
|
|
case "__Args":
|
|
case "__OutArgs":
|
|
case "__Return":
|
|
case "__MethodSignature":
|
|
case "__CallContext":
|
|
continue;
|
|
|
|
default:
|
|
object value = msg.Properties [key];
|
|
if (value != null)
|
|
headers.Add (new Header (key, value, false, "http://schemas.microsoft.com/clr/soap/messageProperties"));
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (RemotingServices.IsMethodOverloaded (msg))
|
|
headers.Add (new Header ("__MethodSignature", msg.MethodSignature, false, "http://schemas.microsoft.com/clr/soap/messageProperties"));
|
|
|
|
if (msg.LogicalCallContext != null && msg.LogicalCallContext.HasInfo)
|
|
headers.Add (new Header ("__CallContext", msg.LogicalCallContext, false, "http://schemas.microsoft.com/clr/soap/messageProperties"));
|
|
|
|
if (headers.Count == 0) return null;
|
|
return (Header[]) headers.ToArray (typeof(Header));
|
|
}
|
|
|
|
object GetNullValue (Type paramType)
|
|
{
|
|
#if TARGET_JVM
|
|
if (paramType.IsEnum)
|
|
{
|
|
return Activator.CreateInstance(paramType);
|
|
}
|
|
#endif
|
|
switch (Type.GetTypeCode (paramType))
|
|
{
|
|
case TypeCode.Boolean: return false;
|
|
case TypeCode.Byte: return (byte)0;
|
|
case TypeCode.Char: return '\0';
|
|
case TypeCode.Decimal: return (decimal)0;
|
|
case TypeCode.Double: return (double)0;
|
|
case TypeCode.Int16: return (short)0;
|
|
case TypeCode.Int32: return (int)0;
|
|
case TypeCode.Int64: return (long)0;
|
|
case TypeCode.SByte: return (sbyte)0;
|
|
case TypeCode.Single: return (float)0;
|
|
case TypeCode.UInt16: return (ushort)0;
|
|
case TypeCode.UInt32: return (uint)0;
|
|
case TypeCode.UInt64: return (ulong)0;
|
|
default:
|
|
#if TARGET_JVM
|
|
if (paramType.IsValueType)
|
|
{
|
|
return Activator.CreateInstance(paramType);
|
|
}
|
|
#endif
|
|
return null;
|
|
}
|
|
}
|
|
}
|
|
}
|