public bool SendPacket(G2Packet packet)
{
if (Core.InvokeRequired)
{
Debug.Assert(false);
}
byte[] final = packet.Encode(Network.Protocol);
if (Comm.State != RudpState.Connected)
{
return(false);
}
PacketLogEntry logEntry = new PacketLogEntry(Core.TimeNow, TransportProtocol.Rudp, DirectionType.Out, Comm.PrimaryAddress.Address, final);
Core.Network.LogPacket(logEntry);
// dont worry about buffers, cause initial comm buffer is large enough to fit all negotiating packets
if (SendEncryptor == null)
{
int length = final.Length;
Comm.Send(final, ref length);
return(true);
}
// goal - dont fill encrypt buffer because it will block stuff like pings during transfers
// use as temp, return failed if no room
if (SendBuffer == null)
{
SendBuffer = new byte[BUFF_SIZE];
}
if (EncryptBuffer == null)
{
EncryptBuffer = new byte[BUFF_SIZE];
}
LastSends.Enqueue(new Tuple <int, int>(EncryptBuffSize, final.Length));
if (LastSends.Count > 100)
{
LastSends.Dequeue();
}
// ensure enough space in encrypt buff for packet and expedite packets
if (BUFF_SIZE - EncryptBuffSize < final.Length + 128)
{
throw new Exception("Packet Dropped");
}
// encode put into send buff
lock (SendBuffer)
{
final.CopyTo(SendBuffer, SendBuffSize);
SendBuffSize += final.Length;
}
return(FlushSend()); // return true if room in comm buffer
}
public void SendReliable(DhtClient client, uint service, int type, G2Packet packet, bool expedite)
{
if (!Clients.ContainsKey(client.RoutingID))
{
return;
}
RudpPacket comm = CreateRudpPacket(client, service, type, packet, true);
LightClient target = Clients[client.RoutingID];
if (expedite)
{
target.NextTry = Core.TimeNow;
target.Packets.AddFirst(new Tuple <uint, RudpPacket>(service, comm));
target.TrySend(Network);
return;
}
Active[client.RoutingID] = target;
target.Packets.AddLast(new Tuple <uint, RudpPacket>(service, comm));
while (target.Packets.Count > 30)
{
//crit - log to console? Debug.Assert(false);
target.Packets.RemoveFirst();
}
target.TrySend(Network);
}
public void SendTo(G2Packet packet)
{
if (Core.InvokeRequired)
{
Debug.Assert(false);
}
if (packet is NetworkPacket)
{
((NetworkPacket)packet).SourceID = Network.Local.UserID;
((NetworkPacket)packet).ClientID = Network.Local.ClientID;
}
byte[] encoded = packet.Encode(Network.Protocol);
PacketLogEntry logEntry = new PacketLogEntry(Core.TimeNow, TransportProtocol.LAN, DirectionType.Out, null, encoded);
Network.LogPacket(logEntry);
byte[] final = null;
// encrypt, turn off encryption during simulation
if (Core.Sim == null || Core.Sim.Internet.TestEncryption)
{
final = Utilities.EncryptBytes(encoded, Network.OpCrypt.Key);
}
else
{
final = encoded;
}
// send
try
{
if (Core.Sim != null)
{
//Core.Sim.Internet.SendPacket(SimPacketType.Udp, Network, final, address.ToEndPoint(), null);
return;
}
if (LanSocket == null)
{
return;
}
if (encoded.Length > MAX_UDP_SIZE)
{
throw new Exception("Packet larger than " + MAX_UDP_SIZE.ToString() + " bytes");
}
EndPoint tempSender = (EndPoint) new IPEndPoint(IPAddress.Broadcast, ListenPort);
LanSocket.BeginSendTo(final, 0, final.Length, SocketFlags.None, tempSender, new AsyncCallback(UdpSocket_SendTo), LanSocket);
}
catch (Exception ex)
{
Network.UpdateLog("Exception", "LanHandler::SendTo: " + ex.Message);
}
}
public void GotPacket(G2Packet pack)
{
Buffer.PushPacketToReceive(pack);
if (isHub)
{
G2Network.Instance.NewActionAvailable(); // signal processing thread only for connected hubs ( != browsable peer )
}
}
public bool SendData(uint service, uint datatype, G2Packet packet)
{
CommData data = new CommData(service, datatype, packet.Encode(Network.Protocol));
Core.ServiceBandwidth[service].OutPerSec += data.Data.Length;
return(SendPacket(data));
}
/**
* Send LNI And PI packets
* */
public void SendStartPackets()
{
G2Packet lni = Settings.SmartLNIPacket();
SendPacket(lni);
G2Packet PI = new G2PacketPI();
SendPacket(PI);
}
/**
* 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);
}
}
private static bool isPartialFile(G2PacketH hit)
{
G2Packet part = hit.getFirstChildPacket(G2PacketType.PART);
if (part != null)
{
return(true);
}
return(false);
}
private string getVendorCodeFromQueryHit(G2PacketQH2 qh2)
{
G2Packet vendorPacket = qh2.getFirstChildPacket(G2PacketType.V);
if (vendorPacket == null)
{
return("");
}
return(((G2PacketV)vendorPacket).Str);
}
private string getDNSNameFromQueryHit(G2PacketQH2 qh2)
{
G2Packet dns = qh2.getFirstChildPacket(G2PacketType.DNS);
if (dns == null)
{
return("");
}
return(((G2PacketDNS)dns).Str);
}
public int SendPacket(DhtAddress contact, G2Packet packet)
{
if (contact.TunnelServer != null)
{
return(SendTunnelPacket(contact, packet));
}
else
{
return(UdpControl.SendTo(contact, packet));
}
}
/**
* Wait for packet to send to peer from its buffer and send it
* */
public void SendThread()
{
while (!shouldStop_)
{
G2Packet pack = peer.Buffer.PollPacketToSend();
MemoryStream str = new MemoryStream((int)pack.getTotalPacketLength());
pack.Write(str);
bool succ = Send(str);
}
}
/** Search address of the servent
* may be null
**/
private static NodeAddress getAddressFromQueryHit(G2PacketQH2 qh2)
{
G2Packet p = qh2.getFirstChildPacket(G2PacketType.NA);
if (p == null)
{
return(null);
}
G2PacketNA na = p as G2PacketNA;
return(na.node);
}
/**
* Return creation time in DateTime format if present
* otherwise return current time
* */
private static DateTime getCreationTimeFromHit(G2PacketH hit)
{
G2Packet pack = hit.getFirstChildPacket(G2PacketType.CT);
if (pack == null)
{
return(DateTime.Now);
}
G2PacketCT ct = pack as G2PacketCT;
return(BinaryUtils.UnixTimeStampToDateTime(ct.Timestamp));
}
/**
* Pick a packet to analyse by the processing thread
* */
public G2Packet PollPacketToReceive()
{
G2Packet pack = null;
lock (ReceiveBuffer) {
if (ReceiveBuffer.Count > 0)
{
pack = (G2Packet)ReceiveBuffer.Dequeue();
}
}
return(pack);
}
private G2Packet HandlePacketPI(NodePeer p, G2PacketPI pack)
{
p.ResetPingTimer();
G2Packet udp = pack.getFirstChildPacket(G2PacketType.UDP);
G2Packet response = new G2PacketPO();
// PING relayed but we dont act as hub for now
if (udp != null)
{
}
response.FinalizePacket();
return(response);
}
/**
* Retrieve a packet
* */
public G2Packet PollPacketToSend()
{
G2Packet pack = null;
lock (SendBuffer) {
while (SendBuffer.Count == 0)
{
Monitor.Wait(SendBuffer);
}
pack = (G2Packet)SendBuffer.Dequeue();
}
return(pack);
}
/**
* Get a URL link if present
* IF not present , it has to beretrieved by HTTP request
* */
private static string getDownloadLink(G2PacketH hit)
{
G2Packet pack = hit.getFirstChildPacket(G2PacketType.URL);
if (pack == null)
{
return("");
}
G2PacketURL url = pack as G2PacketURL;
if (url == null)
{
return("");
}
return(url.Str);
}
/* *
* Return the nickname if there is one
* otherwise return empty string
* */
private static String getNickFromQueryHit(G2PacketQH2 qh2)
{
G2Packet upro = qh2.getFirstChildPacket(G2PacketType.UPRO);
if (upro == null)
{
return("");
}
G2Packet nick = upro.getFirstChildPacket(G2PacketType.NICK);
if (nick == null)
{
return("");
}
return(((G2PacketNICK)nick).Str);
}
public void ReadPackets()
{
using (StreamReader fileStream = new StreamReader(fileToRead))
{
var str = fileStream.ReadToEnd();
G2Log.Write("File : " + str);
byte[] bytes = StringToByteArray(str);
NodePeer p = new NodePeer(IPAddress.Parse("127.0.0.1"), 16546, 0, false);
G2PacketReader reader = new G2PacketReader(p);
reader.Read(bytes, bytes.Length);
G2Log.Write("G2PacketTest: ReadPacket file " + fileToRead);
G2Packet pack = p.Buffer.PollPacketToReceive();
G2Log.Write(pack.ToString());
//if(pack.type == G2PacketType.LNI) testLNI (pack);
}
}
private static ActionInnocence.P2PScan.PeerCollection getAlternateLocationsFromQueryHit(G2PacketQH2 qh2)
{
G2Packet pack = qh2.getFirstChildPacket(G2PacketType.ALT);
if (pack == null)
{
return(null);
}
G2PacketALT altPack = pack as G2PacketALT;
ActionInnocence.P2PScan.PeerCollection coll = new ActionInnocence.P2PScan.PeerCollection();
foreach (NodeAddress add in altPack.Addresses)
{
coll.Add(new ActionInnocence.P2PScan.Peer(add.ipv4.ToString(), add.ToString(), add.port, ""));
}
return(coll);
}
private G2PacketQH2 PollResultPacket()
{
G2PacketQH2 resultPack;
lock (LockBuffer)
{
// not while because we can terminate the thread with the timer
if (Buffer.ReceiveBufferCount == 0)
{
Monitor.Wait(LockBuffer);
}
G2Packet pack = Buffer.PollPacketToReceive();
resultPack = pack as G2PacketQH2;
}
return(resultPack);
}
private G2Packet HandlePacketLNI(NodePeer peer, G2PacketLNI pack)
{
G2Packet p = pack.getFirstChildPacket(G2PacketType.NA);
if (p != null)
{
peer.ListeningNode = ((G2PacketNA)p).node;
}
p = pack.getFirstChildPacket(G2PacketType.GU);
if (p != null)
{
peer.Guid = ((G2PacketGU)p).nodeGuid;
}
// can handle vendor code etc etc
return(null);
}
RudpPacket CreateRudpPacket(DhtClient client, uint service, int type, G2Packet packet, bool reliable)
{
RudpPacket comm = new RudpPacket();
comm.SenderID = Network.Local.UserID;
comm.SenderClient = Network.Local.ClientID;
comm.TargetID = client.UserID;
comm.TargetClient = client.ClientID;
comm.PacketType = RudpPacketType.Light;
comm.Payload = RudpLight.Encode(service, type, packet.Encode(Network.Protocol));
if (reliable)
{
comm.PeerID = (ushort)Core.RndGen.Next(ushort.MaxValue); // used to ack
comm.Sequence = 1;
}
return(comm);
}
/**
* Stop the connection to the peer,
* and sends the results back
* */
private void SearchTimeOut(Object sender, EventArgs args)
{
G2Packet pack = null;
while ((pack = Peer.Buffer.PollPacketToReceive()) != null)
{
G2PacketQH2 qh2 = pack as G2PacketQH2;
if (qh2 == null)
{
continue;
}
packetResults.Add(qh2);
}
Peer.Close();
if (EndSearch != null)
{
EndSearch(referenceToPeer, referenceToSearchResults, packetResults);
}
}
/**
* CHeck incoming message for this peer, and push a response if needed
* */
private void OnNewMessage(NodePeer p)
{
G2Packet pack = null;
G2Packet response = null;
while ((pack = p.Buffer.PollPacketToReceive()) != null)
{
response = HandlePacket(p, pack); // network related packets (ping/pong/etc)
if (response != null)
{
p.SendPacket(response);
response = null;
}
if (pack.type == G2PacketType.QA || pack.type == G2PacketType.QH2)
{// search related packets
SearchManager.EnqueueResultPacket(p, pack);
continue;
}
pack = null;
}
}
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 !!");
}
public void SendUnreliable(uint service, uint type, G2Packet packet)
{
// fast, secure, out-of-band method of sending data
// useful for things like VOIP during a file transfer with host
// data has got to go out asap, no matter what
// check rudp socket is connected
if (Status != SessionStatus.Active)
{
return;
}
// add to special rudp packet
RudpPacket rudp = new RudpPacket();
rudp.SenderID = Network.Local.UserID;
rudp.SenderClient = Network.Local.ClientID;
rudp.TargetID = UserID;
rudp.TargetClient = ClientID;
rudp.PeerID = Comm.RemotePeerID;
rudp.PacketType = RudpPacketType.Unreliable;
CommData data = new CommData(service, type, packet.Encode(Network.Protocol));
rudp.Payload = Utilities.EncryptBytes(data.Encode(Network.Protocol), OutboundEnc.Key);
// send
Comm.SendPacket(rudp, Comm.PrimaryAddress);
// stats
Core.ServiceBandwidth[service].OutPerSec += data.Data.Length;
PacketLogEntry logEntry = new PacketLogEntry(Core.TimeNow, TransportProtocol.Rudp, DirectionType.Out, Comm.PrimaryAddress.Address, rudp.Payload);
Core.Network.LogPacket(logEntry);
}
/**
* 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");
}
}
}
