private object DecodeScalar(byte[] content)
{
DictNode rootNode = (DictNode)BEncode.Decode(content);
IntNode codeNode = (IntNode)rootNode["code"];
switch (codeNode.Value)
{
case 1:
case 2:
throw new DbProxyException("数据集收到的数据包出错!");
case 3:
DictNode itemNode = (DictNode)rootNode["item"];
string typeName = ((BytesNode)itemNode["type"]).StringText;
string value = ((BytesNode)itemNode["value"]).StringText;
if (rootNode.ContainsKey("parmlist"))
{
HandleParmsNode((rootNode)["parmlist"]);
}
return(NodeEncoder.GetObject(typeName, value));
case 4:
BytesNode messageNode = (BytesNode)rootNode["message"];
throw new DbProxyException(messageNode.StringText);
case 5:
throw new DbProxyException("校验出错!");
default:
throw new DbProxyException(string.Format("无效消息代码:{0}!", codeNode.Value));
}
}
public void TestEncodeByteArray1()
{
//Test1标点符号
BytesNode bah1 = new BytesNode("~!@#$%^&*()_+|`-=\\{}:\"<>?[];',./");
string source1 = BEncode.StringEncode(bah1);
Assert.AreEqual("32:~!@#$%^&*()_+|`-=\\{}:\"<>?[];',./", source1);
//Test2空字符
BytesNode bah2 = new BytesNode("");
string source2 = BEncode.StringEncode(bah2);
Assert.AreEqual(source2, "0:");
//Test3英文字母与数字
BytesNode bah3 = new BytesNode("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789");
string source3 = BEncode.StringEncode(bah3);
Assert.AreEqual(source3, "62:abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789");
//Test4中文字体与全角标点符号
BytesNode bah4 = new BytesNode("微软公司，广州大学");
string source4 = BEncode.StringEncode(bah4);
Assert.AreEqual("18:微软公司，广州大学", source4);
//Test5全角的数字与英文字母
BytesNode bah5 = new BytesNode("ａｂｃｄｅｆｇｈｉｊｋｌｍｎｏｐｑｒｓｔｕｖｗｘｙｚＡＢＣＤＥＦＧＨＩＪＫＬＭＮＯＰＱＲＳＴＵＶＷＸＹＺ０１２３４５６７８９");
string source5 = BEncode.StringEncode(bah5);
Assert.AreEqual("124:ａｂｃｄｅｆｇｈｉｊｋｌｍｎｏｐｑｒｓｔｕｖｗｘｙｚＡＢＣＤＥＦＧＨＩＪＫＬＭＮＯＰＱＲＳＴＵＶＷＸＹＺ０１２３４５６７８９", source5);
}
private int DecodeNonQuery(byte[] content)
{
DictNode rootNode = (DictNode)BEncode.Decode(content);
IntNode codeNode = (IntNode)rootNode["code"];
switch (codeNode.Value)
{
case 1:
IntNode lineNode = (IntNode)rootNode["linenum"];
if (rootNode.ContainsKey("parmlist"))
{
HandleParmsNode((rootNode)["parmlist"]);
}
return(lineNode.Value);
case 2:
case 3:
throw new DbProxyException("数据集收到的数据包出错!");
case 4:
BytesNode messageNode = (BytesNode)rootNode["message"];
throw new DbProxyException(messageNode.StringText);
case 5:
throw new DbProxyException("校验出错!");
default:
throw new DbProxyException(string.Format("无效消息代码:{0}!", codeNode.Value));
}
}
public void TestDecodeByteArray1()
{
//Test1
BytesNode bah1 = (BytesNode)BEncode.Decode("10:0123456789");
Assert.AreEqual(bah1.ByteArray, Encoding.Default.GetBytes("0123456789"));
Assert.AreEqual(bah1.StringText, "0123456789");
//Test2
BytesNode bah2 = (BytesNode)BEncode.Decode("26:abcdefghijklmnopqrstuvwxyz");
Assert.AreEqual(bah2.ByteArray, Encoding.Default.GetBytes("abcdefghijklmnopqrstuvwxyz"));
Assert.AreEqual(bah2.StringText, "abcdefghijklmnopqrstuvwxyz");
//Test3
BytesNode bah3 = (BytesNode)BEncode.Decode("124:ａｂｃｄｅｆｇｈｉｊｋｌｍｎｏｐｑｒｓｔｕｖｗｘｙｚＡＢＣＤＥＦＧＨＩＪＫＬＭＮＯＰＱＲＳＴＵＶＷＸＹＺ０１２３４５６７８９");
Assert.AreEqual(Encoding.Default.GetBytes("ａｂｃｄｅｆｇｈｉｊｋｌｍｎｏｐｑｒｓｔｕｖｗｘｙｚＡＢＣＤＥＦＧＨＩＪＫＬＭＮＯＰＱＲＳＴＵＶＷＸＹＺ０１２３４５６７８９"), bah3.ByteArray);
Assert.AreEqual("ａｂｃｄｅｆｇｈｉｊｋｌｍｎｏｐｑｒｓｔｕｖｗｘｙｚＡＢＣＤＥＦＧＨＩＪＫＬＭＮＯＰＱＲＳＴＵＶＷＸＹＺ０１２３４５６７８９", bah3.StringText);
//Test4
BytesNode bah4 = (BytesNode)BEncode.Decode("0:");
Assert.AreEqual(bah4.ByteArray, Encoding.Default.GetBytes(string.Empty));
Assert.AreEqual(bah4.StringText, string.Empty);
}
/// <summary>
/// 获取参数的数值
/// </summary>
/// <param name="type">参数的类型</param>
/// <param name="valueNode">待解析的节点</param>
/// <returns>返回参数的数值</returns>
private static object GetObject(DbType type, BytesNode valueNode)
{
string valueStr = valueNode.StringText;
if (valueStr == null)
{
return(DBNull.Value);
}
switch (type)
{
case DbType.AnsiString:
case DbType.AnsiStringFixedLength:
return(valueStr);
case DbType.Byte:
return(byte.Parse(valueStr));
case DbType.SByte:
return(sbyte.Parse(valueStr));
case DbType.UInt16:
return(ushort.Parse(valueStr));
case DbType.Int16:
return(short.Parse(valueStr));
case DbType.UInt32:
return(uint.Parse(valueStr));
case DbType.Int32:
return(int.Parse(valueStr));
case DbType.UInt64:
return(ulong.Parse(valueStr));
case DbType.Int64:
return(long.Parse(valueStr));
case DbType.Single:
return(float.Parse(valueStr));
case DbType.Double:
return(double.Parse(valueStr));
case DbType.Decimal:
return(decimal.Parse(valueStr));
case DbType.DateTime:
return(DateTime.Parse(valueStr));
case DbType.Binary:
return(valueNode.ByteArray);
default:
throw new NotSupportedException(string.Format("不支持该类型数据:{0}", type));
}
}
/// <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);
}
private void DecodeReader(byte[] content, DataTable table)
{
DictNode rootNode = (DictNode)BEncode.Decode(content);
IntNode codeNode = (IntNode)rootNode["code"];
switch (codeNode.Value)
{
case 1:
case 3:
throw new DbProxyException("数据集收到的数据包出错!");
case 4:
BytesNode messageNode = (BytesNode)rootNode["message"];
throw new DbProxyException(messageNode.StringText);
case 5:
throw new DbProxyException("校验出错!");
}
//解码类型表
ListNode typelistNode = (ListNode)rootNode["typelist"];
table.BeginInit();
table.BeginLoadData();
foreach (BEncodedNode node in typelistNode)
{
BytesNode nameNode = (BytesNode)(((DictNode)node)["name"]);
BytesNode typeNode = (BytesNode)(((DictNode)node)["type"]);
DataColumn column = new DataColumn(nameNode.StringText);
column.DataType = types[typeNode.StringText];
table.Columns.Add(column);
}
//解码数据集
ListNode itemsNode = (ListNode)rootNode["items"];
for (int i = 0; i < itemsNode.Count; i++)
{
ListNode itemNode = (ListNode)itemsNode[i];
DataRow row = table.NewRow();
for (int j = 0; j < itemNode.Count; j++)
{
Type type = table.Columns[j].DataType;
string valueStr = ((BytesNode)itemNode[j]).StringText;
if (valueStr == null)
{
row[j] = DBNull.Value;
}
else if (type == typeof(string))
{
row[j] = valueStr;
}
else if (type == typeof(byte))
{
row[j] = byte.Parse(valueStr);
}
else if (type == typeof(sbyte))
{
row[j] = sbyte.Parse(valueStr);
}
else if (type == typeof(ushort))
{
row[j] = ushort.Parse(valueStr);
}
else if (type == typeof(short))
{
row[j] = short.Parse(valueStr);
}
else if (type == typeof(uint))
{
row[j] = uint.Parse(valueStr);
}
else if (type == typeof(int))
{
row[j] = int.Parse(valueStr);
}
else if (type == typeof(ulong))
{
row[j] = ulong.Parse(valueStr);
}
else if (type == typeof(long))
{
row[j] = long.Parse(valueStr);
}
else if (type == typeof(byte[]))
{
row[j] = ((BytesNode)itemNode[j]).ByteArray;
}
else if (type == typeof(DateTime))
{
row[j] = DateTime.Parse(valueStr);
}
else if (type == typeof(float))
{
row[j] = float.Parse(valueStr);
}
else if (type == typeof(double))
{
row[j] = double.Parse(valueStr);
}
else if (type == typeof(decimal))
{
row[j] = decimal.Parse(valueStr);
}
}
table.Rows.Add(row);
}
if (rootNode.ContainsKey("parmlist"))
{
HandleParmsNode((rootNode)["parmlist"]);
}
table.EndLoadData();
table.EndInit();
}
internal static object GetObject(string typeName, BytesNode valueNode)
{
if (typeName == "System.Byte[]")
{
return(valueNode.ByteArray);
}
if (typeName == "System.DBNull")
{
return(DBNull.Value);
}
string value = valueNode.StringText;
switch (typeName)
{
case "System.String":
return(value);
case "System.Byte":
return(byte.Parse(value));
case "System.SByte":
return(sbyte.Parse(value));
case "System.UInt16":
return(ushort.Parse(value));
case "System.Int16":
return(short.Parse(value));
case "System.UInt32":
return(uint.Parse(value));
case "System.Int32":
return(int.Parse(value));
case "System.UInt64":
return(ulong.Parse(value));
case "System.Int64":
return(long.Parse(value));
case "System.DateTime":
return(DateTime.Parse(value));
case "System.Single":
return(float.Parse(value));
case "System.Double":
return(double.Parse(value));
case "System.Decimal":
return(decimal.Parse(value));
case "System.Object":
return(value);
default:
throw new NotSupportedException(string.Format("不支持该类型:{0}的数据", typeName));
}
}
public static void StartDownload(Parameters parameters, Flag doneFlag, StatusDelegate statusFunction, ErrorDelegate errorFunction, FinishedDelegate finishedFunction)
{
if (parameters.ResponseFile.Length == 0 && parameters.Url.Length == 0)
{
throw new BitTorrentException("需要Response file 或者 Url");
}
Parameters = parameters;
Stream stream = null;
byte[] response;
long length = 0;
try
{
if (parameters.ResponseFile.Length != 0)
{
stream = File.OpenRead(parameters.ResponseFile);
length = stream.Length;
}
else
{
WebRequest webRequest = WebRequest.Create(parameters.Url);
WebResponse webResponse = webRequest.GetResponse();
stream = webResponse.GetResponseStream();
length = webResponse.ContentLength;
}
response = new byte[length];
stream.Read(response, 0, (int)length);
}
catch
{
throw new BitTorrentException("Problem getting response info");
}
finally
{
if (stream != null)
{
stream.Close();
}
}
DictNode rootNode;
try
{
rootNode = BEncodingFactory.Decode(response) as DictNode;
//BTFormat.CheckMessage(rootNode);
}
catch
{
throw new BitTorrentException("got bad file");
}
DictNode infoNode = rootNode["info"] as DictNode;
List <BitFile> files = new List <BitFile>();
string file;
long fileLength;
try
{
if (infoNode.ContainsKey("length"))
{
fileLength = (infoNode["length"] as IntNode).Value;
BytesNode nameNode = (infoNode["name"] as BytesNode);
if (nameNode == null)
{
return;
}
file = @"k:\torrent\" + nameNode.StringText;
Make(file, false);
files.Add(new BitFile(file, fileLength));
}
else
{
fileLength = 0L;
ListNode filesNode = infoNode["files"] as ListNode;
foreach (BEncodedNode handler in filesNode)
{
DictNode fileNode = infoNode["files"] as DictNode;
fileLength += (fileNode["length"] as IntNode).Value;
}
//访问文件夹
BytesNode nameNode = infoNode["name"] as BytesNode;
if (nameNode == null)
{
return;
}
file = @"C:\torrent\" + nameNode.StringText;
// if this path exists, and no files from the info dict exist, we assume it's a new download and
// the user wants to create a new directory with the default name
bool existed = false;
if (Directory.Exists(file))
{
foreach (BEncodedNode handler in filesNode)
{
DictNode fileNode = handler as DictNode;
ListNode pathNode = fileNode["path"] as ListNode;
if (File.Exists(Path.Combine(file, (pathNode[0] as BytesNode).StringText)))
{
existed = true;
break;
}
}
if (!existed)
{
file = Path.Combine(file, (infoNode["name"] as BytesNode).StringText);
}
}
Make(file, true);
// alert the UI to any possible change in path
//TODO: if (pathFunc != null)
// pathFunc(file)
foreach (BEncodedNode handler in filesNode)
{
DictNode fileNode = handler as DictNode;
ListNode pathNode = fileNode["path"] as ListNode;
string n = file;
foreach (BEncodedNode stringHandler in pathNode)
{
n = Path.Combine(n, (stringHandler as BytesNode).StringText);
}
files.Add(new BitFile(n, (fileNode["length"] as IntNode).Value));
Make(n, false);
}
}
}
catch
{
throw new BitTorrentException("Couldn't allocate directory...");
}
Flag finishFlag = new Flag();
FinishedHelper finishedHelper = new FinishedHelper();
finishedHelper.ErrorFunction = errorFunction;
finishedHelper.FinishedFunction = finishedFunction;
finishedHelper.DoneFlag = finishFlag;
string sID = DateTime.Now.ToLongDateString() + "www.wallywood.co.uk";
byte[] myID = Globals.GetSha1Hash(Encoding.ASCII.GetBytes(sID));//Globals.Sha1.ComputeHash(Encoding.Default.GetBytes(sID));
byte[] piece = (infoNode["pieces"] as BytesNode).ByteArray;
List <byte[]> pieces = new List <byte[]>();
for (int i = 0; i < piece.Length; i += 20)
{
byte[] temp = new byte[20];
Buffer.BlockCopy(piece, i, temp, 0, 20);
pieces.Add(temp);
}
Storage _storage = null;
try
{
try
{
//_storage = new Storage(files, parameters.AllocatePause, statusFunction);
finishedHelper.Storage = _storage;
}
catch (Exception ex)
{
errorFunction("trouble accessing files - " + ex.Message);
}
IntNode pieceLengthNode = infoNode["piece length"] as IntNode;
StorageWrapper = new StorageWrapper(_storage, parameters.DownloadSliceSize, pieces, (int)pieceLengthNode.Value,
finishedHelper.Finished, finishedHelper.Failed, statusFunction, finishFlag, parameters.CheckHashes,
finishedHelper.DataFlunked);
}
// Catch ValueError
// failed("bad data")
// catch IO Error
catch (Exception ex)
{
finishedHelper.Failed("Problem - " + ex.Message);
}
if (finishFlag.IsSet)
{
return;
}
RawServer rawServer = new RawServer(finishFlag, parameters.TimeoutCheckInterval, parameters.Timeout, false);
if (parameters.MaxPort < parameters.MinPort)
{
int temp = parameters.MinPort;
parameters.MinPort = parameters.MaxPort;
parameters.MaxPort = parameters.MinPort;
}
ushort listenPort;
for (listenPort = parameters.MinPort; listenPort <= parameters.MaxPort; listenPort++)
{
try
{
rawServer.Bind(listenPort, parameters.Bind, false);
break;
}
catch (SocketException)
{
//TODO: Error Code
}
}
//TODO: Check whether nothing bound
Choker = new Choker(parameters.MaxUploads, rawServer.AddTask, finishFlag);
Measure uploadMeasure = new Measure(parameters.MaxRatePeriod, parameters.UploadRateFudge);
Measure downloadMeasure = new Measure(parameters.MaxRatePeriod);
RateMeasure rateMeasure = new RateMeasure(StorageWrapper.LeftLength);
Downloader downloader =
new NormalDownloader(StorageWrapper, new PiecePicker(pieces.Count), parameters.RequestBackLog,
parameters.MaxRatePeriod, pieces.Count, downloadMeasure, parameters.SnubTime,
rateMeasure.DataCameIn);
Connecter connecter =
new Connecter(downloader, Choker, pieces.Count, StorageWrapper.IsEverythingPending, uploadMeasure,
parameters.MaxUploadRate << 10, rawServer.AddTask);
byte[] infoHash = Globals.GetSha1Hash(BEncodingFactory.ByteArrayEncode(infoNode));//Globals.Sha1.ComputeHash(BEncodingFactory.ByteArrayEncode(infoNode));
Encrypter encrypter = new Encrypter(connecter, rawServer, myID, parameters.MaxMessageLength, rawServer.AddTask,
parameters.KeepAliveInterval, infoHash, parameters.MaxInitiate);
//ReRequester reRequester =
// new ReRequester((rootNode["announce"] as BytesNode).StringText, parameters.RerequestInterval,
// rawServer.AddTask, connecter.GetConnectionsCount, parameters.MinPeers,
// encrypter.StartConnect, rawServer.AddExternalTask,
// StorageWrapper.GetLeftLength, uploadMeasure.GetTotalLength, downloadMeasure.GetTotalLength,
// listenPort, parameters.IP,
// myID, infoHash, parameters.HttpTimeout, null, parameters.MaxInitiate, finishFlag);
DownloaderFeedback downloaderFeedback =
new DownloaderFeedback(Choker, rawServer.AddTask, statusFunction, uploadMeasure.GetUpdatedRate,
downloadMeasure.GetUpdatedRate, rateMeasure.GetTimeLeft, rateMeasure.GetLeftTime,
fileLength, finishFlag, parameters.DisplayInterval,
parameters.Spew);
statusFunction("connection to peers", -1, -1, -1, -1);
//TODO: finishedHelper.errorfunc
finishedHelper.FinishFlag = finishFlag;
//finishedHelper.ReRequester = reRequester;
finishedHelper.RateMeasure = rateMeasure;
//reRequester.d(0);
rawServer.ListenForever(encrypter);
//reRequester.Announce(2, null);
}
/// <summary>
/// Parse the BEncoded message
/// </summary>
/// <param name="node">Tracker response BEncoded node</param>
/// <returns>return the AnnounceResponse class</returns>
private AnnounceResponse Parse(DictNode node)
{
AnnounceResponse result = new AnnounceResponse();
Debug.Assert(node != null);
//Get failure reason
if (node.ContainsKey("failure reason"))
{
BytesNode failureReasonNode = node["failure reason"] as BytesNode;
Debug.Assert(failureReasonNode != null);
result.FailureReason = failureReasonNode.StringText;
}
else
{
result.FailureReason = string.Empty;
}
//Get warning message
if (node.ContainsKey("warning message"))
{
BytesNode warningMessageNode = node["warning message"] as BytesNode;
Debug.Assert(warningMessageNode != null);
result.WarningMessage = warningMessageNode.StringText;
}
else
{
result.WarningMessage = string.Empty;
}
//Get interval
if (node.ContainsKey("interval"))
{
IntNode intervalNode = node["interval"] as IntNode;
Debug.Assert(intervalNode != null);
result.Interval = intervalNode.IntValue;
}
else
{
result.Interval = Setting.MaxInterval;
}
//Get min interval
if (node.ContainsKey("min interval"))
{
IntNode minIntervalNode = node["min interval"] as IntNode;
Debug.Assert(minIntervalNode != null);
result.MinInterval = minIntervalNode.IntValue;
}
else
{
result.MinInterval = result.Interval;
}
//Get tracker id
if (node.ContainsKey("tracker id"))
{
BytesNode trackerIdNode = node["tracker id"] as BytesNode;
Debug.Assert(trackerIdNode != null);
result.TrackerId = trackerIdNode.StringText;
}
else
{
result.TrackerId = string.Empty;
}
//Get complete
if (node.ContainsKey("complete"))
{
IntNode completeNode = node["complete"] as IntNode;
Debug.Assert(completeNode != null);
result.Complete = completeNode.IntValue;
}
else
{
result.Complete = 0;
}
//Get incomplete
if (node.ContainsKey("incomplete"))
{
IntNode incompleteNode = node["incomplete"] as IntNode;
Debug.Assert(incompleteNode != null);
result.Incomplete = incompleteNode.IntValue;
}
else
{
result.Incomplete = 0;
}
//Get peers
result.Peers = GetPeers(node);
return(result);
}
