mirror of
https://github.com/BepInEx/mono.git
synced 2026-11-19 01:31:17 -10:00
Adding reference source for System.Data System.Data.DataSetExtensions System.Data.Entity System.Data.Entity.Design System.Data.Linq System.Data.SqlXml System.ServiceModel System.ServiceModel.Activation System.ServiceModel.Activities System.ServiceModel.Channels System.ServiceModel.Discovery System.ServiceModel.Internals System.ServiceModel.Routing System.ServiceModel.WasHosting System.ServiceModel.Web System.Web System.Web.ApplicationServices System.Web.DynamicData System.Web.Entity System.Web.Entity.Design System.Web.Extensions System.Web.Mobile System.Web.Routing System.Web.Services System.Xml System.Xml.Linq
865 lines
44 KiB
C#
865 lines
44 KiB
C#
//------------------------------------------------------------------------------
|
|
// <copyright file="SoapClientProtocol.cs" company="Microsoft">
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
|
// </copyright>
|
|
//------------------------------------------------------------------------------
|
|
|
|
namespace System.Web.Services.Protocols {
|
|
using System;
|
|
using System.Text;
|
|
using System.Collections;
|
|
using System.IO;
|
|
using System.Reflection;
|
|
using System.Xml.Serialization;
|
|
using System.Xml;
|
|
using System.Diagnostics;
|
|
using System.Xml.Schema;
|
|
using System.Web.Services.Description;
|
|
using System.Web.Services.Discovery;
|
|
using System.Web.Services.Configuration;
|
|
using System.Net;
|
|
using System.Security.Permissions;
|
|
using System.Threading;
|
|
using System.ComponentModel;
|
|
using System.Runtime.InteropServices;
|
|
using System.Web.Services.Diagnostics;
|
|
|
|
internal class SoapClientType {
|
|
Hashtable methods = new Hashtable();
|
|
WebServiceBindingAttribute binding;
|
|
|
|
internal SoapReflectedExtension[] HighPriExtensions;
|
|
internal SoapReflectedExtension[] LowPriExtensions;
|
|
internal object[] HighPriExtensionInitializers;
|
|
internal object[] LowPriExtensionInitializers;
|
|
|
|
internal string serviceNamespace;
|
|
internal bool serviceDefaultIsEncoded;
|
|
|
|
internal SoapClientType(Type type) {
|
|
this.binding = WebServiceBindingReflector.GetAttribute(type);
|
|
if (this.binding == null) throw new InvalidOperationException(Res.GetString(Res.WebClientBindingAttributeRequired));
|
|
// Note: Service namespace is taken from WebserviceBindingAttribute and not WebserviceAttribute because
|
|
// the generated proxy does not have a WebServiceAttribute; however all have a WebServiceBindingAttribute.
|
|
serviceNamespace = binding.Namespace;
|
|
serviceDefaultIsEncoded = SoapReflector.ServiceDefaultIsEncoded(type);
|
|
ArrayList soapMethodList = new ArrayList();
|
|
ArrayList mappings = new ArrayList();
|
|
GenerateXmlMappings(type, soapMethodList, serviceNamespace, serviceDefaultIsEncoded, mappings);
|
|
XmlMapping[] xmlMappings = (XmlMapping[])mappings.ToArray(typeof(XmlMapping));
|
|
|
|
TraceMethod caller = Tracing.On ? new TraceMethod(this, ".ctor", type) : null;
|
|
if (Tracing.On) Tracing.Enter(Tracing.TraceId(Res.TraceCreateSerializer), caller, new TraceMethod(typeof(XmlSerializer), "FromMappings", xmlMappings, type));
|
|
XmlSerializer[] serializers = XmlSerializer.FromMappings(xmlMappings, type);
|
|
if (Tracing.On) Tracing.Exit(Tracing.TraceId(Res.TraceCreateSerializer), caller);
|
|
|
|
SoapExtensionTypeElementCollection extensionTypes = WebServicesSection.Current.SoapExtensionTypes;
|
|
ArrayList highPri = new ArrayList();
|
|
ArrayList lowPri = new ArrayList();
|
|
for (int i = 0; i < extensionTypes.Count; i++) {
|
|
SoapExtensionTypeElement element = extensionTypes[i];
|
|
SoapReflectedExtension extension = new SoapReflectedExtension(extensionTypes[i].Type, null, extensionTypes[i].Priority);
|
|
if (extensionTypes[i].Group == PriorityGroup.High)
|
|
highPri.Add(extension);
|
|
else
|
|
lowPri.Add(extension);
|
|
}
|
|
|
|
HighPriExtensions = (SoapReflectedExtension[]) highPri.ToArray(typeof(SoapReflectedExtension));
|
|
LowPriExtensions = (SoapReflectedExtension[]) lowPri.ToArray(typeof(SoapReflectedExtension));
|
|
Array.Sort(HighPriExtensions);
|
|
Array.Sort(LowPriExtensions);
|
|
HighPriExtensionInitializers = SoapReflectedExtension.GetInitializers(type, HighPriExtensions);
|
|
LowPriExtensionInitializers = SoapReflectedExtension.GetInitializers(type, LowPriExtensions);
|
|
|
|
int count = 0;
|
|
for (int i = 0; i < soapMethodList.Count; i++) {
|
|
SoapReflectedMethod soapMethod = (SoapReflectedMethod)soapMethodList[i];
|
|
SoapClientMethod clientMethod = new SoapClientMethod();
|
|
clientMethod.parameterSerializer = serializers[count++];
|
|
if (soapMethod.responseMappings != null) clientMethod.returnSerializer = serializers[count++];
|
|
clientMethod.inHeaderSerializer = serializers[count++];
|
|
if (soapMethod.outHeaderMappings != null) clientMethod.outHeaderSerializer = serializers[count++];
|
|
clientMethod.action = soapMethod.action;
|
|
clientMethod.oneWay = soapMethod.oneWay;
|
|
clientMethod.rpc = soapMethod.rpc;
|
|
clientMethod.use = soapMethod.use;
|
|
clientMethod.paramStyle = soapMethod.paramStyle;
|
|
clientMethod.methodInfo = soapMethod.methodInfo;
|
|
clientMethod.extensions = soapMethod.extensions;
|
|
clientMethod.extensionInitializers = SoapReflectedExtension.GetInitializers(clientMethod.methodInfo, soapMethod.extensions);
|
|
ArrayList inHeaders = new ArrayList();
|
|
ArrayList outHeaders = new ArrayList();
|
|
for (int j = 0; j < soapMethod.headers.Length; j++) {
|
|
SoapHeaderMapping mapping = new SoapHeaderMapping();
|
|
SoapReflectedHeader soapHeader = soapMethod.headers[j];
|
|
mapping.memberInfo = soapHeader.memberInfo;
|
|
mapping.repeats = soapHeader.repeats;
|
|
mapping.custom = soapHeader.custom;
|
|
mapping.direction = soapHeader.direction;
|
|
mapping.headerType = soapHeader.headerType;
|
|
if ((mapping.direction & SoapHeaderDirection.In) != 0)
|
|
inHeaders.Add(mapping);
|
|
if ((mapping.direction & (SoapHeaderDirection.Out | SoapHeaderDirection.Fault)) != 0)
|
|
outHeaders.Add(mapping);
|
|
}
|
|
clientMethod.inHeaderMappings = (SoapHeaderMapping[])inHeaders.ToArray(typeof(SoapHeaderMapping));
|
|
if (clientMethod.outHeaderSerializer != null)
|
|
clientMethod.outHeaderMappings = (SoapHeaderMapping[])outHeaders.ToArray(typeof(SoapHeaderMapping));
|
|
methods.Add(soapMethod.name, clientMethod);
|
|
}
|
|
}
|
|
|
|
internal static void GenerateXmlMappings(Type type, ArrayList soapMethodList, string serviceNamespace, bool serviceDefaultIsEncoded, ArrayList mappings) {
|
|
LogicalMethodInfo[] methodInfos = LogicalMethodInfo.Create(type.GetMethods(BindingFlags.Public | BindingFlags.Instance), LogicalMethodTypes.Sync);
|
|
|
|
SoapReflectionImporter soapImporter = SoapReflector.CreateSoapImporter(serviceNamespace, serviceDefaultIsEncoded);
|
|
XmlReflectionImporter xmlImporter = SoapReflector.CreateXmlImporter(serviceNamespace, serviceDefaultIsEncoded);
|
|
WebMethodReflector.IncludeTypes(methodInfos, xmlImporter);
|
|
SoapReflector.IncludeTypes(methodInfos, soapImporter);
|
|
|
|
|
|
for (int i = 0; i < methodInfos.Length; i++) {
|
|
LogicalMethodInfo methodInfo = methodInfos[i];
|
|
SoapReflectedMethod soapMethod = SoapReflector.ReflectMethod(methodInfo, true, xmlImporter, soapImporter, serviceNamespace);
|
|
if (soapMethod == null) continue;
|
|
soapMethodList.Add(soapMethod);
|
|
mappings.Add(soapMethod.requestMappings);
|
|
if (soapMethod.responseMappings != null) mappings.Add(soapMethod.responseMappings);
|
|
mappings.Add(soapMethod.inHeaderMappings);
|
|
if (soapMethod.outHeaderMappings != null) mappings.Add(soapMethod.outHeaderMappings);
|
|
}
|
|
}
|
|
|
|
internal SoapClientMethod GetMethod(string name) {
|
|
return (SoapClientMethod)methods[name];
|
|
}
|
|
|
|
internal WebServiceBindingAttribute Binding {
|
|
get { return binding; }
|
|
}
|
|
}
|
|
|
|
internal class SoapClientMethod {
|
|
internal XmlSerializer returnSerializer;
|
|
internal XmlSerializer parameterSerializer;
|
|
internal XmlSerializer inHeaderSerializer;
|
|
internal XmlSerializer outHeaderSerializer;
|
|
internal string action;
|
|
internal LogicalMethodInfo methodInfo;
|
|
internal SoapHeaderMapping[] inHeaderMappings;
|
|
internal SoapHeaderMapping[] outHeaderMappings;
|
|
internal SoapReflectedExtension[] extensions;
|
|
internal object[] extensionInitializers;
|
|
internal bool oneWay;
|
|
internal bool rpc;
|
|
internal SoapBindingUse use;
|
|
internal SoapParameterStyle paramStyle;
|
|
}
|
|
|
|
/// <include file='doc\SoapClientProtocol.uex' path='docs/doc[@for="SoapHttpClientProtocol"]/*' />
|
|
/// <devdoc>
|
|
/// <para>
|
|
/// Specifies most of the implementation for communicating with a SOAP web service over HTTP.
|
|
/// </para>
|
|
/// </devdoc>
|
|
[ComVisible(true)]
|
|
public class SoapHttpClientProtocol : HttpWebClientProtocol {
|
|
SoapClientType clientType;
|
|
SoapProtocolVersion version = SoapProtocolVersion.Default;
|
|
|
|
/// <include file='doc\SoapClientProtocol.uex' path='docs/doc[@for="SoapHttpClientProtocol.SoapHttpClientProtocol"]/*' />
|
|
/// <devdoc>
|
|
/// <para>
|
|
/// Initializes a new instance of the <see cref='System.Web.Services.Protocols.SoapHttpClientProtocol'/> class.
|
|
/// </para>
|
|
/// </devdoc>
|
|
public SoapHttpClientProtocol()
|
|
: base() {
|
|
Type type = this.GetType();
|
|
clientType = (SoapClientType)GetFromCache(type);
|
|
if (clientType == null) {
|
|
lock (InternalSyncObject) {
|
|
clientType = (SoapClientType)GetFromCache(type);
|
|
if (clientType == null) {
|
|
clientType = new SoapClientType(type);
|
|
AddToCache(type, clientType);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <include file='doc\SoapClientProtocol.uex' path='docs/doc[@for="SoapHttpClientProtocol.Discover"]/*' />
|
|
/// <devdoc>
|
|
/// <para>[To be supplied.]</para>
|
|
/// </devdoc>
|
|
public void Discover() {
|
|
if (clientType.Binding == null)
|
|
throw new InvalidOperationException(Res.GetString(Res.DiscoveryIsNotPossibleBecauseTypeIsMissing1, this.GetType().FullName));
|
|
DiscoveryClientProtocol disco = new DiscoveryClientProtocol(this);
|
|
DiscoveryDocument doc = disco.Discover(Url);
|
|
foreach (object item in doc.References) {
|
|
System.Web.Services.Discovery.SoapBinding soapBinding = item as System.Web.Services.Discovery.SoapBinding;
|
|
if (soapBinding != null) {
|
|
if (clientType.Binding.Name == soapBinding.Binding.Name &&
|
|
clientType.Binding.Namespace == soapBinding.Binding.Namespace) {
|
|
Url = soapBinding.Address;
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
throw new InvalidOperationException(Res.GetString(Res.TheBindingNamedFromNamespaceWasNotFoundIn3, clientType.Binding.Name, clientType.Binding.Namespace, Url));
|
|
}
|
|
|
|
/// <include file='doc\SoapClientProtocol.uex' path='docs/doc[@for="SoapHttpClientProtocol.GetWebRequest"]/*' />
|
|
/// <devdoc>
|
|
/// <para>[To be supplied.]</para>
|
|
/// </devdoc>
|
|
protected override WebRequest GetWebRequest(Uri uri) {
|
|
WebRequest request = base.GetWebRequest(uri);
|
|
return request;
|
|
}
|
|
|
|
/// <include file='doc\SoapClientProtocol.uex' path='docs/doc[@for="SoapHttpClientProtocol.SoapVersion"]/*' />
|
|
[DefaultValue(SoapProtocolVersion.Default), WebServicesDescription(Res.ClientProtocolSoapVersion), ComVisible(false)]
|
|
public SoapProtocolVersion SoapVersion {
|
|
get { return version; }
|
|
set { version = value; }
|
|
}
|
|
|
|
/// <include file='doc\SoapClientProtocol.uex' path='docs/doc[@for="SoapHttpClientProtocol.GetWriterForMessage"]/*' />
|
|
/// <devdoc>
|
|
/// <para>
|
|
/// Allows to intercept XmlWriter creation.
|
|
/// </para>
|
|
/// </devdoc>
|
|
[PermissionSet(SecurityAction.LinkDemand | SecurityAction.InheritanceDemand, Name = "FullTrust")]
|
|
protected virtual XmlWriter GetWriterForMessage(SoapClientMessage message, int bufferSize) {
|
|
if (bufferSize < 512)
|
|
bufferSize = 512;
|
|
XmlTextWriter writer = new XmlTextWriter(new StreamWriter(message.Stream, RequestEncoding != null ? RequestEncoding : new UTF8Encoding(false), bufferSize));
|
|
/*
|
|
if (RequestEncoding != null && RequestEncoding.GetType() != typeof(UTF8Encoding)) {
|
|
writer = new XmlTextWriter(new StreamWriter(message.Stream, RequestEncoding, bufferSize));
|
|
}
|
|
else {
|
|
XmlWriterSettings ws = new XmlWriterSettings();
|
|
ws.Encoding = new UTF8Encoding(false);
|
|
ws.Indent = false;
|
|
ws.NewLineHandling = NewLineHandling.None;
|
|
writer = XmlWriter.Create(message.Stream, ws);
|
|
}
|
|
*/
|
|
return writer;
|
|
}
|
|
|
|
/// <include file='doc\SoapClientProtocol.uex' path='docs/doc[@for="SoapHttpClientProtocol.GetReaderForMessage"]/*' />
|
|
/// <devdoc>
|
|
/// <para>
|
|
/// Allows to intercept XmlReader creation.
|
|
/// </para>
|
|
/// </devdoc>
|
|
|
|
[PermissionSet(SecurityAction.LinkDemand | SecurityAction.InheritanceDemand, Name = "FullTrust")]
|
|
protected virtual XmlReader GetReaderForMessage(SoapClientMessage message, int bufferSize) {
|
|
Encoding enc = message.SoapVersion == SoapProtocolVersion.Soap12 ? RequestResponseUtils.GetEncoding2(message.ContentType) : RequestResponseUtils.GetEncoding(message.ContentType);
|
|
if (bufferSize < 512)
|
|
bufferSize = 512;
|
|
XmlTextReader reader;
|
|
if (enc != null)
|
|
reader = new XmlTextReader(new StreamReader(message.Stream, enc, true, bufferSize));
|
|
else
|
|
//
|
|
reader = new XmlTextReader(message.Stream);
|
|
|
|
reader.DtdProcessing = DtdProcessing.Prohibit;
|
|
reader.Normalization = true;
|
|
reader.XmlResolver = null;
|
|
|
|
return reader;
|
|
}
|
|
|
|
/// <include file='doc\SoapClientProtocol.uex' path='docs/doc[@for="SoapHttpClientProtocol.Invoke"]/*' />
|
|
/// <devdoc>
|
|
/// <para>
|
|
/// Invokes a method of a SOAP web service.
|
|
/// </para>
|
|
/// </devdoc>
|
|
protected object[] Invoke(string methodName, object[] parameters) {
|
|
WebResponse response = null;
|
|
WebRequest request = null;
|
|
try {
|
|
request = GetWebRequest(Uri);
|
|
NotifyClientCallOut(request);
|
|
//
|
|
PendingSyncRequest = request;
|
|
SoapClientMessage message = BeforeSerialize(request, methodName, parameters);
|
|
Stream requestStream = request.GetRequestStream();
|
|
try {
|
|
message.SetStream(requestStream);
|
|
Serialize(message);
|
|
}
|
|
finally {
|
|
requestStream.Close();
|
|
}
|
|
|
|
response = GetWebResponse(request);
|
|
Stream responseStream = null;
|
|
try {
|
|
responseStream = response.GetResponseStream();
|
|
return ReadResponse(message, response, responseStream, false);
|
|
}
|
|
catch (XmlException e) {
|
|
throw new InvalidOperationException(Res.GetString(Res.WebResponseBadXml), e);
|
|
}
|
|
finally {
|
|
if (responseStream != null)
|
|
responseStream.Close();
|
|
}
|
|
}
|
|
finally {
|
|
if (request == PendingSyncRequest)
|
|
PendingSyncRequest = null;
|
|
}
|
|
}
|
|
|
|
/// <include file='doc\SoapClientProtocol.uex' path='docs/doc[@for="SoapHttpClientProtocol.BeginInvoke"]/*' />
|
|
/// <devdoc>
|
|
/// <para>
|
|
/// Starts an asynchronous invocation of a method of a SOAP web
|
|
/// service.
|
|
/// </para>
|
|
/// </devdoc>
|
|
protected IAsyncResult BeginInvoke(string methodName, object[] parameters, AsyncCallback callback, object asyncState) {
|
|
InvokeAsyncState invokeState = new InvokeAsyncState(methodName, parameters);
|
|
WebClientAsyncResult asyncResult = new WebClientAsyncResult(this, invokeState, null, callback, asyncState);
|
|
return BeginSend(Uri, asyncResult, true);
|
|
}
|
|
|
|
/// <include file='doc\SoapClientProtocol.uex' path='docs/doc[@for="SoapHttpClientProtocol.InitializeAsyncRequest"]/*' />
|
|
/// <devdoc>
|
|
/// <para>[To be supplied.]</para>
|
|
/// </devdoc>
|
|
internal override void InitializeAsyncRequest(WebRequest request, object internalAsyncState) {
|
|
InvokeAsyncState invokeState = (InvokeAsyncState)internalAsyncState;
|
|
invokeState.Message = BeforeSerialize(request, invokeState.MethodName, invokeState.Parameters);
|
|
}
|
|
|
|
internal override void AsyncBufferedSerialize(WebRequest request, Stream requestStream, object internalAsyncState) {
|
|
InvokeAsyncState invokeState = (InvokeAsyncState)internalAsyncState;
|
|
SoapClientMessage message = invokeState.Message;
|
|
message.SetStream(requestStream);
|
|
Serialize(invokeState.Message);
|
|
}
|
|
|
|
class InvokeAsyncState {
|
|
public string MethodName;
|
|
public object[] Parameters;
|
|
public SoapClientMessage Message;
|
|
|
|
public InvokeAsyncState(string methodName, object[] parameters) {
|
|
this.MethodName = methodName;
|
|
this.Parameters = parameters;
|
|
}
|
|
}
|
|
|
|
/// <include file='doc\SoapClientProtocol.uex' path='docs/doc[@for="SoapHttpClientProtocol.EndInvoke"]/*' />
|
|
/// <devdoc>
|
|
/// <para>
|
|
/// Ends an asynchronous invocation of a method of a remote SOAP web service.
|
|
/// </para>
|
|
/// </devdoc>
|
|
protected object[] EndInvoke(IAsyncResult asyncResult) {
|
|
object o = null;
|
|
Stream responseStream = null;
|
|
try {
|
|
WebResponse response = EndSend(asyncResult, ref o, ref responseStream);
|
|
InvokeAsyncState invokeState = (InvokeAsyncState)o;
|
|
return ReadResponse(invokeState.Message, response, responseStream, true);
|
|
}
|
|
catch (XmlException e) {
|
|
throw new InvalidOperationException(Res.GetString(Res.WebResponseBadXml), e);
|
|
}
|
|
finally {
|
|
if (responseStream != null)
|
|
responseStream.Close();
|
|
}
|
|
}
|
|
|
|
private void InvokeAsyncCallback(IAsyncResult result) {
|
|
object[] parameters = null;
|
|
Exception exception = null;
|
|
|
|
WebClientAsyncResult asyncResult = (WebClientAsyncResult)result;
|
|
if (asyncResult.Request != null) {
|
|
object o = null;
|
|
Stream responseStream = null;
|
|
try {
|
|
WebResponse response = EndSend(asyncResult, ref o, ref responseStream);
|
|
InvokeAsyncState invokeState = (InvokeAsyncState)o;
|
|
parameters = ReadResponse(invokeState.Message, response, responseStream, true);
|
|
}
|
|
catch (XmlException e) {
|
|
if (Tracing.On) Tracing.ExceptionCatch(TraceEventType.Warning, this, "InvokeAsyncCallback", e);
|
|
exception = new InvalidOperationException(Res.GetString(Res.WebResponseBadXml), e);
|
|
}
|
|
catch (Exception e) {
|
|
if (e is ThreadAbortException || e is StackOverflowException || e is OutOfMemoryException)
|
|
throw;
|
|
if (Tracing.On) Tracing.ExceptionCatch(TraceEventType.Warning, this, "InvokeAsyncCallback", e);
|
|
exception = e;
|
|
}
|
|
finally {
|
|
if (responseStream != null)
|
|
responseStream.Close();
|
|
}
|
|
}
|
|
AsyncOperation asyncOp = (AsyncOperation)result.AsyncState;
|
|
UserToken token = (UserToken)asyncOp.UserSuppliedState;
|
|
OperationCompleted(token.UserState, parameters, exception, false);
|
|
}
|
|
|
|
/// <include file='doc\SoapClientProtocol.uex' path='docs/doc[@for="SoapClientProtocol.InvokeAsync"]/*' />
|
|
/// <devdoc>
|
|
/// <para>[To be supplied.]</para>
|
|
/// </devdoc>
|
|
protected void InvokeAsync(string methodName, object[] parameters, SendOrPostCallback callback) {
|
|
InvokeAsync(methodName, parameters, callback, null);
|
|
}
|
|
|
|
/// <include file='doc\SoapClientProtocol.uex' path='docs/doc[@for="SoapClientProtocol.InvokeAsync1"]/*' />
|
|
/// <devdoc>
|
|
/// <para>[To be supplied.]</para>
|
|
/// </devdoc>
|
|
protected void InvokeAsync(string methodName, object[] parameters, SendOrPostCallback callback, object userState) {
|
|
if (userState == null)
|
|
userState = NullToken;
|
|
InvokeAsyncState invokeState = new InvokeAsyncState(methodName, parameters);
|
|
AsyncOperation asyncOp = AsyncOperationManager.CreateOperation(new UserToken(callback, userState));
|
|
WebClientAsyncResult asyncResult = new WebClientAsyncResult(this, invokeState, null, new AsyncCallback(InvokeAsyncCallback), asyncOp);
|
|
try {
|
|
AsyncInvokes.Add(userState, asyncResult);
|
|
}
|
|
catch (Exception e) {
|
|
if (e is ThreadAbortException || e is StackOverflowException || e is OutOfMemoryException)
|
|
throw;
|
|
if (Tracing.On) Tracing.ExceptionCatch(TraceEventType.Warning, this, "InvokeAsync", e);
|
|
Exception exception = new ArgumentException(Res.GetString(Res.AsyncDuplicateUserState), e);
|
|
InvokeCompletedEventArgs eventArgs = new InvokeCompletedEventArgs(new object[] { null }, exception, false, userState);
|
|
asyncOp.PostOperationCompleted(callback, eventArgs);
|
|
return;
|
|
}
|
|
try {
|
|
BeginSend(Uri, asyncResult, true);
|
|
}
|
|
catch (Exception e) {
|
|
if (e is ThreadAbortException || e is StackOverflowException || e is OutOfMemoryException)
|
|
throw;
|
|
if (Tracing.On) Tracing.ExceptionCatch(TraceEventType.Warning, this, "InvokeAsync", e);
|
|
OperationCompleted(userState, new object[] { null }, e, false);
|
|
}
|
|
}
|
|
|
|
private static Array CombineExtensionsHelper(Array array1, Array array2, Array array3, Type elementType) {
|
|
int length = array1.Length + array2.Length + array3.Length;
|
|
if (length == 0)
|
|
return null;
|
|
Array result = null;
|
|
if (elementType == typeof(SoapReflectedExtension))
|
|
result = new SoapReflectedExtension[length];
|
|
else if (elementType == typeof(object))
|
|
result = new object[length];
|
|
else
|
|
throw new ArgumentException(Res.GetString(Res.ElementTypeMustBeObjectOrSoapReflectedException), "elementType");
|
|
|
|
int pos = 0;
|
|
Array.Copy(array1, 0, result, pos, array1.Length);
|
|
pos += array1.Length;
|
|
Array.Copy(array2, 0, result, pos, array2.Length);
|
|
pos += array2.Length;
|
|
Array.Copy(array3, 0, result, pos, array3.Length);
|
|
return result;
|
|
}
|
|
|
|
private string EnvelopeNs {
|
|
get {
|
|
return this.version == SoapProtocolVersion.Soap12 ? Soap12.Namespace : Soap.Namespace;
|
|
}
|
|
}
|
|
|
|
private string EncodingNs {
|
|
get {
|
|
return this.version == SoapProtocolVersion.Soap12 ? Soap12.Encoding : Soap.Encoding;
|
|
}
|
|
}
|
|
|
|
private string HttpContentType {
|
|
get {
|
|
return this.version == SoapProtocolVersion.Soap12 ? ContentType.ApplicationSoap : ContentType.TextXml;
|
|
}
|
|
}
|
|
|
|
SoapClientMessage BeforeSerialize(WebRequest request, string methodName, object[] parameters) {
|
|
if (parameters == null) throw new ArgumentNullException("parameters");
|
|
SoapClientMethod method = clientType.GetMethod(methodName);
|
|
if (method == null) throw new ArgumentException(Res.GetString(Res.WebInvalidMethodName, methodName));
|
|
|
|
// Run BeforeSerialize extension pass. Extensions are not allowed
|
|
// to write into the stream during this pass.
|
|
SoapReflectedExtension[] allExtensions = (SoapReflectedExtension[])CombineExtensionsHelper(clientType.HighPriExtensions, method.extensions, clientType.LowPriExtensions, typeof(SoapReflectedExtension));
|
|
object[] allExtensionInitializers = (object[])CombineExtensionsHelper(clientType.HighPriExtensionInitializers, method.extensionInitializers, clientType.LowPriExtensionInitializers, typeof(object));
|
|
SoapExtension[] initializedExtensions = SoapMessage.InitializeExtensions(allExtensions, allExtensionInitializers);
|
|
SoapClientMessage message = new SoapClientMessage(this, method, Url);
|
|
message.initializedExtensions = initializedExtensions;
|
|
if (initializedExtensions != null)
|
|
message.SetExtensionStream(new SoapExtensionStream());
|
|
message.InitExtensionStreamChain(message.initializedExtensions);
|
|
|
|
string soapAction = UrlEncoder.EscapeString(method.action, Encoding.UTF8);
|
|
message.SetStage(SoapMessageStage.BeforeSerialize);
|
|
if (this.version == SoapProtocolVersion.Soap12)
|
|
message.ContentType = ContentType.Compose(ContentType.ApplicationSoap, RequestEncoding != null ? RequestEncoding : Encoding.UTF8, soapAction);
|
|
else
|
|
message.ContentType = ContentType.Compose(ContentType.TextXml, RequestEncoding != null ? RequestEncoding : Encoding.UTF8);
|
|
message.SetParameterValues(parameters);
|
|
SoapHeaderHandling.GetHeaderMembers(message.Headers, this, method.inHeaderMappings, SoapHeaderDirection.In, true);
|
|
message.RunExtensions(message.initializedExtensions, true);
|
|
|
|
// Last chance to set request headers
|
|
request.ContentType = message.ContentType;
|
|
if (message.ContentEncoding != null && message.ContentEncoding.Length > 0)
|
|
request.Headers[ContentType.ContentEncoding] = message.ContentEncoding;
|
|
|
|
request.Method = "POST";
|
|
if (this.version != SoapProtocolVersion.Soap12 && request.Headers[Soap.Action] == null) {
|
|
StringBuilder actionStringBuilder = new StringBuilder(soapAction.Length + 2);
|
|
actionStringBuilder.Append('"');
|
|
actionStringBuilder.Append(soapAction);
|
|
actionStringBuilder.Append('"');
|
|
request.Headers.Add(Soap.Action, actionStringBuilder.ToString());
|
|
}
|
|
|
|
return message;
|
|
}
|
|
|
|
void Serialize(SoapClientMessage message) {
|
|
Stream stream = message.Stream;
|
|
SoapClientMethod method = message.Method;
|
|
bool isEncoded = method.use == SoapBindingUse.Encoded;
|
|
|
|
// Serialize the message.
|
|
string envelopeNs = EnvelopeNs;
|
|
string encodingNs = EncodingNs;
|
|
|
|
XmlWriter writer = GetWriterForMessage(message, 1024);
|
|
if (writer == null)
|
|
throw new InvalidOperationException(Res.GetString(Res.WebNullWriterForMessage));
|
|
|
|
writer.WriteStartDocument();
|
|
writer.WriteStartElement(Soap.Prefix, Soap.Element.Envelope, envelopeNs);
|
|
writer.WriteAttributeString("xmlns", Soap.Prefix, null, envelopeNs);
|
|
if (isEncoded) {
|
|
writer.WriteAttributeString("xmlns", "soapenc", null, encodingNs);
|
|
writer.WriteAttributeString("xmlns", "tns", null, clientType.serviceNamespace);
|
|
writer.WriteAttributeString("xmlns", "types", null, SoapReflector.GetEncodedNamespace(clientType.serviceNamespace, clientType.serviceDefaultIsEncoded));
|
|
}
|
|
writer.WriteAttributeString("xmlns", "xsi", null, XmlSchema.InstanceNamespace);
|
|
writer.WriteAttributeString("xmlns", "xsd", null, XmlSchema.Namespace);
|
|
SoapHeaderHandling.WriteHeaders(writer, method.inHeaderSerializer, message.Headers, method.inHeaderMappings, SoapHeaderDirection.In, isEncoded, clientType.serviceNamespace, clientType.serviceDefaultIsEncoded, envelopeNs);
|
|
writer.WriteStartElement(Soap.Element.Body, envelopeNs);
|
|
if (isEncoded && version != SoapProtocolVersion.Soap12) // don't write encodingStyle on soap:Body for soap 1.2
|
|
writer.WriteAttributeString("soap", Soap.Attribute.EncodingStyle, null, encodingNs);
|
|
|
|
object[] parameters = message.GetParameterValues();
|
|
TraceMethod caller = Tracing.On ? new TraceMethod(this, "Serialize") : null;
|
|
|
|
if (Tracing.On) Tracing.Enter(Tracing.TraceId(Res.TraceWriteRequest), caller, new TraceMethod(method.parameterSerializer, "Serialize", writer, parameters, null, isEncoded ? encodingNs : null));
|
|
method.parameterSerializer.Serialize(writer, parameters, null, isEncoded ? encodingNs : null);
|
|
if (Tracing.On) Tracing.Exit(Tracing.TraceId(Res.TraceWriteRequest), caller);
|
|
|
|
writer.WriteEndElement();
|
|
writer.WriteEndElement();
|
|
writer.Flush();
|
|
|
|
// run the after serialize extension pass.
|
|
message.SetStage(SoapMessageStage.AfterSerialize);
|
|
message.RunExtensions(message.initializedExtensions, true);
|
|
}
|
|
|
|
object[] ReadResponse(SoapClientMessage message, WebResponse response, Stream responseStream, bool asyncCall) {
|
|
SoapClientMethod method = message.Method;
|
|
|
|
//
|
|
|
|
|
|
HttpWebResponse httpResponse = response as HttpWebResponse;
|
|
int statusCode = httpResponse != null ? (int)httpResponse.StatusCode : -1;
|
|
if (statusCode >= 300 && statusCode != 500 && statusCode != 400)
|
|
throw new WebException(RequestResponseUtils.CreateResponseExceptionString(httpResponse, responseStream), null,
|
|
WebExceptionStatus.ProtocolError, httpResponse);
|
|
|
|
message.Headers.Clear();
|
|
message.SetStream(responseStream);
|
|
message.InitExtensionStreamChain(message.initializedExtensions);
|
|
|
|
message.SetStage(SoapMessageStage.BeforeDeserialize);
|
|
message.ContentType = response.ContentType;
|
|
message.ContentEncoding = response.Headers[ContentType.ContentEncoding];
|
|
message.RunExtensions(message.initializedExtensions, false);
|
|
|
|
if (method.oneWay && (httpResponse == null || (int)httpResponse.StatusCode != 500)) {
|
|
return new object[0];
|
|
}
|
|
|
|
// this statusCode check is just so we don't repeat the contentType check we did above
|
|
bool isSoap = ContentType.IsSoap(message.ContentType);
|
|
if (!isSoap || (isSoap && (httpResponse != null) && (httpResponse.ContentLength == 0))) {
|
|
// special-case 400 since we exempted it above on the off-chance it might be a soap 1.2 sender fault.
|
|
// based on the content-type, it looks like it's probably just a regular old 400
|
|
if (statusCode == 400)
|
|
throw new WebException(RequestResponseUtils.CreateResponseExceptionString(httpResponse, responseStream), null,
|
|
WebExceptionStatus.ProtocolError, httpResponse);
|
|
else
|
|
throw new InvalidOperationException(Res.GetString(Res.WebResponseContent, message.ContentType, HttpContentType) +
|
|
Environment.NewLine +
|
|
RequestResponseUtils.CreateResponseExceptionString(response, responseStream));
|
|
}
|
|
if (message.Exception != null) {
|
|
throw message.Exception;
|
|
}
|
|
|
|
// perf fix: changed buffer size passed to StreamReader
|
|
int bufferSize;
|
|
if (asyncCall || httpResponse == null)
|
|
bufferSize = 512;
|
|
else {
|
|
bufferSize = RequestResponseUtils.GetBufferSize((int)httpResponse.ContentLength);
|
|
}
|
|
XmlReader reader = GetReaderForMessage(message, bufferSize);
|
|
if (reader == null)
|
|
throw new InvalidOperationException(Res.GetString(Res.WebNullReaderForMessage));
|
|
|
|
reader.MoveToContent();
|
|
int depth = reader.Depth;
|
|
|
|
// should be able to handle no ns, soap 1.1 ns, or soap 1.2 ns
|
|
string encodingNs = EncodingNs;
|
|
string envelopeNs = reader.NamespaceURI;
|
|
|
|
if (envelopeNs == null || envelopeNs.Length == 0)
|
|
// ok to omit namespace -- assume correct version
|
|
reader.ReadStartElement(Soap.Element.Envelope);
|
|
else if (reader.NamespaceURI == Soap.Namespace)
|
|
reader.ReadStartElement(Soap.Element.Envelope, Soap.Namespace);
|
|
else if (reader.NamespaceURI == Soap12.Namespace)
|
|
reader.ReadStartElement(Soap.Element.Envelope, Soap12.Namespace);
|
|
else
|
|
throw new SoapException(Res.GetString(Res.WebInvalidEnvelopeNamespace, envelopeNs, EnvelopeNs), SoapException.VersionMismatchFaultCode);
|
|
|
|
reader.MoveToContent();
|
|
SoapHeaderHandling headerHandler = new SoapHeaderHandling();
|
|
headerHandler.ReadHeaders(reader, method.outHeaderSerializer, message.Headers, method.outHeaderMappings, SoapHeaderDirection.Out | SoapHeaderDirection.Fault, envelopeNs, method.use == SoapBindingUse.Encoded ? encodingNs : null, false);
|
|
reader.MoveToContent();
|
|
reader.ReadStartElement(Soap.Element.Body, envelopeNs);
|
|
reader.MoveToContent();
|
|
if (reader.IsStartElement(Soap.Element.Fault, envelopeNs)) {
|
|
message.Exception = ReadSoapException(reader);
|
|
}
|
|
else {
|
|
if (method.oneWay) {
|
|
reader.Skip();
|
|
message.SetParameterValues(new object[0]);
|
|
}
|
|
else {
|
|
TraceMethod caller = Tracing.On ? new TraceMethod(this, "ReadResponse") : null;
|
|
bool isEncodedSoap = method.use == SoapBindingUse.Encoded;
|
|
if (Tracing.On) Tracing.Enter(Tracing.TraceId(Res.TraceReadResponse), caller, new TraceMethod(method.returnSerializer, "Deserialize", reader, isEncodedSoap ? encodingNs : null));
|
|
|
|
bool useDeserializationEvents = !isEncodedSoap && (WebServicesSection.Current.SoapEnvelopeProcessing.IsStrict || Tracing.On);
|
|
if (useDeserializationEvents) {
|
|
XmlDeserializationEvents events = Tracing.On ? Tracing.GetDeserializationEvents() : RuntimeUtils.GetDeserializationEvents();
|
|
message.SetParameterValues((object[])method.returnSerializer.Deserialize(reader, null, events));
|
|
}
|
|
else {
|
|
message.SetParameterValues((object[])method.returnSerializer.Deserialize(reader, isEncodedSoap ? encodingNs : null));
|
|
}
|
|
|
|
if (Tracing.On) Tracing.Exit(Tracing.TraceId(Res.TraceReadResponse), caller);
|
|
}
|
|
}
|
|
|
|
// Consume soap:Body and soap:Envelope closing tags
|
|
while (depth < reader.Depth && reader.Read()) {
|
|
// Nothing, just read on
|
|
}
|
|
// consume end tag
|
|
if (reader.NodeType == XmlNodeType.EndElement) {
|
|
reader.Read();
|
|
}
|
|
|
|
message.SetStage(SoapMessageStage.AfterDeserialize);
|
|
message.RunExtensions(message.initializedExtensions, false);
|
|
SoapHeaderHandling.SetHeaderMembers(message.Headers, this, method.outHeaderMappings, SoapHeaderDirection.Out | SoapHeaderDirection.Fault, true);
|
|
|
|
if (message.Exception != null) throw message.Exception;
|
|
return message.GetParameterValues();
|
|
}
|
|
|
|
SoapException ReadSoapException(XmlReader reader) {
|
|
XmlQualifiedName faultCode = XmlQualifiedName.Empty;
|
|
string faultString = null;
|
|
string faultActor = null;
|
|
string faultRole = null;
|
|
XmlNode detail = null;
|
|
SoapFaultSubCode subcode = null;
|
|
string lang = null;
|
|
bool soap12 = (reader.NamespaceURI == Soap12.Namespace);
|
|
if (reader.IsEmptyElement) {
|
|
reader.Skip();
|
|
}
|
|
else {
|
|
reader.ReadStartElement();
|
|
reader.MoveToContent();
|
|
int depth = reader.Depth;
|
|
while (reader.NodeType != XmlNodeType.EndElement && reader.NodeType != XmlNodeType.None) {
|
|
if (reader.NamespaceURI == Soap.Namespace || reader.NamespaceURI == Soap12.Namespace || reader.NamespaceURI == null || reader.NamespaceURI.Length == 0) {
|
|
if (reader.LocalName == Soap.Element.FaultCode || reader.LocalName == Soap12.Element.FaultCode) {
|
|
if (soap12)
|
|
faultCode = ReadSoap12FaultCode(reader, out subcode);
|
|
else
|
|
faultCode = ReadFaultCode(reader);
|
|
}
|
|
else if (reader.LocalName == Soap.Element.FaultString) {
|
|
lang = reader.GetAttribute(Soap.Attribute.Lang, Soap.XmlNamespace);
|
|
reader.MoveToElement();
|
|
faultString = reader.ReadElementString();
|
|
}
|
|
else if (reader.LocalName == Soap12.Element.FaultReason) {
|
|
if (reader.IsEmptyElement)
|
|
reader.Skip();
|
|
else {
|
|
reader.ReadStartElement(); // consume Reason element to get to Text child
|
|
reader.MoveToContent();
|
|
while (reader.NodeType != XmlNodeType.EndElement && reader.NodeType != XmlNodeType.None) {
|
|
if (reader.LocalName == Soap12.Element.FaultReasonText && reader.NamespaceURI == Soap12.Namespace) {
|
|
faultString = reader.ReadElementString();
|
|
}
|
|
else {
|
|
reader.Skip();
|
|
}
|
|
reader.MoveToContent();
|
|
}
|
|
while (reader.NodeType == XmlNodeType.Whitespace) reader.Skip();
|
|
if (reader.NodeType == XmlNodeType.None) reader.Skip();
|
|
else reader.ReadEndElement();
|
|
}
|
|
}
|
|
else if (reader.LocalName == Soap.Element.FaultActor || reader.LocalName == Soap12.Element.FaultNode) {
|
|
faultActor = reader.ReadElementString();
|
|
}
|
|
else if (reader.LocalName == Soap.Element.FaultDetail || reader.LocalName == Soap12.Element.FaultDetail) {
|
|
detail = new XmlDocument().ReadNode(reader);
|
|
}
|
|
else if (reader.LocalName == Soap12.Element.FaultRole) {
|
|
faultRole = reader.ReadElementString();
|
|
}
|
|
else {
|
|
reader.Skip();
|
|
}
|
|
}
|
|
else {
|
|
reader.Skip();
|
|
}
|
|
reader.MoveToContent();
|
|
}
|
|
// Consume soap:Body and soap:Envelope closing tags
|
|
while (reader.Read() && depth < reader.Depth) {
|
|
// Nothing, just read on
|
|
}
|
|
// consume end tag
|
|
if (reader.NodeType == XmlNodeType.EndElement) {
|
|
reader.Read();
|
|
}
|
|
}
|
|
if (detail != null || soap12) // with soap 1.2, can't tell if fault is for header
|
|
return new SoapException(faultString, faultCode, faultActor, faultRole, lang, detail, subcode, null);
|
|
else
|
|
return new SoapHeaderException(faultString, faultCode, faultActor, faultRole, lang, subcode, null);
|
|
}
|
|
|
|
private XmlQualifiedName ReadSoap12FaultCode(XmlReader reader, out SoapFaultSubCode subcode) {
|
|
SoapFaultSubCode code = ReadSoap12FaultCodesRecursive(reader, 0);
|
|
if (code == null) {
|
|
subcode = null;
|
|
return null;
|
|
}
|
|
else {
|
|
subcode = code.SubCode;
|
|
return code.Code;
|
|
}
|
|
}
|
|
|
|
private SoapFaultSubCode ReadSoap12FaultCodesRecursive(XmlReader reader, int depth) {
|
|
if (depth > 100) return null;
|
|
if (reader.IsEmptyElement) {
|
|
reader.Skip();
|
|
return null;
|
|
}
|
|
XmlQualifiedName code = null;
|
|
SoapFaultSubCode subcode = null;
|
|
int faultDepth = reader.Depth;
|
|
reader.ReadStartElement();
|
|
reader.MoveToContent();
|
|
while (reader.NodeType != XmlNodeType.EndElement && reader.NodeType != XmlNodeType.None) {
|
|
if (reader.NamespaceURI == Soap12.Namespace || reader.NamespaceURI == null || reader.NamespaceURI.Length == 0) {
|
|
if (reader.LocalName == Soap12.Element.FaultCodeValue) {
|
|
code = ReadFaultCode(reader);
|
|
}
|
|
else if (reader.LocalName == Soap12.Element.FaultSubcode) {
|
|
subcode = ReadSoap12FaultCodesRecursive(reader, depth + 1);
|
|
}
|
|
else {
|
|
reader.Skip();
|
|
}
|
|
}
|
|
else {
|
|
reader.Skip();
|
|
}
|
|
reader.MoveToContent();
|
|
}
|
|
// Consume closing tag
|
|
while (faultDepth < reader.Depth && reader.Read()) {
|
|
// Nothing, just read on
|
|
}
|
|
// consume end tag
|
|
if (reader.NodeType == XmlNodeType.EndElement) {
|
|
reader.Read();
|
|
}
|
|
|
|
return new SoapFaultSubCode(code, subcode);
|
|
}
|
|
|
|
private XmlQualifiedName ReadFaultCode(XmlReader reader) {
|
|
if (reader.IsEmptyElement) {
|
|
reader.Skip();
|
|
return null;
|
|
}
|
|
reader.ReadStartElement();
|
|
string qnameValue = reader.ReadString();
|
|
int colon = qnameValue.IndexOf(":", StringComparison.Ordinal);
|
|
string ns = reader.NamespaceURI;
|
|
if (colon >= 0) {
|
|
string prefix = qnameValue.Substring(0, colon);
|
|
ns = reader.LookupNamespace(prefix);
|
|
if (ns == null)
|
|
throw new InvalidOperationException(Res.GetString(Res.WebQNamePrefixUndefined, prefix));
|
|
}
|
|
reader.ReadEndElement();
|
|
|
|
return new XmlQualifiedName(qnameValue.Substring(colon + 1), ns);
|
|
}
|
|
}
|
|
}
|
|
|
|
|