public static Torrent LoadFromFile(string filePath, string downloadPath) { var obj = BEncoding.DecodeFile(filePath); var name = Path.GetFileNameWithoutExtension(filePath); return(BEncodingObjectToTorrent(obj, name, downloadPath)); }
public void DecodeExistingFile() { BEncoding decoding = new BEncoding(Tools.GetTestDataFilePath("ubuntu-15.04-desktop-amd64.iso.torrent")); BEncodedDictionary values = (BEncodedDictionary)decoding.Decode(); Assert.AreEqual("http://torrent.ubuntu.com:6969/announce", values["announce"].ToString()); }
private void DecodeByteArray_ReturnTrue() { var testcase = "5:hello"; var bytes = GetBytes(testcase); var decodedResult = BEncoding.DecodeNextObject(GetIterator(bytes)) as byte[]; var decodedStr = GetString(decodedResult); Debug.Assert(decodedStr == "hello"); }
/// <summary> /// Charge un torrent depuis un fichier /// </summary> /// <param name="path"></param> public Torrent(string path) : this() { BEncoding decoding = new BEncoding(path); _data = (BEncodedDictionary)decoding.Decode(); //charge le torrent depuis les données récupérés LoadTorrent(); }
private static CBORObject EncodingFromBytes(byte[] b) { try { using (var s = new MemoryStream(b)) { return(BEncoding.Read(s)); } } catch (IOException ex) { throw new CBORException(String.Empty, ex); } }
/// <summary> /// Saves this torrent information to a file on disk. /// </summary> /// <param name="filePath">The path to the file to create.</param> public void SaveToFile(string filePath) { if (filePath == null) { throw new ArgumentNullException("filePath"); } var torrentInfo = Save(); BEncoding.EncodeToFile(torrentInfo, filePath); }
public void CheckFileTypeTorrent() { try { BEncoding encoding = new BEncoding("fichierquiexistepas.torrent"); Assert.Fail("An exception should have been thrown"); } catch (FileNotFoundException ex) { Assert.AreEqual("The given file was not found.", ex.Message); } catch (Exception ex) { Assert.Fail(string.Format("Unexpected exception of type {0} caught: {1}", ex.GetType(), ex.Message)); } }
private void DecodeInt_ReturnTrue() { var testcase = 2331; var bytes = GetBytes($"i{testcase}e"); var resObj = BEncoding.DecodeNextObject(GetIterator(bytes)); Debug.Assert(resObj is long); var intVal = (long)resObj; Debug.Assert(intVal == 2331); }
private static InfoHash ComputeInfoHash(BEncoding.Dictionary info) { using (var stream = new MemoryStream()) { BEncoding.Encode(info, stream); stream.Seek(0L, SeekOrigin.Begin); byte[] hash = HashHelper.ComputeSHA1(stream); return(new InfoHash(hash)); } }
private static byte[] EncodingToBytes(CBORObject b) { try { using (var ms = new MemoryStream()) { BEncoding.Write(b, ms); return(ms.ToArray()); } } catch (IOException ex) { throw new CBORException(String.Empty, ex); } }
/// <summary> /// Makes an announce request to this tracker. /// </summary> /// <param name="request">The announce request object.</param> /// <returns>The announce response.</returns> public override async Task <AnnounceResponse> Announce(AnnounceRequest request) { if (request == null) { throw new ArgumentNullException("request"); } // Check if announces are allowed if (announceUri == null) { return(null); } try { Uri uri = request.GetUri(announceUri, key, trackerID); byte[] responseBytes = await client.GetByteArrayAsync(uri).ConfigureAwait(false); Stats.IncreaseDownloadedBytes(responseBytes.Length); var info = BEncoding.Decode(responseBytes) as BEncoding.Dictionary; if (info == null) { status = TrackerStatus.InvalidResponse; failureMessage = "The tracker returned an invalid announce response."; return(null); } var announceResponse = HandleAnnounceResponse(info); if (announceResponse == null) { status = TrackerStatus.InvalidResponse; failureMessage = "The tracker returned an invalid announce response."; return(null); } failureMessage = announceResponse.FailureReason; warningMessage = announceResponse.WarningMessage; status = TrackerStatus.OK; return(announceResponse); } catch (HttpRequestException ex) { status = TrackerStatus.Offline; failureMessage = string.Format("Failed to perform announce request: {0}", ex.Message); return(null); } catch (Exception ex) { status = TrackerStatus.InvalidResponse; failureMessage = string.Format("Exception performing announce request: {0}", ex.Message); return(null); } }
/// <summary> /// Makes a scrape request to this tracker. /// </summary> /// <param name="infoHashes">The optional array of info hashes. Can be null or empty.</param> /// <returns>The announce response.</returns> public override async Task <ScrapeResponse> Scrape(InfoHash[] infoHashes) { if (infoHashes == null) { throw new ArgumentNullException("infoHashes"); } // Check if scrapes are allowed if (scrapeUri == null) { return(null); } try { var queryParameters = new KeyValuePair <string, object> [infoHashes.Length]; for (int i = 0; i < infoHashes.Length; i++) { queryParameters[i] = new KeyValuePair <string, object>("info_hash", infoHashes[i].ToUrlEncodedString()); } var uri = UriHelper.AppendQueryString(scrapeUri, queryParameters); byte[] responseBytes = await client.GetByteArrayAsync(uri).ConfigureAwait(false); Stats.IncreaseDownloadedBytes(responseBytes.Length); var info = BEncoding.Decode(responseBytes) as BEncoding.Dictionary; if (info == null) { failureMessage = "The tracker returned an invalid scrape response."; return(null); } var scrapeResponse = HandleScrapeResponse(info); if (scrapeResponse == null) { failureMessage = "The tracker returned an invalid scrape response."; return(null); } return(scrapeResponse); } catch (HttpRequestException ex) { failureMessage = string.Format("Failed to perform scrape request: {0}", ex.Message); return(null); } catch (Exception ex) { failureMessage = string.Format("Exception performing scrape request: {0}", ex.Message); return(null); } }
/// <summary> /// Saves this torrent information to a stream. /// </summary> /// <param name="stream">The stream to save to.</param> public void SaveToStream(Stream stream) { if (stream == null) { throw new ArgumentNullException("stream"); } else if (!stream.CanWrite) { throw new ArgumentException("The stream cannot be written to.", "stream"); } var torrentInfo = Save(); BEncoding.Encode(torrentInfo, stream); }
/// <summary> /// Loads torrent information from a torrent file on disk. /// </summary> /// <param name="filePath">The path to the torrent file.</param> public void LoadFromFile(string filePath) { if (filePath == null) { throw new ArgumentNullException("filePath"); } var torrentInfo = BEncoding.DecodeFromFile(filePath) as BEncoding.Dictionary; if (torrentInfo == null) { throw new InvalidDataException("The specified file does not appear to include torrent information."); } Load(torrentInfo); }
/// <summary> /// Loads torrent information from a stream. /// </summary> /// <param name="stream">The stream to load the torrent from.</param> public void LoadFromStream(Stream stream) { if (stream == null) { throw new ArgumentNullException("stream"); } else if (!stream.CanRead) { throw new ArgumentException("The stream cannot be read from.", "stream"); } var torrentInfo = BEncoding.Decode(stream) as BEncoding.Dictionary; if (torrentInfo == null) { throw new InvalidDataException("The specified file does not appear to include torrent information."); } Load(torrentInfo); }
private void DecodeDictionary_ReturnTrue() { var authorInfo = "i'am"; var infoVal = 331; var testcase = $"d4:infoi{infoVal}e6:author{authorInfo.Length}:{authorInfo}"; var bytes = GetBytes(testcase); var result = BEncoding.DecodeNextObject(GetIterator(bytes)); Debug.Assert(result is IDictionary <string, object>); var dict = result as IDictionary <string, object>; Debug.Assert(dict.Keys.Contains("info")); Debug.Assert(dict.Keys.Contains("author")); Debug.Assert((long)dict["info"] == 331); var authorBytes = GetBytes(authorInfo); var resultAuthor = (byte[])dict["author"]; Debug.Assert(resultAuthor.Length == authorBytes.Length); Debug.Assert(authorBytes.SequenceEqual(resultAuthor)); }
public void CheckFileTypeNotTorrent() { BEncoding encoding = new BEncoding("fichierquiexistepas.extension"); }
public void CheckFileExists() { BEncoding encoding = new BEncoding("fichierquiexistepas.torrent"); }
public static void SafeToFile(Torrent torrent) { var obj = TorrentToBEncodingObject(torrent); BEncoding.EncodeToFile(obj, $"{torrent.Name}.{TORRENT_EXTENSION_FILE}"); }
/// <summary> /// /// </summary> public void Request() { string encoded_hash = Torrent.GetEncodedInfoHash(); //construction de la requête vers le tracker StringBuilder builder = new StringBuilder(Tracker.Url); builder.AppendFormat("?info_hash={0}", encoded_hash); builder.Append("&peer_id=adkiepeycosozpsngtoi"); builder.Append("&uploaded=0"); builder.Append("&downloaded=0"); builder.AppendFormat("&compact={0}", Compact ? 1 : 0); builder.Append("&left=120000"); builder.Append("&event=started"); builder.Append("&port=6881"); //création de la requête GET HttpWebRequest request = (HttpWebRequest)WebRequest.Create(builder.ToString()); request.Method = "GET"; //envoi de la requête using (WebResponse response = request.GetResponse()) { //récupération de la réponse using (Stream stream = response.GetResponseStream()) { using (var reader = new StreamReader(stream, Encoding.Default)) { string responseText = reader.ReadToEnd(); byte[] data = Encoding.Default.GetBytes(responseText); BEncoding encoding = new BEncoding(data); BEncodedDictionary dictionary = (BEncodedDictionary)encoding.Decode(); Complete = (BEncodedInteger)dictionary["complete"]; Incomplete = (BEncodedInteger)dictionary["incomplete"]; Interval = (BEncodedInteger)dictionary["interval"]; // la liste des peers peut être soit une liste, soit une chaine simplifiée en big endian if (dictionary["peers"] is BEncodedList) { BEncodedList peers = (BEncodedList)dictionary["peers"]; } else if (dictionary["peers"] is BEncodedString) { byte[] peers = Encoding.Default.GetBytes((BEncodedString)dictionary["peers"]); for (int i = 0; i < peers.Length; i = i + 6) { byte[] ip = new byte[4]; byte[] port = new byte[2]; Array.Copy(peers, i, ip, 0, 4); Array.Copy(peers, i + 4, port, 0, 2); Array.Reverse(port); IPEndPoint ipEndPoint = new IPEndPoint(new IPAddress(ip), BitConverter.ToUInt16(port, 0)); Peer peer = new Peer(ipEndPoint); Peers.Add(peer); } } } } } }
public void CheckFilePathEmpty() { BEncoding encoding = new BEncoding(string.Empty); }
public void CheckDataEmpty() { BEncoding encoding = new BEncoding(new byte[0]); }
public Torrent(string name, string downloadDir, List <FileItem> files, List <string> trackers, int pieceSize, byte[] pieceHashes = null, int blockSize = 16384, bool?isPrivate = false) { Name = name; DownloadDirectory = downloadDir; Files = files; PieceSize = pieceSize; BlockSize = blockSize; IsPrivate = isPrivate; fileWriteLocks = new object[Files.Count]; for (var i = 0; i < Files.Count; ++i) { fileWriteLocks[i] = new object(); } if (trackers != null) { foreach (var url in trackers) { var tracker = new Tracker(url); Trackers.Add(tracker); tracker.PeerListUpdated += HandlePeerListUpdated; } } var piecesCount = Convert.ToInt32(Math.Ceiling(TotalSize / Convert.ToDouble(PieceSize))); PieceHashes = new byte[piecesCount][]; IsPieceVerified = new bool[piecesCount]; IsBlockAcquired = new bool[piecesCount][]; for (var i = 0; i < PieceCount; ++i) { IsBlockAcquired[i] = new bool[GetBlockCount(i)]; } if (pieceHashes != null) { for (var i = 0; i < PieceCount; ++i) { PieceHashes[i] = GetHash(i); } } else { for (var i = 0; i < PieceCount; ++i) { PieceHashes[i] = new byte[20]; Buffer.BlockCopy(pieceHashes, i * 20, PieceHashes[i], 0, 20); } } object info = TorrentInfoToBEncodingObject(this); byte[] bytes = BEncoding.Encode(info); InfoHash = SHA1.Create().ComputeHash(bytes); for (var i = 0; i < PieceCount; ++i) { CheckIntegrityOfPiece(i); } }