public void AfterReceiveReply(ref System.ServiceModel.Channels.Message reply, object correlationState) { MessageBuffer msgBuffer = reply.CreateBufferedCopy(int.MaxValue); MemoryStream ms = new MemoryStream(); msgBuffer.WriteMessage(ms); ms.Position = 0; StreamReader sr = new StreamReader(ms); string output = sr.ReadToEnd(); sr.Close(); soapMessages.SoapResponse = output; soapMessages.SoapResponseMessageId = GetMessageId(output); reply = msgBuffer.CreateMessage(); msgBuffer.Close(); //Below for debug, write Soap to static File //DirectoryInfo DirectoryInfo = new DirectoryInfo(@"C:\temp\HIServiceSOAP"); //if (!DirectoryInfo.Exists) //{ // DirectoryInfo.Create(); //} //FileInfo FileInfo = new FileInfo($"{DirectoryInfo.FullName}\\{DateTime.Now.ToString("yyyyMMddTHHmmss")}_ResponseSoap.xml"); //File.WriteAllText(FileInfo.FullName, soapMessages.SoapRequest); // Comment this out as if error back from ESB - it doesn't get passed Validation // bool isValid = VerifyXML(soapMessages.SoapResponse); // soapMessages.IsSoapResponseSignatureValid = VerifyXML(soapMessages.SoapResponse); }
public void AfterReceiveReply(ref System.ServiceModel.Channels.Message reply, object correlationState) { MessageBuffer msgBuffer = reply.CreateBufferedCopy(int.MaxValue); MemoryStream ms = new MemoryStream(); msgBuffer.WriteMessage(ms); ms.Position = 0; StreamReader sr = new StreamReader(ms); string output = sr.ReadToEnd(); sr.Close(); soapMessages.SoapResponse = output; soapMessages.SoapResponseMessageId = GetMessageId(output); reply = msgBuffer.CreateMessage(); msgBuffer.Close(); // Comment this out as if error back from ESB - it doesn't get passed Validation // bool isValid = VerifyXML(soapMessages.SoapResponse); // soapMessages.IsSoapResponseSignatureValid = VerifyXML(soapMessages.SoapResponse); }
public void AfterReceiveReply(ref System.ServiceModel.Channels.Message reply, object correlationState) { lock (_syncObject) { if (MessageSink != null) { // so bizarre...but if you don't, you'll ruin comms between the service and client MessageBuffer buffer = reply.CreateBufferedCopy(Int32.MaxValue); reply = buffer.CreateMessage(); // so bizarre...but if you don't, you'll ruin comms between the service and client Message msg = buffer.CreateMessage(); StringBuilder sb = new StringBuilder(); XmlWriter xw = XmlWriter.Create(sb); msg.WriteBody(xw); xw.Close(); MessageSink.WriteMessage(String.Format("Received ({0}):", DateTime.Now.ToUniversalTime().ToString())); MessageSink.WriteMessage(msg.ToString()); MessageSink.WriteMessage("Body:"); MessageSink.WriteMessage(sb.ToString()); buffer.Close(); } } }
/// <summary> /// Extracts the body of a WCF Message and returns it as an XmlDocment /// </summary> /// <param name="msg">The WCF message</param> /// <param name="discardOriginalMessage">If true, the body of the original message will not be /// readable after calling this method</param> /// <returns>The body of the Message as an XmlDocument</returns> public static XmlDocument GetMessageBodyAsXmlDocument(Message msg, bool discardOriginalMessage) { XmlDocument messageXml; if (msg.IsEmpty) { messageXml = null; } else { messageXml = new XmlDocument(); if (!discardOriginalMessage) { MessageBuffer bufferCopy = msg.CreateBufferedCopy(int.MaxValue); XmlDictionaryReader reader = bufferCopy.CreateMessage().GetReaderAtBodyContents(); messageXml.Load(reader); reader.Close(); msg = bufferCopy.CreateMessage(); bufferCopy.Close(); } else { XmlDictionaryReader reader = msg.GetReaderAtBodyContents(); messageXml.Load(reader); reader.Close(); } } return(messageXml); }
public void TestCreateMessageFromClosedBuffer() { Message m = Message.CreateMessage(MessageVersion.Default, String.Empty); MessageBuffer b = m.CreateBufferedCopy(0); b.Close(); b.CreateMessage(); }
private void Release() { if (buffer == null) { return; } buffer.Close(); buffer = null; message = null; }
/// <summary> /// Enables inspection or modification of a message after a reply message is /// received but prior to passing it back to the client application /// </summary> /// <param name="reply"></param> /// <param name="correlationState"></param> public void AfterReceiveReply(ref Message reply, object correlationState) { MessageBuffer buffer = reply.CreateBufferedCopy(Int32.MaxValue); var requestCopy = buffer.CreateMessage(); var messageLog = new MessageInspectorLogger(); messageLog.Log(requestCopy); reply = buffer.CreateMessage(); buffer.Close(); }
public void AfterReceiveReply(ref Message reply, object correlationState) { MessageBuffer messageBuffer = reply.CreateBufferedCopy(1048576); MemoryStream memoryStream = new MemoryStream(); messageBuffer.WriteMessage(memoryStream); memoryStream.Position = 0L; StreamReader streamReader = new StreamReader(memoryStream); this.RawResponse = streamReader.ReadToEnd(); streamReader.Close(); memoryStream.Close(); reply = messageBuffer.CreateMessage(); messageBuffer.Close(); }
/// <summary> /// Enables inspection or modification of a message before a request message is /// sent to a service /// </summary> /// <param name="request"></param> /// <param name="channel"></param> /// <returns></returns> public object BeforeSendRequest(ref Message request, IClientChannel channel) { MessageBuffer buffer = request.CreateBufferedCopy(Int32.MaxValue); var requestCopy = buffer.CreateMessage(); var messageLog = new MessageInspectorLogger(); messageLog.Log(requestCopy); request = buffer.CreateMessage(); buffer.Close(); return(null); }
public object AfterReceiveRequest(ref System.ServiceModel.Channels.Message request, System.ServiceModel.IClientChannel channel, System.ServiceModel.InstanceContext instanceContext) { //create a copy of the message since a message can be read only once MessageBuffer buffer = request.CreateBufferedCopy(Int32.MaxValue); request = buffer.CreateMessage(); Message dupeRequest = buffer.CreateMessage(); //log the action Helper.Log(dupeRequest.Headers.Action); buffer.Close(); Helper.Log("IDispatchMessageInspector.AfterReceiveRequest() called from " + Helper.GetClientIP()); return(null); }
/// <summary> /// Async method of ProcessMessage. /// </summary> /// <param name="request">request message</param> /// <param name="callback">callback method</param> /// <param name="asyncState">async state</param> /// <returns>async result</returns> public IAsyncResult BeginProcessMessage(Message request, AsyncCallback callback, object asyncState) { MessageBuffer buffer = request.CreateBufferedCopy(int.MaxValue); byte[] messageData = AzureQueueItem.Serialize(buffer.CreateMessage()); QueueAsyncResult asyncResult = new QueueAsyncResult(callback, asyncState); UniqueId messageId = request.Headers.MessageId; asyncResult.MessageId = messageId; asyncResult.StorageClient = this.requestStorageClient; try { BrokerTracing.TraceVerbose( "[AzureServiceClient].BeginProcessMessage: Try to add message {0} to the request queue.", messageId); var reliableState = new ReliableQueueClient.ReliableState(asyncResult, messageId); // Notice: It can happen that response message is back before // EndAddMessage is called on the request message. So // add/update the callback info to AzureQueueManager before // calling BeginAddMessage avoid the issue that response comes // back but can't find callback info. this.manager.AddQueueAsyncResult(asyncResult, this.requestStorageClient.QueueName, this.responseStorageName); this.requestStorageClient.BeginAddMessage(messageData, messageId, this.BeginAddMessageCallback, reliableState); } catch (Exception e) { BrokerTracing.TraceError( "[AzureServiceClient].BeginProcessMessage: Failed to add message {0}, {1}", messageId, e); this.manager.CompleteCallback(asyncResult, null, e); } finally { buffer.Close(); } return(asyncResult); }
internal MessageLogTraceRecord(ref System.ServiceModel.Channels.Message message, XmlReader reader, System.ServiceModel.Diagnostics.MessageLoggingSource source, bool logMessageBody) : this(source) { MessageBuffer buffer = null; try { this.logMessageBody = logMessageBody; this.message = message; this.reader = reader; this.type = message.GetType(); } finally { if (buffer != null) { buffer.Close(); } } }
public object BeforeSendRequest(ref System.ServiceModel.Channels.Message request, System.ServiceModel.IClientChannel channel) { lock (_syncObject) { if (MessageSink != null) { // so bizarre...but if you don't, you'll ruin comms between the service and client MessageBuffer buffer = request.CreateBufferedCopy(Int32.MaxValue); request = buffer.CreateMessage(); // so bizarre...but if you don't, you'll ruin comms between the service and client MessageSink.WriteMessage(String.Format("Sending ({0}):", DateTime.Now.ToUniversalTime().ToString())); MessageSink.WriteMessage(buffer.CreateMessage().ToString()); buffer.Close(); } } return(null); }
public void AfterReceiveReply(ref System.ServiceModel.Channels.Message reply, object correlationState) { MessageBuffer msgBuffer = reply.CreateBufferedCopy(int.MaxValue); Message msg = msgBuffer.CreateMessage(); soapMessages.SoapResponse = ConvertMessageToString(msg); reply = msgBuffer.CreateMessage(); msgBuffer.Close(); // Verify signature on soap response try { soapMessages.SoapResponseSignatureStatus = SoapSignatureUtility.VerifyXML(soapMessages.SoapResponse); } catch (Exception ex) { } }
public void PoxBufferedMessage_BufferedCopy_Negative() { // write message throws argument null // All props throw after close, create message, write message throw after close using (Message message = this.GetMessage()) { MessageBuffer buffer = message.CreateBufferedCopy(0); // WriteMessage throws ArgumentNullException. ExceptionHelper.ExpectArgumentNullException(() => { buffer.WriteMessage(null); }, "stream"); // All members throw ObjectDisposedException after Close. buffer.Close(); ExceptionHelper.ExpectException <ObjectDisposedException>(() => { int bufferSize = buffer.BufferSize; }, ObjectDisposedText); ExceptionHelper.ExpectException <ObjectDisposedException>(() => { string contentType = buffer.MessageContentType; }, ObjectDisposedText); ExceptionHelper.ExpectException <ObjectDisposedException>(() => { buffer.CreateMessage(); }, ObjectDisposedText); ExceptionHelper.ExpectException <ObjectDisposedException>(() => { using (MemoryStream stream = new MemoryStream()) { buffer.WriteMessage(stream); } }, ObjectDisposedText); } }
internal MessageLogTraceRecord(ref Message message, XmlReader reader, MessageLoggingSource source, bool logMessageBody) : this(source) { Fx.Assert(message != null, ""); MessageBuffer buffer = null; try { this.logMessageBody = logMessageBody; this.message = message; this.reader = reader; this.type = message.GetType(); } finally { if (buffer != null) { buffer.Close(); } } }
public void AfterReceiveReply(ref System.ServiceModel.Channels.Message reply, object correlationState) { MessageBuffer msgBuffer = reply.CreateBufferedCopy(int.MaxValue); MemoryStream ms = new MemoryStream(); msgBuffer.WriteMessage(ms); ms.Position = 0; StreamReader sr = new StreamReader(ms); string output = sr.ReadToEnd(); sr.Close(); //File.WriteAllText("C:\\Temp\\SOAP_Response.xml", output); soapMessages.SoapResponse = output; reply = msgBuffer.CreateMessage(); msgBuffer.Close(); }
public object BeforeSendRequest(ref Message request, IClientChannel channel) { // Try to get Request ID from inbound request. Guid OrganizationRequestId = Guid.Empty; try { // Get a copy to work with. using (MessageBuffer mbuff = request.CreateBufferedCopy(Int32.MaxValue)) { request = mbuff.CreateMessage(); // Copy it back to the request buffer. using (XmlDictionaryReader msgReader = mbuff.CreateMessage().GetReaderAtBodyContents()) { msgReader.MoveToContent(); while (msgReader.Read()) { if (msgReader.NodeType == XmlNodeType.Element && msgReader.LocalName.Equals("RequestId", StringComparison.OrdinalIgnoreCase)) { string readValue = msgReader.ReadElementContentAsString(); if (!string.IsNullOrEmpty(readValue)) { Guid.TryParse(readValue, out OrganizationRequestId); // Find the request ID from the message and assign it to the new tracking id. } break; } } } mbuff.Close(); } } catch { } // Adding HTTP Headers object httpRequestMessageObject; if (request.Properties.TryGetValue(HttpRequestMessageProperty.Name, out httpRequestMessageObject)) { HttpRequestMessageProperty httpRequestMessage = httpRequestMessageObject as HttpRequestMessageProperty; if (string.IsNullOrEmpty(httpRequestMessage.Headers[Utilities.CDSRequestHeaders.USER_AGENT_HTTP_HEADER])) { httpRequestMessage.Headers[Utilities.CDSRequestHeaders.USER_AGENT_HTTP_HEADER] = _userAgent; } if (string.IsNullOrEmpty(httpRequestMessage.Headers[HttpRequestHeader.Connection])) { httpRequestMessage.Headers.Add(HttpRequestHeader.Connection, Utilities.CDSRequestHeaders.CONNECTION_KEEP_ALIVE); } if (OrganizationRequestId != Guid.Empty && string.IsNullOrEmpty(httpRequestMessage.Headers[Utilities.CDSRequestHeaders.X_MS_CLIENT_REQUEST_ID])) { httpRequestMessage.Headers[Utilities.CDSRequestHeaders.X_MS_CLIENT_REQUEST_ID] = OrganizationRequestId.ToString(); } if ((_callerCdsConnectionServiceHandler != null && (_callerCdsConnectionServiceHandler.SessionTrackingId.HasValue && _callerCdsConnectionServiceHandler.SessionTrackingId.Value != Guid.Empty)) && string.IsNullOrEmpty(httpRequestMessage.Headers[Utilities.CDSRequestHeaders.X_MS_CLIENT_SESSION_ID])) { httpRequestMessage.Headers[Utilities.CDSRequestHeaders.X_MS_CLIENT_SESSION_ID] = _callerCdsConnectionServiceHandler.SessionTrackingId.Value.ToString(); } if ((_callerCdsConnectionServiceHandler != null && _callerCdsConnectionServiceHandler.ForceServerCacheConsistency && string.IsNullOrEmpty(httpRequestMessage.Headers[Utilities.CDSRequestHeaders.FORCE_CONSISTENCY]))) { httpRequestMessage.Headers[Utilities.CDSRequestHeaders.FORCE_CONSISTENCY] = "Strong"; } } else { HttpRequestMessageProperty httpRequestMessage = new HttpRequestMessageProperty(); httpRequestMessage.Headers.Add(Utilities.CDSRequestHeaders.USER_AGENT_HTTP_HEADER, _userAgent); httpRequestMessage.Headers.Add(HttpRequestHeader.Connection, Utilities.CDSRequestHeaders.CONNECTION_KEEP_ALIVE); if (OrganizationRequestId != Guid.Empty) { httpRequestMessage.Headers.Add(Utilities.CDSRequestHeaders.X_MS_CLIENT_REQUEST_ID, OrganizationRequestId.ToString()); } if (_callerCdsConnectionServiceHandler != null && (_callerCdsConnectionServiceHandler.SessionTrackingId.HasValue && _callerCdsConnectionServiceHandler.SessionTrackingId.Value != Guid.Empty)) { httpRequestMessage.Headers.Add(Utilities.CDSRequestHeaders.X_MS_CLIENT_SESSION_ID, _callerCdsConnectionServiceHandler.SessionTrackingId.Value.ToString()); } if ((_callerCdsConnectionServiceHandler != null && _callerCdsConnectionServiceHandler.ForceServerCacheConsistency && string.IsNullOrEmpty(httpRequestMessage.Headers[Utilities.CDSRequestHeaders.FORCE_CONSISTENCY]))) { httpRequestMessage.Headers.Add(Utilities.CDSRequestHeaders.FORCE_CONSISTENCY, "Strong"); } request.Properties.Add(HttpRequestMessageProperty.Name, httpRequestMessage); } // Adding SOAP headers Guid callerId = Guid.Empty; if (_callerCdsConnectionServiceHandler != null) { if (_callerCdsConnectionServiceHandler.CdsWebClient != null) { callerId = _callerCdsConnectionServiceHandler.CdsWebClient.CallerId; } } if (callerId == Guid.Empty) // Prefer the CRM Caller ID over hte AADObjectID. { if (_callerCdsConnectionServiceHandler != null && (_callerCdsConnectionServiceHandler.CallerAADObjectId.HasValue && _callerCdsConnectionServiceHandler.CallerAADObjectId.Value != Guid.Empty)) { // Add Caller ID to the SOAP Envolope. // Set a header request with the AAD Caller Object ID. using (OperationContextScope scope = new OperationContextScope((IContextChannel)channel)) { var AADCallerIdHeader = new MessageHeader <Guid>(_callerCdsConnectionServiceHandler.CallerAADObjectId.Value).GetUntypedHeader(Utilities.CDSRequestHeaders.AAD_CALLER_OBJECT_ID_HTTP_HEADER, "http://schemas.microsoft.com/xrm/2011/Contracts"); request.Headers.Add(AADCallerIdHeader); } } } if (OrganizationRequestId != Guid.Empty) { using (OperationContextScope scope = new OperationContextScope((IContextChannel)channel)) { var ClientRequestHeader = new MessageHeader <Guid>(OrganizationRequestId).GetUntypedHeader(Utilities.CDSRequestHeaders.X_MS_CLIENT_REQUEST_ID, "http://schemas.microsoft.com/xrm/2011/Contracts"); request.Headers.Add(ClientRequestHeader); } } if (_callerCdsConnectionServiceHandler != null && (_callerCdsConnectionServiceHandler.SessionTrackingId.HasValue && _callerCdsConnectionServiceHandler.SessionTrackingId.Value != Guid.Empty)) { using (OperationContextScope scope = new OperationContextScope((IContextChannel)channel)) { var ClientSessionRequestHeader = new MessageHeader <Guid>(_callerCdsConnectionServiceHandler.SessionTrackingId.Value).GetUntypedHeader(Utilities.CDSRequestHeaders.X_MS_CLIENT_SESSION_ID, "http://schemas.microsoft.com/xrm/2011/Contracts"); request.Headers.Add(ClientSessionRequestHeader); } } if ((_callerCdsConnectionServiceHandler != null && _callerCdsConnectionServiceHandler.ForceServerCacheConsistency)) { using (OperationContextScope scope = new OperationContextScope((IContextChannel)channel)) { var ForceConsistencytHeader = new MessageHeader <string>("Strong").GetUntypedHeader(Utilities.CDSRequestHeaders.FORCE_CONSISTENCY, "http://schemas.microsoft.com/xrm/2011/Contracts"); request.Headers.Add(ForceConsistencytHeader); } } return(null); }
public object AfterReceiveRequest(ref Message request, IClientChannel channel, InstanceContext instanceContext) { /* * if (!request.IsFault) * { * var quotas = new XmlDictionaryReaderQuotas(); * var bodyReader = request.GetReaderAtBodyContents().ReadSubtree(); * * var wrapperSettings = new XmlReaderSettings(); * wrapperSettings.CloseInput = true; * wrapperSettings.ValidationFlags = XmlSchemaValidationFlags.None; * wrapperSettings.ValidationType = ValidationType.None; * * var wrappedReader = XmlReader.Create(bodyReader, wrapperSettings); * * File.WriteAllText(Path.Combine("Z:\\Logs\\", Guid.NewGuid().ToString("N") + ".xml"), * wrappedReader.ReadOuterXml()); * * var memStream = new MemoryStream(); * var xdw = XmlDictionaryWriter.CreateBinaryWriter(memStream); * xdw.WriteNode(wrappedReader, false); * xdw.Flush(); * memStream.Position = 0L; * * var xdr = XmlDictionaryReader.CreateBinaryReader(memStream, quotas); * * Message replacedMessage = Message.CreateMessage(request.Version, null, xdr); * replacedMessage.Headers.CopyHeadersFrom(request.Headers); * replacedMessage.Properties.CopyProperties(request.Properties); * request = replacedMessage; * } */ // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! // WARNING: DOES NOT WORK WITH SECURED BINDINGS!!! // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! MessageBuffer buffer = request.CreateBufferedCopy(int.MaxValue); // cannot create even buffered copy when binding is secured try { Message toBeLogged = buffer.CreateMessage(); string filePath = GetLogFilePath(); using (var fileStream = new FileStream(filePath, FileMode.CreateNew, FileAccess.Write, FileShare.Read, 0x2000, FileOptions.SequentialScan)) using (var xdw = XmlDictionaryWriter.CreateTextWriter(fileStream, Encoding.UTF8, false)) { toBeLogged.WriteMessage(xdw); xdw.Flush(); } request = buffer.CreateMessage(); } finally { if (buffer != null) { buffer.Close(); } } return(null); }
public void Dispose() { _owner.Close(); }
public void Close() { localBuffer.Close(); Console.WriteLine("reader closed"); }
public object BeforeSendRequest(ref System.ServiceModel.Channels.Message request, System.ServiceModel.IClientChannel channel) { string startInfo = "application/soap+xml"; string boundary = string.Format("uuid:{0}+id=1", Guid.NewGuid()); string startUri = "http://tempuri.org/0"; // Set message ID UniqueId messageId = new UniqueId(); soapMessages.SoapRequestMessageId = messageId.ToString(); // Modify MessageId and From headers request.Headers.MessageId = messageId; request.Headers.From = new EndpointAddress("http://www.w3.org/2005/08/addressing/anonymous"); request.Headers.To = new Uri("http://www.w3.org/2005/08/addressing/anonymous"); // Create message buffer (Message needs to be recreated multiple times) MessageBuffer msgBuffer = request.CreateBufferedCopy(int.MaxValue); // Get assembled soap request and sign var messageToSign = msgBuffer.CreateMessage(); var bigXml = ConvertMessageToString(messageToSign); var signedBigXml = Encoding.UTF8.GetString(SoapSignatureUtility.SignBodyAndAddressingHeaders(Encoding.UTF8.GetBytes(bigXml), signingCertificate)); soapMessages.SoapRequest = signedBigXml; // Encoding message into MTOM format using MTOM writer request = msgBuffer.CreateMessage(); var initialMs = new MemoryStream(); var initialWriter = XmlDictionaryWriter.CreateMtomWriter(initialMs, Encoding.UTF8, int.MaxValue, startInfo, boundary, startUri, true, true); request.WriteMessage(initialWriter); initialWriter.Flush(); var originalMessageSize = (int)initialMs.Length; // Copy MTOM message into buffer byte[] bufferUnsigned = new byte[originalMessageSize]; Array.Copy(initialMs.GetBuffer(), 0, bufferUnsigned, 0, (int)initialMs.Position); string mtomString = Encoding.UTF8.GetString(bufferUnsigned); // Get SOAP XML from MTOM message, with start and end index int startSoapIndex; var unsignedXml = GetSoapFromString(mtomString, out startSoapIndex); int endSoapIndex = startSoapIndex + unsignedXml.Length; // If binary MIME parts are found in MTOM message, then replace out base64 content with MTOM include statement string signedFinalXml = signedBigXml; var partHeaderMatches = Regex.Matches(mtomString, @"((Content-ID: <.*>\s+)|(Content-Transfer-Encoding: binary\s+)|(Content-Type: application/octet-stream\s+)){3}", RegexOptions.IgnoreCase); if (partHeaderMatches.Count > 0) { for (int x = 0; x < partHeaderMatches.Count; x++) { var contentId = Regex.Match(partHeaderMatches[x].Value, "Content-ID: <(.*?)>"); var encodedContentId = HttpUtility.UrlEncode(contentId.Groups[1].Value).Replace(".", @"\."); var unencodedContentId = contentId.Groups[1].Value.Replace(".", @"\."); // var xopIncludeMatch = Regex.Match(unsignedXml, "(<[^>]+?>)(<([^>]+?:)?Include href=\"cid:(" + encodedContentId + ")\"[^>]*?/>)(</[^>]+?>)", RegexOptions.IgnoreCase); var xopIncludeMatch = Regex.Match(unsignedXml, "(<[^>]+?>)(<([^>]+?:)?Include href=\"cid:(" + encodedContentId + "|" + unencodedContentId + ")\"[^>]*?/>)(</[^>]+?>)", RegexOptions.IgnoreCase); signedFinalXml = Regex.Replace(signedFinalXml, xopIncludeMatch.Groups[1] + "[^<]*?" + xopIncludeMatch.Groups[5], xopIncludeMatch.Groups[0].Value); } } else { signedFinalXml = signedBigXml; } // Get difference in message length between unsigned and signed SOAP messages int diff = Encoding.UTF8.GetBytes(signedFinalXml).Length - Encoding.UTF8.GetBytes(unsignedXml).Length; // Create buffer large enough to contain MTOM message with signed SOAP XML byte[] bufferSigned = new byte[bufferUnsigned.Length + diff]; // Copy MIME start content (everything before SOAP XML) from unsigned buffer to signed buffer Array.Copy(bufferUnsigned, bufferSigned, startSoapIndex); // Copy signed SOAP XML into signed buffer after MIME start content var signedXmlArray = Encoding.UTF8.GetBytes(signedFinalXml); Array.Copy(signedXmlArray, 0, bufferSigned, startSoapIndex, signedXmlArray.Length); // Copy MIME end content to after signed SOAP XML Array.Copy(bufferUnsigned, endSoapIndex, bufferSigned, startSoapIndex + signedXmlArray.Length, bufferUnsigned.Length - (endSoapIndex + 1)); var mimeContent = new ArraySegment <byte>(bufferSigned, 0, originalMessageSize + diff).Array; soapMessages.MtomRequest = mimeContent; // Recreate request (Message) using MTOM reader var outputReader = XmlDictionaryReader.CreateMtomReader(mimeContent, 0, mimeContent.Length, Encoding.UTF8, new XmlDictionaryReaderQuotas()); request = Message.CreateMessage(outputReader, int.MaxValue, request.Version); // Dispose things msgBuffer.Close(); return(null); }
public override void Close() { buffer.Close(); }
public object BeforeSendRequest(ref Message request, IClientChannel channel) { if (request == null) { throw new ArgumentNullException("request"); } // Service Runtime'a gececek olan kullanici, ip vs. gibi degerler bir header olarak request'e eklenecek. MessageBuffer buffer = request.CreateBufferedCopy(request.ToString().Length); Message tRequest = buffer.CreateMessage(); ServiceContextInfo contextInfo = null; var containsMessageHeader = false; if (OperationContext.Current != null && OperationContext.Current.IncomingMessageHeaders != null) { int contextHeaderIndex = OperationContext.Current.IncomingMessageHeaders.FindHeader(ServiceBase.ContextDataKey, ServiceBase.ContextDataNamespaceKey); if (contextHeaderIndex >= 0) { //contextInfo = OperationContext.Current.IncomingMessageHeaders.GetHeader<DefaultServiceContextInfo>(contextHeaderIndex); var typeFinder = EngineContext.Current.Resolve <ITypeFinder>(); var contextInfos = typeFinder.FindClassesOfType <ServiceContextInfo>().ToList(); var currentContextInfo = contextInfos.Count() == 1 ? contextInfos[0] : contextInfos.FirstOrDefault( t => !(t == typeof(DefaultServiceContextInfo))); using (XmlDictionaryReader reader = OperationContext.Current.IncomingMessageHeaders.GetReaderAtHeader(contextHeaderIndex)) { MessageHeaderInfo headerInfo = OperationContext.Current.IncomingMessageHeaders[contextHeaderIndex]; var serializer = new DataContractSerializer(currentContextInfo.UnderlyingSystemType, headerInfo.Name, headerInfo.Namespace, null, int.MaxValue, false, false, null); contextInfo = serializer.ReadObject(reader) as ServiceContextInfo; } containsMessageHeader = true; } } if (!containsMessageHeader) { if (_currentContextInfoProviderType == null) { var typeFinder = EngineContext.Current.Resolve <ITypeFinder>(); var contextInfoProviders = typeFinder.FindClassesOfType <ServiceContextInfoProvider>().ToList(); _currentContextInfoProviderType = contextInfoProviders.Count() == 1 ? contextInfoProviders[0] : contextInfoProviders.FirstOrDefault( t => !(t == typeof(DefaultServiceContextInfoProvider))); } if (_currentContextInfoProviderType == null) { _currentContextInfoProviderType = typeof(DefaultServiceContextInfoProvider); } var contextInfoProvider = Activator.CreateInstance(_currentContextInfoProviderType) as ServiceContextInfoProvider; if (contextInfoProvider != null) { contextInfo = contextInfoProvider.GetServiceContextInfo(); } if (contextInfo == null) //default { contextInfo = new DefaultServiceContextInfo(); } contextInfo.ClientIp = "127.0.0.1"; } MessageHeader header = null; // --------------------------------------------------------------------------------------------------------------------------------- header = MessageHeader.CreateHeader(ServiceBase.ContextDataKey, ServiceBase.ContextDataNamespaceKey, contextInfo); tRequest.Headers.Add(header); ClientComputerInfo clientcomputerInfo = null; containsMessageHeader = false; if (OperationContext.Current != null && OperationContext.Current.IncomingMessageHeaders != null) { int contextHeaderIndex = OperationContext.Current.IncomingMessageHeaders.FindHeader(ServiceBase.ClientComputerInfoKey, ServiceBase.ClientComputerInfoNamespaceKey); if (contextHeaderIndex >= 0) { clientcomputerInfo = OperationContext.Current.IncomingMessageHeaders.GetHeader <ClientComputerInfo>(contextHeaderIndex); containsMessageHeader = true; } } if (!containsMessageHeader) { //istek yapilan yerde bu kullanilacak clientcomputerInfo = new ClientComputerInfo() { ClientComputerName = System.Net.Dns.GetHostName(), ClientComputerIpAddress = ServiceBase.GetLocalIPAddress() }; } header = MessageHeader.CreateHeader(ServiceBase.ClientComputerInfoKey, ServiceBase.ClientComputerInfoNamespaceKey, clientcomputerInfo); tRequest.Headers.Add(header); request = tRequest; buffer.Close(); return(null); }