/// <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;
}
