private void WriteOutputStream(SoapMessage message) { this.newStream.Position = 0; Copy(this.newStream, this.oldStream); if (AccreditSection.GetConfig().AccreditSettings.SoapRecord & message is SoapServerMessage) { if (AccreditSection.GetConfig().AccreditSettings.SoapRecordOutput) { this.newStream.Position = 0; TextReader reader = new StreamReader(this.newStream); this.soapRecorder.OutputStream = reader.ReadToEnd(); } this.soapRecorder.EndDate = DateTime.Now; if (HttpContext.Current != null) this.soapRecorder.HostIP = HttpContext.Current.Request.UserHostAddress; string sql = ORMapping.GetInsertSql<SoapRecorder>(this.soapRecorder, TSqlBuilder.Instance); try { OGUCommonDefine.ExecuteNonQuery(sql); } catch (DbException ex) { if (ex.Message.IndexOf("WEB_READ_LOG") > 0) InitDatabase(sql); //else // throw ex; } } }
public override void ProcessMessage(SoapMessage message) { switch (message.Stage) { case SoapMessageStage.BeforeDeserialize: Copy(_OldStream, _NewStream); _NewStream.Position = 0; break; case SoapMessageStage.AfterSerialize: if (null != message.Exception) { string sDetailNode = "<detail />"; if (null != message.Exception) { MemoryStream cMemoryStream = new MemoryStream(); XmlSerializer cXmlSerializer = new XmlSerializer(typeof(helpers.web.Exception)); cXmlSerializer.Serialize(cMemoryStream, new helpers.web.Exception(message.Exception)); cMemoryStream.Position = 0; sDetailNode = "<detail><exception>" + (new StreamReader(cMemoryStream)).ReadToEnd().ToBase64() + "</exception></detail>"; cMemoryStream.Close(); } _NewStream.Position = 0; TextReader tr = new StreamReader(_NewStream); string s = tr.ReadToEnd(); s = s.Replace("<detail />", sDetailNode); _NewStream = new MemoryStream(); TextWriter tw = new StreamWriter(_NewStream); tw.Write(s); tw.Flush(); } _NewStream.Position = 0; Copy(_NewStream, _OldStream); break; } }
public void BeforeSerialize(SoapMessage message) //ObjectOut { if(System.Environment.OSVersion.Platform != PlatformID.WinCE) { //NOTE this only works if you handle StreamOut/In too //NOTE this only works on .NETfx TimestampHeader timestampHeader = new TimestampHeader(300); message.Headers.Add(timestampHeader); //if(EndPoint == EndPointType.Addressing) ActionHeader actionHeader = new ActionHeader(message.Action); //FromHeader fromHeader = new FromHeader(null); ReplyToHeader replyToHeader = new ReplyToHeader(null); MessageIdHeader messageIdHeader = new MessageIdHeader(null); ToHeader toHeader = new ToHeader(message.Url); message.Headers.Add(actionHeader); //message.Headers.Add(fromHeader); message.Headers.Add(replyToHeader); message.Headers.Add(messageIdHeader); message.Headers.Add(toHeader); //else //routing //pathHeader pHeader = new pathHeader(message.Action, message.Url, null); //message.Headers.Add(pHeader); } return; }
public override void ProcessMessage(System.Web.Services.Protocols.SoapMessage message) { switch (message.Stage) { case SoapMessageStage.BeforeDeserialize: Copy(_OldStream, _NewStream); _NewStream.Position = 0; break; case SoapMessageStage.AfterSerialize: if (message.Exception != null) { Handler ueh = new Handler(); string strDetailNode; //-- handle our exception, and get the SOAP <detail> string strDetailNode = ueh.HandleWebServiceException(message); //-- read the entire SOAP message stream into a string _NewStream.Position = 0; TextReader tr = new StreamReader(_NewStream); //-- insert our exception details into the string string s = tr.ReadToEnd(); s = s.Replace("<detail />", strDetailNode); //-- overwrite the stream with our modified string _NewStream = new MemoryStream(); TextWriter tw = new StreamWriter(_NewStream); tw.Write(s); tw.Flush(); } _NewStream.Position = 0; Copy(_NewStream, _OldStream); break; } }
private string _processSoap(SoapMessage message) { StringBuilder sb = new StringBuilder(8192); string result; try { sb.Append(message.MethodInfo.Name); for (int i = 0; i < message.MethodInfo.Parameters.Length; i++) { sb.Append("[" + message.MethodInfo.Parameters[i].Name + "="); if (message.MethodInfo.Parameters[i].ParameterType.FullName.StartsWith("System.") && !message.MethodInfo.Parameters[i].IsOut) { sb.Append((message.GetInParameterValue(i) != null) ? message.GetInParameterValue(i) : "null"); } else { sb.Append(message.MethodInfo.Parameters[i].ParameterType.FullName); } sb.Append("]"); } result = sb.ToString(); } catch { result = null; } finally { } return result; }
public void AfterSerialize(SoapMessage message) //StreamOut { if(onClientOrServer == OnClientOrServer.Unknown) onClientOrServer = OnClientOrServer.Client; /* //HACK because .NETcf does not add Headers in BeforeSerialize above if(Environment.OSVersion.Platform == PlatformID.WinCE) { newStream.Position = 0; //Hack MemoryStream below because of XmlDocument bug closing stream byte [] tempBa = new byte[newStream.Length]; int bytesRead = newStream.Read(tempBa, 0, (int) newStream.Length); MemoryStream ms = new MemoryStream(tempBa); //BUG NOTE this closes the underlying stream on .NETcf XmlDocument xd = new XmlDocument(); xd.Load(ms); //MemoryStream will be closed now HeadersHandler.AddHeaders(xd, message.Action, message.Url); newStream.Position = 0; XmlTextWriter xtw = new XmlTextWriter(newStream, System.Text.Encoding.UTF8); xtw.Namespaces = true; xd.WriteTo(xtw); xtw.Flush(); //xtw.Close(); } //END WinCE HACK */ //these 2 lines have be called at a minimum newStream.Position = 0; Copy(newStream, oldStream); //for next guy return; }
/// <summary> /// 处理消息。 /// BeforeDeserialize和AfterDeserialize是发生在服务内代码执行之前。 /// BeforeSerialize和AfterSerialize是发生在服务内代码执行之后。 /// 整个执行时序是:ChainStream,BeforeDeserialize,AfterDeserialize,BeforeSerialize,AfterSerialize /// </summary> /// <param name="message"></param> public override void ProcessMessage(SoapMessage message) { //仅处理Server端 if (message is SoapServerMessage) { switch (message.Stage) { case SoapMessageStage.BeforeDeserialize: break; case SoapMessageStage.AfterDeserialize: //进入 InitParameters(message); InitializeCounters(this._InstanceName); BeforeExecuteMethodCounter(message); break; case SoapMessageStage.BeforeSerialize: break; case SoapMessageStage.AfterSerialize: //离开 AfterExecuteMethodCounter(message); break; default: throw new Exception("Error Message Stage"); } } }
private void AfterSerialize(SoapMessage message) { newStream.Position = 0; WriteOutput(message); newStream.Position = 0; Copy(newStream, oldStream); }
/// <summary> /// ASP.Net web-service specific exception handler, to be called from UnhandledExceptionHandlerSoapExtension /// </summary> /// <returns> /// string with "<detail></detail>" XML element, suitable for insertion into SOAP message /// </returns> /// <remarks> /// existing SOAP detail message, prior to insertion, looks like: /// /// <soap:Fault> /// <faultcode>soap:Server</faultcode> /// <faultstring>Server was unable to process request.</faultstring> /// <detail /> <== /// </soap:Fault> /// </remarks> public string HandleWebServiceException(System.Web.Services.Protocols.SoapMessage sm) { HandleException(sm.Exception); XmlDocument doc = new XmlDocument(); XmlNode DetailNode = doc.CreateNode(XmlNodeType.Element, SoapException.DetailElementName.Name, SoapException.DetailElementName.Namespace); XmlNode TypeNode = doc.CreateNode(XmlNodeType.Element, "ExceptionType", SoapException.DetailElementName.Namespace); TypeNode.InnerText = _strExceptionType; DetailNode.AppendChild(TypeNode); XmlNode MessageNode = doc.CreateNode(XmlNodeType.Element, "ExceptionMessage", SoapException.DetailElementName.Namespace); MessageNode.InnerText = sm.Exception.Message; DetailNode.AppendChild(MessageNode); XmlNode InfoNode = doc.CreateNode(XmlNodeType.Element, "ExceptionInfo", SoapException.DetailElementName.Namespace); InfoNode.InnerText = _strException; DetailNode.AppendChild(InfoNode); return(DetailNode.OuterXml.ToString()); }
/// <inheritdoc /> /// <summary> /// ProcessMessage processes the soap message. /// </summary> /// <param name="message"> /// The incoming soap message. /// </param> public override void ProcessMessage(SoapMessage message) { // Log some informational items for reviewing in this sample application. Logger.Debug($"Stage : {message.Stage}"); switch (message.Stage) { case SoapMessageStage.BeforeSerialize: break; case SoapMessageStage.AfterSerialize: this.WriteOutput(message); break; case SoapMessageStage.BeforeDeserialize: this.WriteInput(message); break; case SoapMessageStage.AfterDeserialize: break; default: throw new ArgumentOutOfRangeException(); } }
public override void ProcessMessage( System.Web.Services.Protocols.SoapMessage message) { switch (message.Stage) { case System.Web.Services.Protocols.SoapMessageStage.BeforeSerialize: if (level > 2) { WriteToLog(message.Stage.ToString(), EventLogEntryType.Information); } break; case System.Web.Services.Protocols.SoapMessageStage.AfterSerialize: LogOutputMessage(message); break; case System.Web.Services.Protocols.SoapMessageStage.BeforeDeserialize: LogInputMessage(message); break; case System.Web.Services.Protocols.SoapMessageStage.AfterDeserialize: if (level > 2) { WriteToLog(message.Stage.ToString(), EventLogEntryType.Information); } break; } }
/// <summary> /// Processs the message. /// </summary> /// <param name="message">Message.</param> public override void ProcessMessage(SoapMessage message) { switch (message.Stage) { case SoapMessageStage.BeforeSerialize: break; case SoapMessageStage.AfterSerialize: StoreRequestMessage(message); // Pass it off as the actual stream //Copy(newStream, oldStream); // Indicate for the return that we don't wish to chain anything in break; case SoapMessageStage.BeforeDeserialize: StoreResponseMessage(message); // Pass it off as the actual stream break; case SoapMessageStage.AfterDeserialize: break; default: throw new ArgumentException("Invalid message stage [" + message.Stage + "]", "message"); } }
public override void ProcessMessage(System.Web.Services.Protocols.SoapMessage message) { switch (message.Stage) { case SoapMessageStage.BeforeSerialize: break; case SoapMessageStage.AfterSerialize: xmlRequest = GetSoapEnvelope(newStream); CopyStream(newStream, oldStream); RecordLog(message.Action); break; case SoapMessageStage.BeforeDeserialize: CopyStream(oldStream, newStream); xmlResponse = GetSoapEnvelope(newStream); break; case SoapMessageStage.AfterDeserialize: break; } }
public void WriteRequest(SoapMessage message) { newStream.Position = 0; if(_textBox != null) { _textBox.Text += string.Format("-----SoapRequest at {0}\r\n\r\n", DateTime.Now); _textBox.Text += new StreamReader(newStream).ReadToEnd() + "\r\n\r\n"; } newStream.Position = 0; Copy(newStream, oldStream); }
/// <summary> /// Process the soap message and try validate calling party authentication /// by examing the message headers. We are searching for custom message header /// containing a WRAP authentication token. /// This method is automatically called by the ASMX WebService infrastructure /// </summary> /// <param name="message">The <see cref="T:System.Web.Services.Protocols.SoapMessage"/> to process.</param> public override void ProcessMessage(SoapMessage message) { if (message.Stage == SoapMessageStage.AfterDeserialize && message is SoapServerMessage) { // we need to catch the message after it has come from the client // and has been deserialized if (message.Headers.Count < 1) { // the number of message headers is less than 1, for sure there is no authentication throw new ApplicationException("You are not authorized to use this resource"); } foreach (SoapHeader header in message.Headers) { if (header is SoapUnknownHeader) { // The custom header sent will be unknown header. // Get the token value from the InnerText proprety of the header string tokenHeaderValue = ((SoapUnknownHeader)header).Element.InnerText; // Parse the token string to real token instance SimpleWebToken token = SimpleWebToken.Parse(tokenHeaderValue); // Check token validity - checks token Signature, Expire date // and, because included as parameter - the token Audience SimpleWebTokenValidationResult result = SimpleWebToken.Validate(token, this._tokenHelper.ACSSigningKey, expectedAudience: ConfigurationManager.AppSettings["SiAudience"]); if (result == SimpleWebTokenValidationResult.Valid) { var server = ((SoapServerMessage)message).Server; if (server is IClaimsAwareService) { // inject the ClaimsPrincipal to the instance of the service // thus the method can perform additional checks ((IClaimsAwareService)server).SetClaimsPricipal(token.ToPrinciple()); } foreach (var claim in token.Claims.AllKeys) { // debugging purposes only - printout the claims collection System.Diagnostics.Debug.WriteLine(string.Format("{0} => {1} ", claim, token.Claims[claim])); } } else { throw new ApplicationException(string.Format("Authentication failed: {0}",result.ToString())); } } } } }
/// <summary> /// /// </summary> /// <param name="message"></param> public override void ProcessMessageBeforeDeserialize(System.Web.Services.Protocols.SoapMessage message) { StreamEncryptor compressor = StreamEncryptor.Create(EncryptionMode); try { compressor.ProcessStream(previousStream, currentStream, StreamProcessMode.Decrypt); } catch (Exception e) { throw new SoapException(e.Message, SoapException.ServerFaultCode, e); } }
public override void ProcessMessage(SoapMessage message) { try { if (message.Stage == SoapMessageStage.AfterDeserialize) { string _mtd = this._processSoap(message); string _userExecute = string.Format("USERID '{0}' ", "unknown"); foreach (SoapHeader header in message.Headers) { if (header is AuthHeader) { AuthHeader credentials = (AuthHeader)header; try { switch (credentials.CryptoAlgorithm) { case AuthHeader.CryptoAlgorithmEnum.NONE: _userExecute = string.Format("USERID '{0}' ", credentials.AuthKey.Split(new char[] { '|' })[0]); break; case AuthHeader.CryptoAlgorithmEnum.TRIPLEDES: _userExecute = string.Format("USERID '{0}' ", CryptorEngineTripleDES.Decrypt(SAFConfiguration.readConnectionStringCoreEncrypted(), new SecurityInfo(SAFConfiguration.readMasterKey(), SAFConfiguration.readInfoKey(), SAFConfiguration.readInfoIV()), true).Split(new char[] { '|' })[0]); break; } } catch (SoapException ex) { SAFLOGGER.Write(SAFLOGGER.LOGGEREventID.EXCEPTION, "SAFAPILOGGER", new string[] { "http://sfexpand.SAFBusiness.AuthExtension.softfinanca.com/", ex.ToString() }); } } } SAFLOGGER.dump(SAFLOGGER.LOGGEREventID.INFORMATION, "SAFAPILOGGER", new string[] { _userExecute + _mtd }); } } catch { } }
/// <summary> /// Write the input of the incoming soap response. /// </summary> /// <param name="message"> /// The message. /// </param> public void WriteInput(SoapMessage message) { CopyStream(this.oldStream, this.newStream); this.newStream.Position = 0; var reader = new StreamReader(this.newStream); var requestXml = reader.ReadToEnd(); // Trimming the end of the string b/c some of my requests and responses had newlines :-( Logger.Debug($"Response | {requestXml.TrimEnd('\r', '\n') }"); // Example of the using PrettyXml // Logger.Debug(this.PrettyXml(requestXml)); this.newStream.Position = 0; }
public void WriteOutput(SoapMessage message) { newStream.Position = 0; FileStream fs = new FileStream(filename, FileMode.Append, FileAccess.Write); StreamWriter w = new StreamWriter(fs); string soapString = (message is SoapServerMessage) ? "SoapResponse" : "SoapRequest"; w.WriteLine("-----" + soapString + " at " + DateTime.Now); w.Flush(); Copy(newStream, fs); w.Close(); newStream.Position = 0; Copy(newStream, oldStream); }
public override void ProcessMessage(SoapMessage message) { if (GlimpseManager.IsGlimpseActive() == false) return; switch (message.Stage) { case SoapMessageStage.BeforeSerialize: _result.RequestArgs = GetRequestArgs(message); break; case SoapMessageStage.AfterSerialize: _result.RequestXml = GetXml(_newStream); CopyStream(_newStream, _oldStream); break; case SoapMessageStage.BeforeDeserialize: CopyStream(_oldStream, _newStream); _result.ResponseXml = GetXml(_newStream); break; case SoapMessageStage.AfterDeserialize: TimerResult dt = GlimpseManager.GetExecutionTimer().Stop(_timer); bool hasError = (message.Exception != null); object retVal; if (hasError) retVal = message.Exception; else if (message.MethodInfo.IsVoid) retVal = "The SOAP call is to a void method"; else retVal = message.GetReturnValue(); _result.Url = message.Url; _result.Method = message.MethodInfo.Name + (hasError ? " - ERROR" : ""); _result.ResponseResult = retVal; _result.Duration = dt.Duration.Milliseconds + "ms"; _result.Stacktrace = new StackTrace(4, true).ToString(); GlimpseManager.LogMessage(_result); var timeline = new SoapTimelineMessage(); timeline.EventName = message.MethodInfo.Name + (hasError ? " - ERROR" : ""); timeline.EventSubText = message.Url + "\n" + retVal; timeline.Offset = dt.Offset; timeline.Duration = dt.Duration; timeline.StartTime = dt.StartTime; timeline.EventCategory = SoapTimelineCategory; GlimpseManager.LogMessage(timeline); break; } }
public void BeforeSerialize(SoapMessage message) //ObjectOut { if(onClientOrServer == OnClientOrServer.Unknown) onClientOrServer = OnClientOrServer.Client; if(System.Environment.OSVersion.Platform != PlatformID.WinCE) { //NOTE this only works if you handle StreamOut/In too //NOTE this only works on .NETfx //TimestampHeader timestampHeader = new TimestampHeader(300); //message.Headers.Add(timestampHeader); if(onClientOrServer == OnClientOrServer.Server) { ActionHeader actionHeader = new ActionHeader(message.Action + "Response"); //else check what the inAction is RelatesToHeader relatesToHeader = null; if(inMessageId != null) relatesToHeader = new RelatesToHeader(inMessageId); ToHeader toHeader = null; if(inReplyTo != null) toHeader = new ToHeader(inReplyTo); //TODO ReferenceProperties message.Headers.Add(actionHeader); if(relatesToHeader != null) message.Headers.Add(relatesToHeader); if(toHeader != null) message.Headers.Add(toHeader); } else { //if(EndPoint == EndPointType.Addressing) ActionHeader actionHeader = new ActionHeader(message.Action); FromHeader fromHeader = new FromHeader(null); MessageIdHeader messageIdHeader = new MessageIdHeader(null); ToHeader toHeader = new ToHeader(message.Url); //TODO Subscription would need a ReplyTo header for asynch web services //ReplyToHeader replyToHeader = new ReplyToHeader("http://tempuri.org/RespondToClientCall/"); ReplyToHeader replyToHeader = new ReplyToHeader(message.Url); //just respond normally? message.Headers.Add(replyToHeader); message.Headers.Add(actionHeader); message.Headers.Add(fromHeader); message.Headers.Add(messageIdHeader); message.Headers.Add(toHeader); } //else //routing //pathHeader pHeader = new pathHeader(message.Action, message.Url, null); //message.Headers.Add(pHeader); } return; }
public override void ProcessMessage(SoapMessage message) { int num = -1; if (message.Stage == SoapMessageStage.AfterDeserialize) { foreach (SoapHeader soapHeader in message.Headers) { if (soapHeader is AuthHeader) { AuthHeader arg_33_0 = (AuthHeader)soapHeader; } } throw new SoapException("[" + num.ToString() + "] " + this._authRespMsg, SoapException.ClientFaultCode); } }
// If the SoapMessageStage is such that the SoapRequest or // SoapResponse is still in the SOAP format to be sent or received, // save it out to a file. public override void ProcessMessage(SoapMessage message) { switch (message.Stage) { case SoapMessageStage.BeforeSerialize: break; case SoapMessageStage.AfterSerialize: WriteOutput(message); break; case SoapMessageStage.BeforeDeserialize: WriteInput(message); break; case SoapMessageStage.AfterDeserialize: break; } }
public override void ProcessMessage(SoapMessage message) { string messageAsString; StreamReader reader; StreamWriter writer; switch (message.Stage) { case SoapMessageStage.BeforeSerialize: break; case SoapMessageStage.AfterDeserialize: break; case SoapMessageStage.BeforeDeserialize: reader = new StreamReader(_streamOut); writer = new StreamWriter(_streamIn); messageAsString = reader.ReadToEnd(); switch (message.MethodInfo.Name) { case "getWorklogs": case "addWorklogWithNewRemainingEstimate": case "addWorklogAndAutoAdjustRemainingEstimate": case "addWorklogAndRetainRemainingEstimate": messageAsString = messageAsString .Replace("IssueServiceImpl$RemoteWorklogImpl", "RemoteWorklog") .Replace("service", "beans"); break; } writer.Write(messageAsString); writer.Flush(); _streamIn.Position = 0; break; case SoapMessageStage.AfterSerialize: _streamIn.Position = 0; reader = new StreamReader(_streamIn); writer = new StreamWriter(_streamOut); messageAsString = reader.ReadToEnd(); writer.Write(messageAsString); writer.Flush(); break; } }
/// <summary> /// /// </summary> /// <param name="message"></param> public override void ProcessMessageBeforeDeserialize(System.Web.Services.Protocols.SoapMessage message) { StreamCompressor compressor = StreamCompressor.Create(CompressorMode); try { //对于处理BeforeDeserialize过程时,因为系统会按照优先级从高到低逐个调用SOAP扩展(跟上述过程刚好相反) //的ProcessMessage方法,因此输入流必须是previousStream所指向的对象,该对象是优先级别更高的SOAP扩展的 //currentStream所指向的内存流对象,或者当前SOAP扩展自身是个最高优先级别的扩展时,其previousStream所 //指向的对象是个来自网络的输入流对象,而该函数所接受的输出流对象则应该是currentStream所指向的流对象。 compressor.ProcessStream(previousStream, currentStream, StreamProcessMode.Decompress); } catch (Exception e) { throw new SoapException(e.Message, SoapException.ServerFaultCode, e); } }
/// <summary> /// /// </summary> /// <param name="message"></param> public override void ProcessMessageAfterSerialize(System.Web.Services.Protocols.SoapMessage message) { StreamCompressor compressor = StreamCompressor.Create(CompressorMode); try { //对于处理AfterSerialize过程时,因为系统按优先级从低到高逐个调用SOAP扩展的ProcessMessage方法, //因此输入流必须是currentStream指向的对象,该对象就是在ChainStream方法中定义的MemoryStream对象, //而输出流是previousStream所指向的对象,该对象是更高优先级的SOAP扩展的输入流对象或者当前SOAP扩展 //自身是最高优先级别的扩展时,其previousStream所指向的对象是个SoapExternalStream对象,这个对象只 //是一个包装类对象而已,它底层包含了一个用于将构成Http/Soap协议所必要的信息发送到网络中输出流。 compressor.ProcessStream(currentStream, previousStream, StreamProcessMode.Compress); } catch (Exception e) { throw new SoapException(e.Message, SoapException.ServerFaultCode, e); } }
public override void ProcessMessage(SoapMessage message) { switch (message.Stage) { case SoapMessageStage.BeforeSerialize: break; case SoapMessageStage.AfterSerialize: WriteRequest(message); break; case SoapMessageStage.BeforeDeserialize: WriteResponse(message); break; case SoapMessageStage.AfterDeserialize: break; default: throw new Exception("invalid stage"); } }
public void WriteInput(SoapMessage message) { Copy(oldStream, newStream); Stream resp = new MemoryStream(); newStream.Position = 0; Copy(newStream, resp); resp.Position = 0; using (TextReader reader = new StreamReader(resp)) { try { //string response = reader.ReadToEnd(); Context.Current.Response = reader.ReadToEnd(); } catch { } } newStream.Position = 0; }
/// <summary> /// Soap消息的不同状态处理 /// </summary> /// <param name="message">内部传输的Soap消息【带有状态】</param> public override void ProcessMessage(SoapMessage message) { switch (message.Stage) { case SoapMessageStage.BeforeSerialize: break; case SoapMessageStage.BeforeDeserialize: this.WriteInputStream(message); break; case SoapMessageStage.AfterSerialize: this.WriteOutputStream(message); break; case SoapMessageStage.AfterDeserialize: break; default: throw new Exception("Error Message Stage"); } }
public override void ProcessMessage(SoapMessage message) { switch (message.Stage) { case SoapMessageStage.BeforeDeserialize: // Incoming message LogMessageFromStream(message.Stream); break; case SoapMessageStage.AfterDeserialize: break; case SoapMessageStage.BeforeSerialize: break; case SoapMessageStage.AfterSerialize: break; } }
public override void ProcessMessage(SoapMessage message) { switch (message.Stage) { case SoapMessageStage.BeforeSerialize: BeforeSerialize(message); break; case SoapMessageStage.AfterSerialize: AfterSerialize(message); break; case SoapMessageStage.BeforeDeserialize: BeforeDeserialize(message); break; case SoapMessageStage.AfterDeserialize: AfterDeserialize(message); break; default: throw new Exception("invalid SoapExtension.ProcessMessage stage"); } }
public override void ProcessMessage(SoapMessage message) { switch (message.Stage) { case SoapMessageStage.BeforeSerialize: //Add the CustomSoapHeader to outgoing client requests if (message is SoapClientMessage) { AddHeader(message); } break; case SoapMessageStage.AfterSerialize: AfterSerialize(message); break; case SoapMessageStage.BeforeDeserialize: BeforeDeserialize(message); break; case SoapMessageStage.AfterDeserialize: break; } }
/// <summary> /// /// </summary> /// <param name="message"></param> public override void ProcessMessage(SoapMessage message) { if (message.Stage == SoapMessageStage.AfterSerialize) { _newStream.Position = 0; if (message.Exception != null && message.Exception.InnerException != null) { InsertDetailIntoOldStream(message.Exception.InnerException); } else { CopyStream(_newStream, _oldStream); } } else if (message.Stage == SoapMessageStage.BeforeDeserialize) { CopyStream(_oldStream, _newStream); _newStream.Position = 0; } }
public override void ProcessMessage(SoapMessage message) { switch (message.Stage) { case SoapMessageStage.BeforeSerialize: break; case SoapMessageStage.AfterSerialize: Encrypt(); break; case SoapMessageStage.BeforeDeserialize: Decrypt(); break; case SoapMessageStage.AfterDeserialize: break; default: throw new Exception("invalid stage"); } }
public override void ProcessMessage(SoapMessage message) { // bool bIsServer; // if(message.GetType() == typeof(SoapServerMessage)) // { // bIsServer = true; // } // else // { // bIsServer = false; // } switch (message.Stage) { // Incomming from client case SoapMessageStage.BeforeDeserialize: ReceiveStream(); ReverseIncomingStream(); LogInput(message); break; // About to call methods case SoapMessageStage.AfterDeserialize: break; // After Method call case SoapMessageStage.BeforeSerialize: break; // Outgoing to client case SoapMessageStage.AfterSerialize: ReverseOutgoingStream(); LogOutput(message); ReturnStream(); break; default: throw new Exception("No stage such as this..."); } }
public void AfterDeserialize(SoapMessage message) //ObjectIn { SoapMessage mess = message; return; }
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); }
public override void ProcessMessage(System.Web.Services.Protocols.SoapMessage message) { var resultado = StreamToString(message.Stream); }
public override void ProcessMessage(System.Web.Services.Protocols.SoapMessage message) { AgentMessageTable ab = AgentMessageTable.Instance; // if (AgentMessageTable.GetSize() >= 100) // ; AgentMessageTable a = AgentMessageTable.Instance; System.Console.WriteLine("Tread " + Thread.CurrentThread.ManagedThreadId + " Message Table:" + AgentMessageTable.GetSize()); try { if (HttpContext.Current == null) { } else { //depends.Push(HttpContext.Current.Request.Url); } if (message == null) { throw new ArgumentNullException("message"); } if (message.GetType() == typeof(SoapClientMessage)) { switch (message.Stage) { case SoapMessageStage.BeforeSerialize: //outbound message client this.ProcessOutboundRequest(message); //this.InsertHeadersOutbound(message, true); return; case SoapMessageStage.AfterSerialize: //outbound message client return; case SoapMessageStage.BeforeDeserialize: this.GrabClientResponseMessageBeforeDeserialization(message); //inbound message client //4-16-2012 moved call to after deserialization to obtain soap headers for dependency detection return; case SoapMessageStage.AfterDeserialize: this.ProcessInboundResponse(message); return; } } else if (message.GetType() == typeof(SoapServerMessage)) { switch (message.Stage) { case SoapMessageStage.BeforeSerialize: //outbound server this.InsertHeadersOutbound(message, false); return; case SoapMessageStage.AfterSerialize: //outbound server this.ProcessOutboundResponse(message); return; case SoapMessageStage.BeforeDeserialize: //this.ProcessInboundRequest(message); //this yields no access to soap headers return; case SoapMessageStage.AfterDeserialize: this.ProcessInboundRequest(message); //just moved this return; } } else { try { Logger.warn(this.GetType().FullName + "unknown message type was not handled: " + message.GetType().FullName); } catch { } } } catch (Exception ex) { Logger.error(ex, this.GetType().FullName + "error caught when processing a message"); /* String s = ""; * while (ex != null) * { * s += ex.Message + System.Environment.NewLine + ex.StackTrace + System.Environment.NewLine + ex.InnerException + System.Environment.NewLine + System.Environment.NewLine; * ex = ex.InnerException; * } * try * { * if (FGSMSConstants.log) EventLog.WriteEntry(this.GetType().FullName, "error caught " + message.GetType().FullName + s, EventLogEntryType.Error); * } * catch { }*/ } }
internal override bool Initialize() { // try to guess the request version so we can handle any exceptions that might come up GuessVersion(); message = new SoapServerMessage(this); onewayInitException = null; serverType = (SoapServerType)GetFromCache(typeof(SoapServerProtocol), Type); if (serverType == null) { lock (Type){ serverType = (SoapServerType)GetFromCache(typeof(SoapServerProtocol), Type); if (serverType == null) { serverType = new SoapServerType(Type, versionsSupported); AddToCache(typeof(SoapServerProtocol), Type, serverType); } } } // We delay throwing any exceptions out of the extension until we determine if the method is one-way or not. Exception extensionException = null; try { message.highPriConfigExtensions = SoapMessage.InitializeExtensions(serverType.HighPriExtensions, serverType.HighPriExtensionInitializers); // For one-way methods we rely on Request.InputStream guaranteeing that the entire request body has arrived message.SetStream(Request.InputStream); Debug.Assert(message.Stream.CanSeek, "Web services SOAP handler assumes a seekable stream."); message.InitExtensionStreamChain(message.highPriConfigExtensions); message.SetStage(SoapMessageStage.BeforeDeserialize); message.ContentType = Request.ContentType; message.ContentEncoding = Request.Headers[ContentType.ContentEncoding]; message.RunExtensions(message.highPriConfigExtensions); } catch (Exception e) { extensionException = e; } // set this here since we might throw before we init the other extensions message.allExtensions = message.highPriConfigExtensions; // maybe the extensions that just ran changed some of the request data so we can make a better version guess GuessVersion(); try { this.serverMethod = helper.RouteRequest(); // the RouteRequest impl should throw an exception if it can't route the request but just in case... if (this.serverMethod == null) { throw new SoapException(Res.GetString(Res.UnableToHandleRequest0), new XmlQualifiedName(Soap.ServerCode, Soap.Namespace)); } } catch (Exception) { if (helper.RequestNamespace != null) { SetHelper(SoapServerProtocolHelper.GetHelper(this, helper.RequestNamespace)); } // version mismatches override other errors CheckHelperVersion(); throw; } this.isOneWay = serverMethod.oneWay; if (extensionException == null) { try { SoapReflectedExtension[] otherReflectedExtensions = (SoapReflectedExtension[])CombineExtensionsHelper(serverMethod.extensions, serverType.LowPriExtensions, typeof(SoapReflectedExtension)); object[] otherInitializers = (object[])CombineExtensionsHelper(serverMethod.extensionInitializers, serverType.LowPriExtensionInitializers, typeof(object)); message.otherExtensions = SoapMessage.InitializeExtensions(otherReflectedExtensions, otherInitializers); message.allExtensions = (SoapExtension[])CombineExtensionsHelper(message.highPriConfigExtensions, message.otherExtensions, typeof(SoapExtension)); } catch (Exception e) { extensionException = e; } } if (extensionException != null) { if (isOneWay) { onewayInitException = extensionException; } else { throw new SoapException(Res.GetString(Res.WebConfigExtensionError), new XmlQualifiedName(Soap.ServerCode, Soap.Namespace), extensionException); } } return(true); }
internal override bool Initialize() { this.GuessVersion(); this.message = new SoapServerMessage(this); this.onewayInitException = null; this.serverType = (SoapServerType)base.GetFromCache(typeof(SoapServerProtocol), base.Type); if (this.serverType == null) { lock (ServerProtocol.InternalSyncObject) { this.serverType = (SoapServerType)base.GetFromCache(typeof(SoapServerProtocol), base.Type); if (this.serverType == null) { this.serverType = new SoapServerType(base.Type, this.protocolsSupported); base.AddToCache(typeof(SoapServerProtocol), base.Type, this.serverType); } } } Exception innerException = null; try { this.message.highPriConfigExtensions = SoapMessage.InitializeExtensions(this.serverType.HighPriExtensions, this.serverType.HighPriExtensionInitializers); this.message.highPriConfigExtensions = this.ModifyInitializedExtensions(PriorityGroup.High, this.message.highPriConfigExtensions); this.message.SetStream(base.Request.InputStream); this.message.InitExtensionStreamChain(this.message.highPriConfigExtensions); this.message.SetStage(SoapMessageStage.BeforeDeserialize); this.message.ContentType = base.Request.ContentType; this.message.ContentEncoding = base.Request.Headers["Content-Encoding"]; this.message.RunExtensions(this.message.highPriConfigExtensions, false); innerException = this.message.Exception; } catch (Exception exception2) { if (((exception2 is ThreadAbortException) || (exception2 is StackOverflowException)) || (exception2 is OutOfMemoryException)) { throw; } if (Tracing.On) { Tracing.ExceptionCatch(TraceEventType.Warning, this, "Initialize", exception2); } innerException = exception2; } this.message.allExtensions = this.message.highPriConfigExtensions; this.GuessVersion(); try { this.serverMethod = this.RouteRequest(this.message); if (this.serverMethod == null) { throw new SoapException(System.Web.Services.Res.GetString("UnableToHandleRequest0"), new XmlQualifiedName("Server", "http://schemas.xmlsoap.org/soap/envelope/")); } } catch (Exception exception3) { if (((exception3 is ThreadAbortException) || (exception3 is StackOverflowException)) || (exception3 is OutOfMemoryException)) { throw; } if (this.helper.RequestNamespace != null) { this.SetHelper(SoapServerProtocolHelper.GetHelper(this, this.helper.RequestNamespace)); } this.CheckHelperVersion(); throw; } this.isOneWay = this.serverMethod.oneWay; if (innerException == null) { try { SoapReflectedExtension[] reflectedExtensions = (SoapReflectedExtension[])CombineExtensionsHelper(this.serverMethod.extensions, this.serverType.LowPriExtensions, typeof(SoapReflectedExtension)); object[] extensionInitializers = (object[])CombineExtensionsHelper(this.serverMethod.extensionInitializers, this.serverType.LowPriExtensionInitializers, typeof(object)); this.message.otherExtensions = SoapMessage.InitializeExtensions(reflectedExtensions, extensionInitializers); this.message.otherExtensions = this.ModifyInitializedExtensions(PriorityGroup.Low, this.message.otherExtensions); this.message.allExtensions = (SoapExtension[])CombineExtensionsHelper(this.message.highPriConfigExtensions, this.message.otherExtensions, typeof(SoapExtension)); } catch (Exception exception4) { if (((exception4 is ThreadAbortException) || (exception4 is StackOverflowException)) || (exception4 is OutOfMemoryException)) { throw; } if (Tracing.On) { Tracing.ExceptionCatch(TraceEventType.Warning, this, "Initialize", exception4); } innerException = exception4; } } if (innerException != null) { if (!this.isOneWay) { if (innerException is SoapException) { throw innerException; } throw SoapException.Create(this.Version, System.Web.Services.Res.GetString("WebConfigExtensionError"), new XmlQualifiedName("Server", "http://schemas.xmlsoap.org/soap/envelope/"), innerException); } this.onewayInitException = innerException; } return(true); }
public void AfterSerialize(SoapMessage message) //StreamOut { newStream.Position = 0; //Hack MemoryStream below because of XmlDocument bug closing stream byte [] tempBa = new byte[newStream.Length]; int bytesRead = newStream.Read(tempBa, 0, (int) newStream.Length); MemoryStream ms = new MemoryStream(tempBa); //BUG NOTE this closes the underlying stream on .NETcf XmlDocument xd = new XmlDocument(); xd.Load(ms); //MemoryStream will be closed now //outgoing //timestamp and routing HeadersHandler.AddHeaders(xd, message.Action, message.Url); //XmlEncHandler.EncryptXml(xd); XmlSigHandler.SignXml(xd); //or before XmlEnc. //Trace newStream.Position = 0; XmlTextWriter xtw = new XmlTextWriter(newStream, System.Text.Encoding.UTF8); xtw.Namespaces = true; xd.WriteTo(xtw); xtw.Flush(); //xtw.Close(); //these 2 lines have be called at a minimum newStream.Position = 0; Copy(newStream, oldStream); //for next guy return; }
public void BeforeSerialize(SoapMessage message) //ObjectOut { //NOTE this only works if you handle StreamOut/In too //NOTE this only works on .NETfx return; }
public abstract void ProcessMessage(SoapMessage message);
public void BeforeSerialize(SoapMessage message) //ObjectOut { if(onClientOrServer == OnClientOrServer.Unknown) onClientOrServer = OnClientOrServer.Client; return; }