private void Cache_FileAquired(OpVersionedFile file)
{
if (file.UserID != Network.Local.UserID)
return;
// only we can open the buddly list stored on the network
byte[] key = Core.User.Settings.KeyPair.Decrypt(file.Header.FileKey, false);
using (TaggedStream tagged = new TaggedStream(Cache.GetFilePath(file.Header), Network.Protocol))
using (IVCryptoStream crypto = IVCryptoStream.Load(tagged, key))
{
BuddyList.SafeClear();
PacketStream stream = new PacketStream(crypto, Network.Protocol, FileAccess.Read);
G2Header root = null;
while (stream.ReadPacket(ref root))
if (root.Name == BuddyPacket.Buddy)
{
OpBuddy buddy = OpBuddy.Decode(root);
ulong id = Utilities.KeytoID(buddy.Key);
Core.IndexKey(id, ref buddy.Key);
Core.IndexName(id, buddy.Name);
if(buddy.Ignored)
IgnoreList.SafeAdd(id, buddy);
else
BuddyList.SafeAdd(id, buddy);
}
}
Core.RunInGuiThread(GuiUpdate);
}
private void ApplyDiff(ulong id)
{
// change log - who / not
// read file uid
// if exists locally
// if integrated mark as so
// else mark as changed, run history diff, and use last note
// if doesnt exist
// add file as a temp
// user does - add to storage, to add it
// if remote doesnt have any record of local file, ignore
ChangeCount[id] = 0;
OpStorage storage = Storages.GetStorage(id);
if (storage == null)
{
FailedDiffs.Add(id);
return;
}
string path = Storages.GetFilePath(storage);
if (!File.Exists(path))
{
FailedDiffs.Add(id);
return;
}
try
{
using (TaggedStream filex = new TaggedStream(path, Core.GuiProtocol))
using (IVCryptoStream crypto = IVCryptoStream.Load(filex, storage.File.Header.FileKey))
{
PacketStream stream = new PacketStream(crypto, Storages.Protocol, FileAccess.Read);
ulong remoteUID = 0;
FolderNode currentFolder = RootFolder;
bool readingProject = false;
G2Header header = null;
while (stream.ReadPacket(ref header))
{
if (header.Name == StoragePacket.Root)
{
StorageRoot root = StorageRoot.Decode(header);
readingProject = (root.ProjectID == ProjectID);
}
if (readingProject)
{
if (header.Name == StoragePacket.Folder)
{
StorageFolder folder = StorageFolder.Decode(header);
// if new UID
if (remoteUID == folder.UID)
continue;
remoteUID = folder.UID;
// check scope
bool ignore = false;
if (folder.Scope.Count > 0 && !Trust.IsInScope(folder.Scope, UserID, ProjectID))
ignore = true;
bool added = false;
while (!added)
{
if (currentFolder.Details.UID == folder.ParentUID)
{
// if folder exists with UID
if (currentFolder.Folders.ContainsKey(remoteUID))
currentFolder = currentFolder.Folders[remoteUID];
// else add folder as temp, mark as changed
else
{
if (ignore) // temp so traverse works, but not saved in structure
{
currentFolder = new FolderNode(this, folder, currentFolder, false);
break;
}
else
currentFolder = currentFolder.AddFolderInfo(folder, true);
}
bool found = false;
currentFolder.Archived.LockReading(delegate()
{
foreach (StorageFolder archive in currentFolder.Archived)
if (Storages.ItemDiff(archive, folder) == StorageActions.None)
if (archive.Date == folder.Date)
{
found = true;
break;
}
});
if (!found)
{
currentFolder.Changes[id] = folder;
currentFolder.UpdateOverlay();
}
// diff file properties, if different, add as change
/*if (currentFolder.Temp || Storages.ItemDiff(currentFolder.Details, folder) != StorageActions.None)
{
currentFolder.Changes[id] = folder;
currentFolder.UpdateOverlay();
}*/
added = true;
}
else if (currentFolder.Parent.GetType() == typeof(FolderNode))
currentFolder = (FolderNode)currentFolder.Parent;
else
break;
}
}
if (header.Name == StoragePacket.File)
{
StorageFile file = StorageFile.Decode(header);
// if new UID
if (remoteUID == file.UID)
continue;
remoteUID = file.UID;
// check scope
if (file.Scope.Count > 0 && !Trust.IsInScope(file.Scope, UserID, ProjectID))
continue;
FileItem currentFile = null;
// if file exists with UID
if (currentFolder.Files.ContainsKey(remoteUID))
currentFile = currentFolder.Files[remoteUID];
// else add file as temp, mark as changed
else
currentFile = currentFolder.AddFileInfo(file, true);
// if file is integrated, still add, so that reject functions
// true if file doesnt exist in local file history
// if it does exist and file is newer than latest, true
bool found = false;
currentFile.Archived.LockReading(delegate()
{
foreach (StorageFile archive in currentFile.Archived)
if (Storages.ItemDiff(archive, file) == StorageActions.None)
if (archive.Date == file.Date)
{
found = true;
break;
}
});
if (!found)
currentFile.Changes[id] = file;
}
}
}
}
}
catch
{
FailedDiffs.Add(id);
}
}
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);
}
}
private void LoadHeader(string path, byte[] key)
{
try
{
using (TaggedStream filex = new TaggedStream(path, Core.GuiProtocol))
using (IVCryptoStream crypto = IVCryptoStream.Load(filex, key))
{
PacketStream stream = new PacketStream(crypto, Storages.Protocol, FileAccess.Read);
FolderNode currentFolder = RootFolder;
bool readingProject = false;
G2Header header = null;
while (stream.ReadPacket(ref header))
{
if (header.Name == StoragePacket.Root)
{
StorageRoot root = StorageRoot.Decode(header);
readingProject = (root.ProjectID == ProjectID);
}
// show archived if selected, only add top uid, not copies
if (readingProject)
{
if (header.Name == StoragePacket.Folder)
{
StorageFolder folder = StorageFolder.Decode(header);
bool added = false;
while (!added)
{
if (currentFolder.Details.UID == folder.ParentUID)
{
currentFolder = currentFolder.AddFolderInfo(folder, false);
// re-select on re-load
if (SelectedFolder != null && currentFolder.Details.UID == SelectedFolder.Details.UID)
{
currentFolder.Selected = true;
SelectedFolder = currentFolder;
}
added = true;
}
else if (currentFolder.Parent.GetType() == typeof(FolderNode))
currentFolder = (FolderNode)currentFolder.Parent;
else
break;
}
if (!added)
{
Debug.Assert(false);
throw new Exception("Error loading CFS");
}
}
if (header.Name == StoragePacket.File)
{
StorageFile file = StorageFile.Decode(header);
currentFolder.AddFileInfo(file, false);
}
}
}
}
}
catch (Exception ex)
{
Core.Network.UpdateLog("Storage", "Error loading files " + ex.Message);
}
}
private void RescanDiff(ulong id)
{
/*
* see if uid exists in rescan map
if file
add to changes
if folder
add temp if uid doesnt exist
set inTarget[uid], add further uids if recurse set
*/
OpStorage storage = Storages.GetStorage(id);
if (storage == null)
return;
string path = Storages.GetFilePath(storage);
if (!File.Exists(path))
return;
try
{
using (TaggedStream filex = new TaggedStream(path, Core.GuiProtocol))
using (IVCryptoStream crypto = IVCryptoStream.Load(filex, storage.File.Header.FileKey))
{
PacketStream stream = new PacketStream(crypto, Storages.Protocol, FileAccess.Read);
ulong remoteUID = 0;
FolderNode currentFolder = RootFolder;
bool readingProject = false;
G2Header header = null;
List<ulong> Recursing = new List<ulong>();
while (stream.ReadPacket(ref header))
{
if (header.Name == StoragePacket.Root)
{
StorageRoot root = StorageRoot.Decode(header);
readingProject = (root.ProjectID == ProjectID);
}
if (readingProject)
{
if (header.Name == StoragePacket.Folder)
{
StorageFolder folder = StorageFolder.Decode(header);
// if new UID
if (remoteUID == folder.UID)
continue;
remoteUID = folder.UID;
if (RescanFolderMap.ContainsKey(remoteUID))
if (RescanFolderMap[remoteUID].Recurse)
Recursing.Add(remoteUID);
if (Recursing.Count > 0 || RescanFolderMap.ContainsKey(remoteUID))
{
bool added = false;
while (!added)
{
if (currentFolder.Details.UID == folder.ParentUID)
{
// if folder exists with UID
if (currentFolder.Folders.ContainsKey(remoteUID))
currentFolder = currentFolder.Folders[remoteUID];
// else add folder as temp, mark as changed
else
currentFolder = currentFolder.AddFolderInfo(folder, true);
// diff file properties, if different, add as change
if (currentFolder.Temp || Storages.ItemDiff(currentFolder.Details, folder) != StorageActions.None)
{
currentFolder.Changes[id] = folder;
currentFolder.UpdateOverlay();
}
added = true;
}
else if (currentFolder.Parent.GetType() == typeof(FolderNode))
{
// if current folder id equals recurse marker stop recursing
if (Recursing.Contains(currentFolder.Details.UID))
Recursing.Remove(currentFolder.Details.UID);
currentFolder = (FolderNode)currentFolder.Parent;
}
else
break;
}
}
}
if (header.Name == StoragePacket.File)
{
StorageFile file = StorageFile.Decode(header);
// if new UID
if (remoteUID == file.UID)
continue;
remoteUID = file.UID;
if (Recursing.Count > 0 /*|| RescanFileMap.ContainsKey(remoteUID)*/)
{
FileItem currentFile = null;
// if file exists with UID
if (currentFolder.Files.ContainsKey(remoteUID))
currentFile = currentFolder.Files[remoteUID];
// else add file as temp, mark as changed
else
currentFile = currentFolder.AddFileInfo(file, true);
//crit check if file is integrated
if (currentFile.Temp || Storages.ItemDiff(currentFile.Details, file) != StorageActions.None)
currentFile.Changes[id] = file;
}
}
}
}
}
}
catch
{
}
}
public void LoadPlan(ulong id)
{
if (Core.InvokeRequired)
{
Core.RunInCoreBlocked(delegate() { LoadPlan(id); });
return;
}
OpPlan plan = GetPlan(id, false);
if (plan == null)
return;
// if local plan file not created yet
if (plan.File.Header == null)
{
if (plan.UserID == Core.UserID)
plan.Init();
return;
}
try
{
string path = Cache.GetFilePath(plan.File.Header);
if (!File.Exists(path))
return;
plan.Init();
List<int> myjobs = new List<int>();
using (TaggedStream file = new TaggedStream(path, Network.Protocol))
using (IVCryptoStream crypto = IVCryptoStream.Load(file, plan.File.Header.FileKey))
{
PacketStream stream = new PacketStream(crypto, Network.Protocol, FileAccess.Read);
G2Header root = null;
while (stream.ReadPacket(ref root))
{
if (root.Name == PlanPacket.Block)
{
PlanBlock block = PlanBlock.Decode(root);
if (block != null)
plan.AddBlock(block);
}
if (root.Name == PlanPacket.Goal)
{
PlanGoal goal = PlanGoal.Decode(root);
if (goal != null)
plan.AddGoal(goal);
}
if (root.Name == PlanPacket.Item)
{
PlanItem item = PlanItem.Decode(root);
if (item != null)
plan.AddItem(item);
}
}
}
plan.Loaded = true;
// check if we have tasks for this person, that those jobs still exist
//crit do check with plan items, make sure goal exists for them
/*List<PlanTask> removeList = new List<PlanTask>();
bool update = false;
foreach(List<PlanTask> tasklist in LocalPlan.TaskMap.Values)
{
removeList.Clear();
foreach (PlanTask task in tasklist)
if(task.Assigner == id)
if(!myjobs.Contains(task.Unique))
removeList.Add(task);
foreach(PlanTask task in removeList)
tasklist.Remove(task);
if (removeList.Count > 0)
update = true;
}
if (update)
SaveLocal();*/
}
catch (Exception ex)
{
Core.Network.UpdateLog("Plan", "Error loading plan " + ex.Message);
}
}
public string GetPostTitle(OpPost post)
{
// loads info when first demanded, cached afterwards
if (post.Info == null)
try
{
string path = GetPostPath(post.Header);
if (!File.Exists(path))
return "";
post.Attached = new List<PostFile>();
using (TaggedStream file = new TaggedStream(path, Network.Protocol))
using (IVCryptoStream crypto = IVCryptoStream.Load(file, post.Header.FileKey))
{
PacketStream stream = new PacketStream(crypto, Network.Protocol, FileAccess.Read);
G2Header root = null;
while (stream.ReadPacket(ref root))
{
if (root.Name == BoardPacket.PostInfo)
post.Info = PostInfo.Decode(root);
else if (root.Name == BoardPacket.PostFile)
post.Attached.Add(PostFile.Decode(root));
}
}
}
catch (Exception ex)
{
Network.UpdateLog("Board", "Could not load post " + post.Header.SourceID.ToString() + ": " + ex.Message);
}
if (post.Info == null)
return "";
if (post.Header.ParentID == 0)
return post.Info.Subject;
else
return post.Info.Quip;
}
private void ShowMessage(LocalMail message)
{
if (message == null)
{
SetHeader("");
MessageBody.Clear();
return;
}
string content = "<b><font size=2>" + message.Info.Subject + "</font></b> from " +
Core.GetName(message.Header.SourceID) + ", sent " +
Utilities.FormatTime(message.Info.Date) + @"<br>
<b>To:</b> " + Mail.GetNames(message.To) + "<br>";
if(message.CC.Count > 0)
content += "<b>CC:</b> " + Mail.GetNames(message.CC) + "<br>";
if(message.Attached.Count > 1)
{
string attachHtml = "";
for (int i = 0; i < message.Attached.Count; i++)
{
if (message.Attached[i].Name == "body")
continue;
attachHtml += "<a href='http://attach/" + i.ToString() + "'>" + message.Attached[i].Name + "</a> (" + Utilities.ByteSizetoString(message.Attached[i].Size) + "), ";
}
attachHtml = attachHtml.TrimEnd(new char[] { ' ', ',' });
content += "<b>Attachments: </b> " + attachHtml;
}
content += "<br>";
string actions = "";
if (message.Header.TargetID == Core.UserID)
actions += @"<a href='http://reply" + "'>Reply</a>";
actions += @", <a href='http://forward'>Forward</a>";
actions += @", <a href='http://delete'>Delete</a>";
content += "<b>Actions: </b>" + actions.Trim(',', ' ');
SetHeader(content);
// body
try
{
using (TaggedStream stream = new TaggedStream(Mail.GetLocalPath(message.Header), Core.GuiProtocol))
using (CryptoStream crypto = IVCryptoStream.Load(stream, message.Header.LocalKey))
{
int buffSize = 4096;
byte[] buffer = new byte[4096];
long bytesLeft = message.Header.FileStart;
while (bytesLeft > 0)
{
int readSize = (bytesLeft > buffSize) ? buffSize : (int)bytesLeft;
int read = crypto.Read(buffer, 0, readSize);
bytesLeft -= read;
}
// load file
foreach (MailFile file in message.Attached)
if (file.Name == "body")
{
byte[] msgBytes = new byte[file.Size];
crypto.Read(msgBytes, 0, (int)file.Size);
UTF8Encoding utf = new UTF8Encoding();
MessageBody.Clear();
MessageBody.SelectionFont = new Font("Tahoma", 9.75f);
MessageBody.SelectionColor = Color.Black;
if (message.Info.Format == TextFormat.RTF)
MessageBody.Rtf = utf.GetString(msgBytes);
else
MessageBody.Text = utf.GetString(msgBytes);
MessageBody.DetectLinksDefault();
}
}
}
catch (Exception ex)
{
MessageBox.Show(this, "Error Opening Mail: " + ex.Message);
}
if (message.Header.Read == false)
{
message.Header.Read = true;
Mail.SaveMailbox = true;
if (MessageView.SelectedNodes.Count > 0)
((MessageNode)MessageView.SelectedNodes[0]).UpdateRow();
}
}
private void LoadWorking()
{
OpStorage local = Storages.GetStorage(Core.UserID);
if (local == null)
return;
// load working
try
{
string path = Storages.GetWorkingPath(ProjectID);
byte[] key = Storages.LocalFileKey;
if (File.Exists(path)) // use locally committed storage file
{
Modified = true; // working file present on startup, meaning there are changes lingering to be committed
}
else
{
path = Storages.GetFilePath(local);
if (!File.Exists(path))
return;
key = local.File.Header.FileKey;
}
using (TaggedStream source = new TaggedStream(path, Protocol))
using (IVCryptoStream crypto = IVCryptoStream.Load(source, key))
{
PacketStream stream = new PacketStream(crypto, Protocol, FileAccess.Read);
G2Header header = null;
bool readingProject = false;
LocalFolder CurrentFolder = RootFolder;
string CurrentPath = RootPath;
while (stream.ReadPacket(ref header))
{
if (header.Name == StoragePacket.Root)
{
StorageRoot root = StorageRoot.Decode(header);
readingProject = (root.ProjectID == ProjectID);
}
if (readingProject)
{
if (header.Name == StoragePacket.Folder)
{
StorageFolder folder = StorageFolder.Decode(header);
bool added = false;
while (!added)
{
if (CurrentFolder.Info.UID == folder.ParentUID)
{
// tracked, so need to add multiple folders (archives) with same UIDs
CurrentFolder = CurrentFolder.AddFolderInfo(folder);
added = true;
}
else if (CurrentFolder.Parent == null) // error
break;
else if (CurrentFolder.Parent.GetType() == typeof(LocalFolder))
CurrentFolder = CurrentFolder.Parent;
else
break;
}
if (!added)
{
Debug.Assert(false);
throw new Exception("Error loading CFS");
}
}
if (header.Name == StoragePacket.File)
{
StorageFile file = StorageFile.Decode(header);
CurrentFolder.AddFileInfo(file);
}
}
}
}
}
catch (Exception ex)
{
Core.Network.UpdateLog("Storage", "Error loading headers " + ex.Message);
}
}
public void SaveLocal(uint project)
{
try
{
string tempPath = Core.GetTempPath();
byte[] key = Utilities.GenerateKey(Core.StrongRndGen, 256);
using (IVCryptoStream stream = IVCryptoStream.Save(tempPath, key))
{
// write loaded projects
WorkingStorage working = null;
if (Working.ContainsKey(project))
working = Working[project];
if (working != null)
{
Protocol.WriteToFile(new StorageRoot(working.ProjectID), stream);
working.WriteWorkingFile(stream, working.RootFolder, true);
working.Modified = false;
try { File.Delete(GetWorkingPath(project)); }
catch { }
}
// open old file and copy entries, except for working
OpStorage local = GetStorage(Core.UserID);
if (local != null)
{
string oldPath = GetFilePath(local);
if (File.Exists(oldPath))
{
using (TaggedStream file = new TaggedStream(oldPath, Network.Protocol))
using (IVCryptoStream crypto = IVCryptoStream.Load(file, local.File.Header.FileKey))
{
PacketStream oldStream = new PacketStream(crypto, Protocol, FileAccess.Read);
bool write = false;
G2Header g2header = null;
while (oldStream.ReadPacket(ref g2header))
{
if (g2header.Name == StoragePacket.Root)
{
StorageRoot root = StorageRoot.Decode(g2header);
write = (root.ProjectID != project);
}
//copy packet right to new file
if (write) //crit test
stream.Write(g2header.Data, g2header.PacketPos, g2header.PacketSize);
}
}
}
}
stream.WriteByte(0); // signal last packet
stream.FlushFinalBlock();
}
SavingLocal = true; // prevents auto-integrate from re-calling saveLocal
OpVersionedFile vfile = Cache.UpdateLocal(tempPath, key, BitConverter.GetBytes(Core.TimeNow.ToUniversalTime().ToBinary()));
SavingLocal = false;
Store.PublishDirect(Core.Trust.GetLocsAbove(), Core.UserID, ServiceID, FileTypeCache, vfile.SignedHeader);
}
catch (Exception ex)
{
Core.Network.UpdateLog("Storage", "Error updating local " + ex.Message);
}
if (StorageUpdate != null)
Core.RunInGuiThread(StorageUpdate, GetStorage(Core.UserID));
}
public void Load(LoadModeType loadMode)
{
RijndaelManaged Password = new RijndaelManaged();
Password.Key = PasswordKey;
byte[] iv = new byte[16];
byte[] salt = new byte[4];
OpCore lookup = null;
if (Core != null)
lookup = Core.Context.Lookup;
try
{
using (TaggedStream file = new TaggedStream(ProfilePath, Protocol, ProcessSplash)) // tagged with splash
{
// first 16 bytes IV, next 4 bytes is salt
file.Read(iv, 0, 16);
file.Read(salt, 0, 4);
Password.IV = iv;
using (CryptoStream crypto = new CryptoStream(file, Password.CreateDecryptor(), CryptoStreamMode.Read))
{
PacketStream stream = new PacketStream(crypto, Protocol, FileAccess.Read);
G2Header root = null;
while (stream.ReadPacket(ref root))
{
if (loadMode == LoadModeType.Settings)
{
if (root.Name == IdentityPacket.OperationSettings)
Settings = SettingsPacket.Decode(root);
if (root.Name == IdentityPacket.UserInfo && Core != null &&
(Core.Sim == null || !Core.Sim.Internet.FreshStart))
Core.IndexInfo(UserInfo.Decode(root));
// save icon to identity file because only root node saves icon/splash to link file
// to minimize link file size, but allow user to set custom icon/splash if there are not overrides
if (root.Name == IdentityPacket.Icon)
OpIcon = IconPacket.Decode(root).OpIcon;
}
if (lookup != null && (loadMode == LoadModeType.AllCaches || loadMode == LoadModeType.LookupCache))
{
if (root.Name == IdentityPacket.LookupCachedIP)
lookup.Network.Cache.AddSavedContact(CachedIP.Decode(root));
if (root.Name == IdentityPacket.LookupCachedWeb)
lookup.Network.Cache.AddWebCache(WebCache.Decode(root));
}
if (loadMode == LoadModeType.AllCaches)
{
if (root.Name == IdentityPacket.OpCachedIP)
Core.Network.Cache.AddSavedContact(CachedIP.Decode(root));
if (root.Name == IdentityPacket.OpCachedWeb)
Core.Network.Cache.AddWebCache(WebCache.Decode(root));
}
}
}
}
}
catch(Exception ex)
{
throw ex;
}
}
private void UnloadHeaderFile(string path, byte[] key)
{
try
{
if (!File.Exists(path))
return;
using (TaggedStream filex = new TaggedStream(path, Network.Protocol))
using (IVCryptoStream crypto = IVCryptoStream.Load(filex, key))
{
PacketStream stream = new PacketStream(crypto, Protocol, FileAccess.Read);
G2Header header = null;
while (stream.ReadPacket(ref header))
{
if (header.Name == StoragePacket.File)
{
StorageFile packet = StorageFile.Decode(header);
if (packet == null)
continue;
OpFile commonFile = null;
if (!FileMap.SafeTryGetValue(packet.HashID, out commonFile))
continue;
commonFile.DeRef();
}
}
}
}
catch (Exception ex)
{
Core.Network.UpdateLog("Storage", "Error loading files " + ex.Message);
}
}
private void LoadHeaderFile(string path, OpStorage storage, bool reload, bool working)
{
try
{
if (!File.Exists(path))
return;
bool cached = Network.Routing.InCacheArea(storage.UserID);
bool local = false;
byte[] key = working ? LocalFileKey : storage.File.Header.FileKey;
using (TaggedStream filex = new TaggedStream(path, Network.Protocol))
using (IVCryptoStream crypto = IVCryptoStream.Load(filex, key))
{
PacketStream stream = new PacketStream(crypto, Protocol, FileAccess.Read);
G2Header header = null;
ulong currentUID = 0;
while (stream.ReadPacket(ref header))
{
if (!working && header.Name == StoragePacket.Root)
{
StorageRoot packet = StorageRoot.Decode(header);
local = Core.UserID == storage.UserID ||
GetHigherRegion(Core.UserID, packet.ProjectID).Contains(storage.UserID) ||
Trust.GetDownlinkIDs(Core.UserID, packet.ProjectID, 1).Contains(storage.UserID);
}
if (header.Name == StoragePacket.File)
{
StorageFile packet = StorageFile.Decode(header);
if (packet == null)
continue;
bool historyFile = true;
if (packet.UID != currentUID)
{
historyFile = false;
currentUID = packet.UID;
}
OpFile file = null;
if (!FileMap.SafeTryGetValue(packet.HashID, out file))
{
file = new OpFile(packet);
FileMap.SafeAdd(packet.HashID, file);
}
InternalFileMap.SafeAdd(packet.InternalHashID, file);
if (!reload)
file.References++;
if (!working) // if one ref is public, then whole file is marked public
file.Working = false;
if (packet.HashID == 0 || packet.InternalHash == null)
{
Debug.Assert(false);
continue;
}
string filepath = GetFilePath(packet.HashID);
file.Downloaded = File.Exists(filepath);
if (Loading && file.Downloaded && !ReferencedPaths.Contains(filepath))
ReferencedPaths.Add(filepath);
if (!file.Downloaded)
{
// if in local range only store latest
if (local && !historyFile)
DownloadFile(storage.UserID, packet);
// if storage is in cache range, download all files
else if (Network.Established && cached)
DownloadFile(storage.UserID, packet);
}
// on link update, if in local range, get latest files
// (handled by location update, when it sees a new version of storage component is available)
}
}
}
}
catch (Exception ex)
{
Core.Network.UpdateLog("Storage", "Error loading files " + ex.Message);
}
}
public void CollectionDownloadFinished(object[] args)
{
ShareCollection collection = args[0] as ShareCollection;
ushort client = (ushort) args[1];
collection.Files.LockWriting(() =>
{
foreach (SharedFile file in collection.Files.Where(c => c.ClientID == client).ToArray())
collection.Files.Remove(file);
});
try
{
string finalpath = GetPublicPath(collection);
using (TaggedStream tagged = new TaggedStream(finalpath, Network.Protocol))
using (IVCryptoStream crypto = IVCryptoStream.Load(tagged, collection.Key))
{
PacketStream stream = new PacketStream(crypto, Network.Protocol, FileAccess.Read);
G2Header root = null;
collection.Files.LockWriting(() =>
{
while (stream.ReadPacket(ref root))
if (root.Name == SharePacket.File)
{
SharedFile file = SharedFile.Decode(root, client);
// dont add dupes from diff client ids
if (collection.Files.Any(f => f.Size == file.Size && Utilities.MemCompare(f.Hash, file.Hash)))
continue;
file.FileID = OpTransfer.GetFileID(ServiceID, file.Hash, file.Size);
collection.Files.SafeAdd(file);
}
});
}
}
catch (Exception ex)
{
Core.Network.UpdateLog("Mail", "Error loading local mail " + ex.Message);
}
collection.Status = collection.Files.SafeCount + " Files Shared";
Core.RunInGuiThread(GuiCollectionUpdate, collection.UserID);
}
private ProfileTemplate GetTemplate(ulong id)
{
OpProfile profile = Profiles.GetProfile(id);
if (profile == null)
return null;
ProfileTemplate template = new ProfileTemplate(false, true);
template.User = Core.GetName(id); ;
template.FilePath = Profiles.GetFilePath(profile);
template.FileKey = profile.File.Header.FileKey;
if (!profile.Loaded)
Profiles.LoadProfile(profile.UserID);
try
{
using (TaggedStream stream = new TaggedStream(template.FilePath, Core.GuiProtocol))
using (IVCryptoStream crypto = IVCryptoStream.Load(stream, template.FileKey))
{
int buffSize = 4096;
byte[] buffer = new byte[4096];
long bytesLeft = profile.EmbeddedStart;
while (bytesLeft > 0)
{
int readSize = (bytesLeft > (long)buffSize) ? buffSize : (int)bytesLeft;
int read = crypto.Read(buffer, 0, readSize);
bytesLeft -= (long)read;
}
foreach (ProfileAttachment attach in profile.Attached)
if (attach.Name.StartsWith("template"))
{
byte[] html = new byte[attach.Size];
crypto.Read(html, 0, (int)attach.Size);
template.Html = UTF8Encoding.UTF8.GetString(html);
SHA1CryptoServiceProvider sha1 = new SHA1CryptoServiceProvider();
template.Hash = sha1.ComputeHash(html);
break;
}
}
}
catch
{
return null;
}
return template;
}
public bool RefreshHigherChanges(ulong id)
{
// first remove changes from this id
RemoveHigherChanges(RootFolder, id);
bool save = false;
OpStorage storage = Storages.GetStorage(id);
if (storage == null)
return save;
// this is the first step in auto-integration
// go through this id's storage file, and add any changes or updates to our own system
string path = Storages.GetFilePath(storage);
if (!File.Exists(path))
return save;
try
{
using (TaggedStream filex = new TaggedStream(path, Protocol))
using (IVCryptoStream crypto = IVCryptoStream.Load(filex, storage.File.Header.FileKey))
{
PacketStream stream = new PacketStream(crypto, Protocol, FileAccess.Read);
ulong currentUID = 0;
LocalFolder currentFolder = RootFolder;
LocalFile currentFile = null;
bool ignoreCurrent = false;
bool readingProject = false;
G2Header header = null;
while (stream.ReadPacket(ref header))
{
if (header.Name == StoragePacket.Root)
{
StorageRoot root = StorageRoot.Decode(header);
readingProject = (root.ProjectID == ProjectID);
}
if (readingProject)
{
if (header.Name == StoragePacket.Folder)
{
StorageFolder readFolder = StorageFolder.Decode(header);
// if new uid
if (currentUID != readFolder.UID)
{
// if only 1 entry in changes for previous file, remove it, its probably a dupe of local
// and integration needs more than one file to happen
if (currentFolder.HigherChanges.ContainsKey(id) && currentFolder.HigherChanges[id].Count == 1)
currentFolder.HigherChanges.Remove(id);
// set new id
currentUID = readFolder.UID;
// check scope
ignoreCurrent = false;
if (readFolder.Scope.Count > 0 && !Core.Trust.IsInScope(readFolder.Scope, Core.UserID, ProjectID))
ignoreCurrent = true;
bool added = false;
while (!added)
{
if (currentFolder.Info.UID == readFolder.ParentUID)
{
LocalFolder subFolder = null;
if (currentFolder.Folders.SafeTryGetValue(currentUID, out subFolder))
currentFolder = subFolder;
else
{
// if ignoring, add folder so we can traverse id's file, but dont save changes to local storage mapping
if (ignoreCurrent)
{
currentFolder = new LocalFolder(currentFolder, readFolder);
break;
}
// check for conflicting name
currentFolder.Folders.LockReading(delegate()
{
foreach (LocalFolder subfolder in currentFolder.Folders.Values)
if (!subfolder.Info.IsFlagged(StorageFlags.Archived) && subfolder.Info.Name == readFolder.Name)
subfolder.Info.Name = subfolder.Info.Name + ".fix";
});
// if not found, create folder
currentFolder = currentFolder.AddFolderInfo(readFolder);
save = true;
}
added = true;
}
else if (currentFolder.Parent == null)
break; // error, couldn't find parent of folder that was read
else if (currentFolder.Parent.GetType() == typeof(LocalFolder))
currentFolder = currentFolder.Parent;
else
break;
}
}
// if file does not equal null
if (currentFolder != null && !ignoreCurrent)
{
// log change if file newer than ours
// if if not in higher's history
// or if file integrated by higher by a node we would have inherited from
// we look for our own file in higher changes, if there then we can auto integrate
if (readFolder.Date >= currentFolder.Info.Date)
if (readFolder.IntegratedID == 0 ||
readFolder.IntegratedID == Core.UserID ||
Core.Trust.IsAdjacent(readFolder.IntegratedID, ProjectID))
currentFolder.AddHigherChange(id, readFolder);
}
}
if (header.Name == StoragePacket.File)
{
StorageFile readFile = StorageFile.Decode(header);
// if new uid
if (currentUID != readFile.UID)
{
// if only 1 entry in changes for previous file, remove it, its probably a dupe of local
// and integration needs more than one file to happen
if (currentFile != null && currentFile.HigherChanges.ContainsKey(id) && currentFile.HigherChanges[id].Count == 1)
currentFile.HigherChanges.Remove(id);
// set new id
currentUID = readFile.UID;
currentFile = null;
// check scope
ignoreCurrent = false;
if (readFile.Scope.Count > 0 && !Core.Trust.IsInScope(readFile.Scope, Core.UserID, ProjectID))
{
ignoreCurrent = true;
continue;
}
// if file exists with UID, else add file as temp, mark as changed
if (!currentFolder.Files.SafeTryGetValue(currentUID, out currentFile))
{
// check for conflicting name
currentFolder.Files.LockReading(delegate()
{
foreach (LocalFile checkFile in currentFolder.Files.Values)
if (!checkFile.Info.IsFlagged(StorageFlags.Archived) && checkFile.Info.Name == readFile.Name)
checkFile.Info.Name = checkFile.Info.Name + ".fix";
});
currentFile = currentFolder.AddFileInfo(readFile);
save = true;
if (!Storages.FileExists(currentFile.Info))
Storages.DownloadFile(id, currentFile.Info);
}
}
// if file does not equal null
if (currentFile != null && !ignoreCurrent)
{
if (readFile.Date >= currentFile.Info.Date)
if (readFile.IntegratedID == 0 ||
readFile.IntegratedID == Core.UserID ||
Core.Trust.IsAdjacent(readFile.IntegratedID, ProjectID))
currentFile.AddHigherChange(id, readFile);
}
}
}
}
}
}
catch
{
}
return save;
}
public static void DecryptTagFile(string source, string destination, byte[] key, OpCore core)
{
int bufferSize = 4096;
byte[] buffer = new byte[4096]; // needs to be 4k to packet stream break/resume work
string tempPath = (core != null) ? core.GetTempPath() : destination;
G2Protocol protocol = (core != null) ? core.Network.Protocol : new G2Protocol();
using (FileStream tempFile = new FileStream(tempPath, FileMode.Create))
using (TaggedStream encFile = new TaggedStream(source, protocol))
using (IVCryptoStream stream = IVCryptoStream.Load(encFile, key))
{
int read = bufferSize;
while (read == bufferSize)
{
read = stream.Read(buffer, 0, bufferSize);
tempFile.Write(buffer, 0, read);
}
}
// move to official path
if (core == null)
return;
File.Copy(tempPath, destination, true);
File.Delete(tempPath);
}
private static string LoadProfile(ProfileService service, OpProfile profile, string tempPath, Dictionary<string, string> textFields, Dictionary<string, string> fileFields)
{
string template = null;
textFields.Clear();
textFields["local_help"] = (profile.UserID == service.Core.UserID) ? "<font size=2>Right-click or click <a href='http://edit'>here</a> to Edit</font>" : "";
if(fileFields != null)
fileFields.Clear();
if (!profile.Loaded)
service.LoadProfile(profile.UserID);
try
{
using (TaggedStream stream = new TaggedStream(service.GetFilePath(profile), service.Core.GuiProtocol))
using (IVCryptoStream crypto = IVCryptoStream.Load(stream, profile.File.Header.FileKey))
{
int buffSize = 4096;
byte[] buffer = new byte[4096];
long bytesLeft = profile.EmbeddedStart;
while (bytesLeft > 0)
{
int readSize = (bytesLeft > (long)buffSize) ? buffSize : (int)bytesLeft;
int read = crypto.Read(buffer, 0, readSize);
bytesLeft -= (long)read;
}
// load file
foreach (ProfileAttachment attached in profile.Attached)
{
if (attached.Name.StartsWith("template"))
{
byte[] html = new byte[attached.Size];
crypto.Read(html, 0, (int)attached.Size);
UTF8Encoding utf = new UTF8Encoding();
template = utf.GetString(html);
}
else if (attached.Name.StartsWith("fields"))
{
byte[] data = new byte[attached.Size];
crypto.Read(data, 0, (int)attached.Size);
int start = 0, length = data.Length;
G2ReadResult streamStatus = G2ReadResult.PACKET_GOOD;
while (streamStatus == G2ReadResult.PACKET_GOOD)
{
G2ReceivedPacket packet = new G2ReceivedPacket();
packet.Root = new G2Header(data);
streamStatus = G2Protocol.ReadNextPacket(packet.Root, ref start, ref length);
if (streamStatus != G2ReadResult.PACKET_GOOD)
break;
if (packet.Root.Name == ProfilePacket.Field)
{
ProfileField field = ProfileField.Decode(packet.Root);
if (field.Value == null)
continue;
if (field.FieldType == ProfileFieldType.Text)
textFields[field.Name] = UTF8Encoding.UTF8.GetString(field.Value);
else if (field.FieldType == ProfileFieldType.File && fileFields != null)
fileFields[field.Name] = UTF8Encoding.UTF8.GetString(field.Value);
}
}
}
else if (attached.Name.StartsWith("file=") && fileFields != null)
{
string name = attached.Name.Substring(5);
try
{
string fileKey = null;
foreach (string key in fileFields.Keys)
if (name == fileFields[key])
{
fileKey = key;
break;
}
fileFields[fileKey] = tempPath + Path.DirectorySeparatorChar + name;
using (FileStream extract = new FileStream(fileFields[fileKey], FileMode.CreateNew, FileAccess.Write))
{
long remaining = attached.Size;
byte[] buff = new byte[2096];
while (remaining > 0)
{
int read = (remaining > 2096) ? 2096 : (int)remaining;
remaining -= read;
crypto.Read(buff, 0, read);
extract.Write(buff, 0, read);
}
}
}
catch
{ }
}
}
}
}
catch (Exception)
{
}
return template;
}
