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)
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",
(unsigned)result, errorret);
psync_process_api_error(result);
if (psync_handle_api_result(result) == PSYNC_NET_TEMPFAIL)
return -result;
else {
*err = psync_strndup("Connection error.", 17);
*err = putil_strndup("Connection error.", 17);
return -1;
}
}
@ -365,7 +365,7 @@ void get_ba_member_email(uint64_t userid, char **email /*OUT*/,
const char *resret =
papi_find_result2(users->array[0], "email", PARAM_STR)->str;
*length = strlen(resret);
*email = psync_strndup(resret, *length);
*email = putil_strndup(resret, *length);
fname = papi_find_result2(users->array[0], "firstname", 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 =
papi_find_result2(teams->array[0], "name", PARAM_STR)->str;
*length = strlen(teamret);
*name = psync_strndup(teamret, *length);
*name = putil_strndup(teamret, *length);
}
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);
}
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 = 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);
free(res);
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,
privatesha1);
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,
&b64privlen);
b64pub =
psync_base64_encode((unsigned char *)pub,
putil_base64_encode((unsigned char *)pub,
offsetof(pub_key_ver1, key) + rsapublen, &b64publen);
free(priv);
free(pub);
@ -487,7 +487,7 @@ int pcryptofolder_get_hint(char **hint) {
}
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);
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));
}
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);
free(res);
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;
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);
free(res);
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));
}
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);
if (enckey) {
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));
}
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);
if (enckey) {
symkey = prsa_decrypt_data(crypto_privkey, enckey, enckeylen);
@ -1282,7 +1282,7 @@ char *pcryptofolder_flddecode_filename(pcrypto_textdec_t decoder,
const char *name) {
unsigned char *filenameenc, *filenamedec;
size_t filenameenclen;
filenameenc = psync_base32_decode((const unsigned char *)name, strlen(name),
filenameenc = putil_base32_decode((const unsigned char *)name, strlen(name),
&filenameenclen);
if (!filenameenc)
return NULL;
@ -1353,7 +1353,7 @@ char * pcryptofolder_fldencode_filename(pcrypto_textenc_t encoder,
pcrypto_encode_text(encoder, (const unsigned char *)name,
strlen(name), &filenameenc, &filenameenclen);
filenameb32 =
psync_base32_encode(filenameenc, filenameenclen, &filenameenclen);
putil_base32_encode(filenameenc, filenameenclen, &filenameenclen);
free(filenameenc);
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])) {
case PSYNC_FS_TASK_CREAT:
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);
if (enckey) {
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;
size_t keylen;
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);
if (!key)
return (pcrypto_sector_encdec_t)errptr(
@ -1560,7 +1560,7 @@ static char *get_name_encoded(psync_folderid_t folderid,
return (char *)enc;
pcrypto_encode_text(enc, (const unsigned char *)name,
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(nameenc);
return ret;
@ -1597,7 +1597,7 @@ static int get_fldr_name(psync_folderid_t folderid,
const char *name, char **ename,
const char **err) {
if (folderid == 0) {
*ename = psync_strdup(name);
*ename = putil_strdup(name);
return PSYNC_CRYPTO_SUCCESS;
} else {
psync_sql_res *res;
@ -1613,7 +1613,7 @@ static int get_fldr_name(psync_folderid_t folderid,
if (enc)
return get_cfldr_name(folderid, name, ename, err);
else {
*ename = psync_strdup(name);
*ename = putil_strdup(name);
return PSYNC_CRYPTO_SUCCESS;
}
}
@ -1681,7 +1681,7 @@ char *pcryptofolder_filencoder_key_get(psync_fsfileid_t fileid,
encsym = get_file_enckey(fileid, hash, 0);
if (is_err(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);
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));
}
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);
return ret;
}
@ -1739,7 +1739,7 @@ char *pcryptofolder_filencoder_key_newplain(
}
*deckey = symkeyv1_to_symkey(&sym);
putil_wipe(&sym, sizeof(sym));
ret = (char *)psync_base64_encode(encsym->data, encsym->datalen, keylen);
ret = (char *)putil_base64_encode(encsym->data, encsym->datalen, keylen);
free(encsym);
return ret;
}
@ -1779,7 +1779,7 @@ int pcryptofolder_mkdir(psync_folderid_t folderid, const char *name,
pdbg_logf(D_ERROR, "RSA encryption failed");
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,
b64encsymlen, encsym, newfolderid);
free(encsym);
@ -1888,8 +1888,8 @@ int psync_pcloud_crypto_reencode_key(
prsa_free_private(priv);
return to_err(rsasign);
}
*privenc = (char *)psync_base64_encode(newpriv, newprivlen, &dummy);
*sign = (char *)psync_base64_encode(rsasign->data, rsasign->datalen, &dummy);
*privenc = (char *)putil_base64_encode(newpriv, newprivlen, &dummy);
*sign = (char *)putil_base64_encode(rsasign->data, rsasign->datalen, &dummy);
free(rsasign);
free(newpriv);
prsa_free_public(pub);
@ -1963,8 +1963,8 @@ int psync_pcloud_crypto_encode_key(const char *newpassphrase, uint32_t flags,
prsa_free_binary(rsapriv);
return to_err(rsasign);
}
*privenc = (char *)psync_base64_encode(newpriv, rsaprivlen, &dummy);
*sign = (char *)psync_base64_encode(rsasign->data, rsasign->datalen, &dummy);
*privenc = (char *)putil_base64_encode(newpriv, rsaprivlen, &dummy);
*sign = (char *)putil_base64_encode(rsasign->data, rsasign->datalen, &dummy);
free(rsasign);
putil_wipe(newpriv, rsaprivlen);
free(newpriv);
@ -2069,13 +2069,13 @@ int pcryptofolder_change_pass(const char *oldpassphrase,
}
pdbg_logf(D_NOTICE, "downloaded user keys");
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 = 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);
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);
free(bres);
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);
time_format(ts.tv_sec, ts.tv_nsec, dttime);
putil_time_format(ts.tv_sec, ts.tv_nsec, dttime);
threadid = pthread_self();
memcpy(&u, &threadid, sizeof(u));
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 */
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 */
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] != '.' || de->d_name[2] != 0))) {
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);
free(path);
if (fd == -1)
@ -74,19 +74,19 @@ char *pdevice_id() {
}
closedir(dh);
}
device = psync_strcat(hardware, ", Linux", NULL);
device = putil_strcat(hardware, ", Linux", NULL);
return device;
}
char *pdevice_name() {
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);
return ret;
}
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) {

22
pclsync/pdiff.c
View File

@ -251,7 +251,7 @@ static int check_active_subscribtion(const binresult *res) {
char *status;
sub = papi_check_result2(res, "lastsubscription", PARAM_HASH);
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")) {
free(status);
return 1;
@ -332,7 +332,7 @@ static psock_t *get_connected_socket() {
"REPLACE INTO setting (id, value) VALUES ('deviceid', ?)");
psql_bind_str(q, 1, deviceidhex);
psql_run_free(q);
deviceid = psync_strdup(deviceidhex);
deviceid = putil_strdup(deviceidhex);
}
pdbg_logf(D_NOTICE, "using deviceid %s", deviceid);
@ -367,11 +367,11 @@ static psock_t *get_connected_socket() {
}
if (!auth && psync_my_auth[0])
auth = psync_strdup(psync_my_auth);
auth = putil_strdup(psync_my_auth);
if (!user && psync_my_user)
user = psync_strdup(psync_my_user);
user = putil_strdup(psync_my_user);
if (!pass && psync_my_pass)
pass = psync_strdup(psync_my_pass);
pass = putil_strdup(psync_my_pass);
if (!auth && (!pass || !user)) {
if (tfa) {
tfa = 0;
@ -463,7 +463,7 @@ static psock_t *get_connected_socket() {
if (result == 2297) {
free(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 =
papi_find_result2(res, "hasdevices", PARAM_BOOL)->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) {
free(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_wait(PSTATUS_TYPE_AUTH, PSTATUS_AUTH_PROVIDED);
psock_close(sock);
@ -491,7 +491,7 @@ static psock_t *get_connected_socket() {
cres = papi_check_result2(res, "location", PARAM_HASH);
if (cres) {
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;
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;
lid = psync_setting_get_uint(_PS(location_id));
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));
if (luserid) {
@ -2918,7 +2918,7 @@ static void psync_run_analyze_if_needed() {
for (i = 0; i < ARRAY_SIZE(skiptables); i++)
if (!strcmp(srow[0], skiptables[i]))
goto skip;
tablenames[tablecnt++] = psync_strdup(srow[0]);
tablenames[tablecnt++] = putil_strdup(srow[0]);
skip:;
}
psql_free(res);
@ -2926,7 +2926,7 @@ static void psync_run_analyze_if_needed() {
while (tablecnt) {
--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]);
psql_statement(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;
char *oldpath, *newpath;
arr = (const char **)ptr;
oldpath = psync_strcat(arr[0], st->name, NULL);
newpath = psync_strcat(arr[1], st->name, NULL);
oldpath = putil_strcat(arr[0], st->name, NULL);
newpath = putil_strcat(arr[1], st->name, NULL);
pfile_rename(oldpath, newpath);
free(newpath);
free(oldpath);
@ -717,7 +717,7 @@ static int task_download_file(download_task_t *dt) {
if (!stat(dt->tmpname, &st) &&
pfile_stat_size(&st) >= PSYNC_MIN_SIZE_FOR_CHECKSUMS) {
tmpold =
psync_strcat(dt->localpath, "/", dt->filename,
putil_strcat(dt->localpath, "/", dt->filename,
"-old", PSYNC_APPEND_PARTIAL_FILES, NULL);
if (pfile_rename_overwrite(dt->tmpname, tmpold)) {
free(tmpold);
@ -740,7 +740,7 @@ static int task_download_file(download_task_t *dt) {
hosts = papi_find_result2(res, "hosts", PARAM_ARRAY);
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);
buff = malloc(PSYNC_COPY_BUFFER_SIZE);
http = NULL;
@ -975,7 +975,7 @@ static int task_rename_file(psync_syncid_t oldsyncid, psync_syncid_t newsyncid,
free(newfolder);
return 0;
}
newpath = psync_strcat(newfolder, "/", newname, NULL);
newpath = putil_strcat(newfolder, "/", newname, NULL);
ret = 0;
psync_stop_localscan();
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))
return 0;
localname =
psync_strcat(localpath, "/", filename, NULL);
tmpname = psync_strcat(localpath, "/", filename,
putil_strcat(localpath, "/", filename, NULL);
tmpname = putil_strcat(localpath, "/", filename,
PSYNC_APPEND_PARTIAL_FILES, NULL);
len = strlen(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);
while ((vrow = psql_fetch(res))) {
pupload_del_tasks(psync_get_number(vrow[0]));
nm = psync_strcat(localpath, "/",
nm = putil_strcat(localpath, "/",
psync_get_string(vrow[1]), NULL);
pdbg_logf(D_NOTICE, "deleting %s", 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, 2, syncid);
while ((vrow = psql_fetch(res))) {
nm = psync_strcat(localpath, "/",
nm = putil_strcat(localpath, "/",
psync_get_string(vrow[1]), NULL);
task_del_folder_rec_do(nm, psync_get_number(vrow[0]), syncid);
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++)
if (pfile_invalid_chars[(unsigned char)*ptr]) {
if (!vname)
vname = psync_strdup(name);
vname = putil_strdup(name);
vname[ptr - name] = PSYNC_REPLACE_INV_CH_IN_FILENAMES;
}
if (vname) {

2
pclsync/pfile.c
View File

@ -419,7 +419,7 @@ int pfile_run_update(const char *path) {
dup2(fd, STDERR_FILENO);
close(fd);
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);
pdbg_logf(D_ERROR, "exec of %s failed", 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++;
}
if (unlikely(!cnt))
return psync_strdup("");
return putil_strdup("");
seplen = strlen(sep);
ret = str = malloc(slen + cnt * seplen + 1);
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);
if (!ret[0]) {
free(ret);
ret = psync_strdup("/");
ret = putil_strdup("/");
if (retlen)
*retlen = 1;
}
@ -397,7 +397,7 @@ char *pfolder_path_sep(psync_folderid_t folderid, const char *sep,
psync_free_string_list(&folderlist);
if (!ret[0]) {
free(ret);
ret = psync_strdup(sep);
ret = putil_strdup(sep);
if (retlen)
*retlen = 1;
}
@ -822,12 +822,12 @@ psync_folder_list_t *pfolder_sync_folders(char *syncTypes) {
strlens = 0;
if (strlen(syncTypes) > 0) {
psync_slprintf(sql, 1024,
putil_slprintf(sql, 1024,
"SELECT id, folderid, localpath, synctype FROM syncfolder "
"WHERE folderid IS NOT NULL AND synctype IN (%s)",
syncTypes);
} else {
psync_slprintf(sql, 1024,
putil_slprintf(sql, 1024,
"SELECT id, folderid, localpath, synctype FROM syncfolder "
"WHERE folderid IS NOT NULL");
}
@ -851,7 +851,7 @@ psync_folder_list_t *pfolder_sync_folders(char *syncTypes) {
folderid = psync_get_number(row[1]);
str = pfolder_path(folderid, &l);
if (unlikely(!str)) {
str = psync_strdup("/Invalid/Path");
str = putil_strdup("/Invalid/Path");
l = strlen(str);
}
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) + 1] = 0;
filename =
psync_strcat(cachepath, "/", fileidhex, NULL);
putil_strcat(cachepath, "/", fileidhex, NULL);
pfile_delete(filename);
free(filename);
fileidhex[sizeof(psync_fsfileid_t)] = 'f';
filename =
psync_strcat(cachepath, "/", fileidhex, NULL);
putil_strcat(cachepath, "/", fileidhex, NULL);
pfile_delete(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);
}
free(fl->currentname);
fl->currentname = psync_strdup(name);
fl->currentname = putil_strdup(name);
pthread_mutex_unlock(&fl->mutex);
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;
cachepath = psync_setting_get_string(_PS(fscachepath));
filename =
psync_strcat(cachepath, "/", fileidhex, NULL);
putil_strcat(cachepath, "/", fileidhex, NULL);
stret = stat(filename, &st);
if (stret)
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;
else{
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
(fd==INVALID_HANDLE_VALUE) return -EIO; stret=pfile_pread(fd, &osize,
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);
#endif
fl->currentfolder = folder;
fl->currentname = psync_strdup(name);
fl->currentname = putil_strdup(name);
fl->fileid = fileid;
fl->remotefileid = remotefileid;
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));
if (of->datafile == INVALID_HANDLE_VALUE) {
filename =
psync_strcat(cachepath, "/", fileidhex, NULL);
putil_strcat(cachepath, "/", fileidhex, NULL);
of->datafile = pfile_open(filename, O_RDWR,
O_CREAT | (trunc ? O_TRUNC : 0));
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) {
fileidhex[sizeof(psync_fsfileid_t)] = 'i';
filename =
psync_strcat(cachepath, "/", fileidhex, NULL);
putil_strcat(cachepath, "/", fileidhex, NULL);
of->indexfile = pfile_open(filename, O_RDWR,
O_CREAT | (trunc ? O_TRUNC : 0));
free(filename);
@ -1183,7 +1183,7 @@ static int open_write_files(psync_openfile_t *of, int trunc) {
if (of->logfile == INVALID_HANDLE_VALUE) {
fileidhex[sizeof(psync_fsfileid_t)] = 'l';
filename =
psync_strcat(cachepath, "/", fileidhex, NULL);
putil_strcat(cachepath, "/", fileidhex, NULL);
of->logfile = pfile_open(filename, O_RDWR, O_CREAT | O_TRUNC);
free(filename);
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;
cachepath = psync_setting_get_string(_PS(fscachepath));
filename =
psync_strcat(cachepath, "/", fileidhex, NULL);
putil_strcat(cachepath, "/", fileidhex, NULL);
if (fl && fl->datafile != INVALID_HANDLE_VALUE) {
pdbg_logf(D_NOTICE, "found open file for file id %ld", (long)fl->fileid);
if (crtime)
@ -3295,7 +3295,7 @@ static void psync_invalidate_os_cache_noret() {
char *path;
pthread_mutex_lock(&start_mutex);
if (started == 1)
path = psync_strdup(psync_current_mountpoint);
path = putil_strdup(psync_current_mountpoint);
else
path = NULL;
pthread_mutex_unlock(&start_mutex);
@ -3367,9 +3367,9 @@ void psync_fs_refresh_folder(psync_folderid_t folderid) {
pthread_mutex_lock(&start_mutex);
if (started == 1) {
if (pfile_invalidate_os_cache_needed())
fpath = psync_strcat(psync_current_mountpoint, path, NULL);
fpath = putil_strcat(psync_current_mountpoint, path, NULL);
else
fpath = psync_strcat(psync_current_mountpoint, path, "/",
fpath = putil_strcat(psync_current_mountpoint, path, "/",
psync_fake_prefix, rndhex, NULL);
} else
fpath = NULL;
@ -3396,7 +3396,7 @@ static char *psync_fuse_get_mountpoint() {
int stat_result;
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_errno = errno;
@ -3436,7 +3436,7 @@ char *psync_fs_getmountpoint() {
char *ret;
pthread_mutex_lock(&start_mutex);
if (started == 1)
ret = psync_strdup(psync_current_mountpoint);
ret = putil_strdup(psync_current_mountpoint);
else
ret = NULL;
pthread_mutex_unlock(&start_mutex);
@ -3451,7 +3451,7 @@ char *psync_fs_get_path_by_folderid(psync_folderid_t folderid) {
char *mp, *path, *ret;
pthread_mutex_lock(&start_mutex);
if (started == 1)
mp = psync_strdup(psync_current_mountpoint);
mp = putil_strdup(psync_current_mountpoint);
else
mp = NULL;
pthread_mutex_unlock(&start_mutex);
@ -3463,7 +3463,7 @@ char *psync_fs_get_path_by_folderid(psync_folderid_t folderid) {
free(mp);
return NULL;
}
ret = psync_strcat(mp, path, NULL);
ret = putil_strcat(mp, path, NULL);
free(mp);
free(path);
return ret;
@ -3473,7 +3473,7 @@ char *psync_fs_get_path_by_fileid(psync_fileid_t fileid) {
char *mp, *path, *ret;
pthread_mutex_lock(&start_mutex);
if (started == 1)
mp = psync_strdup(psync_current_mountpoint);
mp = putil_strdup(psync_current_mountpoint);
else
mp = NULL;
pthread_mutex_unlock(&start_mutex);
@ -3484,7 +3484,7 @@ char *psync_fs_get_path_by_fileid(psync_fileid_t fileid) {
free(mp);
return NULL;
}
ret = psync_strcat(mp, path, NULL);
ret = putil_strcat(mp, path, NULL);
free(mp);
free(path);
return ret;
@ -3620,7 +3620,7 @@ static void psync_fs_init_once() {
pssl_rand_strong(rndbuff, sizeof(rndbuff));
psync_binhex(rndhex, rndbuff, sizeof(rndbuff));
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);
#endif
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));
fileidhex[sizeof(psync_fsfileid_t)] = 'l';
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';
flog = psync_strcat(cachepath, "/", fileidhex, NULL);
flog = putil_strcat(cachepath, "/", fileidhex, NULL);
if (pdbg_unlikely(pfile_rename_overwrite(olog, flog)) ||
pdbg_unlikely((of->logfile = pfile_open(olog, O_RDWR,
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));
fileidhex[sizeof(psync_fsfileid_t)] = 'l';
fileidhex[sizeof(psync_fsfileid_t) + 1] = 0;
log = psync_strcat(cachepath, "/", fileidhex, NULL);
log = putil_strcat(cachepath, "/", fileidhex, NULL);
if (pfile_delete(log))
pdbg_logf(D_NOTICE, "could not delete old log file %s", log);
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;
ch = st->name[len - 1];
if (ch == 'l' || ch == 'f') {
path = psync_strcat((const char *)ptr, "/", st->name,
path = putil_strcat((const char *)ptr, "/", st->name,
NULL);
psync_fs_crypto_check_log(path, st->name);
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);
return NULL;
}
name = psync_strndup(path, len);
name = putil_strndup(path, len);
encname = pcryptofolder_fldencode_filename(enc, name);
pcryptofolder_fldencoder_release(folderid, enc);
free(name);
@ -114,7 +114,7 @@ char *get_decname_for_folder(psync_fsfolderid_t folderid, const char *path,
cryptoerr = psync_crypto_to_error(dec);
return NULL;
}
name = psync_strndup(path, len);
name = putil_strndup(path, len);
decname = pcryptofolder_flddecode_filename(dec, name);
pcryptofolder_flddecoder_release(folderid, dec);
free(name);
@ -213,7 +213,7 @@ psync_fspath_t *psync_fsfolder_resolve_path(const char *path) {
row = psql_fetch_int(res);
folder = psync_fstask_get_folder_tasks_rdlocked(cfolderid);
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->flags & PSYNC_FOLDER_FLAG_INVISIBLE) {
free(name);
@ -307,7 +307,7 @@ psync_fsfolderid_t psync_fsfolderid_by_path(const char *path,
row = psql_fetch_int(res);
folder = psync_fstask_get_folder_tasks_rdlocked(cfolderid);
if (folder) {
char *name = psync_strndup(ename, elen);
char *name = putil_strndup(ename, elen);
if ((mk = psync_fstask_find_mkdir(folder, name, 0))) {
cfolderid = mk->folderid;
flags = mk->flags;
@ -393,7 +393,7 @@ psync_fsfolderid_t psync_fsfolderidperm_by_path(const char *path,
row = psql_fetch_int(res);
folder = psync_fstask_get_folder_tasks_rdlocked(cfolderid);
if (folder) {
char *name = psync_strndup(ename, elen);
char *name = putil_strndup(ename, elen);
if ((mk = psync_fstask_find_mkdir(folder, name, 0))) {
cfolderid = mk->folderid;
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;
unsigned char *enckey;
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);
if (pdbg_likely(enckey)) {
res = psql_prepare(
@ -402,7 +402,7 @@ static void set_key_for_fileid(psync_fileid_t fileid, uint64_t hash,
unsigned char *enckey;
size_t enckeylen;
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)) {
res = psql_prepare(
"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) + 1] = 0;
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';
indexname = psync_strcat(cname, "/", fileidhex, NULL);
indexname = putil_strcat(cname, "/", fileidhex, NULL);
res = psql_query_rdlock("SELECT uploadid FROM fstaskupload WHERE "
"fstaskid=? ORDER BY uploadid DESC LIMIT 1");
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));
fileidhex[sizeof(psync_fsfileid_t)] = 'd';
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);
stret = stat(filename, &st);
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));
fileidhex[sizeof(psync_fsfileid_t)] = 'd';
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);
fd = pfile_open(filename, O_RDONLY, 0);
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) {
nn = malloc(sizeof(char) * (et - task->text1 + 7));
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) {
nn = psync_strcat(task->text1, "(1)", NULL);
nn = putil_strcat(task->text1, "(1)", NULL);
}
res = psql_prepare("UPDATE fstask SET text1=? WHERE id=?");
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;
cachepath = psync_setting_get_string(_PS(fscachepath));
filename =
psync_strcat(cachepath, "/", fileidhex, NULL);
putil_strcat(cachepath, "/", fileidhex, NULL);
pdbg_assertw(pfile_delete(filename) == 0);
free(filename);
if (index) {
fileidhex[sizeof(psync_fsfileid_t)] = 'i';
filename =
psync_strcat(cachepath, "/", fileidhex, NULL);
putil_strcat(cachepath, "/", fileidhex, NULL);
pdbg_assertw(pfile_delete(filename) == 0);
free(filename);
}
@ -2027,12 +2027,12 @@ static void clean_stuck_tasks() {
fileidhex[sizeof(psync_fsfileid_t)] = 'd';
fileidhex[sizeof(psync_fsfileid_t) + 1] = 0;
filename =
psync_strcat(cachepath, "/", fileidhex, NULL);
putil_strcat(cachepath, "/", fileidhex, NULL);
pfile_delete(filename);
free(filename);
fileidhex[sizeof(psync_fsfileid_t)] = 'i';
filename =
psync_strcat(cachepath, "/", fileidhex, NULL);
putil_strcat(cachepath, "/", fileidhex, NULL);
pfile_delete(filename);
free(filename);
psql_start();

2
pclsync/plibs.c
View File

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

10
pclsync/plibs.h
View File

@ -91,8 +91,8 @@ extern "C" {
&(v))))
#define psync_dup_string(v) \
(likely((v).type == PSYNC_TSTRING) \
? psync_strndup((v).str, (v).length) \
: psync_strdup(psql_expect_str(__FILE__, __FUNCTION__, \
? putil_strndup((v).str, (v).length) \
: putil_strdup(psql_expect_str(__FILE__, __FUNCTION__, \
__LINE__, &(v))))
#define psync_get_lstring(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);
dst = (char *)memcpy(dst, prefix, plen) + plen;
do {
*dst++ = base64_table[id % 64];
*dst++ = putil_base64_table[id % 64];
id /= 64;
} while (id);
*dst = 0;
@ -177,12 +177,12 @@ static inline void psync_get_string_id2(char *dst, const char *prefix, uint64_t
plen = strlen(prefix);
dst = (char *)memcpy(dst, prefix, plen) + plen;
do {
*dst++ = base64_table[id1 % 64];
*dst++ = putil_base64_table[id1 % 64];
id1 /= 64;
} while (id1);
*dst++ = '.';
do {
*dst++ = base64_table[id2 % 64];
*dst++ = putil_base64_table[id2 % 64];
id2 /= 64;
} while (id2);
*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] != '.' ||
(de->d_name[1] != 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))
add_dir_scan(dir, cpath);
}
@ -222,7 +222,7 @@ static uint32_t process_notification(localnotify_dir *dir) {
while (wch) {
if (wch->watchid == ev.wd) {
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),
wch->namelen + 1);
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;
if (psync_is_name_to_ignore(e->name))
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",
e->isfolder ? "folder" : "file", e->name);
return;
@ -569,7 +569,7 @@ scanner_scan_folder(const char *localpath, psync_folderid_t folderid,
psync_list_for_each_element(l, &disklist, sync_folderlist,
list) if (l->isfolder && l->localid &&
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,
deviceid);
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) {
char *path;
path = psync_strcat((char *)vpath, "/", st->name, NULL);
path = putil_strcat((char *)vpath, "/", st->name, NULL);
if (pfile_stat_isfolder(&st->stat)) {
ppath_ls(path, rm_all, path);
rmdir(path);
@ -355,7 +355,7 @@ static void rm_ign(void *vpath, ppath_stat *st) {
char *path;
int ign;
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 (ign)
ppath_ls(path, rm_all, path);
@ -984,9 +984,9 @@ cont:
*ptr = 0;
/* pdbg_logf(D_NOTICE, "key=%s, value=%s", key, val);*/
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))
keepalive = psync_ato32(val + 8);
keepalive = putil_ato32(val + 8);
key = ptr + 1;
isval = 0;
} else if (ch == ':' && !isval) {
@ -1482,9 +1482,9 @@ cont:
*ptr = 0;
/* pdbg_logf(D_NOTICE, "key=%s, value=%s", key, val);*/
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))
keepalive = psync_ato32(val + 8);
keepalive = putil_ato32(val + 8);
key = ptr + 1;
isval = 0;
} 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);
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);
http = NULL;
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) {
pdbg_logf(D_WARNING, "command %s returned code %u", cmd, (unsigned)result);
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);
}
free(res);
return (int)result;
neterr:
if (err)
*err = psync_strdup("Could not connect to the server.");
*err = putil_strdup("Could not connect to the server.");
return -1;
}

12
pclsync/pnotify.c
View File

@ -80,12 +80,12 @@ static void psync_notifications_download_thumb(const binresult *thumb,
filename = strrchr(path, '/');
if (pdbg_unlikely(!filename++))
return;
filepath = psync_strcat(thumbpath, "/", filename, NULL);
filepath = putil_strcat(thumbpath, "/", filename, NULL);
if (!stat(filepath, &st)) {
pdbg_logf(D_NOTICE, "skipping download of %s as it already exists", filename);
goto err0;
}
tmpfilepath = psync_strcat(filepath, ".part", NULL);
tmpfilepath = putil_strcat(filepath, ".part", NULL);
pdbg_logf(D_NOTICE, "downloading thumbnail %s", filename);
if (pdbg_unlikely((fd = pfile_open(tmpfilepath, O_WRONLY,
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);
if (pdbg_unlikely(!sock))
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);
if (pdbg_unlikely(psync_http_request(sock, host, path, 0, 0, cookie)))
goto err3;
@ -187,7 +187,7 @@ void pnotify_set_callback(
pthread_mutex_lock(&ntf_mutex);
ts = ntf_thumb_size;
if (thumbsize)
ntf_thumb_size = psync_strdup(thumbsize);
ntf_thumb_size = putil_strdup(thumbsize);
else
ntf_thumb_size = NULL;
if (ts)
@ -326,7 +326,7 @@ psync_notification_list_t *pnotify_get() {
filename = strrchr(papi_find_result2(br, "path", PARAM_STR)->str, '/');
if (filename++) {
psync_notification_remove_from_list(&thumbs, filename);
filepath = psync_strcat(thumbpath, "/",
filepath = putil_strcat(thumbpath, "/",
filename, NULL);
if (!stat(filepath, &st)) {
pntf->thumb = filepath;
@ -355,7 +355,7 @@ psync_notification_list_t *pnotify_get() {
nx = ptree_get_next_safe(thumbs);
pdbg_logf(D_NOTICE, "deleting unused thumb %s",
ptree_element(thumbs, psync_thumb_list_t, tree)->name);
filepath = psync_strcat(
filepath = putil_strcat(
thumbpath, "/",
ptree_element(thumbs, psync_thumb_list_t, tree)->name, NULL);
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))
return NULL;
return psync_strdup((char *)memcpy(
return putil_strdup((char *)memcpy(
buff + off - sizeof(PSYNC_CONSTRUCT_HEADER) + 3, PSYNC_CONSTRUCT_HEADER,
sizeof(PSYNC_CONSTRUCT_HEADER) - 1));
}
@ -2440,7 +2440,7 @@ retry:
return;
}
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);
sock = psync_http_connect_multihost_from_cache(hosts, &host);
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) + 1] = 0;
tm = ptimer_time();
filename = psync_strcat(psync_setting_get_string(_PS(fscachepath)),
filename = putil_strcat(psync_setting_get_string(_PS(fscachepath)),
"/", fileidhex, NULL);
fd = pfile_open(filename, O_RDONLY, 0);
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();
cachepath = psync_setting_get_string(_PS(fscachepath));
filename =
psync_strcat(cachepath, "/", fileidhex, NULL);
putil_strcat(cachepath, "/", fileidhex, NULL);
fileidhex[sizeof(psync_fsfileid_t)] = 'i';
indexname =
psync_strcat(cachepath, "/", fileidhex, NULL);
putil_strcat(cachepath, "/", fileidhex, NULL);
fd = pfile_open(indexname, O_RDONLY, 0);
if (unlikely(fd == INVALID_HANDLE_VALUE)) {
pdbg_logf(D_ERROR,
@ -4109,7 +4109,7 @@ void ppagecache_init() {
if (stat(cache_dir, &st)) {
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);
if (stat(cache_file, &st))
psql_statement("DELETE FROM pagecache");
@ -4192,7 +4192,7 @@ void ppagecache_reopen_read() {
if (stat(cache_dir, &st)) {
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);
readcache = pfile_open(cache_file, O_RDWR, O_CREAT);
free(cache_file);
@ -4240,7 +4240,7 @@ int ppagecache_move(const char *path) {
int newrdcache, ordcache;
uint32_t i, cnt;
pdbg_logf(D_NOTICE, "start");
rdpath = psync_strcat(path, "/",
rdpath = putil_strcat(path, "/",
PSYNC_DEFAULT_READ_CACHE_FILE, NULL);
if (!stat(rdpath, &st)) {
free(rdpath);
@ -4251,7 +4251,7 @@ int ppagecache_move(const char *path) {
free(rdpath);
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(&flush_cache_mutex);
psql_start();

14
pclsync/ppath.c
View File

@ -20,13 +20,13 @@ char *ppath_default_db() {
return NULL;
}
dbp = psync_strcat(pcdir, "/", PSYNC_DEFAULT_DB_NAME, NULL);
dbp = putil_strcat(pcdir, "/", PSYNC_DEFAULT_DB_NAME, NULL);
free(pcdir);
if (stat(dbp, &st)) {
// Inline the old database path function here
if ((home = ppath_home())) {
oldp = psync_strcat(home, "/", PSYNC_DEFAULT_POSIX_DBNAME, NULL);
oldp = putil_strcat(home, "/", PSYNC_DEFAULT_POSIX_DBNAME, NULL);
free(home);
if (oldp) {
@ -69,7 +69,7 @@ char *ppath_home() {
return NULL;
dir = result->pw_dir;
}
return psync_strdup(dir);
return putil_strdup(dir);
}
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)))
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)) &&
(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);
} else if (de->d_type == DT_UNKNOWN) {
// 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))) {
pst.isfolder = S_ISDIR(st.st_mode);
callback(ptr, &pst);
@ -172,7 +172,7 @@ char *ppath_pcloud() {
return NULL;
}
path = psync_strcat(homedir, "/", PSYNC_DEFAULT_POSIX_DIR, NULL);
path = putil_strcat(homedir, "/", PSYNC_DEFAULT_POSIX_DIR, NULL);
free(homedir);
if (pdbg_unlikely(!path)) {
return NULL;
@ -192,7 +192,7 @@ char *ppath_private(char *name) {
path = ppath_pcloud();
if (!path)
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)) {
free(rpath);
free(path);

16
pclsync/psettings.c
View File

@ -117,11 +117,11 @@ void psync_settings_reset() {
char *home, *defaultfs, *defaultcache;
psync_settingid_t i;
home = ppath_home();
defaultfs = psync_strcat(home, "/",
defaultfs = putil_strcat(home, "/",
PSYNC_DEFAULT_FS_FOLDER, NULL);
free(home);
home = ppath_pcloud();
defaultcache = psync_strcat(home, "/",
defaultcache = putil_strcat(home, "/",
PSYNC_DEFAULT_CACHE_FOLDER, NULL);
free(home);
for (i = 0; i < ARRAY_SIZE(settings); i++)
@ -151,7 +151,7 @@ void psync_settings_reset() {
settings[_PS(ignorepaths)].str = PSYNC_IGNORE_PATHS_DEFAULT;
for (i = 0; i < ARRAY_SIZE(settings); i++) {
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)
settings[i].fix_callback(&settings[i].str);
} else if (settings[i].fix_callback) {
@ -172,11 +172,11 @@ void psync_settings_init() {
char *home, *defaultfs, *defaultcache;
psync_settingid_t i;
home = ppath_home();
defaultfs = psync_strcat(home, "/",
defaultfs = putil_strcat(home, "/",
PSYNC_DEFAULT_FS_FOLDER, NULL);
free(home);
home = ppath_pcloud();
defaultcache = psync_strcat(home, "/",
defaultcache = putil_strcat(home, "/",
PSYNC_DEFAULT_CACHE_FOLDER, NULL);
free(home);
settings[_PS(ignorepatterns)].str = PSYNC_IGNORE_PATTERNS_DEFAULT;
@ -195,7 +195,7 @@ void psync_settings_init() {
settings[_PS(ignorepaths)].str = PSYNC_IGNORE_PATHS_DEFAULT;
for (i = 0; i < ARRAY_SIZE(settings); i++) {
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)
settings[i].fix_callback(&settings[i].str);
} else if (settings[i].fix_callback) {
@ -214,7 +214,7 @@ void psync_settings_init() {
if (!strcmp(name, settings[i].name)) {
if (settings[i].type == PSYNC_TSTRING) {
free(settings[i].str);
settings[i].str = psync_strdup(row[1]);
settings[i].str = putil_strdup(row[1]);
if (settings[i].fix_callback)
settings[i].fix_callback(&settings[i].str);
} 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;
CHECK_SETTINGID_AND_TYPE(-1, PSYNC_TSTRING);
oldval = settings[settingid].str;
newval = psync_strdup(value);
newval = putil_strdup(value);
if (settings[settingid].fix_callback)
settings[settingid].fix_callback(&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;
int sock;
char sport[8];
psync_slprintf(sport, sizeof(sport), "%d", port);
putil_slprintf(sport, sizeof(sport), "%d", port);
sock = connect_socket(host, sport);
if (pdbg_unlikely(sock == INVALID_SOCKET)) {

6
pclsync/psql.c
View File

@ -199,7 +199,7 @@ void psql_dump_locks() {
rd_lock_data *lock;
char dttime[36];
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",
wrlockthread, wrlockfile, wrlockline, dttime);
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);
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",
lock->thread, lock->file, lock->line, dttime);
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;
ret = (char *)sqlite3_column_text(stmt, 0);
if (ret)
ret = psync_strdup(ret);
ret = putil_strdup(ret);
sqlite3_finalize(stmt);
psql_rdunlock();
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,
PSYNC_SHA512_DIGEST_LEN, 5000, sizeof(passwordbin), passwordbin);
mbedtls_md_free(&ctx);
usercopy = psync_base64_encode(passwordbin, sizeof(passwordbin), &userlen);
usercopy = putil_base64_encode(passwordbin, sizeof(passwordbin), &userlen);
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) + 1] = 0;
filename =
psync_strcat(fscpath, "/", fileidhex, NULL);
putil_strcat(fscpath, "/", fileidhex, NULL);
if (!stat(filename, &st)) {
filestou++;
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);
for (i = 0; i < PSYNC_SCAN_TYPES_CNT; i++)
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],
psync_scan_typenames[scnt[i][1]]);
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++)
if (pfile_invalid_chars[(unsigned char)*ptr]) {
if (!vname)
vname = psync_strdup(name);
vname = putil_strdup(name);
vname[ptr - name] = '_';
}
if (vname)
@ -307,7 +307,7 @@ static void psync_sync_newsyncedfolder(psync_syncid_t syncid) {
folderid = psync_get_number(row[0]);
synctype = psync_get_number(row[1]);
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);
if (synctype & PSYNC_DOWNLOAD_ONLY) {
psyncer_dl_folder_add(syncid, synctype, folderid, 0);
@ -463,8 +463,8 @@ re:
continue;
}
localpath = psync_strdup(localpath);
remotepath = psync_strdup(remotepath);
localpath = putil_strdup(localpath);
remotepath = putil_strdup(remotepath);
psql_free(res);
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; }
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() {
@ -288,10 +288,10 @@ void psync_set_user_pass(const char *username, const char *password, int save) {
} else {
pthread_mutex_lock(&psync_my_auth_mutex);
free(psync_my_user);
psync_my_user = psync_strdup(username);
psync_my_user = putil_strdup(username);
free(psync_my_pass);
if (password && password[0])
psync_my_pass = psync_strdup(password);
psync_my_pass = putil_strdup(password);
pthread_mutex_unlock(&psync_my_auth_mutex);
}
pstatus_set(PSTATUS_TYPE_AUTH, PSTATUS_AUTH_PROVIDED);
@ -305,7 +305,7 @@ void psync_set_pass(const char *password, int save) {
else {
pthread_mutex_lock(&psync_my_auth_mutex);
free(psync_my_pass);
psync_my_pass = psync_strdup(password);
psync_my_pass = putil_strdup(password);
pthread_mutex_unlock(&psync_my_auth_mutex);
}
pstatus_set(PSTATUS_TYPE_AUTH, PSTATUS_AUTH_PROVIDED);
@ -316,7 +316,7 @@ void psync_set_auth(const char *auth, int save) {
if (save)
psync_set_string_value("auth", auth);
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);
}
@ -380,7 +380,7 @@ apiservers_list_t *psync_get_apiservers(char **err) {
if (unlikely(!api)) {
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;
}
bres = papi_send2(api, "getlocationapi", params);
@ -389,13 +389,13 @@ apiservers_list_t *psync_get_apiservers(char **err) {
else {
psync_apipool_release_bad(api);
pdbg_logf(D_WARNING, "Send command returned invalid result.\n");
*err = psync_strndup("Connection error.", 17);
*err = putil_strndup("Connection error.", 17);
return NULL;
}
result = papi_find_result2(bres, "result", PARAM_NUM)->num;
if (unlikely(result)) {
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",
(unsigned)result);
return NULL;
@ -529,9 +529,9 @@ static void check_tfa_result(uint64_t result) {
static char *binresult_to_str(const binresult *res) {
if (!res)
return psync_strdup("field not found");
return putil_strdup("field not found");
if (res->type == PARAM_STR)
return psync_strdup(res->str);
return putil_strdup(res->str);
else if (res->type == PARAM_NUM) {
char buff[32], *ptr;
uint64_t n;
@ -542,9 +542,9 @@ static char *binresult_to_str(const binresult *res) {
*--ptr = '0' + n % 10;
n /= 10;
} while (n);
return psync_strdup(ptr);
return putil_strdup(ptr);
} 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) {
pdbg_logf(D_WARNING, "command %s returned code %u", cmd, (unsigned)result);
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);
}
if (result)
@ -915,7 +915,7 @@ static int do_run_command_get_res(const char *cmd, size_t cmdlen,
return (int)result;
neterr:
if (err)
*err = psync_strdup("Could not connect to the server.");
*err = putil_strdup("Could not connect to the server.");
return -1;
}
@ -931,14 +931,14 @@ int psync_register(const char *email, const char *password, int termsaccepted,
psync_set_apiserver(binapi, locationid);
else {
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);
return -1;
}
sock = papi_connect(binapi, psync_setting_get_bool(_PS(usessl)));
if (pdbg_unlikely(!sock)) {
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);
return -1;
}
@ -946,7 +946,7 @@ int psync_register(const char *email, const char *password, int termsaccepted,
if (pdbg_unlikely(!res)) {
psock_close(sock);
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);
return -1;
}
@ -954,7 +954,7 @@ int psync_register(const char *email, const char *password, int termsaccepted,
if (result) {
pdbg_logf(D_WARNING, "command register returned code %u", (unsigned)result);
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);
}
psock_close(sock);
@ -993,7 +993,7 @@ int psync_change_password(const char *currentpass, const char *newpass,
free(device);
if (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));
free(res);
return 0;
@ -1130,7 +1130,7 @@ char *psync_get_string_value(const char *valuename) {
psql_bind_str(res, 1, valuename);
row = psql_fetch_str(res);
if (row)
ret = psync_strdup(row[0]);
ret = putil_strdup(row[0]);
else
ret = NULL;
psql_free(res);
@ -1495,7 +1495,7 @@ static void psync_del_all_except(void *ptr, ppath_fast_stat *st) {
nmarr = (const char **)ptr;
if (!strcmp(st->name, nmarr[1]) || pfile_stat_fast_isfolder(st))
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);
if (pfile_delete(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[1] = nmd;
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(path);
return ret;
@ -2105,7 +2105,7 @@ int psync_fs_move_cache(const char *path) {
char *psync_get_token() {
if (psync_my_auth[0])
return psync_strdup(psync_my_auth);
return putil_strdup(psync_my_auth);
else
return NULL;
}
@ -2136,7 +2136,7 @@ int psync_get_promo(char **url, uint64_t *width, uint64_t *height) {
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) {
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)) {
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.");
return PERROR_PARENT_OR_SUBFOLDER_ALREADY_SYNCING;
} else if (!strcmp(srow[0], localPath)) {
psql_free(sql);
*errMsg = psync_strdup(
*errMsg = putil_strdup(
"There is already an active sync or backup for this folder.");
return PERROR_FOLDER_ALREADY_SYNCING;
}
@ -2268,7 +2268,7 @@ int psync_is_folder_syncable(char *localPath, char **errMsg) {
localPath[len] == '\\')) {
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;
}
free(syncmp);
@ -2283,7 +2283,7 @@ int psync_is_folder_syncable(char *localPath, char **errMsg) {
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.");
return PERROR_PARENT_IS_IGNORED;
}
@ -2304,7 +2304,7 @@ psync_folderid_t create_bup_mach_folder(char **msgErr) {
rootFolIdObj = NULL;
tmpBuff = get_pc_name();
psync_strlcpy(bRootFoName, tmpBuff, 64);
putil_strlcpy(bRootFoName, tmpBuff, 64);
free(tmpBuff);
@ -2377,10 +2377,10 @@ int psync_create_backup(char *path, char **errMsg) {
if (folders.cnt > 1) {
oParCnt = 1;
optFolName = psync_strdup(folders.folders[folders.cnt - 2]);
optFolName = putil_strdup(folders.folders[folders.cnt - 2]);
} else {
oParCnt = 0;
optFolName = psync_strdup("");
optFolName = putil_strdup("");
}
eventParams reqPar = {4, // Number of parameters we are passing below.
@ -2406,7 +2406,7 @@ int psync_create_backup(char *path, char **errMsg) {
free(retData);
if (syncFId < 0) {
*errMsg = psync_strdup("Error creating backup.");
*errMsg = putil_strdup("Error creating backup.");
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;
fda->localpath = dwl->localpath;
fda->fd = INVALID_HANDLE_VALUE;
len = psync_slprintf(buff, sizeof(buff),
len = putil_slprintf(buff, sizeof(buff),
"act=dwl,strm=%" PRIu64 ",fileid=%" PRIu64 "\n",
(uint64_t)s->streamid, (uint64_t)dwl->fileid);
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);
fda->localpath = dwl->localpath;
fda->fd = INVALID_HANDLE_VALUE;
len = psync_slprintf(
len = putil_slprintf(
buff, sizeof(buff),
"act=dwlnm,strm=%" PRIu64 ",fileid=%" PRIu64 ",sha1=%.40s\n",
(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;
if (buffer[0] == 0) {
return psync_strdup("GENERIC_MAC");
return putil_strdup("GENERIC_MAC");
} 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 (err) {
*err = psync_strdup("Could not connect to the server.");
*err = putil_strdup("Could not connect to the server.");
}
return -1;
@ -189,7 +189,7 @@ int ptools_create_backend_event(const char *binapi, const char *category,
psock_close(sock);
if (err) {
*err = psync_strdup("Could not connect to the server.");
*err = putil_strdup("Could not connect to the server.");
}
return -1;
@ -201,7 +201,7 @@ int ptools_create_backend_event(const char *binapi, const char *category,
if (result) {
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);
@ -298,7 +298,7 @@ int ptools_backend_call(const char *binapi, const char *wsPath,
if (pdbg_unlikely(!sock)) {
if (err) {
*err = psync_strdup("Could not connect to the server.");
*err = putil_strdup("Could not connect to the server.");
}
return -1;
@ -313,7 +313,7 @@ int ptools_backend_call(const char *binapi, const char *wsPath,
psock_close(sock);
if (err) {
*err = psync_strdup("Could not connect to the server.");
*err = putil_strdup("Could not connect to the server.");
}
return -1;
@ -325,7 +325,7 @@ int ptools_backend_call(const char *binapi, const char *wsPath,
if (result) {
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);
@ -353,7 +353,7 @@ char *ptools_get_machine_name() {
strcpy(pcName, "LinuxMachine");
}
return psync_strdup(pcName);
return putil_strdup(pcName);
}
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
// before the ":"
fName[k] = '\0';
buff = psync_strcat("Drive ", &fName, NULL);
psync_strlcpy(fName, buff, strlen(buff) + 1);
buff = putil_strcat("Drive ", &fName, NULL);
putil_strlcpy(fName, buff, strlen(buff) + 1);
k = k + strlen("Drive ");
} else {
@ -381,7 +381,7 @@ void ptools_parse_os_path(char *path, folderPath *folders, char *delim, int mode
}
} else {
fName[k] = 0;
folders->folders[j] = psync_strdup(fName);
folders->folders[j] = putil_strdup(fName);
k = 0;
j++;
@ -393,7 +393,7 @@ void ptools_parse_os_path(char *path, folderPath *folders, char *delim, int mode
fName[k] = 0;
if (strlen(fName) > 0) {
folders->folders[j] = psync_strdup(fName);
folders->folders[j] = putil_strdup(fName);
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();
if (unlikely(!api)) {
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;
}
@ -165,7 +165,7 @@ int64_t do_psync_file_public_link(const char *path, int64_t *plinkid,
api = psync_apipool_get();
if (unlikely(!api)) {
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);
return 1;
}
@ -179,13 +179,13 @@ int64_t do_psync_file_public_link(const char *path, int64_t *plinkid,
else {
psync_apipool_release_bad(api);
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;
}
result = papi_find_result2(bres, "result", PARAM_NUM)->num;
if (unlikely(result)) {
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",
(unsigned)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;
*link = psync_strndup(rescode, strlen(rescode));
*link = putil_strndup(rescode, strlen(rescode));
linkid = papi_find_result2(bres, "linkid", PARAM_NUM)->num;
if (plinkid)
*plinkid = linkid;
@ -221,7 +221,7 @@ int64_t do_psync_folder_public_link(const char *path, char **link /*OUT*/,
api = psync_apipool_get();
if (unlikely(!api)) {
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;
}
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();
if (unlikely(!api)) {
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;
}
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;
if (unlikely(result)) {
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",
(unsigned)result);
psync_process_api_error(result);
if (psync_handle_api_result(result) == PSYNC_NET_TEMPFAIL)
return -result;
else {
*err = psync_strndup("Connection error.", 17);
*err = putil_strndup("Connection error.", 17);
return -1;
}
}
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;
free(bres);
@ -295,7 +295,7 @@ int64_t do_psync_folder_public_link_full(const char *path, char **link /*OUT*/,
api = psync_apipool_get();
if (unlikely(!api)) {
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;
}
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();
if (unlikely(!api)) {
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;
}
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;
if (unlikely(result)) {
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",
(unsigned)result);
psync_process_api_error(result);
if (psync_handle_api_result(result) == PSYNC_NET_TEMPFAIL)
return -result;
else {
*err = psync_strndup("Connection error.", 17);
*err = putil_strndup("Connection error.", 17);
return -1;
}
}
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;
free(bres);
@ -371,7 +371,7 @@ int64_t do_psync_folder_updownlink_link(int canupload,
api = psync_apipool_get();
if (unlikely(!api)) {
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;
}
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;
if (unlikely(result)) {
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 createfolderlinkwithuploadandsend returned error code %u",
(unsigned)result);
@ -394,7 +394,7 @@ int64_t do_psync_folder_updownlink_link(int canupload,
if (psync_handle_api_result(result) == PSYNC_NET_TEMPFAIL)
return -result;
else {
*err = psync_strndup("Connection error.", 17);
*err = putil_strndup("Connection error.", 17);
return -1;
}
}
@ -507,7 +507,7 @@ int64_t do_ptree_public_link(const char *linkname, const char *root,
api = psync_apipool_get();
if (unlikely(!api)) {
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;
}
@ -519,26 +519,26 @@ int64_t do_ptree_public_link(const char *linkname, const char *root,
else {
psync_apipool_release_bad(api);
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;
}
result = papi_find_result2(bres, "result", PARAM_NUM)->num;
if (unlikely(result)) {
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",
(unsigned)result);
psync_process_api_error(result);
if (psync_handle_api_result(result) == PSYNC_NET_TEMPFAIL)
return -result;
else {
*err = psync_strndup("Connection error.", 17);
*err = putil_strndup("Connection error.", 17);
return -1;
}
}
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;
@ -575,7 +575,7 @@ int cache_links(char *err, size_t err_size /*OUT*/) {
api = psync_apipool_get();
if (unlikely(!api)) {
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.");
return -2;
}
@ -588,7 +588,7 @@ int cache_links(char *err, size_t err_size /*OUT*/) {
api = psync_apipool_get();
if (unlikely(!api)) {
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.");
return -2;
}
@ -602,7 +602,7 @@ int cache_links(char *err, size_t err_size /*OUT*/) {
else {
psync_apipool_release_bad(api);
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.");
free(bres);
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;
if (unlikely(result)) {
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);
pdbg_logf(D_WARNING, "command listpublinks returned error code %u",
(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)
return -result;
else {
//*err = psync_strndup("Connection error.", 17);
//*err = putil_strndup("Connection error.", 17);
snprintf(err, err_size, "Connection error.");
return 0;
}
@ -725,7 +725,7 @@ int do_psync_delete_link(int64_t linkid, char **err /*OUT*/) {
api = psync_apipool_get();
if (unlikely(!api)) {
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;
}
bres = papi_send2(api, "deletepublink", params);
@ -735,20 +735,20 @@ int do_psync_delete_link(int64_t linkid, char **err /*OUT*/) {
else {
psync_apipool_release_bad(api);
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;
}
result = papi_find_result2(bres, "result", PARAM_NUM)->num;
if (unlikely(result)) {
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",
(unsigned)result);
psync_process_api_error(result);
if (psync_handle_api_result(result) == PSYNC_NET_TEMPFAIL)
return -result;
else {
*err = psync_strndup("Connection error.", 17);
*err = putil_strndup("Connection error.", 17);
return -1;
}
}
@ -765,20 +765,20 @@ int process_bres(const char *cmd, binresult *bres, psock_t *api,
else {
psync_apipool_release_bad(api);
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;
}
result = papi_find_result2(bres, "result", PARAM_NUM)->num;
if (unlikely(result)) {
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,
(unsigned)result);
psync_process_api_error(result);
if (psync_handle_api_result(result) == PSYNC_NET_TEMPFAIL)
return -result;
else {
*err = psync_strndup("Connection error.", 17);
*err = putil_strndup("Connection error.", 17);
return -1;
}
}
@ -827,7 +827,7 @@ int do_psync_change_link(unsigned long long linkid, unsigned long long expire,
api = psync_apipool_get();
if (unlikely(!api)) {
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;
}
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();
if (unlikely(!api)) {
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;
}
@ -877,7 +877,7 @@ int do_change_link_password(unsigned long long linkid, const char *password,
api = psync_apipool_get();
if (unlikely(!api)) {
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;
}
@ -906,7 +906,7 @@ int do_change_link_enable_upload(unsigned long long linkid,
api = psync_apipool_get();
if (unlikely(!api)) {
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;
}
if (enableuploadforeveryone || enableuploadforchosenusers) {
@ -945,7 +945,7 @@ int64_t do_psync_upload_link(const char *path, const char *comment,
api = psync_apipool_get();
if (unlikely(!api)) {
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;
}
@ -969,7 +969,7 @@ int64_t do_psync_upload_link(const char *path, const char *comment,
api = psync_apipool_get();
if (unlikely(!api)) {
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;
}
bres = papi_send(api, "createuploadlink",
@ -982,26 +982,26 @@ int64_t do_psync_upload_link(const char *path, const char *comment,
else {
psync_apipool_release_bad(api);
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;
}
result = papi_find_result2(bres, "result", PARAM_NUM)->num;
if (unlikely(result)) {
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",
(unsigned)result);
psync_process_api_error(result);
if (psync_handle_api_result(result) == PSYNC_NET_TEMPFAIL)
return -result;
else {
*err = psync_strndup("Connection error.", 17);
*err = putil_strndup("Connection error.", 17);
return -1;
}
}
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;
@ -1022,7 +1022,7 @@ int do_psync_delete_upload_link(int64_t uploadlinkid, char **err /*OUT*/) {
api = psync_apipool_get();
if (unlikely(!api)) {
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;
}
@ -1126,7 +1126,7 @@ plink_contents_t *do_show_link(const char *code, char **err /*OUT*/) {
api = psync_apipool_get();
if (unlikely(!api)) {
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;
}
@ -1137,7 +1137,7 @@ plink_contents_t *do_show_link(const char *code, char **err /*OUT*/) {
else {
psync_apipool_release_bad(api);
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;
}
@ -1204,7 +1204,7 @@ int cache_upload_links(char **err /*OUT*/) {
api = psync_apipool_get();
if (unlikely(!api)) {
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;
}
bres = papi_send2(api, "listuploadlinks", params);
@ -1215,7 +1215,7 @@ int cache_upload_links(char **err /*OUT*/) {
api = psync_apipool_get();
if (unlikely(!api)) {
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;
}
bres = papi_send2(api, "listuploadlinks", params);
@ -1226,20 +1226,20 @@ int cache_upload_links(char **err /*OUT*/) {
else {
psync_apipool_release_bad(api);
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;
}
result = papi_find_result2(bres, "result", PARAM_NUM)->num;
if (unlikely(result)) {
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",
(unsigned)result);
psync_process_api_error(result);
if (psync_handle_api_result(result) == PSYNC_NET_TEMPFAIL)
return -result;
else {
*err = psync_strndup("Connection error.", 17);
*err = putil_strndup("Connection error.", 17);
return -1;
}
}
@ -1415,7 +1415,7 @@ preciever_list_t *do_list_email_with_access(unsigned long long linkid,
api = psync_apipool_get();
if (unlikely(!api)) {
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;
}
bres = papi_send2(api, "publink/listemailswithaccess", params);
@ -1424,20 +1424,20 @@ preciever_list_t *do_list_email_with_access(unsigned long long linkid,
else {
psync_apipool_release_bad(api);
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;
}
result = papi_find_result2(bres, "result", PARAM_NUM)->num;
if (unlikely(result)) {
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",
(unsigned)result);
psync_process_api_error(result);
if (psync_handle_api_result(result) == PSYNC_NET_TEMPFAIL)
return NULL;
else {
*err = psync_strndup("Connection error.", 17);
*err = putil_strndup("Connection error.", 17);
return NULL;
}
}
@ -1484,7 +1484,7 @@ int do_link_add_access(unsigned long long linkid, const char *mail,
api = psync_apipool_get();
if (unlikely(!api)) {
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;
}
@ -1507,7 +1507,7 @@ int do_link_remove_access(unsigned long long linkid,
api = psync_apipool_get();
if (unlikely(!api)) {
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;
}
@ -1534,7 +1534,7 @@ bookmarks_list_t *do_cache_bookmarks(char **err) {
api = psync_apipool_get();
if (unlikely(!api)) {
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;
}
@ -1545,20 +1545,20 @@ bookmarks_list_t *do_cache_bookmarks(char **err) {
else {
psync_apipool_release_bad(api);
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;
}
result = papi_find_result2(bres, "result", PARAM_NUM)->num;
if (unlikely(result)) {
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",
(unsigned)result);
psync_process_api_error(result);
if (psync_handle_api_result(result) == PSYNC_NET_TEMPFAIL)
return NULL;
else {
*err = psync_strndup("Connection error.", 17);
*err = putil_strndup("Connection error.", 17);
return NULL;
}
}
@ -1618,7 +1618,7 @@ int do_remove_bookmark(const char *code, int locationid, char **err) {
api = psync_apipool_get();
if (unlikely(!api)) {
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;
}
@ -1643,7 +1643,7 @@ int do_change_bookmark(const char *code, int locationid, const char *name,
api = psync_apipool_get();
if (unlikely(!api)) {
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;
}

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=?");
psql_bind_uint(sql, 1, localfileid);
if ((srow = psql_fetch_str(sql))) {
char *nname = psync_strdup(srow[0]);
char *nname = putil_strdup(srow[0]);
psql_free(sql);
pdbg_logf(D_NOTICE, "looking for folderid=%lu and name=%s in file",
(unsigned long)folderid, nname);
@ -1463,7 +1463,7 @@ static int task_uploadfile(psync_syncid_t syncid, psync_folderid_t localfileid,
}
if (*s1 == *s2) { //==0
pdbg_logf(D_NOTICE, "uploading %s as %s", name, srow[0]);
nname = psync_strdup(srow[0]);
nname = putil_strdup(srow[0]);
name = nname;
}
}

44
pclsync/putil.c
View File

@ -14,7 +14,7 @@
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',
'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',
@ -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",
"May", "Jun", "Jul", "Aug",
"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
}
char *psync_strdup(const char *str) {
char *putil_strdup(const char *str) {
size_t len;
len = strlen(str) + 1;
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;
char *ptr;
len = strlen(str) + 1;
@ -133,14 +133,14 @@ char *psync_strnormalize_filename(const char *str) {
return ptr;
}
char *psync_strndup(const char *str, size_t len) {
char *putil_strndup(const char *str, size_t len) {
char *ptr;
ptr = (char *)memcpy(malloc(sizeof(char) * len + 1), str, len);
ptr[len] = 0;
return ptr;
}
char *psync_strcat(const char *str, ...) {
char *putil_strcat(const char *str, ...) {
size_t i, size, len;
const char *strs[64];
size_t lengths[64];
@ -170,7 +170,7 @@ char *psync_strcat(const char *str, ...) {
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;
int ret;
va_start(ap, format);
@ -181,7 +181,7 @@ int psync_slprintf(char *str, size_t size, const char *format, ...) {
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) {
static const unsigned char *table =
(const unsigned char *)"ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";
@ -220,7 +220,7 @@ unsigned char *psync_base32_encode(const unsigned char *str, size_t length,
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) {
unsigned char *result, *p;
uint32_t bits, buff;
@ -252,7 +252,7 @@ unsigned char *psync_base32_decode(const unsigned char *str, size_t length,
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) {
const unsigned char *current = str;
unsigned char *p;
@ -262,22 +262,22 @@ unsigned char *psync_base64_encode(const unsigned char *str, size_t length,
p = result;
while (length > 2) {
*p++ = base64_table[current[0] >> 2];
*p++ = base64_table[((current[0] & 0x03) << 4) + (current[1] >> 4)];
*p++ = base64_table[((current[1] & 0x0f) << 2) + (current[2] >> 6)];
*p++ = base64_table[current[2] & 0x3f];
*p++ = putil_base64_table[current[0] >> 2];
*p++ = putil_base64_table[((current[0] & 0x03) << 4) + (current[1] >> 4)];
*p++ = putil_base64_table[((current[1] & 0x0f) << 2) + (current[2] >> 6)];
*p++ = putil_base64_table[current[2] & 0x3f];
current += 3;
length -= 3;
}
if (length != 0) {
*p++ = base64_table[current[0] >> 2];
*p++ = putil_base64_table[current[0] >> 2];
if (length > 1) {
*p++ = base64_table[((current[0] & 0x03) << 4) + (current[1] >> 4)];
*p++ = base64_table[(current[1] & 0x0f) << 2];
*p++ = putil_base64_table[((current[0] & 0x03) << 4) + (current[1] >> 4)];
*p++ = putil_base64_table[(current[1] & 0x0f) << 2];
*p++ = '='; /* Add padding */
} else {
*p++ = base64_table[(current[0] & 0x03) << 4];
*p++ = putil_base64_table[(current[0] & 0x03) << 4];
*p++ = '='; /* Add padding */
*p++ = '='; /* Add padding */
}
@ -288,7 +288,7 @@ unsigned char *psync_base64_encode(const unsigned char *str, size_t length,
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) {
const unsigned char *current = str;
unsigned char *result;
@ -328,7 +328,7 @@ unsigned char *psync_base64_decode(const unsigned char *str, size_t length,
return result;
}
int psync_is_valid_utf8(const char *str) {
int putil_is_valid_utf8(const char *str) {
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,
@ -359,14 +359,14 @@ int psync_is_valid_utf8(const char *str) {
return 1;
}
uint64_t psync_ato64(const char *str) {
uint64_t putil_ato64(const char *str) {
uint64_t n = 0;
while (*str >= '0' && *str <= '9')
n = n * 10 + (*str++) - '0';
return n;
}
uint32_t psync_ato32(const char *str) {
uint32_t putil_ato32(const char *str) {
uint32_t n = 0;
while (*str >= '0' && *str <= '9')
n = n * 10 + (*str++) - '0';

30
pclsync/putil.h
View File

@ -24,24 +24,24 @@ extern "C" {
return PSYNC_INVALID_SYNCID; \
} while (0)
extern const char base64_table[];
extern const char putil_base64_table[];
void putil_wipe(void *mem, size_t sz);
void time_format(time_t tm, unsigned long ns, char *result);
char *psync_strdup(const char *str) PSYNC_MALLOC PSYNC_NONNULL(1);
char *psync_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 *psync_strcat(const char *str, ...) PSYNC_MALLOC PSYNC_SENTINEL;
int psync_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 *psync_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 *psync_base64_decode(const unsigned char *str, size_t length, size_t *ret_length);
int psync_is_valid_utf8(const char *str);
uint64_t psync_ato64(const char *str);
uint32_t psync_ato32(const char *str);
void putil_time_format(time_t tm, unsigned long ns, char *result);
char *putil_strdup(const char *str) PSYNC_MALLOC PSYNC_NONNULL(1);
char *putil_strnormalize_filename(const char *str) PSYNC_MALLOC PSYNC_NONNULL(1);
char *putil_strndup(const char *str, size_t len) PSYNC_MALLOC PSYNC_NONNULL(1);
char *putil_strcat(const char *str, ...) PSYNC_MALLOC PSYNC_SENTINEL;
int putil_slprintf(char *str, size_t size, const char *format, ...) PSYNC_NONNULL(1, 3);
unsigned char *putil_base32_encode(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 *putil_base64_encode(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 putil_is_valid_utf8(const char *str);
uint64_t putil_ato64(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;
len = strlen(src);
if (likely(len < size)) {