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