lkn
/
pcloudcc-lneely
mirror of https://github.com/lneely/pcloudcc-lneely.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

ptree namespace

This commit is contained in:
Levi Neely 2025-03-01 21:53:41 +01:00
parent 50e49d308c
commit 8bad4912f0
20 changed files with 326 additions and 326 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

96
pclsync/pfs.c
View File

@ -168,13 +168,13 @@ int psync_fs_update_openfile(uint64_t taskid, uint64_t writeid,
psync_sql_lock();
tr = openfiles;
while (tr) {
d = fileid - psync_tree_element(tr, psync_openfile_t, tree)->fileid;
d = fileid - ptree_element(tr, psync_openfile_t, tree)->fileid;
if (d < 0)
tr = tr->left;
else if (d > 0)
tr = tr->right;
else {
fl = psync_tree_element(tr, psync_openfile_t, tree);
fl = ptree_element(tr, psync_openfile_t, tree);
psync_fs_lock_file(fl);
if (fl->writeid == writeid) {
if (fl->encrypted) {
@ -209,12 +209,12 @@ int psync_fs_update_openfile(uint64_t taskid, uint64_t writeid,
pfile_close(fl->indexfile);
fl->indexfile = INVALID_HANDLE_VALUE;
}
psync_tree_del(&openfiles, &fl->tree);
ptree_del(&openfiles, &fl->tree);
tr = openfiles;
d = -1;
while (tr) {
d = newfileid -
psync_tree_element(tr, psync_openfile_t, tree)->fileid;
ptree_element(tr, psync_openfile_t, tree)->fileid;
if (d < 0) {
if (tr->left)
tr = tr->left;
@ -232,9 +232,9 @@ int psync_fs_update_openfile(uint64_t taskid, uint64_t writeid,
}
}
if (d < 0)
psync_tree_add_before(&openfiles, tr, &fl->tree);
ptree_add_before(&openfiles, tr, &fl->tree);
else
psync_tree_add_after(&openfiles, tr, &fl->tree);
ptree_add_after(&openfiles, tr, &fl->tree);
ret = 0;
} else {
debug(D_NOTICE, "writeid of fileid %ld (%s) differs %lu!=%lu",
@ -278,13 +278,13 @@ int psync_fs_update_openfile(uint64_t taskid, uint64_t writeid,
psync_sql_lock();
tr=openfiles;
while (tr){
d=fileid-psync_tree_element(tr, psync_openfile_t, tree)->fileid;
d=fileid-ptree_element(tr, psync_openfile_t, tree)->fileid;
if (d<0)
tr=tr->left;
else if (d>0)
tr=tr->right;
else{
fl=psync_tree_element(tr, psync_openfile_t, tree);
fl=ptree_element(tr, psync_openfile_t, tree);
psync_fs_lock_file(fl);
fl->uploading=1;
pthread_mutex_unlock(&fl->mutex);
@ -302,13 +302,13 @@ int psync_fs_rename_openfile_locked(psync_fsfileid_t fileid,
int64_t d;
tr = openfiles;
while (tr) {
d = fileid - psync_tree_element(tr, psync_openfile_t, tree)->fileid;
d = fileid - ptree_element(tr, psync_openfile_t, tree)->fileid;
if (d < 0)
tr = tr->left;
else if (d > 0)
tr = tr->right;
else {
fl = psync_tree_element(tr, psync_openfile_t, tree);
fl = ptree_element(tr, psync_openfile_t, tree);
psync_fs_lock_file(fl);
if (fl->currentfolder->folderid != folderid) {
psync_fstask_release_folder_tasks_locked(fl->currentfolder);
@ -334,13 +334,13 @@ void psync_fs_mark_openfile_deleted(uint64_t taskid) {
psync_sql_lock();
tr = openfiles;
while (tr) {
d = fileid - psync_tree_element(tr, psync_openfile_t, tree)->fileid;
d = fileid - ptree_element(tr, psync_openfile_t, tree)->fileid;
if (d < 0)
tr = tr->left;
else if (d > 0)
tr = tr->right;
else {
fl = psync_tree_element(tr, psync_openfile_t, tree);
fl = ptree_element(tr, psync_openfile_t, tree);
debug(D_NOTICE, "file being deleted %s is still open, marking as deleted",
fl->currentname);
psync_fs_lock_file(fl);
@ -366,13 +366,13 @@ int64_t psync_fs_get_file_writeid(uint64_t taskid) {
psync_sql_rdlock();
tr = openfiles;
while (tr) {
d = fileid - psync_tree_element(tr, psync_openfile_t, tree)->fileid;
d = fileid - ptree_element(tr, psync_openfile_t, tree)->fileid;
if (d < 0)
tr = tr->left;
else if (d > 0)
tr = tr->right;
else {
fl = psync_tree_element(tr, psync_openfile_t, tree);
fl = ptree_element(tr, psync_openfile_t, tree);
psync_fs_lock_file(fl);
d = fl->writeid;
pthread_mutex_unlock(&fl->mutex);
@ -396,12 +396,12 @@ void psync_fs_update_openfile_fileid_locked(psync_openfile_t *of,
psync_tree *tr;
int64_t d;
assertw(of->fileid != fileid);
psync_tree_del(&openfiles, &of->tree);
ptree_del(&openfiles, &of->tree);
of->fileid = fileid;
tr = openfiles;
if (tr)
while (1) {
d = fileid - psync_tree_element(tr, psync_openfile_t, tree)->fileid;
d = fileid - ptree_element(tr, psync_openfile_t, tree)->fileid;
if (d < 0) {
if (tr->left)
tr = tr->left;
@ -421,7 +421,7 @@ void psync_fs_update_openfile_fileid_locked(psync_openfile_t *of,
}
else
openfiles = &of->tree;
psync_tree_added_at(&openfiles, tr, &of->tree);
ptree_added_at(&openfiles, tr, &of->tree);
}
#define folderid_to_inode(folderid) ((folderid) * 3)
@ -552,13 +552,13 @@ static int fill_stat_from_open_file(psync_fsfileid_t fileid,
psync_sql_rdlock();
tr = openfiles;
while (tr) {
d = fileid - psync_tree_element(tr, psync_openfile_t, tree)->fileid;
d = fileid - ptree_element(tr, psync_openfile_t, tree)->fileid;
if (d < 0)
tr = tr->left;
else if (d > 0)
tr = tr->right;
else {
fl = psync_tree_element(tr, psync_openfile_t, tree);
fl = ptree_element(tr, psync_openfile_t, tree);
psync_fs_lock_file(fl);
stbuf->st_size = fl->currentsize;
debug(D_NOTICE, "found open file with size %lu",
@ -596,13 +596,13 @@ static int psync_creat_local_to_file_stat(psync_fstask_creat_t *cr,
psync_sql_rdlock();
tr = openfiles;
while (tr) {
d = cr->fileid - psync_tree_element(tr, psync_openfile_t, tree)->fileid;
d = cr->fileid - ptree_element(tr, psync_openfile_t, tree)->fileid;
if (d < 0)
tr = tr->left;
else if (d > 0)
tr = tr->right;
else {
fl = psync_tree_element(tr, psync_openfile_t, tree);
fl = ptree_element(tr, psync_openfile_t, tree);
psync_fs_lock_file(fl);
break;
}
@ -935,36 +935,36 @@ static int psync_fs_readdir(const char *path, void *buf, fuse_fill_dir_t filler,
psync_sql_free_result(res);
}
if (folder) {
psync_tree_for_each(trel, folder->mkdirs) {
ptree_for_each(trel, folder->mkdirs) {
#if defined(FS_MAX_ACCEPTABLE_FILENAME_LEN)
if (unlikely_log(
strlen(
psync_tree_element(trel, psync_fstask_mkdir_t, tree)->name) >
ptree_element(trel, psync_fstask_mkdir_t, tree)->name) >
FS_MAX_ACCEPTABLE_FILENAME_LEN))
continue;
#endif
if (psync_tree_element(trel, psync_fstask_mkdir_t, tree)->flags &
if (ptree_element(trel, psync_fstask_mkdir_t, tree)->flags &
PSYNC_FOLDER_FLAG_INVISIBLE)
continue;
psync_mkdir_to_folder_stat(
psync_tree_element(trel, psync_fstask_mkdir_t, tree), &st);
ptree_element(trel, psync_fstask_mkdir_t, tree), &st);
filler_decoded(dec, filler, buf,
psync_tree_element(trel, psync_fstask_mkdir_t, tree)->name,
ptree_element(trel, psync_fstask_mkdir_t, tree)->name,
&st, 0);
}
psync_tree_for_each(trel, folder->creats) {
ptree_for_each(trel, folder->creats) {
#if defined(FS_MAX_ACCEPTABLE_FILENAME_LEN)
if (unlikely_log(
strlen(
psync_tree_element(trel, psync_fstask_creat_t, tree)->name) >
ptree_element(trel, psync_fstask_creat_t, tree)->name) >
FS_MAX_ACCEPTABLE_FILENAME_LEN))
continue;
#endif
if (!psync_creat_to_file_stat(
psync_tree_element(trel, psync_fstask_creat_t, tree), &st, flags))
ptree_element(trel, psync_fstask_creat_t, tree), &st, flags))
filler_decoded(
dec, filler, buf,
psync_tree_element(trel, psync_fstask_creat_t, tree)->name, &st, 0);
ptree_element(trel, psync_fstask_creat_t, tree)->name, &st, 0);
}
}
psync_sql_rdunlock();
@ -985,7 +985,7 @@ psync_fs_create_file(psync_fsfileid_t fileid, psync_fsfileid_t remotefileid,
tr = openfiles;
d = -1;
while (tr) {
d = fileid - psync_tree_element(tr, psync_openfile_t, tree)->fileid;
d = fileid - ptree_element(tr, psync_openfile_t, tree)->fileid;
if (d < 0) {
if (tr->left)
tr = tr->left;
@ -997,7 +997,7 @@ psync_fs_create_file(psync_fsfileid_t fileid, psync_fsfileid_t remotefileid,
else
break;
} else {
fl = psync_tree_element(tr, psync_openfile_t, tree);
fl = ptree_element(tr, psync_openfile_t, tree);
if (lock) {
psync_fs_lock_file(fl);
psync_fs_inc_of_refcnt_locked(fl);
@ -1025,9 +1025,9 @@ psync_fs_create_file(psync_fsfileid_t fileid, psync_fsfileid_t remotefileid,
size = pfscrypto_plain_size(size);
}
if (d < 0)
psync_tree_add_before(&openfiles, tr, &fl->tree);
ptree_add_before(&openfiles, tr, &fl->tree);
else
psync_tree_add_after(&openfiles, tr, &fl->tree);
ptree_add_after(&openfiles, tr, &fl->tree);
#if IS_DEBUG
{
pthread_mutexattr_t mattr;
@ -1227,7 +1227,7 @@ static void psync_fs_del_creat(psync_fspath_t *fpath, psync_openfile_t *of) {
folder = psync_fstask_get_or_create_folder_tasks_locked(fpath->folderid);
if (likely(folder)) {
if (likely((cr = psync_fstask_find_creat(folder, fpath->name, 0)))) {
psync_tree_del(&folder->creats, &cr->tree);
ptree_del(&folder->creats, &cr->tree);
folder->taskscnt--;
psync_free(cr);
}
@ -1716,7 +1716,7 @@ static void psync_fs_free_openfile(psync_openfile_t *of) {
pcrypto_sec_encdec_free(of->encoder);
}
close_if_valid(of->logfile);
psync_tree_for_each_element_call_safe(
ptree_for_each_element_call_safe(
of->sectorsinlog, psync_sector_inlog_t, tree, psync_free);
delete_log_files(of);
if (of->authenticatedints)
@ -1733,7 +1733,7 @@ static void psync_fs_free_openfile(psync_openfile_t *of) {
psync_sql_lock();
cr = psync_fstask_find_creat(of->currentfolder, of->currentname, 0);
if (cr) {
psync_tree_del(&of->currentfolder->creats, &cr->tree);
ptree_del(&of->currentfolder->creats, &cr->tree);
of->currentfolder->taskscnt--;
psync_free(cr);
}
@ -1763,7 +1763,7 @@ void psync_fs_dec_of_refcnt(psync_openfile_t *of) {
psync_fs_get_both_locks(of);
refcnt = --of->refcnt;
if (!refcnt)
psync_tree_del(&openfiles, &of->tree);
ptree_del(&openfiles, &of->tree);
psync_sql_unlock();
pthread_mutex_unlock(&of->mutex);
if (!refcnt)
@ -1783,7 +1783,7 @@ void psync_fs_dec_of_refcnt_and_readers(psync_openfile_t *of) {
of->runningreads--;
refcnt = --of->refcnt;
if (refcnt == 0)
psync_tree_del(&openfiles, &of->tree);
ptree_del(&openfiles, &of->tree);
psync_sql_unlock();
pthread_mutex_unlock(&of->mutex);
if (!refcnt)
@ -2246,13 +2246,13 @@ psync_fs_reopen_static_file_for_writing(psync_openfile_t *of) {
psync_fs_static_to_task(taskid, cr->taskid);
cr = psync_fstask_find_creat(of->currentfolder, of->currentname, taskid);
if (likely_log(cr)) {
psync_tree_del(&of->currentfolder->creats, &cr->tree);
ptree_del(&of->currentfolder->creats, &cr->tree);
of->currentfolder->taskscnt--;
psync_free(cr);
}
un = psync_fstask_find_unlink(of->currentfolder, of->currentname, taskid);
if (likely_log(un)) {
psync_tree_del(&of->currentfolder->unlinks, &un->tree);
ptree_del(&of->currentfolder->unlinks, &un->tree);
of->currentfolder->taskscnt--;
psync_free(un);
}
@ -2640,11 +2640,11 @@ static int psync_fs_rename_static_file(psync_fstask_folder_t *srcfolder,
(long)to_folderid);
un = psync_fstask_find_unlink(dstfolder, new_name, cr->taskid);
if (un) {
psync_tree_del(&dstfolder->unlinks, &un->tree);
ptree_del(&dstfolder->unlinks, &un->tree);
psync_free(un);
dstfolder->taskscnt--;
}
psync_tree_del(&dstfolder->creats, &cr->tree);
ptree_del(&dstfolder->creats, &cr->tree);
psync_free(cr);
dstfolder->taskscnt--;
}
@ -2668,11 +2668,11 @@ static int psync_fs_rename_static_file(psync_fstask_folder_t *srcfolder,
psync_fstask_release_folder_tasks_locked(dstfolder);
un = psync_fstask_find_unlink(srcfolder, srccr->name, srccr->taskid);
if (likely_log(un)) {
psync_tree_del(&srcfolder->unlinks, &un->tree);
ptree_del(&srcfolder->unlinks, &un->tree);
psync_free(un);
srcfolder->taskscnt--;
}
psync_tree_del(&srcfolder->creats, &srccr->tree);
ptree_del(&srcfolder->creats, &srccr->tree);
psync_free(srccr);
srcfolder->taskscnt--;
return 0;
@ -3055,13 +3055,13 @@ static int psync_fs_set_filetime_locked(psync_fsfileid_t fileid,
tr = openfiles;
fl = NULL;
while (tr) {
d = fileid - psync_tree_element(tr, psync_openfile_t, tree)->fileid;
d = fileid - ptree_element(tr, psync_openfile_t, tree)->fileid;
if (d < 0)
tr = tr->left;
else if (d > 0)
tr = tr->right;
else {
fl = psync_tree_element(tr, psync_openfile_t, tree);
fl = ptree_element(tr, psync_openfile_t, tree);
break;
}
}
@ -3450,7 +3450,7 @@ static void psync_fs_dump_internals() {
psync_openfile_t *of;
debug(D_NOTICE, "dumping internal state");
psync_sql_rdlock();
psync_tree_for_each_element(of, openfiles, psync_openfile_t, tree)
ptree_for_each_element(of, openfiles, psync_openfile_t, tree)
debug(D_NOTICE, "open file %s fileid %ld folderid %ld", of->currentname,
(long)of->fileid, (long)of->currentfolder->folderid);
psync_fstask_dump_state();

34
pclsync/pfscrypto.c
View File

@ -439,13 +439,13 @@ psync_fs_crypto_read_newfile_full_sector(psync_openfile_t *of, char *buf,
psync_crypto_sectorid_t sectorid) {
psync_crypto_sectorid_diff_t d;
psync_sector_inlog_t *tr;
tr = psync_tree_element(of->sectorsinlog, psync_sector_inlog_t, tree);
tr = ptree_element(of->sectorsinlog, psync_sector_inlog_t, tree);
while (tr) {
d = sectorid - tr->sectorid;
if (d < 0)
tr = psync_tree_element(tr->tree.left, psync_sector_inlog_t, tree);
tr = ptree_element(tr->tree.left, psync_sector_inlog_t, tree);
else if (d > 0)
tr = psync_tree_element(tr->tree.right, psync_sector_inlog_t, tree);
tr = ptree_element(tr->tree.right, psync_sector_inlog_t, tree);
else
return psync_fs_crypto_read_newfile_full_sector_from_log(of, buf, tr);
}
@ -549,20 +549,20 @@ psync_fs_crypto_set_sector_log_offset(psync_openfile_t *of,
psync_crypto_sectorid_diff_t d;
psync_sector_inlog_t *tr, *ntr;
psync_tree **pe;
tr = psync_tree_element(of->sectorsinlog, psync_sector_inlog_t, tree);
tr = ptree_element(of->sectorsinlog, psync_sector_inlog_t, tree);
pe = &of->sectorsinlog;
while (tr) {
d = sectorid - tr->sectorid;
if (d < 0) {
if (tr->tree.left)
tr = psync_tree_element(tr->tree.left, psync_sector_inlog_t, tree);
tr = ptree_element(tr->tree.left, psync_sector_inlog_t, tree);
else {
pe = &tr->tree.left;
break;
}
} else if (d > 0) {
if (tr->tree.right)
tr = psync_tree_element(tr->tree.right, psync_sector_inlog_t, tree);
tr = ptree_element(tr->tree.right, psync_sector_inlog_t, tree);
else {
pe = &tr->tree.right;
break;
@ -578,7 +578,7 @@ psync_fs_crypto_set_sector_log_offset(psync_openfile_t *of,
ntr->sectorid = sectorid;
ntr->logoffset = offset;
memcpy(ntr->auth, auth, PSYNC_CRYPTO_AUTH_SIZE);
psync_tree_added_at(&of->sectorsinlog, &tr->tree, &ntr->tree);
ptree_added_at(&of->sectorsinlog, &tr->tree, &ntr->tree);
}
static int psync_fs_crypto_switch_sectors(psync_openfile_t *of,
@ -730,7 +730,7 @@ static int psync_fs_write_auth_tree_to_log(psync_openfile_t *of,
VAR_ARRAY(authsect, psync_crypto_auth_sector_t,
offsets->treelevels + 1);
lastsect = PSYNC_CRYPTO_INVALID_SECTORID;
sect = psync_tree_element(psync_tree_get_first(of->sectorsinlog),
sect = ptree_element(ptree_get_first(of->sectorsinlog),
psync_sector_inlog_t, tree);
while (sect) {
if (lastsect / PSYNC_CRYPTO_HASH_TREE_SECTORS !=
@ -743,7 +743,7 @@ static int psync_fs_write_auth_tree_to_log(psync_openfile_t *of,
memcpy(authsect[0][sect->sectorid % PSYNC_CRYPTO_HASH_TREE_SECTORS],
sect->auth, PSYNC_CRYPTO_AUTH_SIZE);
lastsect = sect->sectorid;
sect = psync_tree_element(psync_tree_get_next(&sect->tree),
sect = ptree_element(ptree_get_next(&sect->tree),
psync_sector_inlog_t, tree);
}
ret = psync_fs_crypto_switch_sectors(
@ -1104,7 +1104,7 @@ static int psync_fs_crypto_do_finalize_log(psync_openfile_t *of, int fullsync) {
psync_free(flog);
return -EIO;
}
psync_tree_for_each_element_call_safe(of->sectorsinlog, psync_sector_inlog_t,
ptree_for_each_element_call_safe(of->sectorsinlog, psync_sector_inlog_t,
tree, psync_free);
of->sectorsinlog = PSYNC_TREE_EMPTY;
ret = psync_fs_crypto_log_flush_and_process(of, flog, 0, 1);
@ -1702,7 +1702,7 @@ static int pfscrypto_truncate_to_zero(psync_openfile_t *of) {
psync_interval_tree_add(&of->writeintervals, 0,
pfscrypto_crypto_size(of->initialsize));
}
psync_tree_for_each_element_call_safe(of->sectorsinlog, psync_sector_inlog_t,
ptree_for_each_element_call_safe(of->sectorsinlog, psync_sector_inlog_t,
tree, psync_free);
of->sectorsinlog = PSYNC_TREE_EMPTY;
of->currentsize = 0;
@ -1783,14 +1783,14 @@ retry:
}
}
of->currentsize = lastsectoff;
tr = psync_tree_get_last(of->sectorsinlog);
while (tr && psync_tree_element(tr, psync_sector_inlog_t, tree)->sectorid >=
tr = ptree_get_last(of->sectorsinlog);
while (tr && ptree_element(tr, psync_sector_inlog_t, tree)->sectorid >=
lastsectorid) {
ntr = psync_tree_get_prev(tr);
ntr = ptree_get_prev(tr);
assert(!ntr ||
psync_tree_element(tr, psync_sector_inlog_t, tree)->sectorid >
psync_tree_element(ntr, psync_sector_inlog_t, tree)->sectorid);
psync_tree_del(&of->sectorsinlog, tr);
ptree_element(tr, psync_sector_inlog_t, tree)->sectorid >
ptree_element(ntr, psync_sector_inlog_t, tree)->sectorid);
ptree_del(&of->sectorsinlog, tr);
psync_free(tr);
tr = ntr;
}

128
pclsync/pfstasks.c
View File

@ -109,7 +109,7 @@ psync_fstask_get_or_create_folder_tasks_locked(psync_fsfolderid_t folderid) {
d = -1;
while (tr) {
folder = psync_tree_element(tr, psync_fstask_folder_t, tree);
folder = ptree_element(tr, psync_fstask_folder_t, tree);
d = folderid - folder->folderid;
if (d < 0) {
if (tr->left)
@ -131,9 +131,9 @@ psync_fstask_get_or_create_folder_tasks_locked(psync_fsfolderid_t folderid) {
memset(folder, 0, sizeof(psync_fstask_folder_t));
if (d < 0)
psync_tree_add_before(&folders, tr, &folder->tree);
ptree_add_before(&folders, tr, &folder->tree);
else
psync_tree_add_after(&folders, tr, &folder->tree);
ptree_add_after(&folders, tr, &folder->tree);
folder->folderid = folderid;
folder->refcnt = 1;
@ -149,7 +149,7 @@ psync_fstask_get_folder_tasks_locked(psync_fsfolderid_t folderid) {
tr = folders;
while (tr) {
folder = psync_tree_element(tr, psync_fstask_folder_t, tree);
folder = ptree_element(tr, psync_fstask_folder_t, tree);
if (folderid < folder->folderid)
tr = tr->left;
@ -171,7 +171,7 @@ psync_fstask_get_folder_tasks_rdlocked(psync_fsfolderid_t folderid) {
psync_tree *tr;
tr = folders;
while (tr) {
folder = psync_tree_element(tr, psync_fstask_folder_t, tree);
folder = ptree_element(tr, psync_fstask_folder_t, tree);
if (folderid < folder->folderid)
tr = tr->left;
else if (folderid > folder->folderid)
@ -192,7 +192,7 @@ void psync_fstask_release_folder_tasks_locked(psync_fstask_folder_t *folder) {
#endif
if (--folder->refcnt == 0 && !folder->taskscnt) {
debug(D_NOTICE, "releasing folder id %ld", (long int)folder->folderid);
psync_tree_del(&folders, &folder->tree);
ptree_del(&folders, &folder->tree);
psync_free(folder);
}
}
@ -214,21 +214,21 @@ static psync_tree *psync_fstask_search_tree(psync_tree *tree, size_t nameoff,
return tree;
else {
psync_tree *tn;
tn = psync_tree_get_prev(tree);
tn = ptree_get_prev(tree);
while (tn) {
if (strcmp(name, ((char *)tn) + nameoff))
break;
if (*((uint64_t *)(((char *)tn) + taskidoff)) == taskid)
return tn;
tn = psync_tree_get_prev(tn);
tn = ptree_get_prev(tn);
}
tn = psync_tree_get_next(tree);
tn = ptree_get_next(tree);
while (tn) {
if (strcmp(name, ((char *)tn) + nameoff))
break;
if (*((uint64_t *)(((char *)tn) + taskidoff)) == taskid)
return tn;
tn = psync_tree_get_next(tn);
tn = ptree_get_next(tn);
}
return NULL;
}
@ -236,11 +236,11 @@ static psync_tree *psync_fstask_search_tree(psync_tree *tree, size_t nameoff,
static psync_tree *psync_fstask_walk_tree(psync_tree *tree, uint64_t taskid,
size_t taskidoff) {
tree = psync_tree_get_first(tree);
tree = ptree_get_first(tree);
while (tree) {
if (*((uint64_t *)(((char *)tree) + taskidoff)) == taskid)
return tree;
tree = psync_tree_get_next(tree);
tree = ptree_get_next(tree);
}
return NULL;
}
@ -252,7 +252,7 @@ static void psync_fstask_insert_into_tree(psync_tree **tree, size_t nameoff,
int c;
if (!*tree) {
psync_tree_add_after(tree, NULL, element);
ptree_add_after(tree, NULL, element);
return;
}
@ -266,7 +266,7 @@ static void psync_fstask_insert_into_tree(psync_tree **tree, size_t nameoff,
if (node->left)
node = node->left;
else {
psync_tree_add_before(tree, node, element);
ptree_add_before(tree, node, element);
return;
}
} else {
@ -276,7 +276,7 @@ static void psync_fstask_insert_into_tree(psync_tree **tree, size_t nameoff,
if (node->right)
node = node->right;
else {
psync_tree_add_after(tree, node, element);
ptree_add_after(tree, node, element);
return;
}
}
@ -286,7 +286,7 @@ static void psync_fstask_insert_into_tree(psync_tree **tree, size_t nameoff,
psync_fstask_mkdir_t *psync_fstask_find_mkdir(psync_fstask_folder_t *folder,
const char *name,
uint64_t taskid) {
return psync_tree_element(
return ptree_element(
psync_fstask_search_tree(folder->mkdirs,
offsetof(psync_fstask_mkdir_t, name), name,
taskid, offsetof(psync_fstask_mkdir_t, taskid)),
@ -296,7 +296,7 @@ psync_fstask_mkdir_t *psync_fstask_find_mkdir(psync_fstask_folder_t *folder,
psync_fstask_rmdir_t *psync_fstask_find_rmdir(psync_fstask_folder_t *folder,
const char *name,
uint64_t taskid) {
return psync_tree_element(
return ptree_element(
psync_fstask_search_tree(folder->rmdirs,
offsetof(psync_fstask_rmdir_t, name), name,
taskid, offsetof(psync_fstask_rmdir_t, taskid)),
@ -306,7 +306,7 @@ psync_fstask_rmdir_t *psync_fstask_find_rmdir(psync_fstask_folder_t *folder,
psync_fstask_creat_t *psync_fstask_find_creat(psync_fstask_folder_t *folder,
const char *name,
uint64_t taskid) {
return psync_tree_element(
return ptree_element(
psync_fstask_search_tree(folder->creats,
offsetof(psync_fstask_creat_t, name), name,
taskid, offsetof(psync_fstask_creat_t, taskid)),
@ -316,7 +316,7 @@ psync_fstask_creat_t *psync_fstask_find_creat(psync_fstask_folder_t *folder,
psync_fstask_unlink_t *psync_fstask_find_unlink(psync_fstask_folder_t *folder,
const char *name,
uint64_t taskid) {
return psync_tree_element(
return ptree_element(
psync_fstask_search_tree(folder->unlinks,
offsetof(psync_fstask_unlink_t, name), name,
taskid, offsetof(psync_fstask_unlink_t, taskid)),
@ -326,7 +326,7 @@ psync_fstask_unlink_t *psync_fstask_find_unlink(psync_fstask_folder_t *folder,
psync_fstask_mkdir_t *
psync_fstask_find_mkdir_by_folderid(psync_fstask_folder_t *folder,
psync_fsfolderid_t folderid) {
return psync_tree_element(
return ptree_element(
psync_fstask_walk_tree(folder->mkdirs, folderid,
offsetof(psync_fstask_mkdir_t, folderid)),
psync_fstask_mkdir_t, tree);
@ -335,7 +335,7 @@ psync_fstask_find_mkdir_by_folderid(psync_fstask_folder_t *folder,
psync_fstask_creat_t *
psync_fstask_find_creat_by_fileid(psync_fstask_folder_t *folder,
psync_fsfileid_t fileid) {
return psync_tree_element(
return ptree_element(
psync_fstask_walk_tree(folder->creats, fileid,
offsetof(psync_fstask_creat_t, fileid)),
psync_fstask_creat_t, tree);
@ -626,7 +626,7 @@ int psync_fstask_rmdir(psync_fsfolderid_t folderid, uint32_t parentflags,
psync_sql_free_result(res);
}
if (mk) {
psync_tree_del(&folder->mkdirs, &mk->tree);
ptree_del(&folder->mkdirs, &mk->tree);
psync_free(mk);
}
if (cfolder)
@ -770,7 +770,7 @@ psync_fstask_add_modified_file(psync_fstask_folder_t *folder, const char *name,
task = psync_fstask_find_creat(folder, name, 0);
if (task) {
psync_fstask_depend(taskid, task->taskid);
psync_tree_del(&folder->creats, &task->tree);
ptree_del(&folder->creats, &task->tree);
psync_free(task);
folder->taskscnt--;
}
@ -1016,11 +1016,11 @@ int psync_fstask_unlink(psync_fsfolderid_t folderid, const char *name) {
if (unlikely(cr->fileid == 0)) {
task = psync_fstask_find_unlink(folder, cr->name, cr->taskid);
if (likely_log(task)) {
psync_tree_del(&folder->unlinks, &task->tree);
ptree_del(&folder->unlinks, &task->tree);
folder->taskscnt--;
psync_free(task);
}
psync_tree_del(&folder->creats, &cr->tree);
ptree_del(&folder->creats, &cr->tree);
psync_free(cr);
folder->taskscnt--;
psync_fstask_release_folder_tasks_locked(folder);
@ -1028,7 +1028,7 @@ int psync_fstask_unlink(psync_fsfolderid_t folderid, const char *name) {
}
depend = cr->taskid;
fileid = cr->fileid;
psync_tree_del(&folder->creats, &cr->tree);
ptree_del(&folder->creats, &cr->tree);
psync_free(cr);
folder->taskscnt--;
if (folder->folderid >= 0)
@ -1168,7 +1168,7 @@ int psync_fstask_rename_file(psync_fsfileid_t fileid,
return -EIO;
}
if (cr) {
psync_tree_del(&folder->creats, &cr->tree);
ptree_del(&folder->creats, &cr->tree);
psync_free(cr);
folder->taskscnt--;
if (folder->folderid >= 0)
@ -1194,7 +1194,7 @@ int psync_fstask_rename_file(psync_fsfileid_t fileid,
new_name, (long)cr->fileid, (unsigned long)to_folderid);
if (cr->fileid < 0)
psync_fstask_stop_and_delete_file(cr->fileid);
psync_tree_del(&folder->creats, &cr->tree);
ptree_del(&folder->creats, &cr->tree);
psync_free(cr);
folder->taskscnt--;
}
@ -1393,7 +1393,7 @@ int psync_fstask_rename_folder(psync_fsfolderid_t folderid,
}
if (mk) {
psync_tree_del(&folder->mkdirs, &mk->tree);
ptree_del(&folder->mkdirs, &mk->tree);
psync_free(mk);
folder->taskscnt--;
}
@ -1415,7 +1415,7 @@ int psync_fstask_rename_folder(psync_fsfolderid_t folderid,
if (mk) {
debug(D_NOTICE, "renaming over mkdir %s", name);
psync_tree_del(&folder->mkdirs, &mk->tree);
ptree_del(&folder->mkdirs, &mk->tree);
psync_free(mk);
folder->taskscnt--;
}
@ -1451,8 +1451,8 @@ int psync_fstask_rename_folder(psync_fsfolderid_t folderid,
}
static int folder_cmp(const psync_tree *t1, const psync_tree *t2) {
int64_t d = psync_tree_element(t1, psync_fstask_folder_t, tree)->folderid -
psync_tree_element(t2, psync_fstask_folder_t, tree)->folderid;
int64_t d = ptree_element(t1, psync_fstask_folder_t, tree)->folderid -
ptree_element(t2, psync_fstask_folder_t, tree)->folderid;
if (d < 0)
return -1;
else if (d > 0)
@ -1472,7 +1472,7 @@ void psync_fstask_folder_created(psync_folderid_t parentfolderid,
if (folder) {
mk = psync_fstask_find_mkdir(folder, name, taskid);
if (mk) {
psync_tree_del(&folder->mkdirs, &mk->tree);
ptree_del(&folder->mkdirs, &mk->tree);
psync_free(mk);
folder->taskscnt--;
pchg = 1;
@ -1512,9 +1512,9 @@ void psync_fstask_folder_created(psync_folderid_t parentfolderid,
if (folder) {
debug(D_NOTICE, "re-inserting into tree folder diffs of folder %ld as %lu",
(long)folder->folderid, (unsigned long)folderid);
psync_tree_del(&folders, &folder->tree);
ptree_del(&folders, &folder->tree);
folder->folderid = folderid;
psync_tree_add(&folders, &folder->tree, folder_cmp);
ptree_add(&folders, &folder->tree, folder_cmp);
psync_fstask_release_folder_tasks_locked(folder);
ppathstatus_drive_fldr_changed(folderid);
}
@ -1530,7 +1530,7 @@ void psync_fstask_folder_deleted(psync_folderid_t parentfolderid,
if (folder) {
rm = psync_fstask_find_rmdir(folder, name, taskid);
if (rm) {
psync_tree_del(&folder->rmdirs, &rm->tree);
ptree_del(&folder->rmdirs, &rm->tree);
psync_free(rm);
folder->taskscnt--;
}
@ -1583,13 +1583,13 @@ void psync_fstask_file_created(psync_folderid_t parentfolderid, uint64_t taskid,
if (folder) {
cr = psync_fstask_find_creat(folder, name, taskid);
if (cr) {
psync_tree_del(&folder->creats, &cr->tree);
ptree_del(&folder->creats, &cr->tree);
psync_free(cr);
folder->taskscnt--;
}
un = psync_fstask_find_unlink(folder, name, taskid);
if (un) {
psync_tree_del(&folder->unlinks, &un->tree);
ptree_del(&folder->unlinks, &un->tree);
psync_free(un);
folder->taskscnt--;
} else
@ -1615,13 +1615,13 @@ void psync_fstask_file_modified(psync_folderid_t parentfolderid,
if (folder) {
cr = psync_fstask_find_creat(folder, name, taskid);
if (cr) {
psync_tree_del(&folder->creats, &cr->tree);
ptree_del(&folder->creats, &cr->tree);
psync_free(cr);
folder->taskscnt--;
}
un = psync_fstask_find_unlink(folder, name, taskid);
if (un) {
psync_tree_del(&folder->unlinks, &un->tree);
ptree_del(&folder->unlinks, &un->tree);
psync_free(un);
folder->taskscnt--;
}
@ -1641,7 +1641,7 @@ void psync_fstask_file_deleted(psync_folderid_t parentfolderid, uint64_t taskid,
if (folder) {
un = psync_fstask_find_unlink(folder, name, taskid);
if (un) {
psync_tree_del(&folder->unlinks, &un->tree);
ptree_del(&folder->unlinks, &un->tree);
psync_free(un);
folder->taskscnt--;
}
@ -1660,13 +1660,13 @@ void psync_fstask_file_renamed(psync_folderid_t folderid, uint64_t taskid,
if (folder) {
un = psync_fstask_find_unlink(folder, name, taskid);
if (un) {
psync_tree_del(&folder->unlinks, &un->tree);
ptree_del(&folder->unlinks, &un->tree);
psync_free(un);
folder->taskscnt--;
}
cr = psync_fstask_find_creat(folder, name, taskid);
if (cr) {
psync_tree_del(&folder->creats, &cr->tree);
ptree_del(&folder->creats, &cr->tree);
psync_free(cr);
folder->taskscnt--;
}
@ -1682,7 +1682,7 @@ void psync_fstask_file_renamed(psync_folderid_t folderid, uint64_t taskid,
un = psync_fstask_find_unlink(folder, psync_get_string(row[2]),
psync_get_number(row[0]));
if (un) {
psync_tree_del(&folder->unlinks, &un->tree);
ptree_del(&folder->unlinks, &un->tree);
psync_free(un);
folder->taskscnt--;
}
@ -1713,13 +1713,13 @@ void psync_fstask_folder_renamed(psync_folderid_t parentfolderid,
if (folder) {
mk = psync_fstask_find_mkdir(folder, name, taskid);
if (mk) {
psync_tree_del(&folder->mkdirs, &mk->tree);
ptree_del(&folder->mkdirs, &mk->tree);
psync_free(mk);
folder->taskscnt--;
}
rm = psync_fstask_find_rmdir(folder, name, taskid);
if (rm) {
psync_tree_del(&folder->rmdirs, &rm->tree);
ptree_del(&folder->rmdirs, &rm->tree);
psync_free(rm);
folder->taskscnt--;
}
@ -1735,7 +1735,7 @@ void psync_fstask_folder_renamed(psync_folderid_t parentfolderid,
rm = psync_fstask_find_rmdir(folder, psync_get_string(row[2]),
psync_get_number(row[0]));
if (rm) {
psync_tree_del(&folder->rmdirs, &rm->tree);
ptree_del(&folder->rmdirs, &rm->tree);
psync_free(rm);
folder->taskscnt--;
}
@ -1799,7 +1799,7 @@ static void psync_init_task_rmdir(psync_variant_row row) {
folder = psync_fstask_get_or_create_folder_tasks_locked(folderid);
mk = psync_fstask_find_mkdir(folder, name, 0);
if (mk) {
psync_tree_del(&folder->mkdirs, &mk->tree);
ptree_del(&folder->mkdirs, &mk->tree);
psync_free(mk);
folder->taskscnt--;
}
@ -1859,7 +1859,7 @@ static void psync_init_do_task_unlink(uint64_t taskid,
folder = psync_fstask_get_or_create_folder_tasks_locked(folderid);
cr = psync_fstask_find_creat(folder, name, 0);
if (cr) {
psync_tree_del(&folder->creats, &cr->tree);
ptree_del(&folder->creats, &cr->tree);
psync_free(cr);
folder->taskscnt--;
}
@ -1901,7 +1901,7 @@ static void psync_init_task_renfile_from(psync_variant_row row) {
folder =
psync_fstask_get_or_create_folder_tasks_locked(psync_get_number(row[2]));
if ((cr = psync_fstask_find_creat(folder, name, 0))) {
psync_tree_del(&folder->creats, &cr->tree);
ptree_del(&folder->creats, &cr->tree);
psync_free(cr);
folder->taskscnt--;
}
@ -1931,7 +1931,7 @@ static void psync_init_task_renfile_to(psync_variant_row row) {
folder = psync_fstask_get_or_create_folder_tasks_locked(folderid);
cr = psync_fstask_find_creat(folder, name, 0);
if (cr) {
psync_tree_del(&folder->creats, &cr->tree);
ptree_del(&folder->creats, &cr->tree);
folder->taskscnt--;
psync_free(cr);
}
@ -1970,7 +1970,7 @@ static void psync_init_task_renfolder_from(psync_variant_row row) {
folder =
psync_fstask_get_or_create_folder_tasks_locked(psync_get_number(row[2]));
if ((mk = psync_fstask_find_mkdir(folder, name, 0))) {
psync_tree_del(&folder->mkdirs, &mk->tree);
ptree_del(&folder->mkdirs, &mk->tree);
psync_free(mk);
folder->taskscnt--;
}
@ -2035,7 +2035,7 @@ static void psync_init_task_modify(psync_variant_row row) {
taskid = psync_get_number(row[0]);
cr = psync_fstask_find_creat(folder, name, 0);
if (cr) {
psync_tree_del(&folder->creats, &cr->tree);
ptree_del(&folder->creats, &cr->tree);
psync_free(cr);
folder->taskscnt--;
}
@ -2078,9 +2078,9 @@ static psync_init_task_ptr psync_init_task_func[] = {
static void psync_fstask_free_tree(psync_tree *tr) {
psync_tree *ntr;
tr = psync_tree_get_first_safe(tr);
tr = ptree_get_first_safe(tr);
while (tr) {
ntr = psync_tree_get_next_safe(tr);
ntr = ptree_get_next_safe(tr);
psync_free(tr);
tr = ntr;
}
@ -2090,16 +2090,16 @@ void psync_fstask_clean() {
psync_fstask_folder_t *folder;
psync_tree *tr;
psync_sql_lock();
tr = psync_tree_get_first(folders);
tr = ptree_get_first(folders);
while (tr) {
folder = psync_tree_element(tr, psync_fstask_folder_t, tree);
tr = psync_tree_get_next(tr);
folder = ptree_element(tr, psync_fstask_folder_t, tree);
tr = ptree_get_next(tr);
psync_fstask_free_tree(folder->creats);
psync_fstask_free_tree(folder->unlinks);
psync_fstask_free_tree(folder->mkdirs);
psync_fstask_free_tree(folder->rmdirs);
if (folder->refcnt == 0) {
psync_tree_del(&folders, &folder->tree);
ptree_del(&folders, &folder->tree);
psync_free(folder);
} else {
folder->creats = PSYNC_TREE_EMPTY;
@ -2180,30 +2180,30 @@ void psync_fstask_dump_state() {
psync_fstask_creat_t *cr;
psync_fstask_unlink_t *un;
uint32_t cnt;
psync_tree_for_each_element(folder, folders, psync_fstask_folder_t, tree) {
ptree_for_each_element(folder, folders, psync_fstask_folder_t, tree) {
debug(D_NOTICE, "open folderid %ld taskcnt %u refcnt %u",
(long)folder->folderid, (unsigned)folder->taskscnt,
(unsigned)folder->refcnt);
cnt = 0;
psync_tree_for_each_element(mk, folder->mkdirs, psync_fstask_mkdir_t,
ptree_for_each_element(mk, folder->mkdirs, psync_fstask_mkdir_t,
tree) {
debug(D_NOTICE, " mkdir %s folderid %ld taskid %lu", mk->name,
(long)mk->folderid, (unsigned long)mk->taskid);
cnt++;
}
psync_tree_for_each_element(rm, folder->rmdirs, psync_fstask_rmdir_t,
ptree_for_each_element(rm, folder->rmdirs, psync_fstask_rmdir_t,
tree) {
debug(D_NOTICE, " mkdir %s folderid %ld taskid %lu", rm->name,
(long)rm->folderid, (unsigned long)rm->taskid);
cnt++;
}
psync_tree_for_each_element(cr, folder->creats, psync_fstask_creat_t,
ptree_for_each_element(cr, folder->creats, psync_fstask_creat_t,
tree) {
debug(D_NOTICE, " creat %s fileid %ld taskid %lu", cr->name,
(long)cr->fileid, (unsigned long)cr->taskid);
cnt++;
}
psync_tree_for_each_element(un, folder->unlinks, psync_fstask_unlink_t,
ptree_for_each_element(un, folder->unlinks, psync_fstask_unlink_t,
tree) {
debug(D_NOTICE, " unlink %s fileid %ld taskid %lu", un->name,
(long)un->fileid, (unsigned long)un->taskid);

12
pclsync/pintervaltree.c
View File

@ -38,7 +38,7 @@ static psync_interval_tree_t *psync_interval_tree_new(uint64_t from,
tree->from = from;
tree->to = to;
return psync_interval_tree_element(
psync_tree_get_add_after(PSYNC_TREE_EMPTY, NULL, &tree->tree));
ptree_get_add_after(PSYNC_TREE_EMPTY, NULL, &tree->tree));
}
static psync_interval_tree_t *psync_interval_new(uint64_t from, uint64_t to) {
@ -93,7 +93,7 @@ psync_interval_tree_get_add(psync_interval_tree_t *tree, uint64_t from,
e2 = psync_interval_new(from, to);
return psync_interval_tree_consume_intervals(
psync_interval_tree_element(
psync_tree_get_add_before(&tree->tree, &e->tree, &e2->tree)),
ptree_get_add_before(&tree->tree, &e->tree, &e2->tree)),
e2);
}
} else {
@ -104,7 +104,7 @@ psync_interval_tree_get_add(psync_interval_tree_t *tree, uint64_t from,
e2 = psync_interval_new(from, to);
return psync_interval_tree_consume_intervals(
psync_interval_tree_element(
psync_tree_get_add_after(&tree->tree, &e->tree, &e2->tree)),
ptree_get_add_after(&tree->tree, &e->tree, &e2->tree)),
e2);
}
}
@ -124,7 +124,7 @@ void psync_interval_tree_remove(psync_interval_tree_t **tree, uint64_t from,
while (tr) {
if (tr->from < from && tr->to > to) {
// the only case we have to split interval
psync_tree_add_after((psync_tree **)tree, &tr->tree,
ptree_add_after((psync_tree **)tree, &tr->tree,
&psync_interval_new(to, tr->to)->tree);
tr->to = from;
break;
@ -144,7 +144,7 @@ void psync_interval_tree_remove(psync_interval_tree_t **tree, uint64_t from,
void psync_interval_tree_free(psync_interval_tree_t *tree) {
if (tree)
psync_tree_for_each_element_call_safe(&tree->tree, psync_interval_tree_t,
ptree_for_each_element_call_safe(&tree->tree, psync_interval_tree_t,
tree, psync_free);
}
@ -159,7 +159,7 @@ psync_interval_tree_get_cut_end(psync_interval_tree_t *tree, uint64_t end) {
}
prev = psync_interval_tree_get_prev(last);
tree = psync_interval_tree_element(
psync_tree_get_del(&tree->tree, &last->tree));
ptree_get_del(&tree->tree, &last->tree));
psync_free(last);
last = prev;
}

12
pclsync/pintervaltree.h
View File

@ -42,35 +42,35 @@ typedef struct {
} psync_interval_tree_t;
#define psync_interval_tree_element(a) \
psync_tree_element(a, psync_interval_tree_t, tree)
ptree_element(a, psync_interval_tree_t, tree)
#define psync_interval_tree_for_each(a, l) \
for (a = psync_interval_tree_get_first(l); a != NULL; \
a = psync_interval_tree_get_next(a))
static inline psync_interval_tree_t *
psync_interval_tree_get_first(psync_interval_tree_t *tree) {
return psync_interval_tree_element(psync_tree_get_first(&tree->tree));
return psync_interval_tree_element(ptree_get_first(&tree->tree));
}
static inline psync_interval_tree_t *
psync_interval_tree_get_last(psync_interval_tree_t *tree) {
return psync_interval_tree_element(psync_tree_get_last(&tree->tree));
return psync_interval_tree_element(ptree_get_last(&tree->tree));
}
static inline psync_interval_tree_t *
psync_interval_tree_get_next(psync_interval_tree_t *tree) {
return psync_interval_tree_element(psync_tree_get_next(&tree->tree));
return psync_interval_tree_element(ptree_get_next(&tree->tree));
}
static inline psync_interval_tree_t *
psync_interval_tree_get_prev(psync_interval_tree_t *tree) {
return psync_interval_tree_element(psync_tree_get_prev(&tree->tree));
return psync_interval_tree_element(ptree_get_prev(&tree->tree));
}
static inline void psync_interval_tree_del(psync_interval_tree_t **tree,
psync_interval_tree_t *node) {
*tree = psync_interval_tree_element(
psync_tree_get_del(&(*tree)->tree, &node->tree));
ptree_get_del(&(*tree)->tree, &node->tree));
}
static inline psync_interval_tree_t *

8
pclsync/plibs.c
View File

@ -948,24 +948,24 @@ static void psync_sql_check_query_plan_locked(const char *sql) {
psync_tree *node;
int cmp;
if (!sql_tree) {
psync_tree_add_after(&sql_tree, NULL, psync_sql_new_tree_node(sql));
ptree_add_after(&sql_tree, NULL, psync_sql_new_tree_node(sql));
return;
}
node = sql_tree;
while (1) {
cmp = strcmp(sql, psync_tree_element(node, psync_sql_tree_t, tree)->sql);
cmp = strcmp(sql, ptree_element(node, psync_sql_tree_t, tree)->sql);
if (cmp < 0) {
if (node->left)
node = node->left;
else {
psync_tree_add_before(&sql_tree, node, psync_sql_new_tree_node(sql));
ptree_add_before(&sql_tree, node, psync_sql_new_tree_node(sql));
break;
}
} else if (cmp > 0) {
if (node->right)
node = node->right;
else {
psync_tree_add_after(&sql_tree, node, psync_sql_new_tree_node(sql));
ptree_add_after(&sql_tree, node, psync_sql_new_tree_node(sql));
break;
}
} else

18
pclsync/pmemlock.c
View File

@ -87,7 +87,7 @@ retry:
tr = locked_pages;
if (tr) {
while (1) {
node = psync_tree_element(tr, locked_page_t, tree);
node = ptree_element(tr, locked_page_t, tree);
if (pageid < node->pageid) {
if (tr->left)
tr = tr->left;
@ -136,7 +136,7 @@ retry:
node->pageid = pageid;
node->refcnt = 1;
*addto = &node->tree;
psync_tree_added_at(&locked_pages, tr, &node->tree);
ptree_added_at(&locked_pages, tr, &node->tree);
}
}
pthread_mutex_unlock(&page_mutex);
@ -150,7 +150,7 @@ static int unlock_page(pageid_t pageid, int page_size) {
pthread_mutex_lock(&page_mutex);
tr = locked_pages;
while (tr) {
node = psync_tree_element(tr, locked_page_t, tree);
node = ptree_element(tr, locked_page_t, tree);
if (pageid < node->pageid)
tr = tr->left;
else if (pageid > node->pageid)
@ -164,7 +164,7 @@ static int unlock_page(pageid_t pageid, int page_size) {
(unsigned long)pageid * page_size, (unsigned)node->refcnt);
ret = 0;
} else {
psync_tree_del(&locked_pages, tr);
ptree_del(&locked_pages, tr);
psync_free(node);
// do not move out of the mutex, will create race conditions
if (unlikely(pmem_munlock((void *)(pageid * page_size), page_size)))
@ -252,7 +252,7 @@ void *pmemlock_malloc(size_t size) {
// call pmemlock_free() on few pointers, therefore allocator_mutex is
// recursive
pthread_mutex_lock(&allocator_mutex);
psync_tree_for_each_element(range, allocator_ranges, allocator_range, tree)
ptree_for_each_element(range, allocator_ranges, allocator_range, tree)
psync_interval_tree_for_each(interval, range->freeintervals) {
intsize = interval->to - interval->from;
if (intsize >= size && intsize < bestsize) {
@ -319,7 +319,7 @@ void *pmemlock_malloc(size_t size) {
tr = allocator_ranges;
if (tr) {
while (1) {
range = psync_tree_element(tr, allocator_range, tree);
range = ptree_element(tr, allocator_range, tree);
if (brange->mem < range->mem) {
assert(brange->mem + brange->size <= range->mem);
if (tr->left)
@ -341,7 +341,7 @@ void *pmemlock_malloc(size_t size) {
} else
addto = &allocator_ranges;
*addto = &brange->tree;
psync_tree_added_at(&allocator_ranges, tr, &brange->tree);
ptree_added_at(&allocator_ranges, tr, &brange->tree);
pthread_mutex_unlock(&allocator_mutex);
return ret;
}
@ -370,7 +370,7 @@ void pmemlock_free(void *ptr) {
pthread_mutex_lock(&allocator_mutex);
tr = allocator_ranges;
while (tr) {
range = psync_tree_element(tr, allocator_range, tree);
range = ptree_element(tr, allocator_range, tree);
if (cptr < range->mem)
tr = tr->left;
else if (cptr >= range->mem + range->size)
@ -385,7 +385,7 @@ found:
cptr - range->mem + size);
if (range->freeintervals->from == LM_RANGE_OVERHEAD &&
range->freeintervals->to == range->size)
psync_tree_del(&allocator_ranges, &range->tree);
ptree_del(&allocator_ranges, &range->tree);
else
range = NULL;
pthread_mutex_unlock(&allocator_mutex);

32
pclsync/pnetlibs.c
View File

@ -1116,7 +1116,7 @@ static void connect_cache_thread(void *ptr) {
sock =
psock_connect(node->host, node->usessl ? 443 : 80, node->usessl);
pthread_mutex_lock(&connect_cache_mutex);
psync_tree_del(&connect_cache_tree, &node->tree);
ptree_del(&connect_cache_tree, &node->tree);
if (node->haswaiter) {
*node->res = sock;
node->ready = 1;
@ -1157,23 +1157,23 @@ static connect_cache_tree_node_t *
connect_cache_neighbour_is_free_duplicate(psync_tree *e, const char *host) {
connect_cache_tree_node_t *node;
psync_tree *n;
n = psync_tree_get_next(e);
n = ptree_get_next(e);
while (n) {
node = psync_tree_element(n, connect_cache_tree_node_t, tree);
node = ptree_element(n, connect_cache_tree_node_t, tree);
if (strcmp(node->host, host))
break;
if (!node->haswaiter)
return node;
n = psync_tree_get_next(n);
n = ptree_get_next(n);
}
n = psync_tree_get_prev(e);
n = ptree_get_prev(e);
while (n) {
node = psync_tree_element(n, connect_cache_tree_node_t, tree);
node = ptree_element(n, connect_cache_tree_node_t, tree);
if (strcmp(node->host, host))
break;
if (!node->haswaiter)
return node;
n = psync_tree_get_prev(n);
n = ptree_get_prev(n);
}
return NULL;
}
@ -1186,18 +1186,18 @@ void psync_http_connect_and_cache_host(const char *host) {
pthread_mutex_lock(&connect_cache_mutex);
if (!connect_cache_tree) {
node = connect_cache_create_node(host);
psync_tree_add_after(&connect_cache_tree, NULL, &node->tree);
ptree_add_after(&connect_cache_tree, NULL, &node->tree);
} else {
e = connect_cache_tree;
while (1) {
node = psync_tree_element(e, connect_cache_tree_node_t, tree);
node = ptree_element(e, connect_cache_tree_node_t, tree);
c = strcmp(host, node->host);
if (c < 0) {
if (e->left)
e = e->left;
else {
node = connect_cache_create_node(host);
psync_tree_add_before(&connect_cache_tree, e, &node->tree);
ptree_add_before(&connect_cache_tree, e, &node->tree);
break;
}
} else if (c > 0) {
@ -1205,7 +1205,7 @@ void psync_http_connect_and_cache_host(const char *host) {
e = e->right;
else {
node = connect_cache_create_node(host);
psync_tree_add_after(&connect_cache_tree, e, &node->tree);
ptree_add_after(&connect_cache_tree, e, &node->tree);
break;
}
} else {
@ -1215,7 +1215,7 @@ void psync_http_connect_and_cache_host(const char *host) {
break;
} else {
node = connect_cache_create_node(host);
psync_tree_add_after(&connect_cache_tree, e, &node->tree);
ptree_add_after(&connect_cache_tree, e, &node->tree);
break;
}
}
@ -1237,7 +1237,7 @@ psock_t *connect_cache_wait_for_http_connection(const char *host,
if (connect_cache_tree) {
e = connect_cache_tree;
while (1) {
node = psync_tree_element(e, connect_cache_tree_node_t, tree);
node = ptree_element(e, connect_cache_tree_node_t, tree);
c = strcmp(host, node->host);
if (c < 0) {
if (e->left)
@ -2528,7 +2528,7 @@ psync_file_lock_t *psync_lock_file(const char *path) {
at = &file_lock_tree;
while (tr) {
cmp = strcmp(
path, psync_tree_element(tr, psync_file_lock_t, tree)->filename);
path, ptree_element(tr, psync_file_lock_t, tree)->filename);
if (cmp < 0) {
if (tr->left)
tr = tr->left;
@ -2550,14 +2550,14 @@ psync_file_lock_t *psync_lock_file(const char *path) {
}
}
*at = &lock->tree;
psync_tree_added_at(&file_lock_tree, tr, &lock->tree);
ptree_added_at(&file_lock_tree, tr, &lock->tree);
pthread_mutex_unlock(&file_lock_mutex);
return lock;
}
void psync_unlock_file(psync_file_lock_t *lock) {
pthread_mutex_lock(&file_lock_mutex);
psync_tree_del(&file_lock_tree, &lock->tree);
ptree_del(&file_lock_tree, &lock->tree);
pthread_mutex_unlock(&file_lock_mutex);
psync_free(lock);
}

18
pclsync/pnotify.c
View File

@ -234,7 +234,7 @@ static void psync_notifications_thumb_dir_list(void *ptr,
if (tr) {
while (1) {
cmp = strcmp(
st->name, psync_tree_element(tr, psync_thumb_list_t, tree)->name);
st->name, ptree_element(tr, psync_thumb_list_t, tree)->name);
if (cmp < 0) {
if (tr->left)
tr = tr->left;
@ -262,7 +262,7 @@ static void psync_notifications_thumb_dir_list(void *ptr,
len);
memcpy(tl->name, st->name, len);
*addto = &tl->tree;
psync_tree_added_at(tree, tr, &tl->tree);
ptree_added_at(tree, tr, &tl->tree);
}
static void psync_notification_remove_from_list(psync_tree **tree,
@ -272,13 +272,13 @@ static void psync_notification_remove_from_list(psync_tree **tree,
tr = *tree;
while (tr) {
cmp = strcmp(
name, psync_tree_element(tr, psync_thumb_list_t, tree)->name);
name, ptree_element(tr, psync_thumb_list_t, tree)->name);
if (cmp < 0)
tr = tr->left;
else if (cmp > 0)
tr = tr->right;
else {
psync_tree_del(tree, tr);
ptree_del(tree, tr);
break;
}
}
@ -350,17 +350,17 @@ psync_notification_list_t *pnotify_get() {
}
}
pthread_mutex_unlock(&ntf_mutex);
thumbs = psync_tree_get_first_safe(thumbs);
thumbs = ptree_get_first_safe(thumbs);
while (thumbs) {
nx = psync_tree_get_next_safe(thumbs);
nx = ptree_get_next_safe(thumbs);
debug(D_NOTICE, "deleting unused thumb %s",
psync_tree_element(thumbs, psync_thumb_list_t, tree)->name);
ptree_element(thumbs, psync_thumb_list_t, tree)->name);
filepath = psync_strcat(
thumbpath, "/",
psync_tree_element(thumbs, psync_thumb_list_t, tree)->name, NULL);
ptree_element(thumbs, psync_thumb_list_t, tree)->name, NULL);
pfile_delete(filepath);
psync_free(filepath);
psync_free(psync_tree_element(thumbs, psync_thumb_list_t, tree));
psync_free(ptree_element(thumbs, psync_thumb_list_t, tree));
thumbs = nx;
}
psync_free(thumbpath);

10
pclsync/ppagecache.c
View File

@ -510,7 +510,7 @@ static void set_urls(psync_urls_t *urls, binresult *res) {
if (urls->refcnt++ > 0)
pthread_cond_broadcast(&url_cache_cond);
} else {
psync_tree_del(&url_cache_tree, &urls->tree);
ptree_del(&url_cache_tree, &urls->tree);
if (urls->refcnt) {
urls->status = 2;
pthread_cond_broadcast(&url_cache_cond);
@ -662,7 +662,7 @@ static psync_urls_t *get_urls_for_request(psync_request_t *req) {
pel = &url_cache_tree;
d = -1;
while (el) {
urls = psync_tree_element(el, psync_urls_t, tree);
urls = ptree_element(el, psync_urls_t, tree);
d = req->hash - urls->hash;
if (d == 0)
break;
@ -700,7 +700,7 @@ static psync_urls_t *get_urls_for_request(psync_request_t *req) {
urls->refcnt = 0;
urls->status = 0;
*pel = &urls->tree;
psync_tree_added_at(&url_cache_tree, el, &urls->tree);
ptree_added_at(&url_cache_tree, el, &urls->tree);
pthread_mutex_unlock(&url_cache_mutex);
psync_get_string_id(buff, "URLS", req->hash);
res = (binresult *)pcache_get(buff);
@ -721,7 +721,7 @@ static void release_urls(psync_urls_t *urls) {
if (likely(urls->status == 1)) {
char buff[16];
time_t ctime, etime;
psync_tree_del(&url_cache_tree, &urls->tree);
ptree_del(&url_cache_tree, &urls->tree);
ctime = ptimer_time();
etime = papi_find_result2(urls->urls, "expires", PARAM_NUM)->num;
if (etime > ctime + 3600) {
@ -742,7 +742,7 @@ static void release_bad_urls(psync_urls_t *urls) {
pthread_mutex_lock(&url_cache_mutex);
if (urls->status == 1) {
urls->status = 2;
psync_tree_del(&url_cache_tree, &urls->tree);
ptree_del(&url_cache_tree, &urls->tree);
}
if (--urls->refcnt)
urls = NULL;

24
pclsync/ppathstatus.c
View File

@ -165,10 +165,10 @@ void ppathstatus_init() {
psync_list_add_tail(&parent_cache_lru, &parent_cache_entries[i].list_lru);
psync_list_add_tail(&cache_free, &parent_cache_entries[i].list_hash);
}
psync_tree_for_each_element_call_safe(folder_tasks, folder_tasks_t, tree,
ptree_for_each_element_call_safe(folder_tasks, folder_tasks_t, tree,
psync_free);
folder_tasks = PSYNC_TREE_EMPTY;
psync_tree_for_each_element_call_safe(sync_data, sync_data_t, tree,
ptree_for_each_element_call_safe(sync_data, sync_data_t, tree,
sync_data_free);
sync_data = PSYNC_TREE_EMPTY;
ppathstatus_reload_syncs();
@ -265,7 +265,7 @@ static folder_tasks_t *get_folder_tasks(psync_folderid_t folderid, int create) {
tr = folder_tasks;
atr = &folder_tasks;
while (tr) {
ft = psync_tree_element(tr, folder_tasks_t, tree);
ft = ptree_element(tr, folder_tasks_t, tree);
if (folderid < ft->folderid) {
if (tr->left) {
tr = tr->left;
@ -287,7 +287,7 @@ static folder_tasks_t *get_folder_tasks(psync_folderid_t folderid, int create) {
if (create) {
ft = psync_new(folder_tasks_t);
*atr = &ft->tree;
psync_tree_added_at(&folder_tasks, tr, &ft->tree);
ptree_added_at(&folder_tasks, tr, &ft->tree);
ft->folderid = folderid;
ft->child_task_cnt = 0;
ft->own_tasks = 0;
@ -301,7 +301,7 @@ static folder_tasks_t *get_folder_tasks(psync_folderid_t folderid, int create) {
static void free_folder_tasks(folder_tasks_t *ft) {
debug(D_NOTICE, "marking folderid %lu as clean", (unsigned long)ft->folderid);
psync_tree_del(&folder_tasks, &ft->tree);
ptree_del(&folder_tasks, &ft->tree);
psync_free(ft);
}
@ -451,7 +451,7 @@ void ppathstatus_fldr_deleted(psync_folderid_t folderid) {
}
static void sync_data_free(sync_data_t *sd) {
psync_tree_for_each_element_call_safe(sd->folder_tasks, folder_tasks_t, tree,
ptree_for_each_element_call_safe(sd->folder_tasks, folder_tasks_t, tree,
psync_free);
psync_free(sd);
}
@ -462,7 +462,7 @@ static sync_data_t *get_sync_data(psync_syncid_t syncid, int create) {
tr = sync_data;
atr = &sync_data;
while (tr) {
sd = psync_tree_element(tr, sync_data_t, tree);
sd = ptree_element(tr, sync_data_t, tree);
if (syncid < sd->syncid) {
if (tr->left) {
tr = tr->left;
@ -488,7 +488,7 @@ static sync_data_t *get_sync_data(psync_syncid_t syncid, int create) {
sd = psync_new(sync_data_t);
sd->syncid = syncid;
*atr = &sd->tree;
psync_tree_added_at(&sync_data, tr, &sd->tree);
ptree_added_at(&sync_data, tr, &sd->tree);
psync_list_init(&sd->cache_free);
psync_list_init(&sd->parent_cache_lru);
for (i = 0; i < SYNC_PARENT_HASH_SIZE; i++)
@ -511,7 +511,7 @@ get_sync_folder_tasks(sync_data_t *sd, psync_folderid_t folderid, int create) {
tr = sd->folder_tasks;
atr = &sd->folder_tasks;
while (tr) {
ft = psync_tree_element(tr, folder_tasks_t, tree);
ft = ptree_element(tr, folder_tasks_t, tree);
if (folderid < ft->folderid) {
if (tr->left) {
tr = tr->left;
@ -533,7 +533,7 @@ get_sync_folder_tasks(sync_data_t *sd, psync_folderid_t folderid, int create) {
if (create) {
ft = psync_new(folder_tasks_t);
*atr = &ft->tree;
psync_tree_added_at(&sd->folder_tasks, tr, &ft->tree);
ptree_added_at(&sd->folder_tasks, tr, &ft->tree);
ft->folderid = folderid;
ft->child_task_cnt = 0;
ft->own_tasks = 0;
@ -661,7 +661,7 @@ static int local_folder_has_tasks(psync_syncid_t syncid,
static void free_sync_folder_tasks(sync_data_t *sd, folder_tasks_t *ft) {
debug(D_NOTICE, "marking folderid %lu from syncid %u as clean",
(unsigned long)ft->folderid, (unsigned)sd->syncid);
psync_tree_del(&sd->folder_tasks, &ft->tree);
ptree_del(&sd->folder_tasks, &ft->tree);
psync_free(ft);
}
@ -699,7 +699,7 @@ void ppathstatus_syncfldr_delete(psync_syncid_t syncid) {
psync_sql_lock();
sd = get_sync_data(syncid, 0);
if (sd)
psync_tree_del(&sync_data, &sd->tree);
ptree_del(&sync_data, &sd->tree);
psync_sql_unlock();
if (sd)
sync_data_free(sd);

6
pclsync/prunthrottled.c
View File

@ -60,7 +60,7 @@ static void ratelimit_timer(psync_timer_t timer, void *ptr) {
name = node->name;
} else {
run = 0;
psync_tree_del(&tasks, &node->tree);
ptree_del(&tasks, &node->tree);
}
pthread_mutex_unlock(&task_mutex);
if (run) {
@ -82,7 +82,7 @@ void prun_throttled(const char *name, prun_throttle_cb call,
tr = tasks;
if (tr) {
while (1) {
node = psync_tree_element(tr, psync_rr_tree_node, tree);
node = ptree_element(tr, psync_rr_tree_node, tree);
if (call < node->call) {
if (tr->left)
tr = tr->left;
@ -117,7 +117,7 @@ void prun_throttled(const char *name, prun_throttle_cb call,
node->name = name;
node->scheduled = 0;
*addto = &node->tree;
psync_tree_added_at(&tasks, tr, &node->tree);
ptree_added_at(&tasks, tr, &node->tree);
}
pthread_mutex_unlock(&task_mutex);
if (!found) {

28
pclsync/psyncer.c
View File

@ -72,26 +72,26 @@ static psync_tree *psync_new_sd_folder(psync_folderid_t folderid) {
static void psync_add_folder_to_downloadlist_locked(psync_folderid_t folderid) {
synced_down_folder *f;
if (!synced_down_folders) {
psync_tree_add_after(&synced_down_folders, NULL,
ptree_add_after(&synced_down_folders, NULL,
psync_new_sd_folder(folderid));
return;
}
f = psync_tree_element(synced_down_folders, synced_down_folder, tree);
f = ptree_element(synced_down_folders, synced_down_folder, tree);
while (1) {
if (folderid < f->folderid) {
if (f->tree.left)
f = psync_tree_element(f->tree.left, synced_down_folder, tree);
f = ptree_element(f->tree.left, synced_down_folder, tree);
else {
f->tree.left = psync_new_sd_folder(folderid);
psync_tree_added_at(&synced_down_folders, &f->tree, f->tree.left);
ptree_added_at(&synced_down_folders, &f->tree, f->tree.left);
break;
}
} else if (folderid > f->folderid) {
if (f->tree.right)
f = psync_tree_element(f->tree.right, synced_down_folder, tree);
f = ptree_element(f->tree.right, synced_down_folder, tree);
else {
f->tree.right = psync_new_sd_folder(folderid);
psync_tree_added_at(&synced_down_folders, &f->tree, f->tree.right);
ptree_added_at(&synced_down_folders, &f->tree, f->tree.right);
break;
}
} else {
@ -112,14 +112,14 @@ void psyncer_dl_queue_add(psync_folderid_t folderid) {
void psyncer_dl_queue_del(psync_folderid_t folderid) {
synced_down_folder *f;
pthread_mutex_lock(&sync_down_mutex);
f = psync_tree_element(synced_down_folders, synced_down_folder, tree);
f = ptree_element(synced_down_folders, synced_down_folder, tree);
while (f) {
if (folderid < f->folderid)
f = psync_tree_element(f->tree.left, synced_down_folder, tree);
f = ptree_element(f->tree.left, synced_down_folder, tree);
else if (folderid > f->folderid)
f = psync_tree_element(f->tree.right, synced_down_folder, tree);
f = ptree_element(f->tree.right, synced_down_folder, tree);
else {
psync_tree_del(&synced_down_folders, &f->tree);
ptree_del(&synced_down_folders, &f->tree);
psync_free(f);
break;
}
@ -129,7 +129,7 @@ void psyncer_dl_queue_del(psync_folderid_t folderid) {
void psyncer_dl_queue_clear() {
pthread_mutex_lock(&sync_down_mutex);
psync_tree_for_each_element_call_safe(synced_down_folders, synced_down_folder,
ptree_for_each_element_call_safe(synced_down_folders, synced_down_folder,
tree, psync_free);
synced_down_folders = PSYNC_TREE_EMPTY;
pthread_mutex_unlock(&sync_down_mutex);
@ -138,12 +138,12 @@ void psyncer_dl_queue_clear() {
int psyncer_dl_has_folder(psync_folderid_t folderid) {
synced_down_folder *f;
pthread_mutex_lock(&sync_down_mutex);
f = psync_tree_element(synced_down_folders, synced_down_folder, tree);
f = ptree_element(synced_down_folders, synced_down_folder, tree);
while (f) {
if (folderid < f->folderid)
f = psync_tree_element(f->tree.left, synced_down_folder, tree);
f = ptree_element(f->tree.left, synced_down_folder, tree);
else if (folderid > f->folderid)
f = psync_tree_element(f->tree.right, synced_down_folder, tree);
f = ptree_element(f->tree.right, synced_down_folder, tree);
else
break;
}

4
pclsync/psynclib.c
View File

@ -2484,11 +2484,11 @@ int64_t psync_folder_updownlink_link(int canupload, unsigned long long folderid,
return do_psync_folder_updownlink_link(canupload, folderid, mail, err);
}
int64_t psync_tree_public_link(const char *linkname, const char *root,
int64_t ptree_public_link(const char *linkname, const char *root,
char **folders, int numfolders, char **files,
int numfiles, char **link /*OUT*/,
char **err /*OUT*/) {
return do_psync_tree_public_link(linkname, root, folders, numfolders, files,
return do_ptree_public_link(linkname, root, folders, numfolders, files,
numfiles, link, err, 0, 0, 0);
}

4
pclsync/psynclib.h
View File

@ -1446,7 +1446,7 @@ external_status_t psync_status_folder(const char *path);
* if any is returned.
*
*
* psync_tree_public_link() creates public link for a tree. Tree is define by
* ptree_public_link() creates public link for a tree. Tree is define by
* root folder and arrays of folders and file paths. Each entry in the arrays
* describes a path to file or folder. Number of entries in the arrays is
* passed separately. The API constructs a virtual folder of this files and
@ -1504,7 +1504,7 @@ int64_t psync_folder_public_link_full(const char *path, char **link /*OUT*/,
const char *password);
int64_t psync_folder_updownlink_link(int canupload, unsigned long long folderid,
const char *mail, char **err /*OUT*/);
int64_t psync_tree_public_link(const char *linkname, const char *root,
int64_t ptree_public_link(const char *linkname, const char *root,
char **folders, int numfolders, char **files,
int numfiles, char **link /*OUT*/,
char **err /*OUT*/);

10
pclsync/ptask.c
View File

@ -251,7 +251,7 @@ static int download_send_error(stream_t *s, async_params_t *prms,
s->cb(s->cbext, &r);
debug(D_NOTICE, "closing stream %u", (unsigned)s->streamid);
psync_tree_del(&prms->streams, &s->tree);
ptree_del(&prms->streams, &s->tree);
if (s->free)
s->free(s, error);
psync_free(s);
@ -597,7 +597,7 @@ static void proc_async_transfer(void *ptr) {
psync_apipool_release_bad(prms->api);
pdeflate_destroy(prms->enc);
pdeflate_destroy(prms->dec);
psync_tree_for_each_element_call_safe(prms->streams, stream_t, tree,
ptree_for_each_element_call_safe(prms->streams, stream_t, tree,
stream_destroy);
psync_free(prms);
}
@ -727,12 +727,12 @@ static stream_t *stream_create(async_params_t *prms, size_t addsize) {
ret->streamid = ++prms->laststreamid;
ret->flags = 0;
ret->free = NULL;
parent = psync_tree_get_last(prms->streams);
parent = ptree_get_last(prms->streams);
if (parent)
parent->right = &ret->tree;
else
prms->streams = &ret->tree;
psync_tree_added_at(&prms->streams, parent, &ret->tree);
ptree_added_at(&prms->streams, parent, &ret->tree);
return ret;
}
@ -756,7 +756,7 @@ static int stream_process_data(async_params_t *prms) {
int ret;
tr = prms->streams;
while (tr) {
s = psync_tree_element(tr, stream_t, tree);
s = ptree_element(tr, stream_t, tree);
if (prms->currentstreamid < s->streamid)
tr = tr->left;
else if (prms->currentstreamid > s->streamid)

118
pclsync/ptree.c
View File

@ -33,49 +33,49 @@
#include <assert.h>
#include <string.h>
static inline long int psync_tree_max(long int a, long int b) {
static inline long int ptree_max(long int a, long int b) {
return a > b ? a : b;
}
static void psync_tree_recalc_height(psync_tree *e) {
static void ptree_recalc_height(psync_tree *e) {
e->height =
psync_tree_max(psync_tree_height(e->left), psync_tree_height(e->right)) +
ptree_max(ptree_height(e->left), ptree_height(e->right)) +
1;
}
static psync_tree *psync_tree_rotate_left(psync_tree *e) {
static psync_tree *ptree_rotate_left(psync_tree *e) {
psync_tree *e2;
e2 = e->right;
e2->parent = e->parent;
e->right = e2->left;
if (e->right) {
e->right->parent = e;
psync_tree_recalc_height(e);
ptree_recalc_height(e);
} else
e->height = psync_tree_height(e->left) + 1;
e->height = ptree_height(e->left) + 1;
e->parent = e2;
e2->left = e;
psync_tree_recalc_height(e2);
ptree_recalc_height(e2);
return e2;
}
static psync_tree *psync_tree_rotate_right(psync_tree *e) {
static psync_tree *ptree_rotate_right(psync_tree *e) {
psync_tree *e2;
e2 = e->left;
e2->parent = e->parent;
e->left = e2->right;
if (e->left) {
e->left->parent = e;
psync_tree_recalc_height(e);
ptree_recalc_height(e);
} else
e->height = psync_tree_height(e->right) + 1;
e->height = ptree_height(e->right) + 1;
e->parent = e2;
e2->right = e;
psync_tree_recalc_height(e2);
ptree_recalc_height(e2);
return e2;
}
psync_tree *psync_tree_init_node(psync_tree *node) {
psync_tree *ptree_init_node(psync_tree *node) {
node->left = NULL;
node->right = NULL;
node->parent = NULL;
@ -83,12 +83,12 @@ psync_tree *psync_tree_init_node(psync_tree *node) {
return node;
}
static psync_tree *psync_tree_go_up_rebalance_add(psync_tree *tree,
static psync_tree *ptree_go_up_rebalance_add(psync_tree *tree,
psync_tree *e) {
long int lheight, rheight, dheight;
up:
lheight = psync_tree_height(e->left);
rheight = psync_tree_height(e->right);
lheight = ptree_height(e->left);
rheight = ptree_height(e->right);
dheight = lheight - rheight;
if (dheight == 0)
return tree;
@ -102,46 +102,46 @@ up:
return tree;
}
} else if (dheight == 2) {
if (psync_tree_height(e->left->right) > psync_tree_height(e->left->left))
e->left = psync_tree_rotate_left(e->left);
if (ptree_height(e->left->right) > ptree_height(e->left->left))
e->left = ptree_rotate_left(e->left);
if (e == tree)
return psync_tree_rotate_right(e);
return ptree_rotate_right(e);
else {
psync_tree *e2 = e->parent;
if (e2->left == e)
e2->left = psync_tree_rotate_right(e);
e2->left = ptree_rotate_right(e);
else {
assert(e2->right == e);
e2->right = psync_tree_rotate_right(e);
e2->right = ptree_rotate_right(e);
}
return tree;
}
} else {
assert(dheight == -2);
if (psync_tree_height(e->right->left) > psync_tree_height(e->right->right))
e->right = psync_tree_rotate_right(e->right);
if (ptree_height(e->right->left) > ptree_height(e->right->right))
e->right = ptree_rotate_right(e->right);
if (e == tree)
return psync_tree_rotate_left(e);
return ptree_rotate_left(e);
else {
psync_tree *e2 = e->parent;
if (e2->left == e)
e2->left = psync_tree_rotate_left(e);
e2->left = ptree_rotate_left(e);
else {
assert(e2->right == e);
e2->right = psync_tree_rotate_left(e);
e2->right = ptree_rotate_left(e);
}
return tree;
}
}
}
psync_tree *psync_tree_get_add_after(psync_tree *tree, psync_tree *node,
psync_tree *ptree_get_add_after(psync_tree *tree, psync_tree *node,
psync_tree *newnode) {
if (!tree)
return psync_tree_init_node(newnode);
return ptree_init_node(newnode);
if (!node)
return psync_tree_get_add_before(tree, psync_tree_get_first(tree), newnode);
psync_tree_init_node(newnode);
return ptree_get_add_before(tree, ptree_get_first(tree), newnode);
ptree_init_node(newnode);
if (node->right) {
node = node->right;
while (node->left)
@ -150,16 +150,16 @@ psync_tree *psync_tree_get_add_after(psync_tree *tree, psync_tree *node,
} else
node->right = newnode;
newnode->parent = node;
return psync_tree_go_up_rebalance_add(tree, node);
return ptree_go_up_rebalance_add(tree, node);
}
psync_tree *psync_tree_get_add_before(psync_tree *tree, psync_tree *node,
psync_tree *ptree_get_add_before(psync_tree *tree, psync_tree *node,
psync_tree *newnode) {
if (!tree)
return psync_tree_init_node(newnode);
return ptree_init_node(newnode);
if (!node)
return psync_tree_get_add_after(tree, psync_tree_get_last(tree), newnode);
psync_tree_init_node(newnode);
return ptree_get_add_after(tree, ptree_get_last(tree), newnode);
ptree_init_node(newnode);
if (node->left) {
node = node->left;
while (node->right)
@ -168,25 +168,25 @@ psync_tree *psync_tree_get_add_before(psync_tree *tree, psync_tree *node,
} else
node->left = newnode;
newnode->parent = node;
return psync_tree_go_up_rebalance_add(tree, node);
return ptree_go_up_rebalance_add(tree, node);
}
psync_tree *psync_tree_get_added_at(psync_tree *tree, psync_tree *parent,
psync_tree *ptree_get_added_at(psync_tree *tree, psync_tree *parent,
psync_tree *newnode) {
psync_tree_init_node(newnode);
ptree_init_node(newnode);
newnode->parent = parent;
if (parent)
return psync_tree_go_up_rebalance_add(tree, parent);
return ptree_go_up_rebalance_add(tree, parent);
else
return tree;
}
static psync_tree *psync_tree_go_up_rebalance_del(psync_tree *tree,
static psync_tree *ptree_go_up_rebalance_del(psync_tree *tree,
psync_tree *e) {
long int lheight, rheight, dheight;
up:
lheight = psync_tree_height(e->left);
rheight = psync_tree_height(e->right);
lheight = ptree_height(e->left);
rheight = ptree_height(e->right);
dheight = lheight - rheight;
if (dheight == 0) {
e->height = rheight + 1;
@ -200,34 +200,34 @@ up:
} else if (dheight == 1 || dheight == -1)
return tree;
else if (dheight == 2) {
if (psync_tree_height(e->left->right) > psync_tree_height(e->left->left))
e->left = psync_tree_rotate_left(e->left);
if (ptree_height(e->left->right) > ptree_height(e->left->left))
e->left = ptree_rotate_left(e->left);
if (e == tree)
return psync_tree_rotate_right(e);
return ptree_rotate_right(e);
else {
psync_tree *e2 = e->parent;
if (e2->left == e)
e2->left = psync_tree_rotate_right(e);
e2->left = ptree_rotate_right(e);
else {
assert(e2->right == e);
e2->right = psync_tree_rotate_right(e);
e2->right = ptree_rotate_right(e);
}
e = e2;
goto up;
}
} else {
assert(dheight == -2);
if (psync_tree_height(e->right->left) > psync_tree_height(e->right->right))
e->right = psync_tree_rotate_right(e->right);
if (ptree_height(e->right->left) > ptree_height(e->right->right))
e->right = ptree_rotate_right(e->right);
if (e == tree)
return psync_tree_rotate_left(e);
return ptree_rotate_left(e);
else {
psync_tree *e2 = e->parent;
if (e2->left == e)
e2->left = psync_tree_rotate_left(e);
e2->left = ptree_rotate_left(e);
else {
assert(e2->right == e);
e2->right = psync_tree_rotate_left(e);
e2->right = ptree_rotate_left(e);
}
e = e2;
goto up;
@ -235,7 +235,7 @@ up:
}
}
static psync_tree *psync_tree_replace_me_with(psync_tree *tree,
static psync_tree *ptree_replace_me_with(psync_tree *tree,
psync_tree *node,
psync_tree *repl) {
psync_tree *parent;
@ -252,20 +252,20 @@ static psync_tree *psync_tree_replace_me_with(psync_tree *tree,
if (repl)
repl->parent = parent;
if (parent)
return psync_tree_go_up_rebalance_del(tree, parent);
return ptree_go_up_rebalance_del(tree, parent);
else if (!tree)
return NULL;
else
return psync_tree_go_up_rebalance_del(tree, tree);
return ptree_go_up_rebalance_del(tree, tree);
}
psync_tree *psync_tree_get_del(psync_tree *tree, psync_tree *node) {
psync_tree *ptree_get_del(psync_tree *tree, psync_tree *node) {
if (!node->left && !node->right)
return psync_tree_replace_me_with(tree, node, NULL);
return ptree_replace_me_with(tree, node, NULL);
else if (!node->left)
return psync_tree_replace_me_with(tree, node, node->right);
return ptree_replace_me_with(tree, node, node->right);
else if (!node->right)
return psync_tree_replace_me_with(tree, node, node->left);
return ptree_replace_me_with(tree, node, node->left);
else {
psync_tree *el, *parent, **addr;
if (node->left->height > node->right->height) {
@ -309,6 +309,6 @@ psync_tree *psync_tree_get_del(psync_tree *tree, psync_tree *node) {
assert(node == tree);
tree = el;
}
return psync_tree_go_up_rebalance_del(tree, parent);
return ptree_go_up_rebalance_del(tree, parent);
}
}

86
pclsync/ptree.h
View File

@ -44,42 +44,42 @@ typedef struct _psync_tree {
#define PSYNC_TREE_EMPTY NULL
#define psync_tree_isempty(l) ((l) == NULL)
#define psync_tree_element(a, t, n) ((t *)((char *)(a)-offsetof(t, n)))
#define psync_tree_for_each(a, l) \
for (a = psync_tree_get_first(l); a != NULL; a = psync_tree_get_next(a))
#define psync_tree_for_each_element(a, l, t, n) \
for (a = psync_tree_element(psync_tree_get_first(l), t, n); &a->n != NULL; \
a = psync_tree_element(psync_tree_get_next(&a->n), t, n))
#define ptree_isempty(l) ((l) == NULL)
#define ptree_element(a, t, n) ((t *)((char *)(a)-offsetof(t, n)))
#define ptree_for_each(a, l) \
for (a = ptree_get_first(l); a != NULL; a = ptree_get_next(a))
#define ptree_for_each_element(a, l, t, n) \
for (a = ptree_element(ptree_get_first(l), t, n); &a->n != NULL; \
a = ptree_element(ptree_get_next(&a->n), t, n))
#define psync_tree_for_each_element_call(l, t, n, c) \
#define ptree_for_each_element_call(l, t, n, c) \
do { \
psync_tree *___tmpa; \
___tmpa = psync_tree_get_first(l); \
___tmpa = ptree_get_first(l); \
while (___tmpa) { \
c(psync_tree_element(___tmpa, t, n)); \
___tmpa = psync_tree_get_next(___tmpa); \
c(ptree_element(___tmpa, t, n)); \
___tmpa = ptree_get_next(___tmpa); \
} \
} while (0)
#define psync_tree_for_each_element_call_safe(l, t, n, c) \
#define ptree_for_each_element_call_safe(l, t, n, c) \
do { \
psync_tree *___tmpa, *___tmpb; \
___tmpa = psync_tree_get_first_safe(l); \
___tmpa = ptree_get_first_safe(l); \
while (___tmpa) { \
___tmpb = psync_tree_get_next_safe(___tmpa); \
c(psync_tree_element(___tmpa, t, n)); \
___tmpb = ptree_get_next_safe(___tmpa); \
c(ptree_element(___tmpa, t, n)); \
___tmpa = ___tmpb; \
} \
} while (0)
typedef int (*psync_tree_compare)(const psync_tree *, const psync_tree *);
typedef int (*ptree_compare)(const psync_tree *, const psync_tree *);
static inline long int psync_tree_height(psync_tree *tree) {
static inline long int ptree_height(psync_tree *tree) {
return tree ? tree->height : 0;
}
static inline psync_tree *psync_tree_get_first(psync_tree *tree) {
static inline psync_tree *ptree_get_first(psync_tree *tree) {
if (!tree)
return tree;
while (tree->left)
@ -87,7 +87,7 @@ static inline psync_tree *psync_tree_get_first(psync_tree *tree) {
return tree;
}
static inline psync_tree *psync_tree_get_last(psync_tree *tree) {
static inline psync_tree *ptree_get_last(psync_tree *tree) {
if (!tree)
return tree;
while (tree->right)
@ -95,7 +95,7 @@ static inline psync_tree *psync_tree_get_last(psync_tree *tree) {
return tree;
}
static inline psync_tree *psync_tree_get_next(psync_tree *tree) {
static inline psync_tree *ptree_get_next(psync_tree *tree) {
if (tree->right) {
tree = tree->right;
while (tree->left)
@ -108,7 +108,7 @@ static inline psync_tree *psync_tree_get_next(psync_tree *tree) {
}
}
static inline psync_tree *psync_tree_get_prev(psync_tree *tree) {
static inline psync_tree *ptree_get_prev(psync_tree *tree) {
if (tree->left) {
tree = tree->left;
while (tree->right)
@ -121,7 +121,7 @@ static inline psync_tree *psync_tree_get_prev(psync_tree *tree) {
}
}
static inline psync_tree *psync_tree_get_first_safe(psync_tree *tree) {
static inline psync_tree *ptree_get_first_safe(psync_tree *tree) {
if (!tree)
return tree;
while (1) {
@ -135,7 +135,7 @@ static inline psync_tree *psync_tree_get_first_safe(psync_tree *tree) {
return tree;
}
static inline psync_tree *psync_tree_get_next_safe(psync_tree *tree) {
static inline psync_tree *ptree_get_next_safe(psync_tree *tree) {
if (!tree->parent)
return NULL;
if (tree->parent->right == tree || tree->parent->right == NULL)
@ -152,59 +152,59 @@ static inline psync_tree *psync_tree_get_next_safe(psync_tree *tree) {
return tree;
}
psync_tree *psync_tree_get_add_after(psync_tree *tree, psync_tree *node,
psync_tree *ptree_get_add_after(psync_tree *tree, psync_tree *node,
psync_tree *newnode);
psync_tree *psync_tree_get_add_before(psync_tree *tree, psync_tree *node,
psync_tree *ptree_get_add_before(psync_tree *tree, psync_tree *node,
psync_tree *newnode);
psync_tree *psync_tree_get_added_at(psync_tree *tree, psync_tree *parent,
psync_tree *ptree_get_added_at(psync_tree *tree, psync_tree *parent,
psync_tree *newnode);
psync_tree *psync_tree_get_del(psync_tree *tree, psync_tree *node);
psync_tree *ptree_get_del(psync_tree *tree, psync_tree *node);
static inline psync_tree *psync_tree_get_add(psync_tree *tree,
static inline psync_tree *ptree_get_add(psync_tree *tree,
psync_tree *newnode,
psync_tree_compare comp) {
ptree_compare comp) {
psync_tree *el;
if (!tree)
return psync_tree_get_add_after(tree, NULL, newnode);
return ptree_get_add_after(tree, NULL, newnode);
el = tree;
while (1) {
if (comp(newnode, el) < 0) {
if (el->left)
el = el->left;
else
return psync_tree_get_add_before(tree, el, newnode);
return ptree_get_add_before(tree, el, newnode);
} else {
if (el->right)
el = el->right;
else
return psync_tree_get_add_after(tree, el, newnode);
return ptree_get_add_after(tree, el, newnode);
}
}
}
static inline void psync_tree_add_after(psync_tree **tree, psync_tree *node,
static inline void ptree_add_after(psync_tree **tree, psync_tree *node,
psync_tree *newnode) {
*tree = psync_tree_get_add_after(*tree, node, newnode);
*tree = ptree_get_add_after(*tree, node, newnode);
}
static inline void psync_tree_add_before(psync_tree **tree, psync_tree *node,
static inline void ptree_add_before(psync_tree **tree, psync_tree *node,
psync_tree *newnode) {
*tree = psync_tree_get_add_before(*tree, node, newnode);
*tree = ptree_get_add_before(*tree, node, newnode);
}
static inline void psync_tree_added_at(psync_tree **tree, psync_tree *parent,
static inline void ptree_added_at(psync_tree **tree, psync_tree *parent,
psync_tree *newnode) {
*tree = psync_tree_get_added_at(*tree, parent, newnode);
*tree = ptree_get_added_at(*tree, parent, newnode);
}
static inline void psync_tree_del(psync_tree **tree, psync_tree *node) {
*tree = psync_tree_get_del(*tree, node);
static inline void ptree_del(psync_tree **tree, psync_tree *node) {
*tree = ptree_get_del(*tree, node);
}
static inline void psync_tree_add(psync_tree **tree, psync_tree *newnode,
psync_tree_compare comp) {
*tree = psync_tree_get_add(*tree, newnode, comp);
static inline void ptree_add(psync_tree **tree, psync_tree *newnode,
ptree_compare comp) {
*tree = ptree_get_add(*tree, newnode, comp);
}
#endif

2
pclsync/publiclinks.c
View File

@ -402,7 +402,7 @@ int64_t do_psync_folder_updownlink_link(int canupload,
return result;
}
int64_t do_psync_tree_public_link(const char *linkname, const char *root,
int64_t do_ptree_public_link(const char *linkname, const char *root,
char **folders, int numfolders, char **files,
int numfiles, char **link /*OUT*/,
char **err /*OUT*/, uint64_t expire,

2
pclsync/publiclinks.h
View File

@ -49,7 +49,7 @@ int64_t do_psync_folder_public_link_full(const char *path, char **link /*OUT*/,
char **err /*OUT*/, uint64_t expire,
int maxdownloads, int maxtraffic,
const char *password);
int64_t do_psync_tree_public_link(const char *linkname, const char *root,
int64_t do_ptree_public_link(const char *linkname, const char *root,
char **folders, int numfolders, char **files,
int numfiles, char **link /*OUT*/,
char **err /*OUT*/, uint64_t expire,