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

Fix #103: Refactor putil to use putil_ namespace and enforce encapsulation 

All public functions in putil now use the putil_ prefix (e.g., putil_strdup,
putil_strcat, putil_time_format, putil_base64_encode, etc.). Internal
variables (normalize_table, base64_reverse_table) and the constructor remain
static. Updated all 34 call-site files across pclsync accordingly.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
This commit is contained in:
Levi Neely 2026-03-02 22:11:12 +01:00
parent d6858a0166
commit b4f28ed681
34 changed files with 317 additions and 317 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
pclsync/pbusinessaccount.c
View File

@ -73,14 +73,14 @@ static int handle_result(const binresult *bres, uint64_t result, char **err) {
if (strlen(errorret) == 0) if (strlen(errorret) == 0)
errorret = papi_find_result2(bres, "message", PARAM_STR)->str; errorret = papi_find_result2(bres, "message", PARAM_STR)->str;
*err = psync_strndup(errorret, strlen(errorret)); *err = putil_strndup(errorret, strlen(errorret));
pdbg_logf(D_WARNING, "command gettreepublink returned error code %u message %s", pdbg_logf(D_WARNING, "command gettreepublink returned error code %u message %s",
(unsigned)result, errorret); (unsigned)result, errorret);
psync_process_api_error(result); psync_process_api_error(result);
if (psync_handle_api_result(result) == PSYNC_NET_TEMPFAIL) if (psync_handle_api_result(result) == PSYNC_NET_TEMPFAIL)
return -result; return -result;
else { else {
*err = psync_strndup("Connection error.", 17); *err = putil_strndup("Connection error.", 17);
return -1; return -1;
} }
} }
@ -365,7 +365,7 @@ void get_ba_member_email(uint64_t userid, char **email /*OUT*/,
const char *resret = const char *resret =
papi_find_result2(users->array[0], "email", PARAM_STR)->str; papi_find_result2(users->array[0], "email", PARAM_STR)->str;
*length = strlen(resret); *length = strlen(resret);
*email = psync_strndup(resret, *length); *email = putil_strndup(resret, *length);
fname = papi_find_result2(users->array[0], "firstname", PARAM_STR)->str; fname = papi_find_result2(users->array[0], "firstname", PARAM_STR)->str;
lname = papi_find_result2(users->array[0], "lastname", PARAM_STR)->str; lname = papi_find_result2(users->array[0], "lastname", PARAM_STR)->str;
} }
@ -430,7 +430,7 @@ void get_ba_team_name(uint64_t teamid, char **name /*OUT*/,
const char *teamret = const char *teamret =
papi_find_result2(teams->array[0], "name", PARAM_STR)->str; papi_find_result2(teams->array[0], "name", PARAM_STR)->str;
*length = strlen(teamret); *length = strlen(teamret);
*name = psync_strndup(teamret, *length); *name = putil_strndup(teamret, *length);
} }
free(bres); free(bres);

54
pclsync/pcryptofolder.c
View File

@ -244,10 +244,10 @@ static int download_keys(unsigned char **rsapriv, size_t *rsaprivlen, unsigned c
return pdbg_return_const(PSYNC_CRYPTO_START_UNKNOWN_ERROR); return pdbg_return_const(PSYNC_CRYPTO_START_UNKNOWN_ERROR);
} }
data = papi_find_result2(res, "privatekey", PARAM_STR); data = papi_find_result2(res, "privatekey", PARAM_STR);
rsaprivstruct = psync_base64_decode((const unsigned char *)data->str, rsaprivstruct = putil_base64_decode((const unsigned char *)data->str,
data->length, &rsaprivstructlen); data->length, &rsaprivstructlen);
data = papi_find_result2(res, "publickey", PARAM_STR); data = papi_find_result2(res, "publickey", PARAM_STR);
rsapubstruct = psync_base64_decode((const unsigned char *)data->str, rsapubstruct = putil_base64_decode((const unsigned char *)data->str,
data->length, &rsapubstructlen); data->length, &rsapubstructlen);
free(res); free(res);
sha1hex(rsaprivstruct, rsaprivstructlen, privatesha1); sha1hex(rsaprivstruct, rsaprivstructlen, privatesha1);
@ -337,11 +337,11 @@ setup_upload(const unsigned char *rsapriv, size_t rsaprivlen,
sha1hex(priv, offsetof(priv_key_ver1, key) + rsaprivlen, sha1hex(priv, offsetof(priv_key_ver1, key) + rsaprivlen,
privatesha1); privatesha1);
sha1hex(pub, offsetof(pub_key_ver1, key) + rsapublen, publicsha1); sha1hex(pub, offsetof(pub_key_ver1, key) + rsapublen, publicsha1);
b64priv = psync_base64_encode((unsigned char *)priv, b64priv = putil_base64_encode((unsigned char *)priv,
offsetof(priv_key_ver1, key) + rsaprivlen, offsetof(priv_key_ver1, key) + rsaprivlen,
&b64privlen); &b64privlen);
b64pub = b64pub =
psync_base64_encode((unsigned char *)pub, putil_base64_encode((unsigned char *)pub,
offsetof(pub_key_ver1, key) + rsapublen, &b64publen); offsetof(pub_key_ver1, key) + rsapublen, &b64publen);
free(priv); free(priv);
free(pub); free(pub);
@ -487,7 +487,7 @@ int pcryptofolder_get_hint(char **hint) {
} }
return pdbg_return_const(PSYNC_CRYPTO_HINT_UNKNOWN_ERROR); return pdbg_return_const(PSYNC_CRYPTO_HINT_UNKNOWN_ERROR);
} }
*hint = psync_strdup(papi_find_result2(res, "hint", PARAM_STR)->str); *hint = putil_strdup(papi_find_result2(res, "hint", PARAM_STR)->str);
free(res); free(res);
return PSYNC_CRYPTO_HINT_SUCCESS; return PSYNC_CRYPTO_HINT_SUCCESS;
} }
@ -845,7 +845,7 @@ static psync_encrypted_symmetric_key_t download_fldr_enckey(psync_folderid_t fol
pdbg_return_const(PSYNC_CRYPTO_API_ERR_INTERNAL)); pdbg_return_const(PSYNC_CRYPTO_API_ERR_INTERNAL));
} }
b64key = papi_find_result2(res, "key", PARAM_STR); b64key = papi_find_result2(res, "key", PARAM_STR);
key = psync_base64_decode((const unsigned char *)b64key->str, b64key->length, key = putil_base64_decode((const unsigned char *)b64key->str, b64key->length,
&keylen); &keylen);
free(res); free(res);
if (!key) if (!key)
@ -898,7 +898,7 @@ static psync_encrypted_symmetric_key_t download_file_enckey(psync_fileid_t filei
} }
result = papi_find_result2(res, "hash", PARAM_NUM)->num; result = papi_find_result2(res, "hash", PARAM_NUM)->num;
b64key = papi_find_result2(res, "key", PARAM_STR); b64key = papi_find_result2(res, "key", PARAM_STR);
key = psync_base64_decode((const unsigned char *)b64key->str, b64key->length, key = putil_base64_decode((const unsigned char *)b64key->str, b64key->length,
&keylen); &keylen);
free(res); free(res);
if (!key) if (!key)
@ -1136,7 +1136,7 @@ static pcrypto_textenc_t get_tmp_fldrencoder_safe(psync_fsfolderid_t folderid) {
pdbg_return_const(PSYNC_CRYPTO_FOLDER_NOT_ENCRYPTED)); pdbg_return_const(PSYNC_CRYPTO_FOLDER_NOT_ENCRYPTED));
} }
b64enckey = (const unsigned char *)psync_get_lstring(row[0], &b64enckeylen); b64enckey = (const unsigned char *)psync_get_lstring(row[0], &b64enckeylen);
enckey = psync_base64_decode(b64enckey, b64enckeylen, &enckeylen); enckey = putil_base64_decode(b64enckey, b64enckeylen, &enckeylen);
psql_free(res); psql_free(res);
if (enckey) { if (enckey) {
symkey = prsa_decrypt_data(crypto_privkey, enckey, enckeylen); symkey = prsa_decrypt_data(crypto_privkey, enckey, enckeylen);
@ -1192,7 +1192,7 @@ static pcrypto_textdec_t get_tmp_fldrdecoder_safe(psync_fsfolderid_t folderid) {
pdbg_return_const(PSYNC_CRYPTO_FOLDER_NOT_ENCRYPTED)); pdbg_return_const(PSYNC_CRYPTO_FOLDER_NOT_ENCRYPTED));
} }
b64enckey = (const unsigned char *)psync_get_lstring(row[0], &b64enckeylen); b64enckey = (const unsigned char *)psync_get_lstring(row[0], &b64enckeylen);
enckey = psync_base64_decode(b64enckey, b64enckeylen, &enckeylen); enckey = putil_base64_decode(b64enckey, b64enckeylen, &enckeylen);
psql_free(res); psql_free(res);
if (enckey) { if (enckey) {
symkey = prsa_decrypt_data(crypto_privkey, enckey, enckeylen); symkey = prsa_decrypt_data(crypto_privkey, enckey, enckeylen);
@ -1282,7 +1282,7 @@ char *pcryptofolder_flddecode_filename(pcrypto_textdec_t decoder,
const char *name) { const char *name) {
unsigned char *filenameenc, *filenamedec; unsigned char *filenameenc, *filenamedec;
size_t filenameenclen; size_t filenameenclen;
filenameenc = psync_base32_decode((const unsigned char *)name, strlen(name), filenameenc = putil_base32_decode((const unsigned char *)name, strlen(name),
&filenameenclen); &filenameenclen);
if (!filenameenc) if (!filenameenc)
return NULL; return NULL;
@ -1353,7 +1353,7 @@ char * pcryptofolder_fldencode_filename(pcrypto_textenc_t encoder,
pcrypto_encode_text(encoder, (const unsigned char *)name, pcrypto_encode_text(encoder, (const unsigned char *)name,
strlen(name), &filenameenc, &filenameenclen); strlen(name), &filenameenc, &filenameenclen);
filenameb32 = filenameb32 =
psync_base32_encode(filenameenc, filenameenclen, &filenameenclen); putil_base32_encode(filenameenc, filenameenclen, &filenameenclen);
free(filenameenc); free(filenameenc);
return (char *)filenameb32; return (char *)filenameb32;
} }
@ -1421,7 +1421,7 @@ static pcrypto_sector_encdec_t get_fileencoder_tmp(psync_fsfileid_t fileid,
switch (psync_get_number(row[0])) { switch (psync_get_number(row[0])) {
case PSYNC_FS_TASK_CREAT: case PSYNC_FS_TASK_CREAT:
b64enckey = (const unsigned char *)psync_get_lstring(row[2], &b64enckeylen); b64enckey = (const unsigned char *)psync_get_lstring(row[2], &b64enckeylen);
enckey = psync_base64_decode(b64enckey, b64enckeylen, &enckeylen); enckey = putil_base64_decode(b64enckey, b64enckeylen, &enckeylen);
psql_free(res); psql_free(res);
if (enckey) { if (enckey) {
symkey = prsa_decrypt_data(crypto_privkey, enckey, enckeylen); symkey = prsa_decrypt_data(crypto_privkey, enckey, enckeylen);
@ -1504,7 +1504,7 @@ pcrypto_sector_encdec_t pcryptofolder_filencoder_from_binresult(psync_fileid_t f
uint64_t hash; uint64_t hash;
size_t keylen; size_t keylen;
b64key = papi_find_result2(res, "key", PARAM_STR); b64key = papi_find_result2(res, "key", PARAM_STR);
key = psync_base64_decode((const unsigned char *)b64key->str, b64key->length, key = putil_base64_decode((const unsigned char *)b64key->str, b64key->length,
&keylen); &keylen);
if (!key) if (!key)
return (pcrypto_sector_encdec_t)errptr( return (pcrypto_sector_encdec_t)errptr(
@ -1560,7 +1560,7 @@ static char *get_name_encoded(psync_folderid_t folderid,
return (char *)enc; return (char *)enc;
pcrypto_encode_text(enc, (const unsigned char *)name, pcrypto_encode_text(enc, (const unsigned char *)name,
strlen(name), &nameenc, &nameenclen); strlen(name), &nameenc, &nameenclen);
ret = (char *)psync_base32_encode(nameenc, nameenclen, &nameenclen); ret = (char *)putil_base32_encode(nameenc, nameenclen, &nameenclen);
free_direncoder(folderid, enc); free_direncoder(folderid, enc);
free(nameenc); free(nameenc);
return ret; return ret;
@ -1597,7 +1597,7 @@ static int get_fldr_name(psync_folderid_t folderid,
const char *name, char **ename, const char *name, char **ename,
const char **err) { const char **err) {
if (folderid == 0) { if (folderid == 0) {
*ename = psync_strdup(name); *ename = putil_strdup(name);
return PSYNC_CRYPTO_SUCCESS; return PSYNC_CRYPTO_SUCCESS;
} else { } else {
psync_sql_res *res; psync_sql_res *res;
@ -1613,7 +1613,7 @@ static int get_fldr_name(psync_folderid_t folderid,
if (enc) if (enc)
return get_cfldr_name(folderid, name, ename, err); return get_cfldr_name(folderid, name, ename, err);
else { else {
*ename = psync_strdup(name); *ename = putil_strdup(name);
return PSYNC_CRYPTO_SUCCESS; return PSYNC_CRYPTO_SUCCESS;
} }
} }
@ -1681,7 +1681,7 @@ char *pcryptofolder_filencoder_key_get(psync_fsfileid_t fileid,
encsym = get_file_enckey(fileid, hash, 0); encsym = get_file_enckey(fileid, hash, 0);
if (is_err(encsym)) if (is_err(encsym))
return (char *)encsym; return (char *)encsym;
ret = (char *)psync_base64_encode(encsym->data, encsym->datalen, keylen); ret = (char *)putil_base64_encode(encsym->data, encsym->datalen, keylen);
free(encsym); free(encsym);
return ret; return ret;
} }
@ -1709,7 +1709,7 @@ char *pcryptofolder_filencoder_key_new(uint32_t flags, size_t *keylen) {
return (char *)errptr(pdbg_return_const(PSYNC_CRYPTO_RSA_ERROR)); return (char *)errptr(pdbg_return_const(PSYNC_CRYPTO_RSA_ERROR));
} }
putil_wipe(&sym, sizeof(sym)); putil_wipe(&sym, sizeof(sym));
ret = (char *)psync_base64_encode(encsym->data, encsym->datalen, keylen); ret = (char *)putil_base64_encode(encsym->data, encsym->datalen, keylen);
free(encsym); free(encsym);
return ret; return ret;
} }
@ -1739,7 +1739,7 @@ char *pcryptofolder_filencoder_key_newplain(
} }
*deckey = symkeyv1_to_symkey(&sym); *deckey = symkeyv1_to_symkey(&sym);
putil_wipe(&sym, sizeof(sym)); putil_wipe(&sym, sizeof(sym));
ret = (char *)psync_base64_encode(encsym->data, encsym->datalen, keylen); ret = (char *)putil_base64_encode(encsym->data, encsym->datalen, keylen);
free(encsym); free(encsym);
return ret; return ret;
} }
@ -1779,7 +1779,7 @@ int pcryptofolder_mkdir(psync_folderid_t folderid, const char *name,
pdbg_logf(D_ERROR, "RSA encryption failed"); pdbg_logf(D_ERROR, "RSA encryption failed");
return set_err(pdbg_return_const(PSYNC_CRYPTO_RSA_ERROR), err); return set_err(pdbg_return_const(PSYNC_CRYPTO_RSA_ERROR), err);
} }
b64encsym = psync_base64_encode(encsym->data, encsym->datalen, &b64encsymlen); b64encsym = putil_base64_encode(encsym->data, encsym->datalen, &b64encsymlen);
ret = psync_cloud_crypto_send_mkdir(folderid, ename, err, (char *)b64encsym, ret = psync_cloud_crypto_send_mkdir(folderid, ename, err, (char *)b64encsym,
b64encsymlen, encsym, newfolderid); b64encsymlen, encsym, newfolderid);
free(encsym); free(encsym);
@ -1888,8 +1888,8 @@ int psync_pcloud_crypto_reencode_key(
prsa_free_private(priv); prsa_free_private(priv);
return to_err(rsasign); return to_err(rsasign);
} }
*privenc = (char *)psync_base64_encode(newpriv, newprivlen, &dummy); *privenc = (char *)putil_base64_encode(newpriv, newprivlen, &dummy);
*sign = (char *)psync_base64_encode(rsasign->data, rsasign->datalen, &dummy); *sign = (char *)putil_base64_encode(rsasign->data, rsasign->datalen, &dummy);
free(rsasign); free(rsasign);
free(newpriv); free(newpriv);
prsa_free_public(pub); prsa_free_public(pub);
@ -1963,8 +1963,8 @@ int psync_pcloud_crypto_encode_key(const char *newpassphrase, uint32_t flags,
prsa_free_binary(rsapriv); prsa_free_binary(rsapriv);
return to_err(rsasign); return to_err(rsasign);
} }
*privenc = (char *)psync_base64_encode(newpriv, rsaprivlen, &dummy); *privenc = (char *)putil_base64_encode(newpriv, rsaprivlen, &dummy);
*sign = (char *)psync_base64_encode(rsasign->data, rsasign->datalen, &dummy); *sign = (char *)putil_base64_encode(rsasign->data, rsasign->datalen, &dummy);
free(rsasign); free(rsasign);
putil_wipe(newpriv, rsaprivlen); putil_wipe(newpriv, rsaprivlen);
free(newpriv); free(newpriv);
@ -2069,13 +2069,13 @@ int pcryptofolder_change_pass(const char *oldpassphrase,
} }
pdbg_logf(D_NOTICE, "downloaded user keys"); pdbg_logf(D_NOTICE, "downloaded user keys");
data = papi_find_result2(bres, "privatekey", PARAM_STR); data = papi_find_result2(bres, "privatekey", PARAM_STR);
privkey = psync_base64_decode((const unsigned char *)data->str, privkey = putil_base64_decode((const unsigned char *)data->str,
data->length, &privkeylen); data->length, &privkeylen);
data = papi_find_result2(bres, "publickey", PARAM_STR); data = papi_find_result2(bres, "publickey", PARAM_STR);
pubkey = psync_base64_decode((const unsigned char *)data->str, data->length, pubkey = putil_base64_decode((const unsigned char *)data->str, data->length,
&pubkeylen); &pubkeylen);
data = papi_find_result2(bres, "salt", PARAM_STR); data = papi_find_result2(bres, "salt", PARAM_STR);
salt = psync_base64_decode((const unsigned char *)data->str, data->length, salt = putil_base64_decode((const unsigned char *)data->str, data->length,
&saltlen); &saltlen);
free(bres); free(bres);
if (unlikely(!privkey || !pubkey)) { if (unlikely(!privkey || !pubkey)) {

4
pclsync/pdbg.c
View File

@ -160,7 +160,7 @@ int pdbg_printf(const char *file, const char *function, int unsigned line, int u
} }
clock_gettime(CLOCK_REALTIME, &ts); clock_gettime(CLOCK_REALTIME, &ts);
time_format(ts.tv_sec, ts.tv_nsec, dttime); putil_time_format(ts.tv_sec, ts.tv_nsec, dttime);
threadid = pthread_self(); threadid = pthread_self();
memcpy(&u, &threadid, sizeof(u)); memcpy(&u, &threadid, sizeof(u));
snprintf(format, sizeof(format), "%s %u %s %s: %s:%u (function %s): %s\n", snprintf(format, sizeof(format), "%s %u %s %s: %s:%u (function %s): %s\n",
@ -251,7 +251,7 @@ void pdbg_write_fs_event(const char *fmt, ...) {
/* Get timestamp */ /* Get timestamp */
clock_gettime(CLOCK_REALTIME, &ts); clock_gettime(CLOCK_REALTIME, &ts);
time_format(ts.tv_sec, ts.tv_nsec, dttime); putil_time_format(ts.tv_sec, ts.tv_nsec, dttime);
/* Write timestamp followed by event message */ /* Write timestamp followed by event message */
fprintf(fs_event_log, "%s ", dttime); fprintf(fs_event_log, "%s ", dttime);

8
pclsync/pdevice.c
View File

@ -59,7 +59,7 @@ char *pdevice_id() {
(de->d_name[1] != 0 && (de->d_name[1] != 0 &&
(de->d_name[1] != '.' || de->d_name[2] != 0))) { (de->d_name[1] != '.' || de->d_name[2] != 0))) {
path = path =
psync_strcat("/sys/class/power_supply/", de->d_name, "/type", NULL); putil_strcat("/sys/class/power_supply/", de->d_name, "/type", NULL);
fd = open(path, O_RDONLY); fd = open(path, O_RDONLY);
free(path); free(path);
if (fd == -1) if (fd == -1)
@ -74,19 +74,19 @@ char *pdevice_id() {
} }
closedir(dh); closedir(dh);
} }
device = psync_strcat(hardware, ", Linux", NULL); device = putil_strcat(hardware, ", Linux", NULL);
return device; return device;
} }
char *pdevice_name() { char *pdevice_name() {
char *osname = pdevice_get_os(); char *osname = pdevice_get_os();
char *ret = psync_strcat(osname, ", ", psync_software_name, NULL); char *ret = putil_strcat(osname, ", ", psync_software_name, NULL);
free(osname); free(osname);
return ret; return ret;
} }
char *pdevice_get_os() { char *pdevice_get_os() {
return psync_os_name ? psync_strdup(psync_os_name) : pdevice_id(); return psync_os_name ? putil_strdup(psync_os_name) : pdevice_id();
} }
void pdevice_set_software(const char *snm) { void pdevice_set_software(const char *snm) {

22
pclsync/pdiff.c
View File

@ -251,7 +251,7 @@ static int check_active_subscribtion(const binresult *res) {
char *status; char *status;
sub = papi_check_result2(res, "lastsubscription", PARAM_HASH); sub = papi_check_result2(res, "lastsubscription", PARAM_HASH);
if (sub) { if (sub) {
status = psync_strdup(papi_find_result2(sub, "status", PARAM_STR)->str); status = putil_strdup(papi_find_result2(sub, "status", PARAM_STR)->str);
if (!strcmp(status, "active")) { if (!strcmp(status, "active")) {
free(status); free(status);
return 1; return 1;
@ -332,7 +332,7 @@ static psock_t *get_connected_socket() {
"REPLACE INTO setting (id, value) VALUES ('deviceid', ?)"); "REPLACE INTO setting (id, value) VALUES ('deviceid', ?)");
psql_bind_str(q, 1, deviceidhex); psql_bind_str(q, 1, deviceidhex);
psql_run_free(q); psql_run_free(q);
deviceid = psync_strdup(deviceidhex); deviceid = putil_strdup(deviceidhex);
} }
pdbg_logf(D_NOTICE, "using deviceid %s", deviceid); pdbg_logf(D_NOTICE, "using deviceid %s", deviceid);
@ -367,11 +367,11 @@ static psock_t *get_connected_socket() {
} }
if (!auth && psync_my_auth[0]) if (!auth && psync_my_auth[0])
auth = psync_strdup(psync_my_auth); auth = putil_strdup(psync_my_auth);
if (!user && psync_my_user) if (!user && psync_my_user)
user = psync_strdup(psync_my_user); user = putil_strdup(psync_my_user);
if (!pass && psync_my_pass) if (!pass && psync_my_pass)
pass = psync_strdup(psync_my_pass); pass = putil_strdup(psync_my_pass);
if (!auth && (!pass || !user)) { if (!auth && (!pass || !user)) {
if (tfa) { if (tfa) {
tfa = 0; tfa = 0;
@ -463,7 +463,7 @@ static psock_t *get_connected_socket() {
if (result == 2297) { if (result == 2297) {
free(psync_my_2fa_token); free(psync_my_2fa_token);
psync_my_2fa_token = psync_my_2fa_token =
psync_strdup(papi_find_result2(res, "token", PARAM_STR)->str); putil_strdup(papi_find_result2(res, "token", PARAM_STR)->str);
psync_my_2fa_has_devices = psync_my_2fa_has_devices =
papi_find_result2(res, "hasdevices", PARAM_BOOL)->num; papi_find_result2(res, "hasdevices", PARAM_BOOL)->num;
psync_my_2fa_type = papi_find_result2(res, "tfatype", PARAM_NUM)->num; psync_my_2fa_type = papi_find_result2(res, "tfatype", PARAM_NUM)->num;
@ -479,7 +479,7 @@ static psock_t *get_connected_socket() {
if (result == 2306) { if (result == 2306) {
free(psync_my_verify_token); free(psync_my_verify_token);
psync_my_verify_token = psync_my_verify_token =
psync_strdup(papi_find_result2(res, "verifytoken", PARAM_STR)->str); putil_strdup(papi_find_result2(res, "verifytoken", PARAM_STR)->str);
pstatus_set(PSTATUS_TYPE_AUTH, PSTATUS_AUTH_VERIFYREQ); pstatus_set(PSTATUS_TYPE_AUTH, PSTATUS_AUTH_VERIFYREQ);
pstatus_wait(PSTATUS_TYPE_AUTH, PSTATUS_AUTH_PROVIDED); pstatus_wait(PSTATUS_TYPE_AUTH, PSTATUS_AUTH_PROVIDED);
psock_close(sock); psock_close(sock);
@ -491,7 +491,7 @@ static psock_t *get_connected_socket() {
cres = papi_check_result2(res, "location", PARAM_HASH); cres = papi_check_result2(res, "location", PARAM_HASH);
if (cres) { if (cres) {
binapi = binapi =
psync_strdup(papi_find_result2(cres, "binapi", PARAM_STR)->str); putil_strdup(papi_find_result2(cres, "binapi", PARAM_STR)->str);
locationid = papi_find_result2(cres, "id", PARAM_NUM)->num; locationid = papi_find_result2(cres, "id", PARAM_NUM)->num;
psync_set_apiserver(binapi, locationid); psync_set_apiserver(binapi, locationid);
@ -566,7 +566,7 @@ static psock_t *get_connected_socket() {
psync_is_business = papi_find_result2(res, "business", PARAM_BOOL)->num; psync_is_business = papi_find_result2(res, "business", PARAM_BOOL)->num;
lid = psync_setting_get_uint(_PS(location_id)); lid = psync_setting_get_uint(_PS(location_id));
psql_start(); psql_start();
psync_strlcpy(psync_my_auth, papi_find_result2(res, "auth", PARAM_STR)->str, putil_strlcpy(psync_my_auth, papi_find_result2(res, "auth", PARAM_STR)->str,
sizeof(psync_my_auth)); sizeof(psync_my_auth));
if (luserid) { if (luserid) {
@ -2918,7 +2918,7 @@ static void psync_run_analyze_if_needed() {
for (i = 0; i < ARRAY_SIZE(skiptables); i++) for (i = 0; i < ARRAY_SIZE(skiptables); i++)
if (!strcmp(srow[0], skiptables[i])) if (!strcmp(srow[0], skiptables[i]))
goto skip; goto skip;
tablenames[tablecnt++] = psync_strdup(srow[0]); tablenames[tablecnt++] = putil_strdup(srow[0]);
skip:; skip:;
} }
psql_free(res); psql_free(res);
@ -2926,7 +2926,7 @@ static void psync_run_analyze_if_needed() {
while (tablecnt) { while (tablecnt) {
--tablecnt; --tablecnt;
pdbg_logf(D_NOTICE, "running ANALYZE on %s", tablenames[tablecnt]); pdbg_logf(D_NOTICE, "running ANALYZE on %s", tablenames[tablecnt]);
sql = psync_strcat("ANALYZE ", tablenames[tablecnt], ";", NULL); sql = putil_strcat("ANALYZE ", tablenames[tablecnt], ";", NULL);
free(tablenames[tablecnt]); free(tablenames[tablecnt]);
psql_statement(sql); psql_statement(sql);
free(sql); free(sql);

20
pclsync/pdownload.c
View File

@ -159,8 +159,8 @@ static void do_move(void *ptr, ppath_stat *st) {
const char **arr; const char **arr;
char *oldpath, *newpath; char *oldpath, *newpath;
arr = (const char **)ptr; arr = (const char **)ptr;
oldpath = psync_strcat(arr[0], st->name, NULL); oldpath = putil_strcat(arr[0], st->name, NULL);
newpath = psync_strcat(arr[1], st->name, NULL); newpath = putil_strcat(arr[1], st->name, NULL);
pfile_rename(oldpath, newpath); pfile_rename(oldpath, newpath);
free(newpath); free(newpath);
free(oldpath); free(oldpath);
@ -717,7 +717,7 @@ static int task_download_file(download_task_t *dt) {
if (!stat(dt->tmpname, &st) && if (!stat(dt->tmpname, &st) &&
pfile_stat_size(&st) >= PSYNC_MIN_SIZE_FOR_CHECKSUMS) { pfile_stat_size(&st) >= PSYNC_MIN_SIZE_FOR_CHECKSUMS) {
tmpold = tmpold =
psync_strcat(dt->localpath, "/", dt->filename, putil_strcat(dt->localpath, "/", dt->filename,
"-old", PSYNC_APPEND_PARTIAL_FILES, NULL); "-old", PSYNC_APPEND_PARTIAL_FILES, NULL);
if (pfile_rename_overwrite(dt->tmpname, tmpold)) { if (pfile_rename_overwrite(dt->tmpname, tmpold)) {
free(tmpold); free(tmpold);
@ -740,7 +740,7 @@ static int task_download_file(download_task_t *dt) {
hosts = papi_find_result2(res, "hosts", PARAM_ARRAY); hosts = papi_find_result2(res, "hosts", PARAM_ARRAY);
requestpath = papi_find_result2(res, "path", PARAM_STR)->str; requestpath = papi_find_result2(res, "path", PARAM_STR)->str;
psync_slprintf(cookie, sizeof(cookie), "Cookie: dwltag=%s\015\012", putil_slprintf(cookie, sizeof(cookie), "Cookie: dwltag=%s\015\012",
papi_find_result2(res, "dwltag", PARAM_STR)->str); papi_find_result2(res, "dwltag", PARAM_STR)->str);
buff = malloc(PSYNC_COPY_BUFFER_SIZE); buff = malloc(PSYNC_COPY_BUFFER_SIZE);
http = NULL; http = NULL;
@ -975,7 +975,7 @@ static int task_rename_file(psync_syncid_t oldsyncid, psync_syncid_t newsyncid,
free(newfolder); free(newfolder);
return 0; return 0;
} }
newpath = psync_strcat(newfolder, "/", newname, NULL); newpath = putil_strcat(newfolder, "/", newname, NULL);
ret = 0; ret = 0;
psync_stop_localscan(); psync_stop_localscan();
if (pfile_rename_overwrite(oldpath, newpath)) { if (pfile_rename_overwrite(oldpath, newpath)) {
@ -1198,8 +1198,8 @@ static int task_run_download_file(uint64_t taskid, psync_syncid_t syncid,
if (pdbg_unlikely(!localpath)) if (pdbg_unlikely(!localpath))
return 0; return 0;
localname = localname =
psync_strcat(localpath, "/", filename, NULL); putil_strcat(localpath, "/", filename, NULL);
tmpname = psync_strcat(localpath, "/", filename, tmpname = putil_strcat(localpath, "/", filename,
PSYNC_APPEND_PARTIAL_FILES, NULL); PSYNC_APPEND_PARTIAL_FILES, NULL);
len = strlen(filename); len = strlen(filename);
dt = (download_task_t *)malloc(offsetof(download_task_t, filename) + dt = (download_task_t *)malloc(offsetof(download_task_t, filename) +
@ -1337,7 +1337,7 @@ static void task_del_folder_rec_do(const char *localpath,
psql_bind_uint(res, 2, syncid); psql_bind_uint(res, 2, syncid);
while ((vrow = psql_fetch(res))) { while ((vrow = psql_fetch(res))) {
pupload_del_tasks(psync_get_number(vrow[0])); pupload_del_tasks(psync_get_number(vrow[0]));
nm = psync_strcat(localpath, "/", nm = putil_strcat(localpath, "/",
psync_get_string(vrow[1]), NULL); psync_get_string(vrow[1]), NULL);
pdbg_logf(D_NOTICE, "deleting %s", nm); pdbg_logf(D_NOTICE, "deleting %s", nm);
pfile_delete(nm); pfile_delete(nm);
@ -1354,7 +1354,7 @@ static void task_del_folder_rec_do(const char *localpath,
psql_bind_uint(res, 1, localfolderid); psql_bind_uint(res, 1, localfolderid);
psql_bind_uint(res, 2, syncid); psql_bind_uint(res, 2, syncid);
while ((vrow = psql_fetch(res))) { while ((vrow = psql_fetch(res))) {
nm = psync_strcat(localpath, "/", nm = putil_strcat(localpath, "/",
psync_get_string(vrow[1]), NULL); psync_get_string(vrow[1]), NULL);
task_del_folder_rec_do(nm, psync_get_number(vrow[0]), syncid); task_del_folder_rec_do(nm, psync_get_number(vrow[0]), syncid);
free(nm); free(nm);
@ -1420,7 +1420,7 @@ static int download_task(uint64_t taskid, uint32_t type, psync_syncid_t syncid,
for (ptr = name; *ptr; ptr++) for (ptr = name; *ptr; ptr++)
if (pfile_invalid_chars[(unsigned char)*ptr]) { if (pfile_invalid_chars[(unsigned char)*ptr]) {
if (!vname) if (!vname)
vname = psync_strdup(name); vname = putil_strdup(name);
vname[ptr - name] = PSYNC_REPLACE_INV_CH_IN_FILENAMES; vname[ptr - name] = PSYNC_REPLACE_INV_CH_IN_FILENAMES;
} }
if (vname) { if (vname) {

2
pclsync/pfile.c
View File

@ -419,7 +419,7 @@ int pfile_run_update(const char *path) {
dup2(fd, STDERR_FILENO); dup2(fd, STDERR_FILENO);
close(fd); close(fd);
setsid(); setsid();
ex = psync_strcat(PSYNC_RUN_CMD " \"", path, "\"", NULL); ex = putil_strcat(PSYNC_RUN_CMD " \"", path, "\"", NULL);
execl("/bin/sh", "/bin/sh", "-c", ex, NULL); execl("/bin/sh", "/bin/sh", "-c", ex, NULL);
pdbg_logf(D_ERROR, "exec of %s failed", ex); pdbg_logf(D_ERROR, "exec of %s failed", ex);
free(ex); free(ex);

12
pclsync/pfolder.c
View File

@ -343,7 +343,7 @@ char *psync_join_string_list(const char *sep, psync_list *lst, size_t *retlen) {
cnt++; cnt++;
} }
if (unlikely(!cnt)) if (unlikely(!cnt))
return psync_strdup(""); return putil_strdup("");
seplen = strlen(sep); seplen = strlen(sep);
ret = str = malloc(slen + cnt * seplen + 1); ret = str = malloc(slen + cnt * seplen + 1);
psync_list_for_each_element(e, lst, string_list, list) { psync_list_for_each_element(e, lst, string_list, list) {
@ -375,7 +375,7 @@ char *pfolder_path(psync_folderid_t folderid, size_t *retlen) {
psync_free_string_list(&folderlist); psync_free_string_list(&folderlist);
if (!ret[0]) { if (!ret[0]) {
free(ret); free(ret);
ret = psync_strdup("/"); ret = putil_strdup("/");
if (retlen) if (retlen)
*retlen = 1; *retlen = 1;
} }
@ -397,7 +397,7 @@ char *pfolder_path_sep(psync_folderid_t folderid, const char *sep,
psync_free_string_list(&folderlist); psync_free_string_list(&folderlist);
if (!ret[0]) { if (!ret[0]) {
free(ret); free(ret);
ret = psync_strdup(sep); ret = putil_strdup(sep);
if (retlen) if (retlen)
*retlen = 1; *retlen = 1;
} }
@ -822,12 +822,12 @@ psync_folder_list_t *pfolder_sync_folders(char *syncTypes) {
strlens = 0; strlens = 0;
if (strlen(syncTypes) > 0) { if (strlen(syncTypes) > 0) {
psync_slprintf(sql, 1024, putil_slprintf(sql, 1024,
"SELECT id, folderid, localpath, synctype FROM syncfolder " "SELECT id, folderid, localpath, synctype FROM syncfolder "
"WHERE folderid IS NOT NULL AND synctype IN (%s)", "WHERE folderid IS NOT NULL AND synctype IN (%s)",
syncTypes); syncTypes);
} else { } else {
psync_slprintf(sql, 1024, putil_slprintf(sql, 1024,
"SELECT id, folderid, localpath, synctype FROM syncfolder " "SELECT id, folderid, localpath, synctype FROM syncfolder "
"WHERE folderid IS NOT NULL"); "WHERE folderid IS NOT NULL");
} }
@ -851,7 +851,7 @@ psync_folder_list_t *pfolder_sync_folders(char *syncTypes) {
folderid = psync_get_number(row[1]); folderid = psync_get_number(row[1]);
str = pfolder_path(folderid, &l); str = pfolder_path(folderid, &l);
if (unlikely(!str)) { if (unlikely(!str)) {
str = psync_strdup("/Invalid/Path"); str = putil_strdup("/Invalid/Path");
l = strlen(str); l = strlen(str);
} }
l++; l++;

40
pclsync/pfs.c
View File

@ -138,12 +138,12 @@ static void delete_log_files(psync_openfile_t *of) {
fileidhex[sizeof(psync_fsfileid_t)] = 'l'; fileidhex[sizeof(psync_fsfileid_t)] = 'l';
fileidhex[sizeof(psync_fsfileid_t) + 1] = 0; fileidhex[sizeof(psync_fsfileid_t) + 1] = 0;
filename = filename =
psync_strcat(cachepath, "/", fileidhex, NULL); putil_strcat(cachepath, "/", fileidhex, NULL);
pfile_delete(filename); pfile_delete(filename);
free(filename); free(filename);
fileidhex[sizeof(psync_fsfileid_t)] = 'f'; fileidhex[sizeof(psync_fsfileid_t)] = 'f';
filename = filename =
psync_strcat(cachepath, "/", fileidhex, NULL); putil_strcat(cachepath, "/", fileidhex, NULL);
pfile_delete(filename); pfile_delete(filename);
free(filename); free(filename);
} }
@ -310,7 +310,7 @@ int psync_fs_rename_openfile_locked(psync_fsfileid_t fileid,
psync_fstask_get_or_create_folder_tasks_locked(folderid); psync_fstask_get_or_create_folder_tasks_locked(folderid);
} }
free(fl->currentname); free(fl->currentname);
fl->currentname = psync_strdup(name); fl->currentname = putil_strdup(name);
pthread_mutex_unlock(&fl->mutex); pthread_mutex_unlock(&fl->mutex);
return 1; return 1;
} }
@ -617,7 +617,7 @@ static int psync_creat_local_to_file_stat(psync_fstask_creat_t *cr,
fileidhex[sizeof(psync_fsfileid_t) + 1] = 0; fileidhex[sizeof(psync_fsfileid_t) + 1] = 0;
cachepath = psync_setting_get_string(_PS(fscachepath)); cachepath = psync_setting_get_string(_PS(fscachepath));
filename = filename =
psync_strcat(cachepath, "/", fileidhex, NULL); putil_strcat(cachepath, "/", fileidhex, NULL);
stret = stat(filename, &st); stret = stat(filename, &st);
if (stret) if (stret)
pdbg_logf(D_NOTICE, "could not stat file %s", filename); pdbg_logf(D_NOTICE, "could not stat file %s", filename);
@ -629,7 +629,7 @@ static int psync_creat_local_to_file_stat(psync_fstask_creat_t *cr,
osize=0; osize=0;
else{ else{
fileidhex[sizeof(psync_fsfileid_t)]='i'; fileidhex[sizeof(psync_fsfileid_t)]='i';
filename=psync_strcat(cachepath, "/", fileidhex, filename=putil_strcat(cachepath, "/", fileidhex,
NULL); fd=pfile_open(filename, O_RDONLY, 0); 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, (fd==INVALID_HANDLE_VALUE) return -EIO; stret=pfile_pread(fd, &osize,
sizeof(osize), offsetof(index_header, copyfromoriginal)); sizeof(osize), offsetof(index_header, copyfromoriginal));
@ -1034,7 +1034,7 @@ psync_fs_create_file(psync_fsfileid_t fileid, psync_fsfileid_t remotefileid,
pthread_mutex_init(&fl->mutex, NULL); pthread_mutex_init(&fl->mutex, NULL);
#endif #endif
fl->currentfolder = folder; fl->currentfolder = folder;
fl->currentname = psync_strdup(name); fl->currentname = putil_strdup(name);
fl->fileid = fileid; fl->fileid = fileid;
fl->remotefileid = remotefileid; fl->remotefileid = remotefileid;
fl->hash = hash; fl->hash = hash;
@ -1137,7 +1137,7 @@ static int open_write_files(psync_openfile_t *of, int trunc) {
cachepath = psync_setting_get_string(_PS(fscachepath)); cachepath = psync_setting_get_string(_PS(fscachepath));
if (of->datafile == INVALID_HANDLE_VALUE) { if (of->datafile == INVALID_HANDLE_VALUE) {
filename = filename =
psync_strcat(cachepath, "/", fileidhex, NULL); putil_strcat(cachepath, "/", fileidhex, NULL);
of->datafile = pfile_open(filename, O_RDWR, of->datafile = pfile_open(filename, O_RDWR,
O_CREAT | (trunc ? O_TRUNC : 0)); O_CREAT | (trunc ? O_TRUNC : 0));
free(filename); free(filename);
@ -1163,7 +1163,7 @@ static int open_write_files(psync_openfile_t *of, int trunc) {
if (!of->newfile && of->indexfile == INVALID_HANDLE_VALUE) { if (!of->newfile && of->indexfile == INVALID_HANDLE_VALUE) {
fileidhex[sizeof(psync_fsfileid_t)] = 'i'; fileidhex[sizeof(psync_fsfileid_t)] = 'i';
filename = filename =
psync_strcat(cachepath, "/", fileidhex, NULL); putil_strcat(cachepath, "/", fileidhex, NULL);
of->indexfile = pfile_open(filename, O_RDWR, of->indexfile = pfile_open(filename, O_RDWR,
O_CREAT | (trunc ? O_TRUNC : 0)); O_CREAT | (trunc ? O_TRUNC : 0));
free(filename); free(filename);
@ -1183,7 +1183,7 @@ static int open_write_files(psync_openfile_t *of, int trunc) {
if (of->logfile == INVALID_HANDLE_VALUE) { if (of->logfile == INVALID_HANDLE_VALUE) {
fileidhex[sizeof(psync_fsfileid_t)] = 'l'; fileidhex[sizeof(psync_fsfileid_t)] = 'l';
filename = filename =
psync_strcat(cachepath, "/", fileidhex, NULL); putil_strcat(cachepath, "/", fileidhex, NULL);
of->logfile = pfile_open(filename, O_RDWR, O_CREAT | O_TRUNC); of->logfile = pfile_open(filename, O_RDWR, O_CREAT | O_TRUNC);
free(filename); free(filename);
if (of->logfile == INVALID_HANDLE_VALUE) { if (of->logfile == INVALID_HANDLE_VALUE) {
@ -3065,7 +3065,7 @@ static int psync_fs_set_filetime_locked(psync_fsfileid_t fileid,
fileidhex[sizeof(psync_fsfileid_t) + 1] = 0; fileidhex[sizeof(psync_fsfileid_t) + 1] = 0;
cachepath = psync_setting_get_string(_PS(fscachepath)); cachepath = psync_setting_get_string(_PS(fscachepath));
filename = filename =
psync_strcat(cachepath, "/", fileidhex, NULL); putil_strcat(cachepath, "/", fileidhex, NULL);
if (fl && fl->datafile != INVALID_HANDLE_VALUE) { if (fl && fl->datafile != INVALID_HANDLE_VALUE) {
pdbg_logf(D_NOTICE, "found open file for file id %ld", (long)fl->fileid); pdbg_logf(D_NOTICE, "found open file for file id %ld", (long)fl->fileid);
if (crtime) if (crtime)
@ -3295,7 +3295,7 @@ static void psync_invalidate_os_cache_noret() {
char *path; char *path;
pthread_mutex_lock(&start_mutex); pthread_mutex_lock(&start_mutex);
if (started == 1) if (started == 1)
path = psync_strdup(psync_current_mountpoint); path = putil_strdup(psync_current_mountpoint);
else else
path = NULL; path = NULL;
pthread_mutex_unlock(&start_mutex); pthread_mutex_unlock(&start_mutex);
@ -3367,9 +3367,9 @@ void psync_fs_refresh_folder(psync_folderid_t folderid) {
pthread_mutex_lock(&start_mutex); pthread_mutex_lock(&start_mutex);
if (started == 1) { if (started == 1) {
if (pfile_invalidate_os_cache_needed()) if (pfile_invalidate_os_cache_needed())
fpath = psync_strcat(psync_current_mountpoint, path, NULL); fpath = putil_strcat(psync_current_mountpoint, path, NULL);
else else
fpath = psync_strcat(psync_current_mountpoint, path, "/", fpath = putil_strcat(psync_current_mountpoint, path, "/",
psync_fake_prefix, rndhex, NULL); psync_fake_prefix, rndhex, NULL);
} else } else
fpath = NULL; fpath = NULL;
@ -3396,7 +3396,7 @@ static char *psync_fuse_get_mountpoint() {
int stat_result; int stat_result;
int stat_errno; int stat_errno;
mp = psync_strdup(psync_setting_get_string(_PS(fsroot))); mp = putil_strdup(psync_setting_get_string(_PS(fsroot)));
stat_result = stat(mp, &st); stat_result = stat(mp, &st);
stat_errno = errno; stat_errno = errno;
@ -3436,7 +3436,7 @@ char *psync_fs_getmountpoint() {
char *ret; char *ret;
pthread_mutex_lock(&start_mutex); pthread_mutex_lock(&start_mutex);
if (started == 1) if (started == 1)
ret = psync_strdup(psync_current_mountpoint); ret = putil_strdup(psync_current_mountpoint);
else else
ret = NULL; ret = NULL;
pthread_mutex_unlock(&start_mutex); pthread_mutex_unlock(&start_mutex);
@ -3451,7 +3451,7 @@ char *psync_fs_get_path_by_folderid(psync_folderid_t folderid) {
char *mp, *path, *ret; char *mp, *path, *ret;
pthread_mutex_lock(&start_mutex); pthread_mutex_lock(&start_mutex);
if (started == 1) if (started == 1)
mp = psync_strdup(psync_current_mountpoint); mp = putil_strdup(psync_current_mountpoint);
else else
mp = NULL; mp = NULL;
pthread_mutex_unlock(&start_mutex); pthread_mutex_unlock(&start_mutex);
@ -3463,7 +3463,7 @@ char *psync_fs_get_path_by_folderid(psync_folderid_t folderid) {
free(mp); free(mp);
return NULL; return NULL;
} }
ret = psync_strcat(mp, path, NULL); ret = putil_strcat(mp, path, NULL);
free(mp); free(mp);
free(path); free(path);
return ret; return ret;
@ -3473,7 +3473,7 @@ char *psync_fs_get_path_by_fileid(psync_fileid_t fileid) {
char *mp, *path, *ret; char *mp, *path, *ret;
pthread_mutex_lock(&start_mutex); pthread_mutex_lock(&start_mutex);
if (started == 1) if (started == 1)
mp = psync_strdup(psync_current_mountpoint); mp = putil_strdup(psync_current_mountpoint);
else else
mp = NULL; mp = NULL;
pthread_mutex_unlock(&start_mutex); pthread_mutex_unlock(&start_mutex);
@ -3484,7 +3484,7 @@ char *psync_fs_get_path_by_fileid(psync_fileid_t fileid) {
free(mp); free(mp);
return NULL; return NULL;
} }
ret = psync_strcat(mp, path, NULL); ret = putil_strcat(mp, path, NULL);
free(mp); free(mp);
free(path); free(path);
return ret; return ret;
@ -3620,7 +3620,7 @@ static void psync_fs_init_once() {
pssl_rand_strong(rndbuff, sizeof(rndbuff)); pssl_rand_strong(rndbuff, sizeof(rndbuff));
psync_binhex(rndhex, rndbuff, sizeof(rndbuff)); psync_binhex(rndhex, rndbuff, sizeof(rndbuff));
rndhex[2 * sizeof(rndbuff)] = 0; rndhex[2 * sizeof(rndbuff)] = 0;
psync_fake_prefix = psync_strcat(".refresh", rndhex, NULL); psync_fake_prefix = putil_strcat(".refresh", rndhex, NULL);
psync_fake_prefix_len = strlen(psync_fake_prefix); psync_fake_prefix_len = strlen(psync_fake_prefix);
#endif #endif
psync_fstask_init(); psync_fstask_init();

8
pclsync/pfscrypto.c
View File

@ -1087,9 +1087,9 @@ static int psync_fs_crypto_do_finalize_log(psync_openfile_t *of, int fullsync) {
psync_binhex(fileidhex, &fileid, sizeof(psync_fsfileid_t)); psync_binhex(fileidhex, &fileid, sizeof(psync_fsfileid_t));
fileidhex[sizeof(psync_fsfileid_t)] = 'l'; fileidhex[sizeof(psync_fsfileid_t)] = 'l';
fileidhex[sizeof(psync_fsfileid_t) + 1] = 0; fileidhex[sizeof(psync_fsfileid_t) + 1] = 0;
olog = psync_strcat(cachepath, "/", fileidhex, NULL); olog = putil_strcat(cachepath, "/", fileidhex, NULL);
fileidhex[sizeof(psync_fsfileid_t)] = 'f'; fileidhex[sizeof(psync_fsfileid_t)] = 'f';
flog = psync_strcat(cachepath, "/", fileidhex, NULL); flog = putil_strcat(cachepath, "/", fileidhex, NULL);
if (pdbg_unlikely(pfile_rename_overwrite(olog, flog)) || if (pdbg_unlikely(pfile_rename_overwrite(olog, flog)) ||
pdbg_unlikely((of->logfile = pfile_open(olog, O_RDWR, pdbg_unlikely((of->logfile = pfile_open(olog, O_RDWR,
O_CREAT | O_TRUNC)) == O_CREAT | O_TRUNC)) ==
@ -1156,7 +1156,7 @@ psync_fs_crypto_reset_log_to_off(psync_openfile_t *of, uint32_t off) {
psync_binhex(fileidhex, &fileid, sizeof(psync_fsfileid_t)); psync_binhex(fileidhex, &fileid, sizeof(psync_fsfileid_t));
fileidhex[sizeof(psync_fsfileid_t)] = 'l'; fileidhex[sizeof(psync_fsfileid_t)] = 'l';
fileidhex[sizeof(psync_fsfileid_t) + 1] = 0; fileidhex[sizeof(psync_fsfileid_t) + 1] = 0;
log = psync_strcat(cachepath, "/", fileidhex, NULL); log = putil_strcat(cachepath, "/", fileidhex, NULL);
if (pfile_delete(log)) if (pfile_delete(log))
pdbg_logf(D_NOTICE, "could not delete old log file %s", log); pdbg_logf(D_NOTICE, "could not delete old log file %s", log);
of->logfile = pfile_open(log, O_RDWR, O_CREAT | O_TRUNC); of->logfile = pfile_open(log, O_RDWR, O_CREAT | O_TRUNC);
@ -2083,7 +2083,7 @@ static void psync_fs_crypto_check_file(void *ptr, ppath_fast_stat *st) {
return; return;
ch = st->name[len - 1]; ch = st->name[len - 1];
if (ch == 'l' || ch == 'f') { if (ch == 'l' || ch == 'f') {
path = psync_strcat((const char *)ptr, "/", st->name, path = putil_strcat((const char *)ptr, "/", st->name,
NULL); NULL);
psync_fs_crypto_check_log(path, st->name); psync_fs_crypto_check_log(path, st->name);
free(path); free(path);

10
pclsync/pfsfolder.c
View File

@ -62,7 +62,7 @@ static char *get_encname_for_folder(psync_fsfolderid_t folderid,
cryptoerr = psync_crypto_to_error(enc); cryptoerr = psync_crypto_to_error(enc);
return NULL; return NULL;
} }
name = psync_strndup(path, len); name = putil_strndup(path, len);
encname = pcryptofolder_fldencode_filename(enc, name); encname = pcryptofolder_fldencode_filename(enc, name);
pcryptofolder_fldencoder_release(folderid, enc); pcryptofolder_fldencoder_release(folderid, enc);
free(name); free(name);
@ -114,7 +114,7 @@ char *get_decname_for_folder(psync_fsfolderid_t folderid, const char *path,
cryptoerr = psync_crypto_to_error(dec); cryptoerr = psync_crypto_to_error(dec);
return NULL; return NULL;
} }
name = psync_strndup(path, len); name = putil_strndup(path, len);
decname = pcryptofolder_flddecode_filename(dec, name); decname = pcryptofolder_flddecode_filename(dec, name);
pcryptofolder_flddecoder_release(folderid, dec); pcryptofolder_flddecoder_release(folderid, dec);
free(name); free(name);
@ -213,7 +213,7 @@ psync_fspath_t *psync_fsfolder_resolve_path(const char *path) {
row = psql_fetch_int(res); row = psql_fetch_int(res);
folder = psync_fstask_get_folder_tasks_rdlocked(cfolderid); folder = psync_fstask_get_folder_tasks_rdlocked(cfolderid);
if (folder) { if (folder) {
char *name = psync_strndup(ename, elen); char *name = putil_strndup(ename, elen);
if ((mk = psync_fstask_find_mkdir(folder, name, 0))) { if ((mk = psync_fstask_find_mkdir(folder, name, 0))) {
if (mk->flags & PSYNC_FOLDER_FLAG_INVISIBLE) { if (mk->flags & PSYNC_FOLDER_FLAG_INVISIBLE) {
free(name); free(name);
@ -307,7 +307,7 @@ psync_fsfolderid_t psync_fsfolderid_by_path(const char *path,
row = psql_fetch_int(res); row = psql_fetch_int(res);
folder = psync_fstask_get_folder_tasks_rdlocked(cfolderid); folder = psync_fstask_get_folder_tasks_rdlocked(cfolderid);
if (folder) { if (folder) {
char *name = psync_strndup(ename, elen); char *name = putil_strndup(ename, elen);
if ((mk = psync_fstask_find_mkdir(folder, name, 0))) { if ((mk = psync_fstask_find_mkdir(folder, name, 0))) {
cfolderid = mk->folderid; cfolderid = mk->folderid;
flags = mk->flags; flags = mk->flags;
@ -393,7 +393,7 @@ psync_fsfolderid_t psync_fsfolderidperm_by_path(const char *path,
row = psql_fetch_int(res); row = psql_fetch_int(res);
folder = psync_fstask_get_folder_tasks_rdlocked(cfolderid); folder = psync_fstask_get_folder_tasks_rdlocked(cfolderid);
if (folder) { if (folder) {
char *name = psync_strndup(ename, elen); char *name = putil_strndup(ename, elen);
if ((mk = psync_fstask_find_mkdir(folder, name, 0))) { if ((mk = psync_fstask_find_mkdir(folder, name, 0))) {
cfolderid = mk->folderid; cfolderid = mk->folderid;
flags = mk->flags; flags = mk->flags;

24
pclsync/pfsupload.c
View File

@ -161,7 +161,7 @@ static int psync_process_task_mkdir(fsupload_task_t *task) {
psync_sql_res *res; psync_sql_res *res;
unsigned char *enckey; unsigned char *enckey;
size_t enckeylen; size_t enckeylen;
enckey = psync_base64_decode((const unsigned char *)task->text2, enckey = putil_base64_decode((const unsigned char *)task->text2,
strlen(task->text2), &enckeylen); strlen(task->text2), &enckeylen);
if (pdbg_likely(enckey)) { if (pdbg_likely(enckey)) {
res = psql_prepare( res = psql_prepare(
@ -402,7 +402,7 @@ static void set_key_for_fileid(psync_fileid_t fileid, uint64_t hash,
unsigned char *enckey; unsigned char *enckey;
size_t enckeylen; size_t enckeylen;
enckey = enckey =
psync_base64_decode((const unsigned char *)key, strlen(key), &enckeylen); putil_base64_decode((const unsigned char *)key, strlen(key), &enckeylen);
if (pdbg_likely(enckey)) { if (pdbg_likely(enckey)) {
res = psql_prepare( res = psql_prepare(
"REPLACE INTO cryptofilekey (fileid, hash, enckey) VALUES (?, ?, ?)"); "REPLACE INTO cryptofilekey (fileid, hash, enckey) VALUES (?, ?, ?)");
@ -1181,9 +1181,9 @@ static void large_upload() {
fileidhex[sizeof(psync_fsfileid_t)] = 'd'; fileidhex[sizeof(psync_fsfileid_t)] = 'd';
fileidhex[sizeof(psync_fsfileid_t) + 1] = 0; fileidhex[sizeof(psync_fsfileid_t) + 1] = 0;
cname = psync_setting_get_string(_PS(fscachepath)); cname = psync_setting_get_string(_PS(fscachepath));
filename = psync_strcat(cname, "/", fileidhex, NULL); filename = putil_strcat(cname, "/", fileidhex, NULL);
fileidhex[sizeof(psync_fsfileid_t)] = 'i'; fileidhex[sizeof(psync_fsfileid_t)] = 'i';
indexname = psync_strcat(cname, "/", fileidhex, NULL); indexname = putil_strcat(cname, "/", fileidhex, NULL);
res = psql_query_rdlock("SELECT uploadid FROM fstaskupload WHERE " res = psql_query_rdlock("SELECT uploadid FROM fstaskupload WHERE "
"fstaskid=? ORDER BY uploadid DESC LIMIT 1"); "fstaskid=? ORDER BY uploadid DESC LIMIT 1");
psql_bind_uint(res, 1, taskid); psql_bind_uint(res, 1, taskid);
@ -1269,7 +1269,7 @@ int psync_fsupload_in_current_small_uploads_batch_locked(uint64_t taskid) {
psync_binhex(fileidhex, &task->id, sizeof(psync_fsfileid_t)); psync_binhex(fileidhex, &task->id, sizeof(psync_fsfileid_t));
fileidhex[sizeof(psync_fsfileid_t)] = 'd'; fileidhex[sizeof(psync_fsfileid_t)] = 'd';
fileidhex[sizeof(psync_fsfileid_t) + 1] = 0; fileidhex[sizeof(psync_fsfileid_t) + 1] = 0;
filename = psync_strcat(psync_setting_get_string(_PS(fscachepath)), filename = putil_strcat(psync_setting_get_string(_PS(fscachepath)),
"/", fileidhex, NULL); "/", fileidhex, NULL);
stret = stat(filename, &st); stret = stat(filename, &st);
if (stret) if (stret)
@ -1296,7 +1296,7 @@ static int psync_send_task_creat(psock_t *api, fsupload_task_t *task) {
psync_binhex(fileidhex, &task->id, sizeof(psync_fsfileid_t)); psync_binhex(fileidhex, &task->id, sizeof(psync_fsfileid_t));
fileidhex[sizeof(psync_fsfileid_t)] = 'd'; fileidhex[sizeof(psync_fsfileid_t)] = 'd';
fileidhex[sizeof(psync_fsfileid_t) + 1] = 0; fileidhex[sizeof(psync_fsfileid_t) + 1] = 0;
filename = psync_strcat(psync_setting_get_string(_PS(fscachepath)), filename = putil_strcat(psync_setting_get_string(_PS(fscachepath)),
"/", fileidhex, NULL); "/", fileidhex, NULL);
fd = pfile_open(filename, O_RDONLY, 0); fd = pfile_open(filename, O_RDONLY, 0);
free(filename); free(filename);
@ -1594,11 +1594,11 @@ static void change_folder_name(fsupload_task_t *task) {
if (et > task->text1 && et[0] == '(' && atol(et + 1) < 20) { if (et > task->text1 && et[0] == '(' && atol(et + 1) < 20) {
nn = malloc(sizeof(char) * (et - task->text1 + 7)); nn = malloc(sizeof(char) * (et - task->text1 + 7));
memcpy(nn, task->text1, et - task->text1); memcpy(nn, task->text1, et - task->text1);
psync_slprintf(nn + (et - task->text1), 7, " (%d)", atoi(et + 1) + 1); putil_slprintf(nn + (et - task->text1), 7, " (%d)", atoi(et + 1) + 1);
} }
} }
if (!nn) { if (!nn) {
nn = psync_strcat(task->text1, "(1)", NULL); nn = putil_strcat(task->text1, "(1)", NULL);
} }
res = psql_prepare("UPDATE fstask SET text1=? WHERE id=?"); res = psql_prepare("UPDATE fstask SET text1=? WHERE id=?");
psql_bind_str(res, 1, nn); psql_bind_str(res, 1, nn);
@ -1679,13 +1679,13 @@ static void psync_delete_write_cache_file(uint64_t taskid, int index) {
fileidhex[sizeof(psync_fsfileid_t) + 1] = 0; fileidhex[sizeof(psync_fsfileid_t) + 1] = 0;
cachepath = psync_setting_get_string(_PS(fscachepath)); cachepath = psync_setting_get_string(_PS(fscachepath));
filename = filename =
psync_strcat(cachepath, "/", fileidhex, NULL); putil_strcat(cachepath, "/", fileidhex, NULL);
pdbg_assertw(pfile_delete(filename) == 0); pdbg_assertw(pfile_delete(filename) == 0);
free(filename); free(filename);
if (index) { if (index) {
fileidhex[sizeof(psync_fsfileid_t)] = 'i'; fileidhex[sizeof(psync_fsfileid_t)] = 'i';
filename = filename =
psync_strcat(cachepath, "/", fileidhex, NULL); putil_strcat(cachepath, "/", fileidhex, NULL);
pdbg_assertw(pfile_delete(filename) == 0); pdbg_assertw(pfile_delete(filename) == 0);
free(filename); free(filename);
} }
@ -2027,12 +2027,12 @@ static void clean_stuck_tasks() {
fileidhex[sizeof(psync_fsfileid_t)] = 'd'; fileidhex[sizeof(psync_fsfileid_t)] = 'd';
fileidhex[sizeof(psync_fsfileid_t) + 1] = 0; fileidhex[sizeof(psync_fsfileid_t) + 1] = 0;
filename = filename =
psync_strcat(cachepath, "/", fileidhex, NULL); putil_strcat(cachepath, "/", fileidhex, NULL);
pfile_delete(filename); pfile_delete(filename);
free(filename); free(filename);
fileidhex[sizeof(psync_fsfileid_t)] = 'i'; fileidhex[sizeof(psync_fsfileid_t)] = 'i';
filename = filename =
psync_strcat(cachepath, "/", fileidhex, NULL); putil_strcat(cachepath, "/", fileidhex, NULL);
pfile_delete(filename); pfile_delete(filename);
free(filename); free(filename);
psql_start(); psql_start();

2
pclsync/plibs.c
View File

@ -92,7 +92,7 @@ int psync_rename_conflicted_file(const char *path) {
num = 0; num = 0;
while (1) { while (1) {
if (num) if (num)
l = psync_slprintf(npath + dotidx, 32, " (conflicted %ld)", num); l = putil_slprintf(npath + dotidx, 32, " (conflicted %ld)", num);
else { else {
l = 13; l = 13;
memcpy(npath + dotidx, " (conflicted)", l); memcpy(npath + dotidx, " (conflicted)", l);

10
pclsync/plibs.h
View File

@ -91,8 +91,8 @@ extern "C" {
&(v)))) &(v))))
#define psync_dup_string(v) \ #define psync_dup_string(v) \
(likely((v).type == PSYNC_TSTRING) \ (likely((v).type == PSYNC_TSTRING) \
? psync_strndup((v).str, (v).length) \ ? putil_strndup((v).str, (v).length) \
: psync_strdup(psql_expect_str(__FILE__, __FUNCTION__, \ : putil_strdup(psql_expect_str(__FILE__, __FUNCTION__, \
__LINE__, &(v)))) __LINE__, &(v))))
#define psync_get_lstring(v, l) \ #define psync_get_lstring(v, l) \
psql_lstring_expected(__FILE__, __FUNCTION__, __LINE__, &(v), l) psql_lstring_expected(__FILE__, __FUNCTION__, __LINE__, &(v), l)
@ -165,7 +165,7 @@ static inline void psync_get_string_id(char *dst, const char *prefix, uint64_t i
plen = strlen(prefix); plen = strlen(prefix);
dst = (char *)memcpy(dst, prefix, plen) + plen; dst = (char *)memcpy(dst, prefix, plen) + plen;
do { do {
*dst++ = base64_table[id % 64]; *dst++ = putil_base64_table[id % 64];
id /= 64; id /= 64;
} while (id); } while (id);
*dst = 0; *dst = 0;
@ -177,12 +177,12 @@ static inline void psync_get_string_id2(char *dst, const char *prefix, uint64_t
plen = strlen(prefix); plen = strlen(prefix);
dst = (char *)memcpy(dst, prefix, plen) + plen; dst = (char *)memcpy(dst, prefix, plen) + plen;
do { do {
*dst++ = base64_table[id1 % 64]; *dst++ = putil_base64_table[id1 % 64];
id1 /= 64; id1 /= 64;
} while (id1); } while (id1);
*dst++ = '.'; *dst++ = '.';
do { do {
*dst++ = base64_table[id2 % 64]; *dst++ = putil_base64_table[id2 % 64];
id2 /= 64; id2 /= 64;
} while (id2); } while (id2);
*dst = 0; *dst = 0;

4
pclsync/plocalnotify.c
View File

@ -119,7 +119,7 @@ static void add_dir_scan(localnotify_dir *dir, const char *path) {
if (de->d_name[0] != '.' || if (de->d_name[0] != '.' ||
(de->d_name[1] != 0 && (de->d_name[1] != 0 &&
(de->d_name[1] != '.' || de->d_name[2] != 0))) { (de->d_name[1] != '.' || de->d_name[2] != 0))) {
psync_strlcpy(cpath + pl, de->d_name, namelen + 1); putil_strlcpy(cpath + pl, de->d_name, namelen + 1);
if (!lstat(cpath, &st) && S_ISDIR(st.st_mode)) if (!lstat(cpath, &st) && S_ISDIR(st.st_mode))
add_dir_scan(dir, cpath); add_dir_scan(dir, cpath);
} }
@ -222,7 +222,7 @@ static uint32_t process_notification(localnotify_dir *dir) {
while (wch) { while (wch) {
if (wch->watchid == ev.wd) { if (wch->watchid == ev.wd) {
wch->path[wch->pathlen] = '/'; wch->path[wch->pathlen] = '/';
psync_strlcpy(wch->path + wch->pathlen + 1, putil_strlcpy(wch->path + wch->pathlen + 1,
buff + off + offsetof(struct inotify_event, name), buff + off + offsetof(struct inotify_event, name),
wch->namelen + 1); wch->namelen + 1);
if (!lstat(wch->path, &st) && S_ISDIR(st.st_mode)) if (!lstat(wch->path, &st) && S_ISDIR(st.st_mode))

4
pclsync/plocalscan.c
View File

@ -438,7 +438,7 @@ static void add_new_element(const sync_folderlist *e, psync_folderid_t folderid,
return; return;
if (psync_is_name_to_ignore(e->name)) if (psync_is_name_to_ignore(e->name))
return; return;
if (!psync_is_valid_utf8(e->name)) { if (!putil_is_valid_utf8(e->name)) {
pdbg_logf(D_WARNING, "ignoring %s with invalid UTF8 name %s", pdbg_logf(D_WARNING, "ignoring %s with invalid UTF8 name %s",
e->isfolder ? "folder" : "file", e->name); e->isfolder ? "folder" : "file", e->name);
return; return;
@ -569,7 +569,7 @@ scanner_scan_folder(const char *localpath, psync_folderid_t folderid,
psync_list_for_each_element(l, &disklist, sync_folderlist, psync_list_for_each_element(l, &disklist, sync_folderlist,
list) if (l->isfolder && l->localid && list) if (l->isfolder && l->localid &&
l->deviceid == deviceid) { l->deviceid == deviceid) {
subpath = psync_strcat(localpath, "/", l->name, NULL); subpath = putil_strcat(localpath, "/", l->name, NULL);
scanner_scan_folder(subpath, l->remoteid, l->localid, syncid, synctype, scanner_scan_folder(subpath, l->remoteid, l->localid, syncid, synctype,
deviceid); deviceid);
free(subpath); free(subpath);

18
pclsync/pnetlibs.c
View File

@ -342,7 +342,7 @@ void psync_apipool_release_bad(psock_t *api) { psync_ret_api(api); }
static void rm_all(void *vpath, ppath_stat *st) { static void rm_all(void *vpath, ppath_stat *st) {
char *path; char *path;
path = psync_strcat((char *)vpath, "/", st->name, NULL); path = putil_strcat((char *)vpath, "/", st->name, NULL);
if (pfile_stat_isfolder(&st->stat)) { if (pfile_stat_isfolder(&st->stat)) {
ppath_ls(path, rm_all, path); ppath_ls(path, rm_all, path);
rmdir(path); rmdir(path);
@ -355,7 +355,7 @@ static void rm_ign(void *vpath, ppath_stat *st) {
char *path; char *path;
int ign; int ign;
ign = psync_is_name_to_ignore(st->name); ign = psync_is_name_to_ignore(st->name);
path = psync_strcat((char *)vpath, "/", st->name, NULL); path = putil_strcat((char *)vpath, "/", st->name, NULL);
if (pfile_stat_isfolder(&st->stat)) { if (pfile_stat_isfolder(&st->stat)) {
if (ign) if (ign)
ppath_ls(path, rm_all, path); ppath_ls(path, rm_all, path);
@ -984,9 +984,9 @@ cont:
*ptr = 0; *ptr = 0;
/* pdbg_logf(D_NOTICE, "key=%s, value=%s", key, val);*/ /* pdbg_logf(D_NOTICE, "key=%s, value=%s", key, val);*/
if (!memcmp(key, "content-length", 14)) if (!memcmp(key, "content-length", 14))
clen = psync_ato64(val); clen = putil_ato64(val);
else if (!memcmp(key, "keep-alive", 10) && !memcmp(val, "timeout=", 8)) else if (!memcmp(key, "keep-alive", 10) && !memcmp(val, "timeout=", 8))
keepalive = psync_ato32(val + 8); keepalive = putil_ato32(val + 8);
key = ptr + 1; key = ptr + 1;
isval = 0; isval = 0;
} else if (ch == ':' && !isval) { } else if (ch == ':' && !isval) {
@ -1482,9 +1482,9 @@ cont:
*ptr = 0; *ptr = 0;
/* pdbg_logf(D_NOTICE, "key=%s, value=%s", key, val);*/ /* pdbg_logf(D_NOTICE, "key=%s, value=%s", key, val);*/
if (!memcmp(key, "content-length", 14)) if (!memcmp(key, "content-length", 14))
clen = psync_ato64(val); clen = putil_ato64(val);
else if (!memcmp(key, "keep-alive", 10) && !memcmp(val, "timeout=", 8)) else if (!memcmp(key, "keep-alive", 10) && !memcmp(val, "timeout=", 8))
keepalive = psync_ato32(val + 8); keepalive = putil_ato32(val + 8);
key = ptr + 1; key = ptr + 1;
isval = 0; isval = 0;
} else if (ch == ':' && !isval) { } else if (ch == ':' && !isval) {
@ -1624,7 +1624,7 @@ static int psync_net_get_checksums(psock_t *api, psync_fileid_t fileid,
} }
hosts = papi_find_result2(res, "hosts", PARAM_ARRAY); hosts = papi_find_result2(res, "hosts", PARAM_ARRAY);
requestpath = papi_find_result2(res, "path", PARAM_STR)->str; requestpath = papi_find_result2(res, "path", PARAM_STR)->str;
psync_slprintf(cookie, sizeof(cookie), "Cookie: dwltag=%s\015\012", putil_slprintf(cookie, sizeof(cookie), "Cookie: dwltag=%s\015\012",
papi_find_result2(res, "dwltag", PARAM_STR)->str); papi_find_result2(res, "dwltag", PARAM_STR)->str);
http = NULL; http = NULL;
for (i = 0; i < hosts->length; i++) for (i = 0; i < hosts->length; i++)
@ -2682,13 +2682,13 @@ int psync_do_run_command_res(const char *cmd, size_t cmdlen,
if (result) { if (result) {
pdbg_logf(D_WARNING, "command %s returned code %u", cmd, (unsigned)result); pdbg_logf(D_WARNING, "command %s returned code %u", cmd, (unsigned)result);
if (err) if (err)
*err = psync_strdup(papi_find_result2(res, "error", PARAM_STR)->str); *err = putil_strdup(papi_find_result2(res, "error", PARAM_STR)->str);
psync_process_api_error(result); psync_process_api_error(result);
} }
free(res); free(res);
return (int)result; return (int)result;
neterr: neterr:
if (err) if (err)
*err = psync_strdup("Could not connect to the server."); *err = putil_strdup("Could not connect to the server.");
return -1; return -1;
} }

12
pclsync/pnotify.c
View File

@ -80,12 +80,12 @@ static void psync_notifications_download_thumb(const binresult *thumb,
filename = strrchr(path, '/'); filename = strrchr(path, '/');
if (pdbg_unlikely(!filename++)) if (pdbg_unlikely(!filename++))
return; return;
filepath = psync_strcat(thumbpath, "/", filename, NULL); filepath = putil_strcat(thumbpath, "/", filename, NULL);
if (!stat(filepath, &st)) { if (!stat(filepath, &st)) {
pdbg_logf(D_NOTICE, "skipping download of %s as it already exists", filename); pdbg_logf(D_NOTICE, "skipping download of %s as it already exists", filename);
goto err0; goto err0;
} }
tmpfilepath = psync_strcat(filepath, ".part", NULL); tmpfilepath = putil_strcat(filepath, ".part", NULL);
pdbg_logf(D_NOTICE, "downloading thumbnail %s", filename); pdbg_logf(D_NOTICE, "downloading thumbnail %s", filename);
if (pdbg_unlikely((fd = pfile_open(tmpfilepath, O_WRONLY, if (pdbg_unlikely((fd = pfile_open(tmpfilepath, O_WRONLY,
O_CREAT | O_TRUNC)) == O_CREAT | O_TRUNC)) ==
@ -95,7 +95,7 @@ static void psync_notifications_download_thumb(const binresult *thumb,
papi_find_result2(thumb, "hosts", PARAM_ARRAY), &host); papi_find_result2(thumb, "hosts", PARAM_ARRAY), &host);
if (pdbg_unlikely(!sock)) if (pdbg_unlikely(!sock))
goto err2; goto err2;
psync_slprintf(cookie, sizeof(cookie), "Cookie: dwltag=%s\015\012", putil_slprintf(cookie, sizeof(cookie), "Cookie: dwltag=%s\015\012",
papi_find_result2(thumb, "dwltag", PARAM_STR)->str); papi_find_result2(thumb, "dwltag", PARAM_STR)->str);
if (pdbg_unlikely(psync_http_request(sock, host, path, 0, 0, cookie))) if (pdbg_unlikely(psync_http_request(sock, host, path, 0, 0, cookie)))
goto err3; goto err3;
@ -187,7 +187,7 @@ void pnotify_set_callback(
pthread_mutex_lock(&ntf_mutex); pthread_mutex_lock(&ntf_mutex);
ts = ntf_thumb_size; ts = ntf_thumb_size;
if (thumbsize) if (thumbsize)
ntf_thumb_size = psync_strdup(thumbsize); ntf_thumb_size = putil_strdup(thumbsize);
else else
ntf_thumb_size = NULL; ntf_thumb_size = NULL;
if (ts) if (ts)
@ -326,7 +326,7 @@ psync_notification_list_t *pnotify_get() {
filename = strrchr(papi_find_result2(br, "path", PARAM_STR)->str, '/'); filename = strrchr(papi_find_result2(br, "path", PARAM_STR)->str, '/');
if (filename++) { if (filename++) {
psync_notification_remove_from_list(&thumbs, filename); psync_notification_remove_from_list(&thumbs, filename);
filepath = psync_strcat(thumbpath, "/", filepath = putil_strcat(thumbpath, "/",
filename, NULL); filename, NULL);
if (!stat(filepath, &st)) { if (!stat(filepath, &st)) {
pntf->thumb = filepath; pntf->thumb = filepath;
@ -355,7 +355,7 @@ psync_notification_list_t *pnotify_get() {
nx = ptree_get_next_safe(thumbs); nx = ptree_get_next_safe(thumbs);
pdbg_logf(D_NOTICE, "deleting unused thumb %s", pdbg_logf(D_NOTICE, "deleting unused thumb %s",
ptree_element(thumbs, psync_thumb_list_t, tree)->name); ptree_element(thumbs, psync_thumb_list_t, tree)->name);
filepath = psync_strcat( filepath = putil_strcat(
thumbpath, "/", thumbpath, "/",
ptree_element(thumbs, psync_thumb_list_t, tree)->name, NULL); ptree_element(thumbs, psync_thumb_list_t, tree)->name, NULL);
pfile_delete(filepath); pfile_delete(filepath);

18
pclsync/ppagecache.c
View File

@ -2384,7 +2384,7 @@ char *psync_http_construct_range_next_header(psync_request_t *request,
} }
if (off < sizeof(PSYNC_CONSTRUCT_HEADER)) if (off < sizeof(PSYNC_CONSTRUCT_HEADER))
return NULL; return NULL;
return psync_strdup((char *)memcpy( return putil_strdup((char *)memcpy(
buff + off - sizeof(PSYNC_CONSTRUCT_HEADER) + 3, PSYNC_CONSTRUCT_HEADER, buff + off - sizeof(PSYNC_CONSTRUCT_HEADER) + 3, PSYNC_CONSTRUCT_HEADER,
sizeof(PSYNC_CONSTRUCT_HEADER) - 1)); sizeof(PSYNC_CONSTRUCT_HEADER) - 1));
} }
@ -2440,7 +2440,7 @@ retry:
return; return;
} }
hosts = papi_find_result2(urls->urls, "hosts", PARAM_ARRAY); hosts = papi_find_result2(urls->urls, "hosts", PARAM_ARRAY);
psync_slprintf(cookie, sizeof(cookie), "Cookie: dwltag=%s\015\012", putil_slprintf(cookie, sizeof(cookie), "Cookie: dwltag=%s\015\012",
papi_find_result2(urls->urls, "dwltag", PARAM_STR)->str); papi_find_result2(urls->urls, "dwltag", PARAM_STR)->str);
sock = psync_http_connect_multihost_from_cache(hosts, &host); sock = psync_http_connect_multihost_from_cache(hosts, &host);
if (!sock) { if (!sock) {
@ -3527,7 +3527,7 @@ static void psync_pagecache_new_upload_to_cache(uint64_t taskid, uint64_t hash,
fileidhex[sizeof(psync_fsfileid_t)] = 'd'; fileidhex[sizeof(psync_fsfileid_t)] = 'd';
fileidhex[sizeof(psync_fsfileid_t) + 1] = 0; fileidhex[sizeof(psync_fsfileid_t) + 1] = 0;
tm = ptimer_time(); tm = ptimer_time();
filename = psync_strcat(psync_setting_get_string(_PS(fscachepath)), filename = putil_strcat(psync_setting_get_string(_PS(fscachepath)),
"/", fileidhex, NULL); "/", fileidhex, NULL);
fd = pfile_open(filename, O_RDONLY, 0); fd = pfile_open(filename, O_RDONLY, 0);
if (fd == INVALID_HANDLE_VALUE) { if (fd == INVALID_HANDLE_VALUE) {
@ -3613,10 +3613,10 @@ static void psync_pagecache_modify_to_cache(uint64_t taskid, uint64_t hash,
tm = ptimer_time(); tm = ptimer_time();
cachepath = psync_setting_get_string(_PS(fscachepath)); cachepath = psync_setting_get_string(_PS(fscachepath));
filename = filename =
psync_strcat(cachepath, "/", fileidhex, NULL); putil_strcat(cachepath, "/", fileidhex, NULL);
fileidhex[sizeof(psync_fsfileid_t)] = 'i'; fileidhex[sizeof(psync_fsfileid_t)] = 'i';
indexname = indexname =
psync_strcat(cachepath, "/", fileidhex, NULL); putil_strcat(cachepath, "/", fileidhex, NULL);
fd = pfile_open(indexname, O_RDONLY, 0); fd = pfile_open(indexname, O_RDONLY, 0);
if (unlikely(fd == INVALID_HANDLE_VALUE)) { if (unlikely(fd == INVALID_HANDLE_VALUE)) {
pdbg_logf(D_ERROR, pdbg_logf(D_ERROR,
@ -4109,7 +4109,7 @@ void ppagecache_init() {
if (stat(cache_dir, &st)) { if (stat(cache_dir, &st)) {
mkdir(cache_dir, PSYNC_DEFAULT_POSIX_FOLDER_MODE); mkdir(cache_dir, PSYNC_DEFAULT_POSIX_FOLDER_MODE);
} }
cache_file = psync_strcat(cache_dir, "/", cache_file = putil_strcat(cache_dir, "/",
PSYNC_DEFAULT_READ_CACHE_FILE, NULL); PSYNC_DEFAULT_READ_CACHE_FILE, NULL);
if (stat(cache_file, &st)) if (stat(cache_file, &st))
psql_statement("DELETE FROM pagecache"); psql_statement("DELETE FROM pagecache");
@ -4192,7 +4192,7 @@ void ppagecache_reopen_read() {
if (stat(cache_dir, &st)) { if (stat(cache_dir, &st)) {
mkdir(cache_dir, PSYNC_DEFAULT_POSIX_FOLDER_MODE); mkdir(cache_dir, PSYNC_DEFAULT_POSIX_FOLDER_MODE);
} }
cache_file = psync_strcat(cache_dir, "/", cache_file = putil_strcat(cache_dir, "/",
PSYNC_DEFAULT_READ_CACHE_FILE, NULL); PSYNC_DEFAULT_READ_CACHE_FILE, NULL);
readcache = pfile_open(cache_file, O_RDWR, O_CREAT); readcache = pfile_open(cache_file, O_RDWR, O_CREAT);
free(cache_file); free(cache_file);
@ -4240,7 +4240,7 @@ int ppagecache_move(const char *path) {
int newrdcache, ordcache; int newrdcache, ordcache;
uint32_t i, cnt; uint32_t i, cnt;
pdbg_logf(D_NOTICE, "start"); pdbg_logf(D_NOTICE, "start");
rdpath = psync_strcat(path, "/", rdpath = putil_strcat(path, "/",
PSYNC_DEFAULT_READ_CACHE_FILE, NULL); PSYNC_DEFAULT_READ_CACHE_FILE, NULL);
if (!stat(rdpath, &st)) { if (!stat(rdpath, &st)) {
free(rdpath); free(rdpath);
@ -4251,7 +4251,7 @@ int ppagecache_move(const char *path) {
free(rdpath); free(rdpath);
return pdbg_return_const(PERROR_CACHE_MOVE_NO_WRITE_ACCESS); return pdbg_return_const(PERROR_CACHE_MOVE_NO_WRITE_ACCESS);
} }
opath = psync_strdup(psync_setting_get_string(_PS(fscachepath))); opath = putil_strdup(psync_setting_get_string(_PS(fscachepath)));
pthread_mutex_lock(&clean_cache_mutex); pthread_mutex_lock(&clean_cache_mutex);
pthread_mutex_lock(&flush_cache_mutex); pthread_mutex_lock(&flush_cache_mutex);
psql_start(); psql_start();

14
pclsync/ppath.c
View File

@ -20,13 +20,13 @@ char *ppath_default_db() {
return NULL; return NULL;
} }
dbp = psync_strcat(pcdir, "/", PSYNC_DEFAULT_DB_NAME, NULL); dbp = putil_strcat(pcdir, "/", PSYNC_DEFAULT_DB_NAME, NULL);
free(pcdir); free(pcdir);
if (stat(dbp, &st)) { if (stat(dbp, &st)) {
// Inline the old database path function here // Inline the old database path function here
if ((home = ppath_home())) { if ((home = ppath_home())) {
oldp = psync_strcat(home, "/", PSYNC_DEFAULT_POSIX_DBNAME, NULL); oldp = putil_strcat(home, "/", PSYNC_DEFAULT_POSIX_DBNAME, NULL);
free(home); free(home);
if (oldp) { if (oldp) {
@ -69,7 +69,7 @@ char *ppath_home() {
return NULL; return NULL;
dir = result->pw_dir; dir = result->pw_dir;
} }
return psync_strdup(dir); return putil_strdup(dir);
} }
int ppath_ls(const char *path, ppath_ls_cb callback, void *ptr) { int ppath_ls(const char *path, ppath_ls_cb callback, void *ptr) {
@ -100,7 +100,7 @@ int ppath_ls(const char *path, ppath_ls_cb callback, void *ptr) {
(de->d_name[1] == 0 || (de->d_name[1] == '.' && de->d_name[2] == 0))) (de->d_name[1] == 0 || (de->d_name[1] == '.' && de->d_name[2] == 0)))
continue; continue;
psync_strlcpy(cpath + pl, de->d_name, NAME_MAX + 1); putil_strlcpy(cpath + pl, de->d_name, NAME_MAX + 1);
if (pdbg_likely(!lstat(cpath, &pst.stat)) && if (pdbg_likely(!lstat(cpath, &pst.stat)) &&
(S_ISREG(pst.stat.st_mode) || S_ISDIR(pst.stat.st_mode))) { (S_ISREG(pst.stat.st_mode) || S_ISDIR(pst.stat.st_mode))) {
@ -150,7 +150,7 @@ int ppath_ls_fast(const char *path, ppath_ls_fast_cb callback, void *ptr) {
callback(ptr, &pst); callback(ptr, &pst);
} else if (de->d_type == DT_UNKNOWN) { } else if (de->d_type == DT_UNKNOWN) {
// Fall back to lstat for unknown file types // Fall back to lstat for unknown file types
psync_strlcpy(cpath + pl, de->d_name, NAME_MAX + 1); putil_strlcpy(cpath + pl, de->d_name, NAME_MAX + 1);
if (!pdbg_unlikely(lstat(cpath, &st))) { if (!pdbg_unlikely(lstat(cpath, &st))) {
pst.isfolder = S_ISDIR(st.st_mode); pst.isfolder = S_ISDIR(st.st_mode);
callback(ptr, &pst); callback(ptr, &pst);
@ -172,7 +172,7 @@ char *ppath_pcloud() {
return NULL; return NULL;
} }
path = psync_strcat(homedir, "/", PSYNC_DEFAULT_POSIX_DIR, NULL); path = putil_strcat(homedir, "/", PSYNC_DEFAULT_POSIX_DIR, NULL);
free(homedir); free(homedir);
if (pdbg_unlikely(!path)) { if (pdbg_unlikely(!path)) {
return NULL; return NULL;
@ -192,7 +192,7 @@ char *ppath_private(char *name) {
path = ppath_pcloud(); path = ppath_pcloud();
if (!path) if (!path)
return NULL; return NULL;
rpath = psync_strcat(path, "/", name, NULL); rpath = putil_strcat(path, "/", name, NULL);
if (stat(rpath, &st) && mkdir(path, PSYNC_DEFAULT_POSIX_FOLDER_MODE)) { if (stat(rpath, &st) && mkdir(path, PSYNC_DEFAULT_POSIX_FOLDER_MODE)) {
free(rpath); free(rpath);
free(path); free(path);

16
pclsync/psettings.c
View File

@ -117,11 +117,11 @@ void psync_settings_reset() {
char *home, *defaultfs, *defaultcache; char *home, *defaultfs, *defaultcache;
psync_settingid_t i; psync_settingid_t i;
home = ppath_home(); home = ppath_home();
defaultfs = psync_strcat(home, "/", defaultfs = putil_strcat(home, "/",
PSYNC_DEFAULT_FS_FOLDER, NULL); PSYNC_DEFAULT_FS_FOLDER, NULL);
free(home); free(home);
home = ppath_pcloud(); home = ppath_pcloud();
defaultcache = psync_strcat(home, "/", defaultcache = putil_strcat(home, "/",
PSYNC_DEFAULT_CACHE_FOLDER, NULL); PSYNC_DEFAULT_CACHE_FOLDER, NULL);
free(home); free(home);
for (i = 0; i < ARRAY_SIZE(settings); i++) for (i = 0; i < ARRAY_SIZE(settings); i++)
@ -151,7 +151,7 @@ void psync_settings_reset() {
settings[_PS(ignorepaths)].str = PSYNC_IGNORE_PATHS_DEFAULT; settings[_PS(ignorepaths)].str = PSYNC_IGNORE_PATHS_DEFAULT;
for (i = 0; i < ARRAY_SIZE(settings); i++) { for (i = 0; i < ARRAY_SIZE(settings); i++) {
if (settings[i].type == PSYNC_TSTRING) { if (settings[i].type == PSYNC_TSTRING) {
settings[i].str = psync_strdup(settings[i].str); settings[i].str = putil_strdup(settings[i].str);
if (settings[i].fix_callback) if (settings[i].fix_callback)
settings[i].fix_callback(&settings[i].str); settings[i].fix_callback(&settings[i].str);
} else if (settings[i].fix_callback) { } else if (settings[i].fix_callback) {
@ -172,11 +172,11 @@ void psync_settings_init() {
char *home, *defaultfs, *defaultcache; char *home, *defaultfs, *defaultcache;
psync_settingid_t i; psync_settingid_t i;
home = ppath_home(); home = ppath_home();
defaultfs = psync_strcat(home, "/", defaultfs = putil_strcat(home, "/",
PSYNC_DEFAULT_FS_FOLDER, NULL); PSYNC_DEFAULT_FS_FOLDER, NULL);
free(home); free(home);
home = ppath_pcloud(); home = ppath_pcloud();
defaultcache = psync_strcat(home, "/", defaultcache = putil_strcat(home, "/",
PSYNC_DEFAULT_CACHE_FOLDER, NULL); PSYNC_DEFAULT_CACHE_FOLDER, NULL);
free(home); free(home);
settings[_PS(ignorepatterns)].str = PSYNC_IGNORE_PATTERNS_DEFAULT; settings[_PS(ignorepatterns)].str = PSYNC_IGNORE_PATTERNS_DEFAULT;
@ -195,7 +195,7 @@ void psync_settings_init() {
settings[_PS(ignorepaths)].str = PSYNC_IGNORE_PATHS_DEFAULT; settings[_PS(ignorepaths)].str = PSYNC_IGNORE_PATHS_DEFAULT;
for (i = 0; i < ARRAY_SIZE(settings); i++) { for (i = 0; i < ARRAY_SIZE(settings); i++) {
if (settings[i].type == PSYNC_TSTRING) { if (settings[i].type == PSYNC_TSTRING) {
settings[i].str = psync_strdup(settings[i].str); settings[i].str = putil_strdup(settings[i].str);
if (settings[i].fix_callback) if (settings[i].fix_callback)
settings[i].fix_callback(&settings[i].str); settings[i].fix_callback(&settings[i].str);
} else if (settings[i].fix_callback) { } else if (settings[i].fix_callback) {
@ -214,7 +214,7 @@ void psync_settings_init() {
if (!strcmp(name, settings[i].name)) { if (!strcmp(name, settings[i].name)) {
if (settings[i].type == PSYNC_TSTRING) { if (settings[i].type == PSYNC_TSTRING) {
free(settings[i].str); free(settings[i].str);
settings[i].str = psync_strdup(row[1]); settings[i].str = putil_strdup(row[1]);
if (settings[i].fix_callback) if (settings[i].fix_callback)
settings[i].fix_callback(&settings[i].str); settings[i].fix_callback(&settings[i].str);
} else if (settings[i].type == PSYNC_TNUMBER) { } else if (settings[i].type == PSYNC_TNUMBER) {
@ -333,7 +333,7 @@ int psync_setting_set_string(psync_settingid_t settingid, const char *value) {
char *oldval, *newval; char *oldval, *newval;
CHECK_SETTINGID_AND_TYPE(-1, PSYNC_TSTRING); CHECK_SETTINGID_AND_TYPE(-1, PSYNC_TSTRING);
oldval = settings[settingid].str; oldval = settings[settingid].str;
newval = psync_strdup(value); newval = putil_strdup(value);
if (settings[settingid].fix_callback) if (settings[settingid].fix_callback)
settings[settingid].fix_callback(&newval); settings[settingid].fix_callback(&newval);
settings[settingid].str = newval; settings[settingid].str = newval;

2
pclsync/psock.c
View File

@ -461,7 +461,7 @@ psock_t *psock_connect(const char *host, int unsigned port, int ssl) {
void *sslc; void *sslc;
int sock; int sock;
char sport[8]; char sport[8];
psync_slprintf(sport, sizeof(sport), "%d", port); putil_slprintf(sport, sizeof(sport), "%d", port);
sock = connect_socket(host, sport); sock = connect_socket(host, sport);
if (pdbg_unlikely(sock == INVALID_SOCKET)) { if (pdbg_unlikely(sock == INVALID_SOCKET)) {

6
pclsync/psql.c
View File

@ -199,7 +199,7 @@ void psql_dump_locks() {
rd_lock_data *lock; rd_lock_data *lock;
char dttime[36]; char dttime[36];
if (wrlocked) { if (wrlocked) {
time_format(lockstart.tv_sec, lockstart.tv_nsec, dttime); putil_time_format(lockstart.tv_sec, lockstart.tv_nsec, dttime);
pdbg_logf(D_ERROR, "write lock taken by thread %s from %s:%u at %s", pdbg_logf(D_ERROR, "write lock taken by thread %s from %s:%u at %s",
wrlockthread, wrlockfile, wrlockline, dttime); wrlockthread, wrlockfile, wrlockline, dttime);
sendpdbg_logf("write lock taken by thread %s from %s:%u at %s", wrlockthread, sendpdbg_logf("write lock taken by thread %s from %s:%u at %s", wrlockthread,
@ -207,7 +207,7 @@ void psql_dump_locks() {
} }
pthread_mutex_lock(&rdmutex); pthread_mutex_lock(&rdmutex);
psync_list_for_each_element(lock, &rdlocks, rd_lock_data, list) { psync_list_for_each_element(lock, &rdlocks, rd_lock_data, list) {
time_format(lock->tm.tv_sec, lock->tm.tv_nsec, dttime); putil_time_format(lock->tm.tv_sec, lock->tm.tv_nsec, dttime);
pdbg_logf(D_ERROR, "read lock taken by thread %s from %s:%u at %s", pdbg_logf(D_ERROR, "read lock taken by thread %s from %s:%u at %s",
lock->thread, lock->file, lock->line, dttime); lock->thread, lock->file, lock->line, dttime);
sendpdbg_logf("read lock taken by thread %s from %s:%u at %s", lock->thread, sendpdbg_logf("read lock taken by thread %s from %s:%u at %s", lock->thread,
@ -628,7 +628,7 @@ char *psql_cellstr(const char *sql) {
char *ret; char *ret;
ret = (char *)sqlite3_column_text(stmt, 0); ret = (char *)sqlite3_column_text(stmt, 0);
if (ret) if (ret)
ret = psync_strdup(ret); ret = putil_strdup(ret);
sqlite3_finalize(stmt); sqlite3_finalize(stmt);
psql_rdunlock(); psql_rdunlock();
return ret; return ret;

2
pclsync/pssl.c
View File

@ -704,7 +704,7 @@ char *psymkey_derive(const char *username,
mbedtls_pkcs5_pbkdf2_hmac(&ctx, (const unsigned char *)passphrase, strlen(passphrase), usersha512, mbedtls_pkcs5_pbkdf2_hmac(&ctx, (const unsigned char *)passphrase, strlen(passphrase), usersha512,
PSYNC_SHA512_DIGEST_LEN, 5000, sizeof(passwordbin), passwordbin); PSYNC_SHA512_DIGEST_LEN, 5000, sizeof(passwordbin), passwordbin);
mbedtls_md_free(&ctx); mbedtls_md_free(&ctx);
usercopy = psync_base64_encode(passwordbin, sizeof(passwordbin), &userlen); usercopy = putil_base64_encode(passwordbin, sizeof(passwordbin), &userlen);
return (char *)usercopy; return (char *)usercopy;
} }

2
pclsync/pstatus.c
View File

@ -218,7 +218,7 @@ void pstatus_upload_recalc() {
fileidhex[sizeof(psync_fsfileid_t)] = 'd'; fileidhex[sizeof(psync_fsfileid_t)] = 'd';
fileidhex[sizeof(psync_fsfileid_t) + 1] = 0; fileidhex[sizeof(psync_fsfileid_t) + 1] = 0;
filename = filename =
psync_strcat(fscpath, "/", fileidhex, NULL); putil_strcat(fscpath, "/", fileidhex, NULL);
if (!stat(filename, &st)) { if (!stat(filename, &st)) {
filestou++; filestou++;
bytestou += pfile_stat_size(&st); bytestou += pfile_stat_size(&st);

2
pclsync/psuggest.c
View File

@ -222,7 +222,7 @@ psuggested_folders_t *psuggest_scan_folder(const char *path) {
qsort(scnt, PSYNC_SCAN_TYPES_CNT, sizeof(scnt[0]), sort_comp_tuple_rev); qsort(scnt, PSYNC_SCAN_TYPES_CNT, sizeof(scnt[0]), sort_comp_tuple_rev);
for (i = 0; i < PSYNC_SCAN_TYPES_CNT; i++) for (i = 0; i < PSYNC_SCAN_TYPES_CNT; i++)
if (scnt[i][1] && scnt[i][0] >= PSYNC_SCANNER_MIN_DISPLAY) { if (scnt[i][1] && scnt[i][0] >= PSYNC_SCANNER_MIN_DISPLAY) {
off += psync_slprintf(buff + off, sizeof(buff) - off, "%u %s, ", off += putil_slprintf(buff + off, sizeof(buff) - off, "%u %s, ",
(unsigned)scnt[i][0], (unsigned)scnt[i][0],
psync_scan_typenames[scnt[i][1]]); psync_scan_typenames[scnt[i][1]]);
if (off >= sizeof(buff)) if (off >= sizeof(buff))

8
pclsync/psyncer.c
View File

@ -192,7 +192,7 @@ psync_folderid_t psyncer_db_folder_create(
for (ptr = name; *ptr; ptr++) for (ptr = name; *ptr; ptr++)
if (pfile_invalid_chars[(unsigned char)*ptr]) { if (pfile_invalid_chars[(unsigned char)*ptr]) {
if (!vname) if (!vname)
vname = psync_strdup(name); vname = putil_strdup(name);
vname[ptr - name] = '_'; vname[ptr - name] = '_';
} }
if (vname) if (vname)
@ -307,7 +307,7 @@ static void psync_sync_newsyncedfolder(psync_syncid_t syncid) {
folderid = psync_get_number(row[0]); folderid = psync_get_number(row[0]);
synctype = psync_get_number(row[1]); synctype = psync_get_number(row[1]);
localpath = localpath =
psync_strndup(psync_get_string(row[2]), strlen(psync_get_string(row[2]))); putil_strndup(psync_get_string(row[2]), strlen(psync_get_string(row[2])));
psql_free(res); psql_free(res);
if (synctype & PSYNC_DOWNLOAD_ONLY) { if (synctype & PSYNC_DOWNLOAD_ONLY) {
psyncer_dl_folder_add(syncid, synctype, folderid, 0); psyncer_dl_folder_add(syncid, synctype, folderid, 0);
@ -463,8 +463,8 @@ re:
continue; continue;
} }
localpath = psync_strdup(localpath); localpath = putil_strdup(localpath);
remotepath = psync_strdup(remotepath); remotepath = putil_strdup(remotepath);
psql_free(res); psql_free(res);
folderid = pfolder_id_create(remotepath); folderid = pfolder_id_create(remotepath);

64
pclsync/psynclib.c
View File

@ -112,7 +112,7 @@ static inline int psync_status_is_offline() {
uint32_t psync_get_last_error() { return psync_error; } uint32_t psync_get_last_error() { return psync_error; }
void psync_set_database_path(const char *databasepath) { void psync_set_database_path(const char *databasepath) {
psync_database = psync_strdup(databasepath); psync_database = putil_strdup(databasepath);
} }
static void psync_stop_crypto_on_sleep() { static void psync_stop_crypto_on_sleep() {
@ -288,10 +288,10 @@ void psync_set_user_pass(const char *username, const char *password, int save) {
} else { } else {
pthread_mutex_lock(&psync_my_auth_mutex); pthread_mutex_lock(&psync_my_auth_mutex);
free(psync_my_user); free(psync_my_user);
psync_my_user = psync_strdup(username); psync_my_user = putil_strdup(username);
free(psync_my_pass); free(psync_my_pass);
if (password && password[0]) if (password && password[0])
psync_my_pass = psync_strdup(password); psync_my_pass = putil_strdup(password);
pthread_mutex_unlock(&psync_my_auth_mutex); pthread_mutex_unlock(&psync_my_auth_mutex);
} }
pstatus_set(PSTATUS_TYPE_AUTH, PSTATUS_AUTH_PROVIDED); pstatus_set(PSTATUS_TYPE_AUTH, PSTATUS_AUTH_PROVIDED);
@ -305,7 +305,7 @@ void psync_set_pass(const char *password, int save) {
else { else {
pthread_mutex_lock(&psync_my_auth_mutex); pthread_mutex_lock(&psync_my_auth_mutex);
free(psync_my_pass); free(psync_my_pass);
psync_my_pass = psync_strdup(password); psync_my_pass = putil_strdup(password);
pthread_mutex_unlock(&psync_my_auth_mutex); pthread_mutex_unlock(&psync_my_auth_mutex);
} }
pstatus_set(PSTATUS_TYPE_AUTH, PSTATUS_AUTH_PROVIDED); pstatus_set(PSTATUS_TYPE_AUTH, PSTATUS_AUTH_PROVIDED);
@ -316,7 +316,7 @@ void psync_set_auth(const char *auth, int save) {
if (save) if (save)
psync_set_string_value("auth", auth); psync_set_string_value("auth", auth);
else else
psync_strlcpy(psync_my_auth, auth, sizeof(psync_my_auth)); putil_strlcpy(psync_my_auth, auth, sizeof(psync_my_auth));
pstatus_set(PSTATUS_TYPE_AUTH, PSTATUS_AUTH_PROVIDED); pstatus_set(PSTATUS_TYPE_AUTH, PSTATUS_AUTH_PROVIDED);
} }
@ -380,7 +380,7 @@ apiservers_list_t *psync_get_apiservers(char **err) {
if (unlikely(!api)) { if (unlikely(!api)) {
pdbg_logf(D_WARNING, "Can't get api from the pool. No pool ?\n"); pdbg_logf(D_WARNING, "Can't get api from the pool. No pool ?\n");
*err = psync_strndup("Can't get api from the pool.", 29); *err = putil_strndup("Can't get api from the pool.", 29);
return NULL; return NULL;
} }
bres = papi_send2(api, "getlocationapi", params); bres = papi_send2(api, "getlocationapi", params);
@ -389,13 +389,13 @@ apiservers_list_t *psync_get_apiservers(char **err) {
else { else {
psync_apipool_release_bad(api); psync_apipool_release_bad(api);
pdbg_logf(D_WARNING, "Send command returned invalid result.\n"); pdbg_logf(D_WARNING, "Send command returned invalid result.\n");
*err = psync_strndup("Connection error.", 17); *err = putil_strndup("Connection error.", 17);
return NULL; return NULL;
} }
result = papi_find_result2(bres, "result", PARAM_NUM)->num; result = papi_find_result2(bres, "result", PARAM_NUM)->num;
if (unlikely(result)) { if (unlikely(result)) {
errorret = papi_find_result2(bres, "error", PARAM_STR)->str; errorret = papi_find_result2(bres, "error", PARAM_STR)->str;
*err = psync_strndup(errorret, strlen(errorret)); *err = putil_strndup(errorret, strlen(errorret));
pdbg_logf(D_WARNING, "command getlocationapi returned error code %u", pdbg_logf(D_WARNING, "command getlocationapi returned error code %u",
(unsigned)result); (unsigned)result);
return NULL; return NULL;
@ -529,9 +529,9 @@ static void check_tfa_result(uint64_t result) {
static char *binresult_to_str(const binresult *res) { static char *binresult_to_str(const binresult *res) {
if (!res) if (!res)
return psync_strdup("field not found"); return putil_strdup("field not found");
if (res->type == PARAM_STR) if (res->type == PARAM_STR)
return psync_strdup(res->str); return putil_strdup(res->str);
else if (res->type == PARAM_NUM) { else if (res->type == PARAM_NUM) {
char buff[32], *ptr; char buff[32], *ptr;
uint64_t n; uint64_t n;
@ -542,9 +542,9 @@ static char *binresult_to_str(const binresult *res) {
*--ptr = '0' + n % 10; *--ptr = '0' + n % 10;
n /= 10; n /= 10;
} while (n); } while (n);
return psync_strdup(ptr); return putil_strdup(ptr);
} else { } else {
return psync_strdup("bad field type"); return putil_strdup("bad field type");
} }
} }
@ -905,7 +905,7 @@ static int do_run_command_get_res(const char *cmd, size_t cmdlen,
if (result) { if (result) {
pdbg_logf(D_WARNING, "command %s returned code %u", cmd, (unsigned)result); pdbg_logf(D_WARNING, "command %s returned code %u", cmd, (unsigned)result);
if (err) if (err)
*err = psync_strdup(papi_find_result2(res, "error", PARAM_STR)->str); *err = putil_strdup(papi_find_result2(res, "error", PARAM_STR)->str);
psync_process_api_error(result); psync_process_api_error(result);
} }
if (result) if (result)
@ -915,7 +915,7 @@ static int do_run_command_get_res(const char *cmd, size_t cmdlen,
return (int)result; return (int)result;
neterr: neterr:
if (err) if (err)
*err = psync_strdup("Could not connect to the server."); *err = putil_strdup("Could not connect to the server.");
return -1; return -1;
} }
@ -931,14 +931,14 @@ int psync_register(const char *email, const char *password, int termsaccepted,
psync_set_apiserver(binapi, locationid); psync_set_apiserver(binapi, locationid);
else { else {
if (err) if (err)
*err = psync_strdup("Could not connect to the server."); *err = putil_strdup("Could not connect to the server.");
psync_set_apiserver(PSYNC_API_HOST, PSYNC_LOCATIONID_DEFAULT); psync_set_apiserver(PSYNC_API_HOST, PSYNC_LOCATIONID_DEFAULT);
return -1; return -1;
} }
sock = papi_connect(binapi, psync_setting_get_bool(_PS(usessl))); sock = papi_connect(binapi, psync_setting_get_bool(_PS(usessl)));
if (pdbg_unlikely(!sock)) { if (pdbg_unlikely(!sock)) {
if (err) if (err)
*err = psync_strdup("Could not connect to the server."); *err = putil_strdup("Could not connect to the server.");
psync_set_apiserver(PSYNC_API_HOST, PSYNC_LOCATIONID_DEFAULT); psync_set_apiserver(PSYNC_API_HOST, PSYNC_LOCATIONID_DEFAULT);
return -1; return -1;
} }
@ -946,7 +946,7 @@ int psync_register(const char *email, const char *password, int termsaccepted,
if (pdbg_unlikely(!res)) { if (pdbg_unlikely(!res)) {
psock_close(sock); psock_close(sock);
if (err) if (err)
*err = psync_strdup("Could not connect to the server."); *err = putil_strdup("Could not connect to the server.");
psync_set_apiserver(PSYNC_API_HOST, PSYNC_LOCATIONID_DEFAULT); psync_set_apiserver(PSYNC_API_HOST, PSYNC_LOCATIONID_DEFAULT);
return -1; return -1;
} }
@ -954,7 +954,7 @@ int psync_register(const char *email, const char *password, int termsaccepted,
if (result) { if (result) {
pdbg_logf(D_WARNING, "command register returned code %u", (unsigned)result); pdbg_logf(D_WARNING, "command register returned code %u", (unsigned)result);
if (err) if (err)
*err = psync_strdup(papi_find_result2(res, "error", PARAM_STR)->str); *err = putil_strdup(papi_find_result2(res, "error", PARAM_STR)->str);
psync_set_apiserver(PSYNC_API_HOST, PSYNC_LOCATIONID_DEFAULT); psync_set_apiserver(PSYNC_API_HOST, PSYNC_LOCATIONID_DEFAULT);
} }
psock_close(sock); psock_close(sock);
@ -993,7 +993,7 @@ int psync_change_password(const char *currentpass, const char *newpass,
free(device); free(device);
if (ret) if (ret)
return ret; return ret;
psync_strlcpy(psync_my_auth, papi_find_result2(res, "auth", PARAM_STR)->str, putil_strlcpy(psync_my_auth, papi_find_result2(res, "auth", PARAM_STR)->str,
sizeof(psync_my_auth)); sizeof(psync_my_auth));
free(res); free(res);
return 0; return 0;
@ -1130,7 +1130,7 @@ char *psync_get_string_value(const char *valuename) {
psql_bind_str(res, 1, valuename); psql_bind_str(res, 1, valuename);
row = psql_fetch_str(res); row = psql_fetch_str(res);
if (row) if (row)
ret = psync_strdup(row[0]); ret = putil_strdup(row[0]);
else else
ret = NULL; ret = NULL;
psql_free(res); psql_free(res);
@ -1495,7 +1495,7 @@ static void psync_del_all_except(void *ptr, ppath_fast_stat *st) {
nmarr = (const char **)ptr; nmarr = (const char **)ptr;
if (!strcmp(st->name, nmarr[1]) || pfile_stat_fast_isfolder(st)) if (!strcmp(st->name, nmarr[1]) || pfile_stat_fast_isfolder(st))
return; return;
fp = psync_strcat(nmarr[0], "/", st->name, NULL); fp = putil_strcat(nmarr[0], "/", st->name, NULL);
pdbg_logf(D_NOTICE, "deleting old update file %s", fp); pdbg_logf(D_NOTICE, "deleting old update file %s", fp);
if (pfile_delete(fp)) if (pfile_delete(fp))
pdbg_logf(D_WARNING, "could not delete %s", fp); pdbg_logf(D_WARNING, "could not delete %s", fp);
@ -1516,7 +1516,7 @@ static char *psync_filename_from_res(const binresult *res) {
nmarr[0] = path; nmarr[0] = path;
nmarr[1] = nmd; nmarr[1] = nmd;
ppath_ls_fast(path, psync_del_all_except, (void *)nmarr); ppath_ls_fast(path, psync_del_all_except, (void *)nmarr);
ret = psync_strcat(path, "/", nmd, NULL); ret = putil_strcat(path, "/", nmd, NULL);
free(nmd); free(nmd);
free(path); free(path);
return ret; return ret;
@ -2105,7 +2105,7 @@ int psync_fs_move_cache(const char *path) {
char *psync_get_token() { char *psync_get_token() {
if (psync_my_auth[0]) if (psync_my_auth[0])
return psync_strdup(psync_my_auth); return putil_strdup(psync_my_auth);
else else
return NULL; return NULL;
} }
@ -2136,7 +2136,7 @@ int psync_get_promo(char **url, uint64_t *width, uint64_t *height) {
return result; return result;
} }
*url = psync_strdup(papi_find_result2(res, "url", PARAM_STR)->str); *url = putil_strdup(papi_find_result2(res, "url", PARAM_STR)->str);
if (!papi_find_result2(res, "width", PARAM_NUM)->num) { if (!papi_find_result2(res, "width", PARAM_NUM)->num) {
pdbg_logf(D_NOTICE, "Parameter width not found."); pdbg_logf(D_NOTICE, "Parameter width not found.");
@ -2241,13 +2241,13 @@ int psync_is_folder_syncable(char *localPath, char **errMsg) {
if (psyncer_str_has_prefix(srow[0], localPath)) { if (psyncer_str_has_prefix(srow[0], localPath)) {
psql_free(sql); psql_free(sql);
*errMsg = psync_strdup("There is already an active sync or backup for a " *errMsg = putil_strdup("There is already an active sync or backup for a "
"parent of this folder."); "parent of this folder.");
return PERROR_PARENT_OR_SUBFOLDER_ALREADY_SYNCING; return PERROR_PARENT_OR_SUBFOLDER_ALREADY_SYNCING;
} else if (!strcmp(srow[0], localPath)) { } else if (!strcmp(srow[0], localPath)) {
psql_free(sql); psql_free(sql);
*errMsg = psync_strdup( *errMsg = putil_strdup(
"There is already an active sync or backup for this folder."); "There is already an active sync or backup for this folder.");
return PERROR_FOLDER_ALREADY_SYNCING; return PERROR_FOLDER_ALREADY_SYNCING;
} }
@ -2268,7 +2268,7 @@ int psync_is_folder_syncable(char *localPath, char **errMsg) {
localPath[len] == '\\')) { localPath[len] == '\\')) {
free(syncmp); free(syncmp);
*errMsg = psync_strdup("Folder is located on pCloud drive."); *errMsg = putil_strdup("Folder is located on pCloud drive.");
return PERROR_LOCAL_IS_ON_PDRIVE; return PERROR_LOCAL_IS_ON_PDRIVE;
} }
free(syncmp); free(syncmp);
@ -2283,7 +2283,7 @@ int psync_is_folder_syncable(char *localPath, char **errMsg) {
localPath); localPath);
if (psyncer_str_starts_with(folders.folders[i], localPath)) { if (psyncer_str_starts_with(folders.folders[i], localPath)) {
*errMsg = psync_strdup( *errMsg = putil_strdup(
"This folder is a child of a folder in your ignore folders list."); "This folder is a child of a folder in your ignore folders list.");
return PERROR_PARENT_IS_IGNORED; return PERROR_PARENT_IS_IGNORED;
} }
@ -2304,7 +2304,7 @@ psync_folderid_t create_bup_mach_folder(char **msgErr) {
rootFolIdObj = NULL; rootFolIdObj = NULL;
tmpBuff = get_pc_name(); tmpBuff = get_pc_name();
psync_strlcpy(bRootFoName, tmpBuff, 64); putil_strlcpy(bRootFoName, tmpBuff, 64);
free(tmpBuff); free(tmpBuff);
@ -2377,10 +2377,10 @@ int psync_create_backup(char *path, char **errMsg) {
if (folders.cnt > 1) { if (folders.cnt > 1) {
oParCnt = 1; oParCnt = 1;
optFolName = psync_strdup(folders.folders[folders.cnt - 2]); optFolName = putil_strdup(folders.folders[folders.cnt - 2]);
} else { } else {
oParCnt = 0; oParCnt = 0;
optFolName = psync_strdup(""); optFolName = putil_strdup("");
} }
eventParams reqPar = {4, // Number of parameters we are passing below. eventParams reqPar = {4, // Number of parameters we are passing below.
@ -2406,7 +2406,7 @@ int psync_create_backup(char *path, char **errMsg) {
free(retData); free(retData);
if (syncFId < 0) { if (syncFId < 0) {
*errMsg = psync_strdup("Error creating backup."); *errMsg = putil_strdup("Error creating backup.");
return syncFId; return syncFId;
} }

4
pclsync/ptask.c
View File

@ -457,7 +457,7 @@ static int handle_download(async_params_t *prms,
s->process_data = download_process_headers; s->process_data = download_process_headers;
fda->localpath = dwl->localpath; fda->localpath = dwl->localpath;
fda->fd = INVALID_HANDLE_VALUE; fda->fd = INVALID_HANDLE_VALUE;
len = psync_slprintf(buff, sizeof(buff), len = putil_slprintf(buff, sizeof(buff),
"act=dwl,strm=%" PRIu64 ",fileid=%" PRIu64 "\n", "act=dwl,strm=%" PRIu64 ",fileid=%" PRIu64 "\n",
(uint64_t)s->streamid, (uint64_t)dwl->fileid); (uint64_t)s->streamid, (uint64_t)dwl->fileid);
if (data_send(prms, buff, len)) { if (data_send(prms, buff, len)) {
@ -488,7 +488,7 @@ static int handle_download_nm(async_params_t *prms,
memcpy(fda->osha1hex, dwl->sha1hex, PSYNC_SHA1_DIGEST_HEXLEN); memcpy(fda->osha1hex, dwl->sha1hex, PSYNC_SHA1_DIGEST_HEXLEN);
fda->localpath = dwl->localpath; fda->localpath = dwl->localpath;
fda->fd = INVALID_HANDLE_VALUE; fda->fd = INVALID_HANDLE_VALUE;
len = psync_slprintf( len = putil_slprintf(
buff, sizeof(buff), buff, sizeof(buff),
"act=dwlnm,strm=%" PRIu64 ",fileid=%" PRIu64 ",sha1=%.40s\n", "act=dwlnm,strm=%" PRIu64 ",fileid=%" PRIu64 ",sha1=%.40s\n",
(uint64_t)s->streamid, (uint64_t)dwl->fileid, dwl->sha1hex); (uint64_t)s->streamid, (uint64_t)dwl->fileid, dwl->sha1hex);

26
pclsync/ptools.c
View File

@ -76,10 +76,10 @@ char *ptools_get_mac_addr() {
buffer[12] = 0; buffer[12] = 0;
if (buffer[0] == 0) { if (buffer[0] == 0) {
return psync_strdup("GENERIC_MAC"); return putil_strdup("GENERIC_MAC");
} else { } else {
return psync_strdup(buffer); return putil_strdup(buffer);
} }
} }
@ -102,7 +102,7 @@ int ptools_create_backend_event(const char *binapi, const char *category,
if (pdbg_unlikely(!sock)) { if (pdbg_unlikely(!sock)) {
if (err) { if (err) {
*err = psync_strdup("Could not connect to the server."); *err = putil_strdup("Could not connect to the server.");
} }
return -1; return -1;
@ -189,7 +189,7 @@ int ptools_create_backend_event(const char *binapi, const char *category,
psock_close(sock); psock_close(sock);
if (err) { if (err) {
*err = psync_strdup("Could not connect to the server."); *err = putil_strdup("Could not connect to the server.");
} }
return -1; return -1;
@ -201,7 +201,7 @@ int ptools_create_backend_event(const char *binapi, const char *category,
if (result) { if (result) {
if (err) { if (err) {
*err = psync_strdup(papi_find_result2(res, "error", PARAM_STR)->str); *err = putil_strdup(papi_find_result2(res, "error", PARAM_STR)->str);
} }
pdbg_logf(D_CRITICAL, "Event command failed. Error:[%s]", *err); pdbg_logf(D_CRITICAL, "Event command failed. Error:[%s]", *err);
@ -298,7 +298,7 @@ int ptools_backend_call(const char *binapi, const char *wsPath,
if (pdbg_unlikely(!sock)) { if (pdbg_unlikely(!sock)) {
if (err) { if (err) {
*err = psync_strdup("Could not connect to the server."); *err = putil_strdup("Could not connect to the server.");
} }
return -1; return -1;
@ -313,7 +313,7 @@ int ptools_backend_call(const char *binapi, const char *wsPath,
psock_close(sock); psock_close(sock);
if (err) { if (err) {
*err = psync_strdup("Could not connect to the server."); *err = putil_strdup("Could not connect to the server.");
} }
return -1; return -1;
@ -325,7 +325,7 @@ int ptools_backend_call(const char *binapi, const char *wsPath,
if (result) { if (result) {
if (err) { if (err) {
*err = psync_strdup(papi_find_result2(res, "error", PARAM_STR)->str); *err = putil_strdup(papi_find_result2(res, "error", PARAM_STR)->str);
} }
pdbg_logf(D_CRITICAL, "Backend command failed. Error:[%s]", *err); pdbg_logf(D_CRITICAL, "Backend command failed. Error:[%s]", *err);
@ -353,7 +353,7 @@ char *ptools_get_machine_name() {
strcpy(pcName, "LinuxMachine"); strcpy(pcName, "LinuxMachine");
} }
return psync_strdup(pcName); return putil_strdup(pcName);
} }
void ptools_parse_os_path(char *path, folderPath *folders, char *delim, int mode) { void ptools_parse_os_path(char *path, folderPath *folders, char *delim, int mode) {
@ -371,8 +371,8 @@ void ptools_parse_os_path(char *path, folderPath *folders, char *delim, int mode
// In case we meet a ":" as in C:\ we set the name to Drive + the string // In case we meet a ":" as in C:\ we set the name to Drive + the string
// before the ":" // before the ":"
fName[k] = '\0'; fName[k] = '\0';
buff = psync_strcat("Drive ", &fName, NULL); buff = putil_strcat("Drive ", &fName, NULL);
psync_strlcpy(fName, buff, strlen(buff) + 1); putil_strlcpy(fName, buff, strlen(buff) + 1);
k = k + strlen("Drive "); k = k + strlen("Drive ");
} else { } else {
@ -381,7 +381,7 @@ void ptools_parse_os_path(char *path, folderPath *folders, char *delim, int mode
} }
} else { } else {
fName[k] = 0; fName[k] = 0;
folders->folders[j] = psync_strdup(fName); folders->folders[j] = putil_strdup(fName);
k = 0; k = 0;
j++; j++;
@ -393,7 +393,7 @@ void ptools_parse_os_path(char *path, folderPath *folders, char *delim, int mode
fName[k] = 0; fName[k] = 0;
if (strlen(fName) > 0) { if (strlen(fName) > 0) {
folders->folders[j] = psync_strdup(fName); folders->folders[j] = putil_strdup(fName);
j++; j++;
} }

130
pclsync/publiclinks.c
View File

@ -143,7 +143,7 @@ int64_t do_psync_file_public_link(const char *path, int64_t *plinkid,
api = psync_apipool_get(); api = psync_apipool_get();
if (unlikely(!api)) { if (unlikely(!api)) {
pdbg_logf(D_WARNING, "Can't gat api from the pool. No pool ?\n"); pdbg_logf(D_WARNING, "Can't gat api from the pool. No pool ?\n");
*err = psync_strndup("Connection error.", 17); *err = putil_strndup("Connection error.", 17);
return 2; return 2;
} }
@ -165,7 +165,7 @@ int64_t do_psync_file_public_link(const char *path, int64_t *plinkid,
api = psync_apipool_get(); api = psync_apipool_get();
if (unlikely(!api)) { if (unlikely(!api)) {
pdbg_logf(D_WARNING, "Can't gat api from the pool. No pool ?\n"); pdbg_logf(D_WARNING, "Can't gat api from the pool. No pool ?\n");
*err = psync_strndup("Connection error.", 17); *err = putil_strndup("Connection error.", 17);
free(t); free(t);
return 1; return 1;
} }
@ -179,13 +179,13 @@ int64_t do_psync_file_public_link(const char *path, int64_t *plinkid,
else { else {
psync_apipool_release_bad(api); psync_apipool_release_bad(api);
pdbg_logf(D_WARNING, "Send command returned in valid result.\n"); pdbg_logf(D_WARNING, "Send command returned in valid result.\n");
*err = psync_strndup("Connection error.", 17); *err = putil_strndup("Connection error.", 17);
return 2; return 2;
} }
result = papi_find_result2(bres, "result", PARAM_NUM)->num; result = papi_find_result2(bres, "result", PARAM_NUM)->num;
if (unlikely(result)) { if (unlikely(result)) {
errorret = papi_find_result2(bres, "error", PARAM_STR)->str; errorret = papi_find_result2(bres, "error", PARAM_STR)->str;
*err = psync_strndup(errorret, strlen(errorret)); *err = putil_strndup(errorret, strlen(errorret));
pdbg_logf(D_WARNING, "command getfilepublink returned error code %u", pdbg_logf(D_WARNING, "command getfilepublink returned error code %u",
(unsigned)result); (unsigned)result);
psync_process_api_error(result); psync_process_api_error(result);
@ -194,7 +194,7 @@ int64_t do_psync_file_public_link(const char *path, int64_t *plinkid,
} }
rescode = papi_find_result2(bres, "link", PARAM_STR)->str; rescode = papi_find_result2(bres, "link", PARAM_STR)->str;
*link = psync_strndup(rescode, strlen(rescode)); *link = putil_strndup(rescode, strlen(rescode));
linkid = papi_find_result2(bres, "linkid", PARAM_NUM)->num; linkid = papi_find_result2(bres, "linkid", PARAM_NUM)->num;
if (plinkid) if (plinkid)
*plinkid = linkid; *plinkid = linkid;
@ -221,7 +221,7 @@ int64_t do_psync_folder_public_link(const char *path, char **link /*OUT*/,
api = psync_apipool_get(); api = psync_apipool_get();
if (unlikely(!api)) { if (unlikely(!api)) {
pdbg_logf(D_WARNING, "Can't gat api from the pool. No pool ?\n"); pdbg_logf(D_WARNING, "Can't gat api from the pool. No pool ?\n");
*err = psync_strndup("Connection error.", 17); *err = putil_strndup("Connection error.", 17);
return -2; return -2;
} }
bres = papi_send2(api, "getfolderpublink", params); bres = papi_send2(api, "getfolderpublink", params);
@ -242,7 +242,7 @@ int64_t do_psync_folder_public_link(const char *path, char **link /*OUT*/,
api = psync_apipool_get(); api = psync_apipool_get();
if (unlikely(!api)) { if (unlikely(!api)) {
pdbg_logf(D_WARNING, "Can't gat api from the pool. No pool ?\n"); pdbg_logf(D_WARNING, "Can't gat api from the pool. No pool ?\n");
*err = psync_strndup("Connection error.", 17); *err = putil_strndup("Connection error.", 17);
return -2; return -2;
} }
bres = papi_send(api, "getfolderpublink", bres = papi_send(api, "getfolderpublink",
@ -259,19 +259,19 @@ int64_t do_psync_folder_public_link(const char *path, char **link /*OUT*/,
result = papi_find_result2(bres, "result", PARAM_NUM)->num; result = papi_find_result2(bres, "result", PARAM_NUM)->num;
if (unlikely(result)) { if (unlikely(result)) {
errorret = papi_find_result2(bres, "error", PARAM_STR)->str; errorret = papi_find_result2(bres, "error", PARAM_STR)->str;
*err = psync_strndup(errorret, strlen(errorret)); *err = putil_strndup(errorret, strlen(errorret));
pdbg_logf(D_WARNING, "command getfilepublink returned error code %u", pdbg_logf(D_WARNING, "command getfilepublink returned error code %u",
(unsigned)result); (unsigned)result);
psync_process_api_error(result); psync_process_api_error(result);
if (psync_handle_api_result(result) == PSYNC_NET_TEMPFAIL) if (psync_handle_api_result(result) == PSYNC_NET_TEMPFAIL)
return -result; return -result;
else { else {
*err = psync_strndup("Connection error.", 17); *err = putil_strndup("Connection error.", 17);
return -1; return -1;
} }
} }
rescode = papi_find_result2(bres, "link", PARAM_STR)->str; rescode = papi_find_result2(bres, "link", PARAM_STR)->str;
*link = psync_strndup(rescode, strlen(rescode)); *link = putil_strndup(rescode, strlen(rescode));
result = papi_find_result2(bres, "linkid", PARAM_NUM)->num; result = papi_find_result2(bres, "linkid", PARAM_NUM)->num;
free(bres); free(bres);
@ -295,7 +295,7 @@ int64_t do_psync_folder_public_link_full(const char *path, char **link /*OUT*/,
api = psync_apipool_get(); api = psync_apipool_get();
if (unlikely(!api)) { if (unlikely(!api)) {
pdbg_logf(D_WARNING, "Can't gat api from the pool. No pool ?\n"); pdbg_logf(D_WARNING, "Can't gat api from the pool. No pool ?\n");
*err = psync_strndup("Connection error.", 17); *err = putil_strndup("Connection error.", 17);
return -2; return -2;
} }
bres = papi_send2(api, "getfolderpublink", params); bres = papi_send2(api, "getfolderpublink", params);
@ -318,7 +318,7 @@ int64_t do_psync_folder_public_link_full(const char *path, char **link /*OUT*/,
api = psync_apipool_get(); api = psync_apipool_get();
if (unlikely(!api)) { if (unlikely(!api)) {
pdbg_logf(D_WARNING, "Can't gat api from the pool. No pool ?\n"); pdbg_logf(D_WARNING, "Can't gat api from the pool. No pool ?\n");
*err = psync_strndup("Connection error.", 17); *err = putil_strndup("Connection error.", 17);
return -2; return -2;
} }
bres = papi_send(api, "getfolderpublink", bres = papi_send(api, "getfolderpublink",
@ -336,20 +336,20 @@ int64_t do_psync_folder_public_link_full(const char *path, char **link /*OUT*/,
result = papi_find_result2(bres, "result", PARAM_NUM)->num; result = papi_find_result2(bres, "result", PARAM_NUM)->num;
if (unlikely(result)) { if (unlikely(result)) {
errorret = papi_find_result2(bres, "error", PARAM_STR)->str; errorret = papi_find_result2(bres, "error", PARAM_STR)->str;
*err = psync_strndup(errorret, strlen(errorret)); *err = putil_strndup(errorret, strlen(errorret));
pdbg_logf(D_WARNING, "command getfilepublink returned error code %u", pdbg_logf(D_WARNING, "command getfilepublink returned error code %u",
(unsigned)result); (unsigned)result);
psync_process_api_error(result); psync_process_api_error(result);
if (psync_handle_api_result(result) == PSYNC_NET_TEMPFAIL) if (psync_handle_api_result(result) == PSYNC_NET_TEMPFAIL)
return -result; return -result;
else { else {
*err = psync_strndup("Connection error.", 17); *err = putil_strndup("Connection error.", 17);
return -1; return -1;
} }
} }
rescode = papi_find_result2(bres, "link", PARAM_STR)->str; rescode = papi_find_result2(bres, "link", PARAM_STR)->str;
*link = psync_strndup(rescode, strlen(rescode)); *link = putil_strndup(rescode, strlen(rescode));
result = papi_find_result2(bres, "linkid", PARAM_NUM)->num; result = papi_find_result2(bres, "linkid", PARAM_NUM)->num;
free(bres); free(bres);
@ -371,7 +371,7 @@ int64_t do_psync_folder_updownlink_link(int canupload,
api = psync_apipool_get(); api = psync_apipool_get();
if (unlikely(!api)) { if (unlikely(!api)) {
pdbg_logf(D_WARNING, "Can't get api from the pool. No pool ?\n"); pdbg_logf(D_WARNING, "Can't get api from the pool. No pool ?\n");
*err = psync_strndup("Connection error.", 17); *err = putil_strndup("Connection error.", 17);
return -2; return -2;
} }
bres = papi_send2(api, "publink/createfolderlinkandsend", params); bres = papi_send2(api, "publink/createfolderlinkandsend", params);
@ -386,7 +386,7 @@ int64_t do_psync_folder_updownlink_link(int canupload,
result = papi_find_result2(bres, "result", PARAM_NUM)->num; result = papi_find_result2(bres, "result", PARAM_NUM)->num;
if (unlikely(result)) { if (unlikely(result)) {
errorret = papi_find_result2(bres, "error", PARAM_STR)->str; errorret = papi_find_result2(bres, "error", PARAM_STR)->str;
*err = psync_strndup(errorret, strlen(errorret)); *err = putil_strndup(errorret, strlen(errorret));
pdbg_logf(D_WARNING, pdbg_logf(D_WARNING,
"command createfolderlinkwithuploadandsend returned error code %u", "command createfolderlinkwithuploadandsend returned error code %u",
(unsigned)result); (unsigned)result);
@ -394,7 +394,7 @@ int64_t do_psync_folder_updownlink_link(int canupload,
if (psync_handle_api_result(result) == PSYNC_NET_TEMPFAIL) if (psync_handle_api_result(result) == PSYNC_NET_TEMPFAIL)
return -result; return -result;
else { else {
*err = psync_strndup("Connection error.", 17); *err = putil_strndup("Connection error.", 17);
return -1; return -1;
} }
} }
@ -507,7 +507,7 @@ int64_t do_ptree_public_link(const char *linkname, const char *root,
api = psync_apipool_get(); api = psync_apipool_get();
if (unlikely(!api)) { if (unlikely(!api)) {
pdbg_logf(D_WARNING, "Can't gat api from the pool. No pool ?\n"); pdbg_logf(D_WARNING, "Can't gat api from the pool. No pool ?\n");
*err = psync_strndup("Connection error.", 17); *err = putil_strndup("Connection error.", 17);
return -2; return -2;
} }
@ -519,26 +519,26 @@ int64_t do_ptree_public_link(const char *linkname, const char *root,
else { else {
psync_apipool_release_bad(api); psync_apipool_release_bad(api);
pdbg_logf(D_WARNING, "Send command returned in valid result.\n"); pdbg_logf(D_WARNING, "Send command returned in valid result.\n");
*err = psync_strndup("Connection error.", 17); *err = putil_strndup("Connection error.", 17);
return -2; return -2;
} }
result = papi_find_result2(bres, "result", PARAM_NUM)->num; result = papi_find_result2(bres, "result", PARAM_NUM)->num;
if (unlikely(result)) { if (unlikely(result)) {
errorret = papi_find_result2(bres, "error", PARAM_STR)->str; errorret = papi_find_result2(bres, "error", PARAM_STR)->str;
*err = psync_strndup(errorret, strlen(errorret)); *err = putil_strndup(errorret, strlen(errorret));
pdbg_logf(D_WARNING, "command gettreepublink returned error code %u", pdbg_logf(D_WARNING, "command gettreepublink returned error code %u",
(unsigned)result); (unsigned)result);
psync_process_api_error(result); psync_process_api_error(result);
if (psync_handle_api_result(result) == PSYNC_NET_TEMPFAIL) if (psync_handle_api_result(result) == PSYNC_NET_TEMPFAIL)
return -result; return -result;
else { else {
*err = psync_strndup("Connection error.", 17); *err = putil_strndup("Connection error.", 17);
return -1; return -1;
} }
} }
rescode = papi_find_result2(bres, "link", PARAM_STR)->str; rescode = papi_find_result2(bres, "link", PARAM_STR)->str;
*link = psync_strndup(rescode, strlen(rescode)); *link = putil_strndup(rescode, strlen(rescode));
result = papi_find_result2(bres, "linkid", PARAM_NUM)->num; result = papi_find_result2(bres, "linkid", PARAM_NUM)->num;
@ -575,7 +575,7 @@ int cache_links(char *err, size_t err_size /*OUT*/) {
api = psync_apipool_get(); api = psync_apipool_get();
if (unlikely(!api)) { if (unlikely(!api)) {
pdbg_logf(D_WARNING, "Can't gat api from the pool. No pool ?\n"); pdbg_logf(D_WARNING, "Can't gat api from the pool. No pool ?\n");
//*err = psync_strndup("Connection error.", 17); //*err = putil_strndup("Connection error.", 17);
snprintf(err, err_size, "Connection error."); snprintf(err, err_size, "Connection error.");
return -2; return -2;
} }
@ -588,7 +588,7 @@ int cache_links(char *err, size_t err_size /*OUT*/) {
api = psync_apipool_get(); api = psync_apipool_get();
if (unlikely(!api)) { if (unlikely(!api)) {
pdbg_logf(D_WARNING, "Can't gat api from the pool. No pool ?\n"); pdbg_logf(D_WARNING, "Can't gat api from the pool. No pool ?\n");
//*err = psync_strndup("Connection error.", 17); //*err = putil_strndup("Connection error.", 17);
snprintf(err, err_size, "Connection error."); snprintf(err, err_size, "Connection error.");
return -2; return -2;
} }
@ -602,7 +602,7 @@ int cache_links(char *err, size_t err_size /*OUT*/) {
else { else {
psync_apipool_release_bad(api); psync_apipool_release_bad(api);
pdbg_logf(D_WARNING, "Send command returned in valid result.\n"); pdbg_logf(D_WARNING, "Send command returned in valid result.\n");
//*err = psync_strndup("Connection error.", 17); //*err = putil_strndup("Connection error.", 17);
snprintf(err, err_size, "Connection error."); snprintf(err, err_size, "Connection error.");
free(bres); free(bres);
return 0; return 0;
@ -610,7 +610,7 @@ int cache_links(char *err, size_t err_size /*OUT*/) {
result = papi_find_result2(bres, "result", PARAM_NUM)->num; result = papi_find_result2(bres, "result", PARAM_NUM)->num;
if (unlikely(result)) { if (unlikely(result)) {
errorret = papi_find_result2(bres, "error", PARAM_STR)->str; errorret = papi_find_result2(bres, "error", PARAM_STR)->str;
//*err = psync_strndup(errorret, strlen(errorret)); //*err = putil_strndup(errorret, strlen(errorret));
snprintf(err, err_size, "%s", errorret); snprintf(err, err_size, "%s", errorret);
pdbg_logf(D_WARNING, "command listpublinks returned error code %u", pdbg_logf(D_WARNING, "command listpublinks returned error code %u",
(unsigned)result); (unsigned)result);
@ -619,7 +619,7 @@ int cache_links(char *err, size_t err_size /*OUT*/) {
if (psync_handle_api_result(result) == PSYNC_NET_TEMPFAIL) if (psync_handle_api_result(result) == PSYNC_NET_TEMPFAIL)
return -result; return -result;
else { else {
//*err = psync_strndup("Connection error.", 17); //*err = putil_strndup("Connection error.", 17);
snprintf(err, err_size, "Connection error."); snprintf(err, err_size, "Connection error.");
return 0; return 0;
} }
@ -725,7 +725,7 @@ int do_psync_delete_link(int64_t linkid, char **err /*OUT*/) {
api = psync_apipool_get(); api = psync_apipool_get();
if (unlikely(!api)) { if (unlikely(!api)) {
pdbg_logf(D_WARNING, "Can't gat api from the pool. No pool ?\n"); pdbg_logf(D_WARNING, "Can't gat api from the pool. No pool ?\n");
*err = psync_strndup("Connection error.", 17); *err = putil_strndup("Connection error.", 17);
return -2; return -2;
} }
bres = papi_send2(api, "deletepublink", params); bres = papi_send2(api, "deletepublink", params);
@ -735,20 +735,20 @@ int do_psync_delete_link(int64_t linkid, char **err /*OUT*/) {
else { else {
psync_apipool_release_bad(api); psync_apipool_release_bad(api);
pdbg_logf(D_WARNING, "Send command returned in valid result.\n"); pdbg_logf(D_WARNING, "Send command returned in valid result.\n");
*err = psync_strndup("Connection error.", 17); *err = putil_strndup("Connection error.", 17);
return -2; return -2;
} }
result = papi_find_result2(bres, "result", PARAM_NUM)->num; result = papi_find_result2(bres, "result", PARAM_NUM)->num;
if (unlikely(result)) { if (unlikely(result)) {
errorret = papi_find_result2(bres, "error", PARAM_STR)->str; errorret = papi_find_result2(bres, "error", PARAM_STR)->str;
*err = psync_strndup(errorret, strlen(errorret)); *err = putil_strndup(errorret, strlen(errorret));
pdbg_logf(D_WARNING, "command deletepublink returned error code %u", pdbg_logf(D_WARNING, "command deletepublink returned error code %u",
(unsigned)result); (unsigned)result);
psync_process_api_error(result); psync_process_api_error(result);
if (psync_handle_api_result(result) == PSYNC_NET_TEMPFAIL) if (psync_handle_api_result(result) == PSYNC_NET_TEMPFAIL)
return -result; return -result;
else { else {
*err = psync_strndup("Connection error.", 17); *err = putil_strndup("Connection error.", 17);
return -1; return -1;
} }
} }
@ -765,20 +765,20 @@ int process_bres(const char *cmd, binresult *bres, psock_t *api,
else { else {
psync_apipool_release_bad(api); psync_apipool_release_bad(api);
pdbg_logf(D_WARNING, "Send command returned in valid result.\n"); pdbg_logf(D_WARNING, "Send command returned in valid result.\n");
*err = psync_strndup("Connection error.", 17); *err = putil_strndup("Connection error.", 17);
return -2; return -2;
} }
result = papi_find_result2(bres, "result", PARAM_NUM)->num; result = papi_find_result2(bres, "result", PARAM_NUM)->num;
if (unlikely(result)) { if (unlikely(result)) {
errorret = papi_find_result2(bres, "error", PARAM_STR)->str; errorret = papi_find_result2(bres, "error", PARAM_STR)->str;
*err = psync_strndup(errorret, strlen(errorret)); *err = putil_strndup(errorret, strlen(errorret));
pdbg_logf(D_WARNING, "command %s returned error code %u", cmd, pdbg_logf(D_WARNING, "command %s returned error code %u", cmd,
(unsigned)result); (unsigned)result);
psync_process_api_error(result); psync_process_api_error(result);
if (psync_handle_api_result(result) == PSYNC_NET_TEMPFAIL) if (psync_handle_api_result(result) == PSYNC_NET_TEMPFAIL)
return -result; return -result;
else { else {
*err = psync_strndup("Connection error.", 17); *err = putil_strndup("Connection error.", 17);
return -1; return -1;
} }
} }
@ -827,7 +827,7 @@ int do_psync_change_link(unsigned long long linkid, unsigned long long expire,
api = psync_apipool_get(); api = psync_apipool_get();
if (unlikely(!api)) { if (unlikely(!api)) {
pdbg_logf(D_WARNING, "Can't get api from the pool. No pool ?\n"); pdbg_logf(D_WARNING, "Can't get api from the pool. No pool ?\n");
*err = psync_strndup("Connection error.", 17); *err = putil_strndup("Connection error.", 17);
return -2; return -2;
} }
bres = papi_send(api, "changepublink", sizeof("changepublink") - 1, t, bres = papi_send(api, "changepublink", sizeof("changepublink") - 1, t,
@ -847,7 +847,7 @@ int do_change_link_expire(unsigned long long linkid, unsigned long long expire,
api = psync_apipool_get(); api = psync_apipool_get();
if (unlikely(!api)) { if (unlikely(!api)) {
pdbg_logf(D_WARNING, "Can't gat api from the pool. No pool ?\n"); pdbg_logf(D_WARNING, "Can't gat api from the pool. No pool ?\n");
*err = psync_strndup("Connection error.", 17); *err = putil_strndup("Connection error.", 17);
return -2; return -2;
} }
@ -877,7 +877,7 @@ int do_change_link_password(unsigned long long linkid, const char *password,
api = psync_apipool_get(); api = psync_apipool_get();
if (unlikely(!api)) { if (unlikely(!api)) {
pdbg_logf(D_WARNING, "Can't gat api from the pool. No pool ?\n"); pdbg_logf(D_WARNING, "Can't gat api from the pool. No pool ?\n");
*err = psync_strndup("Connection error.", 17); *err = putil_strndup("Connection error.", 17);
return -2; return -2;
} }
@ -906,7 +906,7 @@ int do_change_link_enable_upload(unsigned long long linkid,
api = psync_apipool_get(); api = psync_apipool_get();
if (unlikely(!api)) { if (unlikely(!api)) {
pdbg_logf(D_WARNING, "Can't gat api from the pool. No pool ?\n"); pdbg_logf(D_WARNING, "Can't gat api from the pool. No pool ?\n");
*err = psync_strndup("Connection error.", 17); *err = putil_strndup("Connection error.", 17);
return -2; return -2;
} }
if (enableuploadforeveryone || enableuploadforchosenusers) { if (enableuploadforeveryone || enableuploadforchosenusers) {
@ -945,7 +945,7 @@ int64_t do_psync_upload_link(const char *path, const char *comment,
api = psync_apipool_get(); api = psync_apipool_get();
if (unlikely(!api)) { if (unlikely(!api)) {
pdbg_logf(D_WARNING, "Can't gat api from the pool. No pool ?\n"); pdbg_logf(D_WARNING, "Can't gat api from the pool. No pool ?\n");
*err = psync_strndup("Connection error.", 17); *err = putil_strndup("Connection error.", 17);
return -2; return -2;
} }
@ -969,7 +969,7 @@ int64_t do_psync_upload_link(const char *path, const char *comment,
api = psync_apipool_get(); api = psync_apipool_get();
if (unlikely(!api)) { if (unlikely(!api)) {
pdbg_logf(D_WARNING, "Can't gat api from the pool. No pool ?\n"); pdbg_logf(D_WARNING, "Can't gat api from the pool. No pool ?\n");
*err = psync_strndup("Connection error.", 17); *err = putil_strndup("Connection error.", 17);
return -2; return -2;
} }
bres = papi_send(api, "createuploadlink", bres = papi_send(api, "createuploadlink",
@ -982,26 +982,26 @@ int64_t do_psync_upload_link(const char *path, const char *comment,
else { else {
psync_apipool_release_bad(api); psync_apipool_release_bad(api);
pdbg_logf(D_WARNING, "Send command returned in valid result.\n"); pdbg_logf(D_WARNING, "Send command returned in valid result.\n");
*err = psync_strndup("Connection error.", 17); *err = putil_strndup("Connection error.", 17);
return -2; return -2;
} }
result = papi_find_result2(bres, "result", PARAM_NUM)->num; result = papi_find_result2(bres, "result", PARAM_NUM)->num;
if (unlikely(result)) { if (unlikely(result)) {
errorret = papi_find_result2(bres, "error", PARAM_STR)->str; errorret = papi_find_result2(bres, "error", PARAM_STR)->str;
*err = psync_strndup(errorret, strlen(errorret)); *err = putil_strndup(errorret, strlen(errorret));
pdbg_logf(D_WARNING, "command createuploadlink returned error code %u", pdbg_logf(D_WARNING, "command createuploadlink returned error code %u",
(unsigned)result); (unsigned)result);
psync_process_api_error(result); psync_process_api_error(result);
if (psync_handle_api_result(result) == PSYNC_NET_TEMPFAIL) if (psync_handle_api_result(result) == PSYNC_NET_TEMPFAIL)
return -result; return -result;
else { else {
*err = psync_strndup("Connection error.", 17); *err = putil_strndup("Connection error.", 17);
return -1; return -1;
} }
} }
rescode = papi_find_result2(bres, "link", PARAM_STR)->str; rescode = papi_find_result2(bres, "link", PARAM_STR)->str;
*link = psync_strndup(rescode, strlen(rescode)); *link = putil_strndup(rescode, strlen(rescode));
result = papi_find_result2(bres, "uploadlinkid", PARAM_NUM)->num; result = papi_find_result2(bres, "uploadlinkid", PARAM_NUM)->num;
@ -1022,7 +1022,7 @@ int do_psync_delete_upload_link(int64_t uploadlinkid, char **err /*OUT*/) {
api = psync_apipool_get(); api = psync_apipool_get();
if (unlikely(!api)) { if (unlikely(!api)) {
pdbg_logf(D_WARNING, "Can't gat api from the pool. No pool ?\n"); pdbg_logf(D_WARNING, "Can't gat api from the pool. No pool ?\n");
*err = psync_strndup("Connection error.", 17); *err = putil_strndup("Connection error.", 17);
return -2; return -2;
} }
@ -1126,7 +1126,7 @@ plink_contents_t *do_show_link(const char *code, char **err /*OUT*/) {
api = psync_apipool_get(); api = psync_apipool_get();
if (unlikely(!api)) { if (unlikely(!api)) {
pdbg_logf(D_WARNING, "Can't gat api from the pool. No pool ?\n"); pdbg_logf(D_WARNING, "Can't gat api from the pool. No pool ?\n");
*err = psync_strndup("Can't gat api from the pool.", 29); *err = putil_strndup("Can't gat api from the pool.", 29);
return NULL; return NULL;
} }
@ -1137,7 +1137,7 @@ plink_contents_t *do_show_link(const char *code, char **err /*OUT*/) {
else { else {
psync_apipool_release_bad(api); psync_apipool_release_bad(api);
pdbg_logf(D_WARNING, "Send command returned in valid result.\n"); pdbg_logf(D_WARNING, "Send command returned in valid result.\n");
*err = psync_strndup("Connection error.", 17); *err = putil_strndup("Connection error.", 17);
return NULL; return NULL;
} }
@ -1204,7 +1204,7 @@ int cache_upload_links(char **err /*OUT*/) {
api = psync_apipool_get(); api = psync_apipool_get();
if (unlikely(!api)) { if (unlikely(!api)) {
pdbg_logf(D_WARNING, "Can't gat api from the pool. No pool ?\n"); pdbg_logf(D_WARNING, "Can't gat api from the pool. No pool ?\n");
*err = psync_strndup("Connection error.", 17); *err = putil_strndup("Connection error.", 17);
return -2; return -2;
} }
bres = papi_send2(api, "listuploadlinks", params); bres = papi_send2(api, "listuploadlinks", params);
@ -1215,7 +1215,7 @@ int cache_upload_links(char **err /*OUT*/) {
api = psync_apipool_get(); api = psync_apipool_get();
if (unlikely(!api)) { if (unlikely(!api)) {
pdbg_logf(D_WARNING, "Can't gat api from the pool. No pool ?\n"); pdbg_logf(D_WARNING, "Can't gat api from the pool. No pool ?\n");
*err = psync_strndup("Connection error.", 17); *err = putil_strndup("Connection error.", 17);
return -2; return -2;
} }
bres = papi_send2(api, "listuploadlinks", params); bres = papi_send2(api, "listuploadlinks", params);
@ -1226,20 +1226,20 @@ int cache_upload_links(char **err /*OUT*/) {
else { else {
psync_apipool_release_bad(api); psync_apipool_release_bad(api);
pdbg_logf(D_WARNING, "Send command returned in valid result.\n"); pdbg_logf(D_WARNING, "Send command returned in valid result.\n");
*err = psync_strndup("Connection error.", 17); *err = putil_strndup("Connection error.", 17);
return -2; return -2;
} }
result = papi_find_result2(bres, "result", PARAM_NUM)->num; result = papi_find_result2(bres, "result", PARAM_NUM)->num;
if (unlikely(result)) { if (unlikely(result)) {
errorret = papi_find_result2(bres, "error", PARAM_STR)->str; errorret = papi_find_result2(bres, "error", PARAM_STR)->str;
*err = psync_strndup(errorret, strlen(errorret)); *err = putil_strndup(errorret, strlen(errorret));
pdbg_logf(D_WARNING, "command listpublinks returned error code %u", pdbg_logf(D_WARNING, "command listpublinks returned error code %u",
(unsigned)result); (unsigned)result);
psync_process_api_error(result); psync_process_api_error(result);
if (psync_handle_api_result(result) == PSYNC_NET_TEMPFAIL) if (psync_handle_api_result(result) == PSYNC_NET_TEMPFAIL)
return -result; return -result;
else { else {
*err = psync_strndup("Connection error.", 17); *err = putil_strndup("Connection error.", 17);
return -1; return -1;
} }
} }
@ -1415,7 +1415,7 @@ preciever_list_t *do_list_email_with_access(unsigned long long linkid,
api = psync_apipool_get(); api = psync_apipool_get();
if (unlikely(!api)) { if (unlikely(!api)) {
pdbg_logf(D_WARNING, "Can't gat api from the pool. No pool ?\n"); pdbg_logf(D_WARNING, "Can't gat api from the pool. No pool ?\n");
*err = psync_strndup("Connection error.", 17); *err = putil_strndup("Connection error.", 17);
return NULL; return NULL;
} }
bres = papi_send2(api, "publink/listemailswithaccess", params); bres = papi_send2(api, "publink/listemailswithaccess", params);
@ -1424,20 +1424,20 @@ preciever_list_t *do_list_email_with_access(unsigned long long linkid,
else { else {
psync_apipool_release_bad(api); psync_apipool_release_bad(api);
pdbg_logf(D_WARNING, "Send command returned in valid result.\n"); pdbg_logf(D_WARNING, "Send command returned in valid result.\n");
*err = psync_strndup("Connection error.", 17); *err = putil_strndup("Connection error.", 17);
return NULL; return NULL;
} }
result = papi_find_result2(bres, "result", PARAM_NUM)->num; result = papi_find_result2(bres, "result", PARAM_NUM)->num;
if (unlikely(result)) { if (unlikely(result)) {
errorret = papi_find_result2(bres, "error", PARAM_STR)->str; errorret = papi_find_result2(bres, "error", PARAM_STR)->str;
*err = psync_strndup(errorret, strlen(errorret)); *err = putil_strndup(errorret, strlen(errorret));
pdbg_logf(D_WARNING, "command listemailswithaccess returned error code %u", pdbg_logf(D_WARNING, "command listemailswithaccess returned error code %u",
(unsigned)result); (unsigned)result);
psync_process_api_error(result); psync_process_api_error(result);
if (psync_handle_api_result(result) == PSYNC_NET_TEMPFAIL) if (psync_handle_api_result(result) == PSYNC_NET_TEMPFAIL)
return NULL; return NULL;
else { else {
*err = psync_strndup("Connection error.", 17); *err = putil_strndup("Connection error.", 17);
return NULL; return NULL;
} }
} }
@ -1484,7 +1484,7 @@ int do_link_add_access(unsigned long long linkid, const char *mail,
api = psync_apipool_get(); api = psync_apipool_get();
if (unlikely(!api)) { if (unlikely(!api)) {
pdbg_logf(D_WARNING, "Can't gat api from the pool. No pool ?\n"); pdbg_logf(D_WARNING, "Can't gat api from the pool. No pool ?\n");
*err = psync_strndup("Connection error.", 17); *err = putil_strndup("Connection error.", 17);
return -2; return -2;
} }
@ -1507,7 +1507,7 @@ int do_link_remove_access(unsigned long long linkid,
api = psync_apipool_get(); api = psync_apipool_get();
if (unlikely(!api)) { if (unlikely(!api)) {
pdbg_logf(D_WARNING, "Can't gat api from the pool. No pool ?\n"); pdbg_logf(D_WARNING, "Can't gat api from the pool. No pool ?\n");
*err = psync_strndup("Connection error.", 17); *err = putil_strndup("Connection error.", 17);
return -2; return -2;
} }
@ -1534,7 +1534,7 @@ bookmarks_list_t *do_cache_bookmarks(char **err) {
api = psync_apipool_get(); api = psync_apipool_get();
if (unlikely(!api)) { if (unlikely(!api)) {
pdbg_logf(D_WARNING, "Can't gat api from the pool. No pool ?\n"); pdbg_logf(D_WARNING, "Can't gat api from the pool. No pool ?\n");
*err = psync_strndup("Connection error.", 17); *err = putil_strndup("Connection error.", 17);
return NULL; return NULL;
} }
@ -1545,20 +1545,20 @@ bookmarks_list_t *do_cache_bookmarks(char **err) {
else { else {
psync_apipool_release_bad(api); psync_apipool_release_bad(api);
pdbg_logf(D_WARNING, "Send command returned in valid result.\n"); pdbg_logf(D_WARNING, "Send command returned in valid result.\n");
*err = psync_strndup("Connection error.", 17); *err = putil_strndup("Connection error.", 17);
return NULL; return NULL;
} }
result = papi_find_result2(bres, "result", PARAM_NUM)->num; result = papi_find_result2(bres, "result", PARAM_NUM)->num;
if (unlikely(result)) { if (unlikely(result)) {
errorret = papi_find_result2(bres, "error", PARAM_STR)->str; errorret = papi_find_result2(bres, "error", PARAM_STR)->str;
*err = psync_strndup(errorret, strlen(errorret)); *err = putil_strndup(errorret, strlen(errorret));
pdbg_logf(D_WARNING, "command deletepublink returned error code %u", pdbg_logf(D_WARNING, "command deletepublink returned error code %u",
(unsigned)result); (unsigned)result);
psync_process_api_error(result); psync_process_api_error(result);
if (psync_handle_api_result(result) == PSYNC_NET_TEMPFAIL) if (psync_handle_api_result(result) == PSYNC_NET_TEMPFAIL)
return NULL; return NULL;
else { else {
*err = psync_strndup("Connection error.", 17); *err = putil_strndup("Connection error.", 17);
return NULL; return NULL;
} }
} }
@ -1618,7 +1618,7 @@ int do_remove_bookmark(const char *code, int locationid, char **err) {
api = psync_apipool_get(); api = psync_apipool_get();
if (unlikely(!api)) { if (unlikely(!api)) {
pdbg_logf(D_WARNING, "Can't gat api from the pool. No pool ?\n"); pdbg_logf(D_WARNING, "Can't gat api from the pool. No pool ?\n");
*err = psync_strndup("Connection error.", 17); *err = putil_strndup("Connection error.", 17);
return -2; return -2;
} }
@ -1643,7 +1643,7 @@ int do_change_bookmark(const char *code, int locationid, const char *name,
api = psync_apipool_get(); api = psync_apipool_get();
if (unlikely(!api)) { if (unlikely(!api)) {
pdbg_logf(D_WARNING, "Can't gat api from the pool. No pool ?\n"); pdbg_logf(D_WARNING, "Can't gat api from the pool. No pool ?\n");
*err = psync_strndup("Connection error.", 17); *err = putil_strndup("Connection error.", 17);
return -2; return -2;
} }

4
pclsync/pupload.c
View File

@ -1067,7 +1067,7 @@ static int upload_big_file(const char *localpath, const unsigned char *hashhex,
sql = psql_query_rdlock("SELECT name FROM localfile WHERE id=?"); sql = psql_query_rdlock("SELECT name FROM localfile WHERE id=?");
psql_bind_uint(sql, 1, localfileid); psql_bind_uint(sql, 1, localfileid);
if ((srow = psql_fetch_str(sql))) { if ((srow = psql_fetch_str(sql))) {
char *nname = psync_strdup(srow[0]); char *nname = putil_strdup(srow[0]);
psql_free(sql); psql_free(sql);
pdbg_logf(D_NOTICE, "looking for folderid=%lu and name=%s in file", pdbg_logf(D_NOTICE, "looking for folderid=%lu and name=%s in file",
(unsigned long)folderid, nname); (unsigned long)folderid, nname);
@ -1463,7 +1463,7 @@ static int task_uploadfile(psync_syncid_t syncid, psync_folderid_t localfileid,
} }
if (*s1 == *s2) { //==0 if (*s1 == *s2) { //==0
pdbg_logf(D_NOTICE, "uploading %s as %s", name, srow[0]); pdbg_logf(D_NOTICE, "uploading %s as %s", name, srow[0]);
nname = psync_strdup(srow[0]); nname = putil_strdup(srow[0]);
name = nname; name = nname;
} }
} }

44
pclsync/putil.c
View File

@ -14,7 +14,7 @@
static char normalize_table[256]; static char normalize_table[256];
const char base64_table[] = { const char putil_base64_table[] = {
'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',
@ -73,7 +73,7 @@ void putil_wipe(void *mem, size_t sz) {
} }
} }
void time_format(time_t tm, unsigned long ns, char *result) { void putil_time_format(time_t tm, unsigned long ns, char *result) {
static const char month_names[12][4] = {"Jan", "Feb", "Mar", "Apr", static const char month_names[12][4] = {"Jan", "Feb", "Mar", "Apr",
"May", "Jun", "Jul", "Aug", "May", "Jun", "Jul", "Aug",
"Sep", "Oct", "Nov", "Dec"}; "Sep", "Oct", "Nov", "Dec"};
@ -117,13 +117,13 @@ void time_format(time_t tm, unsigned long ns, char *result) {
memcpy(result, " +0000", 7); // copies the null byte memcpy(result, " +0000", 7); // copies the null byte
} }
char *psync_strdup(const char *str) { char *putil_strdup(const char *str) {
size_t len; size_t len;
len = strlen(str) + 1; len = strlen(str) + 1;
return (char *)memcpy(malloc(sizeof(char) * len), str, len); return (char *)memcpy(malloc(sizeof(char) * len), str, len);
} }
char *psync_strnormalize_filename(const char *str) { char *putil_strnormalize_filename(const char *str) {
size_t len, i; size_t len, i;
char *ptr; char *ptr;
len = strlen(str) + 1; len = strlen(str) + 1;
@ -133,14 +133,14 @@ char *psync_strnormalize_filename(const char *str) {
return ptr; return ptr;
} }
char *psync_strndup(const char *str, size_t len) { char *putil_strndup(const char *str, size_t len) {
char *ptr; char *ptr;
ptr = (char *)memcpy(malloc(sizeof(char) * len + 1), str, len); ptr = (char *)memcpy(malloc(sizeof(char) * len + 1), str, len);
ptr[len] = 0; ptr[len] = 0;
return ptr; return ptr;
} }
char *psync_strcat(const char *str, ...) { char *putil_strcat(const char *str, ...) {
size_t i, size, len; size_t i, size, len;
const char *strs[64]; const char *strs[64];
size_t lengths[64]; size_t lengths[64];
@ -170,7 +170,7 @@ char *psync_strcat(const char *str, ...) {
return ptr3; return ptr3;
} }
int psync_slprintf(char *str, size_t size, const char *format, ...) { int putil_slprintf(char *str, size_t size, const char *format, ...) {
va_list ap; va_list ap;
int ret; int ret;
va_start(ap, format); va_start(ap, format);
@ -181,7 +181,7 @@ int psync_slprintf(char *str, size_t size, const char *format, ...) {
return ret; return ret;
} }
unsigned char *psync_base32_encode(const unsigned char *str, size_t length, unsigned char *putil_base32_encode(const unsigned char *str, size_t length,
size_t *ret_length) { size_t *ret_length) {
static const unsigned char *table = static const unsigned char *table =
(const unsigned char *)"ABCDEFGHIJKLMNOPQRSTUVWXYZ234567"; (const unsigned char *)"ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";
@ -220,7 +220,7 @@ unsigned char *psync_base32_encode(const unsigned char *str, size_t length,
return result; return result;
} }
unsigned char *psync_base32_decode(const unsigned char *str, size_t length, unsigned char *putil_base32_decode(const unsigned char *str, size_t length,
size_t *ret_length) { size_t *ret_length) {
unsigned char *result, *p; unsigned char *result, *p;
uint32_t bits, buff; uint32_t bits, buff;
@ -252,7 +252,7 @@ unsigned char *psync_base32_decode(const unsigned char *str, size_t length,
return result; return result;
} }
unsigned char *psync_base64_encode(const unsigned char *str, size_t length, unsigned char *putil_base64_encode(const unsigned char *str, size_t length,
size_t *ret_length) { size_t *ret_length) {
const unsigned char *current = str; const unsigned char *current = str;
unsigned char *p; unsigned char *p;
@ -262,22 +262,22 @@ unsigned char *psync_base64_encode(const unsigned char *str, size_t length,
p = result; p = result;
while (length > 2) { while (length > 2) {
*p++ = base64_table[current[0] >> 2]; *p++ = putil_base64_table[current[0] >> 2];
*p++ = base64_table[((current[0] & 0x03) << 4) + (current[1] >> 4)]; *p++ = putil_base64_table[((current[0] & 0x03) << 4) + (current[1] >> 4)];
*p++ = base64_table[((current[1] & 0x0f) << 2) + (current[2] >> 6)]; *p++ = putil_base64_table[((current[1] & 0x0f) << 2) + (current[2] >> 6)];
*p++ = base64_table[current[2] & 0x3f]; *p++ = putil_base64_table[current[2] & 0x3f];
current += 3; current += 3;
length -= 3; length -= 3;
} }
if (length != 0) { if (length != 0) {
*p++ = base64_table[current[0] >> 2]; *p++ = putil_base64_table[current[0] >> 2];
if (length > 1) { if (length > 1) {
*p++ = base64_table[((current[0] & 0x03) << 4) + (current[1] >> 4)]; *p++ = putil_base64_table[((current[0] & 0x03) << 4) + (current[1] >> 4)];
*p++ = base64_table[(current[1] & 0x0f) << 2]; *p++ = putil_base64_table[(current[1] & 0x0f) << 2];
*p++ = '='; /* Add padding */ *p++ = '='; /* Add padding */
} else { } else {
*p++ = base64_table[(current[0] & 0x03) << 4]; *p++ = putil_base64_table[(current[0] & 0x03) << 4];
*p++ = '='; /* Add padding */ *p++ = '='; /* Add padding */
*p++ = '='; /* Add padding */ *p++ = '='; /* Add padding */
} }
@ -288,7 +288,7 @@ unsigned char *psync_base64_encode(const unsigned char *str, size_t length,
return result; return result;
} }
unsigned char *psync_base64_decode(const unsigned char *str, size_t length, unsigned char *putil_base64_decode(const unsigned char *str, size_t length,
size_t *ret_length) { size_t *ret_length) {
const unsigned char *current = str; const unsigned char *current = str;
unsigned char *result; unsigned char *result;
@ -328,7 +328,7 @@ unsigned char *psync_base64_decode(const unsigned char *str, size_t length,
return result; return result;
} }
int psync_is_valid_utf8(const char *str) { int putil_is_valid_utf8(const char *str) {
static const int8_t trailing[] = { static const int8_t trailing[] = {
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
@ -359,14 +359,14 @@ int psync_is_valid_utf8(const char *str) {
return 1; return 1;
} }
uint64_t psync_ato64(const char *str) { uint64_t putil_ato64(const char *str) {
uint64_t n = 0; uint64_t n = 0;
while (*str >= '0' && *str <= '9') while (*str >= '0' && *str <= '9')
n = n * 10 + (*str++) - '0'; n = n * 10 + (*str++) - '0';
return n; return n;
} }
uint32_t psync_ato32(const char *str) { uint32_t putil_ato32(const char *str) {
uint32_t n = 0; uint32_t n = 0;
while (*str >= '0' && *str <= '9') while (*str >= '0' && *str <= '9')
n = n * 10 + (*str++) - '0'; n = n * 10 + (*str++) - '0';

30
pclsync/putil.h
View File

@ -24,24 +24,24 @@ extern "C" {
return PSYNC_INVALID_SYNCID; \ return PSYNC_INVALID_SYNCID; \
} while (0) } while (0)
extern const char base64_table[]; extern const char putil_base64_table[];
void putil_wipe(void *mem, size_t sz); void putil_wipe(void *mem, size_t sz);
void time_format(time_t tm, unsigned long ns, char *result); void putil_time_format(time_t tm, unsigned long ns, char *result);
char *psync_strdup(const char *str) PSYNC_MALLOC PSYNC_NONNULL(1); char *putil_strdup(const char *str) PSYNC_MALLOC PSYNC_NONNULL(1);
char *psync_strnormalize_filename(const char *str) PSYNC_MALLOC PSYNC_NONNULL(1); char *putil_strnormalize_filename(const char *str) PSYNC_MALLOC PSYNC_NONNULL(1);
char *psync_strndup(const char *str, size_t len) PSYNC_MALLOC PSYNC_NONNULL(1); char *putil_strndup(const char *str, size_t len) PSYNC_MALLOC PSYNC_NONNULL(1);
char *psync_strcat(const char *str, ...) PSYNC_MALLOC PSYNC_SENTINEL; char *putil_strcat(const char *str, ...) PSYNC_MALLOC PSYNC_SENTINEL;
int psync_slprintf(char *str, size_t size, const char *format, ...) PSYNC_NONNULL(1, 3); int putil_slprintf(char *str, size_t size, const char *format, ...) PSYNC_NONNULL(1, 3);
unsigned char *psync_base32_encode(const unsigned char *str, size_t length, size_t *ret_length); unsigned char *putil_base32_encode(const unsigned char *str, size_t length, size_t *ret_length);
unsigned char *psync_base32_decode(const unsigned char *str, size_t length, size_t *ret_length); unsigned char *putil_base32_decode(const unsigned char *str, size_t length, size_t *ret_length);
unsigned char *psync_base64_encode(const unsigned char *str, size_t length, size_t *ret_length); unsigned char *putil_base64_encode(const unsigned char *str, size_t length, size_t *ret_length);
unsigned char *psync_base64_decode(const unsigned char *str, size_t length, size_t *ret_length); unsigned char *putil_base64_decode(const unsigned char *str, size_t length, size_t *ret_length);
int psync_is_valid_utf8(const char *str); int putil_is_valid_utf8(const char *str);
uint64_t psync_ato64(const char *str); uint64_t putil_ato64(const char *str);
uint32_t psync_ato32(const char *str); uint32_t putil_ato32(const char *str);
static inline size_t psync_strlcpy(char *dst, const char *src, size_t size) { static inline size_t putil_strlcpy(char *dst, const char *src, size_t size) {
size_t len; size_t len;
len = strlen(src); len = strlen(src);
if (likely(len < size)) { if (likely(len < size)) {