public void Send_ProxySearchRequest() { SearchReq request = new SearchReq(); request.Source = Network.GetLocalSource(); request.SearchID = SearchID; request.TargetID = TargetID; request.Service = Service; request.DataType = DataType; request.Parameters = Parameters; ProxyTcp.SendPacket(request); }
public void SendRequest(DhtAddress address, UInt64 targetID, uint searchID, uint service, uint datatype, byte[] parameters) { SearchReq request = new SearchReq(); request.Source = Network.GetLocalSource(); request.SearchID = searchID; request.TargetID = targetID; request.Service = service; request.DataType = datatype; request.Parameters = parameters; int sentBytes = 0; TcpConnect direct = Network.TcpControl.GetProxy(address); if (direct != null) { sentBytes = direct.SendPacket(request); } else { sentBytes = Network.SendPacket(address, request); } Core.ServiceBandwidth[request.Service].OutPerSec += sentBytes; }
public void Send_StoreReq(DhtAddress address, DhtClient localProxy, DataReq publish) { if (address == null) { return; } StoreReq store = new StoreReq(); store.Source = Network.GetLocalSource(); store.Key = publish.Target; store.Service = publish.Service; store.DataType = publish.DataType; store.Data = publish.Data; int sentBytes = 0; TcpConnect direct = Network.TcpControl.GetProxy(address); if (direct != null) { sentBytes = direct.SendPacket(store); } else if (address.TunnelClient != null) { sentBytes = Network.SendTunnelPacket(address, store); } // if blocked send tcp with to tag else if (Core.Firewall == FirewallType.Blocked) { store.ToAddress = address; TcpConnect proxy = Network.TcpControl.GetProxy(localProxy); if (proxy != null) { sentBytes = proxy.SendPacket(store); } else { sentBytes = Network.TcpControl.SendRandomProxy(store); } } else { sentBytes = Network.UdpControl.SendTo(address, store); } Core.ServiceBandwidth[store.Service].OutPerSec += sentBytes; }
// sends a direct request, no acks are returned, if host has what is requested it sends a store request as a reply // make sure whatevers calling this handles the resulting store request public void SendDirectRequest(DhtAddress dest, ulong target, uint service, uint datatype, byte[] parameters) { SearchReq request = new SearchReq(); request.Source = Network.GetLocalSource(); request.TargetID = target; request.Service = service; request.DataType = datatype; request.Parameters = parameters; request.Nodes = false; int sentBytes = 0; TcpConnect socket = Network.TcpControl.GetProxy(dest); if (socket != null) { sentBytes = socket.SendPacket(request); } else if (dest.TunnelClient != null) { sentBytes = Network.SendTunnelPacket(dest, request); } else if (Core.Firewall == FirewallType.Blocked) { request.ToAddress = dest; sentBytes = Network.TcpControl.SendRandomProxy(request); } else { sentBytes = Network.UdpControl.SendTo(dest, request); } Core.ServiceBandwidth[request.Service].OutPerSec += sentBytes; // if remote end has what we need they will send us a store request }
public void Receive_CrawlRequest(G2ReceivedPacket packet) { CrawlRequest request = CrawlRequest.Decode(packet); if (Local.Equals(request.Target)) { Send_CrawlAck(request, packet); } // Forward to appropriate node else { TcpConnect client = TcpControl.GetProxy(request.Target); if (client != null) { request.FromAddress = packet.Source; // add so receiving host knows where to send response too client.SendPacket(request); } } }
// nodes in lookup proxy mode are psuedo-open, instead of udp they send tunneled packets // tunnel packets include routing information to the lookup target as well as // the encrytped operation packet embedded in the payload public int SendTunnelPacket(DhtAddress contact, G2Packet embed) { Debug.Assert(contact.TunnelClient != null && contact.TunnelServer != null); Debug.Assert(Core.Context.Lookup != null); Debug.Assert(!IsLookup); Debug.Assert(Core.User.Settings.OpAccess != AccessType.Secret); if (IsLookup || Core.Context.Lookup == null || Core.User.Settings.OpAccess == AccessType.Secret) { return(0); } OpCore lookup = Core.Context.Lookup; // tunnel packet through lookup network byte[] encoded = embed.Encode(Protocol); PacketLogEntry logEntry = new PacketLogEntry(Core.TimeNow, TransportProtocol.Tunnel, DirectionType.Out, contact, encoded); LogPacket(logEntry); TunnelPacket packet = new TunnelPacket(); // encrypt, turn off encryption during simulation if (Core.Sim == null || Core.Sim.Internet.TestEncryption) { packet.Payload = Utilities.EncryptBytes(encoded, GetAugmentedKey(contact.UserID)); } else { packet.Payload = encoded; } packet.Source = new TunnelAddress(lookup.Network.Local, Core.TunnelID); packet.Target = contact.TunnelClient; int bytesSent = 0; // if we are the tunnel server (our lookup net is open, but op is blocked) if (lookup.Network.Local.Equals(contact.TunnelServer)) // use dhtclient compare { lookup.RunInCoreAsync(delegate() { TcpConnect direct = lookup.Network.TcpControl.GetProxy(packet.Target); if (direct != null) { packet.SourceServer = new DhtAddress(Core.LocalIP, lookup.Network.GetLocalSource()); bytesSent = direct.SendPacket(packet); } }); return(bytesSent); } // if not open send proxied through local lookup proxy // NAT as well because receiver would need to send all responses through same local lookup proxy // for NATd host to get replies if (Core.Firewall != FirewallType.Open) { packet.TargetServer = contact.TunnelServer; lookup.RunInCoreAsync(delegate() { TcpConnect server = lookup.Network.TcpControl.GetProxy(packet.TargetServer) ?? // direct path lookup.Network.TcpControl.GetProxyServer(contact.IP) ?? // reRoute through same server lookup.Network.TcpControl.GetRandomProxy(); // random proxy if (server != null) { packet.SourceServer = new DhtAddress(server.RemoteIP, server); bytesSent = server.SendPacket(packet); } }); } // else we are open, send op ip address in the souce server else { packet.SourceServer = new DhtAddress(Core.LocalIP, lookup.Network.GetLocalSource()); lookup.RunInCoreAsync(delegate() { bytesSent = lookup.Network.UdpControl.SendTo(contact.TunnelServer, packet); }); } return(bytesSent); }
public void ReceivePacket(G2ReceivedPacket packet) { // Network packet if (packet.Root.Name == RootPacket.Network) { NetworkPacket netPacket = NetworkPacket.Decode(packet.Root); G2ReceivedPacket embedded = new G2ReceivedPacket(); embedded.Tcp = packet.Tcp; embedded.Source = packet.Source; embedded.Source.UserID = netPacket.SourceID; embedded.Source.ClientID = netPacket.ClientID; embedded.Root = new G2Header(netPacket.InternalData); // from - received from proxy server if (netPacket.FromAddress != null) { if (packet.ReceivedUdp) { throw new Exception("From tag set on packet received udp"); } if (packet.Tcp.Proxy != ProxyType.Server) { throw new Exception("From tag (" + netPacket.FromAddress.ToString() + ") set on packet not received from server (" + packet.Tcp.ToString() + ")"); } embedded.Source = new DhtContact(netPacket.FromAddress); } // to - received from proxied node, and not for us if (netPacket.ToAddress != null && !(netPacket.ToAddress.UserID == Local.UserID && netPacket.ToAddress.ClientID == Local.ClientID)) { if (packet.ReceivedUdp) { throw new Exception("To tag set on packet received udp"); } if (packet.Tcp.Proxy == ProxyType.Server || packet.Tcp.Proxy == ProxyType.Unset) { throw new Exception("To tag set on packet received from server"); } DhtAddress address = netPacket.ToAddress; netPacket.ToAddress = null; TcpConnect direct = TcpControl.GetProxy(address); if (direct != null) { direct.SendPacket(netPacket); } else { UdpControl.SendTo(address, netPacket); } return; } // process if (G2Protocol.ReadPacket(embedded.Root)) { ReceiveNetworkPacket(embedded); } } // Tunnel Packet else if (packet.Root.Name == RootPacket.Tunnel) { // can only tunnel over lookup network if (!IsLookup) { return; } PacketLogEntry logEntry = new PacketLogEntry(Core.TimeNow, TransportProtocol.Tunnel, DirectionType.In, packet.Source, packet.Root.Data); LogPacket(logEntry); TunnelPacket tunnel = TunnelPacket.Decode(packet.Root); // handle locally if (tunnel.Target.Equals(Local)) { Core.Context.Cores.LockReading(delegate() { foreach (OpCore core in Core.Context.Cores) { if (core.TunnelID == tunnel.Target.TunnelID) { core.Network.ReceiveTunnelPacket(packet, tunnel); } } }); } else if (tunnel.TargetServer != null) { TcpConnect direct = TcpControl.GetProxy(tunnel.Target); // if directly connected add from and forwared if (direct != null) { direct.SendPacket(tunnel); } // only forward udp if received over tcp from a proxied host else if (tunnel.TargetServer != null && packet.ReceivedTcp && packet.Tcp.Proxy != ProxyType.Server) { UdpControl.SendTo(tunnel.TargetServer, tunnel); } } } // Communication Packet else if (packet.Root.Name == RootPacket.Comm) { RudpPacket commPacket = RudpPacket.Decode(packet); // received direct packet.Source.UserID = commPacket.SenderID; packet.Source.ClientID = commPacket.SenderClient; // remote node is proxied if (commPacket.RemoteProxy != null) { packet.Source = new DhtContact(commPacket.RemoteProxy); } // For local host if (commPacket.TargetID == Local.UserID && commPacket.TargetClient == Local.ClientID) { ReceiveCommPacket(packet, commPacket); return; } // Also Forward to appropriate node TcpConnect socket = TcpControl.GetProxy(commPacket.TargetID, commPacket.TargetClient); if (socket != null) { // forward to proxied node - strip TO flag, add from address commPacket.ToAddress = null; commPacket.RemoteProxy = packet.Source; // if remote proxy is null, then we are setting this to the packet's original source socket.SendPacket(commPacket); return; } // received from a proxied node, forward udp if (packet.ReceivedTcp && commPacket.ToAddress != null) { DhtAddress target = commPacket.ToAddress; commPacket.ToAddress = null; // strip TO flag commPacket.RemoteProxy = new DhtAddress(Core.LocalIP, GetLocalSource()); UdpControl.SendTo(target, commPacket); } } }