void Search_DonePublish(DhtSearch search)
{
DataReq publish = (DataReq)search.Carry;
// need to carry over componentid that wanted search also so store works
foreach (DhtLookup node in search.LookupList)
{
Send_StoreReq(node.Contact, null, publish);
}
}
public void Receive_StoreReq(G2ReceivedPacket packet)
{
StoreReq store = StoreReq.Decode(packet);
if (Core.ServiceBandwidth.ContainsKey(store.Service))
{
Core.ServiceBandwidth[store.Service].InPerSec += packet.Root.Data.Length;
}
if (store.Source.Firewall == FirewallType.Open)
{
// dont need to add to routing if nat/blocked because eventual routing ping by server will auto add
Network.Routing.Add(new DhtContact(store.Source, packet.Source.IP));
}
// forward to proxied nodes - only replicate data to blocked nodes on operation network
if (!Network.IsLookup)
{
// when we go offline it will be these nodes that update their next proxy with stored info
foreach (TcpConnect socket in Network.TcpControl.ProxyClients)
{
if (packet.Tcp != socket)
{
if (packet.ReceivedUdp)
{
store.FromAddress = packet.Source;
}
socket.SendPacket(store);
}
}
}
// pass to components
DataReq data = new DataReq(packet.Source, store.Key, store.Service, store.DataType, store.Data);
if (packet.ReceivedTcp && packet.Tcp.Proxy == ProxyType.Server)
{
data.LocalProxy = new DhtClient(packet.Tcp);
}
if (data.Service == 0)
{
Receive_Patch(packet.Source, store.Data);
}
else if (StoreEvent.Contains(store.Service, store.DataType))
{
StoreEvent[store.Service, store.DataType].Invoke(data);
}
}
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;
}
public void PublishDirect(List <LocationData> locations, ulong target, uint service, uint datatype, byte[] data)
{
if (Core.InvokeRequired)
{
Core.RunInCoreAsync(delegate() { PublishDirect(locations, target, service, datatype, data); });
return;
}
DataReq req = new DataReq(null, target, service, datatype, data);
foreach (LocationData location in locations)
{
DhtAddress address = new DhtAddress(location.IP, location.Source);
Send_StoreReq(address, null, req);
foreach (DhtAddress proxy in location.Proxies)
{
Send_StoreReq(proxy, null, req);
}
}
}
public void PublishNetwork(ulong target, uint service, uint datatype, byte[] data)
{
if (Core.InvokeRequired)
{
Debug.Assert(false);
}
string type = "Publish " + Core.GetServiceName(service);
if (target == Core.UserID)
{
Network.UpdateLog("general", "Publishing " + Core.GetServiceName(service));
}
DataReq store = new DataReq(null, target, service, datatype, data);
// find users closest to publish target
if (target == Network.Local.UserID)
{
foreach (DhtContact closest in Network.Routing.GetCacheArea())
{
Send_StoreReq(closest, null, store);
}
foreach (TcpConnect socket in Network.TcpControl.ProxyClients)
{
Send_StoreReq(new DhtAddress(socket.RemoteIP, socket), null, store);
}
}
else
{
DhtSearch search = Network.Searches.Start(target, type, 0, 0, null, null);
if (search != null)
{
search.DoneEvent = Search_DonePublish;
search.Carry = store;
}
}
}
void Store_Local(DataReq store)
{
// getting published to - search results - patch
SignedData signed = SignedData.Decode(store.Data);
if (signed == null)
return;
G2Header embedded = new G2Header(signed.Data);
// figure out data contained
if (G2Protocol.ReadPacket(embedded))
if (embedded.Name == DataPacket.VersionedFile)
Process_VersionedFile(store, signed, VersionedFileHeader.Decode(signed.Data));
}
private void Process_VersionedFile(DataReq data, SignedData signed, VersionedFileHeader header)
{
Core.IndexKey(header.KeyID, ref header.Key);
OpVersionedFile current = GetFile(header.KeyID);
// if link loaded
if (current != null)
{
// lower version
if (header.Version < current.Header.Version)
{
if (data != null && data.Source != null)
Store.Send_StoreReq(data.Source, data.LocalProxy, new DataReq(null, current.UserID, Service, DataType, current.SignedHeader));
return;
}
// higher version
else if (header.Version > current.Header.Version)
{
CacheFile(signed, header);
}
}
// else load file, set new header after file loaded
else
CacheFile(signed, header);
}
void Store_Local(DataReq store)
{
// getting published to - search results - patch
SignedData signed = SignedData.Decode(store.Data);
if (signed == null)
return;
G2Header embedded = new G2Header(signed.Data);
// figure out data contained
if (G2Protocol.ReadPacket(embedded))
if (embedded.Name == TrustPacket.UplinkReq)
Process_UplinkReq(store, signed, UplinkRequest.Decode(embedded));
}
private void Process_UplinkReq(DataReq data, SignedData signed, UplinkRequest request)
{
Core.IndexKey(request.KeyID, ref request.Key);
Core.IndexKey(request.TargetID, ref request.Target);
if (!Utilities.CheckSignedData(request.Key, signed.Data, signed.Signature))
return;
OpTrust requesterTrust = GetTrust(request.KeyID);
if (requesterTrust != null && requesterTrust.Loaded && requesterTrust.File.Header.Version > request.LinkVersion)
return;
// check if target in linkmap, if not add
OpTrust targetTrust = GetTrust(request.TargetID);
if (targetTrust == null)
{
targetTrust = new OpTrust(new OpVersionedFile(request.Target) );
TrustMap.SafeAdd(request.TargetID, targetTrust);
}
if (targetTrust.Loaded && targetTrust.File.Header.Version > request.TargetVersion)
return;
request.Signed = signed.Encode(Network.Protocol); // so we can send it in results / save, later on
// check for duplicate requests
OpLink targetLink = targetTrust.GetLink(request.ProjectID);
if (targetLink != null)
{
foreach (UplinkRequest compare in targetLink.Requests)
if (Utilities.MemCompare(compare.Signed, request.Signed))
return;
}
else
{
targetTrust.AddProject(request.ProjectID, true);
targetLink = targetTrust.GetLink(request.ProjectID);
}
// add
targetLink.Requests.Add(request);
// if target is marked as linked or focused, update link of target and sender
if (targetTrust.Loaded && (targetTrust.InLocalLinkTree || Core.KeepData.SafeContainsKey(targetTrust.UserID)))
{
if (targetTrust.File.Header.Version < request.TargetVersion)
Cache.Research(targetTrust.UserID);
if (requesterTrust == null)
{
requesterTrust = new OpTrust(new OpVersionedFile(request.Key));
TrustMap.SafeAdd(request.KeyID, requesterTrust);
}
// once new version of requester's link file has been downloaded, interface will be updated
if (!requesterTrust.Loaded || (requesterTrust.File.Header.Version < request.LinkVersion))
Cache.Research(requesterTrust.UserID);
}
RunSaveUplinks = true;
}
public void PublishNetwork(ulong target, uint service, uint datatype, byte[] data)
{
if (Core.InvokeRequired)
Debug.Assert(false);
string type = "Publish " + Core.GetServiceName(service);
if(target == Core.UserID)
Network.UpdateLog("general", "Publishing " + Core.GetServiceName(service));
DataReq store = new DataReq(null, target, service, datatype, data);
// find users closest to publish target
if (target == Network.Local.UserID)
{
foreach (DhtContact closest in Network.Routing.GetCacheArea())
Send_StoreReq(closest, null, store);
foreach (TcpConnect socket in Network.TcpControl.ProxyClients)
Send_StoreReq(new DhtAddress(socket.RemoteIP, socket), null, store);
}
else
{
DhtSearch search = Network.Searches.Start(target, type, 0, 0, null, null);
if (search != null)
{
search.DoneEvent = Search_DonePublish;
search.Carry = store;
}
}
}
public void PublishDirect(List<LocationData> locations, ulong target, uint service, uint datatype, byte[] data)
{
if (Core.InvokeRequired)
{
Core.RunInCoreAsync(delegate() { PublishDirect(locations, target, service, datatype, data); });
return;
}
DataReq req = new DataReq(null, target, service, datatype, data);
foreach (LocationData location in locations)
{
DhtAddress address = new DhtAddress(location.IP, location.Source);
Send_StoreReq(address, null, req);
foreach (DhtAddress proxy in location.Proxies)
Send_StoreReq(proxy, null, req);
}
}
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;
}
public void Receive_StoreReq(G2ReceivedPacket packet)
{
StoreReq store = StoreReq.Decode(packet);
if (Core.ServiceBandwidth.ContainsKey(store.Service))
Core.ServiceBandwidth[store.Service].InPerSec += packet.Root.Data.Length;
if (store.Source.Firewall == FirewallType.Open )
// dont need to add to routing if nat/blocked because eventual routing ping by server will auto add
Network.Routing.Add(new DhtContact(store.Source, packet.Source.IP));
// forward to proxied nodes - only replicate data to blocked nodes on operation network
if (!Network.IsLookup)
// when we go offline it will be these nodes that update their next proxy with stored info
foreach (TcpConnect socket in Network.TcpControl.ProxyClients)
if (packet.Tcp != socket)
{
if (packet.ReceivedUdp)
store.FromAddress = packet.Source;
socket.SendPacket(store);
}
// pass to components
DataReq data = new DataReq(packet.Source, store.Key, store.Service, store.DataType, store.Data);
if (packet.ReceivedTcp && packet.Tcp.Proxy == ProxyType.Server)
data.LocalProxy = new DhtClient(packet.Tcp);
if(data.Service == 0)
Receive_Patch(packet.Source, store.Data);
else if (StoreEvent.Contains(store.Service, store.DataType))
StoreEvent[store.Service, store.DataType].Invoke(data);
}
void Store_Local(DataReq store)
{
// location being published to hashid so others can get sources
TempData temp = TempData.Decode(store.Target, store.Data);
if (temp == null)
return;
TempData dupe = CachedData.Where(l => l.TargetID == temp.TargetID && Utilities.MemCompare(l.Data, temp.Data)).FirstOrDefault();
if (dupe != null)
{
if(temp.TTL > dupe.TTL)
dupe.TTL = temp.TTL;
return;
}
CachedData.Add(temp);
}
private void Process_PostHeader(DataReq data, SignedData signed, PostHeader header)
{
Core.IndexKey(header.SourceID, ref header.Source);
Core.IndexKey(header.TargetID, ref header.Target);
PostUID uid = new PostUID(header);
OpPost current = GetPost(header.TargetID, uid);
// if link loaded
if (current != null)
{
// lower version, send update
if (header.Version < current.Header.Version)
{
if (data != null && data.Source != null)
Store.Send_StoreReq(data.Source, data.LocalProxy, new DataReq(null, header.TargetID, ServiceID, 0, current.SignedHeader));
return;
}
// higher version
else if (header.Version > current.Header.Version)
{
CachePost(signed, header);
}
// equal version do nothing
}
// else load file, set new header after file loaded
else
CachePost(signed, header);
}
