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

more stupid macros gone. moved util functions from plibs to putil

This commit is contained in:
Levi Neely 2025-03-13 21:39:21 +01:00
parent c3e4546917
commit dc8ffdb1a4
35 changed files with 424 additions and 431 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
pclsync/papi.c
View File

@ -378,8 +378,8 @@ static binresult *parse_result(unsigned char *data, size_t datalen) {
retlen = calc_ret_len(&datac, &datalenc, &strcnt);
if (retlen == -1)
return NULL;
datac = psync_new_cnt(unsigned char, retlen);
strings = psync_new_cnt(binresult *, strcnt);
datac = malloc(sizeof(unsigned char) * retlen);
strings = malloc(sizeof(binresult *) * strcnt);
strcnt = 0;
res = do_parse_result(&data, &datac, strings, &strcnt);
free(strings);

6
pclsync/pcrypto.c
View File

@ -182,7 +182,7 @@ pcrypto_ctr_encdec_t pcrypto_ctr_encdec_create(psync_symmetric_key_t key) {
if (pdbg_unlikely(enc == PSYNC_INVALID_ENCODER)) {
return PSYNC_CRYPTO_INVALID_ENCODER;
}
ret = psync_new(pcrypto_key_t);
ret = malloc(sizeof(pcrypto_key_t));
ret->encoder = enc;
memcpy(ret->iv, key->key + PSYNC_AES256_KEY_SIZE, PSYNC_AES256_BLOCK_SIZE);
return ret;
@ -286,7 +286,7 @@ void pcrypto_encode_text(pcrypto_textenc_t enc,
aesdst = aessrc + PSYNC_AES256_BLOCK_SIZE;
hmac = aessrc + PSYNC_AES256_BLOCK_SIZE * 2;
ol = ALIGN_A256_BS(txtlen);
outptr = psync_new_cnt(unsigned char, ol);
outptr = malloc(sizeof(unsigned char) * ol);
*out = outptr;
*outlen = ol;
if (txtlen <= PSYNC_AES256_BLOCK_SIZE) {
@ -327,7 +327,7 @@ pcrypto_decode_text(pcrypto_textdec_t enc,
return NULL;
aessrc = ALIGN_PTR_A256_BS(buff);
aesdst = aessrc + PSYNC_AES256_BLOCK_SIZE;
outptr = psync_new_cnt(unsigned char, datalen + 1);
outptr = malloc(sizeof(unsigned char) * (datalen + 1));
ret = outptr;
datalen /= PSYNC_AES256_BLOCK_SIZE;
if (datalen == 1) {

4
pclsync/pcryptofolder.c
View File

@ -795,7 +795,7 @@ static void save_folder_key(psync_folderid_t folderid,
// we are likely holding (few) read locks on the database, so executing here
// will deadlock
insert_folder_key_task *t;
t = psync_new(insert_folder_key_task);
t = malloc(sizeof(insert_folder_key_task));
t->key = psymkey_copy_encrypted(enckey);
t->id = folderid;
prun_thread1("save folder key to db task", ptask_cfldr_save_fldrkey, t);
@ -804,7 +804,7 @@ static void save_folder_key(psync_folderid_t folderid,
static void save_file_key_to_db(psync_fileid_t fileid, uint64_t hash,
psync_encrypted_symmetric_key_t enckey) {
insert_file_key_task *t;
t = psync_new(insert_file_key_task);
t = malloc(sizeof(insert_file_key_task));
t->key = psymkey_copy_encrypted(enckey);
t->id = fileid;
t->hash = hash;

4
pclsync/pdeflate.c
View File

@ -55,7 +55,7 @@ struct _psync_deflate_t {
psync_deflate_t *pdeflate_init(int level) {
psync_deflate_t *def;
int ret;
def = psync_new(psync_deflate_t);
def = malloc(sizeof(psync_deflate_t));
memset(&def->stream, 0, sizeof(def->stream));
def->flushbuff = NULL;
def->bufferstartoff = 0;
@ -137,7 +137,7 @@ static int psync_deflate_finish_flush_add_buffer(psync_deflate_t *def,
uint32_t alloced, used, current;
int ret;
alloced = 4096;
buff = psync_new_cnt(unsigned char, alloced);
buff = malloc(sizeof(unsigned char) * alloced);
current = alloced;
used = 0;
def->flags &= ~FLAG_MORE_DATA;

8
pclsync/pdiff.c
View File

@ -170,7 +170,7 @@ static void do_send_eventdata(void *param);
static void psync_notify_cache_change(psync_changetype_t event) {
paccount_cache_callback_t callback;
psync_changetype_t *chtype = psync_new(psync_changetype_t);
psync_changetype_t *chtype = malloc(sizeof(psync_changetype_t));
*chtype = event;
callback = psync_cache_callback;
if (callback)
@ -229,7 +229,7 @@ static binresult *get_userinfo_user_pass(psock_t *sock, const char *username,
pdbg_logf(D_NOTICE, "got digest %s", dig->str);
ul = strlen(username);
uc = psync_new_cnt(unsigned char, ul);
uc = malloc(sizeof(unsigned char) * ul);
for (i = 0; i < ul; i++)
uc[i] = tolower(username[i]);
@ -2758,7 +2758,7 @@ static void psync_diff_refresh_fs(const binresult *entries) {
}
if (!refresh_last)
return;
ptr = psync_new(refresh_folders_ptr_t);
ptr = malloc(sizeof(refresh_folders_ptr_t));
ptr->refresh_folders = refresh_folders;
ptr->refresh_last = refresh_last;
prun_thread1("fs folder refresh", psync_diff_refresh_thread, ptr);
@ -2787,7 +2787,7 @@ static void psync_run_analyze_if_needed() {
else
tablecnt = 0;
psync_sql_free_result(res);
tablenames = psync_new_cnt(char *, tablecnt);
tablenames = malloc(sizeof(char *) * tablecnt);
res = psync_sql_query_rdlock(
"SELECT name FROM sqlite_master WHERE type='table' LIMIT ?");
psync_sql_bind_uint(res, 1, tablecnt);

2
pclsync/pfile.c
View File

@ -275,7 +275,7 @@ int pfile_preread(int fd, uint64_t offset, size_t count) {
cfd = pfile_dup(fd);
if (cfd == INVALID_HANDLE_VALUE)
return -1;
pr = psync_new(psync_file_preread_t);
pr = malloc(sizeof(psync_file_preread_t));
pr->offset = offset;
pr->count = count;
pr->fd = cfd;

4
pclsync/pfolder.c
View File

@ -729,7 +729,7 @@ pentry_t *pfolder_stat(const char *remotepath) {
if (remotepath[0] != '/')
return NULL;
if (remotepath[1] == 0) {
ret = psync_new(pentry_t);
ret = malloc(sizeof(pentry_t));
ret->name = "/";
ret->namelen = 1;
ret->isfolder = 1;
@ -744,7 +744,7 @@ pentry_t *pfolder_stat(const char *remotepath) {
if (len == 0)
folderid = 0;
else {
cremotepath = psync_new_cnt(char, len + 1);
cremotepath = malloc(sizeof(char) * (len + 1));
memcpy(cremotepath, remotepath, len + 1);
cremotepath[len] = 0;
folderid = pfolder_id(cremotepath);

4
pclsync/pfs.c
View File

@ -1020,7 +1020,7 @@ psync_fs_create_file(psync_fsfileid_t fileid, psync_fsfileid_t remotefileid,
fl = (psync_openfile_t *)malloc(offsetof(psync_openfile_t, encoder));
memset(fl, 0, offsetof(psync_openfile_t, encoder));
} else {
fl = psync_new(psync_openfile_t);
fl = malloc(sizeof(psync_openfile_t));
memset(fl, 0, sizeof(psync_openfile_t));
size = pfscrypto_plain_size(size);
}
@ -1846,7 +1846,7 @@ static void psync_fs_write_timer(psync_timer_t timer, void *ptr) {
goto unlock_ex;
}
of->releasedforupload = 1;
ofw = psync_new(psync_openfile_writeid_t);
ofw = malloc(sizeof(psync_openfile_writeid_t));
ofw->of = of;
ofw->writeid = of->writeid;
pthread_mutex_unlock(&of->mutex);

8
pclsync/pfscrypto.c
View File

@ -573,7 +573,7 @@ psync_fs_crypto_set_sector_log_offset(psync_openfile_t *of,
return;
}
}
ntr = psync_new(psync_sector_inlog_t);
ntr = malloc(sizeof(psync_sector_inlog_t));
*pe = &ntr->tree;
ntr->sectorid = sectorid;
ntr->logoffset = offset;
@ -1605,8 +1605,8 @@ retry:
if (!icnt)
psync_interval_tree_free(needtodwl);
else {
ranges = psync_new_cnt(psync_pagecache_read_range, icnt);
tmpbuf = psync_new_cnt(char, isize);
ranges = malloc(sizeof(psync_pagecache_read_range) * icnt);
tmpbuf = malloc(sizeof(char) * isize);
icnt = 0;
isize = 0;
itr = psync_interval_tree_get_first(needtodwl);
@ -1881,7 +1881,7 @@ static int psync_fs_crypto_run_extender(psync_openfile_t *of, uint64_t size) {
pdbg_assert(!of->extender);
pdbg_logf(D_NOTICE, "will run extender thread to extend from %lu to %lu",
(unsigned long)of->currentsize, (unsigned long)size);
ext = psync_new(psync_enc_file_extender_t);
ext = malloc(sizeof(psync_enc_file_extender_t));
pthread_cond_init(&ext->cond, NULL);
ext->extendto = size;
ext->extendedto = of->currentsize;

2
pclsync/pfsfolder.c
View File

@ -97,7 +97,7 @@ static psync_fspath_t *ret_folder_data(psync_fsfolderid_t folderid,
ret->permissions = permissions;
ret->flags = flags;
} else {
ret = psync_new(psync_fspath_t);
ret = malloc(sizeof(psync_fspath_t));
ret->folderid = folderid;
ret->name = name;
ret->shareid = shareid;

2
pclsync/pfstasks.c
View File

@ -127,7 +127,7 @@ psync_fstask_get_or_create_folder_tasks_locked(psync_fsfolderid_t folderid) {
}
}
folder = psync_new(psync_fstask_folder_t);
folder = malloc(sizeof(psync_fstask_folder_t));
memset(folder, 0, sizeof(psync_fstask_folder_t));
if (d < 0)

6
pclsync/pfsupload.c
View File

@ -1170,7 +1170,7 @@ static void large_upload() {
else {
cname = psync_get_lstring(row[4], &len);
len++;
key = psync_new_cnt(char, len);
key = malloc(sizeof(char) * len);
memcpy(key, cname, len);
}
cname = psync_get_lstring(row[3], &len);
@ -1178,7 +1178,7 @@ static void large_upload() {
fileid = psync_get_number(row[6]);
hash = psync_get_number_or_null(row[7]);
len++;
name = psync_new_cnt(char, len);
name = malloc(sizeof(char) * len);
memcpy(name, cname, len);
current_upload_taskid = taskid;
stop_current_upload = 0;
@ -1598,7 +1598,7 @@ static void change_folder_name(fsupload_task_t *task) {
while (et > task->text1 + 2 && isdigit(et[0]))
et--;
if (et > task->text1 && et[0] == '(' && atol(et + 1) < 20) {
nn = psync_new_cnt(char, et - task->text1 + 7);
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);
}

4
pclsync/pintervaltree.c
View File

@ -34,7 +34,7 @@
static psync_interval_tree_t *psync_interval_tree_new(uint64_t from,
uint64_t to) {
psync_interval_tree_t *tree = psync_new(psync_interval_tree_t);
psync_interval_tree_t *tree = malloc(sizeof(psync_interval_tree_t));
tree->from = from;
tree->to = to;
return psync_interval_tree_element(
@ -42,7 +42,7 @@ static psync_interval_tree_t *psync_interval_tree_new(uint64_t from,
}
static psync_interval_tree_t *psync_interval_new(uint64_t from, uint64_t to) {
psync_interval_tree_t *tree = psync_new(psync_interval_tree_t);
psync_interval_tree_t *tree = malloc(sizeof(psync_interval_tree_t));
tree->from = from;
tree->to = to;
return tree;

307
pclsync/plibs.c
View File

@ -85,31 +85,7 @@ static const uint8_t __hex_lookupl[513] = {"000102030405060708090a0b0c0d0e0f"
"e0e1e2e3e4e5e6e7e8e9eaebecedeeef"
"f0f1f2f3f4f5f6f7f8f9fafbfcfdfeff"};
const char 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',
'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '-', '_'};
static const char base64_reverse_table[256] = {
-2, -2, -2, -2, -2, -2, -2, -2, -2, -1, -1, -2, -2, -1, -2, -2, -2, -2, -2,
-2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -1, -2, -2, -2, -2, -2,
-2, -2, -2, -2, -2, 62, -2, 62, -2, 63, 52, 53, 54, 55, 56, 57, 58, 59, 60,
61, -2, -2, -2, -1, -2, -2, -2, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -2, -2, -2, -2,
63, -2, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42,
43, 44, 45, 46, 47, 48, 49, 50, 51, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
-2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
-2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
-2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
-2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
-2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
-2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
-2, -2, -2, -2, -2, -2, -2, -2, -2};
uint16_t const *__hex_lookup = (uint16_t *)__hex_lookupl;
static char normalize_table[256];
const static char *psync_typenames[] = {
"[invalid type]", "[number]", "[string]", "[float]", "[null]", "[bool]"};
@ -135,244 +111,6 @@ static int in_transaction = 0;
static int transaction_failed = 0;
static psync_list tran_callbacks;
char *psync_strdup(const char *str) {
size_t len;
len = strlen(str) + 1;
return (char *)memcpy(psync_new_cnt(char, len), str, len);
}
char *psync_strnormalize_filename(const char *str) {
size_t len, i;
char *ptr;
len = strlen(str) + 1;
ptr = psync_new_cnt(char, len);
for (i = 0; i < len; i++)
ptr[i] = normalize_table[(unsigned char)str[i]];
return ptr;
}
char *psync_strndup(const char *str, size_t len) {
char *ptr;
ptr = (char *)memcpy(psync_new_cnt(char, len + 1), str, len);
ptr[len] = 0;
return ptr;
}
char *psync_strcat(const char *str, ...) {
size_t i, size, len;
const char *strs[64];
size_t lengths[64];
const char *ptr;
char *ptr2, *ptr3;
va_list ap;
va_start(ap, str);
strs[0] = str;
len = strlen(str);
lengths[0] = len;
size = len + 1;
i = 1;
while ((ptr = va_arg(ap, const char *))) {
pdbg_assert(i < ARRAY_SIZE(strs));
len = strlen(ptr);
lengths[i] = len;
strs[i++] = ptr;
size += len;
}
va_end(ap);
ptr2 = ptr3 = (char *)malloc(size);
for (size = 0; size < i; size++) {
memcpy(ptr2, strs[size], lengths[size]);
ptr2 += lengths[size];
}
*ptr2 = 0;
return ptr3;
}
int psync_slprintf(char *str, size_t size, const char *format, ...) {
va_list ap;
int ret;
va_start(ap, format);
ret = vsnprintf(str, size, format, ap);
va_end(ap);
if (pdbg_unlikely(ret >= size))
str[size - 1] = 0;
return ret;
}
unsigned char *psync_base32_encode(const unsigned char *str, size_t length,
size_t *ret_length) {
static const unsigned char *table =
(const unsigned char *)"ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";
unsigned char *result;
unsigned char *p;
uint32_t bits, buff;
result = (unsigned char *)malloc(((length + 4) / 5) * 8 + 1);
p = result;
bits = 0;
buff = 0; // don't really have to initialize this one, but a compiler that
// will detect that this is safe is yet to be born
while (length) {
if (bits < 5) {
buff = (buff << 8) | (*str++);
length--;
bits += 8;
}
bits -= 5;
*p++ = table[0x1f & (buff >> bits)];
}
while (bits) {
if (bits < 5) {
buff <<= (5 - bits);
bits = 5;
}
bits -= 5;
*p++ = table[0x1f & (buff >> bits)];
}
*ret_length = p - result;
*p = 0;
return result;
}
unsigned char *psync_base32_decode(const unsigned char *str, size_t length,
size_t *ret_length) {
unsigned char *result, *p;
uint32_t bits, buff;
unsigned char ch;
result = (unsigned char *)malloc((length + 7) / 8 * 5 + 1);
p = result;
bits = 0;
buff = 0;
while (length) {
ch = *str++;
length--;
if (ch >= 'A' && ch <= 'Z')
ch = (ch & 0x1f) - 1;
else if (ch >= '2' && ch <= '7')
ch -= '2' - 26;
else {
free(result);
return NULL;
}
buff = (buff << 5) + ch;
bits += 5;
if (bits >= 8) {
bits -= 8;
*p++ = buff >> bits;
}
}
*p = 0;
*ret_length = p - result;
return result;
}
unsigned char *psync_base64_encode(const unsigned char *str, size_t length,
size_t *ret_length) {
const unsigned char *current = str;
unsigned char *p;
unsigned char *result;
result = (unsigned char *)malloc(((length + 2) / 3) * 4 + 1);
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];
current += 3;
length -= 3;
}
if (length != 0) {
*p++ = 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];
} else
*p++ = base64_table[(current[0] & 0x03) << 4];
}
*ret_length = p - result;
*p = 0;
return result;
}
unsigned char *psync_base64_decode(const unsigned char *str, size_t length,
size_t *ret_length) {
const unsigned char *current = str;
unsigned char *result;
size_t i = 0, j = 0;
ssize_t ch;
result = (unsigned char *)malloc((length + 3) / 4 * 3 + 1);
while (length-- > 0) {
ch = base64_reverse_table[*current++];
if (ch == -1)
continue;
else if (ch == -2) {
free(result);
return NULL;
}
switch (i % 4) {
case 0:
result[j] = ch << 2;
break;
case 1:
result[j++] |= ch >> 4;
result[j] = (ch & 0x0f) << 4;
break;
case 2:
result[j++] |= ch >> 2;
result[j] = (ch & 0x03) << 6;
break;
case 3:
result[j++] |= ch;
break;
}
i++;
}
*ret_length = j;
result[j] = 0;
return result;
}
int psync_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,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, -1, -1, -1, -1,
-1, -1, -1, -1};
int8_t t;
while (*str) {
t = trailing[(unsigned char)*str++];
if (unlikely(t)) {
if (t < 0)
return 0;
while (t--)
if ((((unsigned char)*str++) & 0xc0) != 0x80)
return 0;
}
}
return 1;
}
void psync_sql_err_callback(void *ptr, int code, const char *msg) {
pdbg_logf(D_WARNING, "database warning %d: %s", code, msg);
}
@ -589,7 +327,7 @@ static void record_wrunlock() {
static void record_rdlock(const char *file, unsigned line,
struct timespec *tm) {
rd_lock_data *lock;
lock = psync_new(rd_lock_data);
lock = malloc(sizeof(rd_lock_data));
lock->file = file;
lock->thread = psync_thread_name;
lock->line = line;
@ -611,7 +349,6 @@ static rd_lock_data *record_rdunlock() {
return lock;
}
void psync_sql_dump_locks() {
rd_lock_data *lock;
char dttime[36];
@ -901,7 +638,7 @@ void psync_sql_transation_add_callbacks(
psync_transaction_callback_t rollback_callback, void *ptr) {
tran_callback_t *cb;
pdbg_assert(in_transaction);
cb = psync_new(tran_callback_t);
cb = malloc(sizeof(tran_callback_t));
cb->commit_callback = commit_callback;
cb->rollback_callback = rollback_callback;
cb->ptr = ptr;
@ -939,7 +676,7 @@ static void psync_sql_do_check_query_plan(const char *sql) {
static psync_tree *psync_sql_new_tree_node(const char *sql) {
psync_sql_tree_t *node;
node = psync_new(psync_sql_tree_t);
node = malloc(sizeof(psync_sql_tree_t));
node->sql = sql;
return &node->tree;
}
@ -1467,7 +1204,7 @@ psync_sql_res *psync_sql_prep_statement_nocache(const char *sql) {
#endif
return NULL;
}
res = psync_new(psync_sql_res);
res = malloc(sizeof(psync_sql_res));
res->stmt = stmt;
res->sql = sql;
#if IS_DEBUG
@ -1750,15 +1487,6 @@ int psync_rename_conflicted_file(const char *path) {
}
}
void psync_libs_init() {
unsigned long i;
for (i = 0; i < 256; i++)
normalize_table[i] = i;
normalize_table[':'] = '_';
normalize_table['/'] = '_';
normalize_table['\\'] = '_';
}
static void run_after_sec(psync_timer_t timer, void *ptr) {
struct run_after_ptr *fp = (struct run_after_ptr *)ptr;
ptimer_stop(timer);
@ -1768,19 +1496,19 @@ static void run_after_sec(psync_timer_t timer, void *ptr) {
void psync_run_after_sec(psync_run_after_t run, void *ptr, uint32_t seconds) {
struct run_after_ptr *fp;
fp = psync_new(struct run_after_ptr);
fp = malloc(sizeof(struct run_after_ptr));
fp->run = run;
fp->ptr = ptr;
ptimer_register(run_after_sec, seconds, fp);
}
static void free_after_sec(psync_timer_t timer, void *ptr) {
static void proc_free_after(psync_timer_t timer, void *ptr) {
ptimer_stop(timer);
free(ptr);
}
void psync_free_after_sec(void *ptr, uint32_t seconds) {
ptimer_register(free_after_sec, seconds, ptr);
ptimer_register(proc_free_after, seconds, ptr);
}
int psync_match_pattern(const char *name, const char *pattern, size_t plen) {
@ -1816,20 +1544,6 @@ int psync_match_pattern(const char *name, const char *pattern, size_t plen) {
return name[i] == 0;
}
uint64_t psync_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 n = 0;
while (*str >= '0' && *str <= '9')
n = n * 10 + (*str++) - '0';
return n;
}
typedef struct {
psync_list list;
unsigned long used;
@ -1868,7 +1582,7 @@ struct psync_list_builder_t_ {
psync_list_builder_t *psync_list_builder_create(size_t element_size,
size_t offset) {
psync_list_builder_t *builder;
builder = psync_new(psync_list_builder_t);
builder = malloc(sizeof(psync_list_builder_t));
builder->element_size = element_size;
builder->elements_offset = offset;
if (element_size <= 200)
@ -1890,7 +1604,7 @@ static uint32_t *psync_list_bulder_push_num(psync_list_builder_t *builder) {
if (!builder->last_numbers ||
builder->last_numbers->used >=
sizeof(builder->last_numbers->numbers) / sizeof(uint32_t)) {
psync_list_num_list *l = psync_new(psync_list_num_list);
psync_list_num_list *l = malloc(sizeof(psync_list_num_list));
l->used = 0;
builder->last_numbers = l;
psync_list_add_tail(&builder->number_list, &l->list);
@ -2008,7 +1722,7 @@ void *psync_list_builder_finalize(psync_list_builder_t *builder) {
builder->stringalloc;
pdbg_logf(D_NOTICE, "allocating %lu bytes, %lu of which for strings",
(unsigned long)sz, (unsigned long)builder->stringalloc);
ret = psync_new_cnt(char, sz);
ret = malloc(sizeof(char) * sz);
if (builder->elements_offset <= sizeof(builder->cnt))
memcpy(ret, &builder->cnt, builder->elements_offset);
else
@ -2199,7 +1913,6 @@ int psync_task_complete(void *h, void *data) {
return ret;
}
#define rot(x, k) (((x) << (k)) | ((x) >> (32 - (k))))
static uint32_t pq_rnd() {
static uint32_t a = 0x95ae3d25, b = 0xe225d755, c = 0xc63a2ae7,
d = 0xe4556265;

42
pclsync/plibs.h
View File

@ -129,9 +129,6 @@ extern "C" {
} while (0)
#endif
#define psync_new(type) (type *)malloc(sizeof(type))
#define psync_new_cnt(type, cnt) (type *)malloc(sizeof(type) * (cnt))
#define psync_binhex(dst, src, cnt) \
do { \
size_t it__; \
@ -201,27 +198,6 @@ extern uint64_t psync_my_userid;
extern pthread_mutex_t psync_my_auth_mutex;
extern PSYNC_THREAD uint32_t psync_error;
extern uint16_t const *__hex_lookup;
extern const char base64_table[];
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);
int psync_sql_connect(const char *db) PSYNC_NONNULL(1);
int psync_sql_close();
@ -317,15 +293,11 @@ uint64_t psync_sql_insertid() PSYNC_PURE;
int psync_rename_conflicted_file(const char *path);
void psync_libs_init();
void psync_run_after_sec(psync_run_after_t run, void *ptr, uint32_t seconds);
void psync_free_after_sec(void *ptr, uint32_t seconds);
int psync_match_pattern(const char *name, const char *pattern, size_t plen);
uint64_t psync_ato64(const char *str);
uint32_t psync_ato32(const char *str);
psync_list_builder_t *psync_list_builder_create(size_t element_size,
size_t offset);
void psync_list_bulder_add_sql(psync_list_builder_t *builder,
@ -395,20 +367,6 @@ static inline void psync_get_string_id2(char *dst, const char *prefix,
*dst = 0;
}
static inline size_t psync_strlcpy(char *dst, const char *src, size_t size) {
size_t len;
len = strlen(src);
if (pdbg_likely(len < size)) {
memcpy(dst, src, len + 1);
return len;
} else if (pdbg_likely(size)) {
memcpy(dst, src, size - 1);
dst[size - 1] = 0;
return size - 1;
} else
return 0;
}
#ifdef __cplusplus
}
#endif

14
pclsync/pnetlibs.c
View File

@ -1742,7 +1742,7 @@ static psync_block_checksum
**psync_net_get_sorted_checksums(psync_file_checksums *checksums){
psync_block_checksum **ret;
uint32_t i;
ret=psync_new_cnt(psync_block_checksum *, checksums->blockcnt);
ret=malloc(sizeof(psync_block_checksum *) * checksums->blockcnt);
for (i=0; i<checksums->blockcnt; i++)
ret[i]=&checksums->blocks[i];
qsort(ret, checksums->blockcnt, sizeof(psync_block_checksum *),
@ -2092,12 +2092,12 @@ int psync_net_download_ranges(psync_list *ranges, psync_fileid_t fileid,
return PSYNC_NET_TEMPFAIL;
}
hash = psync_net_create_hash(checksums);
blockactions = psync_new_cnt(psync_block_action, checksums->blockcnt);
blockactions = malloc(sizeof(psync_block_action) * checksums->blockcnt);
memset(blockactions, 0, sizeof(psync_block_action) * checksums->blockcnt);
for (i = 0; i < filecnt; i++)
psync_net_check_file_for_blocks(files[i], checksums, hash, blockactions, i);
free(hash);
range = psync_new(psync_range_list_t);
range = malloc(sizeof(psync_range_list_t));
range->len = checksums->blocksize;
range->type = blockactions[0].type;
if (range->type == PSYNC_RANGE_COPY) {
@ -2117,7 +2117,7 @@ int psync_net_download_ranges(psync_list *ranges, psync_fileid_t fileid,
(range->type == PSYNC_RANGE_COPY &&
(range->filename != files[blockactions[i].idx] ||
range->off + range->len != blockactions[i].off))) {
range = psync_new(psync_range_list_t);
range = malloc(sizeof(psync_range_list_t));
range->len = bs;
range->type = blockactions[i].type;
if (range->type == PSYNC_RANGE_COPY) {
@ -2133,7 +2133,7 @@ int psync_net_download_ranges(psync_list *ranges, psync_fileid_t fileid,
free(blockactions);
return PSYNC_NET_OK;
fulldownload:
range = psync_new(psync_range_list_t);
range = malloc(sizeof(psync_range_list_t));
range->off = 0;
range->len = filesize;
range->type = PSYNC_RANGE_TRANSFER;
@ -2204,7 +2204,7 @@ static int check_range_for_blocks(psync_file_checksums *checksums,
ur->uploadoffset + ur->len == off + buffoff + outbyteoff)
ur->len += blen;
else {
ur = psync_new(psync_upload_range_list_t);
ur = malloc(sizeof(psync_upload_range_list_t));
ur->uploadoffset = off + buffoff + outbyteoff;
ur->off = (uint64_t)(blockidx - 1) * checksums->blocksize;
ur->len = blen;
@ -2309,7 +2309,7 @@ static void merge_list_to_element(psync_upload_range_list_t *le,
psync_list_add_after(&le->list, &ur->list);
le->len -= ur->len;
} else {
n = psync_new(psync_upload_range_list_t);
n = malloc(sizeof(psync_upload_range_list_t));
n->uploadoffset = n->off = ur->uploadoffset + ur->len;
pdbg_assertw(le->len > ur->uploadoffset - le->uploadoffset + ur->len);
n->len = le->len - (ur->uploadoffset - le->uploadoffset) - ur->len;

6
pclsync/pp2p.c
View File

@ -352,7 +352,7 @@ static void psync_p2p_tcphandler(void *ptr) {
free(binpubrsa);
goto err0;
}
token = psync_new_cnt(char, packet.tokenlen);
token = malloc(sizeof(char) * packet.tokenlen);
if (pdbg_unlikely(socket_read_all(sock, token, packet.tokenlen)) ||
pdbg_unlikely(!check_token(token, packet.tokenlen, binpubrsa->data,
packet.keylen, hashhex))) {
@ -508,7 +508,7 @@ static void psync_p2p_thread() {
else
psys_sleep_milliseconds(1);
} else if (sret == 1) {
inconn = psync_new(int);
inconn = malloc(sizeof(int));
*inconn = accept(tcpsock, NULL, NULL);
if (pdbg_unlikely(*inconn == INVALID_SOCKET))
free(inconn);
@ -761,7 +761,7 @@ int pp2p_check_download(psync_fileid_t fileid,
psync_binhex(pct1.genhash, hashbin, PSYNC_HASH_DIGEST_LEN);
memcpy(pct1.computername, computername, PSYNC_HASH_DIGEST_HEXLEN);
il = psock_list_adapters();
sockets = psync_new_cnt(int, il->interfacecnt);
sockets = malloc(sizeof(int) * il->interfacecnt);
FD_ZERO(&rfds);
msock = 0;
for (i = 0; i < il->interfacecnt; i++) {

34
pclsync/ppagecache.c
View File

@ -482,7 +482,7 @@ static int wait_shared_api() {
psock_t *capi;
int ret;
capi = sharedapi;
waiter = psync_new(shared_api_waiter_t);
waiter = malloc(sizeof(shared_api_waiter_t));
pthread_cond_init(&waiter->cond, NULL);
waiter->api = NULL;
psync_list_add_tail(&sharedapiwaiters, &waiter->list);
@ -696,7 +696,7 @@ static psync_urls_t *get_urls_for_request(psync_request_t *req) {
pthread_mutex_unlock(&url_cache_mutex);
return NULL;
}
urls = psync_new(psync_urls_t);
urls = malloc(sizeof(psync_urls_t));
urls->hash = req->hash;
urls->refcnt = 0;
urls->status = 0;
@ -786,7 +786,7 @@ static unsigned char *has_pages_in_db(uint64_t hash, uint64_t pageid,
uint32_t fcnt;
if (unlikely(!pagecnt))
return NULL;
ret = psync_new_cnt(unsigned char, pagecnt);
ret = malloc(sizeof(unsigned char) * pagecnt);
memset(ret, 0, pagecnt);
fromid = 0;
fcnt = 0;
@ -2284,7 +2284,7 @@ static void check_or_request_page(uint64_t fileid, uint64_t hash,
break;
}
if (!found) {
pw = psync_new(psync_page_wait_t);
pw = malloc(sizeof(psync_page_wait_t));
psync_list_add_tail(&wait_page_hash[h], &pw->list);
psync_list_init(&pw->waiters);
pw->hash = hash;
@ -2297,7 +2297,7 @@ static void check_or_request_page(uint64_t fileid, uint64_t hash,
if (range && range->offset + range->length == pageid * PSYNC_FS_PAGE_SIZE)
range->length += PSYNC_FS_PAGE_SIZE;
else {
range = psync_new(psync_request_range_t);
range = malloc(sizeof(psync_request_range_t));
psync_list_add_tail(ranges, &range->list);
range->offset = pageid * PSYNC_FS_PAGE_SIZE;
range->length = PSYNC_FS_PAGE_SIZE;
@ -2454,7 +2454,7 @@ static void psync_pagecache_read_unmodified_readahead(
if (found)
continue;
// pdbg_logf(D_NOTICE, "read-aheading page %lu", first_page_id+i);
pw = psync_new(psync_page_wait_t);
pw = malloc(sizeof(psync_page_wait_t));
psync_list_add_tail(&wait_page_hash[h], &pw->list);
psync_list_init(&pw->waiters);
pw->hash = hash;
@ -2468,7 +2468,7 @@ static void psync_pagecache_read_unmodified_readahead(
(first_page_id + i) * PSYNC_FS_PAGE_SIZE)
range->length += PSYNC_FS_PAGE_SIZE;
else {
range = psync_new(psync_request_range_t);
range = malloc(sizeof(psync_request_range_t));
psync_list_add_tail(ranges, &range->list);
range->offset = (first_page_id + i) * PSYNC_FS_PAGE_SIZE;
range->length = PSYNC_FS_PAGE_SIZE;
@ -2496,7 +2496,7 @@ add_page_waiter(psync_list *wait_list, psync_list *range_list, uint64_t hash,
psync_page_wait_t *pw;
psync_request_range_t *range;
unsigned long h;
pwt = psync_new(psync_page_waiter_t);
pwt = malloc(sizeof(psync_page_waiter_t));
pthread_cond_init(&pwt->cond, NULL);
pwt->buff = buff;
pwt->pageidx = pageidx;
@ -2510,7 +2510,7 @@ add_page_waiter(psync_list *wait_list, psync_list *range_list, uint64_t hash,
list) if (pw->hash == hash &&
pw->pageid == pageid) goto found;
pdbg_logf(D_NOTICE, "page %lu not found", (unsigned long)pageid);
pw = psync_new(psync_page_wait_t);
pw = malloc(sizeof(psync_page_wait_t));
psync_list_add_tail(&wait_page_hash[h], &pw->list);
psync_list_init(&pw->waiters);
pw->hash = hash;
@ -2523,7 +2523,7 @@ add_page_waiter(psync_list *wait_list, psync_list *range_list, uint64_t hash,
if (range && range->offset + range->length == pageid * PSYNC_FS_PAGE_SIZE)
range->length += PSYNC_FS_PAGE_SIZE;
else {
range = psync_new(psync_request_range_t);
range = malloc(sizeof(psync_request_range_t));
psync_list_add_tail(range_list, &range->list);
range->offset = pageid * PSYNC_FS_PAGE_SIZE;
range->length = PSYNC_FS_PAGE_SIZE;
@ -2575,7 +2575,7 @@ int ppagecache_read_unmod_locked(psync_openfile_t *of, char *buf,
pagecnt = psize / PSYNC_FS_PAGE_SIZE;
first_page_id = poffset / PSYNC_FS_PAGE_SIZE;
psync_list_init(&waiting);
rq = psync_new(psync_request_t);
rq = malloc(sizeof(psync_request_t));
psync_list_init(&rq->ranges);
lock_wait(hash);
if (pagecnt > 1 && pagecnt <= sizeof(dbread) * 8 && psize == size) {
@ -2789,11 +2789,11 @@ int ppagecache_read_unmod_enc_locked(psync_openfile_t *of,
psize = size_round_up_to_page(size + pageoff);
pagecnt = psize / PSYNC_FS_PAGE_SIZE;
first_page_id = poffset / PSYNC_FS_PAGE_SIZE;
rq = psync_new(psync_request_t);
rq = malloc(sizeof(psync_request_t));
psync_list_init(&rq->ranges);
psync_list_init(&waiting);
psync_list_init(&auth_pages);
dp = psync_new_cnt(psync_crypto_data_page, pagecnt);
dp = malloc(sizeof(psync_crypto_data_page) * pagecnt);
memset(dp, 0, sizeof(psync_crypto_data_page) * pagecnt);
ap = NULL;
lock_wait(hash);
@ -2805,7 +2805,7 @@ int ppagecache_read_unmod_enc_locked(psync_openfile_t *of,
}
pfscrypto_get_auth_off(first_page_id + i, 0, &offsets,
&aoffset, &asize, &aoff);
ap = psync_new(psync_crypto_auth_page);
ap = malloc(sizeof(psync_crypto_auth_page));
ap->waiter = NULL;
ap->parent = NULL;
ap->firstpageid = (first_page_id + i) / PSYNC_CRYPTO_HASH_TREE_SECTORS *
@ -2825,7 +2825,7 @@ int ppagecache_read_unmod_enc_locked(psync_openfile_t *of,
for (l = 1; l <= offsets.treelevels; l++) {
pfscrypto_get_auth_off(first_page_id + i, l, &offsets,
&aoffset, &asize, &aoff);
cap = psync_new(psync_crypto_auth_page);
cap = malloc(sizeof(psync_crypto_auth_page));
cap->waiter = NULL;
cap->parent = NULL;
cap->firstpageid = 0;
@ -2858,7 +2858,7 @@ int ppagecache_read_unmod_enc_locked(psync_openfile_t *of,
} else
pbuff = buf + i * PSYNC_FS_PAGE_SIZE - pageoff;
if (!pbuff) {
pbuff = psync_new_cnt(char, apsize);
pbuff = malloc(sizeof(char) * apsize);
dp[i].freebuff = 1;
}
dp[i].buff = pbuff;
@ -3048,7 +3048,7 @@ int ppagecache_readv_locked(psync_openfile_t *of,
} else
needkey = 0;
pthread_mutex_unlock(&of->mutex);
rq = psync_new(psync_request_t);
rq = malloc(sizeof(psync_request_t));
psync_list_init(&rq->ranges);
psync_list_init(&waiting);
for (i = 0; i < cnt; i++) {

4
pclsync/ppassword.c
View File

@ -326,8 +326,8 @@ uint64_t ppassword_score(const char *cpassword) {
}
if (!plen)
return score;
lpwd = psync_new_cnt(unsigned char, plen);
ldpwd = psync_new_cnt(unsigned char, plen);
lpwd = malloc(sizeof(unsigned char) * plen);
ldpwd = malloc(sizeof(unsigned char) * plen);
for (nlen = 0; nlen < plen; nlen++) {
lpwd[nlen] = tolower(password[nlen]);
if (lpwd[nlen] == '0')

10
pclsync/ppathstatus.c
View File

@ -284,7 +284,7 @@ static folder_tasks_t *get_folder_tasks(psync_folderid_t folderid, int create) {
}
}
if (create) {
ft = psync_new(folder_tasks_t);
ft = malloc(sizeof(folder_tasks_t));
*atr = &ft->tree;
ptree_added_at(&folder_tasks, tr, &ft->tree);
ft->folderid = folderid;
@ -424,7 +424,7 @@ void ppathstatus_fldr_moved(psync_folderid_t folderid,
ppathstatus_del_from_parent_cache(folderid);
if (!get_folder_tasks(folderid, 0))
return;
mp = psync_new(folder_moved_params_t);
mp = malloc(sizeof(folder_moved_params_t));
mp->folderid = folderid;
mp->old_parent_folderid = old_parent_folderid;
mp->new_parent_folderid = new_parent_folderid;
@ -483,7 +483,7 @@ static sync_data_t *get_sync_data(psync_syncid_t syncid, int create) {
return NULL;
} else {
size_t i;
sd = psync_new(sync_data_t);
sd = malloc(sizeof(sync_data_t));
sd->syncid = syncid;
*atr = &sd->tree;
ptree_added_at(&sync_data, tr, &sd->tree);
@ -529,7 +529,7 @@ get_sync_folder_tasks(sync_data_t *sd, psync_folderid_t folderid, int create) {
}
}
if (create) {
ft = psync_new(folder_tasks_t);
ft = malloc(sizeof(folder_tasks_t));
*atr = &ft->tree;
ptree_added_at(&sd->folder_tasks, tr, &ft->tree);
ft->folderid = folderid;
@ -773,7 +773,7 @@ void ppathstatus_syncfldr_moved(psync_folderid_t folderid,
sync_del_from_parent_cache(sd, folderid);
if (!get_folder_tasks(folderid, 0))
return;
mp = psync_new(sync_folder_moved_params_t);
mp = malloc(sizeof(sync_folder_moved_params_t));
mp->folderid = folderid;
mp->old_parent_folderid = old_parent_folderid;
mp->new_parent_folderid = new_parent_folderid;

4
pclsync/pqevent.c
View File

@ -416,7 +416,7 @@ void pqevent_queue_eventid(psync_eventtype_t eventid) {
if (eventthreadrunning) {
event_list_t *event;
event = psync_new(event_list_t);
event = malloc(sizeof(event_list_t));
event->data.ptr = NULL;
event->event = eventid;
event->freedata = 0;
@ -432,7 +432,7 @@ void pqevent_queue_event(psync_eventtype_t eventid, void *eventdata) {
if (eventthreadrunning) {
event_list_t *event;
event = psync_new(event_list_t);
event = malloc(sizeof(event_list_t));
event->data.ptr = eventdata;
event->event = eventid;
event->freedata = 1;

2
pclsync/prun.c
View File

@ -34,7 +34,7 @@ static void start_thread(const char *name, void *run, void *ptr) {
pthread_t thread;
pthread_attr_t attr;
data = psync_new(thread_data);
data = malloc(sizeof(thread_data));
data->run = run;
data->ptr = ptr;
data->name = name;

2
pclsync/prunthrottled.c
View File

@ -112,7 +112,7 @@ void prun_throttled(const char *name, prun_throttle_cb call,
node->scheduled = 1;
}
} else {
node = psync_new(psync_rr_tree_node);
node = malloc(sizeof(psync_rr_tree_node));
node->call = call;
node->name = name;
node->scheduled = 0;

2
pclsync/psock.c
View File

@ -481,7 +481,7 @@ psock_t *psock_connect(const char *host, int unsigned port, int ssl) {
} else {
sslc = NULL;
}
ret = psync_new(psock_t);
ret = malloc(sizeof(psock_t));
ret->ssl = sslc;
ret->buffer = NULL;
ret->sock = sock;

16
pclsync/pssl.c
View File

@ -275,7 +275,7 @@ static void free_session(void *ptr) {
static void save_session(ssl_connection_t *conn) {
mbedtls_ssl_session *sess;
sess = psync_new(mbedtls_ssl_session);
sess = malloc(sizeof(mbedtls_ssl_session));
// mbedtls_ssl_get_session seems to copy all elements, instead of referencing
// them, therefore it is thread safe to add session upon connect
memset(sess, 0, sizeof(mbedtls_ssl_session));
@ -477,7 +477,7 @@ void pssl_rand_strong(unsigned char *buf, int num) {
psync_rsa_t pssl_gen_rsa(int bits) {
mbedtls_rsa_context *ctx;
ctx = psync_new(mbedtls_rsa_context);
ctx = malloc(sizeof(mbedtls_rsa_context));
mbedtls_rsa_init(ctx);
mbedtls_rsa_set_padding(ctx, MBEDTLS_RSA_PKCS_V21, MBEDTLS_MD_SHA1);
@ -512,7 +512,7 @@ void prsa_free_public(psync_rsa_publickey_t key) {
psync_rsa_privatekey_t prsa_get_private(psync_rsa_t rsa) {
mbedtls_rsa_context *ctx;
ctx = psync_new(mbedtls_rsa_context);
ctx = malloc(sizeof(mbedtls_rsa_context));
mbedtls_rsa_init(ctx);
mbedtls_rsa_set_padding(ctx, MBEDTLS_RSA_PKCS_V21, MBEDTLS_MD_SHA1);
@ -584,7 +584,7 @@ psync_rsa_publickey_t prsa_load_public(const unsigned char *keydata,
pdbg_logf(D_WARNING, "pk_parse_public_key failed with code %d (-0x%04x); resorting to " "mbedtls 1.x RSA fallback", ret, -ret);
return PSYNC_INVALID_RSA;
}
rsa = psync_new(mbedtls_rsa_context);
rsa = malloc(sizeof(mbedtls_rsa_context));
mbedtls_rsa_init(rsa);
mbedtls_rsa_set_padding(rsa, MBEDTLS_RSA_PKCS_V21, MBEDTLS_MD_SHA1);
ret = mbedtls_rsa_copy(rsa, mbedtls_pk_rsa(ctx));
@ -639,7 +639,7 @@ psync_rsa_privatekey_t prsa_load_private(const unsigned char *keydata, size_t ke
ssl_pdbg_logf(D_WARNING, ret, "pk_parse_key failed");
return PSYNC_INVALID_RSA;
}
rsa = psync_new(mbedtls_rsa_context);
rsa = malloc(sizeof(mbedtls_rsa_context));
mbedtls_rsa_init(rsa);
mbedtls_rsa_set_padding(rsa, MBEDTLS_RSA_PKCS_V21, MBEDTLS_MD_SHA1);
ret = mbedtls_rsa_copy(rsa, mbedtls_pk_rsa(ctx));
@ -691,7 +691,7 @@ char *psymkey_derive(const char *username,
mbedtls_md_context_t ctx;
size_t userlen, i;
userlen = strlen(username);
usercopy = psync_new_cnt(unsigned char, userlen);
usercopy = malloc(sizeof(unsigned char) * userlen);
for (i = 0; i < userlen; i++)
if ((unsigned char)username[i] <= 127)
usercopy[i] = tolower((unsigned char)username[i]);
@ -767,7 +767,7 @@ psync_aes256_encoder
paes_create_encoder(psync_symmetric_key_t key) {
mbedtls_aes_context *aes;
pdbg_assert(key->keylen >= PSYNC_AES256_KEY_SIZE);
aes = psync_new(mbedtls_aes_context);
aes = malloc(sizeof(mbedtls_aes_context));
mbedtls_aes_setkey_enc(aes, key->key, 256);
return aes;
}
@ -781,7 +781,7 @@ psync_aes256_encoder
paes_create_decoder(psync_symmetric_key_t key) {
mbedtls_aes_context *aes;
pdbg_assert(key->keylen >= PSYNC_AES256_KEY_SIZE);
aes = psync_new(mbedtls_aes_context);
aes = malloc(sizeof(mbedtls_aes_context));
mbedtls_aes_setkey_dec(aes, key->key, 256);
return aes;
}

4
pclsync/psuggest.c
View File

@ -162,7 +162,7 @@ static void suggest_folders(scan_folder *f, psync_list *suggestions) {
if (sum >= PSYNC_SCANNER_MIN_FILES &&
sum >= (f->filecnt[0] + sum) * PSYNC_SCANNER_PERCENT / 100) {
// pdbg_logf(D_NOTICE, "suggesting %s sum %u", f->path, sum);
s = psync_new(suggested_folder);
s = malloc(sizeof(suggested_folder));
s->folder = f;
s->filecnt = sum;
psync_list_add_tail(suggestions, &s->list);
@ -199,7 +199,7 @@ psuggested_folders_t *psuggest_scan_folder(const char *path) {
size_t descslen[PSYNC_SCANNER_MAX_SUGGESTIONS];
char buff[256];
uint32_t scnt[PSYNC_SCAN_TYPES_CNT][2];
f = psync_new(scan_folder);
f = malloc(sizeof(scan_folder));
psync_list_init(&f->nextfolder);
psync_list_init(&f->subfolders);
f->path = path;

4
pclsync/psyncer.c
View File

@ -64,7 +64,7 @@ static psync_tree *synced_down_folders = PSYNC_TREE_EMPTY;
static pthread_mutex_t sync_down_mutex = PTHREAD_MUTEX_INITIALIZER;
static psync_tree *psync_new_sd_folder(psync_folderid_t folderid) {
synced_down_folder *f = psync_new(synced_down_folder);
synced_down_folder *f = malloc(sizeof(synced_down_folder));
f->folderid = folderid;
return &f->tree;
}
@ -350,7 +350,7 @@ static void psync_do_sync_thread(void *ptr) {
}
void psyncer_create(psync_syncid_t syncid) {
psync_syncid_t *psid = psync_new(psync_syncid_t);
psync_syncid_t *psid = malloc(sizeof(psync_syncid_t));
*psid = syncid;
prun_thread1("syncer", psync_do_sync_thread, psid);
}

3
pclsync/psynclib.c
View File

@ -193,7 +193,6 @@ int psync_init() {
return -1;
}
psync_libs_init();
psync_settings_init();
pstatus_init();
ptimer_sleep_handler(psync_stop_crypto_on_sleep);
@ -1921,7 +1920,7 @@ psync_folderid_t *psync_crypto_folderids() {
size_t alloc, l;
alloc = 2;
l = 0;
ret = psync_new_cnt(psync_folderid_t, alloc);
ret = malloc(sizeof(psync_folderid_t) * alloc);
res = psync_sql_query_rdlock(
"SELECT f1.id FROM folder f1, folder f2 WHERE f1.parentfolderid=f2.id "
"AND "

2
pclsync/psys.c
View File

@ -47,7 +47,7 @@ void psys_init() {
psync_uid = getuid();
psync_gid = getgid();
psync_gids_cnt = getgroups(0, NULL);
psync_gids = psync_new_cnt(gid_t, psync_gids_cnt);
psync_gids = malloc(sizeof(gid_t) * psync_gids_cnt);
if (pdbg_unlikely(getgroups(psync_gids_cnt, psync_gids) != psync_gids_cnt))
psync_gids_cnt = 0;
pdbg_logf(D_NOTICE, "detected page size %ld", sysconf(_SC_PAGESIZE));

2
pclsync/ptask.c
View File

@ -655,7 +655,7 @@ static int proc_start_async_transfer() {
pdbg_logf(D_NOTICE, "pdeflate_init() failed");
goto err3;
}
tparams = psync_new(async_params_t);
tparams = malloc(sizeof(async_params_t));
memset(tparams, 0, sizeof(async_params_t));
tparams->enc = enc;
tparams->dec = dec;

2
pclsync/ptevent.c
View File

@ -27,7 +27,7 @@ void ptevent_process(event_data_struct *data) {
event_data_struct *event_data;
if (data_event_fptr) {
event_data = psync_new(event_data_struct);
event_data = malloc(sizeof(event_data_struct));
event_data->eventid = data->eventid;
event_data->uint1 = data->uint1;
event_data->uint2 = data->uint2;

6
pclsync/ptimer.c
View File

@ -193,7 +193,7 @@ psync_timer_t ptimer_register(psync_timer_callback func, time_t numsec,
psync_timer_t timer;
uint32_t i;
time_t n;
timer = psync_new(psync_timer_structure_t);
timer = malloc(sizeof(psync_timer_structure_t));
timer->call = func;
timer->param = param;
n = TIMER_ARRAY_SIZE;
@ -242,7 +242,7 @@ int ptimer_stop(psync_timer_t timer) {
void ptimer_exception_handler(psync_exception_callback func) {
struct exception_list *t;
t = psync_new(struct exception_list);
t = malloc(sizeof(struct exception_list));
t->next = NULL;
t->func = func;
t->threadid = pthread_self();
@ -254,7 +254,7 @@ void ptimer_exception_handler(psync_exception_callback func) {
void ptimer_sleep_handler(psync_exception_callback func) {
struct exception_list *t;
t = psync_new(struct exception_list);
t = malloc(sizeof(struct exception_list));
t->next = NULL;
t->func = func;
t->threadid = pthread_self();

8
pclsync/pupload.c
View File

@ -364,7 +364,7 @@ int handle_api_errors(sync_err_struct *err_struct) {
pdbg_logf(D_NOTICE, "Got sync path: [%s] Sync folder: [%s]", syncFolder,
folder);
event_data = psync_new(event_data_struct);
event_data = malloc(sizeof(event_data_struct));
event_data->eventid = PEVENT_SYNC_RENAME_F;
event_data->str1 = strdup(err_struct->newName);
event_data->str2 = folder;
@ -1019,7 +1019,7 @@ static int upload_big_file(const char *localpath, const unsigned char *hashhex,
}
psync_list_init(&rlist);
if (likely(uploadoffset < fsize)) {
le = psync_new(psync_upload_range_list_t);
le = malloc(sizeof(psync_upload_range_list_t));
le->uploadoffset = uploadoffset;
le->off = uploadoffset;
le->len = fsize - uploadoffset;
@ -1119,14 +1119,14 @@ static int upload_big_file(const char *localpath, const unsigned char *hashhex,
list) if ((le->type == PSYNC_URANGE_COPY_FILE ||
le->type == PSYNC_URANGE_COPY_UPLOAD) &&
le->len > PSYNC_MAX_COPY_FROM_REQ) {
le2 = psync_new(psync_upload_range_list_t);
le2 = malloc(sizeof(psync_upload_range_list_t));
*le2 = *le;
le->len = PSYNC_MAX_COPY_FROM_REQ;
le2->off += PSYNC_MAX_COPY_FROM_REQ;
le2->len -= PSYNC_MAX_COPY_FROM_REQ;
psync_list_add_after(&le->list, &le2->list);
}
le = psync_new(psync_upload_range_list_t);
le = malloc(sizeof(psync_upload_range_list_t));
le->type = PSYNC_URANGE_LAST;
psync_list_add_tail(&rlist, &le->list);
psync_list_for_each_element(le, &rlist, psync_upload_range_list_t, list) {

289
pclsync/putil.c
View File

@ -1,5 +1,7 @@
#include <errno.h>
#include <stdarg.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
@ -9,6 +11,42 @@
#include "pdbg.h"
#include "putil.h"
static char normalize_table[256];
const char 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',
'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '-', '_'};
static const char base64_reverse_table[256] = {
-2, -2, -2, -2, -2, -2, -2, -2, -2, -1, -1, -2, -2, -1, -2, -2, -2, -2, -2,
-2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -1, -2, -2, -2, -2, -2,
-2, -2, -2, -2, -2, 62, -2, 62, -2, 63, 52, 53, 54, 55, 56, 57, 58, 59, 60,
61, -2, -2, -2, -1, -2, -2, -2, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -2, -2, -2, -2,
63, -2, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42,
43, 44, 45, 46, 47, 48, 49, 50, 51, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
-2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
-2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
-2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
-2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
-2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
-2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,
-2, -2, -2, -2, -2, -2, -2, -2, -2};
__attribute((constructor)) static void init() {
unsigned long i;
for (i = 0; i < 256; i++) {
normalize_table[i] = i;
}
normalize_table[':'] = '_';
normalize_table['/'] = '_';
normalize_table['\\'] = '_';
}
// wipe a segment of memory mem of size sz using a DoD 5220.22-M compliant
// 3-pass wipe. the first pass overwrites the memory with zeroes, the second
// with ones, and the third with random data using the urandom entropy
@ -82,3 +120,254 @@ 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) {
size_t len;
len = strlen(str) + 1;
return (char *)memcpy(malloc(sizeof(char) * len), str, len);
}
char *psync_strnormalize_filename(const char *str) {
size_t len, i;
char *ptr;
len = strlen(str) + 1;
ptr = malloc(sizeof(char) * len);
for (i = 0; i < len; i++)
ptr[i] = normalize_table[(unsigned char)str[i]];
return ptr;
}
char *psync_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, ...) {
size_t i, size, len;
const char *strs[64];
size_t lengths[64];
const char *ptr;
char *ptr2, *ptr3;
va_list ap;
va_start(ap, str);
strs[0] = str;
len = strlen(str);
lengths[0] = len;
size = len + 1;
i = 1;
while ((ptr = va_arg(ap, const char *))) {
pdbg_assert(i < ARRAY_SIZE(strs));
len = strlen(ptr);
lengths[i] = len;
strs[i++] = ptr;
size += len;
}
va_end(ap);
ptr2 = ptr3 = (char *)malloc(size);
for (size = 0; size < i; size++) {
memcpy(ptr2, strs[size], lengths[size]);
ptr2 += lengths[size];
}
*ptr2 = 0;
return ptr3;
}
int psync_slprintf(char *str, size_t size, const char *format, ...) {
va_list ap;
int ret;
va_start(ap, format);
ret = vsnprintf(str, size, format, ap);
va_end(ap);
if (pdbg_unlikely(ret >= size))
str[size - 1] = 0;
return ret;
}
unsigned char *psync_base32_encode(const unsigned char *str, size_t length,
size_t *ret_length) {
static const unsigned char *table =
(const unsigned char *)"ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";
unsigned char *result;
unsigned char *p;
uint32_t bits, buff;
result = (unsigned char *)malloc(((length + 4) / 5) * 8 + 1);
p = result;
bits = 0;
buff = 0; // don't really have to initialize this one, but a compiler that
// will detect that this is safe is yet to be born
while (length) {
if (bits < 5) {
buff = (buff << 8) | (*str++);
length--;
bits += 8;
}
bits -= 5;
*p++ = table[0x1f & (buff >> bits)];
}
while (bits) {
if (bits < 5) {
buff <<= (5 - bits);
bits = 5;
}
bits -= 5;
*p++ = table[0x1f & (buff >> bits)];
}
*ret_length = p - result;
*p = 0;
return result;
}
unsigned char *psync_base32_decode(const unsigned char *str, size_t length,
size_t *ret_length) {
unsigned char *result, *p;
uint32_t bits, buff;
unsigned char ch;
result = (unsigned char *)malloc((length + 7) / 8 * 5 + 1);
p = result;
bits = 0;
buff = 0;
while (length) {
ch = *str++;
length--;
if (ch >= 'A' && ch <= 'Z')
ch = (ch & 0x1f) - 1;
else if (ch >= '2' && ch <= '7')
ch -= '2' - 26;
else {
free(result);
return NULL;
}
buff = (buff << 5) + ch;
bits += 5;
if (bits >= 8) {
bits -= 8;
*p++ = buff >> bits;
}
}
*p = 0;
*ret_length = p - result;
return result;
}
unsigned char *psync_base64_encode(const unsigned char *str, size_t length,
size_t *ret_length) {
const unsigned char *current = str;
unsigned char *p;
unsigned char *result;
result = (unsigned char *)malloc(((length + 2) / 3) * 4 + 1);
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];
current += 3;
length -= 3;
}
if (length != 0) {
*p++ = 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];
} else
*p++ = base64_table[(current[0] & 0x03) << 4];
}
*ret_length = p - result;
*p = 0;
return result;
}
unsigned char *psync_base64_decode(const unsigned char *str, size_t length,
size_t *ret_length) {
const unsigned char *current = str;
unsigned char *result;
size_t i = 0, j = 0;
ssize_t ch;
result = (unsigned char *)malloc((length + 3) / 4 * 3 + 1);
while (length-- > 0) {
ch = base64_reverse_table[*current++];
if (ch == -1)
continue;
else if (ch == -2) {
free(result);
return NULL;
}
switch (i % 4) {
case 0:
result[j] = ch << 2;
break;
case 1:
result[j++] |= ch >> 4;
result[j] = (ch & 0x0f) << 4;
break;
case 2:
result[j++] |= ch >> 2;
result[j] = (ch & 0x03) << 6;
break;
case 3:
result[j++] |= ch;
break;
}
i++;
}
*ret_length = j;
result[j] = 0;
return result;
}
int psync_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,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, -1, -1, -1, -1,
-1, -1, -1, -1};
int8_t t;
while (*str) {
t = trailing[(unsigned char)*str++];
if (unlikely(t)) {
if (t < 0)
return 0;
while (t--)
if ((((unsigned char)*str++) & 0xc0) != 0x80)
return 0;
}
}
return 1;
}
uint64_t psync_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 n = 0;
while (*str >= '0' && *str <= '9')
n = n * 10 + (*str++) - '0';
return n;
}

34
pclsync/putil.h
View File

@ -1,6 +1,8 @@
#ifndef __PUTIL_H
#define __PUTIL_H
#include <stdint.h>
#include <string.h>
#ifdef __cplusplus
extern "C" {
#endif
@ -8,13 +10,45 @@ extern "C" {
#include <stddef.h>
#include <time.h>
#include "pcompiler.h"
#define NTO_STR(s) TO_STR(s)
#define TO_STR(s) #s
#define VAR_ARRAY(name, type, size) type name[size]
#define ARRAY_SIZE(arr) (sizeof(arr) / sizeof((arr)[0]))
#define rot(x, k) (((x) << (k)) | ((x) >> (32 - (k))))
extern const char 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);
static inline size_t psync_strlcpy(char *dst, const char *src, size_t size) {
size_t len;
len = strlen(src);
if (likely(len < size)) {
memcpy(dst, src, len + 1);
return len;
} else if (likely(size)) {
memcpy(dst, src, size - 1);
dst[size - 1] = 0;
return size - 1;
} else
return 0;
}
#ifdef __cplusplus
}