internal override object[] ReadParameters() {
message.InitExtensionStreamChain(message.otherExtensions);
message.RunExtensions(message.otherExtensions, true);
// do a sanity check on the content-type before we check the version since otherwise the error might be really nasty
if (!ContentType.IsSoap(message.ContentType))
throw new SoapException(Res.GetString(Res.WebRequestContent, message.ContentType, helper.HttpContentType),
new XmlQualifiedName(Soap.Code.Client, Soap.Namespace), new SoapFaultSubCode(Soap12FaultCodes.UnsupportedMediaTypeFaultCode));
// now that all the extensions have run, establish the real version of the request
XmlReader reader = null;
try {
reader = GetXmlReader();
reader.MoveToContent();
SetHelper(SoapServerProtocolHelper.GetHelper(this, reader.NamespaceURI));
}
catch (XmlException e) {
throw new SoapException(Res.GetString(Res.WebRequestUnableToRead), new XmlQualifiedName(Soap.Code.Client, Soap.Namespace), e);
}
CheckHelperVersion();
// now do a more specific content-type check for soap 1.1 only (soap 1.2 allows various xml content types)
if (version == SoapProtocolVersion.Soap11 && !ContentType.MatchesBase(message.ContentType, helper.HttpContentType))
throw new SoapException(Res.GetString(Res.WebRequestContent, message.ContentType, helper.HttpContentType),
new XmlQualifiedName(Soap.Code.Client, Soap.Namespace), new SoapFaultSubCode(Soap12FaultCodes.UnsupportedMediaTypeFaultCode));
if (message.Exception != null) {
throw message.Exception;
}
try {
if (!reader.IsStartElement(Soap.Element.Envelope, helper.EnvelopeNs))
throw new InvalidOperationException(Res.GetString(Res.WebMissingEnvelopeElement));
if (reader.IsEmptyElement)
throw new InvalidOperationException(Res.GetString(Res.WebMissingBodyElement));
int depth = reader.Depth;
reader.ReadStartElement(Soap.Element.Envelope, helper.EnvelopeNs);
reader.MoveToContent();
// run time check for R2738 A MESSAGE MUST include all soapbind:headers specified on a wsdl:input or wsdl:output of a wsdl:operationwsdl:binding that describes it.
bool checkRequiredHeaders = (this.serverMethod.wsiClaims & WsiProfiles.BasicProfile1_1) != 0 && version != SoapProtocolVersion.Soap12;
string missingHeader = new SoapHeaderHandling().ReadHeaders(reader, serverMethod.inHeaderSerializer, message.Headers, serverMethod.inHeaderMappings, SoapHeaderDirection.In, helper.EnvelopeNs, serverMethod.use == SoapBindingUse.Encoded ? helper.EncodingNs : null, checkRequiredHeaders);
if (missingHeader != null) {
throw new SoapHeaderException(Res.GetString(Res.WebMissingHeader, missingHeader),
new XmlQualifiedName(Soap.Code.MustUnderstand, Soap.Namespace));
}
if (!reader.IsStartElement(Soap.Element.Body, helper.EnvelopeNs))
throw new InvalidOperationException(Res.GetString(Res.WebMissingBodyElement));
reader.ReadStartElement(Soap.Element.Body, helper.EnvelopeNs);
reader.MoveToContent();
object[] values;
bool isEncodedSoap = serverMethod.use == SoapBindingUse.Encoded;
TraceMethod caller = Tracing.On ? new TraceMethod(this, "ReadParameters") : null;
if (Tracing.On) Tracing.Enter(Tracing.TraceId(Res.TraceReadRequest), caller, new TraceMethod(serverMethod.parameterSerializer, "Deserialize", reader, serverMethod.use == SoapBindingUse.Encoded ? helper.EncodingNs : null));
bool useDeserializationEvents = !isEncodedSoap && (WebServicesSection.Current.SoapEnvelopeProcessing.IsStrict || Tracing.On);
if (useDeserializationEvents) {
XmlDeserializationEvents events = Tracing.On ? Tracing.GetDeserializationEvents() : RuntimeUtils.GetDeserializationEvents();
values = (object[])serverMethod.parameterSerializer.Deserialize(reader, null, events);
}
else {
values = (object[])serverMethod.parameterSerializer.Deserialize(reader, isEncodedSoap ? helper.EncodingNs : null);
}
if (Tracing.On) Tracing.Exit(Tracing.TraceId(Res.TraceReadRequest), 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.SetParameterValues(values);
return values;
}
catch (SoapException) {
throw;
}
catch (Exception e) {
if (e is ThreadAbortException || e is StackOverflowException || e is OutOfMemoryException) {
throw;
}
throw new SoapException(Res.GetString(Res.WebRequestUnableToRead), new XmlQualifiedName(Soap.Code.Client, Soap.Namespace), e);
}
}
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();
}
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);
}
internal override bool WriteException(Exception e, Stream outputStream)
{
if (message == null)
{
return(false);
}
message.Headers.Clear();
if (serverMethod != null)
{
SoapHeaderHandling.GetHeaderMembers(message.Headers, this.Target, serverMethod.outHeaderMappings, SoapHeaderDirection.Fault, false);
}
SoapException soapException;
if (e is SoapException)
{
soapException = (SoapException)e;
}
else if (serverMethod != null && serverMethod.rpc && helper.Version == SoapProtocolVersion.Soap12 && e is ArgumentException)
{
// special case to handle soap 1.2 rpc "BadArguments" fault
soapException = new SoapException(Res.GetString(Res.WebRequestUnableToProcess), new XmlQualifiedName(Soap.ClientCode, Soap.Namespace), null, null, null, new SoapFaultSubcode(Soap12FaultCodes.RpcBadArgumentsFaultCode), e);
}
else
{
soapException = new SoapException(Res.GetString(Res.WebRequestUnableToProcess), new XmlQualifiedName(Soap.ServerCode, Soap.Namespace), e);
}
if (SoapException.IsVersionMismatchFaultCode(soapException.Code))
{
if (IsSupported(ProtocolsEnum.HttpSoap12))
{
SoapUnknownHeader unknownHeader = CreateUpgradeHeader();
if (unknownHeader != null)
{
Message.Headers.Add(unknownHeader);
}
}
}
Response.ClearHeaders();
Response.Clear();
helper.SetResponseErrorCode(Response, soapException);
bool disableExtensions = false;
if (message.allExtensions != null)
{
message.SetExtensionStream(new SoapExtensionStream());
}
try {
message.InitExtensionStreamChain(message.allExtensions);
}
catch (Exception) {
disableExtensions = true;
}
message.SetStage(SoapMessageStage.BeforeSerialize);
message.ContentType = ContentType.Compose(helper.HttpContentType, Encoding.UTF8);
message.SetException(soapException);
if (!disableExtensions)
{
try {
message.RunExtensions(message.allExtensions);
}
catch (Exception) {
disableExtensions = true;
}
}
message.SetStream(outputStream);
Response.ContentType = message.ContentType;
if (message.ContentEncoding != null && message.ContentEncoding.Length > 0)
{
Response.AppendHeader(ContentType.ContentEncoding, message.ContentEncoding);
}
bool isEncoded = serverMethod != null && serverMethod.use == SoapBindingUse.Encoded;
StreamWriter sw = new StreamWriter(message.Stream, new UTF8Encoding(false), 128);
XmlTextWriter writer = isEncoded && message.Headers.Count > 0 ? new XmlSpecialTextWriter(sw, helper.Version) : new XmlTextWriter(sw);
writer.Formatting = Formatting.Indented; // CONSIDER, don't format to save space
writer.Indentation = 2; // CONSIDER, don't indent to save space
helper.WriteFault(writer, soapException);
if (!disableExtensions)
{
try {
message.SetStage(SoapMessageStage.AfterSerialize);
message.RunExtensions(message.allExtensions);
}
catch (Exception) {
// it's too late to do anything about this -- we've already written to the stream
}
}
return(true);
}
internal override void WriteReturns(object[] returnValues, Stream outputStream)
{
if (serverMethod.oneWay)
{
return;
}
bool isEncoded = serverMethod.use == SoapBindingUse.Encoded;
SoapHeaderHandling.EnsureHeadersUnderstood(message.Headers);
message.Headers.Clear();
SoapHeaderHandling.GetHeaderMembers(message.Headers, this.Target, serverMethod.outHeaderMappings, SoapHeaderDirection.Out, false);
if (message.allExtensions != null)
{
message.SetExtensionStream(new SoapExtensionStream());
}
message.InitExtensionStreamChain(message.allExtensions);
message.SetStage(SoapMessageStage.BeforeSerialize);
message.ContentType = ContentType.Compose(helper.HttpContentType, Encoding.UTF8);
message.SetParameterValues(returnValues);
message.RunExtensions(message.allExtensions);
message.SetStream(outputStream);
Response.ContentType = message.ContentType;
if (message.ContentEncoding != null && message.ContentEncoding.Length > 0)
{
Response.AppendHeader(ContentType.ContentEncoding, message.ContentEncoding);
}
StreamWriter sw = new StreamWriter(message.Stream, new UTF8Encoding(false), 128);
XmlTextWriter writer = isEncoded && message.Headers.Count > 0 ? new XmlSpecialTextWriter(sw, helper.Version) : new XmlTextWriter(sw);
writer.WriteStartDocument();
writer.WriteStartElement("soap", Soap.Envelope, helper.EnvelopeNs);
writer.WriteAttributeString("xmlns", "soap", null, helper.EnvelopeNs);
if (isEncoded)
{
writer.WriteAttributeString("xmlns", "soapenc", null, helper.EncodingNs);
writer.WriteAttributeString("xmlns", "tns", null, serverType.serviceNamespace);
writer.WriteAttributeString("xmlns", "types", null, SoapReflector.GetEncodedNamespace(serverType.serviceNamespace, serverType.serviceDefaultIsEncoded));
}
if (serverMethod.rpc && version == SoapProtocolVersion.Soap12)
{
writer.WriteAttributeString("xmlns", "rpc", null, Soap12.RpcNamespace);
}
writer.WriteAttributeString("xmlns", "xsi", null, XmlSchema.InstanceNamespace);
writer.WriteAttributeString("xmlns", "xsd", null, XmlSchema.Namespace);
SoapHeaderHandling.WriteHeaders(writer, serverMethod.outHeaderSerializer, message.Headers, serverMethod.outHeaderMappings, SoapHeaderDirection.Out, isEncoded, serverType.serviceNamespace, serverType.serviceDefaultIsEncoded, helper.EnvelopeNs);
writer.WriteStartElement(Soap.Body, helper.EnvelopeNs);
if (isEncoded)
{
writer.WriteAttributeString("soap", Soap.EncodingStyle, null, helper.EncodingNs);
}
// SOAP12: not using encodingStyle
//serverMethod.returnSerializer.Serialize(writer, returnValues, null, isEncoded ? helper.EncodingNs : null);
serverMethod.returnSerializer.Serialize(writer, returnValues, null);
writer.WriteEndElement();
writer.WriteEndElement();
writer.Flush();
message.SetStage(SoapMessageStage.AfterSerialize);
message.RunExtensions(message.allExtensions);
}
private object[] ReadResponse(SoapClientMessage message, WebResponse response, Stream responseStream, bool asyncCall)
{
SoapClientMethod method = message.Method;
HttpWebResponse httpWebResponse = response as HttpWebResponse;
int num1 = httpWebResponse != null ? (int)httpWebResponse.StatusCode : -1;
if (num1 >= 300 && num1 != 500 && num1 != 400)
{
throw new WebException(RequestResponseUtils.CreateResponseExceptionString((WebResponse)httpWebResponse, responseStream), (Exception)null, WebExceptionStatus.ProtocolError, (WebResponse)httpWebResponse);
}
message.Headers.Clear();
message.SetStream(responseStream);
message.InitExtensionStreamChain(message.initializedExtensions);
message.SetStage(SoapMessageStage.BeforeDeserialize);
message.ContentType = response.ContentType;
message.ContentEncoding = ((NameValueCollection)response.Headers)["Content-Encoding"];
message.RunExtensions(message.initializedExtensions, false);
if (method.oneWay && (httpWebResponse == null || httpWebResponse.StatusCode != HttpStatusCode.InternalServerError))
{
return(new object[0]);
}
bool flag1 = ContentType.IsSoap(message.ContentType);
if (!flag1 || flag1 && httpWebResponse != null && httpWebResponse.ContentLength == 0L)
{
if (num1 == 400)
{
throw new WebException(RequestResponseUtils.CreateResponseExceptionString((WebResponse)httpWebResponse, responseStream), (Exception)null, WebExceptionStatus.ProtocolError, (WebResponse)httpWebResponse);
}
throw new InvalidOperationException(System.Web.Services.Res.GetString("WebResponseContent", (object)message.ContentType, (object)this.HttpContentType) + Environment.NewLine + RequestResponseUtils.CreateResponseExceptionString(response, responseStream));
}
else
{
if (message.Exception != null)
{
throw message.Exception;
}
int bufferSize = asyncCall || httpWebResponse == null ? 512 : RequestResponseUtils.GetBufferSize((int)httpWebResponse.ContentLength);
XmlReader readerForMessage = this.GetReaderForMessage(message, bufferSize);
if (readerForMessage == null)
{
throw new InvalidOperationException(System.Web.Services.Res.GetString("WebNullReaderForMessage"));
}
int num2 = (int)readerForMessage.MoveToContent();
int depth = readerForMessage.Depth;
string encodingNs = this.EncodingNs;
string namespaceUri = readerForMessage.NamespaceURI;
if (namespaceUri == null || namespaceUri.Length == 0)
{
readerForMessage.ReadStartElement("Envelope");
}
else if (readerForMessage.NamespaceURI == "http://schemas.xmlsoap.org/soap/envelope/")
{
readerForMessage.ReadStartElement("Envelope", "http://schemas.xmlsoap.org/soap/envelope/");
}
else if (readerForMessage.NamespaceURI == "http://www.w3.org/2003/05/soap-envelope")
{
readerForMessage.ReadStartElement("Envelope", "http://www.w3.org/2003/05/soap-envelope");
}
else
{
throw new SoapException(System.Web.Services.Res.GetString("WebInvalidEnvelopeNamespace", (object)namespaceUri, (object)this.EnvelopeNs), SoapException.VersionMismatchFaultCode);
}
int num3 = (int)readerForMessage.MoveToContent();
new SoapHeaderHandling().ReadHeaders(readerForMessage, method.outHeaderSerializer, message.Headers, method.outHeaderMappings, SoapHeaderDirection.Out | SoapHeaderDirection.Fault, namespaceUri, method.use == SoapBindingUse.Encoded ? encodingNs : (string)null, false);
int num4 = (int)readerForMessage.MoveToContent();
readerForMessage.ReadStartElement("Body", namespaceUri);
int num5 = (int)readerForMessage.MoveToContent();
if (readerForMessage.IsStartElement("Fault", namespaceUri))
{
message.Exception = this.ReadSoapException(readerForMessage);
}
else if (method.oneWay)
{
readerForMessage.Skip();
message.SetParameterValues(new object[0]);
}
else
{
TraceMethod caller = Tracing.On ? new TraceMethod((object)this, "ReadResponse", new object[0]) : (TraceMethod)null;
bool flag2 = method.use == SoapBindingUse.Encoded;
if (Tracing.On)
{
Tracing.Enter(Tracing.TraceId("TraceReadResponse"), caller, new TraceMethod((object)method.returnSerializer, "Deserialize", new object[2]
{
(object)readerForMessage,
flag2 ? (object)encodingNs : (object)(string)null
}));
}
if (!flag2 && (WebServicesSection.Current.SoapEnvelopeProcessing.IsStrict || Tracing.On))
{
XmlDeserializationEvents events = Tracing.On ? Tracing.GetDeserializationEvents() : RuntimeUtils.GetDeserializationEvents();
message.SetParameterValues((object[])method.returnSerializer.Deserialize(readerForMessage, (string)null, events));
}
else
{
message.SetParameterValues((object[])method.returnSerializer.Deserialize(readerForMessage, flag2 ? encodingNs : (string)null));
}
if (Tracing.On)
{
Tracing.Exit(Tracing.TraceId("TraceReadResponse"), caller);
}
}
do
{
;
}while (depth < readerForMessage.Depth && readerForMessage.Read());
if (readerForMessage.NodeType == XmlNodeType.EndElement)
{
readerForMessage.Read();
}
message.SetStage(SoapMessageStage.AfterDeserialize);
message.RunExtensions(message.initializedExtensions, false);
SoapHeaderHandling.SetHeaderMembers(message.Headers, (object)this, method.outHeaderMappings, SoapHeaderDirection.Out | SoapHeaderDirection.Fault, true);
if (message.Exception != null)
{
throw message.Exception;
}
else
{
return(message.GetParameterValues());
}
}
}
private object[] ReadResponse(SoapClientMessage message, WebResponse response, Stream responseStream, bool asyncCall)
{
int bufferSize;
SoapClientMethod method = message.Method;
HttpWebResponse response2 = response as HttpWebResponse;
int num = (response2 != null) ? ((int)response2.StatusCode) : -1;
if (((num >= 300) && (num != 500)) && (num != 400))
{
throw new WebException(RequestResponseUtils.CreateResponseExceptionString(response2, responseStream), null, WebExceptionStatus.ProtocolError, response2);
}
message.Headers.Clear();
message.SetStream(responseStream);
message.InitExtensionStreamChain(message.initializedExtensions);
message.SetStage(SoapMessageStage.BeforeDeserialize);
message.ContentType = response.ContentType;
message.ContentEncoding = response.Headers["Content-Encoding"];
message.RunExtensions(message.initializedExtensions, false);
if (method.oneWay && ((response2 == null) || (response2.StatusCode != HttpStatusCode.InternalServerError)))
{
return(new object[0]);
}
bool flag = ContentType.IsSoap(message.ContentType);
if (!flag || ((flag && (response2 != null)) && (response2.ContentLength == 0L)))
{
if (num == 400)
{
throw new WebException(RequestResponseUtils.CreateResponseExceptionString(response2, responseStream), null, WebExceptionStatus.ProtocolError, response2);
}
throw new InvalidOperationException(System.Web.Services.Res.GetString("WebResponseContent", new object[] { message.ContentType, this.HttpContentType }) + Environment.NewLine + RequestResponseUtils.CreateResponseExceptionString(response, responseStream));
}
if (message.Exception != null)
{
throw message.Exception;
}
if (asyncCall || (response2 == null))
{
bufferSize = 0x200;
}
else
{
bufferSize = RequestResponseUtils.GetBufferSize((int)response2.ContentLength);
}
XmlReader readerForMessage = this.GetReaderForMessage(message, bufferSize);
if (readerForMessage == null)
{
throw new InvalidOperationException(System.Web.Services.Res.GetString("WebNullReaderForMessage"));
}
readerForMessage.MoveToContent();
int depth = readerForMessage.Depth;
string encodingNs = this.EncodingNs;
string namespaceURI = readerForMessage.NamespaceURI;
if ((namespaceURI == null) || (namespaceURI.Length == 0))
{
readerForMessage.ReadStartElement("Envelope");
}
else if (readerForMessage.NamespaceURI == "http://schemas.xmlsoap.org/soap/envelope/")
{
readerForMessage.ReadStartElement("Envelope", "http://schemas.xmlsoap.org/soap/envelope/");
}
else
{
if (readerForMessage.NamespaceURI != "http://www.w3.org/2003/05/soap-envelope")
{
throw new SoapException(System.Web.Services.Res.GetString("WebInvalidEnvelopeNamespace", new object[] { namespaceURI, this.EnvelopeNs }), SoapException.VersionMismatchFaultCode);
}
readerForMessage.ReadStartElement("Envelope", "http://www.w3.org/2003/05/soap-envelope");
}
readerForMessage.MoveToContent();
new SoapHeaderHandling().ReadHeaders(readerForMessage, method.outHeaderSerializer, message.Headers, method.outHeaderMappings, SoapHeaderDirection.Fault | SoapHeaderDirection.Out, namespaceURI, (method.use == SoapBindingUse.Encoded) ? encodingNs : null, false);
readerForMessage.MoveToContent();
readerForMessage.ReadStartElement("Body", namespaceURI);
readerForMessage.MoveToContent();
if (readerForMessage.IsStartElement("Fault", namespaceURI))
{
message.Exception = this.ReadSoapException(readerForMessage);
}
else if (method.oneWay)
{
readerForMessage.Skip();
message.SetParameterValues(new object[0]);
}
else
{
TraceMethod caller = Tracing.On ? new TraceMethod(this, "ReadResponse", new object[0]) : null;
bool flag2 = method.use == SoapBindingUse.Encoded;
if (Tracing.On)
{
Tracing.Enter(Tracing.TraceId("TraceReadResponse"), caller, new TraceMethod(method.returnSerializer, "Deserialize", new object[] { readerForMessage, flag2 ? encodingNs : null }));
}
if (!flag2 && (WebServicesSection.Current.SoapEnvelopeProcessing.IsStrict || Tracing.On))
{
XmlDeserializationEvents events = Tracing.On ? Tracing.GetDeserializationEvents() : RuntimeUtils.GetDeserializationEvents();
message.SetParameterValues((object[])method.returnSerializer.Deserialize(readerForMessage, null, events));
}
else
{
message.SetParameterValues((object[])method.returnSerializer.Deserialize(readerForMessage, flag2 ? encodingNs : null));
}
if (Tracing.On)
{
Tracing.Exit(Tracing.TraceId("TraceReadResponse"), caller);
}
}
while ((depth < readerForMessage.Depth) && readerForMessage.Read())
{
}
if (readerForMessage.NodeType == XmlNodeType.EndElement)
{
readerForMessage.Read();
}
message.SetStage(SoapMessageStage.AfterDeserialize);
message.RunExtensions(message.initializedExtensions, false);
SoapHeaderHandling.SetHeaderMembers(message.Headers, this, method.outHeaderMappings, SoapHeaderDirection.Fault | SoapHeaderDirection.Out, true);
if (message.Exception != null)
{
throw message.Exception;
}
return(message.GetParameterValues());
}
