static int generic_object(struct json_object **dstp, struct json_object *jobj, const char *key, enum odict_type type) { struct json_object *dst; if (!dstp || !jobj || !key) return EINVAL; if (!json_object_object_get_ex(jobj, key, &dst)) { return ENOENT; } if (!json_object_is_type(dst, type)) { return EPROTO; } *dstp = dst; return 0; }
int jzon_double(double *dst, struct json_object *obj, const char *key) { struct json_object *value; enum odict_type type; if (!dst || !obj || !key) return EINVAL; if (!json_object_object_get_ex(obj, key, &value)) return ENOENT; type = json_object_get_type(value); if (type != json_type_double && type != json_type_int) return EPROTO; *dst = json_object_get_double(value); return 0; }
int json_get_field(struct sip_msg* msg, char* json, char* field, char* dst) { str json_s; str field_s; pv_spec_t *dst_pv; pv_value_t dst_val; char *value; struct json_object *j = NULL; struct json_object *oj = NULL; int ret; if (fixup_get_svalue(msg, (gparam_p)json, &json_s) != 0) { LM_ERR("cannot get json string value\n"); return -1; } if (fixup_get_svalue(msg, (gparam_p)field, &field_s) != 0) { LM_ERR("cannot get field string value\n"); return -1; } dst_pv = (pv_spec_t *)dst; j = json_tokener_parse(json_s.s); if (j==NULL) { LM_ERR("empty or invalid JSON\n"); return -1; } json_object_object_get_ex(j, field_s.s, &oj); if(oj!=NULL) { value = (char*)json_object_to_json_string(oj); dst_val.rs.s = value; dst_val.rs.len = strlen(value); dst_val.flags = PV_VAL_STR; dst_pv->setf(msg, &dst_pv->pvp, (int)EQ_T, &dst_val); ret = 1; } else { ret = -1; } json_object_put(j); return ret; }
static struct json_object * jp_match_next(struct jp_opcode *ptr, struct json_object *root, struct json_object *cur, jp_match_cb_t cb, void *priv) { int idx; struct json_object *next = NULL; if (!ptr) { if (cb) cb(cur, priv); return cur; } switch (ptr->type) { case T_STRING: case T_LABEL: if (json_object_object_get_ex(cur, ptr->str, &next)) return jp_match_next(ptr->sibling, root, next, cb, priv); break; case T_NUMBER: idx = ptr->num; if (idx < 0) idx += json_object_array_length(cur); if (idx >= 0) next = json_object_array_get_idx(cur, idx); if (next) return jp_match_next(ptr->sibling, root, next, cb, priv); break; default: return jp_match_expr(ptr, root, cur, cb, priv); } return NULL; }
static char * get_stream_url(struct movie_entry *e) { char url[1000]; char name[100]; json_object *root; json_object *obj; json_bool jres; const char *format_ext = (e->format == SF_MP4) ? "mp4" : "wmv"; provider->error_number = 0; if (e->format == SF_MP4) { snprintf(url, 499, "%svideo/media/%d/watch.json?format=%s&protocol=hls&bitrate=%d", api_root, e->id, format_ext, e->bitrate); } else { snprintf(url, 499, "%svideo/media/%d/watch.json?format=%s&bitrate=%d", api_root, e->id, format_ext, e->bitrate); } snprintf(name, 99, "stream-%d", e->id); logi("fetch %s to %s", url, name); root = get_cached(url, name); if (provider->error_number != 0) return NULL; int status = get_int(root, "status_code"); if (status != 200) { sprintf(last_error, "get stream status: %d", status); provider->error_number = 1; return NULL; } jres = json_object_object_get_ex(root, "data", &obj); if (jres == FALSE) { sprintf(last_error, "Cannot get stream data"); provider->error_number = 1; return NULL; } char *stream_url = strdup(get_str(obj, "url")); json_object_put(root); return stream_url; }
static GError * _load_hash (struct json_object *obj, const gchar *k, GHashTable *dst) { struct json_object *sub = NULL; if (!json_object_object_get_ex(obj, k, &sub)) return NULL; if (!json_object_is_type(sub, json_type_object)) return NEWERROR(CODE_BAD_REQUEST, "Invalid '%s' field", k); json_object_object_foreach(sub,key,val) { if (!json_object_is_type(val, json_type_string)) continue; g_hash_table_insert(dst, g_strdup(key), metautils_gba_from_string( json_object_get_string(val))); } return NULL; }
/** * Get value by key. * @param osName Key name. * @return Json array object. * * @since GDAL 2.3 */ CPLJSONArray CPLJSONObject::GetArray(const std::string &osName) const { std::string objectName; CPLJSONObject object = GetObjectByPath( osName, objectName ); if( object.IsValid() ) { json_object *poVal = nullptr; if( json_object_object_get_ex( TO_JSONOBJ(object.GetInternalHandle()), objectName.c_str(), &poVal ) ) { if( poVal && json_object_get_type( poVal ) == json_type_array ) { return CPLJSONArray( objectName, poVal ); } } } return CPLJSONArray( "", nullptr ); }
void CategoryStats::deserialize(json_object *o) { if(!o) return; /* Reset all */ memset(categories, 0, ntop->get_flashstart()->getNumCategories()*sizeof(u_int64_t)); for(int id=0; id<ntop->get_flashstart()->getNumCategories(); id++) { char *name = ntop->get_flashstart()->getCategoryName(id); if(name != NULL) { json_object *bytes; if(json_object_object_get_ex(o, name, &bytes)) { categories[id] = json_object_get_int64(bytes); } } } }
static int processor_setup_minute(processor_state_t *self, json_object *request) { // we know that started_at data is valid since we already checked that // when determining which processor to call int minute = 0; json_object *started_at_obj = NULL; if (json_object_object_get_ex(request, "started_at", &started_at_obj)) { const char *started_at = json_object_get_string(started_at_obj); char hours[3] = {started_at[11], started_at[12], '\0'}; char minutes[3] = {started_at[14], started_at[15], '\0'}; minute = 60 * atoi(hours) + atoi(minutes); } json_object *minute_obj = json_object_new_int(minute); json_object_object_add(request, "minute", minute_obj); // printf("[D] minute: %d\n", minute); return minute; }
/* search a key (what) in object "where", and return a pointer to its * associated object. If nullable is false, exit if key is not found */ static inline struct json_object* get_in_object(struct json_object *where, const char *what, int nullable) { struct json_object *to; json_bool ret; ret = json_object_object_get_ex(where, what, &to); if (!nullable && !ret) { log_critical(PFX "Error while parsing config\n" PFL); exit(EXIT_INV_CONFIG); } if (!nullable && strcmp(json_object_to_json_string(to), "null") == 0) { log_critical(PFX "Cannot find key %s", what); exit(EXIT_INV_CONFIG); } return to; }
const char *get_field_string_json(json_object *e, const char *path) { const char *str; json_object *node; if (path) { if (!json_object_object_get_ex(e, path, &node)) return NULL; } else node = e; if (json_object_get_type(node) == json_type_string) { str = json_object_get_string(node); return str; } return NULL; }
char *pocket_auth(const char *key, const char *token) { struct buffer s; json_object *response; char* access_token; buffer_init(&s); request(URL_AUTHORIZE, create_auth_petition(key, token), &s, 0); response = json_tokener_parse(s.ptr); json_object_object_get_ex(response, "access_token", &response); access_token = (char *)json_object_get_string(response); free(response); buffer_cleanup(&s); return access_token; }
char *pocket_get_token(const char *key) { struct buffer s; json_object *response; char *token; buffer_init(&s); request(URL_REQUEST, create_request_petition(key), &s, 0); response = json_tokener_parse(s.ptr); json_object_object_get_ex(response, "code", &response); token = (char *)json_object_get_string(response); free(response); buffer_cleanup(&s); return token; }
static const digest_handler *LUKS2_digest_handler(struct crypt_device *cd, int digest) { struct luks2_hdr *hdr; json_object *jobj1, *jobj2; if (digest < 0) return NULL; if (!(hdr = crypt_get_hdr(cd, CRYPT_LUKS2))) return NULL; if (!(jobj1 = LUKS2_get_digest_jobj(hdr, digest))) return NULL; if (!json_object_object_get_ex(jobj1, "type", &jobj2)) return NULL; return LUKS2_digest_handler_type(cd, json_object_get_string(jobj2)); }
static void pretty_print_input(json_object *i) { json_object *id, *name, *size, *caps; json_object_object_get_ex(i, "identifier", &id); json_object_object_get_ex(i, "name", &name); json_object_object_get_ex(i, "size", &size); json_object_object_get_ex(i, "capabilities", &caps); printf( "Input device %s\n Type: ", json_object_get_string(name)); struct { const char *a; const char *b; } cap_names[] = { { "keyboard", "Keyboard" }, { "pointer", "Mouse" }, { "touch", "Touch" }, { "tablet_tool", "Tablet tool" }, { "tablet_pad", "Tablet pad" }, { "gesture", "Gesture" }, { "switch", "Switch" }, }; size_t len = json_object_array_length(caps); if (len == 0) { printf("Unknown"); } json_object *cap; for (size_t i = 0; i < len; ++i) { cap = json_object_array_get_idx(caps, i); const char *cap_s = json_object_get_string(cap); const char *_name = NULL; for (size_t j = 0; j < sizeof(cap_names) / sizeof(cap_names[0]); ++i) { if (strcmp(cap_names[i].a, cap_s) == 0) { _name = cap_names[i].b; break; } } printf("%s%s", _name ? _name : cap_s, len > 1 && i != len - 1 ? ", " : ""); } printf("\n Sway ID: %s\n", json_object_get_string(id)); if (size) { json_object *width, *height; json_object_object_get_ex(size, "width", &width); json_object_object_get_ex(size, "height", &height); printf(" Size: %lfmm x %lfmm\n", json_object_get_double(width), json_object_get_double(height)); } printf("\n"); }
static void * recv_start(void*arg) { struct sockaddr_in addr; char buffer[100]; char *buf = (char*)malloc(1000); if(!buf) { printf("malloc fialed!\n"); return; } socklen_t addrlen; struct json_object * jsonobj; while(1) { struct json_object *json_opr; recvfrom(c2java_socket,&buffer,1000,0,(struct sockaddr*)(&addr),&addrlen); jsonobj = json_tokener_parse((const char*)&buffer); json_object_object_get_ex(jsonobj,"opr",&json_opr); char *opr = json_object_get_string(json_opr); if(is_error(jsonobj)) { printf("json failed!\n"); } if(!strcmp(opr,"start")) { display_endpoint(buf); sendto(c2java_socket,buf,strlen(buf),0,(struct sockaddr*)(&addr),sizeof(struct sockaddr)); } else if(!strcmp(opr,"put")) { } json_object_put(jsonobj); display_endpoint(buf); printf("name:%s\n",buf); *buf = '\0'; } }
/** * Given a JSON object representing an OpenStack service, find the first endpoint of the given version. * If an endpoint of the given version is found, return it. * Otherwise, if no endpoint of the given version is found, return NULL. */ static struct json_object * service_find_endpoint_by_version(keystone_context_t *context, struct json_object *service, unsigned int desired_api_version) { struct json_object *endpoints, *endpoint; if (json_object_object_get_ex(service, "endpoints", &endpoints)) { if (0 == desired_api_version) { /* No desired API version currently set, so use the first endpoint found */ endpoint = json_array_get(context, endpoints, 0); } else { /* Looking for a certain version of the Swift RESTful API */ endpoint = json_array_find(context, endpoints, filter_endpoint_by_version, (void *) &desired_api_version); } } else { context->keystone_error("response.access.serviceCatalog[n] lacks an 'endpoints' key", KSERR_PARSE); endpoint = NULL; /* Lacking the expected key */ } return endpoint; }
bool handle_ipc_event(struct bar *bar) { struct ipc_response *resp = ipc_recv_response(bar->ipc_event_socketfd); if (!resp) { return false; } switch (resp->type) { case IPC_EVENT_WORKSPACE: ipc_update_workspaces(bar); break; case IPC_EVENT_MODE: { json_object *result = json_tokener_parse(resp->payload); if (!result) { free_ipc_response(resp); sway_log(L_ERROR, "failed to parse payload as json"); return false; } json_object *json_change; if (json_object_object_get_ex(result, "change", &json_change)) { const char *change = json_object_get_string(json_change); free(bar->config->mode); if (strcmp(change, "default") == 0) { bar->config->mode = NULL; } else { bar->config->mode = strdup(change); } } else { sway_log(L_ERROR, "failed to parse response"); } json_object_put(result); break; } default: free_ipc_response(resp); return false; } free_ipc_response(resp); return true; }
GError * m2v2_json_load_single_xbean (struct json_object *j, gpointer *pbean) { if (!json_object_is_type (j, json_type_object)) return NEWERROR(CODE_BAD_REQUEST, "Invalid object type"); struct json_object *jtype = NULL; if (!json_object_object_get_ex (j, "type", &jtype)) return NEWERROR(CODE_BAD_REQUEST, "Missing 'type' field"); if (!json_object_is_type (jtype, json_type_string)) return NEWERROR(CODE_BAD_REQUEST, "Invalid 'type' field"); const char *stype = json_object_get_string (jtype); if (!g_ascii_strcasecmp(stype, "alias")) return m2v2_json_load_single_alias (j, pbean); if (!g_ascii_strcasecmp(stype, "header")) return m2v2_json_load_single_header (j, pbean); if (!g_ascii_strcasecmp(stype, "chunk")) return m2v2_json_load_single_chunk (j, pbean); return NEWERROR(CODE_BAD_REQUEST, "Unexpected 'type' field"); }
/** * @ingroup VuoMathExpression * Decodes the JSON object to create a new value. * * @eg{ * { * "expression" : "y = x + 4" * } * } */ VuoMathExpression VuoMathExpression_makeFromJson(json_object *js) { VuoMathExpression me; json_object *o = NULL; if (json_object_object_get_ex(js, "expression", &o)) { me.expression = VuoText_makeFromJson(o); VuoMathExpressionError error = NULL; me.parser = VuoMathExpressionParser_makeFromSingleExpression(me.expression, &error); free(error); } else { me.expression = VuoText_make(""); me.parser = NULL; } return me; }
static json_object *ReadMetaFile(const char *metafile) { char *buf, *buf2; size_t size; json_object *obj, *result; if (!g_file_get_contents(metafile, &buf, &size, NULL)) { return NULL; } buf2 = strndup(buf, size); obj = json_tokener_parse(buf2); g_free(buf); g_free(buf2); if (is_error(obj)) { return NULL; } if (!json_object_object_get_ex(obj, "result", &result)) { return NULL; } return obj; }
/** Get monitor command @param monitor Monitor to save command @param json_monitor JSON monitor to extract command */ static const char * extract_monitor_cmd(enum monitor_cmd_type *type, /* @todo const */ struct json_object *json_monitor) { static const char *cmd_keys[] = { #define _X(menum, cmd, type, fn) cmd, MONITOR_CMDS_X #undef _X }; for (size_t i = 0; i < RD_ARRAYSIZE(cmd_keys); ++i) { struct json_object *json_cmd_arg = NULL; const bool get_rc = json_object_object_get_ex( json_monitor, cmd_keys[i], &json_cmd_arg); if (get_rc) { *type = i; return json_object_get_string(json_cmd_arg); } } return NULL; }
telebot_error_e telebot_parser_get_file_path(struct json_object *obj, char **path) { if (obj == NULL) return TELEBOT_ERROR_INVALID_PARAMETER; if (path == NULL) return TELEBOT_ERROR_INVALID_PARAMETER; struct json_object *file_path; if (json_object_object_get_ex (obj, "file_path", &file_path)) { *path = strdup(json_object_get_string(file_path)); json_object_put (file_path); } else { *path = NULL; return TELEBOT_ERROR_OPERATION_FAILED; } return TELEBOT_ERROR_NONE; }
static void install(struct afb_req request) { struct json_object *obj, *added; char *query; const char *filename; struct afb_arg arg; /* get the argument */ arg = afb_req_get(request, "widget"); filename = arg.path; if (filename == NULL) { afb_req_fail(request, "bad-request", "missing 'widget' file"); return; } /* makes the query */ if (0 >= asprintf(&query, "\"%s\"", filename)) { afb_req_fail(request, "server-error", "out of memory"); return; } obj = jbus_call_sj_sync(jbus, _install_, query); if (afb_interface->verbosity) fprintf(stderr, "(afm-main-plugin) install(%s) -> %s\n", query, obj ? json_object_to_json_string(obj) : "NULL"); free(query); /* check status */ if (obj == NULL) { afb_req_fail(request, "failed", "framework daemon failure"); return; } /* embed if needed */ if (json_object_object_get_ex(obj, _added_, &added)) obj = added; obj = json_object_get(obj); obj = embed(_id_, obj); afb_req_success(request, obj, NULL); }
static void bodhi_read_value(json_object *json, const char *item_name, void *value, int flags) { json_object *j = NULL; if (!json_object_object_get_ex(json, item_name, &j)) { error_msg("'%s' section is not available", item_name); return; } switch (flags) { case BODHI_READ_INT: *(int *) value = json_object_get_int(j); break; case BODHI_READ_STR: *(char **) value = (char *) strtrimch(xstrdup(json_object_to_json_string(j)), '"'); break; case BODHI_READ_JSON_OBJ: *(json_object **) value = (json_object *) j; break; }; }
int jzon_strdup(char **dst, struct json_object *obj, const char *key) { struct json_object *value; enum odict_type type; if (!dst || !obj || !key) return EINVAL; if (!json_object_object_get_ex(obj, key, &value)) return ENOENT; type = json_object_get_type(value); if (type == json_type_string) { return str_dup(dst, json_object_get_string(value)); } else if (type == json_type_null) { *dst = NULL; return 0; } else { return EPROTO; } }
static void handle_message(struct worker* client, const char* data){ struct json_object* json = json_tokener_parse(data); if ( !json ){ logmsg("Failed to parse JSON\n"); return; } struct json_object* type; if ( !json_object_object_get_ex(json, "type", &type) ){ logmsg("message missing type\n"); return; } const char* type_str = json_object_get_string(type); if ( strcmp(type_str, "update") == 0 ){ handle_update(json); } else { logmsg("unhandled message type %s\n", type_str); } json_object_put(json); }
mraa_result_t mraa_init_json_platform_get_index(json_object* jobj, const char* io, const char* key, int index, int* pos, int upper) { json_object* jobj_temp = NULL; if (json_object_object_get_ex(jobj, key, &jobj_temp)) { if (!json_object_is_type(jobj_temp, json_type_int)) { syslog(LOG_ERR, "init_json_platform: %s index at position: %d not an int", io, index); return MRAA_ERROR_INVALID_RESOURCE; } *pos = (int) json_object_get_int(jobj_temp); if (*pos < 0 || *pos > upper) { syslog(LOG_ERR, "init_json_platform: %s %s at position: %d, gave: %d which was out of range", io, key, index, *pos); return MRAA_ERROR_INVALID_RESOURCE; } return MRAA_SUCCESS; } syslog(LOG_ERR, "init_json_platform: An %s was not found for the %s", key, io); return MRAA_ERROR_NO_DATA_AVAILABLE; }
void NdpiStats::deserialize(NetworkInterface *iface, json_object *o) { if(!o) return; /* Reset all */ for(int i=0; i<MAX_NDPI_PROTOS; i++) if(counters[i] != NULL) free(counters[i]); memset(counters, 0, sizeof(counters)); for(int proto_id=0; proto_id<MAX_NDPI_PROTOS; proto_id++) { char *name = iface->get_ndpi_proto_name(proto_id); if(name != NULL) { json_object *obj; if(json_object_object_get_ex(o, name, &obj)) { json_object *bytes, *packets; if((counters[proto_id] = (ProtoCounter*)malloc(sizeof(ProtoCounter))) != NULL) { if(json_object_object_get_ex(obj, "bytes", &bytes)) { json_object *sent, *rcvd; if(json_object_object_get_ex(bytes, "sent", &sent)) counters[proto_id]->bytes.sent = json_object_get_int64(sent); if(json_object_object_get_ex(bytes, "rcvd", &rcvd)) counters[proto_id]->bytes.rcvd = json_object_get_int64(rcvd); } if(json_object_object_get_ex(obj, "packets", &packets)) { json_object *sent, *rcvd; if(json_object_object_get_ex(bytes, "sent", &sent)) counters[proto_id]->packets.sent = json_object_get_int64(sent); if(json_object_object_get_ex(bytes, "rcvd", &rcvd)) counters[proto_id]->packets.rcvd = json_object_get_int64(rcvd); } } } } } }
void bot::thread() { std::string message; while(!this->quit) { message = this->janus_servers[this->server]->read(); if(message.size()) { json_object *json_command = NULL, *temp = NULL; json_command = json_tokener_parse(message.c_str()); std::string method; try { if(!json_object_object_get_ex(json_command, "method", &temp)) throw "'method' not found in command: " + message; } catch(std::string e) { output(e); json_object_put(json_command); json_object_put(temp); return; } method = json_object_get_string(temp); json_object_put(json_command); json_object_put(temp); if(this->server_method[method] != NULL) (this->server_method[method])(this, message); else output("Unknown method " + method); } this->update_pos(); usleep(200000); } }