internal void IntroductionRelayOffered(IntroducerInfo intro)
{
if (!RouterContext.Inst.IsFirewalled)
{
return;
}
Logging.LogTransport($"SSU Introduction: Added introducer {intro.Host}, {intro.IntroKey}, {intro.IntroTag}, {intro.EndPoint}");
switch (GatherIntroducersState)
{
case GatherIntroducersStates.Startup:
ConsiderUpdateIntroducers.Do(() =>
{
var intros = SelectIntroducers()
.Select(p => p.Left.RemoteIntroducerInfo);
if (intros.Any())
{
SetIntroducers(intros);
ConsiderUpdateIntroducers.Frequency = TickSpan.Minutes(10);
GatherIntroducersState = GatherIntroducersStates.Established;
}
});
break;
case GatherIntroducersStates.Established:
ConsiderUpdateIntroducers.Do(() =>
{
SetIntroducers(SelectIntroducers()
.Select(p => p.Left.RemoteIntroducerInfo));
});
break;
}
}
public override SSUState Run()
{
if (Timeout(HandshakeStateTimeoutSeconds))
{
if (Session.RemoteRouterIdentity != null)
{
NetDb.Inst.Statistics.SlowHandshakeConnect(Session.RemoteRouterIdentity.IdentHash);
}
throw new FailedToConnectException("SSU " + Session.DebugId + " Failed to connect. Timeout.");
}
if (Request == null)
{
return(this);
}
ResendSessionCreatedAction.Do(() =>
{
if (++Retries > HandshakeStateMaxRetries)
{
throw new FailedToConnectException("SSU " + Session.DebugId + " Failed to connect. Too many retries.");
}
DebugUtils.Log("SSU SessionCreatedState " + Session.DebugId + " : Resending SessionCreated message.");
SendSessionCreated();
});
return(this);
}
public void Execute()
{
TunnelBuild.Do(() =>
{
try
{
BuildNewTunnels();
}
catch (Exception ex)
{
Logging.Log("ClientTunnelProvider Execute BuildNewTunnels", ex);
}
});
DestinationExecute.Do(() =>
{
var dests = Destinations.Select(d => d.Value).ToArray();
foreach (var onedest in dests)
{
try
{
onedest.Execute();
}
catch (Exception ex)
{
Logging.Log("ClientTunnelProvider Execute DestExecute", ex);
}
}
ReplaceTunnels.Do(CheckForTunnelReplacementTimeout);
LogStatus.Do(LogStatusReport);
});
}
public IEnumerable <DataFragment> NotAckedFragments()
{
RemoveOldMessages.Do(() =>
{
CleanUpOldMessages();
});
lock ( AckQueue )
{
var one = AckQueue.First;
while (one != null)
{
var next = one.Next;
if (!one.Value.AllFragmentsAcked)
{
var naf = one.Value.NotAckedFragments();
foreach (var frag in naf)
{
yield return(frag);
}
}
else
{
AckQueue.Remove(one);
}
one = next;
}
}
}
public override SSUState Run()
{
if (Timeout(HandshakeStateTimeout * 4))
{
Session.Host.EPStatisitcs.ConnectionTimeout(Session.RemoteEP);
if (Session.RemoteRouterIdentity != null)
{
NetDb.Inst.Statistics.SlowHandshakeConnect(Session.RemoteRouterIdentity.IdentHash);
}
throw new FailedToConnectException($"SSU {this}: Failed to connect. Timeout.");
}
ResendSessionRequestAction.Do(() =>
{
if (++Retries > HandshakeStateMaxRetries)
{
throw new FailedToConnectException($"SSU {this}: Failed to connect. Too many retries.");
}
SendSessionRequest();
});
return(this);
}
public override SSUState Run()
{
if (Timeout(HandshakeStateTimeout * 2))
{
Session.Host.EPStatisitcs.ConnectionTimeout(Session.RemoteEP);
if (Session.RemoteRouterIdentity != null)
{
NetDb.Inst.Statistics.SlowHandshakeConnect(Session.RemoteRouterIdentity.IdentHash);
}
Session.Host.ReportEPProblem(Session.RemoteEP);
throw new FailedToConnectException($"SSU {Session.DebugId} Failed to connect. Timeout.");
}
if (Request == null)
{
return(this);
}
ResendSessionCreatedAction.Do(() =>
{
if (++Retries > HandshakeStateMaxRetries)
{
throw new FailedToConnectException($"SSU {Session.DebugId} Failed to connect. Too many retries.");
}
Logging.LogTransport($"SSU SessionCreatedState {Session.DebugId} : Resending SessionCreated message.");
SendSessionCreated();
});
return(this);
}
public override SSUState Run()
{
if (NextState != null)
{
Session.Host.RelayResponseReceived -= Host_RelayResponseReceived;
return(NextState);
}
// Extra time because of introduction negotiation delay
if (Timeout(HandshakeStateTimeout * 2))
{
Session.Host.RelayResponseReceived -= Host_RelayResponseReceived;
throw new FailedToConnectException($"SSU RelayRequestState {Session.DebugId} Failed to connect. Timeout.");
}
ResendRelayRequestAction.Do(() =>
{
if (++Retries > RelayRequestStateMaxRetries)
{
Session.Host.RelayResponseReceived -= Host_RelayResponseReceived;
throw new FailedToConnectException($"SSU {Session.DebugId} RelayRequestState, too many retries.");
}
SendRelayRequest();
});
return(this);
}
public override bool Exectue()
{
var ok = true;
PreTunnelDataBatching.Do(() => { ok = HandleReceiveQueue(); });
return(ok);
}
private void Run()
{
try
{
var ntcphost = new NTCPHost();
ntcphost.ConnectionCreated += new Action <ITransport>(ntcphost_ConnectionCreated);
SsuHost.ConnectionCreated += new Action <ITransport>(SsuHost_ConnectionCreated);
while (!Terminated)
{
try
{
Thread.Sleep(1000);
var known = CurrentlyUnknownRouters.FindKnown();
foreach (var found in known)
{
foreach (var msg in found.Messages)
{
Logging.LogTransport("TransportProvider: Destination " + found.Destination.Id32Short + " found. Sending data.");
TransportProvider.Send(found.Destination, msg);
}
}
ActiveConnectionLog.Log(() => string.Format("TransportProvider: Running: {0}. Established: {1}.",
RunningTransports.Count,
EstablishedTransports.Count));
DropOldExceptions.Do(delegate
{
lock ( AddressesWithExceptions )
{
var remove = AddressesWithExceptions.Where(eh =>
eh.Value.Generated.DeltaToNow.ToMinutes >= ExeptionHistoryLifetimeMinutes).Select(eh => eh.Key).ToArray();
foreach (var one in remove)
{
AddressesWithExceptions.Remove(one);
}
}
});
}
catch (ThreadAbortException ex)
{
Logging.Log(ex);
}
catch (Exception ex)
{
Logging.Log(ex);
}
}
}
finally
{
Terminated = true;
}
}
internal void Run()
{
Resend.Do(() =>
{
try
{
List <KeyValuePair <II2NPHeader16, GarlicCreationInfo> > tosend = new List <KeyValuePair <II2NPHeader16, GarlicCreationInfo> >();
lock ( Window )
{
var resend = Window.Where(gci => gci.Value.LastSend.DeltaToNow > GarlicTimeBetweenResends);
if (WaitingForEGAck != null && WaitingForEGAck.DeltaToNow > GarlicTimeBetweenResends)
{
DebugUtils.LogDebug("TagsTransferWindow: Run: ElGamal message needs to be resent. Starting over.");
Session.Reset();
}
foreach (var one in resend.ToArray())
{
var egmsg = Session.Encrypt(true, one.Value.TrackingId, one.Value.Cloves);
var npmsg = new GarlicMessage(egmsg.Garlic).GetHeader16(I2NPHeader.GenerateMessageId());
one.Value.LastSend.SetNow();
tosend.Add(new KeyValuePair <II2NPHeader16, GarlicCreationInfo>(npmsg, egmsg));
if (WaitingForEGAck == null && !one.Value.AckMessageId.HasValue)
{
// Non explicit ack cloves that should not be retransmitted any more.
Window.Remove(one.Key);
}
}
}
foreach (var pair in tosend)
{
DebugUtils.LogDebug(string.Format("TagsTransferWindow: Resend: ({0}) TrackingId: {1}, Ack MessageId: {2}.",
pair.Value.KeyType, pair.Value.TrackingId, pair.Value.AckMessageId));
if (pair.Value.AckMessageId.HasValue)
{
lock ( OutstandingMessageIds )
{
OutstandingMessageIds[pair.Value.AckMessageId.Value] = pair.Value;
}
}
TunnelSelector(Session.LatestRemoteLeaseSet, pair.Key, pair.Value);
}
}
catch (Exception ex)
{
Session.Reset();
DebugUtils.Log("TagsTransferWindow Run", ex);
}
});
}
internal bool IsFiltered(IPAddress addr)
{
Decay.Do(() =>
{
var toremove = new List <IPAddress>();
lock ( MonitorIPWindow )
{
foreach (var one in MonitorIPWindow)
{
var startcount = one.Value.Count;
while (one.Value.Count > 0 && one.Value.Last.Value.DeltaToNow.ToMinutes > IPFaultHistoryWindowMinutes)
{
one.Value.RemoveLast();
}
if (startcount >= NumberOfFailuresToBlock && one.Value.Count < NumberOfFailuresToBlock)
{
Logging.LogTransport("DecayingIPBlockFilter: Window under blocking level " + one.Key.ToString());
toremove.Add(one.Key);
}
else
if (one.Value.Count == 0)
{
toremove.Add(one.Key);
}
}
foreach (var remove in toremove)
{
MonitorIPWindow.Remove(remove);
}
}
});
lock ( BlockedIPs )
{
TickCounter blocktime;
if (BlockedIPs.TryGetValue(addr, out blocktime))
{
if (blocktime.DeltaToNow.ToMinutes > BlockTimeMinutes)
{
Logging.LogTransport("DecayingIPBlockFilter: Unblocking " + addr.ToString());
BlockedIPs.Remove(addr);
return(false);
}
return(true);
}
return(false);
}
}
public override bool Exectue()
{
FragBufferReport.Do(delegate()
{
var fbsize = Reassembler.BufferedFragmentCount;
DebugUtils.Log("EndpointTunnel: " + Destination.Id32Short + " Fragment buffer size: " + fbsize.ToString());
if (fbsize > 2000)
{
throw new Exception("BufferedFragmentCount > 2000 !"); // Trying to fill my memory?
}
});
return(HandleReceiveQueue());
}
private void Run()
{
try
{
DebugUtils.LogInformation("NetDb: Path: " + NetDbPath);
DebugUtils.Log("Reading NetDb...");
var sw1 = new Stopwatch();
sw1.Start();
Load();
sw1.Stop();
DebugUtils.Log(string.Format("Done reading NetDb. {0}. {1} entries.", sw1.Elapsed, RouterInfos.Count));
LoadFinished.Set();
while (TransportProvider.Inst == null)
{
Thread.Sleep(500);
}
var PeriodicSave = new PeriodicAction(TickSpan.Minutes(5));
var PeriodicFFUpdate = new PeriodicAction(TickSpan.Seconds(5));
var FloodfillUpdate = new FloodfillUpdater();
while (!Terminated)
{
try
{
PeriodicSave.Do(() => Save(true));
PeriodicFFUpdate.Do(() => FloodfillUpdate.Run());
IdentHashLookup.Run();
Thread.Sleep(2000);
}
catch (ThreadAbortException ex)
{
DebugUtils.Log(ex);
Terminated = true;
}
catch (Exception ex)
{
DebugUtils.Log(ex);
}
}
}
finally
{
Terminated = true;
}
}
public override bool Exectue()
{
if (Terminated || RemoteGateway == null)
{
return(false);
}
FragBufferReport.Do(delegate()
{
var fbsize = Reassembler.BufferedFragmentCount;
DebugUtils.Log("InboundTunnel " + TunnelDebugTrace + ": " + Destination.Id32Short + " Fragment buffer size: " + fbsize.ToString());
if (fbsize > 2000)
{
throw new Exception("BufferedFragmentCount > 2000 !"); // Trying to fill my memory?
}
});
return(HandleReceiveQueue() && HandleSendQueue());
}
public override bool Exectue()
{
if (Terminated || RemoteGateway == null)
{
return(false);
}
FragBufferReport.Do(delegate()
{
var fbsize = Reassembler.BufferedFragmentCount;
Logging.Log($"{this}: {Destination.Id32Short} Fragment buffer size: {fbsize}");
if (fbsize > 2000)
{
throw new Exception("BufferedFragmentCount > 2000 !"); // Trying to fill my memory?
}
});
return(HandleReceiveQueue() && HandleSendQueue());
}
public override SSUState Run()
{
if (NextState != null)
{
Session.Host.RelayResponseReceived -= Host_RelayResponseReceived;
return(NextState);
}
if (Timeout(HandshakeStateTimeoutSeconds))
{
Session.Host.RelayResponseReceived -= Host_RelayResponseReceived;
throw new FailedToConnectException("SSU RelayRequestState {Session.DebugId} Failed to connect. Timeout.");
}
ResendRelayRequestAction.Do(() =>
{
if (++Retries > RelayRequestStateMaxRetries)
{
Logging.LogTransport($"SSU RelayRequestState: {Session.DebugId}" +
$" Using introducer '{CurrentIntroducer.EndPoint}' timed out.");
if (Introducers.Count == 0)
{
Session.Host.RelayResponseReceived -= Host_RelayResponseReceived;
throw new FailedToConnectException($"SSU +{Session.TransportInstance}+ Failed to find a non established introducer");
}
else
{
CurrentIntroducer = Introducers[0];
Introducers.RemoveAt(0);
Logging.LogTransport($"SSU RelayRequestState: +{Session.TransportInstance}+ " +
$"Trying introducer '{CurrentIntroducer.EndPoint}' next.");
Retries = 0;
}
}
SendRelayRequest();
});
return(this);
}
public override SSUState Run()
{
if (Timeout(HandshakeStateTimeoutSeconds))
{
throw new FailedToConnectException("SSU SessionRequestState " + Session.DebugId + " Failed to connect. Timeout.");
}
ResendSessionRequestAction.Do(() =>
{
if (++Retries > HandshakeStateMaxRetries)
{
throw new FailedToConnectException("SSU SessionRequestState " + Session.DebugId + " Failed to connect. Too many retries.");
}
SendSessionRequest();
});
return(this);
}
internal void Execute()
{
if (TestRemoteDest != null &&
OutboundEstablishedPool.Count >= 2 &&
InboundEstablishedPool.Count >= 2 &&
TestRemoteDest.InboundEstablishedPool.Count >= 2)
{
try
{
SendNewData.Do(() =>
{
var dest = TestRemoteDest.MyDestination;
var origmessage = new DeliveryStatusMessage(I2NPHeader.GenerateMessageId());
var big = BufUtils.RandomInt(100) < 5;
Destinations.Send(dest, true,
new GarlicCloveDeliveryDestination(
origmessage, dest.IdentHash),
(big ?
new GarlicCloveDeliveryDestination(BigMessage, dest.IdentHash) :
new GarlicCloveDeliveryDestination(origmessage, dest.IdentHash)));
});
}
catch (Exception ex)
{
SendNewData.Reset();
DebugUtils.Log(ex);
}
}
QueueStatusLog.Do(() =>
{
DebugUtils.LogInformation(string.Format(
"ClientTunnelProvider {4}: Established tunnels in: {0,2}, out: {1,2}. Pending in: {2,2}, out {3,2}",
InboundEstablishedPool.Count, OutboundEstablishedPool.Count,
InboundPending.Count, OutboundPending.Count, MyDestination.IdentHash.Id32Short));
});
Destinations.Run();
}
public override SSUState Run()
{
if (Timeout(HandshakeStateTimeoutSeconds))
{
if (Session.RemoteRouterIdentity != null)
{
NetDb.Inst.Statistics.SlowHandshakeConnect(Session.RemoteRouterIdentity.IdentHash);
}
throw new FailedToConnectException("SSU SessionConfirmedState " + Session.DebugId + " Failed to connect. Timeout.");
}
ResendSessionConfirmedAction.Do(() =>
{
if (++Retries > HandshakeStateMaxRetries)
{
throw new FailedToConnectException("SSU " + Session.DebugId + " Failed to connect");
}
Logging.LogTransport("SSU SessionConfirmedState " + Session.DebugId + " : Resending SessionConfirmed message.");
// SendFragmentedSessionConfirmed(); // Not all routers seem to support this
/**
* From InboundEstablishState.java
*
* -----8<-----
* Note that while a SessionConfirmed could in theory be fragmented,
* in practice a RouterIdentity is 387 bytes and a single fragment is 512 bytes max,
* so it will never be fragmented.
* -----8<-----
*/
SendUnfragmentedSessionConfirmed();
});
return(this);
}
public override SSUState Run()
{
// Idle
if (Timeout(InactivityTimeoutSeconds))
{
DebugUtils.LogDebug(() => string.Format("SSU EstablishedState {0}: Inactivity timeout. Sending SessionDestroyed.", Session.DebugId));
SendSessionDestroyed();
return(null);
}
if (Session.Defragmenter.GotAcks || Session.SendQueue.Count > 0 || Session.Fragmenter.GotUnsentFragments)
{
do
{
SendAcksAndData();
} while (Session.SendQueue.Count > 0);
}
ResendFragmentsAction.Do(delegate
{
if (Session.Fragmenter.AllFragmentsAcked)
{
return;
}
ResendNotAcked(Session.Fragmenter.NotAckedFragments());
});
if (Session.QueuedFirstPeerTestToCharlie != null)
{
SendFirstPeerTestToCharlie(Session.QueuedFirstPeerTestToCharlie);
Session.QueuedFirstPeerTestToCharlie = null;
}
return(this);
}
internal void Execute()
{
TunnelBuild.Do(() =>
{
try
{
BuildNewTunnels();
}
catch (Exception ex)
{
DebugUtils.Log("ClientTunnelProvider Execute BuildNewTunnels", ex);
}
});
DestinationExecute.Do(() =>
{
ClientDestination[] dests;
lock ( Destinations )
{
dests = Destinations.Select(d => d.Value).ToArray();
}
foreach (var onedest in dests)
{
try
{
onedest.Execute();
}
catch (Exception ex)
{
DebugUtils.Log("ClientTunnelProvider Execute DestExecute", ex);
}
}
});
}
internal void Execute()
{
TunnelBuild.Do(() => BuildNewTunnels());
}
static void Main(string[] args)
{
PeriodicAction LsLookup = new PeriodicAction(TickSpan.Minutes(5));
DebugUtils.LogToConsole = true;
DebugUtils.LogToFile("i2p.log");
DebugUtils.LogInformation("Me: " + RouterContext.Inst.MyRouterIdentity.IdentHash.Id32);
for (int i = 0; i < args.Length; ++i)
{
switch (args[i])
{
case "--addr":
if (args.Length > i)
{
RouterContext.Inst.DefaultExtAddress = IPAddress.Parse(args[++i]);
}
break;
case "--port":
if (args.Length > i)
{
var port = int.Parse(args[++i]);
RouterContext.Inst.DefaultTCPPort = port;
RouterContext.Inst.DefaultUDPPort = port;
}
break;
case "--nofw":
RouterContext.Inst.IsFirewalled = false;
break;
default:
Console.WriteLine("Usage: I2P.exe --addr 12.34.56.78 --port 8081 --nofw");
break;
}
}
RouterContext.Inst.ApplyNewSettings();
var pnp = new UPnp();
Thread.Sleep(5000); // Give UPnp a chance
Router.Start();
while (true)
{
try
{
Connected = true;
var dest = new I2PDestinationInfo(I2PSigningKey.SigningKeyTypes.EdDSA_SHA512_Ed25519);
var mydest = Router.CreateDestination(dest, false);
mydest.DataReceived += new ClientDestination.DestinationDataReceived(mydest_DataReceived);
var hashes = new I2PIdentHash[] {
new I2PIdentHash("udhdrtrcetjm5sxaskjyr5ztseszydbh4dpl3pl4utgqqw2v4jna.b32.i2p"),
new I2PIdentHash("7tbay5p4kzemkxvyvbf6v7eau3zemsnnl2aoyqhg5jzpr5eke7tq.b32.i2p"),
new I2PIdentHash("ukeu3k5oycga3uneqgtnvselmt4yemvoilkln7jpvafvfx7dnkdq.b32.i2p")
};
while (Connected)
{
Thread.Sleep(20000);
/*
* if ( LS != null )
* {
* mydest.Send( LS, BufUtils.Random( 200 ), false );
* }*/
LsLookup.Do(() => mydest.LookupDestination(hashes.Random(), new ClientDestination.DestinationLookupResult(LookupResult)));
}
}
catch (SocketException ex)
{
DebugUtils.Log(ex);
}
catch (IOException ex)
{
DebugUtils.Log(ex);
}
catch (Exception ex)
{
DebugUtils.Log(ex);
}
}
}
public void SendAcks(BufRefLen writer, out bool explicitacks, out bool bitfieldsacks)
{
RemoveOldMessages.Do(() =>
{
RemoveExpired();
});
List <RebuildI2NPMessage> expl = null;
List <RebuildI2NPMessage> bitm = null;
var space = writer.Length;
var remainingackmsgs = AckQueue.Count;
while (space > 30 &&
(expl == null || expl.Count < MaxExplicitAcksPerMessage) &&
(bitm == null || bitm.Count < MaxBitmapAcksPerMessage) &&
remainingackmsgs-- > 0)
{
RebuildI2NPMessage msg = null;
lock ( AckQueue )
{
if (AckQueue.Count == 0)
{
break;
}
var lln = AckQueue.Last;
msg = lln.Value;
if (msg.AckSent.DeltaToNowMilliseconds < MillisecondsBetweenAcks)
{
continue;
}
AckQueue.RemoveLast();
bool resendsok;
if (msg.AllFragmentsFound)
{
resendsok = msg.ExplicitAcksSent < NumberOfExplicitAckResends;
}
else
{
resendsok = msg.BitmapAcksSent < NumberOfBitmapAckResends;
}
if (resendsok && msg != null)
{
AckQueue.AddFirst(lln);
}
}
if (msg == null)
{
continue;
}
if (msg.AllFragmentsFound)
{
if (expl == null)
{
expl = new List <RebuildI2NPMessage>(MaxExplicitAcksPerMessage);
space -= 1;
}
space -= 4;
expl.Add(msg);
}
else
{
if (bitm == null)
{
bitm = new List <RebuildI2NPMessage>(MaxBitmapAcksPerMessage);
space -= 1;
}
space -= msg.AckBitmapSize;
bitm.Add(msg);
}
}
if (expl != null)
{
writer.Write8((byte)expl.Count);
foreach (var msg in expl)
{
#if LOG_ALL_TRANSPORT
Logging.LogTransport("SSU DataDefragmenter sent expl ack: " + msg.MessageId.ToString() + " (" + msg.ExplicitAcksSent.ToString() + ")");
#endif
writer.Write32(msg.MessageId);
msg.AckSent.SetNow();
++msg.ExplicitAcksSent;
}
}
if (bitm != null)
{
writer.Write8((byte)bitm.Count);
foreach (var msg in bitm)
{
#if LOG_ALL_TRANSPORT
Logging.LogTransport("SSU DataDefragmenter sent bitmap ack: " + msg.MessageId.ToString());
#endif
writer.Write32(msg.MessageId);
writer.Write(msg.AckBitmap());
msg.AckSent.SetNow();
++msg.BitmapAcksSent;
}
}
explicitacks = expl != null;
bitfieldsacks = bitm != null;
}
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);
}
}
}
private void Run()
{
try
{
var ntcphost = new NTCPHost();
ntcphost.ConnectionCreated += NTCPhost_ConnectionCreated;
SsuHost.ConnectionCreated += SSUHost_ConnectionCreated;
while (!Terminated)
{
try
{
Thread.Sleep(1000);
var known = CurrentlyUnknownRouters.FindKnown();
foreach (var found in known)
{
foreach (var msg in found.Messages)
{
Logging.LogTransport($"TransportProvider: Destination {found.Destination.Id32Short} found. Sending data.");
TransportProvider.Send(found.Destination, msg);
}
}
#if DEBUG
ActiveConnectionLog.Do(() =>
{
var ntcprunning = RunningTransports.Where(t => t.Protocol == "NTCP").ToArray();
var ssurunning = RunningTransports.Where(t => t.Protocol == "SSU").ToArray();
var ntcpestablished = EstablishedTransports.SelectMany(t => t.Value.Where(t2 => t2.Key.Protocol == "NTCP")).ToArray();
var ssuestablished = EstablishedTransports.SelectMany(t => t.Value.Where(t2 => t2.Key.Protocol == "SSU")).ToArray();
Logging.LogDebug(
$"TransportProvider: Established out/in " +
$"({ssuestablished.Count( t => t.Key.Outgoing )}/{ssurunning.Count( t => t.Outgoing )})/" +
$"({ssuestablished.Count( t => !t.Key.Outgoing )}/{ssurunning.Count( t => !t.Outgoing )}) SSU, " +
$"({ntcpestablished.Count( t => t.Key.Outgoing )}/{ntcprunning.Count( t => t.Outgoing )})/" +
$"({ntcpestablished.Count( t => !t.Key.Outgoing )}/{ntcprunning.Count( t => !t.Outgoing )}) NTCP.");
var ntcpsent = ntcprunning.Sum(t => t.BytesSent);
var ntcprecv = ntcprunning.Sum(t => t.BytesReceived);
var ssusent = ssurunning.Sum(t => t.BytesSent);
var ssurecv = ssurunning.Sum(t => t.BytesReceived);
Logging.LogDebug(
$"TransportProvider: send / recv " +
$"SSU: {BytesToReadable( ssusent ),12} / {BytesToReadable( ssurecv ),12} " +
$"NTCP: {BytesToReadable( ntcpsent ),12} / {BytesToReadable( ntcprecv ),12}");
});
#endif
DropOldExceptions.Do(delegate
{
lock ( AddressesWithExceptions )
{
var remove = AddressesWithExceptions.Where(eh =>
eh.Value.Generated.DeltaToNow.ToMinutes >= ExeptionHistoryLifetimeMinutes).Select(eh => eh.Key).ToArray();
foreach (var one in remove)
{
AddressesWithExceptions.Remove(one);
}
}
});
}
catch (ThreadAbortException ex)
{
Logging.Log(ex);
}
catch (Exception ex)
{
Logging.Log(ex);
}
}
}
finally
{
Terminated = true;
}
}
internal void Execute()
{
TunnelBuild.Do(BuildNewTunnels);
}
public override SSUState Run()
{
// Idle
if (Timeout(InactivityTimeout))
{
Logging.LogTransport($"SSU EstablishedState {Session.DebugId}: Inactivity timeout. Sending SessionDestroyed.");
SendSessionDestroyed();
return(null);
}
UpdateSessionLengthStats.Do(() =>
Session.Host.EPStatisitcs.UpdateSessionLength(
Session.RemoteEP,
Session.StartTime.DeltaToNow));
var dosend = Session.Defragmenter.GotAcks ||
(!Session.SendQueue.IsEmpty) ||
Session.Fragmenter.GotUnsentFragments;
TickSpan timeout = null;
if (!dosend)
{
if (SessionLayer.RouterContext.Inst.IsFirewalled)
{
if (Session.IsIntroducerConnection)
{
timeout = IntroducerKeepaliveTimeout;
}
else
{
timeout = NonIntroducerKeepaliveTimeout;
}
}
else
{
timeout = NotFirewalledKeepaliveTimeout;
}
}
if (!dosend && LastIntroducerKeepalive.DeltaToNow > timeout)
{
dosend = true;
#if LOG_MUCH_TRANSPORT
Logging.LogTransport($"SSU EstablishedState {Session.DebugId}:" +
$"{(Session.IsIntroducerConnection ? " Introducer" : "")} keepalive.");
#endif
LastIntroducerKeepalive.SetNow();
}
if (dosend)
{
do
{
SendAcksAndData();
} while (!Session.SendQueue.IsEmpty);
}
ResendFragmentsAction.Do(delegate
{
if (Session.Fragmenter.AllFragmentsAcked)
{
return;
}
ResendNotAcked(Session.Fragmenter.NotAckedFragments());
});
if (Session.QueuedFirstPeerTestToCharlie != null)
{
SendFirstPeerTestToCharlie(Session.QueuedFirstPeerTestToCharlie);
Session.QueuedFirstPeerTestToCharlie = null;
}
return(this);
}
public void Execute()
{
LogStatus.Do(LogStatusReport);
}
public IEnumerable <TunnelMessage> Process(IEnumerable <TunnelDataMessage> tdmsgs)
{
var result = new List <TunnelMessage>();
RemoveUnmatchedFragments.Do(() =>
{
lock ( MessageFragments )
{
var remove = MessageFragments.Where(p => p.Value.Created.DeltaToNow.ToMinutes > RememberUnmatchedFragmentsForMinutes).
Select(p => p.Key).ToArray();
foreach (var key in remove)
{
Logging.LogDebug("TunnelDataFragmentReassembly: Removing old unmatched fragment for " + key.ToString());
MessageFragments.Remove(key);
}
}
});
foreach (var msg in tdmsgs)
{
var hash = I2PHashSHA256.GetHash(msg.TunnelDataPayload, msg.IV);
var eq = BufUtils.Equal(msg.Checksum.PeekB(0, 4), 0, hash, 0, 4);
if (!eq)
{
// Do not stop processing, just throw away faulty data
// throw new SignatureCheckFailureException( "TunnelDataFragmentReassembly: SHA256 check failed in TunnelData" );
Logging.LogDebug("TunnelDataFragmentReassembly: SHA256 check failed in TunnelData");
continue;
}
var reader = (BufRefLen)msg.TunnelDataPayload;
while (reader.Length > 0)
{
var frag = new TunnelDataFragment(reader);
if (frag.FollowOnFragment)
{
List <TunnelDataFragment> fragments;
if (!MessageFragments.ContainsKey(frag.MessageId))
{
fragments = new List <TunnelDataFragment>();
MessageFragments[frag.MessageId] = new TunnelDataFragmentList(fragments);
}
else
{
fragments = MessageFragments[frag.MessageId].List;
}
if (fragments.Count <= frag.FragmentNumber)
{
fragments.AddRange(new TunnelDataFragment[frag.FragmentNumber - fragments.Count + 1]);
}
fragments[frag.FragmentNumber] = frag;
CheckForAllFragmentsFound(result, frag.MessageId, fragments);
}
else
{
if (frag.Fragmented)
{
List <TunnelDataFragment> fragments;
if (!MessageFragments.ContainsKey(frag.MessageId))
{
fragments = new List <TunnelDataFragment>();
MessageFragments[frag.MessageId] = new TunnelDataFragmentList(fragments);
}
else
{
fragments = MessageFragments[frag.MessageId].List;
}
if (fragments.Count == 0)
{
fragments.AddRange(new TunnelDataFragment[1]);
}
fragments[0] = frag;
CheckForAllFragmentsFound(result, frag.MessageId, fragments);
}
else
{
AddTunnelMessage(result, frag, frag.Payload.ToByteArray());
}
}
}
}
return(result);
}