/// <summary>
/// 创建异常数据
/// </summary>
/// <param name="e">异常数据</param>
/// <returns>返回异常数据节点</returns>
static DictNode CreateExceptionNode(Exception e)
{
DictNode result = new DictNode();
result.Add("code", 4);
result.Add("message", string.Format("{0}: {1}", e.GetType(), e.Message));
return(result);
}
/// <summary>
///
/// </summary>
/// <param name="key"></param>
/// <param name="iv"></param>
/// <returns></returns>
private byte[] BuildAckMessage(byte[] key, byte[] iv)
{
DictNode node = new DictNode();
node.Add("key", key);
node.Add("iv", iv);
return(BEncode.ByteArrayEncode(node));
}
/// <summary>
/// 新建握手数据包
/// </summary>
/// <param name="key">密钥</param>
/// <param name="iv">初始化向量</param>
/// <returns>返回握手数据包</returns>
public static byte[] BuildHandshake(byte[] key, byte[] iv)
{
DictNode node = new DictNode();
node.Add("key", key);
node.Add("iv", iv);
return(BEncode.ByteArrayEncode(node));
}
public void TestDecodeHandler1()
{
byte[] source = File.ReadAllBytes(@"E:\Bittorrent\Torrents\winedt70.exe.torrent");
DictNode dh = (DictNode)BEncodingFactory.Decode(source);
Assert.AreEqual("http://192.168.1.150:8080/announce", (dh["announce"] as BytesNode).StringText);
Assert.AreEqual("http://192.168.1.150:8080/announce", _encoding.GetString((dh["announce"] as BytesNode).ByteArray));
}
/// <summary>
/// 验证握手数据包
/// </summary>
/// <param name="handshake">握手数据包</param>
/// <param name="key">密钥</param>
/// <param name="iv">初始化向量</param>
/// <returns>如果验证成功返回true;否则返回false</returns>
public static bool VerifyHandshake(byte[] handshake, byte[] key, byte[] iv)
{
DictNode node = (DictNode)BEncode.Decode(handshake);
byte[] handshakeKey = ((BytesNode)node["key"]).ByteArray;
byte[] handshakeIV = ((BytesNode)node["iv"]).ByteArray;
return(BytesComparer.Compare(handshakeKey, key) && BytesComparer.Compare(handshakeIV, iv));
}
/// <summary>
/// 建立失败打开数据包
/// </summary>
/// <param name="message">失败消息</param>
/// <returns>返回数据包</returns>
private byte[] BuildFailOpenPacket(string message)
{
DictNode result = new DictNode();
result.Add("code", 6);
result.Add("message", message);
return(BEncode.ByteArrayEncode(result));
}
/// <summary>
/// 建立成功打开数据包
/// </summary>
/// <param name="key">密钥</param>
/// <param name="iv">初始化向量</param>
/// <returns>返回数据包</returns>
private byte[] BuildSuccessOpenPacket(byte[] key, byte[] iv)
{
DictNode result = new DictNode();
result.Add("code", 1);
result.Add("key", key);
result.Add("iv", iv);
return(BEncode.ByteArrayEncode(result));
}
/// <summary>
/// 记录数据包
/// </summary>
/// <param name="buffer">待记录的数据包</param>
/// <param name="endPoint">IP端点</param>
public override void Write(byte[] buffer, IPEndPoint endPoint)
{
DictNode node = new DictNode();
node.Add("buffer", buffer);
node.Add("endpoint", endPoint.ToString());
byte[] sndMsg = BEncode.ByteArrayEncode(node);
handler.SendNormalPacket(sndMsg);
}
/// <summary>
/// 建立打开DB Proxy Server包
/// </summary>
/// <returns>返回数据包</returns>
private byte[] BuildOpenPacket()
{
DictNode rootNode = new DictNode();
rootNode.Add("action", 1);
rootNode.Add("deviceid", deviceId);
rootNode.Add("priority", priority);
return(BEncode.ByteArrayEncode(rootNode));
}
/// <summary>
/// 建立连接包
/// </summary>
/// <returns></returns>
private byte[] BuildHandshakeMessage()
{
DictNode node = new DictNode();
node.Add("port", clientPort);
node.Add("key", key);
node.Add("iv", iv);
return(BEncode.ByteArrayEncode(node));
}
/// <summary>
/// 创建SQL文本的命令
/// </summary>
/// <param name="node">待解析的节点</param>
/// <returns>返回SQL文本的命令</returns>
internal static DbCommand CreateTextCommand(DictNode node)
{
DbCommand result = new SqlCommand();
string cmdText = ((BytesNode)node["text"]).StringText;
result.CommandText = cmdText;
result.CommandType = CommandType.Text;
return(result);
}
public override object ExecuteScalar()
{
DictNode contentNode = new DictNode();
contentNode.Add("action", 5);
byte[] sendMsg = BuildMessage(contentNode);
connection.SendPacket(sendMsg);
byte[] rcvMsg = connection.ReceivePacket();
return(DecodeScalar(rcvMsg));
}
public override int ExecuteNonQuery()
{
DictNode contentNode = new DictNode();
contentNode.Add("action", 3);
byte[] sendMsg = BuildMessage(contentNode);
connection.SendPacket(sendMsg);
byte[] rcvMsg = connection.ReceivePacket();
return(DecodeNonQuery(rcvMsg));
}
public T Lookup(char[] key)
{
DictNode dn = LookupImpl(key);
if (dn == null)
{
return(default(T));
}
return(dn.Value);
}
private void HandleParmsNode(BEncodedNode parmlistNode)
{
ListNode parmsNode = (ListNode)parmlistNode;
foreach (BEncodedNode node in parmsNode)
{
DictNode parmNode = (DictNode)node;
string name = ((BytesNode)parmNode["name"]).StringText;
string typeName = ((BytesNode)parmNode["type"]).StringText;
parameters[name].Value = NodeEncoder.GetObject(typeName, (BytesNode)parmNode["value"]);
}
}
public new DbProxyDataReader ExecuteReader()
{
DbProxyDataReader result = new DbProxyDataReader(this);
DictNode contentNode = new DictNode();
contentNode.Add("action", 4);
byte[] sendMsg = BuildMessage(contentNode);
connection.SendPacket(sendMsg);
byte[] rcvMsg = connection.ReceivePacket();
DecodeReader(rcvMsg, result.SchemaTable);
return(result);
}
/// <summary>
/// 创建类型节点
/// </summary>
/// <param name="rdr">数据库读取器</param>
/// <returns>返回类型节点</returns>
private ListNode CreateTypeListNode(IDataRecord rdr)
{
ListNode result = new ListNode();
for (int i = 0; i < rdr.FieldCount; i++)
{
DictNode columnNode = new DictNode();
columnNode.Add("name", rdr.GetName(i));
columnNode.Add("type", rdr.GetDataTypeName(i));
result.Add(columnNode);
}
return(result);
}
/// <summary>
/// 创建Scalar返回值节点
/// </summary>
/// <param name="obj">Scalar返回值</param>
/// <returns>返回Scalar返回值节点</returns>
private BEncodedNode CreateItemNode(object obj)
{
string typeName = obj != null?obj.GetType().ToString() : typeof(object).ToString();
BytesNode valueNode = obj != null
? typeName != "System.Byte[]" ? new BytesNode(obj.ToString()) : (byte[])obj
: BytesNode.NullBytesNode;
DictNode result = new DictNode();
result.Add("type", typeName);
result.Add("value", valueNode);
return(result);
}
/// <summary>
/// 处理Reader函数
/// </summary>
/// <param name="cmd">数据库命令</param>
public DictNode HandleReader(DbCommand cmd)
{
DictNode result = new DictNode();
using (DbConnection conn = new SqlConnection(connectionString))
{
conn.Open();
cmd.Connection = conn;
using (DbDataReader rdr = cmd.ExecuteReader(CommandBehavior.CloseConnection))
{
ListNode typeListNode = CreateTypeListNode(rdr);
result.Add("typelist", typeListNode);
ListNode itemsNode = new ListNode();
while (rdr.Read())
{
ListNode itemNode = new ListNode();
for (int i = 0; i < rdr.FieldCount; i++)
{
if (rdr.IsDBNull(i))
{
itemNode.Add(BytesNode.NullBytesNode);
}
else
{
if (IsBinaryType(rdr.GetDataTypeName(i)))
{
itemNode.Add((byte[])rdr.GetValue(i));
}
else
{
itemNode.Add(rdr.GetValue(i).ToString());
}
}
}
itemsNode.Add(itemNode);
}
result.Add("items", itemsNode);
}
}
result.Add("code", 2);
ListNode parmlistNode = CreateParmListNode(cmd);
if (parmlistNode.Count != 0)
{
result.Add("parmlist", parmlistNode);
}
return(result);
}
private byte[] BuildMessage(DictNode contentNode)
{
switch (commandType)
{
case CommandType.Text:
contentNode.Add("type", TextNum);
return(BuildTextMessage(contentNode));
case CommandType.StoredProcedure:
contentNode.Add("type", ProcNum);
return(BuildProcMessage(contentNode));
}
throw new DbProxyException("建立传输数据出错!");
}
/// <summary>
/// 交互函数
/// </summary>
/// <param name="stateInfo"></param>
internal void Exchange(object stateInfo)
{
try
{
isClose = false;
do
{
byte[] rcvMsg = handler.ReceiveSealedPacket();
DictNode responseNode = HandlePacket(rcvMsg);
byte[] sndMsg = BEncode.ByteArrayEncode(responseNode);
handler.SendSealedPacket(sndMsg);
if (isClose)
{
return;
}
} while (true);
}
catch (TdsException te)
{
Console.WriteLine("Tds Exception:{0}", te.Message);
}
catch (PacketException pe)
{
Console.WriteLine("Packet Exception:{0}", pe.Message);
}
catch (IOException ioe)
{
Console.WriteLine("IO Exception:{0}", ioe.Message);
}
catch (SocketException se)
{
Console.WriteLine("Socket Exception:{0}", se.Message);
}
catch (BEncodingException bee)
{
Console.WriteLine("BEncoding Exception:{0}", bee.Message);
}
finally
{
monitor.Unregister(handler);
handler.Close();
}
}
// Adds a word into the data structure.
public void AddWord(String word)
{
DictNode node = root;
foreach (var c in word)
{
int index = c - 'a';
if (node.children[index] == null)
{
node.children[index] = new DictNode();
}
node = node.children[index];
}
node.isWord = true;
}
/// <summary>
/// 生成存储过程发送的字节流
/// </summary>
/// <returns>返回发送的字节流</returns>
private byte[] BuildProcMessage(DictNode contentNode)
{
contentNode.Add("text", commandText);
//建立参数列表
if (parameters.Count != 0)
{
ListNode parmsNode = new ListNode();
foreach (DbProxyParameter para in parameters)
{
DictNode parmNode = new DictNode();
parmNode.Add("name", para.ParameterName);
parmNode.Add("type", (int)para.DbType);
switch (para.Direction)
{
case ParameterDirection.Input:
parmNode.Add("value", NodeEncoder.GetValueNode(para));
break;
case ParameterDirection.Output:
parmNode.Add("direction", OutputNum);
break;
case ParameterDirection.InputOutput:
parmNode.Add("direction", InputOutputNum);
parmNode.Add("value", NodeEncoder.GetValueNode(para));
break;
case ParameterDirection.ReturnValue:
parmNode.Add("direction", ReturnValueNum);
break;
}
if (para.Size != 0)
{
parmNode.Add("size", para.Size);
}
parmsNode.Add(parmNode);
}
contentNode.Add("parms", parmsNode);
}
return(BEncode.ByteArrayEncode(contentNode));
}
private void LookupTolerantImpl(DictNode cur, MatchCandidate mc)
{
if (cur.Children == null)
{
return;
}
//System.Diagnostics.Trace.WriteLine("--------------------------");
//System.Diagnostics.Trace.WriteLine(string.Format("Processing children for word {0}", mc.Word));
for (byte childPos = 0; childPos < cur.Children.Length; childPos++)
{
DictNode child = cur.Children[childPos];
DoKeyMatching(child, 0, mc);
}
//System.Diagnostics.Trace.WriteLine(string.Format("Completed processing node children for word {0}", mc.Word));
//System.Diagnostics.Trace.WriteLine("--------------------------");
}
/// <summary>
/// Simple, efficient method for exact lookup in the radix
/// </summary>
/// <param name="key"></param>
/// <returns></returns>
private DictNode LookupImpl(char[] key)
{
byte keyPos = 0, n;
int keyLength = GetCharArrayLength(key);
DictNode cur = m_root;
while (cur != null && cur.Children != null)
{
for (byte childPos = 0; ; childPos++)
{
DictNode child = cur.Children[childPos];
// Do key matching
n = 0;
while (n < child.Key.Length && keyPos < keyLength && child.Key[n] == key[keyPos])
{
keyPos++;
n++;
}
if (n == child.Key.Length) // We consumed the child's key, and so far it matches our key
{
// We consumed both the child's key and the requested key, meaning we found the requested node
if (keyLength == keyPos)
{
return(child);
}
// We consumed this child's key, but the key we are looking for isn't over yet
else if (keyLength > keyPos)
{
cur = child;
break;
}
}
else if (n > 0 || // Incomplete match to child's key (worths nothing)
childPos + 1 == cur.Children.Length // We looked at all the node's children
)
{
return(null);
}
}
}
return(null);
}
/// <summary>
/// Get the list of peers
/// </summary>
/// <param name="node">The response node that received from tracker</param>
/// <returns>Return the list of peers</returns>
private List <Peer> GetPeers(DictNode node)
{
List <Peer> peers = new List <Peer>();
BEncodedNode peersNode = node["peers"];
if (peersNode is BytesNode)
{
var peersBytes = ((BytesNode)peersNode).ByteArray;
for (int i = 0; i < peersBytes.Length; i += 6)
{
string host = string.Format("{0}.{1}.{2}.{3}", peersBytes[i], peersBytes[i + 1], peersBytes[i + 2],
peersBytes[i + 3]);
int port = (peersBytes[i + 4] << 8) + peersBytes[i + 5];
Peer peer = new Peer
{
Host = host,
Port = port,
};
peers.Add(peer);
}
}
else if (peersNode is ListNode)
{
var listNode = peersNode as ListNode;
for (int i = 0; i < listNode.Count; i++)
{
DictNode dictNode = listNode[i] as DictNode;
string peerId = ((BytesNode)dictNode["peer id"]).StringText;
string ip = ((BytesNode)dictNode["ip"]).StringText;
int port = ((IntNode)dictNode["port"]).IntValue;
Peer peer = new Peer
{
Host = ip,
Port = port
};
peers.Add(peer);
}
}
return(peers);
}
/// <summary>
/// 创建存储过程的命令
/// </summary>
/// <param name="node">待解析的节点</param>
/// <returns>返回存储过程的命令</returns>
internal static DbCommand CreateProcCommand(DictNode node)
{
DbCommand result = new SqlCommand();
string cmdText = ((BytesNode)node["text"]).StringText;
result.CommandText = cmdText;
result.CommandType = CommandType.StoredProcedure;
if (node.ContainsKey("parms"))
{
ListNode parmsNode = ((ListNode)node["parms"]);
foreach (BEncodedNode parmNode in parmsNode)
{
DictNode dictNode = (DictNode)parmNode;
result.Parameters.Add(CreateParm(dictNode));
}
}
return(result);
}
/// <summary>
/// 检验打开数据包
/// </summary>
/// <param name="packet">打开数据包</param>
/// <returns>如果打开成功,返回ture,否则返回false</returns>
private bool CheckOpenPacket(byte[] packet)
{
DictNode openPacket = (DictNode)BEncode.Decode(packet);
int code = ((IntNode)openPacket["code"]).Value;
switch (code)
{
case 1:
byte[] key = ((BytesNode)openPacket["key"]).ByteArray;
byte[] iv = ((BytesNode)openPacket["iv"]).ByteArray;
handler.SetKeyIV(key, iv);
return(true);
case 6:
string messag = ((BytesNode)openPacket["message"]).StringText;
throw new DbProxyException(messag);
default:
throw new DbProxyException("错误的消息代码");
}
}
public void TestEncodeHandler1()
{
FileStream sourceFile = File.OpenRead(@"E:\Bittorrent\Torrents\winedt70.exe.torrent");
byte[] source = new byte[sourceFile.Length];
sourceFile.Read(source, 0, (int)sourceFile.Length);
sourceFile.Close();
DictNode dh = (DictNode)BEncodingFactory.Decode(source);
byte[] destion = BEncodingFactory.ByteArrayEncode(dh);
FileStream targetFile = File.OpenWrite(@"E:\Bittorrent\Torrents\test.torrent");
targetFile.Write(destion, 0, destion.Length);
int i;
for (i = 0; i < source.Length; i++)
{
Assert.AreEqual(source[i], destion[i]);
}
targetFile.Close();
}
/// <summary>
/// 检验打开数据包
/// </summary>
/// <param name="packet">打开数据包</param>
/// <param name="key">密钥</param>
/// <param name="iv">初始化向量</param>
/// <param name="error">错误信息</param>
/// <returns>如果打开成功,返回ture,否则返回false</returns>
private bool CheckOpenPacket(byte[] packet, out byte[] key, out byte[] iv, out string error)
{
key = null;
iv = null;
port = -1;
error = string.Empty;
try
{
DictNode node = (DictNode)BEncode.Decode(packet);
if (node.ContainsKey("key") && node.ContainsKey("iv"))
{
key = ((BytesNode)node["key"]).ByteArray;
iv = ((BytesNode)node["iv"]).ByteArray;
return(true);
}
error = "数据包不包含密钥或者初始化向量或者端口信息!";
}
catch (BEncodingException bee)
{
error = bee.Message;
}
return(false);
}
