Exemple #1
0
        private SoapClientMessage BeforeSerialize(WebRequest request, string methodName, object[] parameters)
        {
            if (parameters == null)
            {
                throw new ArgumentNullException("parameters");
            }
            SoapClientMethod method = this.clientType.GetMethod(methodName);

            if (method == null)
            {
                throw new ArgumentException(System.Web.Services.Res.GetString("WebInvalidMethodName", new object[1]
                {
                    (object)methodName
                }));
            }
            else
            {
                SoapExtension[]   soapExtensionArray = SoapMessage.InitializeExtensions((SoapReflectedExtension[])SoapHttpClientProtocol.CombineExtensionsHelper((Array)this.clientType.HighPriExtensions, (Array)method.extensions, (Array)this.clientType.LowPriExtensions, typeof(SoapReflectedExtension)), (object[])SoapHttpClientProtocol.CombineExtensionsHelper((Array)this.clientType.HighPriExtensionInitializers, (Array)method.extensionInitializers, (Array)this.clientType.LowPriExtensionInitializers, typeof(object)));
                SoapClientMessage soapClientMessage  = new SoapClientMessage(this, method, this.Url);
                soapClientMessage.initializedExtensions = soapExtensionArray;
                if (soapExtensionArray != null)
                {
                    soapClientMessage.SetExtensionStream(new SoapExtensionStream());
                }
                soapClientMessage.InitExtensionStreamChain(soapClientMessage.initializedExtensions);
                string action = UrlEncoder.EscapeString(method.action, Encoding.UTF8);
                soapClientMessage.SetStage(SoapMessageStage.BeforeSerialize);
                if (this.version == SoapProtocolVersion.Soap12)
                {
                    soapClientMessage.ContentType = ContentType.Compose("application/soap+xml", this.RequestEncoding != null ? this.RequestEncoding : Encoding.UTF8, action);
                }
                else
                {
                    soapClientMessage.ContentType = ContentType.Compose("text/xml", this.RequestEncoding != null ? this.RequestEncoding : Encoding.UTF8);
                }
                soapClientMessage.SetParameterValues(parameters);
                SoapHeaderHandling.GetHeaderMembers(soapClientMessage.Headers, (object)this, method.inHeaderMappings, SoapHeaderDirection.In, true);
                soapClientMessage.RunExtensions(soapClientMessage.initializedExtensions, true);
                request.ContentType = soapClientMessage.ContentType;
                if (soapClientMessage.ContentEncoding != null && soapClientMessage.ContentEncoding.Length > 0)
                {
                    ((NameValueCollection)request.Headers)["Content-Encoding"] = soapClientMessage.ContentEncoding;
                }
                request.Method = "POST";
                if (this.version != SoapProtocolVersion.Soap12 && ((NameValueCollection)request.Headers)["SOAPAction"] == null)
                {
                    StringBuilder stringBuilder = new StringBuilder(action.Length + 2);
                    stringBuilder.Append('"');
                    stringBuilder.Append(action);
                    stringBuilder.Append('"');
                    ((NameValueCollection)request.Headers).Add("SOAPAction", ((object)stringBuilder).ToString());
                }
                return(soapClientMessage);
            }
        }
Exemple #2
0
        private SoapClientMessage BeforeSerialize(WebRequest request, string methodName, object[] parameters)
        {
            if (parameters == null)
            {
                throw new ArgumentNullException("parameters");
            }
            SoapClientMethod method = this.clientType.GetMethod(methodName);

            if (method == null)
            {
                throw new ArgumentException(System.Web.Services.Res.GetString("WebInvalidMethodName", new object[] { methodName }));
            }
            SoapReflectedExtension[] reflectedExtensions = (SoapReflectedExtension[])CombineExtensionsHelper(this.clientType.HighPriExtensions, method.extensions, this.clientType.LowPriExtensions, typeof(SoapReflectedExtension));
            object[]          extensionInitializers      = (object[])CombineExtensionsHelper(this.clientType.HighPriExtensionInitializers, method.extensionInitializers, this.clientType.LowPriExtensionInitializers, typeof(object));
            SoapExtension[]   extensionArray2            = SoapMessage.InitializeExtensions(reflectedExtensions, extensionInitializers);
            SoapClientMessage message = new SoapClientMessage(this, method, base.Url)
            {
                initializedExtensions = extensionArray2
            };

            if (extensionArray2 != null)
            {
                message.SetExtensionStream(new SoapExtensionStream());
            }
            message.InitExtensionStreamChain(message.initializedExtensions);
            string action = UrlEncoder.EscapeString(method.action, Encoding.UTF8);

            message.SetStage(SoapMessageStage.BeforeSerialize);
            if (this.version == SoapProtocolVersion.Soap12)
            {
                message.ContentType = ContentType.Compose("application/soap+xml", (base.RequestEncoding != null) ? base.RequestEncoding : Encoding.UTF8, action);
            }
            else
            {
                message.ContentType = ContentType.Compose("text/xml", (base.RequestEncoding != null) ? base.RequestEncoding : Encoding.UTF8);
            }
            message.SetParameterValues(parameters);
            SoapHeaderHandling.GetHeaderMembers(message.Headers, this, method.inHeaderMappings, SoapHeaderDirection.In, true);
            message.RunExtensions(message.initializedExtensions, true);
            request.ContentType = message.ContentType;
            if ((message.ContentEncoding != null) && (message.ContentEncoding.Length > 0))
            {
                request.Headers["Content-Encoding"] = message.ContentEncoding;
            }
            request.Method = "POST";
            if ((this.version != SoapProtocolVersion.Soap12) && (request.Headers["SOAPAction"] == null))
            {
                StringBuilder builder = new StringBuilder(action.Length + 2);
                builder.Append('"');
                builder.Append(action);
                builder.Append('"');
                request.Headers.Add("SOAPAction", builder.ToString());
            }
            return(message);
        }
 private SoapClientMessage BeforeSerialize(WebRequest request, string methodName, object[] parameters)
 {
     if (parameters == null)
     {
         throw new ArgumentNullException("parameters");
     }
     SoapClientMethod method = this.clientType.GetMethod(methodName);
     if (method == null)
     {
         throw new ArgumentException(System.Web.Services.Res.GetString("WebInvalidMethodName", new object[] { methodName }));
     }
     SoapReflectedExtension[] reflectedExtensions = (SoapReflectedExtension[]) CombineExtensionsHelper(this.clientType.HighPriExtensions, method.extensions, this.clientType.LowPriExtensions, typeof(SoapReflectedExtension));
     object[] extensionInitializers = (object[]) CombineExtensionsHelper(this.clientType.HighPriExtensionInitializers, method.extensionInitializers, this.clientType.LowPriExtensionInitializers, typeof(object));
     SoapExtension[] extensionArray2 = SoapMessage.InitializeExtensions(reflectedExtensions, extensionInitializers);
     SoapClientMessage message = new SoapClientMessage(this, method, base.Url) {
         initializedExtensions = extensionArray2
     };
     if (extensionArray2 != null)
     {
         message.SetExtensionStream(new SoapExtensionStream());
     }
     message.InitExtensionStreamChain(message.initializedExtensions);
     string action = UrlEncoder.EscapeString(method.action, Encoding.UTF8);
     message.SetStage(SoapMessageStage.BeforeSerialize);
     if (this.version == SoapProtocolVersion.Soap12)
     {
         message.ContentType = ContentType.Compose("application/soap+xml", (base.RequestEncoding != null) ? base.RequestEncoding : Encoding.UTF8, action);
     }
     else
     {
         message.ContentType = ContentType.Compose("text/xml", (base.RequestEncoding != null) ? base.RequestEncoding : Encoding.UTF8);
     }
     message.SetParameterValues(parameters);
     SoapHeaderHandling.GetHeaderMembers(message.Headers, this, method.inHeaderMappings, SoapHeaderDirection.In, true);
     message.RunExtensions(message.initializedExtensions, true);
     request.ContentType = message.ContentType;
     if ((message.ContentEncoding != null) && (message.ContentEncoding.Length > 0))
     {
         request.Headers["Content-Encoding"] = message.ContentEncoding;
     }
     request.Method = "POST";
     if ((this.version != SoapProtocolVersion.Soap12) && (request.Headers["SOAPAction"] == null))
     {
         StringBuilder builder = new StringBuilder(action.Length + 2);
         builder.Append('"');
         builder.Append(action);
         builder.Append('"');
         request.Headers.Add("SOAPAction", builder.ToString());
     }
     return message;
 }
        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;
        }
Exemple #6
0
        object[] ReadResponse(SoapClientMessage message, WebResponse response, Stream responseStream, bool asyncCall)
        {
            SoapClientMethod method = message.Method;

            // CONSIDER,yannc: use the SoapExtensionStream here as well so we throw exceptions
            //      : if the extension touches stream properties/methods in before deserialize.
            // note that if there is an error status code then the response might be content-type=text/plain.
            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);

            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
            if (!ContentType.IsSoap(message.ContentType))
            {
                // 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) +
                                                        "\r\n" +
                                                        RequestResponseUtils.CreateResponseExceptionString(response, responseStream));
                }
            }

            Encoding enc = RequestResponseUtils.GetEncoding(message.ContentType);

            // perf fix: changed buffer size passed to StreamReader
            int bufferSize;

            if (asyncCall || httpResponse == null)
            {
                bufferSize = 512;
            }
            else
            {
                int contentLength = (int)httpResponse.ContentLength;
                if (contentLength == -1)
                {
                    bufferSize = 8000;
                }
                else if (contentLength <= 16000)
                {
                    bufferSize = contentLength;
                }
                else
                {
                    bufferSize = 16000;
                }
            }
            XmlTextReader reader;

            if (enc != null)
            {
                reader = new XmlTextReader(new StreamReader(message.Stream, enc, true, bufferSize));
            }
            else
            {
                // CONSIDER: do i need to pass a buffer size somehow?
                reader = new XmlTextReader(message.Stream);
            }

            reader.Normalization = true;
            reader.XmlResolver   = null;
            reader.MoveToContent();
            // 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.Envelope);
            }
            else if (reader.NamespaceURI == Soap.Namespace)
            {
                reader.ReadStartElement(Soap.Envelope, Soap.Namespace);
            }
            else if (reader.NamespaceURI == Soap12.Namespace)
            {
                reader.ReadStartElement(Soap.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);
            reader.MoveToContent();
            reader.ReadStartElement(Soap.Body, envelopeNs);
            reader.MoveToContent();
            if (reader.IsStartElement(Soap.Fault, envelopeNs))
            {
                message.SetException(ReadSoapException(reader));
            }
            else
            {
                if (method.oneWay)
                {
                    reader.Skip();
                    message.SetParameterValues(new object[0]);
                }
                else
                {
                    // SOAP12: not using encodingStyle
                    //message.SetParameterValues((object[])method.returnSerializer.Deserialize(reader, method.use == SoapBindingUse.Encoded ? encodingNs : null));
                    message.SetParameterValues((object[])method.returnSerializer.Deserialize(reader));
                }
            }

            while (reader.NodeType == XmlNodeType.Whitespace)
            {
                reader.Skip();
            }
            if (reader.NodeType == XmlNodeType.None)
            {
                reader.Skip();
            }
            else
            {
                reader.ReadEndElement();
            }
            while (reader.NodeType == XmlNodeType.Whitespace)
            {
                reader.Skip();
            }
            if (reader.NodeType == XmlNodeType.None)
            {
                reader.Skip();
            }
            else
            {
                reader.ReadEndElement();
            }

            message.SetStage(SoapMessageStage.AfterDeserialize);
            message.RunExtensions(message.initializedExtensions);
            SoapHeaderHandling.SetHeaderMembers(message.Headers, this, method.outHeaderMappings, SoapHeaderDirection.Out | SoapHeaderDirection.Fault, true);

            if (message.Exception != null)
            {
                throw message.Exception;
            }
            return(message.GetParameterValues());
        }
Exemple #7
0
        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);

            // 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);
        }
        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());
        }
 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 SoapClientMessage BeforeSerialize(WebRequest request, string methodName, object[] parameters)
 {
   if (parameters == null)
     throw new ArgumentNullException("parameters");
   SoapClientMethod method = this.clientType.GetMethod(methodName);
   if (method == null)
   {
     throw new ArgumentException(System.Web.Services.Res.GetString("WebInvalidMethodName", new object[1]
     {
       (object) methodName
     }));
   }
   else
   {
     SoapExtension[] soapExtensionArray = SoapMessage.InitializeExtensions((SoapReflectedExtension[]) SoapHttpClientProtocol.CombineExtensionsHelper((Array) this.clientType.HighPriExtensions, (Array) method.extensions, (Array) this.clientType.LowPriExtensions, typeof (SoapReflectedExtension)), (object[]) SoapHttpClientProtocol.CombineExtensionsHelper((Array) this.clientType.HighPriExtensionInitializers, (Array) method.extensionInitializers, (Array) this.clientType.LowPriExtensionInitializers, typeof (object)));
     SoapClientMessage soapClientMessage = new SoapClientMessage(this, method, this.Url);
     soapClientMessage.initializedExtensions = soapExtensionArray;
     if (soapExtensionArray != null)
       soapClientMessage.SetExtensionStream(new SoapExtensionStream());
     soapClientMessage.InitExtensionStreamChain(soapClientMessage.initializedExtensions);
     string action = UrlEncoder.EscapeString(method.action, Encoding.UTF8);
     soapClientMessage.SetStage(SoapMessageStage.BeforeSerialize);
     if (this.version == SoapProtocolVersion.Soap12)
       soapClientMessage.ContentType = ContentType.Compose("application/soap+xml", this.RequestEncoding != null ? this.RequestEncoding : Encoding.UTF8, action);
     else
       soapClientMessage.ContentType = ContentType.Compose("text/xml", this.RequestEncoding != null ? this.RequestEncoding : Encoding.UTF8);
     soapClientMessage.SetParameterValues(parameters);
     SoapHeaderHandling.GetHeaderMembers(soapClientMessage.Headers, (object) this, method.inHeaderMappings, SoapHeaderDirection.In, true);
     soapClientMessage.RunExtensions(soapClientMessage.initializedExtensions, true);
     request.ContentType = soapClientMessage.ContentType;
     if (soapClientMessage.ContentEncoding != null && soapClientMessage.ContentEncoding.Length > 0)
       ((NameValueCollection) request.Headers)["Content-Encoding"] = soapClientMessage.ContentEncoding;
     request.Method = "POST";
     if (this.version != SoapProtocolVersion.Soap12 && ((NameValueCollection) request.Headers)["SOAPAction"] == null)
     {
       StringBuilder stringBuilder = new StringBuilder(action.Length + 2);
       stringBuilder.Append('"');
       stringBuilder.Append(action);
       stringBuilder.Append('"');
       ((NameValueCollection) request.Headers).Add("SOAPAction", ((object) stringBuilder).ToString());
     }
     return soapClientMessage;
   }
 }
Exemple #11
0
        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();
 }
Exemple #13
0
        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());
        }