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("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"); string source5 = BEncode.StringEncode(bah5); Assert.AreEqual("124:abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789", 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:abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"); Assert.AreEqual(Encoding.Default.GetBytes("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"), bah3.ByteArray); Assert.AreEqual("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789", 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); }