public static MessageType TryParseMessage(byte[] messageBytes, out BDictionary message)
{
if (BObject.TryParse(messageBytes, out BObject bObject))
{
if (bObject is BDictionary dictionary)
{
message = dictionary;
if (message.TryGetValue("y", out BString type))
{
if (!message.ContainsKey <BString>("t"))
{
return(MessageType.Invalid);
}
switch (type.Text)
{
case "q": return(MessageType.Query);
case "r": return(MessageType.Response);
case "e": return(MessageType.Error);
default: return(MessageType.Unknown);
}
}
}
}
message = null;
return(MessageType.Invalid);
}
public void TestInstanceId()
{
var a = new AObject();
var b = new BObject();
Assert.AreEqual <uint>(1, a.InstanceId);
Assert.AreEqual <uint>(2, b.InstanceId);
}
public void BDictionary_EnforcedSorting_Unsorted()
{
// { "b", 1 }, { "a", 2 }
byte[] encoded = Encoding.UTF8.GetBytes("d1:bi1e1:ai2ee");
BDictionary.EnforceDictionarySorting = true;
Assert.False(BObject.TryParse(encoded, out BObject bObject));
BDictionary.EnforceDictionarySorting = false;
}
public void BObject_AreNotSame()
{
object test = new object();
object areSame = test;
Assert.AreSame(test, areSame);
object test2 = BObject.Clone(test);
Assert.AreNotSame(test, test2);
}
private IBanFormat.BbanItem[] GetBbanItems(BObject obj)
{
var arr = obj["bban"] as BArray;
return arr.OfType<BObject>()
.Select(o => new IBanFormat.BbanItem
{
Count = o["count"].Int32Value,
Type = o["type"].StringValue
})
.ToArray();
}
protected IBanFormat GetIbanFormat(BObject obj)
{
var bbitems = GetBbanItems(obj);
return(new IBanFormat
{
Country = obj["country"].StringValue,
Total = obj["total"].Int32Value,
Format = obj["format"].StringValue,
Bban = bbitems
});
}
// prints bencode generic object
public void Print(BObject BObj)
{
if (BObj is BDictionary)
{
PrintBdict(BObj as BDictionary);
}
else if (BObj is BList)
{
PrintBlist(BObj as BList);
}
else
{
Console.WriteLine(BObj);
}
}
private void TestBInteger(long testInteger)
{
BInteger bInteger = new BInteger(testInteger);
byte[] encoded = bInteger.Encode();
Assert.True(BObject.TryParse(encoded, out BInteger bObject));
Assert.Equal(testInteger, bObject.Value);
using (MemoryStream ms = new MemoryStream())
{
bInteger.Encode(ms);
encoded = ms.ToArray();
}
Assert.True(BObject.TryParse(encoded, out bObject));
Assert.Equal(testInteger, bObject.Value);
Assert.Equal(encoded.Length, bInteger.EncodedSize);
}
private void TestBList(List <BObject> testList)
{
BList bList = new BList(testList);
byte[] encoded = bList.Encode();
Assert.True(BObject.TryParse(encoded, out BList bObject));
Assert.True(bList.Equals(bObject));
using (MemoryStream ms = new MemoryStream())
{
bList.Encode(ms);
encoded = ms.ToArray();
}
Assert.True(BObject.TryParse(encoded, out bObject));
Assert.True(bList.Equals(bObject));
Assert.Equal(encoded.Length, bList.GetEncodedSize());
}
private void TestBDictionary(Dictionary <BString, BObject> testDictionary)
{
BDictionary bDictionary = new BDictionary(testDictionary);
byte[] encoded = bDictionary.Encode();
Assert.True(BObject.TryParse(encoded, out BDictionary bObject));
Assert.True(bDictionary.Equals(bObject));
using (MemoryStream ms = new MemoryStream())
{
bDictionary.Encode(ms);
encoded = ms.ToArray();
}
Assert.True(BObject.TryParse(encoded, out bObject));
Assert.True(bDictionary.Equals(bObject));
Assert.Equal(encoded.Length, bDictionary.GetEncodedSize());
}
private async void ObjManager_objReceived(object sender, ObjReceivedEventArgs e)
{
BObject bObj = e.Obj;
Metadata metadata = bObj.GetMetadata();
ObjReceived?.Invoke(this, e);
string objType = bObj.GetType();
switch (objType)
{
case "FilePartObj":
FilePartObj filePart = e.Obj.GetObject <FilePartObj>();
await ProcessFilePart(filePart, metadata);
break;
/*
* case "FileAck":
* FileAck ackMsg = e.Obj.GetObject<FileAck>();
* await ProcessAckMessage(ackMsg, metadata);
* break;
*/
case "FileReqMeta":
FileReqMeta fileRequestMetadata = e.Obj.GetObject <FileReqMeta>();
await ProcessIncomingFilesRequest(fileRequestMetadata, metadata);
break;
case "ReqAck":
ReqAck fileReqAck = e.Obj.GetObject <ReqAck>();
await ProcessFileReqAck(fileReqAck, metadata);
break;
default:
break;
}
}
//constructor
public ObjReceivedEventArgs(BObject mObj, Metadata mMetadata)
{
this.Obj = mObj;
this.Meta = mMetadata;
}
public void BInteger_NegativeZero()
{
byte[] encoded = Encoding.UTF8.GetBytes("i-0e");
Assert.False(BObject.TryParse(encoded, out BObject bObject));
}
public void BInteger_EmptyIsValidAndZero()
{
byte[] encoded = Encoding.UTF8.GetBytes("ie");
Assert.True(BObject.TryParse(encoded, out BInteger bObject));
Assert.Equal(0L, bObject.Value);
}
public void BInteger_MultipleNegative()
{
byte[] encoded = Encoding.UTF8.GetBytes("i--1e");
Assert.False(BObject.TryParse(encoded, out BObject bObject));
}
public void BInteger_MisplacedNegative()
{
byte[] encoded = Encoding.UTF8.GetBytes("i123-4e");
Assert.False(BObject.TryParse(encoded, out BObject bObject));
}
public void BList_MissingTerminator()
{
byte[] encoded = Encoding.UTF8.GetBytes("li1e");
Assert.False(BObject.TryParse(encoded, out BObject bObject));
}
public void BDictionary_MissingTerminator()
{
byte[] encoded = Encoding.UTF8.GetBytes("d4:testi1e");
Assert.False(BObject.TryParse(encoded, out BObject bObject));
}
public static bool TryParse(BDictionary message, out GetPeersResponse response)
{
response = null;
if (message.TryGetValue("t", out BString transactionId) && transactionId.Length > 0 &&
message.TryGetValue("a", out BDictionary arguments) &&
arguments.TryGetValue("id", out BString nodeId) && nodeId.Length == NodeID.Size &&
arguments.TryGetValue("token", out BString token) && token.Length > 0)
{
if (arguments.TryGetValue("values", out BList values))
{
PeerContact[] peers = new PeerContact[values.Count];
for (int i = 0; i < peers.Length; i++)
{
BObject value = values[i];
if (value is BString peer)
{
if (peer.Length == IPv4PeerContact.CompactInfoSize)
{
peers[i] = new IPv4PeerContact(peer);
}
else if (peer.Length == IPv6PeerContact.CompactInfoSize)
{
peers[i] = new IPv6PeerContact(peer);
}
else
{
return(false);
}
}
else
{
return(false);
}
}
response = new GetPeersResponse(new TransactionID(transactionId), new NodeID(nodeId), new PeerToken(token), peers);
}
else
{
IPv4Node[] nodes = null;
IPv6Node[] nodes6 = null;
if (arguments.TryGetValue("nodes", out BString nodeBytes))
{
if (!IPv4Node.TryParseCompactNodeInfos(nodeBytes.Bytes, out nodes))
{
return(false);
}
}
if (arguments.TryGetValue("nodes6", out BString node6Bytes))
{
if (!IPv6Node.TryParseCompactNodeInfos(nodeBytes.Bytes, out nodes6))
{
return(false);
}
}
if (nodes != null)
{
if (nodes6 != null)
{
response = new GetPeersResponse(new TransactionID(transactionId), new NodeID(nodeId), new PeerToken(token), nodes, nodes6);
}
else
{
response = new GetPeersResponse(new TransactionID(transactionId), new NodeID(nodeId), new PeerToken(token), nodes);
}
}
else if (nodes6 != null)
{
response = new GetPeersResponse(new TransactionID(transactionId), new NodeID(nodeId), new PeerToken(token), nodes6);
}
}
}
return(response != null);
}
