static GHashTable *filter_table = NULL;
-static gboolean
-json_unescape_str(char *input)
-{
- return wsjson_unescape_json_string(input, input);
-}
-
static const char *
json_find_attr(const char *buf, const jsmntok_t *tokens, int count, const char *attr)
{
if (str[i] < 0x20)
{
putchar('\\');
- fputs(json_cntrl[str[i]], stdout);
+ fputs(json_cntrl[(guint)str[i]], stdout);
}
else
{
int *pi = (int *) userdata;
sharkd_json_object_open(*pi != 0);
- sharkd_json_value_stringf(FALSE, "name", "%s", stat_tap->title);
+ sharkd_json_value_string(FALSE, "name", stat_tap->title);
sharkd_json_value_stringf(TRUE, "tap", "nstat:%s", (const char *) key);
sharkd_json_object_close();
int *pi = (int *) userdata;
sharkd_json_object_open(*pi != 0);
- sharkd_json_value_stringf(FALSE, "name", "%s", sequence_analysis_get_ui_name(analysis));
+ sharkd_json_value_string(FALSE, "name", sequence_analysis_get_ui_name(analysis));
sharkd_json_value_stringf(TRUE, "tap", "seqa:%s", (const char *) key);
sharkd_json_object_close();
* Process info request
*
* Output object with attributes:
+ * (m) version - version number
+ *
* (m) columns - available column formats, array of object with attributes:
* 'name' - column name
* 'format' - column format-name
* 'name' - sequence analysis name
* 'tap' - sharkd tap-name
*
- * (m) taps - available taps, array of object with attributes:
+ * (m) taps - available taps, array of object with attributes:
* 'name' - tap name
* 'tap' - sharkd tap-name
*
- * (m) follow - available followers, array of object with attributes:
+ * (m) follow - available followers, array of object with attributes:
+ * 'name' - tap name
+ * 'tap' - sharkd tap-name
+ *
+ * (m) ftypes - conversation table for FT_ number to string, array of FT_xxx strings.
+ *
+ * (m) nstat - available table-based taps, array of object with attributes:
* 'name' - tap name
* 'tap' - sharkd tap-name
*
- * (m) ftypes - conversation table for FT_ number to string
*/
static void
sharkd_session_process_info(void)
const char *col_descr = col_format_desc(i);
sharkd_json_object_open(i != 0);
- sharkd_json_value_stringf(FALSE, "name", "%s", col_descr);
- sharkd_json_value_stringf(TRUE, "format", "%s", col_format);
+ sharkd_json_value_string(FALSE, "name", col_descr);
+ sharkd_json_value_string(TRUE, "format", col_format);
sharkd_json_object_close();
}
sharkd_json_array_close();
stats_tree_cfg *cfg = (stats_tree_cfg *) l->data;
sharkd_json_object_open(sepa);
- sharkd_json_value_stringf(FALSE, "name", "%s", cfg->name);
+ sharkd_json_value_string(FALSE, "name", cfg->name);
sharkd_json_value_stringf(TRUE, "tap", "stat:%s", cfg->abbr);
sharkd_json_object_close();
sepa = TRUE;
sharkd_json_value_anyf(TRUE, "num", "%u", framenum);
- if (fdata->flags.has_user_comment || fdata->flags.has_phdr_comment)
+ if (fdata->has_user_comment || fdata->has_phdr_comment)
{
- if (!fdata->flags.has_user_comment || sharkd_get_user_comment(fdata) != NULL)
+ if (!fdata->has_user_comment || sharkd_get_user_comment(fdata) != NULL)
sharkd_json_value_anyf(TRUE, "ct", "true");
}
- if (fdata->flags.ignored)
+ if (fdata->ignored)
sharkd_json_value_anyf(TRUE, "i", "true");
- if (fdata->flags.marked)
+ if (fdata->marked)
sharkd_json_value_anyf(TRUE, "m", "true");
if (fdata->color_filter)
sharkd_json_object_open(sepa);
/* code based on stats_tree_get_values_from_node() */
- sharkd_json_value_stringf(FALSE, "name", "%s", node->name);
+ sharkd_json_value_string(FALSE, "name", node->name);
sharkd_json_value_anyf(TRUE, "count", "%d", node->counter);
if (node->counter && ((node->st_flags & ST_FLG_AVERAGE) || node->rng))
{
- sharkd_json_value_anyf(TRUE, "avg", "%.2f", ((float)node->total) / node->counter);
- sharkd_json_value_anyf(TRUE, "min", "%d", node->minvalue);
- sharkd_json_value_anyf(TRUE, "max", "%d", node->maxvalue);
+ switch(node->datatype)
+ {
+ case STAT_DT_INT:
+ sharkd_json_value_anyf(TRUE, "avg", "%.2f", ((float)node->total.int_total) / node->counter);
+ sharkd_json_value_anyf(TRUE, "min", "%d", node->minvalue.int_min);
+ sharkd_json_value_anyf(TRUE, "max", "%d", node->maxvalue.int_max);
+ break;
+ case STAT_DT_FLOAT:
+ sharkd_json_value_anyf(TRUE, "avg", "%.2f", node->total.float_total / node->counter);
+ sharkd_json_value_anyf(TRUE, "min", "%f", node->minvalue.float_min);
+ sharkd_json_value_anyf(TRUE, "max", "%f", node->maxvalue.float_max);
+ break;
+ }
}
if (node->st->elapsed)
else
sharkd_json_value_anyf(TRUE, "burstrate", "%.4f", ((double)node->max_burst) / prefs.st_burst_windowlen);
- sharkd_json_value_anyf(TRUE, "bursttime", "%.3f", ((double)node->burst_time / 1000.0));
+ sharkd_json_value_anyf(TRUE, "bursttime", "%.3f", (node->burst_time / 1000.0));
}
if (node->children)
sharkd_json_value_stringf(FALSE, "tap", "stats:%s", st->cfg->abbr);
sharkd_json_value_string(TRUE, "type", "stats");
- sharkd_json_value_stringf(TRUE, "name", "%s", st->cfg->name);
+ sharkd_json_value_string(TRUE, "name", st->cfg->name);
sharkd_json_value_anyf(TRUE, "stats", NULL);
sharkd_session_process_tap_stats_node_cb(&st->root);
putchar(',');
}
-static gboolean
+static tap_packet_status
sharkd_session_packet_tap_expert_cb(void *tapdata, packet_info *pinfo _U_, epan_dissect_t *edt _U_, const void *pointer)
{
struct sharkd_expert_tap *etd = (struct sharkd_expert_tap *) tapdata;
expert_info_t *ei_copy;
if (ei == NULL)
- return FALSE;
+ return TAP_PACKET_DONT_REDRAW;
ei_copy = g_new(expert_info_t, 1);
/* Note: this is a shallow copy */
etd->details = g_slist_prepend(etd->details, ei_copy);
- return TRUE;
+ return TAP_PACKET_REDRAW;
}
static void
sharkd_json_object_open(sepa);
- sharkd_json_value_stringf(FALSE, "t", "%s", sai->time_str);
+ sharkd_json_value_string(FALSE, "t", sai->time_str);
sharkd_json_value_anyf(TRUE, "n", "[%u,%u]", sai->src_node, sai->dst_node);
sharkd_json_value_anyf(TRUE, "pn", "[%u,%u]", sai->port_src, sai->port_dst);
g_free(rtp_req);
}
-static gboolean
+static tap_packet_status
sharkd_session_packet_tap_rtp_analyse_cb(void *tapdata, packet_info *pinfo, epan_dissect_t *edt _U_, const void *pointer)
{
struct sharkd_analyse_rtp *rtp_req = (struct sharkd_analyse_rtp *) tapdata;
rtp_req->packets = g_slist_append(rtp_req->packets, item);
}
- return TRUE;
+ return TAP_PACKET_REDRAW;
}
/**
* (m) type - tap output type
* (m) proto - protocol short name
* (o) filter - filter string
+ * (o) geoip - whether GeoIP information is available, boolean
*
* (o) convs - array of object with attributes:
* (m) saddr - source address
* (m) rxb - RX bytes
* (m) start - (relative) first packet time
* (m) stop - (relative) last packet time
+ * (o) filter - conversation filter
*
* (o) hosts - array of object with attributes:
* (m) host - host address
sharkd_json_object_open(i != 0);
- sharkd_json_value_stringf(FALSE, "saddr", "%s", (src_addr = get_conversation_address(NULL, &iui->src_address, iu->resolve_name)));
- sharkd_json_value_stringf(TRUE, "daddr", "%s", (dst_addr = get_conversation_address(NULL, &iui->dst_address, iu->resolve_name)));
+ sharkd_json_value_string(FALSE, "saddr", (src_addr = get_conversation_address(NULL, &iui->src_address, iu->resolve_name)));
+ sharkd_json_value_string(TRUE, "daddr", (dst_addr = get_conversation_address(NULL, &iui->dst_address, iu->resolve_name)));
if (proto_with_port)
{
- sharkd_json_value_stringf(TRUE, "sport", "%s", (src_port = get_conversation_port(NULL, iui->src_port, iui->etype, iu->resolve_port)));
- sharkd_json_value_stringf(TRUE, "dport", "%s", (dst_port = get_conversation_port(NULL, iui->dst_port, iui->etype, iu->resolve_port)));
+ sharkd_json_value_string(TRUE, "sport", (src_port = get_conversation_port(NULL, iui->src_port, iui->etype, iu->resolve_port)));
+ sharkd_json_value_string(TRUE, "dport", (dst_port = get_conversation_port(NULL, iui->dst_port, iui->etype, iu->resolve_port)));
wmem_free(NULL, src_port);
wmem_free(NULL, dst_port);
filter_str = get_conversation_filter(iui, CONV_DIR_A_TO_FROM_B);
if (filter_str)
{
- sharkd_json_value_stringf(TRUE, "filter", "%s", filter_str);
+ sharkd_json_value_string(TRUE, "filter", filter_str);
g_free(filter_str);
}
sharkd_json_object_open(i != 0);
- sharkd_json_value_stringf(FALSE, "host", "%s", (host_str = get_conversation_address(NULL, &host->myaddress, iu->resolve_name)));
+ sharkd_json_value_string(FALSE, "host", (host_str = get_conversation_address(NULL, &host->myaddress, iu->resolve_name)));
if (proto_with_port)
{
- sharkd_json_value_stringf(TRUE, "port", "%s", (port_str = get_conversation_port(NULL, host->port, host->etype, iu->resolve_port)));
+ sharkd_json_value_string(TRUE, "port", (port_str = get_conversation_port(NULL, host->port, host->etype, iu->resolve_port)));
wmem_free(NULL, port_str);
}
filter_str = get_hostlist_filter(host);
if (filter_str)
{
- sharkd_json_value_stringf(TRUE, "filter", "%s", filter_str);
+ sharkd_json_value_string(TRUE, "filter", filter_str);
g_free(filter_str);
}
sharkd_json_object_open(i != 0);
- sharkd_json_value_stringf(FALSE, "t", "%s", table->title);
+ sharkd_json_value_string(FALSE, "t", table->title);
sharkd_json_array_open(TRUE, "i");
for (j = 0; j < table->num_elements; j++)
sharkd_json_value_string(FALSE, "tap", object_list->type);
sharkd_json_value_string(TRUE, "type", "eo");
- sharkd_json_value_stringf(TRUE, "proto", "%s", object_list->proto);
+ sharkd_json_value_string(TRUE, "proto", object_list->proto);
sharkd_json_array_open(TRUE, "objects");
for (slist = object_list->entries; slist; slist = slist->next)
gboolean sepa = FALSE;
sharkd_json_object_open(FALSE);
- sharkd_json_value_stringf(FALSE, "tap", "rtp-streams");
+ sharkd_json_value_string(FALSE, "tap", "rtp-streams");
sharkd_json_value_string(TRUE, "type", "rtp-streams");
sharkd_json_array_open(TRUE, "streams");
sharkd_json_object_open(sepa);
sharkd_json_value_anyf(FALSE, "ssrc", "%u", calc.ssrc);
- sharkd_json_value_stringf(TRUE, "payload", "%s", calc.all_payload_type_names);
+ sharkd_json_value_string(TRUE, "payload", calc.all_payload_type_names);
- sharkd_json_value_stringf(TRUE, "saddr", "%s", calc.src_addr_str);
+ sharkd_json_value_string(TRUE, "saddr", calc.src_addr_str);
sharkd_json_value_anyf(TRUE, "sport", "%u", calc.src_port);
- sharkd_json_value_stringf(TRUE, "daddr", "%s", calc.dst_addr_str);
+ sharkd_json_value_string(TRUE, "daddr", calc.dst_addr_str);
sharkd_json_value_anyf(TRUE, "dport", "%u", calc.dst_port);
sharkd_json_value_anyf(TRUE, "pkts", "%u", calc.packet_count);
sharkd_json_array_open(FALSE, "taps");
sharkd_retap();
+ // This dummy value exists to permit unconditionally adding ',' in the taps callback.
+ // XXX convert to json_dumper and remove this.
sharkd_json_value_anyf(FALSE, NULL, "null");
sharkd_json_array_close();
if (finfo->hfinfo->type == FT_PROTOCOL)
{
- sharkd_json_value_stringf(TRUE, "t", "proto");
+ sharkd_json_value_string(TRUE, "t", "proto");
}
else if (finfo->hfinfo->type == FT_FRAMENUM)
{
g_assert(severity != NULL);
- sharkd_json_value_stringf(TRUE, "s", "%s", severity);
+ sharkd_json_value_string(TRUE, "s", severity);
}
if (((proto_tree *) node)->first_child)
sharkd_json_value_anyf(FALSE, "err", "0");
- if (fdata->flags.has_user_comment)
+ if (fdata->has_user_comment)
pkt_comment = sharkd_get_user_comment(fdata);
- else if (fdata->flags.has_phdr_comment)
+ else if (fdata->has_phdr_comment)
pkt_comment = pi->rec->opt_comment;
if (pkt_comment)
sharkd_json_array_close();
}
- if (fdata->flags.ignored)
+ if (fdata->ignored)
sharkd_json_value_anyf(TRUE, "i", "true");
- if (fdata->flags.marked)
+ if (fdata->marked)
sharkd_json_value_anyf(TRUE, "m", "true");
if (fdata->color_filter)
{
const guchar *cp = tvb_get_ptr(tvb, 0, length);
- /* XXX pi.fd->flags.encoding */
+ /* XXX pi.fd->encoding */
sharkd_json_value_base64(TRUE, "bytes", cp, length);
}
else
{
const guchar *cp = tvb_get_ptr(tvb, 0, length);
- /* XXX pi.fd->flags.encoding */
+ /* XXX pi.fd->encoding */
sharkd_json_value_base64(TRUE, "bytes", cp, length);
}
else
}
sharkd_json_array_open(TRUE, "fol");
+ // This dummy entry allows sharkd_follower_visit_layers_cb() to always insert ',' before dumping item.
+ // XXX convert to json_dumper and remove the dummy entry.
sharkd_json_value_anyf(FALSE, NULL, "0");
follow_iterate_followers(sharkd_follower_visit_layers_cb, pi);
sharkd_json_array_close();
GString *error;
};
-static gboolean
+static tap_packet_status
sharkd_iograph_packet(void *g, packet_info *pinfo, epan_dissect_t *edt, const void *dummy _U_)
{
struct sharkd_iograph *graph = (struct sharkd_iograph *) g;
int idx;
+ gboolean update_succeeded;
idx = get_io_graph_index(pinfo, graph->interval);
if (idx < 0 || idx >= SHARKD_IOGRAPH_MAX_ITEMS)
- return FALSE;
+ return TAP_PACKET_DONT_REDRAW;
if (idx + 1 > graph->num_items)
{
graph->num_items = idx + 1;
}
- return update_io_graph_item(graph->items, idx, pinfo, edt, graph->hf_index, graph->calc_type, graph->interval);
+ update_succeeded = update_io_graph_item(graph->items, idx, pinfo, edt, graph->hf_index, graph->calc_type, graph->interval);
+ /* XXX - TAP_PACKET_FAILED if the item couldn't be updated, with an error message? */
+ return update_succeeded ? TAP_PACKET_REDRAW : TAP_PACKET_DONT_REDRAW;
}
/**
if (dfp && dfilter_deprecated_tokens(dfp))
s = "warn";
- sharkd_json_value_stringf(TRUE, "filter", "%s", s);
+ sharkd_json_value_string(TRUE, "filter", s);
dfilter_free(dfp);
}
else
{
header_field_info *hfi = proto_registrar_get_byname(tok_field);
- sharkd_json_value_stringf(TRUE, "field", (hfi) ? "ok" : "notfound");
+ sharkd_json_value_string(TRUE, "field", (hfi) ? "ok" : "notfound");
}
sharkd_json_object_close();
return 0;
sharkd_json_object_open(data->sepa);
- sharkd_json_value_stringf(FALSE, "f", "%s", module->name);
- sharkd_json_value_stringf(TRUE, "d", "%s", module->title);
+ sharkd_json_value_string(FALSE, "f", module->name);
+ sharkd_json_value_string(TRUE, "d", module->title);
sharkd_json_object_close();
data->sepa = TRUE;
sharkd_json_object_open(data->sepa);
sharkd_json_value_stringf(FALSE, "f", "%s.%s", data->module, pref_name);
- sharkd_json_value_stringf(TRUE, "d", "%s", pref_title);
+ sharkd_json_value_string(TRUE, "d", pref_title);
sharkd_json_object_close();
data->sepa = TRUE;
case PREF_DECODE_AS_RANGE:
{
char *range_str = range_convert_range(NULL, prefs_get_range_value_real(pref, pref_current));
- sharkd_json_value_stringf(FALSE, "r", "%s", range_str);
+ sharkd_json_value_string(FALSE, "r", range_str);
wmem_free(NULL, range_str);
break;
}
g_hash_table_destroy(decoders_hash_);
}
-static gboolean
+static tap_packet_status
sharkd_session_packet_download_tap_rtp_cb(void *tapdata, packet_info *pinfo, epan_dissect_t *edt _U_, const void *data)
{
const struct _rtp_info *rtp_info = (const struct _rtp_info *) data;
/* do not consider RTP packets without a setup frame */
if (rtp_info->info_setup_frame_num == 0)
- return FALSE;
+ return TAP_PACKET_DONT_REDRAW;
if (rtpstream_id_equal_pinfo_rtp_info(&req_rtp->id, pinfo, rtp_info))
{
req_rtp->packets = g_slist_append(req_rtp->packets, rtp_packet);
}
- return FALSE;
+ return TAP_PACKET_DONT_REDRAW;
}
/**
buf[tokens[i + 1].end] = '\0';
/* unescape only value, as keys are simple strings */
- if (tokens[i + 1].type == JSMN_STRING && !json_unescape_str(&buf[tokens[i + 1].start]))
+ if (tokens[i + 1].type == JSMN_STRING && !json_decode_string_inplace(&buf[tokens[i + 1].start]))
{
fprintf(stderr, "sanity check(3b): [%d] cannot unescape string\n", i + 1);
return;
/* every command is line seperated JSON */
int ret;
- ret = wsjson_parse(buf, NULL, 0);
+ ret = json_parse(buf, NULL, 0);
if (ret < 0)
{
fprintf(stderr, "invalid JSON -> closing\n");
memset(tokens, 0, ret * sizeof(jsmntok_t));
- ret = wsjson_parse(buf, tokens, ret);
+ ret = json_parse(buf, tokens, ret);
if (ret < 0)
{
fprintf(stderr, "invalid JSON(2) -> closing\n");
git.samba.org / metze / wireshark / wip.git / blobdiff