diff --git a/pclsync/pfs.c b/pclsync/pfs.c
index 2959523..1dfafc4 100644
--- a/pclsync/pfs.c
+++ b/pclsync/pfs.c
@@ -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();
diff --git a/pclsync/pfscrypto.c b/pclsync/pfscrypto.c
index 4896ffd..3b73fda 100644
--- a/pclsync/pfscrypto.c
+++ b/pclsync/pfscrypto.c
@@ -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;
   }
diff --git a/pclsync/pfstasks.c b/pclsync/pfstasks.c
index 4a365f0..304736a 100644
--- a/pclsync/pfstasks.c
+++ b/pclsync/pfstasks.c
@@ -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);
diff --git a/pclsync/pintervaltree.c b/pclsync/pintervaltree.c
index f502475..dad5797 100644
--- a/pclsync/pintervaltree.c
+++ b/pclsync/pintervaltree.c
@@ -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;
   }
diff --git a/pclsync/pintervaltree.h b/pclsync/pintervaltree.h
index 4586b82..41c1845 100644
--- a/pclsync/pintervaltree.h
+++ b/pclsync/pintervaltree.h
@@ -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 *
diff --git a/pclsync/plibs.c b/pclsync/plibs.c
index c1b1d1c..1af1c7b 100644
--- a/pclsync/plibs.c
+++ b/pclsync/plibs.c
@@ -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
diff --git a/pclsync/pmemlock.c b/pclsync/pmemlock.c
index 1958764..24dc028 100644
--- a/pclsync/pmemlock.c
+++ b/pclsync/pmemlock.c
@@ -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);
diff --git a/pclsync/pnetlibs.c b/pclsync/pnetlibs.c
index d939058..f22da0f 100644
--- a/pclsync/pnetlibs.c
+++ b/pclsync/pnetlibs.c
@@ -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);
 }
diff --git a/pclsync/pnotify.c b/pclsync/pnotify.c
index 6975e74..a959a84 100644
--- a/pclsync/pnotify.c
+++ b/pclsync/pnotify.c
@@ -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);
diff --git a/pclsync/ppagecache.c b/pclsync/ppagecache.c
index 816387b..8483150 100644
--- a/pclsync/ppagecache.c
+++ b/pclsync/ppagecache.c
@@ -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;
diff --git a/pclsync/ppathstatus.c b/pclsync/ppathstatus.c
index 4bd4995..4d1aa16 100644
--- a/pclsync/ppathstatus.c
+++ b/pclsync/ppathstatus.c
@@ -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);
diff --git a/pclsync/prunthrottled.c b/pclsync/prunthrottled.c
index 1e5dfb9..74df695 100644
--- a/pclsync/prunthrottled.c
+++ b/pclsync/prunthrottled.c
@@ -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) {
diff --git a/pclsync/psyncer.c b/pclsync/psyncer.c
index 5ba0e4e..5452508 100644
--- a/pclsync/psyncer.c
+++ b/pclsync/psyncer.c
@@ -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;
   }
diff --git a/pclsync/psynclib.c b/pclsync/psynclib.c
index 6206d58..fc9f804 100644
--- a/pclsync/psynclib.c
+++ b/pclsync/psynclib.c
@@ -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);
 }
 
diff --git a/pclsync/psynclib.h b/pclsync/psynclib.h
index be6c497..386b63f 100644
--- a/pclsync/psynclib.h
+++ b/pclsync/psynclib.h
@@ -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*/);
diff --git a/pclsync/ptask.c b/pclsync/ptask.c
index df4764b..729078d 100644
--- a/pclsync/ptask.c
+++ b/pclsync/ptask.c
@@ -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)
diff --git a/pclsync/ptree.c b/pclsync/ptree.c
index 95f3f64..26db737 100644
--- a/pclsync/ptree.c
+++ b/pclsync/ptree.c
@@ -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);
   }
 }
diff --git a/pclsync/ptree.h b/pclsync/ptree.h
index fec69c4..753c9bf 100644
--- a/pclsync/ptree.h
+++ b/pclsync/ptree.h
@@ -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
diff --git a/pclsync/publiclinks.c b/pclsync/publiclinks.c
index bc81fe7..a00004e 100644
--- a/pclsync/publiclinks.c
+++ b/pclsync/publiclinks.c
@@ -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,
diff --git a/pclsync/publiclinks.h b/pclsync/publiclinks.h
index de5993d..ced4562 100644
--- a/pclsync/publiclinks.h
+++ b/pclsync/publiclinks.h
@@ -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,