#include "mega/node.h"

#include "mega/megaclient.h"

#include "mega/megaapp.h"

#include "mega/share.h"

#include "mega/serialize64.h"

#include "mega/base64.h"

#include "mega/sync.h"

#include "mega/transfer.h"

#include "mega/transferslot.h"

#include "mega/logging.h"

namespace mega {

Node::Node(MegaClient* cclient, node_vector* dp, handle h, handle ph,

}

Node::~Node()

{

if (keyApplied())

{

client->mAppliedKeyNodeCount--;

assert(client->mAppliedKeyNodeCount >= 0);

}

// abort pending direct reads

client->preadabort(this);

// remove node's fingerprint from hash

if (!client->mOptimizePurgeNodes)

{

client->mFingerprints.remove(this);

}

#ifdef ENABLE_SYNC

// remove from todebris node_set

if (todebris_it != client->todebris.end())

{

client->todebris.erase(todebris_it);

}

// remove from tounlink node_set

if (tounlink_it != client->tounlink.end())

{

client->tounlink.erase(tounlink_it);

}

#endif

if (outshares)

{

// delete outshares, including pointers from users for this node

for (share_map::iterator it = outshares->begin(); it != outshares->end(); it++)

{

delete it->second;

}

delete outshares;

}

if (pendingshares)

{

// delete pending shares

for (share_map::iterator it = pendingshares->begin(); it != pendingshares->end(); it++)

{

delete it->second;

}

delete pendingshares;

}

if (!client->mOptimizePurgeNodes)

{

// remove from parent's children

if (parent)

{

parent->children.erase(child_it);

}

Node* fa = firstancestor();

handle ancestor = fa->nodehandle;

if (ancestor == client->rootnodes[0] || ancestor == client->rootnodes[1] || ancestor == client->rootnodes[2] || fa->inshare)

{

client->mNodeCounters[firstancestor()->nodehandle] -= subnodeCounts();

}

if (inshare)

{

client->mNodeCounters.erase(nodehandle);

}

// delete child-parent associations (normally not used, as nodes are

// deleted bottom-up)

for (node_list::iterator it = children.begin(); it != children.end(); it++)

{

(*it)->parent = NULL;

}

}

if (plink)

{

client->mPublicLinks.erase(nodehandle);

}

delete plink;

delete inshare;

delete sharekey;

#ifdef ENABLE_SYNC

// sync: remove reference from local filesystem node

if (localnode)

{

localnode->deleted = true;

localnode->node = NULL;

}

// in case this node is currently being transferred for syncing: abort transfer

delete syncget;

#endif

}

void Node::setkeyfromjson(const char* k)

}

void Node::setkey(const byte* newkey)

}

Node* Node::unserialize(MegaClient* client, const string* d, node_vector* dp)

{

handle h, ph;

nodetype_t t;

m_off_t s;

handle u;

const byte* k = NULL;

const char* fa;

m_time_t ts;

const byte* skey;

const char* ptr = d->data();

const char* end = ptr + d->size();

unsigned short ll;

Node* n;

int i;

char isExported = '\0';

char hasLinkCreationTs = '\0';

if (ptr + sizeof s + 2 * MegaClient::NODEHANDLE + MegaClient::USERHANDLE + 2 * sizeof ts + sizeof ll > end)

{

return NULL;

}

s = MemAccess::get<m_off_t>(ptr);

ptr += sizeof s;

if (s < 0 && s >= -RUBBISHNODE)

{

t = (nodetype_t)-s;

}

else

{

t = FILENODE;

}

h = 0;

memcpy((char*)&h, ptr, MegaClient::NODEHANDLE);

ptr += MegaClient::NODEHANDLE;

ph = 0;

memcpy((char*)&ph, ptr, MegaClient::NODEHANDLE);

ptr += MegaClient::NODEHANDLE;

if (!ph)

{

ph = UNDEF;

}

u = 0;

memcpy((char*)&u, ptr, MegaClient::USERHANDLE);

ptr += MegaClient::USERHANDLE;

// FIME: use m_time_t / Serialize64 instead

ptr += sizeof(time_t);

ts = (uint32_t)MemAccess::get<time_t>(ptr);

ptr += sizeof(time_t);

if ((t == FILENODE) || (t == FOLDERNODE))

{

int keylen = ((t == FILENODE) ? FILENODEKEYLENGTH : FOLDERNODEKEYLENGTH);

if (ptr + keylen + 8 + sizeof(short) > end)

{

return NULL;

}

k = (const byte*)ptr;

ptr += keylen;

}

if (t == FILENODE)

{

ll = MemAccess::get<unsigned short>(ptr);

ptr += sizeof ll;

if (ptr + ll > end)

{

return NULL;

}

fa = ptr;

ptr += ll;

}

else

{

fa = NULL;

}

if (ptr + sizeof isExported + sizeof hasLinkCreationTs > end)

{

return NULL;

}

isExported = MemAccess::get<char>(ptr);

ptr += sizeof(isExported);

hasLinkCreationTs = MemAccess::get<char>(ptr);

ptr += sizeof(hasLinkCreationTs);

for (i = 6; i--;)

{

if (ptr + (unsigned char)*ptr < end)

{

ptr += (unsigned char)*ptr + 1;

}

}

if (ptr + sizeof(short) > end)

{

return NULL;

}

short numshares = MemAccess::get<short>(ptr);

ptr += sizeof(numshares);

if (numshares)

{

if (ptr + SymmCipher::KEYLENGTH > end)

{

return NULL;

}

skey = (const byte*)ptr;

ptr += SymmCipher::KEYLENGTH;

}

else

{

skey = NULL;

}

n = new Node(client, dp, h, ph, t, s, u, fa, ts);

if (k)

{

n->setkey(k);

}

// read inshare, outshares, or pending shares

while (numshares) // inshares: -1, outshare/s: num_shares

{

int direction = (numshares > 0) ? -1 : 0;

NewShare *newShare = Share::unserialize(direction, h, skey, &ptr, end);

if (!newShare)

{

LOG_err << "Failed to unserialize Share";

break;

}

client->newshares.push_back(newShare);

if (numshares > 0) // outshare/s

{

numshares--;

}

else // inshare

{

break;

}

}

ptr = n->attrs.unserialize(ptr, end);

if (!ptr)

{

delete n;

return NULL;

}

// It's needed to re-normalize node names because

// the updated version of utf8proc doesn't provide

// exactly the same output as the previous one that

// we were using

attr_map::iterator it = n->attrs.map.find('n');

if (it != n->attrs.map.end())

{

client->fsaccess->normalize(&(it->second));

}

PublicLink *plink = NULL;

if (isExported)

{

if (ptr + MegaClient::NODEHANDLE + sizeof(m_time_t) + sizeof(bool) > end)

{

delete n;

return NULL;

}

handle ph = 0;

memcpy((char*)&ph, ptr, MegaClient::NODEHANDLE);

ptr += MegaClient::NODEHANDLE;

m_time_t ets = MemAccess::get<m_time_t>(ptr);

ptr += sizeof(ets);

bool takendown = MemAccess::get<bool>(ptr);

ptr += sizeof(takendown);

m_time_t cts = 0;

if (hasLinkCreationTs)

{

cts = MemAccess::get<m_time_t>(ptr);

ptr += sizeof(cts);

}

plink = new PublicLink(ph, cts, ets, takendown);

client->mPublicLinks[n->nodehandle] = plink->ph;

}

n->plink = plink;

n->setfingerprint();

if (ptr == end)

{

return n;

}

else

{

delete n;

return NULL;

}

}

bool Node::serialize(string* d)

}

void Node::copystring(string* s, const char* p)

}

byte* Node::decryptattr(SymmCipher* key, const char* attrstring, size_t attrstrlen)

{

if (attrstrlen)

{

int l = int(attrstrlen * 3 / 4 + 3);

byte* buf = new byte[l];

l = Base64::atob(attrstring, buf, l);

if (!(l & (SymmCipher::BLOCKSIZE - 1)))

{

key->cbc_decrypt(buf, l);

if (!memcmp(buf, "MEGA{\"", 6))

{

return buf;

}

}

delete[] buf;

}

return NULL;

}

void Node::parseattr(byte *bufattr, AttrMap &attrs, m_off_t size, m_time_t &mtime , string &fileName, string &fingerprint, FileFingerprint &ffp)

}

SymmCipher* Node::nodecipher()

{

if (client->tmpnodecipher.setkey(&nodekeydata))

{

return &client->tmpnodecipher;

}

return NULL;

}

void Node::setattr()

}

void Node::setfingerprint()

}

const char* Node::displayname() const

{

// not yet decrypted

if (attrstring)

{

LOG_debug << "NO_KEY " << type << " " << size << " " << Base64Str<MegaClient::NODEHANDLE>(nodehandle);

#ifdef ENABLE_SYNC

if (localnode)

{

LOG_debug << "Local name: " << localnode->name;

}

#endif

return "NO_KEY";

}

attr_map::const_iterator it;

it = attrs.map.find('n');

if (it == attrs.map.end())

{

if (type < ROOTNODE || type > RUBBISHNODE)

{

LOG_debug << "CRYPTO_ERROR " << type << " " << size << " " << nodehandle;

#ifdef ENABLE_SYNC

if (localnode)

{

LOG_debug << "Local name: " << localnode->name;

}

#endif

}

return "CRYPTO_ERROR";

}

if (!it->second.size())

{

LOG_debug << "BLANK " << type << " " << size << " " << nodehandle;

#ifdef ENABLE_SYNC

if (localnode)

{

LOG_debug << "Local name: " << localnode->name;

}

#endif

return "BLANK";

}

return it->second.c_str();

}

string Node::displaypath() const

}

int Node::hasfileattribute(fatype t) const

{

return Node::hasfileattribute(&fileattrstring, t);

}

int Node::hasfileattribute(const string *fileattrstring, fatype t)

}

bool Node::applykey()

}

NodeCounter Node::subnodeCounts() const

}

bool Node::setparent(Node* p)