static void* ac_json_80211_ofdmcontrol_createmessageelement(struct json_object* jsonparent, uint16_t radioid) {
struct json_object* jsonitem;
struct capwap_80211_ofdmcontrol_element* ofdmcontrol;
ofdmcontrol = (struct capwap_80211_ofdmcontrol_element*)capwap_alloc(sizeof(struct capwap_80211_ofdmcontrol_element));
memset(ofdmcontrol, 0, sizeof(struct capwap_80211_ofdmcontrol_element));
ofdmcontrol->radioid = radioid;
/* */
jsonitem = compat_json_object_object_get(jsonparent, "CurrentChan");
if (jsonitem && (json_object_get_type(jsonitem) == json_type_int)) {
ofdmcontrol->currentchannel = (uint8_t)json_object_get_int(jsonitem);
} else {
capwap_free(ofdmcontrol);
return NULL;
}
jsonitem = compat_json_object_object_get(jsonparent, "BandSupport");
if (jsonitem && (json_object_get_type(jsonitem) == json_type_int)) {
ofdmcontrol->bandsupport = (uint8_t)json_object_get_int(jsonitem) & CAPWAP_OFDMCONTROL_BAND_MASK;
} else {
capwap_free(ofdmcontrol);
return NULL;
}
jsonitem = compat_json_object_object_get(jsonparent, "TIThreshold");
if (jsonitem && (json_object_get_type(jsonitem) == json_type_int)) {
ofdmcontrol->tithreshold = (uint32_t)json_object_get_int(jsonitem);
} else {
capwap_free(ofdmcontrol);
return NULL;
}
return ofdmcontrol;
}
static void* ac_json_80211_wtpradiofailalarm_createmessageelement(struct json_object* jsonparent, uint16_t radioid) {
struct json_object* jsonitem;
struct capwap_80211_wtpradiofailalarm_element* wtpradiofailalarm;
wtpradiofailalarm = (struct capwap_80211_wtpradiofailalarm_element*)capwap_alloc(sizeof(struct capwap_80211_wtpradiofailalarm_element));
memset(wtpradiofailalarm, 0, sizeof(struct capwap_80211_wtpradiofailalarm_element));
wtpradiofailalarm->radioid = radioid;
/* */
jsonitem = compat_json_object_object_get(jsonparent, "Type");
if (jsonitem && (json_object_get_type(jsonitem) == json_type_int)) {
wtpradiofailalarm->type = (uint8_t)json_object_get_int(jsonitem);
} else {
capwap_free(wtpradiofailalarm);
return NULL;
}
/* */
jsonitem = compat_json_object_object_get(jsonparent, "Status");
if (jsonitem && (json_object_get_type(jsonitem) == json_type_int)) {
wtpradiofailalarm->status = (uint8_t)json_object_get_int(jsonitem);
} else {
capwap_free(wtpradiofailalarm);
return NULL;
}
return wtpradiofailalarm;
}
static int init(const char *config_file,const char *orderid_file)
{
int fd_order;
request = ghttp_request_new();
my_object = json_object_from_file(config_file);
machine_id = json_object_get_int(json_object_object_get(my_object,MACHINE_ID));
info_version = json_object_get_int(json_object_object_get(my_object,INFO_VERSION));
format_qrcode = json_object_get_string(json_object_object_get(my_object,ENCODE_FORMAT));
fd_order=open(orderid_file,O_RDWR);
if(fd_order==-1)
{
int order_id=0;
fd_order=open(orderid_file,O_RDWR|O_CREAT,0666);
write(fd_order,(void*)&order_id,sizeof(unsigned int));
lseek(fd_order,0,SEEK_SET);
}
p_order_id=(unsigned int*)mmap(NULL,sizeof(unsigned int),PROT_READ|PROT_WRITE,MAP_SHARED,fd_order,0);
if(p_order_id==-1)
return -3;
ghttp_set_uri(request, json_object_get_string(json_object_object_get(my_object,HOST)));
ghttp_prepare(request);
ghttp_set_sync(request, ghttp_async);
ghttp_set_type(request, ghttp_type_post);
ghttp_set_header(request, http_hdr_Connection, "keep-alive");
http_request(REQ_REGISTER);
while(http_response_process((void*)config_file)==-1);
ghttp_flush_response_buffer(request);
return 0;
}
static int http_response_process(void * arg)
{
struct json_object *resp;
if(ghttp_process(request)==ghttp_done)
{
resp=json_tokener_parse(ghttp_get_body(request));
resp_ret.type=json_object_get_int(json_object_object_get(resp,RESP_TYPE));
resp_ret.result=json_object_get_int(json_object_object_get(resp,RESP_RESULT));
if(resp_ret.type==REQ_REGISTER)
{
json_object_object_del(resp, RESP_TYPE);
json_object_to_file((char *)arg,resp);
}
else
{
if((resp_ret.type==REQ_SUBMIT)&&(!resp_ret.result))
{
sprintf(qrcode_buf,format_qrcode,machine_id,*p_order_id,info_version);
pid_t pid=vfork();
if(!pid)
execlp("qrencode","qrencode","-s 6","-m 2","-lH","-oqrcode.png",qrcode_buf,0);
else
wait(NULL);
}
}
json_object_put(resp);
return 0;
}
else
return -1;
}
static int process_msg(void *msg,int len)
{
char *body = (char *)msg + HEADER_LEN;
json_object *jmsg = json_tokener_parse(body);
if(!jmsg)
return -1;
json_object *jsccmd = json_util_get(jmsg,"cmd");
if(!jsccmd)
return -1;
int sccmd = json_object_get_int(jsccmd);
json_object *jcmcmd = json_util_get(jmsg,"msg.cmd");
int cmcmd = json_object_get_int(jcmcmd);
switch(sccmd){
case MSGID_RESPONSE_EXECPROC:
switch (cmcmd){
case MSGID_REQUEST_NEWACCOUNT:
sc_logic_createaccount(jmsg);
break;
case MSGID_REQUEST_LOGIN:
sc_logic_login(jmsg);
break;
}
break;
}
json_object_put(jmsg);
return 0;
}
telebot_error_e telebot_parser_get_audio(struct json_object *obj,
telebot_audio_t *audio)
{
if (obj == NULL)
return TELEBOT_ERROR_INVALID_PARAMETER;
if (audio == NULL)
return TELEBOT_ERROR_INVALID_PARAMETER;
memset(audio, 0, sizeof(telebot_audio_t));
struct json_object *file_id;
if (json_object_object_get_ex(obj, "file_id", &file_id)) {
snprintf(audio->file_id, TELEBOT_FILE_ID_SIZE, "%s",
json_object_get_string(file_id));
json_object_put(file_id);
}
else {
ERR("Object is not audio type, file_id not found");
return TELEBOT_ERROR_OPERATION_FAILED;
}
struct json_object *duration;
if (json_object_object_get_ex(obj, "duration", &duration)){
audio->duration = json_object_get_int(duration);
json_object_put(duration);
}
else {
ERR("Object is not audio type, duration not found");
return TELEBOT_ERROR_OPERATION_FAILED;
}
struct json_object *performer;
if (json_object_object_get_ex(obj, "performer", &performer)) {
snprintf(audio->performer, TELEBOT_AUDIO_PERFORMER_SIZE, "%s",
json_object_get_string(performer));
json_object_put(performer);
}
struct json_object *title;
if (json_object_object_get_ex(obj, "title", &title)) {
snprintf(audio->title, TELEBOT_AUDIO_TITLE_SIZE, "%s",
json_object_get_string(title));
json_object_put(title);
}
struct json_object *mime_type;
if (json_object_object_get_ex(obj, "mime_type", &mime_type)) {
snprintf(audio->mime_type, TELEBOT_AUDIO_MIME_TYPE_SIZE, "%s",
json_object_get_string(mime_type));
json_object_put(mime_type);
}
struct json_object *file_size;
if (json_object_object_get_ex(obj, "file_size", &file_size)) {
audio->file_size = json_object_get_int(file_size);
json_object_put(file_size);
}
return TELEBOT_ERROR_NONE;
}
static void pretty_print_output(json_object *o) {
json_object *name, *rect, *focused, *active, *ws, *scale;
json_object_object_get_ex(o, "name", &name);
json_object_object_get_ex(o, "rect", &rect);
json_object_object_get_ex(o, "focused", &focused);
json_object_object_get_ex(o, "active", &active);
json_object_object_get_ex(o, "current_workspace", &ws);
json_object_object_get_ex(o, "scale", &scale);
json_object *x, *y, *width, *height;
json_object_object_get_ex(rect, "x", &x);
json_object_object_get_ex(rect, "y", &y);
json_object_object_get_ex(rect, "width", &width);
json_object_object_get_ex(rect, "height", &height);
printf(
"Output %s%s%s\n"
" Geometry: %dx%d @ %d,%d\n"
" Scale factor: %dx\n"
" Workspace: %s\n\n",
json_object_get_string(name),
json_object_get_boolean(focused) ? " (focused)" : "",
!json_object_get_boolean(active) ? " (inactive)" : "",
json_object_get_int(width), json_object_get_int(height),
json_object_get_int(x), json_object_get_int(y),
json_object_get_int(scale),
json_object_get_string(ws)
);
}
bool Bitmaszyna::lasttrades(string market)
{
struct json_object *json,*jtmp,*jtmp2;
struct array_list *arr;
int i;
curl_mutex.lock();
trades.clear();
if (getTickerData(market+"/transactions.json",&json))
{
arr=json_object_get_array(json);
for(i=0;i<arr->length;i++)
{
Offer offer;
jtmp=(struct json_object *)array_list_get_idx(arr,i);
json_object_object_get_ex(jtmp,"date",&jtmp2);
offer.time=json_object_get_int64(jtmp2);
json_object_object_get_ex(jtmp,"price",&jtmp2);
offer.price=json_object_get_double(jtmp2);
json_object_object_get_ex(jtmp,"amount",&jtmp2);
offer.amount=json_object_get_double(jtmp2);
json_object_object_get_ex(jtmp,"type",&jtmp2);
offer.type=json_object_get_int(jtmp2);
json_object_object_get_ex(jtmp,"type",&jtmp2);
offer.id=json_object_get_int(jtmp2);
trades.push_back(offer);
}
json_object_put(json);
curl_mutex.unlock();
return(true);
}
curl_mutex.unlock();
return(false);
}
static int cli_lacp_getpartnerinterface(void *c_sys, int argc, cli_args_t *args)
{
short unsigned int *pusportpriority;
unsigned char *pucstate;
short unsigned int *puskey;
unsigned char *pucsystemid;
long unsigned int *pulmaclen;
int port = port_to_num(args[0].value);
#if 0
LACP_GetAggPortPartnerPortPriority(port, pusportpriority);
usleep(10000);
LACP_GetAggPortPartnerState(port, pucstate);
usleep(10000);
LACP_GetAggPortPartnerOperKey(port, puskey);
usleep(10000);
LACP_GetAggPortPartnerSystemId(port, pucsystemid, pulmaclen);
return 0;
#endif
#if 1
processFlag_dislacp = 1;
LACP_GetAggPortPartnerPortPriority(port, pusportpriority);
struct json_object *new_obj1 = NULL;
new_obj1 = json_tokener_parse(msg_lacp->msg);
struct json_object *obj1 = json_object_object_get(new_obj1, "PortPartnerPortPriority");
printf(" PortPartnerPortPriority :%d\n", json_object_get_int(obj1));
json_object_put(obj1);
json_object_put(new_obj1);
processFlag_dislacp = 1;
LACP_GetAggPortPartnerState(port, pucstate);
struct json_object *new_obj2 = NULL;
new_obj2 = json_tokener_parse(msg_lacp->msg);
struct json_object *obj2 = json_object_object_get(new_obj2, "PortPartnerState");
printf(" PortPartnerState :%d\n", json_object_get_int(obj2));
json_object_put(obj2);
json_object_put(new_obj2);
processFlag_dislacp = 1;
LACP_GetAggPortPartnerOperKey(port, puskey);
struct json_object *new_obj3 = NULL;
new_obj3 = json_tokener_parse(msg_lacp->msg);
struct json_object *obj3 = json_object_object_get(new_obj3, "PortPartnerOperKey");
printf(" PortPartnerOperKey :%d\n", json_object_get_int(obj3));
json_object_put(obj3);
json_object_put(new_obj3);
processFlag_dislacp = 1;
LACP_GetAggPortPartnerSystemId(port, pucsystemid, pulmaclen);
struct json_object *new_obj4 = NULL;
new_obj4 = json_tokener_parse(msg_lacp->msg);
struct json_object *obj4 = json_object_object_get(new_obj4, "PortPartnerSystemId");
printf(" PortPartnerSystemId :%d\n", json_object_get_int(obj4));
json_object_put(obj4);
json_object_put(new_obj4);
processFlag_dislacp = 0;
return 0;
#endif
}
OSStatus ConfigIncommingJsonMessage( const char *input, mico_Context_t * const inContext )
{
OSStatus err = kNoErr;
json_object *new_obj;
config_delegate_log_trace();
new_obj = json_tokener_parse(input);
require_action(new_obj, exit, err = kUnknownErr);
config_delegate_log("Recv config object=%s", json_object_to_json_string(new_obj));
mico_rtos_lock_mutex(&inContext->flashContentInRam_mutex);
json_object_object_foreach(new_obj, key, val) {
if(!strcmp(key, "Device Name")){
strncpy(inContext->flashContentInRam.micoSystemConfig.name, json_object_get_string(val), maxNameLen);
}else if(!strcmp(key, "RF power save")){
inContext->flashContentInRam.micoSystemConfig.rfPowerSaveEnable = json_object_get_boolean(val);
}else if(!strcmp(key, "MCU power save")){
inContext->flashContentInRam.micoSystemConfig.mcuPowerSaveEnable = json_object_get_boolean(val);
}else if(!strcmp(key, "Bonjour")){
inContext->flashContentInRam.micoSystemConfig.bonjourEnable = json_object_get_boolean(val);
}else if(!strcmp(key, "Wi-Fi")){
strncpy(inContext->flashContentInRam.micoSystemConfig.ssid, json_object_get_string(val), maxSsidLen);
inContext->flashContentInRam.micoSystemConfig.channel = 0;
memset(inContext->flashContentInRam.micoSystemConfig.bssid, 0x0, 6);
inContext->flashContentInRam.micoSystemConfig.security = SECURITY_TYPE_AUTO;
memcpy(inContext->flashContentInRam.micoSystemConfig.key, inContext->flashContentInRam.micoSystemConfig.user_key, maxKeyLen);
inContext->flashContentInRam.micoSystemConfig.keyLength = inContext->flashContentInRam.micoSystemConfig.user_keyLength;
}else if(!strcmp(key, "Password")){
inContext->flashContentInRam.micoSystemConfig.security = SECURITY_TYPE_AUTO;
strncpy(inContext->flashContentInRam.micoSystemConfig.key, json_object_get_string(val), maxKeyLen);
strncpy(inContext->flashContentInRam.micoSystemConfig.user_key, json_object_get_string(val), maxKeyLen);
inContext->flashContentInRam.micoSystemConfig.keyLength = strlen(inContext->flashContentInRam.micoSystemConfig.key);
inContext->flashContentInRam.micoSystemConfig.user_keyLength = strlen(inContext->flashContentInRam.micoSystemConfig.key);
}else if(!strcmp(key, "DHCP")){
inContext->flashContentInRam.micoSystemConfig.dhcpEnable = json_object_get_boolean(val);
}else if(!strcmp(key, "IP address")){
strncpy(inContext->flashContentInRam.micoSystemConfig.localIp, json_object_get_string(val), maxIpLen);
}else if(!strcmp(key, "Net Mask")){
strncpy(inContext->flashContentInRam.micoSystemConfig.netMask, json_object_get_string(val), maxIpLen);
}else if(!strcmp(key, "Gateway")){
strncpy(inContext->flashContentInRam.micoSystemConfig.gateWay, json_object_get_string(val), maxIpLen);
}else if(!strcmp(key, "DNS Server")){
strncpy(inContext->flashContentInRam.micoSystemConfig.dnsServer, json_object_get_string(val), maxIpLen);
}else if(!strcmp(key, "Connect SPP Server")){
inContext->flashContentInRam.appConfig.remoteServerEnable = json_object_get_boolean(val);
}else if(!strcmp(key, "SPP Server")){
strncpy(inContext->flashContentInRam.appConfig.remoteServerDomain, json_object_get_string(val), 64);
}else if(!strcmp(key, "SPP Server Port")){
inContext->flashContentInRam.appConfig.remoteServerPort = json_object_get_int(val);
}else if(!strcmp(key, "Baurdrate")){
inContext->flashContentInRam.appConfig.USART_BaudRate = json_object_get_int(val);
}
}
json_object_put(new_obj);
mico_rtos_unlock_mutex(&inContext->flashContentInRam_mutex);
exit:
return err;
}
/*************
* Check for time limit.
* Returns number of seconds remaining on schedule, 0 if none,
* -1 if not found
**************/
time_t get_time_limit(struct json_object *json_obj, char *key) {
int bcount, tcount, i, j;
time_t tb_begin, tb_end, now_ticks, remain = NOTFOUND;
int mult = 60/PERIOD;
struct json_object *profiles;
if(json_obj == NULL)
return NOTFOUND;
time_t t_time = time(NULL);
struct tm *now = localtime(&t_time);
now_ticks = now_secs(now);
profiles = json_object_object_get(json_obj, "profiles");
if(profiles == NULL) {
return NOTFOUND;
}
if(json_object_is_type(profiles, json_type_array)) {
bcount = json_object_array_length(profiles);
for(i=0; i<bcount; i++) {
struct json_object *profile = json_object_array_get_idx(profiles, i);
if(profile == NULL)
break;
char *id = get_field_as_string(profile, "id");
if(id == NULL)
break;
if(strncasecmp(key, id, strlen(key)) == 0) {
log_msg(LOG_DEBUG, "Found profile for: %s\n", id);
remain = EXPIRED;
struct json_object *tb = json_object_object_get(profile, "tb");
if(tb == NULL)
break;
struct json_object *today = json_object_array_get_idx(tb, now->tm_wday);
if(today == NULL)
break;
tcount = json_object_array_length(today) - 1;
for(j=tcount; j>=0; j--) {
struct json_object *hblock = json_object_array_get_idx(today, j);
if(hblock == NULL)
break;
tb_begin = json_object_get_int(json_object_array_get_idx(hblock, 0)) * 60 * 60/mult;
tb_end = tb_begin + json_object_get_int(json_object_array_get_idx(hblock, 1)) * 60 * 60/mult;
if((now_ticks > tb_begin) && (now_ticks < tb_end)) {
remain = tb_end - now_ticks;
log_msg(LOG_DEBUG, "Found time block for %s, %d, %d, time left: %d\n", id, tb_begin, tb_end, remain);
break;
}
}
free(id);
}
}
}
json_object_put(profiles);
return remain;
}
telebot_error_e telebot_parser_get_sticker(struct json_object *obj,
telebot_sticker_t *sticker)
{
if (obj == NULL)
return TELEBOT_ERROR_INVALID_PARAMETER;
if (sticker == NULL)
return TELEBOT_ERROR_INVALID_PARAMETER;
memset(sticker, 0, sizeof(telebot_sticker_t));
struct json_object *file_id;
if (json_object_object_get_ex(obj, "file_id", &file_id)) {
snprintf(sticker->file_id, TELEBOT_FILE_ID_SIZE, "%s",
json_object_get_string(file_id));
json_object_put(file_id);
}
else {
ERR("Object is not sticker type, file_id not found");
return TELEBOT_ERROR_OPERATION_FAILED;
}
struct json_object *width;
if (json_object_object_get_ex(obj, "width", &width)){
sticker->width = json_object_get_int(width);
json_object_put(width);
}
else {
ERR("Object is not sticker type, width not found");
return TELEBOT_ERROR_OPERATION_FAILED;
}
struct json_object *height;
if (json_object_object_get_ex(obj, "height", &height)){
sticker->height = json_object_get_int(height);
json_object_put(height);
}
else {
ERR("Object is not sticker type, height not found");
return TELEBOT_ERROR_OPERATION_FAILED;
}
struct json_object *thumb;
if (json_object_object_get_ex(obj, "thumb", &thumb)) {
if (telebot_parser_get_photo(thumb, &(sticker->thumb)) !=
TELEBOT_ERROR_NONE)
ERR("Failed to get <thumb> from sticker object");
json_object_put(thumb);
}
struct json_object *file_size;
if (json_object_object_get_ex(obj, "file_size", &file_size)) {
sticker->file_size = json_object_get_int(file_size);
json_object_put(file_size);
}
return TELEBOT_ERROR_NONE;
}
int pv_get_json (struct sip_msg* msg, pv_param_t* pvp, pv_value_t* val)
{
pv_json_t * var ;
json_t * obj;
json_name * id = (json_name *) pvp->pvn.u.dname;
UNUSED(id);
if( expand_tag_list( msg, ((json_name *)pvp->pvn.u.dname)->tags ) < 0)
{
LM_ERR("Cannot expand variables in path\n");
return pv_get_null( msg, pvp, val);
}
var = get_pv_json(pvp);
if( var == NULL )
{
/* this is not an error - we simply came across a json spec
* pointing a json var which was never set/init */
LM_DBG("Variable named:%.*s not found\n",id->name.len,id->name.s);
return pv_get_null( msg, pvp, val);
}
obj = get_object(var, pvp, NULL, 0);
memset(val, 0, sizeof(pv_value_t));
if( obj == NULL )
return pv_get_null( msg, pvp, val);
if( json_object_is_type(obj, json_type_int) )
{
val->rs.s = sint2str(json_object_get_int(obj), &val->rs.len);
val->ri = json_object_get_int(obj);;
val->flags |= PV_VAL_INT|PV_TYPE_INT|PV_VAL_STR;
}
else if( json_object_is_type(obj, json_type_string))
{
val->flags = PV_VAL_STR;
val->rs.s = (char*)json_object_get_string( obj );
#if JSON_LIB_VERSION >= 10
val->rs.len = json_object_get_string_len( obj );
#else
val->rs.len = strlen(val->rs.s);
#endif
} else {
val->flags = PV_VAL_STR;
val->rs.s = (char*)json_object_to_json_string( obj );
val->rs.len = strlen(val->rs.s);
}
return 0;
}
int kpfs_node_get_root_path()
{
char *response = NULL;
json_object *jobj = NULL;
off_t quota_used = 0;
long quota_total = 0;
off_t max_file_size = 0;
int len = 512;
char *user_name = NULL;
char *user_id = NULL;
char *p = NULL;
response = (char *)kpfs_api_account_info();
KPFS_FILE_LOG("access [/] %s:\n", response);
p = strstr(response, KPFS_ID_QUOTA_TOTAL);
if (p) {
sscanf(p, KPFS_ID_QUOTA_TOTAL "\": " CURL_FORMAT_OFF_T ",", "a_total);
}
jobj = json_tokener_parse(response);
if (NULL == jobj || is_error(jobj)) {
KPFS_FILE_LOG("%s:%d, json_tokener_parse return error.\n", __FUNCTION__, __LINE__);
KPFS_SAFE_FREE(response);
return -1;
}
json_object_object_foreach(jobj, key, val) {
if (!strcmp(key, KPFS_ID_QUOTA_USED)) {
quota_used = (off_t) json_object_get_double(val);;
} else if (!strcmp(key, KPFS_ID_MAX_FILE_SIZE)) {
if (json_type_int == json_object_get_type(val)) {
max_file_size = (off_t) json_object_get_int(val);
}
} else if (!strcmp(key, KPFS_ID_USER_ID)) {
if (json_type_int == json_object_get_type(val)) {
user_id = calloc(len, 1);
snprintf(user_id, len, "%d", json_object_get_int(val));
}
} else if (!strcmp(key, KPFS_ID_USER_NAME)) {
if (json_type_string == json_object_get_type(val)) {
user_name = calloc(len, 1);
snprintf(user_name, len, "%s", json_object_get_string(val));
}
}
}
json_object_put(jobj);
KPFS_SAFE_FREE(response);
kpfs_util_account_info_store(user_name, user_id, quota_total, quota_used, max_file_size);
if (NULL == kpfs_node_root_create(user_id, user_name, quota_used))
return -1;
return 0;
}
void ttrss_api::fetch_feeds_per_category(struct json_object * cat, std::vector<tagged_feedurl>& feeds) {
const char * cat_name = NULL;
struct json_object * cat_title_obj = NULL;
int cat_id;
if (cat) {
struct json_object * cat_id_obj = json_object_object_get(cat, "id");
cat_id = json_object_get_int(cat_id_obj);
// ignore special categories, for now
if(cat_id < 0)
return;
cat_title_obj = json_object_object_get(cat, "title");
cat_name = json_object_get_string(cat_title_obj);
LOG(LOG_DEBUG, "ttrss_api::fetch_feeds_per_category: id = %d title = %s", cat_id, cat_name);
}
else {
// As uncategorized is a category itself (id = 0) and the default value
// for a getFeeds is id = 0, the feeds in uncategorized will appear twice
return;
}
std::map<std::string, std::string> args;
if (cat)
args["cat_id"] = utils::to_string<int>(cat_id);
struct json_object * feed_list_obj = run_op("getFeeds", args);
if (!feed_list_obj)
return;
struct array_list * feed_list = json_object_get_array(feed_list_obj);
int feed_list_size = array_list_length(feed_list);
for (int j=0;j<feed_list_size;j++) {
struct json_object * feed = (struct json_object *)array_list_get_idx(feed_list, j);
int feed_id = json_object_get_int(json_object_object_get(feed, "id"));
const char * feed_title = json_object_get_string(json_object_object_get(feed, "title"));
const char * feed_url = json_object_get_string(json_object_object_get(feed, "feed_url"));
std::vector<std::string> tags;
tags.push_back(std::string("~") + feed_title);
if (cat_name) {
tags.push_back(cat_name);
}
feeds.push_back(tagged_feedurl(utils::strprintf("%s#%d", feed_url, feed_id), tags));
// TODO: cache feed_id -> feed_url (or feed_url -> feed_id ?)
}
json_object_put(feed_list_obj);
}
gboolean mmsvc_core_msg_json_deserialize_len(char *key, char* buf, int *parse_len, void *data, mused_msg_parse_err_e *err)
{
int type;
json_object *val, *jobj;
g_return_val_if_fail(key != NULL, FALSE);
g_return_val_if_fail(buf != NULL, FALSE);
g_return_val_if_fail(data != NULL, FALSE);
g_return_val_if_fail(parse_len != NULL, FALSE);
jobj = _mmsvc_core_msg_json_tokener_parse_len(buf, parse_len, err);
g_return_val_if_fail(jobj != NULL, FALSE);
val = _mmsvc_core_msg_json_find_obj(jobj, key);
if (!val) {
LOGE("\"%s\" key is not founded", key);
return FALSE;
}
type = json_object_get_type(val);
switch (type) {
case json_type_null:
LOGD("json_type_null\n");
break;
case json_type_boolean:
LOGD("json_type_boolean (%s) value: %d", key, json_object_get_boolean(val));
break;
case json_type_double:
*(double *)data = json_object_get_double(val);
LOGD("json_type_double (%s) value: %p", key, (double *)data);
break;
case json_type_int:
*(int *)data = json_object_get_int(val);
LOGD("json_type_int (%s) value: %p", key, (int *)data);
break;
case json_type_object:
LOGD("json_type_object (%s) value: %d", key, json_object_get_object(val));
break;
case json_type_string:
strncpy((char *)data, json_object_get_string(val), strlen(json_object_get_string(val)));
LOGD("json_type_string (%s) value: %s", key, (char *)data);
break;
case json_type_array:
LOGD("json_type_array (%s)", key);
int i, len;
int *int_data = (int *)data;
len = json_object_array_length(val);
for (i = 0; i < len; i++)
int_data[i] = json_object_get_int(json_object_array_get_idx(val, i));
break;
}
json_object_put(jobj);
return TRUE;
}
/* Parses the given JSON String
* Returns
* - 0 on success and all the arguments will be pointing to parsed data
* - 1 on failure and garbage elsewhere
*/
int parse_json(const char* json_str, int * arg_c, int *live, char * user, char * group, char * command) {
json_object * jobj;
json_object *j_tmp; /* tmp json object to store intermediate values */
jobj = json_tokener_parse(json_str);
/* if json parsing has failed */
if (jobj == NULL) {
json_object_put(jobj);
_LOGGER("(ERROR) Json Parsing Failed for JSON String [%s]", json_str);
return 1;
}
/* get command */
j_tmp = json_object_object_get(jobj, "command");
if (j_tmp == NULL) {
json_object_put(jobj);
return 1;
}
strcpy(command, json_object_get_string(j_tmp));
/* get user */
j_tmp = json_object_object_get(jobj, "runas_user");
if (j_tmp == NULL) {
json_object_put(jobj);
return 1;
}
strcpy(user, json_object_get_string(j_tmp));
/* get group, if group is missing, it is ok */
j_tmp = json_object_object_get(jobj, "runas_group");
if (j_tmp == NULL) {
group[0] = '\0';
} else {
strcpy(group, json_object_get_string(j_tmp));
}
/* get argc */
j_tmp = json_object_object_get(jobj, "argc");
if (j_tmp == NULL) {
json_object_put(jobj);
return 1;
}
*arg_c = json_object_get_int(j_tmp);
/* get live, if set take it */
j_tmp = json_object_object_get(jobj, "live");
if (j_tmp != NULL)
*live = json_object_get_int(j_tmp);
json_object_put(jobj);
return 0;
}
static int
parse_geojson_coord(json_object *poObj, bool *hasz, POINTARRAY *pa)
{
POINT4D pt;
int iType = 0;
POSTGIS_DEBUGF(3, "parse_geojson_coord called for object %s.", json_object_to_json_string( poObj ) );
if( json_type_array == json_object_get_type( poObj ) )
{
json_object* poObjCoord = NULL;
const int nSize = json_object_array_length( poObj );
POSTGIS_DEBUGF(3, "parse_geojson_coord called for array size %d.", nSize );
// Read X coordinate
poObjCoord = json_object_array_get_idx( poObj, 0 );
iType = json_object_get_type(poObjCoord);
if (iType == json_type_double)
pt.x = json_object_get_double( poObjCoord );
else
pt.x = json_object_get_int( poObjCoord );
POSTGIS_DEBUGF(3, "parse_geojson_coord pt.x = %f.", pt.x );
// Read Y coordiante
poObjCoord = json_object_array_get_idx( poObj, 1 );
if (iType == json_type_double)
pt.y = json_object_get_double( poObjCoord );
else
pt.y = json_object_get_int( poObjCoord );
POSTGIS_DEBUGF(3, "parse_geojson_coord pt.y = %f.", pt.y );
*hasz = false;
if( nSize == 3 )
{
// Read Z coordiante
poObjCoord = json_object_array_get_idx( poObj, 2 );
if (iType == 3)
pt.z = json_object_get_double( poObjCoord );
else
pt.z = json_object_get_int( poObjCoord );
POSTGIS_DEBUGF(3, "parse_geojson_coord pt.z = %f.", pt.z );
*hasz = true;
}
}
return ptarray_append_point(pa, &pt, LW_FALSE);
}
bool EASPolicy::fromJSON(json_object* policy)
{
json_object *prop = 0, *key = 0;
prop = json_object_object_get(policy, "password");
if (prop && !is_error(prop)) {
key = json_object_object_get(prop, "enabled");
m_passwordRequired = json_object_get_boolean(key);
key = json_object_object_get(prop, "minLength");
if (key)
m_minLength = json_object_get_int(key);
else
m_minLength = 1;
key = json_object_object_get(prop, "maxRetries");
if (key)
m_maxRetries = json_object_get_int(key);
else
m_maxRetries = 1;
key = json_object_object_get(prop, "alphaNumeric");
m_isAlphaNumeric = json_object_get_boolean(key);
}
else {
m_passwordRequired = false;
m_minLength = 1;
m_maxRetries = 1;
m_isAlphaNumeric = false;
}
key = json_object_object_get(policy, "inactivityInSeconds");
if (key) {
m_inactivityInSeconds = json_object_get_int(key);
}
else {
m_inactivityInSeconds = 0;
}
key = json_object_object_get(policy, "id");
if (key) {
char* str = json_object_get_string(key);
m_id = (str != NULL ? str : "");
}
return !m_id.empty();
}
telebot_error_e telebot_parser_get_photo(struct json_object *obj,
telebot_photo_t *photo)
{
if (obj == NULL)
return TELEBOT_ERROR_INVALID_PARAMETER;
if (photo == NULL)
return TELEBOT_ERROR_INVALID_PARAMETER;
memset(photo, 0, sizeof(telebot_photo_t));
struct json_object *file_id;
if (json_object_object_get_ex(obj, "file_id", &file_id)) {
snprintf(photo->file_id, TELEBOT_FILE_ID_SIZE, "%s",
json_object_get_string(file_id));
json_object_put(file_id);
}
else {
ERR("Object is not photo size type, file_id not found");
return TELEBOT_ERROR_OPERATION_FAILED;
}
struct json_object *width;
if (json_object_object_get_ex(obj, "width", &width)){
photo->width = json_object_get_int(width);
json_object_put(width);
}
else {
ERR("Object is not photo size type, width not found");
return TELEBOT_ERROR_OPERATION_FAILED;
}
struct json_object *height;
if (json_object_object_get_ex(obj, "height", &height)){
photo->height = json_object_get_int(height);
json_object_put(height);
}
else {
ERR("Object is not photo size type, height not found");
return TELEBOT_ERROR_OPERATION_FAILED;
}
struct json_object *file_size;
if (json_object_object_get_ex(obj, "file_size", &file_size)) {
photo->file_size = json_object_get_int(file_size);
json_object_put(file_size);
}
return TELEBOT_ERROR_NONE;
}
/* Get punch details - private helper */
void get_json_punch(struct s_punch *punch, json_object *jp){
enum json_type type;
json_object_object_foreach(jp, keyp, valp) {
type = json_object_get_type(valp);
if(strcmp(keyp, "time") == 0 && type == json_type_int){
punch->time = json_object_get_int(valp);
}
if(strcmp(keyp, "tst") == 0 && type == json_type_int){
punch->timestat = json_object_get_int(valp);
}
if(strcmp(keyp, "cn") == 0 && type == json_type_int){
punch->cn = json_object_get_int(valp);
}
}
static void ParseLineString(OGRLineString* poLS, json_object* poRing,
json_object* poArcsDB, ScalingParams* psParams)
{
int nArcsDB = json_object_array_length(poArcsDB);
int nArcsRing = json_object_array_length(poRing);
for(int j=0; j<nArcsRing; j++)
{
json_object* poArcId = json_object_array_get_idx(poRing, j);
if( poArcId != NULL && json_type_int == json_object_get_type(poArcId) )
{
int nArcId = json_object_get_int(poArcId);
int bReverse = FALSE;
if( nArcId < 0 )
{
nArcId = - nArcId - 1;
bReverse = TRUE;
}
if( nArcId < nArcsDB )
{
ParseArc(poLS, poArcsDB, nArcId, bReverse, psParams);
}
}
}
}
static void get_field(json_object *e, const char *path, void *dest)
{
json_object *fld = NULL;
enum json_type type;
fld = json_object_object_get(e, path);
if (fld) {
type = json_object_get_type(fld);
switch (type) {
case json_type_boolean:
*(unsigned int *)dest = json_object_get_boolean(fld);
break;
case json_type_int:
*(unsigned int *)dest = json_object_get_int(fld);
break;
case json_type_string:
strcpy(dest, json_object_get_string(fld));
break;
case json_type_double:
*(double *)dest = json_object_get_double(fld);
break;
default:
break;
}
}
}
/*
* Obtain the datanode REST servers host/port data
*/
static List*
parse_datanodes_response(List *rest_srvrs, StringInfo rest_buf)
{
struct json_object *whole = json_tokener_parse(rest_buf->data);
if ((whole == NULL) || is_error(whole))
{
elog(ERROR, "Failed to parse datanode list from PXF");
}
struct json_object *nodes = json_object_object_get(whole, "regions");
int length = json_object_array_length(nodes);
/* obtain host/port data for the REST server running on each HDFS data node */
for (int i = 0; i < length; i++)
{
PxfServer* srv = (PxfServer*)palloc(sizeof(PxfServer));
struct json_object *js_node = json_object_array_get_idx(nodes, i);
struct json_object *js_host = json_object_object_get(js_node, "host");
srv->host = pstrdup(json_object_get_string(js_host));
struct json_object *js_port = json_object_object_get(js_node, "port");
srv->port = json_object_get_int(js_port);
rest_srvrs = lappend(rest_srvrs, srv);
}
return rest_srvrs;
}
void _HKCreateWritePerCharacteristic(struct _hapAccessory_t inHapObject[], HK_Char_ID_t id, json_object *value_obj, bool moreComing, mico_Context_t * const inContext)
{
struct _hapCharacteristic_t pCharacteristic;
value_union value;
if(id.serviceID == 0 || id.characteristicID == 0)
return;
pCharacteristic = ((inHapObject[id.aid-1]).services[id.serviceID-1]).characteristic[id.characteristicID-1];
if( pCharacteristic.secureWrite == true && id.serviceID && id.characteristicID ){
switch(pCharacteristic.valueType ){
case ValueType_bool:
value.boolValue = json_object_get_boolean(value_obj);
break;
case ValueType_int:
value.intValue = json_object_get_int(value_obj);
break;
case ValueType_float:
value.floatValue = json_object_get_double(value_obj);
break;
case ValueType_string:
value.stringValue = (char *)json_object_get_string(value_obj);
break;
case ValueType_date:
value.stringValue = (char *)json_object_get_string(value_obj);
break;
case ValueType_null:
break;
default:
break;
}
HKWriteCharacteristicValue(id.aid, id.serviceID, id.characteristicID, value, moreComing, inContext);
}
}
static void json_value_str(struct json_object *obj, GString *out, int level)
{
int i;
switch(json_object_get_type(obj)) {
case json_type_null:
g_string_append(out, "(null)");
break;
case json_type_boolean:
g_string_append(out, json_object_get_boolean(obj) ? "true" : "false");
break;
case json_type_double:
g_string_append_printf(out, "%f", json_object_get_double(obj));
break;
case json_type_int:
g_string_append_printf(out, "%d", json_object_get_int(obj));
break;
case json_type_string:
g_string_append_printf(out, "\"%s\"", json_object_get_string(obj));
break;
case json_type_object:
json_object_str(obj, out, level);
break;
case json_type_array:
json_array_str(obj, out, level);
}
}
int pa_format_info_get_prop_int(pa_format_info *f, const char *key, int *v) {
const char *str;
json_object *o;
pa_assert(f);
pa_assert(key);
pa_assert(v);
str = pa_proplist_gets(f->plist, key);
if (!str)
return -PA_ERR_NOENTITY;
o = json_tokener_parse(str);
if (is_error(o))
return -PA_ERR_INVALID;
if (json_object_get_type(o) != json_type_int) {
json_object_put(o);
return -PA_ERR_INVALID;
}
*v = json_object_get_int(o);
json_object_put(o);
return 0;
}
static void dump_kvs_val (const char *key, const char *json_str)
{
JSON o = Jfromstr (json_str);
if (!o) {
printf ("%s: invalid JSON", key);
return;
}
switch (json_object_get_type (o)) {
case json_type_null:
printf ("%s = nil\n", key);
break;
case json_type_boolean:
printf ("%s = %s\n", key, json_object_get_boolean (o)
? "true" : "false");
break;
case json_type_double:
printf ("%s = %f\n", key, json_object_get_double (o));
break;
case json_type_int:
printf ("%s = %d\n", key, json_object_get_int (o));
break;
case json_type_string:
printf ("%s = %s\n", key, json_object_get_string (o));
break;
case json_type_array:
case json_type_object:
default:
printf ("%s = %s\n", key, Jtostr (o));
break;
}
Jput (o);
}
void draw_item(json_object *o)
{
stringstream dummy;
if(json_object_is_type(o, json_type_boolean))
{
json_object_get_boolean(o)?draw_text("1"):draw_text("0");
one_down();
}
if(json_object_is_type(o, json_type_double))
{
dummy << json_object_get_double(o);
draw_text(dummy.str().c_str());
one_down();
}
if(json_object_is_type(o, json_type_int))
{
dummy << json_object_get_int(o);
draw_text(dummy.str().c_str());
one_down();
}
if(json_object_is_type(o, json_type_object))
{
one_right();
json_object_object_foreach(o, key,val)
{
draw_text(key);
one_down();
draw_item(val);
one_down();
}
one_left();
}
static union command_args *unserialize_store_key_req(struct json_object *in,
uint16_t version) {
struct json_object *temp;
union command_args *ret_union =
(union command_args *) malloc(sizeof(union command_args));
struct store_key_req *ret = &ret_union->store_key_req;
if(version != 1)
goto err_exit;
if(!json_object_object_get_ex(in, "key_id_accepted", &temp)) {
LOG(LOG_LVL_CRIT, "Key \"key_id_accepted\" does not exists.");
goto err_exit;
}
ret->key_id_accepted = (uint8_t) json_object_get_int(temp);
if(!json_object_object_get_ex(in, "key_id", &temp)){
LOG(LOG_LVL_CRIT, "Key \"key_id\" does not exists.");
goto err_exit;
}
ret->key_id = strdup(json_object_get_string(temp));
return ret_union;
err_exit:
free(ret_union);
return NULL;
}
