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 Encoding_DefaultIsUTF8()
{
var bstring = new BString("foo");
bstring.Encoding.Should().Be(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);
}
