std::shared_ptr<json_object>& ResourceCache::loadAsset(const std::string& name) { std::shared_ptr<json_object> object; if (this->assetCache.find(name) == this->assetCache.end()) { Logger::getInstance().log(Logger::LOG_INFO, "Asset `%s' not in cache, trying to load", name.c_str()); std::string fullPath(this->buildPath(name).c_str()); auto entitySource = this->loadSource(fullPath.c_str()); if (entitySource == nullptr) { Logger::getInstance().log(Logger::LOG_ERROR, "Failed to open `%s'", fullPath.c_str()); return this->assetCache["nullptr"]; } json_tokener_error parseError; object = std::shared_ptr<json_object>( json_tokener_parse_verbose(entitySource.get(), &parseError), json_object_put); if (object == nullptr) { Logger::getInstance().log(Logger::LOG_ERROR, "Failed to parse `%s': %s", fullPath.c_str(), json_tokener_error_desc(parseError)); return this->assetCache["nullptr"]; } this->assetCache.insert(std::make_pair(name, object)); } else { Logger::getInstance().log(Logger::LOG_INFO, "Asset `%s' picked from cache", name.c_str()); } return this->assetCache.at(name); }
json_object * rocsmq_get_message_json(p_rocsmq_message mesg) { enum json_tokener_error error; json_object * obj = json_tokener_parse_verbose(mesg->tail, &error); int i; if (error != json_tokener_success) { log_message(ERROR,"Json Parse: %s", json_tokener_error_desc(error)); return 0; } return obj; }
static void test_verbose_parse() { json_object *new_obj; enum json_tokener_error error = json_tokener_success; new_obj = json_tokener_parse_verbose("{ foo }", &error); assert (error == json_tokener_error_parse_object_key_name); assert (new_obj == NULL); new_obj = json_tokener_parse("{ foo }"); assert (new_obj == NULL); new_obj = json_tokener_parse("foo"); assert (new_obj == NULL); new_obj = json_tokener_parse_verbose("foo", &error); assert (new_obj == NULL); /* b/c the string starts with 'f' parsing return a boolean error */ assert (error == json_tokener_error_parse_boolean); printf("json_tokener_parse_versbose() OK\n"); }
/** Couchbase callback for get (read) operations * * @param instance Couchbase connection instance. * @param cookie Couchbase cookie for returning information from callbacks. * @param error Couchbase error object. * @param resp Couchbase get operation response object. */ void couchbase_get_callback(lcb_t instance, const void *cookie, lcb_error_t error, const lcb_get_resp_t *resp) { cookie_u cu; /* union of const and non const pointers */ cu.cdata = cookie; /* set const union member to cookie passed from couchbase */ cookie_t *c = (cookie_t *) cu.data; /* set our cookie struct using non-const member */ const char *bytes = resp->v.v0.bytes; /* the payload of this chunk */ lcb_size_t nbytes = resp->v.v0.nbytes; /* length of this data chunk */ /* check error */ switch (error) { case LCB_SUCCESS: /* check for valid bytes */ if (bytes && nbytes > 1) { /* debug */ DEBUG("rlm_couchbase: (get_callback) got %zu bytes", nbytes); /* build json object */ c->jobj = json_tokener_parse_verbose(bytes, &c->jerr); /* switch on current error status */ switch (c->jerr) { case json_tokener_continue: /* do nothing */ break; case json_tokener_success: /* do nothing */ break; default: /* log error */ ERROR("rlm_couchbase: (get_callback) JSON Tokener error: %s", json_tokener_error_desc(c->jerr)); break; } } break; case LCB_KEY_ENOENT: /* ignored */ DEBUG("rlm_couchbase: (get_callback) key does not exist"); break; default: /* log error */ ERROR("rlm_couchbase: (get_callback) %s (0x%x)", lcb_strerror(instance, error), error); break; } }
ss_conf_t* ss_conf_file_parse(char* conf_path) { int is_ok = 1; int rv; char* conf_buffer = NULL; json_object* json_underlying = NULL; json_object* items = NULL; json_object* item = NULL; json_error_t json_error = json_tokener_success; conf_buffer = ss_conf_file_read(conf_path); if (conf_buffer == NULL) { fprintf(stderr, "conf file read error\n"); is_ok = 0; goto error_out; } json_underlying = json_tokener_parse_verbose(conf_buffer, &json_error); if (json_underlying == NULL) { is_ok = 0; fprintf(stderr, "json parse error: %s\n", json_tokener_error_desc(json_error)); is_ok = 0; goto error_out; } ss_conf = je_calloc(1, sizeof(ss_conf_t)); if (ss_conf == NULL) { fprintf(stderr, "could not allocate sdn_sensor configuration\n"); is_ok = 0; goto error_out; } ss_conf->json = json_object_get(json_underlying); is_ok = json_object_is_type(ss_conf->json, json_type_object); if (!is_ok) { is_ok = 0; fprintf(stderr, "json configuration root is not object\n"); is_ok = 0; goto error_out; } //const char* content = json_object_to_json_string_ext(ss_conf->json, JSON_C_TO_STRING_PRETTY); //fprintf(stderr, "json configuration:\n%s\n", content); TAILQ_INIT(&ss_conf->re_chain.re_list); TAILQ_INIT(&ss_conf->pcap_chain.pcap_list); TAILQ_INIT(&ss_conf->dns_chain.dns_list); TAILQ_INIT(&ss_conf->ioc_chain.ioc_list); items = ss_json_object_get(ss_conf->json, "network"); if (items == NULL) { fprintf(stderr, "could not load network configuration\n"); is_ok = 0; goto error_out; } if (!json_object_is_type(items, json_type_object)) { fprintf(stderr, "network configuration is not object\n"); is_ok = 0; goto error_out; } rv = ss_conf_network_parse(items); if (rv) { fprintf(stderr, "could not parse network configuration\n"); is_ok = 0; goto error_out; } items = ss_json_object_get(ss_conf->json, "dpdk"); if (items == NULL) { fprintf(stderr, "could not load dpdk configuration\n"); is_ok = 0; goto error_out; } if (!json_object_is_type(items, json_type_object)) { fprintf(stderr, "dpdk configuration is not object\n"); is_ok = 0; goto error_out; } rv = ss_conf_dpdk_parse(items); if (rv) { fprintf(stderr, "could not parse dpdk configuration\n"); is_ok = 0; goto error_out; } items = ss_json_object_get(ss_conf->json, "re_chain"); if (items) { is_ok = json_object_is_type(items, json_type_array); if (!is_ok) { fprintf(stderr, "re_chain is not an array\n"); goto error_out; } int length = json_object_array_length(items); for (int i = 0; i < length; ++i) { item = json_object_array_get_idx(items, i); ss_re_entry_t* entry = ss_re_entry_create(item); /* if (entry == NULL) { fprintf(stderr, "could not create re_chain entry\n"); if (entry) je_free(entry); is_ok = 0; goto error_out; } */ if (entry == NULL) { fprintf(stderr, "could not create re_chain entry %d\n", i); ss_re_entry_destroy(entry); is_ok = 0; goto error_out; } ss_re_chain_add(entry); } } items = ss_json_object_get(ss_conf->json, "pcap_chain"); if (items) { is_ok = json_object_is_type(items, json_type_array); if (!is_ok) { fprintf(stderr, "pcap_chain is not an array\n"); goto error_out; } int length = json_object_array_length(items); for (int i = 0; i < length; ++i) { item = json_object_array_get_idx(items, i); ss_pcap_entry_t* entry = ss_pcap_entry_create(item); if (entry == NULL) { fprintf(stderr, "could not create pcap_chain entry %d\n", i); ss_pcap_entry_destroy(entry); is_ok = 0; goto error_out; } ss_pcap_chain_add(entry); } } items = ss_json_object_get(ss_conf->json, "dns_chain"); if (items) { is_ok = json_object_is_type(items, json_type_array); if (!is_ok) { fprintf(stderr, "dns_chain is not an array\n"); goto error_out; } int length = json_object_array_length(items); for (int i = 0; i < length; ++i) { item = json_object_array_get_idx(items, i); ss_dns_entry_t* entry = ss_dns_entry_create(item); if (entry == NULL) { fprintf(stderr, "could not create dns_chain entry %d\n", i); ss_dns_entry_destroy(entry); is_ok = 0; goto error_out; } ss_dns_chain_add(entry); } } items = ss_json_object_get(ss_conf->json, "cidr_table"); if (items) { is_ok = json_object_is_type(items, json_type_array); if (!is_ok) { fprintf(stderr, "cidr_table is not an array\n"); goto error_out; } int length = json_object_array_length(items); for (int i = 0; i < length; ++i) { item = json_object_array_get_idx(items, i); ss_cidr_entry_t* entry = ss_cidr_entry_create(item); /* if (entry == NULL) { fprintf(stderr, "could not create cidr_table entry %d\n", i); ss_cidr_entry_destroy(entry); is_ok = 0; goto error_out; } */ ss_cidr_table_add(&ss_conf->cidr_table, entry); } } // XXX: do more stuff error_out: if (conf_buffer) { je_free(conf_buffer); conf_buffer = NULL; } if (!is_ok && ss_conf) { ss_conf_destroy(); ss_conf = NULL; } return ss_conf; }
void BlynkMQTT::on_message(const struct mosquitto_message* message) { const char *payloads = (const char *)message->payload; bool matches; mosqpp::topic_matches_sub("mqblynk/command/#", message->topic, &matches); if (matches) { if (strstr(payloads, "quit")) { printf("exiting on quit request\n"); this->_should_run = false; } else { printf("command unrecognised!: %s\n", payloads); } return; } enum json_tokener_error js_tok_error; struct json_object *js = json_tokener_parse_verbose((const char*)message->payload, &js_tok_error); if (js_tok_error != json_tokener_success) { printf("Invalid json, reason: %s, actual data: %s\n", json_tokener_error_desc(js_tok_error), (const char*)message->payload); return; } for (auto map : this->_conf.outputs) { bool matches; int rc = mosqpp::topic_matches_sub(map->topic, message->topic, &matches); if (rc != MOSQ_ERR_SUCCESS) { printf("invalid params is code error, out of memory we can't handle: %d\n", rc); break; } if (matches) { map->blynk = &this->_blynk; jp_match(map->_jp->path, js, mq_blynk_js_cb, &map); // if (strcmp(map.magic, "int") == 0) { // int x = atoi((const char*) message->payload); // printf("blynking int %d -> %d\n", map.pin, x); // this->_blynk.virtualWrite(map.pin, x); // } else if (strcmp(map.magic, "str") == 0) { // const char *x = (const char *) message->payload; // printf("blynking str %d -> %s\n", map.pin, x); // this->_blynk.virtualWrite(map.pin, x); // } else if (strcmp(map.magic, "lcd") == 0) { // const char *x = (const char *) message->payload; // printf("blynking lcd %d -> %s\n", map.pin, x); // char mem[64] = ""; // BlynkParam cmd(mem, 0, sizeof(mem)); // cmd.add("p"); // cmd.add(0); // cmd.add(0); // cmd.add(x); // this->_blynk.virtualWrite(map.pin, cmd); // } else { // printf("unknown magic mapping: %s\n", map.magic); // } } } json_object_put(js); }
json_object_put(new_obj); new_obj = json_tokener_parse("{ \"foo\": \"bar\", \"baz\": null, \"bool0\": true }"); printf("new_obj.to_string()=%s\n", json_object_to_json_string(new_obj)); json_object_put(new_obj); new_obj = json_tokener_parse("{ \"foo\": [null, \"foo\"] }"); printf("new_obj.to_string()=%s\n", json_object_to_json_string(new_obj)); json_object_put(new_obj); new_obj = json_tokener_parse("{ \"abc\": 12, \"foo\": \"bar\", \"bool0\": false, \"bool1\": true, \"arr\": [ 1, 2, 3, null, 5 ] }"); printf("new_obj.to_string()=%s\n", json_object_to_json_string(new_obj)); json_object_put(new_obj); enum json_tokener_error error = json_tokener_success; new_obj = json_tokener_parse_verbose("{ foo }", &error); assert (error == json_tokener_error_parse_object_key_name); assert (new_obj == NULL); new_obj = json_tokener_parse("{ foo }"); assert (new_obj == NULL); // if(is_error(new_obj)) printf("got error as expected\n"); new_obj = json_tokener_parse("foo"); assert (new_obj == NULL); new_obj = json_tokener_parse_verbose("foo", &error); assert (new_obj == NULL); assert (error == json_tokener_error_parse_boolean); new_obj = json_tokener_parse("{ \"foo");
bool settings_read(void) { bool rv; bool bind_defaults; bool nonexistent_ok; rv = true; bind_defaults = true; nonexistent_ok = false; /* Read and delete the old versions first if it exists. */ settings_read_v1(); if(settings_read_v2()) { bind_defaults = false; nonexistent_ok = true; // If we managed to read the old .lua file, then failing to read the new .json file should not cause any error messages. } /* Read the new version if it exists. */ char * json; int json_size; snprintf(filename, sizeof filename, "%s", get_save_filename("settings.json")); if(read_file(filename, &json, &json_size) == true) { enum json_tokener_error e; struct json_object * obj; obj = json_tokener_parse_verbose(json, &e); if(obj != NULL) { bool ok; struct json_object_iterator it; struct json_object_iterator itEnd; int active_questline; ok = true; it = json_object_iter_begin(obj); itEnd = json_object_iter_end(obj); active_questline = globals.active_questline; while(ok == true && !json_object_iter_equal(&it, &itEnd)) { const char * name; struct json_object * value; enum json_type type; bool dummy_boolean; name = json_object_iter_peek_name(&it); value = json_object_iter_peek_value(&it); type = json_object_get_type(value); struct { const char * name; enum json_type type; bool (*callback)(struct json_object * value, void * value_ptr); void * value_ptr; } stuff[] = { { "Fullscreen", json_type_boolean, cb_bool, &globals.fullscreen }, { "OpenGL", json_type_boolean, cb_bool, &globals.opengl }, { "OpenGL_POT", json_type_boolean, cb_opengl_pot, NULL }, { "OpenGL_compressed_textures", json_type_boolean, cb_bool, &globals.opengl_compressed_textures }, { "SFX", json_type_boolean, cb_bool, &globals.use_sfx }, { "Music", json_type_boolean, cb_bool, &globals.use_music }, { "SFX_max_channels", json_type_int, cb_int, &globals.max_channels }, { "Sound_volume", json_type_int, cb_sound_volume, NULL }, { "Joysticks", json_type_boolean, cb_bool, &globals.use_joysticks }, { "CaveSelection", json_type_string, cb_cave_selection, NULL }, { "CaveSelectionLevel", json_type_int, cb_cave_selection_level, NULL }, { "ShowFPS", json_type_boolean, cb_bool, &globals.fps_counter_active }, { "GameMode", json_type_string, cb_game_mode, NULL }, { "ActiveQuestline", json_type_int, cb_int, &active_questline }, { "TitleMidarea", json_type_string, cb_title_midarea, NULL }, { "IronGirlMode", json_type_boolean, cb_bool, &globals.iron_girl_mode }, { "Locale", json_type_string, cb_locale, NULL }, { "MapTilting", json_type_boolean, cb_bool, &globals.map_tilting }, { "SmoothClassicMode", json_type_boolean, cb_bool, &globals.smooth_classic_mode }, { "Bindings", json_type_array, cb_bindings, NULL }, { "Themes", json_type_array, cb_themes, NULL }, { "WriteSettings", json_type_boolean, cb_bool, &globals.write_settings }, { "TestsCompleted", json_type_boolean, cb_bool, &dummy_boolean }, // Ignored. { NULL, json_type_int, NULL, NULL } }; int ind; ind = -1; for(int i = 0; ind == -1 && stuff[i].name != NULL; i++) if(!strcmp(stuff[i].name, name)) ind = i; if(ind >= 0) { if(stuff[ind].type == type) { ok = stuff[ind].callback(value, stuff[ind].value_ptr); /* Don't bind the default keybindings if we were able to read them from the settings.json. */ if(ok == true && !strcmp(name, "Bindings")) bind_defaults = false; } else { fprintf(stderr, "%s: Incorrect value type %s for '%s', expected %s.\n", filename, json_type_to_name(type), name, json_type_to_name(stuff[ind].type)); ok = false; } } else { fprintf(stderr, "%s: Failed to parse: unknown variable '%s'.\n", filename, name); ok = false; } json_object_iter_next(&it); } if(ok == true) globals.active_questline = active_questline; else rv = false; } else { fprintf(stderr, "%s: Failed to parse: %d: %s\n", filename, (int) e, json_tokener_error_desc(e)); } free(json); } else { if(nonexistent_ok == false) fprintf(stderr, "%s: Failed to read '%s'.\n", __FUNCTION__, filename); } if(bind_defaults) ui_bindings_default(true); if(globals.iron_girl_mode) theme_set(THEME_TRAIT, "iron-girl"); return rv; }
VerifyResult verify_assertion_local(request_rec *r, const char *assertion) { char *pair; char *last = NULL; VerifyResult res = apr_pcalloc(r->pool, sizeof(struct _VerifyResult)); char *assertion_string = apr_pstrdup(r->pool, assertion); char *delim = "."; const char *assertions[16]; int i = 0; /* XXX: Need to make sure we don't overrun assertions[] */ for (pair = apr_strtok(assertion_string, delim, &last); pair; pair = apr_strtok(NULL, delim, &last)) { assertions[i++] = pair; } ap_log_rerror(APLOG_MARK, APLOG_WARNING | APLOG_NOERRNO, 0, r, ERRTAG "Local Assertion Verification enabled but not implemented yet"); int assertion_count = i; json_object *json_assertions[16]; enum json_tokener_error jerr; for (i = 0; i < assertion_count; i++) { assertions[i] = base64url_decode(r->pool, assertions[i]); json_assertions[i] = json_tokener_parse_verbose(assertions[i], &jerr); if (json_tokener_success != jerr) { ap_log_rerror(APLOG_MARK, APLOG_DEBUG | APLOG_NOERRNO, 0, r, ERRTAG "json parse error %s", json_tokener_error_desc(jerr)); ap_log_rerror(APLOG_MARK, APLOG_DEBUG | APLOG_NOERRNO, 0, r, ERRTAG "Raw Pair %d is %s", i, assertions[i]); } else { ap_log_rerror(APLOG_MARK, APLOG_DEBUG | APLOG_NOERRNO, 0, r, ERRTAG "JSON is %s", json_object_to_json_string(json_assertions[i])); } } json_object *principal = json_object_object_get(json_assertions[1], "principal"); json_object *issuer = json_object_object_get(json_assertions[1], "iss"); json_object *expiry = json_object_object_get(json_assertions[3], "exp"); json_object *audience = json_object_object_get(json_assertions[3], "aud"); json_object *email = NULL; /* Not fully implemented yet */ res->errorResponse = "Local verification enabled but not implemented yet"; if (principal && json_object_is_type(principal, json_type_object)) { email = json_object_object_get(principal, "email"); if (email && json_object_is_type(email, json_type_string)) { res->verifiedEmail = json_object_get_string(email); } } if (issuer && json_object_is_type(issuer, json_type_string)) { res->identityIssuer = json_object_get_string(issuer); } if (audience && json_object_is_type(audience, json_type_string)) { const char *audience_str = json_object_get_string(audience); ap_log_rerror(APLOG_MARK, APLOG_DEBUG | APLOG_NOERRNO, 0, r, ERRTAG "Audience is %s", audience_str); } if (expiry && json_object_is_type(expiry, json_type_int)) { int64_t expiry_time = json_object_get_int64(expiry); ap_log_rerror(APLOG_MARK, APLOG_DEBUG | APLOG_NOERRNO, 0, r, ERRTAG "Expiry is %" APR_INT64_T_FMT, expiry_time); } /* Fake success */ if (email && issuer) { res->errorResponse = NULL; } return res; }
int main(int argc, char *argv[]) { printf("Content-type: text/plain\n\n"); char *data = alfred_read_file(stdin); enum json_tokener_error err; json_object *json = json_tokener_parse_verbose(data, &err); // Shouldn't need this var any more g_free(data); // Parse error if (err != json_tokener_success) { alfred_error_static(ALFRED_ERROR_MALFORMED_COMMAND); return 0; } char *method = alfred_json_get_string(json, "method"); char *alfred = alfred_json_get_string(json, "alfred"); char *key = alfred_json_get_string(json, "key"); json_object *params = json_object_object_get(json, "params"); if (!method || !alfred || !key || !params) { alfred_error_static(ALFRED_ERROR_MALFORMED_COMMAND); g_free(method); g_free(alfred); g_free(key); if (params) { json_object_put(params); } return 0; } alfred_auth_set_key(key); alfred_sql_init(); gchar **info = g_strsplit(method, ".", 2); if (info && info[0] && info[1]) { if (strcmp(info[0], "Alfred") == 0) { alfred_module_alfred(info[1], params); } else if (strcmp(info[0], "Location") == 0) { alfred_module_location(info[1], params); } else if (strcmp(info[0], "Net") == 0) { alfred_module_net(info[1], params); } else if (strcmp(info[0], "Password") == 0) { alfred_module_password(info[1], params); } else if (strcmp(info[0], "XBMC") == 0) { alfred_module_xbmc(info[1], params); } else if (!alfred_authed()) { alfred_error_static(ALFRED_ERROR_NOT_AUTHENTICATED); } else { alfred_error_static(ALFRED_ERROR_UNKNOWN_COMMAND); } } else if (!alfred_authed()) { alfred_error_static(ALFRED_ERROR_NOT_AUTHENTICATED); } else { alfred_error_static(ALFRED_ERROR_UNKNOWN_COMMAND); } alfred_sql_shutdown(); // For good measure alfred_auth_forget_key(); g_strfreev(info); g_free(method); g_free(alfred); g_free(key); json_object_put(json); return 0; }
int main(int argc, char *argv[]) { CURL *ch; /* curl handle */ CURLcode rcode; /* curl result code */ json_object *json; /* json post body */ enum json_tokener_error jerr = json_tokener_success; /* json parse error */ struct curl_fetch_st curl_fetch; /* curl fetch struct */ struct curl_fetch_st *cf = &curl_fetch; /* pointer to fetch struct */ struct curl_slist *headers = NULL; /* http headers to send with request */ /* url to test site */ char *url = "http://energybill.ir/api/remote"; /* init curl handle */ if ((ch = curl_easy_init()) == NULL) { /* log error */ fprintf(stderr, "ERROR: Failed to create curl handle in fetch_session"); /* return error */ return 1; } /* set content type */ headers = curl_slist_append(headers, "Accept: application/json"); headers = curl_slist_append(headers, "Content-Type: application/json"); /* create json object for post */ json = json_object_new_object(); /* build post data */ //linux one: curl -H "Accept:application/json" -H "Content-Type: application/json" -X POST -d '{"SerialNumber":"61600010","AccumulatedEnergy":0.0,"AccumulatedVolume":0.0,"TariffEnergy":0.0,"FlowSensorVolume":0.0,"Power":0.0,"Aux1":0,"Aux2":0,"MeterTime":null,"OnTime":0,"ErrorTime":0,"LowTemp":0.0,"HighTemp":0.0,"ErrorCode":0}' http://energybill.ir/api/remote //curl -H "Accept: application/json" -H "Content-type: application/json" -X POST -d // curl -H "Accept:application/json" -H "Content-Type: application/json" -X POST -d '{"SerialNumber":"61600010","AccumulatedEnergy":10.6,"AccumulatedVolume":15.42,"TariffEnergy":0.0,"FlowSensorVolume":0.0,"Power":0.0,"Aux1":0,"Aux2":0,"MeterTime":null,"OnTime":0,"ErrorTime":0,"LowTemp":0.0,"HighTemp":0.0,"ErrorCode":0}' http://energybill.ir/api/remote FILE *fptr; fptr=fopen("Room_Temperature.txt","r"); char buffer[5]; fgets (buffer,5,fptr); printf ("TT%s",buffer); FILE *fptrh; fptrh=fopen("Room_Humidity.txt","r"); char bufferh[5]; fgets (bufferh,5,fptrh); printf ("HH%s",bufferh); json_object_object_add(json, "SerialNumber", json_object_new_string("51600004")); json_object_object_add(json, "AccumulatedEnergy", json_object_new_int(0)); json_object_object_add(json, "AccumulatedVolume", json_object_new_int(0)); json_object_object_add(json, "TariffEnergy", json_object_new_int(0)); json_object_object_add(json, "FlowSensorVolume", json_object_new_int(atoi(bufferh))); json_object_object_add(json, "Power", json_object_new_int(0)); json_object_object_add(json, "Aux1", json_object_new_int(0)); json_object_object_add(json, "Aux2", json_object_new_int(0)); //json_object_object_add(json, "MeterTime", json_object_new_int((int32_t))); json_object_object_add(json, "OnTime", json_object_new_int(0)); json_object_object_add(json, "ErrorTime", json_object_new_int(0)); json_object_object_add(json, "LowTemp", json_object_new_double(atoi(bufferh))); json_object_object_add(json, "HighTemp", json_object_new_double(atof(buffer))); json_object_object_add(json, "ErrorCode", json_object_new_int(0)); /* set curl options */ curl_easy_setopt(ch, CURLOPT_CUSTOMREQUEST, "POST"); curl_easy_setopt(ch, CURLOPT_HTTPHEADER, headers); curl_easy_setopt(ch, CURLOPT_POSTFIELDS, json_object_to_json_string(json)); /* fetch page and capture return code */ rcode = curl_fetch_url(ch, url, cf); /* cleanup curl handle */ curl_easy_cleanup(ch); /* free headers */ curl_slist_free_all(headers); /* free json object */ json_object_put(json); /* check return code */ if (rcode != CURLE_OK || cf->size < 1) { /* log error */ fprintf(stderr, "ERROR: Failed to fetch url (%s) - curl said: %s \n", url, curl_easy_strerror(rcode)); /* return error */ return 2; } /* check payload */ if (cf->payload != NULL) { /* print result */ printf("CURL Returned: \n%s\n", cf->payload); /* parse return */ json = json_tokener_parse_verbose(cf->payload, &jerr); /* free payload */ free(cf->payload); } else { /* error */ fprintf(stderr, "ERROR: Failed to populate payload"); /* free payload */ free(cf->payload); /* return */ return 3; } /* check error */ if (jerr != json_tokener_success) { /* error */ fprintf(stderr, "ERROR: Failed to parse json string\n"); /* free json object */ json_object_put(json); /* return */ return 4; } /* debugging */ printf("Parsed JSON: %s\n", json_object_to_json_string(json)); /* exit */ return 0; }