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

psync_free removed

This commit is contained in:
Levi Neely 2025-03-11 21:55:21 +01:00
parent 3fd249f3f8
commit 58771bb524
50 changed files with 852 additions and 881 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

26
pclsync/papi.c
View File

@ -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 {

48
pclsync/pbusinessaccount.c
View File

@ -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))

12
pclsync/pcache.c
View File

@ -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)]);

8
pclsync/pcontacts.c
View File

@ -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);
}

6
pclsync/pcrypto.c
View File

@ -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++;

182
pclsync/pcryptofolder.c
View File

@ -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;
}

10
pclsync/pdeflate.c
View File

@ -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;

2
pclsync/pdevice.c
View File

@ -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)) {

118
pclsync/pdiff.c
View File

@ -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);

68
pclsync/pdownload.c
View File

@ -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;
}

4
pclsync/pfile.c
View File

@ -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);
}
}

30
pclsync/pfolder.c
View File

@ -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;
}

140
pclsync/pfs.c
View File

@ -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);

32
pclsync/pfscrypto.c
View File

@ -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);
}
}

20
pclsync/pfsfolder.c
View File

@ -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;

72
pclsync/pfstasks.c
View File

@ -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;

84
pclsync/pfsupload.c
View File

@ -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() {

12
pclsync/pfsxattr.c
View File

@ -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;
}

9
pclsync/pintervaltree.c
View File

@ -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;

41
pclsync/plibs.c
View File

@ -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) {

12
pclsync/plocalnotify.c
View File

@ -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;

40
pclsync/plocalscan.c
View File

@ -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);
}

6
pclsync/pmemlock.c
View File

@ -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);
}
}

104
pclsync/pnetlibs.c
View File

@ -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)

28
pclsync/pnotify.c
View File

@ -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)

48
pclsync/pp2p.c
View File

@ -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;
}

94
pclsync/ppagecache.c
View File

@ -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;
}

4
pclsync/ppassword.c
View File

@ -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;
}

18
pclsync/ppath.c
View File

@ -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;
}

24
pclsync/ppathstatus.c
View File

@ -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,

8
pclsync/pqevent.c
View File

@ -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);
}

2
pclsync/prand.c
View File

@ -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");

4
pclsync/prpc.c
View File

@ -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;

2
pclsync/prun.c
View File

@ -24,7 +24,7 @@ static void *thread_entry(void *data) {
((thread0_run)td->run)();
}
psync_free(data);
free(data);
return NULL;
}

2
pclsync/prunthrottled.c
View File

@ -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);
}
}

18
pclsync/psettings.c
View File

@ -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);

8
pclsync/psock.c
View File

@ -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) {

32
pclsync/pssl.c
View File

@ -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

2
pclsync/pstatus.c
View File

@ -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;

7
pclsync/psuggest.c
View File

@ -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;
}

25
pclsync/psyncer.c
View File

@ -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);

90
pclsync/psynclib.c
View File

@ -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;
}

3
pclsync/psynclib.h
View File

@ -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
*

18
pclsync/ptask.c
View File

@ -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);
}

2
pclsync/ptevent.c
View File

@ -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) {

5
pclsync/ptimer.c
View File

@ -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;

4
pclsync/ptools.c
View File

@ -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) {

86
pclsync/publiclinks.c
View File

@ -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;
}

102
pclsync/pupload.c
View File

@ -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;
}

11
pclsync_lib.cpp
View File

@ -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);