示例#1
0
        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);
        }