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

654 lines
20 KiB
C
Raw Blame History

/*
Copyright (c) 2013 Anton Titov.
Copyright (c) 2013 pCloud Ltd. All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met: Redistributions of source code must retain the above
copyright notice, this list of conditions and the following
disclaimer. Redistributions in binary form must reproduce the above
copyright notice, this list of conditions and the following
disclaimer in the documentation and/or other materials provided with
the distribution. Neither the name of pCloud Ltd nor the names of
its contributors may be used to endorse or promote products derived
from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL pCloud Ltd BE
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "papi.h"
#include "psynclib.h"
#include "plibs.h"
#include "psettings.h"
#include "ptimer.h"
#include <string.h>
#include <stddef.h>
#define RPARAM_STR1 0
#define RPARAM_STR2 1
#define RPARAM_STR3 2
#define RPARAM_STR4 3
#define RPARAM_RSTR1 4
#define RPARAM_RSTR2 5
#define RPARAM_RSTR3 6
#define RPARAM_RSTR4 7
#define RPARAM_NUM1 8
#define RPARAM_NUM2 9
#define RPARAM_NUM3 10
#define RPARAM_NUM4 11
#define RPARAM_NUM5 12
#define RPARAM_NUM6 13
#define RPARAM_NUM7 14
#define RPARAM_NUM8 15
#define RPARAM_HASH 16
#define RPARAM_ARRAY 17
#define RPARAM_BFALSE 18
#define RPARAM_BTRUE 19
#define RPARAM_DATA 20
/* 100-149 inclusive - strings 0-49 bytes in length without additional len parameter */
#define RPARAM_SHORT_STR_BASE 100
/* 150-199 inclusive - reused strings id 0-49 bytes in length without additional id parameter */
#define RPARAM_SHORT_RSTR_BASE 150
/* 200-219 inclusive - small numbers 0-19 */
#define RPARAM_SMALL_NUM_BASE 200
#define RPARAM_END 255
#define VSHORT_STR_LEN 50
#define VSHORT_RSTR_CNT 50
#define VSMALL_NUMBER_NUM 20
static const binresult BOOL_TRUE={PARAM_BOOL, 0, {1}};
static const binresult BOOL_FALSE={PARAM_BOOL, 0, {0}};
static const binresult STR_EMPTY={PARAM_STR, 0, {0}};
static const binresult NUM_ZERO={PARAM_NUM, 0, {0}};
static const binresult HASH_EMPTY={PARAM_HASH, 0, {0}};
static const binresult ARRAY_EMPTY={PARAM_ARRAY, 0, {0}};
static const binresult DATA_EMPTY={PARAM_DATA, 0, {0}};
static const binresult *empty_types[]={&STR_EMPTY, &NUM_ZERO, &BOOL_FALSE, &ARRAY_EMPTY, &HASH_EMPTY, &DATA_EMPTY};
static const char *type_names[]={"string", "number", "boolean", "array", "hash", "data"};
static const binresult NUM_SMALL[VSMALL_NUMBER_NUM]={
{PARAM_NUM, 0, {0}},
{PARAM_NUM, 0, {1}},
{PARAM_NUM, 0, {2}},
{PARAM_NUM, 0, {3}},
{PARAM_NUM, 0, {4}},
{PARAM_NUM, 0, {5}},
{PARAM_NUM, 0, {6}},
{PARAM_NUM, 0, {7}},
{PARAM_NUM, 0, {8}},
{PARAM_NUM, 0, {9}},
{PARAM_NUM, 0, {10}},
{PARAM_NUM, 0, {11}},
{PARAM_NUM, 0, {12}},
{PARAM_NUM, 0, {13}},
{PARAM_NUM, 0, {14}},
{PARAM_NUM, 0, {15}},
{PARAM_NUM, 0, {16}},
{PARAM_NUM, 0, {17}},
{PARAM_NUM, 0, {18}},
{PARAM_NUM, 0, {19}}
};
static uint32_t connfailures=0;
psync_socket *psync_api_connect(const char *hostname, int usessl){
static time_t notuntil=0;
psync_socket *ret;
const char *userapi = psync_setting_get_string(_PS(api_server));
if (psync_timer_time()>notuntil || !userapi){
ret = psync_socket_connect(hostname, usessl ? PSYNC_API_PORT_SSL : PSYNC_API_PORT, usessl);
if (ret)
return ret;
if (!userapi || !strcmp(hostname, userapi))
return NULL;
ret=psync_socket_connect(userapi, usessl ? PSYNC_API_PORT_SSL : PSYNC_API_PORT, usessl);
if (ret) {
debug(D_NOTICE, "failed to connect to %s, but was able to connect to %s", hostname, userapi);
notuntil = psync_timer_time() + 1800;
}
return ret;
}
return psync_socket_connect(userapi, usessl ? PSYNC_API_PORT_SSL : PSYNC_API_PORT, usessl);
}
void psync_api_conn_fail_inc(){
connfailures++;
}
void psync_api_conn_fail_reset(){
if (connfailures%5==4)
connfailures=4;
else
connfailures=0;
}
#define _NEED_DATA(cnt) if (unlikely_log(*datalen<(cnt))) return -1
#define ALIGN_BYTES psync_alignof(uint64_t)
static ssize_t calc_ret_len(unsigned char **restrict data, size_t *restrict datalen, size_t *restrict strcnt){
size_t type, len;
long cond;
_NEED_DATA(1);
type=**data;
(*data)++;
(*datalen)--;
if ((cond=(type>=RPARAM_SHORT_STR_BASE && type<RPARAM_SHORT_STR_BASE+VSHORT_STR_LEN)) || (type>=RPARAM_STR1 && type<=RPARAM_STR4)){
if (cond)
len=type-RPARAM_SHORT_STR_BASE;
else{
size_t l=type-RPARAM_STR1+1;
_NEED_DATA(l);
len=0;
memcpy(&len, *data, l);
*data+=l;
*datalen-=l;
}
_NEED_DATA(len);
*data+=len;
*datalen-=len;
len=((len+ALIGN_BYTES)/ALIGN_BYTES)*ALIGN_BYTES;
(*strcnt)++;
return offsetof(binresult, str)+len;
}
else if ((cond=(type>=RPARAM_RSTR1 && type<=RPARAM_RSTR4)) || (type>=RPARAM_SHORT_RSTR_BASE && type<RPARAM_SHORT_RSTR_BASE+VSHORT_RSTR_CNT)){
if (cond){
size_t l=type-RPARAM_RSTR1+1;
_NEED_DATA(l);
len=0;
memcpy(&len, *data, l);
*data+=l;
*datalen-=l;
}
else
len=type-RPARAM_SHORT_RSTR_BASE;
if (len<*strcnt)
return 0;
else
return -1;
}
else if (type>=RPARAM_NUM1 && type<=RPARAM_NUM8){
len=type-RPARAM_NUM1+1;
_NEED_DATA(len);
*data+=len;
*datalen-=len;
return sizeof(binresult);
}
else if (type>=RPARAM_SMALL_NUM_BASE && type<RPARAM_SMALL_NUM_BASE+VSMALL_NUMBER_NUM)
return 0;
else if (type==RPARAM_BFALSE || type==RPARAM_BTRUE)
return 0;
else if (type==RPARAM_ARRAY){
ssize_t ret, r;
int unsigned cnt;
cnt=0;
ret=sizeof(binresult);
while (**data!=RPARAM_END){
r=calc_ret_len(data, datalen, strcnt);
if (r==-1)
return -1;
ret+=r;
cnt++;
_NEED_DATA(1);
}
(*data)++;
(*datalen)--;
ret+=sizeof(binresult *)*cnt;
return ret;
}
else if (type==RPARAM_HASH){
ssize_t ret, r;
int unsigned cnt;
cnt=0;
ret=sizeof(binresult);
while (**data!=RPARAM_END){
r=calc_ret_len(data, datalen, strcnt);
if (r==-1)
return -1;
ret+=r;
r=calc_ret_len(data, datalen, strcnt);
if (r==-1)
return -1;
ret+=r;
cnt++;
_NEED_DATA(1);
}
(*data)++;
(*datalen)--;
ret+=sizeof(hashpair)*cnt;
return ret;
}
else if (type==RPARAM_DATA){
_NEED_DATA(8);
*data+=8;
*datalen-=8;
return sizeof(binresult);
}
else
return -1;
}
static binresult *do_parse_result(unsigned char **restrict indata, unsigned char **restrict odata, binresult **restrict strings, size_t *restrict nextstrid){
binresult *ret;
long cond;
psync_uint_t type, len;
type=**indata;
(*indata)++;
if ((cond=(type>=RPARAM_SHORT_STR_BASE && type<RPARAM_SHORT_STR_BASE+VSHORT_STR_LEN)) || (type>=RPARAM_STR1 && type<=RPARAM_STR4)){
if (cond)
len=type-RPARAM_SHORT_STR_BASE;
else{
size_t l=type-RPARAM_STR1+1;
len=0;
memcpy(&len, *indata, l);
*indata+=l;
}
ret=(binresult *)(*odata);
*odata+=offsetof(binresult, str);
ret->type=PARAM_STR;
strings[*nextstrid]=ret;
(*nextstrid)++;
ret->length=len;
memcpy(*odata, *indata, len);
(*odata)[len]=0;
*odata+=((len+ALIGN_BYTES)/ALIGN_BYTES)*ALIGN_BYTES;
*indata+=len;
return ret;
}
else if ((cond=(type>=RPARAM_RSTR1 && type<=RPARAM_RSTR4)) || (type>=RPARAM_SHORT_RSTR_BASE && type<RPARAM_SHORT_RSTR_BASE+VSHORT_RSTR_CNT)){
size_t id;
if (cond){
len=type-RPARAM_RSTR1+1;
id=0;
memcpy(&id, *indata, len);
*indata+=len;
}
else
id=type-RPARAM_SHORT_RSTR_BASE;
return strings[id];
}
else if (type>=RPARAM_NUM1 && type<=RPARAM_NUM8){
ret=(binresult *)(*odata);
*odata+=sizeof(binresult);
ret->type=PARAM_NUM;
len=type-RPARAM_NUM1+1;
ret->num=0;
memcpy(&ret->num, *indata, len);
*indata+=len;
return ret;
}
else if (type>=RPARAM_SMALL_NUM_BASE && type<RPARAM_SMALL_NUM_BASE+VSMALL_NUMBER_NUM)
return (binresult *)&NUM_SMALL[type-RPARAM_SMALL_NUM_BASE];
else if (type==RPARAM_BTRUE)
return (binresult *)&BOOL_TRUE;
else if (type==RPARAM_BFALSE)
return (binresult *)&BOOL_FALSE;
else if (type==RPARAM_ARRAY){
binresult **arr;
psync_uint_t cnt, alloc;
ret=(binresult *)(*odata);
*odata+=sizeof(binresult);
ret->type=PARAM_ARRAY;
arr=NULL;
cnt=0;
alloc=128;
arr=(binresult **)psync_malloc(sizeof(binresult *)*alloc);
while (**indata!=RPARAM_END){
if (cnt==alloc){
alloc*=2;
arr=(binresult **)psync_realloc(arr, sizeof(binresult *)*alloc);
}
arr[cnt++]=do_parse_result(indata, odata, strings, nextstrid);
}
(*indata)++;
ret->length=cnt;
ret->array=(struct _binresult **)*odata;
*odata+=sizeof(struct _binresult *)*cnt;
memcpy(ret->array, arr, sizeof(struct _binresult *)*cnt);
psync_free(arr);
return ret;
}
else if (type==RPARAM_HASH){
struct _hashpair *arr;
psync_uint_t cnt, alloc;
binresult *key;
ret=(binresult *)(*odata);
*odata+=sizeof(binresult);
ret->type=PARAM_HASH;
arr=NULL;
cnt=0;
alloc=32;
arr=(struct _hashpair *)psync_malloc(sizeof(struct _hashpair)*alloc);
while (**indata!=RPARAM_END){
if (cnt==alloc){
alloc*=2;
arr=(struct _hashpair *)psync_realloc(arr, sizeof(struct _hashpair)*alloc);
}
key=do_parse_result(indata, odata, strings, nextstrid);
arr[cnt].value=do_parse_result(indata, odata, strings, nextstrid);
if (key->type==PARAM_STR){
arr[cnt].key=key->str;
cnt++;
}
}
(*indata)++;
ret->length=cnt;
ret->hash=(struct _hashpair *)*odata;
*odata+=sizeof(struct _hashpair)*cnt;
memcpy(ret->hash, arr, sizeof(struct _hashpair)*cnt);
psync_free(arr);
return ret;
}
else if (type==RPARAM_DATA){
ret=(binresult *)(*odata);
*odata+=sizeof(binresult);
ret->type=PARAM_DATA;
memcpy(&ret->num, *indata, 8);
*indata+=8;
return ret;
}
return NULL;
}
static binresult *parse_result(unsigned char *data, size_t datalen){
unsigned char *datac;
binresult **strings;
binresult *res;
ssize_t retlen;
size_t datalenc, strcnt;
datac=data;
datalenc=datalen;
strcnt=0;
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);
strcnt=0;
res=do_parse_result(&data, &datac, strings, &strcnt);
psync_free(strings);
return res;
}
binresult *get_result(psync_socket *sock){
unsigned char *data;
binresult *res;
uint32_t ressize;
if (unlikely_log(psync_socket_readall(sock, &ressize, sizeof(uint32_t)) != sizeof(uint32_t))) {
return NULL;
}
data=(unsigned char *)psync_malloc(ressize);
if (unlikely_log(psync_socket_readall(sock, data, ressize)!=ressize)){
psync_free(data);
return NULL;
}
res=parse_result(data, ressize);
psync_free(data);
return res;
}
binresult *get_result_thread(psync_socket *sock){
unsigned char *data;
binresult *res;
uint32_t ressize;
if (unlikely_log(psync_socket_readall_thread(sock, &ressize, sizeof(uint32_t))!=sizeof(uint32_t)))
return NULL;
data=(unsigned char *)psync_malloc(ressize);
if (unlikely_log(psync_socket_readall_thread(sock, data, ressize)!=ressize)){
psync_free(data);
return NULL;
}
res=parse_result(data, ressize);
psync_free(data);
return res;
}
void async_result_reader_init(async_result_reader *reader){
reader->state=0;
reader->bytesread=0;
reader->bytestoread=sizeof(uint32_t);
reader->data=(unsigned char *)&reader->respsize;
}
void async_result_reader_destroy(async_result_reader *reader){
if (reader->state==1)
psync_free(reader->data);
}
int get_result_async(psync_socket *sock, async_result_reader *reader){
int rd;
again:
rd=psync_socket_read_noblock(sock, reader->data+reader->bytesread, reader->bytestoread-reader->bytesread);
if (rd==PSYNC_SOCKET_WOULDBLOCK)
return ASYNC_RES_NEEDMORE;
else if (rd==PSYNC_SOCKET_ERROR || rd==0){
if (reader->state==1)
psync_free(reader->data);
async_result_reader_init(reader);
reader->result=NULL;
return ASYNC_RES_READY;
}
reader->bytesread+=rd;
if (reader->bytesread==reader->bytestoread){
if (reader->state==0){
reader->state=1;
reader->bytesread=0;
reader->bytestoread=reader->respsize;
reader->data=(unsigned char *)psync_malloc(reader->respsize);
goto again;
}
else{
assert(reader->state==1);
reader->result=parse_result(reader->data, reader->respsize);
psync_free(reader->data);
async_result_reader_init(reader);
return ASYNC_RES_READY;
}
}
else
return ASYNC_RES_NEEDMORE;
}
unsigned char *do_prepare_command(const char *command, size_t cmdlen, const binparam *params, size_t paramcnt, int64_t datalen, size_t additionalalloc, size_t *retlen){
size_t i, plen;
unsigned char *data, *sdata;
/* 2 byte len (not included), 1 byte cmdlen, 1 byte paramcnt, cmdlen bytes cmd*/
plen=cmdlen+2;
if (datalen!=-1)
plen+=sizeof(uint64_t);
for (i = 0; i < paramcnt; i++) {
if (params[i].paramtype == PARAM_STR) {
plen += params[i].paramnamelen + params[i].opts + 5; /* 1byte type+paramnamelen, nbytes paramnamelen, 4byte strlen, nbytes str */
}
else if (params[i].paramtype == PARAM_NUM) {
plen += params[i].paramnamelen + 1 + sizeof(uint64_t);
}
else if (params[i].paramtype == PARAM_BOOL) {
plen += params[i].paramnamelen + 2;
}
}
if (unlikely_log(plen>0xffff))
return NULL;
sdata=data=(unsigned char *)psync_malloc(plen+2+additionalalloc);
memcpy(data, &plen, 2);
data+=2;
if (datalen!=-1){
*data++=cmdlen|0x80;
memcpy(data, &datalen, sizeof(uint64_t));
data+=sizeof(uint64_t);
}
else
*data++=cmdlen;
memcpy(data, command, cmdlen);
data+=cmdlen;
*data++=paramcnt;
for (i=0; i<paramcnt; i++){
*data++=(params[i].paramtype<<6)+params[i].paramnamelen;
memcpy(data, params[i].paramname, params[i].paramnamelen);
data+=params[i].paramnamelen;
if (params[i].paramtype==PARAM_STR){
memcpy(data, &params[i].opts, 4);
data+=4;
memcpy(data, params[i].str, params[i].opts);
data+=params[i].opts;
}
else if (params[i].paramtype==PARAM_NUM){
memcpy(data, &params[i].num, sizeof(uint64_t));
data+=sizeof(uint64_t);
}
else if (params[i].paramtype==PARAM_BOOL)
*data++=params[i].num&1;
}
plen+=2;
*retlen=plen;
return sdata;
}
binresult *do_send_command(psync_socket *sock, const char *command, size_t cmdlen, const binparam *params, size_t paramcnt, int64_t datalen, int readres){
unsigned char *sdata;
size_t plen;
sdata=do_prepare_command(command, cmdlen, params, paramcnt, datalen, 0, &plen);
if (!sdata) {
return NULL;
}
if (readres&2){
if (unlikely_log(psync_socket_writeall_thread(sock, sdata, plen)!=plen)){
psync_free(sdata);
return NULL;
}
}
else{
if (unlikely_log(psync_socket_writeall(sock, sdata, plen)!=plen)){
psync_free(sdata);
return NULL;
}
}
psync_free(sdata);
if (readres&1){
return get_result(sock);
} else {
return PTR_OK;
}
}
void psync_do_dump_binresult(const binresult *res, const char *file, const char *function, int unsigned line){
uint32_t i;
psync_debug(file, function, line, D_NOTICE, "dumping existing fields of the hash");
for (i=0; i<res->length; i++)
switch (res->hash[i].value->type){
case PARAM_HASH:
psync_debug(file, function, line, D_NOTICE, " %s=[hash]", res->hash[i].key);
break;
case PARAM_ARRAY:
psync_debug(file, function, line, D_NOTICE, " %s=[array]", res->hash[i].key);
break;
case PARAM_DATA:
psync_debug(file, function, line, D_NOTICE, " %s=[data]", res->hash[i].key);
break;
case PARAM_NUM:
psync_debug(file, function, line, D_NOTICE, " %s=%llu", res->hash[i].key, (long long unsigned)res->hash[i].value->num);
break;
case PARAM_STR:
psync_debug(file, function, line, D_NOTICE, " %s=\"%s\"", res->hash[i].key, res->hash[i].value->str);
break;
case PARAM_BOOL:
psync_debug(file, function, line, D_NOTICE, " %s=%s", res->hash[i].key, res->hash[i].value->num?"true":"false");
break;
default:
psync_debug(file, function, line, D_NOTICE, " %s=!unknown type %u", res->hash[i].key, (unsigned)res->hash[i].value->type);
break;
}
}
const binresult *psync_do_find_result(const binresult *res, const char *name, uint32_t type, const char *file, const char *function, int unsigned line){
uint32_t i;
if (unlikely(!res || res->type!=PARAM_HASH)){
if (D_CRITICAL<=DEBUG_LEVEL){
const char *nm="NULL";
if (res){
nm=type_names[res->type];
}
psync_debug(file, function, line, D_CRITICAL, "expecting hash as first parameter, got %s", nm);
}
return empty_types[type];
}
for (i=0; i<res->length; i++)
if (!strcmp(res->hash[i].key, name)){
if (likely(res->hash[i].value->type==type))
return res->hash[i].value;
else{
if (D_CRITICAL<=DEBUG_LEVEL)
psync_debug(file, function, line, D_CRITICAL, "type error for key %s, expected %s got %s", name, type_names[type], type_names[res->hash[i].value->type]);
return empty_types[type];
}
}
if (D_CRITICAL<=DEBUG_LEVEL)
psync_debug(file, function, line, D_CRITICAL, "could not find key %s", name);
#if IS_DEBUG
psync_do_dump_binresult(res, file, function, line);
#endif
return empty_types[type];
}
const binresult *psync_do_check_result(const binresult *res, const char *name, uint32_t type, const char *file, const char *function, int unsigned line){
uint32_t i;
if (unlikely(!res || res->type!=PARAM_HASH)){
if (D_CRITICAL<=DEBUG_LEVEL){
const char *nm="NULL";
if (res)
nm=type_names[res->type];
psync_debug(file, function, line, D_CRITICAL, "expecting hash as first parameter, got %s", nm);
}
return NULL;
}
for (i=0; i<res->length; i++)
if (!strcmp(res->hash[i].key, name)){
if (likely(res->hash[i].value->type==type))
return res->hash[i].value;
else{
if (D_CRITICAL<=DEBUG_LEVEL)
psync_debug(file, function, line, D_CRITICAL, "type error for key %s, expected %s got %s", name, type_names[type], type_names[res->hash[i].value->type]);
return NULL;
}
}
return NULL;
}
const binresult *psync_do_get_result(const binresult *res, const char *name, const char *file, const char *function, int unsigned line){
uint32_t i;
if (unlikely(!res || res->type!=PARAM_HASH)){
if (D_CRITICAL<=DEBUG_LEVEL){
const char *nm="NULL";
if (res)
nm=type_names[res->type];
psync_debug(file, function, line, D_CRITICAL, "expecting hash as first parameter, got %s", nm);
}
return NULL;
}
for (i=0; i<res->length; i++)
if (!strcmp(res->hash[i].key, name))
return res->hash[i].value;
return NULL;
}
Reference in New Issue View Git Blame Copy Permalink