public void IsFileStreamWhenInitialCapacityIsLargerThenDefaultThreshold() { using (VirtualStream stream = VirtualStream.Create(VirtualStream.ThresholdMax + 1)) { Assert.True(stream.UnderlyingStream is FileStream); } }
/// <summary> /// Retrieve the contents of a message into a stream /// </summary> /// <param name="message"></param> /// <param name="bufferSize"></param> /// <param name="thresholdSize"></param> /// <returns></returns> public Stream ProcessRequestReturnStream(XLANGMessage message, int bufferSize, int thresholdSize) { Stream partStream = null; try { using (VirtualStream virtualStream = new VirtualStream(bufferSize, thresholdSize)) { using (partStream = (Stream)message[0].RetrieveAs(typeof(Stream))) //Note that when calling this code, if the XmlDocument is quite large, keeping it in a memory with a MemoryStream may have an adverse effect on performance. //In this case, it may be worthwhile to consider an approach that uses a VirtualStream + ReadonlySeekableStream to buffer it to the file system, //if its size is bigger than the thresholdSize parameter. //Keep in mind that: // - If the message size is smaller than the threshold size, the VirtualStream class buffers the stream to a MemoryStream. // - If the message size is bigger than the threshold size, the VirtualStream class buffers the stream to a temporary file. using (ReadOnlySeekableStream readOnlySeekableStream = new ReadOnlySeekableStream(partStream, virtualStream, bufferSize)) { using (XmlReader reader = XmlReader.Create(readOnlySeekableStream)) { } } } } catch (Exception ex) { throw ex; } finally { message.Dispose(); } return(partStream); }
public void IsFileStreamWhenInitialCapacityIsLargerThenSpecifiedThreshold() { using (VirtualStream stream = VirtualStream.Create(10, 7)) { Assert.True(stream.UnderlyingStream is FileStream); } }
public ListFormatOverrideTable(FileInformationBlock fib, VirtualStream tableStream) { if (fib.lcbPlfLfo > 0) { var reader = new VirtualStreamReader(tableStream); reader.BaseStream.Seek((long)fib.fcPlfLfo, System.IO.SeekOrigin.Begin); //read the count of LFOs int count = reader.ReadInt32(); //read the LFOs for (int i = 0; i < count; i++) { this.Add(new ListFormatOverride(reader, LFO_LENGTH)); } //read the LFOLVLs for (int i = 0; i < count; i++) { for (int j = 0; j < this[i].clfolvl; j++) { this[i].rgLfoLvl[j] = new ListFormatOverrideLevel(reader, LFOLVL_LENGTH); } } } }
/// <summary> /// Implements IComponent.Execute method. /// </summary> /// <param name="pc">Pipeline context</param> /// <param name="inmsg">Input message.</param> /// <returns>Processed input message with appended or prepended data.</returns> /// <remarks> /// Converts xsl-fo transformed messages to pdf /// </remarks> public IBaseMessage Execute(IPipelineContext pc, IBaseMessage inmsg) { IBaseMessagePart bodyPart = inmsg.BodyPart; if (bodyPart.Data != null) { VirtualStream vtstm = new VirtualStream(VirtualStream.MemoryFlag.AutoOverFlowToDisk); FonetDriver driver = FonetDriver.Make(); driver.CloseOnExit = false;//important for biztalk to work ... set position = 0 PdfRendererOptions options = new PdfRendererOptions(); options.Title = Title; options.Subject = Subject; options.UserPassword = Password; driver.Options = options; Stream stm = bodyPart.GetOriginalDataStream(); stm.Seek(0, SeekOrigin.Begin); driver.Render(stm, vtstm); vtstm.Seek(0, SeekOrigin.Begin); bodyPart.Data = vtstm; } return(inmsg); }
public IBaseMessage Execute(IPipelineContext pContext, IBaseMessage pInMsg) { string errorMessage; if (!Validate(out errorMessage)) { throw new ArgumentException(errorMessage); } String value = null; IBaseMessagePart bodyPart = pInMsg.BodyPart; Stream inboundStream = bodyPart.GetOriginalDataStream(); VirtualStream virtualStream = new VirtualStream(VirtualStream.MemoryFlag.AutoOverFlowToDisk); ReadOnlySeekableStream readOnlySeekableStream = new ReadOnlySeekableStream(inboundStream, virtualStream); XmlTextReader xmlTextReader = new XmlTextReader(readOnlySeekableStream); XPathCollection xPathCollection = new XPathCollection(); XPathReader xPathReader = new XPathReader(xmlTextReader, xPathCollection); xPathCollection.Add(XPath); while (xPathReader.ReadUntilMatch()) { if (xPathReader.Match(0)) { if (xPathReader.NodeType == XmlNodeType.Attribute) { value = xPathReader.GetAttribute(xPathReader.Name); } else { value = xPathReader.ReadString(); } if (PromoteProperty) { pInMsg.Context.Promote(new ContextProperty(PropertyPath), value); } else { pInMsg.Context.Write(new ContextProperty(PropertyPath), value); } break; } } if (string.IsNullOrEmpty(value) && ThrowIfNoMatch) { throw new InvalidOperationException("The specified XPath did not exist or contained an empty value."); } readOnlySeekableStream.Position = 0; pContext.ResourceTracker.AddResource(readOnlySeekableStream); bodyPart.Data = readOnlySeekableStream; return(pInMsg); }
/// <summary> /// Returnes a list of all ParagraphPropertyExceptions which correspond to text /// between the given offsets. /// </summary> /// <param name="fcMin">The lower boundary</param> /// <param name="fcMax">The upper boundary</param> /// <param name="fib">The FileInformationBlock</param> /// <param name="wordStream">The VirtualStream "WordStream"</param> /// <param name="tableStream">The VirtualStream "0Table" or "1Table"</param> /// <returns>The FCs</returns> public static List <ParagraphPropertyExceptions> GetParagraphPropertyExceptions( Int32 fcMin, Int32 fcMax, FileInformationBlock fib, VirtualStream wordStream, VirtualStream tableStream, VirtualStream dataStream) { List <ParagraphPropertyExceptions> list = new List <ParagraphPropertyExceptions>(); List <FormattedDiskPagePAPX> fkps = FormattedDiskPagePAPX.GetAllPAPXFKPs(fib, wordStream, tableStream, dataStream); for (int i = 0; i < fkps.Count; i++) { FormattedDiskPagePAPX fkp = fkps[i]; for (int j = 0; j < fkp.grppapx.Length; j++) { if (fkp.rgfc[j] >= fcMin && fkp.rgfc[j] < fcMax) { list.Add(fkp.grppapx[j]); } } } return(list); }
private void BlockField_CreateDataBlock(BlockField field, long baseOffset, ref long offset) { //Create a condensed block if (field.BlockList.Count > 0) { //Prepare ITagBlock block = field.BlockList[0]; int localOffset = (int)(field.BlockAddress - baseOffset); //Create using (VirtualStream vs = new VirtualStream(offset)) using (BinaryWriter writer = new BinaryWriter(vs)) { //Align vs.Align(block.Alignment); //Write foreach (ITagBlock child in field.BlockList) { child.Write(writer); } //Add tagBlockView.Blocks.Add(localOffset, (int)vs.Length, block.BlockName); offset = field.BlockAddress + vs.Length; } } //Create child blocks foreach (ITagBlock block in field.BlockList) { TagBlock_CreateChildBlocks(block, baseOffset, ref offset); } }
private static void AddAttachmentToMultipart(Multipart bodyMultipart, Attachment attachment) { // A stream that is passed to a ContentObject must be seekable. If this is not the case, // we'll have to create a new stream which is seekable and assign it to the Attachment.Content. if (attachment.Content.CanSeek == false) { var tempStream = new VirtualStream(forAsync: true); attachment.Content.CopyTo(tempStream); tempStream.Position = 0; attachment.UpdateContent(tempStream, attachment.ContentType); } try { var attachmentMimePart = new MimePart(attachment.ContentType) { ContentId = attachment.Id, ContentObject = new ContentObject(attachment.Content), ContentDisposition = new ContentDisposition(ContentDisposition.Attachment), ContentTransferEncoding = ContentEncoding.Binary // We need to explicitly set this to binary, // otherwise we can enounter issues with CRLFs & signing. }; bodyMultipart.Add(attachmentMimePart); } catch (ArgumentException ex) { Logger.Error(ex); throw new NotSupportedException($"Attachment {attachment.Id} has a content-type that is not supported ({attachment.ContentType})."); } }
public IBaseMessage Execute(IPipelineContext pContext, IBaseMessage pInMsg) { if (DocumentSpecName == null) { throw new ArgumentException("DocSpec must be specified"); } this.WorkBook = WorkbookFactory.Create(pInMsg.BodyPart.Data, ImportOption.SheetContentOnly); IFormulaEvaluator formulaEvaluator = null; if (this.WorkBook is XSSFWorkbook) { formulaEvaluator = new XSSFFormulaEvaluator(this.WorkBook); } else { formulaEvaluator = new HSSFFormulaEvaluator(this.WorkBook); } this.WorkBookSchema = GetWorkBookSchema(pContext, formulaEvaluator); VirtualStream outSstm = ProcessWorkbook(); pInMsg.BodyPart.Data = outSstm; pInMsg.Context.Promote(new ContextProperty(SystemProperties.MessageType), $"{this.WorkBookSchema.Namespace}#{this.WorkBookSchema.Name}"); pInMsg.Context.Write(new ContextProperty(SystemProperties.SchemaStrongName), DocumentSpecName.SchemaName); pContext.ResourceTracker.AddResource(outSstm); return(pInMsg); }
private void CompressAttachment(Attachment attachment) { PartInfo referenced = _partInfos.FirstOrDefault(attachment.Matches); if (referenced == null) { throw new InvalidOperationException( $"Can't compress attachment {attachment.Id} because no matching PartInfo element was found in UserMessage"); } VirtualStream outputStream = VirtualStream.Create( attachment.EstimatedContentSize > -1 ? attachment.EstimatedContentSize : VirtualStream.ThresholdMax); CompressionLevel compressionLevel = DetermineCompressionLevelFor(attachment); using (var gzipCompression = new GZipStream(outputStream, compressionLevel, leaveOpen: true)) { attachment.Content.CopyTo(gzipCompression); } outputStream.Position = 0; attachment.MimeType = attachment.ContentType; attachment.CompressionType = CompressionType; referenced.CompressionType = CompressionType; attachment.UpdateContent(outputStream, CompressionType); }
private Stream Apply(XslCompiledTransform xsl, XsltArgumentList arguments, Encoding encoding) { var output = new VirtualStream(DEFAULT_BUFFER_SIZE, DEFAULT_THRESHOLD_SIZE); // Clone() to get a modifiable copy of the transform's settings var settings = xsl.OutputSettings.Clone(); settings.CloseOutput = false; settings.Encoding = encoding; using (var writer = XmlWriter.Create(output, settings)) { if (_streams.Length == 1) { if (_streams[0] is CompositeStream compositeStream) { xsl.Transform(compositeStream.Streams, arguments, writer); } else { xsl.Transform(_streams[0], arguments, writer); } } else { xsl.Transform(_streams, arguments, writer); } output.Seek(0, SeekOrigin.Begin); return(output); } }
/// <summary> /// Implements IComponent.Execute method. /// </summary> /// <param name="pc">Pipeline context</param> /// <param name="inmsg">Input message</param> /// <returns>Original input message</returns> /// <remarks> /// IComponent.Execute method is used to initiate /// the processing of the message in this pipeline component. /// </remarks> public Microsoft.BizTalk.Message.Interop.IBaseMessage Execute(Microsoft.BizTalk.Component.Interop.IPipelineContext pc, Microsoft.BizTalk.Message.Interop.IBaseMessage inmsg) { string ActivityID = Guid.NewGuid().ToString(); string ShareLocation = "D:\\Share\\TrackingArchive\\"; // Should be an UNC Path with desired access granted to the User Account string FileExtension = ".txt"; string FullFilePath = ShareLocation + ActivityID + FileExtension; StringBuilder SBContext = new StringBuilder(); ReadOnlySeekableStream stream = new ReadOnlySeekableStream(inmsg.BodyPart.GetOriginalDataStream()); Stream sourceStream = inmsg.BodyPart.GetOriginalDataStream(); if (!sourceStream.CanSeek) { ReadOnlySeekableStream seekableStream = new ReadOnlySeekableStream(sourceStream); inmsg.BodyPart.Data = seekableStream; sourceStream = inmsg.BodyPart.Data; } if (inmsg.BodyPart != null) { VirtualStream virtualStream = new VirtualStream(sourceStream); PipelineHelper.ArchiveToFileLocation(virtualStream, FullFilePath); PipelineHelper.ArchivetoStorage(pc, inmsg, FullFilePath, true); sourceStream.Position = 0; inmsg.BodyPart.Data = sourceStream; inmsg.BodyPart.Data.Position = 0; } return(inmsg); #endregion }
public static void ArchiveToFileLocation(VirtualStream dataStream, string FullFilePath) { try { //string saveTo = "C:\\Projects\\Unicer.Archive\\ArchiveFolder\\teste.xml"; // create a write stream FileStream FileArchiveStream = new FileStream(FullFilePath, FileMode.Create, FileAccess.Write); BinaryWriter FileBinaryWriter = new BinaryWriter(FileArchiveStream); // Read the stream and write to the archive file byte[] Buffer = new byte[256]; int SizeRead; while ((SizeRead = dataStream.Read(Buffer, 0, 256)) != 0) { FileBinaryWriter.Write(Buffer, 0, SizeRead); } // Flush and close the output stream FileBinaryWriter.Flush(); FileBinaryWriter.Close(); } catch (IOException Ex) { //System.Diagnostics.EventLog.WriteEntry(EventData.EVENT_LOG_SOURCE, "An error occured creating the archive file - the file has not been archived.\n\nThe following error was raised: " + Ex.Message, EventLogEntryType.Error); } // dataStream.Seek(0, SeekOrigin.Begin); //(ERROR IS THROW HERE) // return (dataStream); }
public List <char> GetAllChars(VirtualStream wordStream) { List <char> chars = new List <char>(); foreach (PieceDescriptor pcd in this.Pieces) { //get the FC end of this piece Int32 pcdFcEnd = pcd.cpEnd - pcd.cpStart; if (pcd.encoding == Encoding.Unicode) { pcdFcEnd *= 2; } pcdFcEnd += (Int32)pcd.fc; int cb = pcdFcEnd - (Int32)pcd.fc; byte[] bytes = new byte[cb]; //read all bytes wordStream.Read(bytes, 0, cb, (Int32)pcd.fc); //get the chars char[] plainChars = pcd.encoding.GetString(bytes).ToCharArray(); //add to list foreach (char c in plainChars) { chars.Add(c); } } return(chars); }
public void AS4ComponentDoesntAlterEncryptedDataFromOriginalHolodeckMessage() { // Arrange Holodeck.CopyPModeToHolodeckB("8.1.22-pmode.xml"); AS4Component.OverrideSettings(DynamicDiscoverySettings); AS4Component.Start(); InsertSmpConfigurationForAS4Component(ReceiveAgentEndpoint, enableEncryption: false); var str = VirtualStream.Create(); str.Write(Properties.Resources._8_1_22_message, 0, Properties.Resources._8_1_22_message.Length); str.Position = 0; const string contentType = "multipart/related; boundary= \"MIMEBoundary_4ac2a25e8a3af891754f9f7316ac08062c50de1368ddfada\"; type=\"application/soap+xml\";"; // Act new StubSender().SendMessage(str, contentType); // Assert Assert.True( PollingAt(AS4ReceiptsPath), "No Receipt found at AS4.NET Component for Encrypted Dynamic Forwarding Test"); }
/// <summary> /// Create the output message when validation errors are captured /// </summary> /// <param name="pContext">Pipeline context</param> /// <param name="pInMsg">Input message in the pipeline</param> /// <param name="errorStream">Stream for the Validation Errors</param> /// <param name="requestId">Request Id</param> /// <returns></returns> public static IBaseMessage CreateOutPutMessage(IPipelineContext pContext, IBaseMessage pInMsg, VirtualStream errorStream, string requestId) { VirtualStream seekableStream = new VirtualStream(pInMsg.BodyPart.GetOriginalDataStream()); seekableStream.Position = 0; errorStream.Position = 0; VirtualStream outMsgStream = CreateValidationErrorMessage(seekableStream, errorStream, requestId); outMsgStream.Position = 0; IBaseMessageFactory messageFactory = pContext.GetMessageFactory(); IBaseMessage pOutMsg = messageFactory.CreateMessage(); IBaseMessagePart pOutMsgBodyPart = messageFactory.CreateMessagePart(); IBasePropertyBag pOutPb = PipelineUtil.CopyPropertyBag(pInMsg.BodyPart.PartProperties, messageFactory); pOutMsg.Context = PipelineUtil.CloneMessageContext(pInMsg.Context); pOutMsgBodyPart.Charset = Constants.BodyPartCharSet; pOutMsgBodyPart.ContentType = Constants.BodyPartContentType; pOutMsgBodyPart.Data = outMsgStream; string outMessageType = string.Format("{0}#{1}", Constants.AIBPValidationErrorNameSpace, Constants.AIBPValidationErrorRootNode); pOutMsg.Context.Promote(Constants.MessageTypePropName, Constants.SystemPropertiesNamespace, outMessageType); pOutMsg.AddPart("Body", pOutMsgBodyPart, true); // Add resources to the resource tracker to be disposed of at correct time pContext.ResourceTracker.AddResource(seekableStream); pContext.ResourceTracker.AddResource(outMsgStream); pContext.ResourceTracker.AddResource(errorStream); return(pOutMsg); }
/// <summary> /// Create a new <see cref="AS4Response"/> instance. /// </summary> /// <param name="requestMessage"></param> /// <param name="webResponse"></param> /// <returns></returns> public static async Task <AS4Response> Create(MessagingContext requestMessage, HttpWebResponse webResponse) { var response = new AS4Response(requestMessage, webResponse); var responseStream = webResponse.GetResponseStream() ?? Stream.Null; var contentStream = VirtualStream.Create(webResponse.ContentLength, forAsync: true); await responseStream.CopyToFastAsync(contentStream); contentStream.Position = 0; response.ReceivedStream = new ReceivedMessage( contentStream, webResponse.ContentType, webResponse.ResponseUri?.AbsolutePath ?? "unknown", webResponse.ContentLength); response.ReceivedAS4Message = await TryDeserializeReceivedStream(response.ReceivedStream, CancellationToken.None); if (Logger.IsInfoEnabled) { if (response.ReceivedAS4Message.IsEmpty == false) { LogReceivedAS4Response( requestMessage.AS4Message, response.ReceivedAS4Message); } } return(response); }
/// <summary> /// Loads a <see cref="Stream" /> at a given stored <paramref name="location" />. /// </summary> /// <param name="location">The location.</param> /// <returns></returns> public async Task <Stream> LoadMessageBodyAsync(string location) { if (location == null) { throw new ArgumentNullException(nameof(location)); } string fileLocation = SubstringWithoutFileUri(location); if (string.IsNullOrEmpty(fileLocation)) { return(null); } if (File.Exists(fileLocation)) { using (FileStream fileStream = FileUtils.OpenReadAsync(fileLocation, options: FileOptions.SequentialScan)) { VirtualStream virtualStream = VirtualStream.Create( fileStream.CanSeek ? fileStream.Length : VirtualStream.ThresholdMax, forAsync: true); await fileStream.CopyToFastAsync(virtualStream).ConfigureAwait(false); virtualStream.Position = 0; return(virtualStream); } } return(null); }
/// <summary> /// Parses the bytes to retrieve a AuthorTable /// </summary> /// <param name="bytes">The bytes</param> public AuthorTable(FileInformationBlock fib, VirtualStream tableStream) { int pos = 8; byte[] uniChar = new byte[2]; StringBuilder name = new StringBuilder(); while (pos < fib.lcbSttbfRMark) { tableStream.Read(uniChar, 0, 2, (int)(fib.fcSttbfRMark + pos)); char cPos = Encoding.Unicode.GetString(uniChar).ToCharArray()[0]; if ((int)cPos > 0x1F) { name.Append(cPos); } else { //there is a seperator that terminates this name this.Add(name.ToString()); name = new StringBuilder(); } pos += 2; } //add last name this.Add(name.ToString()); }
private static Stream Transform(XmlReader reader, Type map, System.Xml.Xsl.XsltArgumentList arguments) { if (_logger.IsDebugEnabled) { _logger.DebugFormat("About to execute transform '{0}'.", map.AssemblyQualifiedName); } var transformDescriptor = XsltCache.Instance[map]; using (reader) { var outputStream = new VirtualStream(DEFAULT_BUFFER_SIZE, DEFAULT_THRESHOLD_SIZE); var writerSettings = transformDescriptor.XslCompiledTransform.OutputSettings.Override( s => { s.CloseOutput = false; s.Encoding = Encoding.UTF8; }); using (var writer = XmlWriter.Create(outputStream, writerSettings)) { if (_logger.IsDebugEnabled) { _logger.DebugFormat("Executing transform '{0}'.", map.AssemblyQualifiedName); } var xsltArguments = transformDescriptor.Arguments.Union(arguments); transformDescriptor.XslCompiledTransform.Transform(reader, xsltArguments, writer); } outputStream.Seek(0, SeekOrigin.Begin); return(outputStream); } }
/// <summary> /// Parses an StwUser structure into a dictionary of key-value-pairs /// </summary> /// <param name="tableStream">The input table stream</param> /// <param name="fcStwUser">fcStwUser (4 bytes): An unsigned integer that specifies an offset into the Table Stream. /// An StwUser that specifies the user-defined variables and VBA digital signature (2), as specified by /// [MS-OSHARED] section 2.3.2, begins at this offset. /// /// If lcbStwUser is zero, fcStwUser is undefined and MUST be ignored.</param> /// <param name="lcbStwUser">lcbStwUser (4 bytes): An unsigned integer that specifies the size, in bytes, /// of the StwUser at offset fcStwUser</param> public StwUser(VirtualStream tableStream, UInt32 fcStwUser, UInt32 lcbStwUser) { if (lcbStwUser == 0) { return; } tableStream.Seek(fcStwUser, System.IO.SeekOrigin.Begin); // parse the names var names = new StringTable(typeof(string), tableStream, fcStwUser, lcbStwUser); // parse the values var values = new List <string>(); while (tableStream.Position < fcStwUser + lcbStwUser) { values.Add(Utils.ReadXst(tableStream)); } // map to the dictionary if (names.Strings.Count == values.Count) { for (int i = 0; i < names.Strings.Count; i++) { this.Add(names.Strings[i], values[i]); } } }
public ListTable(FileInformationBlock fib, VirtualStream tableStream) { if (fib.lcbPlfLst > 0) { var reader = new VirtualStreamReader(tableStream); reader.BaseStream.Seek(fib.fcPlfLst, System.IO.SeekOrigin.Begin); //the ListTable is not a real plex: //it starts with a count, followed by the array of LSTF structs, //followed by the array of LVLF structs //read count short count = reader.ReadInt16(); //read the LSTF structs for (int i = 0; i < count; i++) { this.Add(new ListData(reader, ByteStructure.VARIABLE_LENGTH)); } //read the LVLF structs for (int i = 0; i < count; i++) { var lstf = this[i]; for (int j = 0; j < lstf.rglvl.Length; j++) { lstf.rglvl[j] = new ListLevel(reader, ByteStructure.VARIABLE_LENGTH); } } } }
private static async Task <ReceivedMessage> WrapRequestInSeekableMessageAsync(HttpListenerRequest request, long contentLength) { Logger.Trace("Start copying to VirtualStream"); var dest = new VirtualStream( request.ContentLength64 > VirtualStream.ThresholdMax ? VirtualStream.MemoryFlag.OnlyToDisk : VirtualStream.MemoryFlag.AutoOverFlowToDisk, forAsync: true); if (contentLength > 0) { dest.SetLength(contentLength); } await request.InputStream .CopyToFastAsync(dest) .ConfigureAwait(false); dest.Position = 0; return(new ReceivedMessage( underlyingStream: dest, contentType: request.ContentType, origin: request.UserHostAddress, length: request.ContentLength64)); }
/// <summary> /// Checks seekability of the data stream in the body part of specified message and returns a new <see cref="Microsoft.BizTalk.Streaming.ReadOnlySeekableStream"/> /// stream should the original stream fail to support the Seek operation. /// </summary> /// <param name="msg">The message instance represented by the <see cref="Microsoft.BizTalk.Message.Interop.IBaseMessage"/> object.</param> /// <param name="pContext">A reference to <see cref="Microsoft.BizTalk.Component.Interop.IPipelineContext"/> object that contains the current pipeline context.</param> /// <returns>Either the original data stream or a new stream wrapping the original stream and providing support for the Seek operation, or a null reference if the specified message doesn't contain a body part.</returns> public static Stream EnsureSeekableStream(IBaseMessage msg, IPipelineContext pContext) { if (msg != null && msg.BodyPart != null) { Stream messageDataStream = msg.BodyPart.GetOriginalDataStream(); if (!messageDataStream.CanSeek) { Stream virtualStream = new VirtualStream(VirtualStreamBufferSize, VirtualStreamThresholdSize); pContext.ResourceTracker.AddResource(virtualStream); Stream seekableStream = new ReadOnlySeekableStream(messageDataStream, virtualStream, VirtualStreamBufferSize); msg.BodyPart.Data = seekableStream; return(seekableStream); } else { return(messageDataStream); } } else { return(null); } }
/// <summary> /// Returns a list of all PAPX FCs between they given boundaries. /// </summary> /// <param name="fcMin">The lower boundary</param> /// <param name="fcMax">The upper boundary</param> /// <param name="fib">The FileInformationBlock</param> /// <param name="wordStream">The VirtualStream "WordStream"</param> /// <param name="tableStream">The VirtualStream "0Table" or "1Table"</param> /// <returns>The FCs</returns> public static List <Int32> GetFileCharacterPositions( Int32 fcMin, Int32 fcMax, FileInformationBlock fib, VirtualStream wordStream, VirtualStream tableStream, VirtualStream dataStream) { List <Int32> list = new List <Int32>(); List <FormattedDiskPagePAPX> fkps = FormattedDiskPagePAPX.GetAllPAPXFKPs(fib, wordStream, tableStream, dataStream); for (int i = 0; i < fkps.Count; i++) { FormattedDiskPage fkp = fkps[i]; //the last entry of each is always the same as the first entry of the next FKP //so, ignore all last _entries except for the last FKP. int max = fkp.rgfc.Length; if (i < fkps.Count - 1) { max--; } for (int j = 0; j < max; j++) { if (fkp.rgfc[j] >= fcMin && fkp.rgfc[j] < fcMax) { list.Add(fkp.rgfc[j]); } } } return(list); }
/// <summary> /// Removes the byte order mask. /// </summary> /// <param name="inStream">Input stream.</param> /// <returns>New stream without the byte order mask.</returns> public static Stream RemoveByteOrderMark(Stream inStream) { if (inStream == null) { throw new ArgumentNullException("inStream"); } int num = MatchByteOrderMarkSequence(inStream); if (num <= 0) { return(inStream); } VirtualStream virtualStream = new VirtualStream((int)inStream.Length); byte[] buffer = new byte[BUFFER_SIZE]; inStream.Position = (long)num; int count; while ((count = inStream.Read(buffer, 0, BUFFER_SIZE)) > 0) { virtualStream.Write(buffer, 0, count); } virtualStream.Flush(); virtualStream.Position = 0L; return(virtualStream); }
private Stream Apply(XslCompiledTransform xsl, XsltArgumentList arguments, Encoding encoding) { var output = new VirtualStream(DEFAULT_BUFFER_SIZE, DEFAULT_THRESHOLD_SIZE); // Clone() to have a modifiable copy of the transform's settings var settings = xsl.OutputSettings.Clone(); settings.CloseOutput = false; settings.Encoding = encoding; using (var writer = XmlWriter.Create(output, settings)) { if (_streams.Length == 1) { // TODO ?? *always* skip CompositeStream.Read() and wraps CompositeStream.Streams in a CompositeXmlReader instead ?? //var compositeStream = _streams[0] as CompositeStream; //if (compositeStream != null) // xsl.Transform(compositeStream.Streams, arguments, writer); //else xsl.Transform(_streams[0], arguments, writer); } else { xsl.Transform(_streams, arguments, writer); } output.Seek(0, SeekOrigin.Begin); return(output); } }
private int TagGroup_CalculateChecksum(ITagGroup tagGroup) { int checksum = 0; using (VirtualStream tagStream = new VirtualStream(TagGroupHeader.Size)) using (BinaryWriter writer = new BinaryWriter(tagStream)) { tagGroup.Write(writer); tagStream.Align(4); if (tagStream.Length == 0) { return(0); } byte[] tagGroupBuffer = tagStream.ToArray(); checksum = BitConverter.ToInt32(tagGroupBuffer, 0); for (int i = 1; i < tagGroupBuffer.Length / 4; i++) { checksum ^= BitConverter.ToInt32(tagGroupBuffer, i * 4); } } return(checksum); }
/// <summary> /// Transform to a <see cref="MessagingContext" /> /// with a <see cref="AS4Message" /> included /// </summary> /// <param name="message"></param> /// <returns></returns> public async Task <MessagingContext> TransformAsync(ReceivedMessage message) { if (message == null) { throw new ArgumentNullException(nameof(message)); } if (message.UnderlyingStream == null) { throw new InvalidDataException( $"The incoming stream from {message.Origin} is not an ebMS Message"); } if (!ContentTypeSupporter.IsContentTypeSupported(message.ContentType)) { throw new InvalidDataException( $"ContentType {nameof(message.ContentType)} is not supported"); } VirtualStream messageStream = await CopyIncomingStreamToVirtualStream(message); AS4Message as4Message = await DeserializeMessage(message.ContentType, messageStream, CancellationToken.None); return(new MessagingContext(as4Message, message, MessagingContextMode.Unknown)); }
public Microsoft.BizTalk.Message.Interop.IBaseMessage Execute(IPipelineContext pContext, Microsoft.BizTalk.Message.Interop.IBaseMessage pInMsg) { IBaseMessagePart bodyPart = pInMsg.BodyPart; Stream inboundStream = bodyPart.GetOriginalDataStream(); VirtualStream virtualStream = new VirtualStream(0x280, 0x100000); ReadOnlySeekableStream readOnlySeekableStream = new ReadOnlySeekableStream(inboundStream, virtualStream, 0x280); string tempFile = Path.GetTempFileName(); using (FileStream fs = new FileStream(tempFile, FileMode.Open, FileAccess.Write, FileShare.Read)) { byte[] buffer = new byte[0x280]; int bytesRead = readOnlySeekableStream.Read(buffer, 0, buffer.Length); while (bytesRead != 0) { fs.Write(buffer, 0, bytesRead); fs.Flush(); bytesRead = readOnlySeekableStream.Read(buffer, 0, buffer.Length); } } VirtualStream outputStream = new VirtualStream(); using (XmlWriter xw = XmlWriter.Create(outputStream)) { const string NameSpace = "http://Codit.LFT.Schemas"; xw.WriteStartDocument(); xw.WriteStartElement("ns0", "LFT", NameSpace); xw.WriteElementString("TempFile", tempFile); xw.WriteEndDocument(); } outputStream.Position = 0; pContext.ResourceTracker.AddResource(outputStream); pInMsg.BodyPart.Data = outputStream; return pInMsg; }
private ReadOnlySeekableStream GetSeekableStream(IBaseMessage msg) { Stream inboundStream = msg.BodyPart.GetOriginalDataStream(); VirtualStream virtualStream = new VirtualStream(VirtualStream.MemoryFlag.AutoOverFlowToDisk); ReadOnlySeekableStream readOnlySeekableStream = new ReadOnlySeekableStream(inboundStream, virtualStream); readOnlySeekableStream.Position = 0; readOnlySeekableStream.Seek(0, SeekOrigin.Begin); return readOnlySeekableStream; }
public IBaseMessage Execute(IPipelineContext pContext, IBaseMessage pInMsg) { string errorMessage; if (!Validate(out errorMessage)) { throw new ArgumentException(errorMessage); } String value = null; IBaseMessagePart bodyPart = pInMsg.BodyPart; Stream inboundStream = bodyPart.GetOriginalDataStream(); VirtualStream virtualStream = new VirtualStream(VirtualStream.MemoryFlag.AutoOverFlowToDisk); ReadOnlySeekableStream readOnlySeekableStream = new ReadOnlySeekableStream(inboundStream, virtualStream); XmlTextReader xmlTextReader = new XmlTextReader(readOnlySeekableStream); XPathCollection xPathCollection = new XPathCollection(); XPathReader xPathReader = new XPathReader(xmlTextReader, xPathCollection); xPathCollection.Add(XPath); while (xPathReader.ReadUntilMatch()) { if (xPathReader.Match(0)) { value = xPathReader.ReadString(); if (PromoteProperty) { pInMsg.Context.Promote(new ContextProperty(PropertyPath), value); } else { pInMsg.Context.Write(new ContextProperty(PropertyPath), value); } break; } } if (string.IsNullOrEmpty(value) && ThrowIfNoMatch) { throw new InvalidOperationException("The specified XPath did not exist or contained an empty value."); } readOnlySeekableStream.Position = 0; pContext.ResourceTracker.AddResource(readOnlySeekableStream); bodyPart.Data = readOnlySeekableStream; return pInMsg; }
public void Disassemble(IPipelineContext pContext, IBaseMessage pInMsg) { string errorMessage; if (!Validate(out errorMessage)) { throw new ArgumentException(errorMessage); } //Get a reference to the BizTalk schema. var documentSpec = pContext.GetDocumentSpecByName(DocumentSpecName); //Get a list of properties defined in the schema. var annotations = documentSpec.GetPropertyAnnotationEnumerator(); var doc = new XmlDocument(); using (var sw = new StringWriter(new StringBuilder())) { //Create a new instance of the schema. doc.Load(((IFFDocumentSpec)documentSpec).CreateXmlInstance(sw)); } //Write all properties to the message body. while (annotations.MoveNext()) { var annotation = (IPropertyAnnotation)annotations.Current; var node = doc.SelectSingleNode(annotation.XPath); object propertyValue; if (pInMsg.Context.TryRead(new ContextProperty(annotation.Name, annotation.Namespace), out propertyValue)) { node.InnerText = propertyValue.ToString(); } } var data = new VirtualStream(); pContext.ResourceTracker.AddResource(data); doc.Save(data); data.Seek(0, SeekOrigin.Begin); var outMsg = pInMsg; outMsg.BodyPart.Data = data; //Promote message type and SchemaStrongName outMsg.Context.Promote(new ContextProperty(SystemProperties.MessageType), documentSpec.DocType); outMsg.Context.Promote(new ContextProperty(SystemProperties.SchemaStrongName), documentSpec.DocSpecStrongName); _outputQueue.Enqueue(outMsg); }
public Microsoft.BizTalk.Message.Interop.IBaseMessage Execute(IPipelineContext pContext, Microsoft.BizTalk.Message.Interop.IBaseMessage pInMsg) { IBaseMessagePart bodyPart = pInMsg.BodyPart; Stream inboundStream = bodyPart.GetOriginalDataStream(); VirtualStream virtualStream = new VirtualStream(0x280, 0x100000); ReadOnlySeekableStream readOnlySeekableStream = new ReadOnlySeekableStream(inboundStream, virtualStream, 0x280); XmlTextReader xmlTextReader = new XmlTextReader(readOnlySeekableStream); XPathCollection xPathCollection = new XPathCollection(); xPathCollection.Add("/*[local-name()='LFT' and namespace-uri()='http://Codit.LFT.Schemas']/*[local-name()='TempFile' and namespace-uri()='']"); XPathReader xPathReader = new XPathReader(xmlTextReader, xPathCollection); bool ok = false; string val = string.Empty; while (xPathReader.ReadUntilMatch()) { if (xPathReader.Match(0) && !ok) { val = xPathReader.ReadString(); ok = true; } } if (ok) { VirtualStream outboundStream = new VirtualStream(0x280, 0xA00000); using (FileStream fs = new FileStream(val, FileMode.Open, FileAccess.Read, FileShare.Read)) { byte[] buffer = new byte[4096]; int bytesRead = fs.Read(buffer, 0, buffer.Length); while (bytesRead != 0) { outboundStream.Write(buffer, 0, bytesRead); outboundStream.Flush(); bytesRead = fs.Read(buffer, 0, buffer.Length); } } outboundStream.Position = 0; bodyPart.Data = outboundStream; } return pInMsg; }
private static Stream MessageWriter( Action<XmlWriter, XmlReader, string, string, NamespaceFormEnum, string> writeElement, Stream stream, Encoding encoding, string nsToModify = null, string newNamespace = null, NamespaceFormEnum namespaceForm = NamespaceFormEnum.Unqualified, string xPath = "") { var outStream = new VirtualStream(); using (var reader = XmlReader.Create(stream)) { using (var writer = XmlWriter.Create(outStream, new XmlWriterSettings {Encoding = encoding})) { while (reader.Read()) { switch (reader.NodeType) { case XmlNodeType.CDATA: writer.WriteCData(reader.Value); break; case XmlNodeType.Comment: writer.WriteComment(reader.Value); break; case XmlNodeType.DocumentType: writer.WriteDocType(reader.Name, reader.GetAttribute("PUBLIC"), reader.GetAttribute("SYSTEM"), reader.Value); break; case XmlNodeType.Element: var isEmpty = reader.IsEmptyElement; // Will call the injected action depending if it's add, modify or remove writeElement(writer, reader, nsToModify, newNamespace, namespaceForm, xPath); while (reader.MoveToNextAttribute()) { // Copy all attributed that aren't namespaces if (reader.Value != nsToModify && reader.NamespaceURI != "http://www.w3.org/2000/xmlns/") writer.WriteAttributeString(reader.Prefix, reader.LocalName, reader.NamespaceURI, reader.Value); } if (isEmpty) writer.WriteEndElement(); break; case XmlNodeType.EndElement: writer.WriteFullEndElement(); break; case XmlNodeType.EntityReference: writer.WriteEntityRef(reader.Name); break; case XmlNodeType.XmlDeclaration: case XmlNodeType.ProcessingInstruction: writer.WriteProcessingInstruction(reader.Name, reader.Value); break; case XmlNodeType.Text: writer.WriteString(reader.Value); break; case XmlNodeType.SignificantWhitespace: case XmlNodeType.Whitespace: writer.WriteWhitespace(reader.Value); break; } } } } stream.Seek(0, SeekOrigin.Begin); outStream.Seek(0, SeekOrigin.Begin); return outStream; }
private static Stream GetSeekeableMessageStream(IBaseMessage message) { var messageStream = message.BodyPart.GetOriginalDataStream(); if (messageStream.CanSeek) return messageStream; // Create a virtual and seekable stream const int bufferSize = 0x280; const int thresholdSize = 0x100000; Stream virtualReadStream = new VirtualStream(bufferSize, thresholdSize); Stream seekableReadStream = new ReadOnlySeekableStream(messageStream, virtualReadStream, bufferSize); messageStream = seekableReadStream; message.BodyPart.Data = messageStream; return messageStream; }
private static void writeMessage(Microsoft.BizTalk.Message.Interop.IBaseMessage inmsg, XmlDocument xmlDoc) { var outputStream = new VirtualStream(); using (var writer = XmlWriter.Create(outputStream, new XmlWriterSettings() { CloseOutput = false, Encoding = Encoding.UTF8 })) { xmlDoc.WriteTo(writer); writer.Flush(); } outputStream.Seek(0, SeekOrigin.Begin); inmsg.BodyPart.Charset = Encoding.UTF8.WebName; inmsg.BodyPart.Data = outputStream; }
/// <summary> /// Implements IComponent.Execute method. /// </summary> /// <param name="pc">Pipeline context</param> /// <param name="inmsg">Input message</param> /// <returns>Original input message</returns> /// <remarks> /// IComponent.Execute method is used to initiate /// the processing of the message in this pipeline component. /// </remarks> public Microsoft.BizTalk.Message.Interop.IBaseMessage Execute(Microsoft.BizTalk.Component.Interop.IPipelineContext pc, Microsoft.BizTalk.Message.Interop.IBaseMessage inmsg) { #region Handle CORS Requests // Detect of the incoming message is an HTTP CORS request // http://www.w3.org/TR/cors/ object httpMethod = null; httpMethod = inmsg.Context.Read(HTTP_METHOD_PROPNAME, WCF_PROPERTIES_NS); if (httpMethod != null && (httpMethod as string) == OPTIONS_METHOD) { // Remove the message body before returning var emptyOutputStream = new VirtualStream(); inmsg.BodyPart.Data = emptyOutputStream; return inmsg; } #endregion // Make message seekable if (!inmsg.BodyPart.Data.CanSeek) { var originalStream = inmsg.BodyPart.Data; Stream seekableStream = new ReadOnlySeekableStream(originalStream); inmsg.BodyPart.Data = seekableStream; pc.ResourceTracker.AddResource(originalStream); } // Here again we are loading the entire document into memory // this is still a bad plan, and shouldn't be done in production // if you expect larger message sizes XmlDocument xmlDoc = new XmlDocument(); xmlDoc.Load(inmsg.BodyPart.Data); if (xmlDoc.FirstChild.LocalName == "xml") xmlDoc.RemoveChild(xmlDoc.FirstChild); // Remove any root-level attributes added in the process of creating the XML // (Think xmlns attributes that have no meaning in JSON) xmlDoc.DocumentElement.Attributes.RemoveAll(); string jsonString = JsonConvert.SerializeXmlNode(xmlDoc, Newtonsoft.Json.Formatting.Indented, true); #region Handle JSONP Request // Here we are detecting if there has been any value promoted to the jsonp callback property // which will contain the name of the function that should be passed the JSON data returned // by the service. object jsonpCallback = inmsg.Context.Read(JSONP_CALLBACK_PROPNAME, JSON_SCHEMAS_NS); string jsonpCallbackName = (jsonpCallback ?? (object)string.Empty) as string; if (!string.IsNullOrWhiteSpace(jsonpCallbackName)) jsonString = string.Format("{0}({1});", jsonpCallbackName, jsonString); #endregion var outputStream = new VirtualStream(new MemoryStream(Encoding.UTF8.GetBytes(jsonString))); inmsg.BodyPart.Data = outputStream; return inmsg; }
/// <summary> /// Implements IComponent.Execute method. /// </summary> /// <param name="pc">Pipeline context</param> /// <param name="inmsg">Input message</param> /// <returns>Original input message</returns> /// <remarks> /// IComponent.Execute method is used to initiate /// the processing of the message in this pipeline component. /// </remarks> public Microsoft.BizTalk.Message.Interop.IBaseMessage Execute(Microsoft.BizTalk.Component.Interop.IPipelineContext pc, Microsoft.BizTalk.Message.Interop.IBaseMessage inmsg) { Stream dataStream = new VirtualStream(VirtualStream.MemoryFlag.AutoOverFlowToDisk); pc.ResourceTracker.AddResource(dataStream); using (XmlWriter writer = XmlWriter.Create(dataStream)) { // Start creating the message body writer.WriteStartDocument(); writer.WriteStartElement("ns0", ROOT_NODE_NAME, TARGET_NAMESPACE); for (int i = 0; i < inmsg.Context.CountProperties; i++) { // Read in current property information string propName = null; string propNamespace = null; object propValue = inmsg.Context.ReadAt(i, out propName, out propNamespace); // Skip properties that we don't care about due to configuration (default is to allow all properties) if (ExcludeSystemProperties && propNamespace == SYSTEM_NAMESPACE) continue; if (!String.IsNullOrWhiteSpace(CustomPropertyNamespace) && propNamespace != CustomPropertyNamespace) continue; // Create Property element writer.WriteStartElement(PROPERTY_NODE_NAME); // Create attributes on Property element writer.WriteStartAttribute(NAMESPACE_ATTRIBUTE); writer.WriteString(propNamespace); writer.WriteEndAttribute(); writer.WriteStartAttribute(NAME_ATTRIBUTE); writer.WriteString(propName); writer.WriteEndAttribute(); // Write value inside property element writer.WriteString(Convert.ToString(propValue)); writer.WriteEndElement(); } // Finish out the message writer.WriteEndElement(); writer.WriteEndDocument(); writer.Flush(); } dataStream.Seek(0, SeekOrigin.Begin); var outmsg = Utility.CloneMessage(inmsg, pc); outmsg.BodyPart.Data = dataStream; return outmsg; }