public OpLink(OpTrust trust, uint project) { Trust = trust; Project = project; }
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 TrustService(OpCore core) { Core = core; Core.Trust = this; Store = Core.Network.Store; Network = Core.Network; Core.SecondTimerEvent += Core_SecondTimer; Core.MinuteTimerEvent += Core_MinuteTimer; Core.KeepDataCore += new KeepDataHandler(Core_KeepData); Cache = new VersionedCache(Network, ServiceID, DataTypeFile, false); Network.CoreStatusChange += new StatusChange(Network_StatusChange); // piggyback searching for uplink requests on cache file data Store.StoreEvent[ServiceID, DataTypeFile] += new StoreHandler(Store_Local); Network.Searches.SearchEvent[ServiceID, DataTypeFile] += new SearchRequestHandler(Search_Local); Core.Locations.KnowOnline += new KnowOnlineHandler(Location_KnowOnline); Cache.FileAquired += new FileAquiredHandler(Cache_FileAquired); Cache.FileRemoved += new FileRemovedHandler(Cache_FileRemoved); Cache.Load(); ProjectNames.SafeAdd(0, Core.User.Settings.Operation); LinkPath = Core.User.RootPath + Path.DirectorySeparatorChar + "Data" + Path.DirectorySeparatorChar + ServiceID.ToString(); Directory.CreateDirectory(LinkPath); LocalFileKey = Core.User.Settings.FileKey; LoadUplinkReqs(); LocalTrust = GetTrust(Core.UserID); if (LocalTrust == null) { LocalTrust = new OpTrust(new OpVersionedFile(Core.User.Settings.KeyPublic)); TrustMap.SafeAdd(Core.UserID, LocalTrust); } if (!LocalTrust.Loaded) { LocalTrust.Name = Core.User.Settings.UserName; LocalTrust.AddProject(0, true); // operation SaveLocal(); } }
private void Process_ProjectData(OpTrust trust, SignedData signed, ProjectData project) { if (!Utilities.CheckSignedData(trust.File.Key, signed.Data, signed.Signature)) return; if (project.ID != 0 && !ProjectNames.SafeContainsKey(project.ID)) ProjectNames.SafeAdd(project.ID, project.Name); trust.AddProject(project.ID, true); if (project.ID == 0) { trust.Name = project.UserName; Core.IndexName(trust.UserID, trust.Name); } OpLink link = trust.GetLink(project.ID); }
private void Process_LinkData(OpTrust trust, SignedData signed, LinkData linkData) { if (!Utilities.CheckSignedData(trust.File.Key, signed.Data, signed.Signature)) return; Core.IndexKey(linkData.TargetID, ref linkData.Target); uint project = linkData.Project; OpLink localLink = trust.GetLink(project); if (localLink == null) return; OpTrust targetTrust = GetTrust(linkData.TargetID, false); if (targetTrust == null) { targetTrust = new OpTrust(new OpVersionedFile(linkData.Target)); TrustMap.SafeAdd(linkData.TargetID, targetTrust); } targetTrust.AddProject(project, false); OpLink targetLink = targetTrust.GetLink(project); if (linkData.Uplink) { localLink.Uplink = targetLink; targetLink.Downlinks.Add(localLink); // always know a link's trust structure to the top if (!targetTrust.Loaded) Cache.Research(targetTrust.UserID); //if (targetLink.Uplink == null) // AddRoot(targetLink); } else { if (linkData.Title != null) localLink.Titles[targetLink.UserID] = linkData.Title; localLink.Confirmed.Add(targetLink.UserID); } }
private void Cache_FileAquired(OpVersionedFile cachefile) { try { // get link directly, even if in unloaded state we need the same reference OpTrust trust = null; TrustMap.SafeTryGetValue(cachefile.UserID, out trust); if (trust == null) { trust = new OpTrust(cachefile); TrustMap.SafeAdd(cachefile.UserID, trust); } else trust.File = cachefile; // clean roots, if link has loopID, remove loop node entirely, it will be recreated if needed later ProjectRoots.LockReading(delegate() { foreach (uint project in ProjectRoots.Keys) { OpLink link = trust.GetLink(project); if (link == null) continue; ThreadedList<OpLink> roots = ProjectRoots[project]; roots.SafeRemove(link); // remove loop node if (link.LoopRoot != null) roots.LockReading(delegate() { foreach (OpLink root in roots) if (root.UserID == link.LoopRoot.UserID) { roots.SafeRemove(root); // root is a loop node // remove associations with loop node foreach (OpLink downlink in root.Downlinks) downlink.LoopRoot = null; break; } }); } }); trust.Reset(); // load data from link file string inheritName = null; string inheritOp = null; Bitmap inheritIcon = null; byte[] inheritSplash = null; using (TaggedStream file = new TaggedStream(Cache.GetFilePath(cachefile.Header), Network.Protocol)) using (IVCryptoStream crypto = IVCryptoStream.Load(file, cachefile.Header.FileKey)) { PacketStream stream = new PacketStream(crypto, Network.Protocol, FileAccess.Read); G2Header packetRoot = null; while (stream.ReadPacket(ref packetRoot)) { if (packetRoot.Name == DataPacket.SignedData) { SignedData signed = SignedData.Decode(packetRoot); G2Header embedded = new G2Header(signed.Data); // figure out data contained if (G2Protocol.ReadPacket(embedded)) { if (embedded.Name == TrustPacket.ProjectData) { ProjectData project = ProjectData.Decode(embedded); Process_ProjectData(trust, signed, project); if (project.ID == 0) { inheritName = project.UserName; inheritOp = project.Name; } } else if (embedded.Name == TrustPacket.LinkData) Process_LinkData(trust, signed, LinkData.Decode(embedded)); } } else if (packetRoot.Name == TrustPacket.WebCache) Network.Cache.AddWebCache(WebCache.Decode(packetRoot)); else if (packetRoot.Name == TrustPacket.Icon) inheritIcon = IconPacket.Decode(packetRoot).OpIcon; else if (packetRoot.Name == TrustPacket.Splash) { LargeDataPacket splash = LargeDataPacket.Decode(packetRoot); if (splash.Size > 0) inheritSplash = LargeDataPacket.Read(splash, stream, TrustPacket.Splash); } } } // set new header trust.Loaded = true; // set as root if node has no uplinks foreach (OpLink link in trust.Links.Values) if (link.Uplink == null) AddRoot(link); // if uplink is unknown - process link data will search for the unknown parent // if loop created, create new loop node with unique ID, assign all nodes in loop the ID and add as downlinks foreach (OpLink link in trust.Links.Values) if (IsLooped(link)) { uint project = link.Project; OpLink loop = new OpTrust(project, (ulong)Core.RndGen.Next()).GetLink(project); loop.IsLoopRoot = true; List<ulong> uplinks = GetUnconfirmedUplinkIDs(trust.UserID, project); uplinks.Add(trust.UserID); foreach (ulong uplink in uplinks) { OpLink member = GetLink(uplink, project); if (member == null) continue; member.LoopRoot = loop; loop.Downlinks.Add(member); loop.Confirmed.Add(member.UserID); //needed for getlowers } AddRoot(loop); } trust.CheckRequestVersions(); if (LinkUpdate != null) LinkUpdate.Invoke(trust); if (Core.NewsWorthy(trust.UserID, 0, false)) Core.MakeNews(ServiceIDs.Trust, "Trust updated by " + Core.GetName(trust.UserID), trust.UserID, 0, true); // update subs if (Network.Established) { List<LocationData> locations = new List<LocationData>(); ProjectRoots.LockReading(delegate() { foreach (uint project in ProjectRoots.Keys) if (Core.UserID == trust.UserID || IsHigher(trust.UserID, project)) GetLocsBelow(Core.UserID, project, locations); }); Store.PublishDirect(locations, trust.UserID, ServiceID, 0, cachefile.SignedHeader); } // inherit local settings if(Core.UserID == trust.UserID) { if (inheritName != null) Core.User.Settings.UserName = inheritName; } // inherit settings from highest node, first node in loop if (IsInheritNode(trust.UserID)) { if (inheritOp != null) Core.User.Settings.Operation = inheritOp; if (inheritIcon != null) { Core.User.OpIcon = inheritIcon; Core.User.IconUpdate(); } if (inheritSplash != null) Core.User.OpSplash = (Bitmap)Bitmap.FromStream(new MemoryStream(inheritSplash)); else Core.User.OpSplash = null; } // update interface node Core.RunInGuiThread(GuiUpdate, trust.UserID); foreach (OpLink link in trust.Links.Values) foreach (OpLink downlink in link.Downlinks) Core.RunInGuiThread(GuiUpdate, downlink.UserID); } catch (Exception ex) { Network.UpdateLog("Link", "Error loading file " + ex.Message); } }
public void Trust_Update(OpTrust trust) { if (!ActiveUsers.Contains(trust.UserID)) return; IMStatus status = null; if (IMMap.SafeTryGetValue(trust.UserID, out status)) Update(status); }
void Trust_Update(OpTrust trust) { // update working projects (add) if (trust.UserID == Core.UserID) { OpStorage local = GetStorage(Core.UserID); foreach (uint project in Trust.LocalTrust.Links.Keys) if (!Working.ContainsKey(project)) { if(local != null) LoadHeaderFile(GetWorkingPath(project), local, false, true); Working[project] = new WorkingStorage(this, project); } } // remove all higher changes, reload with new highers (cause link changed foreach (WorkingStorage working in Working.Values ) if (Core.UserID == trust.UserID || Trust.IsHigher(trust.UserID, working.ProjectID)) { working.RemoveAllHigherChanges(); foreach (ulong uplink in Trust.GetAutoInheritIDs(Core.UserID, working.ProjectID)) working.RefreshHigherChanges(uplink); } }