public string ToDisplayString(DataKey root, Logger logger)
{
DataValue method = root.SelectSingleNode("Method") as DataValue;
DataValue path = root.SelectSingleNode("Path") as DataValue;
return String.Format("{0} {1}", method, path);
}
public void SetNode(DataNode node, DataNode selected, Color color, bool readOnly)
{
if (node is DataKey)
{
_key = node as DataKey;
_color = color;
_readOnly = readOnly;
UpdateList();
}
else
{
throw new ArgumentException("Node needs to be a DataKey type");
}
}
public override bool MoveToNext()
{
if (_currNode.Parent != null)
{
DataKey key = _currNode.Parent;
int index = key.SubNodes.IndexOf(_currNode);
if ((index >= 0) && ((index + 1) < key.SubNodes.Count))
{
UpdateCurrentNode(key.SubNodes[index + 1]);
return(true);
}
}
return(false);
}
public override bool MoveToPrevious()
{
if (_currNode.Parent != null)
{
DataKey key = _currNode.Parent;
int index = key.SubNodes.IndexOf(_currNode);
if (index > 0)
{
UpdateCurrentNode(key.SubNodes[index - 1]);
return(true);
}
}
return(false);
}
private void AddCookie(string cookie, DataKey root, Logger logger)
{
string[] kv = cookie.Split(new [] {'='}, 2, StringSplitOptions.RemoveEmptyEntries);
string k = kv[0].Trim();
string v = "";
if(kv.Length > 1)
{
v = kv[1].Trim();
}
if(!String.IsNullOrEmpty(k))
{
root.AddValue(k, v);
}
}
/// <summary>
/// Replace node with a dictionary key
/// </summary>
/// <param name="dict">The dictionary key</param>
public DataKey ReplaceNode(IDictionary dict)
{
DataKey ret = new DataKey(this.Name, dict);
if (Parent != null)
{
Parent.ReplaceNode(this, ret);
}
else
{
if ((_frame != null) && (_frame.Root == this))
{
_frame.Root = ret;
}
}
return(ret);
}
/// <summary>
/// Convert to a dictionary, this can be a lossy process if multiple nodes with the same value exist
/// </summary>
/// <returns>The key as a dictionary</returns>
public IDictionary ToDictionary()
{
Dictionary <string, object> dict = new Dictionary <string, object>();
foreach (DataNode node in _subNodes)
{
DataKey key = node as DataKey;
if (key != null)
{
dict[node.Name] = key.ToDictionary();
}
else
{
dict[node.Name] = ((DataValue)node).Value;
}
}
return(dict);
}
/// <summary>
/// Convert the frame to a string value
/// </summary>
/// <param name="value">The string value</param>
/// <param name="encoding">The encoding for the string</param>
/// <returns>The data value</returns>
public DataValue FromDataString(string value, Encoding encoding)
{
DataValue ret = null;
bool doConvert = true;
// If already basic, don't convert the entire frame
if (IsDataString)
{
StringDataValue dv = SelectSingleNode("/Data") as StringDataValue;
if (dv != null)
{
dv.Value = value;
// Only set encoding if different
if (encoding != null)
{
dv.StringEncoding = encoding;
}
ret = dv;
doConvert = false;
}
}
// Not basic or we failed
if (doConvert)
{
DataKey root = new DataKey("Root");
root.Class = new Guid(DataNodeClasses.STRING_NODE_CLASS);
root.FormatString = "$Data";
root.SetLinks(this, null);
ret = root.AddValue("Data", value, encoding ?? BinaryEncoding.Instance);
Root = root;
}
OnModified();
return(ret);
}
private bool CompareKeys(DataKey x, DataKey y)
{
bool ret = true;
if (x.SubNodes.Count != y.SubNodes.Count)
{
ret = false;
}
else
{
for (int i = 0; i < y.SubNodes.Count; ++i)
{
if (!Equals(x.SubNodes[i], y.SubNodes[i]))
{
ret = false;
break;
}
}
}
return(ret);
}
/// <summary>
/// Replace the current node
/// </summary>
/// <param name="node">The new node to replace with</param>
public void ReplaceNode(DataNode node)
{
if (Parent != null)
{
Parent.ReplaceNode(this, node);
}
else
{
if ((_frame != null) && (_frame.Root == this))
{
DataKey key = node as DataKey;
if (key != null)
{
_frame.Root = key;
}
else
{
_frame.ConvertToBasic(node.ToArray());
}
}
}
}
public override DataFrame Read()
{
try
{
if(_request == null)
{
_request = HttpParser.ReadRequestHeader(new DataReader(_stm), false, _logger);
lock (_requestQueue)
{
_requestQueue.Enqueue(_request);
}
ProcessProxyRequestHeaders(_request);
}
if (_chunks == null)
{
_chunks = _request.ReadChunks(_config).GetEnumerator();
// If we can't move to the first chunk (headers) there is a serious issue
if (!_chunks.MoveNext())
{
throw new EndOfStreamException();
}
}
HttpRequestDataChunk chunk = _chunks.Current;
if (!_chunks.MoveNext())
{
_request = null;
_chunks = null;
}
DataKey root = new DataKey("Root");
root.AddValue(new DynamicDataValue(DATA_NAME, chunk));
return new DataFrame(root);
}
catch (EndOfStreamException)
{
return null;
}
}
/// <summary>
///
/// </summary>
/// <param name="root"></param>
/// <param name="logger"></param>
/// <returns></returns>
public string ToDisplayString(DataKey root, Logger logger)
{
return "DNS Packet";
}
/// <summary>
///
/// </summary>
/// <param name="root"></param>
/// <param name="logger"></param>
/// <returns></returns>
public byte[] ToArray(DataKey root, Logger logger)
{
return DNSPacket.FromDataKey(root).ToArray();
}
/// <summary>
///
/// </summary>
/// <param name="data"></param>
/// <param name="root"></param>
/// <param name="logger"></param>
public void FromArray(byte[] data, DataKey root, Logger logger)
{
DNSPacket packet = DNSPacket.FromArray(data);
packet.ToDataKey(root);
}
private DataKey AddKey(DataKey key)
{
AddSubNode(key);
return key;
}
public static HTTPDataRequest FromDataKey(DataKey key)
{
return ObjectConverter.FromNode<HTTPDataRequest>(key);
}
private DataKey AddKey(DataKey key)
{
AddSubNode(key);
return(key);
}
/// <summary>
/// Convert to a data key
/// </summary>
/// <param name="key">The data key</param>
public void ToDataKey(DataKey key)
{
ObjectConverter.ToNode(key, this, typeof(UnknownDNSRR), typeof(CNameDNSRR), typeof(ADNSRR));
}
/// <summary>
/// Constructor, creates a basic frame with a known root
/// </summary>
/// <param name="root">The root key</param>
public DataFrame(DataKey root)
{
Root = root;
}
private bool SetMember(string name, dynamic value)
{
DataValue v = GetNodeNoThrow(name) as DataValue;
DataNode n = value as DataNode;
IDictionary dict = value as IDictionary;
IList list = value as IList;
if ((dict == null) && (list != null) && !(value is byte[]))
{
dict = ListToDictionary("Item", list);
}
if (dict != null)
{
DataKey key = new DataKey(name);
key.PopulateFromDictionary(dict);
n = key;
}
if (v != null)
{
if (n != null)
{
v.ReplaceNode(n);
n.Name = name;
}
else
{
v.Value = value;
}
}
else
{
if (n != null)
{
n.Name = name;
AddSubNode(n);
}
else
{
dynamic key = this;
key.AddValue(name, value);
}
}
return true;
}
private static void CopyAsFilter(DataKey root, List<DataFrameFilterFactory> exp)
{
foreach (DataNode node in root.SubNodes)
{
DataValue value = node as DataValue;
if (value != null)
{
exp.Add(GetFilterForValue(value));
}
else
{
DataKey key = node as DataKey;
if (key != null)
{
CopyAsFilter(key, exp);
}
}
}
}
/// <summary>
/// Create a list of filters for a key
/// </summary>
/// <param name="root">The root key</param>
/// <returns>The list of filters</returns>
public static IEnumerable<DataFrameFilterFactory> CreateFilter(DataKey root)
{
List<DataFrameFilterFactory> filters = new List<DataFrameFilterFactory>();
foreach (DataNode node in root.SubNodes)
{
DataValue value = node as DataValue;
if (value != null)
{
filters.Add(CreateFilter(value));
}
else
{
DataKey key = node as DataKey;
if (key != null)
{
filters.AddRange(CreateFilter(key));
}
}
}
return filters;
}
private DataFrame CreateFrame(HttpDataChunk response)
{
DataKey root = new DataKey("Root");
root.AddValue(new DynamicDataValue(DATA_NAME, response));
return new DataFrame(root);
}
/// <summary>
/// Sets the referenced data frame, internal access only
/// </summary>
/// <param name="frame"></param>
/// <param name="parent"></param>
internal virtual void SetLinks(DataFrame frame, DataKey parent)
{
_frame = frame;
_parent = parent;
}
public void FromReader(DataReader reader, DataKey root, Logger logger)
{
HTTPDataResponse req = new HTTPDataResponse(reader, logger);
req.ToDataKey(root);
}
public string ToDisplayString(DataKey root, Logger logger)
{
DataValue respcode = root.SelectSingleNode("Respcode") as DataValue;
return String.Format("HTTP Response: {0}", respcode);
}
public void ToWriter(DataWriter writer, DataKey root, Logger logger)
{
HTTPDataResponse resp = HTTPDataResponse.FromDataKey(root);
resp.ToWriter(writer, logger);
}
public static HTTPDataResponse FromDataKey(DataKey key)
{
return ObjectConverter.FromNode<HTTPDataResponse>(key);
}
/// <summary>
/// Overridden form, sets all subnodes to the current frame as well
/// </summary>
/// <param name="frame">The root data frame</param>
/// <param name="parent">The parent datakey</param>
internal override void SetLinks(DataFrame frame, DataKey parent)
{
base.SetLinks(frame, parent);
foreach(DataNode node in _subNodes)
{
node.SetLinks(frame, this);
}
}
public void ToDataKey(DataKey key)
{
ObjectConverter.ToNode(key, this);
}
/// <summary>
/// Convert from a data key
/// </summary>
/// <param name="key">The data key</param>
/// <returns>The DNS Packet</returns>
public static DNSPacket FromDataKey(DataKey key)
{
return ObjectConverter.FromNode<DNSPacket>(key, typeof(UnknownDNSRR), typeof(CNameDNSRR), typeof(ADNSRR));
}
