Files
dotnet-bot adf899c629 Adding System.Data..., System.ServiceModel..., and System.Web...
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
2016-05-03 00:07:37 +02:00

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