/// <summary> /// Serializes service result to a X-Road message response. /// </summary> protected virtual void SerializeXRoadResponse(XRoadContext context) { OnBeforeSerialization(context); context.Request.ContentStream.Position = 0; using (var reader = XmlReader.Create(context.Request.ContentStream, new XmlReaderSettings { CloseInput = false })) { var writer = new XmlTextWriter(context.Response.ContentStream, context.Response.ContentEncoding); writer.WriteStartDocument(); var protocolDefinition = context.Response.ServiceManager?.ProtocolDefinition; if (context.MessageFormatter.TryMoveToEnvelope(reader)) { context.MessageFormatter.WriteStartEnvelope(writer, reader.Prefix); writer.WriteAttributes(reader, true); writer.WriteMissingAttributes(protocolDefinition); } else { writer.WriteSoapEnvelope(context.MessageFormatter, protocolDefinition); } if (context.MessageFormatter.TryMoveToHeader(reader)) { writer.WriteNode(reader, true); } context.MessageFormatter.WriteStartBody(writer); if (context.MessageFormatter.TryMoveToBody(reader)) { writer.WriteAttributes(reader, true); } context.ServiceMap.SerializeResponse(writer, context.Result, context.Response, reader, CustomSerialization); writer.WriteEndDocument(); writer.Flush(); } context.Response.SaveTo(context.HttpContext, context.MessageFormatter); OnAfterSerialization(context); }
// Writes the content (inner XML) of the current node into the provided XmlTextWriter. private async Task WriteNodeAsync(XmlTextWriter xtw, bool defattr) { int d = NodeType == XmlNodeType.None ? -1 : Depth; while (await ReadAsync().ConfigureAwait(false) && d < Depth) { switch (NodeType) { case XmlNodeType.Element: xtw.WriteStartElement(Prefix, LocalName, NamespaceURI); xtw.QuoteChar = QuoteChar; xtw.WriteAttributes(this, defattr); if (IsEmptyElement) { xtw.WriteEndElement(); } break; case XmlNodeType.Text: xtw.WriteString(await GetValueAsync().ConfigureAwait(false)); break; case XmlNodeType.Whitespace: case XmlNodeType.SignificantWhitespace: xtw.WriteWhitespace(await GetValueAsync().ConfigureAwait(false)); break; case XmlNodeType.CDATA: xtw.WriteCData(Value); break; case XmlNodeType.EntityReference: xtw.WriteEntityRef(Name); break; case XmlNodeType.XmlDeclaration: case XmlNodeType.ProcessingInstruction: xtw.WriteProcessingInstruction(Name, Value); break; case XmlNodeType.DocumentType: xtw.WriteDocType(Name, GetAttribute("PUBLIC"), GetAttribute("SYSTEM"), Value); break; case XmlNodeType.Comment: xtw.WriteComment(Value); break; case XmlNodeType.EndElement: xtw.WriteFullEndElement(); break; } } if (d == Depth && NodeType == XmlNodeType.EndElement) { await ReadAsync().ConfigureAwait(false); } }
private void WriteNode(XmlTextWriter xtw, bool defattr) { int d = this.NodeType == XmlNodeType.None ? -1 : this.Depth; while (this.Read() && (d < this.Depth)) { switch (this.NodeType) { case XmlNodeType.Element: xtw.WriteStartElement(this.Prefix, this.LocalName, this.NamespaceURI); xtw.QuoteChar = this.QuoteChar; xtw.WriteAttributes(this, defattr); if (this.IsEmptyElement) { xtw.WriteEndElement(); } break; case XmlNodeType.Text: xtw.WriteString(this.Value); break; case XmlNodeType.Whitespace: case XmlNodeType.SignificantWhitespace: xtw.WriteWhitespace(this.Value); break; case XmlNodeType.CDATA: xtw.WriteCData(this.Value); break; case XmlNodeType.EntityReference: xtw.WriteEntityRef(this.Name); break; case XmlNodeType.XmlDeclaration: case XmlNodeType.ProcessingInstruction: xtw.WriteProcessingInstruction(this.Name, this.Value); break; case XmlNodeType.DocumentType: xtw.WriteDocType(this.Name, this.GetAttribute("PUBLIC"), this.GetAttribute("SYSTEM"), this.Value); break; case XmlNodeType.Comment: xtw.WriteComment(this.Value); break; case XmlNodeType.EndElement: xtw.WriteFullEndElement(); break; } } if (d == this.Depth && this.NodeType == XmlNodeType.EndElement) { Read(); } }
/// <summary> /// Serializes service result to a X-Road message response. /// </summary> protected virtual void SerializeXRoadResponse(XRoadContextClassic context) { OnBeforeSerialization(context); context.Request.ContentStream.Position = 0; using (var reader = XmlReader.Create(context.Request.ContentStream, new XmlReaderSettings { CloseInput = false })) { var writer = new XmlTextWriter(context.Response.ContentStream, context.Response.ContentEncoding); writer.WriteStartDocument(); if (reader.MoveToElement(0) && reader.IsCurrentElement(0, "Envelope", NamespaceConstants.SOAP_ENV)) { writer.WriteStartElement(reader.Prefix, "Envelope", NamespaceConstants.SOAP_ENV); writer.WriteAttributes(reader, true); } else { writer.WriteStartElement(PrefixConstants.SOAP_ENV, "Envelope", NamespaceConstants.SOAP_ENV); writer.WriteAttributeString("xmlns", PrefixConstants.SOAP_ENV, NamespaceConstants.XMLNS, NamespaceConstants.SOAP_ENV); } if (reader.MoveToElement(1) && reader.IsCurrentElement(1, "Header", NamespaceConstants.SOAP_ENV)) { writer.WriteNode(reader, true); } writer.WriteStartElement("Body", NamespaceConstants.SOAP_ENV); if (reader.IsCurrentElement(1, "Body", NamespaceConstants.SOAP_ENV) || reader.MoveToElement(1, "Body", NamespaceConstants.SOAP_ENV)) { writer.WriteAttributes(reader, true); } context.ServiceMap.SerializeResponse(writer, context.Result, context.Response, reader, CustomSerialization); writer.WriteEndDocument(); writer.Flush(); } context.Response.SaveTo(context.HttpContext); OnAfterSerialization(context); }
static void Main(string[] args) { XmlTextReader Reader = new XmlTextReader(@"..\..\..\Data\Users.xml"); XmlTextWriter Writer = new XmlTextWriter(@"..\..\..\Data\Users2.xml", null); Writer.Formatting = Formatting.Indented; while (Reader.Read()) { if ((Reader.NodeType == XmlNodeType.Element) && (Reader.Name == "User")) { Writer.WriteStartElement(Reader.Name); Reader.MoveToNextAttribute(); Writer.WriteAttributeString("ID", "User" + Reader.Value); Reader.MoveToNextAttribute(); Writer.WriteAttributeString("UserName", Reader.Value); } else { switch (Reader.NodeType) { case XmlNodeType.Element: Writer.WriteStartElement(Reader.Name); Writer.WriteAttributes(Reader, false); break; case XmlNodeType.CDATA: Writer.WriteCData(Reader.Value); break; case XmlNodeType.EndElement: Writer.WriteEndElement(); break; case XmlNodeType.EntityReference: Writer.WriteEntityRef(Reader.Name); break; case XmlNodeType.ProcessingInstruction: Writer.WriteProcessingInstruction(Reader.Name, Reader.Value); break; case XmlNodeType.Text: case XmlNodeType.SignificantWhitespace: Writer.WriteString(Reader.Value); break; default: break; } } } Reader.Close(); Writer.Close(); }
/// <summary> /// Copy a node from the current XmlTextReader object to the given XmlTextWriter object. /// </summary> /// <param name="xw">the XmlTextWriter object to write to</param> public void CopyNode(XmlTextWriter xw) { switch (NodeType) { case XmlNodeType.Element: xw.WriteStartElement(Name); xw.WriteAttributes(this, true); if (IsEmptyElement) { xw.WriteEndElement(); } break; case XmlNodeType.EndElement: xw.WriteEndElement(); break; case XmlNodeType.Text: xw.WriteString(Value); break; case XmlNodeType.SignificantWhitespace: xw.WriteWhitespace(Value); break; case XmlNodeType.Whitespace: // You could insert xw.WriteWhitespace(Value); to preserve // insignificant white space, but it either adds bloat or // messes up formatting. break; case XmlNodeType.Attribute: xw.WriteAttributeString(Name, Value); break; case XmlNodeType.ProcessingInstruction: xw.WriteProcessingInstruction(Name, Value); break; case XmlNodeType.XmlDeclaration: xw.WriteStartDocument(true); break; default: Logit.WriteLine("Doing NOTHING with type=" + NodeType.ToString() + " Name=" + Name + " Value=" + Value); // DEBUG break; } }
public void WriteAttributes() { string xml = "<root><test a='b' c='d' /><b /></root>"; XmlTextReader xtr = new XmlTextReader(xml, XmlNodeType.Document, null); xtw.QuoteChar = '\''; xtr.Read(); xtw.WriteStartElement("root"); // <root xtr.Read(); xtw.WriteStartElement("test"); // ><test xtw.WriteAttributes(xtr, false); // a='b' c='d' Assert.AreEqual(XmlNodeType.Element, xtr.NodeType); xtw.WriteEndElement(); // /> xtw.WriteStartElement("b"); // <b xtw.WriteEndElement(); // /> xtw.WriteEndElement(); // </root> xtw.Close(); Assert.AreEqual(xml, writer.ToString()); }
public void WriteAttributes() { XmlDocument doc = new XmlDocument(); StringWriter sw = new StringWriter(); XmlWriter wr = new XmlTextWriter(sw); StringBuilder sb = sw.GetStringBuilder(); XmlParserContext ctx = new XmlParserContext(doc.NameTable, new XmlNamespaceManager(doc.NameTable), "", XmlSpace.Default); XmlTextReader xtr = new XmlTextReader("<?xml version='1.0' encoding='utf-8' standalone='no'?><root a1='A' b2='B' c3='C'><foo><bar /></foo></root>", XmlNodeType.Document, ctx); xtr.Read(); // read XMLDecl wr.WriteAttributes(xtr, false); // This method don't always have to take this double-quoted style... Assert.AreEqual("version=\"1.0\" encoding=\"utf-8\" standalone=\"no\"", sw.ToString().Trim(), "#WriteAttributes.XmlDecl.1"); sb.Remove(0, sb.Length); // init ctx = new XmlParserContext(doc.NameTable, new XmlNamespaceManager(doc.NameTable), "", XmlSpace.Default); xtr = new XmlTextReader("<?xml version='1.0' standalone='no'?><root a1='A' b2='B' c3='C'><foo><bar /></foo></root>", XmlNodeType.Document, ctx); xtr.Read(); // read XMLDecl Assert.AreEqual(XmlNodeType.XmlDeclaration, xtr.NodeType); sw = new StringWriter(); wr = new XmlTextWriter(sw); // This block raises an error on MS.NET 1.0. wr.WriteAttributes(xtr, false); // This method don't always have to take this double-quoted style... Assert.AreEqual("version=\"1.0\" standalone=\"no\"", sw.ToString().Trim(), "#WriteAttributes.XmlDecl.2"); sw = new StringWriter(); wr = new XmlTextWriter(sw); sb.Remove(0, sb.Length); // init xtr.Read(); // read root Assert.AreEqual(XmlNodeType.Element, xtr.NodeType); wr.WriteStartElement(xtr.LocalName, xtr.NamespaceURI); wr.WriteAttributes(xtr, false); wr.WriteEndElement(); wr.Close(); // This method don't always have to take this double-quoted style... Assert.AreEqual("<root a1=\"A\" b2=\"B\" c3=\"C\" />", sw.ToString().Trim(), "#WriteAttributes.Element"); xtr.Close(); }
private void RewriteFullElements(ref XmlTextWriter wrt, string aDOXmlString) { XmlTextReader rdr = new XmlTextReader(aDOXmlString, XmlNodeType.Document, null); rdr.MoveToContent(); while (rdr.ReadState != ReadState.EndOfFile) { if (rdr.Name == "s:Schema") { wrt.WriteNode(rdr, false); wrt.Flush(); } else if (rdr.Name == "z:row" && rdr.NodeType == XmlNodeType.Element) { wrt.WriteStartElement("z", "row", "#RowsetSchema"); rdr.MoveToFirstAttribute(); wrt.WriteAttributes(rdr, true); wrt.Flush(); } else if (rdr.Name == "z:row" && rdr.NodeType == XmlNodeType.EndElement) { wrt.WriteEndElement(); wrt.Flush(); } else if (rdr.Name == "rs:data" && rdr.NodeType == XmlNodeType.Element) { wrt.WriteStartElement("rs", "data", "urn:schemas-microsoft-com:rowset"); } else if (rdr.Name == "rs:data" && rdr.NodeType == XmlNodeType.EndElement) { wrt.WriteEndElement(); wrt.Flush(); } rdr.Read(); } wrt.WriteEndElement(); wrt.Flush(); }
private XmlDocument XmlFromSgml(TextReader textReader) { Stack <string> stack = new Stack <string>(); TextWriter logWriter = new StringWriter(); try { Sgml.SgmlReader reader = new Sgml.SgmlReader(); reader.DocType = "HTML"; reader.WhitespaceHandling = WhitespaceHandling.All; reader.CaseFolding = Sgml.CaseFolding.ToLower; reader.InputStream = textReader; reader.ErrorLog = logWriter; StringWriter writer = new StringWriter(); XmlWriter xmlWriter = null; try { xmlWriter = new XmlTextWriter(writer); bool rootElement = true; string lastElementName = ""; while ((reader.Read()) && !reader.EOF) { switch (reader.NodeType) { case XmlNodeType.Element: try { xmlWriter.WriteStartElement(reader.LocalName); xmlWriter.WriteAttributes(reader, true); if (reader.IsEmptyElement) { xmlWriter.WriteEndElement(); lastElementName = ""; } else { lastElementName = reader.LocalName; } } catch (Exception exc) { logger.LogError(exc, lastElementName); } break; case XmlNodeType.Text: if (string.IsNullOrEmpty(lastElementName)) { string text = reader.Value; xmlWriter.WriteString(text); } else { if (rootElement) { rootElement = false; stack.Push("."); } else { xmlWriter.WriteElementString("value", reader.Value); xmlWriter.WriteEndElement(); stack.Push(lastElementName); } lastElementName = ""; } break; case XmlNodeType.EndElement: if (stack.Peek() == reader.LocalName) { stack.Pop(); break; } logger.LogTrace(reader.LocalName); try { xmlWriter.WriteEndElement(); lastElementName = ""; } catch (Exception exc) { logger.LogError(exc, lastElementName); } break; } } } finally { if (xmlWriter != null) { xmlWriter.Close(); } } string xml = writer.ToString(); XmlDocument doc = new XmlDocument(); doc.PreserveWhitespace = true; doc.LoadXml(xml); return(doc); } finally { string str = logWriter.ToString(); if (string.IsNullOrEmpty(str)) { logger.LogError(str); } logWriter.Dispose(); } }
/// <summary> /// Copies everything from the reader object to the writer instance /// </summary> /// <param name="writer">The XmlTextWriter to copy to.</param> /// <param name="reader">The XmlReader to read from.</param> /// <param name="defattr">true to copy the default attributes from the XmlReader; otherwise, false.</param> /// <param name="skipHtmlNode">是否跳过html节点</param> /// <param name="clearTag">是否清除html tag,只输出纯文本</param> /// <param name="maxCount">copy的文本的字符数,如果maxCount<=0,copy全部文本</param> /// <param name="endStr">如果只copy了部分文本,部分文本后的附加字符,如...</param> public static void WriteXml(XmlTextWriter writer, XmlReader reader, bool defattr, bool skipHtmlNode, bool clearTag, int maxCount, string endStr) { if (writer == null) { throw new ArgumentNullException("writer"); } if (reader == null) { throw new ArgumentNullException("reader"); } int count = 0; bool finished = false; reader.Read(); while (!finished && !reader.EOF) { char[] writeNodeBuffer = null; bool canReadValueChunk = reader.CanReadValueChunk; int num = (reader.NodeType == XmlNodeType.None) ? -1 : reader.Depth; do { if (clearTag && reader.NodeType != XmlNodeType.Text) { writer.WriteString(" "); continue; } switch (reader.NodeType) { case XmlNodeType.Element: if (skipHtmlNode && reader.Name != null && reader.Name.ToLower() == "html") { break; } writer.WriteStartElement(reader.Prefix, reader.LocalName, reader.NamespaceURI); writer.WriteAttributes(reader, defattr); if (reader.IsEmptyElement) { writer.WriteEndElement(); } break; case XmlNodeType.Text: int num2; if (!canReadValueChunk) { if (maxCount > 0) { string value = reader.Value; if ((count + value.Length) >= maxCount) { value = value.Substring(0, (maxCount - count)); if (!String.IsNullOrEmpty(endStr)) { value += endStr; } finished = true; } writer.WriteString(value); count += value.Length; } else { writer.WriteString(reader.Value); } break; } if (writeNodeBuffer == null) { writeNodeBuffer = new char[0x400]; } while ((num2 = reader.ReadValueChunk(writeNodeBuffer, 0, 0x400)) > 0) { if (maxCount > 0) { if ((count + num2) >= maxCount) { num2 = maxCount - count; writer.WriteChars(writeNodeBuffer, 0, num2); if (!String.IsNullOrEmpty(endStr)) { writer.WriteString(endStr); } finished = true; } else { writer.WriteChars(writeNodeBuffer, 0, num2); } count += num2; } else { writer.WriteChars(writeNodeBuffer, 0, num2); } } break; case XmlNodeType.CDATA: writer.WriteCData(reader.Value); break; case XmlNodeType.EntityReference: writer.WriteEntityRef(reader.Name); break; case XmlNodeType.ProcessingInstruction: case XmlNodeType.XmlDeclaration: writer.WriteProcessingInstruction(reader.Name, 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.Whitespace: case XmlNodeType.SignificantWhitespace: writer.WriteWhitespace(reader.Value); break; case XmlNodeType.EndElement: if (skipHtmlNode && reader.Name != null && reader.Name.ToLower() == "html") { break; } writer.WriteFullEndElement(); break; } }while(!finished && reader.Read() && ((num < reader.Depth) || ((num == reader.Depth) && (reader.NodeType == XmlNodeType.EndElement)))); } }
public static string InjectInXml(string XML, int InjectionPosition, string Payload) { bool IsOldVersion = true; //StringBuilder OutXml = new StringBuilder(); StringReader XMLStringReader = new StringReader(XML.Trim()); XmlReader Reader = XmlReader.Create(XMLStringReader); //XmlWriter Writer = XmlWriter.Create(OutXml); StringWriter OutXml = new StringWriter(); XmlTextWriter Writer = new XmlTextWriter(OutXml); Writer.Formatting = Formatting.Indented; int ParameterCount = 0; bool Read = true; //bool NextRead = false; bool FirstElement = true; while (Read) { //if (!NextRead) Read = Reader.Read(); //NextRead = false; Read = Reader.Read(); if (!Read) { continue; } //while (Reader.NodeType == XmlNodeType.Whitespace || Reader.NodeType == XmlNodeType.SignificantWhitespace) //{ // Reader.Read(); //} if (Reader.IsStartElement()) { Writer.WriteStartElement(Reader.Name); if (Reader.HasAttributes) { Writer.WriteAttributes(Reader, false); if (FirstElement) { string FPV = Reader.GetAttribute("fpv"); if (FPV != null) { if (FPV == "4") { IsOldVersion = false; } } } } FirstElement = false; if (Reader.IsEmptyElement) { if (ParameterCount == InjectionPosition) { if (IsOldVersion) { Writer.WriteString(Tools.XmlSafe(Payload)); } else { Writer.WriteString(Tools.Base64Encode(Payload)); } } else { Writer.WriteString(Reader.Value); } ParameterCount++; Writer.WriteEndElement(); } //Read = Reader.Read(); //while (Reader.NodeType == XmlNodeType.Whitespace || Reader.NodeType == XmlNodeType.SignificantWhitespace) //{ // Reader.Read(); //} //if (Reader.NodeType == XmlNodeType.Text || Reader.NodeType == XmlNodeType.EndElement) //{ // if (ParameterCount == InjectionPosition) // Writer.WriteString(Payload); // else // Writer.WriteString(Reader.Value); // ParameterCount++; //} //else //{ // NextRead = true; //} //if (Reader.NodeType == XmlNodeType.EndElement) //{ // //if (ParameterCount == InjectionPosition) // // Writer.WriteString(Payload); // //else // // Writer.WriteString(""); // //ParameterCount++; // Writer.WriteEndElement(); //} } else if (Reader.NodeType == XmlNodeType.Text) { if (ParameterCount == InjectionPosition) { if (IsOldVersion) { Writer.WriteString(Tools.XmlSafe(Payload)); } else { Writer.WriteString(Tools.Base64Encode(Payload)); } } else { Writer.WriteString(Reader.Value); } ParameterCount++; } else if (Reader.NodeType == XmlNodeType.Whitespace || Reader.NodeType == XmlNodeType.SignificantWhitespace) { } else if (Reader.NodeType == XmlNodeType.EndElement) { Writer.WriteEndElement(); } //else //{ // if (Reader.NodeType == XmlNodeType.EndElement) // { // Writer.WriteEndElement(); // } // //else // //{ // // if (ParameterCount == InjectionPosition) // // Writer.WriteString(Payload); // // else // // Writer.WriteString(Reader.Value); // // ParameterCount++; // //} //} } Reader.Close(); Writer.Close(); OutXml.Close(); //string OutXmlString = OutXml.ToString().Split(new string[] { "?>" }, 2, StringSplitOptions.None)[1]; return(OutXml.ToString()); }
/// <summary> /// Using the dictionary, if transaction id is in the dictionary, rewrite the host and path /// </summary> /// <param name="dictionary"></param> /// <returns></returns> internal static bool RewriteRootPathAsReferer(Dictionary <string, string> dictionary, int refererCount, int transactionCount) { bool matchTransactionAndRefererCount = false; string xmlFile = "identifier.xml"; int rCount = 0; int tCount = 0; string tempId = "0000"; string originalHost = ""; bool foundInDictionary = false; #region Xml Reader and Writer initialization Encoding utf8withoutbom = new UTF8Encoding(false); XmlTextReader reader = new XmlTextReader(xmlFile); reader.WhitespaceHandling = WhitespaceHandling.All; XmlValidatingReader vr = new XmlValidatingReader(reader); //XmlReaderSettings xmlReaderSettings = new XmlReaderSettings(); vr.ValidationType = ValidationType.None; vr.EntityHandling = EntityHandling.ExpandEntities; StreamWriter sw = new StreamWriter("reformated.xml", false, utf8withoutbom); XmlWriter writer = new XmlTextWriter(sw); #endregion writer.WriteRaw("<?xml version=\"1.0\" encoding=\"iso-8859-1\"?>"); reader.MoveToContent(); do { #region Encounter start elements if (reader.NodeType == XmlNodeType.Element) { writer.WriteStartElement(reader.Prefix, reader.LocalName, reader.NamespaceURI); if (reader.Name.Equals("transaction")) { //cycle through all attributes of the transaction tCount++; //method was turned to ID from GenerateTransactionIdentifiers() tempId = reader.GetAttribute("method"); for (int i = 0; i < reader.AttributeCount; i++) { //look for the method attribute if (reader.Name.Equals("host")) { //will be used for appending path originalHost = reader.Value; if (dictionary.ContainsKey(tempId)) { //rewrite host into referer if (reader.GetAttribute("protocol").Equals("https")) { writer.WriteAttributeString(reader.Name, " Referer: " + dictionary[tempId] + " "); } else { writer.WriteAttributeString(reader.Name, " Referer: " + dictionary[tempId] + " "); } rCount++; } else { if (reader.GetAttribute("protocol").Equals("https")) { writer.WriteAttributeString(reader.Name, " " + "No Referer "); } else { writer.WriteAttributeString(reader.Name, " " + "No Referer "); } } } else if (reader.Name.Equals("path")) { //rewrite path into originalHost with referer writer.WriteAttributeString(reader.Name, originalHost + reader.GetAttribute(reader.Name)); } else if (reader.Name.Equals("transaction")) { //skip } else { //write the rest of the attributes writer.WriteAttributeString(reader.Name, reader.GetAttribute(reader.Name)); } reader.MoveToNextAttribute(); } } writer.WriteAttributes(reader, true); ////The below ensures that ssl tags have a short end tag //if (reader.Name.Equals("ssl") // || reader.Name.Equals("alpn")) //{ // writer.WriteEndElement(); //} //else if (reader.Name.Equals("first-line")) //{ // //if the first-line has a short end tag, maintain it as a short end tag // if (reader.IsEmptyElement) // { // writer.WriteEndElement(); // } //} if (reader.IsEmptyElement) { writer.WriteEndElement(); } } #endregion #region Encounter end elements //else if ((reader.NodeType == XmlNodeType.EndElement) || reader.IsEmptyElement) else if (reader.NodeType == XmlNodeType.EndElement) { //Console.Write("\n3"); writer.WriteEndElement(); //WriteAttributes(reader, writer);//is this line neccessary? No it isn't. } #endregion #region Encounter attributes outside of elements //takes care of all other elements' attributes, but this shouldn't be reached. else if (reader.NodeType == XmlNodeType.Attribute) { Console.WriteLine("Attribute: " + reader.Name.ToString() + " found outside of element."); writer.WriteAttributes(reader, true); } #endregion #region Encounter inner text else if (reader.NodeType == XmlNodeType.Text) { //Console.Write("2"); writer.WriteString(reader.Value); } #endregion #region Encounter CDATA else if (reader.NodeType.Equals(XmlNodeType.CDATA)) { writer.WriteRaw("<![CDATA[" + reader.Value + "]]>"); } #endregion } while (reader.Read()); writer.Close(); reader.Close(); if (rCount == refererCount) { if (tCount == transactionCount) { matchTransactionAndRefererCount = true; } } return(matchTransactionAndRefererCount); }
/// <summary> /// Converts the specified html into XHTML compliant text. /// </summary> /// <param name="html">html to convert.</param> /// <param name="converter">The converter.</param> /// <returns></returns> private string ConvertHtmlToXHtml(string html, Converter <string, string> converter) { _reader.DocType = "html"; _reader.WhitespaceHandling = WhitespaceHandling.All; // Hack to fix SF bug #1678030 html = RemoveNewLineBeforeCdata(html); _reader.InputStream = new StringReader(string.Format("<html>{0}</html>", html)); _reader.CaseFolding = CaseFolding.ToLower; var writer = new StringWriter(); XmlWriter xmlWriter = null; try { xmlWriter = new XmlTextWriter(writer); bool insideAnchor = false; bool skipRead = false; while ((skipRead || _reader.Read()) && !_reader.EOF) { skipRead = false; switch (_reader.NodeType) { case XmlNodeType.Element: //Special case for anchor tags for the time being. //We need some way to communicate which elements the current node is nested within if (_reader.IsEmptyElement) { xmlWriter.WriteStartElement(_reader.LocalName); xmlWriter.WriteAttributes(_reader, true); if (_reader.LocalName == "a" || _reader.LocalName == "script" || _reader.LocalName == "iframe" || _reader.LocalName == "object") { xmlWriter.WriteFullEndElement(); } else { xmlWriter.WriteEndElement(); } } else { if (_reader.LocalName == "a") { insideAnchor = true; } xmlWriter.WriteStartElement(_reader.LocalName); xmlWriter.WriteAttributes(_reader, true); } break; case XmlNodeType.Text: string text = _reader.Value; if (converter != null && !insideAnchor) { xmlWriter.WriteRaw(converter(HttpUtility.HtmlEncode(text))); } else { xmlWriter.WriteString(text); } break; case XmlNodeType.EndElement: if (_reader.LocalName == "a") { insideAnchor = false; } if (_reader.LocalName == "a" || _reader.LocalName == "script" || _reader.LocalName == "iframe" || _reader.LocalName == "object") { xmlWriter.WriteFullEndElement(); } else { xmlWriter.WriteEndElement(); } break; default: xmlWriter.WriteNode(_reader, true); skipRead = true; break; } } } finally { if (xmlWriter != null) { xmlWriter.Close(); } } string xml = writer.ToString(); return(xml.Substring("<html>".Length, xml.Length - "<html></html>".Length)); }
/// <summary> /// Goes through a charlesLog.xml file and changes the Method attribute to IDs /// <param name="xmlFile">Charles Log XML file name</param> /// </summary> /// <returns>Count of Transactions</returns> internal static int GenerateTransactionIdentifiers(string xmlFile) { int transactionCount = 0; #region Xml Reader and Writer initialization XmlTextReader reader = new XmlTextReader(xmlFile); Encoding utf8withoutbom = new UTF8Encoding(false); reader.WhitespaceHandling = WhitespaceHandling.All; XmlValidatingReader vr = new XmlValidatingReader(reader); //XmlReaderSettings xmlReaderSettings = new XmlReaderSettings(); vr.ValidationType = ValidationType.None; vr.EntityHandling = EntityHandling.ExpandEntities; StreamWriter sw = new StreamWriter("identifier.xml", false, utf8withoutbom); XmlWriter writer = new XmlTextWriter(sw); #endregion #region Read log step by step and write to identifiers.xml writer.WriteRaw("<?xml version=\"1.0\" encoding=\"iso-8859-1\"?>"); reader.MoveToContent(); do { #region Encounter start elements if (reader.NodeType == XmlNodeType.Element) { writer.WriteStartElement(reader.Prefix, reader.LocalName, reader.NamespaceURI); if (reader.Name.Equals("transaction")) { //cycle through all attributes of the transaction for (int i = 0; i < reader.AttributeCount; i++) { //look for the method attribute if (reader.Name.Equals("method")) { //change it to transaction Count writer.WriteAttributeString(reader.Name, transactionCount.ToString("00000")); transactionCount++; } else if (reader.Name.Equals("transaction")) { //skip } else { //write the rest of the attributes writer.WriteAttributeString(reader.Name, reader.GetAttribute(reader.Name)); } reader.MoveToNextAttribute(); } } writer.WriteAttributes(reader, true); if (reader.IsEmptyElement) { writer.WriteEndElement(); } ////The below checks short end tags //if (reader.Name.Equals("ssl") // || reader.Name.Equals("alpn")) //{ // writer.WriteEndElement(); //} //else if (reader.Name.Equals("first-line")) //{ // //if the first-line has a short end tag, maintain it as a short end tag // if (reader.IsEmptyElement) // { // writer.WriteEndElement(); // } //} } #endregion #region Encounter end elements else if (reader.NodeType == XmlNodeType.EndElement) { //Console.Write("\n3"); writer.WriteEndElement(); //WriteAttributes(reader, writer);//is this line neccessary? No it isn't. } //else if (reader.IsEmptyElement) { // writer.WriteEndElement(); //} #endregion #region Encounter attributes outside of elements //takes care of all other elements' attributes, but this shouldn't be reached. else if (reader.NodeType == XmlNodeType.Attribute) { Console.WriteLine("Attribute: " + reader.Name.ToString() + " found outside of element."); writer.WriteAttributes(reader, true); } #endregion #region Encounter inner text else if (reader.NodeType == XmlNodeType.Text) { //Console.Write("2"); writer.WriteString(reader.Value); } #endregion #region Encounter CDATA else if (reader.NodeType.Equals(XmlNodeType.CDATA)) { writer.WriteRaw("<![CDATA[" + reader.Value + "]]>"); } #endregion } while (reader.Read()); #endregion writer.Close(); reader.Close(); return(transactionCount); }
// duplicate all writes to the log writer public override void WriteAttributes(XmlReader reader, Boolean defattr) { base.WriteAttributes(reader, defattr); _logWriter.WriteAttributes(reader, defattr); }
public TableXml(TableXsd tableXsd, FileInfo path, FileIndex fileIndex, int tableNo) : base(path, fileIndex, tableXsd.Schema, TableNamespace(tableXsd), TableNamespaceLocation(TableNamespace(tableXsd), tableNo)) { path.Refresh(); if (path.Exists == false) { // We will now use Document from the base class. return; } // We will now void to load large XML documents (> 32MB) into // the memory because this can make an OutOfMemoryException // Therefore we will set the Document to NULL and use // a XmlTextWriter instead. long maxSizeForUsingXmlDocument = 1024 * 1024 * 32; if (path.Length < maxSizeForUsingXmlDocument) { try { using (var fileStream = new FileStream(path.FullName, FileMode.Open, FileAccess.ReadWrite, FileShare.Read)) { using (var xmlReader = XmlReader.Create(fileStream, CreateXmlReaderSettings(base.Schema, ValidationType.None))) { Document.Load(xmlReader); xmlReader.Close(); } } return; } catch (OutOfMemoryException) { Document = null; GC.Collect(); GC.WaitForPendingFinalizers(); } } Document = null; _shadowFile = new FileInfo($"{path.FullName}.shadow"); try { DeleteFile(_shadowFile); _shadowFileStream = new FileStream(_shadowFile.FullName, FileMode.CreateNew, FileAccess.ReadWrite, FileShare.Read); _xmlTextWriter = new XmlTextWriter(_shadowFileStream, Encoding.UTF8) { Formatting = Formatting.Indented }; using (var sourceFileStream = new FileStream(path.FullName, FileMode.Open, FileAccess.Read, FileShare.Read)) { using (var xmlReader = XmlReader.Create(sourceFileStream, CreateXmlReaderSettings(base.Schema, ValidationType.None))) { while (xmlReader.Read()) { switch (xmlReader.NodeType) { case XmlNodeType.Element: _xmlTextWriter.WriteStartElement(xmlReader.Prefix, xmlReader.LocalName, xmlReader.NamespaceURI); _xmlTextWriter.WriteAttributes(xmlReader, true); if (xmlReader.IsEmptyElement) { _xmlTextWriter.WriteEndElement(); } break; case XmlNodeType.Text: _xmlTextWriter.WriteString(xmlReader.Value); break; case XmlNodeType.Whitespace: case XmlNodeType.SignificantWhitespace: _xmlTextWriter.WriteWhitespace(xmlReader.Value); break; case XmlNodeType.CDATA: _xmlTextWriter.WriteCData(xmlReader.Value); break; case XmlNodeType.EntityReference: _xmlTextWriter.WriteEntityRef(xmlReader.Name); break; case XmlNodeType.XmlDeclaration: case XmlNodeType.ProcessingInstruction: _xmlTextWriter.WriteProcessingInstruction(xmlReader.Name, xmlReader.Value); break; case XmlNodeType.DocumentType: _xmlTextWriter.WriteDocType(xmlReader.Name, xmlReader.GetAttribute("PUBLIC"), xmlReader.GetAttribute("SYSTEM"), xmlReader.Value); break; case XmlNodeType.Comment: _xmlTextWriter.WriteComment(xmlReader.Value); break; case XmlNodeType.EndElement: if (string.Compare(xmlReader.LocalName, "table", StringComparison.Ordinal) == 0) { break; } _xmlTextWriter.WriteFullEndElement(); break; } } } } } catch { _xmlTextWriter?.Close(); _shadowFileStream?.Close(); _shadowFileStream?.Dispose(); DeleteFile(_shadowFile); throw; } }
internal bool ParseReaderNode() { if (reader.Depth > markupDepth) { if (writer != null) // ProcessMarkup { switch (reader.NodeType) { case XmlNodeType.Element: writer.WriteStartElement(reader.Prefix, reader.LocalName, reader.NamespaceURI); writer.WriteAttributes(reader, false); if (reader.IsEmptyElement) { writer.WriteEndElement(); } break; case XmlNodeType.Text: writer.WriteString(reader.Value); break; case XmlNodeType.SignificantWhitespace: writer.WriteWhitespace(reader.Value); break; case XmlNodeType.CDATA: writer.WriteCData(reader.Value); break; case XmlNodeType.EntityReference: writer.WriteEntityRef(reader.Name); break; case XmlNodeType.Comment: writer.WriteComment(reader.Value); break; case XmlNodeType.EndElement: writer.WriteFullEndElement(); break; } } return(true); } if (reader.NodeType == XmlNodeType.Element) { if (builder.ProcessElement(reader.Prefix, reader.LocalName, reader.NamespaceURI)) { namespaceManager.PushScope(); if (reader.MoveToFirstAttribute()) { do { builder.ProcessAttribute(reader.Prefix, reader.LocalName, reader.NamespaceURI, reader.Value); if (Ref.Equal(reader.NamespaceURI, schemaNames.NsXmlNs) && isProcessNamespaces) { namespaceManager.AddNamespace(reader.Prefix == string.Empty ? string.Empty : reader.LocalName, reader.Value); } }while (reader.MoveToNextAttribute()); reader.MoveToElement(); // get back to the element } builder.StartChildren(); if (reader.IsEmptyElement) { namespaceManager.PopScope(); builder.EndChildren(); } else if (!builder.IsContentParsed()) { markupDepth = reader.Depth; stringWriter = new StringWriter(); writer = new XmlTextWriter(stringWriter); writer.WriteStartElement(reader.LocalName); } } else if (!reader.IsEmptyElement) { markupDepth = reader.Depth; writer = null; } } else if (reader.NodeType == XmlNodeType.Text || reader.NodeType == XmlNodeType.EntityReference || reader.NodeType == XmlNodeType.SignificantWhitespace || reader.NodeType == XmlNodeType.CDATA) { builder.ProcessCData(reader.Value); } else if (reader.NodeType == XmlNodeType.EndElement) { if (reader.Depth == markupDepth) { if (writer != null) // processUnparsedContent { writer.WriteEndElement(); writer.Close(); writer = null; XmlDocument doc = new XmlDocument(); doc.Load(new XmlTextReader(new StringReader(stringWriter.ToString()))); XmlNodeList list = doc.DocumentElement.ChildNodes; XmlNode[] markup = new XmlNode[list.Count]; for (int i = 0; i < list.Count; i++) { markup[i] = list[i]; } builder.ProcessMarkup(markup); namespaceManager.PopScope(); builder.EndChildren(); } markupDepth = int.MaxValue; } else { namespaceManager.PopScope(); builder.EndChildren(); } if (reader.Depth == schemaXmlDepth) { return(false); // done } } return(true); }
public static string InjectInXml(string XML, int InjectionPosition, string Payload) { //StringBuilder OutXml = new StringBuilder(); StringReader XMLStringReader = new StringReader(XML.Trim()); XmlReader Reader = XmlReader.Create(XMLStringReader); //XmlWriter Writer = XmlWriter.Create(OutXml); StringWriter OutXml = new StringWriter(); XmlTextWriter Writer = new XmlTextWriter(OutXml); int ParameterCount = 0; bool Read = true; bool NextRead = false; while (Read) { if (!NextRead) { Read = Reader.Read(); } NextRead = false; if (!Read) { continue; } if (Reader.IsStartElement()) { Writer.WriteStartElement(Reader.Name); if (Reader.HasAttributes) { Writer.WriteAttributes(Reader, false); } Read = Reader.Read(); if (Reader.NodeType == XmlNodeType.EndElement) { if (ParameterCount == InjectionPosition) { Writer.WriteString(Payload); } else { Writer.WriteString(""); } ParameterCount++; Writer.WriteEndElement(); } else { NextRead = true; } } else { if (Reader.NodeType == XmlNodeType.EndElement) { Writer.WriteEndElement(); } else { if (ParameterCount == InjectionPosition) { Writer.WriteString(Payload); } else { Writer.WriteString(Reader.Value); } ParameterCount++; } } } Reader.Close(); Writer.Close(); OutXml.Close(); //string OutXmlString = OutXml.ToString().Split(new string[] { "?>" }, 2, StringSplitOptions.None)[1]; return(OutXml.ToString()); }
private XmlTextReader ProcessPublishedContext(XmlTextReader xReader, PipelineContext context) { TextWriter sWriter = new StringWriter(); XmlTextWriter xWriter = new XmlTextWriter(sWriter); xReader.MoveToContent(); while (!xReader.EOF) { switch (xReader.NodeType) { case XmlNodeType.Element: xWriter.WriteStartElement(xReader.Prefix, xReader.LocalName, xReader.NamespaceURI); xWriter.WriteAttributes(xReader, false); try { if (IsValidItem(xReader)) { using (var client = new CoreServiceUtility()) { string id = xReader.GetAttribute("ID"); // Get the id of item from List string catman = "catman-"; string bptman = "bptman-"; if (id.StartsWith(catman)) { id = id.ToString().Replace(catman, string.Empty); } else if (id.StartsWith(bptman)) { id = id.ToString().Replace(bptman, string.Empty); } TcmUri uri = new TcmUri(id); // Validate the the types of items if (uri.ItemType == ItemType.Component || uri.ItemType == ItemType.Page || uri.ItemType == ItemType.StructureGroup || uri.ItemType == ItemType.Category) { string publishedCotexts = null; List <string> publishedPurposeList = new List <string>(); try { var publishInfo = client.GetListPublishInfo(id); //Validate item is published if (publishInfo.Count() > 0) { foreach (var info in publishInfo) { if (!String.IsNullOrEmpty(info.TargetPurpose)) { //Validate item is published from current publication if (client.IsPublished(id, info.TargetPurpose)) { publishedPurposeList.Add(info.TargetPurpose); } } else { Trace.TraceError($"TargetInfo is NUll"); } } if (publishedPurposeList.Count > 0) { publishedCotexts = String.Join(",", publishedPurposeList.Distinct()); xWriter.WriteAttributeString("PublishedTo", publishedCotexts); // Add the data into the list } else { xWriter.WriteAttributeString("PublishedTo", "-"); } } else { xWriter.WriteAttributeString("PublishedTo", "-"); } } catch (Exception ex) { Trace.TraceError("Exception :" + ex.Message + "Stack Trace :" + ex.StackTrace); } } else { xWriter.WriteAttributeString("PublishedTo", "N/A"); xReader.MoveToElement(); } } } } catch (Exception ex) { Trace.TraceError("Exception: " + ex.Message + "Stack Trace :" + ex.StackTrace); } if (xReader.IsEmptyElement) { xWriter.WriteEndElement(); } break; case XmlNodeType.EndElement: xWriter.WriteEndElement(); break; case XmlNodeType.CDATA: xWriter.WriteCData(xReader.Value); break; case XmlNodeType.Comment: xWriter.WriteComment(xReader.Value); break; case XmlNodeType.DocumentType: xWriter.WriteDocType(xReader.Name, null, null, null); break; case XmlNodeType.EntityReference: xWriter.WriteEntityRef(xReader.Name); break; case XmlNodeType.ProcessingInstruction: xWriter.WriteProcessingInstruction(xReader.Name, xReader.Value); break; case XmlNodeType.SignificantWhitespace: xWriter.WriteWhitespace(xReader.Value); break; case XmlNodeType.Text: xWriter.WriteString(xReader.Value); break; case XmlNodeType.Whitespace: xWriter.WriteWhitespace(xReader.Value); break; } xReader.Read(); } ; xWriter.Flush(); xReader = new XmlTextReader(new StringReader(sWriter.ToString())); xReader.MoveToContent(); return(xReader); }
public void Split(ESplitType splitType, int splitSize, string fileSuffixXpath) { _data.Read(); //Capture all of the items before the first element while (_data.NodeType != XmlNodeType.Element) { _output.WriteNode(_data, true); } //Prepare the document header and footer sections for use later... _output.WriteStartElement(_data.Name); _output.WriteAttributes(_data, true); var header = _outputBuilder.ToString() + ">"; var footer = "</" + _data.Name + ">"; //skip past the first node _data.Read(); int elementCounter = 0; int splitCount = 0; bool emptyDocument = false; FileInfo dataFI = new FileInfo(_dataPath); string outputFileName = dataFI.Name.Substring(0, dataFI.Name.LastIndexOf(".")); StreamWriter writer = null; while (!_data.EOF) { //Only count the nodes that interest us... if (!IgnorableNodeType(_data.NodeType)) { elementCounter++; } else { emptyDocument = false; } //copy everything from the reader _output.WriteNode(_data, true); if ((splitType == ESplitType.ElementCount && elementCounter >= splitSize) || (splitType == ESplitType.Filesize && (_outputBuilder.Length - header.Length) >= splitSize * 1000)) { ////construct the final XML string ExportXmlFile(footer, writer, outputFileName, splitCount); //reset counters splitCount++; elementCounter = 0; //reset string builder _outputBuilder.Length = 0; _outputBuilder.Append(header); emptyDocument = true; } } //If there is anything left, export it - no footer required! if (_outputBuilder.Length > 0) { ExportXmlFile("", writer, outputFileName, splitCount); } SplitTotal = splitCount; }