public void BStringCompareNull() { BString a = new BString(""); BString other = null; int result = a.CompareTo(other); }
public void EncodeString() { BString testString = new BString("Hello World"); string test = BencodingUtils.EncodeString(testString); Assert.AreEqual("11:Hello World", test); }
public void EqualityList() { // Make initial list BList testList = new BList(); BString testString = new BString("Hello World"); BInt testInt = new BInt(5); testList.Add(testString); testList.Add(testInt); // Make test list BList testList2 = new BList(); BString testString2 = new BString("Hello World"); BInt testInt2 = new BInt(5); testList2.Add(testString2); testList2.Add(testInt2); // Test equality recursive Assert.AreEqual(testList, testList2); // Test null list BList nullList = null; Assert.IsFalse(testList.Equals(nullList)); // Test different counts testList2.Add(new BInt(10)); Assert.IsFalse(testList.Equals(testList2)); // Test different values testList.Add(new BInt(9)); Assert.IsFalse(testList.Equals(testList2)); }
public void Encode_ISO88591() { var encoding = Encoding.GetEncoding("ISO-8859-1"); var bstring = new BString("æøå äö èéê ñ", encoding); Assert.AreEqual("12:æøå äö èéê ñ", bstring.Encode()); Assert.AreEqual("12:æøå äö èéê ñ", bstring.Encode(encoding)); Assert.AreEqual(bstring.Encode(), bstring.Encode(encoding)); }
public void Encode_ISO88591_WithoutSpecifyingEncoding() { var encoding = Encoding.GetEncoding("ISO-8859-1"); var bytes = encoding.GetBytes("æøå äö èéê ñ"); var bstring = new BString(bytes); Assert.AreNotEqual("12:æøå äö èéê ñ", bstring.Encode()); Assert.AreEqual("12:æøå äö èéê ñ", bstring.Encode(encoding)); Assert.AreNotEqual(bstring.Encode(), bstring.Encode(encoding)); }
public void CanEncode_ISO88591() { var encoding = Encoding.GetEncoding("ISO-8859-1"); var bstring = new BString("æøå äö èéê ñ", encoding); var bencode = bstring.EncodeAsString(encoding); bencode.Should().Be("12:æøå äö èéê ñ"); }
public void CanEncode_ISO88591_WithoutSpecifyingEncoding() { var encoding = Encoding.GetEncoding("ISO-8859-1"); var bytes = encoding.GetBytes("æøå äö èéê ñ"); var bstring = new BString(bytes); var bencode = bstring.EncodeAsString(encoding); bencode.Should().Be("12:æøå äö èéê ñ"); }
public void CanEncodeToStream() { var bstring = new BString("hello world"); using (var stream = new MemoryStream()) { bstring.EncodeTo(stream); stream.Length.Should().Be(14); stream.AsString().Should().Be("11:hello world"); } }
public void CanParseSimple(string bencode, IBencodeParser bparser) { var key = new BString("key"); var value = new BString("value"); SetupBencodeParser(bparser, bencode, key, value, hasEndChar:true); var parser = new BDictionaryParser(bparser); var bdictionary = parser.ParseString(bencode); bdictionary.Count.Should().Be(1); bdictionary.Should().ContainKey(key); bdictionary[key].Should().BeSameAs(value); }
public void EncodeList() { BList testList = new BList(); BString testString = new BString("Hello World"); BInt testInt = new BInt(5); testList.Add(testString); testList.Add(testInt); string test = BencodingUtils.EncodeString(testList); Assert.AreEqual("l11:Hello Worldi5ee", test); }
public void EncodeDictionary() { BDict testDict = new BDict(); BString testString = new BString("Hello World"); BInt testInt = new BInt(5); testDict.Add("a", testString); testDict.Add("b", testInt); string test = BencodingUtils.EncodeString(testDict); Assert.AreEqual("d1:a11:Hello World1:bi5ee", test); }
public void BStringCompare() { for (char a = 'A'; a < 'Z'; a++) { for (char b = 'A'; b < 'Z'; b++) { string strA = a.ToString(); string strB = b.ToString(); BString bStrA = new BString(strA); BString bStrB = new BString(strB); Assert.AreEqual(strA.CompareTo(strB), bStrA.CompareTo(bStrB)); } } }
private static void SetupBencodeParser(IBencodeParser bparser, string bencode, BString key, IBObject value, bool hasEndChar) { bparser.Parse<BString>(Arg.Any<BencodeStream>()) .Returns(key); bparser.Parse(Arg.Any<BencodeStream>()) .Returns(value) .AndDoes(x => { // Set stream position to end of list, skipping all "parsed" content var stream = x.Arg<BencodeStream>(); stream.Position += Math.Max(1, bencode.Length - 1); if (hasEndChar) stream.Position--; }); }
public void EqualityDict() { // Make initial dict BDict testDict = new BDict(); BString testString = new BString("Hello World"); BInt testInt = new BInt(5); testDict.Add("a", testString); testDict.Add("b", testInt); // Make test dict BDict testDict2 = new BDict(); BString testString2 = new BString("Hello World"); BInt testInt2 = new BInt(5); testDict2.Add("a", testString2); testDict2.Add("b", testInt2); // Test equality recursive Assert.AreEqual(testDict, testDict2); // Test null dict BDict nullDict = null; Assert.IsFalse(testDict.Equals(nullDict)); // Test different counts testDict2.Add("c", new BInt(10)); Assert.IsFalse(testDict.Equals(testDict2)); // Test different values testDict.Add("c", new BInt(9)); Assert.IsFalse(testDict.Equals(testDict2)); // Test missing keys testDict2.Remove("c"); testDict2.Add("d", new BInt(9)); Assert.IsFalse(testDict.Equals(testDict2)); }
public void EqualsBString() { var bstring1 = new BString("Test String"); var bstring2 = new BString("Test String"); Assert.AreEqual(bstring1, bstring2); }
/// <summary> /// Background thread handling all incoming traffic /// </summary> private void ReceivePackets() { while (true) { try { // Get a datagram receiveFrom = new IPEndPoint(IPAddress.Any, localPort); // Stopwatch sw = new Stopwatch(); // sw.Start(); byte[] data = udpClientReceive.Receive(ref receiveFrom); //if (sw.ElapsedMilliseconds > 10) { Console.WriteLine(sw.ElapsedMilliseconds); } //sw.Stop(); // Decode the message Stream stream = new MemoryStream(data); IBencodingType receivedMsg = BencodingUtils.Decode(stream); string decoded = BencodingUtils.ExtendedASCIIEncoding.GetString(data.ToArray()); //Log("Received message!"); // t is transaction id // y is e for error, r for reply, q for query if (receivedMsg is BDict) // throws error.. todo: fix { BDict dictMsg = (BDict)receivedMsg; if (dictMsg.ContainsKey("y")) { if (dictMsg["y"].Equals(new BString("e"))) { //Log("Received error! (ignored)"); } else if (dictMsg["y"].Equals(new BString("r"))) { // received reply if (dictMsg.ContainsKey("r")) { if (dictMsg["r"] is BDict) { BDict dictMsg2 = (BDict)dictMsg["r"]; if (dictMsg2.ContainsKey("values")) { //Log("Received list of peers for torrent!"); countRecvPeerPackets++; } else if (dictMsg2.ContainsKey("nodes")) { // could be an answer to find node or get peers //Log("Received list of nodeID & IP & port!"); countRecvNodePackets++; BString nodeIDString = (BString)dictMsg2["nodes"]; UpdateContactList(nodeIDString); } else { // no values and no nodes, assuming its a ping, // at least some form of response } } else { } } } else if (dictMsg["y"].Equals(new BString("q"))) { // received query countRecvQuery++; //Log("Received query! (ignored)"); } } } } catch (Exception ex) { //Log("Error receiving data: " + ex.ToString()); } } }
public void Encode_Simple() { var bstring = new BString("Test String"); Assert.AreEqual("11:Test String", bstring.Encode()); }
public void BStringHashcode() { BString a = new BString("testHashCode"); Assert.AreEqual("testHashCode".GetHashCode(), a.GetHashCode()); }
public void EqualsOperator_String_WithSameContentAreEqual(string str1, string str2) { var bstring = new BString(str1); (bstring == str2).Should().BeTrue(); }
void multiFileTorrent(BDictionary info, TorrentCreationViewModel vm, List<FileInfo> files) { BList filesList = new BList(); foreach (FileInfo file in files) { BDictionary fileDictionary = new BDictionary(); fileDictionary["length"] = new BInteger(file.Length); BList pathList = new BList(); String relativePath = file.FullName.Remove(0, vm.PathRoot.Length); foreach (String elem in relativePath.Split(new char[] { '\\' })) { if (!String.IsNullOrEmpty(elem)) { pathList.Add(elem); } } fileDictionary["path"] = pathList; filesList.Add(fileDictionary); } info["name"] = new BString(vm.TorrentName); info["files"] = filesList; }
public void DuplicateKey_ThrowsInvalidBencodeException(IBencodeParser bparser, BString someKey, BString someValue) { bparser.Parse <BString>(Arg.Any <BencodeReader>()).Returns(someKey, someKey); bparser.Parse(Arg.Any <BencodeReader>()).Returns(someValue); var parser = new BDictionaryParser(bparser); Action action = () => parser.ParseString("di42ee"); action.Should().Throw <InvalidBencodeException <BDictionary> >().WithMessage("*The dictionary already contains the key*"); }
public void SetTransaction(BString transactionId, DHTMessage message) { int tid = BitConverter.ToInt16(transactionId.Value, 0); fTransactions[tid] = message; }
public void SendAnnouncePeerQuery(IPEndPoint address, byte[] infoHash, byte implied_port, int port, BString token) { DHTNode node = fRoutingTable.FindNode(address); if (node != null) { long nowTicks = DateTime.Now.Ticks; if (nowTicks - node.LastAnnouncementTime < AnnounceLife.Ticks) { return; } node.LastAnnouncementTime = nowTicks; // TODO: update announce by timer, every 30m } var transactionID = DHTHelper.GetTransactionId(); byte[] nid = fLocalID; BDictionary sendData = DHTMessage.CreateAnnouncePeerQuery(transactionID, nid, infoHash, implied_port, port, token); SetTransaction(transactionID, new DHTMessage(MsgType.query, QueryType.announce_peer, sendData)); Send(address, sendData); }
/// <summary> /// Converts nodeID from BString to displayable hex string /// </summary> /// <param name="nodeID"></param> /// <returns></returns> private string BStringToHexNodeID(BString nodeID) { string hex = BitConverter.ToString(BencodingUtils.ExtendedASCIIEncoding.GetBytes(nodeID.Value)); return(hex.Replace("-", "")); }
/// <summary> /// Background thread handling all incoming traffic /// </summary> private void ReceivePackets() { while (true) { try { // Get a datagram receiveFrom = new IPEndPoint(IPAddress.Any, localPort); byte[] data = udpClient.Receive(ref receiveFrom); // Decode the message Stream stream = new MemoryStream(data); IBencodingType receivedMsg = BencodingUtils.Decode(stream); string decoded = BencodingUtils.ExtendedASCIIEncoding.GetString(data.ToArray()); Log("Received message!"); //Log(decoded); // t is transaction id : todo: check, since ports are reused // y is e for error, r for reply, q for query if (receivedMsg is BDict) // throws error.. todo: fix { BDict dictMsg = (BDict)receivedMsg; if (dictMsg.ContainsKey("y")) { if (dictMsg["y"].Equals(new BString("e"))) { // received error Log("Received error! (ignored)"); } else if (dictMsg["y"].Equals(new BString("r"))) { // received reply if (dictMsg.ContainsKey("r")) { if (dictMsg["r"] is BDict) { BDict dictMsg2 = (BDict)dictMsg["r"]; if (dictMsg2.ContainsKey("values") && dictMsg.ContainsKey("t")) { Log("Received list of peers for torrent!"); countRecvPeerPackets++; BList peerAdrs = (BList)dictMsg2["values"]; UpdateTorrentPeerList(peerAdrs, (BString)dictMsg["t"]); } else if (dictMsg2.ContainsKey("nodes") && dictMsg.ContainsKey("t")) { // could be an answer to find node or get peers Log("Received list of nodeID & IP & port!"); countRecvNodePackets++; BString nodeIDString = (BString)dictMsg2["nodes"]; UpdateContactList(nodeIDString, (BString)dictMsg["t"]); } else { } } else { } } } else if (dictMsg["y"].Equals(new BString("q"))) { // received query Log("Received query! (ignored)"); } } } } catch (Exception ex) { Log("Error receiving data: " + ex.ToString()); } } }
public void MissingEndChar_ThrowsInvalidBencodeExceptionAsync(string bencode, IBencodeParser bparser, BString someKey, IBObject someValue) { // Arrange bparser.ParseAsync <BString>(Arg.Any <PipeBencodeReader>()) .Returns(someKey); bparser.ParseAsync(Arg.Any <PipeBencodeReader>()) .Returns(someValue) .AndSkipsAheadAsync(bencode.Length - 1); // Act var parser = new BDictionaryParser(bparser); Func <Task> action = async() => await parser.ParseStringAsync(bencode); // Assert action.Should().Throw <InvalidBencodeException <BDictionary> >().WithMessage("*Missing end character of object*"); }
public void DuplicateKey_ThrowsInvalidBencodeExceptionAsync(IBencodeParser bparser, BString someKey, BString someValue) { bparser.ParseAsync <BString>(Arg.Any <PipeBencodeReader>()).Returns(someKey, someKey); bparser.ParseAsync(Arg.Any <PipeBencodeReader>()).Returns(someValue); var parser = new BDictionaryParser(bparser); Func <Task> action = async() => await parser.ParseStringAsync("di42ee"); action.Should().Throw <InvalidBencodeException <BDictionary> >().WithMessage("*The dictionary already contains the key*"); }
public void InvalidValue_ThrowsInvalidBencodeExceptionAsync(IBencodeParser bparser, BString someKey) { bparser.ParseAsync <BString>(Arg.Any <PipeBencodeReader>()).Returns(someKey); bparser.ParseAsync(Arg.Any <PipeBencodeReader>()).Throws <BencodeException>(); var parser = new BDictionaryParser(bparser); Func <Task> action = async() => await parser.ParseStringAsync("di42ee"); action.Should().Throw <InvalidBencodeException <BDictionary> >().WithMessage("*Could not parse dictionary value*"); }
public void Encoding_DefaultIsUTF8() { var bstring = new BString("foo"); bstring.Encoding.Should().Be(Encoding.UTF8); }
static void HandleMessage(BDictionary message, TcpClient client) { var opValue = message["op"]; var opString = opValue as BString; var autoCompletionSupportEnabled = RT.booleanCast(((IPersistentMap)configVar.invoke()).valAt(Keyword.intern("nrepl-auto-completion"))); if (opString != null) { var session = GetSession(message); switch (opString.ToString()) { case "clone": var newSession = CloneSession(session); SendMessage( new BDictionary { { "id", message["id"] }, { "status", new BList { "done" } }, { "new-session", newSession.ToString() } }, client); break; case "describe": // TODO include arcadia version var clojureVersion = (IPersistentMap)RT.var("clojure.core", "*clojure-version*").deref(); var clojureMajor = (int)clojureVersion.valAt(Keyword.intern("major")); var clojureMinor = (int)clojureVersion.valAt(Keyword.intern("minor")); var clojureIncremental = (int)clojureVersion.valAt(Keyword.intern("incremental")); var clojureQualifier = (string)clojureVersion.valAt(Keyword.intern("qualifier")); var supportedOps = new BDictionary { { "eval", 1 }, { "load-file", 1 }, { "describe", 1 }, { "clone", 1 }, { "info", 1 }, { "eldoc", 1 }, { "classpath", 1 }, }; // Debug.Log("Autocomplete support is enabled?: " + autoCompletionSupportEnabled); if (autoCompletionSupportEnabled) { supportedOps.Add("complete", 1); } SendMessage( new BDictionary { { "id", message["id"] }, { "session", session.ToString() }, { "status", new BList { "done" } }, { "ops", supportedOps }, { "versions", new BDictionary { { "clojure", new BDictionary { { "major", clojureMajor }, { "minor", clojureMinor }, { "incremental", clojureIncremental }, { "qualifier", clojureQualifier } } }, { "nrepl", new BDictionary { { "major", 0 }, { "minor", 2 }, { "incremental", 3 } } } } } }, client); break; case "eval": var fn = new EvalFn(message, client); fn.invoke(); break; case "load-file": message["code"] = new BString("(do " + message["file"].ToString() + " )"); var loadFn = new EvalFn(message, client); loadFn.invoke(); break; case "eldoc": case "info": String symbolStr = message["symbol"].ToString(); // Editors like Calva that support doc-on-hover sometimes will ask about empty strings or spaces if (symbolStr == "" || symbolStr == null || symbolStr == " ") { break; } IPersistentMap symbolMetadata = null; try { symbolMetadata = (IPersistentMap)metaVar.invoke(nsResolveVar.invoke( findNsVar.invoke(symbolVar.invoke(message["ns"].ToString())), symbolVar.invoke(symbolStr))); } catch (TypeNotFoundException) { // We'll just ignore this call if the type cannot be found. This happens sometimes. // TODO: One particular case when this happens is when querying info for a namespace. // That case should be handled separately (e.g., via `find-ns`?) } if (symbolMetadata != null) { var resultMessage = new BDictionary { { "id", message["id"] }, { "session", session.ToString() }, { "status", new BList { "done" } } }; foreach (var entry in symbolMetadata) { if (entry.val() != null) { String keyStr = entry.key().ToString().Substring(1); String keyVal = entry.val().ToString(); if (keyStr == "arglists") { keyStr = "arglists-str"; } if (keyStr == "forms") { keyStr = "forms-str"; } resultMessage[keyStr] = new BString(keyVal); } } SendMessage(resultMessage, client); } else { SendMessage( new BDictionary { { "id", message["id"] }, { "session", session.ToString() }, { "status", new BList { "done", "no-info" } } }, client); } break; case "complete": // When autoCompletionSupportEnabled is false, we don't advertise auto-completion support. // some editors seem to ignore this and request anyway, so we return an unknown op message. if (!autoCompletionSupportEnabled) { SendMessage( new BDictionary { { "id", message["id"] }, { "session", session.ToString() }, { "status", new BList { "done", "error", "unknown-op" } } }, client); break; } Namespace ns = Namespace.find(Symbol.create(message["ns"].ToString())); var sessionBindings = _sessions[session]; var completeBindings = sessionBindings; if (ns != null) { completeBindings = completeBindings.assoc(RT.CurrentNSVar, ns); } // Make sure to eval this in the right namespace Var.pushThreadBindings(completeBindings); BList completions = (BList)completeVar.invoke(message["symbol"].ToString()); Var.popThreadBindings(); SendMessage(new BDictionary { { "id", message["id"] }, { "session", session.ToString() }, { "status", new BList { "done" } }, { "completions", completions } }, client); break; case "classpath": BList classpath = new BList(); foreach (String p in Environment.GetEnvironmentVariable("CLOJURE_LOAD_PATH").Split(System.IO.Path.PathSeparator)) { if (p != "") { classpath.Add(Path.GetFullPath(p)); } } SendMessage(new BDictionary { { "id", message["id"] }, { "session", session.ToString() }, { "status", new BList { "done" } }, { "classpath", classpath }, }, client); break; default: SendMessage( new BDictionary { { "id", message["id"] }, { "session", session.ToString() }, { "status", new BList { "done", "error", "unknown-op" } } }, client); break; } } }
void singleFileTorrent(BDictionary info, FileInfo file) { info["name"] = new BString(file.Name); info["length"] = new BInteger(file.Length); }
public bool Load(Stream stream) { _root = BencodingUtils.Decode(stream); if (_root == null) { return(false); } BDict dictRoot = (_root as BDict); if (dictRoot == null) { return(false); } if (dictRoot.ContainsKey("announce")) { Announce = (BString)dictRoot["announce"]; } if (dictRoot.ContainsKey("announce-list")) { BList announceList = (BList)dictRoot["announce-list"]; foreach (IBencodingType type in announceList) { if (type is BString) { AnnounceList.Add(type as BString); } else { BList list = type as BList; if (list == null) { continue; } BList listType = list; foreach (IBencodingType bencodingType in listType) { BString s = (BString)bencodingType; AnnounceList.Add(s); } } } } if (dictRoot.ContainsKey("comment")) { Comment = (BString)dictRoot["comment"]; } if (dictRoot.ContainsKey("created by")) { CreatedBy = (BString)dictRoot["created by"]; } if (dictRoot.ContainsKey("creation date")) { long ts = (BInt)dictRoot["creation date"]; CreationDate = new DateTime(1970, 1, 1).AddSeconds(ts); } if (dictRoot.ContainsKey("info")) { BDict infoDict = (BDict)dictRoot["info"]; using (SHA1Managed sha1 = new SHA1Managed()) { byte[] str = BencodingUtils.EncodeBytes(infoDict); Hash = sha1.ComputeHash(str); } if (infoDict.ContainsKey("files")) { //multi file mode BList fileList = (BList)infoDict["files"]; foreach (IBencodingType bencodingType in fileList) { BDict fileDict = (BDict)bencodingType; String filename = string.Empty; Int64 filesize = default(Int64); if (fileDict.ContainsKey("path")) { BList filenameList = (BList)fileDict["path"]; foreach (IBencodingType type in filenameList) { filename += (BString)type; filename += "\\"; } filename = filename.Trim('\\'); } if (fileDict.ContainsKey("length")) { filesize = (BInt)fileDict["length"]; } Files.Add(filename, filesize); } } if (infoDict.ContainsKey("name")) { Name = (BString)infoDict["name"]; if (Files.Count == 0 && infoDict.ContainsKey("length")) { Files.Add(Name, (BInt)infoDict["length"]); } } if (infoDict.ContainsKey("private")) { BInt isPrivate = (BInt)infoDict["private"]; Private = isPrivate != 0; } if (infoDict.ContainsKey("pieces")) { BString pieces = (BString)infoDict["pieces"]; for (int x = 0; x < pieces.ByteValue.Length; x += 20) { byte[] hash = pieces.ByteValue.GetBytes(x, 20); PieceHashes.Add(hash); } } if (infoDict.ContainsKey("piece length")) { PieceSize = (BInt)infoDict["piece length"]; } } return(true); }
void createTorrent(TorrentCreationViewModel vm) { /* info: a dictionary that describes the file(s) of the torrent. There are two possible forms: one for the case of a 'single-file' torrent with no directory structure, and one for the case of a 'multi-file' torrent (see below for details) announce: The announce URL of the tracker (string) announce-list: (optional) this is an extention to the official specification, offering backwards-compatibility. (list of lists of strings). The official request for a specification change is here. creation date: (optional) the creation time of the torrent, in standard UNIX epoch format (integer, seconds since 1-Jan-1970 00:00:00 UTC) comment: (optional) free-form textual comments of the author (string) created by: (optional) name and version of the program used to create the .torrent (string) encoding: (optional) the string encoding format used to generate the pieces part of the info dictionary in the .torrent metafile (string) */ BDictionary info = new BDictionary(); info["pieces"] = new BString(buildPiecesHash(vm.Media)); info["piece length"] = new BInteger(pieceLength); info["private"] = new BInteger(vm.IsPrivate ? 1 : 0); if (vm.Media.Count == 1) { singleFileTorrent(info, new FileInfo(vm.Media.ElementAt(0).Location)); } else { List<FileInfo> fileInfo = new List<FileInfo>(); foreach (MediaFileItem item in vm.Media) { fileInfo.Add(new FileInfo(item.Location)); } multiFileTorrent(info, vm, fileInfo); } BDictionary metaInfo = new BDictionary(); metaInfo["info"] = info; metaInfo["announce"] = new BString(vm.AnnounceURL); metaInfo["creation date"] = new BInteger((long)(DateTime.Now - new DateTime(1970, 1, 1)).TotalSeconds); metaInfo["created by"] = new BString(createdBy); if (!String.IsNullOrEmpty(vm.Comment) && !String.IsNullOrWhiteSpace(vm.Comment) && vm.IsCommentEnabled) { metaInfo["comment"] = new BString(vm.Comment); } if (!String.IsNullOrEmpty(encoding) && !String.IsNullOrWhiteSpace(encoding) && vm.IsCommentEnabled) { metaInfo["encoding"] = new BString(encoding); } String torrentName = String.IsNullOrEmpty(vm.TorrentName) ? Path.GetFileNameWithoutExtension(vm.Media.ElementAt(0).Location) : vm.TorrentName; String torrentFullName = vm.OutputPath + "\\" + torrentName + ".torrent"; if (CancellationToken.IsCancellationRequested) return; FileStream outputTorrent = null; try { outputTorrent = new FileStream(torrentFullName, FileMode.CreateNew); BinaryWriter bw = new BinaryWriter(outputTorrent); foreach (char c in metaInfo.ToBencodedString()) { bw.Write((byte)c); } InfoMessages.Add("Created torrent file: " + torrentFullName); } finally { if (outputTorrent != null) { outputTorrent.Close(); } } }
public void HashCodesAreNotEqual() { var bstring = new BString("Test String"); Assert.AreNotEqual(bstring.GetHashCode(), new BString("Test Strin").GetHashCode()); Assert.AreNotEqual(bstring.GetHashCode(), new BString("Test Strin ").GetHashCode()); Assert.AreNotEqual(bstring.GetHashCode(), new BString("Test String ").GetHashCode()); Assert.AreNotEqual(bstring.GetHashCode(), new BString("Test String2").GetHashCode()); Assert.AreNotEqual(bstring.GetHashCode(), new BString("Test StrinG").GetHashCode()); Assert.AreNotEqual(bstring.GetHashCode(), new BString("test string").GetHashCode()); Assert.AreNotEqual(bstring.GetHashCode(), new BString("TestString").GetHashCode()); Assert.AreNotEqual(bstring.GetHashCode(), new BString("teststring").GetHashCode()); Assert.AreNotEqual(bstring.GetHashCode(), new BString("TøstStrøng").GetHashCode()); }
private void OnRecvFindNodeResponse(DHTNode remoteNode, BString nodesStr) { // according to bep_0005, find_node response contain a list of nodes ProcessNodesStr(remoteNode, nodesStr); }
public void Encode_EmptyString() { var bstring = new BString(""); Assert.AreEqual("0:", bstring.Encode()); }
public void InvalidValue_ThrowsInvalidBencodeException(IBencodeParser bparser, BString someKey) { bparser.Parse <BString>(Arg.Any <BencodeReader>()).Returns(someKey); bparser.Parse(Arg.Any <BencodeReader>()).Throws <BencodeException>(); var parser = new BDictionaryParser(bparser); Action action = () => parser.ParseString("di42ee"); action.Should().Throw <InvalidBencodeException <BDictionary> >().WithMessage("*Could not parse dictionary value*"); }
public void ConstructorWithNullValue_ResultsInEmptyValue() { var bstring = new BString((string)null); bstring.Value.ToArray().Should().BeEmpty(); }
internal void SendAnnouncePeerQuery(DHTNode remoteNode, DHTId infoHash, byte implied_port, int port, BString token) { if (remoteNode == null || token == null || token.Length == 0) { return; } long nowTicks = DateTime.UtcNow.Ticks; if (nowTicks - remoteNode.LastAnnouncementTime < AnnounceLife.Ticks) { return; } remoteNode.LastAnnouncementTime = nowTicks; #if DEBUG_DHT_INTERNALS fLogger.WriteDebug("Send announce peer query {0}, {1}, {2}", remoteNode.EndPoint, implied_port, port); #endif // https://www.bittorrent.org/beps/bep_0005.html // If implied_port (0/1) is present and non-zero, the port argument should be ignored // and the source port of the UDP packet should be used as the peer's port instead. var transactionID = DHTTransactions.GetNextId(); var msg = DHTMessage.CreateAnnouncePeerQuery(transactionID, fLocalID, infoHash, implied_port, port, token); fTransactions.SetQuery(transactionID, msg); Send(remoteNode.EndPoint, msg); }
static void HandleMessage(BDictionary message, TcpClient client) { var opValue = message["op"]; var opString = opValue as BString; if (opString != null) { var session = GetSession(message); switch (opString.ToString()) { case "clone": var newSession = CloneSession(session); SendMessage( new BDictionary { { "id", message["id"] }, { "status", new BList { "done" } }, { "new-session", newSession.ToString() } }, client); break; case "describe": // TODO include arcadia version var clojureVersion = (IPersistentMap)RT.var("clojure.core", "*clojure-version*").deref(); var clojureMajor = (int)clojureVersion.valAt(Keyword.intern("major")); var clojureMinor = (int)clojureVersion.valAt(Keyword.intern("minor")); var clojureIncremental = (int)clojureVersion.valAt(Keyword.intern("incremental")); var clojureQualifier = (string)clojureVersion.valAt(Keyword.intern("qualifier")); SendMessage( new BDictionary { { "id", message["id"] }, { "session", session.ToString() }, { "status", new BList { "done" } }, { "ops", new BDictionary { { "eval", 1 }, { "load-file", 1 }, { "describe", 1 }, { "clone", 1 }, { "info", 1 }, } }, { "versions", new BDictionary { { "clojure", new BDictionary { { "major", clojureMajor }, { "minor", clojureMinor }, { "incremental", clojureIncremental }, { "qualifier", clojureQualifier } } }, { "nrepl", new BDictionary { { "major", 0 }, { "minor", 2 }, { "incremental", 3 } } } } } }, client); break; case "eval": var fn = new EvalFn(message, client); addCallbackVar.invoke(fn); break; case "load-file": message["code"] = new BString("(do " + message["file"].ToString() + " )"); var loadFn = new EvalFn(message, client); addCallbackVar.invoke(loadFn); break; case "info": var symbolMetadata = (IPersistentMap)metaVar.invoke(nsResolveVar.invoke( findNsVar.invoke(symbolVar.invoke(message["ns"].ToString())), symbolVar.invoke(message["symbol"].ToString()))); if (symbolMetadata != null) { var resultMessage = new BDictionary { { "id", message["id"] }, { "session", session.ToString() }, { "status", new BList { "done" } } }; foreach (var entry in symbolMetadata) { if (entry.val() != null) { resultMessage[entry.key().ToString().Substring(1)] = new BString(entry.val().ToString()); } } SendMessage(resultMessage, client); } else { SendMessage( new BDictionary { { "id", message["id"] }, { "session", session.ToString() }, { "status", new BList { "done", "no-info" } } }, client); } break; default: SendMessage( new BDictionary { { "id", message["id"] }, { "session", session.ToString() }, { "status", new BList { "done", "error", "unknown-op" } } }, client); break; } } }
public void GetSizeInBytes_UTF8() { var bstring = new BString("æøå äö èéê ñ", Encoding.UTF8); bstring.GetSizeInBytes().Should().Be(24); }
public void EqualsStringWithEqualsOperator() { var bstring = new BString("Test String"); Assert.IsTrue("Test String" == bstring); }
public void ConstructorWithNullValue() { var bstring = new BString((string)null); }
public void ConstructorEmpty_ResultsInEmptyValue() { var bstring = new BString(); bstring.Value.ToArray().Should().BeEmpty(); }
public void GetSizeInBytes() { var bstring = new BString("abc", Encoding.UTF8); bstring.GetSizeInBytes().Should().Be(5); }
private void OnRecvGetPeersResponse(DHTNode remoteNode, BString nodesStr, BList valuesList, BString token) { // according to bep_0005, get_peers response can contain a list of nodes ProcessNodesStr(remoteNode, nodesStr); if (!ProcessValuesStr(remoteNode, valuesList, token)) { SendAnnouncePeerQuery(remoteNode, fSearchInfoHash, 0, PublicEndPoint.Port, token); } }
public void Encode_NumbersAndSpecialCharacters() { var bstring = new BString("123:?!#{}'|<>"); Assert.AreEqual("13:123:?!#{}'|<>", bstring.Encode()); }
public void CanEncode_UTF8() { var bstring = new BString("æøå äö èéê ñ", Encoding.UTF8); var bencode = bstring.EncodeAsString(); bencode.Should().Be("21:æøå äö èéê ñ"); }
public void Encode_UTF8() { var bstring = new BString("æøå äö èéê ñ"); Assert.AreEqual("21:æøå äö èéê ñ", bstring.Encode()); Assert.AreEqual("21:æøå äö èéê ñ", bstring.Encode(Encoding.UTF8)); }
public void EqualsBStringWithEqualsOperator() { var bstring1 = new BString("Test String"); var bstring2 = new BString("Test String"); Assert.IsTrue(bstring1 == bstring2); }
public void EqualsOperator_String_WithDifferentContentAreNotEqual(string str1, string str2) { var bstring = new BString(str1); (bstring == str2).Should().BeFalse(); }
public void HashCodesAreEqual() { var bstring1 = new BString("Test String"); var bstring2 = new BString("Test String"); var expected = bstring1.GetHashCode(); var actual = bstring2.GetHashCode(); Assert.AreEqual(expected, actual); }
public static BDictionary CreateAnnouncePeerQuery(BString transactionID, byte[] nid, byte[] infoHash, byte implied_port, int port, BString token) { BDictionary sendData = new BDictionary(); sendData.Add("t", transactionID); sendData.Add("y", "q"); sendData.Add("q", "announce_peer"); var args = new BDictionary(); args.Add("id", new BString(nid)); if (implied_port != 0) { args.Add("implied_port", new BNumber(implied_port)); } args.Add("info_hash", new BString(infoHash)); args.Add("port", new BNumber(port)); args.Add("token", token); sendData.Add("a", args); return(sendData); }