Files
mono/mcs/class/System.Runtime.Remoting/System.Runtime.Remoting.Channels/SoapMessageFormatter.cs
T
Robert Jordan 628dd4e2e0 2007-05-07 Robert Jordan <[email protected]>
* 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
2007-05-07 15:42:16 +00:00

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;
}
}
}
}