bson* bson_from_json_str(const char* str)
{
yajl_val root;
char* errbuf;
bson *b;
errbuf = malloc( sizeof(char) * 1024 );
root = yajl_tree_parse( str, errbuf, 1024 );
if( !root )
{
puts( "Parse error: " );
if( strlen( errbuf ) )
puts( errbuf );
else
puts( "unknown error." );
yajl_tree_free( root );
free( errbuf );
return NULL;
}
free( errbuf );
assert( YAJL_IS_OBJECT( root ) );
b = malloc( sizeof( bson ) );
bson_init( b );
bson_from_json_object( b, root );
bson_finish( b );
yajl_tree_free( root );
return b;
}
/* Handle JSON data (one request) and call
* appropriate event OVS DB handler. Currently,
* update callback 'ovs_db_table_update_cb' and
* result callback 'ovs_db_result_cb' is supported.
*/
static int ovs_db_json_data_process(ovs_db_t *pdb, const char *data,
size_t len) {
const char *method = NULL;
char yajl_errbuf[OVS_YAJL_ERROR_BUFFER_SIZE];
const char *method_path[] = {"method", NULL};
const char *result_path[] = {"result", NULL};
char *sjson = NULL;
yajl_val jnode, jval;
/* duplicate the data to make null-terminated string
* required for yajl_tree_parse() */
if ((sjson = calloc(1, len + 1)) == NULL)
return -1;
sstrncpy(sjson, data, len + 1);
OVS_DEBUG("[len=%" PRIsz "] %s", len, sjson);
/* parse json data */
jnode = yajl_tree_parse(sjson, yajl_errbuf, sizeof(yajl_errbuf));
if (jnode == NULL) {
OVS_ERROR("yajl_tree_parse() %s", yajl_errbuf);
sfree(sjson);
return -1;
}
/* get method name */
if ((jval = yajl_tree_get(jnode, method_path, yajl_t_string)) != NULL) {
if ((method = YAJL_GET_STRING(jval)) == NULL) {
yajl_tree_free(jnode);
sfree(sjson);
return -1;
}
if (strcmp("echo", method) == 0) {
/* echo request from the server */
if (ovs_db_table_echo_cb(pdb, jnode) < 0)
OVS_ERROR("handle echo request failed");
} else if (strcmp("update", method) == 0) {
/* update notification */
if (ovs_db_table_update_cb(pdb, jnode) < 0)
OVS_ERROR("handle update notification failed");
}
} else if ((jval = yajl_tree_get(jnode, result_path, yajl_t_any)) != NULL) {
/* result notification */
if (ovs_db_result_cb(pdb, jnode) < 0)
OVS_ERROR("handle result reply failed");
} else
OVS_ERROR("connot find method or result failed");
/* release memory */
yajl_tree_free(jnode);
sfree(sjson);
return 0;
}
Analogsignal*
parseJSON(char* responseGnode){
yajl_val node;
char errbuf[1024];
node = yajl_tree_parse((const char *) responseGnode, errbuf, sizeof(errbuf));
const char * path[] = { "selected", 0 };
yajl_val v = yajl_tree_get(node, path, yajl_t_array);
yajl_val node2 = YAJL_GET_ARRAY(v)->values[0];
const char * path2[] = { "permalink", 0 };
yajl_val v2 = yajl_tree_get(node2, path2, yajl_t_string);
// if (v2) printf("%s: %s\n", path2[0], YAJL_GET_STRING(v2));
yajl_val node3 = YAJL_GET_OBJECT(v2);
const char * path3[] = { "fields", 0 };
yajl_val v3 = yajl_tree_get(node2, path3, yajl_t_object);
const char * path4[] = { "description", 0 };
yajl_val v4 = yajl_tree_get(v3, path4, yajl_t_string);
Analogsignal *analog = (Analogsignal *)malloc(sizeof(Analogsignal));
strcpy (analog->permalink, YAJL_GET_STRING(v2));
strcpy (analog->description, YAJL_GET_STRING(v4));
yajl_tree_free(node);
return analog;
}
/*
* Parse the json package
*/
int parse_gps_json(const char * buffer, struct gps_package * data) {
yajl_val node;
char errbuf[1024];
/* null plug buffers */
errbuf[0] = 0;
/* we have the whole config file in memory. let's parse it ... */
node = yajl_tree_parse((const char *) buffer, errbuf, sizeof(errbuf));
/* parse error handling */
/*if (node == NULL) {
fprintf(stderr, "parse_error: ");
if (strlen(errbuf)) fprintf(stderr, " %s", errbuf);
else fprintf(stderr, "unknown error");
fprintf(stderr, "\n");
return 0;
}*/
/* ... and extract a nested value from the json file */
{
const char * lat_path[] = { "lat", (const char *) 0 };
const char * lon_path[] = { "lon", (const char *) 0 };
yajl_val lat = yajl_tree_get(node, lat_path, yajl_t_number);
yajl_val lon = yajl_tree_get(node, lon_path, yajl_t_number);
if (lat) data->lat = YAJL_GET_DOUBLE(lat);
else return 0;
if (lon) data->lon = YAJL_GET_DOUBLE(lon);
else return 0;
}
yajl_tree_free(node);
return 1;
}
static rc_ReturnCode_t send_reg_payload(const char *payload, size_t payloadLen, int *regId)
{
rc_ReturnCode_t res;
char *rpayload = NULL, *respPayload = NULL;
uint32_t respPayloadLen;
yajl_val yval = NULL;
res = emp_send_and_wait_response(EMP_REGISTERSMSLISTENER, 0, payload, payloadLen, &respPayload, &respPayloadLen);
if (res != RC_OK)
goto quit;
rpayload = strndup(respPayload, respPayloadLen);
if (rpayload == NULL)
{
res = RC_NO_MEMORY;
goto quit;
}
YAJL_TREE_PARSE(yval, rpayload);
if (yval->type != yajl_t_number)
{
SWI_LOG("SMS", ERROR, "Invalid regId type received from RA, got type=%u, expected %u\n", __FUNCTION__, yval->type, yajl_t_number);
res = RC_BAD_PARAMETER;
goto quit;
}
*regId = YAJL_GET_INTEGER(yval);
quit:
yajl_tree_free(yval);
free(respPayload);
free(rpayload);
return res;
}
size_t
parse_get_response (void *ptr, size_t size, size_t nmemb, void *stream)
{
yajl_val node;
yajl_val value;
node = yajl_tree_parse(ptr,NULL,0);
if (node) {
value = my_yajl_tree_get(node,value_path,yajl_t_string);
if (value) {
/*
* YAJL probably copied it once, now we're going to
* copy it again. If anybody really cares for such
* small and infrequently used values, we'd have to do
* do something much more complicated (like using the
* stream interface) to avoid the copy. Right now it's
* just not worth it.
*/
*((char **)stream) = strdup(MY_YAJL_GET_STRING(value));
}
else {
/* Might as well try this. */
*((char **)stream) = parse_array_response(node);
}
yajl_tree_free(node);
}
return size*nmemb;
}
void FontLoadFromJSON(Font *f, const char *imgPath, const char *jsonPath)
{
yajl_val node = YAJLReadFile(jsonPath);
if (node == NULL)
{
fprintf(stderr, "Error parsing font JSON '%s'\n", jsonPath);
goto bail;
}
memset(f, 0, sizeof *f);
// Load definitions from JSON data
YAJLVec2i(&f->Size, node, "Size");
YAJLInt(&f->Stride, node, "Stride");
// Padding order is: left/top/right/bottom
const yajl_val paddingNode = YAJLFindNode(node, "Padding");
f->Padding.Left = (int)YAJL_GET_INTEGER(YAJL_GET_ARRAY(paddingNode)->values[0]);
f->Padding.Top = (int)YAJL_GET_INTEGER(YAJL_GET_ARRAY(paddingNode)->values[1]);
f->Padding.Right = (int)YAJL_GET_INTEGER(YAJL_GET_ARRAY(paddingNode)->values[2]);
f->Padding.Bottom = (int)YAJL_GET_INTEGER(YAJL_GET_ARRAY(paddingNode)->values[3]);
YAJLVec2i(&f->Gap, node, "Gap");
bool proportional = false;
YAJLBool(&proportional, node, "Proportional");
FontLoad(f, imgPath, proportional);
bail:
yajl_tree_free(node);
}
TEST_F(Yajl, yajl_tree_parse) {
for (size_t i = 0; i < kTrialCount; i++) {
yajl_val root = yajl_tree_parse(json_, NULL, 0);
ASSERT_TRUE(root != NULL);
yajl_tree_free(root);
}
}
yajl_val yajl_tree_parse_options (const char *input,
char *error_buffer, size_t error_buffer_size,
yajl_tree_option options)
{
static const yajl_callbacks callbacks =
{
/* null = */ handle_null,
/* boolean = */ handle_boolean,
/* integer = */ NULL,
/* double = */ NULL,
/* number = */ handle_number,
/* string = */ handle_string,
/* start map = */ handle_start_map,
/* map key = */ handle_string,
/* end map = */ handle_end_map,
/* start array = */ handle_start_array,
/* end array = */ handle_end_array
};
yajl_handle handle;
yajl_status status;
char * internal_err_str;
context_t ctx = { NULL, NULL, NULL, 0 };
ctx.errbuf = error_buffer;
ctx.errbuf_size = error_buffer_size;
if (error_buffer != NULL)
memset (error_buffer, 0, error_buffer_size);
handle = yajl_alloc (&callbacks, NULL, &ctx);
yajl_config(handle, yajl_allow_comments,
(options & yajl_tree_option_dont_allow_comments) ? 0 : 1);
yajl_config(handle, yajl_allow_trailing_separator,
(options & yajl_tree_option_allow_trailing_separator) ? 1 : 0);
status = yajl_parse(handle,
(unsigned char *) input,
strlen (input));
status = yajl_complete_parse (handle);
if (status != yajl_status_ok) {
if (error_buffer != NULL && error_buffer_size > 0) {
internal_err_str = (char *) yajl_get_error(handle, 1,
(const unsigned char *) input,
strlen(input));
snprintf(error_buffer, error_buffer_size, "%s", internal_err_str);
YA_FREE(&(handle->alloc), internal_err_str);
}
while (ctx.stack) {
yajl_tree_free(context_pop(&ctx));
}
yajl_free (handle);
return NULL;
}
yajl_free (handle);
return (ctx.root);
}
static char *
parse_json_get_object_string (const char *json, const char *key, int flags,
const char *func, const char *cmd)
{
char *str, *ret;
yajl_val tree = NULL, node;
size_t i, len;
tree = parse_json (json, func);
if (tree == NULL)
return NULL;
if (! YAJL_IS_OBJECT (tree))
goto bad_type;
len = YAJL_GET_OBJECT (tree)->len;
for (i = 0; i < len; ++i) {
if (STREQ (YAJL_GET_OBJECT (tree)->keys[i], key)) {
node = YAJL_GET_OBJECT (tree)->values[i];
if ((flags & GET_STRING_NULL_TO_EMPTY) && YAJL_IS_NULL (node))
ret = strdup ("");
else {
str = YAJL_GET_STRING (node);
if (str == NULL)
goto bad_type;
ret = strdup (str);
}
if (ret == NULL)
reply_with_perror ("strdup");
yajl_tree_free (tree);
return ret;
}
}
bad_type:
reply_with_error ("output of '%s' was not a JSON object "
"containing a key '%s' of type string", cmd, key);
yajl_tree_free (tree);
return NULL;
}
int webhdfs_set_times (webhdfs_t *fs, const char *path, int mtime, int atime) {
webhdfs_req_t req;
yajl_val node, v;
webhdfs_req_open(&req, fs, path);
webhdfs_req_set_args(&req, "op=SETTIMES&modificationtime=%d&accesstime=%d",
mtime, atime);
webhdfs_req_exec(&req, WEBHDFS_REQ_PUT);
node = webhdfs_req_json_response(&req);
webhdfs_req_close(&req);
if ((v = webhdfs_response_exception(node)) != NULL) {
yajl_tree_free(node);
return(1);
}
yajl_tree_free(node);
return(0);
}
webhdfs_dir_t *webhdfs_dir_open (webhdfs_t *fs,
const char *path)
{
const char *file_status[] = {"FileStatus", NULL};
webhdfs_dir_t *dir;
webhdfs_req_t req;
yajl_val node, v;
webhdfs_req_open(&req, fs, path);
webhdfs_req_set_args(&req, "op=LISTSTATUS");
char *error = NULL;
webhdfs_req_exec(&req, WEBHDFS_REQ_GET, &error);
if (error) free(error);
node = webhdfs_req_json_response(&req);
webhdfs_req_close(&req);
if ((v = webhdfs_response_exception(node)) != NULL) {
yajl_tree_free(node);
return(NULL);
}
if ((v = webhdfs_response_file_statuses(node)) == NULL) {
yajl_tree_free(node);
return(NULL);
}
if ((v = yajl_tree_get(v, file_status, yajl_t_array)) == NULL) {
yajl_tree_free(node);
return(NULL);
}
if ((dir = (webhdfs_dir_t *) malloc(sizeof(webhdfs_dir_t))) == NULL) {
yajl_tree_free(node);
return(NULL);
}
dir->root = node;
dir->statuses = v;
dir->current = 0;
return(dir);
}
int webhdfs_chmod (webhdfs_t *fs, const char *path, int permission) {
webhdfs_req_t req;
yajl_val node, v;
webhdfs_req_open(&req, fs, path);
webhdfs_req_set_args(&req, "op=SETPERMISSION&permission=%o", permission);
char *error = NULL;
webhdfs_req_exec(&req, WEBHDFS_REQ_PUT, &error);
if (error) free(error);
node = webhdfs_req_json_response(&req);
webhdfs_req_close(&req);
if ((v = webhdfs_response_exception(node)) != NULL) {
yajl_tree_free(node);
return(1);
}
yajl_tree_free(node);
return(0);
}
static rc_ReturnCode_t newSmsHdlr(uint32_t payloadsize, char* payload)
{
int regId;
rc_ReturnCode_t res = RC_OK;
cb_list_t *entry;
char *sender, *message, *jsonPayload;
yajl_val yval;
jsonPayload = malloc(payloadsize + 1);
memcpy(jsonPayload, payload, payloadsize);
jsonPayload[payloadsize] = '\0';
YAJL_TREE_PARSE(yval, jsonPayload);
if (yval->u.array.values[0]->type != yajl_t_string)
{
SWI_LOG("SMS", ERROR, "%s: sender is not an string, got type=%d\n", __FUNCTION__, yval->u.array.values[0]->type);
res = RC_BAD_PARAMETER;
goto quit;
}
sender = YAJL_GET_STRING(yval->u.array.values[0]);
if (yval->u.array.values[1]->type != yajl_t_string)
{
SWI_LOG("SMS", ERROR, "%s: message is not an string, got type=%d\n", __FUNCTION__, yval->u.array.values[1]->type);
res = RC_BAD_PARAMETER;
goto quit;
}
message = YAJL_GET_STRING(yval->u.array.values[1]);
if (yval->u.array.values[2]->type != yajl_t_number)
{
SWI_LOG("SMS", ERROR, "%s: regId is not an number, got type=%d\n", __FUNCTION__, yval->u.array.values[2]->type);
res = RC_BAD_PARAMETER;
goto quit;
}
regId = YAJL_GET_INTEGER(yval->u.array.values[2]);
pthread_mutex_lock(&handler_lock);
for (entry = cb_list; entry; entry = entry->next)
{
if (entry->regId == regId)
{
entry->cb(sender, message);
break;
}
}
pthread_mutex_unlock(&handler_lock);
quit:
free(jsonPayload);
emp_freemessage(payload);
yajl_tree_free(yval);
return res;
}
int webhdfs_chmod (webhdfs_t *fs, const char *path, int permission) {
webhdfs_req_t req;
yajl_val node, v;
webhdfs_req_open(&req, fs, path);
// the permission must be in radix-8 format and it's maximal value is 777
int short_permission = permission % (8 * 8 * 8);
webhdfs_req_set_args(&req, "op=SETPERMISSION&permission=%o", short_permission);
webhdfs_req_exec(&req, WEBHDFS_REQ_PUT);
node = webhdfs_req_json_response(&req);
webhdfs_req_close(&req);
if ((v = webhdfs_response_exception(node)) != NULL) {
yajl_tree_free(node);
return(1);
}
yajl_tree_free(node);
return(0);
}
bool JSONParser::parse(const String& json)
{
char errbuf[128];
yajl_val value = yajl_tree_parse(json.constData(), errbuf, sizeof(errbuf));
if (!value) {
mRoot = Value(); // just in case
return false;
}
mRoot = yajlValueToValue(value);
yajl_tree_free(value);
return isValid();
}
int load_()
{
int err = 0;
yajl_val js_configs = parse_config_file_();
if (js_configs == NULL) {
err = wsn_last_err();
} else {
err = translate_configs_(js_configs);
yajl_tree_free(js_configs);
}
return err;
}
int webhdfs_chown (webhdfs_t *fs,
const char *path,
const char *user,
const char *group)
{
webhdfs_req_t req;
yajl_val node, v;
webhdfs_req_open(&req, fs, path);
webhdfs_req_set_args(&req, "op=SETOWNER&user=%s&group=%s", user, group);
webhdfs_req_exec(&req, WEBHDFS_REQ_PUT);
node = webhdfs_req_json_response(&req);
webhdfs_req_close(&req);
if ((v = webhdfs_response_exception(node)) != NULL) {
yajl_tree_free(node);
return(1);
}
yajl_tree_free(node);
return(0);
}
void utils_decrypt_report(const char *report)
{
int decrypt_len;
char *dec;
memset(decrypted_report, 0, sizeof(decrypted_report));
yajl_val json_node = yajl_tree_parse(report, NULL, 0);
if (!json_node) {
strcpy(decrypted_report, "/* error: Failed to parse report. */");
return;
}
size_t i, r = json_node->u.object.len;
for (i = 0; i < r; i++) {
const char *ciphertext_path[] = { cmd_str(CMD_ciphertext), (const char *) 0 };
const char *echo_path[] = { "echo", (const char *) 0 };
const char *ciphertext = YAJL_GET_STRING(yajl_tree_get(json_node, ciphertext_path,
yajl_t_string));
const char *echo = YAJL_GET_STRING(yajl_tree_get(json_node, echo_path, yajl_t_string));
if (ciphertext) {
dec = aes_cbc_b64_decrypt((const unsigned char *)ciphertext, strlens(ciphertext),
&decrypt_len, PASSWORD_STAND);
if (!dec) {
strcpy(decrypted_report, "/* error: Failed to decrypt. */");
goto exit;
}
sprintf(decrypted_report, "/* ciphertext */ %.*s", decrypt_len, dec);
free(dec);
goto exit;
} else if (echo) {
dec = aes_cbc_b64_decrypt((const unsigned char *)echo, strlens(echo), &decrypt_len,
PASSWORD_VERIFY);
if (!dec) {
strcpy(decrypted_report, "/* error: Failed to decrypt echo. */");
goto exit;
}
sprintf(decrypted_report, "/* echo */ %.*s", decrypt_len, dec);
free(dec);
goto exit;
}
}
strcpy(decrypted_report, report);
exit:
yajl_tree_free(json_node);
return;
}
int webhdfs_mkdir (webhdfs_t *fs, const char *path, int permission) {
webhdfs_req_t req;
yajl_val node, v;
webhdfs_req_open(&req, fs, path);
webhdfs_req_set_args(&req, "op=MKDIRS&permission=%o", permission);
webhdfs_req_exec(&req, WEBHDFS_REQ_PUT);
node = webhdfs_req_json_response(&req);
webhdfs_req_close(&req);
if ((v = webhdfs_response_exception(node)) != NULL) {
yajl_tree_free(node);
return(1);
}
if ((v = webhdfs_response_boolean(node)) != NULL) {
int failure = YAJL_IS_FALSE(v);
yajl_tree_free(node);
return(failure);
}
yajl_tree_free(node);
return(2);
}
int webhdfs_set_replication (webhdfs_t *fs, const char *path, int replication) {
webhdfs_req_t req;
yajl_val node, v;
webhdfs_req_open(&req, fs, path);
webhdfs_req_set_args(&req, "op=SETREPLICATION&replication=%d", replication);
webhdfs_req_exec(&req, WEBHDFS_REQ_PUT);
node = webhdfs_req_json_response(&req);
webhdfs_req_close(&req);
if ((v = webhdfs_response_exception(node)) != NULL) {
yajl_tree_free(node);
return(1);
}
if ((v = webhdfs_response_boolean(node)) != NULL) {
int failure = YAJL_IS_FALSE(v);
yajl_tree_free(node);
return(failure);
}
yajl_tree_free(node);
return(2);
}
char *webhdfs_home_dir (webhdfs_t *fs) {
webhdfs_req_t req;
yajl_val node, v;
webhdfs_req_open(&req, fs, NULL);
webhdfs_req_set_args(&req, "op=GETHOMEDIRECTORY");
webhdfs_req_exec(&req, WEBHDFS_REQ_GET);
node = webhdfs_req_json_response(&req);
webhdfs_req_close(&req);
if ((v = webhdfs_response_exception(node)) != NULL) {
yajl_tree_free(node);
return(NULL);
}
if ((v = webhdfs_response_path(node)) != NULL) {
char *path = strdup(YAJL_GET_STRING(v));
yajl_tree_free(node);
return(path);
}
yajl_tree_free(node);
return(NULL);
}
int webhdfs_rename_snapshot (webhdfs_t *fs, const char *path, const char *oldname, const char *newname) {
webhdfs_req_t req;
yajl_val node, v;
webhdfs_req_open(&req, fs, path);
webhdfs_req_set_args(&req, "op=RENAMESNAPSHOT&oldsnapshotname=%s&snapshotname=%s", oldname, newname);
webhdfs_req_exec(&req, WEBHDFS_REQ_PUT);
node = webhdfs_req_json_response(&req);
webhdfs_req_close(&req);
if ((v = webhdfs_response_exception(node)) != NULL) {
yajl_tree_free(node);
return(1);
}
if ((v = webhdfs_response_boolean(node)) != NULL) {
int failure = YAJL_IS_FALSE(v);
yajl_tree_free(node);
return(failure);
}
yajl_tree_free(node);
return(2);
}
static void yajl_array_free (yajl_val v)
{
size_t i;
if (!YAJL_IS_ARRAY(v)) return;
for (i = 0; i < v->u.array.len; i++)
{
yajl_tree_free (v->u.array.values[i]);
v->u.array.values[i] = NULL;
}
free(v->u.array.values);
free(v);
}
int
main(void)
{
size_t rd;
yajl_val node;
char errbuf[1024];
/* null plug buffers */
fileData[0] = errbuf[0] = 0;
/* read the entire config file */
rd = fread((void*)fileData, 1, sizeof(fileData) - 1, stdin);
/* file read error handling */
if (rd == 0 && !feof(stdin)) {
fprintf(stderr, "error encountered on file read\n");
return 1;
} else if (rd >= sizeof(fileData) - 1) {
fprintf(stderr, "config file too big\n");
return 1;
}
/* we have the whole config file in memory. let's parse it ... */
node = yajl_tree_parse((const char*)fileData, errbuf, sizeof(errbuf));
/* parse error handling */
if (node == NULL) {
fprintf(stderr, "parse_error: ");
if (strlen(errbuf)) fprintf(stderr, " %s", errbuf);
else fprintf(stderr, "unknown error");
fprintf(stderr, "\n");
return 1;
}
/* ... and extract a nested value from the config file */
{
const char * path[] = { "Logging", "timeFormat", (const char*)0 };
yajl_val v = yajl_tree_get(node, path, yajl_t_string);
if (v) printf("%s/%s: %s\n", path[0], path[1], YAJL_GET_STRING(v));
else printf("no such node: %s/%s\n", path[0], path[1]);
}
yajl_tree_free(node);
return 0;
}
static void yajl_object_free (yajl_val v)
{
size_t i;
if (!YAJL_IS_OBJECT(v)) return;
for (i = 0; i < v->u.object.len; i++)
{
free((char *) v->u.object.keys[i]);
v->u.object.keys[i] = NULL;
yajl_tree_free (v->u.object.values[i]);
v->u.object.values[i] = NULL;
}
free((void*) v->u.object.keys);
free(v->u.object.values);
free(v);
}
SEXP R_parse(SEXP x, SEXP bigint_as_char) {
/* get data from R */
const char* json = translateCharUTF8(asChar(x));
const int bigint = asLogical(bigint_as_char);
/* ignore BOM as suggested by RFC */
if(json[0] == '\xEF' && json[1] == '\xBB' && json[2] == '\xBF'){
warning("JSON string contains (illegal) UTF8 byte-order-mark!");
json = json + 3;
}
/* parse json */
char errbuf[1024];
yajl_val node = yajl_tree_parse(json, errbuf, sizeof(errbuf));
/* parser error */
if (!node) {
error(errbuf);
}
SEXP out = ParseValue(node, bigint);
yajl_tree_free(node);
return(out);
}
~State()
{
yajl_tree_free(mTree); mTree = NULL;
}
int ovs_db_send_request(ovs_db_t *pdb, const char *method, const char *params,
ovs_db_result_cb_t cb) {
int ret = 0;
yajl_gen_status yajl_gen_ret;
yajl_val jparams;
yajl_gen jgen;
ovs_callback_t *new_cb = NULL;
uint64_t uid;
char uid_buff[OVS_UID_STR_SIZE];
const char *req = NULL;
size_t req_len = 0;
struct timespec ts;
/* sanity check */
if (!pdb || !method || !params)
return -1;
if ((jgen = yajl_gen_alloc(NULL)) == NULL)
return -1;
/* try to parse params */
if ((jparams = yajl_tree_parse(params, NULL, 0)) == NULL) {
OVS_ERROR("params is not a JSON string");
yajl_gen_clear(jgen);
return -1;
}
/* generate method field */
OVS_YAJL_CALL(yajl_gen_map_open, jgen);
OVS_YAJL_CALL(ovs_yajl_gen_tstring, jgen, "method");
OVS_YAJL_CALL(ovs_yajl_gen_tstring, jgen, method);
/* generate params field */
OVS_YAJL_CALL(ovs_yajl_gen_tstring, jgen, "params");
OVS_YAJL_CALL(ovs_yajl_gen_val, jgen, jparams);
yajl_tree_free(jparams);
/* generate id field */
OVS_YAJL_CALL(ovs_yajl_gen_tstring, jgen, "id");
uid = ovs_uid_generate();
snprintf(uid_buff, sizeof(uid_buff), "%" PRIX64, uid);
OVS_YAJL_CALL(ovs_yajl_gen_tstring, jgen, uid_buff);
OVS_YAJL_CALL(yajl_gen_map_close, jgen);
if (cb) {
/* register result callback */
if ((new_cb = calloc(1, sizeof(*new_cb))) == NULL)
goto yajl_gen_failure;
/* add new callback to front */
sem_init(&new_cb->result.sync, 0, 0);
new_cb->result.call = cb;
new_cb->uid = uid;
ovs_db_callback_add(pdb, new_cb);
}
/* send the request */
OVS_YAJL_CALL(yajl_gen_get_buf, jgen, (const unsigned char **)&req, &req_len);
OVS_DEBUG("%s", req);
if (!ovs_db_data_send(pdb, req, req_len)) {
if (cb) {
/* wait for result */
clock_gettime(CLOCK_REALTIME, &ts);
ts.tv_sec += OVS_DB_SEND_REQ_TIMEOUT;
if (sem_timedwait(&new_cb->result.sync, &ts) < 0) {
OVS_ERROR("%s() no replay received within %d sec", __FUNCTION__,
OVS_DB_SEND_REQ_TIMEOUT);
ret = (-1);
}
}
} else {
OVS_ERROR("ovs_db_data_send() failed");
ret = (-1);
}
yajl_gen_failure:
if (new_cb) {
/* destroy callback */
sem_destroy(&new_cb->result.sync);
ovs_db_callback_remove(pdb, new_cb);
}
/* release memory */
yajl_gen_clear(jgen);
return (yajl_gen_ret != yajl_gen_status_ok) ? (-1) : ret;
}
webhdfs_fstat_t *webhdfs_stat (webhdfs_t *fs,
const char *path,
char **error) {
const char *pathSuffix[] = {"pathSuffix", NULL};
const char *replication[] = {"replication", NULL};
const char *permission[] = {"permission", NULL};
const char *length[] = {"length", NULL};
const char *group[] = {"group", NULL};
const char *owner[] = {"owner", NULL};
const char *type[] = {"type", NULL};
const char *mtime[] = {"modificationTime", NULL};
const char *block[] = {"blockSize", NULL};
const char *atime[] = {"accessTime", NULL};
yajl_val root, node, v;
webhdfs_fstat_t *stat;
webhdfs_req_t req;
webhdfs_req_open(&req, fs, path);
webhdfs_req_set_args(&req, "op=GETFILESTATUS");
char *error2 = NULL;
int ret = -1;
if ((ret = webhdfs_req_exec(&req, WEBHDFS_REQ_GET, &error2)) != 0) {
*error = __strdup(error2);
free(error2);
webhdfs_req_close(&req);
return(NULL);
}
root = webhdfs_req_json_response(&req);
webhdfs_req_close(&req);
if ((v = webhdfs_response_exception(root)) != NULL) {
// const char *exceptionNode[] = {"exception", NULL};
// yajl_val exception = yajl_tree_get(v, exceptionNode , yajl_t_string);
// YAJL_GET_STRING(exception);
const char *messageNode[] = {"message", NULL};
yajl_val message = yajl_tree_get(v, messageNode, yajl_t_string);
*error = __strdup(YAJL_GET_STRING(message));
yajl_tree_free(root);
return(NULL);
}
if ((node = webhdfs_response_file_status(root)) == NULL) {
yajl_tree_free(root);
return(NULL);
}
if ((stat = (webhdfs_fstat_t *) malloc(sizeof(webhdfs_fstat_t))) == NULL) {
yajl_tree_free(root);
return(NULL);
}
memset(stat, 0, sizeof(webhdfs_fstat_t));
if ((v = yajl_tree_get(node, atime, yajl_t_number)))
stat->atime = YAJL_GET_INTEGER(v);
if ((v = yajl_tree_get(node, mtime, yajl_t_number)))
stat->mtime = YAJL_GET_INTEGER(v);
if ((v = yajl_tree_get(node, length, yajl_t_number)))
stat->length = YAJL_GET_INTEGER(v);
if ((v = yajl_tree_get(node, block, yajl_t_number)))
stat->block = YAJL_GET_INTEGER(v);
if ((v = yajl_tree_get(node, replication, yajl_t_number)))
stat->replication = YAJL_GET_INTEGER(v);
if ((v = yajl_tree_get(node, permission, yajl_t_string)))
stat->permission = strtol(YAJL_GET_STRING(v), NULL, 8);
if ((v = yajl_tree_get(node, pathSuffix, yajl_t_string)))
stat->path = __strdup(YAJL_GET_STRING(v));
if ((v = yajl_tree_get(node, group, yajl_t_string)))
stat->group = __strdup(YAJL_GET_STRING(v));
if ((v = yajl_tree_get(node, owner, yajl_t_string)))
stat->owner = __strdup(YAJL_GET_STRING(v));
if ((v = yajl_tree_get(node, type, yajl_t_string)))
stat->type = __strdup(YAJL_GET_STRING(v));
yajl_tree_free(root);
return(stat);
}