int bridge_request_handle(bridge_request_t *self) { int ret; char *buffer; struct json_object *in_json; if ((ret = bridge_request_getinput(self, &buffer)) != 0) { bridge_request_fatal(self); goto out; } in_json = json_tokener_parse_ex(self->tokener, buffer, -1); if (!in_json) { bridge_request_fatal(self); ret = -1; goto cleanup; } ret = bridge_request_call_json_dbus(self, in_json); cleanup: json_object_put(in_json); json_tokener_reset(self->tokener); free(buffer); out: if (ret != 0) FCGX_Finish_r(&self->request); return ret; }
iot_json_t *iot_json_string_to_object(const char *s, int len) { if (parser == NULL) { parser = json_tokener_new(); if (parser == NULL) return NULL; } else json_tokener_reset(parser); if (len < 0) len = strlen(s); return json_tokener_parse_ex(parser, s, len); }
/** * Read the memory reader text as a JSON object line, don't consume * terminating newline. The line must not start with whitespace. * * @param mem_json_reader The memory reader to parse the object for. * @param pobject Location for the parsed object pointer. * * @return Global return code. */ static tlog_grc tlog_mem_json_reader_read_json(struct tlog_mem_json_reader *mem_json_reader, struct json_object **pobject) { const char *p; struct json_object *object; enum json_tokener_error jerr; assert(tlog_mem_json_reader_is_valid( (struct tlog_json_reader *)mem_json_reader)); assert(pobject != NULL); json_tokener_reset(mem_json_reader->tok); /* Look for a terminating newline */ for (p = mem_json_reader->pos; p < mem_json_reader->end && *p != '\n'; p++); /* If the line is empty */ if (p == mem_json_reader->pos) { /* Report EOF */ *pobject = NULL; return TLOG_RC_OK; } /* Parse the line */ object = json_tokener_parse_ex(mem_json_reader->tok, mem_json_reader->pos, p - mem_json_reader->pos); mem_json_reader->pos = p; if (object == NULL) { jerr = json_tokener_get_error(mem_json_reader->tok); return (jerr == json_tokener_continue) ? TLOG_RC_MEM_JSON_READER_INCOMPLETE_LINE : TLOG_GRC_FROM(json, jerr); } /* Return the parsed object */ *pobject = object; return TLOG_RC_OK; }
/** * Read a line from the connection and parse it as a json object. * The returned object has ref count 1. */ json_object *net_json_read(struct net_json *connection){ read_line(connection->fd, connection->buf); json_tokener_reset(connection->tok); json_object *obj = json_tokener_parse_ex(connection->tok, connection->buf->buf, connection->buf->bpos); if(obj == NULL){ if(connection->tok->err != json_tokener_success){ error(0, "Error in JSON data (%s at offset %d).\n", json_tokener_errors[connection->tok->err], connection->tok->char_offset); }else{ error(errno, NULL); } } return obj; }
/** * Authenticate against a Keystone authentication service with the given tenant and user names and password. * This yields an authorisation token, which is then used to access all Swift services. */ enum keystone_error keystone_authenticate(keystone_context_t *context, const char *url, const char *tenant_name, const char *username, const char *password) { CURLcode curl_err; struct curl_slist *headers = NULL; size_t body_len; assert(context != NULL); assert(context->pvt.curl != NULL); assert(url != NULL); assert(tenant_name != NULL); assert(username != NULL); assert(password != NULL); body_len = strlen(KEYSTONE_AUTH_PAYLOAD_BEFORE_USERNAME) + strlen(username) + strlen(KEYSTONE_AUTH_PAYLOAD_BEFORE_PASSWORD) + strlen(password) + strlen(KEYSTONE_AUTH_PAYLOAD_BEFORE_TENANT) + strlen(tenant_name) + strlen(KEYSTONE_AUTH_PAYLOAD_END) ; /* Create or reset the JSON tokeniser */ if (NULL == context->pvt.json_tokeniser) { context->pvt.json_tokeniser = json_tokener_new(); if (NULL == context->pvt.json_tokeniser) { context->keystone_error("json_tokener_new failed", KSERR_INIT_FAILED); return KSERR_INIT_FAILED; } } else { json_tokener_reset(context->pvt.json_tokeniser); } curl_err = curl_easy_setopt(context->pvt.curl, CURLOPT_URL, url); if (CURLE_OK != curl_err) { context->curl_error("curl_easy_setopt", curl_err); return KSERR_URL_FAILED; } curl_err = curl_easy_setopt(context->pvt.curl, CURLOPT_POST, 1L); if (CURLE_OK != curl_err) { context->curl_error("curl_easy_setopt", curl_err); return KSERR_URL_FAILED; } /* Append header specifying body content type (since this differs from libcurl's default) */ headers = curl_slist_append(headers, "Content-Type: " KEYSTONE_AUTH_REQUEST_FORMAT); /* Append pseudo-header defeating libcurl's default addition of an "Expect: 100-continue" header. */ headers = curl_slist_append(headers, "Expect:"); /* Generate POST request body containing the authentication credentials */ context->pvt.auth_payload = context->allocator( context->pvt.auth_payload, body_len + 1 /* '\0' */ ); if (NULL == context->pvt.auth_payload) { curl_slist_free_all(headers); return KSERR_ALLOC_FAILED; } sprintf(context->pvt.auth_payload, "%s%s%s%s%s%s%s", KEYSTONE_AUTH_PAYLOAD_BEFORE_USERNAME, username, KEYSTONE_AUTH_PAYLOAD_BEFORE_PASSWORD, password, KEYSTONE_AUTH_PAYLOAD_BEFORE_TENANT, tenant_name, KEYSTONE_AUTH_PAYLOAD_END ); if (context->pvt.debug) { fputs(context->pvt.auth_payload, stderr); } /* Pass the POST request body to libcurl. The data are not copied, so they must persist during the request lifetime. */ curl_err = curl_easy_setopt(context->pvt.curl, CURLOPT_POSTFIELDS, context->pvt.auth_payload); if (CURLE_OK != curl_err) { context->curl_error("curl_easy_setopt", curl_err); curl_slist_free_all(headers); return KSERR_URL_FAILED; } curl_err = curl_easy_setopt(context->pvt.curl, CURLOPT_POSTFIELDSIZE, body_len); if (CURLE_OK != curl_err) { context->curl_error("curl_easy_setopt", curl_err); curl_slist_free_all(headers); return KSERR_URL_FAILED; } /* Add header requesting desired response content type */ headers = curl_slist_append(headers, "Accept: " KEYSTONE_AUTH_RESPONSE_FORMAT); curl_err = curl_easy_setopt(context->pvt.curl, CURLOPT_HTTPHEADER, headers); if (CURLE_OK != curl_err) { context->curl_error("curl_easy_setopt", curl_err); curl_slist_free_all(headers); return KSERR_URL_FAILED; } curl_err = curl_easy_setopt(context->pvt.curl, CURLOPT_WRITEFUNCTION, process_keystone_response); if (CURLE_OK != curl_err) { context->curl_error("curl_easy_setopt", curl_err); curl_slist_free_all(headers); return KSERR_URL_FAILED; } curl_err = curl_easy_setopt(context->pvt.curl, CURLOPT_WRITEDATA, context); if (CURLE_OK != curl_err) { context->curl_error("curl_easy_setopt", curl_err); curl_slist_free_all(headers); return KSERR_URL_FAILED; } curl_err = curl_easy_perform(context->pvt.curl); if (CURLE_OK != curl_err) { context->curl_error("curl_easy_perform", curl_err); curl_slist_free_all(headers); return KSERR_URL_FAILED; } curl_slist_free_all(headers); if (NULL == context->pvt.auth_token) { return KSERR_AUTH_REJECTED; } return KSERR_SUCCESS; }
DWORD WINAPI CollabSocket::recvHandler(void *_sock) { #else void *CollabSocket::recvHandler(void *_sock) { #endif static qstring b; unsigned char buf[2048]; //read a large chunk, we'll be notified if there is more CollabSocket *sock = (CollabSocket*)_sock; json_tokener *tok = json_tokener_new(); while (sock->isConnected()) { int len = sock->recv(buf, sizeof(buf) - 1); if (len == 0) { //end of file break; } if (len < 0) { #ifdef _WIN32 //timeouts are okay if (WSAGetLastError() == WSAETIMEDOUT) { continue; } #else //timeouts are okay if (errno == EAGAIN || errno == EWOULDBLOCK) { continue; } #endif // assumption is that socket is borked and next send will fail also // maybe should close socket here at a minimum. // in any case thread is exiting // reconnecting is a better strategy break; } if (sock->_disp) { json_object *jobj = NULL; enum json_tokener_error jerr; buf[len] = 0; b.append((char*)buf, len); //append new data into static buffer while (1) { jobj = json_tokener_parse_ex(tok, b.c_str(), (int)b.length()); jerr = json_tokener_get_error(tok); if (jerr == json_tokener_continue) { //json object is syntactically correct, but incomplete // msg("json_tokener_continue for %s\n", b.c_str()); break; } else if (jerr != json_tokener_success) { //need to reconnect socket and in the meantime start caching event locally // msg("jerr != json_tokener_success for %s\n", b.c_str()); //need to break out of both loops goto end_loop; } else if (jobj != NULL) { //we extracted a json object from the front of the string //queue it and trim the string // msg("json_tokener_success for %s\n", b.c_str()); if (tok->char_offset < b.length()) { //shift any remaining portions of the buffer to the front b.remove(0, tok->char_offset); } else { b.clear(); } sock->drt->queueObject(jobj); } } json_tokener_reset(tok); } } end_loop: json_tokener_free(tok); sock->cleanup(); return 0; } int send_all(const qstring &s) { if (comm) { return comm->sendAll(s); } return 0; } int send_msg(const qstring &s) { if (comm) { return comm->sendAll(s); } else { if (changeCache != NULL) { // msg("writing to change cache\n"); *changeCache += s; return (int)s.length(); } } return 0; }
static void test_incremental_parse() { json_object *new_obj; enum json_tokener_error jerr; json_tokener *tok; const char *string_to_parse; int ii; int num_ok, num_error; num_ok = 0; num_error = 0; printf("Starting incremental tests.\n"); printf("Note: quotes and backslashes seen in the output here are literal values passed\n"); printf(" to the parse functions. e.g. this is 4 characters: \"\\f\"\n"); string_to_parse = "{ \"foo"; /* } */ printf("json_tokener_parse(%s) ... ", string_to_parse); new_obj = json_tokener_parse(string_to_parse); if (new_obj == NULL) printf("got error as expected\n"); /* test incremental parsing in various forms */ tok = json_tokener_new(); for (ii = 0; incremental_steps[ii].string_to_parse != NULL; ii++) { int this_step_ok = 0; struct incremental_step *step = &incremental_steps[ii]; int length = step->length; int expected_char_offset = step->char_offset; if (step->reset_tokener & 2) json_tokener_set_flags(tok, JSON_TOKENER_STRICT); else json_tokener_set_flags(tok, 0); if (length == -1) length = strlen(step->string_to_parse); if (expected_char_offset == -1) expected_char_offset = length; printf("json_tokener_parse_ex(tok, %-12s, %3d) ... ", step->string_to_parse, length); new_obj = json_tokener_parse_ex(tok, step->string_to_parse, length); jerr = json_tokener_get_error(tok); if (step->expected_error != json_tokener_success) { if (new_obj != NULL) printf("ERROR: invalid object returned: %s\n", json_object_to_json_string(new_obj)); else if (jerr != step->expected_error) printf("ERROR: got wrong error: %s\n", json_tokener_error_desc(jerr)); else if (tok->char_offset != expected_char_offset) printf("ERROR: wrong char_offset %d != expected %d\n", tok->char_offset, expected_char_offset); else { printf("OK: got correct error: %s\n", json_tokener_error_desc(jerr)); this_step_ok = 1; } } else { if (new_obj == NULL) printf("ERROR: expected valid object, instead: %s\n", json_tokener_error_desc(jerr)); else if (tok->char_offset != expected_char_offset) printf("ERROR: wrong char_offset %d != expected %d\n", tok->char_offset, expected_char_offset); else { printf("OK: got object of type [%s]: %s\n", json_type_to_name(json_object_get_type(new_obj)), json_object_to_json_string(new_obj)); this_step_ok = 1; } } if (new_obj) json_object_put(new_obj); if (step->reset_tokener & 1) json_tokener_reset(tok); if (this_step_ok) num_ok++; else num_error++; } json_tokener_free(tok); printf("End Incremental Tests OK=%d ERROR=%d\n", num_ok, num_error); return; }
/** * Read the fd reader text as (a part of) a JSON object line, don't consume * terminating newline. * * @param fd_json_reader The fd reader to parse the object for. * @param pobject Location for the parsed object pointer. * * @return Global return code. */ static tlog_grc tlog_fd_json_reader_read_json(struct tlog_fd_json_reader *fd_json_reader, struct json_object **pobject) { tlog_grc grc; char *p; struct json_object *object; enum json_tokener_error jerr; bool got_text = false; assert(tlog_fd_json_reader_is_valid( (struct tlog_json_reader *)fd_json_reader)); assert(pobject != NULL); json_tokener_reset(fd_json_reader->tok); /* Until EOF */ do { /* If the buffer is not empty */ if (fd_json_reader->pos < fd_json_reader->end) { /* We got something to parse */ got_text = true; /* Look for a terminating newline */ for (p = fd_json_reader->pos; p < fd_json_reader->end && *p != '\n'; p++); /* Parse the next piece */ object = json_tokener_parse_ex(fd_json_reader->tok, fd_json_reader->pos, p - fd_json_reader->pos); fd_json_reader->pos = p; /* If we finished parsing an object */ if (object != NULL) { *pobject = object; return TLOG_RC_OK; } else { jerr = json_tokener_get_error(fd_json_reader->tok); /* If object is not finished */ if (jerr == json_tokener_continue) { /* If we encountered an object-terminating newline */ if (p < fd_json_reader->end) { return TLOG_RC_FD_JSON_READER_INCOMPLETE_LINE; } } else { return TLOG_GRC_FROM(json, jerr); } } } grc = tlog_fd_json_reader_refill_buf(fd_json_reader); if (grc != TLOG_RC_OK) return grc; } while (fd_json_reader->end > fd_json_reader->buf); if (got_text) { return TLOG_RC_FD_JSON_READER_INCOMPLETE_LINE; } else { *pobject = NULL; return TLOG_RC_OK; } }