public void testLNI(G2Packet packTest)
{
G2PacketLNI rLNI = (G2PacketLNI)packTest;
G2PacketGU rGU = (G2PacketGU) rLNI.getFirstChildPacket (G2PacketType.GU);
G2PacketNA rNA = (G2PacketNA) rLNI.getFirstChildPacket (G2PacketType.NA);
G2PacketV rV = (G2PacketV)rLNI.getFirstChildPacket (G2PacketType.V);
G2Packet lni = new G2PacketLNI();
lni.AddChild (new G2PacketNA (rNA.node));
lni.AddChild (new G2PacketGU (rGU.nodeGuid));
lni.AddChild (new G2PacketV (rV.Str));
lni.FinalizePacket ();
G2Log.Write(lni.ToString());
MemoryStream s1 = new MemoryStream ((int)rLNI.getTotalPacketLength ());
MemoryStream s2 = new MemoryStream ((int)lni.getTotalPacketLength ());
rLNI.Write (s1);
lni.Write (s2);
byte[] b1 = s1.ToArray ();
byte[] b2 = s2.ToArray ();
if (b1.Length != b2.Length) {
G2Log.Write (" NOT EQUAL");
return;
}
for (int i = 0; i < b1.Length; i++) {
if (b1 [i] != b2 [i]) {
G2Log.Write ("NOT EQUAL");
return;
}
}
G2Log.Write ("EQUAL !!");
}
/**
* Take a search related packets i.e. QA (ack) or QH2 (hit)
* and stores it into SearchResults class
* */
public void EnqueueResultPacket(NodePeer p, G2Packet pack)
{
// a hub packet ACK a query
if (pack.type == G2PacketType.QA)
{
G2PacketQA qa = pack as G2PacketQA;
G2SearchResults res = null;
bool exists = SearchResults.TryGetValue(qa.guid, out res);
if (!exists) // no entry => not a search we initiated
G2Log.Write("G2SearchManager : Received ACK of non asked Query");
else
{
res.SetAcknowledgement(qa);
G2Log.Write("G2SearchManager Received ACK of search " + SearchDB[qa.guid].Keywords[0]);
}
}
// Hit packet !
else if (pack.type == G2PacketType.QH2)
{
G2PacketQH2 qh2 = pack as G2PacketQH2;
G2SearchResults res = null;
bool exists = SearchResults.TryGetValue(qh2.searchGuid, out res);
if (exists)
{ // a new result packet coming for a requested query
res.PushResultPacket(qh2);
//if (res.TotalFiles > MAX_RESULTS)
// G2Network.Instance.StopNetwork();
}
else // got a response for a query we did not ask ?
G2Log.Write("G2SearchManager : Received a Hit on a NON ASKED Query");
}
}
public Header(G2Packet packet)
{
int totalPayloadLength = packet.getTotalPayloadLength ();
initialize(totalPayloadLength,
packet.type,
packet.children.Count > 0 ? true : false,
getLenLen(totalPayloadLength),
(byte)System.Text.Encoding.UTF8.GetBytes(packet.type).Length) ;
controlByte = ComputeControlByte();
}
public Header(G2Packet packet)
{
int totalPayloadLength = packet.getTotalPayloadLength();
initialize(totalPayloadLength,
packet.type,
packet.children.Count > 0 ? true : false,
getLenLen(totalPayloadLength),
(byte)System.Text.Encoding.UTF8.GetBytes(packet.type).Length);
controlByte = ComputeControlByte();
}
public G2Packet getFirstChildPacket(string type)
{
G2Packet p = null;
foreach (G2Packet cp in children)
{
if (cp.type.Equals(type))
{
p = cp;
break;
}
}
return(p);
}
public string getStringFromChildType(string type)
{
G2Packet pack = getFirstChildPacket(type);
if (pack == null)
{
return("");
}
G2PacketString strPack = pack as G2PacketString;
if (strPack == null)
{
return("");
}
return(strPack.Str);
}
public G2Packet HandlePacket(NodePeer p, G2Packet pack)
{
switch (pack.type)
{
case G2PacketType.PI:
return HandlePacketPI(p, pack as G2PacketPI);
case G2PacketType.UPROC:
return HandlePacketUPROC(p, pack as G2PacketUPROC);
case G2PacketType.LNI:
return HandlePacketLNI(p, pack as G2PacketLNI);
case G2PacketType.KHL:
return HandlePacketKHL(p, pack as G2PacketKHL);
case G2PacketType.QA:
return HandlePacketQA(p, pack as G2PacketQA);
default:
return HandleDefault(p, pack);
}
}
public void AddChild(G2Packet p)
{
children.Add(p);
}
public static G2Packet getPacketByHeader(Header h)
{
G2Packet packet = null;
switch (h.type)
{
case G2PacketType.PVU:
packet = new G2PacketPVU(h);
break;
case G2PacketType.COM:
packet = new G2PacketCOM(h);
break;
case G2PacketType.PART:
packet = new G2PacketPART(h);
break;
case G2PacketType.SZ:
packet = new G2PacketSZ(h);
break;
case G2PacketType.Q2:
packet = new G2PacketQ2(h);
break;
case G2PacketType.DN:
packet = new G2PacketDN(h);
break;
case G2PacketType.KHL:
packet = new G2PacketKHL(h);
break;
case G2PacketType.QA:
packet = new G2PacketQA(h);
break;
case G2PacketType.SS:
packet = new G2PacketSS(h);
break;
case G2PacketType.QH2:
packet = new G2PacketQH2(h);
break;
case G2PacketType.HG:
packet = new G2PacketHG(h);
break;
case G2PacketType.PI:
packet = new G2PacketPI(h);
break;
case G2PacketType.UDP:
packet = new G2PacketUDP(h);
break;
case G2PacketType.PO:
packet = new G2PacketPO(h);
break;
case G2PacketType.S:
packet = new G2PacketS(h);
break;
case G2PacketType.D:
packet = new G2PacketD(h);
break;
case G2PacketType.LNI:
packet = new G2PacketLNI(h);
break;
case G2PacketType.GU:
packet = new G2PacketGU(h);
break;
case G2PacketType.NA:
packet = new G2PacketNA(h);
break;
case G2PacketType.QKR:
packet = new G2PacketQKR(h);
break;
case G2PacketType.QKA:
packet = new G2PacketQKA(h);
break;
case G2PacketType.SNA:
packet = new G2PacketSNA(h);
break;
case G2PacketType.QNA:
packet = new G2PacketQNA(h);
break;
case G2PacketType.V:
packet = new G2PacketV(h);
break;
case G2PacketType.LS:
packet = new G2PacketLS(h);
break;
case G2PacketType.HS:
packet = new G2PacketHS(h);
break;
case G2PacketType.TLS:
packet = new G2PacketTLS(h);
break;
case G2PacketType.TS:
packet = new G2PacketTS(h);
break;
case G2PacketType.NH:
packet = new G2PacketNH(h);
break;
case G2PacketType.RA:
packet = new G2PacketRA(h);
break;
case G2PacketType.BUP:
packet = new G2PacketBUP(h);
break;
case G2PacketType.H:
packet = new G2PacketH(h);
break;
case G2PacketType.URL:
packet = new G2PacketURL(h);
break;
case G2PacketType.URN:
packet = new G2PacketURN(h);
break;
case G2PacketType.UPRO:
packet = new G2PacketUPRO(h);
break;
case G2PacketType.NICK:
packet = new G2PacketNICK(h);
break;
case G2PacketType.BH:
packet = new G2PacketBH(h);
break;
case G2PacketType.FW:
packet = new G2PacketFW(h);
break;
case G2PacketType.MD:
packet = new G2PacketMD(h);
break;
case G2PacketType.UPROC:
packet = new G2PacketUPROC(h);
break;
case G2PacketType.UPROD:
packet = new G2PacketUPROD(h);
break;
case G2PacketType.XML:
packet = new G2PacketXML(h);
break;
default:
packet = new G2PacketDefault(h);
break;
}
return(packet);
}
private int ReadPacket(MemoryStream stream, out G2Packet pack)
{
Header h = null;
try
{
h = Header.ReadHeader(stream);
}
catch (Exception e) {
throw e;
}
int packLength = (int)(h.PayloadLength + h.HeaderLength);
// if stream is not enough big to contain all the packet we need to read more
if (packLength > stream.Length)
throw new NotEnoughDataException("Not enough data in buffer");
pack = G2PacketType.getPacketByHeader(h);
// Set the remote host into packet for further analysis
pack.RemotePeer = this.peer;
// we have a unknown packet so we just read till the end of the packet
if (pack.type == G2PacketType.DEFAULT)
{
// anyway, read & store the bytes
return (int)(h.HeaderLength + pack.ReadPayload(stream, h.PayloadLength));
}
// we have read header, now we calculate how much byte we need to read more (children + payload)
int byteToRead = h.PayloadLength;
int byteRead = 0;
bool endOfChildStream = false;
if (h.compound)
{
while (true)
{
G2Packet childPacket;
try
{
int bRead = ReadPacket(stream, out childPacket);
//Debug.Assert(bRead == childPacket.getTotalPacketLength(),
//"ReadPacket:ChildPacket " + childPacket.type + " bRead = " + bRead + " vs " + childPacket.getTotalPacketLength());
}
catch (BigEndianPacketException e)
{
throw e;
}
catch (EndOfStreamException e)
{
byteRead += 1;
break;
}
pack.AddChild(childPacket);
byteRead += childPacket.getTotalPacketLength();
// root packet does NOT have a payload
if (byteRead == byteToRead)
{
endOfChildStream = true;
break;
}
}
}
// have to count the remaining bytes, because length in header includes child packets.
if (!endOfChildStream && (byteRead < byteToRead))
byteRead += pack.ReadPayload(stream, byteToRead - byteRead);
// return total read byte number
return (int)(byteRead + h.HeaderLength);
}
/**
* Analyse packet and return a packet to send (if there is one)
* or null
* */
private G2Packet HandleDefault(NodePeer p,G2Packet pack)
{
return null;
}
/**
* Push a packet just received, to be analyzed further
* */
public void PushPacketToReceive(G2Packet pack)
{
lock (ReceiveBuffer) {
ReceiveBuffer.Enqueue(pack);
var type = pack.packetHeader.type;
type += pack.type == G2PacketType.DEFAULT ? " (unknown) " : "";
G2Log.Write("PacketBuffer : Enqueued incoming packet " + type + " to receive from " +pack.RemotePeer.ToString());
}
}
/**
* Push a packet to the buffer to be sent by the connection of the peer
* */
public void PushPacketToSend(G2Packet pack)
{
lock (SendBuffer) {
SendBuffer.Enqueue(pack);
var type = pack.packetHeader.type;
type += pack.type == G2PacketType.DEFAULT ? " (unknown) " : "";
G2Log.Write("PacketBuffer : Enqueued packet " + type + " to send to " + pack.RemotePeer.ToString());
Monitor.Pulse (SendBuffer);
}
}
public void AddChild(G2Packet p)
{
children.Add(p);
}
