static void MyDestination_DataReceived(ClientDestination dest, BufLen data)
{
var compareok = DataSent is null ? false : DataSent == data;
Logging.LogInformation($"Program {MyDestination}: MyDestination data received. Matches send: {compareok} {data:15}");
PublishedDestination.Send(MyOrigin.Destination, data);
}
internal void TunnelTimeout(Tunnel tunnel)
{
ClientDestination client = FindClient(tunnel);
if (client == null)
{
return;
}
var replace = FindReplaceRecord(tunnel);
if (replace != null)
{
DebugUtils.LogDebug("ClientTunnelProvider: TunnelTimeout: Failed replacing " + replace.OldTunnel.ToString() +
" with " + tunnel.ToString());
/*
* if ( replace.OldTunnel.Expired )
* {
* DebugUtils.LogDebug( "ClientTunnelProvider: TunnelTimeout: Old tunnel expired. " + replace.OldTunnel.ToString() );
*
* client.RemovePoolTunnel( replace.OldTunnel );
* }*/
ReplaceTunnel(tunnel, client, replace);
}
client.RemoveTunnel(tunnel);
}
internal ClientDestination CreateDestination(I2PDestinationInfo dest, bool publish)
{
var newclient = new ClientDestination(this, dest, publish);
Clients.Add(newclient);
return(newclient);
}
internal void TunnelEstablished(Tunnel tunnel)
{
TunnelUnderReplacement replace = null;
ClientDestination client = FindClient(tunnel);
if (client == null)
{
return;
}
client.TunnelEstablished(tunnel);
lock ( RunningReplacements )
{
replace = RunningReplacements.Where(p => p.Value.NewTunnels.Any(t => t.Equals(tunnel))).
Select(p => p.Value).SingleOrDefault();
if (replace != null)
{
RunningReplacements.Remove(replace.OldTunnel);
}
}
if (replace != null)
{
DebugUtils.LogDebug("ClientTunnelProvider: TunnelEstablished: Successfully replaced old tunnel " + replace.OldTunnel.ToString() +
" with new tunnel " + tunnel.ToString());
RemoveTunnelUnderReplacement(replace.OldTunnel);
//client.RemoveTunnel( replace.OldTunnel );
//TunnelMgr.RemoveTunnel( replace.OldTunnel );
//replace.OldTunnel.Shutdown();
return;
}
}
private void ReplaceTunnel(Tunnel tunnel, ClientDestination client, TunnelUnderReplacement replace)
{
if (tunnel != replace.OldTunnel)
{
replace.NewTunnels.RemoveAll(t => t.Equals(tunnel));
}
while (replace.NewTunnels.Count < NewTunnelCreationFactor)
{
switch (tunnel.Config.Direction)
{
case TunnelConfig.TunnelDirection.Outbound:
var newouttunnel = CreateOutboundTunnel(client, null);
replace.NewTunnels.Add(newouttunnel);
DebugUtils.LogDebug(() => string.Format("ClientTunnelProvider: ReplaceTunnel: Started to replace {0} with {1}.",
tunnel, newouttunnel));
break;
case TunnelConfig.TunnelDirection.Inbound:
var newintunnel = CreateInboundTunnel(client, null);
replace.NewTunnels.Add(newintunnel);
DebugUtils.LogDebug(() => string.Format("ClientTunnelProvider: ReplaceTunnel: Started to replace {0} with {1}.",
tunnel, newintunnel));
break;
default:
throw new NotImplementedException("Only out and inbound tunnels should be reported here.");
}
}
}
public TestSessionKeyOrigin(
ClientDestination owner,
I2PDestination mydest,
I2PDestination remotedest)
: base(owner, mydest, remotedest)
{
}
private void HasBeenServed()
{
Vector3 outOfScreenDestination = ClientDestination.ComputeSpawnOrQuitPosition();
PutMoneyOnCounter();
// Clients leaving are shown behind every other clients
outOfScreenDestination.z = 1;
StartCoroutine(MoveTowardsDestination(outOfScreenDestination, DestroyClient));
}
static void MyDestination_DataReceived(ClientDestination dest, BufLen data)
{
Logging.LogInformation($"Program {UnpublishedDestination}: data received {data:20}");
var reader = new BufRefLen(data);
var unzip = LZUtils.BCGZipDecompressNew((BufLen)reader);
var packet = new StreamingPacket((BufRefLen)unzip);
Logging.LogInformation($"Program {UnpublishedDestination}: {packet}");
}
TunnelInfo CreateOutgoingTunnelChain(ClientDestination dest)
{
var hops = new List <HopInfo>();
for (int i = 0; i < dest.OutboundTunnelHopCount; ++i)
{
var ih = NetDb.Inst.GetRandomRouterForTunnelBuild(false);
hops.Add(new HopInfo(NetDb.Inst[ih].Identity, new I2PTunnelId()));
}
return(new TunnelInfo(hops));
}
private OutboundTunnel CreateOutboundTunnel(ClientDestination dest, TunnelInfo prototype)
{
var config = new TunnelConfig(
TunnelConfig.TunnelDirection.Outbound,
TunnelConfig.TunnelPool.Client,
prototype == null ? CreateOutgoingTunnelChain(dest): prototype);
var tunnel = (OutboundTunnel)TunnelMgr.CreateTunnel(config);
if (tunnel != null)
{
TunnelMgr.AddTunnel(tunnel);
dest.AddOutboundPending(tunnel);
lock (Destinations) Destinations[tunnel] = dest;
}
return(tunnel);
}
static void MyDestination_DataReceived(ClientDestination dest, BufLen data)
{
Logging.LogInformation($"Program {PublishedDestination}: data received {data:15}");
var reader = new BufRefLen(data);
var unzip = LZUtils.BCGZipDecompressNew((BufLen)reader);
var packet = new StreamingPacket((BufRefLen)unzip);
Logging.LogInformation($"Program {PublishedDestination}: {packet} {packet.Payload}");
PublishedDestination.LookupDestination(packet?.From.IdentHash, (hash, ls, tag) =>
{
if (ls is null)
{
Logging.LogInformation($"Program {PublishedDestination}: Failed to lookup {hash?.Id32Short}.");
return;
}
var s = new BufRefStream();
var sh = new StreamingPacket(
PacketFlags.SYNCHRONIZE
| PacketFlags.FROM_INCLUDED
| PacketFlags.SIGNATURE_INCLUDED
| PacketFlags.MAX_PACKET_SIZE_INCLUDED
| PacketFlags.NO_ACK)
{
From = PublishedDestination.Destination,
SigningKey = MyDestinationInfo.PrivateSigningKey,
ReceiveStreamId = packet.ReceiveStreamId,
SendStreamId = SendId,
NACKs = new List <uint>(),
Payload = new BufLen(BufUtils.RandomBytes(30)),
};
sh.Write(s);
var buf = s.ToByteArray();
var zipped = LZUtils.BCGZipCompressNew(new BufLen(buf));
zipped.PokeFlip16(4353, 4); // source port
zipped.PokeFlip16(25, 6); // dest port
zipped[9] = (byte)PayloadFormat.Streaming; // streaming
Logging.LogInformation($"Program {PublishedDestination}: Sending {zipped:20}.");
PublishedDestination.Send(ls.Destination, zipped);
});
}
private InboundTunnel CreateInboundTunnel(ClientDestination dest, TunnelInfo prototype)
{
var config = new TunnelConfig(
TunnelConfig.TunnelDirection.Inbound,
TunnelConfig.TunnelPool.Client,
prototype == null ? CreateIncommingTunnelChain(dest): prototype);
var tunnel = (InboundTunnel)TunnelMgr.CreateTunnel(config);
if (tunnel != null)
{
tunnel.GarlicMessageReceived += new Action <GarlicMessage>(tunnel_GarlicMessageReceived);
TunnelMgr.AddTunnel(tunnel);
dest.AddInboundPending(tunnel);
lock (Destinations) Destinations[tunnel] = dest;
}
return(tunnel);
}
internal void TunnelBuildTimeout(Tunnel tunnel)
{
ClientDestination client = FindClient(tunnel);
if (client == null)
{
return;
}
client.RemoveTunnel(tunnel);
lock ( Destinations )
{
Destinations.Remove(tunnel);
}
var replace = FindReplaceRecord(tunnel);
if (replace != null)
{
DebugUtils.LogDebug("ClientTunnelProvider: TunnelBuildTimeout: Failed replacing " + replace.OldTunnel.ToString() +
" with " + tunnel.ToString());
if (replace.OldTunnel.Expired)
{
DebugUtils.LogDebug("ClientTunnelProvider: TunnelBuildTimeout: Old tunnel expired. " + replace.OldTunnel.ToString());
client.RemoveTunnel(replace.OldTunnel);
}
tunnel.Shutdown();
ReplaceTunnel(tunnel, client, replace);
}
else
{
/*
#if DEBUG
* DebugUtils.LogDebug( "ClientTunnelProvider: TunnelBuildTimeout: Unable to find a matching tunnel under replacement for " +
* tunnel.ToString() );
#endif
*/
}
}
internal void TunnelReplacementNeeded(Tunnel tunnel)
{
ClientDestination client = FindClient(tunnel);
if (client == null)
{
return;
}
TunnelUnderReplacement replace;
lock ( RunningReplacements )
{
if (!RunningReplacements.TryGetValue(tunnel, out replace))
{
return; // Already being replaced
}
// Too many tunnels already?
if (tunnel is InboundTunnel)
{
if (client.InboundTunnelsNeeded < 0)
{
return;
}
}
else
{
if (client.OutboundTunnelsNeeded < 0)
{
return;
}
}
replace = new TunnelUnderReplacement(tunnel, client);
lock ( RunningReplacements )
{
RunningReplacements[tunnel] = replace;
}
}
ReplaceTunnel(tunnel, client, replace);
}
internal void TunnelBuildTimeout(Tunnel tunnel)
{
ClientDestination client = FindClient(tunnel);
if (client == null)
{
return;
}
client.RemoveTunnel(tunnel);
lock ( Destinations )
{
Destinations.Remove(tunnel);
}
var replace = FindReplaceRecord(tunnel);
if (replace != null)
{
Logging.LogDebug($"ClientTunnelProvider: TunnelBuildTimeout: " +
$"Failed replacing {replace.OldTunnel} with {tunnel}");
if (replace.OldTunnel.Expired)
{
Logging.LogDebug($"ClientTunnelProvider: TunnelBuildTimeout: " +
$"Old tunnel expired. {replace.OldTunnel}");
client.RemoveTunnel(replace.OldTunnel);
}
tunnel.Shutdown();
ReplaceTunnel(tunnel, client, replace);
}
else
{
/*
* Logging.LogDebug( $"ClientTunnelProvider: TunnelBuildTimeout: " +
* $"Unable to find a matching tunnel under replacement for {tunnel}" );
*/
}
}
private void SpawnClient()
{
Client clientSpawned;
ClientData clientDataToSpawn;
GameObject clientSpawnedGameObject;
GameObject orderSpawnedGameObject;
clientDataToSpawn = (_isClientsInfinite) ? (_clientGenerator.GetNextClient()) : (_clientsList.Dequeue());
clientSpawnedGameObject = Instantiate(_clientGenericPrefab, ClientDestination.ComputeSpawnOrQuitPosition(), Quaternion.identity, transform);
if (!clientSpawnedGameObject.TryGetComponent <Client>(out clientSpawned))
{
Debug.LogError("Error: No Component 'Client' was found on gameObject '" + clientSpawnedGameObject.name + "'.");
}
else
{
orderSpawnedGameObject = Instantiate(_orderUIPrefab, Camera.main.WorldToScreenPoint(clientSpawnedGameObject.transform.GetChild(0).transform.position), Quaternion.identity, _orderParent);
clientSpawned.CreateClient(clientDataToSpawn, orderSpawnedGameObject.GetComponent <InteractibleOrder>());
orderSpawnedGameObject.SetActive(false);
}
}
static void Main(string[] args)
{
Logging.ReadAppConfig();
Logging.LogToDebug = false;
Logging.LogToConsole = true;
RouterContext.RouterSettingsFile = "EchoServerRouter.bin";
//RouterContext.Inst = new RouterContext(
//new I2PCertificate(
//I2PSigningKey.SigningKeyTypes.EdDSA_SHA512_Ed25519 ) );
for (int i = 0; i < args.Length; ++i)
{
switch (args[i])
{
case "--addr":
case "--address":
if (args.Length > i + 1)
{
RouterContext.Inst.DefaultExtAddress = IPAddress.Parse(args[++i]);
Console.WriteLine($"addr {RouterContext.Inst.DefaultExtAddress}");
}
else
{
Console.WriteLine("--addr require ip number");
return;
}
break;
case "--port":
if (args.Length > i + 1)
{
var port = int.Parse(args[++i]);
RouterContext.Inst.DefaultTCPPort = port;
RouterContext.Inst.DefaultUDPPort = port;
Console.WriteLine($"port {port}");
}
else
{
Console.WriteLine("--port require port number");
return;
}
break;
case "--nofw":
RouterContext.Inst.IsFirewalled = false;
Console.WriteLine($"Firewalled {RouterContext.Inst.IsFirewalled}");
break;
default:
Console.WriteLine(args[i]);
Console.WriteLine("Usage: I2P.exe --addr 12.34.56.78 --port 8081 --nofw");
break;
}
}
RouterContext.Inst.ApplyNewSettings();
Router.Start();
var destb32 = AppSettings["Destination"];
MyDestinationInfo = new I2PDestinationInfo(destb32);
PublishedDestination = Router.CreateDestination(MyDestinationInfo, true, out _);
PublishedDestination.DataReceived += MyDestination_DataReceived;
PublishedDestination.Name = "PublishedDestination";
Logging.LogInformation($"MyDestination: {PublishedDestination.Destination.IdentHash}.b32.i2p {MyDestinationInfo.Destination.Certificate}");
while (true)
{
try
{
Connected = true;
while (Connected)
{
Thread.Sleep(2000);
}
}
catch (SocketException ex)
{
Logging.Log(ex);
}
catch (IOException ex)
{
Logging.Log(ex);
}
catch (Exception ex)
{
Logging.Log(ex);
}
}
}
static void Main(string[] args)
{
Logging.ReadAppConfig();
Logging.LogToDebug = false;
Logging.LogToConsole = true;
RouterContext.RouterSettingsFile = "EchoClientRouter.bin";
RouterContext.Inst = new RouterContext(
new I2PCertificate(
I2PSigningKey.SigningKeyTypes.DSA_SHA1));
for (int i = 0; i < args.Length; ++i)
{
switch (args[i])
{
case "--addr":
case "--address":
if (args.Length > i + 1)
{
RouterContext.Inst.DefaultExtAddress = IPAddress.Parse(args[++i]);
Console.WriteLine($"addr {RouterContext.Inst.DefaultExtAddress}");
}
else
{
Console.WriteLine("--addr require ip number");
return;
}
break;
case "--port":
if (args.Length > i + 1)
{
var port = int.Parse(args[++i]);
RouterContext.Inst.DefaultTCPPort = port;
RouterContext.Inst.DefaultUDPPort = port;
Console.WriteLine($"port {port}");
}
else
{
Console.WriteLine("--port require port number");
return;
}
break;
case "--nofw":
RouterContext.Inst.IsFirewalled = false;
Console.WriteLine($"Firewalled {RouterContext.Inst.IsFirewalled}");
break;
default:
Console.WriteLine(args[i]);
Console.WriteLine("Usage: I2P.exe --addr 12.34.56.78 --port 8081 --nofw");
break;
}
}
RouterContext.Inst.ApplyNewSettings();
Router.Start();
var destb32 = AppSettings["RemoteDestination"];
var remotedest = new I2PIdentHash(destb32);
MyDestinationInfo = new I2PDestinationInfo(I2PSigningKey.SigningKeyTypes.EdDSA_SHA512_Ed25519);
UnpublishedDestination = Router.CreateDestination(MyDestinationInfo, false, out _);
UnpublishedDestination.DataReceived += MyDestination_DataReceived;
UnpublishedDestination.Name = "UnpublishedDestination";
Logging.LogInformation($"MyDestination: {UnpublishedDestination.Destination.IdentHash} {MyDestinationInfo.Destination.Certificate}");
var interval = new PeriodicAction(TickSpan.Seconds(40));
while (true)
{
try
{
Connected = true;
while (Connected)
{
Thread.Sleep(2000);
uint recvid = BufUtils.RandomUintNZ();
interval.Do(() =>
{
Logging.LogInformation($"Program {UnpublishedDestination}: Looking for {remotedest}.");
UnpublishedDestination.LookupDestination(remotedest, (hash, ls, tag) =>
{
if (ls is null)
{
Logging.LogInformation($"Program {UnpublishedDestination}: Failed to lookup {hash.Id32Short}.");
return;
}
var test = new I2PIdentHash(ls.Destination);
Logging.LogInformation($"Program {UnpublishedDestination}: Found {remotedest}, test: {test.Id32Short}.");
var s = new BufRefStream();
var sh = new StreamingPacket(
PacketFlags.SYNCHRONIZE
| PacketFlags.FROM_INCLUDED
| PacketFlags.SIGNATURE_INCLUDED
| PacketFlags.MAX_PACKET_SIZE_INCLUDED
| PacketFlags.NO_ACK)
{
From = UnpublishedDestination.Destination,
SigningKey = MyDestinationInfo.PrivateSigningKey,
ReceiveStreamId = recvid,
NACKs = new List <uint>(),
Payload = new BufLen(new byte[0]),
};
sh.Write(s);
var buf = s.ToByteArray();
var zipped = LZUtils.BCGZipCompressNew(new BufLen(buf));
zipped.PokeFlip16(4353, 4); // source port
zipped.PokeFlip16(25, 6); // dest port
zipped[9] = (byte)PayloadFormat.Streaming; // streaming
Logging.LogInformation($"Program {UnpublishedDestination}: Sending {zipped:20}.");
UnpublishedDestination.Send(ls.Destination, zipped);
});
});
}
}
catch (SocketException ex)
{
Logging.Log(ex);
}
catch (IOException ex)
{
Logging.Log(ex);
}
catch (Exception ex)
{
Logging.Log(ex);
}
}
}
static void MyOrigin_ClientStateChanged(ClientDestination dest, ClientDestination.ClientStates state)
{
Logging.LogInformation($"Program {MyOrigin}: Client state {state}");
}
static void MyOrigin_DataReceived(ClientDestination dest, BufLen data)
{
Logging.LogInformation($"Program {MyOrigin}: data received. {data:15}");
}
static void Main(string[] args)
{
PeriodicAction SendInterval = new PeriodicAction(TickSpan.Seconds(20));
Logging.ReadAppConfig();
Logging.LogToDebug = false;
Logging.LogToConsole = true;
RouterContext.RouterSettingsFile = "I2PDemo.bin";
MyDestinationInfo = new I2PDestinationInfo(I2PSigningKey.SigningKeyTypes.EdDSA_SHA512_Ed25519);
for (int i = 0; i < args.Length; ++i)
{
switch (args[i])
{
case "--addr":
case "--address":
if (args.Length > i + 1)
{
RouterContext.Inst.DefaultExtAddress = IPAddress.Parse(args[++i]);
Console.WriteLine($"addr {RouterContext.Inst.DefaultExtAddress}");
}
else
{
Console.WriteLine("--addr require ip number");
return;
}
break;
case "--port":
if (args.Length > i + 1)
{
var port = int.Parse(args[++i]);
RouterContext.Inst.DefaultTCPPort = port;
RouterContext.Inst.DefaultUDPPort = port;
Console.WriteLine($"port {port}");
}
else
{
Console.WriteLine("--port require port number");
return;
}
break;
case "--nofw":
RouterContext.Inst.IsFirewalled = false;
Console.WriteLine($"Firewalled {RouterContext.Inst.IsFirewalled}");
break;
case "--mkdest":
case "--create-destination":
var certtype = 0;
if (args.Length > i + 1)
{
certtype = int.Parse(args[++i]);
}
I2PSigningKey.SigningKeyTypes ct;
I2PDestinationInfo d;
switch (certtype)
{
default:
case 0:
ct = I2PSigningKey.SigningKeyTypes.EdDSA_SHA512_Ed25519;
d = new I2PDestinationInfo(ct);
break;
case 1:
ct = I2PSigningKey.SigningKeyTypes.DSA_SHA1;
d = new I2PDestinationInfo(ct);
break;
case 2:
ct = I2PSigningKey.SigningKeyTypes.ECDSA_SHA256_P256;
d = new I2PDestinationInfo(ct);
break;
case 3:
ct = I2PSigningKey.SigningKeyTypes.ECDSA_SHA384_P384;
d = new I2PDestinationInfo(ct);
break;
}
Console.WriteLine($"New destination {ct}: {d.ToBase64()}");
return;
case "--destination":
if (args.Length > i + 1)
{
MyDestinationInfo = new I2PDestinationInfo(args[++i]);
Console.WriteLine($"Destination {MyDestinationInfo}");
}
else
{
Console.WriteLine("Base64 encoded Destination required");
return;
}
break;
default:
Console.WriteLine(args[i]);
Console.WriteLine("Usage: I2P.exe --addr 12.34.56.78 --port 8081 --nofw --create-destination [0-3] --destination b64...");
break;
}
}
RouterContext.Inst.ApplyNewSettings();
var pnp = new UPnp();
Thread.Sleep(5000); // Give UPnp a chance
Router.Start();
// Create new identities for this run
MyDestination = MyDestinationInfo.Destination;
#if MANUAL_SIGN
PublishedDestination = Router.CreateDestination(
MyDestination,
MyDestinationInfo.PrivateKey,
true,
out _); // Publish our destinaiton
PublishedDestination.SignLeasesRequest += MyDestination_SignLeasesRequest;
#else
PublishedDestination = Router.CreateDestination(MyDestinationInfo, true, out _); // Publish our destinaiton
#endif
PublishedDestination.DataReceived += MyDestination_DataReceived;
PublishedDestination.Name = "PublishedDestination";
MyOriginInfo = new I2PDestinationInfo(I2PSigningKey.SigningKeyTypes.DSA_SHA1);
MyOrigin = Router.CreateDestination(MyOriginInfo, false, out _);
MyOrigin.ClientStateChanged += MyOrigin_ClientStateChanged;
MyOrigin.DataReceived += MyOrigin_DataReceived;
MyOrigin.Name = "MyOrigin";
Logging.LogInformation($"MyDestination: {PublishedDestination.Destination.IdentHash} {MyDestinationInfo.Destination.Certificate}");
while (true)
{
try
{
Connected = true;
MyOrigin.LookupDestination(PublishedDestination.Destination.IdentHash, LookupResult);
var sendevents = 0;
while (Connected)
{
Thread.Sleep(2000);
if (LookedUpDestination != null &&
MyOrigin.ClientState == ClientDestination.ClientStates.Established)
{
SendInterval.Do(() =>
{
if (sendevents++ < 10)
{
// Send some data to the MyDestination
DataSent = new BufLen(
BufUtils.RandomBytes(
(int)(1 + BufUtils.RandomDouble(25) * 1024)));
var ok = MyOrigin.Send(LookedUpDestination, DataSent);
Logging.LogInformation($"Program {MyOrigin}: Send[{sendevents}] {ok}, {DataSent:15}");
}
if (sendevents > 100)
{
sendevents = 0;
}
});
}
}
}
catch (SocketException ex)
{
Logging.Log(ex);
}
catch (IOException ex)
{
Logging.Log(ex);
}
catch (Exception ex)
{
Logging.Log(ex);
}
}
}
internal TunnelUnderReplacement(Tunnel old, ClientDestination dest)
{
OldTunnel = old;
Destination = dest;
}
