/*
- * Copyright (C) 2013-2014 Jo-Philipp Wich <jow@openwrt.org>
+ * Copyright (C) 2013-2014 Jo-Philipp Wich <jo@mein.io>
*
* Permission to use, copy, modify, and/or distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
#include <stdio.h>
#include <stdbool.h>
+#include <stdint.h>
#include <unistd.h>
#include <errno.h>
struct list_head list;
};
+static void
+print_usage(char *app)
+{
+ printf(
+ "== Usage ==\n\n"
+ " # %s [-a] [-i <file> | -s \"json...\"] {-t <pattern> | -e <pattern>}\n"
+ " -q Quiet, no errors are printed\n"
+ " -h, --help Print this help\n"
+ " -a Implicitely treat input as array, useful for JSON logs\n"
+ " -i path Specify a JSON file to parse\n"
+ " -s \"json\" Specify a JSON string to parse\n"
+ " -l limit Specify max number of results to show\n"
+ " -F separator Specify a field separator when using export\n"
+ " -t <pattern> Print the type of values matched by pattern\n"
+ " -e <pattern> Print the values matched by pattern\n"
+ " -e VAR=<pat> Serialize matched value for shell \"eval\"\n\n"
+ "== Patterns ==\n\n"
+ " Patterns are JsonPath: http://goessner.net/articles/JsonPath/\n"
+ " This tool implements $, @, [], * and the union operator ','\n"
+ " plus the usual expressions and literals.\n"
+ " It does not support the recursive child search operator '..' or\n"
+ " the '?()' and '()' filter expressions as those would require a\n"
+ " complete JavaScript engine to support them.\n\n"
+ "== Examples ==\n\n"
+ " Display the first IPv4 address on lan:\n"
+ " # ifstatus lan | %s -e '@[\"ipv4-address\"][0].address'\n\n"
+ " Extract the release string from the board information:\n"
+ " # ubus call system board | %s -e '@.release.description'\n\n"
+ " Find all interfaces which are up:\n"
+ " # ubus call network.interface dump | \\\n"
+ " %s -e '@.interface[@.up=true].interface'\n\n"
+ " Export br-lan traffic counters for shell eval:\n"
+ " # devstatus br-lan | %s -e 'RX=@.statistics.rx_bytes' \\\n"
+ " -e 'TX=@.statistics.tx_bytes'\n",
+ app, app, app, app, app);
+}
+
static struct json_object *
-parse_json(FILE *fd, const char *source, const char **error)
+parse_json_chunk(struct json_tokener *tok, struct json_object *array,
+ const char *buf, size_t len, enum json_tokener_error *err)
{
- int len;
- char buf[256];
struct json_object *obj = NULL;
+
+ while (len)
+ {
+ obj = json_tokener_parse_ex(tok, buf, len);
+ *err = json_tokener_get_error(tok);
+
+ if (*err == json_tokener_success)
+ {
+ if (array)
+ {
+ json_object_array_add(array, obj);
+ }
+ else
+ {
+ break;
+ }
+ }
+ else if (*err != json_tokener_continue)
+ {
+ break;
+ }
+
+ buf += tok->char_offset;
+ len -= tok->char_offset;
+ }
+
+ return obj;
+}
+
+static struct json_object *
+parse_json(FILE *fd, const char *source, const char **error, bool array_mode)
+{
+ size_t len;
+ char buf[256];
+ struct json_object *obj = NULL, *array = NULL;
struct json_tokener *tok = json_tokener_new();
enum json_tokener_error err = json_tokener_continue;
if (!tok)
+ {
+ *error = "Out of memory";
return NULL;
+ }
+
+ if (array_mode)
+ {
+ array = json_object_new_array();
+
+ if (!array)
+ {
+ json_tokener_free(tok);
+ *error = "Out of memory";
+ return NULL;
+ }
+ }
if (source)
{
- obj = json_tokener_parse_ex(tok, source, strlen(source));
- err = json_tokener_get_error(tok);
+ obj = parse_json_chunk(tok, array, source, strlen(source), &err);
}
else
{
while ((len = fread(buf, 1, sizeof(buf), fd)) > 0)
{
- obj = json_tokener_parse_ex(tok, buf, len);
- err = json_tokener_get_error(tok);
+ obj = parse_json_chunk(tok, array, buf, len, &err);
- if (!err || err != json_tokener_continue)
+ if ((err == json_tokener_success && array_mode == false) ||
+ (err != json_tokener_continue && err != json_tokener_success))
break;
}
}
return NULL;
}
- return obj;
+ return array ? array : obj;
}
static void
}
static void
-export_value(struct list_head *matches, const char *prefix)
+print_separator(const char *sep, int *sc, int sl)
+{
+ if (*sc > 0)
+ {
+ switch (sep[(*sc - 1) % sl])
+ {
+ case '"':
+ printf("'\"'");
+ break;
+
+ case '\'':
+ printf("\"'\"");
+ break;
+
+ case ' ':
+ printf("\\ ");
+ break;
+
+ default:
+ printf("%c", sep[(*sc - 1) % sl]);
+ }
+ }
+
+ (*sc)++;
+}
+
+static void
+export_value(struct list_head *matches, const char *prefix, const char *sep,
+ int limit)
{
int n, len;
- bool first = true;
+ int sc = 0, sl = strlen(sep);
struct match_item *item;
if (list_empty(matches))
list_for_each_entry(item, matches, list)
{
+ if (limit-- <= 0)
+ break;
+
switch (json_object_get_type(item->jsobj))
{
case json_type_object:
if (!val)
continue;
- if (!first)
- printf("\\ ");
-
+ print_separator(sep, &sc, sl);
print_string(key);
- first = false;
}
break;
for (n = 0, len = json_object_array_length(item->jsobj);
n < len; n++)
{
- if (!first)
- printf("\\ ");
-
+ print_separator(sep, &sc, sl);
printf("%d", n);
- first = false;
}
break;
case json_type_boolean:
- if (!first)
- printf("\\ ");
+ print_separator(sep, &sc, sl);
printf("%d", json_object_get_boolean(item->jsobj));
break;
case json_type_int:
- if (!first)
- printf("\\ ");
- printf("%d", json_object_get_int(item->jsobj));
+ print_separator(sep, &sc, sl);
+ printf("%" PRId64, json_object_get_int64(item->jsobj));
break;
case json_type_double:
- if (!first)
- printf("\\ ");
+ print_separator(sep, &sc, sl);
printf("%f", json_object_get_double(item->jsobj));
break;
case json_type_string:
- if (!first)
- printf("\\ ");
+ print_separator(sep, &sc, sl);
print_string(json_object_get_string(item->jsobj));
break;
case json_type_null:
break;
}
-
- first = false;
}
printf("; ");
{
list_for_each_entry(item, matches, list)
{
+ if (limit-- <= 0)
+ break;
+
switch (json_object_get_type(item->jsobj))
{
case json_type_object:
}
static void
-export_type(struct list_head *matches, const char *prefix)
+export_type(struct list_head *matches, const char *prefix, int limit)
{
bool first = true;
struct match_item *item;
if (!first)
printf("\\ ");
+ if (limit-- <= 0)
+ break;
+
printf("%s", types[json_object_get_type(item->jsobj)]);
first = false;
}
}
}
+static void
+print_error(struct jp_state *state, char *expr)
+{
+ int i;
+ bool first = true;
+
+ fprintf(stderr, "Syntax error: ");
+
+ switch (state->error_code)
+ {
+ case -4:
+ fprintf(stderr, "Unexpected character\n");
+ break;
+
+ case -3:
+ fprintf(stderr, "String or label literal too long\n");
+ break;
+
+ case -2:
+ fprintf(stderr, "Invalid escape sequence\n");
+ break;
+
+ case -1:
+ fprintf(stderr, "Unterminated string\n");
+ break;
+
+ default:
+ for (i = 0; i < sizeof(state->error_code) * 8; i++)
+ {
+ if (state->error_code & (1 << i))
+ {
+ fprintf(stderr,
+ first ? "Expecting %s" : " or %s", tokennames[i]);
+
+ first = false;
+ }
+ }
+
+ fprintf(stderr, "\n");
+ break;
+ }
+
+ fprintf(stderr, "In expression %s\n", expr);
+ fprintf(stderr, "Near here ----");
+
+ for (i = 0; i < state->error_pos; i++)
+ fprintf(stderr, "-");
+
+ fprintf(stderr, "^\n");
+}
+
static bool
-filter_json(int opt, struct json_object *jsobj, char *expr)
+filter_json(int opt, struct json_object *jsobj, char *expr, const char *sep,
+ int limit)
{
struct jp_state *state;
const char *prefix = NULL;
state = jp_parse(expr);
- if (!state || state->error)
+ if (!state)
{
- fprintf(stderr, "In expression '%s': %s\n",
- expr, state ? state->error : "Out of memory");
-
+ fprintf(stderr, "Out of memory\n");
+ goto out;
+ }
+ else if (state->error_code)
+ {
+ print_error(state, expr);
goto out;
}
switch (opt)
{
case 't':
- export_type(&matches, prefix);
+ export_type(&matches, prefix, limit);
break;
default:
- export_value(&matches, prefix);
+ export_value(&matches, prefix, sep, limit);
break;
}
int main(int argc, char **argv)
{
- int opt, rv = 0;
+ bool array_mode = false;
+ int opt, rv = 0, limit = 0x7FFFFFFF;
FILE *input = stdin;
struct json_object *jsobj = NULL;
- const char *jserr = NULL, *source = NULL;
+ const char *jserr = NULL, *source = NULL, *separator = " ";
- while ((opt = getopt(argc, argv, "i:s:e:t:q")) != -1)
+ if (argc == 1)
+ {
+ print_usage(argv[0]);
+ goto out;
+ }
+
+ while ((opt = getopt(argc, argv, "ahi:s:e:t:F:l:q")) != -1)
{
switch (opt)
{
+ case 'a':
+ array_mode = true;
+ break;
+
+ case 'h':
+ print_usage(argv[0]);
+ goto out;
+
case 'i':
input = fopen(optarg, "r");
source = optarg;
break;
+ case 'F':
+ if (optarg && *optarg)
+ separator = optarg;
+ break;
+
+ case 'l':
+ limit = atoi(optarg);
+ break;
+
case 't':
case 'e':
if (!jsobj)
{
- jsobj = parse_json(input, source, &jserr);
+ jsobj = parse_json(input, source, &jserr, array_mode);
if (!jsobj)
{
}
}
- if (!filter_json(opt, jsobj, optarg))
+ if (!filter_json(opt, jsobj, optarg, separator, limit))
rv = 1;
break;
if (jsobj)
json_object_put(jsobj);
- if (input != stdin)
+ if (input && input != stdin)
fclose(input);
return rv;
projects / project / jsonpath.git / blobdiff