diff --git a/pclsync/papi.c b/pclsync/papi.c
index 343af44..54c110a 100644
--- a/pclsync/papi.c
+++ b/pclsync/papi.c
@@ -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;
@@ -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;
 }
 
@@ -398,12 +398,12 @@ binresult *papi_result(psock_t *sock) {
   data = (unsigned char *)psync_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;
 }
@@ -418,11 +418,11 @@ binresult *papi_result_thread(psock_t *sock) {
   data = (unsigned char *)psync_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;
@@ -463,7 +463,7 @@ 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;
     }
@@ -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..5fc53f6 100644
--- a/pclsync/pbusinessaccount.c
+++ b/pclsync/pbusinessaccount.c
@@ -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;
 }
@@ -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;
 }
@@ -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;
@@ -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;
   }
@@ -748,13 +748,13 @@ static psync_folderid_t create_index_folder(const char *path) {
     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..34ee282 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)]);
@@ -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..315f026 100644
--- a/pclsync/pcrypto.c
+++ b/pclsync/pcrypto.c
@@ -193,7 +193,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 +343,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 +388,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++;
diff --git a/pclsync/pcryptofolder.c b/pclsync/pcryptofolder.c
index 72d6796..2f81848 100644
--- a/pclsync/pcryptofolder.c
+++ b/pclsync/pcryptofolder.c
@@ -185,7 +185,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)
@@ -239,7 +239,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 +257,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);
@@ -272,8 +272,8 @@ static int download_keys(unsigned char **rsapriv, size_t *rsaprivlen, unsigned c
   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)) {
@@ -292,15 +292,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;
 }
 
@@ -351,12 +351,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 +483,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 +496,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;
 }
 
@@ -511,21 +511,21 @@ static int crypto_keys_match() {
   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 +595,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 +619,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");
@@ -648,10 +648,10 @@ int pcryptofolder_unlock(const char *password) {
     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 +665,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 +683,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 +699,7 @@ static void psync_fs_refresh_crypto_folders() {
     psync_fs_refresh_folder(*fid);
     fid++;
   }
-  psync_free(fids);
+  free(fids);
 }
 
 int pcryptofolder_lock() {
@@ -754,7 +754,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 +847,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 +855,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 +900,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 +908,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 +981,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 +1009,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));
@@ -1148,7 +1148,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 +1205,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 +1296,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 +1362,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 +1434,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 +1519,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 +1536,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 +1570,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 +1663,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 +1676,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 +1690,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 +1718,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 +1748,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 +1779,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;
 }
 
@@ -1877,7 +1877,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 +1891,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 +1915,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;
 }
@@ -1967,27 +1967,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;
@@ -2032,7 +2032,7 @@ int pcryptofolder_change_pass(const char *oldpassphrase,
         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(
@@ -2040,7 +2040,7 @@ int pcryptofolder_change_pass(const char *oldpassphrase,
         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 +2050,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 +2071,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 +2085,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 +2096,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 +2111,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..03e2dbe 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;
@@ -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..4291dbb 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;
     }
   }
@@ -1878,7 +1878,7 @@ static void send_share_notify(psync_eventtype_t eventid, const binresult *share,
   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)))
@@ -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) {
@@ -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..6d3bf67 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;
@@ -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) {
@@ -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;
     }
 
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..77d3e93 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,7 +220,7 @@ 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) {
@@ -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;
 }
 
@@ -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;
@@ -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) {
@@ -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;
   }
@@ -871,7 +871,7 @@ psync_folder_list_t *pfolder_sync_folders(char *syncTypes) {
   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..a32875b 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);
@@ -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;
 }
 
@@ -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,11 +2641,11 @@ 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;
@@ -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..fd07445 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;
 }
 
@@ -90,7 +90,7 @@ static psync_fspath_t *ret_folder_data(psync_fsfolderid_t folderid,
     len = strlen(encname);
     ret = (psync_fspath_t *)psync_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..2efbd45 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);
   }
 }
 
@@ -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);
@@ -771,7 +771,7 @@ 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()))
@@ -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);
@@ -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(
       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,7 +1169,7 @@ 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);
@@ -1195,7 +1195,7 @@ 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(
@@ -1394,7 +1394,7 @@ int psync_fstask_rename_folder(psync_fsfolderid_t folderid,
 
   if (mk) {
     ptree_del(&folder->mkdirs, &mk->tree);
-    psync_free(mk);
+    free(mk);
     folder->taskscnt--;
   }
 
@@ -1416,7 +1416,7 @@ 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--;
   }
 
@@ -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);
@@ -1800,7 +1800,7 @@ 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++;
@@ -1860,7 +1860,7 @@ 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++;
@@ -1902,7 +1902,7 @@ 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++;
@@ -1933,7 +1933,7 @@ 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]);
@@ -1971,7 +1971,7 @@ 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++;
@@ -2036,7 +2036,7 @@ 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++;
@@ -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;
diff --git a/pclsync/pfsupload.c b/pclsync/pfsupload.c
index 1085ee3..ab878b6 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);
@@ -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:
@@ -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)
@@ -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() {
@@ -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..8efe25a 100644
--- a/pclsync/plibs.c
+++ b/pclsync/plibs.c
@@ -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;
@@ -320,7 +320,7 @@ unsigned char *psync_base64_decode(const unsigned char *str, size_t length,
     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;
@@ -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);
@@ -1713,7 +1713,7 @@ psync_full_result_int *psync_sql_fetchall_int(psync_sql_res *res) {
   ret->rows = rows;
   ret->cols = cols;
   memcpy(ret->data, data, sizeof(uint64_t) * off);
-  psync_free(data);
+  free(data);
   return ret;
 }
 
@@ -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) {
@@ -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) {
diff --git a/pclsync/plocalnotify.c b/pclsync/plocalnotify.c
index 96f45db..b4d9a9a 100644
--- a/pclsync/plocalnotify.c
+++ b/pclsync/plocalnotify.c
@@ -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);
   }
 }
@@ -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..db95178 100644
--- a/pclsync/plocalscan.c
+++ b/pclsync/plocalscan.c
@@ -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) {
@@ -268,9 +268,9 @@ static void reload_ignored_folders() {
     }
     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) {
@@ -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;
@@ -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
index 24dc028..0ef6099 100644
--- a/pclsync/pmemlock.c
+++ b/pclsync/pmemlock.c
@@ -165,7 +165,7 @@ static int unlock_page(pageid_t pageid, int page_size) {
       ret = 0;
     } else {
       ptree_del(&locked_pages, tr);
-      psync_free(node);
+      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);
@@ -347,7 +347,7 @@ void *pmemlock_malloc(size_t size) {
 }
 
 void pmemlock_free(void *ptr) {
-  psync_free(ptr);
+  free(ptr);
   return;
   allocator_range *range;
   psync_tree *tr;
@@ -395,7 +395,7 @@ found:
     if (range->locked)
       pmemlock_unlock(range->mem, range->size);
     pmem_munmap(range->mem, range->size);
-    psync_free(range);
+    free(range);
   }
 }
 
diff --git a/pclsync/pnetlibs.c b/pclsync/pnetlibs.c
index a93f63d..382f0f7 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;
 }
 
@@ -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;
 }
@@ -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;
@@ -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:
@@ -1010,7 +1010,7 @@ cont:
 ex:
   rl = ptr - readbuff;
   if (rl == rb) {
-    psync_free(readbuff);
+    free(readbuff);
     readbuff = NULL;
   }
   hsock = (psync_http_socket *)psync_malloc(
@@ -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);
   }
 }
 
@@ -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;
@@ -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)))
@@ -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;
@@ -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;
 }
@@ -2001,7 +2001,7 @@ static void psync_net_check_file_for_blocks(
   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);
@@ -2168,7 +2168,7 @@ static int check_range_for_blocks(psync_file_checksums *checksums,
   buff = psync_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;
 }
 
@@ -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..2c3fde0 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);
@@ -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(
@@ -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..19f18da 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);
   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..809d27c 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);
   }
 }
 
@@ -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..3c7eacd 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);
       }
     }
   }
@@ -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;
 }
@@ -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..43f03d1 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);
   }
 }
 
@@ -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..a2d75f6 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,7 +285,7 @@ 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;
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..9c09c25 100644
--- a/pclsync/psock.c
+++ b/pclsync/psock.c
@@ -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,7 +510,7 @@ 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) {
diff --git a/pclsync/pssl.c b/pclsync/pssl.c
index 1b6bd88..2c01e7d 100644
--- a/pclsync/pssl.c
+++ b/pclsync/pssl.c
@@ -271,7 +271,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 +281,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 +365,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 +387,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 +412,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 +431,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 +439,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 +485,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 +493,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 +519,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;
@@ -593,7 +593,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 +648,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);
@@ -699,7 +699,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);
@@ -723,7 +723,7 @@ prsa_encrypt_data(psync_rsa_publickey_t rsa, const unsigned char *data,
   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",
@@ -775,7 +775,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 +789,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
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..3e9825d 100644
--- a/pclsync/psuggest.c
+++ b/pclsync/psuggest.c
@@ -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) {
@@ -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..95ca6f4 100644
--- a/pclsync/psynclib.c
+++ b/pclsync/psynclib.c
@@ -199,8 +199,6 @@ void *psync_realloc(void *ptr, size_t size) {
     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) {
@@ -384,9 +382,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 +399,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 +439,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 +499,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 +567,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 +577,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 +615,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 +775,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 +1026,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;
@@ -1096,13 +1094,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 +1159,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 +1208,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 +1240,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 +1258,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 +1274,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 +1697,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 +1729,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 +1749,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 +1767,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 +1779,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;
   }
@@ -1870,7 +1868,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 +1885,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 +1898,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;
 }
 
@@ -2063,7 +2061,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 +2108,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 +2137,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 +2384,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 +2399,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 +2409,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 +2524,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 +2878,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;
     }
 
@@ -2948,7 +2946,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..9e6123d 100644
--- a/pclsync/psynclib.h
+++ b/pclsync/psynclib.h
@@ -516,7 +516,6 @@ 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
@@ -668,7 +667,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/ptask.c b/pclsync/ptask.c
index d842969..7e577e5 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;
@@ -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..4a8887d 100644
--- a/pclsync/ptools.c
+++ b/pclsync/ptools.c
@@ -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..d696c88 100644
--- a/pclsync/publiclinks.c
+++ b/pclsync/publiclinks.c
@@ -103,8 +103,8 @@ 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,
@@ -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;
 }
 
@@ -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;
 }
 
@@ -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;
 }
@@ -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;
 }
@@ -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;
 }
 
@@ -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;
 }
@@ -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..77bb8c4 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;
 }
 
@@ -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:
@@ -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,
@@ -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..4bd7478 100644
--- a/pclsync_lib.cpp
+++ b/pclsync_lib.cpp
@@ -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);