diff --git a/pclsync/papi.c b/pclsync/papi.c
index 343af44..8532aaa 100644
--- a/pclsync/papi.c
+++ b/pclsync/papi.c
@@ -308,11 +308,11 @@ static binresult *do_parse_result(unsigned char **restrict indata,
     arr = NULL;
     cnt = 0;
     alloc = 128;
-    arr = (binresult **)psync_malloc(sizeof(binresult *) * alloc);
+    arr = (binresult **)malloc(sizeof(binresult *) * alloc);
     while (**indata != RPARAM_END) {
       if (cnt == alloc) {
         alloc *= 2;
-        arr = (binresult **)psync_realloc(arr, sizeof(binresult *) * alloc);
+        arr = (binresult **)realloc(arr, sizeof(binresult *) * alloc);
       }
       arr[cnt++] = do_parse_result(indata, odata, strings, nextstrid);
     }
@@ -321,7 +321,7 @@ static binresult *do_parse_result(unsigned char **restrict indata,
     ret->array = (struct _binresult **)*odata;
     *odata += sizeof(struct _binresult *) * cnt;
     memcpy(ret->array, arr, sizeof(struct _binresult *) * cnt);
-    psync_free(arr);
+    free(arr);
     return ret;
   } else if (type == RPARAM_HASH) {
     struct _hashpair *arr;
@@ -333,11 +333,11 @@ static binresult *do_parse_result(unsigned char **restrict indata,
     arr = NULL;
     cnt = 0;
     alloc = 32;
-    arr = (struct _hashpair *)psync_malloc(sizeof(struct _hashpair) * alloc);
+    arr = (struct _hashpair *)malloc(sizeof(struct _hashpair) * alloc);
     while (**indata != RPARAM_END) {
       if (cnt == alloc) {
         alloc *= 2;
-        arr = (struct _hashpair *)psync_realloc(arr, sizeof(struct _hashpair) *
+        arr = (struct _hashpair *)realloc(arr, sizeof(struct _hashpair) *
                                                          alloc);
       }
       key = do_parse_result(indata, odata, strings, nextstrid);
@@ -352,7 +352,7 @@ static binresult *do_parse_result(unsigned char **restrict indata,
     ret->hash = (struct _hashpair *)*odata;
     *odata += sizeof(struct _hashpair) * cnt;
     memcpy(ret->hash, arr, sizeof(struct _hashpair) * cnt);
-    psync_free(arr);
+    free(arr);
     return ret;
   } else if (type == RPARAM_DATA) {
     ret = (binresult *)(*odata);
@@ -381,7 +381,7 @@ static binresult *parse_result(unsigned char *data, size_t datalen) {
   strings = psync_new_cnt(binresult *, strcnt);
   strcnt = 0;
   res = do_parse_result(&data, &datac, strings, &strcnt);
-  psync_free(strings);
+  free(strings);
   return res;
 }
 
@@ -395,15 +395,15 @@ binresult *papi_result(psock_t *sock) {
     return NULL;
   }
 
-  data = (unsigned char *)psync_malloc(ressize);
+  data = (unsigned char *)malloc(ressize);
 
   if (unlikely_log(psock_readall(sock, data, ressize) != ressize)) {
-    psync_free(data);
+    free(data);
     return NULL;
   }
 
   res = parse_result(data, ressize);
-  psync_free(data);
+  free(data);
 
   return res;
 }
@@ -415,14 +415,14 @@ binresult *papi_result_thread(psock_t *sock) {
   if (unlikely_log(psock_readall_thread(
                        sock, &ressize, sizeof(uint32_t)) != sizeof(uint32_t)))
     return NULL;
-  data = (unsigned char *)psync_malloc(ressize);
+  data = (unsigned char *)malloc(ressize);
   if (unlikely_log(psock_readall_thread(sock, data, ressize) !=
                    ressize)) {
-    psync_free(data);
+    free(data);
     return NULL;
   }
   res = parse_result(data, ressize);
-  psync_free(data);
+  free(data);
   return res;
 }
 
@@ -435,7 +435,7 @@ void papi_rdr_alloc(async_result_reader *reader) {
 
 void papi_rdr_free(async_result_reader *reader) {
   if (reader->state == 1)
-    psync_free(reader->data);
+    free(reader->data);
 }
 
 int papi_result_async(psock_t *sock, async_result_reader *reader) {
@@ -447,7 +447,7 @@ again:
     return ASYNC_RES_NEEDMORE;
   else if (rd == PSYNC_SOCKET_ERROR || rd == 0) {
     if (reader->state == 1)
-      psync_free(reader->data);
+      free(reader->data);
     papi_rdr_alloc(reader);
     reader->result = NULL;
     return ASYNC_RES_READY;
@@ -458,12 +458,12 @@ again:
       reader->state = 1;
       reader->bytesread = 0;
       reader->bytestoread = reader->respsize;
-      reader->data = (unsigned char *)psync_malloc(reader->respsize);
+      reader->data = (unsigned char *)malloc(reader->respsize);
       goto again;
     } else {
       assert(reader->state == 1);
       reader->result = parse_result(reader->data, reader->respsize);
-      psync_free(reader->data);
+      free(reader->data);
       papi_rdr_alloc(reader);
       return ASYNC_RES_READY;
     }
@@ -496,7 +496,7 @@ unsigned char *papi_prepare(const char *command, size_t cmdlen,
   }
   if (unlikely_log(plen > 0xffff))
     return NULL;
-  sdata = data = (unsigned char *)psync_malloc(plen + 2 + additionalalloc);
+  sdata = data = (unsigned char *)malloc(plen + 2 + additionalalloc);
   memcpy(data, &plen, 2);
   data += 2;
   if (datalen != -1) {
@@ -543,16 +543,16 @@ binresult *papi_send(psock_t *sock, const char *command,
 
   if (readres & 2) {
     if (unlikely_log(psock_writeall_thread(sock, sdata, plen) != plen)) {
-      psync_free(sdata);
+      free(sdata);
       return NULL;
     }
   } else {
     if (unlikely_log(psock_writeall(sock, sdata, plen) != plen)) {
-      psync_free(sdata);
+      free(sdata);
       return NULL;
     }
   }
-  psync_free(sdata);
+  free(sdata);
   if (readres & 1) {
     return papi_result(sock);
   } else {
diff --git a/pclsync/pbusinessaccount.c b/pclsync/pbusinessaccount.c
index de9e538..db050ac 100644
--- a/pclsync/pbusinessaccount.c
+++ b/pclsync/pbusinessaccount.c
@@ -102,12 +102,12 @@ int do_psync_account_stopshare(psync_shareid_t usershareids[], int nusershareid,
   if (unlikely(numparam == 1))
     return -3;
 
-  t = (binparam *)psync_malloc(numparam * sizeof(binparam));
+  t = (binparam *)malloc(numparam * sizeof(binparam));
 
   init_param_str(t, "auth", psync_my_auth);
 
   if (nusershareid) {
-    ids1 = (char *)psync_malloc(nusershareid * FOLDERID_ENTRY_SIZE);
+    ids1 = (char *)malloc(nusershareid * FOLDERID_ENTRY_SIZE);
     idsp = ids1;
     for (i = 0; i < nusershareid; ++i) {
       k = sprintf(idsp, "%lld", (long long)usershareids[i]);
@@ -123,7 +123,7 @@ int do_psync_account_stopshare(psync_shareid_t usershareids[], int nusershareid,
   }
 
   if (nteamshareid) {
-    ids2 = (char *)psync_malloc(nteamshareid * FOLDERID_ENTRY_SIZE);
+    ids2 = (char *)malloc(nteamshareid * FOLDERID_ENTRY_SIZE);
     idsp = ids2;
     for (i = 0; i < nteamshareid; ++i) {
       k = sprintf(idsp, "%lld", (long long)teamshareids[i]);
@@ -177,12 +177,12 @@ int do_psync_account_stopshare(psync_shareid_t usershareids[], int nusershareid,
   }
 
   if (ids1)
-    psync_free(ids1);
+    free(ids1);
   if (ids2)
-    psync_free(ids2);
+    free(ids2);
 
-  psync_free(bres);
-  psync_free(t);
+  free(bres);
+  free(t);
 
   return result;
 }
@@ -208,14 +208,14 @@ int do_psync_account_modifyshare(psync_shareid_t usrshrids[], uint32_t uperms[],
   if (unlikely(numparam == 1))
     return -3;
 
-  t = (binparam *)psync_malloc(numparam * sizeof(binparam));
+  t = (binparam *)malloc(numparam * sizeof(binparam));
 
   init_param_str(t, "auth", psync_my_auth);
 
   if (nushid) {
-    ids1 = (char *)psync_malloc(nushid * FOLDERID_ENTRY_SIZE);
+    ids1 = (char *)malloc(nushid * FOLDERID_ENTRY_SIZE);
     idsp = ids1;
-    perms1 = (char *)psync_malloc(nushid * FOLDERID_ENTRY_SIZE);
+    perms1 = (char *)malloc(nushid * FOLDERID_ENTRY_SIZE);
     permsp = perms1;
     for (i = 0; i < nushid; ++i) {
       k = sprintf(idsp, "%lld", (long long)usrshrids[i]);
@@ -240,9 +240,9 @@ int do_psync_account_modifyshare(psync_shareid_t usrshrids[], uint32_t uperms[],
   }
 
   if (ntmshid) {
-    ids2 = (char *)psync_malloc(ntmshid * FOLDERID_ENTRY_SIZE);
+    ids2 = (char *)malloc(ntmshid * FOLDERID_ENTRY_SIZE);
     idsp = ids2;
-    perms2 = (char *)psync_malloc(ntmshid * FOLDERID_ENTRY_SIZE);
+    perms2 = (char *)malloc(ntmshid * FOLDERID_ENTRY_SIZE);
     permsp = perms2;
 
     for (i = 0; i < ntmshid; ++i) {
@@ -306,16 +306,16 @@ int do_psync_account_modifyshare(psync_shareid_t usrshrids[], uint32_t uperms[],
   }
 
   if (ids1)
-    psync_free(ids1);
+    free(ids1);
   if (ids2)
-    psync_free(ids2);
+    free(ids2);
   if (perms1)
-    psync_free(perms1);
+    free(perms1);
   if (perms2)
-    psync_free(perms2);
+    free(perms2);
 
-  psync_free(bres);
-  psync_free(t);
+  free(bres);
+  free(t);
 
   return result;
 }
@@ -330,7 +330,7 @@ void get_ba_member_email(uint64_t userid, char **email /*OUT*/,
   psync_sql_bind_uint(res, 1, userid);
   if ((row = psync_sql_fetch_row(res))) {
     cstr = psync_get_lstring(row[0], length);
-    *email = (char *)psync_malloc(*length);
+    *email = (char *)malloc(*length);
     memcpy(*email, cstr, *length);
     psync_sql_free_result(res);
     return;
@@ -357,7 +357,7 @@ void get_ba_member_email(uint64_t userid, char **email /*OUT*/,
 
     users = papi_find_result2(bres, "users", PARAM_ARRAY);
     if (!users->length) {
-      psync_free(bres);
+      free(bres);
       debug(D_WARNING, "Account_users returned empty result!\n");
       return;
     } else {
@@ -368,7 +368,7 @@ void get_ba_member_email(uint64_t userid, char **email /*OUT*/,
       fname = papi_find_result2(users->array[0], "firstname", PARAM_STR)->str;
       lname = papi_find_result2(users->array[0], "lastname", PARAM_STR)->str;
     }
-    psync_free(bres);
+    free(bres);
 
     if (*length) {
       psync_sql_res *q;
@@ -396,7 +396,7 @@ void get_ba_team_name(uint64_t teamid, char **name /*OUT*/,
   psync_sql_bind_uint(res, 1, teamid);
   if ((row = psync_sql_fetch_row(res))) {
     cstr = psync_get_lstring(row[0], length);
-    *name = (char *)psync_malloc(*length);
+    *name = (char *)malloc(*length);
     memcpy(*name, cstr, *length);
     psync_sql_free_result(res);
     return;
@@ -422,7 +422,7 @@ void get_ba_team_name(uint64_t teamid, char **name /*OUT*/,
   // debug(D_NOTICE, "Result contains %d teams\n", users->length);
 
   if (!teams->length) {
-    psync_free(bres);
+    free(bres);
     debug(D_WARNING, "Account_teams returned empty result!\n");
     return;
   } else {
@@ -431,7 +431,7 @@ void get_ba_team_name(uint64_t teamid, char **name /*OUT*/,
     *length = strlen(teamret);
     *name = psync_strndup(teamret, *length);
   }
-  psync_free(bres);
+  free(bres);
 
   psync_sql_res *q;
   q = psync_sql_prep_statement(
@@ -515,7 +515,7 @@ void cache_account_emails() {
     psync_sql_commit_transaction();
   }
 end_close:
-  psync_free(bres);
+  free(bres);
 }
 
 void cache_account_teams() {
@@ -549,7 +549,7 @@ void cache_account_teams() {
   // debug(D_NOTICE, "Result contains %d teams\n", users->length);
 
   if (!users->length) {
-    psync_free(bres);
+    free(bres);
     debug(D_WARNING, "Account_teams returned empty result!\n");
     return;
   } else {
@@ -577,7 +577,7 @@ void cache_account_teams() {
     }
     psync_sql_commit_transaction();
   }
-  psync_free(bres);
+  free(bres);
   return;
 }
 
@@ -622,7 +622,7 @@ void cache_ba_my_teams() {
   users = papi_find_result2(bres, "users", PARAM_ARRAY);
 
   if (!users->length) {
-    psync_free(bres);
+    free(bres);
     debug(D_WARNING, "Account_users returned empty result!\n");
     return;
   }
@@ -634,7 +634,7 @@ void cache_ba_my_teams() {
   teams = papi_find_result2(user, "teams", PARAM_ARRAY);
   for (i = 0; i < teams->length; i++)
     cache_my_team(teams->array[i]);
-  psync_free(bres);
+  free(bres);
   psync_sql_unlock();
 }
 
@@ -642,7 +642,7 @@ int api_error_result(binresult *res) {
   uint64_t result;
   result = papi_find_result2(res, "result", PARAM_NUM)->num;
   if (result) {
-    psync_free(res);
+    free(res);
     psync_process_api_error(result);
     return 1;
   }
@@ -741,20 +741,20 @@ static psync_folderid_t create_index_folder(const char *path) {
   while (ind < 100) {
     bufflen = strlen(path) + 1 /*zero char*/ + 3 /*parenthesis*/ +
               3 /*up to 3 digit index*/;
-    buff = (char *)psync_malloc(bufflen);
+    buff = (char *)malloc(bufflen);
     snprintf(buff, bufflen - 1, "%s (%d)", path, ind);
     if (psync_create_remote_folder_by_path(buff, &err) != 0)
       debug(D_NOTICE, "Unable to create folder %s error is %s.", buff, err);
     folderid = pfolder_id(buff);
     if ((folderid != PSYNC_INVALID_FOLDERID) &&
         check_write_permissions(folderid)) {
-      psync_free(buff);
+      free(buff);
       break;
     }
     ++ind;
     if (err)
-      psync_free(err);
-    psync_free(buff);
+      free(err);
+    free(buff);
   }
   return folderid;
 }
@@ -765,7 +765,7 @@ psync_folderid_t psync_check_and_create_folder(const char *path) {
   if (folderid == PSYNC_INVALID_FOLDERID) {
     if (psync_create_remote_folder_by_path(path, &err) != 0) {
       debug(D_NOTICE, "Unable to create folder %s error is %s.", path, err);
-      psync_free(err);
+      free(err);
       folderid = create_index_folder(path);
     }
   } else if (!check_write_permissions(folderid))
diff --git a/pclsync/pcache.c b/pclsync/pcache.c
index 03a479b..4d9977f 100644
--- a/pclsync/pcache.c
+++ b/pclsync/pcache.c
@@ -87,7 +87,7 @@ static void cache_timer(psync_timer_t timer, void *ptr) {
   psync_list_del(&he->list);
   pthread_mutex_unlock(&cachelocks[hash_to_lock(he->hash)]);
   he->free(he->value);
-  psync_free(he);
+  free(he);
   ptimer_stop(timer);
 }
 
@@ -131,7 +131,7 @@ void *pcache_get(const char *key) {
     psync_list_del(&he->list);
     pthread_mutex_unlock(&cachelocks[hash_to_lock(h)]);
     val = he->value;
-    psync_free(he);
+    free(he);
     return val;
   }
   pthread_mutex_unlock(&cachelocks[hash_to_lock(h)]);
@@ -164,7 +164,7 @@ void pcache_add(const char *key, void *ptr, time_t freeafter,
   uint32_t h;
   h = compute_hash(key, &l);
   l++;
-  he = (cache_entry_t *)psync_malloc(offsetof(cache_entry_t, key) + l);
+  he = (cache_entry_t *)malloc(offsetof(cache_entry_t, key) + l);
   he->value = ptr;
   he->free = freefunc;
   he->hash = h;
@@ -178,7 +178,7 @@ void pcache_add(const char *key, void *ptr, time_t freeafter,
                                                    !strcmp(key, he2->key) &&
                                                    ++l == maxkeys)) {
       pthread_mutex_unlock(&cachelocks[hash_to_lock(h)]);
-      psync_free(he);
+      free(he);
       freefunc(ptr);
       //        debug(D_NOTICE, "not adding key %s to cache as there already %u
       //        elements present", key, (unsigned int)maxkeys);
@@ -218,7 +218,7 @@ restart:
     psync_list_del(&he->list);
     pthread_mutex_unlock(&cachelocks[hash_to_lock(h)]);
     he->free(he->value);
-    psync_free(he);
+    free(he);
     goto restart;
   }
   pthread_mutex_unlock(&cachelocks[hash_to_lock(h)]);
@@ -235,7 +235,7 @@ void pcache_clean() {
       if (!ptimer_stop(he->timer)) {
         psync_list_del(l1);
         he->free(he->value);
-        psync_free(he);
+        free(he);
       }
     }
     pthread_mutex_unlock(&cachelocks[hash_to_lock(h)]);
@@ -262,7 +262,7 @@ void pcache_clean_oneof(const char **prefixes, size_t cnt) {
       if (!ptimer_stop(he->timer)) {
         psync_list_del(l1);
         he->free(he->value);
-        psync_free(he);
+        free(he);
       }
     }
     pthread_mutex_unlock(&cachelocks[hash_to_lock(h)]);
diff --git a/pclsync/pcontacts.c b/pclsync/pcontacts.c
index ef77ef8..563830c 100644
--- a/pclsync/pcontacts.c
+++ b/pclsync/pcontacts.c
@@ -69,7 +69,7 @@ int do_call_contactlist(result_visitor vis, void *param) {
   contacts = papi_find_result2(bres, "contacts", PARAM_ARRAY);
 
   if (!contacts->length) {
-    psync_free(bres);
+    free(bres);
     debug(D_WARNING, "Account_users returned empty result!\n");
     return -2;
   } else {
@@ -80,7 +80,7 @@ int do_call_contactlist(result_visitor vis, void *param) {
     psync_sql_commit_transaction();
   }
 
-  psync_free(bres);
+  free(bres);
   return 0;
 }
 
@@ -361,7 +361,7 @@ void cache_shares() {
     debug(D_WARNING, "command listshares returned error code %u message %s",
           (unsigned)result, errorret);
     psync_process_api_error(result);
-    psync_free(bres);
+    free(bres);
     return;
   }
 
@@ -406,5 +406,5 @@ void cache_shares() {
 
   psync_sql_commit_transaction();
 
-  psync_free(bres);
+  free(bres);
 }
diff --git a/pclsync/pcrypto.c b/pclsync/pcrypto.c
index a779863..e9932b0 100644
--- a/pclsync/pcrypto.c
+++ b/pclsync/pcrypto.c
@@ -42,7 +42,6 @@
 
 #include "pcrypto.h"
 #include "plibs.h"
-#include "pmemlock.h"
 #include <stddef.h>
 #include <string.h>
 
@@ -161,7 +160,7 @@ static void copy_iv_and_xor_with_counter(unsigned char *dest,
 
 psync_symmetric_key_t pcrypto_key_len(size_t len) {
   psync_symmetric_key_t key;
-  key = (psync_symmetric_key_t)pmemlock_malloc(
+  key = (psync_symmetric_key_t)malloc(
       offsetof(psync_symmetric_key_struct_t, key) + len);
   key->keylen = len;
   pssl_rand_strong(key->key, len);
@@ -193,7 +192,7 @@ void pcrypto_ctr_encdec_free(
     pcrypto_ctr_encdec_t enc) {
   paes_free_encoder(enc->encoder);
   putil_wipe(enc->iv, PSYNC_AES256_BLOCK_SIZE);
-  psync_free(enc);
+  free(enc);
 }
 
 void pcrypto_ctr_encdec_decode(
@@ -343,7 +342,7 @@ pcrypto_decode_text(pcrypto_textdec_t enc,
     while (ret + len < outptr) {
       if (unlikely(ret[len] != 0)) {
         debug(D_WARNING, "non-zero in the padding found");
-        psync_free(ret);
+        free(ret);
         return NULL;
       }
       len++;
@@ -388,7 +387,7 @@ pcrypto_decode_text(pcrypto_textdec_t enc,
   while (ret + len < outptr) {
     if (unlikely(ret[len] != 0)) {
       debug(D_WARNING, "non-zero in the padding found");
-      psync_free(ret);
+      free(ret);
       return NULL;
     }
     len++;
@@ -406,7 +405,7 @@ pcrypto_textenc_create(psync_symmetric_key_t key) {
   enc = paes_create_encoder(key);
   if (unlikely_log(enc == PSYNC_INVALID_ENCODER))
     return PSYNC_CRYPTO_INVALID_ENCODER;
-  ret = (pcrypto_textenc_t)pmemlock_malloc(
+  ret = (pcrypto_textenc_t)malloc(
       offsetof(pcrypto_key_iv_t, iv) + key->keylen -
       PSYNC_AES256_KEY_SIZE);
   ret->encoder = enc;
@@ -419,7 +418,7 @@ void pcrypto_textenc_free(
     pcrypto_textenc_t enc) {
   paes_free_encoder(enc->encoder);
   putil_wipe(enc->iv, enc->ivlen);
-  pmemlock_free(enc);
+  free(enc);
 }
 
 pcrypto_textdec_t
@@ -432,7 +431,7 @@ pcrypto_textdec_create(psync_symmetric_key_t key) {
   enc = paes_create_decoder(key);
   if (unlikely_log(enc == PSYNC_INVALID_ENCODER))
     return PSYNC_CRYPTO_INVALID_ENCODER;
-  ret = (pcrypto_textenc_t)pmemlock_malloc(
+  ret = (pcrypto_textenc_t)malloc(
       offsetof(pcrypto_key_iv_t, iv) + key->keylen -
       PSYNC_AES256_KEY_SIZE);
   ret->encoder = enc;
@@ -445,7 +444,7 @@ void pcrypto_textdec_free(
     pcrypto_textdec_t enc) {
   paes_free_encoder(enc->encoder);
   putil_wipe(enc->iv, enc->ivlen);
-  pmemlock_free(enc);
+  free(enc);
 }
 
 pcrypto_sector_encdec_t
@@ -463,7 +462,7 @@ pcrypto_sec_encdec_create(psync_symmetric_key_t key) {
     paes_free_encoder(enc);
     return PSYNC_CRYPTO_INVALID_ENCODER;
   }
-  ret = (pcrypto_sector_encdec_t)pmemlock_malloc(
+  ret = (pcrypto_sector_encdec_t)malloc(
       offsetof(pcrypto_encdec_iv_t, iv) + key->keylen -
       PSYNC_AES256_KEY_SIZE);
   ret->encoder = enc;
@@ -478,7 +477,7 @@ void pcrypto_sec_encdec_free(
   paes_free_encoder(enc->encoder);
   paes_free_decoder(enc->decoder);
   putil_wipe(enc->iv, enc->ivlen);
-  pmemlock_free(enc);
+  free(enc);
 }
 
 static int memcmp_const(const unsigned char *s1, const unsigned char *s2,
diff --git a/pclsync/pcryptofolder.c b/pclsync/pcryptofolder.c
index 72d6796..c4fc810 100644
--- a/pclsync/pcryptofolder.c
+++ b/pclsync/pcryptofolder.c
@@ -47,7 +47,6 @@
 #include "pfoldersync.h"
 #include "pfs.h"
 #include "plibs.h"
-#include "pmemlock.h"
 #include "pnetlibs.h"
 #include "psettings.h"
 #include "pssl.h"
@@ -185,7 +184,7 @@ static int setup_do_upload(const unsigned char *rsapriv,
   result = papi_find_result2(res, "result", PARAM_NUM)->num;
   if (!result)
     *cryptoexpires = papi_find_result2(res, "cryptoexpires", PARAM_NUM)->num;
-  psync_free(res);
+  free(res);
   if (result != 0)
     debug(D_WARNING, "crypto_setuserkeys returned %u", (unsigned)result);
   if (result == 0)
@@ -207,7 +206,7 @@ static void load_str_to(const psync_variant *v, unsigned char **ptr,
   const char *str;
   size_t l;
   str = psync_get_lstring(*v, &l);
-  *ptr = (unsigned char *)psync_malloc(l);
+  *ptr = (unsigned char *)malloc(l);
   memcpy(*ptr, str, l);
   *len = l;
 }
@@ -239,7 +238,7 @@ static int download_keys(unsigned char **rsapriv, size_t *rsaprivlen, unsigned c
   }
   result = papi_find_result2(res, "result", PARAM_NUM)->num;
   if (result) {
-    psync_free(res);
+    free(res);
     psync_process_api_error(result);
     switch (result) {
     case 2111:
@@ -257,7 +256,7 @@ static int download_keys(unsigned char **rsapriv, size_t *rsaprivlen, unsigned c
   data = papi_find_result2(res, "publickey", PARAM_STR);
   rsapubstruct = psync_base64_decode((const unsigned char *)data->str,
                                      data->length, &rsapubstructlen);
-  psync_free(res);
+  free(res);
   sha1hex(rsaprivstruct, rsaprivstructlen, privatesha1);
   sha1hex(rsapubstruct, rsapubstructlen, publicsha1);
   debug(D_NOTICE, "rsapubstruct=%s", rsapubstruct);
@@ -266,14 +265,14 @@ static int download_keys(unsigned char **rsapriv, size_t *rsaprivlen, unsigned c
     if (offsetof(pub_key_ver1, key) >= rsapubstructlen)
       goto def1;
     *rsapublen = rsapubstructlen - offsetof(pub_key_ver1, key);
-    *rsapub = (unsigned char *)psync_malloc(*rsapublen);
+    *rsapub = (unsigned char *)malloc(*rsapublen);
     memcpy(*rsapub, rsapubstruct + offsetof(pub_key_ver1, key), *rsapublen);
     break;
   default:
   def1:
     putil_wipe(rsaprivstruct, rsaprivstructlen);
-    psync_free(rsaprivstruct);
-    psync_free(rsapubstruct);
+    free(rsaprivstruct);
+    free(rsapubstruct);
     return PRINT_RETURN_CONST(PSYNC_CRYPTO_START_UNKNOWN_KEY_FORMAT);
   }
   switch (*((uint32_t *)rsaprivstruct)) {
@@ -281,10 +280,10 @@ static int download_keys(unsigned char **rsapriv, size_t *rsaprivlen, unsigned c
     if (offsetof(priv_key_ver1, key) >= rsaprivstructlen)
       goto def2;
     *rsaprivlen = rsaprivstructlen - offsetof(priv_key_ver1, key);
-    *rsapriv = (unsigned char *)psync_malloc(*rsaprivlen);
+    *rsapriv = (unsigned char *)malloc(*rsaprivlen);
     memcpy(*rsapriv, rsaprivstruct + offsetof(priv_key_ver1, key), *rsaprivlen);
     *saltlen = PSYNC_CRYPTO_PBKDF2_SALT_LEN;
-    *salt = (unsigned char *)psync_malloc(PSYNC_CRYPTO_PBKDF2_SALT_LEN);
+    *salt = (unsigned char *)malloc(PSYNC_CRYPTO_PBKDF2_SALT_LEN);
     memcpy(*salt, rsaprivstruct + offsetof(priv_key_ver1, salt),
            PSYNC_CRYPTO_PBKDF2_SALT_LEN);
     *iterations = PSYNC_CRYPTO_PASS_TO_KEY_ITERATIONS;
@@ -292,15 +291,15 @@ static int download_keys(unsigned char **rsapriv, size_t *rsaprivlen, unsigned c
     break;
   default:
   def2:
-    psync_free(*rsapub);
+    free(*rsapub);
     putil_wipe(rsaprivstruct, rsaprivstructlen);  
-    psync_free(rsaprivstruct);
-    psync_free(rsapubstruct);
+    free(rsaprivstruct);
+    free(rsapubstruct);
     return PRINT_RETURN_CONST(PSYNC_CRYPTO_START_UNKNOWN_KEY_FORMAT);
   }
   putil_wipe(rsaprivstruct, rsaprivstructlen);  
-  psync_free(rsaprivstruct);
-  psync_free(rsapubstruct);
+  free(rsaprivstruct);
+  free(rsapubstruct);
   return PSYNC_CRYPTO_START_SUCCESS;
 }
 
@@ -333,12 +332,12 @@ setup_upload(const unsigned char *rsapriv, size_t rsaprivlen,
   int ret;
   *cryptoexpires = 0;
   priv =
-      (priv_key_ver1 *)psync_malloc(offsetof(priv_key_ver1, key) + rsaprivlen);
+      (priv_key_ver1 *)malloc(offsetof(priv_key_ver1, key) + rsaprivlen);
   priv->type = PSYNC_CRYPTO_TYPE_RSA4096_64BYTESALT_20000IT;
   priv->flags = 0;
   memcpy(priv->salt, salt, PSYNC_CRYPTO_PBKDF2_SALT_LEN);
   memcpy(priv->key, rsapriv, rsaprivlen);
-  pub = (pub_key_ver1 *)psync_malloc(offsetof(pub_key_ver1, key) + rsapublen);
+  pub = (pub_key_ver1 *)malloc(offsetof(pub_key_ver1, key) + rsapublen);
   pub->type = PSYNC_CRYPTO_PUB_TYPE_RSA4096;
   pub->flags = 0;
   memcpy(pub->key, rsapub, rsapublen);
@@ -351,12 +350,12 @@ setup_upload(const unsigned char *rsapriv, size_t rsaprivlen,
   b64pub =
       psync_base64_encode((unsigned char *)pub,
                           offsetof(pub_key_ver1, key) + rsapublen, &b64publen);
-  psync_free(priv);
-  psync_free(pub);
+  free(priv);
+  free(pub);
   ret = setup_do_upload(b64priv, b64privlen, b64pub,
                                            b64publen, hint, cryptoexpires);
-  psync_free(b64priv);
-  psync_free(b64pub);
+  free(b64priv);
+  free(b64pub);
   return ret;
 }
 
@@ -483,7 +482,7 @@ int pcryptofolder_get_hint(char **hint) {
   }
   result = papi_find_result2(res, "result", PARAM_NUM)->num;
   if (result) {
-    psync_free(res);
+    free(res);
     psync_process_api_error(result);
     switch (result) {
     case 2122:
@@ -496,7 +495,7 @@ int pcryptofolder_get_hint(char **hint) {
     return PRINT_RETURN_CONST(PSYNC_CRYPTO_HINT_UNKNOWN_ERROR);
   }
   *hint = psync_strdup(papi_find_result2(res, "hint", PARAM_STR)->str);
-  psync_free(res);
+  free(res);
   return PSYNC_CRYPTO_HINT_SUCCESS;
 }
 
@@ -505,27 +504,27 @@ static int crypto_keys_match() {
   psync_encrypted_symmetric_key_t enckey;
   int res;
   debug(D_NOTICE, "trying encrypt/decrypt operation with loaded keys");
-  key = (psync_symmetric_key_t)psync_malloc(
+  key = (psync_symmetric_key_t)malloc(
       offsetof(psync_symmetric_key_struct_t, key) + 64);
   key->keylen = 64;
   pssl_rand_strong(key->key, key->keylen);
   enckey = psymkey_encrypt(crypto_pubkey, key);
   if (enckey == PSYNC_INVALID_ENC_SYM_KEY) {
-    psync_free(key);
+    free(key);
     return 0;
   }
 
   deckey = prsa_decrypt_symm_key_lock(&crypto_privkey, &enckey);
 
-  psync_free(enckey);
+  free(enckey);
   if (deckey == PSYNC_INVALID_SYM_KEY) {
-    psync_free(key);
+    free(key);
     return 0;
   }
   res = key->keylen == deckey->keylen &&
         !memcmp(key->key, deckey->key, key->keylen);
   psymkey_free(deckey);
-  psync_free(key);
+  free(key);
   if (res)
     debug(D_NOTICE, "encrypt/decrypt operation succeeded");
   return res;
@@ -595,9 +594,9 @@ int pcryptofolder_unlock(const char *password) {
       debug(D_BUG,
             "only some of records found in the database, should not happen");
       putil_wipe(rsapriv, rsaprivlen);  
-      psync_free(rsapriv);
-      psync_free(rsapub);
-      psync_free(salt);
+      free(rsapriv);
+      free(rsapub);
+      free(salt);
     }
     ret = download_keys(
         &rsapriv, &rsaprivlen, &rsapub, &rsapublen, &salt, &saltlen,
@@ -619,10 +618,10 @@ int pcryptofolder_unlock(const char *password) {
     pthread_rwlock_unlock(&crypto_lock);
     debug(D_WARNING, "could not load public key");
     putil_wipe(rsapriv, rsaprivlen);    
-    psync_free(rsapriv);
-    psync_free(rsapub);
+    free(rsapriv);
+    free(rsapub);
     putil_wipe(salt, saltlen);  
-    psync_free(salt);
+    free(salt);
     return PRINT_RETURN_CONST(PSYNC_CRYPTO_START_UNKNOWN_KEY_FORMAT);
   }
   debug(D_NOTICE, "successfully loaded public key");
@@ -631,7 +630,7 @@ int pcryptofolder_unlock(const char *password) {
   aeskey = psymkey_generate(password, PSYNC_AES256_KEY_SIZE + PSYNC_AES256_BLOCK_SIZE, salt, saltlen, iterations);
   enc = pcrypto_ctr_encdec_create(aeskey);
   psymkey_free(aeskey);
-  rsaprivdec = (unsigned char *)pmemlock_malloc(rsaprivlen);
+  rsaprivdec = (unsigned char *)malloc(rsaprivlen);
   memcpy(rsaprivdec, rsapriv, rsaprivlen);
   pcrypto_ctr_encdec_decode(enc, rsaprivdec, rsaprivlen, 0);
   pcrypto_ctr_encdec_free(enc);
@@ -641,17 +640,17 @@ int pcryptofolder_unlock(const char *password) {
   debug(D_NOTICE, "trying to load private key");
   crypto_privkey = prsa_load_private(rsaprivdec, rsaprivlen);
   putil_wipe(rsaprivdec, rsaprivlen);
-  pmemlock_free(rsaprivdec);
+  free(rsaprivdec);
   if (crypto_privkey == PSYNC_INVALID_RSA) {
     debug(D_NOTICE, "failed to load private key");
     prsa_free_public(crypto_pubkey);
     crypto_pubkey = PSYNC_INVALID_RSA;
     pthread_rwlock_unlock(&crypto_lock);
     putil_wipe(rsapriv, rsaprivlen);
-    psync_free(rsapriv);
-    psync_free(rsapub);
+    free(rsapriv);
+    free(rsapub);
     putil_wipe(salt, saltlen);
-    psync_free(salt);
+    free(salt);
     return PRINT_RETURN_CONST(PSYNC_CRYPTO_START_BAD_PASSWORD);
   }
   debug(D_NOTICE, "successfully loaded private key");
@@ -665,10 +664,10 @@ int pcryptofolder_unlock(const char *password) {
     pthread_rwlock_unlock(&crypto_lock);
     debug(D_ERROR, "keys don't match");
     putil_wipe(rsapriv, rsaprivlen);
-    psync_free(rsapriv);
-    psync_free(rsapub);
+    free(rsapriv);
+    free(rsapub);
     putil_wipe(salt, saltlen);
-    psync_free(salt);
+    free(salt);
     return PRINT_RETURN_CONST(PSYNC_CRYPTO_START_KEYS_DONT_MATCH);
   }
   debug(D_NOTICE, "public and private keys match, setting crypto started");
@@ -683,10 +682,10 @@ int pcryptofolder_unlock(const char *password) {
                                         publicsha1, privatesha1, flags);
   }
   putil_wipe(rsapriv, rsaprivlen);  
-  psync_free(rsapriv);
-  psync_free(rsapub);
+  free(rsapriv);
+  free(rsapub);
   putil_wipe(salt, saltlen);
-  psync_free(salt);
+  free(salt);
   debug(D_NOTICE, "crypto successfully started");
   return PSYNC_CRYPTO_START_SUCCESS;
 }
@@ -699,7 +698,7 @@ static void psync_fs_refresh_crypto_folders() {
     psync_fs_refresh_folder(*fid);
     fid++;
   }
-  psync_free(fids);
+  free(fids);
 }
 
 int pcryptofolder_lock() {
@@ -754,7 +753,7 @@ int pcryptofolder_reset() {
     }
   }
   result = papi_find_result2(res, "result", PARAM_NUM)->num;
-  psync_free(res);
+  free(res);
   if (result)
     debug(D_WARNING, "crypto_reset returned error %u", (unsigned)result);
   if (result == 0)
@@ -847,7 +846,7 @@ static psync_encrypted_symmetric_key_t download_fldr_enckey(psync_folderid_t fol
           (unsigned long)result);
     crypto_api_errno = result;
     set_crypto_err_msg(res);
-    psync_free(res);
+    free(res);
     psync_process_api_error(result);
     return (psync_encrypted_symmetric_key_t)errptr(
         PRINT_RETURN_CONST(PSYNC_CRYPTO_API_ERR_INTERNAL));
@@ -855,13 +854,13 @@ static psync_encrypted_symmetric_key_t download_fldr_enckey(psync_folderid_t fol
   b64key = papi_find_result2(res, "key", PARAM_STR);
   key = psync_base64_decode((const unsigned char *)b64key->str, b64key->length,
                             &keylen);
-  psync_free(res);
+  free(res);
   if (!key)
     return (psync_encrypted_symmetric_key_t)errptr(
         PRINT_RETURN_CONST(PSYNC_CRYPTO_INVALID_KEY));
   ret = psymkey_alloc_encrypted(keylen);
   memcpy(ret->data, key, keylen);
-  psync_free(key);
+  free(key);
   save_folder_key(folderid, ret);
   return ret;
 }
@@ -900,7 +899,7 @@ static psync_encrypted_symmetric_key_t download_file_enckey(psync_fileid_t filei
           (unsigned long)result);
     crypto_api_errno = result;
     set_crypto_err_msg(res);
-    psync_free(res);
+    free(res);
     return (psync_encrypted_symmetric_key_t)errptr(
         PRINT_RETURN_CONST(PSYNC_CRYPTO_API_ERR_INTERNAL));
   }
@@ -908,13 +907,13 @@ static psync_encrypted_symmetric_key_t download_file_enckey(psync_fileid_t filei
   b64key = papi_find_result2(res, "key", PARAM_STR);
   key = psync_base64_decode((const unsigned char *)b64key->str, b64key->length,
                             &keylen);
-  psync_free(res);
+  free(res);
   if (!key)
     return (psync_encrypted_symmetric_key_t)errptr(
         PRINT_RETURN_CONST(PSYNC_CRYPTO_INVALID_KEY));
   ret = psymkey_alloc_encrypted(keylen);
   memcpy(ret->data, key, keylen);
-  psync_free(key);
+  free(key);
   save_file_key_to_db(fileid, result, ret);
   return ret;
 }
@@ -981,7 +980,7 @@ static psync_symmetric_key_t get_fldr_symkey_safe(psync_folderid_t folderid) {
 
   symkey = prsa_decrypt_symm_key_lock(&crypto_privkey, &enckey);
 
-  psync_free(enckey);
+  free(enckey);
   if (symkey == PSYNC_INVALID_SYM_KEY)
     return (psync_symmetric_key_t)errptr(
         PRINT_RETURN_CONST(PSYNC_CRYPTO_INVALID_KEY));
@@ -1009,7 +1008,7 @@ static psync_symmetric_key_t get_file_symkey_safe(psync_fileid_t fileid, uint64_
 
   symkey = prsa_decrypt_symm_key_lock(&crypto_privkey, &enckey);
 
-  psync_free(enckey);
+  free(enckey);
   if (unlikely_log(symkey == PSYNC_INVALID_SYM_KEY))
     return (psync_symmetric_key_t)errptr(
         PRINT_RETURN_CONST(PSYNC_CRYPTO_INVALID_KEY));
@@ -1040,7 +1039,7 @@ static void psync_crypto_release_file_symkey_locked(psync_fileid_t fileid,
 
 static psync_symmetric_key_t symkeyv1_to_symkey(sym_key_ver1 *v1) {
   psync_symmetric_key_t key;
-  key = (psync_symmetric_key_t)pmemlock_malloc(
+  key = (psync_symmetric_key_t)malloc(
       offsetof(psync_symmetric_key_struct_t, key) + PSYNC_AES256_KEY_SIZE +
       PSYNC_CRYPTO_HMAC_SHA512_KEY_LEN);
   key->keylen = PSYNC_AES256_KEY_SIZE + PSYNC_CRYPTO_HMAC_SHA512_KEY_LEN;
@@ -1148,7 +1147,7 @@ static pcrypto_textenc_t get_tmp_fldrencoder_safe(psync_fsfolderid_t folderid) {
     psync_sql_free_result(res);
     if (enckey) {
       symkey = prsa_decrypt_data(crypto_privkey, enckey, enckeylen);
-      psync_free(enckey);
+      free(enckey);
     } else
       symkey = PSYNC_INVALID_SYM_KEY;
   } else {
@@ -1205,7 +1204,7 @@ static pcrypto_textdec_t get_tmp_fldrdecoder_safe(psync_fsfolderid_t folderid) {
     if (enckey) {
       symkey = prsa_decrypt_data(crypto_privkey, enckey, enckeylen);
 
-      psync_free(enckey);
+      free(enckey);
       if (symkey == PSYNC_INVALID_SYM_KEY)
         debug(D_WARNING, "got key from database that fails rsa decrypt");
     } else {
@@ -1296,7 +1295,7 @@ char *pcryptofolder_flddecode_filename(pcrypto_textdec_t decoder,
     return NULL;
   filenamedec =
       pcrypto_decode_text(decoder, filenameenc, filenameenclen);
-  psync_free(filenameenc);
+  free(filenameenc);
   return (char *)filenamedec;
 }
 
@@ -1362,7 +1361,7 @@ char * pcryptofolder_fldencode_filename(pcrypto_textenc_t encoder,
                                   strlen(name), &filenameenc, &filenameenclen);
   filenameb32 =
       psync_base32_encode(filenameenc, filenameenclen, &filenameenclen);
-  psync_free(filenameenc);
+  free(filenameenc);
   return (char *)filenameb32;
 }
 
@@ -1434,7 +1433,7 @@ static pcrypto_sector_encdec_t get_fileencoder_tmp(psync_fsfileid_t fileid,
     if (enckey) {
       symkey = prsa_decrypt_data(crypto_privkey, enckey, enckeylen);
 
-      psync_free(enckey);
+      free(enckey);
     } else
       symkey = PSYNC_INVALID_SYM_KEY;
     if (symkey == PSYNC_INVALID_SYM_KEY)
@@ -1519,7 +1518,7 @@ pcrypto_sector_encdec_t pcryptofolder_filencoder_from_binresult(psync_fileid_t f
         PRINT_RETURN_CONST(PSYNC_CRYPTO_INVALID_KEY));
   esym = psymkey_alloc_encrypted(keylen);
   memcpy(esym->data, key, keylen);
-  psync_free(key);
+  free(key);
   hash = papi_find_result2(res, "hash", PARAM_NUM)->num;
   save_file_key_to_db(fileid, hash, esym);
   pthread_rwlock_rdlock(&crypto_lock);
@@ -1536,7 +1535,7 @@ pcrypto_sector_encdec_t pcryptofolder_filencoder_from_binresult(psync_fileid_t f
     enc = get_fileencoder(fileid, hash, 0);
   }
   pthread_rwlock_unlock(&crypto_lock);
-  psync_free(esym);
+  free(esym);
   return enc;
 }
 
@@ -1570,7 +1569,7 @@ static char *get_name_encoded(psync_folderid_t folderid,
                                   strlen(name), &nameenc, &nameenclen);
   ret = (char *)psync_base32_encode(nameenc, nameenclen, &nameenclen);
   free_direncoder(folderid, enc);
-  psync_free(nameenc);
+  free(nameenc);
   return ret;
 }
 
@@ -1663,7 +1662,7 @@ int psync_cloud_crypto_send_mkdir(psync_folderid_t folderid, const char *name,
     set_crypto_err_msg(res);
     debug(D_NOTICE, "createfolder returned error %lu %s", (unsigned long)result,
           crypto_api_err);
-    psync_free(res);
+    free(res);
     *err = crypto_api_err;
     psync_process_api_error(result);
     return result;
@@ -1676,7 +1675,7 @@ int psync_cloud_crypto_send_mkdir(psync_folderid_t folderid, const char *name,
   save_folder_key(papi_find_result2(meta, "folderid", PARAM_NUM)->num,
                         encsym);
   psync_sql_commit_transaction();
-  psync_free(res);
+  free(res);
   return PSYNC_CRYPTO_SUCCESS;
 }
 
@@ -1690,7 +1689,7 @@ char *pcryptofolder_filencoder_key_get(psync_fsfileid_t fileid,
   if (is_err(encsym))
     return (char *)encsym;
   ret = (char *)psync_base64_encode(encsym->data, encsym->datalen, keylen);
-  psync_free(encsym);
+  free(encsym);
   return ret;
 }
 
@@ -1718,7 +1717,7 @@ char *pcryptofolder_filencoder_key_new(uint32_t flags, size_t *keylen) {
   }
   putil_wipe(&sym, sizeof(sym));
   ret = (char *)psync_base64_encode(encsym->data, encsym->datalen, keylen);
-  psync_free(encsym);
+  free(encsym);
   return ret;
 }
 
@@ -1748,7 +1747,7 @@ char *pcryptofolder_filencoder_key_newplain(
   *deckey = symkeyv1_to_symkey(&sym);
   putil_wipe(&sym, sizeof(sym));
   ret = (char *)psync_base64_encode(encsym->data, encsym->datalen, keylen);
-  psync_free(encsym);
+  free(encsym);
   return ret;
 }
 
@@ -1779,20 +1778,20 @@ int pcryptofolder_mkdir(psync_folderid_t folderid, const char *name,
   pthread_rwlock_unlock(&crypto_lock);
   if (ret) {
     if (encsym != PSYNC_INVALID_ENC_SYM_KEY)
-      psync_free(encsym);
+      free(encsym);
     return ret;
   }
   if (encsym == PSYNC_INVALID_ENC_SYM_KEY) {
-    psync_free(ename);
+    free(ename);
     debug(D_ERROR, "RSA encryption failed");
     return set_err(PRINT_RETURN_CONST(PSYNC_CRYPTO_RSA_ERROR), err);
   }
   b64encsym = psync_base64_encode(encsym->data, encsym->datalen, &b64encsymlen);
   ret = psync_cloud_crypto_send_mkdir(folderid, ename, err, (char *)b64encsym,
                                       b64encsymlen, encsym, newfolderid);
-  psync_free(encsym);
-  psync_free(ename);
-  psync_free(b64encsym);
+  free(encsym);
+  free(ename);
+  free(b64encsym);
   return ret;
 }
 
@@ -1843,7 +1842,7 @@ int psync_pcloud_crypto_reencode_key(
     psymkey_free(aeskey);
     if (unlikely(enc == PSYNC_CRYPTO_INVALID_ENCODER))
       goto err_nm_1;
-    rsaprivdec = (unsigned char *)psync_malloc(rsaprivlen);
+    rsaprivdec = (unsigned char *)malloc(rsaprivlen);
     if (unlikely(!rsaprivdec)) {
       pcrypto_ctr_encdec_free(enc);
       goto err_nm_1;
@@ -1852,7 +1851,7 @@ int psync_pcloud_crypto_reencode_key(
     pcrypto_ctr_encdec_decode(enc, rsaprivdec, rsaprivlen,
                                                   0);
     pcrypto_ctr_encdec_free(enc);
-    newpriv = (unsigned char *)psync_malloc(offsetof(priv_key_ver1, key) +
+    newpriv = (unsigned char *)malloc(offsetof(priv_key_ver1, key) +
                                             rsaprivlen);
     if (unlikely(!newpriv))
       goto err_nm_1;
@@ -1877,7 +1876,7 @@ int psync_pcloud_crypto_reencode_key(
     newprivlen = offsetof(priv_key_ver1, key) + rsaprivlen;
     priv = prsa_load_private(rsaprivdec, rsaprivlen);
     putil_wipe(rsaprivdec, rsaprivlen);
-    psync_free(rsaprivdec);
+    free(rsaprivdec);
     if (unlikely(priv == PSYNC_INVALID_RSA))
       goto err_ph_1;
     break;
@@ -1891,21 +1890,21 @@ int psync_pcloud_crypto_reencode_key(
   psync_sha256(newpriv, newprivlen, newprivsha);
   rsasign = prsa_sign_sha256_hash(priv, newprivsha);
   if (is_err(rsasign)) {
-    psync_free(is_err);
+    free(rsasign);
     prsa_free_public(pub);
     prsa_free_private(priv);
     return to_err(rsasign);
   }
   *privenc = (char *)psync_base64_encode(newpriv, newprivlen, &dummy);
   *sign = (char *)psync_base64_encode(rsasign->data, rsasign->datalen, &dummy);
-  psync_free(rsasign);
-  psync_free(newpriv);
+  free(rsasign);
+  free(newpriv);
   prsa_free_public(pub);
   prsa_free_private(priv);
 
   if (!*privenc || !*sign) {
-    psync_free(*privenc);
-    psync_free(*sign);
+    free(*privenc);
+    free(*sign);
     return PERROR_NO_MEMORY;
   }
 
@@ -1915,13 +1914,13 @@ err_bk_1:
 err_bk_0:
   return PSYNC_CRYPTO_BAD_KEY;
 err_nm_1:
-  psync_free(newpriv);
+  free(newpriv);
   prsa_free_public(pub);
   return PERROR_NO_MEMORY;
 err_ph_2:
   prsa_free_private(priv);
 err_ph_1:
-  psync_free(newpriv);
+  free(newpriv);
   prsa_free_public(pub);
   return PSYNC_CRYPTO_BAD_PASSPHRASE;
 }
@@ -1941,7 +1940,7 @@ int psync_pcloud_crypto_encode_key(const char *newpassphrase, uint32_t flags,
     goto err_nm_0;
   rsaprivlen = rsapriv->datalen;
   newpriv =
-      (unsigned char *)psync_malloc(offsetof(priv_key_ver1, key) + rsaprivlen);
+      (unsigned char *)malloc(offsetof(priv_key_ver1, key) + rsaprivlen);
   if (unlikely(!newpriv))
     goto err_nm_1;
   rsapriv_struct = (priv_key_ver1 *)newpriv;
@@ -1967,27 +1966,27 @@ int psync_pcloud_crypto_encode_key(const char *newpassphrase, uint32_t flags,
   rsasign = prsa_sign_sha256_hash(crypto_privkey, newprivsha);
   if (is_err(rsasign)) {
     putil_wipe(newpriv, rsaprivlen);
-    psync_free(newpriv);
+    free(newpriv);
     prsa_free_binary(rsapriv);
     return to_err(rsasign);
   }
   *privenc = (char *)psync_base64_encode(newpriv, rsaprivlen, &dummy);
   *sign = (char *)psync_base64_encode(rsasign->data, rsasign->datalen, &dummy);
-  psync_free(rsasign);
+  free(rsasign);
   putil_wipe(newpriv, rsaprivlen);
-  psync_free(newpriv);
+  free(newpriv);
   prsa_free_binary(rsapriv);
 
   if (!*privenc || !*sign) {
-    psync_free(*privenc);
-    psync_free(*sign);
+    free(*privenc);
+    free(*sign);
     return PERROR_NO_MEMORY;
   }
 
   return PSYNC_CRYPTO_SUCCESS;
 
 err_nm_1:
-  psync_free(newpriv);
+  free(newpriv);
   prsa_free_binary(rsapriv);
 err_nm_0:
   return PERROR_NO_MEMORY;
@@ -2026,21 +2025,21 @@ int pcryptofolder_change_pass(const char *oldpassphrase,
       rowcnt++;
       if (!strcmp(id, "crypto_private_key")) {
         load_str_to(&row[1], &privkey, &privkeylen);
-        privatekey_struct = (priv_key_ver1 *)psync_malloc(
+        privatekey_struct = (priv_key_ver1 *)malloc(
             offsetof(priv_key_ver1, key) + privkeylen);
         memset(privatekey_struct, 0, offsetof(priv_key_ver1, key) + privkeylen);
         memcpy(privatekey_struct->key, privkey, privkeylen);
         privatekey_struct->type = PSYNC_CRYPTO_TYPE_RSA4096_64BYTESALT_20000IT;
         putil_wipe(privkey, privkeylen);
-        psync_free(privkey);
+        free(privkey);
       } else if (!strcmp(id, "crypto_public_key")) {
         load_str_to(&row[1], &pubkey, &pubkeylen);
-        pubkey_struct = (pub_key_ver1 *)psync_malloc(
+        pubkey_struct = (pub_key_ver1 *)malloc(
             offsetof(pub_key_ver1, key) + pubkeylen);
         memset(pubkey_struct, 0, offsetof(pub_key_ver1, key) + pubkeylen);
         memcpy(pubkey_struct->key, pubkey, pubkeylen);
         pubkey_struct->type = PSYNC_CRYPTO_PUB_TYPE_RSA4096;
-        psync_free(pubkey);
+        free(pubkey);
       } else if (!strcmp(id, "crypto_private_salt")) {
         load_str_to(&row[1], &salt, &saltlen);
         if (!privatekey_struct) {
@@ -2050,15 +2049,15 @@ int pcryptofolder_change_pass(const char *oldpassphrase,
         }
         memcpy(privatekey_struct->salt, salt, saltlen);
         putil_wipe(salt, saltlen);
-        psync_free(salt);
+        free(salt);
       }
     }
     psync_sql_free_result(res);
   }
   psync_sql_unlock();
   if (rowcnt < 3) {
-    psync_free(privatekey_struct);
-    psync_free(pubkey_struct);
+    free(privatekey_struct);
+    free(pubkey_struct);
     if (!psync_my_auth[0])
       return PERROR_NET_ERROR;
     debug(D_NOTICE, "downloading keys");
@@ -2071,7 +2070,7 @@ int pcryptofolder_change_pass(const char *oldpassphrase,
     if (unlikely(result)) {
       debug(D_WARNING, "crypto_getuserkeys returned error %d: %s", (int)result,
             papi_find_result2(bres, "error", PARAM_STR)->str);
-      psync_free(bres);
+      free(bres);
       cres = (int)result;
       goto ex;
     }
@@ -2085,10 +2084,10 @@ int pcryptofolder_change_pass(const char *oldpassphrase,
     data = papi_find_result2(bres, "salt", PARAM_STR);
     salt = psync_base64_decode((const unsigned char *)data->str, data->length,
                                &saltlen);
-    psync_free(bres);
+    free(bres);
     if (unlikely(!privkey || !pubkey)) {
-      psync_free(privkey);
-      psync_free(pubkey);
+      free(privkey);
+      free(pubkey);
       cres = PERROR_NO_MEMORY;
       goto ex;
     }
@@ -2096,11 +2095,11 @@ int pcryptofolder_change_pass(const char *oldpassphrase,
     cres = psync_pcloud_crypto_reencode_key(
         pubkey, pubkeylen, privkey, privkeylen, oldpassphrase, newpassphrase,
         flags, privenc, sign);
-    psync_free(pubkey);
+    free(pubkey);
     putil_wipe(privkey, privkeylen);    
-    psync_free(privkey);
+    free(privkey);
     putil_wipe(salt, saltlen);    
-    psync_free(salt);
+    free(salt);
     if (cres)
       goto ex;
   } else {
@@ -2111,8 +2110,8 @@ int pcryptofolder_change_pass(const char *oldpassphrase,
         privkeylen + offsetof(priv_key_ver1, key), oldpassphrase, newpassphrase,
         flags, privenc, sign);
     putil_wipe(privatekey_struct, privkeylen + offsetof(priv_key_ver1, key));    
-    psync_free(privatekey_struct);
-    psync_free(pubkey_struct);
+    free(privatekey_struct);
+    free(pubkey_struct);
     if (cres)
       goto ex;
   }
diff --git a/pclsync/pdeflate.c b/pclsync/pdeflate.c
index e1e61a2..047152b 100644
--- a/pclsync/pdeflate.c
+++ b/pclsync/pdeflate.c
@@ -71,7 +71,7 @@ psync_deflate_t *pdeflate_init(int level) {
   if (likely_log(ret == Z_OK))
     return def;
   else {
-    psync_free(def);
+    free(def);
     return NULL;
   }
 }
@@ -81,8 +81,8 @@ void pdeflate_destroy(psync_deflate_t *def) {
     deflateEnd(&def->stream);
   else
     inflateEnd(&def->stream);
-  psync_free(def->flushbuff);
-  psync_free(def);
+  free(def->flushbuff);
+  free(def);
 }
 
 static int psync_deflate_set_out_buff(psync_deflate_t *def) {
@@ -150,7 +150,7 @@ static int psync_deflate_finish_flush_add_buffer(psync_deflate_t *def,
       if (ret != Z_BUF_ERROR)
         return ret;
       if (used == 0) {
-        psync_free(buff);
+        free(buff);
         return Z_OK;
       }
       def->flushbuff = buff;
@@ -168,7 +168,7 @@ static int psync_deflate_finish_flush_add_buffer(psync_deflate_t *def,
     }
     used += current;
     alloced *= 2;
-    buff = (unsigned char *)psync_realloc(buff, alloced);
+    buff = (unsigned char *)realloc(buff, alloced);
     current = alloced - used;
   }
 }
@@ -212,7 +212,7 @@ int pdeflate_read(psync_deflate_t *def, void *data, int len) {
       memcpy(data, def->flushbuff + def->flushbuffoff, len);
       def->flushbuffoff += len;
       if (def->flushbuffoff == def->flushbufflen) {
-        psync_free(def->flushbuff);
+        free(def->flushbuff);
         def->flushbuff = NULL;
       }
       return len;
diff --git a/pclsync/pdevice.c b/pclsync/pdevice.c
index e071a78..b3d88a9 100644
--- a/pclsync/pdevice.c
+++ b/pclsync/pdevice.c
@@ -59,7 +59,7 @@ char *pdevice_id() {
         path =
             psync_strcat("/sys/class/power_supply/", de->d_name, "/type", NULL);
         fd = open(path, O_RDONLY);
-        psync_free(path);
+        free(path);
         if (fd == -1)
           continue;
         if (read(fd, buf, 7) == 7 && !memcmp(buf, "Battery", 7)) {
diff --git a/pclsync/pdiff.c b/pclsync/pdiff.c
index be3af98..3e9c6d3 100644
--- a/pclsync/pdiff.c
+++ b/pclsync/pdiff.c
@@ -176,7 +176,7 @@ static void psync_notify_cache_change(psync_changetype_t event) {
   if (callback)
     prun_thread1("cache start callback", callback, chtype);
   else
-    psync_free(chtype);
+    free(chtype);
 }
 
 static binresult *get_userinfo_user_digest(psock_t *sock, const char *username,
@@ -220,7 +220,7 @@ static binresult *get_userinfo_user_pass(psock_t *sock, const char *username,
     return res;
 
   if (papi_find_result2(res, "result", PARAM_NUM)->num != 0) {
-    psync_free(res);
+    free(res);
     return NULL;
   }
 
@@ -235,7 +235,7 @@ static binresult *get_userinfo_user_pass(psock_t *sock, const char *username,
     uc[i] = tolower(username[i]);
 
   psync_sha1(uc, ul, sha1bin);
-  psync_free(uc);
+  free(uc);
   psync_binhex(sha1hex, sha1bin, PSYNC_SHA1_DIGEST_LEN);
   psync_sha1_init(&ctx);
   psync_sha1_update(&ctx, password, strlen(password));
@@ -248,7 +248,7 @@ static binresult *get_userinfo_user_pass(psock_t *sock, const char *username,
                                  dig->length, osversion, appversion, deviceid,
                                  devicestring);
 
-  psync_free(res);
+  free(res);
   return ret;
 }
 
@@ -259,10 +259,10 @@ static int check_active_subscribtion(const binresult *res) {
   if (sub) {
     status = psync_strdup(papi_find_result2(sub, "status", PARAM_STR)->str);
     if (!strcmp(status, "active")) {
-      psync_free(status);
+      free(status);
       return 1;
     }
-    psync_free(status);
+    free(status);
   }
 
   return 0;
@@ -284,14 +284,14 @@ static int check_user_relocated(uint64_t luserid, psock_t *sock) {
     debug(D_NOTICE, "getolduserids returned error %lu %s",
           (unsigned long)result,
           papi_find_result2(res, "error", PARAM_STR)->str);
-    psync_free(res);
+    free(res);
     return 0;
   }
 
   userids = papi_find_result2(res, "userids", PARAM_ARRAY);
   cnt = userids->length;
   if (!cnt) {
-    psync_free(res);
+    free(res);
     return 0;
   }
 
@@ -321,7 +321,7 @@ static psock_t *get_connected_socket() {
   int saveauth, isbusiness, cryptosetup, digest, lid, isFirstLogin;
 
   digest = 1;
-  psync_free(psync_my_2fa_token);
+  free(psync_my_2fa_token);
   auth = user = pass = psync_my_2fa_token = NULL;
   psync_is_business = 0;
   deviceid = psync_sql_cellstr("SELECT value FROM setting WHERE id='deviceid'");
@@ -346,9 +346,9 @@ static psock_t *get_connected_socket() {
   devicestring = pdevice_name();
 
   while (1) {
-    psync_free(auth);
-    psync_free(user);
-    psync_free(pass);
+    free(auth);
+    free(user);
+    free(pass);
     pstatus_wait(PSTATUS_TYPE_RUN, PSTATUS_RUN_RUN | PSTATUS_RUN_PAUSE);
 
     auth = psync_sql_cellstr("SELECT value FROM setting WHERE id='auth'");
@@ -449,7 +449,7 @@ static psock_t *get_connected_socket() {
       res = papi_send2(sock, "userinfo", params);
     }
 
-    psync_free(osversion);
+    free(osversion);
 
     if (unlikely_log(!res)) {
       psock_close(sock);
@@ -467,7 +467,7 @@ static psock_t *get_connected_socket() {
             papi_find_result2(res, "error", PARAM_STR)->str);
       // here we only handle statuses that need to access the result
       if (result == 2297) {
-        psync_free(psync_my_2fa_token);
+        free(psync_my_2fa_token);
         psync_my_2fa_token =
             psync_strdup(papi_find_result2(res, "token", PARAM_STR)->str);
         psync_my_2fa_has_devices =
@@ -478,18 +478,18 @@ static psock_t *get_connected_socket() {
         pstatus_set(PSTATUS_TYPE_AUTH, PSTATUS_AUTH_TFAREQ);
         pstatus_wait(PSTATUS_TYPE_AUTH, PSTATUS_AUTH_PROVIDED);
         psock_close(sock);
-        psync_free(res);
+        free(res);
         continue;
       }
 
       if (result == 2306) {
-        psync_free(psync_my_verify_token);
+        free(psync_my_verify_token);
         psync_my_verify_token =
             psync_strdup(papi_find_result2(res, "verifytoken", PARAM_STR)->str);
         pstatus_set(PSTATUS_TYPE_AUTH, PSTATUS_AUTH_VERIFYREQ);
         pstatus_wait(PSTATUS_TYPE_AUTH, PSTATUS_AUTH_PROVIDED);
         psock_close(sock);
-        psync_free(res);
+        free(res);
         continue;
       }
 
@@ -504,7 +504,7 @@ static psock_t *get_connected_socket() {
         }
 
         psock_close(sock);
-        psync_free(res);
+        free(res);
         continue;
       }
 
@@ -513,12 +513,12 @@ static psock_t *get_connected_socket() {
         pstatus_set(PSTATUS_TYPE_AUTH, PSTATUS_AUTH_RELOCATING);
         pstatus_wait(PSTATUS_TYPE_AUTH, PSTATUS_AUTH_PROVIDED);
         psock_close(sock);
-        psync_free(res);
+        free(res);
         continue;
       }
 
       psock_close(sock);
-      psync_free(res);
+      free(res);
 
       if (result == 2000 || result == 2012 || result == 2064 ||
           result == 2074 || result == 2092) {
@@ -537,7 +537,7 @@ static psock_t *get_connected_socket() {
             continue;
           } else {
             pstatus_set(PSTATUS_TYPE_AUTH, PSTATUS_AUTH_BADLOGIN);
-            psync_free(psync_my_pass);
+            free(psync_my_pass);
             psync_my_pass = NULL;
           }
         } else {
@@ -587,7 +587,7 @@ static psock_t *get_connected_socket() {
         }
         psync_sql_rollback_transaction();
         psock_close(sock);
-        psync_free(res);
+        free(res);
         pstatus_wait(PSTATUS_TYPE_AUTH, PSTATUS_AUTH_PROVIDED);
         continue;
       }
@@ -677,7 +677,7 @@ static psock_t *get_connected_socket() {
     if (pstatus_get(PSTATUS_TYPE_AUTH) != PSTATUS_AUTH_PROVIDED) {
       psync_sql_rollback_transaction();
       psock_close(sock);
-      psync_free(res);
+      free(res);
       pstatus_wait(PSTATUS_TYPE_AUTH, PSTATUS_AUTH_PROVIDED);
       continue;
     }
@@ -725,8 +725,8 @@ static psock_t *get_connected_socket() {
           strcmp(privatesha1,
                  papi_find_result2(res, "privatesha1", PARAM_STR)->str))
         psync_delete_cached_crypto_keys();
-      psync_free(privatesha1);
-      psync_free(publicsha1);
+      free(privatesha1);
+      free(publicsha1);
     } else
       psync_delete_cached_crypto_keys();
     psync_sql_bind_string(q, 1, "cryptosubscription");
@@ -750,7 +750,7 @@ static psock_t *get_connected_socket() {
           "UPDATE setting SET value=? WHERE id='pass'");
       psync_sql_bind_string(q, 1, psync_my_pass);
       psync_sql_run_free(q);
-      psync_free(psync_my_pass);
+      free(psync_my_pass);
       psync_my_pass = NULL;
     }
     pthread_mutex_unlock(&psync_my_auth_mutex);
@@ -762,7 +762,7 @@ static psock_t *get_connected_socket() {
                              "binapi", PARAM_ARRAY);
     if (cres->length)
       psync_apipool_set_server(cres->array[0]->str);
-    psync_free(res);
+    free(res);
 
     // If the flag is up, send a first login event to track the number of
     // sucessful installs.
@@ -813,20 +813,20 @@ static psock_t *get_connected_socket() {
         debug(D_WARNING,
               "account_info returned %lu, continuing without business info",
               (unsigned long)result);
-      psync_free(res);
+      free(res);
       psync_sql_sync();
     }
 
-    psync_free(chrUserid);
-    psync_free(auth);
-    psync_free(user);
-    psync_free(pass);
-    psync_free(psync_my_2fa_token);
+    free(chrUserid);
+    free(auth);
+    free(user);
+    free(pass);
+    free(psync_my_2fa_token);
     psync_my_2fa_token = NULL;
     psync_my_2fa_code_type = 0;
     psync_my_2fa_code[0] = 0;
-    psync_free(deviceid);
-    psync_free(devicestring);
+    free(deviceid);
+    free(devicestring);
     psync_sql_sync();
     return sock;
   }
@@ -1205,10 +1205,10 @@ static void process_modifyfolder(const binresult *entry) {
           syncid, psync_get_result_cell(fres2, i, 2), folderid, localfolderid);
       needdownload = 1;
     }
-    psync_free(fres1);
-    psync_free(fres2);
+    free(fres1);
+    free(fres2);
   }
-  psync_free(oldname);
+  free(oldname);
 }
 
 static void process_deletefolder(const binresult *entry) {
@@ -1255,7 +1255,7 @@ static void process_deletefolder(const binresult *entry) {
       if (psync_sql_affected_rows() == 1) {
         path = pfolder_path(folderid, NULL);
         ptask_ldir_rm(row[0], folderid, row[1], path);
-        psync_free(path);
+        free(path);
         needdownload = 1;
       }
     }
@@ -1522,7 +1522,7 @@ static void process_modifyfile(const binresult *entry) {
       pdownload_tasks_delete(fileid, 0, 1);
       path = pfolder_file_path(fileid, NULL);
       ptask_lfile_rm(fileid, path);
-      psync_free(path);
+      free(path);
       needdownload = 1;
       return;
     }
@@ -1591,11 +1591,11 @@ static void process_modifyfile(const binresult *entry) {
                                           fileid, path);
       pdownload_tasks_delete(
           fileid, psync_get_result_cell(fres1, i, 0), 1);
-      psync_free(path);
+      free(path);
       needdownload = 1;
     }
-    psync_free(fres1);
-    psync_free(fres2);
+    free(fres1);
+    free(fres2);
   }
 }
 
@@ -1624,7 +1624,7 @@ static void process_deletefile(const binresult *entry) {
     path = pfolder_file_path(fileid, NULL);
     if (likely(path)) {
       ptask_lfile_rm(fileid, path);
-      psync_free(path);
+      free(path);
       needdownload = 1;
     }
   }
@@ -1858,7 +1858,7 @@ static void send_share_notify(psync_eventtype_t eventid, const binresult *share,
     if ((row = psync_sql_fetch_row(res))) {
       cstr = psync_get_lstring(row[0], &sharenamelen);
       stringslen += ++sharenamelen;
-      sharename = (char *)psync_malloc(sharenamelen);
+      sharename = (char *)malloc(sharenamelen);
       memcpy(sharename, cstr, sharenamelen);
       freesharename = 1;
       ctime = psync_get_number(row[1]);
@@ -1871,14 +1871,14 @@ static void send_share_notify(psync_eventtype_t eventid, const binresult *share,
       return;
     }
   }
-  e = (psync_share_event_t *)psync_malloc(sizeof(psync_share_event_t) +
+  e = (psync_share_event_t *)malloc(sizeof(psync_share_event_t) +
                                           stringslen);
   str = (char *)(e + 1);
   memset(e, 0, sizeof(psync_share_event_t));
   e->folderid = papi_find_result2(share, "folderid", PARAM_NUM)->num;
   fill_str(e->sharename, sharename, sharenamelen);
   if (freesharename)
-    psync_free(sharename);
+    free(sharename);
 
   fill_str(e->message, message, messagelen);
   if ((br = papi_check_result2(share, "userid", PARAM_NUM)))
@@ -1915,7 +1915,7 @@ static void send_share_notify(psync_eventtype_t eventid, const binresult *share,
     }
   }
   if (isba) {
-    notify_paramst *params = psync_malloc(sizeof(notify_paramst));
+    notify_paramst *params = malloc(sizeof(notify_paramst));
     params->eventid = eventid;
     params->event_data = e;
     params->touserid = touserid;
@@ -1938,14 +1938,14 @@ static void do_send_eventdata(void *param) {
 
   get_ba_member_email(data->fromuserid, &email, &emaillen);
   fill_str(data->event_data->fromemail, email, emaillen);
-  psync_free(email);
+  free(email);
 
   if (data->touserid)
     get_ba_member_email(data->touserid, &email, &emaillen);
   else
     get_ba_team_name(data->teamid, &email, &emaillen);
   fill_str(data->event_data->toemail, email, emaillen);
-  psync_free(email);
+  free(email);
 
   if (email) {
     pdiff_lock();
@@ -1953,7 +1953,7 @@ static void do_send_eventdata(void *param) {
     pdiff_unlock();
   }
 
-  psync_free(param);
+  free(param);
 }
 
 static void process_requestsharein(const binresult *entry) {
@@ -2269,7 +2269,7 @@ static void process_establishbshareout(const binresult *entry) {
 
   psync_sql_run_free(q);
   if (email)
-    psync_free(email);
+    free(email);
 }
 
 static void delete_share_request(const binresult *share) {
@@ -2711,7 +2711,7 @@ static void psync_diff_refresh_fs_add_folder(psync_folderid_t folderid) {
         refresh_allocated *= 2;
       else
         refresh_allocated = 8;
-      refresh_folders = (psync_folderid_t *)psync_realloc(
+      refresh_folders = (psync_folderid_t *)realloc(
           refresh_folders, sizeof(psync_folderid_t) * refresh_allocated);
     }
     refresh_folders[refresh_last++] = folderid;
@@ -2732,8 +2732,8 @@ static void psync_diff_refresh_thread(void *ptr) {
       psync_fs_refresh_folder(fr->refresh_folders[i]);
       lastfolderid = fr->refresh_folders[i];
     }
-  psync_free(fr->refresh_folders);
-  psync_free(fr);
+  free(fr->refresh_folders);
+  free(fr);
 }
 
 static void psync_diff_refresh_fs(const binresult *entries) {
@@ -2805,13 +2805,13 @@ static void psync_run_analyze_if_needed() {
       --tablecnt;
       debug(D_NOTICE, "running ANALYZE on %s", tablenames[tablecnt]);
       sql = psync_strcat("ANALYZE ", tablenames[tablecnt], ";", NULL);
-      psync_free(tablenames[tablecnt]);
+      free(tablenames[tablecnt]);
       psync_sql_statement(sql);
-      psync_free(sql);
+      free(sql);
       debug(D_NOTICE, "table done");
       psys_sleep_milliseconds(5);
     }
-    psync_free(tablenames);
+    free(tablenames);
     res = psync_sql_prep_statement(
         "REPLACE INTO setting (id, value) VALUES (?, ?)");
     psync_sql_bind_string(res, 1, "lastanalyze");
@@ -2850,7 +2850,7 @@ static int psync_diff_check_quota(psock_t *sock) {
                          "binapi", PARAM_ARRAY);
   if (uq->length)
     psync_apipool_set_server(uq->array[0]->str);
-  psync_free(res);
+  free(res);
   return 0;
 }
 
@@ -2862,7 +2862,7 @@ static void psync_diff_adapter_hash(void *out) {
   pcrc32c_fast_hash256_update(&ctx, list->interfaces,
                             list->interfacecnt * sizeof(psock_iface_t));
   pcrc32c_fast_hash256_final(out, &ctx);
-  psync_free(list);
+  free(list);
 }
 
 static void psync_diff_adapter_timer(psync_timer_t timer, void *ptr) {
@@ -2940,7 +2940,7 @@ restart:
     }
     result = entries->length;
     if (should_free_res) {
-      psync_free(res);
+      free(res);
       should_free_res = 0;
       res = NULL;
     }
@@ -3086,7 +3086,7 @@ restart:
     }
 
     if (should_free_res) {
-      psync_free(res);
+      free(res);
       should_free_res = 0;
       res = NULL;
     }
@@ -3094,7 +3094,7 @@ restart:
 
 cleanup:
   if (should_free_res && res) {
-    psync_free(res);
+    free(res);
   }
   psock_close(sock);
   close(exceptionsock);
diff --git a/pclsync/pdownload.c b/pclsync/pdownload.c
index 9dc6f22..8b916ee 100644
--- a/pclsync/pdownload.c
+++ b/pclsync/pdownload.c
@@ -160,8 +160,8 @@ static void do_move(void *ptr, ppath_stat *st) {
   oldpath = psync_strcat(arr[0], st->name, NULL);
   newpath = psync_strcat(arr[1], st->name, NULL);
   pfile_rename(oldpath, newpath);
-  psync_free(newpath);
-  psync_free(oldpath);
+  free(newpath);
+  free(oldpath);
 }
 
 static int move_folder_contents(const char *oldpath, const char *newpath) {
@@ -241,7 +241,7 @@ static int call_func_for_folder(psync_folderid_t localfolderid,
       psyncer_folder_dec_tasks(localfolderid);
       debug(D_NOTICE, "%s %s", debug, localpath);
     }
-    psync_free(localpath);
+    free(localpath);
   } else {
     debug(D_ERROR, "could not get path for local folder id %lu, syncid %u",
           (long unsigned)localfolderid, (unsigned)syncid);
@@ -268,7 +268,7 @@ static int call_func_for_folder_name(psync_folderid_t localfolderid,
       psyncer_folder_dec_tasks(localfolderid);
       debug(D_NOTICE, "%s %s", debug, localpath);
     }
-    psync_free(localpath);
+    free(localpath);
   } else {
     debug(D_ERROR, "could not get path for local folder id %lu, syncid %u",
           (long unsigned)localfolderid, (unsigned)syncid);
@@ -374,7 +374,7 @@ static int task_renamefolder(psync_syncid_t newsyncid,
   newpath = pfolder_lpath_lfldr(localfolderid, newsyncid, NULL);
   if (unlikely(!newpath)) {
     psync_sql_rollback_transaction();
-    psync_free(oldpath);
+    free(oldpath);
     debug(D_ERROR, "could not get local path for folder id %lu",
           (unsigned long)localfolderid);
     return 0;
@@ -389,8 +389,8 @@ static int task_renamefolder(psync_syncid_t newsyncid,
                            folderid);
     debug(D_NOTICE, "local folder renamed from %s to %s", oldpath, newpath);
   }
-  psync_free(newpath);
-  psync_free(oldpath);
+  free(newpath);
+  free(oldpath);
   return ret;
 }
 
@@ -666,7 +666,7 @@ static int task_download_file(download_task_t *dt) {
         debug(D_NOTICE, "file %s copied from %s", dt->localname, tmpold);
     } else
       debug(D_WARNING, "failed to copy %s from %s", dt->localname, tmpold);
-    psync_free(tmpold);
+    free(tmpold);
     tmpold = NULL;
     if (likely_log(rt == PSYNC_NET_OK))
       return 0;
@@ -700,10 +700,10 @@ static int task_download_file(download_task_t *dt) {
     debug(D_WARNING, "got error %lu from getfilelink", (long unsigned)result);
     psync_process_api_error(result);
     if (psync_handle_api_result(result) == PSYNC_NET_TEMPFAIL) {
-      psync_free(res);
+      free(res);
       return -1;
     } else {
-      psync_free(res);
+      free(res);
       return 0;
     }
   }
@@ -718,7 +718,7 @@ static int task_download_file(download_task_t *dt) {
           psync_strcat(dt->localpath, "/", dt->filename,
                        "-old", PSYNC_APPEND_PARTIAL_FILES, NULL);
       if (pfile_rename_overwrite(dt->tmpname, tmpold)) {
-        psync_free(tmpold);
+        free(tmpold);
         tmpold = NULL;
       } else
         oldfiles[oldcnt++] = tmpold;
@@ -740,7 +740,7 @@ static int task_download_file(download_task_t *dt) {
   requestpath = papi_find_result2(res, "path", PARAM_STR)->str;
   psync_slprintf(cookie, sizeof(cookie), "Cookie: dwltag=%s\015\012",
                  papi_find_result2(res, "dwltag", PARAM_STR)->str);
-  buff = psync_malloc(PSYNC_COPY_BUFFER_SIZE);
+  buff = malloc(PSYNC_COPY_BUFFER_SIZE);
   http = NULL;
   psync_hash_init(&hashctx);
   psync_list_for_each_element(range, &ranges, psync_range_list_t, list) {
@@ -835,7 +835,7 @@ static int task_download_file(download_task_t *dt) {
   }
   if (unlikely_log(pfile_sync(fd)))
     goto err2;
-  psync_free(buff);
+  free(buff);
   psync_hash_final(localhashbin, &hashctx);
   if (unlikely_log(pfile_close(fd)))
     goto err0;
@@ -859,29 +859,27 @@ static int task_download_file(download_task_t *dt) {
   //  pqevent_queue_sync_event_id(PEVENT_FILE_DOWNLOAD_FINISHED, syncid, name,
   //  fileid);
   debug(D_NOTICE, "file downloaded %s", dt->localname);
-  psync_list_for_each_element_call(&ranges, psync_range_list_t, list,
-                                   psync_free);
+  psync_list_for_each_element_call(&ranges, psync_range_list_t, list, free);
   if (tmpold) {
     pfile_delete(tmpold);
-    psync_free(tmpold);
+    free(tmpold);
   }
-  psync_free(res);
+  free(res);
   return 0;
 err2:
   psync_hash_final(localhashbin, &hashctx); /* just in case */
-  psync_free(buff);
+  free(buff);
   if (http)
     psync_http_close(http);
 err1:
   pfile_close(fd);
 err0:
-  psync_list_for_each_element_call(&ranges, psync_range_list_t, list,
-                                   psync_free);
+  psync_list_for_each_element_call(&ranges, psync_range_list_t, list, free);
   if (tmpold) {
     pfile_delete(tmpold);
-    psync_free(tmpold);
+    free(tmpold);
   }
-  psync_free(res);
+  free(res);
   return -1;
 }
 
@@ -909,7 +907,7 @@ static int task_delete_file(psync_syncid_t syncid, psync_fileid_t fileid,
               (int)errno);
         if (errno == EBUSY || errno == EROFS) {
           ret = -1;
-          psync_free(name);
+          free(name);
           continue;
         }
       } else
@@ -918,7 +916,7 @@ static int task_delete_file(psync_syncid_t syncid, psync_fileid_t fileid,
       //      events are not fully implemented anyway
       //      pqevent_queue_sync_event_path(PEVENT_LOCAL_FILE_DELETED, row[1], name,
       //      fileid, remotepath);
-      psync_free(name);
+      free(name);
     }
     stmt = psync_sql_prep_statement("DELETE FROM localfile WHERE id=?");
     psync_sql_bind_uint(stmt, 1, row[0]);
@@ -971,7 +969,7 @@ static int task_rename_file(psync_syncid_t oldsyncid, psync_syncid_t newsyncid,
     return 0;
   oldpath = pfolder_lpath_lfile(lfileid, NULL);
   if (unlikely_log(!oldpath)) {
-    psync_free(newfolder);
+    free(newfolder);
     return 0;
   }
   newpath = psync_strcat(newfolder, "/", newname, NULL);
@@ -1002,9 +1000,9 @@ static int task_rename_file(psync_syncid_t oldsyncid, psync_syncid_t newsyncid,
     }
     psync_resume_localscan();
   }
-  psync_free(newpath);
-  psync_free(oldpath);
-  psync_free(newfolder);
+  free(newpath);
+  free(oldpath);
+  free(newfolder);
   return ret;
 }
 
@@ -1037,10 +1035,10 @@ static void free_download_task(download_task_t *dt) {
   }
   if (dt->lock)
     psync_unlock_file(dt->lock);
-  psync_free(dt->localpath);
-  psync_free(dt->localname);
-  psync_free(dt->tmpname);
-  psync_free(dt);
+  free(dt->localpath);
+  free(dt->localname);
+  free(dt->tmpname);
+  free(dt);
 }
 
 static void free_task_timer_thread(void *ptr) {
@@ -1201,7 +1199,7 @@ static int task_run_download_file(uint64_t taskid, psync_syncid_t syncid,
   tmpname = psync_strcat(localpath, "/", filename,
                          PSYNC_APPEND_PARTIAL_FILES, NULL);
   len = strlen(filename);
-  dt = (download_task_t *)psync_malloc(offsetof(download_task_t, filename) +
+  dt = (download_task_t *)malloc(offsetof(download_task_t, filename) +
                                        len + 1);
   memset(dt, 0, offsetof(download_task_t, filename));
   dt->taskid = taskid;
@@ -1340,7 +1338,7 @@ static void task_del_folder_rec_do(const char *localpath,
                       psync_get_string(vrow[1]), NULL);
     debug(D_NOTICE, "deleting %s", nm);
     pfile_delete(nm);
-    psync_free(nm);
+    free(nm);
   }
   psync_sql_free_result(res);
   res = psync_sql_prep_statement(
@@ -1356,7 +1354,7 @@ static void task_del_folder_rec_do(const char *localpath,
     nm = psync_strcat(localpath, "/",
                       psync_get_string(vrow[1]), NULL);
     task_del_folder_rec_do(nm, psync_get_number(vrow[0]), syncid);
-    psync_free(nm);
+    free(nm);
   }
   psync_sql_free_result(res);
   res = psync_sql_prep_statement(
@@ -1466,7 +1464,7 @@ static int download_task(uint64_t taskid, uint32_t type, psync_syncid_t syncid,
     debug(D_WARNING, "task of type %u, syncid %u, id %lu localid %lu failed",
           (unsigned)type, (unsigned)syncid, (unsigned long)itemid,
           (unsigned long)localitemid);
-  psync_free(vname);
+  free(vname);
   return res;
 }
 
@@ -1498,7 +1496,7 @@ static void download_thread() {
         }
       } else if (type != PSYNC_DOWNLOAD_FILE)
         psys_sleep_milliseconds(PSYNC_SLEEP_ON_FAILED_DOWNLOAD);
-      psync_free(row);
+      free(row);
       continue;
     }
 
@@ -1593,7 +1591,7 @@ download_hashes_t *pdownload_get_hashes() {
   cnt = 0;
   pthread_mutex_lock(&current_downloads_mutex);
   psync_list_for_each_element(dwl, &downloads, download_list_t, list) cnt++;
-  ret = (download_hashes_t *)psync_malloc(
+  ret = (download_hashes_t *)malloc(
       offsetof(download_hashes_t, hashes) +
       sizeof(psync_hex_hash) * cnt);
   cnt = 0;
diff --git a/pclsync/pfile.c b/pclsync/pfile.c
index 4d90cb7..66d9f05 100644
--- a/pclsync/pfile.c
+++ b/pclsync/pfile.c
@@ -266,7 +266,7 @@ static void psync_file_preread_thread(void *ptr) {
     pr->count -= rd;
   }
   pfile_close(pr->fd);
-  psync_free(pr);
+  free(pr);
 }
 
 int pfile_preread(int fd, uint64_t offset, size_t count) {
@@ -415,7 +415,7 @@ int pfile_run_update(const char *path) {
     ex = psync_strcat(PSYNC_RUN_CMD " \"", path, "\"", NULL);
     execl("/bin/sh", "/bin/sh", "-c", ex, NULL);
     debug(D_ERROR, "exec of %s failed", ex);
-    psync_free(ex);
+    free(ex);
     exit(1);
   }
 }
diff --git a/pclsync/pfolder.c b/pclsync/pfolder.c
index 15f6cdb..c63adc7 100644
--- a/pclsync/pfolder.c
+++ b/pclsync/pfolder.c
@@ -195,9 +195,9 @@ psync_folderid_t pfolder_id_create(const char *path) {
                 ->num;
         if (papi_find_result2(bres, "created", PARAM_BOOL)->num)
           pdiff_wake();
-        psync_free(bres);
+        free(bres);
       } else {
-        psync_free(bres);
+        free(bres);
         psync_process_api_error(result);
         if (psync_handle_api_result(result) == PSYNC_NET_TEMPFAIL)
           goto errnet;
@@ -220,12 +220,12 @@ errnet:
 }
 
 static void psync_free_string_list(psync_list *lst) {
-  psync_list_for_each_element_call(lst, string_list, list, psync_free);
+  psync_list_for_each_element_call(lst, string_list, list, free);
 }
 
 static string_list *str_to_list_element(const char *str, size_t len) {
   string_list *le;
-  le = (string_list *)psync_malloc(sizeof(string_list) + len + 1);
+  le = (string_list *)malloc(sizeof(string_list) + len + 1);
   le->str = (char *)(le + 1);
   le->len = len;
   memcpy(le->str, str, len + 1);
@@ -240,7 +240,7 @@ static int psync_add_path_to_list(psync_list *lst, psync_folderid_t folderid) {
   size_t len;
   while (1) {
     if (folderid == 0) {
-      e = (string_list *)psync_malloc(sizeof(string_list));
+      e = (string_list *)malloc(sizeof(string_list));
       e->str = (char *)e;
       e->len = 0;
       psync_list_add_head(lst, &e->list);
@@ -268,18 +268,18 @@ static string_list *str_list_decode(psync_folderid_t folderid, string_list *e) {
   char *fn;
   dec = pcryptofolder_flddecoder_get(folderid);
   if (psync_crypto_is_error(dec)) {
-    psync_free(e);
+    free(e);
     debug(D_WARNING, "got error %d getting decoder for folderid %lu",
           psync_crypto_to_error(dec), (unsigned long)folderid);
     return NULL;
   }
   fn = pcryptofolder_flddecode_filename(dec, e->str);
   pcryptofolder_flddecoder_release(folderid, dec);
-  psync_free(e);
+  free(e);
   if (unlikely_log(!fn))
     return NULL;
   e = str_to_list_element(fn, strlen(fn));
-  psync_free(fn);
+  free(fn);
   return e;
 }
 
@@ -297,7 +297,7 @@ static int psync_add_path_to_list_decode(psync_list *lst,
     if (folderid == 0) {
       if (e)
         psync_list_add_head(lst, &e->list);
-      e = (string_list *)psync_malloc(sizeof(string_list));
+      e = (string_list *)malloc(sizeof(string_list));
       e->str = (char *)e;
       e->len = 0;
       psync_list_add_head(lst, &e->list);
@@ -343,7 +343,7 @@ char *psync_join_string_list(const char *sep, psync_list *lst, size_t *retlen) {
   if (unlikely(!cnt))
     return psync_strdup("");
   seplen = strlen(sep);
-  ret = str = psync_malloc(slen + cnt * seplen + 1);
+  ret = str = malloc(slen + cnt * seplen + 1);
   psync_list_for_each_element(e, lst, string_list, list) {
     memcpy(str, e->str, e->len);
     str += e->len;
@@ -372,7 +372,7 @@ char *pfolder_path(psync_folderid_t folderid, size_t *retlen) {
   ret = psync_join_string_list("/", &folderlist, retlen);
   psync_free_string_list(&folderlist);
   if (!ret[0]) {
-    psync_free(ret);
+    free(ret);
     ret = psync_strdup("/");
     if (retlen)
       *retlen = 1;
@@ -394,7 +394,7 @@ char *pfolder_path_sep(psync_folderid_t folderid, const char *sep,
   ret = psync_join_string_list(sep, &folderlist, retlen);
   psync_free_string_list(&folderlist);
   if (!ret[0]) {
-    psync_free(ret);
+    free(ret);
     ret = psync_strdup(sep);
     if (retlen)
       *retlen = 1;
@@ -542,10 +542,10 @@ char *pfolder_lpath_lfile(psync_fileid_t localfileid,
 
 static folder_list *folder_list_init() {
   folder_list *list;
-  list = (folder_list *)psync_malloc(sizeof(folder_list));
+  list = (folder_list *)malloc(sizeof(folder_list));
   list->entries =
-      (pentry_t *)psync_malloc(sizeof(pentry_t) * INITIAL_ENTRY_CNT);
-  list->namebuff = (char *)psync_malloc(INITIAL_NAME_BUFF);
+      (pentry_t *)malloc(sizeof(pentry_t) * INITIAL_ENTRY_CNT);
+  list->namebuff = (char *)malloc(INITIAL_NAME_BUFF);
   list->nameoff = 0;
   list->namealloc = INITIAL_NAME_BUFF;
   list->entriescnt = 0;
@@ -556,12 +556,12 @@ static folder_list *folder_list_init() {
 static void folder_list_add(folder_list *list, pentry_t *entry) {
   if (list->entriescnt >= list->entriesalloc) {
     list->entriesalloc *= 2;
-    list->entries = (pentry_t *)psync_realloc(
+    list->entries = (pentry_t *)realloc(
         list->entries, sizeof(pentry_t) * list->entriesalloc);
   }
   while (list->nameoff + entry->namelen >= list->namealloc) {
     list->namealloc *= 2;
-    list->namebuff = (char *)psync_realloc(list->namebuff, list->namealloc);
+    list->namebuff = (char *)realloc(list->namebuff, list->namealloc);
   }
   memcpy(&list->entries[list->entriescnt++], entry, sizeof(pentry_t));
   memcpy(list->namebuff + list->nameoff, entry->name, entry->namelen);
@@ -570,9 +570,9 @@ static void folder_list_add(folder_list *list, pentry_t *entry) {
 }
 
 static void folder_list_free(folder_list *list) {
-  psync_free(list->entries);
-  psync_free(list->namebuff);
-  psync_free(list);
+  free(list->entries);
+  free(list->namebuff);
+  free(list);
 }
 
 static pfolder_list_t *folder_list_finalize(folder_list *list) {
@@ -583,7 +583,7 @@ static pfolder_list_t *folder_list_finalize(folder_list *list) {
         (unsigned)(offsetof(pfolder_list_t, entries) +
                    sizeof(pentry_t) * list->entriescnt + list->nameoff),
         (unsigned)list->nameoff);
-  ret = (pfolder_list_t *)psync_malloc(offsetof(pfolder_list_t, entries) +
+  ret = (pfolder_list_t *)malloc(offsetof(pfolder_list_t, entries) +
                                        sizeof(pentry_t) * list->entriescnt +
                                        list->nameoff);
   name = ((char *)ret) + offsetof(pfolder_list_t, entries) +
@@ -748,7 +748,7 @@ pentry_t *pfolder_stat(const char *remotepath) {
     memcpy(cremotepath, remotepath, len + 1);
     cremotepath[len] = 0;
     folderid = pfolder_id(cremotepath);
-    psync_free(cremotepath);
+    free(cremotepath);
     if (folderid == PSYNC_INVALID_FOLDERID)
       return NULL;
   }
@@ -759,7 +759,7 @@ pentry_t *pfolder_stat(const char *remotepath) {
   psync_sql_bind_uint(res, 1, folderid);
   psync_sql_bind_lstring(res, 2, remotepath + len, olen);
   if ((row = psync_sql_fetch_rowint(res))) {
-    ret = (pentry_t *)psync_malloc(sizeof(pentry_t) + olen + 1);
+    ret = (pentry_t *)malloc(sizeof(pentry_t) + olen + 1);
     ret->folder.folderid = row[0];
     ret->folder.cansyncup = ((row[1] & PSYNC_PERM_WRITE) == PSYNC_PERM_WRITE);
     ret->folder.cansyncdown = ((row[1] & PSYNC_PERM_READ) == PSYNC_PERM_READ);
@@ -778,7 +778,7 @@ pentry_t *pfolder_stat(const char *remotepath) {
   psync_sql_bind_uint(res, 1, folderid);
   psync_sql_bind_lstring(res, 2, remotepath + len, olen);
   if ((row = psync_sql_fetch_rowint(res))) {
-    ret = (pentry_t *)psync_malloc(sizeof(pentry_t) + olen + 1);
+    ret = (pentry_t *)malloc(sizeof(pentry_t) + olen + 1);
     ret->file.fileid = row[0];
     ret->file.size = row[1];
     ret->name = (char *)(ret + 1);
@@ -835,12 +835,12 @@ psync_folder_list_t *pfolder_sync_folders(char *syncTypes) {
   while ((row = psync_sql_fetch_row(res))) {
     if (alloced == lastfolder) {
       alloced = (alloced + 32) * 2;
-      folders = (psync_tmp_folder_t *)psync_realloc(
+      folders = (psync_tmp_folder_t *)realloc(
           folders, sizeof(psync_tmp_folder_t) * alloced);
     }
     cstr = psync_get_lstring(row[2], &l);
     l++;
-    str = (char *)psync_malloc(l);
+    str = (char *)malloc(l);
     memcpy(str, cstr, l);
 
     strlens += l;
@@ -864,14 +864,14 @@ psync_folder_list_t *pfolder_sync_folders(char *syncTypes) {
   psync_sql_free_result(res);
   l = offsetof(psync_folder_list_t, folders) +
       sizeof(psync_folder_t) * lastfolder;
-  ret = (psync_folder_list_t *)psync_malloc(l + strlens);
+  ret = (psync_folder_list_t *)malloc(l + strlens);
   str = ((char *)ret) + l;
   ret->foldercnt = lastfolder;
 
   for (i = 0; i < lastfolder; i++) {
     l = folders[i].locallen;
     memcpy(str, folders[i].localpath, l);
-    psync_free(folders[i].localpath);
+    free(folders[i].localpath);
     strncpy(ret->folders[i].localpath, str,
             sizeof(ret->folders[i].localpath) - 1);
     ret->folders[i].localpath[sizeof(ret->folders[i].localpath) - 1] = '\0';
@@ -891,7 +891,7 @@ psync_folder_list_t *pfolder_sync_folders(char *syncTypes) {
 
     l = folders[i].remotelen;
     memcpy(str, folders[i].remotepath, l);
-    psync_free(folders[i].remotepath);
+    free(folders[i].remotepath);
     strncpy(ret->folders[i].remotepath, str,
             sizeof(ret->folders[i].remotepath) - 1);
     ret->folders[i].remotepath[sizeof(ret->folders[i].remotepath) - 1] = '\0';
@@ -914,7 +914,7 @@ psync_folder_list_t *pfolder_sync_folders(char *syncTypes) {
     ret->folders[i].synctype = folders[i].synctype;
   }
 
-  psync_free(folders);
+  free(folders);
 
   return ret;
 }
diff --git a/pclsync/pfs.c b/pclsync/pfs.c
index aab1749..9952690 100644
--- a/pclsync/pfs.c
+++ b/pclsync/pfs.c
@@ -146,12 +146,12 @@ static void delete_log_files(psync_openfile_t *of) {
   filename =
       psync_strcat(cachepath, "/", fileidhex, NULL);
   pfile_delete(filename);
-  psync_free(filename);
+  free(filename);
   fileidhex[sizeof(psync_fsfileid_t)] = 'f';
   filename =
       psync_strcat(cachepath, "/", fileidhex, NULL);
   pfile_delete(filename);
-  psync_free(filename);
+  free(filename);
 }
 
 int psync_fs_update_openfile(uint64_t taskid, uint64_t writeid,
@@ -315,7 +315,7 @@ int psync_fs_rename_openfile_locked(psync_fsfileid_t fileid,
         fl->currentfolder =
             psync_fstask_get_or_create_folder_tasks_locked(folderid);
       }
-      psync_free(fl->currentname);
+      free(fl->currentname);
       fl->currentname = psync_strdup(name);
       pthread_mutex_unlock(&fl->mutex);
       return 1;
@@ -627,7 +627,7 @@ static int psync_creat_local_to_file_stat(psync_fstask_creat_t *cr,
     stret = stat(filename, &st);
     if (stret)
       debug(D_NOTICE, "could not stat file %s", filename);
-    psync_free(filename);
+    free(filename);
   }
   if (stret)
     return -1;
@@ -636,7 +636,7 @@ static int psync_creat_local_to_file_stat(psync_fstask_creat_t *cr,
     else{
       fileidhex[sizeof(psync_fsfileid_t)]='i';
       filename=psync_strcat(cachepath, "/", fileidhex,
-    NULL); fd=pfile_open(filename, O_RDONLY, 0); psync_free(filename); if
+    NULL); fd=pfile_open(filename, O_RDONLY, 0); free(filename); if
     (fd==INVALID_HANDLE_VALUE) return -EIO; stret=pfile_pread(fd, &osize,
     sizeof(osize), offsetof(index_header, copyfromoriginal));
       pfile_close(fd);
@@ -794,12 +794,12 @@ static int psync_fs_getattr(const char *path, struct FUSE_STAT *stbuf) {
     if (mk) {
       if (mk->flags & PSYNC_FOLDER_FLAG_INVISIBLE) {
         psync_sql_rdunlock();
-        psync_free(fpath);
+        free(fpath);
         return -ENOENT;
       }
       psync_mkdir_to_folder_stat(mk, stbuf);
       psync_sql_rdunlock();
-      psync_free(fpath);
+      free(fpath);
       return 0;
     }
   }
@@ -814,7 +814,7 @@ static int psync_fs_getattr(const char *path, struct FUSE_STAT *stbuf) {
     psync_sql_free_result(res);
     if (row) {
       psync_sql_rdunlock();
-      psync_free(fpath);
+      free(fpath);
       return 0;
     }
   }
@@ -835,7 +835,7 @@ static int psync_fs_getattr(const char *path, struct FUSE_STAT *stbuf) {
   } else
     crr = -1;
   psync_sql_rdunlock();
-  psync_free(fpath);
+  free(fpath);
   if (row || !crr)
     return 0;
   debug(D_NOTICE, "returning ENOENT for %s", path);
@@ -852,7 +852,7 @@ static int filler_decoded(pcrypto_textdec_t dec,
     if (!namedec)
       return 0;
     ret = filler(buf, namedec, st, off);
-    psync_free(namedec);
+    free(namedec);
     return ret;
   } else
     return filler(buf, name, st, off);
@@ -1017,7 +1017,7 @@ psync_fs_create_file(psync_fsfileid_t fileid, psync_fsfileid_t remotefileid,
     }
   }
   if (encoder == PSYNC_CRYPTO_INVALID_ENCODER) {
-    fl = (psync_openfile_t *)psync_malloc(offsetof(psync_openfile_t, encoder));
+    fl = (psync_openfile_t *)malloc(offsetof(psync_openfile_t, encoder));
     memset(fl, 0, offsetof(psync_openfile_t, encoder));
   } else {
     fl = psync_new(psync_openfile_t);
@@ -1146,7 +1146,7 @@ static int open_write_files(psync_openfile_t *of, int trunc) {
         psync_strcat(cachepath, "/", fileidhex, NULL);
     of->datafile = pfile_open(filename, O_RDWR,
                                    O_CREAT | (trunc ? O_TRUNC : 0));
-    psync_free(filename);
+    free(filename);
     if (of->datafile == INVALID_HANDLE_VALUE) {
       debug(D_ERROR, "could not open cache file for fileid %ld",
             (long)of->fileid);
@@ -1172,7 +1172,7 @@ static int open_write_files(psync_openfile_t *of, int trunc) {
         psync_strcat(cachepath, "/", fileidhex, NULL);
     of->indexfile = pfile_open(filename, O_RDWR,
                                     O_CREAT | (trunc ? O_TRUNC : 0));
-    psync_free(filename);
+    free(filename);
     if (of->indexfile == INVALID_HANDLE_VALUE) {
       debug(D_ERROR, "could not open cache index file for fileid %ld",
             (long)of->fileid);
@@ -1191,7 +1191,7 @@ static int open_write_files(psync_openfile_t *of, int trunc) {
       filename =
           psync_strcat(cachepath, "/", fileidhex, NULL);
       of->logfile = pfile_open(filename, O_RDWR, O_CREAT | O_TRUNC);
-      psync_free(filename);
+      free(filename);
       if (of->logfile == INVALID_HANDLE_VALUE) {
         debug(D_ERROR, "could not open log file for fileid %ld",
               (long)of->fileid);
@@ -1229,13 +1229,13 @@ static void psync_fs_del_creat(psync_fspath_t *fpath, psync_openfile_t *of) {
     if (likely((cr = psync_fstask_find_creat(folder, fpath->name, 0)))) {
       ptree_del(&folder->creats, &cr->tree);
       folder->taskscnt--;
-      psync_free(cr);
+      free(cr);
     }
     psync_fstask_release_folder_tasks_locked(folder);
   }
   psync_fs_dec_of_refcnt(of);
   psync_sql_unlock();
-  psync_free(fpath);
+  free(fpath);
 }
 
 static int psync_fs_open(const char *path, struct fuse_file_info *fi) {
@@ -1272,14 +1272,14 @@ static int psync_fs_open(const char *path, struct fuse_file_info *fi) {
   if ((fi->flags & 3) != O_RDONLY &&
       !(fpath->permissions & PSYNC_PERM_MODIFY)) {
     psync_sql_unlock();
-    psync_free(fpath);
+    free(fpath);
     return -EACCES;
   }
   // even if there are existing files there, just don't allow opening those
   if (fpath->flags & (PSYNC_FOLDER_FLAG_BACKUP_DEVICE_LIST |
                       PSYNC_FOLDER_FLAG_BACKUP_DEVICE)) {
     psync_sql_unlock();
-    psync_free(fpath);
+    free(fpath);
     return -EACCES;
   }
   folder = psync_fstask_get_or_create_folder_tasks_locked(fpath->folderid);
@@ -1338,7 +1338,7 @@ static int psync_fs_open(const char *path, struct fuse_file_info *fi) {
         psync_fstask_release_folder_tasks_locked(folder);
         psync_sql_unlock();
         debug(D_NOTICE, "opening new file %ld %s", (long)fileid, fpath->name);
-        psync_free(fpath);
+        free(fpath);
         of->newfile = 1;
         of->releasedforupload = status != 1;
         ret = open_write_files(of, fi->flags & O_TRUNC);
@@ -1391,7 +1391,7 @@ static int psync_fs_open(const char *path, struct fuse_file_info *fi) {
                                 fpath->name, encoder);
       psync_fstask_release_folder_tasks_locked(folder);
       psync_sql_unlock();
-      psync_free(fpath);
+      free(fpath);
       of->newfile = 0;
       of->releasedforupload = status != 1;
       ret = open_write_files(of, fi->flags & O_TRUNC);
@@ -1412,7 +1412,7 @@ static int psync_fs_open(const char *path, struct fuse_file_info *fi) {
                                 fpath->name, PSYNC_CRYPTO_INVALID_ENCODER);
       psync_fstask_release_folder_tasks_locked(folder);
       psync_sql_unlock();
-      psync_free(fpath);
+      free(fpath);
       of->modified = 1;
       of->staticfile = 1;
       of->staticdata = (const char *)lc->data;
@@ -1470,7 +1470,7 @@ static int psync_fs_open(const char *path, struct fuse_file_info *fi) {
         encoder = pcrypto_sec_encdec_create(symkey);
         psymkey_free(symkey);
         if (unlikely_log(encoder == PSYNC_CRYPTO_INVALID_ENCODER)) {
-          psync_free(encsymkey);
+          free(encsymkey);
           ret = -ENOMEM;
           goto ex0;
         }
@@ -1482,7 +1482,7 @@ static int psync_fs_open(const char *path, struct fuse_file_info *fi) {
     }
     cr =
         psync_fstask_add_creat(folder, fpath->name, 0, encsymkey, encsymkeylen);
-    psync_free(encsymkey);
+    free(encsymkey);
     if (unlikely_log(!cr)) {
       ret = -EIO;
       goto ex0;
@@ -1500,7 +1500,7 @@ static int psync_fs_open(const char *path, struct fuse_file_info *fi) {
       psync_fs_del_creat(fpath, of);
       return ret;
     }
-    psync_free(fpath);
+    free(fpath);
     fi->fh = openfile_to_fh(of);
     return 0;
   } else if (row) {
@@ -1523,7 +1523,7 @@ static int psync_fs_open(const char *path, struct fuse_file_info *fi) {
 ex0:
   psync_fstask_release_folder_tasks_locked(folder);
   psync_sql_unlock();
-  psync_free(fpath);
+  free(fpath);
   return ret;
 }
 
@@ -1557,7 +1557,7 @@ static int psync_fs_creat_fake_locked(psync_fspath_t *fpath,
   size_t len;
   fileid = psync_fake_fileid++;
   len = strlen(fpath->name) + 1;
-  cr = (psync_fstask_creat_t *)psync_malloc(
+  cr = (psync_fstask_creat_t *)malloc(
       offsetof(psync_fstask_creat_t, name) + len);
   cr->fileid = fileid;
   cr->rfileid = 0;
@@ -1572,7 +1572,7 @@ static int psync_fs_creat_fake_locked(psync_fspath_t *fpath,
   of->newfile = 0;
   of->modified = 0;
   psync_sql_unlock();
-  psync_free(fpath);
+  free(fpath);
   fi->fh = openfile_to_fh(of);
   return 0;
 }
@@ -1611,7 +1611,7 @@ static int psync_fs_creat(const char *path, mode_t mode,
       (fpath->flags & (PSYNC_FOLDER_FLAG_BACKUP_DEVICE_LIST |
                        PSYNC_FOLDER_FLAG_BACKUP_DEVICE))) {
     psync_sql_unlock();
-    psync_free(fpath);
+    free(fpath);
     return -EACCES;
   }
   folder = psync_fstask_get_or_create_folder_tasks_locked(fpath->folderid);
@@ -1620,14 +1620,14 @@ static int psync_fs_creat(const char *path, mode_t mode,
     debug(D_NOTICE, "file %s already exists, processing as open", path);
     ret = psync_fs_open(path, fi);
     psync_sql_unlock();
-    psync_free(fpath);
+    free(fpath);
     return ret;
   }
   if (fpath->flags & PSYNC_FOLDER_FLAG_ENCRYPTED) {
     if (psync_crypto_isexpired()) {
       psync_fstask_release_folder_tasks_locked(folder);
       psync_sql_unlock();
-      psync_free(fpath);
+      free(fpath);
       return -PRINT_RETURN_CONST(PSYNC_FS_ERR_CRYPTO_EXPIRED);
     }
     encsymkey = pcryptofolder_filencoder_key_newplain(
@@ -1635,7 +1635,7 @@ static int psync_fs_creat(const char *path, mode_t mode,
     if (unlikely_log(psync_crypto_is_error(encsymkey))) {
       psync_fstask_release_folder_tasks_locked(folder);
       psync_sql_unlock();
-      psync_free(fpath);
+      free(fpath);
       return -psync_fs_crypto_err_to_errno(psync_crypto_to_error(encsymkey));
     }
     encoder = pcrypto_sec_encdec_create(symkey);
@@ -1643,8 +1643,8 @@ static int psync_fs_creat(const char *path, mode_t mode,
     if (unlikely_log(encoder == PSYNC_CRYPTO_INVALID_ENCODER)) {
       psync_fstask_release_folder_tasks_locked(folder);
       psync_sql_unlock();
-      psync_free(fpath);
-      psync_free(encsymkey);
+      free(fpath);
+      free(encsymkey);
       return -ENOMEM;
     }
   } else {
@@ -1654,11 +1654,11 @@ static int psync_fs_creat(const char *path, mode_t mode,
   }
   cr = psync_fstask_add_creat(folder, fpath->name, 0, encsymkey, encsymkeylen);
   if (encsymkey)
-    psync_free(encsymkey);
+    free(encsymkey);
   if (unlikely_log(!cr)) {
     psync_fstask_release_folder_tasks_locked(folder);
     psync_sql_unlock();
-    psync_free(fpath);
+    free(fpath);
     return -EIO;
   }
   of = psync_fs_create_file(cr->fileid, 0, 0, 0, 1, 0,
@@ -1674,7 +1674,7 @@ static int psync_fs_creat(const char *path, mode_t mode,
     psync_fs_del_creat(fpath, of);
     return ret;
   }
-  psync_free(fpath);
+  free(fpath);
   fi->fh = openfile_to_fh(of);
   return 0;
 }
@@ -1717,7 +1717,7 @@ static void psync_fs_free_openfile(psync_openfile_t *of) {
     }
     close_if_valid(of->logfile);
     ptree_for_each_element_call_safe(
-        of->sectorsinlog, psync_sector_inlog_t, tree, psync_free);
+        of->sectorsinlog, psync_sector_inlog_t, tree, free);
     delete_log_files(of);
     if (of->authenticatedints)
       psync_interval_tree_free(of->authenticatedints);
@@ -1735,13 +1735,13 @@ static void psync_fs_free_openfile(psync_openfile_t *of) {
     if (cr) {
       ptree_del(&of->currentfolder->creats, &cr->tree);
       of->currentfolder->taskscnt--;
-      psync_free(cr);
+      free(cr);
     }
     psync_sql_unlock();
   }
   psync_fstask_release_folder_tasks(of->currentfolder);
-  psync_free(of->currentname);
-  psync_free(of);
+  free(of->currentname);
+  free(of);
 }
 
 static void psync_fs_get_both_locks(psync_openfile_t *of) {
@@ -1821,7 +1821,7 @@ static void psync_fs_upload_release_timer(void *ptr) {
     psync_sql_run_free(res);
   }
   psync_fs_dec_of_refcnt(ofw->of);
-  psync_free(ofw);
+  free(ofw);
   pstatus_upload_recalc_async();
 }
 
@@ -2161,7 +2161,7 @@ psync_fs_reopen_file_for_writing(psync_openfile_t *of) {
     if (unlikely_log(!cr)) {
       psync_sql_unlock();
       ppagecache_unlock_pages();
-      psync_free(encsymkey);
+      free(encsymkey);
       return -EIO;
     }
     psync_fs_update_openfile_fileid_locked(of, cr->fileid);
@@ -2172,7 +2172,7 @@ psync_fs_reopen_file_for_writing(psync_openfile_t *of) {
     ret = open_write_files(of, 0);
     if (unlikely_log(ret)) {
       ppagecache_unlock_pages();
-      psync_free(encsymkey);
+      free(encsymkey);
       return ret;
     }
     if (of->origctime)
@@ -2182,7 +2182,7 @@ psync_fs_reopen_file_for_writing(psync_openfile_t *of) {
           of, of->hash, size);
       ppagecache_unlock_pages();
       if (unlikely_log(ret)) {
-        psync_free(encsymkey);
+        free(encsymkey);
         return -EIO;
       }
     }
@@ -2192,7 +2192,7 @@ psync_fs_reopen_file_for_writing(psync_openfile_t *of) {
   cr = psync_fstask_add_modified_file(of->currentfolder, of->currentname,
                                       of->fileid, of->hash, encsymkey,
                                       encsymkeylen);
-  psync_free(encsymkey);
+  free(encsymkey);
   if (unlikely_log(!cr)) {
     psync_sql_unlock();
     return -EIO;
@@ -2248,13 +2248,13 @@ psync_fs_reopen_static_file_for_writing(psync_openfile_t *of) {
   if (likely_log(cr)) {
     ptree_del(&of->currentfolder->creats, &cr->tree);
     of->currentfolder->taskscnt--;
-    psync_free(cr);
+    free(cr);
   }
   un = psync_fstask_find_unlink(of->currentfolder, of->currentname, taskid);
   if (likely_log(un)) {
     ptree_del(&of->currentfolder->unlinks, &un->tree);
     of->currentfolder->taskscnt--;
-    psync_free(un);
+    free(un);
   }
   psync_sql_unlock();
   of->writeid = 0;
@@ -2528,7 +2528,7 @@ static int psync_fs_mkdir(const char *path, mode_t mode) {
   else
     ret = psync_fstask_mkdir(fpath->folderid, fpath->name, fpath->flags);
   psync_sql_unlock();
-  psync_free(fpath);
+  free(fpath);
   debug(D_NOTICE, "mkdir %s=%d", path, ret);
   return ret;
 }
@@ -2548,7 +2548,7 @@ static int psync_fs_can_rmdir(const char *path) {
   else
     ret = psync_fstask_can_rmdir(fpath->folderid, fpath->flags, fpath->name);
   psync_sql_unlock();
-  psync_free(fpath);
+  free(fpath);
   debug(D_NOTICE, "can_rmdir %s=%d", path, ret);
   return ret;
 }
@@ -2569,7 +2569,7 @@ static int psync_fs_rmdir(const char *path) {
   else
     ret = psync_fstask_rmdir(fpath->folderid, fpath->flags, fpath->name);
   psync_sql_unlock();
-  psync_free(fpath);
+  free(fpath);
   debug(D_NOTICE, "rmdir %s=%d", path, ret);
   return ret;
 }
@@ -2589,7 +2589,7 @@ static int psync_fs_can_unlink(const char *path) {
   else
     ret = psync_fstask_can_unlink(fpath->folderid, fpath->name);
   psync_sql_unlock();
-  psync_free(fpath);
+  free(fpath);
   debug(D_NOTICE, "can_unlink %s=%d", path, ret);
   return ret;
 }
@@ -2620,7 +2620,7 @@ static int psync_fs_unlink(const char *path) {
                       (void *)PEVENT_BKUP_F_DEL_DRIVE);
   }
 
-  psync_free(fpath);
+  free(fpath);
   debug(D_NOTICE, "unlink %s=%d", path, ret);
   return ret;
 }
@@ -2641,22 +2641,22 @@ static int psync_fs_rename_static_file(psync_fstask_folder_t *srcfolder,
     un = psync_fstask_find_unlink(dstfolder, new_name, cr->taskid);
     if (un) {
       ptree_del(&dstfolder->unlinks, &un->tree);
-      psync_free(un);
+      free(un);
       dstfolder->taskscnt--;
     }
     ptree_del(&dstfolder->creats, &cr->tree);
-    psync_free(cr);
+    free(cr);
     dstfolder->taskscnt--;
   }
   len = strlen(new_name) + 1;
-  un = (psync_fstask_unlink_t *)psync_malloc(
+  un = (psync_fstask_unlink_t *)malloc(
       offsetof(psync_fstask_unlink_t, name) + len);
   un->fileid = 0;
   un->taskid = srccr->taskid;
   memcpy(un->name, new_name, len);
   psync_fstask_inject_unlink(dstfolder, un);
   addlen = psync_fstask_creat_local_offset(len - 1);
-  cr = (psync_fstask_creat_t *)psync_malloc(addlen +
+  cr = (psync_fstask_creat_t *)malloc(addlen +
                                             sizeof(psync_fstask_local_creat_t));
   cr->fileid = 0;
   cr->rfileid = 0;
@@ -2669,11 +2669,11 @@ static int psync_fs_rename_static_file(psync_fstask_folder_t *srcfolder,
   un = psync_fstask_find_unlink(srcfolder, srccr->name, srccr->taskid);
   if (likely_log(un)) {
     ptree_del(&srcfolder->unlinks, &un->tree);
-    psync_free(un);
+    free(un);
     srcfolder->taskscnt--;
   }
   ptree_del(&srcfolder->creats, &srccr->tree);
-  psync_free(srccr);
+  free(srccr);
   srcfolder->taskscnt--;
   return 0;
 }
@@ -2990,16 +2990,16 @@ finish:
   if (folder)
     psync_fstask_release_folder_tasks_locked(folder);
   psync_sql_unlock();
-  psync_free(fold_path);
-  psync_free(fnew_path);
+  free(fold_path);
+  free(fnew_path);
   return PRINT_RETURN_FORMAT(ret, " for rename from %s to %s", old_path,
                              new_path);
 err_enoent:
   if (folder)
     psync_fstask_release_folder_tasks_locked(folder);
   psync_sql_unlock();
-  psync_free(fold_path);
-  psync_free(fnew_path);
+  free(fold_path);
+  free(fnew_path);
   debug(D_NOTICE, "returning ENOENT, folder not found");
   return -ENOENT;
 }
@@ -3089,7 +3089,7 @@ static int psync_fs_set_filetime_locked(psync_fsfileid_t fileid,
     debug(D_NOTICE, "setting %s time of %s to %lu=%d",
           crtime ? "creation" : "modification", filename,
           (unsigned long)tv->tv_sec, ret);
-    psync_free(filename);
+    free(filename);
     return ret ? -EACCES : 0;
   }
 }
@@ -3188,7 +3188,7 @@ static int psync_fs_set_time(const char *path, const struct timespec *tv,
   else
     ret = psync_fs_set_time_locked(fpath->folderid, fpath->name, tv, crtime);
   psync_sql_unlock();
-  psync_free(fpath);
+  free(fpath);
   return ret;
 }
 
@@ -3307,7 +3307,7 @@ static void psync_invalidate_os_cache_noret() {
   pthread_mutex_unlock(&start_mutex);
   if (path) {
     pfile_invalidate_os_cache(path);
-    psync_free(path);
+    free(path);
   }
 }
 
@@ -3380,7 +3380,7 @@ void psync_fs_refresh_folder(psync_folderid_t folderid) {
   } else
     fpath = NULL;
   pthread_mutex_unlock(&start_mutex);
-  psync_free(path);
+  free(path);
   if (!fpath)
     return;
   if (pfile_invalidate_os_cache_needed())
@@ -3393,7 +3393,7 @@ void psync_fs_refresh_folder(psync_folderid_t folderid) {
       pfile_delete(fpath);
     }
   }
-  psync_free(fpath);
+  free(fpath);
 }
 
 static char *psync_fuse_get_mountpoint() {
@@ -3401,7 +3401,7 @@ static char *psync_fuse_get_mountpoint() {
   char *mp;
   mp = psync_strdup(psync_setting_get_string(_PS(fsroot)));
   if (stat(mp, &st) && mkdir(mp, PSYNC_DEFAULT_POSIX_FOLDER_MODE)) {
-    psync_free(mp);
+    free(mp);
     return NULL;
   }
   return mp;
@@ -3435,12 +3435,12 @@ char *psync_fs_get_path_by_folderid(psync_folderid_t folderid) {
   path =
       pfolder_path_sep(folderid, "/", NULL);
   if (path == PSYNC_INVALID_PATH) {
-    psync_free(mp);
+    free(mp);
     return NULL;
   }
   ret = psync_strcat(mp, path, NULL);
-  psync_free(mp);
-  psync_free(path);
+  free(mp);
+  free(path);
   return ret;
 }
 
@@ -3518,7 +3518,7 @@ static void psync_fs_do_stop(void) {
 #if IS_DEBUG
     psync_fs_dump_internals();
 #endif
-    psync_free(mp);
+    free(mp);
   }
   pthread_mutex_unlock(&start_mutex);
 }
@@ -3593,7 +3593,7 @@ static void psync_fuse_thread() {
   pthread_mutex_lock(&start_mutex);
   fuse_destroy(psync_fuse);
   debug(D_NOTICE, "fuse_destroy exited");
-  psync_free(psync_current_mountpoint);
+  free(psync_current_mountpoint);
   started = 0;
   pthread_cond_broadcast(&start_cond);
   pthread_mutex_unlock(&start_mutex);
@@ -3699,7 +3699,7 @@ static int psync_fs_do_start() {
 err1:
   fuse_unmount(mp, psync_fuse_channel);
 err0:
-  psync_free(mp);
+  free(mp);
 err00:
   pthread_mutex_unlock(&start_mutex);
   fuse_opt_free_args(&args);
diff --git a/pclsync/pfscrypto.c b/pclsync/pfscrypto.c
index 07bf30e..e640b29 100644
--- a/pclsync/pfscrypto.c
+++ b/pclsync/pfscrypto.c
@@ -1100,17 +1100,16 @@ static int psync_fs_crypto_do_finalize_log(psync_openfile_t *of, int fullsync) {
                                                   O_CREAT | O_TRUNC)) ==
                    INVALID_HANDLE_VALUE) ||
       unlikely_log(pfscrypto_init_log(of))) {
-    psync_free(olog);
-    psync_free(flog);
+    free(olog);
+    free(flog);
     return -EIO;
   }
-  ptree_for_each_element_call_safe(of->sectorsinlog, psync_sector_inlog_t,
-                                        tree, psync_free);
+  ptree_for_each_element_call_safe(of->sectorsinlog, psync_sector_inlog_t, tree, free);
   of->sectorsinlog = PSYNC_TREE_EMPTY;
   ret = psync_fs_crypto_log_flush_and_process(of, flog, 0, 1);
   pfile_delete(flog);
-  psync_free(olog);
-  psync_free(flog);
+  free(olog);
+  free(flog);
   return PRINT_NEG_RETURN(ret);
 }
 
@@ -1626,8 +1625,8 @@ retry:
       // we are unlocked now
       psync_fs_lock_file(of);
       if (unlikely(ret)) {
-        psync_free(ranges);
-        psync_free(tmpbuf);
+        free(ranges);
+        free(tmpbuf);
         debug(D_NOTICE, "downloading of ranges failed");
         return ret;
       }
@@ -1646,8 +1645,8 @@ retry:
                 (unsigned long)ranges[l].offset,
                 (unsigned long)(ranges[l].offset + ranges[l].size),
                 (unsigned long)itr->from, (unsigned long)itr->to);
-          psync_free(ranges);
-          psync_free(tmpbuf);
+          free(ranges);
+          free(tmpbuf);
           goto retry;
         }
         debug(D_NOTICE, "wrote %u bytes to offset %lu",
@@ -1665,8 +1664,8 @@ retry:
       }
       // we do NOT need to fsync of->datafile, as we wrote to positions that
       // were empty
-      psync_free(ranges);
-      psync_free(tmpbuf);
+      free(ranges);
+      free(tmpbuf);
       if (unlikely(ret))
         return ret;
     }
@@ -1702,8 +1701,7 @@ static int pfscrypto_truncate_to_zero(psync_openfile_t *of) {
     psync_interval_tree_add(&of->writeintervals, 0,
                             pfscrypto_crypto_size(of->initialsize));
   }
-  ptree_for_each_element_call_safe(of->sectorsinlog, psync_sector_inlog_t,
-                                        tree, psync_free);
+  ptree_for_each_element_call_safe(of->sectorsinlog, psync_sector_inlog_t, tree, free);
   of->sectorsinlog = PSYNC_TREE_EMPTY;
   of->currentsize = 0;
   psync_fs_crypto_kill_extender_locked(of);
@@ -1791,7 +1789,7 @@ retry:
            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);
+    free(tr);
     tr = ntr;
   }
   ret = psync_fs_crypto_write_newfile_full_sector(of, buf, lastsectorid,
@@ -1873,7 +1871,7 @@ static void psync_fs_extender_thread(void *ptr) {
   of->extender = NULL;
   pthread_mutex_unlock(&of->mutex);
   pthread_cond_destroy(&ext->cond);
-  psync_free(ext);
+  free(ext);
   psync_fs_dec_of_refcnt(of);
 }
 
@@ -2093,7 +2091,7 @@ static void psync_fs_crypto_check_file(void *ptr, ppath_fast_stat *st) {
     path = psync_strcat((const char *)ptr, "/", st->name,
                         NULL);
     psync_fs_crypto_check_log(path, st->name);
-    psync_free(path);
+    free(path);
   }
 }
 
diff --git a/pclsync/pfsfolder.c b/pclsync/pfsfolder.c
index 9270f48..f9100df 100644
--- a/pclsync/pfsfolder.c
+++ b/pclsync/pfsfolder.c
@@ -67,7 +67,7 @@ static char *get_encname_for_folder(psync_fsfolderid_t folderid,
   name = psync_strndup(path, len);
   encname = pcryptofolder_fldencode_filename(enc, name);
   pcryptofolder_fldencoder_release(folderid, enc);
-  psync_free(name);
+  free(name);
   return encname;
 }
 
@@ -88,9 +88,9 @@ static psync_fspath_t *ret_folder_data(psync_fsfolderid_t folderid,
     encname = pcryptofolder_fldencode_filename(enc, name);
     pcryptofolder_fldencoder_release(folderid, enc);
     len = strlen(encname);
-    ret = (psync_fspath_t *)psync_malloc(sizeof(psync_fspath_t) + len + 1);
+    ret = (psync_fspath_t *)malloc(sizeof(psync_fspath_t) + len + 1);
     memcpy(ret + 1, encname, len + 1);
-    psync_free(encname);
+    free(encname);
     ret->folderid = folderid;
     ret->name = (char *)(ret + 1);
     ret->shareid = shareid;
@@ -119,7 +119,7 @@ char *get_decname_for_folder(psync_fsfolderid_t folderid, const char *path,
   name = psync_strndup(path, len);
   decname = pcryptofolder_flddecode_filename(dec, name);
   pcryptofolder_flddecoder_release(folderid, dec);
-  psync_free(name);
+  free(name);
   return decname;
 }
 
@@ -218,7 +218,7 @@ psync_fspath_t *psync_fsfolder_resolve_path(const char *path) {
       char *name = psync_strndup(ename, elen);
       if ((mk = psync_fstask_find_mkdir(folder, name, 0))) {
         if (mk->flags & PSYNC_FOLDER_FLAG_INVISIBLE) {
-          psync_free(name);
+          free(name);
           break;
         }
         cfolderid = mk->folderid;
@@ -232,7 +232,7 @@ psync_fspath_t *psync_fsfolder_resolve_path(const char *path) {
         check_userid(row[3], row[0], &shareid);
       } else
         hasit = 0;
-      psync_free(name);
+      free(name);
     } else {
       if (row) {
         cfolderid = row[0];
@@ -244,7 +244,7 @@ psync_fspath_t *psync_fsfolder_resolve_path(const char *path) {
         hasit = 0;
     }
     if (ename != path)
-      psync_free(ename);
+      free(ename);
     if (!hasit)
       break;
     path += len;
@@ -320,7 +320,7 @@ psync_fsfolderid_t psync_fsfolderid_by_path(const char *path,
         hasit = 1;
       } else
         hasit = 0;
-      psync_free(name);
+      free(name);
     } else {
       if (row) {
         cfolderid = row[0];
@@ -330,7 +330,7 @@ psync_fsfolderid_t psync_fsfolderid_by_path(const char *path,
         hasit = 0;
     }
     if (ename != path)
-      psync_free(ename);
+      free(ename);
     if (!hasit)
       break;
     path += len;
@@ -407,7 +407,7 @@ psync_fsfolderid_t psync_fsfolderidperm_by_path(const char *path,
         hasit = 1;
       } else
         hasit = 0;
-      psync_free(name);
+      free(name);
     } else {
       if (row) {
         cfolderid = row[0];
@@ -418,7 +418,7 @@ psync_fsfolderid_t psync_fsfolderidperm_by_path(const char *path,
         hasit = 0;
     }
     if (ename != path)
-      psync_free(ename);
+      free(ename);
     if (!hasit)
       break;
     path += len;
diff --git a/pclsync/pfstasks.c b/pclsync/pfstasks.c
index 304736a..4a71e51 100644
--- a/pclsync/pfstasks.c
+++ b/pclsync/pfstasks.c
@@ -193,7 +193,7 @@ void psync_fstask_release_folder_tasks_locked(psync_fstask_folder_t *folder) {
   if (--folder->refcnt == 0 && !folder->taskscnt) {
     debug(D_NOTICE, "releasing folder id %ld", (long int)folder->folderid);
     ptree_del(&folders, &folder->tree);
-    psync_free(folder);
+    free(folder);
   }
 }
 
@@ -451,7 +451,7 @@ int psync_fstask_mkdir(psync_fsfolderid_t folderid, const char *name,
     return -EIO;
   }
   len++;
-  task = (psync_fstask_mkdir_t *)psync_malloc(
+  task = (psync_fstask_mkdir_t *)malloc(
       offsetof(psync_fstask_mkdir_t, name) + len);
   task->taskid = taskid;
   task->ctime = task->mtime = ctime;
@@ -627,7 +627,7 @@ int psync_fstask_rmdir(psync_fsfolderid_t folderid, uint32_t parentflags,
   }
   if (mk) {
     ptree_del(&folder->mkdirs, &mk->tree);
-    psync_free(mk);
+    free(mk);
   }
   if (cfolder)
     psync_fstask_release_folder_tasks_locked(cfolder);
@@ -655,7 +655,7 @@ int psync_fstask_rmdir(psync_fsfolderid_t folderid, uint32_t parentflags,
     return -EIO;
   }
   len++;
-  task = (psync_fstask_rmdir_t *)psync_malloc(
+  task = (psync_fstask_rmdir_t *)malloc(
       offsetof(psync_fstask_rmdir_t, name) + len);
   task->taskid = taskid;
   task->folderid = cfolderid;
@@ -702,14 +702,14 @@ psync_fstask_creat_t *psync_fstask_add_creat(psync_fstask_folder_t *folder,
   if (unlikely_log(psync_sql_commit_transaction()))
     return NULL;
   len++;
-  un = (psync_fstask_unlink_t *)psync_malloc(
+  un = (psync_fstask_unlink_t *)malloc(
       offsetof(psync_fstask_unlink_t, name) + len);
   un->fileid = -(psync_fsfileid_t)taskid;
   un->taskid = taskid;
   memcpy(un->name, name, len);
   psync_fstask_insert_into_tree(
       &folder->unlinks, offsetof(psync_fstask_unlink_t, name), &un->tree);
-  task = (psync_fstask_creat_t *)psync_malloc(
+  task = (psync_fstask_creat_t *)malloc(
       offsetof(psync_fstask_creat_t, name) + len);
   task->fileid = -(psync_fsfileid_t)taskid;
   task->rfileid = fileid;
@@ -771,20 +771,20 @@ psync_fstask_add_modified_file(psync_fstask_folder_t *folder, const char *name,
   if (task) {
     psync_fstask_depend(taskid, task->taskid);
     ptree_del(&folder->creats, &task->tree);
-    psync_free(task);
+    free(task);
     folder->taskscnt--;
   }
   if (unlikely_log(psync_sql_commit_transaction()))
     return NULL;
   len++;
-  un = (psync_fstask_unlink_t *)psync_malloc(
+  un = (psync_fstask_unlink_t *)malloc(
       offsetof(psync_fstask_unlink_t, name) + len);
   un->fileid = fileid;
   un->taskid = taskid;
   memcpy(un->name, name, len);
   psync_fstask_insert_into_tree(
       &folder->unlinks, offsetof(psync_fstask_unlink_t, name), &un->tree);
-  task = (psync_fstask_creat_t *)psync_malloc(
+  task = (psync_fstask_creat_t *)malloc(
       offsetof(psync_fstask_creat_t, name) + len);
   task->fileid = -(psync_fsfileid_t)taskid;
   task->rfileid = fileid;
@@ -866,7 +866,7 @@ int psync_fstask_add_local_creat_static(psync_fsfolderid_t folderid,
   debug(D_NOTICE, "adding file %s to folderid %ld, datalen %lu", name,
         (long)folderid, (unsigned long)datalen);
   len++;
-  un = (psync_fstask_unlink_t *)psync_malloc(
+  un = (psync_fstask_unlink_t *)malloc(
       offsetof(psync_fstask_unlink_t, name) + len);
   un->taskid = psync_local_taskid;
   un->fileid = 0;
@@ -874,7 +874,7 @@ int psync_fstask_add_local_creat_static(psync_fsfolderid_t folderid,
   psync_fstask_insert_into_tree(
       &folder->unlinks, offsetof(psync_fstask_unlink_t, name), &un->tree);
   addlen = psync_fstask_creat_local_offset(len - 1);
-  cr = (psync_fstask_creat_t *)psync_malloc(addlen +
+  cr = (psync_fstask_creat_t *)malloc(addlen +
                                             sizeof(psync_fstask_local_creat_t));
   cr->fileid = 0;
   cr->rfileid = 0;
@@ -913,12 +913,12 @@ static psync_fsfileid_t get_file_at_old_location(psync_fsfileid_t fileid) {
   if (folder) {
     cr = psync_fstask_find_creat(folder, rec->name, 0);
     if (cr) {
-      psync_free(rec);
+      free(rec);
       psync_fstask_release_folder_tasks_locked(folder);
       return cr->fileid;
     }
     if (psync_fstask_find_unlink(folder, rec->name, 0)) {
-      psync_free(rec);
+      free(rec);
       psync_fstask_release_folder_tasks_locked(folder);
       return 0;
     }
@@ -933,7 +933,7 @@ static psync_fsfileid_t get_file_at_old_location(psync_fsfileid_t fileid) {
   else
     ret = 0;
   psync_sql_free_result(res);
-  psync_free(rec);
+  free(rec);
   return ret;
 }
 
@@ -1018,10 +1018,10 @@ int psync_fstask_unlink(psync_fsfolderid_t folderid, const char *name) {
       if (likely_log(task)) {
         ptree_del(&folder->unlinks, &task->tree);
         folder->taskscnt--;
-        psync_free(task);
+        free(task);
       }
       ptree_del(&folder->creats, &cr->tree);
-      psync_free(cr);
+      free(cr);
       folder->taskscnt--;
       psync_fstask_release_folder_tasks_locked(folder);
       return 0;
@@ -1029,7 +1029,7 @@ int psync_fstask_unlink(psync_fsfolderid_t folderid, const char *name) {
     depend = cr->taskid;
     fileid = cr->fileid;
     ptree_del(&folder->creats, &cr->tree);
-    psync_free(cr);
+    free(cr);
     folder->taskscnt--;
     if (folder->folderid >= 0)
       ppathstatus_drive_fldr_changed(folder->folderid);
@@ -1073,7 +1073,7 @@ int psync_fstask_unlink(psync_fsfolderid_t folderid, const char *name) {
     return -EIO;
   }
   len++;
-  task = (psync_fstask_unlink_t *)psync_malloc(
+  task = (psync_fstask_unlink_t *)malloc(
       offsetof(psync_fstask_unlink_t, name) + len);
   task->taskid = taskid;
   task->fileid = fileid;
@@ -1094,13 +1094,13 @@ static void add_history_record(psync_fileid_t fileid, psync_folderid_t folderid,
   char key[16];
   psync_get_string_id(key, "HLOC", fileid);
   while ((rec = (file_history_record *)pcache_get(key)))
-    psync_free(rec);
+    free(rec);
   len = strlen(name) + 1;
-  rec = (file_history_record *)psync_malloc(
+  rec = (file_history_record *)malloc(
       offsetof(file_history_record, name) + len);
   rec->folderid = folderid;
   memcpy(rec->name, name, len);
-  pcache_add(key, rec, PSYNC_FS_FILE_LOC_HIST_SEC, psync_free, 1);
+  pcache_add(key, rec, PSYNC_FS_FILE_LOC_HIST_SEC, free, 1);
 }
 
 int psync_fstask_rename_file(psync_fsfileid_t fileid,
@@ -1169,14 +1169,14 @@ int psync_fstask_rename_file(psync_fsfileid_t fileid,
   }
   if (cr) {
     ptree_del(&folder->creats, &cr->tree);
-    psync_free(cr);
+    free(cr);
     folder->taskscnt--;
     if (folder->folderid >= 0)
       ppathstatus_drive_fldr_changed(folder->folderid);
   }
   psync_fs_rename_openfile_locked(fileid, to_folderid, new_name);
   nlen++;
-  rm = (psync_fstask_unlink_t *)psync_malloc(
+  rm = (psync_fstask_unlink_t *)malloc(
       offsetof(psync_fstask_unlink_t, name) + nlen);
   rm->taskid = ftaskid;
   rm->fileid = fileid;
@@ -1195,17 +1195,17 @@ int psync_fstask_rename_file(psync_fsfileid_t fileid,
     if (cr->fileid < 0)
       psync_fstask_stop_and_delete_file(cr->fileid);
     ptree_del(&folder->creats, &cr->tree);
-    psync_free(cr);
+    free(cr);
     folder->taskscnt--;
   }
-  rm = (psync_fstask_unlink_t *)psync_malloc(
+  rm = (psync_fstask_unlink_t *)malloc(
       offsetof(psync_fstask_unlink_t, name) + nnlen);
   rm->fileid = fileid;
   rm->taskid = ttaskid;
   memcpy(rm->name, new_name, nnlen);
   psync_fstask_insert_into_tree(
       &folder->unlinks, offsetof(psync_fstask_unlink_t, name), &rm->tree);
-  cr = (psync_fstask_creat_t *)psync_malloc(
+  cr = (psync_fstask_creat_t *)malloc(
       offsetof(psync_fstask_creat_t, name) + nnlen);
   cr->fileid = fileid;
   cr->rfileid = rfileid;
@@ -1394,12 +1394,12 @@ int psync_fstask_rename_folder(psync_fsfolderid_t folderid,
 
   if (mk) {
     ptree_del(&folder->mkdirs, &mk->tree);
-    psync_free(mk);
+    free(mk);
     folder->taskscnt--;
   }
 
   nlen++;
-  rm = (psync_fstask_rmdir_t *)psync_malloc(
+  rm = (psync_fstask_rmdir_t *)malloc(
       offsetof(psync_fstask_rmdir_t, name) + nlen);
   rm->taskid = ftaskid;
   rm->folderid = folderid;
@@ -1416,12 +1416,12 @@ int psync_fstask_rename_folder(psync_fsfolderid_t folderid,
   if (mk) {
     debug(D_NOTICE, "renaming over mkdir %s", name);
     ptree_del(&folder->mkdirs, &mk->tree);
-    psync_free(mk);
+    free(mk);
     folder->taskscnt--;
   }
 
   nnlen++;
-  rm = (psync_fstask_rmdir_t *)psync_malloc(
+  rm = (psync_fstask_rmdir_t *)malloc(
       offsetof(psync_fstask_rmdir_t, name) + nnlen);
   rm->taskid = ttaskid;
   rm->folderid = folderid;
@@ -1429,7 +1429,7 @@ int psync_fstask_rename_folder(psync_fsfolderid_t folderid,
   psync_fstask_insert_into_tree(
       &folder->rmdirs, offsetof(psync_fstask_rmdir_t, name), &rm->tree);
 
-  mk = (psync_fstask_mkdir_t *)psync_malloc(
+  mk = (psync_fstask_mkdir_t *)malloc(
       offsetof(psync_fstask_mkdir_t, name) + nnlen);
   mk->taskid = ttaskid;
   mk->folderid = folderid;
@@ -1473,7 +1473,7 @@ void psync_fstask_folder_created(psync_folderid_t parentfolderid,
     mk = psync_fstask_find_mkdir(folder, name, taskid);
     if (mk) {
       ptree_del(&folder->mkdirs, &mk->tree);
-      psync_free(mk);
+      free(mk);
       folder->taskscnt--;
       pchg = 1;
     }
@@ -1531,7 +1531,7 @@ void psync_fstask_folder_deleted(psync_folderid_t parentfolderid,
     rm = psync_fstask_find_rmdir(folder, name, taskid);
     if (rm) {
       ptree_del(&folder->rmdirs, &rm->tree);
-      psync_free(rm);
+      free(rm);
       folder->taskscnt--;
     }
     psync_fstask_release_folder_tasks_locked(folder);
@@ -1584,13 +1584,13 @@ void psync_fstask_file_created(psync_folderid_t parentfolderid, uint64_t taskid,
     cr = psync_fstask_find_creat(folder, name, taskid);
     if (cr) {
       ptree_del(&folder->creats, &cr->tree);
-      psync_free(cr);
+      free(cr);
       folder->taskscnt--;
     }
     un = psync_fstask_find_unlink(folder, name, taskid);
     if (un) {
       ptree_del(&folder->unlinks, &un->tree);
-      psync_free(un);
+      free(un);
       folder->taskscnt--;
     } else
       debug(D_NOTICE, "could not find unlink for file %s in folderid %lu", name,
@@ -1616,13 +1616,13 @@ void psync_fstask_file_modified(psync_folderid_t parentfolderid,
     cr = psync_fstask_find_creat(folder, name, taskid);
     if (cr) {
       ptree_del(&folder->creats, &cr->tree);
-      psync_free(cr);
+      free(cr);
       folder->taskscnt--;
     }
     un = psync_fstask_find_unlink(folder, name, taskid);
     if (un) {
       ptree_del(&folder->unlinks, &un->tree);
-      psync_free(un);
+      free(un);
       folder->taskscnt--;
     }
     psync_fstask_release_folder_tasks_locked(folder);
@@ -1642,7 +1642,7 @@ void psync_fstask_file_deleted(psync_folderid_t parentfolderid, uint64_t taskid,
     un = psync_fstask_find_unlink(folder, name, taskid);
     if (un) {
       ptree_del(&folder->unlinks, &un->tree);
-      psync_free(un);
+      free(un);
       folder->taskscnt--;
     }
     psync_fstask_release_folder_tasks_locked(folder);
@@ -1661,13 +1661,13 @@ void psync_fstask_file_renamed(psync_folderid_t folderid, uint64_t taskid,
     un = psync_fstask_find_unlink(folder, name, taskid);
     if (un) {
       ptree_del(&folder->unlinks, &un->tree);
-      psync_free(un);
+      free(un);
       folder->taskscnt--;
     }
     cr = psync_fstask_find_creat(folder, name, taskid);
     if (cr) {
       ptree_del(&folder->creats, &cr->tree);
-      psync_free(cr);
+      free(cr);
       folder->taskscnt--;
     }
     psync_fstask_release_folder_tasks_locked(folder);
@@ -1683,7 +1683,7 @@ void psync_fstask_file_renamed(psync_folderid_t folderid, uint64_t taskid,
                                     psync_get_number(row[0]));
       if (un) {
         ptree_del(&folder->unlinks, &un->tree);
-        psync_free(un);
+        free(un);
         folder->taskscnt--;
       }
       psync_fstask_release_folder_tasks_locked(folder);
@@ -1714,13 +1714,13 @@ void psync_fstask_folder_renamed(psync_folderid_t parentfolderid,
     mk = psync_fstask_find_mkdir(folder, name, taskid);
     if (mk) {
       ptree_del(&folder->mkdirs, &mk->tree);
-      psync_free(mk);
+      free(mk);
       folder->taskscnt--;
     }
     rm = psync_fstask_find_rmdir(folder, name, taskid);
     if (rm) {
       ptree_del(&folder->rmdirs, &rm->tree);
-      psync_free(rm);
+      free(rm);
       folder->taskscnt--;
     }
     psync_fstask_release_folder_tasks_locked(folder);
@@ -1736,7 +1736,7 @@ void psync_fstask_folder_renamed(psync_folderid_t parentfolderid,
                                    psync_get_number(row[0]));
       if (rm) {
         ptree_del(&folder->rmdirs, &rm->tree);
-        psync_free(rm);
+        free(rm);
         folder->taskscnt--;
       }
       psync_fstask_release_folder_tasks_locked(folder);
@@ -1768,7 +1768,7 @@ static void psync_init_task_mkdir(psync_variant_row row) {
   ctime = psync_get_number(row[6]);
   folder = psync_fstask_get_or_create_folder_tasks_locked(folderid);
   len++;
-  task = (psync_fstask_mkdir_t *)psync_malloc(
+  task = (psync_fstask_mkdir_t *)malloc(
       offsetof(psync_fstask_mkdir_t, name) + len);
   task->taskid = taskid;
   task->ctime = task->mtime = ctime;
@@ -1800,11 +1800,11 @@ static void psync_init_task_rmdir(psync_variant_row row) {
   mk = psync_fstask_find_mkdir(folder, name, 0);
   if (mk) {
     ptree_del(&folder->mkdirs, &mk->tree);
-    psync_free(mk);
+    free(mk);
     folder->taskscnt--;
   }
   len++;
-  task = (psync_fstask_rmdir_t *)psync_malloc(
+  task = (psync_fstask_rmdir_t *)malloc(
       offsetof(psync_fstask_rmdir_t, name) + len);
   task->taskid = taskid;
   task->folderid = cfolderid;
@@ -1828,14 +1828,14 @@ static void psync_init_task_creat(psync_variant_row row) {
   name = psync_get_lstring(row[4], &len);
   folder = psync_fstask_get_or_create_folder_tasks_locked(folderid);
   len++;
-  un = (psync_fstask_unlink_t *)psync_malloc(
+  un = (psync_fstask_unlink_t *)malloc(
       offsetof(psync_fstask_unlink_t, name) + len);
   un->fileid = -(psync_fsfileid_t)taskid;
   un->taskid = taskid;
   memcpy(un->name, name, len);
   psync_fstask_insert_into_tree(
       &folder->unlinks, offsetof(psync_fstask_unlink_t, name), &un->tree);
-  task = (psync_fstask_creat_t *)psync_malloc(
+  task = (psync_fstask_creat_t *)malloc(
       offsetof(psync_fstask_creat_t, name) + len);
   task->fileid = -(psync_fsfileid_t)taskid;
   task->rfileid = psync_get_number(row[3]);
@@ -1860,11 +1860,11 @@ static void psync_init_do_task_unlink(uint64_t taskid,
   cr = psync_fstask_find_creat(folder, name, 0);
   if (cr) {
     ptree_del(&folder->creats, &cr->tree);
-    psync_free(cr);
+    free(cr);
     folder->taskscnt--;
   }
   namelen++;
-  task = (psync_fstask_unlink_t *)psync_malloc(
+  task = (psync_fstask_unlink_t *)malloc(
       offsetof(psync_fstask_unlink_t, name) + namelen);
   task->taskid = taskid;
   task->fileid = fileid;
@@ -1902,11 +1902,11 @@ static void psync_init_task_renfile_from(psync_variant_row row) {
       psync_fstask_get_or_create_folder_tasks_locked(psync_get_number(row[2]));
   if ((cr = psync_fstask_find_creat(folder, name, 0))) {
     ptree_del(&folder->creats, &cr->tree);
-    psync_free(cr);
+    free(cr);
     folder->taskscnt--;
   }
   len++;
-  rm = (psync_fstask_unlink_t *)psync_malloc(
+  rm = (psync_fstask_unlink_t *)malloc(
       offsetof(psync_fstask_unlink_t, name) + len);
   rm->taskid = psync_get_number(row[0]);
   rm->fileid = psync_get_snumber(row[3]);
@@ -1933,19 +1933,19 @@ static void psync_init_task_renfile_to(psync_variant_row row) {
   if (cr) {
     ptree_del(&folder->creats, &cr->tree);
     folder->taskscnt--;
-    psync_free(cr);
+    free(cr);
   }
   len++;
   taskid = psync_get_number(row[0]);
   fileid = psync_get_snumber(row[3]);
-  un = (psync_fstask_unlink_t *)psync_malloc(
+  un = (psync_fstask_unlink_t *)malloc(
       offsetof(psync_fstask_unlink_t, name) + len);
   un->fileid = fileid;
   un->taskid = taskid;
   memcpy(un->name, name, len);
   psync_fstask_insert_into_tree(
       &folder->unlinks, offsetof(psync_fstask_creat_t, name), &un->tree);
-  cr = (psync_fstask_creat_t *)psync_malloc(
+  cr = (psync_fstask_creat_t *)malloc(
       offsetof(psync_fstask_creat_t, name) + len);
   cr->fileid = fileid;
   cr->rfileid = psync_get_number(row[7]);
@@ -1971,11 +1971,11 @@ static void psync_init_task_renfolder_from(psync_variant_row row) {
       psync_fstask_get_or_create_folder_tasks_locked(psync_get_number(row[2]));
   if ((mk = psync_fstask_find_mkdir(folder, name, 0))) {
     ptree_del(&folder->mkdirs, &mk->tree);
-    psync_free(mk);
+    free(mk);
     folder->taskscnt--;
   }
   len++;
-  rm = (psync_fstask_rmdir_t *)psync_malloc(
+  rm = (psync_fstask_rmdir_t *)malloc(
       offsetof(psync_fstask_rmdir_t, name) + len);
   rm->taskid = psync_get_number(row[0]);
   rm->folderid = psync_get_snumber(row[8]);
@@ -2000,14 +2000,14 @@ static void psync_init_task_renfolder_to(psync_variant_row row) {
   len++;
   taskid = psync_get_number(row[0]);
   folderid = psync_get_snumber(row[8]);
-  rm = (psync_fstask_rmdir_t *)psync_malloc(
+  rm = (psync_fstask_rmdir_t *)malloc(
       offsetof(psync_fstask_rmdir_t, name) + len);
   rm->taskid = taskid;
   rm->folderid = folderid;
   memcpy(rm->name, name, len);
   psync_fstask_insert_into_tree(
       &folder->rmdirs, offsetof(psync_fstask_rmdir_t, name), &rm->tree);
-  mk = (psync_fstask_mkdir_t *)psync_malloc(
+  mk = (psync_fstask_mkdir_t *)malloc(
       offsetof(psync_fstask_mkdir_t, name) + len);
   mk->taskid = taskid;
   mk->folderid = folderid;
@@ -2036,18 +2036,18 @@ static void psync_init_task_modify(psync_variant_row row) {
   cr = psync_fstask_find_creat(folder, name, 0);
   if (cr) {
     ptree_del(&folder->creats, &cr->tree);
-    psync_free(cr);
+    free(cr);
     folder->taskscnt--;
   }
   len++;
-  un = (psync_fstask_unlink_t *)psync_malloc(
+  un = (psync_fstask_unlink_t *)malloc(
       offsetof(psync_fstask_unlink_t, name) + len);
   un->fileid = psync_get_snumber(row[3]);
   un->taskid = taskid;
   memcpy(un->name, name, len);
   psync_fstask_insert_into_tree(
       &folder->unlinks, offsetof(psync_fstask_unlink_t, name), &un->tree);
-  cr = (psync_fstask_creat_t *)psync_malloc(
+  cr = (psync_fstask_creat_t *)malloc(
       offsetof(psync_fstask_creat_t, name) + len);
   cr->fileid = -(psync_fsfileid_t)cr->taskid;
   cr->rfileid = psync_get_number(row[3]);
@@ -2081,7 +2081,7 @@ static void psync_fstask_free_tree(psync_tree *tr) {
   tr = ptree_get_first_safe(tr);
   while (tr) {
     ntr = ptree_get_next_safe(tr);
-    psync_free(tr);
+    free(tr);
     tr = ntr;
   }
 }
@@ -2100,7 +2100,7 @@ void psync_fstask_clean() {
     psync_fstask_free_tree(folder->rmdirs);
     if (folder->refcnt == 0) {
       ptree_del(&folders, &folder->tree);
-      psync_free(folder);
+      free(folder);
     } else {
       folder->creats = PSYNC_TREE_EMPTY;
       folder->unlinks = PSYNC_TREE_EMPTY;
@@ -2119,7 +2119,7 @@ void psync_fstask_add_banned_folder(psync_fsfolderid_t folderid,
   psync_fstask_rmdir_t *rm;
   size_t len;
   len = strlen(name) + 1;
-  mk = (psync_fstask_mkdir_t *)psync_malloc(
+  mk = (psync_fstask_mkdir_t *)malloc(
       offsetof(psync_fstask_mkdir_t, name) + len);
   mk->taskid = 0;
   mk->ctime = mk->mtime = 0;
@@ -2127,7 +2127,7 @@ void psync_fstask_add_banned_folder(psync_fsfolderid_t folderid,
   mk->subdircnt = 0;
   mk->flags = PSYNC_FOLDER_FLAG_INVISIBLE;
   memcpy(mk->name, name, len);
-  rm = (psync_fstask_rmdir_t *)psync_malloc(
+  rm = (psync_fstask_rmdir_t *)malloc(
       offsetof(psync_fstask_rmdir_t, name) + len);
   rm->taskid = 0;
   rm->folderid = 0;
diff --git a/pclsync/pfsupload.c b/pclsync/pfsupload.c
index 1085ee3..ae192d0 100644
--- a/pclsync/pfsupload.c
+++ b/pclsync/pfsupload.c
@@ -175,7 +175,7 @@ static int psync_process_task_mkdir(fsupload_task_t *task) {
       psync_sql_bind_uint(res, 1, folderid);
       psync_sql_bind_blob(res, 2, (char *)enckey, enckeylen);
       psync_sql_run_free(res);
-      psync_free(enckey);
+      free(enckey);
     }
   }
   debug(D_NOTICE, "folder %lu/%s created", (unsigned long)task->folderid,
@@ -272,15 +272,15 @@ static int psync_send_task_creat_upload_small(psock_t *api,
   }
   if (unlikely_log(pfile_read(fd, data + len, size) != size) ||
       unlikely_log(psync_fs_get_file_writeid(task->id) != task->int1)) {
-    psync_free(data);
+    free(data);
     return -1;
   }
   size += len;
   if (unlikely_log(psync_socket_writeall_upload(api, data, size) != size)) {
-    psync_free(data);
+    free(data);
     return -1;
   } else {
-    psync_free(data);
+    free(data);
     return 0;
   }
 }
@@ -317,7 +317,7 @@ static int clean_uploads_for_task(psock_t *api, psync_uploadid_t taskid) {
       ret = -1;
       break;
     } else
-      psync_free(res);
+      free(res);
   }
   sql = psync_sql_prep_statement("DELETE FROM fstaskupload WHERE fstaskid=?");
   psync_sql_bind_uint(sql, 1, taskid);
@@ -340,7 +340,7 @@ static int large_upload_check_checksum(psock_t *api, uint64_t uploadid,
   result = papi_find_result2(res, "result", PARAM_NUM)->num;
   if (unlikely(result)) {
     debug(D_WARNING, "upload_info returned %lu", (long unsigned)result);
-    psync_free(res);
+    free(res);
     psync_apipool_release(api);
     psync_process_api_error(result);
     return -1;
@@ -348,11 +348,11 @@ static int large_upload_check_checksum(psock_t *api, uint64_t uploadid,
   if (memcmp(filehash, papi_find_result2(res, PSYNC_CHECKSUM, PARAM_STR)->str,
              PSYNC_HASH_DIGEST_HEXLEN)) {
     debug(D_WARNING, "upload_info returned different checksum");
-    psync_free(res);
+    free(res);
     psync_apipool_release(api);
     return -1;
   }
-  psync_free(res);
+  free(res);
   return 0;
 }
 
@@ -416,7 +416,7 @@ static void set_key_for_fileid(psync_fileid_t fileid, uint64_t hash,
     psync_sql_bind_uint(res, 2, hash);
     psync_sql_bind_blob(res, 3, (char *)enckey, enckeylen);
     psync_sql_run_free(res);
-    psync_free(enckey);
+    free(enckey);
   }
   psync_get_string_id(buff, "DKEY", fileid);
   pcache_del(buff);
@@ -575,14 +575,14 @@ static int large_upload_save(psock_t *api, uint64_t uploadid,
   result = papi_find_result2(res, "result", PARAM_NUM)->num;
   if (unlikely(result)) {
     debug(D_WARNING, "upload_save returned %lu", (long unsigned)result);
-    psync_free(res);
+    free(res);
     handle_upload_api_error_taskid(result, taskid);
     return -1;
   }
   debug(D_NOTICE, "sent mtime=%lu", (unsigned long)pfile_stat_mtime(&st));
   ret = save_meta(papi_find_result2(res, "metadata", PARAM_HASH), folderid,
                   name, taskid, writeid, newfile, oldhash, key);
-  psync_free(res);
+  free(res);
   pdiff_wake();
   return ret;
 }
@@ -639,7 +639,7 @@ static int copy_file(psock_t *api, const struct stat *st,
     return -1;
   result = papi_find_result2(res, "result", PARAM_NUM)->num;
   if (unlikely(result)) {
-    psync_free(res);
+    free(res);
     debug(D_WARNING, "command copyfile returned code %u", (unsigned)result);
     psync_process_api_error(result);
     return 0;
@@ -647,7 +647,7 @@ static int copy_file(psock_t *api, const struct stat *st,
   meta = papi_find_result2(res, "metadata", PARAM_HASH);
   debug(D_NOTICE, "sent mtime=%lu", (unsigned long)pfile_stat_mtime(st));
   ret = save_meta(meta, folderid, name, taskid, writeid, 1, 0, NULL);
-  psync_free(res);
+  free(res);
   if (ret) // ret*2-1?
     return -1;
   else
@@ -671,7 +671,7 @@ static int copy_file_if_exists(psock_t *api, const char *filename,
     return -1;
   result = papi_find_result2(res, "result", PARAM_NUM)->num;
   if (unlikely(result)) {
-    psync_free(res);
+    free(res);
     debug(D_WARNING, "command getfilesbychecksum returned code %u",
           (unsigned)result);
     psync_process_api_error(result);
@@ -679,12 +679,12 @@ static int copy_file_if_exists(psock_t *api, const char *filename,
   }
   metas = papi_find_result2(res, "metadata", PARAM_ARRAY);
   if (!metas->length) {
-    psync_free(res);
+    free(res);
     return 0;
   }
   meta = metas->array[0];
   if (stat(filename, &st)) {
-    psync_free(res);
+    free(res);
     return -1;
   }
   ret = copy_file(api, &st, papi_find_result2(meta, "fileid", PARAM_NUM)->num,
@@ -700,7 +700,7 @@ static int copy_file_if_exists(psock_t *api, const char *filename,
           (long unsigned)folderid, name);
     pdiff_wake();
   }
-  psync_free(res);
+  free(res);
   return ret;
 }
 
@@ -769,7 +769,7 @@ static int large_upload_creat(uint64_t taskid, psync_folderid_t folderid,
       goto err0;
     result = papi_find_result2(res, "result", PARAM_NUM)->num;
     if (unlikely(result)) {
-      psync_free(res);
+      free(res);
       psync_apipool_release(api);
       debug(D_WARNING, "upload_create returned %lu", (unsigned long)result);
       psync_process_api_error(result);
@@ -779,7 +779,7 @@ static int large_upload_creat(uint64_t taskid, psync_folderid_t folderid,
         return 0;
     }
     uploadid = papi_find_result2(res, "uploadid", PARAM_NUM)->num;
-    psync_free(res);
+    free(res);
     sql = psync_sql_prep_statement(
         "INSERT INTO fstaskupload (fstaskid, uploadid) VALUES (?, ?)");
     psync_sql_bind_uint(sql, 1, taskid);
@@ -796,7 +796,7 @@ static int large_upload_creat(uint64_t taskid, psync_folderid_t folderid,
   }
   if (large_upload_creat_send_write(api, uploadid, usize, fsize - usize))
     goto err1;
-  buff = psync_malloc(PSYNC_COPY_BUFFER_SIZE);
+  buff = malloc(PSYNC_COPY_BUFFER_SIZE);
   if (usize) {
     asize = usize;
     pupload_bytes_add(asize);
@@ -820,13 +820,13 @@ static int large_upload_creat(uint64_t taskid, psync_folderid_t folderid,
     asize += rrd;
     pupload_bytes_add(rrd);
   }
-  psync_free(buff);
+  free(buff);
   pfile_close(fd);
   res = papi_result(api);
   if (unlikely_log(!res))
     goto err0;
   result = papi_find_result2(res, "result", PARAM_NUM)->num;
-  psync_free(res);
+  free(res);
   if (result) {
     debug(D_WARNING, "upload_write returned error %lu", (long unsigned)result);
     psync_process_api_error(result);
@@ -870,7 +870,7 @@ ret0:
     pupload_bytes_sub(asize);
   return 0;
 err2:
-  psync_free(buff);
+  free(buff);
 err1:
   pfile_close(fd);
 err0:
@@ -924,7 +924,7 @@ static int upload_modify_send_local(psock_t *api,
     return PSYNC_NET_TEMPFAIL;
   bw = 0;
 
-  buff = psync_malloc(PSYNC_COPY_BUFFER_SIZE);
+  buff = malloc(PSYNC_COPY_BUFFER_SIZE);
   while (bw < length) {
     if (unlikely(stop_current_upload)) {
       debug(D_NOTICE, "got stop");
@@ -948,13 +948,13 @@ static int upload_modify_send_local(psock_t *api,
     *upl += rrd;
     pupload_bytes_add(rrd);
   }
-  psync_free(buff);
+  free(buff);
   return PSYNC_NET_OK;
 err0:
-  psync_free(buff);
+  free(buff);
   return PSYNC_NET_TEMPFAIL;
 errp:
-  psync_free(buff);
+  free(buff);
   return PSYNC_NET_PERMFAIL;
 }
 
@@ -965,7 +965,7 @@ static int upload_modify_read_req(psock_t *api) {
   if (!res)
     return PSYNC_NET_TEMPFAIL;
   result = papi_find_result2(res, "result", PARAM_NUM)->num;
-  psync_free(res);
+  free(res);
   if (result) {
     debug(D_WARNING, "got %lu from upload_writefromfile or upload_write",
           (unsigned long)result);
@@ -1022,7 +1022,7 @@ int upload_modify(uint64_t taskid, psync_folderid_t folderid, const char *name,
     goto err2;
   result = papi_find_result2(res, "result", PARAM_NUM)->num;
   if (unlikely(result)) {
-    psync_free(res);
+    free(res);
     psync_apipool_release(api);
     psync_interval_tree_free(tree);
     debug(D_WARNING, "upload_create returned %lu", (unsigned long)result);
@@ -1033,7 +1033,7 @@ int upload_modify(uint64_t taskid, psync_folderid_t folderid, const char *name,
       return 0;
   }
   uploadid = papi_find_result2(res, "uploadid", PARAM_NUM)->num;
-  psync_free(res);
+  free(res);
   sql = psync_sql_prep_statement(
       "INSERT INTO fstaskupload (fstaskid, uploadid) VALUES (?, ?)");
   psync_sql_bind_uint(sql, 1, taskid);
@@ -1229,10 +1229,10 @@ static void large_upload() {
         psync_fsupload_wake();
       psys_sleep_milliseconds(PSYNC_SLEEP_ON_FAILED_UPLOAD);
     }
-    psync_free(indexname);
-    psync_free(filename);
-    psync_free(name);
-    psync_free(key);
+    free(indexname);
+    free(filename);
+    free(name);
+    free(key);
   }
   debug(D_NOTICE, "exited");
 }
@@ -1280,7 +1280,7 @@ int psync_fsupload_in_current_small_uploads_batch_locked(uint64_t taskid) {
     stret = stat(filename, &st);
     if (stret)
       debug(D_WARNING, "can not stat %s", filename);
-    psync_free(filename);
+    free(filename);
     if (stret)
       return 1;
     if (pfile_stat_size(&st) > PSYNC_FS_DIRECT_UPLOAD_LIMIT)
@@ -1305,7 +1305,7 @@ static int psync_send_task_creat(psock_t *api, fsupload_task_t *task) {
     filename = psync_strcat(psync_setting_get_string(_PS(fscachepath)),
                             "/", fileidhex, NULL);
     fd = pfile_open(filename, O_RDONLY, 0);
-    psync_free(filename);
+    free(filename);
     if (unlikely_log(fd == INVALID_HANDLE_VALUE) ||
         unlikely_log(fstat(fd, &st))) {
       if (fd != INVALID_HANDLE_VALUE)
@@ -1522,7 +1522,7 @@ int2, sfolderid FROM fstask WHERE id=?"); psync_sql_bind_uint(res, 1, id);
       size+=row[4].length+1;
     if (row[5].type==PSYNC_TSTRING)
       size+=row[5].length+1;
-    task=(fsupload_task_t *)psync_malloc(size);
+    task=(fsupload_task_t *)malloc(size);
     end=(char *)(task+1);
     task->res=NULL;
     task->id=psync_get_number(row[0]);
@@ -1612,7 +1612,7 @@ static void change_folder_name(fsupload_task_t *task) {
   psync_sql_run_free(res);
   debug(D_NOTICE, "changed target name of task %lu from %s to %s",
         (unsigned long)task->id, task->text1, nn);
-  psync_free(nn);
+  free(nn);
 }
 
 static int handle_rename_folder_api_error(uint64_t result,
@@ -1687,13 +1687,13 @@ static void psync_delete_write_cache_file(uint64_t taskid, int index) {
   filename =
       psync_strcat(cachepath, "/", fileidhex, NULL);
   assertw(pfile_delete(filename) == 0);
-  psync_free(filename);
+  free(filename);
   if (index) {
     fileidhex[sizeof(psync_fsfileid_t)] = 'i';
     filename =
         psync_strcat(cachepath, "/", fileidhex, NULL);
     assertw(pfile_delete(filename) == 0);
-    psync_free(filename);
+    free(filename);
   }
 }
 
@@ -1927,7 +1927,7 @@ static void psync_fsupload_process_tasks(psync_list *tasks) {
           dels++;
         }
       }
-      psync_free(task->res);
+      free(task->res);
     }
   }
 
@@ -2035,12 +2035,12 @@ static void clean_stuck_tasks() {
     filename =
         psync_strcat(cachepath, "/", fileidhex, NULL);
     pfile_delete(filename);
-    psync_free(filename);
+    free(filename);
     fileidhex[sizeof(psync_fsfileid_t)] = 'i';
     filename =
         psync_strcat(cachepath, "/", fileidhex, NULL);
     pfile_delete(filename);
-    psync_free(filename);
+    free(filename);
     psync_sql_start_transaction();
     res = psync_sql_prep_statement(
         "DELETE FROM fstaskdepend WHERE dependfstaskid=?");
@@ -2051,7 +2051,7 @@ static void clean_stuck_tasks() {
     psync_sql_run_free(res);
     psync_sql_commit_transaction();
   }
-  psync_free(fr);
+  free(fr);
 }
 
 static void psync_fsupload_check_tasks() {
@@ -2087,7 +2087,7 @@ static void psync_fsupload_check_tasks() {
       size += row[4].length + 1;
     if (row[5].type == PSYNC_TSTRING)
       size += row[5].length + 1;
-    task = (fsupload_task_t *)psync_malloc(size);
+    task = (fsupload_task_t *)malloc(size);
     end = (char *)(task + 1);
     task->res = NULL;
     task->id = psync_get_number(row[0]);
@@ -2122,7 +2122,7 @@ static void psync_fsupload_check_tasks() {
   psync_sql_lock();
   current_upload_batch = NULL;
   psync_sql_unlock();
-  psync_list_for_each_element_call(&tasks, fsupload_task_t, list, psync_free);
+  psync_list_for_each_element_call(&tasks, fsupload_task_t, list, free);
 }
 
 static void psync_fsupload_thread() {
diff --git a/pclsync/pfsxattr.c b/pclsync/pfsxattr.c
index 85941a0..8948d53 100644
--- a/pclsync/pfsxattr.c
+++ b/pclsync/pfsxattr.c
@@ -149,7 +149,7 @@ static int64_t xattr_get_object_id_locked(const char *path) {
   if (folder) {
     mk = psync_fstask_find_mkdir(folder, fspath->name, 0);
     if (mk) {
-      psync_free(fspath);
+      free(fspath);
       assertw(mk->folderid != 0);
       if (mk->folderid > 0)
         return folderid_to_objid(mk->folderid);
@@ -158,7 +158,7 @@ static int64_t xattr_get_object_id_locked(const char *path) {
     }
     cr = psync_fstask_find_creat(folder, fspath->name, 0);
     if (cr) {
-      psync_free(fspath);
+      free(fspath);
       if (cr->fileid > 0)
         return fileid_to_objid(cr->fileid);
       else if (cr->fileid == 0)
@@ -188,7 +188,7 @@ static int64_t xattr_get_object_id_locked(const char *path) {
     checkfile = !psync_fstask_find_unlink(folder, fspath->name, 0);
   }
   if (fspath->folderid < 0) {
-    psync_free(fspath);
+    free(fspath);
     debug(D_NOTICE, "path %s not found in temporary folder", path);
     return -1;
   }
@@ -203,7 +203,7 @@ static int64_t xattr_get_object_id_locked(const char *path) {
       ret = -1;
     psync_sql_free_result(res);
     if (ret != -1) {
-      psync_free(fspath);
+      free(fspath);
       return ret;
     }
   }
@@ -218,11 +218,11 @@ static int64_t xattr_get_object_id_locked(const char *path) {
       ret = -1;
     psync_sql_free_result(res);
     if (ret != -1) {
-      psync_free(fspath);
+      free(fspath);
       return ret;
     }
   }
-  psync_free(fspath);
+  free(fspath);
   debug(D_NOTICE, "path %s not found", path);
   return -1;
 }
diff --git a/pclsync/pintervaltree.c b/pclsync/pintervaltree.c
index dad5797..7bedc4c 100644
--- a/pclsync/pintervaltree.c
+++ b/pclsync/pintervaltree.c
@@ -58,10 +58,10 @@ psync_interval_tree_consume_intervals(psync_interval_tree_t *tree,
     psync_interval_tree_del(&tree, next);
     if (next->to >= e->to) {
       e->to = next->to;
-      psync_free(next);
+      free(next);
       break;
     }
-    psync_free(next);
+    free(next);
   }
   return tree;
 }
@@ -144,8 +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)
-    ptree_for_each_element_call_safe(&tree->tree, psync_interval_tree_t,
-                                          tree, psync_free);
+    ptree_for_each_element_call_safe(&tree->tree, psync_interval_tree_t, tree, free);
 }
 
 static psync_interval_tree_t *
@@ -160,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(
         ptree_get_del(&tree->tree, &last->tree));
-    psync_free(last);
+    free(last);
     last = prev;
   }
   return tree;
diff --git a/pclsync/plibs.c b/pclsync/plibs.c
index e5d8988..f686bec 100644
--- a/pclsync/plibs.c
+++ b/pclsync/plibs.c
@@ -183,7 +183,7 @@ char *psync_strcat(const char *str, ...) {
     size += len;
   }
   va_end(ap);
-  ptr2 = ptr3 = (char *)psync_malloc(size);
+  ptr2 = ptr3 = (char *)malloc(size);
   for (size = 0; size < i; size++) {
     memcpy(ptr2, strs[size], lengths[size]);
     ptr2 += lengths[size];
@@ -211,7 +211,7 @@ unsigned char *psync_base32_encode(const unsigned char *str, size_t length,
   unsigned char *p;
   uint32_t bits, buff;
 
-  result = (unsigned char *)psync_malloc(((length + 4) / 5) * 8 + 1);
+  result = (unsigned char *)malloc(((length + 4) / 5) * 8 + 1);
   p = result;
 
   bits = 0;
@@ -247,7 +247,7 @@ unsigned char *psync_base32_decode(const unsigned char *str, size_t length,
   unsigned char *result, *p;
   uint32_t bits, buff;
   unsigned char ch;
-  result = (unsigned char *)psync_malloc((length + 7) / 8 * 5 + 1);
+  result = (unsigned char *)malloc((length + 7) / 8 * 5 + 1);
   p = result;
   bits = 0;
   buff = 0;
@@ -259,7 +259,7 @@ unsigned char *psync_base32_decode(const unsigned char *str, size_t length,
     else if (ch >= '2' && ch <= '7')
       ch -= '2' - 26;
     else {
-      psync_free(result);
+      free(result);
       return NULL;
     }
     buff = (buff << 5) + ch;
@@ -280,7 +280,7 @@ unsigned char *psync_base64_encode(const unsigned char *str, size_t length,
   unsigned char *p;
   unsigned char *result;
 
-  result = (unsigned char *)psync_malloc(((length + 2) / 3) * 4 + 1);
+  result = (unsigned char *)malloc(((length + 2) / 3) * 4 + 1);
   p = result;
 
   while (length > 2) {
@@ -313,14 +313,14 @@ unsigned char *psync_base64_decode(const unsigned char *str, size_t length,
   size_t i = 0, j = 0;
   ssize_t ch;
 
-  result = (unsigned char *)psync_malloc((length + 3) / 4 * 3 + 1);
+  result = (unsigned char *)malloc((length + 3) / 4 * 3 + 1);
 
   while (length-- > 0) {
     ch = base64_reverse_table[*current++];
     if (ch == -1)
       continue;
     else if (ch == -2) {
-      psync_free(result);
+      free(result);
       return NULL;
     }
     switch (i % 4) {
@@ -756,7 +756,7 @@ void psync_sql_rdunlock() {
       debug(D_WARNING,
             "held database read lock for %lu milliseconds taken at %s:%u", msec,
             lock->file, lock->line);
-    psync_free(lock);
+    free(lock);
   } else
     plocks_unlock(&psync_db_lock);
 #else
@@ -788,7 +788,7 @@ int psync_sql_tryupgradelock() {
     assert(sqllockcnt == 1);
     sqllockstart = sqlrdlockstart;
     record_wrlock(lock->file, lock->line);
-    psync_free(lock);
+    free(lock);
     return 0;
   }
 #else
@@ -869,7 +869,7 @@ static void run_commit_callbacks(int success) {
       cb->commit_callback(cb->ptr);
     else
       cb->rollback_callback(cb->ptr);
-    psync_free(cb);
+    free(cb);
   }
 }
 
@@ -927,7 +927,7 @@ static void psync_sql_do_check_query_plan(const char *sql) {
   int code;
   exsql = psync_strcat("EXPLAIN QUERY PLAN ", sql, NULL);
   code = sqlite3_prepare_v2(psync_db, exsql, -1, &stmt, 0);
-  psync_free(exsql);
+  free(exsql);
   if (code != SQLITE_OK) {
     debug(D_ERROR, "EXPLAIN QUERY PLAN %s returned error: %d", sql, code);
     return;
@@ -1080,7 +1080,7 @@ char **psync_sql_rowstr(const char *sql) {
       lens[i] = l;
     }
     ln += (sizeof(char *) + 1) * cnt;
-    arr = (char **)psync_malloc(ln);
+    arr = (char **)malloc(ln);
     nstr = ((char *)arr) + sizeof(char *) * cnt;
     for (i = 0; i < cnt; i++) {
       str = (char *)sqlite3_column_blob(stmt, i);
@@ -1142,7 +1142,7 @@ psync_variant *psync_sql_row(const char *sql) {
         lens[i] = l;
       }
     }
-    arr = (psync_variant *)psync_malloc(ln);
+    arr = (psync_variant *)malloc(ln);
     nstr = ((char *)arr) + sizeof(psync_variant) * cnt;
     for (i = 0; i < cnt; i++) {
       t = types[i];
@@ -1212,7 +1212,7 @@ psync_sql_res *psync_sql_query_nocache(const char *sql) {
     return NULL;
   }
   cnt = sqlite3_column_count(stmt);
-  res = (psync_sql_res *)psync_malloc(sizeof(psync_sql_res) +
+  res = (psync_sql_res *)malloc(sizeof(psync_sql_res) +
                                       cnt * sizeof(psync_variant));
   res->stmt = stmt;
   res->sql = sql;
@@ -1280,7 +1280,7 @@ psync_sql_res *psync_sql_query_rdlock_nocache(const char *sql) {
     return NULL;
   }
   cnt = sqlite3_column_count(stmt);
-  res = (psync_sql_res *)psync_malloc(sizeof(psync_sql_res) +
+  res = (psync_sql_res *)malloc(sizeof(psync_sql_res) +
                                       cnt * sizeof(psync_variant));
   res->stmt = stmt;
   res->sql = sql;
@@ -1347,7 +1347,7 @@ psync_sql_res *psync_sql_query_nolock_nocache(const char *sql) {
     return NULL;
   }
   cnt = sqlite3_column_count(stmt);
-  res = (psync_sql_res *)psync_malloc(sizeof(psync_sql_res) +
+  res = (psync_sql_res *)malloc(sizeof(psync_sql_res) +
                                       cnt * sizeof(psync_variant));
   res->stmt = stmt;
   res->sql = sql;
@@ -1395,7 +1395,7 @@ static void psync_sql_free_cache(void *ptr) {
 #if IS_DEBUG
   memset(res, 0xff, sizeof(psync_sql_res));
 #endif
-  psync_free(res);
+  free(res);
 }
 
 static void psync_sql_res_unlock(psync_sql_res *res) {
@@ -1435,7 +1435,7 @@ void psync_sql_free_result_nocache(psync_sql_res *res) {
 #if IS_DEBUG
   memset(res, 0xff, sizeof(psync_sql_res));
 #endif
-  psync_free(res);
+  free(res);
 }
 
 #if IS_DEBUG
@@ -1551,7 +1551,7 @@ int psync_sql_run_free_nocache(psync_sql_res *res) {
     code = 0;
   sqlite3_finalize(res->stmt);
   psync_sql_res_unlock(res);
-  psync_free(res);
+  free(res);
   return code;
 }
 
@@ -1569,7 +1569,7 @@ int psync_sql_run_free(psync_sql_res *res) {
       debug(D_BUG, "transaction query failed, this may lead to restarting "
                    "transaction over and over");
     psync_sql_res_unlock(res);
-    psync_free(res);
+    free(res);
     return -1;
   } else {
     psync_sql_res_unlock(res);
@@ -1698,7 +1698,7 @@ psync_full_result_int *psync_sql_fetchall_int(psync_sql_res *res) {
   while ((code = sqlite3_step(res->stmt)) == SQLITE_ROW) {
     if (rows >= all) {
       all = 10 + all * 2;
-      data = (uint64_t *)psync_realloc(data, sizeof(uint64_t) * cols * all);
+      data = (uint64_t *)realloc(data, sizeof(uint64_t) * cols * all);
     }
     for (i = 0; i < cols; i++)
       data[off + i] = sqlite3_column_int64(res->stmt, i);
@@ -1708,12 +1708,12 @@ psync_full_result_int *psync_sql_fetchall_int(psync_sql_res *res) {
   if (unlikely(code != SQLITE_DONE))
     debug(D_ERROR, "sqlite3_step returned error: %s", sqlite3_errmsg(psync_db));
   psync_sql_free_result(res);
-  ret = (psync_full_result_int *)psync_malloc(
+  ret = (psync_full_result_int *)malloc(
       offsetof(psync_full_result_int, data) + sizeof(uint64_t) * off);
   ret->rows = rows;
   ret->cols = cols;
   memcpy(ret->data, data, sizeof(uint64_t) * off);
-  psync_free(data);
+  free(data);
   return ret;
 }
 
@@ -1732,7 +1732,7 @@ int psync_rename_conflicted_file(const char *path) {
     dotidx--;
   if (!dotidx)
     dotidx = plen;
-  npath = (char *)psync_malloc(plen + 32);
+  npath = (char *)malloc(plen + 32);
   memcpy(npath, path, dotidx);
   num = 0;
   while (1) {
@@ -1746,7 +1746,7 @@ int psync_rename_conflicted_file(const char *path) {
     if (stat(npath, &st)) {
       debug(D_NOTICE, "renaming conflict %s to %s", path, npath);
       l = pfile_rename(path, npath);
-      psync_free(npath);
+      free(npath);
       return l;
     }
     num++;
@@ -1766,7 +1766,7 @@ static void run_after_sec(psync_timer_t timer, void *ptr) {
   struct run_after_ptr *fp = (struct run_after_ptr *)ptr;
   ptimer_stop(timer);
   fp->run(fp->ptr);
-  psync_free(fp);
+  free(fp);
 }
 
 void psync_run_after_sec(psync_run_after_t run, void *ptr, uint32_t seconds) {
@@ -1779,7 +1779,7 @@ void psync_run_after_sec(psync_run_after_t run, void *ptr, uint32_t seconds) {
 
 static void free_after_sec(psync_timer_t timer, void *ptr) {
   ptimer_stop(timer);
-  psync_free(ptr);
+  free(ptr);
 }
 
 void psync_free_after_sec(void *ptr, uint32_t seconds) {
@@ -1919,7 +1919,7 @@ void psync_list_bulder_add_sql(psync_list_builder_t *builder,
   while ((row = psync_sql_fetch_row(res))) {
     if (!builder->last_elements ||
         builder->last_elements->used >= builder->elements_per_list) {
-      builder->last_elements = (psync_list_element_list *)psync_malloc(
+      builder->last_elements = (psync_list_element_list *)malloc(
           offsetof(psync_list_element_list, elements) +
           builder->element_size * builder->elements_per_list);
       psync_list_add_tail(&builder->element_list,
@@ -1946,7 +1946,7 @@ void psync_list_bulder_add_sql(psync_list_builder_t *builder,
 void *psync_list_bulder_add_element(psync_list_builder_t *builder) {
   if (!builder->last_elements ||
       builder->last_elements->used >= builder->elements_per_list) {
-    builder->last_elements = (psync_list_element_list *)psync_malloc(
+    builder->last_elements = (psync_list_element_list *)malloc(
         offsetof(psync_list_element_list, elements) +
         builder->element_size * builder->elements_per_list);
     psync_list_add_tail(&builder->element_list, &builder->last_elements->list);
@@ -1970,13 +1970,13 @@ void psync_list_add_lstring_offset(psync_list_builder_t *builder, size_t offset,
   str = (char **)(builder->current_element + offset);
   builder->stringalloc += length;
   if (unlikely(length > 2000)) {
-    l = (psync_list_string_list *)psync_malloc(sizeof(psync_list_string_list) +
+    l = (psync_list_string_list *)malloc(sizeof(psync_list_string_list) +
                                                length);
     s = (char *)(l + 1);
     psync_list_add_tail(&builder->string_list, &l->list);
   } else if (!builder->last_strings || builder->last_strings->next + length >
                                            builder->last_strings->end) {
-    l = (psync_list_string_list *)psync_malloc(sizeof(psync_list_string_list) +
+    l = (psync_list_string_list *)malloc(sizeof(psync_list_string_list) +
                                                4000);
     s = (char *)(l + 1);
     l->next = s + length;
@@ -2041,13 +2041,10 @@ void *psync_list_builder_finalize(psync_list_builder_t *builder) {
     }
   }
 
-  psync_list_for_each_element_call(&builder->element_list,
-                                   psync_list_element_list, list, psync_free);
-  psync_list_for_each_element_call(&builder->string_list,
-                                   psync_list_string_list, list, psync_free);
-  psync_list_for_each_element_call(&builder->number_list, psync_list_num_list,
-                                   list, psync_free);
-  psync_free(builder);
+  psync_list_for_each_element_call(&builder->element_list, psync_list_element_list, list, free);
+  psync_list_for_each_element_call(&builder->string_list, psync_list_string_list, list, free);
+  psync_list_for_each_element_call(&builder->number_list, psync_list_num_list, list, free);
+  free(builder);
   return ret;
 }
 
@@ -2081,7 +2078,7 @@ static void psync_task_destroy(psync_task_manager_t tm) {
   for (i = 0; i < tm->taskcnt; i++)
     pthread_cond_destroy(&tm->tasks[i].cond);
   pthread_mutex_destroy(&tm->mutex);
-  psync_free(tm);
+  free(tm);
 }
 
 static void psync_task_dec_refcnt(psync_task_manager_t tm) {
@@ -2111,7 +2108,7 @@ psync_task_run_tasks(psync_task_callback_t const *callbacks,
   psync_task_manager_t ret;
   struct psync_task_t_ *t;
   int i;
-  ret = (psync_task_manager_t)psync_malloc(
+  ret = (psync_task_manager_t)malloc(
       offsetof(struct psync_task_manager_t_, tasks) +
       sizeof(struct psync_task_t_) * cnt);
   pthread_mutex_init(&ret->mutex, NULL);
diff --git a/pclsync/plibs.h b/pclsync/plibs.h
index e40f3b5..3f2adf4 100644
--- a/pclsync/plibs.h
+++ b/pclsync/plibs.h
@@ -219,8 +219,8 @@ extern "C" {
 
 #define ARRAY_SIZE(arr) (sizeof(arr) / sizeof((arr)[0]))
 
-#define psync_new(type) (type *)psync_malloc(sizeof(type))
-#define psync_new_cnt(type, cnt) (type *)psync_malloc(sizeof(type) * (cnt))
+#define psync_new(type) (type *)malloc(sizeof(type))
+#define psync_new_cnt(type, cnt) (type *)malloc(sizeof(type) * (cnt))
 
 #define psync_binhex(dst, src, cnt)                                            \
   do {                                                                         \
diff --git a/pclsync/plocalnotify.c b/pclsync/plocalnotify.c
index 96f45db..051cac6 100644
--- a/pclsync/plocalnotify.c
+++ b/pclsync/plocalnotify.c
@@ -97,7 +97,7 @@ static void add_dir_scan(localnotify_dir *dir, const char *path) {
     namelen = 255;
   if (namelen < sizeof(de->d_name) - 1)
     namelen = sizeof(de->d_name) - 1;
-  wch = (localnotify_watch *)psync_malloc(offsetof(localnotify_watch, path) +
+  wch = (localnotify_watch *)malloc(offsetof(localnotify_watch, path) +
                                           pl + 1 + namelen + 1);
   wch->next = dir->watches[wid % WATCH_HASH];
   dir->watches[wid % WATCH_HASH] = wch;
@@ -107,8 +107,8 @@ static void add_dir_scan(localnotify_dir *dir, const char *path) {
   memcpy(wch->path, path, pl + 1);
   if (likely_log(dh = opendir(path))) {
     entrylen = offsetof(struct dirent, d_name) + namelen + 1;
-    cpath = (char *)psync_malloc(pl + namelen + 2);
-    entry = (struct dirent *)psync_malloc(entrylen);
+    cpath = (char *)malloc(pl + namelen + 2);
+    entry = (struct dirent *)malloc(entrylen);
     memcpy(cpath, path, pl);
     if (!pl || cpath[pl - 1] != '/')
       cpath[pl++] = '/';
@@ -122,8 +122,8 @@ static void add_dir_scan(localnotify_dir *dir, const char *path) {
           add_dir_scan(dir, cpath);
       }
     }
-    psync_free(entry);
-    psync_free(cpath);
+    free(entry);
+    free(cpath);
     closedir(dh);
   }
 }
@@ -141,7 +141,7 @@ static void add_syncid(psync_syncid_t syncid) {
     str = psync_get_lstring(row[0], &len);
     len++;
     dir =
-        (localnotify_dir *)psync_malloc(offsetof(localnotify_dir, path) + len);
+        (localnotify_dir *)malloc(offsetof(localnotify_dir, path) + len);
     memcpy(dir->path, str, len);
     psync_sql_free_result(res);
   } else {
@@ -165,7 +165,7 @@ static void add_syncid(psync_syncid_t syncid) {
 err2:
   close(dir->inotifyfd);
 err:
-  psync_free(dir);
+  free(dir);
 }
 
 static void del_syncid(psync_syncid_t syncid) {
@@ -180,13 +180,13 @@ static void del_syncid(psync_syncid_t syncid) {
       while (wch) {
         next = wch->next;
         inotify_rm_watch(dir->inotifyfd, wch->watchid);
-        psync_free(wch);
+        free(wch);
         wch = next;
       }
     }
     epoll_ctl(epoll_fd, EPOLL_CTL_DEL, dir->inotifyfd, NULL);
     close(dir->inotifyfd);
-    psync_free(dir);
+    free(dir);
     return;
   }
 }
@@ -237,7 +237,7 @@ static uint32_t process_notification(localnotify_dir *dir) {
         if (wch->watchid == ev.wd) {
           *pwch = wch->next;
           inotify_rm_watch(dir->inotifyfd, wch->watchid);
-          psync_free(wch);
+          free(wch);
           break;
         } else {
           pwch = &wch->next;
diff --git a/pclsync/plocalscan.c b/pclsync/plocalscan.c
index 5561970..371ba34 100644
--- a/pclsync/plocalscan.c
+++ b/pclsync/plocalscan.c
@@ -172,7 +172,7 @@ static void scanner_set_syncs_to_list(psync_list *lst,
       debug(D_WARNING, "folder %s deviceid is different, ignoring", lp);
       continue;
     }
-    l = (sync_list *)psync_malloc(offsetof(sync_list, localpath) + lplen + 1);
+    l = (sync_list *)malloc(offsetof(sync_list, localpath) + lplen + 1);
     l->folderid = psync_get_number(row[1]);
     l->deviceid = deviceid;
     l->syncid = psync_get_number(row[0]);
@@ -180,7 +180,7 @@ static void scanner_set_syncs_to_list(psync_list *lst,
     memcpy(l->localpath, lp, lplen + 1);
     psync_list_add_tail(lst, &l->list);
     l_full_deviceid =
-        (sync_list *)psync_malloc(offsetof(sync_list, localpath) + lplen + 1);
+        (sync_list *)malloc(offsetof(sync_list, localpath) + lplen + 1);
     l_full_deviceid->folderid = psync_get_number(row[1]);
     l_full_deviceid->deviceid = pfile_stat_device_full(&st);
     l_full_deviceid->syncid = psync_get_number(row[0]);
@@ -189,7 +189,7 @@ static void scanner_set_syncs_to_list(psync_list *lst,
     psync_list_add_tail(lst_deviceid_full, &l_full_deviceid->list);
   }
   psync_sql_free_result(res);
-  psync_free(syncmp);
+  free(syncmp);
 }
 
 static void add_ignored_dir(const char *path) {
@@ -202,7 +202,7 @@ static void add_ignored_dir(const char *path) {
       ign_paths_alloc = 8;
     else
       ign_paths_alloc *= 2;
-    ignored_paths = (device_inode_t *)psync_realloc(
+    ignored_paths = (device_inode_t *)realloc(
         ignored_paths, sizeof(device_inode_t) * ign_paths_alloc);
   }
   ignored_paths[ign_paths_cnt].deviceid = pfile_stat_device_full(&st);
@@ -254,7 +254,7 @@ static void reload_ignored_folders() {
           homelen = strlen(home);
       }
       if (home) {
-        dir = (char *)psync_malloc(dirlen + homelen - 4);
+        dir = (char *)malloc(dirlen + homelen - 4);
         memcpy(dir, home, homelen);
         memcpy(dir + homelen, start + 5, dirlen - 5);
         dir[dirlen + homelen - 5] = 0;
@@ -262,15 +262,15 @@ static void reload_ignored_folders() {
         dir = NULL;
       }
     } else {
-      dir = (char *)psync_malloc(dirlen + 1);
+      dir = (char *)malloc(dirlen + 1);
       memcpy(dir, start, dirlen);
       dir[dirlen] = 0;
     }
     if (dir)
       add_ignored_dir(dir);
-    psync_free(dir);
+    free(dir);
   }
-  psync_free(home);
+  free(home);
 }
 
 static int is_path_to_ignore(uint64_t deviceid, uint64_t inode) {
@@ -297,7 +297,7 @@ static void scanner_local_entry_to_list(void *ptr, ppath_stat *st) {
 
   lst = (psync_list *)ptr;
   l = strlen(st->name) + 1;
-  e = (sync_folderlist *)psync_malloc(offsetof(sync_folderlist, name) + l);
+  e = (sync_folderlist *)malloc(offsetof(sync_folderlist, name) + l);
   e->localid = 0;
   e->remoteid = 0;
   e->inode = pfile_stat_inode(&st->stat);
@@ -361,7 +361,7 @@ static void scanner_db_folder_to_list(psync_syncid_t syncid,
       continue;
     }
     namelen++;
-    e = (sync_folderlist *)psync_malloc(offsetof(sync_folderlist, name) +
+    e = (sync_folderlist *)malloc(offsetof(sync_folderlist, name) +
                                         namelen);
     e->localid = psync_get_number(row[0]);
     e->remoteid = psync_get_number_or_null(row[1]);
@@ -390,7 +390,7 @@ static void scanner_db_folder_to_list(psync_syncid_t syncid,
       continue;
     }
     namelen++;
-    e = (sync_folderlist *)psync_malloc(offsetof(sync_folderlist, name) +
+    e = (sync_folderlist *)malloc(offsetof(sync_folderlist, name) +
                                         namelen);
     e->localid = psync_get_number(row[0]);
     e->remoteid = psync_get_number_or_null(row[1]);
@@ -419,7 +419,7 @@ static sync_folderlist *copy_folderlist_element(const sync_folderlist *e,
   sync_folderlist *ret;
   size_t l;
   l = offsetof(sync_folderlist, name) + strlen(e->name) + 1;
-  ret = (sync_folderlist *)psync_malloc(l);
+  ret = (sync_folderlist *)malloc(l);
   memcpy(ret, e, l);
   ret->localparentfolderid = localfolderid;
   ret->parentfolderid = folderid;
@@ -564,7 +564,7 @@ scanner_scan_folder(const char *localpath, psync_folderid_t folderid,
     add_deleted_element(fdb, folderid, localfolderid, syncid, synctype);
     ldb = ldb->next;
   }
-  psync_list_for_each_element_call(&dblist, sync_folderlist, list, psync_free);
+  psync_list_for_each_element_call(&dblist, sync_folderlist, list, free);
   if (localsleepperfolder) {
     psys_sleep_milliseconds(localsleepperfolder);
     if (psync_current_time - starttime >=
@@ -577,11 +577,10 @@ scanner_scan_folder(const char *localpath, psync_folderid_t folderid,
     subpath = psync_strcat(localpath, "/", l->name, NULL);
     scanner_scan_folder(subpath, l->remoteid, l->localid, syncid, synctype,
                         deviceid);
-    psync_free(subpath);
+    free(subpath);
   }
 
-  psync_list_for_each_element_call(&disklist, sync_folderlist, list,
-                                   psync_free);
+  psync_list_for_each_element_call(&disklist, sync_folderlist, list, free);
 }
 
 static int compare_sizeinodemtime(const psync_list *l1, const psync_list *l2) {
@@ -814,7 +813,7 @@ static void scan_created_folder(sync_folderlist *fl) {
           localpath, (unsigned long)fl->localid, fl->name);
     scanner_scan_folder(localpath, 0, fl->localid, fl->syncid, fl->synctype,
                         fl->deviceid);
-    psync_free(localpath);
+    free(localpath);
   }
 }
 
@@ -1043,9 +1042,8 @@ restart:
       break;
     }
   }
-  psync_list_for_each_element_call(&slist, sync_list, list, psync_free);
-  psync_list_for_each_element_call(&slist_full_deviceid, sync_list, list,
-                                   psync_free);
+  psync_list_for_each_element_call(&slist, sync_list, list, free);
+  psync_list_for_each_element_call(&slist_full_deviceid, sync_list, list, free);
   w = 0;
 
   do {
@@ -1053,8 +1051,7 @@ restart:
     if (unlikely(restart_scan)) {
       pthread_mutex_unlock(&scan_mutex);
       for (i = 0; i < SCAN_LIST_CNT; i++)
-        psync_list_for_each_element_call(&scan_lists[i], sync_folderlist, list,
-                                         psync_free);
+        psync_list_for_each_element_call(&scan_lists[i], sync_folderlist, list, free);
       psys_sleep_milliseconds(restartsleep);
       if (restartsleep < 16000)
         restartsleep *= 2;
@@ -1080,11 +1077,9 @@ restart:
         w++;
         check_for_query_cnt();
       }
-      psync_list_for_each_element_call(&scan_lists[SCAN_LIST_RENFOLDERSROM],
-                                       sync_folderlist, list, psync_free);
+      psync_list_for_each_element_call(&scan_lists[SCAN_LIST_RENFOLDERSROM], sync_folderlist, list, free);
       psync_list_init(&scan_lists[SCAN_LIST_RENFOLDERSROM]);
-      psync_list_for_each_element_call(&scan_lists[SCAN_LIST_RENFOLDERSTO],
-                                       sync_folderlist, list, psync_free);
+      psync_list_for_each_element_call(&scan_lists[SCAN_LIST_RENFOLDERSTO], sync_folderlist, list, free);
       psync_list_init(&scan_lists[SCAN_LIST_RENFOLDERSTO]);
       psync_list_for_each_element(fl, &scan_lists[SCAN_LIST_NEWFOLDERS],
                                   sync_folderlist, list) {
@@ -1102,8 +1097,7 @@ restart:
       }
       psync_list_for_each_element_call(&newtmp, sync_folderlist, list,
                                        scan_created_folder);
-      psync_list_for_each_element_call(&newtmp, sync_folderlist, list,
-                                       psync_free);
+      psync_list_for_each_element_call(&newtmp, sync_folderlist, list, free);
     }
     if (changes) {
       i++;
@@ -1115,8 +1109,7 @@ restart:
   if (unlikely(restart_scan)) {
     pthread_mutex_unlock(&scan_mutex);
     for (i = 0; i < SCAN_LIST_CNT; i++)
-      psync_list_for_each_element_call(&scan_lists[i], sync_folderlist, list,
-                                       psync_free);
+      psync_list_for_each_element_call(&scan_lists[i], sync_folderlist, list, free);
     psys_sleep_milliseconds(restartsleep);
     if (restartsleep < 16000)
       restartsleep *= 2;
@@ -1172,8 +1165,7 @@ restart:
     pstatus_upload_recalc_async();
   }
   for (i = 0; i < SCAN_LIST_CNT; i++)
-    psync_list_for_each_element_call(&scan_lists[i], sync_folderlist, list,
-                                     psync_free);
+    psync_list_for_each_element_call(&scan_lists[i], sync_folderlist, list, free);
   if (movedfolders) {
     starttime = psync_current_time;
     restartsleep = 1000;
@@ -1270,7 +1262,7 @@ void psync_restat_sync_folders_add(psync_syncid_t syncid,
   sync_restat_list *l;
   struct stat st;
   size_t lplen = strlen(localpath);
-  l = (sync_restat_list *)psync_malloc(offsetof(sync_restat_list, localpath) +
+  l = (sync_restat_list *)malloc(offsetof(sync_restat_list, localpath) +
                                        lplen + 1);
   l->syncid = syncid;
   memcpy(l->localpath, localpath, lplen + 1);
@@ -1300,7 +1292,7 @@ void psync_restat_sync_folders_del(psync_syncid_t syncid) {
   }
   if (to_del) {
     psync_list_del(&to_del->list);
-    psync_free(to_del);
+    free(to_del);
   }
   pthread_mutex_unlock(&restat_mutex);
 }
diff --git a/pclsync/pmemlock.c b/pclsync/pmemlock.c
deleted file mode 100644
index 24dc028..0000000
--- a/pclsync/pmemlock.c
+++ /dev/null
@@ -1,408 +0,0 @@
-/*
-   Copyright (c) 2015 Anton Titov.
-
-   Copyright (c) 2015 pCloud Ltd.  All rights reserved.
-
-   Redistribution and use in source and binary forms, with or without
-   modification, are permitted provided that the following conditions
-   are met: Redistributions of source code must retain the above
-   copyright notice, this list of conditions and the following
-   disclaimer.  Redistributions in binary form must reproduce the
-   above copyright notice, this list of conditions and the following
-   disclaimer in the documentation and/or other materials provided
-   with the distribution.  Neither the name of pCloud Ltd nor the
-   names of its contributors may be used to endorse or promote
-   products derived from this software without specific prior written
-   permission.
-
-   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
-   FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL pCloud
-   Ltd BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
-   EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-   PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
-   PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
-   OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
-   USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
-   DAMAGE.
-*/
-
-#include <mbedtls/ctr_drbg.h>
-#include <mbedtls/debug.h>
-#include <mbedtls/entropy.h>
-#include <mbedtls/pkcs5.h>
-#include <mbedtls/ssl.h>
-#include <pthread.h>
-
-#include "pcryptofolder.h"
-#include "pintervaltree.h"
-#include "plibs.h"
-#include "pmem.h"
-#include "pmemlock.h"
-#include "ptree.h"
-#include <stdint.h>
-
-typedef uintptr_t pageid_t;
-typedef struct {
-  psync_tree tree;
-  pageid_t pageid;
-  unsigned long refcnt;
-} locked_page_t;
-
-typedef struct {
-  psync_tree tree;
-  psync_interval_tree_t *freeintervals;
-  char *mem;
-  size_t size;
-  int locked;
-} allocator_range;
-
-static int psync_page_size;
-
-static pthread_mutex_t page_mutex = PTHREAD_MUTEX_INITIALIZER;
-static psync_tree *locked_pages = PSYNC_TREE_EMPTY;
-
-static pthread_mutex_t allocator_mutex;
-static psync_tree *allocator_ranges = PSYNC_TREE_EMPTY;
-
-void pmemlock_init() {
-  pthread_mutexattr_t mattr;
-  pthread_mutexattr_init(&mattr);
-  pthread_mutexattr_settype(&mattr, PTHREAD_MUTEX_RECURSIVE);
-  pthread_mutex_init(&allocator_mutex, &mattr);
-  pthread_mutexattr_destroy(&mattr);
-}
-
-static int lock_page(pageid_t pageid, int page_size) {
-  psync_tree *tr, **addto;
-  locked_page_t *node;
-  int found, ret, tryn;
-  found = 0;
-  ret = 0;
-  tryn = 0;
-retry:
-  pthread_mutex_lock(&page_mutex);
-  tr = locked_pages;
-  if (tr) {
-    while (1) {
-      node = ptree_element(tr, locked_page_t, tree);
-      if (pageid < node->pageid) {
-        if (tr->left)
-          tr = tr->left;
-        else {
-          addto = &tr->left;
-          break;
-        }
-      } else if (pageid > node->pageid) {
-        if (tr->right)
-          tr = tr->right;
-        else {
-          addto = &tr->right;
-          break;
-        }
-      } else {
-        found = 1;
-        break;
-      }
-    }
-  } else
-    addto = &locked_pages;
-  if (found) {
-    node->refcnt++;
-    debug(D_NOTICE, "page %lx is already locked, increasing refcnt to %u",
-          (unsigned long)pageid * page_size, (unsigned)node->refcnt);
-  } else {
-    // Well, we can move the locking out of mutex protected area, but to do
-    // properly, an status "in progress" should be introduced for new elements
-    // in the tree that mlock is yet not returned. This will complicate things a
-    // lot.
-    if (unlikely(pmem_mlock((void *)(pageid * page_size), page_size))) {
-      if (!tryn) {
-        tryn++;
-        pthread_mutex_unlock(&page_mutex);
-        debug(D_NOTICE, "mlock failed, trying to clean cache");
-        pcryptofolder_cache_clean();
-        goto retry;
-      } else {
-        debug(D_WARNING, "mlock for page %lx failed even after cache clean",
-              (unsigned long)pageid * page_size);
-        ret = -1;
-      }
-    } else {
-      debug(D_NOTICE, "locked page %lx", (unsigned long)pageid * page_size);
-      node = psync_new(locked_page_t);
-      node->pageid = pageid;
-      node->refcnt = 1;
-      *addto = &node->tree;
-      ptree_added_at(&locked_pages, tr, &node->tree);
-    }
-  }
-  pthread_mutex_unlock(&page_mutex);
-  return ret;
-}
-
-static int unlock_page(pageid_t pageid, int page_size) {
-  psync_tree *tr;
-  locked_page_t *node;
-  int ret;
-  pthread_mutex_lock(&page_mutex);
-  tr = locked_pages;
-  while (tr) {
-    node = ptree_element(tr, locked_page_t, tree);
-    if (pageid < node->pageid)
-      tr = tr->left;
-    else if (pageid > node->pageid)
-      tr = tr->right;
-    else
-      break;
-  }
-  if (likely(tr)) {
-    if (--node->refcnt) {
-      debug(D_NOTICE, "decreased refcnt of page %lx to %u",
-            (unsigned long)pageid * page_size, (unsigned)node->refcnt);
-      ret = 0;
-    } else {
-      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)))
-        ret = PRINT_RETURN(-1);
-      else {
-        debug(D_NOTICE, "unlocked page %lx", (unsigned long)pageid * page_size);
-        ret = 0;
-      }
-    }
-  } else {
-    ret = -1;
-    debug(D_WARNING, "unlocking page %lx that is not locked",
-          (unsigned long)pageid * page_size);
-  }
-  pthread_mutex_unlock(&page_mutex);
-  return ret;
-}
-
-int pmemlock_lock(void *ptr, size_t size) {
-  pageid_t frompage, topage, i;
-  int page_size;
-  page_size = pmemlock_get_pagesize();
-  if (page_size == -1)
-    return PRINT_RETURN(-1);
-  frompage = (uintptr_t)ptr / page_size;
-  topage = ((uintptr_t)ptr + size - 1) / page_size;
-  for (i = frompage; i <= topage; i++)
-    if (unlikely(lock_page(i, page_size))) {
-      while (i > frompage)
-        unlock_page(--i, page_size);
-      return PRINT_RETURN(-1);
-    }
-  return 0;
-}
-
-int pmemlock_unlock(void *ptr, size_t size) {
-  pageid_t frompage, topage, i;
-  int page_size, ret;
-  page_size = pmemlock_get_pagesize();
-  if (page_size == -1)
-    return PRINT_RETURN(-1);
-  frompage = (uintptr_t)ptr / page_size;
-  topage = ((uintptr_t)ptr + size - 1) / page_size;
-  ret = 0;
-  for (i = frompage; i <= topage; i++)
-    if (unlikely(unlock_page(i, page_size)))
-      ret = PRINT_RETURN(-1);
-  return ret;
-}
-
-#define LM_ALIGN_TO (sizeof(size_t) * 2)
-#define LM_OVERHEAD (sizeof(size_t) * 2)
-#define LM_RANGE_OVERHEAD (LM_ALIGN_TO - sizeof(size_t))
-#define LM_END_MARKER (~((size_t)0))
-
-#if IS_DEBUG
-static void mark_aligment_bytes(char *ptr, size_t from, size_t to) {
-  size_t i;
-  for (i = from; i < to; i++)
-    ((unsigned char *)ptr)[i] = ((size_t)0xff + from - i) & 0xff;
-}
-#endif
-
-void *pmemlock_malloc(size_t size) {
-  return psync_malloc(size);
-  allocator_range *range, *brange;
-  psync_tree *tr, **addto;
-  psync_interval_tree_t *interval;
-  char *ret;
-  uint64_t boffset;
-  size_t intsize, bestsize;
-#if IS_DEBUG
-  size_t origsize = size;
-#endif
-  int page_size;
-  size = ((size + LM_ALIGN_TO - 1)) / LM_ALIGN_TO * LM_ALIGN_TO + LM_OVERHEAD;
-#if IS_DEBUG
-  debug(D_NOTICE, "size=%lu, size with overhead=%lu", (unsigned long)origsize,
-        (unsigned long)size);
-#endif
-  bestsize = ~((size_t)0);
-  brange = NULL;
-  boffset = 0; // just to make compilers happy
-  // psync_mem_lock may call pcryptofolder_cache_clean(), which in turn can
-  // call pmemlock_free() on few pointers, therefore allocator_mutex is
-  // recursive
-  pthread_mutex_lock(&allocator_mutex);
-  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) {
-      bestsize = intsize;
-      brange = range;
-      boffset = interval->from;
-      if (intsize == size)
-        goto foundneededsize;
-    }
-  }
-  if (brange) {
-  foundneededsize:
-    if (unlikely(!brange->locked))
-      if (!pmemlock_lock(brange->mem, brange->size))
-        brange->locked = 1;
-    psync_interval_tree_remove(&brange->freeintervals, boffset, boffset + size);
-    ret = brange->mem + boffset;
-#if IS_DEBUG
-    *((size_t *)ret) = origsize;
-#else
-    *((size_t *)ret) = size;
-#endif
-    *((size_t *)(ret + size - sizeof(size_t))) = LM_END_MARKER;
-    ret += sizeof(size_t);
-#if IS_DEBUG
-    mark_aligment_bytes(ret, origsize, size - LM_OVERHEAD);
-#endif
-  } else
-    ret = NULL;
-  pthread_mutex_unlock(&allocator_mutex);
-  if (ret)
-    return ret;
-  page_size = pmemlock_get_pagesize();
-  if (unlikely(page_size == -1))
-    page_size = 4096;
-  intsize = (size + LM_RANGE_OVERHEAD + page_size - 1) / page_size * page_size;
-  brange = psync_new(allocator_range);
-  brange->freeintervals = NULL;
-  brange->mem = pmem_mmap_safe(intsize);
-  brange->size = intsize;
-  debug(D_NOTICE, "allocating new locked block of size %lu at %p",
-        (unsigned long)intsize, brange->mem);
-  if (unlikely(pmemlock_lock(brange->mem, intsize))) {
-    brange->locked = 0;
-    debug(D_WARNING, "could not lock %lu bytes in memory",
-          (unsigned long)intsize);
-  } else
-    brange->locked = 1;
-  if (intsize > size + LM_RANGE_OVERHEAD)
-    psync_interval_tree_add(&brange->freeintervals, LM_RANGE_OVERHEAD + size,
-                            intsize);
-  ret = brange->mem + LM_RANGE_OVERHEAD;
-#if IS_DEBUG
-  *((size_t *)ret) = origsize;
-#else
-  *((size_t *)ret) = size;
-#endif
-  *((size_t *)(ret + size - sizeof(size_t))) = LM_END_MARKER;
-  ret += sizeof(size_t);
-#if IS_DEBUG
-  mark_aligment_bytes(ret, origsize, size - LM_OVERHEAD);
-#endif
-  pthread_mutex_lock(&allocator_mutex);
-  tr = allocator_ranges;
-  if (tr) {
-    while (1) {
-      range = ptree_element(tr, allocator_range, tree);
-      if (brange->mem < range->mem) {
-        assert(brange->mem + brange->size <= range->mem);
-        if (tr->left)
-          tr = tr->left;
-        else {
-          addto = &tr->left;
-          break;
-        }
-      } else {
-        assert(range->mem + range->size <= brange->mem);
-        if (tr->right)
-          tr = tr->right;
-        else {
-          addto = &tr->right;
-          break;
-        }
-      }
-    }
-  } else
-    addto = &allocator_ranges;
-  *addto = &brange->tree;
-  ptree_added_at(&allocator_ranges, tr, &brange->tree);
-  pthread_mutex_unlock(&allocator_mutex);
-  return ret;
-}
-
-void pmemlock_free(void *ptr) {
-  psync_free(ptr);
-  return;
-  allocator_range *range;
-  psync_tree *tr;
-  char *cptr;
-  size_t size;
-#if IS_DEBUG
-  size_t origsize, i;
-#endif
-  cptr = ((char *)ptr) - sizeof(size_t);
-  size = *((size_t *)cptr);
-#if IS_DEBUG
-  origsize = size;
-  size = ((size + LM_ALIGN_TO - 1)) / LM_ALIGN_TO * LM_ALIGN_TO;
-  debug(D_NOTICE, "size=%lu", (unsigned long)origsize);
-  for (i = origsize; i < size; i++)
-    assert(((unsigned char *)ptr)[i] == (((size_t)0xff + origsize - i) & 0xff));
-  size += LM_OVERHEAD;
-#endif
-  assert(*((size_t *)(cptr + size - sizeof(size_t))) == LM_END_MARKER);
-  pthread_mutex_lock(&allocator_mutex);
-  tr = allocator_ranges;
-  while (tr) {
-    range = ptree_element(tr, allocator_range, tree);
-    if (cptr < range->mem)
-      tr = tr->left;
-    else if (cptr >= range->mem + range->size)
-      tr = tr->right;
-    else
-      goto found;
-  }
-  debug(D_CRITICAL, "freeing memory at %p not found in any range", ptr);
-  abort();
-found:
-  psync_interval_tree_add(&range->freeintervals, cptr - range->mem,
-                          cptr - range->mem + size);
-  if (range->freeintervals->from == LM_RANGE_OVERHEAD &&
-      range->freeintervals->to == range->size)
-    ptree_del(&allocator_ranges, &range->tree);
-  else
-    range = NULL;
-  pthread_mutex_unlock(&allocator_mutex);
-  if (range) {
-    debug(D_NOTICE, "freeing block of size %lu at %p",
-          (unsigned long)range->size, range->mem);
-    if (range->locked)
-      pmemlock_unlock(range->mem, range->size);
-    pmem_munmap(range->mem, range->size);
-    psync_free(range);
-  }
-}
-
-int pmemlock_get_pagesize() { 
-  return psync_page_size; 
-}
-
-void pmemlock_set_pagesize(int sz) {
-  psync_page_size = sz;
-}
diff --git a/pclsync/pmemlock.h b/pclsync/pmemlock.h
deleted file mode 100644
index 33c1e3b..0000000
--- a/pclsync/pmemlock.h
+++ /dev/null
@@ -1,48 +0,0 @@
-/*
-   Copyright (c) 2015 Anton Titov.
-
-   Copyright (c) 2015 pCloud Ltd.  All rights reserved.
-
-   Redistribution and use in source and binary forms, with or without
-   modification, are permitted provided that the following conditions
-   are met: Redistributions of source code must retain the above
-   copyright notice, this list of conditions and the following
-   disclaimer.  Redistributions in binary form must reproduce the
-   above copyright notice, this list of conditions and the following
-   disclaimer in the documentation and/or other materials provided
-   with the distribution.  Neither the name of pCloud Ltd nor the
-   names of its contributors may be used to endorse or promote
-   products derived from this software without specific prior written
-   permission.
-
-   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
-   FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL pCloud
-   Ltd BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
-   EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-   PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
-   PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
-   OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
-   USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
-   DAMAGE.
-*/
-
-#ifndef _PSYNC_MEMLOCK_H
-#define _PSYNC_MEMLOCK_H
-
-#include <stdlib.h>
-
-void pmemlock_init();
-
-int pmemlock_lock(void *ptr, size_t size);
-int pmemlock_unlock(void *ptr, size_t size);
-
-void *pmemlock_malloc(size_t size);
-void pmemlock_free(void *ptr);
-
-int pmemlock_get_pagesize();
-void pmemlock_set_pagesize(int sz);
-
-#endif
diff --git a/pclsync/pnetlibs.c b/pclsync/pnetlibs.c
index a93f63d..aaa2851 100644
--- a/pclsync/pnetlibs.c
+++ b/pclsync/pnetlibs.c
@@ -316,7 +316,7 @@ PSYNC_NOINLINE static void psync_apipool_dump_socket(psock_t *api) {
   }
   debug(D_WARNING, "read result from released socket, dumping and aborting");
   print_tree(res, 0);
-  psync_free(res);
+  free(res);
   abort();
 }
 
@@ -347,7 +347,7 @@ static void rm_all(void *vpath, ppath_stat *st) {
     rmdir(path);
   } else
     pfile_delete(path);
-  psync_free(path);
+  free(path);
 }
 
 static void rm_ign(void *vpath, ppath_stat *st) {
@@ -363,7 +363,7 @@ static void rm_ign(void *vpath, ppath_stat *st) {
     rmdir(path);
   } else if (ign)
     pfile_delete(path);
-  psync_free(path);
+  free(path);
 }
 
 int psync_rmdir_with_trashes(const char *path) {
@@ -438,7 +438,7 @@ int psync_get_remote_file_checksum(psync_fileid_t fileid, unsigned char *hexsum,
   result = papi_find_result2(res, "result", PARAM_NUM)->num;
   if (result) {
     debug(D_WARNING, "checksumfile returned error %lu", (unsigned long)result);
-    psync_free(res);
+    free(res);
     return psync_handle_api_result(result);
   }
   meta = papi_find_result2(res, "metadata", PARAM_HASH);
@@ -456,7 +456,7 @@ int psync_get_remote_file_checksum(psync_fileid_t fileid, unsigned char *hexsum,
   psync_sql_bind_lstring(sres, 3, checksum->str, checksum->length);
   psync_sql_run_free(sres);
   memcpy(hexsum, checksum->str, checksum->length);
-  psync_free(res);
+  free(res);
   return PSYNC_NET_OK;
 }
 
@@ -480,7 +480,7 @@ int psync_get_local_file_checksum(const char *restrict filename,
   fd = pfile_open(filename, O_RDONLY, 0);
   if (fd == INVALID_HANDLE_VALUE)
     return PSYNC_NET_PERMFAIL;
-  buff = psync_malloc(PSYNC_COPY_BUFFER_SIZE);
+  buff = malloc(PSYNC_COPY_BUFFER_SIZE);
 retry:
   if (unlikely_log(fstat(fd, &st)))
     goto err1;
@@ -520,7 +520,7 @@ retry:
     pfile_seek(fd, 0, SEEK_SET);
     goto retry;
   }
-  psync_free(buff);
+  free(buff);
   pfile_close(fd);
   psync_hash_final(hashbin, &hctx);
   psync_binhex(hexsum, hashbin, PSYNC_HASH_DIGEST_LEN);
@@ -528,7 +528,7 @@ retry:
     *fsize = pfile_stat_size(&st);
   return PSYNC_NET_OK;
 err1:
-  psync_free(buff);
+  free(buff);
   pfile_close(fd);
   return PSYNC_NET_PERMFAIL;
 }
@@ -552,7 +552,7 @@ int psync_get_local_file_checksum_part(const char *restrict filename,
     return PSYNC_NET_PERMFAIL;
   if (unlikely_log(fstat(fd, &st)))
     goto err1;
-  buff = psync_malloc(PSYNC_COPY_BUFFER_SIZE);
+  buff = malloc(PSYNC_COPY_BUFFER_SIZE);
   psync_hash_init(&hctx);
   psync_hash_init(&hctxp);
   rsz = pfile_stat_size(&st);
@@ -579,7 +579,7 @@ int psync_get_local_file_checksum_part(const char *restrict filename,
     if (++cnt % 16 == 0)
       psys_sleep_milliseconds(5);
   }
-  psync_free(buff);
+  free(buff);
   pfile_close(fd);
   psync_hash_final(hashbin, &hctx);
   psync_binhex(hexsum, hashbin, PSYNC_HASH_DIGEST_LEN);
@@ -589,7 +589,7 @@ int psync_get_local_file_checksum_part(const char *restrict filename,
     *fsize = pfile_stat_size(&st);
   return PSYNC_NET_OK;
 err2:
-  psync_free(buff);
+  free(buff);
 err1:
   pfile_close(fd);
   return PSYNC_NET_PERMFAIL;
@@ -636,7 +636,7 @@ int psync_copy_local_file_if_checksum_matches(const char *source,
   if (unlikely_log(dfd == INVALID_HANDLE_VALUE))
     goto err1;
   psync_hash_init(&hctx);
-  buff = psync_malloc(PSYNC_COPY_BUFFER_SIZE);
+  buff = malloc(PSYNC_COPY_BUFFER_SIZE);
   while (fsize) {
     if (fsize > PSYNC_COPY_BUFFER_SIZE)
       rrd = PSYNC_COPY_BUFFER_SIZE;
@@ -656,13 +656,13 @@ int psync_copy_local_file_if_checksum_matches(const char *source,
   if (unlikely_log(memcmp(hexsum, hashhex, PSYNC_HASH_DIGEST_HEXLEN)) ||
       unlikely_log(pfile_sync(dfd)))
     goto err2;
-  psync_free(buff);
+  free(buff);
   if (unlikely_log(pfile_close(dfd)))
     goto err1;
   pfile_close(sfd);
   return PSYNC_NET_OK;
 err2:
-  psync_free(buff);
+  free(buff);
   pfile_close(dfd);
   pfile_delete(destination);
 err1:
@@ -926,7 +926,7 @@ psync_http_socket *psync_http_connect(const char *host, const char *path,
       goto err0;
   } else
     debug(D_NOTICE, "got connection to %s from cache", host);
-  readbuff = psync_malloc(PSYNC_HTTP_RESP_BUFFER);
+  readbuff = malloc(PSYNC_HTTP_RESP_BUFFER);
   if (!addhdr)
     addhdr = "";
   if (from || to) {
@@ -1010,10 +1010,10 @@ cont:
 ex:
   rl = ptr - readbuff;
   if (rl == rb) {
-    psync_free(readbuff);
+    free(readbuff);
     readbuff = NULL;
   }
-  hsock = (psync_http_socket *)psync_malloc(
+  hsock = (psync_http_socket *)malloc(
       offsetof(psync_http_socket, cachekey) + cl);
   hsock->sock = sock;
   hsock->readbuff = readbuff;
@@ -1025,7 +1025,7 @@ ex:
   memcpy(hsock->cachekey, cachekey, cl);
   return hsock;
 err1:
-  psync_free(readbuff);
+  free(readbuff);
   psync_socket_close_download(sock);
 err0:
   return NULL;
@@ -1048,8 +1048,8 @@ void psync_http_close(psync_http_socket *http) {
     psync_socket_close_download(http->sock);
   }
   if (http->readbuff)
-    psync_free(http->readbuff);
-  psync_free(http);
+    free(http->readbuff);
+  free(http);
 }
 
 int psync_http_readall(psync_http_socket *http, void *buff, int num) {
@@ -1069,7 +1069,7 @@ int psync_http_readall(psync_http_socket *http, void *buff, int num) {
     http->readbuffoff += cp;
     http->readbytes += cp;
     if (http->readbuffoff >= http->readbuffsize) {
-      psync_free(http->readbuff);
+      free(http->readbuff);
       http->readbuff = NULL;
     }
     if (cp == num)
@@ -1130,7 +1130,7 @@ static void connect_cache_thread(void *ptr) {
     pthread_mutex_unlock(&connect_cache_mutex);
     if (sock)
       debug(D_NOTICE, "added connection to %s to cache", node->host);
-    psync_free(node);
+    free(node);
   }
 }
 
@@ -1138,7 +1138,7 @@ connect_cache_tree_node_t *connect_cache_create_node(const char *host) {
   connect_cache_tree_node_t *res;
   size_t len;
   len = strlen(host) + 1;
-  res = (connect_cache_tree_node_t *)psync_malloc(
+  res = (connect_cache_tree_node_t *)malloc(
       offsetof(connect_cache_tree_node_t, host) + len);
   res->usessl = psync_setting_get_bool(_PS(usessl));
   res->haswaiter = 0;
@@ -1257,7 +1257,7 @@ psock_t *connect_cache_wait_for_http_connection(const char *host,
             pthread_cond_wait(&cond, &connect_cache_mutex);
           } while (!node->ready);
           pthread_mutex_unlock(&connect_cache_mutex);
-          psync_free(node);
+          free(node);
           if (sock)
             debug(D_NOTICE, "waited successfully for connection to %s", host);
           return sock;
@@ -1326,10 +1326,10 @@ psync_http_socket *psync_http_connect_multihost(const binresult *hosts,
       }
     }
   }
-  hsock = (psync_http_socket *)psync_malloc(
+  hsock = (psync_http_socket *)malloc(
       offsetof(psync_http_socket, cachekey) + cl);
   hsock->sock = sock;
-  hsock->readbuff = psync_malloc(PSYNC_HTTP_RESP_BUFFER);
+  hsock->readbuff = malloc(PSYNC_HTTP_RESP_BUFFER);
   ;
   hsock->contentlength = -1;
   hsock->readbytes = 0;
@@ -1369,10 +1369,10 @@ psync_http_connect_multihost_from_cache(const binresult *hosts,
   }
   if (!sock)
     return NULL;
-  hsock = (psync_http_socket *)psync_malloc(
+  hsock = (psync_http_socket *)malloc(
       offsetof(psync_http_socket, cachekey) + cl);
   hsock->sock = sock;
-  hsock->readbuff = psync_malloc(PSYNC_HTTP_RESP_BUFFER);
+  hsock->readbuff = malloc(PSYNC_HTTP_RESP_BUFFER);
   ;
   hsock->contentlength = -1;
   hsock->readbytes = 0;
@@ -1563,7 +1563,7 @@ char *psync_url_decode(const char *s) {
   size_t slen;
   char unsigned ch1, ch2;
   slen = strlen(s);
-  ret = p = (char *)psync_malloc(slen + 1);
+  ret = p = (char *)malloc(slen + 1);
   while (slen--) {
     if (*s == '+')
       *p = ' ';
@@ -1618,7 +1618,7 @@ static int psync_net_get_checksums(psock_t *api, psync_fileid_t fileid,
   result = papi_find_result2(res, "result", PARAM_NUM)->num;
   if (result) {
     debug(D_ERROR, "getchecksumlink returned error %lu", (unsigned long)result);
-    psync_free(res);
+    free(res);
     return psync_handle_api_result(result);
   }
   hosts = papi_find_result2(res, "hosts", PARAM_ARRAY);
@@ -1630,7 +1630,7 @@ static int psync_net_get_checksums(psock_t *api, psync_fileid_t fileid,
     if ((http = psync_http_connect(hosts->array[i]->str, requestpath, 0, 0,
                                    cookie)))
       break;
-  psync_free(res);
+  free(res);
   if (unlikely_log(!http))
     return PSYNC_NET_TEMPFAIL;
   if (unlikely_log(psync_http_readall(http, &hdr, sizeof(hdr)) != sizeof(hdr)))
@@ -1644,7 +1644,7 @@ static int psync_net_get_checksums(psock_t *api, psync_fileid_t fileid,
     psync_http_close(http);
     return PSYNC_NET_OK;
   }
-  cs = (psync_file_checksums *)psync_malloc(
+  cs = (psync_file_checksums *)malloc(
       offsetof(psync_file_checksums, blocks) +
       (sizeof(psync_block_checksum) + sizeof(uint32_t)) * i);
   cs->filesize = hdr.filesize;
@@ -1663,7 +1663,7 @@ static int psync_net_get_checksums(psock_t *api, psync_fileid_t fileid,
   debug(D_NOTICE, "checksums downloaded");
   return PSYNC_NET_OK;
 err1:
-  psync_free(cs);
+  free(cs);
 err0:
   psync_http_close(http);
   return PSYNC_NET_TEMPFAIL;
@@ -1689,10 +1689,10 @@ static int psync_net_get_upload_checksums(psock_t *api,
   if (result) {
     debug(D_ERROR, "upload_blockchecksums returned error %lu",
           (unsigned long)result);
-    psync_free(res);
+    free(res);
     return psync_handle_api_result(result);
   }
-  psync_free(res);
+  free(res);
   if (unlikely_log(psync_socket_readall_download(api, &hdr, sizeof(hdr)) !=
                    sizeof(hdr)))
     goto err0;
@@ -1708,7 +1708,7 @@ static int psync_net_get_upload_checksums(psock_t *api,
   }
   if (!hdr.filesize)
     return PSYNC_NET_PERMFAIL;
-  cs = (psync_file_checksums *)psync_malloc(
+  cs = (psync_file_checksums *)malloc(
       offsetof(psync_file_checksums, blocks) +
       (sizeof(psync_block_checksum) + sizeof(uint32_t)) * i);
   cs->filesize = hdr.filesize;
@@ -1725,7 +1725,7 @@ static int psync_net_get_upload_checksums(psock_t *api,
   *checksums = cs;
   return PSYNC_NET_OK;
 err1:
-  psync_free(cs);
+  free(cs);
 err0:
   return PSYNC_NET_TEMPFAIL;
 }
@@ -1779,7 +1779,7 @@ psync_net_create_hash(const psync_file_checksums *checksums) {
       break;
     cnt += 2;
   }
-  h = (psync_file_checksum_hash *)psync_malloc(
+  h = (psync_file_checksum_hash *)malloc(
       offsetof(psync_file_checksum_hash, elements) + sizeof(uint32_t) * cnt);
   h->elementcnt = cnt;
   memset(h->elements, 0, sizeof(uint32_t) * cnt);
@@ -1997,11 +1997,11 @@ static void psync_net_check_file_for_blocks(
   else
     buffersize = PSYNC_COPY_BUFFER_SIZE;
   hbuffersize = buffersize / 2;
-  buff = psync_malloc(buffersize);
+  buff = malloc(buffersize);
   rd = pfile_read(fd, buff, hbuffersize);
   if (unlikely(rd < (ssize_t)hbuffersize)) {
     if (rd < (ssize_t)checksums->blocksize) {
-      psync_free(buff);
+      free(buff);
       pfile_close(fd);
       return;
     }
@@ -2067,7 +2067,7 @@ static void psync_net_check_file_for_blocks(
     adler = adler32_roll(adler, buff[outbyteoff++], buff[inbyteoff++],
                          checksums->blocksize);
   }
-  psync_free(buff);
+  free(buff);
   pfile_close(fd);
 }
 
@@ -2088,7 +2088,7 @@ int psync_net_download_ranges(psync_list *ranges, psync_fileid_t fileid,
   else if (unlikely_log(rt == PSYNC_NET_TEMPFAIL))
     return PSYNC_NET_TEMPFAIL;
   if (unlikely_log(checksums->filesize != filesize)) {
-    psync_free(checksums);
+    free(checksums);
     return PSYNC_NET_TEMPFAIL;
   }
   hash = psync_net_create_hash(checksums);
@@ -2096,7 +2096,7 @@ int psync_net_download_ranges(psync_list *ranges, psync_fileid_t fileid,
   memset(blockactions, 0, sizeof(psync_block_action) * checksums->blockcnt);
   for (i = 0; i < filecnt; i++)
     psync_net_check_file_for_blocks(files[i], checksums, hash, blockactions, i);
-  psync_free(hash);
+  free(hash);
   range = psync_new(psync_range_list_t);
   range->len = checksums->blocksize;
   range->type = blockactions[0].type;
@@ -2129,8 +2129,8 @@ int psync_net_download_ranges(psync_list *ranges, psync_fileid_t fileid,
     } else
       range->len += bs;
   }
-  psync_free(checksums);
-  psync_free(blockactions);
+  free(checksums);
+  free(blockactions);
   return PSYNC_NET_OK;
 fulldownload:
   range = psync_new(psync_range_list_t);
@@ -2165,10 +2165,10 @@ static int check_range_for_blocks(psync_file_checksums *checksums,
   else
     buffersize = PSYNC_COPY_BUFFER_SIZE;
   hbuffersize = buffersize / 2;
-  buff = psync_malloc(buffersize);
+  buff = malloc(buffersize);
   rd = pfile_read(fd, buff, hbuffersize);
   if (unlikely(rd < (ssize_t)hbuffersize)) {
-    psync_free(buff);
+    free(buff);
     return PSYNC_NET_OK;
   } else
     bufferlen = buffersize;
@@ -2272,7 +2272,7 @@ static int check_range_for_blocks(psync_file_checksums *checksums,
     adler = adler32_roll(adler, buff[outbyteoff++], buff[inbyteoff++],
                          checksums->blocksize);
   }
-  psync_free(buff);
+  free(buff);
   return PSYNC_NET_OK;
 }
 
@@ -2299,7 +2299,7 @@ static void merge_list_to_element(psync_upload_range_list_t *le,
       assertw(psync_list_isempty(rlist));
       psync_list_add_after(&le->list, &ur->list);
       psync_list_del(&le->list);
-      psync_free(le);
+      free(le);
     } else if (ur->uploadoffset == le->uploadoffset) {
       psync_list_add_before(&le->list, &ur->list);
       le->uploadoffset += ur->len;
@@ -2346,8 +2346,8 @@ int psync_net_scan_file_for_blocks(psock_t *api, psync_list *rlist,
     psync_list_init(&nr);
     if (check_range_for_blocks(checksums, hash, ur->off, ur->len, fd, &nr) ==
         PSYNC_NET_TEMPFAIL) {
-      psync_free(hash);
-      psync_free(checksums);
+      free(hash);
+      free(checksums);
       return PSYNC_NET_TEMPFAIL;
     }
     if (!psync_list_isempty(&nr)) {
@@ -2359,8 +2359,8 @@ int psync_net_scan_file_for_blocks(psock_t *api, psync_list *rlist,
       merge_list_to_element(ur, &nr);
     }
   }
-  psync_free(hash);
-  psync_free(checksums);
+  free(hash);
+  free(checksums);
   return PSYNC_NET_OK;
 }
 
@@ -2387,8 +2387,8 @@ int psync_net_scan_upload_for_blocks(psock_t *api, psync_list *rlist,
     psync_list_init(&nr);
     if (check_range_for_blocks(checksums, hash, ur->off, ur->len, fd, &nr) ==
         PSYNC_NET_TEMPFAIL) {
-      psync_free(hash);
-      psync_free(checksums);
+      free(hash);
+      free(checksums);
       return PSYNC_NET_TEMPFAIL;
     }
     if (!psync_list_isempty(&nr)) {
@@ -2399,8 +2399,8 @@ int psync_net_scan_upload_for_blocks(psock_t *api, psync_list *rlist,
       merge_list_to_element(ur, &nr);
     }
   }
-  psync_free(hash);
-  psync_free(checksums);
+  free(hash);
+  free(checksums);
   return PSYNC_NET_OK;
 }
 
@@ -2446,7 +2446,7 @@ static int download_file_revisions(psync_fileid_t fileid) {
   result = papi_find_result2(res, "result", PARAM_NUM)->num;
   if (result) {
     debug(D_ERROR, "listrevisions returned error %lu", (unsigned long)result);
-    psync_free(res);
+    free(res);
     return psync_handle_api_result(result);
   }
   revs = papi_find_result2(res, "revisions", PARAM_ARRAY);
@@ -2487,7 +2487,7 @@ static int download_file_revisions(psync_fileid_t fileid) {
                          PSYNC_HASH_DIGEST_HEXLEN);
   psync_sql_run_free(hc);
   psync_sql_commit_transaction();
-  psync_free(res);
+  free(res);
   return PSYNC_NET_OK;
 }
 
@@ -2515,7 +2515,7 @@ psync_file_lock_t *psync_lock_file(const char *path) {
   size_t len;
   int cmp;
   len = strlen(path) + 1;
-  lock = psync_malloc(offsetof(psync_file_lock_t, filename) + len);
+  lock = malloc(offsetof(psync_file_lock_t, filename) + len);
   memcpy(lock->filename, path, len);
   pthread_mutex_lock(&file_lock_mutex);
   tr = file_lock_tree;
@@ -2539,7 +2539,7 @@ psync_file_lock_t *psync_lock_file(const char *path) {
       }
     } else {
       pthread_mutex_unlock(&file_lock_mutex);
-      psync_free(lock);
+      free(lock);
       return NULL;
     }
   }
@@ -2553,7 +2553,7 @@ void psync_unlock_file(psync_file_lock_t *lock) {
   pthread_mutex_lock(&file_lock_mutex);
   ptree_del(&file_lock_tree, &lock->tree);
   pthread_mutex_unlock(&file_lock_mutex);
-  psync_free(lock);
+  free(lock);
 }
 
 int psync_get_upload_checksum(psync_uploadid_t uploadid, unsigned char *uhash,
@@ -2573,13 +2573,13 @@ int psync_get_upload_checksum(psync_uploadid_t uploadid, unsigned char *uhash,
   }
   psync_apipool_release(api);
   if (papi_find_result2(res, "result", PARAM_NUM)->num) {
-    psync_free(res);
+    free(res);
     return PSYNC_NET_PERMFAIL;
   }
   *usize = papi_find_result2(res, "size", PARAM_NUM)->num;
   memcpy(uhash, papi_find_result2(res, PSYNC_CHECKSUM, PARAM_STR)->str,
          PSYNC_HASH_DIGEST_HEXLEN);
-  psync_free(res);
+  free(res);
   return PSYNC_NET_OK;
 }
 
@@ -2610,11 +2610,11 @@ static void psync_send_debug_thread(void *ptr) {
     debug(D_NOTICE, "sending debug %s", str);
     res = psync_api_run_command("senddebug", params);
     if (res) {
-      psync_free(res);
-      psync_free(last);
+      free(res);
+      free(last);
       last = str;
     } else
-      psync_free(str);
+      free(str);
   } else
     free(str);
   pthread_mutex_unlock(&m);
@@ -2629,7 +2629,7 @@ int psync_send_debug(int thread, const char *file, const char *function,
   ret = pdevice_id();
   snprintf(format, sizeof(format), "%s %s: %s:%u (function %s): %s\n", ret,
            psync_thread_name, file, line, function, fmt);
-  psync_free(ret);
+  free(ret);
   format[sizeof(format) - 1] = 0;
   ret = NULL;
   l = 511;
@@ -2684,7 +2684,7 @@ int psync_do_run_command_res(const char *cmd, size_t cmdlen,
       *err = psync_strdup(papi_find_result2(res, "error", PARAM_STR)->str);
     psync_process_api_error(result);
   }
-  psync_free(res);
+  free(res);
   return (int)result;
 neterr:
   if (err)
diff --git a/pclsync/pnotify.c b/pclsync/pnotify.c
index cf0c6b7..e5014a5 100644
--- a/pclsync/pnotify.c
+++ b/pclsync/pnotify.c
@@ -60,7 +60,7 @@ const char *pnotify_get_thumb_size() { return ntf_thumb_size; }
 void pnotify_notify(binresult *res) {
   pthread_mutex_lock(&ntf_mutex);
   if (ntf_result)
-    psync_free(ntf_result);
+    free(ntf_result);
   ntf_result = res;
   pthread_cond_signal(&ntf_cond);
   pthread_mutex_unlock(&ntf_mutex);
@@ -101,7 +101,7 @@ static void psync_notifications_download_thumb(const binresult *thumb,
     goto err3;
   if (unlikely_log(psync_http_next_request(sock)))
     goto err3;
-  buff = (char *)psync_malloc(PSYNC_COPY_BUFFER_SIZE);
+  buff = (char *)malloc(PSYNC_COPY_BUFFER_SIZE);
   while (1) {
     rd = psync_http_request_readall(sock, buff, PSYNC_COPY_BUFFER_SIZE);
     if (rd <= 0)
@@ -109,7 +109,7 @@ static void psync_notifications_download_thumb(const binresult *thumb,
     if (pfile_write(fd, buff, rd) != rd)
       break;
   }
-  psync_free(buff);
+  free(buff);
 err3:
   psync_http_close(sock);
 err2:
@@ -119,9 +119,9 @@ err1:
     debug(D_NOTICE, "downloaded thumbnail %s", filename);
   else
     debug(D_WARNING, "downloading of thumbnail %s failed", filename);
-  psync_free(tmpfilepath);
+  free(tmpfilepath);
 err0:
-  psync_free(filepath);
+  free(filepath);
 }
 
 static void psync_notifications_set_current_list(binresult *res,
@@ -145,13 +145,13 @@ static void psync_notifications_set_current_list(binresult *res,
   ores = ntf_processed_result;
   if (ntf_processing == 2) {
     ntf_processed_result = NULL;
-    psync_free(res);
+    free(res);
   } else
     ntf_processed_result = res;
   ntf_processing = 0;
   cb = ntf_callback;
   pthread_mutex_unlock(&ntf_mutex);
-  psync_free(ores);
+  free(ores);
   if (cb) {
     debug(D_NOTICE, "calling notification callback, cnt=%u, newcnt=%u",
           (unsigned)cnttotal, (unsigned)cntnew);
@@ -178,7 +178,7 @@ static void psync_notifications_thread() {
     pthread_mutex_unlock(&ntf_mutex);
     psync_notifications_set_current_list(res, thumbpath);
   }
-  psync_free(thumbpath);
+  free(thumbpath);
 }
 
 void pnotify_set_callback(
@@ -258,7 +258,7 @@ static void psync_notifications_thumb_dir_list(void *ptr,
   } else
     addto = tree;
   len = strlen(st->name) + 1;
-  tl = (psync_thumb_list_t *)psync_malloc(offsetof(psync_thumb_list_t, name) +
+  tl = (psync_thumb_list_t *)malloc(offsetof(psync_thumb_list_t, name) +
                                           len);
   memcpy(tl->name, st->name, len);
   *addto = &tl->tree;
@@ -336,7 +336,7 @@ psync_notification_list_t *pnotify_get() {
             debug(D_WARNING,
                   "could not stat thumb %s which is supposed to be downloaded",
                   filename);
-          psync_free(filepath);
+          free(filepath);
         }
       }
       pntf->mtime = papi_find_result2(ntf, "mtime", PARAM_NUM)->num;
@@ -359,11 +359,11 @@ psync_notification_list_t *pnotify_get() {
         thumbpath, "/",
         ptree_element(thumbs, psync_thumb_list_t, tree)->name, NULL);
     pfile_delete(filepath);
-    psync_free(filepath);
-    psync_free(ptree_element(thumbs, psync_thumb_list_t, tree));
+    free(filepath);
+    free(ptree_element(thumbs, psync_thumb_list_t, tree));
     thumbs = nx;
   }
-  psync_free(thumbpath);
+  free(thumbpath);
   res = (psync_notification_list_t *)psync_list_builder_finalize(builder);
   res->newnotificationcnt = cntnew;
   return res;
@@ -382,14 +382,14 @@ void pnotify_clean() {
   thumbpath = ppath_private(PSYNC_DEFAULT_NTF_THUMB_DIR);
   if (thumbpath) {
     ppath_ls(thumbpath, psync_notifications_del_thumb, NULL);
-    psync_free(thumbpath);
+    free(thumbpath);
   }
   if (ntf_processed_result) {
-    psync_free(ntf_processed_result);
+    free(ntf_processed_result);
     ntf_processed_result = NULL;
   }
   if (ntf_result) {
-    psync_free(ntf_result);
+    free(ntf_result);
     ntf_result = NULL;
   }
   if (ntf_processing == 1)
diff --git a/pclsync/pp2p.c b/pclsync/pp2p.c
index 549c24a..572e31b 100644
--- a/pclsync/pp2p.c
+++ b/pclsync/pp2p.c
@@ -198,11 +198,11 @@ static int is_downloading(const unsigned char *hashstart,
     if (!memcmp(hashhex, genhash, PSYNC_HASH_DIGEST_HEXLEN)) {
       if (realhash)
         memcpy(realhash, hashsource, PSYNC_HASH_DIGEST_HEXLEN);
-      psync_free(hashes);
+      free(hashes);
       return 1;
     }
   }
-  psync_free(hashes);
+  free(hashes);
   return 0;
 }
 
@@ -312,7 +312,7 @@ static int check_token(char *token, uint32_t tlen, unsigned char *key,
   }
   psync_apipool_release(api);
   result = papi_find_result2(res, "result", PARAM_NUM)->num;
-  psync_free(res);
+  free(res);
   return result ? 0 : 1;
 }
 
@@ -332,7 +332,7 @@ static void psync_p2p_tcphandler(void *ptr) {
   uint32_t keylen, enctype;
   unsigned char hashhex[PSYNC_HASH_DIGEST_HEXLEN], buff[4096];
   sock = *((int *)ptr);
-  psync_free(ptr);
+  free(ptr);
   debug(D_NOTICE, "got tcp connection");
   if (unlikely_log(socket_read_all(sock, &packet, sizeof(packet))))
     goto err0;
@@ -349,20 +349,20 @@ static void psync_p2p_tcphandler(void *ptr) {
   binpubrsa = pssl_alloc_binary_rsa(packet.keylen);
   if (unlikely_log(
           socket_read_all(sock, binpubrsa->data, binpubrsa->datalen))) {
-    psync_free(binpubrsa);
+    free(binpubrsa);
     goto err0;
   }
   token = psync_new_cnt(char, packet.tokenlen);
   if (unlikely_log(socket_read_all(sock, token, packet.tokenlen)) ||
       unlikely_log(!check_token(token, packet.tokenlen, binpubrsa->data,
                                 packet.keylen, hashhex))) {
-    psync_free(binpubrsa);
-    psync_free(token);
+    free(binpubrsa);
+    free(token);
     goto err0;
   }
-  psync_free(token);
+  free(token);
   pubrsa = prsa_binary_to_public(binpubrsa);
-  psync_free(binpubrsa);
+  free(binpubrsa);
   if (unlikely_log(pubrsa == PSYNC_INVALID_RSA))
     goto err0;
   localpath = pfolder_lpath_lfile(localfileid, NULL);
@@ -370,7 +370,7 @@ static void psync_p2p_tcphandler(void *ptr) {
     goto err0;
   fd = pfile_open(localpath, O_RDONLY, 0);
   debug(D_NOTICE, "sending file %s to peer", localpath);
-  psync_free(localpath);
+  free(localpath);
   if (fd == INVALID_HANDLE_VALUE) {
     debug(D_WARNING, "could not open local file %lu",
           (unsigned long)localfileid);
@@ -389,13 +389,13 @@ static void psync_p2p_tcphandler(void *ptr) {
           socket_write_all(sock, &enctype, sizeof(enctype)) ||
           socket_write_all(sock, encaeskey->data, encaeskey->datalen))) {
     if (encaeskey != PSYNC_INVALID_ENC_SYM_KEY)
-      psync_free(encaeskey);
+      free(encaeskey);
     if (encoder != PSYNC_CRYPTO_INVALID_ENCODER)
       pcrypto_ctr_encdec_free(encoder);
     pfile_close(fd);
     goto err0;
   }
-  psync_free(encaeskey);
+  free(encaeskey);
   off = 0;
   while (off < packet.filesize) {
     if (packet.filesize - off < sizeof(buff))
@@ -511,7 +511,7 @@ static void psync_p2p_thread() {
       inconn = psync_new(int);
       *inconn = accept(tcpsock, NULL, NULL);
       if (unlikely_log(*inconn == INVALID_SOCKET))
-        psync_free(inconn);
+        free(inconn);
       else
         prun_thread1("p2p tcp", psync_p2p_tcphandler, inconn);
     }
@@ -635,14 +635,14 @@ static int psync_p2p_get_download_token(psync_fileid_t fileid,
   }
   psync_apipool_release(api);
   if (unlikely_log(papi_find_result2(res, "result", PARAM_NUM)->num != 0)) {
-    psync_free(res);
+    free(res);
     return PSYNC_NET_PERMFAIL;
   }
   ctoken = papi_find_result2(res, "token", PARAM_STR);
-  *token = psync_malloc(ctoken->length + 1);
+  *token = malloc(ctoken->length + 1);
   memcpy(*token, ctoken->str, ctoken->length + 1);
   *tlen = ctoken->length;
-  psync_free(res);
+  free(res);
   return PSYNC_NET_OK;
 }
 
@@ -678,10 +678,10 @@ static int psync_p2p_download(int sock, psync_fileid_t fileid,
                         &privkey, &ekey)) == PSYNC_INVALID_SYM_KEY)) {
     // unlikely_log((key=psymkey_decrypt(&psync_rsa_private,
     // &ekey))==PSYNC_INVALID_SYM_KEY)){
-    psync_free(ekey);
+    free(ekey);
     return PSYNC_NET_TEMPFAIL;
   }
-  psync_free(ekey);
+  free(ekey);
   decoder = pcrypto_ctr_encdec_create(key);
   psymkey_free(key);
   if (decoder == PSYNC_CRYPTO_INVALID_ENCODER)
@@ -835,8 +835,8 @@ int pp2p_check_download(psync_fileid_t fileid,
   for (i = 0; i < il->interfacecnt; i++)
     if (sockets[i] != INVALID_SOCKET)
       close(sockets[i]);
-  psync_free(il);
-  psync_free(sockets);
+  free(il);
+  free(sockets);
   if (bresp == P2P_RESP_NOPE)
     goto err_perm2;
   else if (bresp == P2P_RESP_WAIT) {
@@ -890,24 +890,24 @@ int pp2p_check_download(psync_fileid_t fileid,
     debug(D_WARNING, "writing to socket failed");
     goto err_temp3;
   }
-  psync_free(token);
+  free(token);
   sret = psync_p2p_download(sock, fileid, filehashhex, fsize, filename);
   close(sock);
   return sret;
 err_perm3:
-  psync_free(token);
+  free(token);
   goto err_perm2;
 err_perm:
   for (i = 0; i < il->interfacecnt; i++)
     if (sockets[i] != INVALID_SOCKET)
       close(sockets[i]);
-  psync_free(il);
-  psync_free(sockets);
+  free(il);
+  free(sockets);
 err_perm2:
   return PSYNC_NET_PERMFAIL;
 err_temp3:
   close(sock);
-  psync_free(token);
+  free(token);
 err_temp2:
   return PSYNC_NET_TEMPFAIL;
 }
diff --git a/pclsync/ppagecache.c b/pclsync/ppagecache.c
index f99fc40..ac24842 100644
--- a/pclsync/ppagecache.c
+++ b/pclsync/ppagecache.c
@@ -330,7 +330,7 @@ static void psync_pagecache_send_page_wait_page(psync_page_wait_t *pw,
     pwt->waiting_for = NULL;
     pthread_cond_broadcast(&pwt->cond);
   }
-  psync_free(pw);
+  free(pw);
 }
 
 static void psync_pagecache_return_free_page_locked(psync_cache_page_t *page) {
@@ -360,13 +360,13 @@ static int psync_pagecache_read_range_from_api(psync_request_t *request,
     return -2;
   dlen = papi_find_result2(res, "result", PARAM_NUM)->num;
   if (unlikely(dlen)) {
-    psync_free(res);
+    free(res);
     debug(D_WARNING, "readfile returned error %lu", (long unsigned)dlen);
     psync_process_api_error(dlen);
     return -2;
   }
   dlen = papi_find_result2(res, "data", PARAM_DATA)->num;
-  psync_free(res);
+  free(res);
   for (i = 0; i < len; i++) {
     page = psync_pagecache_get_free_page(0);
     rb = psync_socket_readall_download_thread(
@@ -499,7 +499,7 @@ static int wait_shared_api() {
   }
   pthread_mutex_unlock(&sharedapi_mutex);
   pthread_cond_destroy(&waiter->cond);
-  psync_free(waiter);
+  free(waiter);
   return ret;
 }
 
@@ -516,7 +516,7 @@ static void set_urls(psync_urls_t *urls, binresult *res) {
       urls->status = 2;
       pthread_cond_broadcast(&url_cache_cond);
     } else
-      psync_free(urls);
+      free(urls);
   }
   pthread_mutex_unlock(&url_cache_mutex);
 }
@@ -584,7 +584,7 @@ static int get_urls(psync_request_t *request, psync_urls_t *urls) {
     result = papi_find_result2(ret, "result", PARAM_NUM)->num;
     if (unlikely(result != 0)) {
       debug(D_WARNING, "getfilelink returned error %lu", result);
-      psync_free(ret);
+      free(ret);
       mark_shared_api_bad(api);
       psync_apipool_release_bad(api);
       psync_process_api_error(result);
@@ -613,7 +613,7 @@ static int get_urls(psync_request_t *request, psync_urls_t *urls) {
       if (unlikely_log(psync_crypto_is_error(enc)))
         goto err4;
       debug(D_NOTICE, "got key for fileid %lu", (unsigned long)request->fileid);
-      psync_free(ret);
+      free(ret);
       psync_fs_lock_file(request->of);
       if (likely_log(request->of->encoder ==
                      PSYNC_CRYPTO_LOADING_SECTOR_ENCODER)) {
@@ -632,7 +632,7 @@ static int get_urls(psync_request_t *request, psync_urls_t *urls) {
       psync_list_del(l1);
       debug(D_NOTICE, "request for offset %lu, size %lu read from API",
             (unsigned long)range->offset, (unsigned long)range->length);
-      psync_free(range);
+      free(range);
     }
     if (pass_shared_api(api))
       psync_apipool_release(api);
@@ -642,7 +642,7 @@ static int get_urls(psync_request_t *request, psync_urls_t *urls) {
   }
   return -1;
 err4:
-  psync_free(ret);
+  free(ret);
 err3:
   if (request->needkey)
     psync_pagecache_set_bad_encoder(request->of);
@@ -692,7 +692,7 @@ static psync_urls_t *get_urls_for_request(psync_request_t *req) {
       return urls;
     }
     if (--urls->refcnt == 0)
-      psync_free(urls);
+      free(urls);
     pthread_mutex_unlock(&url_cache_mutex);
     return NULL;
   }
@@ -727,13 +727,13 @@ static void release_urls(psync_urls_t *urls) {
       etime = papi_find_result2(urls->urls, "expires", PARAM_NUM)->num;
       if (etime > ctime + 3600) {
         psync_get_string_id(buff, "URLS", urls->hash);
-        pcache_add(buff, urls->urls, etime - ctime - 3600, psync_free, 2);
+        pcache_add(buff, urls->urls, etime - ctime - 3600, free, 2);
         urls->urls = NULL;
       }
     }
     pthread_mutex_unlock(&url_cache_mutex);
-    psync_free(urls->urls);
-    psync_free(urls);
+    free(urls->urls);
+    free(urls);
     return;
   }
   pthread_mutex_unlock(&url_cache_mutex);
@@ -749,8 +749,8 @@ static void release_bad_urls(psync_urls_t *urls) {
     urls = NULL;
   pthread_mutex_unlock(&url_cache_mutex);
   if (urls) {
-    psync_free(urls->urls);
-    psync_free(urls);
+    free(urls->urls);
+    free(urls);
   }
 }
 
@@ -1039,7 +1039,7 @@ static void clean_cache() {
   }
   clean_cache_in_progress = 1;
   psync_sql_sync();
-  entries = (pagecache_entry *)psync_malloc(cnt * sizeof(pagecache_entry));
+  entries = (pagecache_entry *)malloc(cnt * sizeof(pagecache_entry));
   i = 0;
   e = 0;
   while (i < cnt) {
@@ -1180,7 +1180,7 @@ static void clean_cache() {
   psync_sql_commit_transaction();
   clean_cache_in_progress = 0;
   pthread_mutex_unlock(&clean_cache_mutex);
-  psync_free(oentries);
+  free(oentries);
   debug(D_NOTICE, "syncing database");
   psync_sql_sync();
   debug(D_NOTICE, "finished cleaning cache, free cache pages %u",
@@ -1750,7 +1750,7 @@ static void check_pages_in_database_by_hash(uint64_t hash,
   }
   if (fres->rows)
     mark_pagescache_used(first_page_id, pagecnt, dbread);
-  psync_free(fres);
+  free(fres);
 }
 
 static long check_page_in_database_by_hash_and_cache(uint64_t hash,
@@ -1898,8 +1898,8 @@ int ppagecache_read_mod_locked(psync_openfile_t *of, char *buf,
 
 static void psync_pagecache_free_request(psync_request_t *request) {
   psync_list_for_each_element_call(&request->ranges, psync_request_range_t,
-                                   list, psync_free);
-  psync_free(request);
+                                   list, free);
+  free(request);
 }
 
 static void psync_pagecache_send_error_page_wait(psync_page_wait_t *pw,
@@ -1912,7 +1912,7 @@ static void psync_pagecache_send_error_page_wait(psync_page_wait_t *pw,
     pwt->ready = 1;
     pthread_cond_broadcast(&pwt->cond);
   }
-  psync_free(pw);
+  free(pw);
 }
 
 static void psync_pagecache_send_range_error(psync_request_range_t *range,
@@ -2226,7 +2226,7 @@ retry:
       err = psync_http_request_range_additional(
           sock, host, path, range->offset, range->offset + range->length - 1,
           range_hdr);
-      psync_free(range_hdr);
+      free(range_hdr);
     } else
       err = psync_http_request(sock, host, path, range->offset,
                                range->offset + range->length - 1, cookie);
@@ -2475,7 +2475,7 @@ static void psync_pagecache_read_unmodified_readahead(
     }
   }
   unlock_wait(hash);
-  psync_free(pages_in_db);
+  free(pages_in_db);
   if (!psync_list_isempty(ranges))
     debug(D_NOTICE,
           "readahead=%lu, rto=%lu, offset=%lu, size=%lu, currentspeed=%u",
@@ -2485,7 +2485,7 @@ static void psync_pagecache_read_unmodified_readahead(
 
 static void psync_free_page_waiter(psync_page_waiter_t *pwt) {
   pthread_cond_destroy(&pwt->cond);
-  psync_free(pwt);
+  free(pwt);
 }
 
 static psync_page_waiter_t *
@@ -2636,7 +2636,7 @@ int ppagecache_read_unmod_locked(psync_openfile_t *of, char *buf,
     prun_thread1("read unmodified", psync_pagecache_read_unmodified_thread,
                       rq);
   } else
-    psync_free(rq);
+    free(rq);
   ret = size;
   if (!psync_list_isempty(&waiting)) {
     psync_list_for_each_element(pwt, &waiting, psync_page_waiter_t,
@@ -2676,7 +2676,7 @@ static void free_waiters(psync_list *waiters) {
       pw = pwt->waiting_for;
       if (psync_list_isempty(&pw->waiters)) {
         psync_list_del(&pw->list);
-        psync_free(pw);
+        free(pw);
       }
     }
     psync_free_page_waiter(pwt);
@@ -2885,7 +2885,7 @@ int ppagecache_read_unmod_enc_locked(psync_openfile_t *of,
     prun_thread1("crypto read unmodified",
                       psync_pagecache_read_unmodified_thread, rq);
   } else
-    psync_free(rq);
+    free(rq);
   ret = 0;
   if (needkey) {
     debug(D_NOTICE, "waiting for key to download");
@@ -3012,14 +3012,12 @@ int ppagecache_read_unmod_enc_locked(psync_openfile_t *of,
   if (!ret)
     ret = size;
 ret0:
-  psync_list_for_each_element_call(&waiting, psync_page_waiter_t, listwaiter,
-                                   psync_free);
-  psync_list_for_each_element_call(&auth_pages, psync_crypto_auth_page, list,
-                                   psync_free);
+  psync_list_for_each_element_call(&waiting, psync_page_waiter_t, listwaiter, free);
+  psync_list_for_each_element_call(&auth_pages, psync_crypto_auth_page, list, free);
   for (i = 0; i < pagecnt; i++)
     if (dp[i].freebuff)
-      psync_free(dp[i].buff);
-  psync_free(dp);
+      free(dp[i].buff);
+  free(dp);
   return ret;
 err0:
   free_waiters(&waiting);
@@ -3103,7 +3101,7 @@ int ppagecache_readv_locked(psync_openfile_t *of,
   }
   if (psync_list_isempty(&rq->ranges) && !needkey) {
     if (psync_list_isempty(&waiting)) {
-      psync_free(rq);
+      free(rq);
       return 0;
     }
   } else {
@@ -3218,7 +3216,7 @@ static void psync_pagecache_new_upload_to_cache(uint64_t taskid, uint64_t hash,
     debug(D_ERROR, "could not open cache file %s for taskid %lu, skipping",
           filename, (unsigned long)taskid);
     pfile_delete(filename);
-    psync_free(filename);
+    free(filename);
     return;
   }
   debug(D_NOTICE, "adding file %s to cache for hash %lu (%ld) size %ld",
@@ -3251,7 +3249,7 @@ static void psync_pagecache_new_upload_to_cache(uint64_t taskid, uint64_t hash,
   pfile_delete(filename);
   debug(D_NOTICE, "finished adding file %s to cache for hash %lu (%ld)",
         filename, (unsigned long)hash, (long)hash);
-  psync_free(filename);
+  free(filename);
 }
 
 static void switch_pageids(uint64_t hash, uint64_t oldhash, uint64_t *pageids,
@@ -3308,8 +3306,8 @@ static void psync_pagecache_modify_to_cache(uint64_t taskid, uint64_t hash,
           indexname, (unsigned long)taskid);
     pfile_delete(filename);
     pfile_delete(indexname);
-    psync_free(filename);
-    psync_free(indexname);
+    free(filename);
+    free(indexname);
     return;
   }
   tree = NULL;
@@ -3480,9 +3478,9 @@ err2:
 err1:
   psync_interval_tree_free(tree);
   pfile_delete(filename);
-  psync_free(filename);
+  free(filename);
   pfile_delete(indexname);
-  psync_free(indexname);
+  free(indexname);
 }
 
 static void psync_pagecache_check_free_space() {
@@ -3597,7 +3595,7 @@ int ppagecache_have_all_pages(uint64_t hash, uint64_t size) {
   for (i = 0; i < pagecnt; i++)
     if (!db[i] && !has_page_in_cache_by_hash(hash, i))
       break;
-  psync_free(db);
+  free(db);
   return i == pagecnt;
 }
 
@@ -3828,7 +3826,7 @@ void ppagecache_init() {
           (unsigned long)db_cache_max_page);
   }
   readcache = pfile_open(cache_file, O_RDWR, O_CREAT);
-  psync_free(cache_file);
+  free(cache_file);
   if (likely_log(pfile_seek(readcache,
                                  db_cache_max_page * PSYNC_FS_PAGE_SIZE,
                                  SEEK_SET) != -1))
@@ -3879,7 +3877,7 @@ void ppagecache_reopen_read() {
   cache_file = psync_strcat(cache_dir, "/",
                             PSYNC_DEFAULT_READ_CACHE_FILE, NULL);
   readcache = pfile_open(cache_file, O_RDWR, O_CREAT);
-  psync_free(cache_file);
+  free(cache_file);
 }
 
 void ppagecache_clean_read() {
@@ -3927,12 +3925,12 @@ int ppagecache_move(const char *path) {
   rdpath = psync_strcat(path, "/",
                         PSYNC_DEFAULT_READ_CACHE_FILE, NULL);
   if (!stat(rdpath, &st)) {
-    psync_free(rdpath);
+    free(rdpath);
     return PRINT_RETURN_CONST(PERROR_CACHE_MOVE_NOT_EMPTY);
   }
   newrdcache = pfile_open(rdpath, O_RDWR, O_CREAT | O_EXCL);
   if (newrdcache == INVALID_HANDLE_VALUE) {
-    psync_free(rdpath);
+    free(rdpath);
     return PRINT_RETURN_CONST(PERROR_CACHE_MOVE_NO_WRITE_ACCESS);
   }
   opath = psync_strdup(psync_setting_get_string(_PS(fscachepath)));
@@ -3957,8 +3955,8 @@ int ppagecache_move(const char *path) {
     pthread_mutex_unlock(&clean_cache_mutex);
     pfile_close(newrdcache);
     pfile_delete(rdpath);
-    psync_free(opath);
-    psync_free(rdpath);
+    free(opath);
+    free(rdpath);
     return PRINT_RETURN_CONST(PERROR_CACHE_MOVE_DRIVE_HAS_TASKS);
   }
   ordcache = readcache;
@@ -3991,8 +3989,8 @@ int ppagecache_move(const char *path) {
   debug(D_NOTICE, "released locks");
   pfile_close(ordcache);
   ppath_ls(opath, clean_cache_del, (void *)1);
-  psync_free(opath);
-  psync_free(rdpath);
+  free(opath);
+  free(rdpath);
   debug(D_NOTICE, "end");
   return 0;
 }
diff --git a/pclsync/ppassword.c b/pclsync/ppassword.c
index 8a471b2..b1c5b15 100644
--- a/pclsync/ppassword.c
+++ b/pclsync/ppassword.c
@@ -354,8 +354,8 @@ uint64_t ppassword_score(const char *cpassword) {
   num = score_variants(password, lpwd, ldpwd, plen);
   putil_wipe(lpwd, plen);
   putil_wipe(ldpwd, plen);
-  psync_free(lpwd);
-  psync_free(ldpwd);
+  free(lpwd);
+  free(ldpwd);
   mul_score(num);
   return score;
 }
diff --git a/pclsync/ppath.c b/pclsync/ppath.c
index a67d028..a30210f 100644
--- a/pclsync/ppath.c
+++ b/pclsync/ppath.c
@@ -19,24 +19,24 @@ char *ppath_default_db() {
   }
 
   dbp = psync_strcat(pcdir, "/", PSYNC_DEFAULT_DB_NAME, NULL);
-  psync_free(pcdir);
+  free(pcdir);
 
   if (stat(dbp, &st)) {
     // Inline the old database path function here
     if ((home = ppath_home())) {
       oldp = psync_strcat(home, "/", PSYNC_DEFAULT_POSIX_DBNAME, NULL);
-      psync_free(home);
+      free(home);
 
       if (oldp) {
         if (!stat(oldp, &st)) {
           if (psync_sql_reopen(oldp)) {
-            psync_free(dbp);
+            free(dbp);
             return oldp;
           } else {
             pfile_rename(oldp, dbp);
           }
         }
-        psync_free(oldp);
+        free(oldp);
       }
     }
   }
@@ -85,7 +85,7 @@ int ppath_ls(const char *path, ppath_ls_cb callback, void *ptr) {
   }
 
   pl = strlen(path);
-  cpath = (char *)psync_malloc(pl + NAME_MAX + 2);
+  cpath = (char *)malloc(pl + NAME_MAX + 2);
   memcpy(cpath, path, pl);
   if (!pl || cpath[pl - 1] != '/')
     cpath[pl++] = '/';
@@ -107,7 +107,7 @@ int ppath_ls(const char *path, ppath_ls_cb callback, void *ptr) {
     }
   }
 
-  psync_free(cpath);
+  free(cpath);
   closedir(dh);
   return 0;
 }
@@ -127,7 +127,7 @@ int ppath_ls_fast(const char *path, ppath_ls_fast_cb callback, void *ptr) {
   }
 
   pl = strlen(path);
-  cpath = (char *)psync_malloc(pl + NAME_MAX + 2);
+  cpath = (char *)malloc(pl + NAME_MAX + 2);
   memcpy(cpath, path, pl);
   if (!pl || cpath[pl - 1] != '/')
     cpath[pl++] = '/';
@@ -157,7 +157,7 @@ int ppath_ls_fast(const char *path, ppath_ls_fast_cb callback, void *ptr) {
     // Ignore other file types
   }
 
-  psync_free(cpath);
+  free(cpath);
   closedir(dh);
   return 0;
 }
@@ -171,14 +171,14 @@ char *ppath_pcloud() {
   }
 
   path = psync_strcat(homedir, "/", PSYNC_DEFAULT_POSIX_DIR, NULL);
-  psync_free(homedir);
+  free(homedir);
   if (unlikely_log(!path)) {
     return NULL;
   }
 
   if (stat(path, &st) &&
       unlikely_log(mkdir(path, PSYNC_DEFAULT_POSIX_FOLDER_MODE))) {
-    psync_free(path);
+    free(path);
     return NULL;
   }
   return path;
@@ -192,7 +192,7 @@ char *ppath_private(char *name) {
     return NULL;
   rpath = psync_strcat(path, "/", name, NULL);
   if (stat(rpath, &st) && mkdir(path, PSYNC_DEFAULT_POSIX_FOLDER_MODE)) {
-    psync_free(rpath);
+    free(rpath);
     free(path);
     return NULL;
   }
diff --git a/pclsync/ppathstatus.c b/pclsync/ppathstatus.c
index 8c11cf9..f2d4c90 100644
--- a/pclsync/ppathstatus.c
+++ b/pclsync/ppathstatus.c
@@ -165,8 +165,7 @@ 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);
   }
-  ptree_for_each_element_call_safe(folder_tasks, folder_tasks_t, tree,
-                                        psync_free);
+  ptree_for_each_element_call_safe(folder_tasks, folder_tasks_t, tree, free);
   folder_tasks = PSYNC_TREE_EMPTY;
   ptree_for_each_element_call_safe(sync_data, sync_data_t, tree,
                                         sync_data_free);
@@ -302,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);
   ptree_del(&folder_tasks, &ft->tree);
-  psync_free(ft);
+  free(ft);
 }
 
 static psync_folderid_t get_parent_folder(psync_folderid_t folderid) {
@@ -413,7 +412,7 @@ static void folder_moved(psync_folderid_t folderid,
 static void folder_moved_commit(void *ptr) {
   folder_moved_params_t *mp = (folder_moved_params_t *)ptr;
   folder_moved(mp->folderid, mp->old_parent_folderid, mp->new_parent_folderid);
-  psync_free(mp);
+  free(mp);
 }
 
 void ppathstatus_fldr_moved(psync_folderid_t folderid,
@@ -429,7 +428,7 @@ void ppathstatus_fldr_moved(psync_folderid_t folderid,
   mp->folderid = folderid;
   mp->old_parent_folderid = old_parent_folderid;
   mp->new_parent_folderid = new_parent_folderid;
-  psync_sql_transation_add_callbacks(folder_moved_commit, psync_free, mp);
+  psync_sql_transation_add_callbacks(folder_moved_commit, free, mp);
 }
 
 void ppathstatus_fldr_deleted(psync_folderid_t folderid) {
@@ -451,9 +450,8 @@ void ppathstatus_fldr_deleted(psync_folderid_t folderid) {
 }
 
 static void sync_data_free(sync_data_t *sd) {
-  ptree_for_each_element_call_safe(sd->folder_tasks, folder_tasks_t, tree,
-                                        psync_free);
-  psync_free(sd);
+  ptree_for_each_element_call_safe(sd->folder_tasks, folder_tasks_t, tree, free);
+  free(sd);
 }
 
 static sync_data_t *get_sync_data(psync_syncid_t syncid, int create) {
@@ -662,7 +660,7 @@ 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);
   ptree_del(&sd->folder_tasks, &ft->tree);
-  psync_free(ft);
+  free(ft);
 }
 
 void ppathstatus_syncfldr_task_completed(
@@ -757,7 +755,7 @@ static void sync_folder_moved_commit(void *ptr) {
   sync_folder_moved_params_t *mp = (sync_folder_moved_params_t *)ptr;
   sync_folder_moved(mp->folderid, mp->old_syncid, mp->old_parent_folderid,
                     mp->new_syncid, mp->new_parent_folderid);
-  psync_free(mp);
+  free(mp);
 }
 
 void ppathstatus_syncfldr_moved(psync_folderid_t folderid,
@@ -781,7 +779,7 @@ void ppathstatus_syncfldr_moved(psync_folderid_t folderid,
   mp->new_parent_folderid = new_parent_folderid;
   mp->old_syncid = old_syncid;
   mp->new_syncid = new_syncid;
-  psync_sql_transation_add_callbacks(sync_folder_moved_commit, psync_free, mp);
+  psync_sql_transation_add_callbacks(sync_folder_moved_commit, free, mp);
 }
 
 void ppathstatus_syncfldr_deleted(psync_syncid_t syncid,
@@ -900,7 +898,7 @@ static int move_encname_to_buff(psync_folderid_t folderid, char *buff,
   if (unlikely(len >= sizeof(buff)))
     return -1;
   memcpy(buff, encname, len + 1);
-  psync_free(encname);
+  free(encname);
   return 0;
 }
 
@@ -1442,7 +1440,7 @@ psync_path_status_t ppathstatus_get(const char *path) {
         dp = NULL;
       }
       psync_sql_unlock();
-      psync_free(dp);
+      free(dp);
       if (len >= drive_path_len && !memcmp(drive_path, path, drive_path_len) &&
           valid_last_char(path[drive_path_len]))
         return psync_path_status_drive(path + drive_path_len,
diff --git a/pclsync/pqevent.c b/pclsync/pqevent.c
index f2481dc..219cc92 100644
--- a/pclsync/pqevent.c
+++ b/pclsync/pqevent.c
@@ -310,9 +310,9 @@ static void proc_send_event(void *ptr) {
     callback(event->event, event->data);
 
     if (event->freedata)
-      psync_free(event->data.ptr);
+      free(event->data.ptr);
 
-    psync_free(event);
+    free(event);
   }
 }
 
@@ -360,7 +360,7 @@ void pqevent_queue_sync_event_id(psync_eventtype_t eventid, psync_syncid_t synci
     if (unlikely_log(!remotepath))
       return;
     pqevent_queue_sync_event_path(eventid, syncid, localpath, remoteid, remotepath);
-    psync_free(remotepath);
+    free(remotepath);
   }
 }
 
@@ -379,7 +379,7 @@ void pqevent_queue_sync_event_path(psync_eventtype_t eventid, psync_syncid_t syn
     else
       slen = sizeof(psync_folder_event_t);
     event =
-        (event_list_t *)psync_malloc(sizeof(event_list_t) + slen + llen + rlen);
+        (event_list_t *)malloc(sizeof(event_list_t) + slen + llen + rlen);
     strct = (char *)(event + 1);
     lcopy = strct + slen;
     rcopy = lcopy + llen;
@@ -442,5 +442,5 @@ void pqevent_queue_event(psync_eventtype_t eventid, void *eventdata) {
     pthread_cond_signal(&eventcond);
     pthread_mutex_unlock(&eventmutex);
   } else
-    psync_free(eventdata);
+    free(eventdata);
 }
diff --git a/pclsync/prand.c b/pclsync/prand.c
index 25cbd97..b891274 100644
--- a/pclsync/prand.c
+++ b/pclsync/prand.c
@@ -130,7 +130,7 @@ void prand_seed(unsigned char *seed, const void *addent, size_t aelen,
     psync_lhash_update(&hctx, home, strlen(home));
     if (likely_log(!stat(home, &st)))
       psync_lhash_update(&hctx, &st, sizeof(st));
-    psync_free(home);
+    free(home);
   }
   if (!fast) {
     debug(D_NOTICE, "getting seed from database");
diff --git a/pclsync/prpc.c b/pclsync/prpc.c
index 12a0f88..ada54ae 100644
--- a/pclsync/prpc.c
+++ b/pclsync/prpc.c
@@ -124,7 +124,7 @@ cleanup:
     close(*sockfd);
   }
   if (response) {
-    psync_free(response);
+    free(response);
   }
 
   debug(D_NOTICE, "InstanceThread exiting.");
@@ -285,14 +285,14 @@ int prpc_register(int cmdid, prpc_handler h) {
     prpc_init();
     memcpy(handlers, handlers_old,
            handlers_size_old * sizeof(prpc_handler));
-    psync_free(handlers_old);
+    free(handlers_old);
   }
   handlers[cmdid - calbacks_lower_band] = h;
   return 0;
 }
 
 void prpc_init() {
-  handlers = (prpc_handler *)psync_malloc(sizeof(prpc_handler) * handlers_size);
+  handlers = (prpc_handler *)malloc(sizeof(prpc_handler) * handlers_size);
   memset(handlers, 0, sizeof(prpc_handler) * handlers_size);
 }
 
diff --git a/pclsync/prun.c b/pclsync/prun.c
index 9b5e5d1..c9db002 100644
--- a/pclsync/prun.c
+++ b/pclsync/prun.c
@@ -24,7 +24,7 @@ static void *thread_entry(void *data) {
     ((thread0_run)td->run)();
   }
   
-  psync_free(data);
+  free(data);
   return NULL;
 }
 
diff --git a/pclsync/prunthrottled.c b/pclsync/prunthrottled.c
index 74df695..4986722 100644
--- a/pclsync/prunthrottled.c
+++ b/pclsync/prunthrottled.c
@@ -68,7 +68,7 @@ static void ratelimit_timer(psync_timer_t timer, void *ptr) {
     prun_thread(name, call);
   } else {
     ptimer_stop(timer);
-    psync_free(node);
+    free(node);
   }
 }
 
diff --git a/pclsync/psettings.c b/pclsync/psettings.c
index 5b849c6..3dfe9ed 100644
--- a/pclsync/psettings.c
+++ b/pclsync/psettings.c
@@ -123,11 +123,11 @@ void psync_settings_reset() {
   home = ppath_home();
   defaultfs = psync_strcat(home, "/",
                            PSYNC_DEFAULT_FS_FOLDER, NULL);
-  psync_free(home);
+  free(home);
   home = ppath_pcloud();
   defaultcache = psync_strcat(home, "/",
                               PSYNC_DEFAULT_CACHE_FOLDER, NULL);
-  psync_free(home);
+  free(home);
   for (i = 0; i < ARRAY_SIZE(settings); i++)
     if (settings[i].type == PSYNC_TSTRING)
       psync_free_after_sec(settings[i].str, 60);
@@ -165,8 +165,8 @@ void psync_settings_reset() {
         settings[i].fix_callback(&settings[i].boolean);
     }
   }
-  psync_free(defaultfs);
-  psync_free(defaultcache);
+  free(defaultfs);
+  free(defaultcache);
 }
 
 void psync_settings_init() {
@@ -178,11 +178,11 @@ void psync_settings_init() {
   home = ppath_home();
   defaultfs = psync_strcat(home, "/",
                            PSYNC_DEFAULT_FS_FOLDER, NULL);
-  psync_free(home);
+  free(home);
   home = ppath_pcloud();
   defaultcache = psync_strcat(home, "/",
                               PSYNC_DEFAULT_CACHE_FOLDER, NULL);
-  psync_free(home);
+  free(home);
   settings[_PS(ignorepatterns)].str = PSYNC_IGNORE_PATTERNS_DEFAULT;
   settings[_PS(fsroot)].str = defaultfs;
   settings[_PS(fscachepath)].str = defaultcache;
@@ -209,15 +209,15 @@ void psync_settings_init() {
         settings[i].fix_callback(&settings[i].boolean);
     }
   }
-  psync_free(defaultfs);
-  psync_free(defaultcache);
+  free(defaultfs);
+  free(defaultcache);
   res = psync_sql_query("SELECT id, value FROM setting");
   while ((row = psync_sql_fetch_rowstr(res))) {
     name = row[0];
     for (i = 0; i < ARRAY_SIZE(settings); i++)
       if (!strcmp(name, settings[i].name)) {
         if (settings[i].type == PSYNC_TSTRING) {
-          psync_free(settings[i].str);
+          free(settings[i].str);
           settings[i].str = psync_strdup(row[1]);
           if (settings[i].fix_callback)
             settings[i].fix_callback(&settings[i].str);
diff --git a/pclsync/psock.c b/pclsync/psock.c
index 6f728ef..da58034 100644
--- a/pclsync/psock.c
+++ b/pclsync/psock.c
@@ -172,7 +172,7 @@ static struct addrinfo *addr_load(const char *host, const char *port) {
     psync_sql_rdunlock();
     return NULL;
   }
-  ret = (struct addrinfo *)psync_malloc(sizeof(struct addrinfo) * row[0] +
+  ret = (struct addrinfo *)malloc(sizeof(struct addrinfo) * row[0] +
                                         row[1]);
   data = (char *)(ret + row[0]);
   for (i = 0; i < row[0] - 1; i++)
@@ -275,7 +275,7 @@ static void cb_connect_res(void *h, void *ptr) {
   res = (struct addrinfo *)ptr;
   sock = connect_res(res);
   r = psync_task_complete(h, (void *)(uintptr_t)sock);
-  psync_free(res);
+  free(res);
   if (r && sock != INVALID_SOCKET)
     close(sock);
 }
@@ -380,7 +380,7 @@ int psock_try_write_buffer(psock_t *sock) {
     while ((b = sock->buffer)) {
       if (b->roffset == b->woffset) {
         sock->buffer = b->next;
-        psync_free(b);
+        free(b);
         continue;
       }
       if (sock->ssl) {
@@ -502,7 +502,7 @@ void psock_close(psock_t *sock) {
       }
   psock_clear_write_buffered(sock);
   close(sock->sock);
-  psync_free(sock);
+  free(sock);
 }
 
 void psock_close_bad(psock_t *sock) {
@@ -510,14 +510,14 @@ void psock_close_bad(psock_t *sock) {
     pssl_free(sock->ssl);
   psock_clear_write_buffered(sock);
   close(sock->sock);
-  psync_free(sock);
+  free(sock);
 }
 
 void psock_set_write_buffered(psock_t *sock) {
   psock_buf_t *sb;
   if (sock->buffer)
     return;
-  sb = (psock_buf_t *)psync_malloc(offsetof(psock_buf_t, buff) +
+  sb = (psock_buf_t *)malloc(offsetof(psock_buf_t, buff) +
                                    PSYNC_FIRST_SOCK_WRITE_BUFF_SIZE);
   sb->next = NULL;
   sb->size = PSYNC_FIRST_SOCK_WRITE_BUFF_SIZE;
@@ -773,7 +773,7 @@ static int psync_socket_write_to_buf(psock_t *sock, const void *buff, int num) {
     do {
       wr = b->size - b->woffset;
       if (!wr) {
-        b->next = (psock_buf_t *)psync_malloc(
+        b->next = (psock_buf_t *)malloc(
             offsetof(psock_buf_t, buff) + PSYNC_SECOND_SOCK_WRITE_BUFF_SIZE);
         b = b->next;
         b->next = NULL;
@@ -1107,7 +1107,7 @@ psock_ifaces_t *psock_list_adapters() {
     }
     addr = addr->ifa_next;
   }
-  ret = psync_malloc(offsetof(psock_ifaces_t, interfaces) +
+  ret = malloc(offsetof(psock_ifaces_t, interfaces) +
                      sizeof(psock_iface_t) * cnt);
   memset(ret, 0,
          offsetof(psock_ifaces_t, interfaces) + sizeof(psock_iface_t) * cnt);
@@ -1135,7 +1135,7 @@ psock_ifaces_t *psock_list_adapters() {
   freeifaddrs(addrs);
   return ret;
 empty:
-  ret = psync_malloc(offsetof(psock_ifaces_t, interfaces));
+  ret = malloc(offsetof(psock_ifaces_t, interfaces));
   ret->interfacecnt = 0;
   return ret;
 }
diff --git a/pclsync/pssl.c b/pclsync/pssl.c
index 1b6bd88..de3d20a 100644
--- a/pclsync/pssl.c
+++ b/pclsync/pssl.c
@@ -52,7 +52,6 @@
 #include "pcache.h"
 #include "pcompiler.h"
 #include "plibs.h"
-#include "pmemlock.h"
 #include "prand.h"
 #include "psettings.h"
 #include "pssl.h"
@@ -71,7 +70,7 @@ static void ssl_debug(int loglevel, int errnum, const char *msg) {
 
 static void free_encrypted(psync_encrypted_data_t e) {
   putil_wipe(e->data, e->datalen);
-  pmemlock_free(e);
+  free(e);
 }
 
 void prsa_free_binary(psync_binary_rsa_key_t bin) {
@@ -80,13 +79,13 @@ void prsa_free_binary(psync_binary_rsa_key_t bin) {
 
 void psymkey_free(psync_symmetric_key_t key) {
   putil_wipe(key->key, key->keylen);
-  pmemlock_free(key);
+  free(key);
 }
 
 psync_encrypted_symmetric_key_t
 psymkey_alloc_encrypted(size_t len) {
   psync_encrypted_symmetric_key_t ret;
-  ret = psync_malloc(offsetof(psync_encrypted_data_struct_t, data) + len);
+  ret = malloc(offsetof(psync_encrypted_data_struct_t, data) + len);
   ret->datalen = len;
   return ret;
 }
@@ -94,7 +93,7 @@ psymkey_alloc_encrypted(size_t len) {
 psync_encrypted_symmetric_key_t
 psymkey_copy_encrypted(psync_encrypted_symmetric_key_t src) {
   psync_encrypted_symmetric_key_t ret;
-  ret = psync_malloc(offsetof(psync_encrypted_data_struct_t, data) +
+  ret = malloc(offsetof(psync_encrypted_data_struct_t, data) +
                      src->datalen);
   ret->datalen = src->datalen;
   memcpy(ret->data, src->data, src->datalen);
@@ -212,7 +211,7 @@ static ssl_connection_t *conn_alloc(const char *hostname) {
   ssl_connection_t *conn;
   size_t len;
   len = strlen(hostname) + 1;
-  conn = (ssl_connection_t *)psync_malloc(offsetof(ssl_connection_t, cachekey) +
+  conn = (ssl_connection_t *)malloc(offsetof(ssl_connection_t, cachekey) +
                                           len + 4);
   conn->isbroken = 0;
   memcpy(conn->cachekey, "SSLS", 4);
@@ -271,7 +270,7 @@ static int mbed_write(void *ptr, const unsigned char *buf, size_t len) {
 
 static void free_session(void *ptr) {
   mbedtls_ssl_session_free((mbedtls_ssl_session *)ptr);
-  psync_free(ptr);
+  free(ptr);
 }
 
 static void save_session(ssl_connection_t *conn) {
@@ -281,7 +280,7 @@ static void save_session(ssl_connection_t *conn) {
   // them, therefore it is thread safe to add session upon connect
   memset(sess, 0, sizeof(mbedtls_ssl_session));
   if (mbedtls_ssl_get_session(&conn->ssl, sess))
-    psync_free(sess);
+    free(sess);
   else
     pcache_add(conn->cachekey, sess, PSYNC_SSL_SESSION_CACHE_TIMEOUT,
                     free_session, PSYNC_MAX_SSL_SESSIONS_PER_DOMAIN);
@@ -365,7 +364,7 @@ int pssl_connect(int sock, void **sslconn,
       debug(D_WARNING, "ssl_set_session failed");
     }
     mbedtls_ssl_session_free(sess);
-    psync_free(sess);
+    free(sess);
   }
 
   ret = mbedtls_ssl_handshake(&conn->ssl);
@@ -387,7 +386,7 @@ int pssl_connect(int sock, void **sslconn,
 err1:
   mbedtls_ssl_free(&conn->ssl);
 err0:
-  psync_free(conn);
+  free(conn);
   return PRINT_RETURN_CONST(PSYNC_SSL_FAIL);
 }
 
@@ -412,7 +411,7 @@ int pssl_connect_finish(void *sslconn, const char *hostname) {
     return PSYNC_SSL_NEED_FINISH;
 fail:
   mbedtls_ssl_free(&conn->ssl);
-  psync_free(conn);
+  free(conn);
   return PRINT_RETURN_CONST(PSYNC_SSL_FAIL);
 }
 
@@ -431,7 +430,7 @@ int pssl_shutdown(void *sslconn) {
     return PSYNC_SSL_NEED_FINISH;
 noshutdown:
   mbedtls_ssl_free(&conn->ssl);
-  psync_free(conn);
+  free(conn);
   return PSYNC_SSL_SUCCESS;
 }
 
@@ -439,7 +438,7 @@ void pssl_free(void *sslconn) {
   ssl_connection_t *conn;
   conn = (ssl_connection_t *)sslconn;
   mbedtls_ssl_free(&conn->ssl);
-  psync_free(conn);
+  free(conn);
 }
 
 int pssl_pendingdata(void *sslconn) {
@@ -485,7 +484,7 @@ psync_rsa_t pssl_gen_rsa(int bits) {
   if (mbedtls_rsa_gen_key(ctx, rng_get, &rng, bits,
                           65537)) {
     mbedtls_rsa_free(ctx);
-    psync_free(ctx);
+    free(ctx);
     return PSYNC_INVALID_RSA;
   } else
     return ctx;
@@ -493,7 +492,7 @@ psync_rsa_t pssl_gen_rsa(int bits) {
 
 void pssl_free_rsa(psync_rsa_t rsa) {
   mbedtls_rsa_free(rsa);
-  psync_free(rsa);
+  free(rsa);
 }
 
 psync_rsa_publickey_t prsa_get_public(psync_rsa_t rsa) {
@@ -519,7 +518,7 @@ psync_rsa_privatekey_t prsa_get_private(psync_rsa_t rsa) {
 
   if (unlikely(mbedtls_rsa_copy(ctx, rsa))) {
     mbedtls_rsa_free(ctx);
-    psync_free(ctx);
+    free(ctx);
     return PSYNC_INVALID_RSA;
   } else
     return ctx;
@@ -545,7 +544,7 @@ prsa_public_to_binary(psync_rsa_publickey_t rsa) {
   if (len <= 0)
     return PSYNC_INVALID_BIN_RSA;
   ret =
-      pmemlock_malloc(offsetof(psync_encrypted_data_struct_t, data) + len);
+      malloc(offsetof(psync_encrypted_data_struct_t, data) + len);
   ret->datalen = len;
   memcpy(ret->data, buff + sizeof(buff) - len, len);
   return ret;
@@ -566,7 +565,7 @@ prsa_private_to_binary(psync_rsa_privatekey_t rsa) {
   if (len <= 0)
     return PSYNC_INVALID_BIN_RSA;
   ret =
-      pmemlock_malloc(offsetof(psync_encrypted_data_struct_t, data) + len);
+      malloc(offsetof(psync_encrypted_data_struct_t, data) + len);
   ret->datalen = len;
   memcpy(ret->data, buff + sizeof(buff) - len, len);
   putil_wipe(buff + sizeof(buff) - len, len);
@@ -593,7 +592,7 @@ psync_rsa_publickey_t prsa_load_public(const unsigned char *keydata,
   if (unlikely(ret)) {
     debug(D_WARNING, "rsa_copy failed with code %d", ret);
     mbedtls_rsa_free(rsa);
-    psync_free(rsa);
+    free(rsa);
     return PSYNC_INVALID_RSA;
   } else {
     mbedtls_rsa_set_padding(rsa, MBEDTLS_RSA_PKCS_V21, MBEDTLS_MD_SHA1);
@@ -648,7 +647,7 @@ psync_rsa_privatekey_t prsa_load_private(const unsigned char *keydata, size_t ke
   if (unlikely(ret)) {
     debug(D_WARNING, "rsa_copy failed with code %d", ret);
     mbedtls_rsa_free(rsa);
-    psync_free(rsa);
+    free(rsa);
     return PSYNC_INVALID_RSA;
   } else {
     mbedtls_rsa_set_padding(rsa, MBEDTLS_RSA_PKCS_V21, MBEDTLS_MD_SHA1);
@@ -670,7 +669,7 @@ psync_symmetric_key_t
 psymkey_generate(const char *password, size_t keylen,
                                       const unsigned char *salt, size_t saltlen,
                                       size_t iterations) {
-  psync_symmetric_key_t key = (psync_symmetric_key_t)pmemlock_malloc(
+  psync_symmetric_key_t key = (psync_symmetric_key_t)malloc(
       keylen + offsetof(psync_symmetric_key_struct_t, key));
   mbedtls_md_context_t ctx;
   mbedtls_md_init(&ctx);
@@ -699,7 +698,7 @@ char *psymkey_derive(const char *username,
     else
       usercopy[i] = '*';
   psync_sha512(usercopy, userlen, usersha512);
-  psync_free(usercopy);
+  free(usercopy);
   mbedtls_md_init(&ctx);
   mbedtls_md_setup(&ctx, mbedtls_md_info_from_type(MBEDTLS_MD_SHA512), 1);
   const mbedtls_md_info_t *md_info = mbedtls_md_info_from_ctx(&ctx);
@@ -718,12 +717,12 @@ prsa_encrypt_data(psync_rsa_publickey_t rsa, const unsigned char *data,
   int code;
   size_t rsalen = mbedtls_rsa_get_len(rsa);
 
-  ret = (psync_encrypted_symmetric_key_t)psync_malloc(
+  ret = (psync_encrypted_symmetric_key_t)malloc(
       offsetof(psync_encrypted_data_struct_t, data) + rsalen);
   if ((code = mbedtls_rsa_rsaes_oaep_encrypt(
            rsa, rng_get, &rng,
            NULL, 0, datalen, data, ret->data))) {
-    psync_free(ret);
+    free(ret);
     debug(
         D_WARNING,
         "rsa_rsaes_oaep_encrypt failed with error=%d, datalen=%lu, rsasize=%d",
@@ -745,7 +744,7 @@ psync_symmetric_key_t prsa_decrypt_data(psync_rsa_privatekey_t rsa,
                                      &rng, NULL,
                                      0, &len, data, buff, sizeof(buff)))
     return PSYNC_INVALID_SYM_KEY;
-  ret = (psync_symmetric_key_t)pmemlock_malloc(
+  ret = (psync_symmetric_key_t)malloc(
       offsetof(psync_symmetric_key_struct_t, key) + len);
   ret->keylen = len;
   memcpy(ret->key, buff, len);
@@ -775,7 +774,7 @@ paes_create_encoder(psync_symmetric_key_t key) {
 
 void paes_free_encoder(psync_aes256_encoder aes) {
   putil_wipe(aes, sizeof(mbedtls_aes_context));
-  psync_free(aes);
+  free(aes);
 }
 
 psync_aes256_encoder
@@ -789,7 +788,7 @@ paes_create_decoder(psync_symmetric_key_t key) {
 
 void paes_free_decoder(psync_aes256_encoder aes) {
   putil_wipe(aes, sizeof(mbedtls_aes_context));
-  psync_free(aes);
+  free(aes);
 }
 
 psync_rsa_signature_t
@@ -799,7 +798,7 @@ prsa_sign_sha256_hash(psync_rsa_privatekey_t rsa,
   int padding, hash_id;
   size_t rsalen = mbedtls_rsa_get_len(rsa);
 
-  ret = (psync_rsa_signature_t)psync_malloc(
+  ret = (psync_rsa_signature_t)malloc(
       offsetof(psync_symmetric_key_struct_t, key) + rsalen);
   if (!ret)
     return (psync_rsa_signature_t)(void *)PERROR_NO_MEMORY;
diff --git a/pclsync/pstatus.c b/pclsync/pstatus.c
index 6cdb0c0..a0d5970 100644
--- a/pclsync/pstatus.c
+++ b/pclsync/pstatus.c
@@ -221,7 +221,7 @@ void pstatus_upload_recalc() {
       filestou++;
       bytestou += pfile_stat_size(&st);
     }
-    psync_free(filename);
+    free(filename);
   }
   psync_sql_free_result(res);
   psync_status.filestoupload = filestou;
diff --git a/pclsync/psuggest.c b/pclsync/psuggest.c
index c848b2e..ac199d5 100644
--- a/pclsync/psuggest.c
+++ b/pclsync/psuggest.c
@@ -115,7 +115,7 @@ static void dir_scan(void *ptr, ppath_fast_stat *st) {
     size_t l, o;
     l = strlen(st->name);
     o = f->pathlen;
-    nf = (scan_folder *)psync_malloc(sizeof(scan_folder) + o + l + 2);
+    nf = (scan_folder *)malloc(sizeof(scan_folder) + o + l + 2);
     psync_list_init(&nf->subfolders);
     path = (char *)(nf + 1);
     memcpy(path, f->path, o);
@@ -184,7 +184,7 @@ static int sort_comp_tuple_rev(const void *p1, const void *p2) {
 static void free_folder(scan_folder *f) {
   psync_list_for_each_element_call(&f->subfolders, scan_folder, nextfolder,
                                    free_folder);
-  psync_free(f);
+  free(f);
 }
 
 psuggested_folders_t *psuggest_scan_folder(const char *path) {
@@ -233,12 +233,12 @@ psuggested_folders_t *psuggest_scan_folder(const char *path) {
     ln += s->folder->pathlen + off + 2;
     sf[cnt] = s;
     descslen[cnt] = off + 1;
-    descs[cnt] = psync_malloc(descslen[cnt]);
+    descs[cnt] = malloc(descslen[cnt]);
     memcpy(descs[cnt], buff, descslen[cnt]);
     if (++cnt >= PSYNC_SCANNER_MAX_SUGGESTIONS)
       break;
   }
-  ret = psync_malloc(offsetof(psuggested_folders_t, entries) +
+  ret = malloc(offsetof(psuggested_folders_t, entries) +
                      sizeof(psuggested_folder_t) * cnt + ln);
   str = ((char *)ret) + offsetof(psuggested_folders_t, entries) +
         sizeof(psuggested_folder_t) * cnt;
@@ -259,12 +259,11 @@ psuggested_folders_t *psuggest_scan_folder(const char *path) {
     ret->entries[i].description = str;
     memcpy(str, descs[i], descslen[i]);
     str += descslen[i];
-    psync_free(descs[i]);
+    free(descs[i]);
     debug(D_NOTICE, "suggesting %s (%s, %s)", ret->entries[i].localpath,
           ret->entries[i].name, ret->entries[i].description);
   }
-  psync_list_for_each_element_call(&suggestions, suggested_folder, list,
-                                   psync_free);
+  psync_list_for_each_element_call(&suggestions, suggested_folder, list, free);
   free_folder(f);
   return ret;
 }
diff --git a/pclsync/psyncer.c b/pclsync/psyncer.c
index 5452508..cc7fbb3 100644
--- a/pclsync/psyncer.c
+++ b/pclsync/psyncer.c
@@ -120,7 +120,7 @@ void psyncer_dl_queue_del(psync_folderid_t folderid) {
       f = ptree_element(f->tree.right, synced_down_folder, tree);
     else {
       ptree_del(&synced_down_folders, &f->tree);
-      psync_free(f);
+      free(f);
       break;
     }
   }
@@ -129,8 +129,7 @@ void psyncer_dl_queue_del(psync_folderid_t folderid) {
 
 void psyncer_dl_queue_clear() {
   pthread_mutex_lock(&sync_down_mutex);
-  ptree_for_each_element_call_safe(synced_down_folders, synced_down_folder,
-                                        tree, psync_free);
+  ptree_for_each_element_call_safe(synced_down_folders, synced_down_folder, tree, free);
   synced_down_folders = PSYNC_TREE_EMPTY;
   pthread_mutex_unlock(&sync_down_mutex);
 }
@@ -212,7 +211,7 @@ psync_folderid_t psyncer_db_folder_create(
   if (psync_sql_affected_rows() > 0) {
     lfolderid = psync_sql_insertid();
     psync_sql_free_result(res);
-    psync_free(vname);
+    free(vname);
     return lfolderid;
   }
   psync_sql_free_result(res);
@@ -242,7 +241,7 @@ psync_folderid_t psyncer_db_folder_create(
     psync_sql_run_free(res);
   }
   psyncer_folder_inc_tasks(lfolderid);
-  psync_free(vname);
+  free(vname);
   return lfolderid;
 }
 
@@ -342,12 +341,12 @@ static void psync_sync_newsyncedfolder(psync_syncid_t syncid) {
     }
   } else
     psync_sql_rollback_transaction();
-  psync_free(localpath);
+  free(localpath);
 }
 
 static void psync_do_sync_thread(void *ptr) {
   psync_sync_newsyncedfolder(*((psync_syncid_t *)ptr));
-  psync_free(ptr);
+  free(ptr);
 }
 
 void psyncer_create(psync_syncid_t syncid) {
@@ -474,8 +473,8 @@ re:
     folderid = pfolder_id_create(remotepath);
     if (unlikely(folderid == PSYNC_INVALID_FOLDERID)) {
       debug(D_WARNING, "could not get folderid/create folder %s", remotepath);
-      psync_free(localpath);
-      psync_free(remotepath);
+      free(localpath);
+      free(remotepath);
       if (psync_error != PERROR_OFFLINE) {
         delete_delayed_sync(id);
         goto re;
@@ -490,8 +489,8 @@ re:
     psync_sql_free_result(stmt);
     if (!urow) {
       psync_sql_commit_transaction();
-      psync_free(localpath);
-      psync_free(remotepath);
+      free(localpath);
+      free(remotepath);
       goto re;
     }
     stmt = psync_sql_prep_statement(
@@ -508,8 +507,8 @@ re:
     else
       syncid = -1;
     psync_sql_free_result(stmt);
-    psync_free(localpath);
-    psync_free(remotepath);
+    free(localpath);
+    free(remotepath);
     if (!psync_sql_commit_transaction() && syncid != -1) {
       ppathstatus_reload_syncs();
       psyncer_create(syncid);
diff --git a/pclsync/psynclib.c b/pclsync/psynclib.c
index c4d6073..41cad7a 100644
--- a/pclsync/psynclib.c
+++ b/pclsync/psynclib.c
@@ -60,7 +60,6 @@
 #include "plist.h"
 #include "plocalnotify.h"
 #include "plocalscan.h"
-#include "pmemlock.h"
 #include "pnetlibs.h"
 #include "pnotify.h"
 #include "prpc.h"
@@ -85,9 +84,6 @@
 #include "pupload.h"
 #include "putil.h"
 
-
-#define BUGHUNT 0
-
 // Variable containing UNIX time of the last backup file deleted event
 time_t lastBupDelEventTime = 0;
 time_t bupNotifDelay = 300;
@@ -99,10 +95,6 @@ typedef struct {
 
 PSYNC_THREAD const char *psync_thread_name = "no name";
 
-static psync_malloc_t psync_real_malloc = malloc;
-static psync_realloc_t psync_real_realloc = realloc;
-static psync_free_t psync_real_free = free;
-
 const char *psync_database = NULL;
 
 static int psync_libstate = 0;
@@ -127,93 +119,12 @@ static inline int psync_status_is_offline() {
     return PSYNC_INVALID_SYNCID;                                               \
   } while (0)
 
-PSYNC_NOINLINE void *psync_emergency_malloc(size_t size) {
-  void *ret;
-  debug(D_WARNING, "could not allocate %lu bytes", size);
-  psync_try_free_memory();
-  ret = psync_real_malloc(size);
-  if (likely(ret))
-#if IS_DEBUG
-    return memset(ret, 0xfa, size);
-#else
-    return ret;
-#endif
-  else {
-    debug(
-        D_CRITICAL,
-        "could not allocate %lu bytes even after freeing some memory, aborting",
-        size);
-    abort();
-    return NULL;
-  }
-}
-
-void *psync_malloc(size_t size) {
-  void *ptr;
-#if 1 == BUGHUNT
-  void *callstack[128];
-  int frames = backtrace(callstack, 128);
-  char **strs = backtrace_symbols(callstack, frames);
-#endif
-  ptr = psync_real_malloc(size);
-#if 1 == BUGHUNT
-  printf("Allocated %zu bytes at %p\n", size, ptr);
-  for (int i = 0; i < frames; i++) {
-    printf("%s\n", strs[i]);
-  }
-  free(strs);
-#endif
-  if (likely(ptr))
-#if IS_DEBUG
-    return memset(ptr, 0xfa, size);
-#else
-    return ptr;
-#endif
-  else
-    return psync_emergency_malloc(size);
-}
-
-PSYNC_NOINLINE void *psync_emergency_realloc(void *ptr, size_t size) {
-  void *ret;
-  debug(D_WARNING, "could not reallocate %lu bytes", size);
-  psync_try_free_memory();
-  ret = psync_real_realloc(ptr, size);
-  if (likely(ret))
-    return ret;
-  else {
-    debug(D_CRITICAL,
-          "could not reallocate %lu bytes even after freeing some memory, "
-          "aborting",
-          size);
-    abort();
-    return NULL;
-  }
-}
-
-void *psync_realloc(void *ptr, size_t size) {
-  void *ret;
-  ret = psync_real_realloc(ptr, size);
-  if (likely(ret))
-    return ret;
-  else
-    return psync_emergency_realloc(ptr, size);
-}
-
-void psync_free(void *ptr) { psync_real_free(ptr); }
-
 uint32_t psync_get_last_error() { return psync_error; }
 
 void psync_set_database_path(const char *databasepath) {
   psync_database = psync_strdup(databasepath);
 }
 
-void psync_set_alloc(psync_malloc_t malloc_call, psync_realloc_t realloc_call,
-                     psync_free_t free_call) {
-  psync_real_malloc = malloc_call;
-  psync_real_realloc = realloc_call;
-  psync_real_free = free_call;
-}
-
 static void psync_stop_crypto_on_sleep() {
   if (psync_setting_get_bool(_PS(sleepstopcrypto)) &&
       pcryptofolder_is_unlocked()) {
@@ -259,7 +170,6 @@ int psync_init() {
       return 0;
     }
   }
-  pmemlock_init();
   pcache_init();
   psys_init();
 
@@ -384,9 +294,9 @@ void psync_set_user_pass(const char *username, const char *password, int save) {
       psync_set_string_value("pass", password);
   } else {
     pthread_mutex_lock(&psync_my_auth_mutex);
-    psync_free(psync_my_user);
+    free(psync_my_user);
     psync_my_user = psync_strdup(username);
-    psync_free(psync_my_pass);
+    free(psync_my_pass);
     if (password && password[0])
       psync_my_pass = psync_strdup(password);
     pthread_mutex_unlock(&psync_my_auth_mutex);
@@ -401,7 +311,7 @@ void psync_set_pass(const char *password, int save) {
     psync_set_string_value("pass", password);
   else {
     pthread_mutex_lock(&psync_my_auth_mutex);
-    psync_free(psync_my_pass);
+    free(psync_my_pass);
     psync_my_pass = psync_strdup(password);
     pthread_mutex_unlock(&psync_my_auth_mutex);
   }
@@ -441,7 +351,7 @@ void psync_logout(uint32_t auth_status, int doinvauth) {
 
   pthread_mutex_lock(&psync_my_auth_mutex);
   putil_wipe(psync_my_pass, sizeof(psync_my_pass));
-  psync_free(psync_my_pass);
+  free(psync_my_pass);
   pthread_mutex_unlock(&psync_my_auth_mutex);
 
   pstatus_set(PSTATUS_TYPE_ONLINE, PSTATUS_ONLINE_CONNECTING);
@@ -501,7 +411,7 @@ apiservers_list_t *psync_get_apiservers(char **err) {
   locations = papi_find_result2(bres, "locations", PARAM_ARRAY);
   locationscnt = locations->length;
   if (!locationscnt) {
-    psync_free(bres);
+    free(bres);
     return NULL;
   }
   builder = psync_list_builder_create(sizeof(apiserver_info_t),
@@ -569,7 +479,7 @@ void psync_unlink() {
   ret = psync_sql_close();
   pfile_delete(psync_database);
   if (ret) {
-    psync_free(deviceid);
+    free(deviceid);
     debug(D_ERROR, "failed to close database, exiting");
     exit(1);
   }
@@ -579,7 +489,7 @@ void psync_unlink() {
     res = psync_sql_prep_statement("REPLACE INTO setting (id, value) VALUES ('deviceid', ?)");
     psync_sql_bind_string(res, 1, deviceid);
     psync_sql_run_free(res);
-    psync_free(deviceid);
+    free(deviceid);
   }
   pthread_mutex_lock(&psync_my_auth_mutex);
   putil_wipe(psync_my_auth, sizeof(psync_my_auth));
@@ -617,7 +527,7 @@ int psync_tfa_type() { return psync_my_2fa_type; }
 static void check_tfa_result(uint64_t result) {
   if (result == 2064) {
     if (pstatus_get(PSTATUS_TYPE_AUTH) == PSTATUS_AUTH_TFAREQ) {
-      psync_free(psync_my_2fa_token);
+      free(psync_my_2fa_token);
       psync_my_2fa_token = NULL;
       pstatus_set(PSTATUS_TYPE_AUTH, PSTATUS_AUTH_PROVIDED);
     }
@@ -777,10 +687,10 @@ psync_syncid_t psync_add_sync_by_folderid(const char *localpath,
     if (!memcmp(syncmp, localpath, len) &&
         (localpath[len] == 0 || localpath[len] == '/' ||
          localpath[len] == '\\')) {
-      psync_free(syncmp);
+      free(syncmp);
       return_isyncid(PERROR_LOCAL_IS_ON_PDRIVE);
     }
-    psync_free(syncmp);
+    free(syncmp);
   }
   res = psync_sql_query("SELECT localpath FROM syncfolder");
   if (unlikely_log(!res))
@@ -1028,7 +938,7 @@ psuggested_folders_t *psync_get_sync_suggestions() {
   home = ppath_home();
   if (likely_log(home)) {
     ret = psuggest_scan_folder(home);
-    psync_free(home);
+    free(home);
     return ret;
   } else {
     psync_error = PERROR_NO_HOMEDIR;
@@ -1067,7 +977,7 @@ int psync_is_lname_to_ignore(const char *name, size_t namelen) {
   size_t ilen, off, pl;
   char buff[120];
   if (namelen >= sizeof(buff))
-    namelower = (char *)psync_malloc(namelen + 1);
+    namelower = (char *)malloc(namelen + 1);
   else
     namelower = buff;
   memcpy(namelower, name, namelen);
@@ -1096,13 +1006,13 @@ int psync_is_lname_to_ignore(const char *name, size_t namelen) {
       pl--;
     if (psync_match_pattern(namelower, pt, pl)) {
       if (namelower != buff)
-        psync_free(namelower);
+        free(namelower);
       debug(D_NOTICE, "ignoring file/folder %s", name);
       return 1;
     }
   } while (sc);
   if (namelower != buff)
-    psync_free(namelower);
+    free(namelower);
   return 0;
 }
 
@@ -1161,7 +1071,7 @@ static int do_run_command_get_res(const char *cmd, size_t cmdlen,
     psync_process_api_error(result);
   }
   if (result)
-    psync_free(res);
+    free(res);
   else
     *pres = res;
   return (int)result;
@@ -1210,7 +1120,7 @@ int psync_register(const char *email, const char *password, int termsaccepted,
     psync_set_apiserver(PSYNC_API_HOST, PSYNC_LOCATIONID_DEFAULT);
   }
   psock_close(sock);
-  psync_free(res);
+  free(res);
   return result;
 }
 
@@ -1242,12 +1152,12 @@ int psync_change_password(const char *currentpass, const char *newpass,
                          PAPI_BOOL("regetauth", 1)};
     ret = run_command_get_res("changepassword", params, err, &res);
   }
-  psync_free(device);
+  free(device);
   if (ret)
     return ret;
   psync_strlcpy(psync_my_auth, papi_find_result2(res, "auth", PARAM_STR)->str,
                 sizeof(psync_my_auth));
-  psync_free(res);
+  free(res);
   return 0;
 }
 
@@ -1260,7 +1170,7 @@ int psync_create_remote_folder_by_path(const char *path, char **err) {
   if (ret)
     return ret;
   pfileops_create_fldr(papi_find_result2(res, "metadata", PARAM_HASH));
-  psync_free(res);
+  free(res);
   pdiff_wake();
   return 0;
 }
@@ -1276,7 +1186,7 @@ int psync_create_remote_folder(psync_folderid_t parentfolderid,
   if (ret)
     return ret;
   pfileops_create_fldr(papi_find_result2(res, "metadata", PARAM_HASH));
-  psync_free(res);
+  free(res);
   pdiff_wake();
   return 0;
 }
@@ -1699,9 +1609,9 @@ int psync_remove_share(psync_shareid_t shareid, char **err) {
     result = psync_account_stopshare(shareid, &err1);
     if (result == 2075) {
       result = 2025;
-      psync_free(err1);
+      free(err1);
     } else {
-      psync_free(*err);
+      free(*err);
       *err = err1;
     }
     debug(D_NOTICE, "erroris  %s", *err);
@@ -1731,9 +1641,9 @@ int psync_modify_share(psync_shareid_t shareid, uint32_t permissions,
         psync_account_modifyshare(shareid, convert_perms(permissions), &err1);
     if (result == 2075) {
       result = 2025;
-      psync_free(err1);
+      free(err1);
     } else {
-      psync_free(*err);
+      free(*err);
       *err = err1;
     }
     debug(D_NOTICE, "erroris  %s", *err);
@@ -1751,7 +1661,7 @@ static void psync_del_all_except(void *ptr, ppath_fast_stat *st) {
   debug(D_NOTICE, "deleting old update file %s", fp);
   if (pfile_delete(fp))
     debug(D_WARNING, "could not delete %s", fp);
-  psync_free(fp);
+  free(fp);
 }
 
 static char *psync_filename_from_res(const binresult *res) {
@@ -1769,8 +1679,8 @@ static char *psync_filename_from_res(const binresult *res) {
   nmarr[1] = nmd;
   ppath_ls_fast(path, psync_del_all_except, (void *)nmarr);
   ret = psync_strcat(path, "/", nmd, NULL);
-  psync_free(nmd);
-  psync_free(path);
+  free(nmd);
+  free(path);
   return ret;
 }
 
@@ -1781,13 +1691,13 @@ static int psync_upload_result(binresult *res, psync_fileid_t *fileid) {
     const binresult *meta =
         papi_find_result2(res, "metadata", PARAM_ARRAY)->array[0];
     *fileid = papi_find_result2(meta, "fileid", PARAM_NUM)->num;
-    psync_free(res);
+    free(res);
     pdiff_wake();
     return 0;
   } else {
     debug(D_WARNING, "uploadfile returned error %u: %s", (unsigned)result,
           papi_find_result2(res, "error", PARAM_STR)->str);
-    psync_free(res);
+    free(res);
     psync_process_api_error(result);
     return result;
   }
@@ -1852,7 +1762,7 @@ static int psync_load_file(const char *local_path, char **data,
     if (fstat(fd, &st1))
       goto err1;
     len = pfile_stat_size(&st1);
-    buff = psync_malloc(len);
+    buff = malloc(len);
     if (!buff)
       goto err1;
     off = 0;
@@ -1870,7 +1780,7 @@ static int psync_load_file(const char *local_path, char **data,
       *length = len;
       return 0;
     }
-    psync_free(buff);
+    free(buff);
   }
   return -1;
 err1:
@@ -1887,7 +1797,7 @@ int psync_upload_file(psync_folderid_t folderid, const char *remote_filename,
   if (psync_load_file(local_path, &data, &length))
     return -2;
   ret = psync_upload_data(folderid, remote_filename, data, length, fileid);
-  psync_free(data);
+  free(data);
   return ret;
 }
 
@@ -1900,7 +1810,7 @@ int psync_upload_file_as(const char *remote_path, const char *remote_filename,
     return -2;
   ret =
       psync_upload_data_as(remote_path, remote_filename, data, length, fileid);
-  psync_free(data);
+  free(data);
   return ret;
 }
 
@@ -2020,7 +1930,7 @@ psync_folderid_t *psync_crypto_folderids() {
     ret[l] = row[0];
     if (++l == alloc) {
       alloc *= 2;
-      ret = (psync_folderid_t *)psync_realloc(ret,
+      ret = (psync_folderid_t *)realloc(ret,
                                               sizeof(psync_folderid_t) * alloc);
     }
   }
@@ -2063,7 +1973,7 @@ int psync_crypto_change_crypto_pass(const char *oldpass, const char *newpass,
       }
     }
     result = papi_find_result2(res, "result", PARAM_NUM)->num;
-    psync_free(res);
+    free(res);
     if (result != 0)
       debug(D_WARNING, "crypto_changeuserprivate returned %u",
             (unsigned)result);
@@ -2110,7 +2020,7 @@ int psync_crypto_change_crypto_pass_unlocked(const char *newpass,
       }
     }
     result = papi_find_result2(res, "result", PARAM_NUM)->num;
-    psync_free(res);
+    free(res);
     if (result != 0)
       debug(D_WARNING, "crypto_changeuserprivate returned %u",
             (unsigned)result);
@@ -2139,7 +2049,7 @@ int psync_crypto_crypto_send_change_user_private() {
     psync_apipool_release(api);
   }
   result = papi_find_result2(res, "result", PARAM_NUM)->num;
-  psync_free(res);
+  free(res);
   if (result != 0)
     debug(D_WARNING, "crypto_sendchangeuserprivate returned %u",
           (unsigned)result);
@@ -2386,12 +2296,12 @@ int psync_get_promo(char **url, uint64_t *width, uint64_t *height) {
 
   if (result) {
     debug(D_WARNING, "getpromourl returned %d", (int)result);
-    psync_free(res);
+    free(res);
     return result;
   }
 
   if (!papi_find_result2(res, "haspromo", PARAM_BOOL)->num) {
-    psync_free(res);
+    free(res);
 
     return result;
   }
@@ -2401,7 +2311,7 @@ int psync_get_promo(char **url, uint64_t *width, uint64_t *height) {
   if (!papi_find_result2(res, "width", PARAM_NUM)->num) {
     debug(D_NOTICE, "Parameter width not found.");
 
-    psync_free(res);
+    free(res);
     return result;
   }
 
@@ -2411,14 +2321,14 @@ int psync_get_promo(char **url, uint64_t *width, uint64_t *height) {
   if (!papi_find_result2(res, "height", PARAM_NUM)->num) {
     debug(D_NOTICE, "Parameter height not found.");
 
-    psync_free(res);
+    free(res);
     return result;
   }
 
   *height = papi_find_result2(res, "height", PARAM_NUM)->num;
   debug(D_NOTICE, "Promo window Height: [%lu]", *height);
 
-  psync_free(res);
+  free(res);
 
   return 0;
 }
@@ -2526,12 +2436,12 @@ int psync_is_folder_syncable(char *localPath, char **errMsg) {
     if (!memcmp(syncmp, localPath, len) &&
         (localPath[len] == 0 || localPath[len] == '/' ||
          localPath[len] == '\\')) {
-      psync_free(syncmp);
+      free(syncmp);
 
       *errMsg = psync_strdup("Folder is located on pCloud drive.");
       return PERROR_LOCAL_IS_ON_PDRIVE;
     }
-    psync_free(syncmp);
+    free(syncmp);
   }
 
   // Check if folder is not a child of an igrnored folder
@@ -2880,12 +2790,12 @@ userinfo_t *psync_get_userinfo() {
                          PAPI_STR("timeformat", "timestamp")};
     res = psync_api_run_command("userinfo", params);
     if (!res) {
-      psync_free(res);
+      free(res);
       return NULL;
     }
     err = papi_find_result2(res, "result", PARAM_NUM)->num;
     if (err) {
-      psync_free(res);
+      free(res);
       return NULL;
     }
 
@@ -2900,7 +2810,7 @@ userinfo_t *psync_get_userinfo() {
     language = cres->str;
     llanguage =
         (cres->length + sizeof(void *)) / sizeof(void *) * sizeof(void *);
-    info = (userinfo_t *)psync_malloc(sizeof(userinfo_t) + lemail + lcurrency +
+    info = (userinfo_t *)malloc(sizeof(userinfo_t) + lemail + lcurrency +
                                       llanguage);
     ptr = (char *)(info + 1);
     memcpy(ptr, email, lemail);
@@ -2948,7 +2858,7 @@ userinfo_t *psync_get_userinfo() {
     info->usedquota = papi_find_result2(res, "usedquota", PARAM_NUM)->num;
     info->freequota = papi_find_result2(res, "freequota", PARAM_NUM)->num;
     info->registered = papi_find_result2(res, "registered", PARAM_NUM)->num;
-    psync_free(res);
+    free(res);
     return info;
   }
 
diff --git a/pclsync/psynclib.h b/pclsync/psynclib.h
index 095899d..a749d00 100644
--- a/pclsync/psynclib.h
+++ b/pclsync/psynclib.h
@@ -514,10 +514,6 @@ typedef void (*psync_free_t)(void *);
 
 typedef void (*psync_generic_callback_t)();
 
-void *psync_malloc(size_t size);
-void *psync_realloc(void *ptr, size_t size);
-void psync_free(void *ptr);
-
 /* Event callback is called every time a download/upload is started/finished,
  * quota is changed, folder is shared or similar. Look at the PEVENT_ constants
  * for a list of possible events.
@@ -668,7 +664,7 @@ void psync_unlink();
  * psync_tfa_send_nofification() - sends notification with two factor
  * authentication code to all already logged in devices. If devices_list is not
  * null it is filled in with list of user's devices. In this case the caller is
- * supposed to free the list with a single call to psync_free(). Returns -1 in
+ * supposed to free the list with a single call to free(). Returns -1 in
  * case of network error or one of the positive error codes listed at
  * https://docsqa2.pcloud.com/methods/auth/tfa_sendcodeviasysnotification.html
  *
diff --git a/pclsync/psys.c b/pclsync/psys.c
index 50506c4..9406005 100644
--- a/pclsync/psys.c
+++ b/pclsync/psys.c
@@ -4,7 +4,6 @@
 #include <sys/resource.h>
 
 #include "plibs.h"
-#include "pmemlock.h"
 #include "psys.h"
 
 static uid_t psync_uid;
@@ -51,8 +50,7 @@ void psys_init() {
   psync_gids = psync_new_cnt(gid_t, psync_gids_cnt);
   if (unlikely_log(getgroups(psync_gids_cnt, psync_gids) != psync_gids_cnt))
     psync_gids_cnt = 0;
-  pmemlock_set_pagesize(sysconf(_SC_PAGESIZE));
-  debug(D_NOTICE, "detected page size %d", pmemlock_get_pagesize());
+  debug(D_NOTICE, "detected page size %ld", sysconf(_SC_PAGESIZE));
 }
 
 time_t psys_time_seconds() {
diff --git a/pclsync/ptask.c b/pclsync/ptask.c
index d842969..36838ac 100644
--- a/pclsync/ptask.c
+++ b/pclsync/ptask.c
@@ -254,7 +254,7 @@ static int download_send_error(stream_t *s, async_params_t *prms,
   ptree_del(&prms->streams, &s->tree);
   if (s->free)
     s->free(s, error);
-  psync_free(s);
+  free(s);
   return 0;
 }
 
@@ -599,7 +599,7 @@ static void proc_async_transfer(void *ptr) {
   pdeflate_destroy(prms->dec);
   ptree_for_each_element_call_safe(prms->streams, stream_t, tree,
                                         stream_destroy);
-  psync_free(prms);
+  free(prms);
 }
 
 static int proc_start_async_transfer() {
@@ -636,11 +636,11 @@ static int proc_start_async_transfer() {
           (int)papi_find_result2(res, "result", PARAM_NUM)->num,
           papi_find_result2(res, "error", PARAM_STR)->str);
     psync_process_api_error(papi_find_result2(res, "result", PARAM_NUM)->num);
-    psync_free(res);
+    free(res);
     psync_apipool_release(api);
     goto err0;
   }
-  psync_free(res);
+  free(res);
   if (socketpair(AF_UNIX, SOCK_STREAM, 0, pair)) {
     debug(D_NOTICE, "socketpair() failed");
     goto err1;
@@ -723,7 +723,7 @@ static int sock_writeall(int sock, const void *buff, size_t len) {
 static stream_t *stream_create(async_params_t *prms, size_t addsize) {
   psync_tree *parent;
   stream_t *ret;
-  ret = (stream_t *)psync_malloc(sizeof(stream_t) + addsize);
+  ret = (stream_t *)malloc(sizeof(stream_t) + addsize);
   ret->streamid = ++prms->laststreamid;
   ret->flags = 0;
   ret->free = NULL;
@@ -747,7 +747,7 @@ static void stream_destroy(stream_t *s) {
   }
   if (s->free)
     s->free(s, PSYNC_ASYNC_ERROR_NET);
-  psync_free(s);
+  free(s);
 }
 
 static int stream_process_data(async_params_t *prms) {
@@ -1065,8 +1065,8 @@ void ptask_cfldr_save_fldrkey(void *ptr) {
   psync_sql_bind_uint(res, 1, t->id);
   psync_sql_bind_blob(res, 2, (const char *)t->key->data, t->key->datalen);
   psync_sql_run_free(res);
-  psync_free(t->key);
-  psync_free(t);
+  free(t->key);
+  free(t);
 }
 
 void ptask_cfldr_save_filekey(void *ptr) {
@@ -1079,6 +1079,6 @@ void ptask_cfldr_save_filekey(void *ptr) {
   psync_sql_bind_uint(res, 2, t->hash);
   psync_sql_bind_blob(res, 3, (const char *)t->key->data, t->key->datalen);
   psync_sql_run_free(res);
-  psync_free(t->key);
-  psync_free(t);
+  free(t->key);
+  free(t);
 }
\ No newline at end of file
diff --git a/pclsync/ptevent.c b/pclsync/ptevent.c
index 3dbc370..645afe8 100644
--- a/pclsync/ptevent.c
+++ b/pclsync/ptevent.c
@@ -15,7 +15,7 @@ static void proc_send_data_event(void *ptr) {
   data_event_fptr(data->eventid, (char *)data->str1, (char *)data->str2,
                   data->uint1, data->uint2);
 
-  psync_free(ptr);
+  free(ptr);
 }
 
 void ptevent_init(void *ptr) {
diff --git a/pclsync/ptimer.c b/pclsync/ptimer.c
index bf586a2..6e2c617 100644
--- a/pclsync/ptimer.c
+++ b/pclsync/ptimer.c
@@ -140,8 +140,7 @@ PSYNC_NOINLINE static void timer_process_timers(psync_list *timers) {
     }
   }
   pthread_mutex_unlock(&timer_mutex);
-  psync_list_for_each_element_call(timers, psync_timer_structure_t, list,
-                                   psync_free);
+  psync_list_for_each_element_call(timers, psync_timer_structure_t, list, free);
 }
 
 static void timer_thread() {
@@ -235,7 +234,7 @@ int ptimer_stop(psync_timer_t timer) {
   }
   pthread_mutex_unlock(&timer_mutex);
   if (needfree) {
-    psync_free(timer);
+    free(timer);
     return 0;
   } else
     return 1;
diff --git a/pclsync/ptools.c b/pclsync/ptools.c
index c81e07d..e863085 100644
--- a/pclsync/ptools.c
+++ b/pclsync/ptools.c
@@ -411,7 +411,7 @@ void ptools_send_psyncs_event(const char *binapi, const char *auth) {
   int intRes;
   int syncCnt = 0;
 
-  errMsg = (char *)psync_malloc(1024 * sizeof(char));
+  errMsg = (char *)malloc(1024 * sizeof(char));
   errMsg[0] = 0;
 
   time(&rawtime);
@@ -425,7 +425,7 @@ void ptools_send_psyncs_event(const char *binapi, const char *auth) {
 
     if (syncCnt < 1) {
       debug(D_NOTICE, "No syncs, skip the event.");
-      psync_free(errMsg);
+      free(errMsg);
       return;
     }
 
@@ -447,7 +447,7 @@ void ptools_send_psyncs_event(const char *binapi, const char *auth) {
     psync_sql_run_free(sql);
   }
 
-  psync_free(errMsg);
+  free(errMsg);
 }
 
 int ptools_set_backend_file_dates(uint64_t fileid, time_t ctime, time_t mtime) {
diff --git a/pclsync/publiclinks.c b/pclsync/publiclinks.c
index a00004e..b209a8a 100644
--- a/pclsync/publiclinks.c
+++ b/pclsync/publiclinks.c
@@ -103,14 +103,14 @@ static void modify_screenshot_public_link(void *par) {
                       "account required.");
   }
 
-  psync_free(linkidp);
-  psync_free(bres);
+  free(linkidp);
+  free(bres);
 }
 
 int64_t do_psync_screenshot_public_link(const char *path, int hasdelay,
                                         uint64_t delay, char **link /*OUT*/,
                                         char **err /*OUT*/) {
-  scr_params *params = psync_malloc(sizeof(scr_params));
+  scr_params *params = malloc(sizeof(scr_params));
   int64_t ret =
       do_psync_file_public_link(path, &params->linkid, link, err, 0, 0, 0);
   if (hasdelay) {
@@ -118,7 +118,7 @@ int64_t do_psync_screenshot_public_link(const char *path, int hasdelay,
     prun_thread1("Modify link expiration.", modify_screenshot_public_link,
                       params);
   } else
-    psync_free(params);
+    free(params);
   return ret;
 }
 
@@ -150,7 +150,7 @@ int64_t do_psync_file_public_link(const char *path, int64_t *plinkid,
     int numparam = 2 + !!expire + !!maxdownloads + !!maxtraffic;
     int pind = 1;
 
-    t = (binparam *)psync_malloc(numparam * sizeof(binparam));
+    t = (binparam *)malloc(numparam * sizeof(binparam));
     init_param_str(t, "auth", psync_my_auth);
     init_param_str(t + pind++, "path", path);
     if (expire)
@@ -163,12 +163,12 @@ int64_t do_psync_file_public_link(const char *path, int64_t *plinkid,
     if (unlikely(!api)) {
       debug(D_WARNING, "Can't gat api from the pool. No pool ?\n");
       *err = psync_strndup("Connection error.", 17);
-      psync_free(t);
+      free(t);
       return 1;
     }
     bres = papi_send(api, "getfilepublink", sizeof("getfilepublink") - 1,
                            t, pind, -1, 1);
-    psync_free(t);
+    free(t);
   }
 
   if (likely(bres))
@@ -197,7 +197,7 @@ int64_t do_psync_file_public_link(const char *path, int64_t *plinkid,
     *plinkid = linkid;
 
 free_ret:
-  psync_free(bres);
+  free(bres);
   return (int64_t)result;
 }
 
@@ -227,7 +227,7 @@ int64_t do_psync_folder_public_link(const char *path, char **link /*OUT*/,
     int numparam = 2 + !!expire + !!maxdownloads + !!maxtraffic;
     int pind = 1;
 
-    t = (binparam *)psync_malloc(numparam * sizeof(binparam));
+    t = (binparam *)malloc(numparam * sizeof(binparam));
     init_param_str(t, "auth", psync_my_auth);
     init_param_str(t + pind++, "path", path);
     if (expire)
@@ -244,7 +244,7 @@ int64_t do_psync_folder_public_link(const char *path, char **link /*OUT*/,
     }
     bres = papi_send(api, "getfolderpublink",
                            sizeof("getfolderpublink") - 1, t, pind, -1, 1);
-    psync_free(t);
+    free(t);
   }
   if (likely(bres))
     psync_apipool_release(api);
@@ -271,7 +271,7 @@ int64_t do_psync_folder_public_link(const char *path, char **link /*OUT*/,
   *link = psync_strndup(rescode, strlen(rescode));
   result = papi_find_result2(bres, "linkid", PARAM_NUM)->num;
 
-  psync_free(bres);
+  free(bres);
 
   return result;
 }
@@ -301,7 +301,7 @@ int64_t do_psync_folder_public_link_full(const char *path, char **link /*OUT*/,
     int numparam = 2 + !!expire + !!maxdownloads + !!maxtraffic + !!password;
     int pind = 1;
 
-    t = (binparam *)psync_malloc(numparam * sizeof(binparam));
+    t = (binparam *)malloc(numparam * sizeof(binparam));
     init_param_str(t, "auth", psync_my_auth);
     init_param_str(t + pind++, "path", path);
     if (password)
@@ -320,7 +320,7 @@ int64_t do_psync_folder_public_link_full(const char *path, char **link /*OUT*/,
     }
     bres = papi_send(api, "getfolderpublink",
                            sizeof("getfolderpublink") - 1, t, pind, -1, 1);
-    psync_free(t);
+    free(t);
   }
 
   if (likely(bres))
@@ -349,7 +349,7 @@ int64_t do_psync_folder_public_link_full(const char *path, char **link /*OUT*/,
   *link = psync_strndup(rescode, strlen(rescode));
   result = papi_find_result2(bres, "linkid", PARAM_NUM)->num;
 
-  psync_free(bres);
+  free(bres);
 
   return result;
 }
@@ -397,7 +397,7 @@ int64_t do_psync_folder_updownlink_link(int canupload,
   }
 
   result = 0;
-  psync_free(bres);
+  free(bres);
 
   return result;
 }
@@ -428,21 +428,21 @@ int64_t do_ptree_public_link(const char *linkname, const char *root,
   if (unlikely(!(!!root + !!numfolders + !!numfiles)))
     return -3;
 
-  t = (binparam *)psync_malloc(numparam * sizeof(binparam));
+  t = (binparam *)malloc(numparam * sizeof(binparam));
 
   init_param_str(t, "auth", psync_my_auth);
 
   init_param_str(t + pind++, "name", linkname);
 
   if (root) {
-    ids = (char *)psync_malloc(FOLDERID_ENTRY_SIZE);
+    ids = (char *)malloc(FOLDERID_ENTRY_SIZE);
     id = psync_fsfolderid_by_path(root, 0);
     k = sprintf(ids, "%lld", (long long)id);
     init_param_str(t + pind++, "folderid", ids);
   }
 
   if (numfolders) {
-    ids1 = (char *)psync_malloc(numfolders * FOLDERID_ENTRY_SIZE);
+    ids1 = (char *)malloc(numfolders * FOLDERID_ENTRY_SIZE);
     idsp = ids1;
     for (i = 0; i < numfolders; ++i) {
       id = psync_fsfolderid_by_path(folders[i], 0);
@@ -462,7 +462,7 @@ int64_t do_ptree_public_link(const char *linkname, const char *root,
     psync_uint_row row;
     psync_fspath_t *filep;
 
-    ids2 = (char *)psync_malloc(numfiles * FOLDERID_ENTRY_SIZE);
+    ids2 = (char *)malloc(numfiles * FOLDERID_ENTRY_SIZE);
     idsp = ids2;
     for (i = 0; i < numfiles; ++i) {
       psync_sql_rdlock();
@@ -540,14 +540,14 @@ int64_t do_ptree_public_link(const char *linkname, const char *root,
   result = papi_find_result2(bres, "linkid", PARAM_NUM)->num;
 
   if (ids)
-    psync_free(ids);
+    free(ids);
   if (ids1)
-    psync_free(ids1);
+    free(ids1);
   if (ids2)
-    psync_free(ids2);
+    free(ids2);
 
-  psync_free(bres);
-  psync_free(t);
+  free(bres);
+  free(t);
 
   return result;
 }
@@ -601,7 +601,7 @@ int cache_links(char *err, size_t err_size /*OUT*/) {
     debug(D_WARNING, "Send command returned in valid result.\n");
     //*err = psync_strndup("Connection error.", 17);
     snprintf(err, err_size, "Connection error.");
-    psync_free(bres);
+    free(bres);
     return 0;
   }
   result = papi_find_result2(bres, "result", PARAM_NUM)->num;
@@ -612,7 +612,7 @@ int cache_links(char *err, size_t err_size /*OUT*/) {
     debug(D_WARNING, "command listpublinks returned error code %u",
           (unsigned)result);
     psync_process_api_error(result);
-    psync_free(bres);
+    free(bres);
     if (psync_handle_api_result(result) == PSYNC_NET_TEMPFAIL)
       return -result;
     else {
@@ -624,7 +624,7 @@ int cache_links(char *err, size_t err_size /*OUT*/) {
   publinks = papi_find_result2(bres, "publinks", PARAM_ARRAY);
   linkscnt = publinks->length;
   if (!linkscnt) {
-    psync_free(bres);
+    free(bres);
     return 0;
   }
   for (i = 0; i < linkscnt; ++i) {
@@ -708,7 +708,7 @@ int cache_links(char *err, size_t err_size /*OUT*/) {
     psync_sql_run_free(q);
   }
 
-  psync_free(bres);
+  free(bres);
   return linkscnt;
 }
 
@@ -749,7 +749,7 @@ int do_psync_delete_link(int64_t linkid, char **err /*OUT*/) {
       return -1;
     }
   }
-  psync_free(bres);
+  free(bres);
   return 0;
 }
 
@@ -798,7 +798,7 @@ int do_psync_change_link(unsigned long long linkid, unsigned long long expire,
   int numparam = 5; // +!!expire + !!maxdownloads + !!maxtraffic + !!password;
   int pind = 1;
 
-  t = (binparam *)psync_malloc(numparam * sizeof(binparam));
+  t = (binparam *)malloc(numparam * sizeof(binparam));
   init_param_str(t, "auth", psync_my_auth);
   init_param_num(t + pind++, "linkid", linkid);
   if (linkpassword)
@@ -829,7 +829,7 @@ int do_psync_change_link(unsigned long long linkid, unsigned long long expire,
   }
   bres = papi_send(api, "changepublink", sizeof("changepublink") - 1, t,
                          pind, -1, 1);
-  psync_free(t);
+  free(t);
   result = process_bres("deletepublink", bres, api, err);
   return result;
 }
@@ -859,7 +859,7 @@ int do_change_link_expire(unsigned long long linkid, unsigned long long expire,
   }
 
   result = process_bres("changepublink", bres, api, err);
-  psync_free(bres);
+  free(bres);
 
   return result;
 }
@@ -888,7 +888,7 @@ int do_change_link_password(unsigned long long linkid, const char *password,
     bres = papi_send2(api, "changepublink", paramsd);
   }
   result = process_bres("changepublink", bres, api, err);
-  psync_free(bres);
+  free(bres);
 
   return result;
 }
@@ -919,7 +919,7 @@ int do_change_link_enable_upload(unsigned long long linkid,
   }
 
   result = process_bres("changepublink", bres, api, err);
-  psync_free(bres);
+  free(bres);
 
   return result;
 }
@@ -953,7 +953,7 @@ int64_t do_psync_upload_link(const char *path, const char *comment,
     int numparam = 3 + !!expire + !!maxspace + !!maxfiles;
     int pind = 1;
 
-    t = (binparam *)psync_malloc(numparam * sizeof(binparam));
+    t = (binparam *)malloc(numparam * sizeof(binparam));
     init_param_str(t, "auth", psync_my_auth);
     init_param_str(t + pind++, "path", path);
     init_param_str(t + pind++, "comment", comment);
@@ -971,7 +971,7 @@ int64_t do_psync_upload_link(const char *path, const char *comment,
     }
     bres = papi_send(api, "createuploadlink",
                            sizeof("createuploadlink") - 1, t, pind, -1, 1);
-    psync_free(t);
+    free(t);
   }
 
   if (likely(bres))
@@ -1002,7 +1002,7 @@ int64_t do_psync_upload_link(const char *path, const char *comment,
 
   result = papi_find_result2(bres, "uploadlinkid", PARAM_NUM)->num;
 
-  psync_free(bres);
+  free(bres);
 
   return result;
 }
@@ -1025,7 +1025,7 @@ int do_psync_delete_upload_link(int64_t uploadlinkid, char **err /*OUT*/) {
 
   bres = papi_send2(api, "deleteuploadlink", params);
   result = process_bres("deletepublink", bres, api, err);
-  psync_free(bres);
+  free(bres);
 
   return result;
 }
@@ -1142,12 +1142,12 @@ plink_contents_t *do_show_link(const char *code, char **err /*OUT*/) {
   if (meta) {
     contents = papi_check_result2(meta, "contents", PARAM_ARRAY);
     if (!contents) {
-      psync_free(bres);
+      free(bres);
       return 0;
     }
     concnt = contents->length;
     if (!concnt) {
-      psync_free(bres);
+      free(bres);
       return 0;
     }
     builder = psync_list_builder_create(sizeof(link_cont_t),
@@ -1171,10 +1171,10 @@ plink_contents_t *do_show_link(const char *code, char **err /*OUT*/) {
       pcont->icon = papi_find_result2(link, "icon", PARAM_NUM)->num;
     }
     ret = (plink_contents_t *)psync_list_builder_finalize(builder);
-    psync_free(bres);
+    free(bres);
     return ret;
   }
-  psync_free(bres);
+  free(bres);
   return 0;
 }
 
@@ -1296,7 +1296,7 @@ int cache_upload_links(char **err /*OUT*/) {
     psync_sql_run_free(q);
   }
 
-  psync_free(bres);
+  free(bres);
 
   return linkscnt;
 }
@@ -1313,11 +1313,11 @@ void cache_links_all() {
     if (err) {
       debug(D_WARNING, "Problem cacheing links errcode %d errmsg[%s]\n", ret,
             err);
-      psync_free(err);
+      free(err);
     }
   }
   if (err)
-    psync_free(err);
+    free(err);
 }
 
 int do_delete_all_links(int64_t folderid, int64_t fileid, char **err) {
@@ -1446,7 +1446,7 @@ preciever_list_t *do_list_email_with_access(unsigned long long linkid,
 
   if (!lcnt) {
     ret = (preciever_list_t *)psync_list_builder_finalize(builder);
-    psync_free(bres);
+    free(bres);
     return ret;
   }
   for (i = 0; i < lcnt; ++i) {
@@ -1463,7 +1463,7 @@ preciever_list_t *do_list_email_with_access(unsigned long long linkid,
   }
   ret = (preciever_list_t *)psync_list_builder_finalize(builder);
 
-  psync_free(bres);
+  free(bres);
 
   return ret;
 }
@@ -1487,7 +1487,7 @@ int do_link_add_access(unsigned long long linkid, const char *mail,
 
   bres = papi_send2(api, "publink/addaccess", params);
   result = process_bres("publink/addaccess", bres, api, err);
-  psync_free(bres);
+  free(bres);
 
   return result;
 }
@@ -1510,7 +1510,7 @@ int do_link_remove_access(unsigned long long linkid,
 
   bres = papi_send2(api, "publink/removeaccess", params);
   result = process_bres("publink/removeaccess", bres, api, err);
-  psync_free(bres);
+  free(bres);
 
   return result;
 }
@@ -1566,7 +1566,7 @@ bookmarks_list_t *do_cache_bookmarks(char **err) {
                                       offsetof(bookmarks_list_t, entries));
   if (!lcnt) {
     ret = (bookmarks_list_t *)psync_list_builder_finalize(builder);
-    psync_free(bres);
+    free(bres);
     return ret;
   }
 
@@ -1599,7 +1599,7 @@ bookmarks_list_t *do_cache_bookmarks(char **err) {
   }
   ret = (bookmarks_list_t *)psync_list_builder_finalize(builder);
 
-  psync_free(bres);
+  free(bres);
 
   return ret;
 }
@@ -1621,7 +1621,7 @@ int do_remove_bookmark(const char *code, int locationid, char **err) {
 
   bres = papi_send2(api, "publink/unpin", params);
   result = process_bres("publink/unpin", bres, api, err);
-  psync_free(bres);
+  free(bres);
 
   return result;
 }
@@ -1646,7 +1646,7 @@ int do_change_bookmark(const char *code, int locationid, const char *name,
 
   bres = papi_send2(api, "publink/changepin", params);
   result = process_bres("publink/changepin", bres, api, err);
-  psync_free(bres);
+  free(bres);
 
   return result;
 }
diff --git a/pclsync/pupload.c b/pclsync/pupload.c
index 9e7fccf..06bcf7a 100644
--- a/pclsync/pupload.c
+++ b/pclsync/pupload.c
@@ -174,7 +174,7 @@ static int64_t do_run_command_res(const char *cmd, size_t cmdlen,
   if (unlikely(!res))
     return -1;
   result = papi_find_result2(res, "result", PARAM_NUM)->num;
-  psync_free(res);
+  free(res);
   if (unlikely(result)) {
     psync_process_api_error(result);
     debug(D_WARNING, "command %s returned code %u", cmd, (unsigned)result);
@@ -240,7 +240,7 @@ static int task_createfolder(psync_syncid_t syncid,
             (unsigned)result, papi_find_result2(bres, "error", PARAM_STR)->str,
             (unsigned long)parentfolderid, name);
       psync_process_api_error(result);
-      psync_free(bres);
+      free(bres);
       if (psync_handle_api_result(result) == PSYNC_NET_TEMPFAIL)
         return -1;
       else
@@ -268,7 +268,7 @@ static int task_createfolder(psync_syncid_t syncid,
     pdiff_unlock();
     if (papi_find_result2(bres, "created", PARAM_BOOL)->num)
       pdiff_wake();
-    psync_free(bres);
+    free(bres);
     return ret;
   }
 }
@@ -375,7 +375,7 @@ int handle_api_errors(sync_err_struct *err_struct) {
 
     ptevent_process(event_data);
 
-    psync_free(event_data);
+    free(event_data);
     break;
 
   default:
@@ -432,7 +432,7 @@ static int task_renameremotefolder(psync_folderid_t folderid,
     ret = handle_api_errors(&err_struct);
   }
 
-  psync_free(res);
+  free(res);
 
   return ret;
 }
@@ -505,7 +505,7 @@ static void set_local_file_conflicted(psync_fileid_t localfileid,
     psync_sql_rollback_transaction();
   else
     psync_sql_commit_transaction();
-  psync_free(newpath);
+  free(newpath);
 }
 
 static int copy_file(psync_fileid_t fileid, uint64_t hash,
@@ -535,7 +535,7 @@ static int copy_file(psync_fileid_t fileid, uint64_t hash,
   result = papi_find_result2(res, "result", PARAM_NUM)->num;
   if (unlikely(result)) {
     pdiff_unlock();
-    psync_free(res);
+    free(res);
     debug(D_WARNING, "command copyfile returned code %u", (unsigned)result);
     psync_process_api_error(result);
     return 0;
@@ -545,7 +545,7 @@ static int copy_file(psync_fileid_t fileid, uint64_t hash,
                            papi_find_result2(meta, "fileid", PARAM_NUM)->num,
                            papi_find_result2(meta, "hash", PARAM_NUM)->num);
   pdiff_unlock();
-  psync_free(res);
+  free(res);
   pdiff_wake();
   return 1;
 }
@@ -607,7 +607,7 @@ static int copy_file_if_exists(const unsigned char *hashhex, uint64_t fsize,
     return -1;
   result = papi_find_result2(res, "result", PARAM_NUM)->num;
   if (unlikely(result)) {
-    psync_free(res);
+    free(res);
     debug(D_WARNING, "command getfilesbychecksum returned code %u",
           (unsigned)result);
     psync_process_api_error(result);
@@ -615,7 +615,7 @@ static int copy_file_if_exists(const unsigned char *hashhex, uint64_t fsize,
   }
   metas = papi_find_result2(res, "metadata", PARAM_ARRAY);
   if (!metas->length) {
-    psync_free(res);
+    free(res);
     return 0;
   }
   meta = metas->array[0];
@@ -633,7 +633,7 @@ static int copy_file_if_exists(const unsigned char *hashhex, uint64_t fsize,
           (long unsigned)folderid, name);
   }
 
-  psync_free(res);
+  free(res);
   return ret;
 }
 
@@ -695,7 +695,7 @@ static int upload_file(const char *localpath, const unsigned char *hashhex,
                                     params, ARRAY_SIZE(params), fsize, 0)))
     goto err1;
   bw = 0;
-  buff = psync_malloc(PSYNC_COPY_BUFFER_SIZE);
+  buff = malloc(PSYNC_COPY_BUFFER_SIZE);
   while (bw < fsize) {
     if (unlikely(upload->stop)) {
       debug(D_NOTICE, "upload of %s stopped", localpath);
@@ -720,7 +720,7 @@ static int upload_file(const char *localpath, const unsigned char *hashhex,
     upload->uploaded += rrd;
     add_bytes_uploaded(rrd);
   }
-  psync_free(buff);
+  free(buff);
   pfile_close(fd);
   psync_set_default_sendbuf(api);
   pdiff_lock();
@@ -733,7 +733,7 @@ static int upload_file(const char *localpath, const unsigned char *hashhex,
   }
   result = papi_find_result2(res, "result", PARAM_NUM)->num;
   if (unlikely(result)) {
-    psync_free(res);
+    free(res);
     debug(D_WARNING, "command uploadfile returned code %u", (unsigned)result);
     psync_process_api_error(result);
     if (psync_handle_api_result(result) == PSYNC_NET_TEMPFAIL)
@@ -773,16 +773,16 @@ static int upload_file(const char *localpath, const unsigned char *hashhex,
           "uploaded file differs localsize=%lu, remotesize=%lu, localhash=%s, "
           "remotehash=%s",
           (unsigned long)fsize, (unsigned long)rsize, hashhex, hashhexsrv);
-    psync_free(res);
+    free(res);
     return -1;
   }
-  psync_free(res);
+  free(res);
   pdiff_wake();
   debug(D_NOTICE, "file %s uploaded to %lu/%s", localpath,
         (long unsigned)folderid, name);
   return 0;
 err2:
-  psync_free(buff);
+  free(buff);
 err1:
   psync_apipool_release_bad(api);
 err0:
@@ -809,7 +809,7 @@ static int upload_range(psock_t *api, psync_upload_range_list_t *r,
     return PSYNC_NET_TEMPFAIL;
   bw = 0;
 
-  buff = psync_malloc(PSYNC_COPY_BUFFER_SIZE);
+  buff = malloc(PSYNC_COPY_BUFFER_SIZE);
   while (bw < r->len) {
     if (unlikely(upload->stop)) {
       debug(D_NOTICE, "upload stopped");
@@ -829,10 +829,10 @@ static int upload_range(psock_t *api, psync_upload_range_list_t *r,
     upload->uploaded += rrd;
     add_bytes_uploaded(rrd);
   }
-  psync_free(buff);
+  free(buff);
   return PSYNC_NET_OK;
 err0:
-  psync_free(buff);
+  free(buff);
   return PSYNC_NET_TEMPFAIL;
 }
 
@@ -943,7 +943,7 @@ static int upload_save(psock_t *api, psync_fileid_t localfileid,
       ret = PSYNC_NET_OK;
       pdiff_wake();
     }
-    psync_free(res);
+    free(res);
   } else
     ret = PSYNC_NET_TEMPFAIL;
   pdiff_unlock();
@@ -986,7 +986,7 @@ static int upload_big_file(const char *localpath, const unsigned char *hashhex,
       goto err0;
     result = papi_find_result2(res, "result", PARAM_NUM)->num;
     if (unlikely(result)) {
-      psync_free(res);
+      free(res);
       psync_apipool_release(api);
       psync_process_api_error(result);
       debug(D_WARNING, "upload_create returned %lu", (unsigned long)result);
@@ -996,7 +996,7 @@ static int upload_big_file(const char *localpath, const unsigned char *hashhex,
         return 0;
     }
     uploadid = papi_find_result2(res, "uploadid", PARAM_NUM)->num;
-    psync_free(res);
+    free(res);
     psync_sql_start_transaction();
     sql = psync_sql_query_nolock("SELECT id FROM localfile WHERE id=?");
     psync_sql_bind_uint(sql, 1, localfileid);
@@ -1030,8 +1030,7 @@ static int upload_big_file(const char *localpath, const unsigned char *hashhex,
   if (unlikely(fd == INVALID_HANDLE_VALUE)) {
     debug(D_WARNING, "could not open local file %s", localpath);
     psync_apipool_release(api);
-    psync_list_for_each_element_call(&rlist, psync_upload_range_list_t, list,
-                                     psync_free);
+    psync_list_for_each_element_call(&rlist, psync_upload_range_list_t, list, free);
     return -1;
   }
   if (likely(uploadoffset < fsize)) {
@@ -1089,12 +1088,12 @@ static int upload_big_file(const char *localpath, const unsigned char *hashhex,
           if (fileid &&
               psync_net_scan_file_for_blocks(api, &rlist, fileid, hash, fd) ==
                   PSYNC_NET_TEMPFAIL) {
-            psync_free(nname);
+            free(nname);
             goto err1;
           }
         } else
           psync_sql_free_result(sql);
-        psync_free(nname);
+        free(nname);
       } else
         psync_sql_free_result(sql);
     }
@@ -1108,10 +1107,10 @@ static int upload_big_file(const char *localpath, const unsigned char *hashhex,
           psync_net_scan_upload_for_blocks(api, &rlist,
                                            psync_get_result_cell(fr, id, 0),
                                            fd) == PSYNC_NET_TEMPFAIL) {
-        psync_free(fr);
+        free(fr);
         goto err1;
       }
-    psync_free(fr);
+    free(fr);
   }
   rid = 0;
   respwait = 0;
@@ -1154,7 +1153,7 @@ static int upload_big_file(const char *localpath, const unsigned char *hashhex,
       result = papi_find_result2(res, "result", PARAM_NUM)->num;
       if (unlikely(result)) {
         id = papi_find_result2(res, "id", PARAM_NUM)->num;
-        psync_free(res);
+        free(res);
         psync_process_api_error(result);
         if (unlikely_log(!id))
           goto err1;
@@ -1163,7 +1162,7 @@ static int upload_big_file(const char *localpath, const unsigned char *hashhex,
           if (unlikely_log(!res))
             goto err1;
           respwait--;
-          psync_free(res);
+          free(res);
         }
         psync_list_for_each_element(le2, &rlist, psync_upload_range_list_t,
                                     list) if (le2->id == id) {
@@ -1193,7 +1192,7 @@ static int upload_big_file(const char *localpath, const unsigned char *hashhex,
                 "file size mismatch after upload, expected: %lu, got: %lu",
                 (unsigned long)fsize,
                 (unsigned long)papi_find_result2(res, "size", PARAM_NUM)->num);
-          psync_free(res);
+          free(res);
           goto err1;
         } else if (unlikely(memcmp(
                        papi_find_result2(res, PSYNC_CHECKSUM, PARAM_STR)->str,
@@ -1203,12 +1202,12 @@ static int upload_big_file(const char *localpath, const unsigned char *hashhex,
               "hash mismatch after upload, expected: %." NTO_STR(
                   PSYNC_HASH_DIGEST_HEXLEN) "s, got: %." NTO_STR(PSYNC_HASH_DIGEST_HEXLEN) "s",
               hashhex, papi_find_result2(res, PSYNC_CHECKSUM, PARAM_STR)->str);
-          psync_free(res);
+          free(res);
           goto err1;
         } else
           assert(respwait == 0);
       }
-      psync_free(res);
+      free(res);
     }
   restart:
     if (le->type == PSYNC_URANGE_UPLOAD) {
@@ -1244,8 +1243,7 @@ static int upload_big_file(const char *localpath, const unsigned char *hashhex,
     respwait++;
     uploadoffset += le->len;
   }
-  psync_list_for_each_element_call(&rlist, psync_upload_range_list_t, list,
-                                   psync_free);
+  psync_list_for_each_element_call(&rlist, psync_upload_range_list_t, list, free);
   if (pfile_size(fd) != fsize) {
     debug(D_NOTICE, "file %s changed filesize while uploading, restarting task",
           localpath);
@@ -1265,15 +1263,13 @@ static int upload_big_file(const char *localpath, const unsigned char *hashhex,
   }
 err1:
   pfile_close(fd);
-  psync_list_for_each_element_call(&rlist, psync_upload_range_list_t, list,
-                                   psync_free);
+  psync_list_for_each_element_call(&rlist, psync_upload_range_list_t, list, free);
 err0:
   psync_apipool_release_bad(api);
   return -1;
 errp:
   pfile_close(fd);
-  psync_list_for_each_element_call(&rlist, psync_upload_range_list_t, list,
-                                   psync_free);
+  psync_list_for_each_element_call(&rlist, psync_upload_range_list_t, list, free);
   psync_apipool_release_bad(api);
   return 0;
 }
@@ -1283,7 +1279,7 @@ static void delete_uploadid(psync_uploadid_t uploadid) {
                        PAPI_NUM("uploadid", uploadid)};
   binresult *res;
   res = psync_api_run_command("upload_delete", params);
-  psync_free(res);
+  free(res);
 }
 
 static void delete_uploadids(psync_fileid_t localfileid) {
@@ -1302,7 +1298,7 @@ static void delete_uploadids(psync_fileid_t localfileid) {
     psync_sql_bind_uint(res, 1, localfileid);
     psync_sql_run_free(res);
   }
-  psync_free(rows);
+  free(rows);
 }
 
 static void delete_from_localfile(psync_fileid_t localfileid) {
@@ -1373,7 +1369,7 @@ static int task_uploadfile(psync_syncid_t syncid, psync_folderid_t localfileid,
         if (stat(localpath, &st)) {
           debug(D_NOTICE, "can not stat %s anymore, failing for now",
                 localpath);
-          psync_free(localpath);
+          free(localpath);
           return -1;
         }
         ctime = ptimer_time();
@@ -1382,7 +1378,7 @@ static int task_uploadfile(psync_syncid_t syncid, psync_folderid_t localfileid,
       if (ret == 10) {
         debug(D_NOTICE, "file %s kept changing %d times, skipping for now",
               localpath, ret);
-        psync_free(localpath);
+        free(localpath);
         return -1;
       }
       debug(D_NOTICE, "file %s got old enough", localpath);
@@ -1391,7 +1387,7 @@ static int task_uploadfile(psync_syncid_t syncid, psync_folderid_t localfileid,
   lock = psync_lock_file(localpath);
   if (!lock) {
     debug(D_NOTICE, "file %s is currently locked, skipping for now", localpath);
-    psync_free(localpath);
+    free(localpath);
     psys_sleep_milliseconds(PSYNC_SLEEP_ON_LOCKED_FILE);
     return -1;
   }
@@ -1408,7 +1404,7 @@ static int task_uploadfile(psync_syncid_t syncid, psync_folderid_t localfileid,
     ret = psync_get_upload_checksum(uploadid, uhashhex, &ufsize);
     if (ret == PSYNC_NET_TEMPFAIL) {
       psync_unlock_file(lock);
-      psync_free(localpath);
+      free(localpath);
       return -1;
     } else if (ret == PSYNC_NET_PERMFAIL)
       uploadid = 0;
@@ -1422,7 +1418,7 @@ static int task_uploadfile(psync_syncid_t syncid, psync_folderid_t localfileid,
     debug(D_WARNING, "could not open local file %s, deleting it from localfile",
           localpath);
     psync_unlock_file(lock);
-    psync_free(localpath);
+    free(localpath);
     delete_from_localfile(localfileid);
     return 0;
   }
@@ -1451,7 +1447,7 @@ static int task_uploadfile(psync_syncid_t syncid, psync_folderid_t localfileid,
           (unsigned long)localfileid);
     psync_sql_free_result(res);
     psync_unlock_file(lock);
-    psync_free(localpath);
+    free(localpath);
     return 0;
   }
   psync_sql_free_result(res);
@@ -1487,8 +1483,8 @@ static int task_uploadfile(psync_syncid_t syncid, psync_folderid_t localfileid,
 
   if (ret == 1 || ret == -1) {
     psync_unlock_file(lock);
-    psync_free(nname);
-    psync_free(localpath);
+    free(nname);
+    free(localpath);
     return ret == 1 ? 0 : -1;
   }
   memcpy(upload->hash, hashhex, PSYNC_HASH_DIGEST_HEXLEN);
@@ -1530,8 +1526,8 @@ static int task_uploadfile(psync_syncid_t syncid, psync_folderid_t localfileid,
     }
   }
   psync_unlock_file(lock);
-  psync_free(nname);
-  psync_free(localpath);
+  free(nname);
+  free(localpath);
   if (!ret)
     delete_uploadids(localfileid);
   return ret;
@@ -1578,7 +1574,7 @@ static void task_run_upload_file_thread(void *ptr) {
   wake_upload_when_ready();
   pthread_mutex_unlock(&current_uploads_mutex);
   pstatus_upload_recalc_async();
-  psync_free(ut);
+  free(ut);
 }
 
 static int task_run_uploadfile(uint64_t taskid, psync_syncid_t syncid,
@@ -1606,7 +1602,7 @@ static int task_run_uploadfile(uint64_t taskid, psync_syncid_t syncid,
   psync_sql_bind_uint(res, 1, taskid);
   psync_sql_run_free(res);
   len = strlen(filename);
-  ut = (upload_task_t *)psync_malloc(offsetof(upload_task_t, filename) + len +
+  ut = (upload_task_t *)malloc(offsetof(upload_task_t, filename) + len +
                                      1);
   ut->upllist.taskid = taskid;
   ut->upllist.localfileid = localfileid;
@@ -1636,7 +1632,7 @@ static int task_run_uploadfile(uint64_t taskid, psync_syncid_t syncid,
   }
   pthread_mutex_unlock(&current_uploads_mutex);
   if (stop) {
-    psync_free(ut);
+    free(ut);
     res = psync_sql_prep_statement("UPDATE task SET inprogress=0 WHERE id=?");
     psync_sql_bind_uint(res, 1, taskid);
     psync_sql_run_free(res);
@@ -1741,7 +1737,7 @@ static void upload_thread() {
         }
       } else if (type != PSYNC_UPLOAD_FILE)
         psys_sleep_milliseconds(PSYNC_SLEEP_ON_FAILED_UPLOAD);
-      psync_free(row);
+      free(row);
       continue;
     }
 
diff --git a/pclsync_lib.cpp b/pclsync_lib.cpp
index 72152d5..cabb52e 100644
--- a/pclsync_lib.cpp
+++ b/pclsync_lib.cpp
@@ -289,7 +289,7 @@ static void status_change(pstatus_t *status) {
   static int cryptocheck = 0;
 
   char *err;
-  err = (char *)psync_malloc(1024);
+  err = (char *)malloc(1024);
 
   std::cout << "Down: " << status->downloadstr << "| Up: " << status->uploadstr
             << ", status is " << status2string(status->status) << std::endl;
@@ -348,8 +348,9 @@ static void status_change(pstatus_t *status) {
         (int)status->status, status2string(status->status));
   }
 
-  if (err)
-    psync_free(err);
+  if (err) {
+    free(err);
+  }
 }
 
 int clib::pclsync_lib::start_crypto(const char *pwd) {
@@ -429,7 +430,7 @@ int clib::pclsync_lib::list_sync_folders(const char *unused) {
   pshm_write(folders, folderssz);
   pthread_mutex_unlock(&mtx);
 
-  psync_free(folders);
+  free(folders);
 
   return 0;
 }
@@ -463,10 +464,10 @@ int clib::pclsync_lib::init() {
       std::cout << "logged in with user " << username_old << ", not "
                 << username_ << ", unlinking" << std::endl;
       psync_unlink();
-      psync_free(username_old);
+      free(username_old);
       return 2;
     }
-    psync_free(username_old);
+    free(username_old);
   }
 
   prpc_register(STARTCRYPTO, &start_crypto);