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

131 remove custom memory management wrappers (#137) 

* psync_free removed

* psync_malloc removed

* psync_realloc removed

* remove dead code

* remove pmemlock

* remove dead code
This commit is contained in:
Levi Neely 2025-03-11 22:27:30 +01:00 committed by GitHub
parent 3fd249f3f8
commit 9da561c767
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
53 changed files with 1053 additions and 1634 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

42
pclsync/papi.c
View File

@ -308,11 +308,11 @@ static binresult *do_parse_result(unsigned char **restrict indata,
arr = NULL;
cnt = 0;
alloc = 128;
arr = (binresult **)psync_malloc(sizeof(binresult *) * alloc);
arr = (binresult **)malloc(sizeof(binresult *) * alloc);
while (**indata != RPARAM_END) {
if (cnt == alloc) {
alloc *= 2;
arr = (binresult **)psync_realloc(arr, sizeof(binresult *) * alloc);
arr = (binresult **)realloc(arr, sizeof(binresult *) * alloc);
}
arr[cnt++] = do_parse_result(indata, odata, strings, nextstrid);
}
@ -321,7 +321,7 @@ static binresult *do_parse_result(unsigned char **restrict indata,
ret->array = (struct _binresult **)*odata;
*odata += sizeof(struct _binresult *) * cnt;
memcpy(ret->array, arr, sizeof(struct _binresult *) * cnt);
psync_free(arr);
free(arr);
return ret;
} else if (type == RPARAM_HASH) {
struct _hashpair *arr;
@ -333,11 +333,11 @@ static binresult *do_parse_result(unsigned char **restrict indata,
arr = NULL;
cnt = 0;
alloc = 32;
arr = (struct _hashpair *)psync_malloc(sizeof(struct _hashpair) * alloc);
arr = (struct _hashpair *)malloc(sizeof(struct _hashpair) * alloc);
while (**indata != RPARAM_END) {
if (cnt == alloc) {
alloc *= 2;
arr = (struct _hashpair *)psync_realloc(arr, sizeof(struct _hashpair) *
arr = (struct _hashpair *)realloc(arr, sizeof(struct _hashpair) *
alloc);
}
key = do_parse_result(indata, odata, strings, nextstrid);
@ -352,7 +352,7 @@ static binresult *do_parse_result(unsigned char **restrict indata,
ret->hash = (struct _hashpair *)*odata;
*odata += sizeof(struct _hashpair) * cnt;
memcpy(ret->hash, arr, sizeof(struct _hashpair) * cnt);
psync_free(arr);
free(arr);
return ret;
} else if (type == RPARAM_DATA) {
ret = (binresult *)(*odata);
@ -381,7 +381,7 @@ static binresult *parse_result(unsigned char *data, size_t datalen) {
strings = psync_new_cnt(binresult *, strcnt);
strcnt = 0;
res = do_parse_result(&data, &datac, strings, &strcnt);
psync_free(strings);
free(strings);
return res;
}
@ -395,15 +395,15 @@ binresult *papi_result(psock_t *sock) {
return NULL;
}
data = (unsigned char *)psync_malloc(ressize);
data = (unsigned char *)malloc(ressize);
if (unlikely_log(psock_readall(sock, data, ressize) != ressize)) {
psync_free(data);
free(data);
return NULL;
}
res = parse_result(data, ressize);
psync_free(data);
free(data);
return res;
}
@ -415,14 +415,14 @@ binresult *papi_result_thread(psock_t *sock) {
if (unlikely_log(psock_readall_thread(
sock, &ressize, sizeof(uint32_t)) != sizeof(uint32_t)))
return NULL;
data = (unsigned char *)psync_malloc(ressize);
data = (unsigned char *)malloc(ressize);
if (unlikely_log(psock_readall_thread(sock, data, ressize) !=
ressize)) {
psync_free(data);
free(data);
return NULL;
}
res = parse_result(data, ressize);
psync_free(data);
free(data);
return res;
}
@ -435,7 +435,7 @@ void papi_rdr_alloc(async_result_reader *reader) {
void papi_rdr_free(async_result_reader *reader) {
if (reader->state == 1)
psync_free(reader->data);
free(reader->data);
}
int papi_result_async(psock_t *sock, async_result_reader *reader) {
@ -447,7 +447,7 @@ again:
return ASYNC_RES_NEEDMORE;
else if (rd == PSYNC_SOCKET_ERROR || rd == 0) {
if (reader->state == 1)
psync_free(reader->data);
free(reader->data);
papi_rdr_alloc(reader);
reader->result = NULL;
return ASYNC_RES_READY;
@ -458,12 +458,12 @@ again:
reader->state = 1;
reader->bytesread = 0;
reader->bytestoread = reader->respsize;
reader->data = (unsigned char *)psync_malloc(reader->respsize);
reader->data = (unsigned char *)malloc(reader->respsize);
goto again;
} else {
assert(reader->state == 1);
reader->result = parse_result(reader->data, reader->respsize);
psync_free(reader->data);
free(reader->data);
papi_rdr_alloc(reader);
return ASYNC_RES_READY;
}
@ -496,7 +496,7 @@ unsigned char *papi_prepare(const char *command, size_t cmdlen,
}
if (unlikely_log(plen > 0xffff))
return NULL;
sdata = data = (unsigned char *)psync_malloc(plen + 2 + additionalalloc);
sdata = data = (unsigned char *)malloc(plen + 2 + additionalalloc);
memcpy(data, &plen, 2);
data += 2;
if (datalen != -1) {
@ -543,16 +543,16 @@ binresult *papi_send(psock_t *sock, const char *command,
if (readres & 2) {
if (unlikely_log(psock_writeall_thread(sock, sdata, plen) != plen)) {
psync_free(sdata);
free(sdata);
return NULL;
}
} else {
if (unlikely_log(psock_writeall(sock, sdata, plen) != plen)) {
psync_free(sdata);
free(sdata);
return NULL;
}
}
psync_free(sdata);
free(sdata);
if (readres & 1) {
return papi_result(sock);
} else {

70
pclsync/pbusinessaccount.c
View File

@ -102,12 +102,12 @@ int do_psync_account_stopshare(psync_shareid_t usershareids[], int nusershareid,
if (unlikely(numparam == 1))
return -3;
t = (binparam *)psync_malloc(numparam * sizeof(binparam));
t = (binparam *)malloc(numparam * sizeof(binparam));
init_param_str(t, "auth", psync_my_auth);
if (nusershareid) {
ids1 = (char *)psync_malloc(nusershareid * FOLDERID_ENTRY_SIZE);
ids1 = (char *)malloc(nusershareid * FOLDERID_ENTRY_SIZE);
idsp = ids1;
for (i = 0; i < nusershareid; ++i) {
k = sprintf(idsp, "%lld", (long long)usershareids[i]);
@ -123,7 +123,7 @@ int do_psync_account_stopshare(psync_shareid_t usershareids[], int nusershareid,
}
if (nteamshareid) {
ids2 = (char *)psync_malloc(nteamshareid * FOLDERID_ENTRY_SIZE);
ids2 = (char *)malloc(nteamshareid * FOLDERID_ENTRY_SIZE);
idsp = ids2;
for (i = 0; i < nteamshareid; ++i) {
k = sprintf(idsp, "%lld", (long long)teamshareids[i]);
@ -177,12 +177,12 @@ int do_psync_account_stopshare(psync_shareid_t usershareids[], int nusershareid,
}
if (ids1)
psync_free(ids1);
free(ids1);
if (ids2)
psync_free(ids2);
free(ids2);
psync_free(bres);
psync_free(t);
free(bres);
free(t);
return result;
}
@ -208,14 +208,14 @@ int do_psync_account_modifyshare(psync_shareid_t usrshrids[], uint32_t uperms[],
if (unlikely(numparam == 1))
return -3;
t = (binparam *)psync_malloc(numparam * sizeof(binparam));
t = (binparam *)malloc(numparam * sizeof(binparam));
init_param_str(t, "auth", psync_my_auth);
if (nushid) {
ids1 = (char *)psync_malloc(nushid * FOLDERID_ENTRY_SIZE);
ids1 = (char *)malloc(nushid * FOLDERID_ENTRY_SIZE);
idsp = ids1;
perms1 = (char *)psync_malloc(nushid * FOLDERID_ENTRY_SIZE);
perms1 = (char *)malloc(nushid * FOLDERID_ENTRY_SIZE);
permsp = perms1;
for (i = 0; i < nushid; ++i) {
k = sprintf(idsp, "%lld", (long long)usrshrids[i]);
@ -240,9 +240,9 @@ int do_psync_account_modifyshare(psync_shareid_t usrshrids[], uint32_t uperms[],
}
if (ntmshid) {
ids2 = (char *)psync_malloc(ntmshid * FOLDERID_ENTRY_SIZE);
ids2 = (char *)malloc(ntmshid * FOLDERID_ENTRY_SIZE);
idsp = ids2;
perms2 = (char *)psync_malloc(ntmshid * FOLDERID_ENTRY_SIZE);
perms2 = (char *)malloc(ntmshid * FOLDERID_ENTRY_SIZE);
permsp = perms2;
for (i = 0; i < ntmshid; ++i) {
@ -306,16 +306,16 @@ int do_psync_account_modifyshare(psync_shareid_t usrshrids[], uint32_t uperms[],
}
if (ids1)
psync_free(ids1);
free(ids1);
if (ids2)
psync_free(ids2);
free(ids2);
if (perms1)
psync_free(perms1);
free(perms1);
if (perms2)
psync_free(perms2);
free(perms2);
psync_free(bres);
psync_free(t);
free(bres);
free(t);
return result;
}
@ -330,7 +330,7 @@ void get_ba_member_email(uint64_t userid, char **email /*OUT*/,
psync_sql_bind_uint(res, 1, userid);
if ((row = psync_sql_fetch_row(res))) {
cstr = psync_get_lstring(row[0], length);
*email = (char *)psync_malloc(*length);
*email = (char *)malloc(*length);
memcpy(*email, cstr, *length);
psync_sql_free_result(res);
return;
@ -357,7 +357,7 @@ void get_ba_member_email(uint64_t userid, char **email /*OUT*/,
users = papi_find_result2(bres, "users", PARAM_ARRAY);
if (!users->length) {
psync_free(bres);
free(bres);
debug(D_WARNING, "Account_users returned empty result!\n");
return;
} else {
@ -368,7 +368,7 @@ void get_ba_member_email(uint64_t userid, char **email /*OUT*/,
fname = papi_find_result2(users->array[0], "firstname", PARAM_STR)->str;
lname = papi_find_result2(users->array[0], "lastname", PARAM_STR)->str;
}
psync_free(bres);
free(bres);
if (*length) {
psync_sql_res *q;
@ -396,7 +396,7 @@ void get_ba_team_name(uint64_t teamid, char **name /*OUT*/,
psync_sql_bind_uint(res, 1, teamid);
if ((row = psync_sql_fetch_row(res))) {
cstr = psync_get_lstring(row[0], length);
*name = (char *)psync_malloc(*length);
*name = (char *)malloc(*length);
memcpy(*name, cstr, *length);
psync_sql_free_result(res);
return;
@ -422,7 +422,7 @@ void get_ba_team_name(uint64_t teamid, char **name /*OUT*/,
// debug(D_NOTICE, "Result contains %d teams\n", users->length);
if (!teams->length) {
psync_free(bres);
free(bres);
debug(D_WARNING, "Account_teams returned empty result!\n");
return;
} else {
@ -431,7 +431,7 @@ void get_ba_team_name(uint64_t teamid, char **name /*OUT*/,
*length = strlen(teamret);
*name = psync_strndup(teamret, *length);
}
psync_free(bres);
free(bres);
psync_sql_res *q;
q = psync_sql_prep_statement(
@ -515,7 +515,7 @@ void cache_account_emails() {
psync_sql_commit_transaction();
}
end_close:
psync_free(bres);
free(bres);
}
void cache_account_teams() {
@ -549,7 +549,7 @@ void cache_account_teams() {
// debug(D_NOTICE, "Result contains %d teams\n", users->length);
if (!users->length) {
psync_free(bres);
free(bres);
debug(D_WARNING, "Account_teams returned empty result!\n");
return;
} else {
@ -577,7 +577,7 @@ void cache_account_teams() {
}
psync_sql_commit_transaction();
}
psync_free(bres);
free(bres);
return;
}
@ -622,7 +622,7 @@ void cache_ba_my_teams() {
users = papi_find_result2(bres, "users", PARAM_ARRAY);
if (!users->length) {
psync_free(bres);
free(bres);
debug(D_WARNING, "Account_users returned empty result!\n");
return;
}
@ -634,7 +634,7 @@ void cache_ba_my_teams() {
teams = papi_find_result2(user, "teams", PARAM_ARRAY);
for (i = 0; i < teams->length; i++)
cache_my_team(teams->array[i]);
psync_free(bres);
free(bres);
psync_sql_unlock();
}
@ -642,7 +642,7 @@ int api_error_result(binresult *res) {
uint64_t result;
result = papi_find_result2(res, "result", PARAM_NUM)->num;
if (result) {
psync_free(res);
free(res);
psync_process_api_error(result);
return 1;
}
@ -741,20 +741,20 @@ static psync_folderid_t create_index_folder(const char *path) {
while (ind < 100) {
bufflen = strlen(path) + 1 /*zero char*/ + 3 /*parenthesis*/ +
3 /*up to 3 digit index*/;
buff = (char *)psync_malloc(bufflen);
buff = (char *)malloc(bufflen);
snprintf(buff, bufflen - 1, "%s (%d)", path, ind);
if (psync_create_remote_folder_by_path(buff, &err) != 0)
debug(D_NOTICE, "Unable to create folder %s error is %s.", buff, err);
folderid = pfolder_id(buff);
if ((folderid != PSYNC_INVALID_FOLDERID) &&
check_write_permissions(folderid)) {
psync_free(buff);
free(buff);
break;
}
++ind;
if (err)
psync_free(err);
psync_free(buff);
free(err);
free(buff);
}
return folderid;
}
@ -765,7 +765,7 @@ psync_folderid_t psync_check_and_create_folder(const char *path) {
if (folderid == PSYNC_INVALID_FOLDERID) {
if (psync_create_remote_folder_by_path(path, &err) != 0) {
debug(D_NOTICE, "Unable to create folder %s error is %s.", path, err);
psync_free(err);
free(err);
folderid = create_index_folder(path);
}
} else if (!check_write_permissions(folderid))

14
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)]);
@ -164,7 +164,7 @@ void pcache_add(const char *key, void *ptr, time_t freeafter,
uint32_t h;
h = compute_hash(key, &l);
l++;
he = (cache_entry_t *)psync_malloc(offsetof(cache_entry_t, key) + l);
he = (cache_entry_t *)malloc(offsetof(cache_entry_t, key) + l);
he->value = ptr;
he->free = freefunc;
he->hash = h;
@ -178,7 +178,7 @@ void pcache_add(const char *key, void *ptr, time_t freeafter,
!strcmp(key, he2->key) &&
++l == maxkeys)) {
pthread_mutex_unlock(&cachelocks[hash_to_lock(h)]);
psync_free(he);
free(he);
freefunc(ptr);
// debug(D_NOTICE, "not adding key %s to cache as there already %u
// elements present", key, (unsigned int)maxkeys);
@ -218,7 +218,7 @@ restart:
psync_list_del(&he->list);
pthread_mutex_unlock(&cachelocks[hash_to_lock(h)]);
he->free(he->value);
psync_free(he);
free(he);
goto restart;
}
pthread_mutex_unlock(&cachelocks[hash_to_lock(h)]);
@ -235,7 +235,7 @@ void pcache_clean() {
if (!ptimer_stop(he->timer)) {
psync_list_del(l1);
he->free(he->value);
psync_free(he);
free(he);
}
}
pthread_mutex_unlock(&cachelocks[hash_to_lock(h)]);
@ -262,7 +262,7 @@ void pcache_clean_oneof(const char **prefixes, size_t cnt) {
if (!ptimer_stop(he->timer)) {
psync_list_del(l1);
he->free(he->value);
psync_free(he);
free(he);
}
}
pthread_mutex_unlock(&cachelocks[hash_to_lock(h)]);

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

21
pclsync/pcrypto.c
View File

@ -42,7 +42,6 @@
#include "pcrypto.h"
#include "plibs.h"
#include "pmemlock.h"
#include <stddef.h>
#include <string.h>
@ -161,7 +160,7 @@ static void copy_iv_and_xor_with_counter(unsigned char *dest,
psync_symmetric_key_t pcrypto_key_len(size_t len) {
psync_symmetric_key_t key;
key = (psync_symmetric_key_t)pmemlock_malloc(
key = (psync_symmetric_key_t)malloc(
offsetof(psync_symmetric_key_struct_t, key) + len);
key->keylen = len;
pssl_rand_strong(key->key, len);
@ -193,7 +192,7 @@ void pcrypto_ctr_encdec_free(
pcrypto_ctr_encdec_t enc) {
paes_free_encoder(enc->encoder);
putil_wipe(enc->iv, PSYNC_AES256_BLOCK_SIZE);
psync_free(enc);
free(enc);
}
void pcrypto_ctr_encdec_decode(
@ -343,7 +342,7 @@ pcrypto_decode_text(pcrypto_textdec_t enc,
while (ret + len < outptr) {
if (unlikely(ret[len] != 0)) {
debug(D_WARNING, "non-zero in the padding found");
psync_free(ret);
free(ret);
return NULL;
}
len++;
@ -388,7 +387,7 @@ pcrypto_decode_text(pcrypto_textdec_t enc,
while (ret + len < outptr) {
if (unlikely(ret[len] != 0)) {
debug(D_WARNING, "non-zero in the padding found");
psync_free(ret);
free(ret);
return NULL;
}
len++;
@ -406,7 +405,7 @@ pcrypto_textenc_create(psync_symmetric_key_t key) {
enc = paes_create_encoder(key);
if (unlikely_log(enc == PSYNC_INVALID_ENCODER))
return PSYNC_CRYPTO_INVALID_ENCODER;
ret = (pcrypto_textenc_t)pmemlock_malloc(
ret = (pcrypto_textenc_t)malloc(
offsetof(pcrypto_key_iv_t, iv) + key->keylen -
PSYNC_AES256_KEY_SIZE);
ret->encoder = enc;
@ -419,7 +418,7 @@ void pcrypto_textenc_free(
pcrypto_textenc_t enc) {
paes_free_encoder(enc->encoder);
putil_wipe(enc->iv, enc->ivlen);
pmemlock_free(enc);
free(enc);
}
pcrypto_textdec_t
@ -432,7 +431,7 @@ pcrypto_textdec_create(psync_symmetric_key_t key) {
enc = paes_create_decoder(key);
if (unlikely_log(enc == PSYNC_INVALID_ENCODER))
return PSYNC_CRYPTO_INVALID_ENCODER;
ret = (pcrypto_textenc_t)pmemlock_malloc(
ret = (pcrypto_textenc_t)malloc(
offsetof(pcrypto_key_iv_t, iv) + key->keylen -
PSYNC_AES256_KEY_SIZE);
ret->encoder = enc;
@ -445,7 +444,7 @@ void pcrypto_textdec_free(
pcrypto_textdec_t enc) {
paes_free_encoder(enc->encoder);
putil_wipe(enc->iv, enc->ivlen);
pmemlock_free(enc);
free(enc);
}
pcrypto_sector_encdec_t
@ -463,7 +462,7 @@ pcrypto_sec_encdec_create(psync_symmetric_key_t key) {
paes_free_encoder(enc);
return PSYNC_CRYPTO_INVALID_ENCODER;
}
ret = (pcrypto_sector_encdec_t)pmemlock_malloc(
ret = (pcrypto_sector_encdec_t)malloc(
offsetof(pcrypto_encdec_iv_t, iv) + key->keylen -
PSYNC_AES256_KEY_SIZE);
ret->encoder = enc;
@ -478,7 +477,7 @@ void pcrypto_sec_encdec_free(
paes_free_encoder(enc->encoder);
paes_free_decoder(enc->decoder);
putil_wipe(enc->iv, enc->ivlen);
pmemlock_free(enc);
free(enc);
}
static int memcmp_const(const unsigned char *s1, const unsigned char *s2,

213
pclsync/pcryptofolder.c
View File

@ -47,7 +47,6 @@
#include "pfoldersync.h"
#include "pfs.h"
#include "plibs.h"
#include "pmemlock.h"
#include "pnetlibs.h"
#include "psettings.h"
#include "pssl.h"
@ -185,7 +184,7 @@ static int setup_do_upload(const unsigned char *rsapriv,
result = papi_find_result2(res, "result", PARAM_NUM)->num;
if (!result)
*cryptoexpires = papi_find_result2(res, "cryptoexpires", PARAM_NUM)->num;
psync_free(res);
free(res);
if (result != 0)
debug(D_WARNING, "crypto_setuserkeys returned %u", (unsigned)result);
if (result == 0)
@ -207,7 +206,7 @@ static void load_str_to(const psync_variant *v, unsigned char **ptr,
const char *str;
size_t l;
str = psync_get_lstring(*v, &l);
*ptr = (unsigned char *)psync_malloc(l);
*ptr = (unsigned char *)malloc(l);
memcpy(*ptr, str, l);
*len = l;
}
@ -239,7 +238,7 @@ static int download_keys(unsigned char **rsapriv, size_t *rsaprivlen, unsigned c
}
result = papi_find_result2(res, "result", PARAM_NUM)->num;
if (result) {
psync_free(res);
free(res);
psync_process_api_error(result);
switch (result) {
case 2111:
@ -257,7 +256,7 @@ static int download_keys(unsigned char **rsapriv, size_t *rsaprivlen, unsigned c
data = papi_find_result2(res, "publickey", PARAM_STR);
rsapubstruct = psync_base64_decode((const unsigned char *)data->str,
data->length, &rsapubstructlen);
psync_free(res);
free(res);
sha1hex(rsaprivstruct, rsaprivstructlen, privatesha1);
sha1hex(rsapubstruct, rsapubstructlen, publicsha1);
debug(D_NOTICE, "rsapubstruct=%s", rsapubstruct);
@ -266,14 +265,14 @@ static int download_keys(unsigned char **rsapriv, size_t *rsaprivlen, unsigned c
if (offsetof(pub_key_ver1, key) >= rsapubstructlen)
goto def1;
*rsapublen = rsapubstructlen - offsetof(pub_key_ver1, key);
*rsapub = (unsigned char *)psync_malloc(*rsapublen);
*rsapub = (unsigned char *)malloc(*rsapublen);
memcpy(*rsapub, rsapubstruct + offsetof(pub_key_ver1, key), *rsapublen);
break;
default:
def1:
putil_wipe(rsaprivstruct, rsaprivstructlen);
psync_free(rsaprivstruct);
psync_free(rsapubstruct);
free(rsaprivstruct);
free(rsapubstruct);
return PRINT_RETURN_CONST(PSYNC_CRYPTO_START_UNKNOWN_KEY_FORMAT);
}
switch (*((uint32_t *)rsaprivstruct)) {
@ -281,10 +280,10 @@ static int download_keys(unsigned char **rsapriv, size_t *rsaprivlen, unsigned c
if (offsetof(priv_key_ver1, key) >= rsaprivstructlen)
goto def2;
*rsaprivlen = rsaprivstructlen - offsetof(priv_key_ver1, key);
*rsapriv = (unsigned char *)psync_malloc(*rsaprivlen);
*rsapriv = (unsigned char *)malloc(*rsaprivlen);
memcpy(*rsapriv, rsaprivstruct + offsetof(priv_key_ver1, key), *rsaprivlen);
*saltlen = PSYNC_CRYPTO_PBKDF2_SALT_LEN;
*salt = (unsigned char *)psync_malloc(PSYNC_CRYPTO_PBKDF2_SALT_LEN);
*salt = (unsigned char *)malloc(PSYNC_CRYPTO_PBKDF2_SALT_LEN);
memcpy(*salt, rsaprivstruct + offsetof(priv_key_ver1, salt),
PSYNC_CRYPTO_PBKDF2_SALT_LEN);
*iterations = PSYNC_CRYPTO_PASS_TO_KEY_ITERATIONS;
@ -292,15 +291,15 @@ static int download_keys(unsigned char **rsapriv, size_t *rsaprivlen, unsigned c
break;
default:
def2:
psync_free(*rsapub);
free(*rsapub);
putil_wipe(rsaprivstruct, rsaprivstructlen);
psync_free(rsaprivstruct);
psync_free(rsapubstruct);
free(rsaprivstruct);
free(rsapubstruct);
return PRINT_RETURN_CONST(PSYNC_CRYPTO_START_UNKNOWN_KEY_FORMAT);
}
putil_wipe(rsaprivstruct, rsaprivstructlen);
psync_free(rsaprivstruct);
psync_free(rsapubstruct);
free(rsaprivstruct);
free(rsapubstruct);
return PSYNC_CRYPTO_START_SUCCESS;
}
@ -333,12 +332,12 @@ setup_upload(const unsigned char *rsapriv, size_t rsaprivlen,
int ret;
*cryptoexpires = 0;
priv =
(priv_key_ver1 *)psync_malloc(offsetof(priv_key_ver1, key) + rsaprivlen);
(priv_key_ver1 *)malloc(offsetof(priv_key_ver1, key) + rsaprivlen);
priv->type = PSYNC_CRYPTO_TYPE_RSA4096_64BYTESALT_20000IT;
priv->flags = 0;
memcpy(priv->salt, salt, PSYNC_CRYPTO_PBKDF2_SALT_LEN);
memcpy(priv->key, rsapriv, rsaprivlen);
pub = (pub_key_ver1 *)psync_malloc(offsetof(pub_key_ver1, key) + rsapublen);
pub = (pub_key_ver1 *)malloc(offsetof(pub_key_ver1, key) + rsapublen);
pub->type = PSYNC_CRYPTO_PUB_TYPE_RSA4096;
pub->flags = 0;
memcpy(pub->key, rsapub, rsapublen);
@ -351,12 +350,12 @@ setup_upload(const unsigned char *rsapriv, size_t rsaprivlen,
b64pub =
psync_base64_encode((unsigned char *)pub,
offsetof(pub_key_ver1, key) + rsapublen, &b64publen);
psync_free(priv);
psync_free(pub);
free(priv);
free(pub);
ret = setup_do_upload(b64priv, b64privlen, b64pub,
b64publen, hint, cryptoexpires);
psync_free(b64priv);
psync_free(b64pub);
free(b64priv);
free(b64pub);
return ret;
}
@ -483,7 +482,7 @@ int pcryptofolder_get_hint(char **hint) {
}
result = papi_find_result2(res, "result", PARAM_NUM)->num;
if (result) {
psync_free(res);
free(res);
psync_process_api_error(result);
switch (result) {
case 2122:
@ -496,7 +495,7 @@ int pcryptofolder_get_hint(char **hint) {
return PRINT_RETURN_CONST(PSYNC_CRYPTO_HINT_UNKNOWN_ERROR);
}
*hint = psync_strdup(papi_find_result2(res, "hint", PARAM_STR)->str);
psync_free(res);
free(res);
return PSYNC_CRYPTO_HINT_SUCCESS;
}
@ -505,27 +504,27 @@ static int crypto_keys_match() {
psync_encrypted_symmetric_key_t enckey;
int res;
debug(D_NOTICE, "trying encrypt/decrypt operation with loaded keys");
key = (psync_symmetric_key_t)psync_malloc(
key = (psync_symmetric_key_t)malloc(
offsetof(psync_symmetric_key_struct_t, key) + 64);
key->keylen = 64;
pssl_rand_strong(key->key, key->keylen);
enckey = psymkey_encrypt(crypto_pubkey, key);
if (enckey == PSYNC_INVALID_ENC_SYM_KEY) {
psync_free(key);
free(key);
return 0;
}
deckey = prsa_decrypt_symm_key_lock(&crypto_privkey, &enckey);
psync_free(enckey);
free(enckey);
if (deckey == PSYNC_INVALID_SYM_KEY) {
psync_free(key);
free(key);
return 0;
}
res = key->keylen == deckey->keylen &&
!memcmp(key->key, deckey->key, key->keylen);
psymkey_free(deckey);
psync_free(key);
free(key);
if (res)
debug(D_NOTICE, "encrypt/decrypt operation succeeded");
return res;
@ -595,9 +594,9 @@ int pcryptofolder_unlock(const char *password) {
debug(D_BUG,
"only some of records found in the database, should not happen");
putil_wipe(rsapriv, rsaprivlen);
psync_free(rsapriv);
psync_free(rsapub);
psync_free(salt);
free(rsapriv);
free(rsapub);
free(salt);
}
ret = download_keys(
&rsapriv, &rsaprivlen, &rsapub, &rsapublen, &salt, &saltlen,
@ -619,10 +618,10 @@ int pcryptofolder_unlock(const char *password) {
pthread_rwlock_unlock(&crypto_lock);
debug(D_WARNING, "could not load public key");
putil_wipe(rsapriv, rsaprivlen);
psync_free(rsapriv);
psync_free(rsapub);
free(rsapriv);
free(rsapub);
putil_wipe(salt, saltlen);
psync_free(salt);
free(salt);
return PRINT_RETURN_CONST(PSYNC_CRYPTO_START_UNKNOWN_KEY_FORMAT);
}
debug(D_NOTICE, "successfully loaded public key");
@ -631,7 +630,7 @@ int pcryptofolder_unlock(const char *password) {
aeskey = psymkey_generate(password, PSYNC_AES256_KEY_SIZE + PSYNC_AES256_BLOCK_SIZE, salt, saltlen, iterations);
enc = pcrypto_ctr_encdec_create(aeskey);
psymkey_free(aeskey);
rsaprivdec = (unsigned char *)pmemlock_malloc(rsaprivlen);
rsaprivdec = (unsigned char *)malloc(rsaprivlen);
memcpy(rsaprivdec, rsapriv, rsaprivlen);
pcrypto_ctr_encdec_decode(enc, rsaprivdec, rsaprivlen, 0);
pcrypto_ctr_encdec_free(enc);
@ -641,17 +640,17 @@ int pcryptofolder_unlock(const char *password) {
debug(D_NOTICE, "trying to load private key");
crypto_privkey = prsa_load_private(rsaprivdec, rsaprivlen);
putil_wipe(rsaprivdec, rsaprivlen);
pmemlock_free(rsaprivdec);
free(rsaprivdec);
if (crypto_privkey == PSYNC_INVALID_RSA) {
debug(D_NOTICE, "failed to load private key");
prsa_free_public(crypto_pubkey);
crypto_pubkey = PSYNC_INVALID_RSA;
pthread_rwlock_unlock(&crypto_lock);
putil_wipe(rsapriv, rsaprivlen);
psync_free(rsapriv);
psync_free(rsapub);
free(rsapriv);
free(rsapub);
putil_wipe(salt, saltlen);
psync_free(salt);
free(salt);
return PRINT_RETURN_CONST(PSYNC_CRYPTO_START_BAD_PASSWORD);
}
debug(D_NOTICE, "successfully loaded private key");
@ -665,10 +664,10 @@ int pcryptofolder_unlock(const char *password) {
pthread_rwlock_unlock(&crypto_lock);
debug(D_ERROR, "keys don't match");
putil_wipe(rsapriv, rsaprivlen);
psync_free(rsapriv);
psync_free(rsapub);
free(rsapriv);
free(rsapub);
putil_wipe(salt, saltlen);
psync_free(salt);
free(salt);
return PRINT_RETURN_CONST(PSYNC_CRYPTO_START_KEYS_DONT_MATCH);
}
debug(D_NOTICE, "public and private keys match, setting crypto started");
@ -683,10 +682,10 @@ int pcryptofolder_unlock(const char *password) {
publicsha1, privatesha1, flags);
}
putil_wipe(rsapriv, rsaprivlen);
psync_free(rsapriv);
psync_free(rsapub);
free(rsapriv);
free(rsapub);
putil_wipe(salt, saltlen);
psync_free(salt);
free(salt);
debug(D_NOTICE, "crypto successfully started");
return PSYNC_CRYPTO_START_SUCCESS;
}
@ -699,7 +698,7 @@ static void psync_fs_refresh_crypto_folders() {
psync_fs_refresh_folder(*fid);
fid++;
}
psync_free(fids);
free(fids);
}
int pcryptofolder_lock() {
@ -754,7 +753,7 @@ int pcryptofolder_reset() {
}
}
result = papi_find_result2(res, "result", PARAM_NUM)->num;
psync_free(res);
free(res);
if (result)
debug(D_WARNING, "crypto_reset returned error %u", (unsigned)result);
if (result == 0)
@ -847,7 +846,7 @@ static psync_encrypted_symmetric_key_t download_fldr_enckey(psync_folderid_t fol
(unsigned long)result);
crypto_api_errno = result;
set_crypto_err_msg(res);
psync_free(res);
free(res);
psync_process_api_error(result);
return (psync_encrypted_symmetric_key_t)errptr(
PRINT_RETURN_CONST(PSYNC_CRYPTO_API_ERR_INTERNAL));
@ -855,13 +854,13 @@ static psync_encrypted_symmetric_key_t download_fldr_enckey(psync_folderid_t fol
b64key = papi_find_result2(res, "key", PARAM_STR);
key = psync_base64_decode((const unsigned char *)b64key->str, b64key->length,
&keylen);
psync_free(res);
free(res);
if (!key)
return (psync_encrypted_symmetric_key_t)errptr(
PRINT_RETURN_CONST(PSYNC_CRYPTO_INVALID_KEY));
ret = psymkey_alloc_encrypted(keylen);
memcpy(ret->data, key, keylen);
psync_free(key);
free(key);
save_folder_key(folderid, ret);
return ret;
}
@ -900,7 +899,7 @@ static psync_encrypted_symmetric_key_t download_file_enckey(psync_fileid_t filei
(unsigned long)result);
crypto_api_errno = result;
set_crypto_err_msg(res);
psync_free(res);
free(res);
return (psync_encrypted_symmetric_key_t)errptr(
PRINT_RETURN_CONST(PSYNC_CRYPTO_API_ERR_INTERNAL));
}
@ -908,13 +907,13 @@ static psync_encrypted_symmetric_key_t download_file_enckey(psync_fileid_t filei
b64key = papi_find_result2(res, "key", PARAM_STR);
key = psync_base64_decode((const unsigned char *)b64key->str, b64key->length,
&keylen);
psync_free(res);
free(res);
if (!key)
return (psync_encrypted_symmetric_key_t)errptr(
PRINT_RETURN_CONST(PSYNC_CRYPTO_INVALID_KEY));
ret = psymkey_alloc_encrypted(keylen);
memcpy(ret->data, key, keylen);
psync_free(key);
free(key);
save_file_key_to_db(fileid, result, ret);
return ret;
}
@ -981,7 +980,7 @@ static psync_symmetric_key_t get_fldr_symkey_safe(psync_folderid_t folderid) {
symkey = prsa_decrypt_symm_key_lock(&crypto_privkey, &enckey);
psync_free(enckey);
free(enckey);
if (symkey == PSYNC_INVALID_SYM_KEY)
return (psync_symmetric_key_t)errptr(
PRINT_RETURN_CONST(PSYNC_CRYPTO_INVALID_KEY));
@ -1009,7 +1008,7 @@ static psync_symmetric_key_t get_file_symkey_safe(psync_fileid_t fileid, uint64_
symkey = prsa_decrypt_symm_key_lock(&crypto_privkey, &enckey);
psync_free(enckey);
free(enckey);
if (unlikely_log(symkey == PSYNC_INVALID_SYM_KEY))
return (psync_symmetric_key_t)errptr(
PRINT_RETURN_CONST(PSYNC_CRYPTO_INVALID_KEY));
@ -1040,7 +1039,7 @@ static void psync_crypto_release_file_symkey_locked(psync_fileid_t fileid,
static psync_symmetric_key_t symkeyv1_to_symkey(sym_key_ver1 *v1) {
psync_symmetric_key_t key;
key = (psync_symmetric_key_t)pmemlock_malloc(
key = (psync_symmetric_key_t)malloc(
offsetof(psync_symmetric_key_struct_t, key) + PSYNC_AES256_KEY_SIZE +
PSYNC_CRYPTO_HMAC_SHA512_KEY_LEN);
key->keylen = PSYNC_AES256_KEY_SIZE + PSYNC_CRYPTO_HMAC_SHA512_KEY_LEN;
@ -1148,7 +1147,7 @@ static pcrypto_textenc_t get_tmp_fldrencoder_safe(psync_fsfolderid_t folderid) {
psync_sql_free_result(res);
if (enckey) {
symkey = prsa_decrypt_data(crypto_privkey, enckey, enckeylen);
psync_free(enckey);
free(enckey);
} else
symkey = PSYNC_INVALID_SYM_KEY;
} else {
@ -1205,7 +1204,7 @@ static pcrypto_textdec_t get_tmp_fldrdecoder_safe(psync_fsfolderid_t folderid) {
if (enckey) {
symkey = prsa_decrypt_data(crypto_privkey, enckey, enckeylen);
psync_free(enckey);
free(enckey);
if (symkey == PSYNC_INVALID_SYM_KEY)
debug(D_WARNING, "got key from database that fails rsa decrypt");
} else {
@ -1296,7 +1295,7 @@ char *pcryptofolder_flddecode_filename(pcrypto_textdec_t decoder,
return NULL;
filenamedec =
pcrypto_decode_text(decoder, filenameenc, filenameenclen);
psync_free(filenameenc);
free(filenameenc);
return (char *)filenamedec;
}
@ -1362,7 +1361,7 @@ char * pcryptofolder_fldencode_filename(pcrypto_textenc_t encoder,
strlen(name), &filenameenc, &filenameenclen);
filenameb32 =
psync_base32_encode(filenameenc, filenameenclen, &filenameenclen);
psync_free(filenameenc);
free(filenameenc);
return (char *)filenameb32;
}
@ -1434,7 +1433,7 @@ static pcrypto_sector_encdec_t get_fileencoder_tmp(psync_fsfileid_t fileid,
if (enckey) {
symkey = prsa_decrypt_data(crypto_privkey, enckey, enckeylen);
psync_free(enckey);
free(enckey);
} else
symkey = PSYNC_INVALID_SYM_KEY;
if (symkey == PSYNC_INVALID_SYM_KEY)
@ -1519,7 +1518,7 @@ pcrypto_sector_encdec_t pcryptofolder_filencoder_from_binresult(psync_fileid_t f
PRINT_RETURN_CONST(PSYNC_CRYPTO_INVALID_KEY));
esym = psymkey_alloc_encrypted(keylen);
memcpy(esym->data, key, keylen);
psync_free(key);
free(key);
hash = papi_find_result2(res, "hash", PARAM_NUM)->num;
save_file_key_to_db(fileid, hash, esym);
pthread_rwlock_rdlock(&crypto_lock);
@ -1536,7 +1535,7 @@ pcrypto_sector_encdec_t pcryptofolder_filencoder_from_binresult(psync_fileid_t f
enc = get_fileencoder(fileid, hash, 0);
}
pthread_rwlock_unlock(&crypto_lock);
psync_free(esym);
free(esym);
return enc;
}
@ -1570,7 +1569,7 @@ static char *get_name_encoded(psync_folderid_t folderid,
strlen(name), &nameenc, &nameenclen);
ret = (char *)psync_base32_encode(nameenc, nameenclen, &nameenclen);
free_direncoder(folderid, enc);
psync_free(nameenc);
free(nameenc);
return ret;
}
@ -1663,7 +1662,7 @@ int psync_cloud_crypto_send_mkdir(psync_folderid_t folderid, const char *name,
set_crypto_err_msg(res);
debug(D_NOTICE, "createfolder returned error %lu %s", (unsigned long)result,
crypto_api_err);
psync_free(res);
free(res);
*err = crypto_api_err;
psync_process_api_error(result);
return result;
@ -1676,7 +1675,7 @@ int psync_cloud_crypto_send_mkdir(psync_folderid_t folderid, const char *name,
save_folder_key(papi_find_result2(meta, "folderid", PARAM_NUM)->num,
encsym);
psync_sql_commit_transaction();
psync_free(res);
free(res);
return PSYNC_CRYPTO_SUCCESS;
}
@ -1690,7 +1689,7 @@ char *pcryptofolder_filencoder_key_get(psync_fsfileid_t fileid,
if (is_err(encsym))
return (char *)encsym;
ret = (char *)psync_base64_encode(encsym->data, encsym->datalen, keylen);
psync_free(encsym);
free(encsym);
return ret;
}
@ -1718,7 +1717,7 @@ char *pcryptofolder_filencoder_key_new(uint32_t flags, size_t *keylen) {
}
putil_wipe(&sym, sizeof(sym));
ret = (char *)psync_base64_encode(encsym->data, encsym->datalen, keylen);
psync_free(encsym);
free(encsym);
return ret;
}
@ -1748,7 +1747,7 @@ char *pcryptofolder_filencoder_key_newplain(
*deckey = symkeyv1_to_symkey(&sym);
putil_wipe(&sym, sizeof(sym));
ret = (char *)psync_base64_encode(encsym->data, encsym->datalen, keylen);
psync_free(encsym);
free(encsym);
return ret;
}
@ -1779,20 +1778,20 @@ int pcryptofolder_mkdir(psync_folderid_t folderid, const char *name,
pthread_rwlock_unlock(&crypto_lock);
if (ret) {
if (encsym != PSYNC_INVALID_ENC_SYM_KEY)
psync_free(encsym);
free(encsym);
return ret;
}
if (encsym == PSYNC_INVALID_ENC_SYM_KEY) {
psync_free(ename);
free(ename);
debug(D_ERROR, "RSA encryption failed");
return set_err(PRINT_RETURN_CONST(PSYNC_CRYPTO_RSA_ERROR), err);
}
b64encsym = psync_base64_encode(encsym->data, encsym->datalen, &b64encsymlen);
ret = psync_cloud_crypto_send_mkdir(folderid, ename, err, (char *)b64encsym,
b64encsymlen, encsym, newfolderid);
psync_free(encsym);
psync_free(ename);
psync_free(b64encsym);
free(encsym);
free(ename);
free(b64encsym);
return ret;
}
@ -1843,7 +1842,7 @@ int psync_pcloud_crypto_reencode_key(
psymkey_free(aeskey);
if (unlikely(enc == PSYNC_CRYPTO_INVALID_ENCODER))
goto err_nm_1;
rsaprivdec = (unsigned char *)psync_malloc(rsaprivlen);
rsaprivdec = (unsigned char *)malloc(rsaprivlen);
if (unlikely(!rsaprivdec)) {
pcrypto_ctr_encdec_free(enc);
goto err_nm_1;
@ -1852,7 +1851,7 @@ int psync_pcloud_crypto_reencode_key(
pcrypto_ctr_encdec_decode(enc, rsaprivdec, rsaprivlen,
0);
pcrypto_ctr_encdec_free(enc);
newpriv = (unsigned char *)psync_malloc(offsetof(priv_key_ver1, key) +
newpriv = (unsigned char *)malloc(offsetof(priv_key_ver1, key) +
rsaprivlen);
if (unlikely(!newpriv))
goto err_nm_1;
@ -1877,7 +1876,7 @@ int psync_pcloud_crypto_reencode_key(
newprivlen = offsetof(priv_key_ver1, key) + rsaprivlen;
priv = prsa_load_private(rsaprivdec, rsaprivlen);
putil_wipe(rsaprivdec, rsaprivlen);
psync_free(rsaprivdec);
free(rsaprivdec);
if (unlikely(priv == PSYNC_INVALID_RSA))
goto err_ph_1;
break;
@ -1891,21 +1890,21 @@ int psync_pcloud_crypto_reencode_key(
psync_sha256(newpriv, newprivlen, newprivsha);
rsasign = prsa_sign_sha256_hash(priv, newprivsha);
if (is_err(rsasign)) {
psync_free(is_err);
free(rsasign);
prsa_free_public(pub);
prsa_free_private(priv);
return to_err(rsasign);
}
*privenc = (char *)psync_base64_encode(newpriv, newprivlen, &dummy);
*sign = (char *)psync_base64_encode(rsasign->data, rsasign->datalen, &dummy);
psync_free(rsasign);
psync_free(newpriv);
free(rsasign);
free(newpriv);
prsa_free_public(pub);
prsa_free_private(priv);
if (!*privenc || !*sign) {
psync_free(*privenc);
psync_free(*sign);
free(*privenc);
free(*sign);
return PERROR_NO_MEMORY;
}
@ -1915,13 +1914,13 @@ err_bk_1:
err_bk_0:
return PSYNC_CRYPTO_BAD_KEY;
err_nm_1:
psync_free(newpriv);
free(newpriv);
prsa_free_public(pub);
return PERROR_NO_MEMORY;
err_ph_2:
prsa_free_private(priv);
err_ph_1:
psync_free(newpriv);
free(newpriv);
prsa_free_public(pub);
return PSYNC_CRYPTO_BAD_PASSPHRASE;
}
@ -1941,7 +1940,7 @@ int psync_pcloud_crypto_encode_key(const char *newpassphrase, uint32_t flags,
goto err_nm_0;
rsaprivlen = rsapriv->datalen;
newpriv =
(unsigned char *)psync_malloc(offsetof(priv_key_ver1, key) + rsaprivlen);
(unsigned char *)malloc(offsetof(priv_key_ver1, key) + rsaprivlen);
if (unlikely(!newpriv))
goto err_nm_1;
rsapriv_struct = (priv_key_ver1 *)newpriv;
@ -1967,27 +1966,27 @@ int psync_pcloud_crypto_encode_key(const char *newpassphrase, uint32_t flags,
rsasign = prsa_sign_sha256_hash(crypto_privkey, newprivsha);
if (is_err(rsasign)) {
putil_wipe(newpriv, rsaprivlen);
psync_free(newpriv);
free(newpriv);
prsa_free_binary(rsapriv);
return to_err(rsasign);
}
*privenc = (char *)psync_base64_encode(newpriv, rsaprivlen, &dummy);
*sign = (char *)psync_base64_encode(rsasign->data, rsasign->datalen, &dummy);
psync_free(rsasign);
free(rsasign);
putil_wipe(newpriv, rsaprivlen);
psync_free(newpriv);
free(newpriv);
prsa_free_binary(rsapriv);
if (!*privenc || !*sign) {
psync_free(*privenc);
psync_free(*sign);
free(*privenc);
free(*sign);
return PERROR_NO_MEMORY;
}
return PSYNC_CRYPTO_SUCCESS;
err_nm_1:
psync_free(newpriv);
free(newpriv);
prsa_free_binary(rsapriv);
err_nm_0:
return PERROR_NO_MEMORY;
@ -2026,21 +2025,21 @@ int pcryptofolder_change_pass(const char *oldpassphrase,
rowcnt++;
if (!strcmp(id, "crypto_private_key")) {
load_str_to(&row[1], &privkey, &privkeylen);
privatekey_struct = (priv_key_ver1 *)psync_malloc(
privatekey_struct = (priv_key_ver1 *)malloc(
offsetof(priv_key_ver1, key) + privkeylen);
memset(privatekey_struct, 0, offsetof(priv_key_ver1, key) + privkeylen);
memcpy(privatekey_struct->key, privkey, privkeylen);
privatekey_struct->type = PSYNC_CRYPTO_TYPE_RSA4096_64BYTESALT_20000IT;
putil_wipe(privkey, privkeylen);
psync_free(privkey);
free(privkey);
} else if (!strcmp(id, "crypto_public_key")) {
load_str_to(&row[1], &pubkey, &pubkeylen);
pubkey_struct = (pub_key_ver1 *)psync_malloc(
pubkey_struct = (pub_key_ver1 *)malloc(
offsetof(pub_key_ver1, key) + pubkeylen);
memset(pubkey_struct, 0, offsetof(pub_key_ver1, key) + pubkeylen);
memcpy(pubkey_struct->key, pubkey, pubkeylen);
pubkey_struct->type = PSYNC_CRYPTO_PUB_TYPE_RSA4096;
psync_free(pubkey);
free(pubkey);
} else if (!strcmp(id, "crypto_private_salt")) {
load_str_to(&row[1], &salt, &saltlen);
if (!privatekey_struct) {
@ -2050,15 +2049,15 @@ int pcryptofolder_change_pass(const char *oldpassphrase,
}
memcpy(privatekey_struct->salt, salt, saltlen);
putil_wipe(salt, saltlen);
psync_free(salt);
free(salt);
}
}
psync_sql_free_result(res);
}
psync_sql_unlock();
if (rowcnt < 3) {
psync_free(privatekey_struct);
psync_free(pubkey_struct);
free(privatekey_struct);
free(pubkey_struct);
if (!psync_my_auth[0])
return PERROR_NET_ERROR;
debug(D_NOTICE, "downloading keys");
@ -2071,7 +2070,7 @@ int pcryptofolder_change_pass(const char *oldpassphrase,
if (unlikely(result)) {
debug(D_WARNING, "crypto_getuserkeys returned error %d: %s", (int)result,
papi_find_result2(bres, "error", PARAM_STR)->str);
psync_free(bres);
free(bres);
cres = (int)result;
goto ex;
}
@ -2085,10 +2084,10 @@ int pcryptofolder_change_pass(const char *oldpassphrase,
data = papi_find_result2(bres, "salt", PARAM_STR);
salt = psync_base64_decode((const unsigned char *)data->str, data->length,
&saltlen);
psync_free(bres);
free(bres);
if (unlikely(!privkey || !pubkey)) {
psync_free(privkey);
psync_free(pubkey);
free(privkey);
free(pubkey);
cres = PERROR_NO_MEMORY;
goto ex;
}
@ -2096,11 +2095,11 @@ int pcryptofolder_change_pass(const char *oldpassphrase,
cres = psync_pcloud_crypto_reencode_key(
pubkey, pubkeylen, privkey, privkeylen, oldpassphrase, newpassphrase,
flags, privenc, sign);
psync_free(pubkey);
free(pubkey);
putil_wipe(privkey, privkeylen);
psync_free(privkey);
free(privkey);
putil_wipe(salt, saltlen);
psync_free(salt);
free(salt);
if (cres)
goto ex;
} else {
@ -2111,8 +2110,8 @@ int pcryptofolder_change_pass(const char *oldpassphrase,
privkeylen + offsetof(priv_key_ver1, key), oldpassphrase, newpassphrase,
flags, privenc, sign);
putil_wipe(privatekey_struct, privkeylen + offsetof(priv_key_ver1, key));
psync_free(privatekey_struct);
psync_free(pubkey_struct);
free(privatekey_struct);
free(pubkey_struct);
if (cres)
goto ex;
}

12
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;
@ -168,7 +168,7 @@ static int psync_deflate_finish_flush_add_buffer(psync_deflate_t *def,
}
used += current;
alloced *= 2;
buff = (unsigned char *)psync_realloc(buff, alloced);
buff = (unsigned char *)realloc(buff, alloced);
current = alloced - used;
}
}
@ -212,7 +212,7 @@ int pdeflate_read(psync_deflate_t *def, void *data, int len) {
memcpy(data, def->flushbuff + def->flushbuffoff, len);
def->flushbuffoff += len;
if (def->flushbuffoff == def->flushbufflen) {
psync_free(def->flushbuff);
free(def->flushbuff);
def->flushbuff = NULL;
}
return len;

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

126
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;
}
}
@ -1858,7 +1858,7 @@ static void send_share_notify(psync_eventtype_t eventid, const binresult *share,
if ((row = psync_sql_fetch_row(res))) {
cstr = psync_get_lstring(row[0], &sharenamelen);
stringslen += ++sharenamelen;
sharename = (char *)psync_malloc(sharenamelen);
sharename = (char *)malloc(sharenamelen);
memcpy(sharename, cstr, sharenamelen);
freesharename = 1;
ctime = psync_get_number(row[1]);
@ -1871,14 +1871,14 @@ static void send_share_notify(psync_eventtype_t eventid, const binresult *share,
return;
}
}
e = (psync_share_event_t *)psync_malloc(sizeof(psync_share_event_t) +
e = (psync_share_event_t *)malloc(sizeof(psync_share_event_t) +
stringslen);
str = (char *)(e + 1);
memset(e, 0, sizeof(psync_share_event_t));
e->folderid = papi_find_result2(share, "folderid", PARAM_NUM)->num;
fill_str(e->sharename, sharename, sharenamelen);
if (freesharename)
psync_free(sharename);
free(sharename);
fill_str(e->message, message, messagelen);
if ((br = papi_check_result2(share, "userid", PARAM_NUM)))
@ -1915,7 +1915,7 @@ static void send_share_notify(psync_eventtype_t eventid, const binresult *share,
}
}
if (isba) {
notify_paramst *params = psync_malloc(sizeof(notify_paramst));
notify_paramst *params = malloc(sizeof(notify_paramst));
params->eventid = eventid;
params->event_data = e;
params->touserid = touserid;
@ -1938,14 +1938,14 @@ static void do_send_eventdata(void *param) {
get_ba_member_email(data->fromuserid, &email, &emaillen);
fill_str(data->event_data->fromemail, email, emaillen);
psync_free(email);
free(email);
if (data->touserid)
get_ba_member_email(data->touserid, &email, &emaillen);
else
get_ba_team_name(data->teamid, &email, &emaillen);
fill_str(data->event_data->toemail, email, emaillen);
psync_free(email);
free(email);
if (email) {
pdiff_lock();
@ -1953,7 +1953,7 @@ static void do_send_eventdata(void *param) {
pdiff_unlock();
}
psync_free(param);
free(param);
}
static void process_requestsharein(const binresult *entry) {
@ -2269,7 +2269,7 @@ static void process_establishbshareout(const binresult *entry) {
psync_sql_run_free(q);
if (email)
psync_free(email);
free(email);
}
static void delete_share_request(const binresult *share) {
@ -2711,7 +2711,7 @@ static void psync_diff_refresh_fs_add_folder(psync_folderid_t folderid) {
refresh_allocated *= 2;
else
refresh_allocated = 8;
refresh_folders = (psync_folderid_t *)psync_realloc(
refresh_folders = (psync_folderid_t *)realloc(
refresh_folders, sizeof(psync_folderid_t) * refresh_allocated);
}
refresh_folders[refresh_last++] = folderid;
@ -2732,8 +2732,8 @@ static void psync_diff_refresh_thread(void *ptr) {
psync_fs_refresh_folder(fr->refresh_folders[i]);
lastfolderid = fr->refresh_folders[i];
}
psync_free(fr->refresh_folders);
psync_free(fr);
free(fr->refresh_folders);
free(fr);
}
static void psync_diff_refresh_fs(const binresult *entries) {
@ -2805,13 +2805,13 @@ static void psync_run_analyze_if_needed() {
--tablecnt;
debug(D_NOTICE, "running ANALYZE on %s", tablenames[tablecnt]);
sql = psync_strcat("ANALYZE ", tablenames[tablecnt], ";", NULL);
psync_free(tablenames[tablecnt]);
free(tablenames[tablecnt]);
psync_sql_statement(sql);
psync_free(sql);
free(sql);
debug(D_NOTICE, "table done");
psys_sleep_milliseconds(5);
}
psync_free(tablenames);
free(tablenames);
res = psync_sql_prep_statement(
"REPLACE INTO setting (id, value) VALUES (?, ?)");
psync_sql_bind_string(res, 1, "lastanalyze");
@ -2850,7 +2850,7 @@ static int psync_diff_check_quota(psock_t *sock) {
"binapi", PARAM_ARRAY);
if (uq->length)
psync_apipool_set_server(uq->array[0]->str);
psync_free(res);
free(res);
return 0;
}
@ -2862,7 +2862,7 @@ static void psync_diff_adapter_hash(void *out) {
pcrc32c_fast_hash256_update(&ctx, list->interfaces,
list->interfacecnt * sizeof(psock_iface_t));
pcrc32c_fast_hash256_final(out, &ctx);
psync_free(list);
free(list);
}
static void psync_diff_adapter_timer(psync_timer_t timer, void *ptr) {
@ -2940,7 +2940,7 @@ restart:
}
result = entries->length;
if (should_free_res) {
psync_free(res);
free(res);
should_free_res = 0;
res = NULL;
}
@ -3086,7 +3086,7 @@ restart:
}
if (should_free_res) {
psync_free(res);
free(res);
should_free_res = 0;
res = NULL;
}
@ -3094,7 +3094,7 @@ restart:
cleanup:
if (should_free_res && res) {
psync_free(res);
free(res);
}
psock_close(sock);
close(exceptionsock);

74
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;
@ -740,7 +740,7 @@ static int task_download_file(download_task_t *dt) {
requestpath = papi_find_result2(res, "path", PARAM_STR)->str;
psync_slprintf(cookie, sizeof(cookie), "Cookie: dwltag=%s\015\012",
papi_find_result2(res, "dwltag", PARAM_STR)->str);
buff = psync_malloc(PSYNC_COPY_BUFFER_SIZE);
buff = malloc(PSYNC_COPY_BUFFER_SIZE);
http = NULL;
psync_hash_init(&hashctx);
psync_list_for_each_element(range, &ranges, psync_range_list_t, list) {
@ -835,7 +835,7 @@ static int task_download_file(download_task_t *dt) {
}
if (unlikely_log(pfile_sync(fd)))
goto err2;
psync_free(buff);
free(buff);
psync_hash_final(localhashbin, &hashctx);
if (unlikely_log(pfile_close(fd)))
goto err0;
@ -859,29 +859,27 @@ static int task_download_file(download_task_t *dt) {
// pqevent_queue_sync_event_id(PEVENT_FILE_DOWNLOAD_FINISHED, syncid, name,
// fileid);
debug(D_NOTICE, "file downloaded %s", dt->localname);
psync_list_for_each_element_call(&ranges, psync_range_list_t, list,
psync_free);
psync_list_for_each_element_call(&ranges, psync_range_list_t, list, free);
if (tmpold) {
pfile_delete(tmpold);
psync_free(tmpold);
free(tmpold);
}
psync_free(res);
free(res);
return 0;
err2:
psync_hash_final(localhashbin, &hashctx); /* just in case */
psync_free(buff);
free(buff);
if (http)
psync_http_close(http);
err1:
pfile_close(fd);
err0:
psync_list_for_each_element_call(&ranges, psync_range_list_t, list,
psync_free);
psync_list_for_each_element_call(&ranges, psync_range_list_t, list, free);
if (tmpold) {
pfile_delete(tmpold);
psync_free(tmpold);
free(tmpold);
}
psync_free(res);
free(res);
return -1;
}
@ -909,7 +907,7 @@ static int task_delete_file(psync_syncid_t syncid, psync_fileid_t fileid,
(int)errno);
if (errno == EBUSY || errno == EROFS) {
ret = -1;
psync_free(name);
free(name);
continue;
}
} else
@ -918,7 +916,7 @@ static int task_delete_file(psync_syncid_t syncid, psync_fileid_t fileid,
// events are not fully implemented anyway
// pqevent_queue_sync_event_path(PEVENT_LOCAL_FILE_DELETED, row[1], name,
// fileid, remotepath);
psync_free(name);
free(name);
}
stmt = psync_sql_prep_statement("DELETE FROM localfile WHERE id=?");
psync_sql_bind_uint(stmt, 1, row[0]);
@ -971,7 +969,7 @@ static int task_rename_file(psync_syncid_t oldsyncid, psync_syncid_t newsyncid,
return 0;
oldpath = pfolder_lpath_lfile(lfileid, NULL);
if (unlikely_log(!oldpath)) {
psync_free(newfolder);
free(newfolder);
return 0;
}
newpath = psync_strcat(newfolder, "/", newname, NULL);
@ -1002,9 +1000,9 @@ static int task_rename_file(psync_syncid_t oldsyncid, psync_syncid_t newsyncid,
}
psync_resume_localscan();
}
psync_free(newpath);
psync_free(oldpath);
psync_free(newfolder);
free(newpath);
free(oldpath);
free(newfolder);
return ret;
}
@ -1037,10 +1035,10 @@ static void free_download_task(download_task_t *dt) {
}
if (dt->lock)
psync_unlock_file(dt->lock);
psync_free(dt->localpath);
psync_free(dt->localname);
psync_free(dt->tmpname);
psync_free(dt);
free(dt->localpath);
free(dt->localname);
free(dt->tmpname);
free(dt);
}
static void free_task_timer_thread(void *ptr) {
@ -1201,7 +1199,7 @@ static int task_run_download_file(uint64_t taskid, psync_syncid_t syncid,
tmpname = psync_strcat(localpath, "/", filename,
PSYNC_APPEND_PARTIAL_FILES, NULL);
len = strlen(filename);
dt = (download_task_t *)psync_malloc(offsetof(download_task_t, filename) +
dt = (download_task_t *)malloc(offsetof(download_task_t, filename) +
len + 1);
memset(dt, 0, offsetof(download_task_t, filename));
dt->taskid = taskid;
@ -1340,7 +1338,7 @@ static void task_del_folder_rec_do(const char *localpath,
psync_get_string(vrow[1]), NULL);
debug(D_NOTICE, "deleting %s", nm);
pfile_delete(nm);
psync_free(nm);
free(nm);
}
psync_sql_free_result(res);
res = psync_sql_prep_statement(
@ -1356,7 +1354,7 @@ static void task_del_folder_rec_do(const char *localpath,
nm = psync_strcat(localpath, "/",
psync_get_string(vrow[1]), NULL);
task_del_folder_rec_do(nm, psync_get_number(vrow[0]), syncid);
psync_free(nm);
free(nm);
}
psync_sql_free_result(res);
res = psync_sql_prep_statement(
@ -1466,7 +1464,7 @@ static int download_task(uint64_t taskid, uint32_t type, psync_syncid_t syncid,
debug(D_WARNING, "task of type %u, syncid %u, id %lu localid %lu failed",
(unsigned)type, (unsigned)syncid, (unsigned long)itemid,
(unsigned long)localitemid);
psync_free(vname);
free(vname);
return res;
}
@ -1498,7 +1496,7 @@ static void download_thread() {
}
} else if (type != PSYNC_DOWNLOAD_FILE)
psys_sleep_milliseconds(PSYNC_SLEEP_ON_FAILED_DOWNLOAD);
psync_free(row);
free(row);
continue;
}
@ -1593,7 +1591,7 @@ download_hashes_t *pdownload_get_hashes() {
cnt = 0;
pthread_mutex_lock(&current_downloads_mutex);
psync_list_for_each_element(dwl, &downloads, download_list_t, list) cnt++;
ret = (download_hashes_t *)psync_malloc(
ret = (download_hashes_t *)malloc(
offsetof(download_hashes_t, hashes) +
sizeof(psync_hex_hash) * cnt);
cnt = 0;

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

60
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,12 +220,12 @@ errnet:
}
static void psync_free_string_list(psync_list *lst) {
psync_list_for_each_element_call(lst, string_list, list, psync_free);
psync_list_for_each_element_call(lst, string_list, list, free);
}
static string_list *str_to_list_element(const char *str, size_t len) {
string_list *le;
le = (string_list *)psync_malloc(sizeof(string_list) + len + 1);
le = (string_list *)malloc(sizeof(string_list) + len + 1);
le->str = (char *)(le + 1);
le->len = len;
memcpy(le->str, str, len + 1);
@ -240,7 +240,7 @@ static int psync_add_path_to_list(psync_list *lst, psync_folderid_t folderid) {
size_t len;
while (1) {
if (folderid == 0) {
e = (string_list *)psync_malloc(sizeof(string_list));
e = (string_list *)malloc(sizeof(string_list));
e->str = (char *)e;
e->len = 0;
psync_list_add_head(lst, &e->list);
@ -268,18 +268,18 @@ static string_list *str_list_decode(psync_folderid_t folderid, string_list *e) {
char *fn;
dec = pcryptofolder_flddecoder_get(folderid);
if (psync_crypto_is_error(dec)) {
psync_free(e);
free(e);
debug(D_WARNING, "got error %d getting decoder for folderid %lu",
psync_crypto_to_error(dec), (unsigned long)folderid);
return NULL;
}
fn = pcryptofolder_flddecode_filename(dec, e->str);
pcryptofolder_flddecoder_release(folderid, dec);
psync_free(e);
free(e);
if (unlikely_log(!fn))
return NULL;
e = str_to_list_element(fn, strlen(fn));
psync_free(fn);
free(fn);
return e;
}
@ -297,7 +297,7 @@ static int psync_add_path_to_list_decode(psync_list *lst,
if (folderid == 0) {
if (e)
psync_list_add_head(lst, &e->list);
e = (string_list *)psync_malloc(sizeof(string_list));
e = (string_list *)malloc(sizeof(string_list));
e->str = (char *)e;
e->len = 0;
psync_list_add_head(lst, &e->list);
@ -343,7 +343,7 @@ char *psync_join_string_list(const char *sep, psync_list *lst, size_t *retlen) {
if (unlikely(!cnt))
return psync_strdup("");
seplen = strlen(sep);
ret = str = psync_malloc(slen + cnt * seplen + 1);
ret = str = malloc(slen + cnt * seplen + 1);
psync_list_for_each_element(e, lst, string_list, list) {
memcpy(str, e->str, e->len);
str += e->len;
@ -372,7 +372,7 @@ char *pfolder_path(psync_folderid_t folderid, size_t *retlen) {
ret = psync_join_string_list("/", &folderlist, retlen);
psync_free_string_list(&folderlist);
if (!ret[0]) {
psync_free(ret);
free(ret);
ret = psync_strdup("/");
if (retlen)
*retlen = 1;
@ -394,7 +394,7 @@ char *pfolder_path_sep(psync_folderid_t folderid, const char *sep,
ret = psync_join_string_list(sep, &folderlist, retlen);
psync_free_string_list(&folderlist);
if (!ret[0]) {
psync_free(ret);
free(ret);
ret = psync_strdup(sep);
if (retlen)
*retlen = 1;
@ -542,10 +542,10 @@ char *pfolder_lpath_lfile(psync_fileid_t localfileid,
static folder_list *folder_list_init() {
folder_list *list;
list = (folder_list *)psync_malloc(sizeof(folder_list));
list = (folder_list *)malloc(sizeof(folder_list));
list->entries =
(pentry_t *)psync_malloc(sizeof(pentry_t) * INITIAL_ENTRY_CNT);
list->namebuff = (char *)psync_malloc(INITIAL_NAME_BUFF);
(pentry_t *)malloc(sizeof(pentry_t) * INITIAL_ENTRY_CNT);
list->namebuff = (char *)malloc(INITIAL_NAME_BUFF);
list->nameoff = 0;
list->namealloc = INITIAL_NAME_BUFF;
list->entriescnt = 0;
@ -556,12 +556,12 @@ static folder_list *folder_list_init() {
static void folder_list_add(folder_list *list, pentry_t *entry) {
if (list->entriescnt >= list->entriesalloc) {
list->entriesalloc *= 2;
list->entries = (pentry_t *)psync_realloc(
list->entries = (pentry_t *)realloc(
list->entries, sizeof(pentry_t) * list->entriesalloc);
}
while (list->nameoff + entry->namelen >= list->namealloc) {
list->namealloc *= 2;
list->namebuff = (char *)psync_realloc(list->namebuff, list->namealloc);
list->namebuff = (char *)realloc(list->namebuff, list->namealloc);
}
memcpy(&list->entries[list->entriescnt++], entry, sizeof(pentry_t));
memcpy(list->namebuff + list->nameoff, entry->name, entry->namelen);
@ -570,9 +570,9 @@ static void folder_list_add(folder_list *list, pentry_t *entry) {
}
static void folder_list_free(folder_list *list) {
psync_free(list->entries);
psync_free(list->namebuff);
psync_free(list);
free(list->entries);
free(list->namebuff);
free(list);
}
static pfolder_list_t *folder_list_finalize(folder_list *list) {
@ -583,7 +583,7 @@ static pfolder_list_t *folder_list_finalize(folder_list *list) {
(unsigned)(offsetof(pfolder_list_t, entries) +
sizeof(pentry_t) * list->entriescnt + list->nameoff),
(unsigned)list->nameoff);
ret = (pfolder_list_t *)psync_malloc(offsetof(pfolder_list_t, entries) +
ret = (pfolder_list_t *)malloc(offsetof(pfolder_list_t, entries) +
sizeof(pentry_t) * list->entriescnt +
list->nameoff);
name = ((char *)ret) + offsetof(pfolder_list_t, entries) +
@ -748,7 +748,7 @@ pentry_t *pfolder_stat(const char *remotepath) {
memcpy(cremotepath, remotepath, len + 1);
cremotepath[len] = 0;
folderid = pfolder_id(cremotepath);
psync_free(cremotepath);
free(cremotepath);
if (folderid == PSYNC_INVALID_FOLDERID)
return NULL;
}
@ -759,7 +759,7 @@ pentry_t *pfolder_stat(const char *remotepath) {
psync_sql_bind_uint(res, 1, folderid);
psync_sql_bind_lstring(res, 2, remotepath + len, olen);
if ((row = psync_sql_fetch_rowint(res))) {
ret = (pentry_t *)psync_malloc(sizeof(pentry_t) + olen + 1);
ret = (pentry_t *)malloc(sizeof(pentry_t) + olen + 1);
ret->folder.folderid = row[0];
ret->folder.cansyncup = ((row[1] & PSYNC_PERM_WRITE) == PSYNC_PERM_WRITE);
ret->folder.cansyncdown = ((row[1] & PSYNC_PERM_READ) == PSYNC_PERM_READ);
@ -778,7 +778,7 @@ pentry_t *pfolder_stat(const char *remotepath) {
psync_sql_bind_uint(res, 1, folderid);
psync_sql_bind_lstring(res, 2, remotepath + len, olen);
if ((row = psync_sql_fetch_rowint(res))) {
ret = (pentry_t *)psync_malloc(sizeof(pentry_t) + olen + 1);
ret = (pentry_t *)malloc(sizeof(pentry_t) + olen + 1);
ret->file.fileid = row[0];
ret->file.size = row[1];
ret->name = (char *)(ret + 1);
@ -835,12 +835,12 @@ psync_folder_list_t *pfolder_sync_folders(char *syncTypes) {
while ((row = psync_sql_fetch_row(res))) {
if (alloced == lastfolder) {
alloced = (alloced + 32) * 2;
folders = (psync_tmp_folder_t *)psync_realloc(
folders = (psync_tmp_folder_t *)realloc(
folders, sizeof(psync_tmp_folder_t) * alloced);
}
cstr = psync_get_lstring(row[2], &l);
l++;
str = (char *)psync_malloc(l);
str = (char *)malloc(l);
memcpy(str, cstr, l);
strlens += l;
@ -864,14 +864,14 @@ psync_folder_list_t *pfolder_sync_folders(char *syncTypes) {
psync_sql_free_result(res);
l = offsetof(psync_folder_list_t, folders) +
sizeof(psync_folder_t) * lastfolder;
ret = (psync_folder_list_t *)psync_malloc(l + strlens);
ret = (psync_folder_list_t *)malloc(l + strlens);
str = ((char *)ret) + l;
ret->foldercnt = lastfolder;
for (i = 0; i < lastfolder; i++) {
l = folders[i].locallen;
memcpy(str, folders[i].localpath, l);
psync_free(folders[i].localpath);
free(folders[i].localpath);
strncpy(ret->folders[i].localpath, str,
sizeof(ret->folders[i].localpath) - 1);
ret->folders[i].localpath[sizeof(ret->folders[i].localpath) - 1] = '\0';
@ -891,7 +891,7 @@ psync_folder_list_t *pfolder_sync_folders(char *syncTypes) {
l = folders[i].remotelen;
memcpy(str, folders[i].remotepath, l);
psync_free(folders[i].remotepath);
free(folders[i].remotepath);
strncpy(ret->folders[i].remotepath, str,
sizeof(ret->folders[i].remotepath) - 1);
ret->folders[i].remotepath[sizeof(ret->folders[i].remotepath) - 1] = '\0';
@ -914,7 +914,7 @@ psync_folder_list_t *pfolder_sync_folders(char *syncTypes) {
ret->folders[i].synctype = folders[i].synctype;
}
psync_free(folders);
free(folders);
return ret;
}

148
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);
@ -1017,7 +1017,7 @@ psync_fs_create_file(psync_fsfileid_t fileid, psync_fsfileid_t remotefileid,
}
}
if (encoder == PSYNC_CRYPTO_INVALID_ENCODER) {
fl = (psync_openfile_t *)psync_malloc(offsetof(psync_openfile_t, encoder));
fl = (psync_openfile_t *)malloc(offsetof(psync_openfile_t, encoder));
memset(fl, 0, offsetof(psync_openfile_t, encoder));
} else {
fl = psync_new(psync_openfile_t);
@ -1146,7 +1146,7 @@ static int open_write_files(psync_openfile_t *of, int trunc) {
psync_strcat(cachepath, "/", fileidhex, NULL);
of->datafile = pfile_open(filename, O_RDWR,
O_CREAT | (trunc ? O_TRUNC : 0));
psync_free(filename);
free(filename);
if (of->datafile == INVALID_HANDLE_VALUE) {
debug(D_ERROR, "could not open cache file for fileid %ld",
(long)of->fileid);
@ -1172,7 +1172,7 @@ static int open_write_files(psync_openfile_t *of, int trunc) {
psync_strcat(cachepath, "/", fileidhex, NULL);
of->indexfile = pfile_open(filename, O_RDWR,
O_CREAT | (trunc ? O_TRUNC : 0));
psync_free(filename);
free(filename);
if (of->indexfile == INVALID_HANDLE_VALUE) {
debug(D_ERROR, "could not open cache index file for fileid %ld",
(long)of->fileid);
@ -1191,7 +1191,7 @@ static int open_write_files(psync_openfile_t *of, int trunc) {
filename =
psync_strcat(cachepath, "/", fileidhex, NULL);
of->logfile = pfile_open(filename, O_RDWR, O_CREAT | O_TRUNC);
psync_free(filename);
free(filename);
if (of->logfile == INVALID_HANDLE_VALUE) {
debug(D_ERROR, "could not open log file for fileid %ld",
(long)of->fileid);
@ -1229,13 +1229,13 @@ static void psync_fs_del_creat(psync_fspath_t *fpath, psync_openfile_t *of) {
if (likely((cr = psync_fstask_find_creat(folder, fpath->name, 0)))) {
ptree_del(&folder->creats, &cr->tree);
folder->taskscnt--;
psync_free(cr);
free(cr);
}
psync_fstask_release_folder_tasks_locked(folder);
}
psync_fs_dec_of_refcnt(of);
psync_sql_unlock();
psync_free(fpath);
free(fpath);
}
static int psync_fs_open(const char *path, struct fuse_file_info *fi) {
@ -1272,14 +1272,14 @@ static int psync_fs_open(const char *path, struct fuse_file_info *fi) {
if ((fi->flags & 3) != O_RDONLY &&
!(fpath->permissions & PSYNC_PERM_MODIFY)) {
psync_sql_unlock();
psync_free(fpath);
free(fpath);
return -EACCES;
}
// even if there are existing files there, just don't allow opening those
if (fpath->flags & (PSYNC_FOLDER_FLAG_BACKUP_DEVICE_LIST |
PSYNC_FOLDER_FLAG_BACKUP_DEVICE)) {
psync_sql_unlock();
psync_free(fpath);
free(fpath);
return -EACCES;
}
folder = psync_fstask_get_or_create_folder_tasks_locked(fpath->folderid);
@ -1338,7 +1338,7 @@ static int psync_fs_open(const char *path, struct fuse_file_info *fi) {
psync_fstask_release_folder_tasks_locked(folder);
psync_sql_unlock();
debug(D_NOTICE, "opening new file %ld %s", (long)fileid, fpath->name);
psync_free(fpath);
free(fpath);
of->newfile = 1;
of->releasedforupload = status != 1;
ret = open_write_files(of, fi->flags & O_TRUNC);
@ -1391,7 +1391,7 @@ static int psync_fs_open(const char *path, struct fuse_file_info *fi) {
fpath->name, encoder);
psync_fstask_release_folder_tasks_locked(folder);
psync_sql_unlock();
psync_free(fpath);
free(fpath);
of->newfile = 0;
of->releasedforupload = status != 1;
ret = open_write_files(of, fi->flags & O_TRUNC);
@ -1412,7 +1412,7 @@ static int psync_fs_open(const char *path, struct fuse_file_info *fi) {
fpath->name, PSYNC_CRYPTO_INVALID_ENCODER);
psync_fstask_release_folder_tasks_locked(folder);
psync_sql_unlock();
psync_free(fpath);
free(fpath);
of->modified = 1;
of->staticfile = 1;
of->staticdata = (const char *)lc->data;
@ -1470,7 +1470,7 @@ static int psync_fs_open(const char *path, struct fuse_file_info *fi) {
encoder = pcrypto_sec_encdec_create(symkey);
psymkey_free(symkey);
if (unlikely_log(encoder == PSYNC_CRYPTO_INVALID_ENCODER)) {
psync_free(encsymkey);
free(encsymkey);
ret = -ENOMEM;
goto ex0;
}
@ -1482,7 +1482,7 @@ static int psync_fs_open(const char *path, struct fuse_file_info *fi) {
}
cr =
psync_fstask_add_creat(folder, fpath->name, 0, encsymkey, encsymkeylen);
psync_free(encsymkey);
free(encsymkey);
if (unlikely_log(!cr)) {
ret = -EIO;
goto ex0;
@ -1500,7 +1500,7 @@ static int psync_fs_open(const char *path, struct fuse_file_info *fi) {
psync_fs_del_creat(fpath, of);
return ret;
}
psync_free(fpath);
free(fpath);
fi->fh = openfile_to_fh(of);
return 0;
} else if (row) {
@ -1523,7 +1523,7 @@ static int psync_fs_open(const char *path, struct fuse_file_info *fi) {
ex0:
psync_fstask_release_folder_tasks_locked(folder);
psync_sql_unlock();
psync_free(fpath);
free(fpath);
return ret;
}
@ -1557,7 +1557,7 @@ static int psync_fs_creat_fake_locked(psync_fspath_t *fpath,
size_t len;
fileid = psync_fake_fileid++;
len = strlen(fpath->name) + 1;
cr = (psync_fstask_creat_t *)psync_malloc(
cr = (psync_fstask_creat_t *)malloc(
offsetof(psync_fstask_creat_t, name) + len);
cr->fileid = fileid;
cr->rfileid = 0;
@ -1572,7 +1572,7 @@ static int psync_fs_creat_fake_locked(psync_fspath_t *fpath,
of->newfile = 0;
of->modified = 0;
psync_sql_unlock();
psync_free(fpath);
free(fpath);
fi->fh = openfile_to_fh(of);
return 0;
}
@ -1611,7 +1611,7 @@ static int psync_fs_creat(const char *path, mode_t mode,
(fpath->flags & (PSYNC_FOLDER_FLAG_BACKUP_DEVICE_LIST |
PSYNC_FOLDER_FLAG_BACKUP_DEVICE))) {
psync_sql_unlock();
psync_free(fpath);
free(fpath);
return -EACCES;
}
folder = psync_fstask_get_or_create_folder_tasks_locked(fpath->folderid);
@ -1620,14 +1620,14 @@ static int psync_fs_creat(const char *path, mode_t mode,
debug(D_NOTICE, "file %s already exists, processing as open", path);
ret = psync_fs_open(path, fi);
psync_sql_unlock();
psync_free(fpath);
free(fpath);
return ret;
}
if (fpath->flags & PSYNC_FOLDER_FLAG_ENCRYPTED) {
if (psync_crypto_isexpired()) {
psync_fstask_release_folder_tasks_locked(folder);
psync_sql_unlock();
psync_free(fpath);
free(fpath);
return -PRINT_RETURN_CONST(PSYNC_FS_ERR_CRYPTO_EXPIRED);
}
encsymkey = pcryptofolder_filencoder_key_newplain(
@ -1635,7 +1635,7 @@ static int psync_fs_creat(const char *path, mode_t mode,
if (unlikely_log(psync_crypto_is_error(encsymkey))) {
psync_fstask_release_folder_tasks_locked(folder);
psync_sql_unlock();
psync_free(fpath);
free(fpath);
return -psync_fs_crypto_err_to_errno(psync_crypto_to_error(encsymkey));
}
encoder = pcrypto_sec_encdec_create(symkey);
@ -1643,8 +1643,8 @@ static int psync_fs_creat(const char *path, mode_t mode,
if (unlikely_log(encoder == PSYNC_CRYPTO_INVALID_ENCODER)) {
psync_fstask_release_folder_tasks_locked(folder);
psync_sql_unlock();
psync_free(fpath);
psync_free(encsymkey);
free(fpath);
free(encsymkey);
return -ENOMEM;
}
} else {
@ -1654,11 +1654,11 @@ static int psync_fs_creat(const char *path, mode_t mode,
}
cr = psync_fstask_add_creat(folder, fpath->name, 0, encsymkey, encsymkeylen);
if (encsymkey)
psync_free(encsymkey);
free(encsymkey);
if (unlikely_log(!cr)) {
psync_fstask_release_folder_tasks_locked(folder);
psync_sql_unlock();
psync_free(fpath);
free(fpath);
return -EIO;
}
of = psync_fs_create_file(cr->fileid, 0, 0, 0, 1, 0,
@ -1674,7 +1674,7 @@ static int psync_fs_creat(const char *path, mode_t mode,
psync_fs_del_creat(fpath, of);
return ret;
}
psync_free(fpath);
free(fpath);
fi->fh = openfile_to_fh(of);
return 0;
}
@ -1717,7 +1717,7 @@ static void psync_fs_free_openfile(psync_openfile_t *of) {
}
close_if_valid(of->logfile);
ptree_for_each_element_call_safe(
of->sectorsinlog, psync_sector_inlog_t, tree, psync_free);
of->sectorsinlog, psync_sector_inlog_t, tree, free);
delete_log_files(of);
if (of->authenticatedints)
psync_interval_tree_free(of->authenticatedints);
@ -1735,13 +1735,13 @@ static void psync_fs_free_openfile(psync_openfile_t *of) {
if (cr) {
ptree_del(&of->currentfolder->creats, &cr->tree);
of->currentfolder->taskscnt--;
psync_free(cr);
free(cr);
}
psync_sql_unlock();
}
psync_fstask_release_folder_tasks(of->currentfolder);
psync_free(of->currentname);
psync_free(of);
free(of->currentname);
free(of);
}
static void psync_fs_get_both_locks(psync_openfile_t *of) {
@ -1821,7 +1821,7 @@ static void psync_fs_upload_release_timer(void *ptr) {
psync_sql_run_free(res);
}
psync_fs_dec_of_refcnt(ofw->of);
psync_free(ofw);
free(ofw);
pstatus_upload_recalc_async();
}
@ -2161,7 +2161,7 @@ psync_fs_reopen_file_for_writing(psync_openfile_t *of) {
if (unlikely_log(!cr)) {
psync_sql_unlock();
ppagecache_unlock_pages();
psync_free(encsymkey);
free(encsymkey);
return -EIO;
}
psync_fs_update_openfile_fileid_locked(of, cr->fileid);
@ -2172,7 +2172,7 @@ psync_fs_reopen_file_for_writing(psync_openfile_t *of) {
ret = open_write_files(of, 0);
if (unlikely_log(ret)) {
ppagecache_unlock_pages();
psync_free(encsymkey);
free(encsymkey);
return ret;
}
if (of->origctime)
@ -2182,7 +2182,7 @@ psync_fs_reopen_file_for_writing(psync_openfile_t *of) {
of, of->hash, size);
ppagecache_unlock_pages();
if (unlikely_log(ret)) {
psync_free(encsymkey);
free(encsymkey);
return -EIO;
}
}
@ -2192,7 +2192,7 @@ psync_fs_reopen_file_for_writing(psync_openfile_t *of) {
cr = psync_fstask_add_modified_file(of->currentfolder, of->currentname,
of->fileid, of->hash, encsymkey,
encsymkeylen);
psync_free(encsymkey);
free(encsymkey);
if (unlikely_log(!cr)) {
psync_sql_unlock();
return -EIO;
@ -2248,13 +2248,13 @@ psync_fs_reopen_static_file_for_writing(psync_openfile_t *of) {
if (likely_log(cr)) {
ptree_del(&of->currentfolder->creats, &cr->tree);
of->currentfolder->taskscnt--;
psync_free(cr);
free(cr);
}
un = psync_fstask_find_unlink(of->currentfolder, of->currentname, taskid);
if (likely_log(un)) {
ptree_del(&of->currentfolder->unlinks, &un->tree);
of->currentfolder->taskscnt--;
psync_free(un);
free(un);
}
psync_sql_unlock();
of->writeid = 0;
@ -2528,7 +2528,7 @@ static int psync_fs_mkdir(const char *path, mode_t mode) {
else
ret = psync_fstask_mkdir(fpath->folderid, fpath->name, fpath->flags);
psync_sql_unlock();
psync_free(fpath);
free(fpath);
debug(D_NOTICE, "mkdir %s=%d", path, ret);
return ret;
}
@ -2548,7 +2548,7 @@ static int psync_fs_can_rmdir(const char *path) {
else
ret = psync_fstask_can_rmdir(fpath->folderid, fpath->flags, fpath->name);
psync_sql_unlock();
psync_free(fpath);
free(fpath);
debug(D_NOTICE, "can_rmdir %s=%d", path, ret);
return ret;
}
@ -2569,7 +2569,7 @@ static int psync_fs_rmdir(const char *path) {
else
ret = psync_fstask_rmdir(fpath->folderid, fpath->flags, fpath->name);
psync_sql_unlock();
psync_free(fpath);
free(fpath);
debug(D_NOTICE, "rmdir %s=%d", path, ret);
return ret;
}
@ -2589,7 +2589,7 @@ static int psync_fs_can_unlink(const char *path) {
else
ret = psync_fstask_can_unlink(fpath->folderid, fpath->name);
psync_sql_unlock();
psync_free(fpath);
free(fpath);
debug(D_NOTICE, "can_unlink %s=%d", path, ret);
return ret;
}
@ -2620,7 +2620,7 @@ static int psync_fs_unlink(const char *path) {
(void *)PEVENT_BKUP_F_DEL_DRIVE);
}
psync_free(fpath);
free(fpath);
debug(D_NOTICE, "unlink %s=%d", path, ret);
return ret;
}
@ -2641,22 +2641,22 @@ static int psync_fs_rename_static_file(psync_fstask_folder_t *srcfolder,
un = psync_fstask_find_unlink(dstfolder, new_name, cr->taskid);
if (un) {
ptree_del(&dstfolder->unlinks, &un->tree);
psync_free(un);
free(un);
dstfolder->taskscnt--;
}
ptree_del(&dstfolder->creats, &cr->tree);
psync_free(cr);
free(cr);
dstfolder->taskscnt--;
}
len = strlen(new_name) + 1;
un = (psync_fstask_unlink_t *)psync_malloc(
un = (psync_fstask_unlink_t *)malloc(
offsetof(psync_fstask_unlink_t, name) + len);
un->fileid = 0;
un->taskid = srccr->taskid;
memcpy(un->name, new_name, len);
psync_fstask_inject_unlink(dstfolder, un);
addlen = psync_fstask_creat_local_offset(len - 1);
cr = (psync_fstask_creat_t *)psync_malloc(addlen +
cr = (psync_fstask_creat_t *)malloc(addlen +
sizeof(psync_fstask_local_creat_t));
cr->fileid = 0;
cr->rfileid = 0;
@ -2669,11 +2669,11 @@ static int psync_fs_rename_static_file(psync_fstask_folder_t *srcfolder,
un = psync_fstask_find_unlink(srcfolder, srccr->name, srccr->taskid);
if (likely_log(un)) {
ptree_del(&srcfolder->unlinks, &un->tree);
psync_free(un);
free(un);
srcfolder->taskscnt--;
}
ptree_del(&srcfolder->creats, &srccr->tree);
psync_free(srccr);
free(srccr);
srcfolder->taskscnt--;
return 0;
}
@ -2990,16 +2990,16 @@ finish:
if (folder)
psync_fstask_release_folder_tasks_locked(folder);
psync_sql_unlock();
psync_free(fold_path);
psync_free(fnew_path);
free(fold_path);
free(fnew_path);
return PRINT_RETURN_FORMAT(ret, " for rename from %s to %s", old_path,
new_path);
err_enoent:
if (folder)
psync_fstask_release_folder_tasks_locked(folder);
psync_sql_unlock();
psync_free(fold_path);
psync_free(fnew_path);
free(fold_path);
free(fnew_path);
debug(D_NOTICE, "returning ENOENT, folder not found");
return -ENOENT;
}
@ -3089,7 +3089,7 @@ static int psync_fs_set_filetime_locked(psync_fsfileid_t fileid,
debug(D_NOTICE, "setting %s time of %s to %lu=%d",
crtime ? "creation" : "modification", filename,
(unsigned long)tv->tv_sec, ret);
psync_free(filename);
free(filename);
return ret ? -EACCES : 0;
}
}
@ -3188,7 +3188,7 @@ static int psync_fs_set_time(const char *path, const struct timespec *tv,
else
ret = psync_fs_set_time_locked(fpath->folderid, fpath->name, tv, crtime);
psync_sql_unlock();
psync_free(fpath);
free(fpath);
return ret;
}
@ -3307,7 +3307,7 @@ static void psync_invalidate_os_cache_noret() {
pthread_mutex_unlock(&start_mutex);
if (path) {
pfile_invalidate_os_cache(path);
psync_free(path);
free(path);
}
}
@ -3380,7 +3380,7 @@ void psync_fs_refresh_folder(psync_folderid_t folderid) {
} else
fpath = NULL;
pthread_mutex_unlock(&start_mutex);
psync_free(path);
free(path);
if (!fpath)
return;
if (pfile_invalidate_os_cache_needed())
@ -3393,7 +3393,7 @@ void psync_fs_refresh_folder(psync_folderid_t folderid) {
pfile_delete(fpath);
}
}
psync_free(fpath);
free(fpath);
}
static char *psync_fuse_get_mountpoint() {
@ -3401,7 +3401,7 @@ static char *psync_fuse_get_mountpoint() {
char *mp;
mp = psync_strdup(psync_setting_get_string(_PS(fsroot)));
if (stat(mp, &st) && mkdir(mp, PSYNC_DEFAULT_POSIX_FOLDER_MODE)) {
psync_free(mp);
free(mp);
return NULL;
}
return mp;
@ -3435,12 +3435,12 @@ char *psync_fs_get_path_by_folderid(psync_folderid_t folderid) {
path =
pfolder_path_sep(folderid, "/", NULL);
if (path == PSYNC_INVALID_PATH) {
psync_free(mp);
free(mp);
return NULL;
}
ret = psync_strcat(mp, path, NULL);
psync_free(mp);
psync_free(path);
free(mp);
free(path);
return ret;
}
@ -3518,7 +3518,7 @@ static void psync_fs_do_stop(void) {
#if IS_DEBUG
psync_fs_dump_internals();
#endif
psync_free(mp);
free(mp);
}
pthread_mutex_unlock(&start_mutex);
}
@ -3593,7 +3593,7 @@ static void psync_fuse_thread() {
pthread_mutex_lock(&start_mutex);
fuse_destroy(psync_fuse);
debug(D_NOTICE, "fuse_destroy exited");
psync_free(psync_current_mountpoint);
free(psync_current_mountpoint);
started = 0;
pthread_cond_broadcast(&start_cond);
pthread_mutex_unlock(&start_mutex);
@ -3699,7 +3699,7 @@ static int psync_fs_do_start() {
err1:
fuse_unmount(mp, psync_fuse_channel);
err0:
psync_free(mp);
free(mp);
err00:
pthread_mutex_unlock(&start_mutex);
fuse_opt_free_args(&args);

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

22
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;
}
@ -88,9 +88,9 @@ static psync_fspath_t *ret_folder_data(psync_fsfolderid_t folderid,
encname = pcryptofolder_fldencode_filename(enc, name);
pcryptofolder_fldencoder_release(folderid, enc);
len = strlen(encname);
ret = (psync_fspath_t *)psync_malloc(sizeof(psync_fspath_t) + len + 1);
ret = (psync_fspath_t *)malloc(sizeof(psync_fspath_t) + len + 1);
memcpy(ret + 1, encname, len + 1);
psync_free(encname);
free(encname);
ret->folderid = folderid;
ret->name = (char *)(ret + 1);
ret->shareid = shareid;
@ -119,7 +119,7 @@ char *get_decname_for_folder(psync_fsfolderid_t folderid, const char *path,
name = psync_strndup(path, len);
decname = pcryptofolder_flddecode_filename(dec, name);
pcryptofolder_flddecoder_release(folderid, dec);
psync_free(name);
free(name);
return decname;
}
@ -218,7 +218,7 @@ psync_fspath_t *psync_fsfolder_resolve_path(const char *path) {
char *name = psync_strndup(ename, elen);
if ((mk = psync_fstask_find_mkdir(folder, name, 0))) {
if (mk->flags & PSYNC_FOLDER_FLAG_INVISIBLE) {
psync_free(name);
free(name);
break;
}
cfolderid = mk->folderid;
@ -232,7 +232,7 @@ psync_fspath_t *psync_fsfolder_resolve_path(const char *path) {
check_userid(row[3], row[0], &shareid);
} else
hasit = 0;
psync_free(name);
free(name);
} else {
if (row) {
cfolderid = row[0];
@ -244,7 +244,7 @@ psync_fspath_t *psync_fsfolder_resolve_path(const char *path) {
hasit = 0;
}
if (ename != path)
psync_free(ename);
free(ename);
if (!hasit)
break;
path += len;
@ -320,7 +320,7 @@ psync_fsfolderid_t psync_fsfolderid_by_path(const char *path,
hasit = 1;
} else
hasit = 0;
psync_free(name);
free(name);
} else {
if (row) {
cfolderid = row[0];
@ -330,7 +330,7 @@ psync_fsfolderid_t psync_fsfolderid_by_path(const char *path,
hasit = 0;
}
if (ename != path)
psync_free(ename);
free(ename);
if (!hasit)
break;
path += len;
@ -407,7 +407,7 @@ psync_fsfolderid_t psync_fsfolderidperm_by_path(const char *path,
hasit = 1;
} else
hasit = 0;
psync_free(name);
free(name);
} else {
if (row) {
cfolderid = row[0];
@ -418,7 +418,7 @@ psync_fsfolderid_t psync_fsfolderidperm_by_path(const char *path,
hasit = 0;
}
if (ename != path)
psync_free(ename);
free(ename);
if (!hasit)
break;
path += len;

134
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);
}
}
@ -451,7 +451,7 @@ int psync_fstask_mkdir(psync_fsfolderid_t folderid, const char *name,
return -EIO;
}
len++;
task = (psync_fstask_mkdir_t *)psync_malloc(
task = (psync_fstask_mkdir_t *)malloc(
offsetof(psync_fstask_mkdir_t, name) + len);
task->taskid = taskid;
task->ctime = task->mtime = ctime;
@ -627,7 +627,7 @@ int psync_fstask_rmdir(psync_fsfolderid_t folderid, uint32_t parentflags,
}
if (mk) {
ptree_del(&folder->mkdirs, &mk->tree);
psync_free(mk);
free(mk);
}
if (cfolder)
psync_fstask_release_folder_tasks_locked(cfolder);
@ -655,7 +655,7 @@ int psync_fstask_rmdir(psync_fsfolderid_t folderid, uint32_t parentflags,
return -EIO;
}
len++;
task = (psync_fstask_rmdir_t *)psync_malloc(
task = (psync_fstask_rmdir_t *)malloc(
offsetof(psync_fstask_rmdir_t, name) + len);
task->taskid = taskid;
task->folderid = cfolderid;
@ -702,14 +702,14 @@ psync_fstask_creat_t *psync_fstask_add_creat(psync_fstask_folder_t *folder,
if (unlikely_log(psync_sql_commit_transaction()))
return NULL;
len++;
un = (psync_fstask_unlink_t *)psync_malloc(
un = (psync_fstask_unlink_t *)malloc(
offsetof(psync_fstask_unlink_t, name) + len);
un->fileid = -(psync_fsfileid_t)taskid;
un->taskid = taskid;
memcpy(un->name, name, len);
psync_fstask_insert_into_tree(
&folder->unlinks, offsetof(psync_fstask_unlink_t, name), &un->tree);
task = (psync_fstask_creat_t *)psync_malloc(
task = (psync_fstask_creat_t *)malloc(
offsetof(psync_fstask_creat_t, name) + len);
task->fileid = -(psync_fsfileid_t)taskid;
task->rfileid = fileid;
@ -771,20 +771,20 @@ psync_fstask_add_modified_file(psync_fstask_folder_t *folder, const char *name,
if (task) {
psync_fstask_depend(taskid, task->taskid);
ptree_del(&folder->creats, &task->tree);
psync_free(task);
free(task);
folder->taskscnt--;
}
if (unlikely_log(psync_sql_commit_transaction()))
return NULL;
len++;
un = (psync_fstask_unlink_t *)psync_malloc(
un = (psync_fstask_unlink_t *)malloc(
offsetof(psync_fstask_unlink_t, name) + len);
un->fileid = fileid;
un->taskid = taskid;
memcpy(un->name, name, len);
psync_fstask_insert_into_tree(
&folder->unlinks, offsetof(psync_fstask_unlink_t, name), &un->tree);
task = (psync_fstask_creat_t *)psync_malloc(
task = (psync_fstask_creat_t *)malloc(
offsetof(psync_fstask_creat_t, name) + len);
task->fileid = -(psync_fsfileid_t)taskid;
task->rfileid = fileid;
@ -866,7 +866,7 @@ int psync_fstask_add_local_creat_static(psync_fsfolderid_t folderid,
debug(D_NOTICE, "adding file %s to folderid %ld, datalen %lu", name,
(long)folderid, (unsigned long)datalen);
len++;
un = (psync_fstask_unlink_t *)psync_malloc(
un = (psync_fstask_unlink_t *)malloc(
offsetof(psync_fstask_unlink_t, name) + len);
un->taskid = psync_local_taskid;
un->fileid = 0;
@ -874,7 +874,7 @@ int psync_fstask_add_local_creat_static(psync_fsfolderid_t folderid,
psync_fstask_insert_into_tree(
&folder->unlinks, offsetof(psync_fstask_unlink_t, name), &un->tree);
addlen = psync_fstask_creat_local_offset(len - 1);
cr = (psync_fstask_creat_t *)psync_malloc(addlen +
cr = (psync_fstask_creat_t *)malloc(addlen +
sizeof(psync_fstask_local_creat_t));
cr->fileid = 0;
cr->rfileid = 0;
@ -913,12 +913,12 @@ static psync_fsfileid_t get_file_at_old_location(psync_fsfileid_t fileid) {
if (folder) {
cr = psync_fstask_find_creat(folder, rec->name, 0);
if (cr) {
psync_free(rec);
free(rec);
psync_fstask_release_folder_tasks_locked(folder);
return cr->fileid;
}
if (psync_fstask_find_unlink(folder, rec->name, 0)) {
psync_free(rec);
free(rec);
psync_fstask_release_folder_tasks_locked(folder);
return 0;
}
@ -933,7 +933,7 @@ static psync_fsfileid_t get_file_at_old_location(psync_fsfileid_t fileid) {
else
ret = 0;
psync_sql_free_result(res);
psync_free(rec);
free(rec);
return ret;
}
@ -1018,10 +1018,10 @@ int psync_fstask_unlink(psync_fsfolderid_t folderid, const char *name) {
if (likely_log(task)) {
ptree_del(&folder->unlinks, &task->tree);
folder->taskscnt--;
psync_free(task);
free(task);
}
ptree_del(&folder->creats, &cr->tree);
psync_free(cr);
free(cr);
folder->taskscnt--;
psync_fstask_release_folder_tasks_locked(folder);
return 0;
@ -1029,7 +1029,7 @@ int psync_fstask_unlink(psync_fsfolderid_t folderid, const char *name) {
depend = cr->taskid;
fileid = cr->fileid;
ptree_del(&folder->creats, &cr->tree);
psync_free(cr);
free(cr);
folder->taskscnt--;
if (folder->folderid >= 0)
ppathstatus_drive_fldr_changed(folder->folderid);
@ -1073,7 +1073,7 @@ int psync_fstask_unlink(psync_fsfolderid_t folderid, const char *name) {
return -EIO;
}
len++;
task = (psync_fstask_unlink_t *)psync_malloc(
task = (psync_fstask_unlink_t *)malloc(
offsetof(psync_fstask_unlink_t, name) + len);
task->taskid = taskid;
task->fileid = fileid;
@ -1094,13 +1094,13 @@ static void add_history_record(psync_fileid_t fileid, psync_folderid_t folderid,
char key[16];
psync_get_string_id(key, "HLOC", fileid);
while ((rec = (file_history_record *)pcache_get(key)))
psync_free(rec);
free(rec);
len = strlen(name) + 1;
rec = (file_history_record *)psync_malloc(
rec = (file_history_record *)malloc(
offsetof(file_history_record, name) + len);
rec->folderid = folderid;
memcpy(rec->name, name, len);
pcache_add(key, rec, PSYNC_FS_FILE_LOC_HIST_SEC, psync_free, 1);
pcache_add(key, rec, PSYNC_FS_FILE_LOC_HIST_SEC, free, 1);
}
int psync_fstask_rename_file(psync_fsfileid_t fileid,
@ -1169,14 +1169,14 @@ int psync_fstask_rename_file(psync_fsfileid_t fileid,
}
if (cr) {
ptree_del(&folder->creats, &cr->tree);
psync_free(cr);
free(cr);
folder->taskscnt--;
if (folder->folderid >= 0)
ppathstatus_drive_fldr_changed(folder->folderid);
}
psync_fs_rename_openfile_locked(fileid, to_folderid, new_name);
nlen++;
rm = (psync_fstask_unlink_t *)psync_malloc(
rm = (psync_fstask_unlink_t *)malloc(
offsetof(psync_fstask_unlink_t, name) + nlen);
rm->taskid = ftaskid;
rm->fileid = fileid;
@ -1195,17 +1195,17 @@ int psync_fstask_rename_file(psync_fsfileid_t fileid,
if (cr->fileid < 0)
psync_fstask_stop_and_delete_file(cr->fileid);
ptree_del(&folder->creats, &cr->tree);
psync_free(cr);
free(cr);
folder->taskscnt--;
}
rm = (psync_fstask_unlink_t *)psync_malloc(
rm = (psync_fstask_unlink_t *)malloc(
offsetof(psync_fstask_unlink_t, name) + nnlen);
rm->fileid = fileid;
rm->taskid = ttaskid;
memcpy(rm->name, new_name, nnlen);
psync_fstask_insert_into_tree(
&folder->unlinks, offsetof(psync_fstask_unlink_t, name), &rm->tree);
cr = (psync_fstask_creat_t *)psync_malloc(
cr = (psync_fstask_creat_t *)malloc(
offsetof(psync_fstask_creat_t, name) + nnlen);
cr->fileid = fileid;
cr->rfileid = rfileid;
@ -1394,12 +1394,12 @@ int psync_fstask_rename_folder(psync_fsfolderid_t folderid,
if (mk) {
ptree_del(&folder->mkdirs, &mk->tree);
psync_free(mk);
free(mk);
folder->taskscnt--;
}
nlen++;
rm = (psync_fstask_rmdir_t *)psync_malloc(
rm = (psync_fstask_rmdir_t *)malloc(
offsetof(psync_fstask_rmdir_t, name) + nlen);
rm->taskid = ftaskid;
rm->folderid = folderid;
@ -1416,12 +1416,12 @@ int psync_fstask_rename_folder(psync_fsfolderid_t folderid,
if (mk) {
debug(D_NOTICE, "renaming over mkdir %s", name);
ptree_del(&folder->mkdirs, &mk->tree);
psync_free(mk);
free(mk);
folder->taskscnt--;
}
nnlen++;
rm = (psync_fstask_rmdir_t *)psync_malloc(
rm = (psync_fstask_rmdir_t *)malloc(
offsetof(psync_fstask_rmdir_t, name) + nnlen);
rm->taskid = ttaskid;
rm->folderid = folderid;
@ -1429,7 +1429,7 @@ int psync_fstask_rename_folder(psync_fsfolderid_t folderid,
psync_fstask_insert_into_tree(
&folder->rmdirs, offsetof(psync_fstask_rmdir_t, name), &rm->tree);
mk = (psync_fstask_mkdir_t *)psync_malloc(
mk = (psync_fstask_mkdir_t *)malloc(
offsetof(psync_fstask_mkdir_t, name) + nnlen);
mk->taskid = ttaskid;
mk->folderid = folderid;
@ -1473,7 +1473,7 @@ void psync_fstask_folder_created(psync_folderid_t parentfolderid,
mk = psync_fstask_find_mkdir(folder, name, taskid);
if (mk) {
ptree_del(&folder->mkdirs, &mk->tree);
psync_free(mk);
free(mk);
folder->taskscnt--;
pchg = 1;
}
@ -1531,7 +1531,7 @@ void psync_fstask_folder_deleted(psync_folderid_t parentfolderid,
rm = psync_fstask_find_rmdir(folder, name, taskid);
if (rm) {
ptree_del(&folder->rmdirs, &rm->tree);
psync_free(rm);
free(rm);
folder->taskscnt--;
}
psync_fstask_release_folder_tasks_locked(folder);
@ -1584,13 +1584,13 @@ void psync_fstask_file_created(psync_folderid_t parentfolderid, uint64_t taskid,
cr = psync_fstask_find_creat(folder, name, taskid);
if (cr) {
ptree_del(&folder->creats, &cr->tree);
psync_free(cr);
free(cr);
folder->taskscnt--;
}
un = psync_fstask_find_unlink(folder, name, taskid);
if (un) {
ptree_del(&folder->unlinks, &un->tree);
psync_free(un);
free(un);
folder->taskscnt--;
} else
debug(D_NOTICE, "could not find unlink for file %s in folderid %lu", name,
@ -1616,13 +1616,13 @@ void psync_fstask_file_modified(psync_folderid_t parentfolderid,
cr = psync_fstask_find_creat(folder, name, taskid);
if (cr) {
ptree_del(&folder->creats, &cr->tree);
psync_free(cr);
free(cr);
folder->taskscnt--;
}
un = psync_fstask_find_unlink(folder, name, taskid);
if (un) {
ptree_del(&folder->unlinks, &un->tree);
psync_free(un);
free(un);
folder->taskscnt--;
}
psync_fstask_release_folder_tasks_locked(folder);
@ -1642,7 +1642,7 @@ void psync_fstask_file_deleted(psync_folderid_t parentfolderid, uint64_t taskid,
un = psync_fstask_find_unlink(folder, name, taskid);
if (un) {
ptree_del(&folder->unlinks, &un->tree);
psync_free(un);
free(un);
folder->taskscnt--;
}
psync_fstask_release_folder_tasks_locked(folder);
@ -1661,13 +1661,13 @@ void psync_fstask_file_renamed(psync_folderid_t folderid, uint64_t taskid,
un = psync_fstask_find_unlink(folder, name, taskid);
if (un) {
ptree_del(&folder->unlinks, &un->tree);
psync_free(un);
free(un);
folder->taskscnt--;
}
cr = psync_fstask_find_creat(folder, name, taskid);
if (cr) {
ptree_del(&folder->creats, &cr->tree);
psync_free(cr);
free(cr);
folder->taskscnt--;
}
psync_fstask_release_folder_tasks_locked(folder);
@ -1683,7 +1683,7 @@ void psync_fstask_file_renamed(psync_folderid_t folderid, uint64_t taskid,
psync_get_number(row[0]));
if (un) {
ptree_del(&folder->unlinks, &un->tree);
psync_free(un);
free(un);
folder->taskscnt--;
}
psync_fstask_release_folder_tasks_locked(folder);
@ -1714,13 +1714,13 @@ void psync_fstask_folder_renamed(psync_folderid_t parentfolderid,
mk = psync_fstask_find_mkdir(folder, name, taskid);
if (mk) {
ptree_del(&folder->mkdirs, &mk->tree);
psync_free(mk);
free(mk);
folder->taskscnt--;
}
rm = psync_fstask_find_rmdir(folder, name, taskid);
if (rm) {
ptree_del(&folder->rmdirs, &rm->tree);
psync_free(rm);
free(rm);
folder->taskscnt--;
}
psync_fstask_release_folder_tasks_locked(folder);
@ -1736,7 +1736,7 @@ void psync_fstask_folder_renamed(psync_folderid_t parentfolderid,
psync_get_number(row[0]));
if (rm) {
ptree_del(&folder->rmdirs, &rm->tree);
psync_free(rm);
free(rm);
folder->taskscnt--;
}
psync_fstask_release_folder_tasks_locked(folder);
@ -1768,7 +1768,7 @@ static void psync_init_task_mkdir(psync_variant_row row) {
ctime = psync_get_number(row[6]);
folder = psync_fstask_get_or_create_folder_tasks_locked(folderid);
len++;
task = (psync_fstask_mkdir_t *)psync_malloc(
task = (psync_fstask_mkdir_t *)malloc(
offsetof(psync_fstask_mkdir_t, name) + len);
task->taskid = taskid;
task->ctime = task->mtime = ctime;
@ -1800,11 +1800,11 @@ static void psync_init_task_rmdir(psync_variant_row row) {
mk = psync_fstask_find_mkdir(folder, name, 0);
if (mk) {
ptree_del(&folder->mkdirs, &mk->tree);
psync_free(mk);
free(mk);
folder->taskscnt--;
}
len++;
task = (psync_fstask_rmdir_t *)psync_malloc(
task = (psync_fstask_rmdir_t *)malloc(
offsetof(psync_fstask_rmdir_t, name) + len);
task->taskid = taskid;
task->folderid = cfolderid;
@ -1828,14 +1828,14 @@ static void psync_init_task_creat(psync_variant_row row) {
name = psync_get_lstring(row[4], &len);
folder = psync_fstask_get_or_create_folder_tasks_locked(folderid);
len++;
un = (psync_fstask_unlink_t *)psync_malloc(
un = (psync_fstask_unlink_t *)malloc(
offsetof(psync_fstask_unlink_t, name) + len);
un->fileid = -(psync_fsfileid_t)taskid;
un->taskid = taskid;
memcpy(un->name, name, len);
psync_fstask_insert_into_tree(
&folder->unlinks, offsetof(psync_fstask_unlink_t, name), &un->tree);
task = (psync_fstask_creat_t *)psync_malloc(
task = (psync_fstask_creat_t *)malloc(
offsetof(psync_fstask_creat_t, name) + len);
task->fileid = -(psync_fsfileid_t)taskid;
task->rfileid = psync_get_number(row[3]);
@ -1860,11 +1860,11 @@ static void psync_init_do_task_unlink(uint64_t taskid,
cr = psync_fstask_find_creat(folder, name, 0);
if (cr) {
ptree_del(&folder->creats, &cr->tree);
psync_free(cr);
free(cr);
folder->taskscnt--;
}
namelen++;
task = (psync_fstask_unlink_t *)psync_malloc(
task = (psync_fstask_unlink_t *)malloc(
offsetof(psync_fstask_unlink_t, name) + namelen);
task->taskid = taskid;
task->fileid = fileid;
@ -1902,11 +1902,11 @@ static void psync_init_task_renfile_from(psync_variant_row row) {
psync_fstask_get_or_create_folder_tasks_locked(psync_get_number(row[2]));
if ((cr = psync_fstask_find_creat(folder, name, 0))) {
ptree_del(&folder->creats, &cr->tree);
psync_free(cr);
free(cr);
folder->taskscnt--;
}
len++;
rm = (psync_fstask_unlink_t *)psync_malloc(
rm = (psync_fstask_unlink_t *)malloc(
offsetof(psync_fstask_unlink_t, name) + len);
rm->taskid = psync_get_number(row[0]);
rm->fileid = psync_get_snumber(row[3]);
@ -1933,19 +1933,19 @@ static void psync_init_task_renfile_to(psync_variant_row row) {
if (cr) {
ptree_del(&folder->creats, &cr->tree);
folder->taskscnt--;
psync_free(cr);
free(cr);
}
len++;
taskid = psync_get_number(row[0]);
fileid = psync_get_snumber(row[3]);
un = (psync_fstask_unlink_t *)psync_malloc(
un = (psync_fstask_unlink_t *)malloc(
offsetof(psync_fstask_unlink_t, name) + len);
un->fileid = fileid;
un->taskid = taskid;
memcpy(un->name, name, len);
psync_fstask_insert_into_tree(
&folder->unlinks, offsetof(psync_fstask_creat_t, name), &un->tree);
cr = (psync_fstask_creat_t *)psync_malloc(
cr = (psync_fstask_creat_t *)malloc(
offsetof(psync_fstask_creat_t, name) + len);
cr->fileid = fileid;
cr->rfileid = psync_get_number(row[7]);
@ -1971,11 +1971,11 @@ static void psync_init_task_renfolder_from(psync_variant_row row) {
psync_fstask_get_or_create_folder_tasks_locked(psync_get_number(row[2]));
if ((mk = psync_fstask_find_mkdir(folder, name, 0))) {
ptree_del(&folder->mkdirs, &mk->tree);
psync_free(mk);
free(mk);
folder->taskscnt--;
}
len++;
rm = (psync_fstask_rmdir_t *)psync_malloc(
rm = (psync_fstask_rmdir_t *)malloc(
offsetof(psync_fstask_rmdir_t, name) + len);
rm->taskid = psync_get_number(row[0]);
rm->folderid = psync_get_snumber(row[8]);
@ -2000,14 +2000,14 @@ static void psync_init_task_renfolder_to(psync_variant_row row) {
len++;
taskid = psync_get_number(row[0]);
folderid = psync_get_snumber(row[8]);
rm = (psync_fstask_rmdir_t *)psync_malloc(
rm = (psync_fstask_rmdir_t *)malloc(
offsetof(psync_fstask_rmdir_t, name) + len);
rm->taskid = taskid;
rm->folderid = folderid;
memcpy(rm->name, name, len);
psync_fstask_insert_into_tree(
&folder->rmdirs, offsetof(psync_fstask_rmdir_t, name), &rm->tree);
mk = (psync_fstask_mkdir_t *)psync_malloc(
mk = (psync_fstask_mkdir_t *)malloc(
offsetof(psync_fstask_mkdir_t, name) + len);
mk->taskid = taskid;
mk->folderid = folderid;
@ -2036,18 +2036,18 @@ static void psync_init_task_modify(psync_variant_row row) {
cr = psync_fstask_find_creat(folder, name, 0);
if (cr) {
ptree_del(&folder->creats, &cr->tree);
psync_free(cr);
free(cr);
folder->taskscnt--;
}
len++;
un = (psync_fstask_unlink_t *)psync_malloc(
un = (psync_fstask_unlink_t *)malloc(
offsetof(psync_fstask_unlink_t, name) + len);
un->fileid = psync_get_snumber(row[3]);
un->taskid = taskid;
memcpy(un->name, name, len);
psync_fstask_insert_into_tree(
&folder->unlinks, offsetof(psync_fstask_unlink_t, name), &un->tree);
cr = (psync_fstask_creat_t *)psync_malloc(
cr = (psync_fstask_creat_t *)malloc(
offsetof(psync_fstask_creat_t, name) + len);
cr->fileid = -(psync_fsfileid_t)cr->taskid;
cr->rfileid = psync_get_number(row[3]);
@ -2081,7 +2081,7 @@ static void psync_fstask_free_tree(psync_tree *tr) {
tr = ptree_get_first_safe(tr);
while (tr) {
ntr = ptree_get_next_safe(tr);
psync_free(tr);
free(tr);
tr = ntr;
}
}
@ -2100,7 +2100,7 @@ void psync_fstask_clean() {
psync_fstask_free_tree(folder->rmdirs);
if (folder->refcnt == 0) {
ptree_del(&folders, &folder->tree);
psync_free(folder);
free(folder);
} else {
folder->creats = PSYNC_TREE_EMPTY;
folder->unlinks = PSYNC_TREE_EMPTY;
@ -2119,7 +2119,7 @@ void psync_fstask_add_banned_folder(psync_fsfolderid_t folderid,
psync_fstask_rmdir_t *rm;
size_t len;
len = strlen(name) + 1;
mk = (psync_fstask_mkdir_t *)psync_malloc(
mk = (psync_fstask_mkdir_t *)malloc(
offsetof(psync_fstask_mkdir_t, name) + len);
mk->taskid = 0;
mk->ctime = mk->mtime = 0;
@ -2127,7 +2127,7 @@ void psync_fstask_add_banned_folder(psync_fsfolderid_t folderid,
mk->subdircnt = 0;
mk->flags = PSYNC_FOLDER_FLAG_INVISIBLE;
memcpy(mk->name, name, len);
rm = (psync_fstask_rmdir_t *)psync_malloc(
rm = (psync_fstask_rmdir_t *)malloc(
offsetof(psync_fstask_rmdir_t, name) + len);
rm->taskid = 0;
rm->folderid = 0;

92
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);
@ -796,7 +796,7 @@ static int large_upload_creat(uint64_t taskid, psync_folderid_t folderid,
}
if (large_upload_creat_send_write(api, uploadid, usize, fsize - usize))
goto err1;
buff = psync_malloc(PSYNC_COPY_BUFFER_SIZE);
buff = malloc(PSYNC_COPY_BUFFER_SIZE);
if (usize) {
asize = usize;
pupload_bytes_add(asize);
@ -820,13 +820,13 @@ static int large_upload_creat(uint64_t taskid, psync_folderid_t folderid,
asize += rrd;
pupload_bytes_add(rrd);
}
psync_free(buff);
free(buff);
pfile_close(fd);
res = papi_result(api);
if (unlikely_log(!res))
goto err0;
result = papi_find_result2(res, "result", PARAM_NUM)->num;
psync_free(res);
free(res);
if (result) {
debug(D_WARNING, "upload_write returned error %lu", (long unsigned)result);
psync_process_api_error(result);
@ -870,7 +870,7 @@ ret0:
pupload_bytes_sub(asize);
return 0;
err2:
psync_free(buff);
free(buff);
err1:
pfile_close(fd);
err0:
@ -924,7 +924,7 @@ static int upload_modify_send_local(psock_t *api,
return PSYNC_NET_TEMPFAIL;
bw = 0;
buff = psync_malloc(PSYNC_COPY_BUFFER_SIZE);
buff = malloc(PSYNC_COPY_BUFFER_SIZE);
while (bw < length) {
if (unlikely(stop_current_upload)) {
debug(D_NOTICE, "got stop");
@ -948,13 +948,13 @@ static int upload_modify_send_local(psock_t *api,
*upl += rrd;
pupload_bytes_add(rrd);
}
psync_free(buff);
free(buff);
return PSYNC_NET_OK;
err0:
psync_free(buff);
free(buff);
return PSYNC_NET_TEMPFAIL;
errp:
psync_free(buff);
free(buff);
return PSYNC_NET_PERMFAIL;
}
@ -965,7 +965,7 @@ static int upload_modify_read_req(psock_t *api) {
if (!res)
return PSYNC_NET_TEMPFAIL;
result = papi_find_result2(res, "result", PARAM_NUM)->num;
psync_free(res);
free(res);
if (result) {
debug(D_WARNING, "got %lu from upload_writefromfile or upload_write",
(unsigned long)result);
@ -1022,7 +1022,7 @@ int upload_modify(uint64_t taskid, psync_folderid_t folderid, const char *name,
goto err2;
result = papi_find_result2(res, "result", PARAM_NUM)->num;
if (unlikely(result)) {
psync_free(res);
free(res);
psync_apipool_release(api);
psync_interval_tree_free(tree);
debug(D_WARNING, "upload_create returned %lu", (unsigned long)result);
@ -1033,7 +1033,7 @@ int upload_modify(uint64_t taskid, psync_folderid_t folderid, const char *name,
return 0;
}
uploadid = papi_find_result2(res, "uploadid", PARAM_NUM)->num;
psync_free(res);
free(res);
sql = psync_sql_prep_statement(
"INSERT INTO fstaskupload (fstaskid, uploadid) VALUES (?, ?)");
psync_sql_bind_uint(sql, 1, taskid);
@ -1229,10 +1229,10 @@ static void large_upload() {
psync_fsupload_wake();
psys_sleep_milliseconds(PSYNC_SLEEP_ON_FAILED_UPLOAD);
}
psync_free(indexname);
psync_free(filename);
psync_free(name);
psync_free(key);
free(indexname);
free(filename);
free(name);
free(key);
}
debug(D_NOTICE, "exited");
}
@ -1280,7 +1280,7 @@ int psync_fsupload_in_current_small_uploads_batch_locked(uint64_t taskid) {
stret = stat(filename, &st);
if (stret)
debug(D_WARNING, "can not stat %s", filename);
psync_free(filename);
free(filename);
if (stret)
return 1;
if (pfile_stat_size(&st) > PSYNC_FS_DIRECT_UPLOAD_LIMIT)
@ -1305,7 +1305,7 @@ static int psync_send_task_creat(psock_t *api, fsupload_task_t *task) {
filename = psync_strcat(psync_setting_get_string(_PS(fscachepath)),
"/", fileidhex, NULL);
fd = pfile_open(filename, O_RDONLY, 0);
psync_free(filename);
free(filename);
if (unlikely_log(fd == INVALID_HANDLE_VALUE) ||
unlikely_log(fstat(fd, &st))) {
if (fd != INVALID_HANDLE_VALUE)
@ -1522,7 +1522,7 @@ int2, sfolderid FROM fstask WHERE id=?"); psync_sql_bind_uint(res, 1, id);
size+=row[4].length+1;
if (row[5].type==PSYNC_TSTRING)
size+=row[5].length+1;
task=(fsupload_task_t *)psync_malloc(size);
task=(fsupload_task_t *)malloc(size);
end=(char *)(task+1);
task->res=NULL;
task->id=psync_get_number(row[0]);
@ -1612,7 +1612,7 @@ static void change_folder_name(fsupload_task_t *task) {
psync_sql_run_free(res);
debug(D_NOTICE, "changed target name of task %lu from %s to %s",
(unsigned long)task->id, task->text1, nn);
psync_free(nn);
free(nn);
}
static int handle_rename_folder_api_error(uint64_t result,
@ -1687,13 +1687,13 @@ static void psync_delete_write_cache_file(uint64_t taskid, int index) {
filename =
psync_strcat(cachepath, "/", fileidhex, NULL);
assertw(pfile_delete(filename) == 0);
psync_free(filename);
free(filename);
if (index) {
fileidhex[sizeof(psync_fsfileid_t)] = 'i';
filename =
psync_strcat(cachepath, "/", fileidhex, NULL);
assertw(pfile_delete(filename) == 0);
psync_free(filename);
free(filename);
}
}
@ -1927,7 +1927,7 @@ static void psync_fsupload_process_tasks(psync_list *tasks) {
dels++;
}
}
psync_free(task->res);
free(task->res);
}
}
@ -2035,12 +2035,12 @@ static void clean_stuck_tasks() {
filename =
psync_strcat(cachepath, "/", fileidhex, NULL);
pfile_delete(filename);
psync_free(filename);
free(filename);
fileidhex[sizeof(psync_fsfileid_t)] = 'i';
filename =
psync_strcat(cachepath, "/", fileidhex, NULL);
pfile_delete(filename);
psync_free(filename);
free(filename);
psync_sql_start_transaction();
res = psync_sql_prep_statement(
"DELETE FROM fstaskdepend WHERE dependfstaskid=?");
@ -2051,7 +2051,7 @@ static void clean_stuck_tasks() {
psync_sql_run_free(res);
psync_sql_commit_transaction();
}
psync_free(fr);
free(fr);
}
static void psync_fsupload_check_tasks() {
@ -2087,7 +2087,7 @@ static void psync_fsupload_check_tasks() {
size += row[4].length + 1;
if (row[5].type == PSYNC_TSTRING)
size += row[5].length + 1;
task = (fsupload_task_t *)psync_malloc(size);
task = (fsupload_task_t *)malloc(size);
end = (char *)(task + 1);
task->res = NULL;
task->id = psync_get_number(row[0]);
@ -2122,7 +2122,7 @@ static void psync_fsupload_check_tasks() {
psync_sql_lock();
current_upload_batch = NULL;
psync_sql_unlock();
psync_list_for_each_element_call(&tasks, fsupload_task_t, list, psync_free);
psync_list_for_each_element_call(&tasks, fsupload_task_t, list, free);
}
static void psync_fsupload_thread() {

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;

77
pclsync/plibs.c
View File

@ -183,7 +183,7 @@ char *psync_strcat(const char *str, ...) {
size += len;
}
va_end(ap);
ptr2 = ptr3 = (char *)psync_malloc(size);
ptr2 = ptr3 = (char *)malloc(size);
for (size = 0; size < i; size++) {
memcpy(ptr2, strs[size], lengths[size]);
ptr2 += lengths[size];
@ -211,7 +211,7 @@ unsigned char *psync_base32_encode(const unsigned char *str, size_t length,
unsigned char *p;
uint32_t bits, buff;
result = (unsigned char *)psync_malloc(((length + 4) / 5) * 8 + 1);
result = (unsigned char *)malloc(((length + 4) / 5) * 8 + 1);
p = result;
bits = 0;
@ -247,7 +247,7 @@ unsigned char *psync_base32_decode(const unsigned char *str, size_t length,
unsigned char *result, *p;
uint32_t bits, buff;
unsigned char ch;
result = (unsigned char *)psync_malloc((length + 7) / 8 * 5 + 1);
result = (unsigned char *)malloc((length + 7) / 8 * 5 + 1);
p = result;
bits = 0;
buff = 0;
@ -259,7 +259,7 @@ unsigned char *psync_base32_decode(const unsigned char *str, size_t length,
else if (ch >= '2' && ch <= '7')
ch -= '2' - 26;
else {
psync_free(result);
free(result);
return NULL;
}
buff = (buff << 5) + ch;
@ -280,7 +280,7 @@ unsigned char *psync_base64_encode(const unsigned char *str, size_t length,
unsigned char *p;
unsigned char *result;
result = (unsigned char *)psync_malloc(((length + 2) / 3) * 4 + 1);
result = (unsigned char *)malloc(((length + 2) / 3) * 4 + 1);
p = result;
while (length > 2) {
@ -313,14 +313,14 @@ unsigned char *psync_base64_decode(const unsigned char *str, size_t length,
size_t i = 0, j = 0;
ssize_t ch;
result = (unsigned char *)psync_malloc((length + 3) / 4 * 3 + 1);
result = (unsigned char *)malloc((length + 3) / 4 * 3 + 1);
while (length-- > 0) {
ch = base64_reverse_table[*current++];
if (ch == -1)
continue;
else if (ch == -2) {
psync_free(result);
free(result);
return NULL;
}
switch (i % 4) {
@ -756,7 +756,7 @@ void psync_sql_rdunlock() {
debug(D_WARNING,
"held database read lock for %lu milliseconds taken at %s:%u", msec,
lock->file, lock->line);
psync_free(lock);
free(lock);
} else
plocks_unlock(&psync_db_lock);
#else
@ -788,7 +788,7 @@ int psync_sql_tryupgradelock() {
assert(sqllockcnt == 1);
sqllockstart = sqlrdlockstart;
record_wrlock(lock->file, lock->line);
psync_free(lock);
free(lock);
return 0;
}
#else
@ -869,7 +869,7 @@ static void run_commit_callbacks(int success) {
cb->commit_callback(cb->ptr);
else
cb->rollback_callback(cb->ptr);
psync_free(cb);
free(cb);
}
}
@ -927,7 +927,7 @@ static void psync_sql_do_check_query_plan(const char *sql) {
int code;
exsql = psync_strcat("EXPLAIN QUERY PLAN ", sql, NULL);
code = sqlite3_prepare_v2(psync_db, exsql, -1, &stmt, 0);
psync_free(exsql);
free(exsql);
if (code != SQLITE_OK) {
debug(D_ERROR, "EXPLAIN QUERY PLAN %s returned error: %d", sql, code);
return;
@ -1080,7 +1080,7 @@ char **psync_sql_rowstr(const char *sql) {
lens[i] = l;
}
ln += (sizeof(char *) + 1) * cnt;
arr = (char **)psync_malloc(ln);
arr = (char **)malloc(ln);
nstr = ((char *)arr) + sizeof(char *) * cnt;
for (i = 0; i < cnt; i++) {
str = (char *)sqlite3_column_blob(stmt, i);
@ -1142,7 +1142,7 @@ psync_variant *psync_sql_row(const char *sql) {
lens[i] = l;
}
}
arr = (psync_variant *)psync_malloc(ln);
arr = (psync_variant *)malloc(ln);
nstr = ((char *)arr) + sizeof(psync_variant) * cnt;
for (i = 0; i < cnt; i++) {
t = types[i];
@ -1212,7 +1212,7 @@ psync_sql_res *psync_sql_query_nocache(const char *sql) {
return NULL;
}
cnt = sqlite3_column_count(stmt);
res = (psync_sql_res *)psync_malloc(sizeof(psync_sql_res) +
res = (psync_sql_res *)malloc(sizeof(psync_sql_res) +
cnt * sizeof(psync_variant));
res->stmt = stmt;
res->sql = sql;
@ -1280,7 +1280,7 @@ psync_sql_res *psync_sql_query_rdlock_nocache(const char *sql) {
return NULL;
}
cnt = sqlite3_column_count(stmt);
res = (psync_sql_res *)psync_malloc(sizeof(psync_sql_res) +
res = (psync_sql_res *)malloc(sizeof(psync_sql_res) +
cnt * sizeof(psync_variant));
res->stmt = stmt;
res->sql = sql;
@ -1347,7 +1347,7 @@ psync_sql_res *psync_sql_query_nolock_nocache(const char *sql) {
return NULL;
}
cnt = sqlite3_column_count(stmt);
res = (psync_sql_res *)psync_malloc(sizeof(psync_sql_res) +
res = (psync_sql_res *)malloc(sizeof(psync_sql_res) +
cnt * sizeof(psync_variant));
res->stmt = stmt;
res->sql = sql;
@ -1395,7 +1395,7 @@ static void psync_sql_free_cache(void *ptr) {
#if IS_DEBUG
memset(res, 0xff, sizeof(psync_sql_res));
#endif
psync_free(res);
free(res);
}
static void psync_sql_res_unlock(psync_sql_res *res) {
@ -1435,7 +1435,7 @@ void psync_sql_free_result_nocache(psync_sql_res *res) {
#if IS_DEBUG
memset(res, 0xff, sizeof(psync_sql_res));
#endif
psync_free(res);
free(res);
}
#if IS_DEBUG
@ -1551,7 +1551,7 @@ int psync_sql_run_free_nocache(psync_sql_res *res) {
code = 0;
sqlite3_finalize(res->stmt);
psync_sql_res_unlock(res);
psync_free(res);
free(res);
return code;
}
@ -1569,7 +1569,7 @@ int psync_sql_run_free(psync_sql_res *res) {
debug(D_BUG, "transaction query failed, this may lead to restarting "
"transaction over and over");
psync_sql_res_unlock(res);
psync_free(res);
free(res);
return -1;
} else {
psync_sql_res_unlock(res);
@ -1698,7 +1698,7 @@ psync_full_result_int *psync_sql_fetchall_int(psync_sql_res *res) {
while ((code = sqlite3_step(res->stmt)) == SQLITE_ROW) {
if (rows >= all) {
all = 10 + all * 2;
data = (uint64_t *)psync_realloc(data, sizeof(uint64_t) * cols * all);
data = (uint64_t *)realloc(data, sizeof(uint64_t) * cols * all);
}
for (i = 0; i < cols; i++)
data[off + i] = sqlite3_column_int64(res->stmt, i);
@ -1708,12 +1708,12 @@ psync_full_result_int *psync_sql_fetchall_int(psync_sql_res *res) {
if (unlikely(code != SQLITE_DONE))
debug(D_ERROR, "sqlite3_step returned error: %s", sqlite3_errmsg(psync_db));
psync_sql_free_result(res);
ret = (psync_full_result_int *)psync_malloc(
ret = (psync_full_result_int *)malloc(
offsetof(psync_full_result_int, data) + sizeof(uint64_t) * off);
ret->rows = rows;
ret->cols = cols;
memcpy(ret->data, data, sizeof(uint64_t) * off);
psync_free(data);
free(data);
return ret;
}
@ -1732,7 +1732,7 @@ int psync_rename_conflicted_file(const char *path) {
dotidx--;
if (!dotidx)
dotidx = plen;
npath = (char *)psync_malloc(plen + 32);
npath = (char *)malloc(plen + 32);
memcpy(npath, path, dotidx);
num = 0;
while (1) {
@ -1746,7 +1746,7 @@ int psync_rename_conflicted_file(const char *path) {
if (stat(npath, &st)) {
debug(D_NOTICE, "renaming conflict %s to %s", path, npath);
l = pfile_rename(path, npath);
psync_free(npath);
free(npath);
return l;
}
num++;
@ -1766,7 +1766,7 @@ static void run_after_sec(psync_timer_t timer, void *ptr) {
struct run_after_ptr *fp = (struct run_after_ptr *)ptr;
ptimer_stop(timer);
fp->run(fp->ptr);
psync_free(fp);
free(fp);
}
void psync_run_after_sec(psync_run_after_t run, void *ptr, uint32_t seconds) {
@ -1779,7 +1779,7 @@ void psync_run_after_sec(psync_run_after_t run, void *ptr, uint32_t seconds) {
static void free_after_sec(psync_timer_t timer, void *ptr) {
ptimer_stop(timer);
psync_free(ptr);
free(ptr);
}
void psync_free_after_sec(void *ptr, uint32_t seconds) {
@ -1919,7 +1919,7 @@ void psync_list_bulder_add_sql(psync_list_builder_t *builder,
while ((row = psync_sql_fetch_row(res))) {
if (!builder->last_elements ||
builder->last_elements->used >= builder->elements_per_list) {
builder->last_elements = (psync_list_element_list *)psync_malloc(
builder->last_elements = (psync_list_element_list *)malloc(
offsetof(psync_list_element_list, elements) +
builder->element_size * builder->elements_per_list);
psync_list_add_tail(&builder->element_list,
@ -1946,7 +1946,7 @@ void psync_list_bulder_add_sql(psync_list_builder_t *builder,
void *psync_list_bulder_add_element(psync_list_builder_t *builder) {
if (!builder->last_elements ||
builder->last_elements->used >= builder->elements_per_list) {
builder->last_elements = (psync_list_element_list *)psync_malloc(
builder->last_elements = (psync_list_element_list *)malloc(
offsetof(psync_list_element_list, elements) +
builder->element_size * builder->elements_per_list);
psync_list_add_tail(&builder->element_list, &builder->last_elements->list);
@ -1970,13 +1970,13 @@ void psync_list_add_lstring_offset(psync_list_builder_t *builder, size_t offset,
str = (char **)(builder->current_element + offset);
builder->stringalloc += length;
if (unlikely(length > 2000)) {
l = (psync_list_string_list *)psync_malloc(sizeof(psync_list_string_list) +
l = (psync_list_string_list *)malloc(sizeof(psync_list_string_list) +
length);
s = (char *)(l + 1);
psync_list_add_tail(&builder->string_list, &l->list);
} else if (!builder->last_strings || builder->last_strings->next + length >
builder->last_strings->end) {
l = (psync_list_string_list *)psync_malloc(sizeof(psync_list_string_list) +
l = (psync_list_string_list *)malloc(sizeof(psync_list_string_list) +
4000);
s = (char *)(l + 1);
l->next = s + length;
@ -2041,13 +2041,10 @@ void *psync_list_builder_finalize(psync_list_builder_t *builder) {
}
}
psync_list_for_each_element_call(&builder->element_list,
psync_list_element_list, list, psync_free);
psync_list_for_each_element_call(&builder->string_list,
psync_list_string_list, list, psync_free);
psync_list_for_each_element_call(&builder->number_list, psync_list_num_list,
list, psync_free);
psync_free(builder);
psync_list_for_each_element_call(&builder->element_list, psync_list_element_list, list, free);
psync_list_for_each_element_call(&builder->string_list, psync_list_string_list, list, free);
psync_list_for_each_element_call(&builder->number_list, psync_list_num_list, list, free);
free(builder);
return ret;
}
@ -2081,7 +2078,7 @@ static void psync_task_destroy(psync_task_manager_t tm) {
for (i = 0; i < tm->taskcnt; i++)
pthread_cond_destroy(&tm->tasks[i].cond);
pthread_mutex_destroy(&tm->mutex);
psync_free(tm);
free(tm);
}
static void psync_task_dec_refcnt(psync_task_manager_t tm) {
@ -2111,7 +2108,7 @@ psync_task_run_tasks(psync_task_callback_t const *callbacks,
psync_task_manager_t ret;
struct psync_task_t_ *t;
int i;
ret = (psync_task_manager_t)psync_malloc(
ret = (psync_task_manager_t)malloc(
offsetof(struct psync_task_manager_t_, tasks) +
sizeof(struct psync_task_t_) * cnt);
pthread_mutex_init(&ret->mutex, NULL);

4
pclsync/plibs.h
View File

@ -219,8 +219,8 @@ extern "C" {
#define ARRAY_SIZE(arr) (sizeof(arr) / sizeof((arr)[0]))
#define psync_new(type) (type *)psync_malloc(sizeof(type))
#define psync_new_cnt(type, cnt) (type *)psync_malloc(sizeof(type) * (cnt))
#define psync_new(type) (type *)malloc(sizeof(type))
#define psync_new_cnt(type, cnt) (type *)malloc(sizeof(type) * (cnt))
#define psync_binhex(dst, src, cnt) \
do { \

20
pclsync/plocalnotify.c
View File

@ -97,7 +97,7 @@ static void add_dir_scan(localnotify_dir *dir, const char *path) {
namelen = 255;
if (namelen < sizeof(de->d_name) - 1)
namelen = sizeof(de->d_name) - 1;
wch = (localnotify_watch *)psync_malloc(offsetof(localnotify_watch, path) +
wch = (localnotify_watch *)malloc(offsetof(localnotify_watch, path) +
pl + 1 + namelen + 1);
wch->next = dir->watches[wid % WATCH_HASH];
dir->watches[wid % WATCH_HASH] = wch;
@ -107,8 +107,8 @@ static void add_dir_scan(localnotify_dir *dir, const char *path) {
memcpy(wch->path, path, pl + 1);
if (likely_log(dh = opendir(path))) {
entrylen = offsetof(struct dirent, d_name) + namelen + 1;
cpath = (char *)psync_malloc(pl + namelen + 2);
entry = (struct dirent *)psync_malloc(entrylen);
cpath = (char *)malloc(pl + namelen + 2);
entry = (struct dirent *)malloc(entrylen);
memcpy(cpath, path, pl);
if (!pl || cpath[pl - 1] != '/')
cpath[pl++] = '/';
@ -122,8 +122,8 @@ static void add_dir_scan(localnotify_dir *dir, const char *path) {
add_dir_scan(dir, cpath);
}
}
psync_free(entry);
psync_free(cpath);
free(entry);
free(cpath);
closedir(dh);
}
}
@ -141,7 +141,7 @@ static void add_syncid(psync_syncid_t syncid) {
str = psync_get_lstring(row[0], &len);
len++;
dir =
(localnotify_dir *)psync_malloc(offsetof(localnotify_dir, path) + len);
(localnotify_dir *)malloc(offsetof(localnotify_dir, path) + len);
memcpy(dir->path, str, len);
psync_sql_free_result(res);
} else {
@ -165,7 +165,7 @@ static void add_syncid(psync_syncid_t syncid) {
err2:
close(dir->inotifyfd);
err:
psync_free(dir);
free(dir);
}
static void del_syncid(psync_syncid_t syncid) {
@ -180,13 +180,13 @@ static void del_syncid(psync_syncid_t syncid) {
while (wch) {
next = wch->next;
inotify_rm_watch(dir->inotifyfd, wch->watchid);
psync_free(wch);
free(wch);
wch = next;
}
}
epoll_ctl(epoll_fd, EPOLL_CTL_DEL, dir->inotifyfd, NULL);
close(dir->inotifyfd);
psync_free(dir);
free(dir);
return;
}
}
@ -237,7 +237,7 @@ static uint32_t process_notification(localnotify_dir *dir) {
if (wch->watchid == ev.wd) {
*pwch = wch->next;
inotify_rm_watch(dir->inotifyfd, wch->watchid);
psync_free(wch);
free(wch);
break;
} else {
pwch = &wch->next;

60
pclsync/plocalscan.c
View File

@ -172,7 +172,7 @@ static void scanner_set_syncs_to_list(psync_list *lst,
debug(D_WARNING, "folder %s deviceid is different, ignoring", lp);
continue;
}
l = (sync_list *)psync_malloc(offsetof(sync_list, localpath) + lplen + 1);
l = (sync_list *)malloc(offsetof(sync_list, localpath) + lplen + 1);
l->folderid = psync_get_number(row[1]);
l->deviceid = deviceid;
l->syncid = psync_get_number(row[0]);
@ -180,7 +180,7 @@ static void scanner_set_syncs_to_list(psync_list *lst,
memcpy(l->localpath, lp, lplen + 1);
psync_list_add_tail(lst, &l->list);
l_full_deviceid =
(sync_list *)psync_malloc(offsetof(sync_list, localpath) + lplen + 1);
(sync_list *)malloc(offsetof(sync_list, localpath) + lplen + 1);
l_full_deviceid->folderid = psync_get_number(row[1]);
l_full_deviceid->deviceid = pfile_stat_device_full(&st);
l_full_deviceid->syncid = psync_get_number(row[0]);
@ -189,7 +189,7 @@ static void scanner_set_syncs_to_list(psync_list *lst,
psync_list_add_tail(lst_deviceid_full, &l_full_deviceid->list);
}
psync_sql_free_result(res);
psync_free(syncmp);
free(syncmp);
}
static void add_ignored_dir(const char *path) {
@ -202,7 +202,7 @@ static void add_ignored_dir(const char *path) {
ign_paths_alloc = 8;
else
ign_paths_alloc *= 2;
ignored_paths = (device_inode_t *)psync_realloc(
ignored_paths = (device_inode_t *)realloc(
ignored_paths, sizeof(device_inode_t) * ign_paths_alloc);
}
ignored_paths[ign_paths_cnt].deviceid = pfile_stat_device_full(&st);
@ -254,7 +254,7 @@ static void reload_ignored_folders() {
homelen = strlen(home);
}
if (home) {
dir = (char *)psync_malloc(dirlen + homelen - 4);
dir = (char *)malloc(dirlen + homelen - 4);
memcpy(dir, home, homelen);
memcpy(dir + homelen, start + 5, dirlen - 5);
dir[dirlen + homelen - 5] = 0;
@ -262,15 +262,15 @@ static void reload_ignored_folders() {
dir = NULL;
}
} else {
dir = (char *)psync_malloc(dirlen + 1);
dir = (char *)malloc(dirlen + 1);
memcpy(dir, start, dirlen);
dir[dirlen] = 0;
}
if (dir)
add_ignored_dir(dir);
psync_free(dir);
free(dir);
}
psync_free(home);
free(home);
}
static int is_path_to_ignore(uint64_t deviceid, uint64_t inode) {
@ -297,7 +297,7 @@ static void scanner_local_entry_to_list(void *ptr, ppath_stat *st) {
lst = (psync_list *)ptr;
l = strlen(st->name) + 1;
e = (sync_folderlist *)psync_malloc(offsetof(sync_folderlist, name) + l);
e = (sync_folderlist *)malloc(offsetof(sync_folderlist, name) + l);
e->localid = 0;
e->remoteid = 0;
e->inode = pfile_stat_inode(&st->stat);
@ -361,7 +361,7 @@ static void scanner_db_folder_to_list(psync_syncid_t syncid,
continue;
}
namelen++;
e = (sync_folderlist *)psync_malloc(offsetof(sync_folderlist, name) +
e = (sync_folderlist *)malloc(offsetof(sync_folderlist, name) +
namelen);
e->localid = psync_get_number(row[0]);
e->remoteid = psync_get_number_or_null(row[1]);
@ -390,7 +390,7 @@ static void scanner_db_folder_to_list(psync_syncid_t syncid,
continue;
}
namelen++;
e = (sync_folderlist *)psync_malloc(offsetof(sync_folderlist, name) +
e = (sync_folderlist *)malloc(offsetof(sync_folderlist, name) +
namelen);
e->localid = psync_get_number(row[0]);
e->remoteid = psync_get_number_or_null(row[1]);
@ -419,7 +419,7 @@ static sync_folderlist *copy_folderlist_element(const sync_folderlist *e,
sync_folderlist *ret;
size_t l;
l = offsetof(sync_folderlist, name) + strlen(e->name) + 1;
ret = (sync_folderlist *)psync_malloc(l);
ret = (sync_folderlist *)malloc(l);
memcpy(ret, e, l);
ret->localparentfolderid = localfolderid;
ret->parentfolderid = folderid;
@ -564,7 +564,7 @@ scanner_scan_folder(const char *localpath, psync_folderid_t folderid,
add_deleted_element(fdb, folderid, localfolderid, syncid, synctype);
ldb = ldb->next;
}
psync_list_for_each_element_call(&dblist, sync_folderlist, list, psync_free);
psync_list_for_each_element_call(&dblist, sync_folderlist, list, free);
if (localsleepperfolder) {
psys_sleep_milliseconds(localsleepperfolder);
if (psync_current_time - starttime >=
@ -577,11 +577,10 @@ scanner_scan_folder(const char *localpath, psync_folderid_t folderid,
subpath = psync_strcat(localpath, "/", l->name, NULL);
scanner_scan_folder(subpath, l->remoteid, l->localid, syncid, synctype,
deviceid);
psync_free(subpath);
free(subpath);
}
psync_list_for_each_element_call(&disklist, sync_folderlist, list,
psync_free);
psync_list_for_each_element_call(&disklist, sync_folderlist, list, free);
}
static int compare_sizeinodemtime(const psync_list *l1, const psync_list *l2) {
@ -814,7 +813,7 @@ static void scan_created_folder(sync_folderlist *fl) {
localpath, (unsigned long)fl->localid, fl->name);
scanner_scan_folder(localpath, 0, fl->localid, fl->syncid, fl->synctype,
fl->deviceid);
psync_free(localpath);
free(localpath);
}
}
@ -1043,9 +1042,8 @@ restart:
break;
}
}
psync_list_for_each_element_call(&slist, sync_list, list, psync_free);
psync_list_for_each_element_call(&slist_full_deviceid, sync_list, list,
psync_free);
psync_list_for_each_element_call(&slist, sync_list, list, free);
psync_list_for_each_element_call(&slist_full_deviceid, sync_list, list, free);
w = 0;
do {
@ -1053,8 +1051,7 @@ restart:
if (unlikely(restart_scan)) {
pthread_mutex_unlock(&scan_mutex);
for (i = 0; i < SCAN_LIST_CNT; i++)
psync_list_for_each_element_call(&scan_lists[i], sync_folderlist, list,
psync_free);
psync_list_for_each_element_call(&scan_lists[i], sync_folderlist, list, free);
psys_sleep_milliseconds(restartsleep);
if (restartsleep < 16000)
restartsleep *= 2;
@ -1080,11 +1077,9 @@ restart:
w++;
check_for_query_cnt();
}
psync_list_for_each_element_call(&scan_lists[SCAN_LIST_RENFOLDERSROM],
sync_folderlist, list, psync_free);
psync_list_for_each_element_call(&scan_lists[SCAN_LIST_RENFOLDERSROM], sync_folderlist, list, free);
psync_list_init(&scan_lists[SCAN_LIST_RENFOLDERSROM]);
psync_list_for_each_element_call(&scan_lists[SCAN_LIST_RENFOLDERSTO],
sync_folderlist, list, psync_free);
psync_list_for_each_element_call(&scan_lists[SCAN_LIST_RENFOLDERSTO], sync_folderlist, list, free);
psync_list_init(&scan_lists[SCAN_LIST_RENFOLDERSTO]);
psync_list_for_each_element(fl, &scan_lists[SCAN_LIST_NEWFOLDERS],
sync_folderlist, list) {
@ -1102,8 +1097,7 @@ restart:
}
psync_list_for_each_element_call(&newtmp, sync_folderlist, list,
scan_created_folder);
psync_list_for_each_element_call(&newtmp, sync_folderlist, list,
psync_free);
psync_list_for_each_element_call(&newtmp, sync_folderlist, list, free);
}
if (changes) {
i++;
@ -1115,8 +1109,7 @@ restart:
if (unlikely(restart_scan)) {
pthread_mutex_unlock(&scan_mutex);
for (i = 0; i < SCAN_LIST_CNT; i++)
psync_list_for_each_element_call(&scan_lists[i], sync_folderlist, list,
psync_free);
psync_list_for_each_element_call(&scan_lists[i], sync_folderlist, list, free);
psys_sleep_milliseconds(restartsleep);
if (restartsleep < 16000)
restartsleep *= 2;
@ -1172,8 +1165,7 @@ restart:
pstatus_upload_recalc_async();
}
for (i = 0; i < SCAN_LIST_CNT; i++)
psync_list_for_each_element_call(&scan_lists[i], sync_folderlist, list,
psync_free);
psync_list_for_each_element_call(&scan_lists[i], sync_folderlist, list, free);
if (movedfolders) {
starttime = psync_current_time;
restartsleep = 1000;
@ -1270,7 +1262,7 @@ void psync_restat_sync_folders_add(psync_syncid_t syncid,
sync_restat_list *l;
struct stat st;
size_t lplen = strlen(localpath);
l = (sync_restat_list *)psync_malloc(offsetof(sync_restat_list, localpath) +
l = (sync_restat_list *)malloc(offsetof(sync_restat_list, localpath) +
lplen + 1);
l->syncid = syncid;
memcpy(l->localpath, localpath, lplen + 1);
@ -1300,7 +1292,7 @@ void psync_restat_sync_folders_del(psync_syncid_t syncid) {
}
if (to_del) {
psync_list_del(&to_del->list);
psync_free(to_del);
free(to_del);
}
pthread_mutex_unlock(&restat_mutex);
}

408
pclsync/pmemlock.c
View File

@ -1,408 +0,0 @@
/*
Copyright (c) 2015 Anton Titov.
Copyright (c) 2015 pCloud Ltd. All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met: Redistributions of source code must retain the above
copyright notice, this list of conditions and the following
disclaimer. Redistributions in binary form must reproduce the
above copyright notice, this list of conditions and the following
disclaimer in the documentation and/or other materials provided
with the distribution. Neither the name of pCloud Ltd nor the
names of its contributors may be used to endorse or promote
products derived from this software without specific prior written
permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL pCloud
Ltd BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
DAMAGE.
*/
#include <mbedtls/ctr_drbg.h>
#include <mbedtls/debug.h>
#include <mbedtls/entropy.h>
#include <mbedtls/pkcs5.h>
#include <mbedtls/ssl.h>
#include <pthread.h>
#include "pcryptofolder.h"
#include "pintervaltree.h"
#include "plibs.h"
#include "pmem.h"
#include "pmemlock.h"
#include "ptree.h"
#include <stdint.h>
typedef uintptr_t pageid_t;
typedef struct {
psync_tree tree;
pageid_t pageid;
unsigned long refcnt;
} locked_page_t;
typedef struct {
psync_tree tree;
psync_interval_tree_t *freeintervals;
char *mem;
size_t size;
int locked;
} allocator_range;
static int psync_page_size;
static pthread_mutex_t page_mutex = PTHREAD_MUTEX_INITIALIZER;
static psync_tree *locked_pages = PSYNC_TREE_EMPTY;
static pthread_mutex_t allocator_mutex;
static psync_tree *allocator_ranges = PSYNC_TREE_EMPTY;
void pmemlock_init() {
pthread_mutexattr_t mattr;
pthread_mutexattr_init(&mattr);
pthread_mutexattr_settype(&mattr, PTHREAD_MUTEX_RECURSIVE);
pthread_mutex_init(&allocator_mutex, &mattr);
pthread_mutexattr_destroy(&mattr);
}
static int lock_page(pageid_t pageid, int page_size) {
psync_tree *tr, **addto;
locked_page_t *node;
int found, ret, tryn;
found = 0;
ret = 0;
tryn = 0;
retry:
pthread_mutex_lock(&page_mutex);
tr = locked_pages;
if (tr) {
while (1) {
node = ptree_element(tr, locked_page_t, tree);
if (pageid < node->pageid) {
if (tr->left)
tr = tr->left;
else {
addto = &tr->left;
break;
}
} else if (pageid > node->pageid) {
if (tr->right)
tr = tr->right;
else {
addto = &tr->right;
break;
}
} else {
found = 1;
break;
}
}
} else
addto = &locked_pages;
if (found) {
node->refcnt++;
debug(D_NOTICE, "page %lx is already locked, increasing refcnt to %u",
(unsigned long)pageid * page_size, (unsigned)node->refcnt);
} else {
// Well, we can move the locking out of mutex protected area, but to do
// properly, an status "in progress" should be introduced for new elements
// in the tree that mlock is yet not returned. This will complicate things a
// lot.
if (unlikely(pmem_mlock((void *)(pageid * page_size), page_size))) {
if (!tryn) {
tryn++;
pthread_mutex_unlock(&page_mutex);
debug(D_NOTICE, "mlock failed, trying to clean cache");
pcryptofolder_cache_clean();
goto retry;
} else {
debug(D_WARNING, "mlock for page %lx failed even after cache clean",
(unsigned long)pageid * page_size);
ret = -1;
}
} else {
debug(D_NOTICE, "locked page %lx", (unsigned long)pageid * page_size);
node = psync_new(locked_page_t);
node->pageid = pageid;
node->refcnt = 1;
*addto = &node->tree;
ptree_added_at(&locked_pages, tr, &node->tree);
}
}
pthread_mutex_unlock(&page_mutex);
return ret;
}
static int unlock_page(pageid_t pageid, int page_size) {
psync_tree *tr;
locked_page_t *node;
int ret;
pthread_mutex_lock(&page_mutex);
tr = locked_pages;
while (tr) {
node = ptree_element(tr, locked_page_t, tree);
if (pageid < node->pageid)
tr = tr->left;
else if (pageid > node->pageid)
tr = tr->right;
else
break;
}
if (likely(tr)) {
if (--node->refcnt) {
debug(D_NOTICE, "decreased refcnt of page %lx to %u",
(unsigned long)pageid * page_size, (unsigned)node->refcnt);
ret = 0;
} else {
ptree_del(&locked_pages, tr);
psync_free(node);
// do not move out of the mutex, will create race conditions
if (unlikely(pmem_munlock((void *)(pageid * page_size), page_size)))
ret = PRINT_RETURN(-1);
else {
debug(D_NOTICE, "unlocked page %lx", (unsigned long)pageid * page_size);
ret = 0;
}
}
} else {
ret = -1;
debug(D_WARNING, "unlocking page %lx that is not locked",
(unsigned long)pageid * page_size);
}
pthread_mutex_unlock(&page_mutex);
return ret;
}
int pmemlock_lock(void *ptr, size_t size) {
pageid_t frompage, topage, i;
int page_size;
page_size = pmemlock_get_pagesize();
if (page_size == -1)
return PRINT_RETURN(-1);
frompage = (uintptr_t)ptr / page_size;
topage = ((uintptr_t)ptr + size - 1) / page_size;
for (i = frompage; i <= topage; i++)
if (unlikely(lock_page(i, page_size))) {
while (i > frompage)
unlock_page(--i, page_size);
return PRINT_RETURN(-1);
}
return 0;
}
int pmemlock_unlock(void *ptr, size_t size) {
pageid_t frompage, topage, i;
int page_size, ret;
page_size = pmemlock_get_pagesize();
if (page_size == -1)
return PRINT_RETURN(-1);
frompage = (uintptr_t)ptr / page_size;
topage = ((uintptr_t)ptr + size - 1) / page_size;
ret = 0;
for (i = frompage; i <= topage; i++)
if (unlikely(unlock_page(i, page_size)))
ret = PRINT_RETURN(-1);
return ret;
}
#define LM_ALIGN_TO (sizeof(size_t) * 2)
#define LM_OVERHEAD (sizeof(size_t) * 2)
#define LM_RANGE_OVERHEAD (LM_ALIGN_TO - sizeof(size_t))
#define LM_END_MARKER (~((size_t)0))
#if IS_DEBUG
static void mark_aligment_bytes(char *ptr, size_t from, size_t to) {
size_t i;
for (i = from; i < to; i++)
((unsigned char *)ptr)[i] = ((size_t)0xff + from - i) & 0xff;
}
#endif
void *pmemlock_malloc(size_t size) {
return psync_malloc(size);
allocator_range *range, *brange;
psync_tree *tr, **addto;
psync_interval_tree_t *interval;
char *ret;
uint64_t boffset;
size_t intsize, bestsize;
#if IS_DEBUG
size_t origsize = size;
#endif
int page_size;
size = ((size + LM_ALIGN_TO - 1)) / LM_ALIGN_TO * LM_ALIGN_TO + LM_OVERHEAD;
#if IS_DEBUG
debug(D_NOTICE, "size=%lu, size with overhead=%lu", (unsigned long)origsize,
(unsigned long)size);
#endif
bestsize = ~((size_t)0);
brange = NULL;
boffset = 0; // just to make compilers happy
// psync_mem_lock may call pcryptofolder_cache_clean(), which in turn can
// call pmemlock_free() on few pointers, therefore allocator_mutex is
// recursive
pthread_mutex_lock(&allocator_mutex);
ptree_for_each_element(range, allocator_ranges, allocator_range, tree)
psync_interval_tree_for_each(interval, range->freeintervals) {
intsize = interval->to - interval->from;
if (intsize >= size && intsize < bestsize) {
bestsize = intsize;
brange = range;
boffset = interval->from;
if (intsize == size)
goto foundneededsize;
}
}
if (brange) {
foundneededsize:
if (unlikely(!brange->locked))
if (!pmemlock_lock(brange->mem, brange->size))
brange->locked = 1;
psync_interval_tree_remove(&brange->freeintervals, boffset, boffset + size);
ret = brange->mem + boffset;
#if IS_DEBUG
*((size_t *)ret) = origsize;
#else
*((size_t *)ret) = size;
#endif
*((size_t *)(ret + size - sizeof(size_t))) = LM_END_MARKER;
ret += sizeof(size_t);
#if IS_DEBUG
mark_aligment_bytes(ret, origsize, size - LM_OVERHEAD);
#endif
} else
ret = NULL;
pthread_mutex_unlock(&allocator_mutex);
if (ret)
return ret;
page_size = pmemlock_get_pagesize();
if (unlikely(page_size == -1))
page_size = 4096;
intsize = (size + LM_RANGE_OVERHEAD + page_size - 1) / page_size * page_size;
brange = psync_new(allocator_range);
brange->freeintervals = NULL;
brange->mem = pmem_mmap_safe(intsize);
brange->size = intsize;
debug(D_NOTICE, "allocating new locked block of size %lu at %p",
(unsigned long)intsize, brange->mem);
if (unlikely(pmemlock_lock(brange->mem, intsize))) {
brange->locked = 0;
debug(D_WARNING, "could not lock %lu bytes in memory",
(unsigned long)intsize);
} else
brange->locked = 1;
if (intsize > size + LM_RANGE_OVERHEAD)
psync_interval_tree_add(&brange->freeintervals, LM_RANGE_OVERHEAD + size,
intsize);
ret = brange->mem + LM_RANGE_OVERHEAD;
#if IS_DEBUG
*((size_t *)ret) = origsize;
#else
*((size_t *)ret) = size;
#endif
*((size_t *)(ret + size - sizeof(size_t))) = LM_END_MARKER;
ret += sizeof(size_t);
#if IS_DEBUG
mark_aligment_bytes(ret, origsize, size - LM_OVERHEAD);
#endif
pthread_mutex_lock(&allocator_mutex);
tr = allocator_ranges;
if (tr) {
while (1) {
range = ptree_element(tr, allocator_range, tree);
if (brange->mem < range->mem) {
assert(brange->mem + brange->size <= range->mem);
if (tr->left)
tr = tr->left;
else {
addto = &tr->left;
break;
}
} else {
assert(range->mem + range->size <= brange->mem);
if (tr->right)
tr = tr->right;
else {
addto = &tr->right;
break;
}
}
}
} else
addto = &allocator_ranges;
*addto = &brange->tree;
ptree_added_at(&allocator_ranges, tr, &brange->tree);
pthread_mutex_unlock(&allocator_mutex);
return ret;
}
void pmemlock_free(void *ptr) {
psync_free(ptr);
return;
allocator_range *range;
psync_tree *tr;
char *cptr;
size_t size;
#if IS_DEBUG
size_t origsize, i;
#endif
cptr = ((char *)ptr) - sizeof(size_t);
size = *((size_t *)cptr);
#if IS_DEBUG
origsize = size;
size = ((size + LM_ALIGN_TO - 1)) / LM_ALIGN_TO * LM_ALIGN_TO;
debug(D_NOTICE, "size=%lu", (unsigned long)origsize);
for (i = origsize; i < size; i++)
assert(((unsigned char *)ptr)[i] == (((size_t)0xff + origsize - i) & 0xff));
size += LM_OVERHEAD;
#endif
assert(*((size_t *)(cptr + size - sizeof(size_t))) == LM_END_MARKER);
pthread_mutex_lock(&allocator_mutex);
tr = allocator_ranges;
while (tr) {
range = ptree_element(tr, allocator_range, tree);
if (cptr < range->mem)
tr = tr->left;
else if (cptr >= range->mem + range->size)
tr = tr->right;
else
goto found;
}
debug(D_CRITICAL, "freeing memory at %p not found in any range", ptr);
abort();
found:
psync_interval_tree_add(&range->freeintervals, cptr - range->mem,
cptr - range->mem + size);
if (range->freeintervals->from == LM_RANGE_OVERHEAD &&
range->freeintervals->to == range->size)
ptree_del(&allocator_ranges, &range->tree);
else
range = NULL;
pthread_mutex_unlock(&allocator_mutex);
if (range) {
debug(D_NOTICE, "freeing block of size %lu at %p",
(unsigned long)range->size, range->mem);
if (range->locked)
pmemlock_unlock(range->mem, range->size);
pmem_munmap(range->mem, range->size);
psync_free(range);
}
}
int pmemlock_get_pagesize() {
return psync_page_size;
}
void pmemlock_set_pagesize(int sz) {
psync_page_size = sz;
}

48
pclsync/pmemlock.h
View File

@ -1,48 +0,0 @@
/*
Copyright (c) 2015 Anton Titov.
Copyright (c) 2015 pCloud Ltd. All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met: Redistributions of source code must retain the above
copyright notice, this list of conditions and the following
disclaimer. Redistributions in binary form must reproduce the
above copyright notice, this list of conditions and the following
disclaimer in the documentation and/or other materials provided
with the distribution. Neither the name of pCloud Ltd nor the
names of its contributors may be used to endorse or promote
products derived from this software without specific prior written
permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL pCloud
Ltd BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
DAMAGE.
*/
#ifndef _PSYNC_MEMLOCK_H
#define _PSYNC_MEMLOCK_H
#include <stdlib.h>
void pmemlock_init();
int pmemlock_lock(void *ptr, size_t size);
int pmemlock_unlock(void *ptr, size_t size);
void *pmemlock_malloc(size_t size);
void pmemlock_free(void *ptr);
int pmemlock_get_pagesize();
void pmemlock_set_pagesize(int sz);
#endif

138
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;
}
@ -480,7 +480,7 @@ int psync_get_local_file_checksum(const char *restrict filename,
fd = pfile_open(filename, O_RDONLY, 0);
if (fd == INVALID_HANDLE_VALUE)
return PSYNC_NET_PERMFAIL;
buff = psync_malloc(PSYNC_COPY_BUFFER_SIZE);
buff = malloc(PSYNC_COPY_BUFFER_SIZE);
retry:
if (unlikely_log(fstat(fd, &st)))
goto err1;
@ -520,7 +520,7 @@ retry:
pfile_seek(fd, 0, SEEK_SET);
goto retry;
}
psync_free(buff);
free(buff);
pfile_close(fd);
psync_hash_final(hashbin, &hctx);
psync_binhex(hexsum, hashbin, PSYNC_HASH_DIGEST_LEN);
@ -528,7 +528,7 @@ retry:
*fsize = pfile_stat_size(&st);
return PSYNC_NET_OK;
err1:
psync_free(buff);
free(buff);
pfile_close(fd);
return PSYNC_NET_PERMFAIL;
}
@ -552,7 +552,7 @@ int psync_get_local_file_checksum_part(const char *restrict filename,
return PSYNC_NET_PERMFAIL;
if (unlikely_log(fstat(fd, &st)))
goto err1;
buff = psync_malloc(PSYNC_COPY_BUFFER_SIZE);
buff = malloc(PSYNC_COPY_BUFFER_SIZE);
psync_hash_init(&hctx);
psync_hash_init(&hctxp);
rsz = pfile_stat_size(&st);
@ -579,7 +579,7 @@ int psync_get_local_file_checksum_part(const char *restrict filename,
if (++cnt % 16 == 0)
psys_sleep_milliseconds(5);
}
psync_free(buff);
free(buff);
pfile_close(fd);
psync_hash_final(hashbin, &hctx);
psync_binhex(hexsum, hashbin, PSYNC_HASH_DIGEST_LEN);
@ -589,7 +589,7 @@ int psync_get_local_file_checksum_part(const char *restrict filename,
*fsize = pfile_stat_size(&st);
return PSYNC_NET_OK;
err2:
psync_free(buff);
free(buff);
err1:
pfile_close(fd);
return PSYNC_NET_PERMFAIL;
@ -636,7 +636,7 @@ int psync_copy_local_file_if_checksum_matches(const char *source,
if (unlikely_log(dfd == INVALID_HANDLE_VALUE))
goto err1;
psync_hash_init(&hctx);
buff = psync_malloc(PSYNC_COPY_BUFFER_SIZE);
buff = malloc(PSYNC_COPY_BUFFER_SIZE);
while (fsize) {
if (fsize > PSYNC_COPY_BUFFER_SIZE)
rrd = PSYNC_COPY_BUFFER_SIZE;
@ -656,13 +656,13 @@ int psync_copy_local_file_if_checksum_matches(const char *source,
if (unlikely_log(memcmp(hexsum, hashhex, PSYNC_HASH_DIGEST_HEXLEN)) ||
unlikely_log(pfile_sync(dfd)))
goto err2;
psync_free(buff);
free(buff);
if (unlikely_log(pfile_close(dfd)))
goto err1;
pfile_close(sfd);
return PSYNC_NET_OK;
err2:
psync_free(buff);
free(buff);
pfile_close(dfd);
pfile_delete(destination);
err1:
@ -926,7 +926,7 @@ psync_http_socket *psync_http_connect(const char *host, const char *path,
goto err0;
} else
debug(D_NOTICE, "got connection to %s from cache", host);
readbuff = psync_malloc(PSYNC_HTTP_RESP_BUFFER);
readbuff = malloc(PSYNC_HTTP_RESP_BUFFER);
if (!addhdr)
addhdr = "";
if (from || to) {
@ -1010,10 +1010,10 @@ cont:
ex:
rl = ptr - readbuff;
if (rl == rb) {
psync_free(readbuff);
free(readbuff);
readbuff = NULL;
}
hsock = (psync_http_socket *)psync_malloc(
hsock = (psync_http_socket *)malloc(
offsetof(psync_http_socket, cachekey) + cl);
hsock->sock = sock;
hsock->readbuff = readbuff;
@ -1025,7 +1025,7 @@ ex:
memcpy(hsock->cachekey, cachekey, cl);
return hsock;
err1:
psync_free(readbuff);
free(readbuff);
psync_socket_close_download(sock);
err0:
return NULL;
@ -1048,8 +1048,8 @@ void psync_http_close(psync_http_socket *http) {
psync_socket_close_download(http->sock);
}
if (http->readbuff)
psync_free(http->readbuff);
psync_free(http);
free(http->readbuff);
free(http);
}
int psync_http_readall(psync_http_socket *http, void *buff, int num) {
@ -1069,7 +1069,7 @@ int psync_http_readall(psync_http_socket *http, void *buff, int num) {
http->readbuffoff += cp;
http->readbytes += cp;
if (http->readbuffoff >= http->readbuffsize) {
psync_free(http->readbuff);
free(http->readbuff);
http->readbuff = NULL;
}
if (cp == num)
@ -1130,7 +1130,7 @@ static void connect_cache_thread(void *ptr) {
pthread_mutex_unlock(&connect_cache_mutex);
if (sock)
debug(D_NOTICE, "added connection to %s to cache", node->host);
psync_free(node);
free(node);
}
}
@ -1138,7 +1138,7 @@ connect_cache_tree_node_t *connect_cache_create_node(const char *host) {
connect_cache_tree_node_t *res;
size_t len;
len = strlen(host) + 1;
res = (connect_cache_tree_node_t *)psync_malloc(
res = (connect_cache_tree_node_t *)malloc(
offsetof(connect_cache_tree_node_t, host) + len);
res->usessl = psync_setting_get_bool(_PS(usessl));
res->haswaiter = 0;
@ -1257,7 +1257,7 @@ psock_t *connect_cache_wait_for_http_connection(const char *host,
pthread_cond_wait(&cond, &connect_cache_mutex);
} while (!node->ready);
pthread_mutex_unlock(&connect_cache_mutex);
psync_free(node);
free(node);
if (sock)
debug(D_NOTICE, "waited successfully for connection to %s", host);
return sock;
@ -1326,10 +1326,10 @@ psync_http_socket *psync_http_connect_multihost(const binresult *hosts,
}
}
}
hsock = (psync_http_socket *)psync_malloc(
hsock = (psync_http_socket *)malloc(
offsetof(psync_http_socket, cachekey) + cl);
hsock->sock = sock;
hsock->readbuff = psync_malloc(PSYNC_HTTP_RESP_BUFFER);
hsock->readbuff = malloc(PSYNC_HTTP_RESP_BUFFER);
;
hsock->contentlength = -1;
hsock->readbytes = 0;
@ -1369,10 +1369,10 @@ psync_http_connect_multihost_from_cache(const binresult *hosts,
}
if (!sock)
return NULL;
hsock = (psync_http_socket *)psync_malloc(
hsock = (psync_http_socket *)malloc(
offsetof(psync_http_socket, cachekey) + cl);
hsock->sock = sock;
hsock->readbuff = psync_malloc(PSYNC_HTTP_RESP_BUFFER);
hsock->readbuff = malloc(PSYNC_HTTP_RESP_BUFFER);
;
hsock->contentlength = -1;
hsock->readbytes = 0;
@ -1563,7 +1563,7 @@ char *psync_url_decode(const char *s) {
size_t slen;
char unsigned ch1, ch2;
slen = strlen(s);
ret = p = (char *)psync_malloc(slen + 1);
ret = p = (char *)malloc(slen + 1);
while (slen--) {
if (*s == '+')
*p = ' ';
@ -1618,7 +1618,7 @@ static int psync_net_get_checksums(psock_t *api, psync_fileid_t fileid,
result = papi_find_result2(res, "result", PARAM_NUM)->num;
if (result) {
debug(D_ERROR, "getchecksumlink returned error %lu", (unsigned long)result);
psync_free(res);
free(res);
return psync_handle_api_result(result);
}
hosts = papi_find_result2(res, "hosts", PARAM_ARRAY);
@ -1630,7 +1630,7 @@ static int psync_net_get_checksums(psock_t *api, psync_fileid_t fileid,
if ((http = psync_http_connect(hosts->array[i]->str, requestpath, 0, 0,
cookie)))
break;
psync_free(res);
free(res);
if (unlikely_log(!http))
return PSYNC_NET_TEMPFAIL;
if (unlikely_log(psync_http_readall(http, &hdr, sizeof(hdr)) != sizeof(hdr)))
@ -1644,7 +1644,7 @@ static int psync_net_get_checksums(psock_t *api, psync_fileid_t fileid,
psync_http_close(http);
return PSYNC_NET_OK;
}
cs = (psync_file_checksums *)psync_malloc(
cs = (psync_file_checksums *)malloc(
offsetof(psync_file_checksums, blocks) +
(sizeof(psync_block_checksum) + sizeof(uint32_t)) * i);
cs->filesize = hdr.filesize;
@ -1663,7 +1663,7 @@ static int psync_net_get_checksums(psock_t *api, psync_fileid_t fileid,
debug(D_NOTICE, "checksums downloaded");
return PSYNC_NET_OK;
err1:
psync_free(cs);
free(cs);
err0:
psync_http_close(http);
return PSYNC_NET_TEMPFAIL;
@ -1689,10 +1689,10 @@ static int psync_net_get_upload_checksums(psock_t *api,
if (result) {
debug(D_ERROR, "upload_blockchecksums returned error %lu",
(unsigned long)result);
psync_free(res);
free(res);
return psync_handle_api_result(result);
}
psync_free(res);
free(res);
if (unlikely_log(psync_socket_readall_download(api, &hdr, sizeof(hdr)) !=
sizeof(hdr)))
goto err0;
@ -1708,7 +1708,7 @@ static int psync_net_get_upload_checksums(psock_t *api,
}
if (!hdr.filesize)
return PSYNC_NET_PERMFAIL;
cs = (psync_file_checksums *)psync_malloc(
cs = (psync_file_checksums *)malloc(
offsetof(psync_file_checksums, blocks) +
(sizeof(psync_block_checksum) + sizeof(uint32_t)) * i);
cs->filesize = hdr.filesize;
@ -1725,7 +1725,7 @@ static int psync_net_get_upload_checksums(psock_t *api,
*checksums = cs;
return PSYNC_NET_OK;
err1:
psync_free(cs);
free(cs);
err0:
return PSYNC_NET_TEMPFAIL;
}
@ -1779,7 +1779,7 @@ psync_net_create_hash(const psync_file_checksums *checksums) {
break;
cnt += 2;
}
h = (psync_file_checksum_hash *)psync_malloc(
h = (psync_file_checksum_hash *)malloc(
offsetof(psync_file_checksum_hash, elements) + sizeof(uint32_t) * cnt);
h->elementcnt = cnt;
memset(h->elements, 0, sizeof(uint32_t) * cnt);
@ -1997,11 +1997,11 @@ static void psync_net_check_file_for_blocks(
else
buffersize = PSYNC_COPY_BUFFER_SIZE;
hbuffersize = buffersize / 2;
buff = psync_malloc(buffersize);
buff = malloc(buffersize);
rd = pfile_read(fd, buff, hbuffersize);
if (unlikely(rd < (ssize_t)hbuffersize)) {
if (rd < (ssize_t)checksums->blocksize) {
psync_free(buff);
free(buff);
pfile_close(fd);
return;
}
@ -2067,7 +2067,7 @@ static void psync_net_check_file_for_blocks(
adler = adler32_roll(adler, buff[outbyteoff++], buff[inbyteoff++],
checksums->blocksize);
}
psync_free(buff);
free(buff);
pfile_close(fd);
}
@ -2088,7 +2088,7 @@ int psync_net_download_ranges(psync_list *ranges, psync_fileid_t fileid,
else if (unlikely_log(rt == PSYNC_NET_TEMPFAIL))
return PSYNC_NET_TEMPFAIL;
if (unlikely_log(checksums->filesize != filesize)) {
psync_free(checksums);
free(checksums);
return PSYNC_NET_TEMPFAIL;
}
hash = psync_net_create_hash(checksums);
@ -2096,7 +2096,7 @@ int psync_net_download_ranges(psync_list *ranges, psync_fileid_t fileid,
memset(blockactions, 0, sizeof(psync_block_action) * checksums->blockcnt);
for (i = 0; i < filecnt; i++)
psync_net_check_file_for_blocks(files[i], checksums, hash, blockactions, i);
psync_free(hash);
free(hash);
range = psync_new(psync_range_list_t);
range->len = checksums->blocksize;
range->type = blockactions[0].type;
@ -2129,8 +2129,8 @@ int psync_net_download_ranges(psync_list *ranges, psync_fileid_t fileid,
} else
range->len += bs;
}
psync_free(checksums);
psync_free(blockactions);
free(checksums);
free(blockactions);
return PSYNC_NET_OK;
fulldownload:
range = psync_new(psync_range_list_t);
@ -2165,10 +2165,10 @@ static int check_range_for_blocks(psync_file_checksums *checksums,
else
buffersize = PSYNC_COPY_BUFFER_SIZE;
hbuffersize = buffersize / 2;
buff = psync_malloc(buffersize);
buff = malloc(buffersize);
rd = pfile_read(fd, buff, hbuffersize);
if (unlikely(rd < (ssize_t)hbuffersize)) {
psync_free(buff);
free(buff);
return PSYNC_NET_OK;
} else
bufferlen = buffersize;
@ -2272,7 +2272,7 @@ static int check_range_for_blocks(psync_file_checksums *checksums,
adler = adler32_roll(adler, buff[outbyteoff++], buff[inbyteoff++],
checksums->blocksize);
}
psync_free(buff);
free(buff);
return PSYNC_NET_OK;
}
@ -2299,7 +2299,7 @@ static void merge_list_to_element(psync_upload_range_list_t *le,
assertw(psync_list_isempty(rlist));
psync_list_add_after(&le->list, &ur->list);
psync_list_del(&le->list);
psync_free(le);
free(le);
} else if (ur->uploadoffset == le->uploadoffset) {
psync_list_add_before(&le->list, &ur->list);
le->uploadoffset += ur->len;
@ -2346,8 +2346,8 @@ int psync_net_scan_file_for_blocks(psock_t *api, psync_list *rlist,
psync_list_init(&nr);
if (check_range_for_blocks(checksums, hash, ur->off, ur->len, fd, &nr) ==
PSYNC_NET_TEMPFAIL) {
psync_free(hash);
psync_free(checksums);
free(hash);
free(checksums);
return PSYNC_NET_TEMPFAIL;
}
if (!psync_list_isempty(&nr)) {
@ -2359,8 +2359,8 @@ int psync_net_scan_file_for_blocks(psock_t *api, psync_list *rlist,
merge_list_to_element(ur, &nr);
}
}
psync_free(hash);
psync_free(checksums);
free(hash);
free(checksums);
return PSYNC_NET_OK;
}
@ -2387,8 +2387,8 @@ int psync_net_scan_upload_for_blocks(psock_t *api, psync_list *rlist,
psync_list_init(&nr);
if (check_range_for_blocks(checksums, hash, ur->off, ur->len, fd, &nr) ==
PSYNC_NET_TEMPFAIL) {
psync_free(hash);
psync_free(checksums);
free(hash);
free(checksums);
return PSYNC_NET_TEMPFAIL;
}
if (!psync_list_isempty(&nr)) {
@ -2399,8 +2399,8 @@ int psync_net_scan_upload_for_blocks(psock_t *api, psync_list *rlist,
merge_list_to_element(ur, &nr);
}
}
psync_free(hash);
psync_free(checksums);
free(hash);
free(checksums);
return PSYNC_NET_OK;
}
@ -2446,7 +2446,7 @@ static int download_file_revisions(psync_fileid_t fileid) {
result = papi_find_result2(res, "result", PARAM_NUM)->num;
if (result) {
debug(D_ERROR, "listrevisions returned error %lu", (unsigned long)result);
psync_free(res);
free(res);
return psync_handle_api_result(result);
}
revs = papi_find_result2(res, "revisions", PARAM_ARRAY);
@ -2487,7 +2487,7 @@ static int download_file_revisions(psync_fileid_t fileid) {
PSYNC_HASH_DIGEST_HEXLEN);
psync_sql_run_free(hc);
psync_sql_commit_transaction();
psync_free(res);
free(res);
return PSYNC_NET_OK;
}
@ -2515,7 +2515,7 @@ psync_file_lock_t *psync_lock_file(const char *path) {
size_t len;
int cmp;
len = strlen(path) + 1;
lock = psync_malloc(offsetof(psync_file_lock_t, filename) + len);
lock = malloc(offsetof(psync_file_lock_t, filename) + len);
memcpy(lock->filename, path, len);
pthread_mutex_lock(&file_lock_mutex);
tr = file_lock_tree;
@ -2539,7 +2539,7 @@ psync_file_lock_t *psync_lock_file(const char *path) {
}
} else {
pthread_mutex_unlock(&file_lock_mutex);
psync_free(lock);
free(lock);
return NULL;
}
}
@ -2553,7 +2553,7 @@ void psync_unlock_file(psync_file_lock_t *lock) {
pthread_mutex_lock(&file_lock_mutex);
ptree_del(&file_lock_tree, &lock->tree);
pthread_mutex_unlock(&file_lock_mutex);
psync_free(lock);
free(lock);
}
int psync_get_upload_checksum(psync_uploadid_t uploadid, unsigned char *uhash,
@ -2573,13 +2573,13 @@ int psync_get_upload_checksum(psync_uploadid_t uploadid, unsigned char *uhash,
}
psync_apipool_release(api);
if (papi_find_result2(res, "result", PARAM_NUM)->num) {
psync_free(res);
free(res);
return PSYNC_NET_PERMFAIL;
}
*usize = papi_find_result2(res, "size", PARAM_NUM)->num;
memcpy(uhash, papi_find_result2(res, PSYNC_CHECKSUM, PARAM_STR)->str,
PSYNC_HASH_DIGEST_HEXLEN);
psync_free(res);
free(res);
return PSYNC_NET_OK;
}
@ -2610,11 +2610,11 @@ static void psync_send_debug_thread(void *ptr) {
debug(D_NOTICE, "sending debug %s", str);
res = psync_api_run_command("senddebug", params);
if (res) {
psync_free(res);
psync_free(last);
free(res);
free(last);
last = str;
} else
psync_free(str);
free(str);
} else
free(str);
pthread_mutex_unlock(&m);
@ -2629,7 +2629,7 @@ int psync_send_debug(int thread, const char *file, const char *function,
ret = pdevice_id();
snprintf(format, sizeof(format), "%s %s: %s:%u (function %s): %s\n", ret,
psync_thread_name, file, line, function, fmt);
psync_free(ret);
free(ret);
format[sizeof(format) - 1] = 0;
ret = NULL;
l = 511;
@ -2684,7 +2684,7 @@ int psync_do_run_command_res(const char *cmd, size_t cmdlen,
*err = psync_strdup(papi_find_result2(res, "error", PARAM_STR)->str);
psync_process_api_error(result);
}
psync_free(res);
free(res);
return (int)result;
neterr:
if (err)

32
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);
@ -101,7 +101,7 @@ static void psync_notifications_download_thumb(const binresult *thumb,
goto err3;
if (unlikely_log(psync_http_next_request(sock)))
goto err3;
buff = (char *)psync_malloc(PSYNC_COPY_BUFFER_SIZE);
buff = (char *)malloc(PSYNC_COPY_BUFFER_SIZE);
while (1) {
rd = psync_http_request_readall(sock, buff, PSYNC_COPY_BUFFER_SIZE);
if (rd <= 0)
@ -109,7 +109,7 @@ static void psync_notifications_download_thumb(const binresult *thumb,
if (pfile_write(fd, buff, rd) != rd)
break;
}
psync_free(buff);
free(buff);
err3:
psync_http_close(sock);
err2:
@ -119,9 +119,9 @@ err1:
debug(D_NOTICE, "downloaded thumbnail %s", filename);
else
debug(D_WARNING, "downloading of thumbnail %s failed", filename);
psync_free(tmpfilepath);
free(tmpfilepath);
err0:
psync_free(filepath);
free(filepath);
}
static void psync_notifications_set_current_list(binresult *res,
@ -145,13 +145,13 @@ static void psync_notifications_set_current_list(binresult *res,
ores = ntf_processed_result;
if (ntf_processing == 2) {
ntf_processed_result = NULL;
psync_free(res);
free(res);
} else
ntf_processed_result = res;
ntf_processing = 0;
cb = ntf_callback;
pthread_mutex_unlock(&ntf_mutex);
psync_free(ores);
free(ores);
if (cb) {
debug(D_NOTICE, "calling notification callback, cnt=%u, newcnt=%u",
(unsigned)cnttotal, (unsigned)cntnew);
@ -178,7 +178,7 @@ static void psync_notifications_thread() {
pthread_mutex_unlock(&ntf_mutex);
psync_notifications_set_current_list(res, thumbpath);
}
psync_free(thumbpath);
free(thumbpath);
}
void pnotify_set_callback(
@ -258,7 +258,7 @@ static void psync_notifications_thumb_dir_list(void *ptr,
} else
addto = tree;
len = strlen(st->name) + 1;
tl = (psync_thumb_list_t *)psync_malloc(offsetof(psync_thumb_list_t, name) +
tl = (psync_thumb_list_t *)malloc(offsetof(psync_thumb_list_t, name) +
len);
memcpy(tl->name, st->name, len);
*addto = &tl->tree;
@ -336,7 +336,7 @@ psync_notification_list_t *pnotify_get() {
debug(D_WARNING,
"could not stat thumb %s which is supposed to be downloaded",
filename);
psync_free(filepath);
free(filepath);
}
}
pntf->mtime = papi_find_result2(ntf, "mtime", PARAM_NUM)->num;
@ -359,11 +359,11 @@ psync_notification_list_t *pnotify_get() {
thumbpath, "/",
ptree_element(thumbs, psync_thumb_list_t, tree)->name, NULL);
pfile_delete(filepath);
psync_free(filepath);
psync_free(ptree_element(thumbs, psync_thumb_list_t, tree));
free(filepath);
free(ptree_element(thumbs, psync_thumb_list_t, tree));
thumbs = nx;
}
psync_free(thumbpath);
free(thumbpath);
res = (psync_notification_list_t *)psync_list_builder_finalize(builder);
res->newnotificationcnt = cntnew;
return res;
@ -382,14 +382,14 @@ void pnotify_clean() {
thumbpath = ppath_private(PSYNC_DEFAULT_NTF_THUMB_DIR);
if (thumbpath) {
ppath_ls(thumbpath, psync_notifications_del_thumb, NULL);
psync_free(thumbpath);
free(thumbpath);
}
if (ntf_processed_result) {
psync_free(ntf_processed_result);
free(ntf_processed_result);
ntf_processed_result = NULL;
}
if (ntf_result) {
psync_free(ntf_result);
free(ntf_result);
ntf_result = NULL;
}
if (ntf_processing == 1)

50
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);
*token = malloc(ctoken->length + 1);
memcpy(*token, ctoken->str, ctoken->length + 1);
*tlen = ctoken->length;
psync_free(res);
free(res);
return PSYNC_NET_OK;
}
@ -678,10 +678,10 @@ static int psync_p2p_download(int sock, psync_fileid_t fileid,
&privkey, &ekey)) == PSYNC_INVALID_SYM_KEY)) {
// unlikely_log((key=psymkey_decrypt(&psync_rsa_private,
// &ekey))==PSYNC_INVALID_SYM_KEY)){
psync_free(ekey);
free(ekey);
return PSYNC_NET_TEMPFAIL;
}
psync_free(ekey);
free(ekey);
decoder = pcrypto_ctr_encdec_create(key);
psymkey_free(key);
if (decoder == PSYNC_CRYPTO_INVALID_ENCODER)
@ -835,8 +835,8 @@ int pp2p_check_download(psync_fileid_t fileid,
for (i = 0; i < il->interfacecnt; i++)
if (sockets[i] != INVALID_SOCKET)
close(sockets[i]);
psync_free(il);
psync_free(sockets);
free(il);
free(sockets);
if (bresp == P2P_RESP_NOPE)
goto err_perm2;
else if (bresp == P2P_RESP_WAIT) {
@ -890,24 +890,24 @@ int pp2p_check_download(psync_fileid_t fileid,
debug(D_WARNING, "writing to socket failed");
goto err_temp3;
}
psync_free(token);
free(token);
sret = psync_p2p_download(sock, fileid, filehashhex, fsize, filename);
close(sock);
return sret;
err_perm3:
psync_free(token);
free(token);
goto err_perm2;
err_perm:
for (i = 0; i < il->interfacecnt; i++)
if (sockets[i] != INVALID_SOCKET)
close(sockets[i]);
psync_free(il);
psync_free(sockets);
free(il);
free(sockets);
err_perm2:
return PSYNC_NET_PERMFAIL;
err_temp3:
close(sock);
psync_free(token);
free(token);
err_temp2:
return PSYNC_NET_TEMPFAIL;
}

96
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);
}
}
@ -1039,7 +1039,7 @@ static void clean_cache() {
}
clean_cache_in_progress = 1;
psync_sql_sync();
entries = (pagecache_entry *)psync_malloc(cnt * sizeof(pagecache_entry));
entries = (pagecache_entry *)malloc(cnt * sizeof(pagecache_entry));
i = 0;
e = 0;
while (i < cnt) {
@ -1180,7 +1180,7 @@ static void clean_cache() {
psync_sql_commit_transaction();
clean_cache_in_progress = 0;
pthread_mutex_unlock(&clean_cache_mutex);
psync_free(oentries);
free(oentries);
debug(D_NOTICE, "syncing database");
psync_sql_sync();
debug(D_NOTICE, "finished cleaning cache, free cache pages %u",
@ -1750,7 +1750,7 @@ static void check_pages_in_database_by_hash(uint64_t hash,
}
if (fres->rows)
mark_pagescache_used(first_page_id, pagecnt, dbread);
psync_free(fres);
free(fres);
}
static long check_page_in_database_by_hash_and_cache(uint64_t hash,
@ -1898,8 +1898,8 @@ int ppagecache_read_mod_locked(psync_openfile_t *of, char *buf,
static void psync_pagecache_free_request(psync_request_t *request) {
psync_list_for_each_element_call(&request->ranges, psync_request_range_t,
list, psync_free);
psync_free(request);
list, free);
free(request);
}
static void psync_pagecache_send_error_page_wait(psync_page_wait_t *pw,
@ -1912,7 +1912,7 @@ static void psync_pagecache_send_error_page_wait(psync_page_wait_t *pw,
pwt->ready = 1;
pthread_cond_broadcast(&pwt->cond);
}
psync_free(pw);
free(pw);
}
static void psync_pagecache_send_range_error(psync_request_range_t *range,
@ -2226,7 +2226,7 @@ retry:
err = psync_http_request_range_additional(
sock, host, path, range->offset, range->offset + range->length - 1,
range_hdr);
psync_free(range_hdr);
free(range_hdr);
} else
err = psync_http_request(sock, host, path, range->offset,
range->offset + range->length - 1, cookie);
@ -2475,7 +2475,7 @@ static void psync_pagecache_read_unmodified_readahead(
}
}
unlock_wait(hash);
psync_free(pages_in_db);
free(pages_in_db);
if (!psync_list_isempty(ranges))
debug(D_NOTICE,
"readahead=%lu, rto=%lu, offset=%lu, size=%lu, currentspeed=%u",
@ -2485,7 +2485,7 @@ static void psync_pagecache_read_unmodified_readahead(
static void psync_free_page_waiter(psync_page_waiter_t *pwt) {
pthread_cond_destroy(&pwt->cond);
psync_free(pwt);
free(pwt);
}
static psync_page_waiter_t *
@ -2636,7 +2636,7 @@ int ppagecache_read_unmod_locked(psync_openfile_t *of, char *buf,
prun_thread1("read unmodified", psync_pagecache_read_unmodified_thread,
rq);
} else
psync_free(rq);
free(rq);
ret = size;
if (!psync_list_isempty(&waiting)) {
psync_list_for_each_element(pwt, &waiting, psync_page_waiter_t,
@ -2676,7 +2676,7 @@ static void free_waiters(psync_list *waiters) {
pw = pwt->waiting_for;
if (psync_list_isempty(&pw->waiters)) {
psync_list_del(&pw->list);
psync_free(pw);
free(pw);
}
}
psync_free_page_waiter(pwt);
@ -2885,7 +2885,7 @@ int ppagecache_read_unmod_enc_locked(psync_openfile_t *of,
prun_thread1("crypto read unmodified",
psync_pagecache_read_unmodified_thread, rq);
} else
psync_free(rq);
free(rq);
ret = 0;
if (needkey) {
debug(D_NOTICE, "waiting for key to download");
@ -3012,14 +3012,12 @@ int ppagecache_read_unmod_enc_locked(psync_openfile_t *of,
if (!ret)
ret = size;
ret0:
psync_list_for_each_element_call(&waiting, psync_page_waiter_t, listwaiter,
psync_free);
psync_list_for_each_element_call(&auth_pages, psync_crypto_auth_page, list,
psync_free);
psync_list_for_each_element_call(&waiting, psync_page_waiter_t, listwaiter, free);
psync_list_for_each_element_call(&auth_pages, psync_crypto_auth_page, list, free);
for (i = 0; i < pagecnt; i++)
if (dp[i].freebuff)
psync_free(dp[i].buff);
psync_free(dp);
free(dp[i].buff);
free(dp);
return ret;
err0:
free_waiters(&waiting);
@ -3103,7 +3101,7 @@ int ppagecache_readv_locked(psync_openfile_t *of,
}
if (psync_list_isempty(&rq->ranges) && !needkey) {
if (psync_list_isempty(&waiting)) {
psync_free(rq);
free(rq);
return 0;
}
} else {
@ -3218,7 +3216,7 @@ static void psync_pagecache_new_upload_to_cache(uint64_t taskid, uint64_t hash,
debug(D_ERROR, "could not open cache file %s for taskid %lu, skipping",
filename, (unsigned long)taskid);
pfile_delete(filename);
psync_free(filename);
free(filename);
return;
}
debug(D_NOTICE, "adding file %s to cache for hash %lu (%ld) size %ld",
@ -3251,7 +3249,7 @@ static void psync_pagecache_new_upload_to_cache(uint64_t taskid, uint64_t hash,
pfile_delete(filename);
debug(D_NOTICE, "finished adding file %s to cache for hash %lu (%ld)",
filename, (unsigned long)hash, (long)hash);
psync_free(filename);
free(filename);
}
static void switch_pageids(uint64_t hash, uint64_t oldhash, uint64_t *pageids,
@ -3308,8 +3306,8 @@ static void psync_pagecache_modify_to_cache(uint64_t taskid, uint64_t hash,
indexname, (unsigned long)taskid);
pfile_delete(filename);
pfile_delete(indexname);
psync_free(filename);
psync_free(indexname);
free(filename);
free(indexname);
return;
}
tree = NULL;
@ -3480,9 +3478,9 @@ err2:
err1:
psync_interval_tree_free(tree);
pfile_delete(filename);
psync_free(filename);
free(filename);
pfile_delete(indexname);
psync_free(indexname);
free(indexname);
}
static void psync_pagecache_check_free_space() {
@ -3597,7 +3595,7 @@ int ppagecache_have_all_pages(uint64_t hash, uint64_t size) {
for (i = 0; i < pagecnt; i++)
if (!db[i] && !has_page_in_cache_by_hash(hash, i))
break;
psync_free(db);
free(db);
return i == pagecnt;
}
@ -3828,7 +3826,7 @@ void ppagecache_init() {
(unsigned long)db_cache_max_page);
}
readcache = pfile_open(cache_file, O_RDWR, O_CREAT);
psync_free(cache_file);
free(cache_file);
if (likely_log(pfile_seek(readcache,
db_cache_max_page * PSYNC_FS_PAGE_SIZE,
SEEK_SET) != -1))
@ -3879,7 +3877,7 @@ void ppagecache_reopen_read() {
cache_file = psync_strcat(cache_dir, "/",
PSYNC_DEFAULT_READ_CACHE_FILE, NULL);
readcache = pfile_open(cache_file, O_RDWR, O_CREAT);
psync_free(cache_file);
free(cache_file);
}
void ppagecache_clean_read() {
@ -3927,12 +3925,12 @@ int ppagecache_move(const char *path) {
rdpath = psync_strcat(path, "/",
PSYNC_DEFAULT_READ_CACHE_FILE, NULL);
if (!stat(rdpath, &st)) {
psync_free(rdpath);
free(rdpath);
return PRINT_RETURN_CONST(PERROR_CACHE_MOVE_NOT_EMPTY);
}
newrdcache = pfile_open(rdpath, O_RDWR, O_CREAT | O_EXCL);
if (newrdcache == INVALID_HANDLE_VALUE) {
psync_free(rdpath);
free(rdpath);
return PRINT_RETURN_CONST(PERROR_CACHE_MOVE_NO_WRITE_ACCESS);
}
opath = psync_strdup(psync_setting_get_string(_PS(fscachepath)));
@ -3957,8 +3955,8 @@ int ppagecache_move(const char *path) {
pthread_mutex_unlock(&clean_cache_mutex);
pfile_close(newrdcache);
pfile_delete(rdpath);
psync_free(opath);
psync_free(rdpath);
free(opath);
free(rdpath);
return PRINT_RETURN_CONST(PERROR_CACHE_MOVE_DRIVE_HAS_TASKS);
}
ordcache = readcache;
@ -3991,8 +3989,8 @@ int ppagecache_move(const char *path) {
debug(D_NOTICE, "released locks");
pfile_close(ordcache);
ppath_ls(opath, clean_cache_del, (void *)1);
psync_free(opath);
psync_free(rdpath);
free(opath);
free(rdpath);
debug(D_NOTICE, "end");
return 0;
}

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

22
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);
}
}
}
@ -85,7 +85,7 @@ int ppath_ls(const char *path, ppath_ls_cb callback, void *ptr) {
}
pl = strlen(path);
cpath = (char *)psync_malloc(pl + NAME_MAX + 2);
cpath = (char *)malloc(pl + NAME_MAX + 2);
memcpy(cpath, path, pl);
if (!pl || cpath[pl - 1] != '/')
cpath[pl++] = '/';
@ -107,7 +107,7 @@ int ppath_ls(const char *path, ppath_ls_cb callback, void *ptr) {
}
}
psync_free(cpath);
free(cpath);
closedir(dh);
return 0;
}
@ -127,7 +127,7 @@ int ppath_ls_fast(const char *path, ppath_ls_fast_cb callback, void *ptr) {
}
pl = strlen(path);
cpath = (char *)psync_malloc(pl + NAME_MAX + 2);
cpath = (char *)malloc(pl + NAME_MAX + 2);
memcpy(cpath, path, pl);
if (!pl || cpath[pl - 1] != '/')
cpath[pl++] = '/';
@ -157,7 +157,7 @@ int ppath_ls_fast(const char *path, ppath_ls_fast_cb callback, void *ptr) {
// Ignore other file types
}
psync_free(cpath);
free(cpath);
closedir(dh);
return 0;
}
@ -171,14 +171,14 @@ char *ppath_pcloud() {
}
path = psync_strcat(homedir, "/", PSYNC_DEFAULT_POSIX_DIR, NULL);
psync_free(homedir);
free(homedir);
if (unlikely_log(!path)) {
return NULL;
}
if (stat(path, &st) &&
unlikely_log(mkdir(path, PSYNC_DEFAULT_POSIX_FOLDER_MODE))) {
psync_free(path);
free(path);
return NULL;
}
return path;
@ -192,7 +192,7 @@ char *ppath_private(char *name) {
return NULL;
rpath = psync_strcat(path, "/", name, NULL);
if (stat(rpath, &st) && mkdir(path, PSYNC_DEFAULT_POSIX_FOLDER_MODE)) {
psync_free(rpath);
free(rpath);
free(path);
return NULL;
}

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,

10
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);
}
}
@ -379,7 +379,7 @@ void pqevent_queue_sync_event_path(psync_eventtype_t eventid, psync_syncid_t syn
else
slen = sizeof(psync_folder_event_t);
event =
(event_list_t *)psync_malloc(sizeof(event_list_t) + slen + llen + rlen);
(event_list_t *)malloc(sizeof(event_list_t) + slen + llen + rlen);
strct = (char *)(event + 1);
lcopy = strct + slen;
rcopy = lcopy + llen;
@ -442,5 +442,5 @@ void pqevent_queue_event(psync_eventtype_t eventid, void *eventdata) {
pthread_cond_signal(&eventcond);
pthread_mutex_unlock(&eventmutex);
} else
psync_free(eventdata);
free(eventdata);
}

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

6
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,14 +285,14 @@ int prpc_register(int cmdid, prpc_handler h) {
prpc_init();
memcpy(handlers, handlers_old,
handlers_size_old * sizeof(prpc_handler));
psync_free(handlers_old);
free(handlers_old);
}
handlers[cmdid - calbacks_lower_band] = h;
return 0;
}
void prpc_init() {
handlers = (prpc_handler *)psync_malloc(sizeof(prpc_handler) * handlers_size);
handlers = (prpc_handler *)malloc(sizeof(prpc_handler) * handlers_size);
memset(handlers, 0, sizeof(prpc_handler) * handlers_size);
}

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

18
pclsync/psock.c
View File

@ -172,7 +172,7 @@ static struct addrinfo *addr_load(const char *host, const char *port) {
psync_sql_rdunlock();
return NULL;
}
ret = (struct addrinfo *)psync_malloc(sizeof(struct addrinfo) * row[0] +
ret = (struct addrinfo *)malloc(sizeof(struct addrinfo) * row[0] +
row[1]);
data = (char *)(ret + row[0]);
for (i = 0; i < row[0] - 1; i++)
@ -275,7 +275,7 @@ static void cb_connect_res(void *h, void *ptr) {
res = (struct addrinfo *)ptr;
sock = connect_res(res);
r = psync_task_complete(h, (void *)(uintptr_t)sock);
psync_free(res);
free(res);
if (r && sock != INVALID_SOCKET)
close(sock);
}
@ -380,7 +380,7 @@ int psock_try_write_buffer(psock_t *sock) {
while ((b = sock->buffer)) {
if (b->roffset == b->woffset) {
sock->buffer = b->next;
psync_free(b);
free(b);
continue;
}
if (sock->ssl) {
@ -502,7 +502,7 @@ void psock_close(psock_t *sock) {
}
psock_clear_write_buffered(sock);
close(sock->sock);
psync_free(sock);
free(sock);
}
void psock_close_bad(psock_t *sock) {
@ -510,14 +510,14 @@ void psock_close_bad(psock_t *sock) {
pssl_free(sock->ssl);
psock_clear_write_buffered(sock);
close(sock->sock);
psync_free(sock);
free(sock);
}
void psock_set_write_buffered(psock_t *sock) {
psock_buf_t *sb;
if (sock->buffer)
return;
sb = (psock_buf_t *)psync_malloc(offsetof(psock_buf_t, buff) +
sb = (psock_buf_t *)malloc(offsetof(psock_buf_t, buff) +
PSYNC_FIRST_SOCK_WRITE_BUFF_SIZE);
sb->next = NULL;
sb->size = PSYNC_FIRST_SOCK_WRITE_BUFF_SIZE;
@ -773,7 +773,7 @@ static int psync_socket_write_to_buf(psock_t *sock, const void *buff, int num) {
do {
wr = b->size - b->woffset;
if (!wr) {
b->next = (psock_buf_t *)psync_malloc(
b->next = (psock_buf_t *)malloc(
offsetof(psock_buf_t, buff) + PSYNC_SECOND_SOCK_WRITE_BUFF_SIZE);
b = b->next;
b->next = NULL;
@ -1107,7 +1107,7 @@ psock_ifaces_t *psock_list_adapters() {
}
addr = addr->ifa_next;
}
ret = psync_malloc(offsetof(psock_ifaces_t, interfaces) +
ret = malloc(offsetof(psock_ifaces_t, interfaces) +
sizeof(psock_iface_t) * cnt);
memset(ret, 0,
offsetof(psock_ifaces_t, interfaces) + sizeof(psock_iface_t) * cnt);
@ -1135,7 +1135,7 @@ psock_ifaces_t *psock_list_adapters() {
freeifaddrs(addrs);
return ret;
empty:
ret = psync_malloc(offsetof(psock_ifaces_t, interfaces));
ret = malloc(offsetof(psock_ifaces_t, interfaces));
ret->interfacecnt = 0;
return ret;
}

55
pclsync/pssl.c
View File

@ -52,7 +52,6 @@
#include "pcache.h"
#include "pcompiler.h"
#include "plibs.h"
#include "pmemlock.h"
#include "prand.h"
#include "psettings.h"
#include "pssl.h"
@ -71,7 +70,7 @@ static void ssl_debug(int loglevel, int errnum, const char *msg) {
static void free_encrypted(psync_encrypted_data_t e) {
putil_wipe(e->data, e->datalen);
pmemlock_free(e);
free(e);
}
void prsa_free_binary(psync_binary_rsa_key_t bin) {
@ -80,13 +79,13 @@ void prsa_free_binary(psync_binary_rsa_key_t bin) {
void psymkey_free(psync_symmetric_key_t key) {
putil_wipe(key->key, key->keylen);
pmemlock_free(key);
free(key);
}
psync_encrypted_symmetric_key_t
psymkey_alloc_encrypted(size_t len) {
psync_encrypted_symmetric_key_t ret;
ret = psync_malloc(offsetof(psync_encrypted_data_struct_t, data) + len);
ret = malloc(offsetof(psync_encrypted_data_struct_t, data) + len);
ret->datalen = len;
return ret;
}
@ -94,7 +93,7 @@ psymkey_alloc_encrypted(size_t len) {
psync_encrypted_symmetric_key_t
psymkey_copy_encrypted(psync_encrypted_symmetric_key_t src) {
psync_encrypted_symmetric_key_t ret;
ret = psync_malloc(offsetof(psync_encrypted_data_struct_t, data) +
ret = malloc(offsetof(psync_encrypted_data_struct_t, data) +
src->datalen);
ret->datalen = src->datalen;
memcpy(ret->data, src->data, src->datalen);
@ -212,7 +211,7 @@ static ssl_connection_t *conn_alloc(const char *hostname) {
ssl_connection_t *conn;
size_t len;
len = strlen(hostname) + 1;
conn = (ssl_connection_t *)psync_malloc(offsetof(ssl_connection_t, cachekey) +
conn = (ssl_connection_t *)malloc(offsetof(ssl_connection_t, cachekey) +
len + 4);
conn->isbroken = 0;
memcpy(conn->cachekey, "SSLS", 4);
@ -271,7 +270,7 @@ static int mbed_write(void *ptr, const unsigned char *buf, size_t len) {
static void free_session(void *ptr) {
mbedtls_ssl_session_free((mbedtls_ssl_session *)ptr);
psync_free(ptr);
free(ptr);
}
static void save_session(ssl_connection_t *conn) {
@ -281,7 +280,7 @@ static void save_session(ssl_connection_t *conn) {
// them, therefore it is thread safe to add session upon connect
memset(sess, 0, sizeof(mbedtls_ssl_session));
if (mbedtls_ssl_get_session(&conn->ssl, sess))
psync_free(sess);
free(sess);
else
pcache_add(conn->cachekey, sess, PSYNC_SSL_SESSION_CACHE_TIMEOUT,
free_session, PSYNC_MAX_SSL_SESSIONS_PER_DOMAIN);
@ -365,7 +364,7 @@ int pssl_connect(int sock, void **sslconn,
debug(D_WARNING, "ssl_set_session failed");
}
mbedtls_ssl_session_free(sess);
psync_free(sess);
free(sess);
}
ret = mbedtls_ssl_handshake(&conn->ssl);
@ -387,7 +386,7 @@ int pssl_connect(int sock, void **sslconn,
err1:
mbedtls_ssl_free(&conn->ssl);
err0:
psync_free(conn);
free(conn);
return PRINT_RETURN_CONST(PSYNC_SSL_FAIL);
}
@ -412,7 +411,7 @@ int pssl_connect_finish(void *sslconn, const char *hostname) {
return PSYNC_SSL_NEED_FINISH;
fail:
mbedtls_ssl_free(&conn->ssl);
psync_free(conn);
free(conn);
return PRINT_RETURN_CONST(PSYNC_SSL_FAIL);
}
@ -431,7 +430,7 @@ int pssl_shutdown(void *sslconn) {
return PSYNC_SSL_NEED_FINISH;
noshutdown:
mbedtls_ssl_free(&conn->ssl);
psync_free(conn);
free(conn);
return PSYNC_SSL_SUCCESS;
}
@ -439,7 +438,7 @@ void pssl_free(void *sslconn) {
ssl_connection_t *conn;
conn = (ssl_connection_t *)sslconn;
mbedtls_ssl_free(&conn->ssl);
psync_free(conn);
free(conn);
}
int pssl_pendingdata(void *sslconn) {
@ -485,7 +484,7 @@ psync_rsa_t pssl_gen_rsa(int bits) {
if (mbedtls_rsa_gen_key(ctx, rng_get, &rng, bits,
65537)) {
mbedtls_rsa_free(ctx);
psync_free(ctx);
free(ctx);
return PSYNC_INVALID_RSA;
} else
return ctx;
@ -493,7 +492,7 @@ psync_rsa_t pssl_gen_rsa(int bits) {
void pssl_free_rsa(psync_rsa_t rsa) {
mbedtls_rsa_free(rsa);
psync_free(rsa);
free(rsa);
}
psync_rsa_publickey_t prsa_get_public(psync_rsa_t rsa) {
@ -519,7 +518,7 @@ psync_rsa_privatekey_t prsa_get_private(psync_rsa_t rsa) {
if (unlikely(mbedtls_rsa_copy(ctx, rsa))) {
mbedtls_rsa_free(ctx);
psync_free(ctx);
free(ctx);
return PSYNC_INVALID_RSA;
} else
return ctx;
@ -545,7 +544,7 @@ prsa_public_to_binary(psync_rsa_publickey_t rsa) {
if (len <= 0)
return PSYNC_INVALID_BIN_RSA;
ret =
pmemlock_malloc(offsetof(psync_encrypted_data_struct_t, data) + len);
malloc(offsetof(psync_encrypted_data_struct_t, data) + len);
ret->datalen = len;
memcpy(ret->data, buff + sizeof(buff) - len, len);
return ret;
@ -566,7 +565,7 @@ prsa_private_to_binary(psync_rsa_privatekey_t rsa) {
if (len <= 0)
return PSYNC_INVALID_BIN_RSA;
ret =
pmemlock_malloc(offsetof(psync_encrypted_data_struct_t, data) + len);
malloc(offsetof(psync_encrypted_data_struct_t, data) + len);
ret->datalen = len;
memcpy(ret->data, buff + sizeof(buff) - len, len);
putil_wipe(buff + sizeof(buff) - len, len);
@ -593,7 +592,7 @@ psync_rsa_publickey_t prsa_load_public(const unsigned char *keydata,
if (unlikely(ret)) {
debug(D_WARNING, "rsa_copy failed with code %d", ret);
mbedtls_rsa_free(rsa);
psync_free(rsa);
free(rsa);
return PSYNC_INVALID_RSA;
} else {
mbedtls_rsa_set_padding(rsa, MBEDTLS_RSA_PKCS_V21, MBEDTLS_MD_SHA1);
@ -648,7 +647,7 @@ psync_rsa_privatekey_t prsa_load_private(const unsigned char *keydata, size_t ke
if (unlikely(ret)) {
debug(D_WARNING, "rsa_copy failed with code %d", ret);
mbedtls_rsa_free(rsa);
psync_free(rsa);
free(rsa);
return PSYNC_INVALID_RSA;
} else {
mbedtls_rsa_set_padding(rsa, MBEDTLS_RSA_PKCS_V21, MBEDTLS_MD_SHA1);
@ -670,7 +669,7 @@ psync_symmetric_key_t
psymkey_generate(const char *password, size_t keylen,
const unsigned char *salt, size_t saltlen,
size_t iterations) {
psync_symmetric_key_t key = (psync_symmetric_key_t)pmemlock_malloc(
psync_symmetric_key_t key = (psync_symmetric_key_t)malloc(
keylen + offsetof(psync_symmetric_key_struct_t, key));
mbedtls_md_context_t ctx;
mbedtls_md_init(&ctx);
@ -699,7 +698,7 @@ char *psymkey_derive(const char *username,
else
usercopy[i] = '*';
psync_sha512(usercopy, userlen, usersha512);
psync_free(usercopy);
free(usercopy);
mbedtls_md_init(&ctx);
mbedtls_md_setup(&ctx, mbedtls_md_info_from_type(MBEDTLS_MD_SHA512), 1);
const mbedtls_md_info_t *md_info = mbedtls_md_info_from_ctx(&ctx);
@ -718,12 +717,12 @@ prsa_encrypt_data(psync_rsa_publickey_t rsa, const unsigned char *data,
int code;
size_t rsalen = mbedtls_rsa_get_len(rsa);
ret = (psync_encrypted_symmetric_key_t)psync_malloc(
ret = (psync_encrypted_symmetric_key_t)malloc(
offsetof(psync_encrypted_data_struct_t, data) + rsalen);
if ((code = mbedtls_rsa_rsaes_oaep_encrypt(
rsa, rng_get, &rng,
NULL, 0, datalen, data, ret->data))) {
psync_free(ret);
free(ret);
debug(
D_WARNING,
"rsa_rsaes_oaep_encrypt failed with error=%d, datalen=%lu, rsasize=%d",
@ -745,7 +744,7 @@ psync_symmetric_key_t prsa_decrypt_data(psync_rsa_privatekey_t rsa,
&rng, NULL,
0, &len, data, buff, sizeof(buff)))
return PSYNC_INVALID_SYM_KEY;
ret = (psync_symmetric_key_t)pmemlock_malloc(
ret = (psync_symmetric_key_t)malloc(
offsetof(psync_symmetric_key_struct_t, key) + len);
ret->keylen = len;
memcpy(ret->key, buff, len);
@ -775,7 +774,7 @@ paes_create_encoder(psync_symmetric_key_t key) {
void paes_free_encoder(psync_aes256_encoder aes) {
putil_wipe(aes, sizeof(mbedtls_aes_context));
psync_free(aes);
free(aes);
}
psync_aes256_encoder
@ -789,7 +788,7 @@ paes_create_decoder(psync_symmetric_key_t key) {
void paes_free_decoder(psync_aes256_encoder aes) {
putil_wipe(aes, sizeof(mbedtls_aes_context));
psync_free(aes);
free(aes);
}
psync_rsa_signature_t
@ -799,7 +798,7 @@ prsa_sign_sha256_hash(psync_rsa_privatekey_t rsa,
int padding, hash_id;
size_t rsalen = mbedtls_rsa_get_len(rsa);
ret = (psync_rsa_signature_t)psync_malloc(
ret = (psync_rsa_signature_t)malloc(
offsetof(psync_symmetric_key_struct_t, key) + rsalen);
if (!ret)
return (psync_rsa_signature_t)(void *)PERROR_NO_MEMORY;

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;

13
pclsync/psuggest.c
View File

@ -115,7 +115,7 @@ static void dir_scan(void *ptr, ppath_fast_stat *st) {
size_t l, o;
l = strlen(st->name);
o = f->pathlen;
nf = (scan_folder *)psync_malloc(sizeof(scan_folder) + o + l + 2);
nf = (scan_folder *)malloc(sizeof(scan_folder) + o + l + 2);
psync_list_init(&nf->subfolders);
path = (char *)(nf + 1);
memcpy(path, f->path, o);
@ -184,7 +184,7 @@ static int sort_comp_tuple_rev(const void *p1, const void *p2) {
static void free_folder(scan_folder *f) {
psync_list_for_each_element_call(&f->subfolders, scan_folder, nextfolder,
free_folder);
psync_free(f);
free(f);
}
psuggested_folders_t *psuggest_scan_folder(const char *path) {
@ -233,12 +233,12 @@ psuggested_folders_t *psuggest_scan_folder(const char *path) {
ln += s->folder->pathlen + off + 2;
sf[cnt] = s;
descslen[cnt] = off + 1;
descs[cnt] = psync_malloc(descslen[cnt]);
descs[cnt] = malloc(descslen[cnt]);
memcpy(descs[cnt], buff, descslen[cnt]);
if (++cnt >= PSYNC_SCANNER_MAX_SUGGESTIONS)
break;
}
ret = psync_malloc(offsetof(psuggested_folders_t, entries) +
ret = malloc(offsetof(psuggested_folders_t, entries) +
sizeof(psuggested_folder_t) * cnt + ln);
str = ((char *)ret) + offsetof(psuggested_folders_t, entries) +
sizeof(psuggested_folder_t) * cnt;
@ -259,12 +259,11 @@ psuggested_folders_t *psuggest_scan_folder(const char *path) {
ret->entries[i].description = str;
memcpy(str, descs[i], descslen[i]);
str += descslen[i];
psync_free(descs[i]);
free(descs[i]);
debug(D_NOTICE, "suggesting %s (%s, %s)", ret->entries[i].localpath,
ret->entries[i].name, ret->entries[i].description);
}
psync_list_for_each_element_call(&suggestions, suggested_folder, list,
psync_free);
psync_list_for_each_element_call(&suggestions, suggested_folder, list, free);
free_folder(f);
return ret;
}

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

186
pclsync/psynclib.c
View File

@ -60,7 +60,6 @@
#include "plist.h"
#include "plocalnotify.h"
#include "plocalscan.h"
#include "pmemlock.h"
#include "pnetlibs.h"
#include "pnotify.h"
#include "prpc.h"
@ -85,9 +84,6 @@
#include "pupload.h"
#include "putil.h"
#define BUGHUNT 0
// Variable containing UNIX time of the last backup file deleted event
time_t lastBupDelEventTime = 0;
time_t bupNotifDelay = 300;
@ -99,10 +95,6 @@ typedef struct {
PSYNC_THREAD const char *psync_thread_name = "no name";
static psync_malloc_t psync_real_malloc = malloc;
static psync_realloc_t psync_real_realloc = realloc;
static psync_free_t psync_real_free = free;
const char *psync_database = NULL;
static int psync_libstate = 0;
@ -127,93 +119,12 @@ static inline int psync_status_is_offline() {
return PSYNC_INVALID_SYNCID; \
} while (0)
PSYNC_NOINLINE void *psync_emergency_malloc(size_t size) {
void *ret;
debug(D_WARNING, "could not allocate %lu bytes", size);
psync_try_free_memory();
ret = psync_real_malloc(size);
if (likely(ret))
#if IS_DEBUG
return memset(ret, 0xfa, size);
#else
return ret;
#endif
else {
debug(
D_CRITICAL,
"could not allocate %lu bytes even after freeing some memory, aborting",
size);
abort();
return NULL;
}
}
void *psync_malloc(size_t size) {
void *ptr;
#if 1 == BUGHUNT
void *callstack[128];
int frames = backtrace(callstack, 128);
char **strs = backtrace_symbols(callstack, frames);
#endif
ptr = psync_real_malloc(size);
#if 1 == BUGHUNT
printf("Allocated %zu bytes at %p\n", size, ptr);
for (int i = 0; i < frames; i++) {
printf("%s\n", strs[i]);
}
free(strs);
#endif
if (likely(ptr))
#if IS_DEBUG
return memset(ptr, 0xfa, size);
#else
return ptr;
#endif
else
return psync_emergency_malloc(size);
}
PSYNC_NOINLINE void *psync_emergency_realloc(void *ptr, size_t size) {
void *ret;
debug(D_WARNING, "could not reallocate %lu bytes", size);
psync_try_free_memory();
ret = psync_real_realloc(ptr, size);
if (likely(ret))
return ret;
else {
debug(D_CRITICAL,
"could not reallocate %lu bytes even after freeing some memory, "
"aborting",
size);
abort();
return NULL;
}
}
void *psync_realloc(void *ptr, size_t size) {
void *ret;
ret = psync_real_realloc(ptr, size);
if (likely(ret))
return ret;
else
return psync_emergency_realloc(ptr, size);
}
void psync_free(void *ptr) { psync_real_free(ptr); }
uint32_t psync_get_last_error() { return psync_error; }
void psync_set_database_path(const char *databasepath) {
psync_database = psync_strdup(databasepath);
}
void psync_set_alloc(psync_malloc_t malloc_call, psync_realloc_t realloc_call,
psync_free_t free_call) {
psync_real_malloc = malloc_call;
psync_real_realloc = realloc_call;
psync_real_free = free_call;
}
static void psync_stop_crypto_on_sleep() {
if (psync_setting_get_bool(_PS(sleepstopcrypto)) &&
pcryptofolder_is_unlocked()) {
@ -259,7 +170,6 @@ int psync_init() {
return 0;
}
}
pmemlock_init();
pcache_init();
psys_init();
@ -384,9 +294,9 @@ void psync_set_user_pass(const char *username, const char *password, int save) {
psync_set_string_value("pass", password);
} else {
pthread_mutex_lock(&psync_my_auth_mutex);
psync_free(psync_my_user);
free(psync_my_user);
psync_my_user = psync_strdup(username);
psync_free(psync_my_pass);
free(psync_my_pass);
if (password && password[0])
psync_my_pass = psync_strdup(password);
pthread_mutex_unlock(&psync_my_auth_mutex);
@ -401,7 +311,7 @@ void psync_set_pass(const char *password, int save) {
psync_set_string_value("pass", password);
else {
pthread_mutex_lock(&psync_my_auth_mutex);
psync_free(psync_my_pass);
free(psync_my_pass);
psync_my_pass = psync_strdup(password);
pthread_mutex_unlock(&psync_my_auth_mutex);
}
@ -441,7 +351,7 @@ void psync_logout(uint32_t auth_status, int doinvauth) {
pthread_mutex_lock(&psync_my_auth_mutex);
putil_wipe(psync_my_pass, sizeof(psync_my_pass));
psync_free(psync_my_pass);
free(psync_my_pass);
pthread_mutex_unlock(&psync_my_auth_mutex);
pstatus_set(PSTATUS_TYPE_ONLINE, PSTATUS_ONLINE_CONNECTING);
@ -501,7 +411,7 @@ apiservers_list_t *psync_get_apiservers(char **err) {
locations = papi_find_result2(bres, "locations", PARAM_ARRAY);
locationscnt = locations->length;
if (!locationscnt) {
psync_free(bres);
free(bres);
return NULL;
}
builder = psync_list_builder_create(sizeof(apiserver_info_t),
@ -569,7 +479,7 @@ void psync_unlink() {
ret = psync_sql_close();
pfile_delete(psync_database);
if (ret) {
psync_free(deviceid);
free(deviceid);
debug(D_ERROR, "failed to close database, exiting");
exit(1);
}
@ -579,7 +489,7 @@ void psync_unlink() {
res = psync_sql_prep_statement("REPLACE INTO setting (id, value) VALUES ('deviceid', ?)");
psync_sql_bind_string(res, 1, deviceid);
psync_sql_run_free(res);
psync_free(deviceid);
free(deviceid);
}
pthread_mutex_lock(&psync_my_auth_mutex);
putil_wipe(psync_my_auth, sizeof(psync_my_auth));
@ -617,7 +527,7 @@ int psync_tfa_type() { return psync_my_2fa_type; }
static void check_tfa_result(uint64_t result) {
if (result == 2064) {
if (pstatus_get(PSTATUS_TYPE_AUTH) == PSTATUS_AUTH_TFAREQ) {
psync_free(psync_my_2fa_token);
free(psync_my_2fa_token);
psync_my_2fa_token = NULL;
pstatus_set(PSTATUS_TYPE_AUTH, PSTATUS_AUTH_PROVIDED);
}
@ -777,10 +687,10 @@ psync_syncid_t psync_add_sync_by_folderid(const char *localpath,
if (!memcmp(syncmp, localpath, len) &&
(localpath[len] == 0 || localpath[len] == '/' ||
localpath[len] == '\\')) {
psync_free(syncmp);
free(syncmp);
return_isyncid(PERROR_LOCAL_IS_ON_PDRIVE);
}
psync_free(syncmp);
free(syncmp);
}
res = psync_sql_query("SELECT localpath FROM syncfolder");
if (unlikely_log(!res))
@ -1028,7 +938,7 @@ psuggested_folders_t *psync_get_sync_suggestions() {
home = ppath_home();
if (likely_log(home)) {
ret = psuggest_scan_folder(home);
psync_free(home);
free(home);
return ret;
} else {
psync_error = PERROR_NO_HOMEDIR;
@ -1067,7 +977,7 @@ int psync_is_lname_to_ignore(const char *name, size_t namelen) {
size_t ilen, off, pl;
char buff[120];
if (namelen >= sizeof(buff))
namelower = (char *)psync_malloc(namelen + 1);
namelower = (char *)malloc(namelen + 1);
else
namelower = buff;
memcpy(namelower, name, namelen);
@ -1096,13 +1006,13 @@ int psync_is_lname_to_ignore(const char *name, size_t namelen) {
pl--;
if (psync_match_pattern(namelower, pt, pl)) {
if (namelower != buff)
psync_free(namelower);
free(namelower);
debug(D_NOTICE, "ignoring file/folder %s", name);
return 1;
}
} while (sc);
if (namelower != buff)
psync_free(namelower);
free(namelower);
return 0;
}
@ -1161,7 +1071,7 @@ static int do_run_command_get_res(const char *cmd, size_t cmdlen,
psync_process_api_error(result);
}
if (result)
psync_free(res);
free(res);
else
*pres = res;
return (int)result;
@ -1210,7 +1120,7 @@ int psync_register(const char *email, const char *password, int termsaccepted,
psync_set_apiserver(PSYNC_API_HOST, PSYNC_LOCATIONID_DEFAULT);
}
psock_close(sock);
psync_free(res);
free(res);
return result;
}
@ -1242,12 +1152,12 @@ int psync_change_password(const char *currentpass, const char *newpass,
PAPI_BOOL("regetauth", 1)};
ret = run_command_get_res("changepassword", params, err, &res);
}
psync_free(device);
free(device);
if (ret)
return ret;
psync_strlcpy(psync_my_auth, papi_find_result2(res, "auth", PARAM_STR)->str,
sizeof(psync_my_auth));
psync_free(res);
free(res);
return 0;
}
@ -1260,7 +1170,7 @@ int psync_create_remote_folder_by_path(const char *path, char **err) {
if (ret)
return ret;
pfileops_create_fldr(papi_find_result2(res, "metadata", PARAM_HASH));
psync_free(res);
free(res);
pdiff_wake();
return 0;
}
@ -1276,7 +1186,7 @@ int psync_create_remote_folder(psync_folderid_t parentfolderid,
if (ret)
return ret;
pfileops_create_fldr(papi_find_result2(res, "metadata", PARAM_HASH));
psync_free(res);
free(res);
pdiff_wake();
return 0;
}
@ -1699,9 +1609,9 @@ int psync_remove_share(psync_shareid_t shareid, char **err) {
result = psync_account_stopshare(shareid, &err1);
if (result == 2075) {
result = 2025;
psync_free(err1);
free(err1);
} else {
psync_free(*err);
free(*err);
*err = err1;
}
debug(D_NOTICE, "erroris %s", *err);
@ -1731,9 +1641,9 @@ int psync_modify_share(psync_shareid_t shareid, uint32_t permissions,
psync_account_modifyshare(shareid, convert_perms(permissions), &err1);
if (result == 2075) {
result = 2025;
psync_free(err1);
free(err1);
} else {
psync_free(*err);
free(*err);
*err = err1;
}
debug(D_NOTICE, "erroris %s", *err);
@ -1751,7 +1661,7 @@ static void psync_del_all_except(void *ptr, ppath_fast_stat *st) {
debug(D_NOTICE, "deleting old update file %s", fp);
if (pfile_delete(fp))
debug(D_WARNING, "could not delete %s", fp);
psync_free(fp);
free(fp);
}
static char *psync_filename_from_res(const binresult *res) {
@ -1769,8 +1679,8 @@ static char *psync_filename_from_res(const binresult *res) {
nmarr[1] = nmd;
ppath_ls_fast(path, psync_del_all_except, (void *)nmarr);
ret = psync_strcat(path, "/", nmd, NULL);
psync_free(nmd);
psync_free(path);
free(nmd);
free(path);
return ret;
}
@ -1781,13 +1691,13 @@ static int psync_upload_result(binresult *res, psync_fileid_t *fileid) {
const binresult *meta =
papi_find_result2(res, "metadata", PARAM_ARRAY)->array[0];
*fileid = papi_find_result2(meta, "fileid", PARAM_NUM)->num;
psync_free(res);
free(res);
pdiff_wake();
return 0;
} else {
debug(D_WARNING, "uploadfile returned error %u: %s", (unsigned)result,
papi_find_result2(res, "error", PARAM_STR)->str);
psync_free(res);
free(res);
psync_process_api_error(result);
return result;
}
@ -1852,7 +1762,7 @@ static int psync_load_file(const char *local_path, char **data,
if (fstat(fd, &st1))
goto err1;
len = pfile_stat_size(&st1);
buff = psync_malloc(len);
buff = malloc(len);
if (!buff)
goto err1;
off = 0;
@ -1870,7 +1780,7 @@ static int psync_load_file(const char *local_path, char **data,
*length = len;
return 0;
}
psync_free(buff);
free(buff);
}
return -1;
err1:
@ -1887,7 +1797,7 @@ int psync_upload_file(psync_folderid_t folderid, const char *remote_filename,
if (psync_load_file(local_path, &data, &length))
return -2;
ret = psync_upload_data(folderid, remote_filename, data, length, fileid);
psync_free(data);
free(data);
return ret;
}
@ -1900,7 +1810,7 @@ int psync_upload_file_as(const char *remote_path, const char *remote_filename,
return -2;
ret =
psync_upload_data_as(remote_path, remote_filename, data, length, fileid);
psync_free(data);
free(data);
return ret;
}
@ -2020,7 +1930,7 @@ psync_folderid_t *psync_crypto_folderids() {
ret[l] = row[0];
if (++l == alloc) {
alloc *= 2;
ret = (psync_folderid_t *)psync_realloc(ret,
ret = (psync_folderid_t *)realloc(ret,
sizeof(psync_folderid_t) * alloc);
}
}
@ -2063,7 +1973,7 @@ int psync_crypto_change_crypto_pass(const char *oldpass, const char *newpass,
}
}
result = papi_find_result2(res, "result", PARAM_NUM)->num;
psync_free(res);
free(res);
if (result != 0)
debug(D_WARNING, "crypto_changeuserprivate returned %u",
(unsigned)result);
@ -2110,7 +2020,7 @@ int psync_crypto_change_crypto_pass_unlocked(const char *newpass,
}
}
result = papi_find_result2(res, "result", PARAM_NUM)->num;
psync_free(res);
free(res);
if (result != 0)
debug(D_WARNING, "crypto_changeuserprivate returned %u",
(unsigned)result);
@ -2139,7 +2049,7 @@ int psync_crypto_crypto_send_change_user_private() {
psync_apipool_release(api);
}
result = papi_find_result2(res, "result", PARAM_NUM)->num;
psync_free(res);
free(res);
if (result != 0)
debug(D_WARNING, "crypto_sendchangeuserprivate returned %u",
(unsigned)result);
@ -2386,12 +2296,12 @@ int psync_get_promo(char **url, uint64_t *width, uint64_t *height) {
if (result) {
debug(D_WARNING, "getpromourl returned %d", (int)result);
psync_free(res);
free(res);
return result;
}
if (!papi_find_result2(res, "haspromo", PARAM_BOOL)->num) {
psync_free(res);
free(res);
return result;
}
@ -2401,7 +2311,7 @@ int psync_get_promo(char **url, uint64_t *width, uint64_t *height) {
if (!papi_find_result2(res, "width", PARAM_NUM)->num) {
debug(D_NOTICE, "Parameter width not found.");
psync_free(res);
free(res);
return result;
}
@ -2411,14 +2321,14 @@ int psync_get_promo(char **url, uint64_t *width, uint64_t *height) {
if (!papi_find_result2(res, "height", PARAM_NUM)->num) {
debug(D_NOTICE, "Parameter height not found.");
psync_free(res);
free(res);
return result;
}
*height = papi_find_result2(res, "height", PARAM_NUM)->num;
debug(D_NOTICE, "Promo window Height: [%lu]", *height);
psync_free(res);
free(res);
return 0;
}
@ -2526,12 +2436,12 @@ int psync_is_folder_syncable(char *localPath, char **errMsg) {
if (!memcmp(syncmp, localPath, len) &&
(localPath[len] == 0 || localPath[len] == '/' ||
localPath[len] == '\\')) {
psync_free(syncmp);
free(syncmp);
*errMsg = psync_strdup("Folder is located on pCloud drive.");
return PERROR_LOCAL_IS_ON_PDRIVE;
}
psync_free(syncmp);
free(syncmp);
}
// Check if folder is not a child of an igrnored folder
@ -2880,12 +2790,12 @@ userinfo_t *psync_get_userinfo() {
PAPI_STR("timeformat", "timestamp")};
res = psync_api_run_command("userinfo", params);
if (!res) {
psync_free(res);
free(res);
return NULL;
}
err = papi_find_result2(res, "result", PARAM_NUM)->num;
if (err) {
psync_free(res);
free(res);
return NULL;
}
@ -2900,7 +2810,7 @@ userinfo_t *psync_get_userinfo() {
language = cres->str;
llanguage =
(cres->length + sizeof(void *)) / sizeof(void *) * sizeof(void *);
info = (userinfo_t *)psync_malloc(sizeof(userinfo_t) + lemail + lcurrency +
info = (userinfo_t *)malloc(sizeof(userinfo_t) + lemail + lcurrency +
llanguage);
ptr = (char *)(info + 1);
memcpy(ptr, email, lemail);
@ -2948,7 +2858,7 @@ userinfo_t *psync_get_userinfo() {
info->usedquota = papi_find_result2(res, "usedquota", PARAM_NUM)->num;
info->freequota = papi_find_result2(res, "freequota", PARAM_NUM)->num;
info->registered = papi_find_result2(res, "registered", PARAM_NUM)->num;
psync_free(res);
free(res);
return info;
}

6
pclsync/psynclib.h
View File

@ -514,10 +514,6 @@ typedef void (*psync_free_t)(void *);
typedef void (*psync_generic_callback_t)();
void *psync_malloc(size_t size);
void *psync_realloc(void *ptr, size_t size);
void psync_free(void *ptr);
/* Event callback is called every time a download/upload is started/finished,
* quota is changed, folder is shared or similar. Look at the PEVENT_ constants
* for a list of possible events.
@ -668,7 +664,7 @@ void psync_unlink();
* psync_tfa_send_nofification() - sends notification with two factor
* authentication code to all already logged in devices. If devices_list is not
* null it is filled in with list of user's devices. In this case the caller is
* supposed to free the list with a single call to psync_free(). Returns -1 in
* supposed to free the list with a single call to free(). Returns -1 in
* case of network error or one of the positive error codes listed at
* https://docsqa2.pcloud.com/methods/auth/tfa_sendcodeviasysnotification.html
*

4
pclsync/psys.c
View File

@ -4,7 +4,6 @@
#include <sys/resource.h>
#include "plibs.h"
#include "pmemlock.h"
#include "psys.h"
static uid_t psync_uid;
@ -51,8 +50,7 @@ void psys_init() {
psync_gids = psync_new_cnt(gid_t, psync_gids_cnt);
if (unlikely_log(getgroups(psync_gids_cnt, psync_gids) != psync_gids_cnt))
psync_gids_cnt = 0;
pmemlock_set_pagesize(sysconf(_SC_PAGESIZE));
debug(D_NOTICE, "detected page size %d", pmemlock_get_pagesize());
debug(D_NOTICE, "detected page size %ld", sysconf(_SC_PAGESIZE));
}
time_t psys_time_seconds() {

20
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;
@ -723,7 +723,7 @@ static int sock_writeall(int sock, const void *buff, size_t len) {
static stream_t *stream_create(async_params_t *prms, size_t addsize) {
psync_tree *parent;
stream_t *ret;
ret = (stream_t *)psync_malloc(sizeof(stream_t) + addsize);
ret = (stream_t *)malloc(sizeof(stream_t) + addsize);
ret->streamid = ++prms->laststreamid;
ret->flags = 0;
ret->free = NULL;
@ -747,7 +747,7 @@ static void stream_destroy(stream_t *s) {
}
if (s->free)
s->free(s, PSYNC_ASYNC_ERROR_NET);
psync_free(s);
free(s);
}
static int stream_process_data(async_params_t *prms) {
@ -1065,8 +1065,8 @@ void ptask_cfldr_save_fldrkey(void *ptr) {
psync_sql_bind_uint(res, 1, t->id);
psync_sql_bind_blob(res, 2, (const char *)t->key->data, t->key->datalen);
psync_sql_run_free(res);
psync_free(t->key);
psync_free(t);
free(t->key);
free(t);
}
void ptask_cfldr_save_filekey(void *ptr) {
@ -1079,6 +1079,6 @@ void ptask_cfldr_save_filekey(void *ptr) {
psync_sql_bind_uint(res, 2, t->hash);
psync_sql_bind_blob(res, 3, (const char *)t->key->data, t->key->datalen);
psync_sql_run_free(res);
psync_free(t->key);
psync_free(t);
free(t->key);
free(t);
}

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;

6
pclsync/ptools.c
View File

@ -411,7 +411,7 @@ void ptools_send_psyncs_event(const char *binapi, const char *auth) {
int intRes;
int syncCnt = 0;
errMsg = (char *)psync_malloc(1024 * sizeof(char));
errMsg = (char *)malloc(1024 * sizeof(char));
errMsg[0] = 0;
time(&rawtime);
@ -425,7 +425,7 @@ void ptools_send_psyncs_event(const char *binapi, const char *auth) {
if (syncCnt < 1) {
debug(D_NOTICE, "No syncs, skip the event.");
psync_free(errMsg);
free(errMsg);
return;
}
@ -447,7 +447,7 @@ void ptools_send_psyncs_event(const char *binapi, const char *auth) {
psync_sql_run_free(sql);
}
psync_free(errMsg);
free(errMsg);
}
int ptools_set_backend_file_dates(uint64_t fileid, time_t ctime, time_t mtime) {

106
pclsync/publiclinks.c
View File

@ -103,14 +103,14 @@ static void modify_screenshot_public_link(void *par) {
"account required.");
}
psync_free(linkidp);
psync_free(bres);
free(linkidp);
free(bres);
}
int64_t do_psync_screenshot_public_link(const char *path, int hasdelay,
uint64_t delay, char **link /*OUT*/,
char **err /*OUT*/) {
scr_params *params = psync_malloc(sizeof(scr_params));
scr_params *params = malloc(sizeof(scr_params));
int64_t ret =
do_psync_file_public_link(path, &params->linkid, link, err, 0, 0, 0);
if (hasdelay) {
@ -118,7 +118,7 @@ int64_t do_psync_screenshot_public_link(const char *path, int hasdelay,
prun_thread1("Modify link expiration.", modify_screenshot_public_link,
params);
} else
psync_free(params);
free(params);
return ret;
}
@ -150,7 +150,7 @@ int64_t do_psync_file_public_link(const char *path, int64_t *plinkid,
int numparam = 2 + !!expire + !!maxdownloads + !!maxtraffic;
int pind = 1;
t = (binparam *)psync_malloc(numparam * sizeof(binparam));
t = (binparam *)malloc(numparam * sizeof(binparam));
init_param_str(t, "auth", psync_my_auth);
init_param_str(t + pind++, "path", path);
if (expire)
@ -163,12 +163,12 @@ int64_t do_psync_file_public_link(const char *path, int64_t *plinkid,
if (unlikely(!api)) {
debug(D_WARNING, "Can't gat api from the pool. No pool ?\n");
*err = psync_strndup("Connection error.", 17);
psync_free(t);
free(t);
return 1;
}
bres = papi_send(api, "getfilepublink", sizeof("getfilepublink") - 1,
t, pind, -1, 1);
psync_free(t);
free(t);
}
if (likely(bres))
@ -197,7 +197,7 @@ int64_t do_psync_file_public_link(const char *path, int64_t *plinkid,
*plinkid = linkid;
free_ret:
psync_free(bres);
free(bres);
return (int64_t)result;
}
@ -227,7 +227,7 @@ int64_t do_psync_folder_public_link(const char *path, char **link /*OUT*/,
int numparam = 2 + !!expire + !!maxdownloads + !!maxtraffic;
int pind = 1;
t = (binparam *)psync_malloc(numparam * sizeof(binparam));
t = (binparam *)malloc(numparam * sizeof(binparam));
init_param_str(t, "auth", psync_my_auth);
init_param_str(t + pind++, "path", path);
if (expire)
@ -244,7 +244,7 @@ int64_t do_psync_folder_public_link(const char *path, char **link /*OUT*/,
}
bres = papi_send(api, "getfolderpublink",
sizeof("getfolderpublink") - 1, t, pind, -1, 1);
psync_free(t);
free(t);
}
if (likely(bres))
psync_apipool_release(api);
@ -271,7 +271,7 @@ int64_t do_psync_folder_public_link(const char *path, char **link /*OUT*/,
*link = psync_strndup(rescode, strlen(rescode));
result = papi_find_result2(bres, "linkid", PARAM_NUM)->num;
psync_free(bres);
free(bres);
return result;
}
@ -301,7 +301,7 @@ int64_t do_psync_folder_public_link_full(const char *path, char **link /*OUT*/,
int numparam = 2 + !!expire + !!maxdownloads + !!maxtraffic + !!password;
int pind = 1;
t = (binparam *)psync_malloc(numparam * sizeof(binparam));
t = (binparam *)malloc(numparam * sizeof(binparam));
init_param_str(t, "auth", psync_my_auth);
init_param_str(t + pind++, "path", path);
if (password)
@ -320,7 +320,7 @@ int64_t do_psync_folder_public_link_full(const char *path, char **link /*OUT*/,
}
bres = papi_send(api, "getfolderpublink",
sizeof("getfolderpublink") - 1, t, pind, -1, 1);
psync_free(t);
free(t);
}
if (likely(bres))
@ -349,7 +349,7 @@ int64_t do_psync_folder_public_link_full(const char *path, char **link /*OUT*/,
*link = psync_strndup(rescode, strlen(rescode));
result = papi_find_result2(bres, "linkid", PARAM_NUM)->num;
psync_free(bres);
free(bres);
return result;
}
@ -397,7 +397,7 @@ int64_t do_psync_folder_updownlink_link(int canupload,
}
result = 0;
psync_free(bres);
free(bres);
return result;
}
@ -428,21 +428,21 @@ int64_t do_ptree_public_link(const char *linkname, const char *root,
if (unlikely(!(!!root + !!numfolders + !!numfiles)))
return -3;
t = (binparam *)psync_malloc(numparam * sizeof(binparam));
t = (binparam *)malloc(numparam * sizeof(binparam));
init_param_str(t, "auth", psync_my_auth);
init_param_str(t + pind++, "name", linkname);
if (root) {
ids = (char *)psync_malloc(FOLDERID_ENTRY_SIZE);
ids = (char *)malloc(FOLDERID_ENTRY_SIZE);
id = psync_fsfolderid_by_path(root, 0);
k = sprintf(ids, "%lld", (long long)id);
init_param_str(t + pind++, "folderid", ids);
}
if (numfolders) {
ids1 = (char *)psync_malloc(numfolders * FOLDERID_ENTRY_SIZE);
ids1 = (char *)malloc(numfolders * FOLDERID_ENTRY_SIZE);
idsp = ids1;
for (i = 0; i < numfolders; ++i) {
id = psync_fsfolderid_by_path(folders[i], 0);
@ -462,7 +462,7 @@ int64_t do_ptree_public_link(const char *linkname, const char *root,
psync_uint_row row;
psync_fspath_t *filep;
ids2 = (char *)psync_malloc(numfiles * FOLDERID_ENTRY_SIZE);
ids2 = (char *)malloc(numfiles * FOLDERID_ENTRY_SIZE);
idsp = ids2;
for (i = 0; i < numfiles; ++i) {
psync_sql_rdlock();
@ -540,14 +540,14 @@ int64_t do_ptree_public_link(const char *linkname, const char *root,
result = papi_find_result2(bres, "linkid", PARAM_NUM)->num;
if (ids)
psync_free(ids);
free(ids);
if (ids1)
psync_free(ids1);
free(ids1);
if (ids2)
psync_free(ids2);
free(ids2);
psync_free(bres);
psync_free(t);
free(bres);
free(t);
return result;
}
@ -601,7 +601,7 @@ int cache_links(char *err, size_t err_size /*OUT*/) {
debug(D_WARNING, "Send command returned in valid result.\n");
//*err = psync_strndup("Connection error.", 17);
snprintf(err, err_size, "Connection error.");
psync_free(bres);
free(bres);
return 0;
}
result = papi_find_result2(bres, "result", PARAM_NUM)->num;
@ -612,7 +612,7 @@ int cache_links(char *err, size_t err_size /*OUT*/) {
debug(D_WARNING, "command listpublinks returned error code %u",
(unsigned)result);
psync_process_api_error(result);
psync_free(bres);
free(bres);
if (psync_handle_api_result(result) == PSYNC_NET_TEMPFAIL)
return -result;
else {
@ -624,7 +624,7 @@ int cache_links(char *err, size_t err_size /*OUT*/) {
publinks = papi_find_result2(bres, "publinks", PARAM_ARRAY);
linkscnt = publinks->length;
if (!linkscnt) {
psync_free(bres);
free(bres);
return 0;
}
for (i = 0; i < linkscnt; ++i) {
@ -708,7 +708,7 @@ int cache_links(char *err, size_t err_size /*OUT*/) {
psync_sql_run_free(q);
}
psync_free(bres);
free(bres);
return linkscnt;
}
@ -749,7 +749,7 @@ int do_psync_delete_link(int64_t linkid, char **err /*OUT*/) {
return -1;
}
}
psync_free(bres);
free(bres);
return 0;
}
@ -798,7 +798,7 @@ int do_psync_change_link(unsigned long long linkid, unsigned long long expire,
int numparam = 5; // +!!expire + !!maxdownloads + !!maxtraffic + !!password;
int pind = 1;
t = (binparam *)psync_malloc(numparam * sizeof(binparam));
t = (binparam *)malloc(numparam * sizeof(binparam));
init_param_str(t, "auth", psync_my_auth);
init_param_num(t + pind++, "linkid", linkid);
if (linkpassword)
@ -829,7 +829,7 @@ int do_psync_change_link(unsigned long long linkid, unsigned long long expire,
}
bres = papi_send(api, "changepublink", sizeof("changepublink") - 1, t,
pind, -1, 1);
psync_free(t);
free(t);
result = process_bres("deletepublink", bres, api, err);
return result;
}
@ -859,7 +859,7 @@ int do_change_link_expire(unsigned long long linkid, unsigned long long expire,
}
result = process_bres("changepublink", bres, api, err);
psync_free(bres);
free(bres);
return result;
}
@ -888,7 +888,7 @@ int do_change_link_password(unsigned long long linkid, const char *password,
bres = papi_send2(api, "changepublink", paramsd);
}
result = process_bres("changepublink", bres, api, err);
psync_free(bres);
free(bres);
return result;
}
@ -919,7 +919,7 @@ int do_change_link_enable_upload(unsigned long long linkid,
}
result = process_bres("changepublink", bres, api, err);
psync_free(bres);
free(bres);
return result;
}
@ -953,7 +953,7 @@ int64_t do_psync_upload_link(const char *path, const char *comment,
int numparam = 3 + !!expire + !!maxspace + !!maxfiles;
int pind = 1;
t = (binparam *)psync_malloc(numparam * sizeof(binparam));
t = (binparam *)malloc(numparam * sizeof(binparam));
init_param_str(t, "auth", psync_my_auth);
init_param_str(t + pind++, "path", path);
init_param_str(t + pind++, "comment", comment);
@ -971,7 +971,7 @@ int64_t do_psync_upload_link(const char *path, const char *comment,
}
bres = papi_send(api, "createuploadlink",
sizeof("createuploadlink") - 1, t, pind, -1, 1);
psync_free(t);
free(t);
}
if (likely(bres))
@ -1002,7 +1002,7 @@ int64_t do_psync_upload_link(const char *path, const char *comment,
result = papi_find_result2(bres, "uploadlinkid", PARAM_NUM)->num;
psync_free(bres);
free(bres);
return result;
}
@ -1025,7 +1025,7 @@ int do_psync_delete_upload_link(int64_t uploadlinkid, char **err /*OUT*/) {
bres = papi_send2(api, "deleteuploadlink", params);
result = process_bres("deletepublink", bres, api, err);
psync_free(bres);
free(bres);
return result;
}
@ -1142,12 +1142,12 @@ plink_contents_t *do_show_link(const char *code, char **err /*OUT*/) {
if (meta) {
contents = papi_check_result2(meta, "contents", PARAM_ARRAY);
if (!contents) {
psync_free(bres);
free(bres);
return 0;
}
concnt = contents->length;
if (!concnt) {
psync_free(bres);
free(bres);
return 0;
}
builder = psync_list_builder_create(sizeof(link_cont_t),
@ -1171,10 +1171,10 @@ plink_contents_t *do_show_link(const char *code, char **err /*OUT*/) {
pcont->icon = papi_find_result2(link, "icon", PARAM_NUM)->num;
}
ret = (plink_contents_t *)psync_list_builder_finalize(builder);
psync_free(bres);
free(bres);
return ret;
}
psync_free(bres);
free(bres);
return 0;
}
@ -1296,7 +1296,7 @@ int cache_upload_links(char **err /*OUT*/) {
psync_sql_run_free(q);
}
psync_free(bres);
free(bres);
return linkscnt;
}
@ -1313,11 +1313,11 @@ void cache_links_all() {
if (err) {
debug(D_WARNING, "Problem cacheing links errcode %d errmsg[%s]\n", ret,
err);
psync_free(err);
free(err);
}
}
if (err)
psync_free(err);
free(err);
}
int do_delete_all_links(int64_t folderid, int64_t fileid, char **err) {
@ -1446,7 +1446,7 @@ preciever_list_t *do_list_email_with_access(unsigned long long linkid,
if (!lcnt) {
ret = (preciever_list_t *)psync_list_builder_finalize(builder);
psync_free(bres);
free(bres);
return ret;
}
for (i = 0; i < lcnt; ++i) {
@ -1463,7 +1463,7 @@ preciever_list_t *do_list_email_with_access(unsigned long long linkid,
}
ret = (preciever_list_t *)psync_list_builder_finalize(builder);
psync_free(bres);
free(bres);
return ret;
}
@ -1487,7 +1487,7 @@ int do_link_add_access(unsigned long long linkid, const char *mail,
bres = papi_send2(api, "publink/addaccess", params);
result = process_bres("publink/addaccess", bres, api, err);
psync_free(bres);
free(bres);
return result;
}
@ -1510,7 +1510,7 @@ int do_link_remove_access(unsigned long long linkid,
bres = papi_send2(api, "publink/removeaccess", params);
result = process_bres("publink/removeaccess", bres, api, err);
psync_free(bres);
free(bres);
return result;
}
@ -1566,7 +1566,7 @@ bookmarks_list_t *do_cache_bookmarks(char **err) {
offsetof(bookmarks_list_t, entries));
if (!lcnt) {
ret = (bookmarks_list_t *)psync_list_builder_finalize(builder);
psync_free(bres);
free(bres);
return ret;
}
@ -1599,7 +1599,7 @@ bookmarks_list_t *do_cache_bookmarks(char **err) {
}
ret = (bookmarks_list_t *)psync_list_builder_finalize(builder);
psync_free(bres);
free(bres);
return ret;
}
@ -1621,7 +1621,7 @@ int do_remove_bookmark(const char *code, int locationid, char **err) {
bres = papi_send2(api, "publink/unpin", params);
result = process_bres("publink/unpin", bres, api, err);
psync_free(bres);
free(bres);
return result;
}
@ -1646,7 +1646,7 @@ int do_change_bookmark(const char *code, int locationid, const char *name,
bres = papi_send2(api, "publink/changepin", params);
result = process_bres("publink/changepin", bres, api, err);
psync_free(bres);
free(bres);
return result;
}

108
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;
}
@ -695,7 +695,7 @@ static int upload_file(const char *localpath, const unsigned char *hashhex,
params, ARRAY_SIZE(params), fsize, 0)))
goto err1;
bw = 0;
buff = psync_malloc(PSYNC_COPY_BUFFER_SIZE);
buff = malloc(PSYNC_COPY_BUFFER_SIZE);
while (bw < fsize) {
if (unlikely(upload->stop)) {
debug(D_NOTICE, "upload of %s stopped", localpath);
@ -720,7 +720,7 @@ static int upload_file(const char *localpath, const unsigned char *hashhex,
upload->uploaded += rrd;
add_bytes_uploaded(rrd);
}
psync_free(buff);
free(buff);
pfile_close(fd);
psync_set_default_sendbuf(api);
pdiff_lock();
@ -733,7 +733,7 @@ static int upload_file(const char *localpath, const unsigned char *hashhex,
}
result = papi_find_result2(res, "result", PARAM_NUM)->num;
if (unlikely(result)) {
psync_free(res);
free(res);
debug(D_WARNING, "command uploadfile returned code %u", (unsigned)result);
psync_process_api_error(result);
if (psync_handle_api_result(result) == PSYNC_NET_TEMPFAIL)
@ -773,16 +773,16 @@ static int upload_file(const char *localpath, const unsigned char *hashhex,
"uploaded file differs localsize=%lu, remotesize=%lu, localhash=%s, "
"remotehash=%s",
(unsigned long)fsize, (unsigned long)rsize, hashhex, hashhexsrv);
psync_free(res);
free(res);
return -1;
}
psync_free(res);
free(res);
pdiff_wake();
debug(D_NOTICE, "file %s uploaded to %lu/%s", localpath,
(long unsigned)folderid, name);
return 0;
err2:
psync_free(buff);
free(buff);
err1:
psync_apipool_release_bad(api);
err0:
@ -809,7 +809,7 @@ static int upload_range(psock_t *api, psync_upload_range_list_t *r,
return PSYNC_NET_TEMPFAIL;
bw = 0;
buff = psync_malloc(PSYNC_COPY_BUFFER_SIZE);
buff = malloc(PSYNC_COPY_BUFFER_SIZE);
while (bw < r->len) {
if (unlikely(upload->stop)) {
debug(D_NOTICE, "upload stopped");
@ -829,10 +829,10 @@ static int upload_range(psock_t *api, psync_upload_range_list_t *r,
upload->uploaded += rrd;
add_bytes_uploaded(rrd);
}
psync_free(buff);
free(buff);
return PSYNC_NET_OK;
err0:
psync_free(buff);
free(buff);
return PSYNC_NET_TEMPFAIL;
}
@ -943,7 +943,7 @@ static int upload_save(psock_t *api, psync_fileid_t localfileid,
ret = PSYNC_NET_OK;
pdiff_wake();
}
psync_free(res);
free(res);
} else
ret = PSYNC_NET_TEMPFAIL;
pdiff_unlock();
@ -986,7 +986,7 @@ static int upload_big_file(const char *localpath, const unsigned char *hashhex,
goto err0;
result = papi_find_result2(res, "result", PARAM_NUM)->num;
if (unlikely(result)) {
psync_free(res);
free(res);
psync_apipool_release(api);
psync_process_api_error(result);
debug(D_WARNING, "upload_create returned %lu", (unsigned long)result);
@ -996,7 +996,7 @@ static int upload_big_file(const char *localpath, const unsigned char *hashhex,
return 0;
}
uploadid = papi_find_result2(res, "uploadid", PARAM_NUM)->num;
psync_free(res);
free(res);
psync_sql_start_transaction();
sql = psync_sql_query_nolock("SELECT id FROM localfile WHERE id=?");
psync_sql_bind_uint(sql, 1, localfileid);
@ -1030,8 +1030,7 @@ static int upload_big_file(const char *localpath, const unsigned char *hashhex,
if (unlikely(fd == INVALID_HANDLE_VALUE)) {
debug(D_WARNING, "could not open local file %s", localpath);
psync_apipool_release(api);
psync_list_for_each_element_call(&rlist, psync_upload_range_list_t, list,
psync_free);
psync_list_for_each_element_call(&rlist, psync_upload_range_list_t, list, free);
return -1;
}
if (likely(uploadoffset < fsize)) {
@ -1089,12 +1088,12 @@ static int upload_big_file(const char *localpath, const unsigned char *hashhex,
if (fileid &&
psync_net_scan_file_for_blocks(api, &rlist, fileid, hash, fd) ==
PSYNC_NET_TEMPFAIL) {
psync_free(nname);
free(nname);
goto err1;
}
} else
psync_sql_free_result(sql);
psync_free(nname);
free(nname);
} else
psync_sql_free_result(sql);
}
@ -1108,10 +1107,10 @@ static int upload_big_file(const char *localpath, const unsigned char *hashhex,
psync_net_scan_upload_for_blocks(api, &rlist,
psync_get_result_cell(fr, id, 0),
fd) == PSYNC_NET_TEMPFAIL) {
psync_free(fr);
free(fr);
goto err1;
}
psync_free(fr);
free(fr);
}
rid = 0;
respwait = 0;
@ -1154,7 +1153,7 @@ static int upload_big_file(const char *localpath, const unsigned char *hashhex,
result = papi_find_result2(res, "result", PARAM_NUM)->num;
if (unlikely(result)) {
id = papi_find_result2(res, "id", PARAM_NUM)->num;
psync_free(res);
free(res);
psync_process_api_error(result);
if (unlikely_log(!id))
goto err1;
@ -1163,7 +1162,7 @@ static int upload_big_file(const char *localpath, const unsigned char *hashhex,
if (unlikely_log(!res))
goto err1;
respwait--;
psync_free(res);
free(res);
}
psync_list_for_each_element(le2, &rlist, psync_upload_range_list_t,
list) if (le2->id == id) {
@ -1193,7 +1192,7 @@ static int upload_big_file(const char *localpath, const unsigned char *hashhex,
"file size mismatch after upload, expected: %lu, got: %lu",
(unsigned long)fsize,
(unsigned long)papi_find_result2(res, "size", PARAM_NUM)->num);
psync_free(res);
free(res);
goto err1;
} else if (unlikely(memcmp(
papi_find_result2(res, PSYNC_CHECKSUM, PARAM_STR)->str,
@ -1203,12 +1202,12 @@ static int upload_big_file(const char *localpath, const unsigned char *hashhex,
"hash mismatch after upload, expected: %." NTO_STR(
PSYNC_HASH_DIGEST_HEXLEN) "s, got: %." NTO_STR(PSYNC_HASH_DIGEST_HEXLEN) "s",
hashhex, papi_find_result2(res, PSYNC_CHECKSUM, PARAM_STR)->str);
psync_free(res);
free(res);
goto err1;
} else
assert(respwait == 0);
}
psync_free(res);
free(res);
}
restart:
if (le->type == PSYNC_URANGE_UPLOAD) {
@ -1244,8 +1243,7 @@ static int upload_big_file(const char *localpath, const unsigned char *hashhex,
respwait++;
uploadoffset += le->len;
}
psync_list_for_each_element_call(&rlist, psync_upload_range_list_t, list,
psync_free);
psync_list_for_each_element_call(&rlist, psync_upload_range_list_t, list, free);
if (pfile_size(fd) != fsize) {
debug(D_NOTICE, "file %s changed filesize while uploading, restarting task",
localpath);
@ -1265,15 +1263,13 @@ static int upload_big_file(const char *localpath, const unsigned char *hashhex,
}
err1:
pfile_close(fd);
psync_list_for_each_element_call(&rlist, psync_upload_range_list_t, list,
psync_free);
psync_list_for_each_element_call(&rlist, psync_upload_range_list_t, list, free);
err0:
psync_apipool_release_bad(api);
return -1;
errp:
pfile_close(fd);
psync_list_for_each_element_call(&rlist, psync_upload_range_list_t, list,
psync_free);
psync_list_for_each_element_call(&rlist, psync_upload_range_list_t, list, free);
psync_apipool_release_bad(api);
return 0;
}
@ -1283,7 +1279,7 @@ static void delete_uploadid(psync_uploadid_t uploadid) {
PAPI_NUM("uploadid", uploadid)};
binresult *res;
res = psync_api_run_command("upload_delete", params);
psync_free(res);
free(res);
}
static void delete_uploadids(psync_fileid_t localfileid) {
@ -1302,7 +1298,7 @@ static void delete_uploadids(psync_fileid_t localfileid) {
psync_sql_bind_uint(res, 1, localfileid);
psync_sql_run_free(res);
}
psync_free(rows);
free(rows);
}
static void delete_from_localfile(psync_fileid_t localfileid) {
@ -1373,7 +1369,7 @@ static int task_uploadfile(psync_syncid_t syncid, psync_folderid_t localfileid,
if (stat(localpath, &st)) {
debug(D_NOTICE, "can not stat %s anymore, failing for now",
localpath);
psync_free(localpath);
free(localpath);
return -1;
}
ctime = ptimer_time();
@ -1382,7 +1378,7 @@ static int task_uploadfile(psync_syncid_t syncid, psync_folderid_t localfileid,
if (ret == 10) {
debug(D_NOTICE, "file %s kept changing %d times, skipping for now",
localpath, ret);
psync_free(localpath);
free(localpath);
return -1;
}
debug(D_NOTICE, "file %s got old enough", localpath);
@ -1391,7 +1387,7 @@ static int task_uploadfile(psync_syncid_t syncid, psync_folderid_t localfileid,
lock = psync_lock_file(localpath);
if (!lock) {
debug(D_NOTICE, "file %s is currently locked, skipping for now", localpath);
psync_free(localpath);
free(localpath);
psys_sleep_milliseconds(PSYNC_SLEEP_ON_LOCKED_FILE);
return -1;
}
@ -1408,7 +1404,7 @@ static int task_uploadfile(psync_syncid_t syncid, psync_folderid_t localfileid,
ret = psync_get_upload_checksum(uploadid, uhashhex, &ufsize);
if (ret == PSYNC_NET_TEMPFAIL) {
psync_unlock_file(lock);
psync_free(localpath);
free(localpath);
return -1;
} else if (ret == PSYNC_NET_PERMFAIL)
uploadid = 0;
@ -1422,7 +1418,7 @@ static int task_uploadfile(psync_syncid_t syncid, psync_folderid_t localfileid,
debug(D_WARNING, "could not open local file %s, deleting it from localfile",
localpath);
psync_unlock_file(lock);
psync_free(localpath);
free(localpath);
delete_from_localfile(localfileid);
return 0;
}
@ -1451,7 +1447,7 @@ static int task_uploadfile(psync_syncid_t syncid, psync_folderid_t localfileid,
(unsigned long)localfileid);
psync_sql_free_result(res);
psync_unlock_file(lock);
psync_free(localpath);
free(localpath);
return 0;
}
psync_sql_free_result(res);
@ -1487,8 +1483,8 @@ static int task_uploadfile(psync_syncid_t syncid, psync_folderid_t localfileid,
if (ret == 1 || ret == -1) {
psync_unlock_file(lock);
psync_free(nname);
psync_free(localpath);
free(nname);
free(localpath);
return ret == 1 ? 0 : -1;
}
memcpy(upload->hash, hashhex, PSYNC_HASH_DIGEST_HEXLEN);
@ -1530,8 +1526,8 @@ static int task_uploadfile(psync_syncid_t syncid, psync_folderid_t localfileid,
}
}
psync_unlock_file(lock);
psync_free(nname);
psync_free(localpath);
free(nname);
free(localpath);
if (!ret)
delete_uploadids(localfileid);
return ret;
@ -1578,7 +1574,7 @@ static void task_run_upload_file_thread(void *ptr) {
wake_upload_when_ready();
pthread_mutex_unlock(&current_uploads_mutex);
pstatus_upload_recalc_async();
psync_free(ut);
free(ut);
}
static int task_run_uploadfile(uint64_t taskid, psync_syncid_t syncid,
@ -1606,7 +1602,7 @@ static int task_run_uploadfile(uint64_t taskid, psync_syncid_t syncid,
psync_sql_bind_uint(res, 1, taskid);
psync_sql_run_free(res);
len = strlen(filename);
ut = (upload_task_t *)psync_malloc(offsetof(upload_task_t, filename) + len +
ut = (upload_task_t *)malloc(offsetof(upload_task_t, filename) + len +
1);
ut->upllist.taskid = taskid;
ut->upllist.localfileid = localfileid;
@ -1636,7 +1632,7 @@ static int task_run_uploadfile(uint64_t taskid, psync_syncid_t syncid,
}
pthread_mutex_unlock(&current_uploads_mutex);
if (stop) {
psync_free(ut);
free(ut);
res = psync_sql_prep_statement("UPDATE task SET inprogress=0 WHERE id=?");
psync_sql_bind_uint(res, 1, taskid);
psync_sql_run_free(res);
@ -1741,7 +1737,7 @@ static void upload_thread() {
}
} else if (type != PSYNC_UPLOAD_FILE)
psys_sleep_milliseconds(PSYNC_SLEEP_ON_FAILED_UPLOAD);
psync_free(row);
free(row);
continue;
}

13
pclsync_lib.cpp
View File

@ -289,7 +289,7 @@ static void status_change(pstatus_t *status) {
static int cryptocheck = 0;
char *err;
err = (char *)psync_malloc(1024);
err = (char *)malloc(1024);
std::cout << "Down: " << status->downloadstr << "| Up: " << status->uploadstr
<< ", status is " << status2string(status->status) << std::endl;
@ -348,8 +348,9 @@ static void status_change(pstatus_t *status) {
(int)status->status, status2string(status->status));
}
if (err)
psync_free(err);
if (err) {
free(err);
}
}
int clib::pclsync_lib::start_crypto(const char *pwd) {
@ -429,7 +430,7 @@ int clib::pclsync_lib::list_sync_folders(const char *unused) {
pshm_write(folders, folderssz);
pthread_mutex_unlock(&mtx);
psync_free(folders);
free(folders);
return 0;
}
@ -463,10 +464,10 @@ int clib::pclsync_lib::init() {
std::cout << "logged in with user " << username_old << ", not "
<< username_ << ", unlinking" << std::endl;
psync_unlink();
psync_free(username_old);
free(username_old);
return 2;
}
psync_free(username_old);
free(username_old);
}
prpc_register(STARTCRYPTO, &start_crypto);