[System.Security.SecuritySafeCritical] // auto-generated internal bool CanCastToXmlType(String xmlTypeName, String xmlTypeNamespace) { Type castType = SoapServices.GetInteropTypeFromXmlType(xmlTypeName, xmlTypeNamespace); if (castType == null) { String typeNamespace; String assemblyName; if (!SoapServices.DecodeXmlNamespaceForClrTypeNamespace(xmlTypeNamespace, out typeNamespace, out assemblyName)) { return(false); } String typeName; if ((typeNamespace != null) && (typeNamespace.Length > 0)) { typeName = typeNamespace + "." + xmlTypeName; } else { typeName = xmlTypeName; } try { Assembly asm = Assembly.Load(assemblyName); castType = asm.GetType(typeName, false, false); } catch { return(false); } } if (castType != null) { return(castType.IsAssignableFrom(this.GetType())); } return(false); } // CanCastToXmlType
internal static bool CanCastToXmlTypeHelper(RuntimeType castType, MarshalByRefObject o) { if (castType == null) { throw new ArgumentNullException("castType"); } if (!castType.IsInterface && !castType.IsMarshalByRef) { return(false); } string xmlType = null; string xmlTypeNamespace = null; if (!SoapServices.GetXmlTypeForInteropType(castType, out xmlType, out xmlTypeNamespace)) { xmlType = castType.Name; xmlTypeNamespace = SoapServices.CodeXmlNamespaceForClrTypeNamespace(castType.Namespace, castType.GetRuntimeAssembly().GetSimpleName()); } return(o.CanCastToXmlType(xmlType, xmlTypeNamespace)); }
public void TestGetInteropType() { Type t; // Manual registration t = SoapServices.GetInteropTypeFromXmlElement("aa", "bb"); Assert.AreEqual(t, null, "M1"); SoapServices.RegisterInteropXmlElement("aa", "bb", typeof(SoapTest)); t = SoapServices.GetInteropTypeFromXmlElement("aa", "bb"); Assert.AreEqual(typeof(SoapTest), t, "M2"); t = SoapServices.GetInteropTypeFromXmlType("aa", "bb"); Assert.AreEqual(null, t, "M3"); SoapServices.RegisterInteropXmlType("aa", "bb", typeof(SoapTest)); t = SoapServices.GetInteropTypeFromXmlType("aa", "bb"); Assert.AreEqual(typeof(SoapTest), t, "M4"); // Preload type SoapServices.PreLoad(typeof(SoapTest2)); t = SoapServices.GetInteropTypeFromXmlElement("ename", ThisNamespace); Assert.AreEqual(typeof(SoapTest2), t, "T1"); t = SoapServices.GetInteropTypeFromXmlType("tname", ThisNamespace); Assert.AreEqual(typeof(SoapTest2), t, "T2"); // Preload assembly SoapServices.PreLoad(typeof(SoapTest).Assembly); t = SoapServices.GetInteropTypeFromXmlElement("SoapTest3", "ens"); Assert.AreEqual(typeof(SoapTest3), t, "A1"); t = SoapServices.GetInteropTypeFromXmlType("SoapTest3", "tns"); Assert.AreEqual(typeof(SoapTest3), t, "A2"); }
/// <summary> /// Create a session and login to UMarket /// </summary> /// <returns></returns> static string CreatAndLoginSession() { #region Config string init = ConfigurationManager.AppSettings["init"].ToString(); // "0277551990";//"0573449847";// "0278793422"; string salt = ConfigurationManager.AppSettings["salt"].ToString(); //"0277551990";//"0278793422"; string pin = ConfigurationManager.AppSettings["pin"].ToString(); // "1212";//"1234"; #endregion // Get string response = SoapServices.SendXMLRequest(GetXMLCommands.GetSessionXML()); var t = XElement.Parse(response); string session = t.Value.Remove(t.Value.Length - 8); pin = GeneralService.GetPin(session, salt, pin); response = GetXMLCommands.GetLoginXML(init, pin, session); response = SoapServices.SendXMLRequest(response); t = XElement.Parse(response); string transactionId = t.Value.Remove(t.Value.Length - 8); return(session); }
internal static void ProcessTypeAttribute(Type type, SoapAttributeInfo attributeInfo) { string str; string str2; SoapTypeAttribute cachedSoapAttribute = (SoapTypeAttribute)InternalRemotingServices.GetCachedSoapAttribute(type); if (cachedSoapAttribute.Embedded) { attributeInfo.m_attributeType |= SoapAttributeType.Embedded; } if (SoapServices.GetXmlElementForInteropType(type, out str, out str2)) { attributeInfo.m_attributeType |= SoapAttributeType.XmlElement; attributeInfo.m_elementName = str; attributeInfo.m_nameSpace = str2; } if (SoapServices.GetXmlTypeForInteropType(type, out str, out str2)) { attributeInfo.m_attributeType |= SoapAttributeType.XmlType; attributeInfo.m_typeName = str; attributeInfo.m_typeNamespace = str2; } }
} // AsyncProcessMessage // // end of IMessageSink implementation // // helper function to serialize the message private void SerializeMessage(IMethodCallMessage mcm, out ITransportHeaders headers, out Stream stream) { BaseTransportHeaders requestHeaders = new BaseTransportHeaders(); headers = requestHeaders; // add SOAPAction header MethodBase mb = mcm.MethodBase; headers["SOAPAction"] = '"' + HttpEncodingHelper.EncodeUriAsXLinkHref( SoapServices.GetSoapActionFromMethodBase(mb)) + '"'; // add other http soap headers requestHeaders.ContentType = CoreChannel.SOAPContentType; if (_channelProtocol == SinkChannelProtocol.Http) { headers["__RequestVerb"] = "POST"; } bool bMemStream = false; stream = _nextSink.GetRequestStream(mcm, headers); if (stream == null) { stream = new ChunkedMemoryStream(CoreChannel.BufferPool); bMemStream = true; } CoreChannel.SerializeSoapMessage(mcm, stream, _includeVersioning); if (bMemStream) { stream.Position = 0; } } // SerializeMessage
public void TestSoapActions() { string act; MethodBase mb; mb = typeof(SoapTest).GetMethod("FesAlgo"); act = SoapServices.GetSoapActionFromMethodBase(mb); Assert.AreEqual("myaction", act, "S1"); mb = typeof(SoapTest).GetMethod("FesAlgoMes"); SoapServices.RegisterSoapActionForMethodBase(mb, "anotheraction"); act = SoapServices.GetSoapActionFromMethodBase(mb); Assert.AreEqual("anotheraction", act, "S2"); mb = typeof(SoapTest).GetMethod("FesAlgoMesEspecial"); act = SoapServices.GetSoapActionFromMethodBase(mb); Assert.AreEqual(GetClassNs(typeof(SoapTest)) + "#FesAlgoMesEspecial", act, "S3"); string typeName, methodName; bool res; res = SoapServices.GetTypeAndMethodNameFromSoapAction("myaction", out typeName, out methodName); Assert.IsTrue(res, "M1"); Assert.AreEqual(GetSimpleTypeName(typeof(SoapTest)), typeName, "M2"); Assert.AreEqual("FesAlgo", methodName, "M3"); res = SoapServices.GetTypeAndMethodNameFromSoapAction("anotheraction", out typeName, out methodName); Assert.IsTrue(res, "M4"); Assert.AreEqual(GetSimpleTypeName(typeof(SoapTest)), typeName, "M5"); Assert.AreEqual("FesAlgoMes", methodName, "M6"); res = SoapServices.GetTypeAndMethodNameFromSoapAction(GetClassNs(typeof(SoapTest)) + "#FesAlgoMesEspecial", out typeName, out methodName); Assert.IsTrue(res, "M7"); Assert.AreEqual(GetSimpleTypeName(typeof(SoapTest)), typeName, "M8"); Assert.AreEqual("FesAlgoMesEspecial", methodName, "M9"); }
// 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); }
public static void Main(string[] args) { //<snippet101> // Convert a CLR namespace and assembly name into an XML namespace. string xmlNamespace = SoapServices.CodeXmlNamespaceForClrTypeNamespace( "ExampleNamespace", "AssemblyName"); Console.WriteLine("The name of the XML namespace is {0}.", xmlNamespace); //</snippet101> //<snippet102> // Extract a CLR namespace and assembly name from an XML namespace. string typeNamespace; string assemblyName; SoapServices.DecodeXmlNamespaceForClrTypeNamespace(xmlNamespace, out typeNamespace, out assemblyName); Console.WriteLine("The name of the CLR namespace is {0}.", typeNamespace); Console.WriteLine("The name of the CLR assembly is {0}.", assemblyName); //</snippet102> //<snippet103> // Get the XML element name and the XML namespace for // an Interop type. string xmlElement; bool isSoapTypeAttribute = SoapServices.GetXmlElementForInteropType( typeof(ExampleNamespace.ExampleClass), out xmlElement, out xmlNamespace); // Print whether the requested value was flagged // with a SoapTypeAttribute. if (isSoapTypeAttribute) { Console.WriteLine( "The requested value was flagged " + "with the SoapTypeAttribute."); } else { Console.WriteLine( "The requested value was not flagged " + "with the SoapTypeAttribute."); } // Print the XML element and the XML namespace. Console.WriteLine( "The XML element for the type " + "ExampleNamespace.ExampleClass is {0}.", xmlElement); Console.WriteLine( "The XML namespace for the type " + "ExampleNamespace.ExampleClass is {0}.", xmlNamespace); //</snippet103> //<snippet104> // Get the XML type name and the XML type namespace for // an Interop type. string xmlTypeName; string xmlTypeNamespace; isSoapTypeAttribute = SoapServices.GetXmlTypeForInteropType( typeof(ExampleNamespace.ExampleClass), out xmlTypeName, out xmlTypeNamespace); // Print whether the requested value was flagged // with a SoapTypeAttribute. if (isSoapTypeAttribute) { Console.WriteLine( "The requested value was flagged " + "with the SoapTypeAttribute."); } else { Console.WriteLine( "The requested value was not flagged " + "with the SoapTypeAttribute."); } // Print the XML type name and the XML type namespace. Console.WriteLine( "The XML type for the type " + "ExampleNamespace.ExampleClass is {0}.", xmlTypeName); Console.WriteLine( "The XML type namespace for the type " + "ExampleNamespace.ExampleClass is {0}.", xmlTypeNamespace); //</snippet104> //<snippet105> // Print the XML namespace for a method invocation and its // response. System.Reflection.MethodBase getHelloMethod = typeof(ExampleNamespace.ExampleClass).GetMethod("GetHello"); string methodCallXmlNamespace = SoapServices.GetXmlNamespaceForMethodCall(getHelloMethod); string methodResponseXmlNamespace = SoapServices.GetXmlNamespaceForMethodResponse(getHelloMethod); Console.WriteLine( "The XML namespace for the invocation of the method " + "GetHello in ExampleClass is {0}.", methodResponseXmlNamespace); Console.WriteLine( "The XML namespace for the response of the method " + "GetHello in ExampleClass is {0}.", methodCallXmlNamespace); //</snippet105> //<snippet106> // Determine whether an XML namespace represents a CLR namespace. string clrNamespace = SoapServices.XmlNsForClrType; if (SoapServices.IsClrTypeNamespace(clrNamespace)) { Console.WriteLine( "The namespace {0} is a CLR namespace.", clrNamespace); } else { Console.WriteLine( "The namespace {0} is not a CLR namespace.", clrNamespace); } //</snippet106> //<snippet130> // Print the XML namespace for the CLR types. Console.WriteLine( "The XML namespace for the CLR types " + "is {0}.", SoapServices.XmlNsForClrType); //</snippet130> //<snippet131> // Print the XML namespace for the CLR types // that have an assembly but no common language runtime namespace. Console.WriteLine( "The XML namespace for the CLR types " + "that have an assembly but no namespace, is {0}.", SoapServices.XmlNsForClrTypeWithAssembly); //</snippet131> //<snippet132> // Print the XML namespace for the CLR types // that are a part of the Mscorlib.dll. Console.WriteLine( "The XML namespace for the CLR types " + "that are part of the Mscorlib.dll, is {0}.", SoapServices.XmlNsForClrTypeWithNs); //</snippet132> //<snippet133> // Print the XML namespace for the CLR types // that have both an assembly and a common language runtime // namespace. Console.WriteLine( "The XML namespace for the CLR types " + "that have both an assembly and a namespace, is {0}.", SoapServices.XmlNsForClrTypeWithNsAndAssembly); //</snippet133> //<snippet140> // Get the SOAP action for the method. System.Reflection.MethodBase getHelloMethodBase = typeof(ExampleNamespace.ExampleClass).GetMethod("GetHello"); string getHelloSoapAction = SoapServices.GetSoapActionFromMethodBase(getHelloMethodBase); Console.WriteLine( "The SOAP action for the method " + "ExampleClass.GetHello is {0}.", getHelloSoapAction); bool isSoapActionValid = SoapServices.IsSoapActionValidForMethodBase( getHelloSoapAction, getHelloMethodBase); if (isSoapActionValid) { Console.WriteLine( "The SOAP action, {0}, " + "is valid for ExampleClass.GetHello", getHelloSoapAction); } else { Console.WriteLine( "The SOAP action, {0}, " + "is not valid for ExampleClass.GetHello", getHelloSoapAction); } // Register the SOAP action for the GetHello method. SoapServices.RegisterSoapActionForMethodBase(getHelloMethodBase); // Get the type and the method names encoded into the SOAP action. string encodedTypeName; string encodedMethodName; SoapServices.GetTypeAndMethodNameFromSoapAction( getHelloSoapAction, out encodedTypeName, out encodedMethodName); Console.WriteLine( "The type name encoded in this SOAP action is {0}.", encodedTypeName); Console.WriteLine( "The method name encoded in this SOAP action is {0}.", encodedMethodName); //</snippet140> //<snippet150> // Get the name and the type of the field using its XML // element name and its XML namespace. For this query to work, // the containing type must be preloaded, and the XML element // name and the XML namespace must be explicitly declared on // the field using a SoapFieldAttribute. // Preload the containing type. SoapServices.PreLoad(typeof(ExampleNamespace.ExampleClass)); // Get the name and the type of a field that will be // serialized as an XML element. Type containingType = typeof(ExampleNamespace.ExampleClass); string xmlElementNamespace = "http://example.org/ExampleFieldNamespace"; string xmlElementName = "ExampleFieldElementName"; Type fieldType; string fieldName; SoapServices.GetInteropFieldTypeAndNameFromXmlElement( containingType, xmlElementName, xmlElementNamespace, out fieldType, out fieldName); Console.WriteLine( "The type of the field is {0}.", fieldType); Console.WriteLine( "The name of the field is {0}.", fieldName); // Get the name and the type of a field that will be // serialized as an XML attribute. string xmlAttributeNamespace = "http://example.org/ExampleAttributeNamespace"; string xmlAttributeName = "ExampleFieldAttributeName"; SoapServices.GetInteropFieldTypeAndNameFromXmlAttribute( containingType, xmlAttributeName, xmlAttributeNamespace, out fieldType, out fieldName); Console.WriteLine( "The type of the field is {0}.", fieldType); Console.WriteLine( "The name of the field is {0}.", fieldName); //</snippet150> //<snippet160> string interopTypeXmlElementName = "ExampleClassElementName"; string interopTypeXmlNamespace = "http://example.org/ExampleXmlNamespace"; Type interopType = SoapServices.GetInteropTypeFromXmlElement( interopTypeXmlElementName, interopTypeXmlNamespace); Console.WriteLine("The interop type is {0}.", interopType); string interopTypeXmlTypeName = "ExampleXmlTypeName"; string interopTypeXmlTypeNamespace = "http://example.org/ExampleXmlTypeNamespace"; interopType = SoapServices.GetInteropTypeFromXmlType( interopTypeXmlTypeName, interopTypeXmlTypeNamespace); Console.WriteLine("The interop type is {0}.", interopType); //</snippet160> //<snippet170> // Get the method base object for the GetHello method. System.Reflection.MethodBase methodBase = typeof(ExampleNamespace.ExampleClass).GetMethod("GetHello"); // Print its current SOAP action. Console.WriteLine( "The SOAP action for the method " + "ExampleClass.GetHello is {0}.", SoapServices.GetSoapActionFromMethodBase(methodBase)); // Set the SOAP action of the GetHello method to a new value. string newSoapAction = "http://example.org/ExampleSoapAction#NewSoapAction"; SoapServices.RegisterSoapActionForMethodBase( methodBase, newSoapAction); Console.WriteLine( "The SOAP action for the method " + "ExampleClass.GetHello is {0}.", SoapServices.GetSoapActionFromMethodBase(methodBase)); // Reset the SOAP action of the GetHello method to its default // value, which is determined using its SoapMethod attribute. SoapServices.RegisterSoapActionForMethodBase(methodBase); Console.WriteLine( "The SOAP action for the method " + "ExampleClass.GetHello is {0}.", SoapServices.GetSoapActionFromMethodBase(methodBase)); //</snippet170> //<snippet120> // Register all types in the assembly with the SoapType attribute. System.Reflection.Assembly executingAssembly = System.Reflection.Assembly.GetExecutingAssembly(); SoapServices.PreLoad(executingAssembly); //</snippet120> //<snippet121> // Register a specific type with the SoapType attribute. Type exampleType = typeof(ExampleNamespace.ExampleClass); SoapServices.PreLoad(exampleType); //</snippet121> //<snippet180> // Get the currently registered type for the given XML element // and namespace. string registeredXmlElementName = "ExampleClassElementName"; string registeredXmlNamespace = "http://example.org/ExampleXmlNamespace"; Type registeredType = SoapServices.GetInteropTypeFromXmlElement( registeredXmlElementName, registeredXmlNamespace); Console.WriteLine( "The registered interop type is {0}.", registeredType); // Register a new type for the XML element and namespace. SoapServices.RegisterInteropXmlElement( registeredXmlElementName, registeredXmlNamespace, typeof(String)); // Get the currently registered type for the given XML element // and namespace. registeredType = SoapServices.GetInteropTypeFromXmlElement( registeredXmlElementName, registeredXmlNamespace); Console.WriteLine( "The registered interop type is {0}.", registeredType); //</snippet180> //<snippet190> // Get the currently registered type for the given XML element // and namespace. string registeredXmlTypeName = "ExampleXmlTypeName"; string registeredXmlTypeNamespace = "http://example.org/ExampleXmlTypeNamespace"; registeredType = SoapServices.GetInteropTypeFromXmlType( registeredXmlTypeName, registeredXmlTypeNamespace); Console.WriteLine( "The registered interop type is {0}.", registeredType); // Register a new type for the XML element and namespace. SoapServices.RegisterInteropXmlType( registeredXmlTypeName, registeredXmlTypeNamespace, typeof(String)); // Get the currently registered type for the given XML element // and namespace. registeredType = SoapServices.GetInteropTypeFromXmlType( registeredXmlTypeName, registeredXmlTypeNamespace); Console.WriteLine( "The registered interop type is {0}.", registeredType); //</snippet190> }
} // StrictBinding /// <include file='doc\SoapFormatterSinks.uex' path='docs/doc[@for="SoapServerFormatterSink.ProcessMessage"]/*' /> public ServerProcessing ProcessMessage(IServerChannelSinkStack sinkStack, IMessage requestMsg, ITransportHeaders requestHeaders, Stream requestStream, out IMessage responseMsg, out ITransportHeaders responseHeaders, out Stream responseStream) { if (requestMsg != null) { // The message has already been deserialized so delegate to the next sink. return(_nextSink.ProcessMessage( sinkStack, requestMsg, requestHeaders, requestStream, out responseMsg, out responseHeaders, out responseStream)); } if (requestHeaders == null) { throw new ArgumentNullException("requestHeaders"); } BaseTransportHeaders wkRequestHeaders = requestHeaders as BaseTransportHeaders; ServerProcessing processing; responseHeaders = null; responseStream = null; String verb = null; String contentType = null; bool bCanServiceRequest = true; // determine the content type String contentTypeHeader = null; if (wkRequestHeaders != null) { contentTypeHeader = wkRequestHeaders.ContentType; } else { contentTypeHeader = requestHeaders["Content-Type"] as String; } if (contentTypeHeader != null) { String charsetValue; HttpChannelHelper.ParseContentType(contentTypeHeader, out contentType, out charsetValue); } // check to see if Content-Type matches if ((contentType != null) && (String.Compare(contentType, CoreChannel.SOAPMimeType, false, CultureInfo.InvariantCulture) != 0)) { bCanServiceRequest = false; } // check for http specific verbs if (_protocol == Protocol.Http) { verb = (String)requestHeaders["__RequestVerb"]; if (!verb.Equals("POST") && !verb.Equals("M-POST")) { bCanServiceRequest = false; } } // either delegate or return an error message if we can't service the request if (!bCanServiceRequest) { // delegate to next sink if available if (_nextSink != null) { return(_nextSink.ProcessMessage(sinkStack, null, requestHeaders, requestStream, out responseMsg, out responseHeaders, out responseStream)); } else { // send back an error message if (_protocol == Protocol.Http) { // return a client bad request error responseHeaders = new TransportHeaders(); responseHeaders["__HttpStatusCode"] = "400"; responseHeaders["__HttpReasonPhrase"] = "Bad Request"; responseStream = null; responseMsg = null; return(ServerProcessing.Complete); } else { // The transport sink will catch this and do something here. throw new RemotingException( CoreChannel.GetResourceString("Remoting_Channels_InvalidRequestFormat")); } } } bool bClientIsClr = true; try { String objectUri = null; if (wkRequestHeaders != null) { objectUri = wkRequestHeaders.RequestUri; } else { objectUri = (String)requestHeaders[CommonTransportKeys.RequestUri]; } if (RemotingServices.GetServerTypeForUri(objectUri) == null) { throw new RemotingException( CoreChannel.GetResourceString("Remoting_ChnlSink_UriNotPublished")); } if (_protocol == Protocol.Http) { String userAgent = (String)requestHeaders["User-Agent"]; if (userAgent != null) { if (userAgent.IndexOf("MS .NET Remoting") == -1) { // user agent string did not contain ".NET Remoting", so it is someone else bClientIsClr = false; } } else { bClientIsClr = false; } } // Deserialize Request - Stream to IMessage String soapActionToVerify; Header[] h = GetChannelHeaders(requestHeaders, out soapActionToVerify); requestMsg = CoreChannel.DeserializeSoapRequestMessage(requestStream, h, _strictBinding); requestStream.Close(); if (requestMsg == null) { throw new RemotingException(CoreChannel.GetResourceString("Remoting_DeserializeMessage")); } // verify soap action if necessary if ((soapActionToVerify != null) && (!SoapServices.IsSoapActionValidForMethodBase( soapActionToVerify, ((IMethodMessage)requestMsg).MethodBase))) { throw new RemotingException( String.Format( CoreChannel.GetResourceString("Remoting_Soap_InvalidSoapAction"), soapActionToVerify) ); } // Dispatch Call sinkStack.Push(this, null); processing = _nextSink.ProcessMessage(sinkStack, requestMsg, requestHeaders, null, out responseMsg, out responseHeaders, out responseStream); // make sure that responseStream is null if (responseStream != null) { throw new RemotingException( CoreChannel.GetResourceString("Remoting_ChnlSink_WantNullResponseStream")); } switch (processing) { case ServerProcessing.Complete: { if (responseMsg == null) { throw new RemotingException(CoreChannel.GetResourceString("Remoting_DispatchMessage")); } sinkStack.Pop(this); SerializeResponse(sinkStack, responseMsg, bClientIsClr, ref responseHeaders, out responseStream); break; } // case ServerProcessing.Complete case ServerProcessing.OneWay: { sinkStack.Pop(this); break; } // case ServerProcessing.OneWay: case ServerProcessing.Async: { sinkStack.Store(this, null); break; } // case ServerProcessing.Async } // switch (processing) } catch (Exception e) { processing = ServerProcessing.Complete; responseMsg = new ReturnMessage(e, (IMethodCallMessage)(requestMsg == null?new ErrorMessage():requestMsg)); CallContext.SetData("__ClientIsClr", bClientIsClr); responseStream = (MemoryStream)CoreChannel.SerializeSoapMessage(responseMsg, _includeVersioning); CallContext.FreeNamedDataSlot("__ClientIsClr"); responseStream.Position = 0; responseHeaders = new TransportHeaders(); if (_protocol == Protocol.Http) { responseHeaders["__HttpStatusCode"] = "500"; responseHeaders["__HttpReasonPhrase"] = "Internal Server Error"; responseHeaders["Content-Type"] = CoreChannel.SOAPContentType; } } return(processing); } // ProcessMessage
public virtual void GetObjectData(object obj, SerializationInfo info, StreamingContext context) { if (info == null) { throw new ArgumentNullException("info"); } if ((obj != null) && (obj != this._rootObj)) { new MessageSurrogate(this._ss).GetObjectData(obj, info, context); } else { IMethodReturnMessage mm = obj as IMethodReturnMessage; if (mm != null) { if (mm.Exception != null) { object data = CallContext.GetData("__ClientIsClr"); bool flag = (data == null) || ((bool)data); info.FullTypeName = "FormatterWrapper"; info.AssemblyName = this.DefaultFakeRecordAssemblyName; Exception innerException = mm.Exception; StringBuilder builder = new StringBuilder(); bool flag2 = false; while (innerException != null) { if (innerException.Message.StartsWith("MustUnderstand", StringComparison.Ordinal)) { flag2 = true; } builder.Append(" **** "); builder.Append(innerException.GetType().FullName); builder.Append(" - "); builder.Append(innerException.Message); innerException = innerException.InnerException; } ServerFault serverFault = null; if (flag) { serverFault = new ServerFault(mm.Exception); } else { serverFault = new ServerFault(mm.Exception.GetType().AssemblyQualifiedName, builder.ToString(), mm.Exception.StackTrace); } string faultCode = "Server"; if (flag2) { faultCode = "MustUnderstand"; } SoapFault fault2 = new SoapFault(faultCode, builder.ToString(), null, serverFault); info.AddValue("__WrappedObject", fault2, _soapFaultType); } else { MethodBase methodBase = mm.MethodBase; SoapMethodAttribute cachedSoapAttribute = (SoapMethodAttribute)InternalRemotingServices.GetCachedSoapAttribute(methodBase); string responseXmlElementName = cachedSoapAttribute.ResponseXmlElementName; string responseXmlNamespace = cachedSoapAttribute.ResponseXmlNamespace; string returnXmlElementName = cachedSoapAttribute.ReturnXmlElementName; ArgMapper mapper = new ArgMapper(mm, true); object[] args = mapper.Args; info.FullTypeName = responseXmlElementName; info.AssemblyName = responseXmlNamespace; Type returnType = ((MethodInfo)methodBase).ReturnType; if ((returnType != null) && !(returnType == _voidType)) { info.AddValue(returnXmlElementName, mm.ReturnValue, returnType); } if (args != null) { Type[] argTypes = mapper.ArgTypes; for (int i = 0; i < args.Length; i++) { string argName = mapper.GetArgName(i); if ((argName == null) || (argName.Length == 0)) { argName = "__param" + i; } info.AddValue(argName, args[i], argTypes[i].IsByRef ? argTypes[i].GetElementType() : argTypes[i]); } } } } else { IMethodCallMessage m = (IMethodCallMessage)obj; MethodBase mb = m.MethodBase; string xmlNamespaceForMethodCall = SoapServices.GetXmlNamespaceForMethodCall(mb); object[] inArgs = m.InArgs; string[] inArgNames = this.GetInArgNames(m, inArgs.Length); Type[] methodSignature = (Type[])m.MethodSignature; info.FullTypeName = m.MethodName; info.AssemblyName = xmlNamespaceForMethodCall; int[] marshalRequestArgMap = InternalRemotingServices.GetReflectionCachedData(mb).MarshalRequestArgMap; for (int j = 0; j < inArgs.Length; j++) { string name = null; if ((inArgNames[j] == null) || (inArgNames[j].Length == 0)) { name = "__param" + j; } else { name = inArgNames[j]; } int index = marshalRequestArgMap[j]; Type type = null; if (methodSignature[index].IsByRef) { type = methodSignature[index].GetElementType(); } else { type = methodSignature[index]; } info.AddValue(name, inArgs[j], type); } } } }
public virtual void GetObjectData(Object obj, SerializationInfo info, StreamingContext context) { if (info == null) { throw new ArgumentNullException("info"); } if ((obj != null) && (obj != _rootObj)) { (new MessageSurrogate(_ss)).GetObjectData(obj, info, context); } else { IMethodReturnMessage msg = obj as IMethodReturnMessage; if (null != msg) { if (msg.Exception == null) { String responseElementName; String responseElementNS; String returnElementName; // obtain response element name namespace MethodBase mb = msg.MethodBase; SoapMethodAttribute attr = (SoapMethodAttribute)InternalRemotingServices.GetCachedSoapAttribute(mb); responseElementName = attr.ResponseXmlElementName; responseElementNS = attr.ResponseXmlNamespace; returnElementName = attr.ReturnXmlElementName; ArgMapper mapper = new ArgMapper(msg, true /*fOut*/); Object[] args = mapper.Args; info.FullTypeName = responseElementName; info.AssemblyName = responseElementNS; Type retType = ((MethodInfo)mb).ReturnType; if (!((retType == null) || (retType == _voidType))) { info.AddValue(returnElementName, msg.ReturnValue, retType); } if (args != null) { Type[] types = mapper.ArgTypes; for (int i = 0; i < args.Length; i++) { String name; name = mapper.GetArgName(i); if ((name == null) || (name.Length == 0)) { name = "__param" + i; } info.AddValue( name, args[i], types[i].IsByRef? types[i].GetElementType():types[i]); } } } else { Object oClientIsClr = CallContext.GetData("__ClientIsClr"); bool bClientIsClr = (oClientIsClr == null) ? true:(bool)oClientIsClr; info.FullTypeName = "FormatterWrapper"; info.AssemblyName = DefaultFakeRecordAssemblyName; Exception ex = msg.Exception; StringBuilder sb = new StringBuilder(); bool bMustUnderstandError = false; while (ex != null) { if (ex.Message.StartsWith("MustUnderstand")) { bMustUnderstandError = true; } sb.Append(" **** "); sb.Append(ex.GetType().FullName); sb.Append(" - "); sb.Append(ex.Message); ex = ex.InnerException; } ServerFault serverFault = null; if (bClientIsClr) { serverFault = new ServerFault(msg.Exception); // Clr is the Client use full exception } else { serverFault = new ServerFault(msg.Exception.GetType().AssemblyQualifiedName, sb.ToString(), msg.Exception.StackTrace); } String faultType = "Server"; if (bMustUnderstandError) { faultType = "MustUnderstand"; } SoapFault soapFault = new SoapFault(faultType, sb.ToString(), null, serverFault); info.AddValue("__WrappedObject", soapFault, _soapFaultType); } } else { IMethodCallMessage mcm = (IMethodCallMessage)obj; // obtain method namespace MethodBase mb = mcm.MethodBase; String methodElementNS = SoapServices.GetXmlNamespaceForMethodCall(mb); Object[] args = mcm.InArgs; String[] names = GetInArgNames(mcm, args.Length); Type[] sig = (Type[])mcm.MethodSignature; info.FullTypeName = mcm.MethodName; info.AssemblyName = methodElementNS; RemotingMethodCachedData cache = (RemotingMethodCachedData)InternalRemotingServices.GetReflectionCachedData(mb); int[] requestArgMap = cache.MarshalRequestArgMap; BCLDebug.Assert( args != null || sig.Length == args.Length, "Signature mismatch"); for (int i = 0; i < args.Length; i++) { String paramName = null; if ((names[i] == null) || (names[i].Length == 0)) { paramName = "__param" + i; } else { paramName = names[i]; } int sigPosition = requestArgMap[i]; Type argType = null; if (sig[sigPosition].IsByRef) { argType = sig[sigPosition].GetElementType(); } else { argType = sig[sigPosition]; } info.AddValue(paramName, args[i], argType); } } } } // GetObjectData
public virtual void GetObjectData(object obj, SerializationInfo info, StreamingContext context) { if (info == null) { throw new ArgumentNullException("info"); } if (obj != null && obj != this._rootObj) { new MessageSurrogate(this._ss).GetObjectData(obj, info, context); } else { IMethodReturnMessage methodReturnMessage = obj as IMethodReturnMessage; if (methodReturnMessage != null) { if (methodReturnMessage.Exception == null) { MethodBase methodBase = methodReturnMessage.MethodBase; SoapMethodAttribute soapMethodAttribute = (SoapMethodAttribute)InternalRemotingServices.GetCachedSoapAttribute((object)methodBase); string responseXmlElementName = soapMethodAttribute.ResponseXmlElementName; string responseXmlNamespace = soapMethodAttribute.ResponseXmlNamespace; string returnXmlElementName = soapMethodAttribute.ReturnXmlElementName; ArgMapper argMapper = new ArgMapper((IMethodMessage)methodReturnMessage, true); object[] args = argMapper.Args; info.FullTypeName = responseXmlElementName; info.AssemblyName = responseXmlNamespace; Type returnType = ((MethodInfo)methodBase).ReturnType; if (!(returnType == (Type)null) && !(returnType == SoapMessageSurrogate._voidType)) { info.AddValue(returnXmlElementName, methodReturnMessage.ReturnValue, returnType); } if (args == null) { return; } Type[] argTypes = argMapper.ArgTypes; for (int argNum = 0; argNum < args.Length; ++argNum) { string name = argMapper.GetArgName(argNum); if (name == null || name.Length == 0) { name = "__param" + (object)argNum; } info.AddValue(name, args[argNum], argTypes[argNum].IsByRef ? argTypes[argNum].GetElementType() : argTypes[argNum]); } } else { object data = CallContext.GetData("__ClientIsClr"); bool flag1 = data == null || (bool)data; info.FullTypeName = "FormatterWrapper"; info.AssemblyName = this.DefaultFakeRecordAssemblyName; Exception exception = methodReturnMessage.Exception; StringBuilder stringBuilder = new StringBuilder(); bool flag2 = false; for (; exception != null; exception = exception.InnerException) { if (exception.Message.StartsWith("MustUnderstand", StringComparison.Ordinal)) { flag2 = true; } stringBuilder.Append(" **** "); stringBuilder.Append(exception.GetType().FullName); stringBuilder.Append(" - "); stringBuilder.Append(exception.Message); } ServerFault serverFault = !flag1 ? new ServerFault(methodReturnMessage.Exception.GetType().AssemblyQualifiedName, stringBuilder.ToString(), methodReturnMessage.Exception.StackTrace) : new ServerFault(methodReturnMessage.Exception); string faultCode = "Server"; if (flag2) { faultCode = "MustUnderstand"; } SoapFault soapFault = new SoapFault(faultCode, stringBuilder.ToString(), (string)null, serverFault); info.AddValue("__WrappedObject", (object)soapFault, SoapMessageSurrogate._soapFaultType); } } else { IMethodCallMessage m = (IMethodCallMessage)obj; MethodBase methodBase = m.MethodBase; string namespaceForMethodCall = SoapServices.GetXmlNamespaceForMethodCall(methodBase); object[] inArgs = m.InArgs; string[] inArgNames = this.GetInArgNames(m, inArgs.Length); Type[] typeArray = (Type[])m.MethodSignature; info.FullTypeName = m.MethodName; info.AssemblyName = namespaceForMethodCall; int[] marshalRequestArgMap = InternalRemotingServices.GetReflectionCachedData(methodBase).MarshalRequestArgMap; for (int index1 = 0; index1 < inArgs.Length; ++index1) { string name = inArgNames[index1] == null || inArgNames[index1].Length == 0 ? "__param" + (object)index1 : inArgNames[index1]; int index2 = marshalRequestArgMap[index1]; Type type = !typeArray[index2].IsByRef ? typeArray[index2] : typeArray[index2].GetElementType(); info.AddValue(name, inArgs[index1], type); } } } }
public ServerProcessing ProcessMessage(IServerChannelSinkStack sinkStack, IMessage requestMsg, ITransportHeaders requestHeaders, Stream requestStream, out IMessage responseMsg, out ITransportHeaders responseHeaders, out Stream responseStream) { ServerProcessing complete; if (requestMsg != null) { return(this._nextSink.ProcessMessage(sinkStack, requestMsg, requestHeaders, requestStream, out responseMsg, out responseHeaders, out responseStream)); } if (requestHeaders == null) { throw new ArgumentNullException("requestHeaders"); } BaseTransportHeaders headers = requestHeaders as BaseTransportHeaders; responseHeaders = null; responseStream = null; string str = null; string str2 = null; bool flag = true; string contentType = null; if (headers != null) { contentType = headers.ContentType; } else { contentType = requestHeaders["Content-Type"] as string; } if (contentType != null) { string str4; HttpChannelHelper.ParseContentType(contentType, out str2, out str4); } if ((str2 != null) && (string.Compare(str2, "text/xml", StringComparison.Ordinal) != 0)) { flag = false; } if (this._protocol == Protocol.Http) { str = (string)requestHeaders["__RequestVerb"]; if (!str.Equals("POST") && !str.Equals("M-POST")) { flag = false; } } if (!flag) { if (this._nextSink != null) { return(this._nextSink.ProcessMessage(sinkStack, null, requestHeaders, requestStream, out responseMsg, out responseHeaders, out responseStream)); } if (this._protocol != Protocol.Http) { throw new RemotingException(CoreChannel.GetResourceString("Remoting_Channels_InvalidRequestFormat")); } responseHeaders = new TransportHeaders(); responseHeaders["__HttpStatusCode"] = "400"; responseHeaders["__HttpReasonPhrase"] = "Bad Request"; responseStream = null; responseMsg = null; return(ServerProcessing.Complete); } bool bClientIsClr = true; try { string str7; string uRI = null; if (headers != null) { uRI = headers.RequestUri; } else { uRI = (string)requestHeaders["__RequestUri"]; } if (RemotingServices.GetServerTypeForUri(uRI) == null) { throw new RemotingException(CoreChannel.GetResourceString("Remoting_ChnlSink_UriNotPublished")); } if (this._protocol == Protocol.Http) { string str6 = (string)requestHeaders["User-Agent"]; if (str6 != null) { if (str6.IndexOf("MS .NET Remoting") == -1) { bClientIsClr = false; } } else { bClientIsClr = false; } } bool data = true; object obj2 = requestHeaders["__CustomErrorsEnabled"]; if ((obj2 != null) && (obj2 is bool)) { data = (bool)obj2; } CallContext.SetData("__CustomErrorsEnabled", data); Header[] channelHeaders = this.GetChannelHeaders(requestHeaders, out str7); PermissionSet set = null; if (this.TypeFilterLevel != System.Runtime.Serialization.Formatters.TypeFilterLevel.Full) { set = new PermissionSet(PermissionState.None); set.SetPermission(new SecurityPermission(SecurityPermissionFlag.SerializationFormatter)); } try { if (set != null) { set.PermitOnly(); } requestMsg = CoreChannel.DeserializeSoapRequestMessage(requestStream, channelHeaders, this._strictBinding, this.TypeFilterLevel); } finally { if (set != null) { CodeAccessPermission.RevertPermitOnly(); } } requestStream.Close(); if (requestMsg == null) { throw new RemotingException(CoreChannel.GetResourceString("Remoting_DeserializeMessage")); } if ((str7 != null) && !SoapServices.IsSoapActionValidForMethodBase(str7, ((IMethodMessage)requestMsg).MethodBase)) { throw new RemotingException(string.Format(CultureInfo.CurrentCulture, CoreChannel.GetResourceString("Remoting_Soap_InvalidSoapAction"), new object[] { str7 })); } sinkStack.Push(this, null); complete = this._nextSink.ProcessMessage(sinkStack, requestMsg, requestHeaders, null, out responseMsg, out responseHeaders, out responseStream); if (responseStream != null) { throw new RemotingException(CoreChannel.GetResourceString("Remoting_ChnlSink_WantNullResponseStream")); } switch (complete) { case ServerProcessing.Complete: if (responseMsg == null) { throw new RemotingException(CoreChannel.GetResourceString("Remoting_DispatchMessage")); } break; case ServerProcessing.OneWay: sinkStack.Pop(this); return(complete); case ServerProcessing.Async: sinkStack.Store(this, null); return(complete); default: return(complete); } sinkStack.Pop(this); this.SerializeResponse(sinkStack, responseMsg, bClientIsClr, ref responseHeaders, out responseStream); return(complete); } catch (Exception exception) { complete = ServerProcessing.Complete; responseMsg = new ReturnMessage(exception, (requestMsg == null) ? ((IMethodCallMessage) new System.Runtime.Remoting.Channels.Http.ErrorMessage()) : ((IMethodCallMessage)requestMsg)); CallContext.SetData("__ClientIsClr", bClientIsClr); responseStream = (MemoryStream)CoreChannel.SerializeSoapMessage(responseMsg, this._includeVersioning); CallContext.FreeNamedDataSlot("__ClientIsClr"); responseStream.Position = 0L; responseHeaders = new TransportHeaders(); if (this._protocol == Protocol.Http) { responseHeaders["__HttpStatusCode"] = "500"; responseHeaders["__HttpReasonPhrase"] = "Internal Server Error"; responseHeaders["Content-Type"] = "text/xml; charset=\"utf-8\""; } } finally { CallContext.FreeNamedDataSlot("__CustomErrorsEnabled"); } return(complete); }
static void Main(string[] args) { #region temp // int iii=1; // Console.WriteLine("Testing--Pos- re-processing"); // IList<TempModel> new_request1 = new List<TempModel>(MainRepository.TempGetAllRequests()); // foreach(var req in new_request1) // { // string ttt = SoapServices.SendXMLRequest(GetXMLCommands.GetRegisterPayment(req.phoneNumber,req.amount)); // MainRepository.TempUpdateNumber(req); // Console.WriteLine(ttt); // Console.WriteLine(iii++); //// testing // } #endregion Console.WriteLine("Tigo Cash Requests Count_v1.5"); #region Constants string init = ConfigurationManager.AppSettings["init"].ToString(); // "0277551990";//"0573449847";// "0278793422"; string salt = ConfigurationManager.AppSettings["salt"].ToString(); //"0277551990";//"0278793422"; string pin = ConfigurationManager.AppSettings["pin"].ToString(); // "1212";//"1234"; string amount = ConfigurationManager.AppSettings["amount"].ToString(); // "1212";//"1234"; string fundsource = ConfigurationManager.AppSettings["fundsource"].ToString(); // "1212";//"1234"; #endregion int i = 1; while (i > 0) { try { IList <RequestModel> new_request = new List <RequestModel>(MainRepository.GetAllRequests()); int int_temp = 0; foreach (RequestModel req in new_request) { if (MainRepository.OnWhileList(req)) { MainRepository.UpdateTigoCashRequest(req, 3); //SMSService.SendSMSMiddleware("Tigo", "0277443830", "Wc-request"); string session = CreatAndLoginSession(); // int current_count = MainRepository.GetCurrentReceiptNumber() + 1; string reponse = string.Empty; // check if registered- to do; reponse = SoapServices.SendXMLRequest(GetXMLCommands.GetAgentStatusXML(req.SubscriberNumber, session)); #region Registration if (reponse.Contains("cashsubscriber")) { } else { reponse = SoapServices.SendXMLRequest(GetXMLCommands.GetRegisterXML(req.RequestBy, session, req.SubscriberNumber, req.SubscriberName, req.SubscriberAddress, "Ghanaian", req.DOB, req.SubscriberIdType, req.SubscriberIdNumber)); LogService.AutoLog(req.SubscriberNumber, DbFriendly(reponse), "TigoCashWelcomePack"); Console.WriteLine("--log--"); } #endregion #region Activate for (int x = 0; x < 10; x++) { string receiptNumber = GetReceiptNumber(); reponse = SoapServices.SendXMLRequest(GetXMLCommands.GetActivateXML(session, req.SubscriberNumber, init, pin, receiptNumber)); // MainRepository.UpdateReceiptNumber(current_count); LogService.AutoLog(req.SubscriberNumber, DbFriendly(reponse), "TigoCashWelcomePack"); Console.WriteLine("--log--"); if (CheckIfSucessfull(reponse)) { MainRepository.UpdateReceiptNumber(receiptNumber, 1); MainRepository.UpdateTigoCashRequest(req, 4); break; } else { if (reponse.Contains("10006")) { MainRepository.UpdateTigoCashRequest(req, 5); // already active break; } else { MainRepository.UpdateReceiptNumber(receiptNumber, 3); // already used } } } #endregion #region Donate 1GHC //if (MainRepository.CheckIfAlreadyProcessed(req.SubscriberNumber)) //{ //MainRepository.UpdateTigoCashRequest(req, 3); // duplicate request //SMSService.SendSMSMiddleware("Tigo", req.RequestBy, "This subscriber " + req.SubscriberIdNumber + " has already received the tigo cash welcome package."); //} //else //{ // reponse = SoapServices.SendXMLRequest(GetXMLCommands.GetAdjustWalletXML(session, fundsource,req.SubscriberNumber)); // LogService.AutoLog(req.SubscriberNumber, DbFriendly(reponse), "TigoCashWelcomePack"); #endregion #region Check response //if (CheckIfSucessfull(reponse)) //{ // //SMSService.SendSMSMiddleware("Tigo", "0277443830", "WC-request-completed"); // LogService.AutoLog(req.SubscriberNumber, "Operation Successful", "TigoCashWelcomePack"); // MainRepository.UpdateTigoCashRequest(req, 1); // SMSService.SendSMSMiddleware("Tigo", req.SubscriberNumber, "Welcome to Tigo Cash, Your account has been credited with 1 GHC. Smile you've got Tigo"); //} //else //{ // MainRepository.UpdateNumberOfTries(req); // SMSService.SendSMSMiddleware("Tigo", req.RequestBy, req.SubscriberNumber + ", Tigo cash registration was not successful"); //} #endregion //} SMSService.SendSMSMiddleware("Tigo", req.SubscriberNumber, "Welcome to Tigo Cash, Your has been activated."); } else { MainRepository.UpdateTigoCashRequest(req, 2); SMSService.SendSMSMiddleware("Tigo", req.RequestBy, "You are not permitted to undertake Tigo Cash transactions"); } Console.WriteLine("Request No. " + int_temp++); } } catch (Exception ex) { LogService.AutoLog("Application Error", ex.Message, "TigoCashWelcomePack"); Console.WriteLine("--error--"); } } }
String GetHeaders(ISmtpMessage smtpMessage, ref Smtp.Fields headers, ref String contentType, ref Header[] msgHeaders) { // Get the headers from the message object headers = smtpMessage.Fields; #if _DEBUG long count = headers.Count; InternalRemotingServices.RemotingTrace(" Count of fields " + count); for (long i = 0; i < count; i++) { //InternalRemotingServices.RemotingTrace(" Field " + i + " " + headers[i].Name + " " + headers[i].Value); } #endif // Get the content type string Field typeField = headers["urn:schemas:mailheader:contenttype"]; if (null == typeField) { throw new FormatException(CoreChannel.GetResourceString("Remoting_MissingContentType")); } contentType = (String)(typeField.Value); InternalRemotingServices.RemotingTrace("Content type " + typeField.Name + " " + contentType); // Extract the requested uri from the mail header Field uriField = headers["urn:schemas:mailheader:requesteduri"]; if (null == uriField) { throw new FormatException(CoreChannel.GetResourceString("Remoting_MissingRequestedURIHeader")); } String uriValue = (String)uriField.Value; if (null == uriValue) { throw new FormatException(CoreChannel.GetResourceString("Remoting_MissingRequestedURIHeader")); } // process SoapAction (extract the type and the name of the method to be invoked) Field actionField = headers["urn:schemas:mailheader:soapaction"]; if (null == actionField) { throw new FormatException(CoreChannel.GetResourceString("Remoting_SoapActionMissing")); } String actionValue = (String)actionField.Value; if (null == actionValue) { throw new FormatException(CoreChannel.GetResourceString("Remoting_SoapActionMissing")); } String typeName, methodName; if (!SoapServices.GetTypeAndMethodNameFromSoapAction(actionValue, out typeName, out methodName)) { // This means there are multiple methods for this soap action, so we will have to // settle for the type based off of the uri. Type type = RemotingServices.GetServerTypeForUri(uriValue); typeName = type.FullName + ", " + type.Module.Assembly.GetName().Name; } // BUGBUG: need code to verify soap action after the message has been deserialized. // this will probably be done once we have the new activation scenario working. msgHeaders = new Header[3]; msgHeaders[0] = new Header("__Uri", uriValue); msgHeaders[1] = new Header("__TypeName", typeName); msgHeaders[2] = new Header("__MethodName", methodName); // Extract the message sequence number field from the // mail header Field seqField = headers["urn:schemas:mailheader:soapmsgseqnum"]; if (null == seqField) { throw new FormatException(CoreChannel.GetResourceString("Remoting_MissingSoapMsgSeqNum")); } String seqValue = (String)(seqField.Value); InternalRemotingServices.RemotingTrace("Guid value " + seqValue); return(seqValue); }
string GetSoapAction(MethodInfo mb) { return(SoapServices.GetSoapActionFromMethodBase(mb)); }
private bool DeserializeMessage(ISoapMessage message) { string typeNamespace, assemblyName; if (xmlReader.Name == SoapTypeMapper.SoapEnvelopePrefix + ":Fault") { Deserialize(); return(false); } #if FIXED SoapServices.DecodeXmlNamespaceForClrTypeNamespace( xmlReader.NamespaceURI, out typeNamespace, out assemblyName); #endif message.MethodName = xmlReader.LocalName; message.XmlNameSpace = xmlReader.NamespaceURI; ArrayList paramNames = new ArrayList(); ArrayList paramValues = new ArrayList(); long paramValuesId = NextAvailableId; int[] indices = new int[1]; if (!xmlReader.IsEmptyElement) { int initialDepth = xmlReader.Depth; xmlReader.Read(); int i = 0; while (xmlReader.Depth > initialDepth) { long paramId, paramHref; object objParam = null; paramNames.Add(xmlReader.Name); Type paramType = null; if (message.ParamTypes != null) { if (i >= message.ParamTypes.Length) { throw new SerializationException("Not enough parameter types in SoapMessages"); } paramType = message.ParamTypes [i]; } indices[0] = i; objParam = DeserializeComponent( paramType, out paramId, out paramHref, paramValuesId, null, indices); indices[0] = paramValues.Add(objParam); if (paramHref != 0) { RecordFixup(paramValuesId, paramHref, paramValues.ToArray(), null, null, null, indices); } else if (paramId != 0) { // RegisterObject(paramId, objParam, null, paramValuesId, null, indices); } else { } i++; } xmlReader.ReadEndElement(); } else { xmlReader.Read(); } message.ParamNames = (string[])paramNames.ToArray(typeof(string)); message.ParamValues = paramValues.ToArray(); RegisterObject(paramValuesId, message.ParamValues, null, 0, null, null); return(true); }
public Element GetXmlElement(string typeFullName, string assemblyName) { Element element; string typeNamespace = string.Empty; string typeName = typeFullName; if (_assemblyFormat == FormatterAssemblyStyle.Simple) { string[] items = assemblyName.Split(','); assemblyName = items[0]; } string assemblyQualifiedName = typeFullName + ", " + assemblyName; element = (Element)typeToXmlNodeTable[assemblyQualifiedName]; if (element == null) { int typeNameIndex = typeFullName.LastIndexOf('.'); if (typeNameIndex != -1) { typeNamespace = typeFullName.Substring(0, typeNameIndex); typeName = typeFullName.Substring(typeNamespace.Length + 1); } #if FIXED string namespaceURI = SoapServices.CodeXmlNamespaceForClrTypeNamespace( typeNamespace, (!assemblyName.StartsWith("mscorlib")) ? assemblyName : String.Empty); #else string namespaceURI = null; #endif string prefix = (string)namespaceToPrefixTable[namespaceURI]; if (prefix == null || prefix == string.Empty) { prefix = "a" + (_prefixNumber++).ToString(); namespaceToPrefixTable[namespaceURI] = prefix; } int i = typeName.IndexOf("["); if (i != -1) { typeName = XmlConvert.EncodeName(typeName.Substring(0, i)) + typeName.Substring(i); } else { int j = typeName.IndexOf("&"); if (j != -1) { typeName = XmlConvert.EncodeName(typeName.Substring(0, j)) + typeName.Substring(j); } else { typeName = XmlConvert.EncodeName(typeName); } } element = new Element( prefix, typeName, namespaceURI); } return(element); }