void IdentHashLookup_RouterInfoReceived(I2PRouterInfo ri)
{
LookupDestination lud = null;
lock ( QueuedMessages )
{
if (QueuedMessages.TryGetValue(ri.Identity.IdentHash, out lud))
{
Logging.LogTransport("UnknownRouterQueue: IdentHashLookup_RouterInfoReceived: Destination " +
ri.Identity.IdentHash.Id32Short + " found. Sending.");
QueuedMessages.Remove(ri.Identity.IdentHash);
}
}
if (lud != null)
{
try
{
foreach (var msg in lud.Messages)
{
TransportProvider.Send(ri.Identity.IdentHash, msg);
}
}
catch (Exception ex)
{
Logging.Log("UnknownRouterQueue", ex);
}
}
}
internal void UpnpNATPortMapAdded(IPAddress addr, string protocol, int port)
{
if (protocol == "TCP" && UPnpExternalTCPPortMapped && UPnpExternalTCPPort == port)
{
return;
}
if (protocol == "UDP" && UPnpExternalUDPPortMapped && UPnpExternalUDPPort == port)
{
return;
}
if (protocol == "TCP")
{
UPnpExternalTCPPortMapped = true;
UPnpExternalTCPPort = port;
}
else
{
UPnpExternalUDPPortMapped = true;
UPnpExternalUDPPort = port;
}
UPnpExternalAddressAvailable = true;
MyRouterInfoCache = null;
ApplyNewSettings();
}
public void TestSimpleDatabaseHeader5StoreCreation()
{
var mapping = new I2PMapping();
mapping["One"] = "1";
mapping["2"] = "Two";
var ri = new I2PRouterInfo(
new I2PRouterIdentity(Public, PublicSigning),
I2PDate.Now,
new I2PRouterAddress[] { new I2PRouterAddress(new IPAddress(424242L), 773, 42, "SSU") },
mapping,
PrivateSigning);
var dbsm = new DatabaseStoreMessage(ri);
var data = dbsm.CreateHeader16.HeaderAndPayload;
var recreated = I2NPMessage.ReadHeader16(new BufRefLen(data));
Assert.IsTrue(recreated.MessageType == I2NPMessage.MessageTypes.DatabaseStore);
var rdsm = (DatabaseStoreMessage)recreated.Message;
Assert.IsTrue(rdsm.RouterInfo.Options["One"] == "1");
Assert.IsTrue(rdsm.RouterInfo.Options["2"] == "Two");
Assert.IsTrue(rdsm.RouterInfo.VerifySignature());
}
public ProtocolCapabilities ContactCapability(I2PRouterInfo router)
{
return(router.Adresses.Any(ra => ra.TransportStyle == "SSU" &&
ra.Options.Contains("key"))
? ProtocolCapabilities.NATTraversal
: ProtocolCapabilities.None);
}
public bool AddRouterInfo(Stream s)
{
var buf = StreamUtils.Read(s);
var ri = new I2PRouterInfo(new BufRef(buf), false);
return(AddRouterInfo(ri));
}
private PeerTestState(SSUHost host, I2PRouterInfo router)
{
Host = host;
Router = router;
Session = (SSUSession)Host.AddSession(router);
//Session.StartPeerTest( this );
}
public void ApplyNewSettings()
{
MyRouterInfoCache = null;
if (NetworkSettingsChanged != null)
{
NetworkSettingsChanged();
}
}
private static bool ValidateRI(I2PRouterInfo one)
{
return(one != null &&
one.Options
.Contains("caps") &&
one.Adresses
.Any(a => a.TransportStyle.Equals("NTCP") ||
a.TransportStyle.Equals("SSU")));
}
public void AddRouterInfo(string file)
{
using (var s = new FileStream(file, FileMode.Open, FileAccess.Read))
{
var buf = StreamUtils.Read(s);
var ri = new I2PRouterInfo(new BufRef(buf), false);
AddRouterInfo(ri);
}
}
public void AddRouterInfo(I2PRouterInfo info)
{
if (!ValidateRI(info))
{
return;
}
lock ( RouterInfos )
{
if (RouterInfos.ContainsKey(info.Identity.IdentHash))
{
var indb = RouterInfos[info.Identity.IdentHash];
if (((DateTime)info.PublishedDate - (DateTime)indb.Key.PublishedDate).TotalSeconds > 10)
{
if (!info.VerifySignature())
{
Logging.LogDebug($"NetDb: RouterInfo failed signature check: {info.Identity.IdentHash.Id32}");
return;
}
var meta = indb.Value;
meta.Deleted = false;
meta.Updated = true;
RouterInfos[info.Identity.IdentHash] = new KeyValuePair <I2PRouterInfo, RouterInfoMeta>(info, meta);
Logging.LogDebugData($"NetDb: Updated RouterInfo for: {info.Identity.IdentHash}");
}
else
{
return;
}
}
else
{
if (!info.VerifySignature())
{
Logging.LogDebug("NetDb: RouterInfo failed signature check: " + info.Identity.IdentHash.Id32);
return;
}
var meta = new RouterInfoMeta
{
Updated = true
};
RouterInfos[info.Identity.IdentHash] = new KeyValuePair <I2PRouterInfo, RouterInfoMeta>(info, meta);
Logging.LogDebugData($"NetDb: Added RouterInfo for: {info.Identity.IdentHash}");
}
if (RouterInfoUpdates != null)
{
ThreadPool.QueueUserWorkItem(a => RouterInfoUpdates(info));
}
}
}
public NTCPClientOutgoing(I2PRouterInfo router)
: base(true)
{
Address = router.Adresses.First(a => a.TransportStyle == "NTCP" &&
a.HaveHostAndPort);
NTCPContext.RemoteRouterIdentity = router.Identity;
RemoteDescription = Address.Options["host"];
OutgoingAddress = Address.Host;
OutgoingPort = int.Parse(Address.Options["port"]);
}
internal void UpnpReportedAddr(string addr)
{
if (UPnpExternalAddressAvailable && UPnpExternalAddress.Equals(IPAddress.Parse(addr)))
{
return;
}
UPnpExternalAddress = IPAddress.Parse(addr);
UPnpExternalAddressAvailable = true;
MyRouterInfoCache = null;
}
void UpdateCachedFields(BufRef reader)
{
CachedKey = new I2PIdentHash(reader);
CachedContent = reader.Read8() == 0 ? MessageContent.RouterInfo : MessageContent.LeaseSet;
CachedReplyToken = reader.Read32();
if (CachedReplyToken != 0)
{
CachedReplyTunnelId = reader.Read32();
CachedReplyGateway = new I2PIdentHash(reader);
}
switch (CachedContent)
{
case MessageContent.RouterInfo:
var length = reader.ReadFlip16();
#if USE_BC_GZIP
CachedRouterInfo = new I2PRouterInfo(
new BufRefLen(LZUtils.BCGZipDecompressNew(new BufLen(reader, 0, length))), true);
#else
using (var ms = new MemoryStream())
{
ms.Write(reader.BaseArray, reader.BaseArrayOffset, length);
ms.Position = 0;
using (var gzs = new GZipStream(ms, CompressionMode.Decompress))
{
var gzdata = StreamUtils.Read(gzs);
CachedRouterInfo = new I2PRouterInfo(new BufRefLen(gzdata), true);
}
}
#endif
reader.Seek(length);
break;
case MessageContent.LeaseSet:
CachedLeaseSet = new I2PLeaseSet(reader);
break;
/*
* case MessageContent.LeaseSet2:
* break;
*
* case MessageContent.EncryptedLeaseSet:
* break;
*
* case MessageContent.MetaLeaseSet:
* break;
*/
default:
throw new InvalidDataException($"DatabaseStoreMessage: {CachedContent} not supported");
}
}
private ITransport CreateTransport(I2PRouterInfo ri)
{
ITransport transport = null;
try
{
var pproviders = TransportProtocols
.Select(tp => new
{
Provider = tp,
Capability = tp.ContactCapability(ri)
})
.Where(tp => tp.Capability != ProtocolCapabilities.None)
.GroupBy(tp => tp.Capability)
.OrderByDescending(cc => (int)cc.Key);
var pprovider = pproviders.FirstOrDefault()?.Random();
if (pprovider == null)
{
Logging.LogTransport(
$"TransportProvider: CreateTransport: No usable address found for {ri.Identity.IdentHash.Id32Short}!");
return(null);
}
transport = pprovider.Provider.AddSession(ri);
Logging.LogTransport($"TransportProvider: Creating new {transport} to {ri.Identity.IdentHash.Id32Short}");
AddTransport(transport);
transport.Connect();
var dstore = new DatabaseStoreMessage(RouterContext.Inst.MyRouterInfo);
transport.Send(dstore);
}
catch (Exception ex)
{
#if LOG_MUCH_TRANSPORT
Logging.LogTransport(ex);
Logging.LogTransport("TransportProvider: CreateTransport stack trace: " + System.Environment.StackTrace);
#else
Logging.LogTransport($"TransportProvider: Exception [{ex.GetType()}] " +
$"'{ex.Message}' to {ri.Identity.IdentHash.Id32Short}.");
#endif
if (transport != null)
{
Remove(transport);
}
throw;
}
return(transport);
}
public ITransport AddSession(I2PRouterInfo router)
{
IPEndPoint remoteep = null;
IPEndPoint key = null;
var addr = router.Adresses.First(a => (a.TransportStyle == "SSU") &&
a.Options.Contains("key") &&
(RouterContext.Inst.UseIpV6 ||
a.Options.ValueContains("host", ".") ||
a.Options.ValueContains("ihost0", ".")));
var dest = router.Identity;
if (addr.HaveHostAndPort)
{
remoteep = new IPEndPoint(addr.Host, addr.Port);
if (!AllowConnectToSelf && IsOurIP(remoteep.Address))
{
Logging.LogTransport($"SSU AddSession: [{dest.IdentHash.Id32}]:{key} - {addr}. Dropped. Not connecting to ourselves.");
return(null);
}
key = remoteep;
Logging.LogDebugData($"SSU AddSession: [{dest.IdentHash.Id32}]:{key} - {addr}");
lock ( Sessions )
{
if (Sessions.ContainsKey(key))
{
var sess = Sessions[key];
return(sess);
}
}
}
var newsess = new SSUSession(
this,
Send,
remoteep,
addr,
dest,
MyRouterContext);
if (key != null)
{
lock ( Sessions )
{
Sessions[key] = newsess;
}
}
return(newsess);
}
public void SSUReportedAddr(IPAddress extaddr)
{
if (extaddr == null)
{
return;
}
if (SSUReportedExternalAddress != null && SSUReportedExternalAddress.Equals(extaddr))
{
return;
}
SSUReportedExternalAddress = extaddr;
MyRouterInfoCache = null;
}
void NetDb_RouterInfoUpdates(I2PRouterInfo ri)
{
if (!OutstandingQueries.TryRemove(ri.Identity.IdentHash, out var info))
{
return;
}
Logging.Log(string.Format("IdentResolver: Lookup of RouterInfo {0} succeeded. {1}",
ri.Identity.IdentHash.Id32Short, info.Start.DeltaToNow));
if (RouterInfoReceived != null)
{
ThreadPool.QueueUserWorkItem(a => RouterInfoReceived(ri));
}
}
internal void SetIntroducers(IEnumerable <IntroducerInfo> introducers)
{
var result = new List <KeyValuePair <string, string> >();
var ix = 0;
foreach (var one in introducers)
{
result.Add(new KeyValuePair <string, string>($"ihost{ix}", one.Host.ToString()));
result.Add(new KeyValuePair <string, string>($"iport{ix}", one.Port.ToString()));
result.Add(new KeyValuePair <string, string>($"ikey{ix}", FreenetBase64.Encode(one.IntroKey)));
result.Add(new KeyValuePair <string, string>($"itag{ix}", one.IntroTag.ToString()));
++ix;
}
SSUIntroducersInfo = result;
MyRouterInfoCache = null;
}
public DatabaseStoreMessage(
I2PRouterInfo info,
uint replytoken,
I2PIdentHash replygw,
I2PTunnelId replytunnelid)
{
BufLen msb;
#if USE_BC_GZIP
msb = LZUtils.BCGZipCompressNew(new BufLen(info.ToByteArray()));
#else
using (var ms = new MemoryStream())
{
var buf = info.ToByteArray();
using (var gzs = new GZipStream(ms, CompressionMode.Compress))
{
gzs.Write(buf, 0, buf.Length);
gzs.Flush();
}
msb = new BufLen(ms.ToArray());
}
#endif
var len = 32 + 1 + 4 + 2 + msb.Length + (replytoken != 0 ? 4 + 32 : 0);
AllocateBuffer(len);
var writer = new BufRefLen(Payload);
writer.Write(info.Identity.IdentHash.Hash);
writer.Write8((byte)MessageContent.RouterInfo);
writer.Write(BitConverter.GetBytes(replytoken));
if (replytoken != 0)
{
writer.Write(BitConverter.GetBytes(replytunnelid));
if (replygw == null || replygw.Hash.Length != 32)
{
throw new FormatException("ReplyGateway has to be 32 bytes long!");
}
writer.Write(replygw.Hash);
}
writer.WriteFlip16((ushort)msb.Length);
writer.Write(msb);
}
DatabaseStoreMessage CreateDatabaseStoreMessage()
{
var mapping = new I2PMapping();
mapping["One"] = "1";
mapping["2"] = "Two";
var ri = new I2PRouterInfo(
new I2PRouterIdentity(Public, PublicSigning),
I2PDate.Now,
new I2PRouterAddress[] { new I2PRouterAddress(new IPAddress(424242L), 773, 42, "SSU") },
mapping,
PrivateSigning);
var dbsm = new DatabaseStoreMessage(ri);
return(dbsm);
}
void NetDb_RouterInfoUpdates(I2PRouterInfo ri)
{
IdentUpdateRequestInfo info;
lock ( OutstandingQueries )
{
if (!OutstandingQueries.TryGetValue(ri.Identity.IdentHash, out info))
{
return;
}
OutstandingQueries.Remove(ri.Identity.IdentHash);
}
DebugUtils.Log(string.Format("IdentResolver: Lookup of RouterInfo {0} succeeded. {1}",
ri.Identity.IdentHash.Id32Short, info.Start.DeltaToNow));
if (RouterInfoReceived != null)
{
ThreadPool.QueueUserWorkItem(a => RouterInfoReceived(ri));
}
}
void UpdateCachedFields(BufRef reader)
{
CachedKey = new I2PIdentHash(reader);
CachedContent = reader.Read8() == 0 ? MessageContent.RouterInfo : MessageContent.LeaseSet;
CachedReplyToken = reader.Read32();
if (CachedReplyToken != 0)
{
CachedReplyTunnelId = reader.Read32();
CachedReplyGateway = new I2PIdentHash(reader);
}
if (CachedContent == MessageContent.RouterInfo)
{
var length = reader.ReadFlip16();
#if USE_BC_GZIP
CachedRouterInfo = new I2PRouterInfo(
new BufRefLen(LZUtils.BCGZipDecompressNew(new BufLen(reader, 0, length))), true);
#else
using (var ms = new MemoryStream())
{
ms.Write(reader.BaseArray, reader.BaseArrayOffset, length);
ms.Position = 0;
using (var gzs = new GZipStream(ms, CompressionMode.Decompress))
{
var gzdata = StreamUtils.Read(gzs);
CachedRouterInfo = new I2PRouterInfo(new BufRefLen(gzdata), true);
}
}
#endif
reader.Seek(length);
}
else
{
CachedLeaseSet = new I2PLeaseSet(reader);
}
}
void Load()
{
using (var s = GetStore())
{
var sw2 = new Stopwatch();
sw2.Start();
var ix = 0;
while (s != null && (ix = s.Next(ix)) > 0)
{
var reader = new BufRefLen(s.Read(ix));
var recordtype = (StoreRecordId)reader.Read32();
try
{
switch (recordtype)
{
case StoreRecordId.StoreIdRouterInfo:
var one = new I2PRouterInfo(reader, false);
var known = RouterInfos.ContainsKey(one.Identity.IdentHash);
if (!ValidateRI(one) && known)
{
s.Delete(RouterInfos[one.Identity.IdentHash].Value.StoreIx);
RouterInfos.Remove(one.Identity.IdentHash);
Statistics.DestinationInformationFaulty(one.Identity.IdentHash);
continue;
}
RouterInfos[one.Identity.IdentHash] = new KeyValuePair <I2PRouterInfo, RouterInfoMeta>(
one,
new RouterInfoMeta(ix));
break;
case StoreRecordId.StoreIdConfig:
AccessConfig(delegate(Dictionary <I2PString, I2PString> settings)
{
var key = new I2PString(reader);
settings[key] = new I2PString(reader);
});
break;
default:
s.Delete(ix);
break;
}
}
catch (Exception ex)
{
DebugUtils.LogDebug($"NetDb: Load: Store exception, ix [{ix}] removed. {ex}");
s.Delete(ix);
}
}
sw2.Stop();
DebugUtils.Log($"Store: {sw2.Elapsed}");
}
var files = GetNetDbFiles();
foreach (var file in files)
{
AddRouterInfo(file);
}
lock (RouterInfos)
if (RouterInfos.Count == 0)
{
DebugUtils.LogWarning($"WARNING: NetDB database contains no routers. Add router files to {NetDbPath}.");
}
Statistics.Load();
UpdateSelectionProbabilities();
Save(true);
foreach (var file in files)
{
File.Delete(file);
}
}
public string GetFullPath(I2PRouterInfo ri)
{
var hash = ri.Identity.IdentHash.Id64;
return(GetFullPath(Path.Combine("r" + hash[0], "routerInfo-" + hash + ".dat")));
}
public ITransport AddSession(I2PRouterInfo router)
{
return(new NTCPClientOutgoing(router));
}
public ProtocolCapabilities ContactCapability(I2PRouterInfo router)
{
return(router.Adresses.Any(ra => ra.TransportStyle == "NTCP" && ra.HaveHostAndPort)
? ProtocolCapabilities.IncomingLowPrio
: ProtocolCapabilities.None);
}
void Load()
{
using (var s = GetStore())
{
var sw2 = new Stopwatch();
sw2.Start();
var ix = 0;
while (s != null && (ix = s.Next(ix)) > 0)
{
var reader = new BufRefLen(s.Read(ix));
var recordtype = (StoreRecordId)reader.Read32();
try
{
switch (recordtype)
{
case StoreRecordId.StoreIdRouterInfo:
var one = new I2PRouterInfo(reader, false);
if (!ValidateRI(one))
{
s.Delete(ix);
RouterInfos.TryRemove(one.Identity.IdentHash, out _);
FloodfillInfos.TryRemove(one.Identity.IdentHash, out _);
Statistics.DestinationInformationFaulty(one.Identity.IdentHash);
continue;
}
if (!RouterContext.Inst.UseIpV6)
{
if (!one.Adresses.Any(a => a.Options.ValueContains("host", ".")))
{
Logging.LogDebug($"NetDb: RouterInfo have no IPV4 address: {one.Identity.IdentHash.Id32}");
s.Delete(ix);
continue;
}
}
var re = new RouterEntry(
one,
new RouterInfoMeta(ix));
RouterInfos[one.Identity.IdentHash] = re;
if (re.IsFloodfill)
{
FloodfillInfos[one.Identity.IdentHash] = re;
}
break;
case StoreRecordId.StoreIdConfig:
AccessConfig(delegate(Dictionary <I2PString, I2PString> settings)
{
var key = new I2PString(reader);
settings[key] = new I2PString(reader);
});
break;
default:
s.Delete(ix);
break;
}
}
catch (Exception ex)
{
Logging.LogDebug($"NetDb: Load: Store exception, ix [{ix}] removed. {ex}");
s.Delete(ix);
}
}
sw2.Stop();
Logging.Log($"Store: {sw2.Elapsed}");
}
ImportNetDbFiles();
if (RouterInfos.Count < 20)
{
Logging.LogWarning($"WARNING: NetDB database contains " +
$"{RouterInfos.Count} routers. Add router files to {NetDbPath}.");
DoBootstrap();
}
Statistics.Load();
IsFirewalledUpdate();
#if DEBUG
ShowDebugDatabaseInfo();
#endif
UpdateSelectionProbabilities();
Save(true);
}
public string GetFullPath(I2PRouterInfo ri)
{
var hash = ri.Identity.IdentHash.Id64;
return(GetFullPath(Path.Combine($"r{hash[0]}", $"routerInfo-{hash}.dat")));
}
private ITransport CreateTransport(I2PRouterInfo ri)
{
ITransport transport = null;
try
{
var ntcpaddr = ri.Adresses.Where(a => (a.TransportStyle == "NTCP") &&
a.HaveHostAndPort &&
(RouterContext.Inst.UseIpV6 ||
a.Options.ValueContains("host", ".")));
var ssuaddr = ri.Adresses.Where(a => (a.TransportStyle == "SSU") &&
a.Options.Contains("key") &&
(RouterContext.Inst.UseIpV6 ||
a.Options.ValueContains("host", ".") ||
a.Options.ValueContains("ihost0", ".")));
I2PRouterAddress ra = ssuaddr
.Where(a => a.Options.Contains("host"))
.Random()
?? ntcpaddr.Random()
?? ssuaddr.Random();
if (ra == null)
{
Logging.LogTransport(
$"TransportProvider: CreateTransport: No usable address found for {ri.Identity.IdentHash.Id32Short}!");
return(null);
}
switch (ra.TransportStyle.ToString())
{
case "SSU":
transport = SsuHost.AddSession(ra, ri.Identity);
break;
case "NTCP":
transport = new NTCPClientOutgoing(ra, ri.Identity);
break;
default:
throw new NotImplementedException();
}
Logging.LogTransport(
string.Format("TransportProvider: Creating new {0} transport {2} to {1}",
ra.TransportStyle, ri.Identity.IdentHash.Id32Short, transport.DebugId));
AddTransport(transport);
transport.Connect();
var dstore = new DatabaseStoreMessage(RouterContext.Inst.MyRouterInfo);
transport.Send(dstore);
}
catch (Exception ex)
{
#if LOG_MUCH_TRANSPORT
Logging.LogTransport(ex);
Logging.LogTransport("TransportProvider: CreateTransport stack trace: " + System.Environment.StackTrace);
#else
Logging.LogTransport($"TransportProvider: Exception [{ex.GetType()}] " +
$"'{ex.Message}' to {ri.Identity.IdentHash.Id32Short}.");
#endif
if (transport != null)
{
Remove(transport);
}
throw;
}
return(transport);
}
public DatabaseStoreMessage(I2PRouterInfo info) : this(info, 0, null, 0)
{
}
