/// <summary> /// 创建参数 /// </summary> /// <param name="parmNode">待解析的节点</param> /// <returns>返回创建的参数</returns> private static DbParameter CreateParm(DictNode parmNode) { SqlParameter parm = new SqlParameter(); parm.ParameterName = ((BytesNode)parmNode["name"]).StringText; parm.DbType = (DbType)((IntNode)parmNode["type"]).Value; if (parmNode.ContainsKey("size")) { parm.Size = ((IntNode)parmNode["size"]).Value; } if (parmNode.ContainsKey("direction")) { ParameterDirection direction = (ParameterDirection)((IntNode)parmNode["direction"]).Value; switch (direction) { case ParameterDirection.Input: case ParameterDirection.InputOutput: parm.Direction = direction; parm.Value = GetObject(parm.DbType, (BytesNode)parmNode["value"]); break; case ParameterDirection.Output: case ParameterDirection.ReturnValue: parm.Direction = direction; break; } } else { parm.Value = GetObject(parm.DbType, (BytesNode)parmNode["value"]); } return(parm); }
/// <summary> /// 处理打开数据包 /// </summary> /// <param name="packet">打开数据包</param> /// <param name="ipAddress">IP地址</param> /// <param name="error">错误信息</param> /// <returns>返回是否成功打开连接</returns> private bool HandleOpenPacket(byte[] packet, string ipAddress, out string error) { string deviceId = string.Empty; DictNode openNode = (DictNode)BEncode.Decode(packet); if (openNode.ContainsKey("deviceid")) { deviceId = ((BytesNode)openNode["deviceid"]).StringText; } else { error = "不包含机构号"; return(false); } if (openNode.ContainsKey("priority")) { int priority = (byte)((IntNode)openNode["priority"]).Value; if (priority > 4 || priority < 0) { error = "优先级错误"; return(false); } } else { error = "不包含优先级"; return(false); } bool result = Validate(deviceId, ipAddress, out error); return(result); }
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)); } }
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)); } }
/// <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); }
/// <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); }
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(); }
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); }