sipwise
/
rtpengine
mirror of https://github.com/sipwise/rtpengine.git
1
0
Fork 0
Code Issues Releases Wiki Activity

MT#55283 use abstract JSON writer for Redis

Browse Source 
Change-Id: Ib667184773d75c5187d6029ca2e9282e7931c5a4
pull/1853/head
Richard Fuchs 2 years ago
parent ef787fb119
commit 81a7d177ef
4 changed files with 85 additions and 108 deletions
Show Stats Download Patch File Download Diff File

8
daemon/control_ng.c
Unescape View File

@ -162,6 +162,12 @@ static parser_arg __bencode_dictionary_add_dictionary_dup(bencode_item_t *n, con
static parser_arg __bencode_dictionary_add_list(bencode_item_t *n, const char *e) { static parser_arg __bencode_dictionary_add_list(bencode_item_t *n, const char *e) {
return (parser_arg) bencode_dictionary_add_list(n, e); return (parser_arg) bencode_dictionary_add_list(n, e);
} }
static parser_arg __bencode_dictionary_add_list_dup(bencode_item_t *n, const char *e) {
size_t len = strlen(e) + 1;
char *s = bencode_buffer_alloc(n->buffer, len);
memcpy(s, e, len);
return (parser_arg) bencode_dictionary_add_list(n, s);
}
static parser_arg __bencode_list_add(bencode_item_t *l, bencode_item_t *e) { static parser_arg __bencode_list_add(bencode_item_t *l, bencode_item_t *e) {
return (parser_arg) bencode_list_add(l, e); return (parser_arg) bencode_list_add(l, e);
} }
@ -453,6 +459,7 @@ const ng_parser_t ng_parser_native = {
.dict_add_dict = __bencode_dictionary_add_dictionary, .dict_add_dict = __bencode_dictionary_add_dictionary,
.dict_add_dict_dup = __bencode_dictionary_add_dictionary_dup, .dict_add_dict_dup = __bencode_dictionary_add_dictionary_dup,
.dict_add_list = __bencode_dictionary_add_list, .dict_add_list = __bencode_dictionary_add_list,
.dict_add_list_dup = __bencode_dictionary_add_list_dup,
.list = __bencode_list, .list = __bencode_list,
.list_add = __bencode_list_add, .list_add = __bencode_list_add,
.list_add_dict = __bencode_list_add_dictionary, .list_add_dict = __bencode_list_add_dictionary,
@ -485,6 +492,7 @@ const ng_parser_t ng_parser_json = {
.dict_add_dict = json_dict_add_dict, .dict_add_dict = json_dict_add_dict,
.dict_add_dict_dup = json_dict_add_dict, .dict_add_dict_dup = json_dict_add_dict,
.dict_add_list = json_dict_add_list, .dict_add_list = json_dict_add_list,
.dict_add_list_dup = json_dict_add_list,
.list = json_list, .list = json_list,
.list_add = json_list_add, .list_add = json_list_add,
.list_add_dict = json_list_add_dict, .list_add_dict = json_list_add_dict,

183
daemon/redis.c
Unescape View File

@ -2287,33 +2287,41 @@ err:
return ret; return ret;
} }
#define JSON_ADD_STRING(f...) do { \ #define JSON_ADD_LIST_STRING(f,...) do { \
int len = snprintf(tmp,sizeof(tmp), f); \ int len = snprintf(tmp,sizeof(tmp), f, __VA_ARGS__); \
json_builder_add_string_value_uri_enc(builder, tmp, len); \ char enc[len * 3 + 1]; \
str_uri_encode_len(enc, tmp, len); \
redis_parser->list_add_str_dup(inner, &STR_NC(enc)); \
} while (0) } while (0)
#define JSON_SET_NSTRING(a,b,c,d) do { \ #define JSON_SET_NSTRING(a,b,c,...) do { \
int len = snprintf(tmp,sizeof(tmp), c, __VA_ARGS__); \
char enc[len * 3 + 1]; \
str_uri_encode_len(enc, tmp, len); \
snprintf(tmp,sizeof(tmp), a,b); \ snprintf(tmp,sizeof(tmp), a,b); \
json_builder_set_member_name(builder, tmp); \ redis_parser->dict_add_str_dup(inner, tmp, &STR_NC(enc)); \
JSON_ADD_STRING(c, d); \
} while (0) } while (0)
#define JSON_SET_NSTRING_CSTR(a,b,d) JSON_SET_NSTRING_LEN(a, b, strlen(d), d) #define JSON_SET_NSTRING_CSTR(a,b,d) JSON_SET_NSTRING_LEN(a, b, strlen(d), d)
#define JSON_SET_NSTRING_LEN(a,b,l,d) do { \ #define JSON_SET_NSTRING_LEN(a,b,l,d) do { \
char enc[l * 3 + 1]; \
str_uri_encode_len(enc, d, l); \
snprintf(tmp,sizeof(tmp), a,b); \ snprintf(tmp,sizeof(tmp), a,b); \
json_builder_set_member_name(builder, tmp); \ redis_parser->dict_add_str_dup(inner, tmp, &STR_NC(enc)); \
json_builder_add_string_value_uri_enc(builder, d, l); \
} while (0) } while (0)
#define JSON_SET_SIMPLE(a,c,d) do { \ #define JSON_SET_SIMPLE(a,c,...) do { \
json_builder_set_member_name(builder, a); \ int len = snprintf(tmp,sizeof(tmp), c, __VA_ARGS__); \
JSON_ADD_STRING(c, d); \ char enc[len * 3 + 1]; \
str_uri_encode_len(enc, tmp, len); \
redis_parser->dict_add_str_dup(inner, a, &STR_NC(enc)); \
} while (0) } while (0)
#define JSON_SET_SIMPLE_LEN(a,l,d) do { \ #define JSON_SET_SIMPLE_LEN(a,l,d) do { \
json_builder_set_member_name(builder, a); \ char enc[l * 3 + 1]; \
json_builder_add_string_value_uri_enc(builder, d, l); \ str_uri_encode_len(enc, d, l); \
redis_parser->dict_add_str_dup(inner, a, &STR_NC(enc)); \
} while (0) } while (0)
#define JSON_SET_SIMPLE_CSTR(a,d) JSON_SET_SIMPLE_LEN(a, (d) ? strlen(d) : 0, (d) ? : "") #define JSON_SET_SIMPLE_CSTR(a,d) redis_parser->dict_add_str_dup(inner, a, &STR(d))
#define JSON_SET_SIMPLE_STR(a,d) JSON_SET_SIMPLE_LEN(a, (d)->len, (d)->s) #define JSON_SET_SIMPLE_STR(a,d) redis_parser->dict_add_str_dup(inner, a, d)
static void json_update_crypto_params(JsonBuilder *builder, const char *key, struct crypto_params *p) { static void json_update_crypto_params(parser_arg inner, const char *key, struct crypto_params *p) {
char tmp[2048]; char tmp[2048];
if (!p->crypto_suite) if (!p->crypto_suite)
@ -2331,7 +2339,7 @@ static void json_update_crypto_params(JsonBuilder *builder, const char *key, str
JSON_SET_NSTRING_LEN("%s-mki", key, p->mki_len, (char *) p->mki); JSON_SET_NSTRING_LEN("%s-mki", key, p->mki_len, (char *) p->mki);
} }
static int json_update_sdes_params(JsonBuilder *builder, const char *pref, static int json_update_sdes_params(parser_arg inner, const char *pref,
unsigned int unique_id, unsigned int unique_id,
const char *k, sdes_q *q) const char *k, sdes_q *q)
{ {
@ -2348,7 +2356,7 @@ static int json_update_sdes_params(JsonBuilder *builder, const char *pref,
return -1; return -1;
JSON_SET_NSTRING("%s_tag", key, "%u", cps->tag); JSON_SET_NSTRING("%s_tag", key, "%u", cps->tag);
json_update_crypto_params(builder, key, p); json_update_crypto_params(inner, key, p);
snprintf(keybuf, sizeof(keybuf), "%s-%u", k, iter++); snprintf(keybuf, sizeof(keybuf), "%s-%u", k, iter++);
key = keybuf; key = keybuf;
@ -2357,7 +2365,7 @@ static int json_update_sdes_params(JsonBuilder *builder, const char *pref,
return 0; return 0;
} }
static void json_update_dtls_fingerprint(JsonBuilder *builder, const char *pref, static void json_update_dtls_fingerprint(parser_arg inner, const char *pref,
unsigned int unique_id, unsigned int unique_id,
const struct dtls_fingerprint *f) const struct dtls_fingerprint *f)
{ {
@ -2372,17 +2380,14 @@ static void json_update_dtls_fingerprint(JsonBuilder *builder, const char *pref,
* encodes the few (k,v) pairs for one call under one json structure * encodes the few (k,v) pairs for one call under one json structure
*/ */
char* redis_encode_json(call_t *c) { static str redis_encode_json(ng_parser_ctx_t *ctx, call_t *c) {
JsonBuilder *builder = json_builder_new ();
char tmp[2048]; char tmp[2048];
json_builder_begin_object(builder); parser_arg root = redis_parser->dict(ctx);
{
json_builder_set_member_name(builder, "json");
json_builder_begin_object(builder); {
parser_arg inner = redis_parser->dict_add_dict(root, "json");
{ {
JSON_SET_SIMPLE("created","%lli", timeval_us(&c->created)); JSON_SET_SIMPLE("created","%lli", timeval_us(&c->created));
@ -2415,15 +2420,11 @@ char* redis_encode_json(call_t *c) {
JSON_SET_SIMPLE_STR("recording_random_tag", &c->recording_random_tag); JSON_SET_SIMPLE_STR("recording_random_tag", &c->recording_random_tag);
} }
json_builder_end_object(builder);
for (__auto_type l = c->stream_fds.head; l; l = l->next) { for (__auto_type l = c->stream_fds.head; l; l = l->next) {
stream_fd *sfd = l->data; stream_fd *sfd = l->data;
snprintf(tmp, sizeof(tmp), "sfd-%u", sfd->unique_id); snprintf(tmp, sizeof(tmp), "sfd-%u", sfd->unique_id);
json_builder_set_member_name(builder, tmp); inner = redis_parser->dict_add_dict_dup(root, tmp);
json_builder_begin_object(builder);
{ {
JSON_SET_SIMPLE_CSTR("pref_family", sfd->local_intf->logical->preferred_family->rfc_name); JSON_SET_SIMPLE_CSTR("pref_family", sfd->local_intf->logical->preferred_family->rfc_name);
@ -2433,10 +2434,8 @@ char* redis_encode_json(call_t *c) {
JSON_SET_SIMPLE("local_intf_uid","%u", sfd->local_intf->unique_id); JSON_SET_SIMPLE("local_intf_uid","%u", sfd->local_intf->unique_id);
JSON_SET_SIMPLE("stream","%u", sfd->stream->unique_id); JSON_SET_SIMPLE("stream","%u", sfd->stream->unique_id);
json_update_crypto_params(builder, "", &sfd->crypto.params); json_update_crypto_params(inner, "", &sfd->crypto.params);
} }
json_builder_end_object(builder);
} // --- for } // --- for
@ -2447,9 +2446,7 @@ char* redis_encode_json(call_t *c) {
LOCK(&ps->out_lock); LOCK(&ps->out_lock);
snprintf(tmp, sizeof(tmp), "stream-%u", ps->unique_id); snprintf(tmp, sizeof(tmp), "stream-%u", ps->unique_id);
json_builder_set_member_name(builder, tmp); inner = redis_parser->dict_add_dict_dup(root, tmp);
json_builder_begin_object(builder);
{ {
JSON_SET_SIMPLE("media","%u",ps->media->unique_id); JSON_SET_SIMPLE("media","%u",ps->media->unique_id);
@ -2464,11 +2461,9 @@ char* redis_encode_json(call_t *c) {
JSON_SET_SIMPLE("stats-bytes","%" PRIu64, atomic64_get_na(&ps->stats_in->bytes)); JSON_SET_SIMPLE("stats-bytes","%" PRIu64, atomic64_get_na(&ps->stats_in->bytes));
JSON_SET_SIMPLE("stats-errors","%" PRIu64, atomic64_get_na(&ps->stats_in->errors)); JSON_SET_SIMPLE("stats-errors","%" PRIu64, atomic64_get_na(&ps->stats_in->errors));
json_update_crypto_params(builder, "", &ps->crypto.params); json_update_crypto_params(inner, "", &ps->crypto.params);
} }
json_builder_end_object(builder);
// stream_sfds was here before // stream_sfds was here before
} // --- for streams.head } // --- for streams.head
@ -2482,33 +2477,27 @@ char* redis_encode_json(call_t *c) {
LOCK(&ps->out_lock); LOCK(&ps->out_lock);
snprintf(tmp, sizeof(tmp), "stream_sfds-%u", ps->unique_id); snprintf(tmp, sizeof(tmp), "stream_sfds-%u", ps->unique_id);
json_builder_set_member_name(builder, tmp); inner = redis_parser->dict_add_list_dup(root, tmp);
json_builder_begin_array(builder);
for (__auto_type k = ps->sfds.head; k; k = k->next) { for (__auto_type k = ps->sfds.head; k; k = k->next) {
stream_fd *sfd = k->data; stream_fd *sfd = k->data;
JSON_ADD_STRING("%u", sfd->unique_id); JSON_ADD_LIST_STRING("%u", sfd->unique_id);
} }
json_builder_end_array(builder);
snprintf(tmp, sizeof(tmp), "rtp_sinks-%u", ps->unique_id); snprintf(tmp, sizeof(tmp), "rtp_sinks-%u", ps->unique_id);
json_builder_set_member_name(builder, tmp); inner = redis_parser->dict_add_list_dup(root, tmp);
json_builder_begin_array(builder);
for (__auto_type k = ps->rtp_sinks.head; k; k = k->next) { for (__auto_type k = ps->rtp_sinks.head; k; k = k->next) {
struct sink_handler *sh = k->data; struct sink_handler *sh = k->data;
struct packet_stream *sink = sh->sink; struct packet_stream *sink = sh->sink;
JSON_ADD_STRING("%u", sink->unique_id); JSON_ADD_LIST_STRING("%u", sink->unique_id);
} }
json_builder_end_array(builder);
snprintf(tmp, sizeof(tmp), "rtcp_sinks-%u", ps->unique_id); snprintf(tmp, sizeof(tmp), "rtcp_sinks-%u", ps->unique_id);
json_builder_set_member_name(builder, tmp); inner = redis_parser->dict_add_list_dup(root, tmp);
json_builder_begin_array(builder);
for (__auto_type k = ps->rtcp_sinks.head; k; k = k->next) { for (__auto_type k = ps->rtcp_sinks.head; k; k = k->next) {
struct sink_handler *sh = k->data; struct sink_handler *sh = k->data;
struct packet_stream *sink = sh->sink; struct packet_stream *sink = sh->sink;
JSON_ADD_STRING("%u", sink->unique_id); JSON_ADD_LIST_STRING("%u", sink->unique_id);
} }
json_builder_end_array(builder);
} }
@ -2516,9 +2505,8 @@ char* redis_encode_json(call_t *c) {
struct call_monologue *ml = l->data; struct call_monologue *ml = l->data;
snprintf(tmp, sizeof(tmp), "tag-%u", ml->unique_id); snprintf(tmp, sizeof(tmp), "tag-%u", ml->unique_id);
json_builder_set_member_name(builder, tmp); inner = redis_parser->dict_add_dict_dup(root, tmp);
json_builder_begin_object(builder);
{ {
JSON_SET_SIMPLE("created", "%llu", (long long unsigned) ml->created); JSON_SET_SIMPLE("created", "%llu", (long long unsigned) ml->created);
@ -2567,7 +2555,6 @@ char* redis_encode_json(call_t *c) {
if (ml->sdp_session_rs >= 0) if (ml->sdp_session_rs >= 0)
JSON_SET_SIMPLE("sdp_session_rs", "%i", ml->sdp_session_rs); JSON_SET_SIMPLE("sdp_session_rs", "%i", ml->sdp_session_rs);
} }
json_builder_end_object(builder);
// other_tags and medias- was here before // other_tags and medias- was here before
@ -2579,34 +2566,29 @@ char* redis_encode_json(call_t *c) {
// XXX these should all go into the above loop // XXX these should all go into the above loop
GList *k = g_hash_table_get_values(ml->associated_tags); GList *k = g_hash_table_get_values(ml->associated_tags);
snprintf(tmp, sizeof(tmp), "associated_tags-%u", ml->unique_id); snprintf(tmp, sizeof(tmp), "associated_tags-%u", ml->unique_id);
json_builder_set_member_name(builder, tmp); inner = redis_parser->dict_add_list_dup(root, tmp);
json_builder_begin_array(builder);
for (GList *m = k; m; m = m->next) { for (GList *m = k; m; m = m->next) {
struct call_monologue *ml2 = m->data; struct call_monologue *ml2 = m->data;
JSON_ADD_STRING("%u", ml2->unique_id); JSON_ADD_LIST_STRING("%u", ml2->unique_id);
} }
json_builder_end_array(builder);
g_list_free(k); g_list_free(k);
snprintf(tmp, sizeof(tmp), "medias-%u", ml->unique_id); snprintf(tmp, sizeof(tmp), "medias-%u", ml->unique_id);
json_builder_set_member_name(builder, tmp); inner = redis_parser->dict_add_list_dup(root, tmp);
json_builder_begin_array (builder);
for (unsigned int j = 0; j < ml->medias->len; j++) { for (unsigned int j = 0; j < ml->medias->len; j++) {
struct call_media *media = ml->medias->pdata[j]; struct call_media *media = ml->medias->pdata[j];
JSON_ADD_STRING("%u", media ? media->unique_id : -1); JSON_ADD_LIST_STRING("%u", media ? media->unique_id : -1);
} }
json_builder_end_array(builder);
// SSRC table dump // SSRC table dump
rwlock_lock_r(&ml->ssrc_hash->lock); rwlock_lock_r(&ml->ssrc_hash->lock);
k = g_hash_table_get_values(ml->ssrc_hash->ht); k = g_hash_table_get_values(ml->ssrc_hash->ht);
snprintf(tmp, sizeof(tmp), "ssrc_table-%u", ml->unique_id); snprintf(tmp, sizeof(tmp), "ssrc_table-%u", ml->unique_id);
json_builder_set_member_name(builder, tmp); parser_arg list = redis_parser->dict_add_list_dup(root, tmp);
json_builder_begin_array(builder);
for (GList *m = k; m; m = m->next) { for (GList *m = k; m; m = m->next) {
struct ssrc_entry_call *se = m->data; struct ssrc_entry_call *se = m->data;
json_builder_begin_object (builder); inner = redis_parser->list_add_dict(list);
JSON_SET_SIMPLE("ssrc", "%" PRIu32, se->h.ssrc); JSON_SET_SIMPLE("ssrc", "%" PRIu32, se->h.ssrc);
// XXX use function for in/out // XXX use function for in/out
@ -2617,10 +2599,7 @@ char* redis_encode_json(call_t *c) {
JSON_SET_SIMPLE("out_srtcp_index", "%u", atomic_get_na(&se->output_ctx.stats->rtcp_seq)); JSON_SET_SIMPLE("out_srtcp_index", "%u", atomic_get_na(&se->output_ctx.stats->rtcp_seq));
JSON_SET_SIMPLE("out_payload_type", "%i", se->output_ctx.tracker.most[0]); JSON_SET_SIMPLE("out_payload_type", "%i", se->output_ctx.tracker.most[0]);
// XXX add rest of info // XXX add rest of info
json_builder_end_object(builder);
} }
json_builder_end_array(builder);
g_list_free(k); g_list_free(k);
rwlock_unlock_r(&ml->ssrc_hash->lock); rwlock_unlock_r(&ml->ssrc_hash->lock);
@ -2634,24 +2613,21 @@ char* redis_encode_json(call_t *c) {
/* store media subscriptions */ /* store media subscriptions */
snprintf(tmp, sizeof(tmp), "media-subscriptions-%u", media->unique_id); snprintf(tmp, sizeof(tmp), "media-subscriptions-%u", media->unique_id);
json_builder_set_member_name(builder, tmp); inner = redis_parser->dict_add_list_dup(root, tmp);
json_builder_begin_array(builder);
for (__auto_type sub = media->media_subscriptions.head; sub; sub = sub->next) for (__auto_type sub = media->media_subscriptions.head; sub; sub = sub->next)
{ {
struct media_subscription * ms = sub->data; struct media_subscription * ms = sub->data;
JSON_ADD_STRING("%u/%u/%u/%u", JSON_ADD_LIST_STRING("%u/%u/%u/%u",
ms->media->unique_id, ms->media->unique_id,
ms->attrs.offer_answer, ms->attrs.offer_answer,
ms->attrs.rtcp_only, ms->attrs.rtcp_only,
ms->attrs.egress); ms->attrs.egress);
} }
json_builder_end_array(builder);
snprintf(tmp, sizeof(tmp), "media-%u", media->unique_id); snprintf(tmp, sizeof(tmp), "media-%u", media->unique_id);
json_builder_set_member_name(builder, tmp); inner = redis_parser->dict_add_dict_dup(root, tmp);
json_builder_begin_object(builder);
{ {
JSON_SET_SIMPLE("tag","%u", media->monologue->unique_id); JSON_SET_SIMPLE("tag","%u", media->monologue->unique_id);
JSON_SET_SIMPLE("index","%u", media->index); JSON_SET_SIMPLE("index","%u", media->index);
@ -2674,14 +2650,12 @@ char* redis_encode_json(call_t *c) {
if (media->bandwidth_rs >= 0) if (media->bandwidth_rs >= 0)
JSON_SET_SIMPLE("bandwidth_rs","%i", media->bandwidth_rs); JSON_SET_SIMPLE("bandwidth_rs","%i", media->bandwidth_rs);
json_update_sdes_params(builder, "media", media->unique_id, "sdes_in", json_update_sdes_params(inner, "media", media->unique_id, "sdes_in",
&media->sdes_in); &media->sdes_in);
json_update_sdes_params(builder, "media", media->unique_id, "sdes_out", json_update_sdes_params(inner, "media", media->unique_id, "sdes_out",
&media->sdes_out); &media->sdes_out);
json_update_dtls_fingerprint(builder, "media", media->unique_id, &media->fingerprint); json_update_dtls_fingerprint(inner, "media", media->unique_id, &media->fingerprint);
} }
json_builder_end_object(builder);
} // --- for medias.head } // --- for medias.head
// -- we do it again here since the jsonbuilder is linear straight forward // -- we do it again here since the jsonbuilder is linear straight forward
@ -2690,43 +2664,36 @@ char* redis_encode_json(call_t *c) {
struct call_media *media = l->data; struct call_media *media = l->data;
snprintf(tmp, sizeof(tmp), "streams-%u", media->unique_id); snprintf(tmp, sizeof(tmp), "streams-%u", media->unique_id);
json_builder_set_member_name(builder, tmp); inner = redis_parser->dict_add_list_dup(root, tmp);
json_builder_begin_array(builder);
for (__auto_type m = media->streams.head; m; m = m->next) { for (__auto_type m = media->streams.head; m; m = m->next) {
struct packet_stream *ps = m->data; struct packet_stream *ps = m->data;
JSON_ADD_STRING("%u", ps->unique_id); JSON_ADD_LIST_STRING("%u", ps->unique_id);
} }
json_builder_end_array(builder);
snprintf(tmp, sizeof(tmp), "maps-%u", media->unique_id); snprintf(tmp, sizeof(tmp), "maps-%u", media->unique_id);
json_builder_set_member_name(builder, tmp); inner = redis_parser->dict_add_list_dup(root, tmp);
json_builder_begin_array(builder);
for (__auto_type m = media->endpoint_maps.head; m; m = m->next) { for (__auto_type m = media->endpoint_maps.head; m; m = m->next) {
struct endpoint_map *ep = m->data; struct endpoint_map *ep = m->data;
JSON_ADD_STRING("%u", ep->unique_id); JSON_ADD_LIST_STRING("%u", ep->unique_id);
} }
json_builder_end_array(builder);
snprintf(tmp, sizeof(tmp), "payload_types-%u", media->unique_id); snprintf(tmp, sizeof(tmp), "payload_types-%u", media->unique_id);
json_builder_set_member_name(builder, tmp); inner = redis_parser->dict_add_list_dup(root, tmp);
json_builder_begin_array(builder);
for (__auto_type m = media->codecs.codec_prefs.head; m; m = m->next) { for (__auto_type m = media->codecs.codec_prefs.head; m; m = m->next) {
rtp_payload_type *pt = m->data; rtp_payload_type *pt = m->data;
JSON_ADD_STRING("%u/" STR_FORMAT "/%u/" STR_FORMAT "/" STR_FORMAT "/%i/%i", JSON_ADD_LIST_STRING("%u/" STR_FORMAT "/%u/" STR_FORMAT "/" STR_FORMAT "/%i/%i",
pt->payload_type, STR_FMT(&pt->encoding), pt->payload_type, STR_FMT(&pt->encoding),
pt->clock_rate, STR_FMT(&pt->encoding_parameters), pt->clock_rate, STR_FMT(&pt->encoding_parameters),
STR_FMT(&pt->format_parameters), pt->bitrate, pt->ptime); STR_FMT(&pt->format_parameters), pt->bitrate, pt->ptime);
} }
json_builder_end_array(builder);
} }
for (__auto_type l = c->endpoint_maps.head; l; l = l->next) { for (__auto_type l = c->endpoint_maps.head; l; l = l->next) {
struct endpoint_map *ep = l->data; struct endpoint_map *ep = l->data;
snprintf(tmp, sizeof(tmp), "map-%u", ep->unique_id); snprintf(tmp, sizeof(tmp), "map-%u", ep->unique_id);
json_builder_set_member_name(builder, tmp); inner = redis_parser->dict_add_dict_dup(root, tmp);
json_builder_begin_object(builder);
{ {
JSON_SET_SIMPLE("wildcard","%i", ep->wildcard); JSON_SET_SIMPLE("wildcard","%i", ep->wildcard);
JSON_SET_SIMPLE("num_ports","%u", ep->num_ports); JSON_SET_SIMPLE("num_ports","%u", ep->num_ports);
@ -2735,7 +2702,6 @@ char* redis_encode_json(call_t *c) {
JSON_SET_SIMPLE_CSTR("endpoint", endpoint_print_buf(&ep->endpoint)); JSON_SET_SIMPLE_CSTR("endpoint", endpoint_print_buf(&ep->endpoint));
} }
json_builder_end_object(builder);
} // --- for c->endpoint_maps.head } // --- for c->endpoint_maps.head
@ -2744,24 +2710,22 @@ char* redis_encode_json(call_t *c) {
struct endpoint_map *ep = l->data; struct endpoint_map *ep = l->data;
snprintf(tmp, sizeof(tmp), "map_sfds-%u", ep->unique_id); snprintf(tmp, sizeof(tmp), "map_sfds-%u", ep->unique_id);
json_builder_set_member_name(builder, tmp); inner = redis_parser->dict_add_list_dup(root, tmp);
json_builder_begin_array(builder);
for (__auto_type m = ep->intf_sfds.head; m; m = m->next) { for (__auto_type m = ep->intf_sfds.head; m; m = m->next) {
struct sfd_intf_list *il = m->data; struct sfd_intf_list *il = m->data;
JSON_ADD_STRING("loc-%u", il->local_intf->unique_id); JSON_ADD_LIST_STRING("loc-%u", il->local_intf->unique_id);
for (__auto_type n = il->list.head; n; n = n->next) { for (__auto_type n = il->list.head; n; n = n->next) {
stream_fd *sfd = n->data; stream_fd *sfd = n->data;
JSON_ADD_STRING("%u", sfd->unique_id); JSON_ADD_LIST_STRING("%u", sfd->unique_id);
} }
} }
json_builder_end_array(builder);
} }
} }
json_builder_end_object(builder);
return glib_json_print(builder);
str ret;
redis_parser->collapse(ctx, root, &ret);
return ret;
} }
@ -2790,19 +2754,22 @@ void redis_update_onekey(call_t *c, struct redis *r) {
goto err; goto err;
} }
char* result = redis_encode_json(c); ng_parser_ctx_t ctx = {.parser = redis_parser};
if (!result) ctx.ngbuf = ng_buffer_new(NULL);
str result = redis_encode_json(&ctx, c);
if (!result.len)
goto err; goto err;
redis_pipe(r, "SET "PB" %s", PBSTR(&c->callid), result); redis_pipe(r, "SET " PB " " PB, PBSTR(&c->callid), PBSTR(&result));
redis_pipe(r, "EXPIRE "PB" %i", PBSTR(&c->callid), redis_expires_s); redis_pipe(r, "EXPIRE "PB" %i", PBSTR(&c->callid), redis_expires_s);
redis_consume(r); redis_consume(r);
if (result)
free(result);
rwlock_unlock_r(&c->master_lock); rwlock_unlock_r(&c->master_lock);
obj_put(ctx.ngbuf);
return; return;
err: err:
if (r->ctx && r->ctx->err) if (r->ctx && r->ctx->err)

1
include/control_ng.h
Unescape View File

@ -147,6 +147,7 @@ struct ng_parser {
parser_arg (*dict_add_dict)(parser_arg, const char *); parser_arg (*dict_add_dict)(parser_arg, const char *);
parser_arg (*dict_add_dict_dup)(parser_arg, const char *); parser_arg (*dict_add_dict_dup)(parser_arg, const char *);
parser_arg (*dict_add_list)(parser_arg, const char *); parser_arg (*dict_add_list)(parser_arg, const char *);
parser_arg (*dict_add_list_dup)(parser_arg, const char *);
parser_arg (*list)(ng_parser_ctx_t *); parser_arg (*list)(ng_parser_ctx_t *);
parser_arg (*list_add)(parser_arg, parser_arg); parser_arg (*list_add)(parser_arg, parser_arg);
parser_arg (*list_add_dict)(parser_arg); parser_arg (*list_add_dict)(parser_arg);

1
lib/str.h
Unescape View File

@ -38,6 +38,7 @@ TYPED_GQUEUE(str, str)
#define STR_EMPTY ((str) { "", 0 }) #define STR_EMPTY ((str) { "", 0 })
#define STR_CONST(s) ((str) { s, sizeof(s)-1 }) #define STR_CONST(s) ((str) { s, sizeof(s)-1 })
#define STR(s) ((str) { (char *) (s), (s) ? strlen(s) : 0 }) #define STR(s) ((str) { (char *) (s), (s) ? strlen(s) : 0 })
#define STR_NC(s) ((str) { (char *) (s), strlen(s) })
#define STR_GS(s) ((str) { (s)->str, (s)->len }) #define STR_GS(s) ((str) { (s)->str, (s)->len })
#define STR_LEN(s, len) ((str) { (char *) (s), len }) #define STR_LEN(s, len) ((str) { (char *) (s), len })
#define STR_LEN_ASSERT(s, len) ({ assert(sizeof(s) >= len); (str) { (char *) (s), len }; }) #define STR_LEN_ASSERT(s, len) ({ assert(sizeof(s) >= len); (str) { (char *) (s), len }; })

Write Preview
Loading…
Cancel
Save