Permalink
Switch branches/tags
Nothing to show
Find file
Fetching contributors…
Cannot retrieve contributors at this time
794 lines (703 sloc) 21.6 KB
#include <stdio.h>
#include <stdlib.h>
#include <argp.h>
#include <stdarg.h>
#include <json/json.h>
#include "parsley.h"
#include "y.tab.h"
#include <json/printbuf.h>
#include "functions.h"
#include "util.h"
#include <string.h>
#include <errno.h>
#include <ctype.h>
#include <stdbool.h>
#include <libxslt/xslt.h>
#include <libxslt/xsltInternals.h>
#include <libxslt/transform.h>
#include <libxml/tree.h>
#include <libxml/parser.h>
#include <libxml/debugXML.h>
#include <libxml/HTMLparser.h>
#include <libxml/HTMLtree.h>
#include <libxml/xmlwriter.h>
#include <libxml/xmlerror.h>
#include <libxml/debugXML.h>
#include <libexslt/exslt.h>
int yywrap(void){
return 1;
}
struct ll {
xmlChar *name;
struct ll *next;
};
static char*
arepl(char* orig, char* old, char* new) {
// printf("y\n");
char* ptr = strdup(orig);
int nlen = strlen(new);
int olen = strlen(old);
char* i;
struct printbuf * buf = printbuf_new();
while((i = strstr(ptr, old)) != NULL) {
printbuf_memappend(buf, ptr, i - ptr);
printbuf_memappend(buf, new, nlen);
ptr = i + olen;
}
printbuf_memappend(buf, ptr, strlen(ptr));
ptr = strdup(buf->buf);
printbuf_free(buf);
return ptr;
}
static char *
full_key_name(contextPtr c) {
if(c == NULL || c->parent == NULL) return strdup("/");
static struct ll * last = NULL;
while(c->parent != NULL) {
if(c->tag != NULL) {
struct ll * ptr = calloc(sizeof(struct ll), 1);
ptr->name = c->tag;
ptr->next = last;
last = ptr;
}
c = c->parent;
}
struct printbuf *buf = printbuf_new();
while(last != NULL) {
sprintbuf(buf, "/%s", last->name);
last = last->next;
}
char *out = strdup(buf->buf);
printbuf_free(buf);
return out;
}
void parsed_parsley_free(parsedParsleyPtr ptr) {
if(ptr->xml != NULL) xmlFree(ptr->xml);
if(ptr->error != NULL) free(ptr->error);
free(ptr);
}
static parsedParsleyPtr parse_error(char* format, ...) {
parsedParsleyPtr ptr = (parsedParsleyPtr) calloc(sizeof(parsed_parsley), 1);
ptr->xml = NULL;
va_list args;
va_start(args, format);
vasprintf(&ptr->error, format, args);
va_end(args);
return ptr;
}
parsedParsleyPtr parsley_parse_file(parsleyPtr parsley, char* file, int flags) {
xmlSetGenericErrorFunc(NULL , parsleyXsltError);
bool html = flags & PARSLEY_OPTIONS_HTML;
char * encoding = flags & PARSLEY_OPTIONS_FORCE_UTF8 ? "UTF-8" : NULL;
if(html) {
htmlParserCtxtPtr htmlCtxt = htmlNewParserCtxt();
htmlDocPtr html = htmlCtxtReadFile(htmlCtxt, file, encoding, HTML_PARSE_RECOVER | HTML_PARSE_NOERROR |HTML_PARSE_NOWARNING);
htmlFreeParserCtxt(htmlCtxt);
if(html == NULL) return parse_error("Couldn't parse file: %s\n", file);
parsedParsleyPtr out = parsley_parse_doc(parsley, html, flags);
xmlFreeDoc(html);
return out;
} else {
xmlParserCtxtPtr ctxt = xmlNewParserCtxt();
xmlDocPtr xml = xmlCtxtReadFile(ctxt, file, encoding, HTML_PARSE_RECOVER | HTML_PARSE_NOERROR |HTML_PARSE_NOWARNING);
xmlFreeParserCtxt(ctxt);
if(xml == NULL) return parse_error("Couldn't parse file: %s\n", file);
parsedParsleyPtr out = parsley_parse_doc(parsley, xml, flags);
xmlFreeDoc(xml);
return out;
}
}
parsedParsleyPtr parsley_parse_string(parsleyPtr parsley, char* string, size_t size, char* base_uri, int flags) {
xmlSetGenericErrorFunc(NULL , parsleyXsltError);
bool html = flags & PARSLEY_OPTIONS_HTML;
char * encoding = flags & PARSLEY_OPTIONS_FORCE_UTF8 ? "UTF-8" : NULL;
if(base_uri == NULL) base_uri = "http://parselets.com/in-memory-string";
if(html) {
htmlParserCtxtPtr htmlCtxt = htmlNewParserCtxt();
htmlDocPtr html = htmlCtxtReadMemory(htmlCtxt, string, size, base_uri, encoding, HTML_PARSE_RECOVER | HTML_PARSE_NOERROR |HTML_PARSE_NOWARNING);
if(html == NULL) return parse_error("Couldn't parse string");
parsedParsleyPtr out = parsley_parse_doc(parsley, html, flags);
xmlFreeDoc(html);
return out;
} else {
xmlParserCtxtPtr ctxt = xmlNewParserCtxt();
xmlDocPtr xml = xmlCtxtReadMemory(ctxt, string, size, base_uri, encoding, HTML_PARSE_RECOVER | HTML_PARSE_NOERROR |HTML_PARSE_NOWARNING);
if(xml == NULL) return parse_error("Couldn't parse string");
parsedParsleyPtr out = parsley_parse_doc(parsley, xml, flags);
xmlFreeDoc(xml);
return out;
}
}
static char *
xpath_of(xmlNodePtr node) {
if(node == NULL || node->name == NULL || node->parent == NULL) return strdup("/");
struct ll * ptr = (struct ll *) calloc(sizeof(struct ll), 1);
while(node->name != NULL && node->parent != NULL) {
if(node->ns == NULL) {
struct ll * tmp = (struct ll *) calloc(sizeof(struct ll), 1);
tmp->name = node->name;
tmp->next = ptr;
ptr = tmp;
}
node = node->parent;
}
struct printbuf *buf = printbuf_new();
sprintbuf(buf, "");
while(ptr->name != NULL) {
sprintbuf(buf, "/%s", ptr->name);
struct ll * last = ptr;
ptr = ptr->next;
free(last);
}
free(ptr);
char *str = strdup(strlen(buf->buf) ? buf->buf : "/");
printbuf_free(buf);
return str;
}
static bool
is_root(xmlNodePtr node) {
return node != NULL && node->ns != NULL && !strcmp(node->ns->prefix, "parsley") && !strcmp(node->name, "root");
}
int compare_pos (const void * a, const void * b)
{
char* as = xmlGetProp(*(xmlNodePtr*)a, "position");
char* bs = xmlGetProp(*(xmlNodePtr*)b, "position");
return atoi(as) - atoi(bs);
}
static void
_xmlAddChild(xmlNodePtr parent, xmlNodePtr child) {
xmlNodePtr node = parent->children;
if(node == NULL) {
parent->children = child;
return;
}
while(node->next != NULL){
node = node->next;
}
node->next = child;
}
static int
_xmlChildElementCount(xmlNodePtr n) {
xmlNodePtr child = n->children;
int i = 0;
while(child != NULL) {
i++;
child = child->next;
}
return i;
}
static bool
xml_empty(xmlNodePtr xml) {
// fprintf(stderr, "%s\n", xml->name);
xmlNodePtr child = xml->children;
while(child != NULL) {
if(child->type != XML_TEXT_NODE) return false;
if(strlen(child->content)) return false;
child = child->next;
}
// printf("hello!\n");
return true;
}
static void
collate(xmlNodePtr xml) {
if(xml == NULL) return ;
if(xml->type != XML_ELEMENT_NODE) return;
if(xml->ns != NULL && !strcmp(xml->ns->prefix, "parsley") && !strcmp(xml->name, "zipped")){
xmlNodePtr parent = xml->parent;
xmlNodePtr child = xml->children;
if(child == NULL) return;
int n = _xmlChildElementCount(xml);
xmlNodePtr* name_nodes = calloc(n, sizeof(xmlNodePtr));
xmlNodePtr* lists = calloc(n, sizeof(xmlNodePtr));
bool* empty = calloc(n, sizeof(bool));
bool* multi = calloc(n, sizeof(bool));
bool* optional = calloc(n, sizeof(bool));
int len = 0;
for(int i = 0; i < n; i++) {
name_nodes[i] = child;
if(child->children == NULL) {
lists[i] = NULL;
} else {
lists[i] = child->children;
multi[i] = false;
optional[i] = xmlGetProp(name_nodes[i], "optional") != NULL;
if(lists[i] != NULL && !strcmp(lists[i]->name, "groups")) {
lists[i] = lists[i]->children;
multi[i] = true;
}
if(lists[i] != NULL) {
lists[i]->parent->extra = i;
len += _xmlChildElementCount(lists[i]->parent);
}
child->children = NULL;
}
child = child->next;
}
xml->children = NULL;
xmlNodePtr* sortable = malloc(len * sizeof(xmlNodePtr));
int j = 0;
for(int i = 0; i < n; i++) {
xmlNodePtr node = lists[i];
while(node != NULL){
sortable[j++] = node;
// printf("%d/%d: %d/%d\n", i, n, j, len);
node = node->next;
}
}
for(int i = 0; i < len; i++) {
sortable[i]->next = NULL;
}
qsort(sortable, len, sizeof(xmlNodePtr), compare_pos);
xmlNodePtr groups = xml->parent;
groups->children = NULL;
xmlNodePtr group;
xmlNodePtr* targets = calloc(sizeof(xmlNodePtr), n);
for(j = 0; j < len; j++) {
int i = sortable[j]->parent->extra;
if (j == 0 || (!empty[i] && !multi[i] && !optional[i])) { // first or full
xmlNodePtr group = xmlNewChild(groups, xml->ns, "group", NULL); //new group
xmlSetProp(group, "optional", "true");
for(int k = 0; k < n; k++) {
empty[k] = true;
targets[k] = xmlCopyNode(name_nodes[k], 2);
_xmlAddChild(group, targets[k]);
if(multi[k]) targets[k] = xmlNewChild(targets[k], xml->ns, "groups", NULL);
}
}
if(!multi[i]) sortable[j] = sortable[j]->children;
if(empty[i] || multi[i]) _xmlAddChild(targets[i], sortable[j]);
empty[i] = false;
}
free(targets);
free(name_nodes);
free(lists);
free(optional);
free(empty);
free(multi);
free(sortable);
collate(groups);
} else {
xmlNodePtr child = xml->children;
while(child != NULL){
collate(child);
child = child->next;
}
}
}
void
parsley_set_user_agent(char const * agent) {
_parsley_set_user_agent(agent);
}
static void
unlink(xmlNodePtr parent, xmlNodePtr child) {
if(child == NULL || parent == NULL) return;
xmlNodePtr ptr = parent->children;
if(ptr == child) {
parent->children = child->next;
if(child->next != NULL) {
child->next->prev = NULL;
}
} else {
while(ptr != NULL) {
if(ptr->next == child) {
ptr->next = child->next;
if(child->next) child->next->prev = ptr;
}
ptr = ptr->next;
}
}
child->next = NULL;
child->prev = NULL;
child->parent = NULL;
}
static void
visit(parsedParsleyPtr ptr, xmlNodePtr xml, char* err);
static void
prune(parsedParsleyPtr ptr, xmlNodePtr xml, char* err) {
if(xml == NULL || is_root(xml)) return;
bool optional = xmlGetProp(xml, "optional") != NULL;
if(optional) {
xmlNodePtr parent = xml->parent;
unlink(parent, xml);
free(err);
err = NULL;
visit(ptr, parent, err);
return;
} else {
if(err == NULL) asprintf(&err, "%s was empty", xpath_of(xml));
if(!is_root(xml->parent)) {
// fprintf(stderr, "prune up: %s\n", xml->parent->name);
prune(ptr, xml->parent, err);
} else {
// fprintf(stderr, "error out\n");
ptr->error = err;
}
}
}
static void
visit(parsedParsleyPtr ptr, xmlNodePtr xml, char* err) {
if(xml == NULL) return;
// printf("trying to visit: %s\n", xml->name);
if(xml->type != XML_ELEMENT_NODE) return;
xmlNodePtr child = xml->children;
xmlNodePtr parent = xml->parent;
if(parent == NULL) return;
// printf("passed guard clause: %s\n", xml->name);
if(xml_empty(xml)) {
if(err == NULL) asprintf(&err, "%s was empty", xpath_of(xml));
prune(ptr, xml, err);
} else if(err != NULL) {
free(err);
}
while(err == NULL && child != NULL){
child->parent = xml;
visit(ptr, child, err);
child = child->next;
}
}
static parsedParsleyPtr current_ptr = NULL;
void
parsleyXsltError(void * ctx, const char * msg, ...) {
if(current_ptr == NULL) return;
va_list ap;
va_start(ap, msg);
if(current_ptr->error == NULL) {
char *tmp;
char *tmp2;
vasprintf(&tmp, msg, ap);
tmp2 = arepl(tmp, "xmlXPathCompOpEval: ", "");
current_ptr->error = arepl(tmp2, "\n", "");
free(tmp);
free(tmp2);
}
va_end(ap);
}
static bool
hasDefaultNS(xmlDocPtr doc) {
return xmlSearchNs(doc, doc->children, NULL) != NULL;
}
static void
_killDefaultNS(xmlNodePtr node) {
if(node == NULL) return;
xmlNsPtr ns = node->nsDef;
if(ns != NULL) {
if(ns->prefix == NULL) node->nsDef = ns->next;
xmlNsPtr prev = ns;
while(ns = ns->next) {
if(ns->prefix == NULL) prev->next = ns->next;
}
}
ns = node->ns;
if(ns != NULL) {
if(ns->prefix == NULL) node->ns = ns->next;
xmlNsPtr prev = ns;
while(ns = ns->next) {
if(ns->prefix == NULL) prev->next = ns->next;
}
}
_killDefaultNS(node->children);
_killDefaultNS(node->next);
}
void
killDefaultNS(xmlDocPtr doc) {
if(hasDefaultNS(doc)) {
_killDefaultNS(doc->children);
}
}
parsedParsleyPtr parsley_parse_doc(parsleyPtr parsley, xmlDocPtr doc, int flags) {
killDefaultNS(doc);
parsedParsleyPtr ptr = (parsedParsleyPtr) calloc(sizeof(parsed_parsley), 1);
ptr->error = NULL;
ptr->parsley = parsley;
parsley_io_set_mode(flags);
xsltTransformContextPtr ctxt = xsltNewTransformContext(parsley->stylesheet, doc);
xmlSetGenericErrorFunc(ctxt, parsleyXsltError);
current_ptr = ptr;
if(flags & PARSLEY_OPTIONS_SGWRAP) {
doc = parsley_apply_span_wrap(doc);
}
ptr->xml = xsltApplyStylesheetUser(parsley->stylesheet, doc, NULL, NULL, NULL, ctxt);
xsltFreeTransformContext(ctxt);
current_ptr = NULL;
if(ptr->error == NULL) {
if(ptr->xml != NULL && ptr->error == NULL) {
if(flags & PARSLEY_OPTIONS_COLLATE) collate(ptr->xml->children);
if(flags & PARSLEY_OPTIONS_PRUNE) visit(ptr, ptr->xml->children, NULL);
}
if(ptr->xml == NULL && ptr->error == NULL) { // == NULL
ptr->error = strdup("Internal runtime error");
}
}
return ptr;
}
static bool
json_invalid_object(parsleyPtr ptr, struct json_object *json) {
json_object_object_foreach(json, key, val) {
if(val==NULL) ptr->error = strdup("Parselets can only be made up of strings, arrays, and objects.");
switch(json_object_get_type(val)) {
case json_type_string:
break;
case json_type_array:
if(json_object_array_length(val) != 1) {
ptr->error = strdup("Parselet arrays should have length 1.");
return true;
}
struct json_object * inner = json_object_array_get_idx(val, 0);
switch(json_object_get_type(inner)) {
case json_type_string:
break;
case json_type_object:
if(json_invalid_object(ptr, inner)) return true;
break;
default:
ptr->error = strdup("Arrays may contain either a single string or an object.");
return true;
}
break;
case json_type_object:
if(json_invalid_object(ptr, val)) {
return true;
}
break;
default:
ptr->error = strdup("Parselets can only be made up of strings, arrays, and objects.");
}
if(val == NULL || !json_object_is_type(val, json_type_string)) return false;
}
return false;
}
static bool
json_invalid(parsleyPtr ptr, struct json_object *json) {
if(!json_object_is_type(json, json_type_object)) {
ptr->error = strdup("The parselet root must be an object");
return true;
}
return json_invalid_object(ptr, json);
}
static void free_context(contextPtr c) {
if(c == NULL) return;
if(c->tag != NULL) free(c->tag);
if(c->filter != NULL) pxpath_free(c->filter);
if(c->expr != NULL) pxpath_free(c->expr);
if(c->parent != NULL && c->parent->child != NULL) {
if(c->parent->child == c) {
c->parent->child = NULL;
} else {
contextPtr ptr = c->parent->child;
while(ptr->next != NULL) {
if(ptr->next == c) {
ptr->next = NULL;
} else {
ptr = ptr->next;
}
}
}
}
if(c->next != NULL) free_context(c->next);
if(c->child != NULL) free_context(c->child);
free(c);
}
static contextPtr
new_context(struct json_object * json, xmlNodePtr node) {
contextPtr c = calloc(sizeof(parsley_context), 1);
c->node = node;
c->ns = node->ns;
c->tag = strdup("root");
c->expr = pxpath_new_path(1, "/");
c->json = json;
return c;
}
parsleyPtr parsley_compile(char* parsley_str, char* incl) {
parsleyPtr parsley = (parsleyPtr) calloc(sizeof(compiled_parsley), 1);
if(last_parsley_error != NULL) {
free(last_parsley_error);
last_parsley_error = NULL;
}
registerEXSLT();
// struct json_tokener *tok = json_tokener_new();
// struct json_object *json = json_tokener_parse_ex(tok, parsley_str);
//
struct json_tokener *tok = json_tokener_new();
struct json_object *json = json_tokener_parse_ex(tok, parsley_str, -1);
int error_offset = tok->char_offset;
if(tok->err != json_tokener_success)
json = error_ptr(-tok->err);
json_tokener_free(tok);
if(is_error(json)) {
asprintf(&(parsley->error), "Your parselet is not valid json: %s at char:%d", json_tokener_errors[-(unsigned long) json], error_offset);
return parsley;
}
if(json_invalid(parsley, json)) {
// fprintf(stderr, "Invalid parselet structure: %s\n", parsley->error);
return parsley;
}
xmlNodePtr node = new_stylesheet_skeleton(incl);
contextPtr context = new_context(json, node);
__parsley_recurse(context);
json_object_put(json); // frees json
parsley->error = last_parsley_error;
if(parsley->error == NULL) {
parsley->stylesheet = xsltParseStylesheetDoc(node->doc);
}
free_context(context);
return parsley;
}
contextPtr deeper_context(contextPtr context, char* key, struct json_object * val) {
contextPtr c = (contextPtr) calloc(sizeof(parsley_context), 1);
c->node = context->node;
c->ns = context->ns;
c->parent = context;
c->tag = parsley_key_tag(key);
c->flags = parsley_key_flags(key);
parsley_parsing_context = c;
c->array = val != NULL && json_object_is_type(val, json_type_array);
c->json = c->array ? json_object_array_get_idx(val, 0) : val;
c->string = val != NULL && json_object_is_type(c->json, json_type_string);
c->filter = parsley_key_filter(key);
c->magic = context->array && context->filter == NULL;
c->expr = c->string ? myparse(json_object_get_string(c->json)) : NULL;
if(context->child == NULL) {
context->child = c;
} else {
contextPtr tmp = context->child;
while(tmp->next != NULL) tmp = tmp->next;
tmp->next = c;
}
// printf(stderr, "json: %s\ntag: %s\nexpr: %s\nfilter: %s\n\n", json_object_get_string(c->json), c->tag, pxpath_to_string(c->expr), pxpath_to_string(c->filter));
return c;
}
void parsley_free(parsleyPtr ptr) {
if(ptr->error != NULL)
free(ptr->error);
if(ptr->stylesheet != NULL)
xsltFreeStylesheet(ptr->stylesheet);
free(ptr);
}
void yyerror(const char * s) {
struct printbuf *buf = printbuf_new();
if(last_parsley_error !=NULL) sprintbuf(buf, "%s\n", last_parsley_error);
sprintbuf(buf, "%s in key: %s", s, full_key_name(parsley_parsing_context));
last_parsley_error = strdup(buf->buf);
printbuf_free(buf);
}
static bool
all_strings(struct json_object * json) {
json_object_object_foreach(json, key, val) {
if(val == NULL || !json_object_is_type(val, json_type_string)) return false;
}
return true;
}
static char *
inner_path(pxpathPtr p) {
if(p == NULL) return NULL;
if(p->type == PXPATH_PATH) return pxpath_to_string(p);
char *tmp = NULL;
pxpathPtr ptr = p->child;
while(ptr != NULL) {
tmp = inner_path(p->child);
if(tmp != NULL) return tmp;
ptr = ptr->next;
}
return NULL;
}
//TODO: tree-based replace, instead of naive string-based
static char *
inner_path_to_dot(pxpathPtr p) {
char *outer = pxpath_to_string(p);
char *inner = inner_path(p);
char *repl = NULL;
if(inner != NULL) {
repl = arepl(outer, inner, ".");
free(inner);
}
free(outer);
return repl;
}
static bool
inner_path_transform(contextPtr c) {
return c->filter == NULL && c->expr != NULL && inner_path(c->expr) != NULL;
}
static char *
resolve_filter(contextPtr c) {
return inner_path_transform(c) ? inner_path(c->expr) : pxpath_to_string(c->filter);
}
static char *
resolve_expr(contextPtr c) {
return inner_path_transform(c) ? inner_path_to_dot(c->expr) : pxpath_to_string(c->expr);
}
static void
render(contextPtr c) {
char *filter = resolve_filter(c);
char *expr = resolve_expr(c);
char *scope = filter == NULL ? expr : filter;
bool magic_children = c->array && filter == NULL;
bool simple_array = c->array && filter != NULL;
bool filtered = filter != NULL;
bool multiple = (c->array || c->magic) && !magic_children;
// printf("node %s\n", c->node->name);
xmlNsPtr parsley = c->ns;
xmlNsPtr xsl = xmlDocGetRootElement(c->node->doc)->ns;
if(c->array) c->node = xmlNewChild(c->node, parsley, "groups", NULL);
if(filtered) {
c->node = xmlNewChild(c->node, xsl, "for-each", NULL);
xmlSetProp(c->node, "select", filter);
}
if(filtered && !multiple) {
c->node = xmlNewChild(c->node, xsl, "if", NULL);
xmlSetProp(c->node, "test", "position() = 1");
}
if(multiple) {
c->node = xmlNewChild(c->node, parsley, "group", NULL);
if (!(c->flags & PARSLEY_BANG)) xmlSetProp(c->node, "optional", "true");
}
xmlNodePtr attr = xmlNewChild(c->node, xsl, "attribute", NULL);
xmlSetProp(attr, "name", "position");
xmlNodePtr counter = xmlNewChild(attr, xsl, "value-of", NULL);
xmlSetProp(counter, "select", "count(preceding::*) + count(ancestor::*)");
if(c->string) {
c->node = xmlNewChild(c->node, xsl, "value-of", NULL);
xmlSetProp(c->node, "select", expr);
} else {
if(magic_children) c->node = xmlNewChild(c->node, parsley, "zipped", NULL);
__parsley_recurse(c);
}
if(filter !=NULL) free(filter);
if(expr !=NULL) free(expr);
}
void __parsley_recurse(contextPtr context) {
contextPtr c;
if(context->json == NULL) return;
// printf(stderr, "<%s> %s\n", context->tag, context->node->name);
json_object_object_foreach(context->json, key, val) {
c = deeper_context(context, key, val);
// printf(stderr, "<%s>\n", c->tag);
c->node = xmlAddChild(c->node, xmlNewNode(NULL, c->tag));
if (c->flags & PARSLEY_OPTIONAL) xmlSetProp(c->node, "optional", "true");
render(c);
}
}
// static char* full_expr(contextPtr context, char* expr) {
// if(expr == NULL) return context->full_expr;
// char* merged = arepl(expr, ".", context->full_expr);
// return arepl(merged, "///", "//");
// }
static char*
inner_key_each(struct json_object * json);
static char* inner_key_of(struct json_object * json) {
switch(json_object_get_type(json)) {
case json_type_string:
return json_object_get_string(json);
case json_type_array:
return NULL;
case json_type_object:
return inner_key_each(json);
}
}
static char*
inner_key_each(struct json_object * json) {
json_object_object_foreach(json, key, val) {
char* inner = inner_key_of(val);
if(inner != NULL) return inner;
}
return NULL;
}