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

MT#55283 extend parser_arg to return types

Browse Source 
Requires boilerplate wrapper functions :(

Change-Id: Ice6b0bb055082fb2c8893ec9a57488f56c0218c3
pull/1848/head
Richard Fuchs 1 year ago
parent 93653fe562
commit 0cc7f3ba44
4 changed files with 83 additions and 68 deletions
Show Stats Download Patch File Download Diff File

96
daemon/call_interfaces.c
Unescape View File

@ -63,7 +63,7 @@ static void call_ng_flags_list(ng_parser_ctx_t *, bencode_item_t *list,
void (*item_callback)(ng_parser_ctx_t *, bencode_item_t *, helper_arg),
helper_arg);
static void call_ng_flags_esc_str_list(ng_parser_ctx_t *out, str *s, helper_arg);
static void ng_stats_ssrc(const ng_parser_t *parser, bencode_item_t *dict, struct ssrc_hash *ht);
static void ng_stats_ssrc(const ng_parser_t *parser, parser_arg dict, struct ssrc_hash *ht);
static str *str_dup_escape(const str *s);
static void call_set_dtmf_block(call_t *call, struct call_monologue *monologue, sdp_ng_flags *flags);
@ -2330,7 +2330,7 @@ err:
return NULL;
}
static void ng_stats(const ng_parser_t *parser, bencode_item_t *d, const struct stream_stats *s,
static void ng_stats(const ng_parser_t *parser, parser_arg d, const struct stream_stats *s,
struct stream_stats *totals)
{
parser->dict_add_int(d, "packets", atomic64_get_na(&s->packets));
@ -2343,7 +2343,7 @@ static void ng_stats(const ng_parser_t *parser, bencode_item_t *d, const struct
atomic64_add_na(&totals->errors, atomic64_get(&s->errors));
}
static void ng_stats_endpoint(const ng_parser_t *parser, bencode_item_t *dict, const endpoint_t *ep) {
static void ng_stats_endpoint(const ng_parser_t *parser, parser_arg dict, const endpoint_t *ep) {
if (!ep->address.family)
return;
parser->dict_add_string(dict, "family", ep->address.family->name);
@ -2351,18 +2351,18 @@ static void ng_stats_endpoint(const ng_parser_t *parser, bencode_item_t *dict, c
parser->dict_add_int(dict, "port", ep->port);
}
static void ng_stats_stream_ssrc(const ng_parser_t *parser, bencode_item_t *dict,
static void ng_stats_stream_ssrc(const ng_parser_t *parser, parser_arg dict,
struct ssrc_ctx *const ssrcs[RTPE_NUM_SSRC_TRACKING],
const char *label)
{
bencode_item_t *list = parser->dict_add_list(dict, label);
parser_arg list = parser->dict_add_list(dict, label);
for (int i = 0; i < RTPE_NUM_SSRC_TRACKING; i++) {
struct ssrc_ctx *c = ssrcs[i];
if (!c)
break;
bencode_item_t *ssrc = parser->list_add_dict(list);
parser_arg ssrc = parser->list_add_dict(list);
parser->dict_add_int(ssrc, "SSRC", ssrcs[i]->parent->h.ssrc);
parser->dict_add_int(ssrc, "bytes", atomic64_get_na(&c->stats->bytes));
@ -2374,13 +2374,13 @@ static void ng_stats_stream_ssrc(const ng_parser_t *parser, bencode_item_t *dict
#define BF_PS(k, f) if (PS_ISSET(ps, f)) parser->list_add_string(flags, k)
static void ng_stats_stream(const ng_parser_t *parser, bencode_item_t *list, const struct packet_stream *ps,
static void ng_stats_stream(const ng_parser_t *parser, parser_arg list, const struct packet_stream *ps,
struct call_stats *totals)
{
bencode_item_t *dict = NULL, *flags;
parser_arg dict = {0}, flags;
struct stream_stats *s;
if (!list)
if (!list.gen)
goto stats;
dict = parser->list_add_dict(list);
@ -2432,14 +2432,14 @@ stats:
#define BF_M(k, f) if (MEDIA_ISSET(m, f)) parser->list_add_string(flags, k)
static void ng_stats_media(const ng_parser_t *parser, bencode_item_t *list, const struct call_media *m,
static void ng_stats_media(const ng_parser_t *parser, parser_arg list, const struct call_media *m,
struct call_stats *totals)
{
bencode_item_t *dict, *streams = NULL, *flags;
parser_arg dict, streams = {0}, flags;
struct packet_stream *ps;
const rtp_payload_type *rtp_pt = NULL;
if (!list)
if (!list.gen)
goto stats;
rtp_pt = __rtp_stats_codec((struct call_media *)m);
@ -2494,10 +2494,10 @@ stats:
}
}
static void ng_stats_monologue(const ng_parser_t *parser, bencode_item_t *dict, const struct call_monologue *ml,
struct call_stats *totals, bencode_item_t *ssrc)
static void ng_stats_monologue(const ng_parser_t *parser, parser_arg dict, const struct call_monologue *ml,
struct call_stats *totals, parser_arg ssrc)
{
bencode_item_t *sub, *medias = NULL;
parser_arg sub, medias = {0};
struct call_media *m;
g_auto(GQueue) mls_subscriptions = G_QUEUE_INIT; /* to avoid duplications */
g_auto(GQueue) mls_subscribers = G_QUEUE_INIT; /* to avoid duplications */
@ -2505,7 +2505,7 @@ static void ng_stats_monologue(const ng_parser_t *parser, bencode_item_t *dict,
if (!ml)
return;
if (!dict)
if (!dict.gen)
goto stats;
if (ml->tag.len)
@ -2523,8 +2523,8 @@ static void ng_stats_monologue(const ng_parser_t *parser, bencode_item_t *dict,
parser->dict_add_str(sub, "label", &ml->label);
parser->dict_add_int(sub, "created", ml->created);
bencode_item_t *b_subscriptions = parser->dict_add_list(sub, "subscriptions");
bencode_item_t *b_subscribers = parser->dict_add_list(sub, "subscribers");
parser_arg b_subscriptions = parser->dict_add_list(sub, "subscriptions");
parser_arg b_subscribers = parser->dict_add_list(sub, "subscribers");
for (int i = 0; i < ml->medias->len; i++)
{
struct call_media * media = ml->medias->pdata[i];
@ -2537,7 +2537,7 @@ static void ng_stats_monologue(const ng_parser_t *parser, bencode_item_t *dict,
{
struct media_subscription * ms = subscription->data;
if (!g_queue_find(&mls_subscriptions, ms->monologue)) {
bencode_item_t *sub1 = parser->list_add_dict(b_subscriptions);
parser_arg sub1 = parser->list_add_dict(b_subscriptions);
parser->dict_add_str(sub1, "tag", &ms->monologue->tag);
parser->dict_add_string(sub1, "type", ms->attrs.offer_answer ? "offer/answer" : "pub/sub");
g_queue_push_tail(&mls_subscriptions, ms->monologue);
@ -2549,7 +2549,7 @@ static void ng_stats_monologue(const ng_parser_t *parser, bencode_item_t *dict,
{
struct media_subscription * ms = subscriber->data;
if (!g_queue_find(&mls_subscribers, ms->monologue)) {
bencode_item_t *sub1 = parser->list_add_dict(b_subscribers);
parser_arg sub1 = parser->list_add_dict(b_subscribers);
parser->dict_add_str(sub1, "tag", &ms->monologue->tag);
parser->dict_add_string(sub1, "type", ms->attrs.offer_answer ? "offer/answer" : "pub/sub");
g_queue_push_tail(&mls_subscribers, ms->monologue);
@ -2561,12 +2561,12 @@ static void ng_stats_monologue(const ng_parser_t *parser, bencode_item_t *dict,
medias = parser->dict_add_list(sub, "medias");
bencode_item_t *list = parser->dict_add_list(sub, "VSC");
parser_arg list = parser->dict_add_list(sub, "VSC");
for (unsigned int i = 0; i < ml->num_dtmf_triggers; i++) {
const struct dtmf_trigger_state *state = &ml->dtmf_trigger_state[i];
if (state->trigger.len == 0)
continue;
bencode_item_t *vsc = parser->list_add_dict(list);
parser_arg vsc = parser->list_add_dict(list);
const char *type = dtmf_trigger_types[state->type];
if (type)
parser->dict_add_string(vsc, "type", type);
@ -2575,7 +2575,7 @@ static void ng_stats_monologue(const ng_parser_t *parser, bencode_item_t *dict,
}
if (ml->call->recording) {
bencode_item_t *rec = parser->dict_add_dict(sub, "recording");
parser_arg rec = parser->dict_add_dict(sub, "recording");
parser->dict_add_int(rec, "excluded", !!ML_ISSET(ml, NO_RECORDING));
parser->dict_add_int(rec, "forwarding", !!ML_ISSET(ml, REC_FORWARDING));
}
@ -2589,7 +2589,7 @@ stats:
}
}
static void ng_stats_ssrc_mos_entry_common(const ng_parser_t *parser, bencode_item_t *subent,
static void ng_stats_ssrc_mos_entry_common(const ng_parser_t *parser, parser_arg subent,
struct ssrc_stats_block *sb,
unsigned int div)
{
@ -2599,28 +2599,28 @@ static void ng_stats_ssrc_mos_entry_common(const ng_parser_t *parser, bencode_it
parser->dict_add_int(subent, "jitter", sb->jitter / div);
parser->dict_add_int(subent, "packet loss", sb->packetloss / div);
}
static void ng_stats_ssrc_mos_entry(const ng_parser_t *parser, bencode_item_t *subent,
static void ng_stats_ssrc_mos_entry(const ng_parser_t *parser, parser_arg subent,
struct ssrc_stats_block *sb)
{
ng_stats_ssrc_mos_entry_common(parser, subent, sb, 1);
parser->dict_add_int(subent, "reported at", sb->reported.tv_sec);
}
static void ng_stats_ssrc_mos_entry_dict(const ng_parser_t *parser, bencode_item_t *ent, const char *label,
static void ng_stats_ssrc_mos_entry_dict(const ng_parser_t *parser, parser_arg ent, const char *label,
struct ssrc_stats_block *sb)
{
bencode_item_t *subent = parser->dict_add_dict(ent, label);
parser_arg subent = parser->dict_add_dict(ent, label);
ng_stats_ssrc_mos_entry(parser, subent, sb);
}
static void ng_stats_ssrc_mos_entry_dict_avg(const ng_parser_t *parser, bencode_item_t *ent, const char *label,
static void ng_stats_ssrc_mos_entry_dict_avg(const ng_parser_t *parser, parser_arg ent, const char *label,
struct ssrc_stats_block *sb,
unsigned int div)
{
bencode_item_t *subent = parser->dict_add_dict(ent, label);
parser_arg subent = parser->dict_add_dict(ent, label);
ng_stats_ssrc_mos_entry_common(parser, subent, sb, div);
parser->dict_add_int(subent, "samples", div);
}
static void ng_stats_ssrc(const ng_parser_t *parser, bencode_item_t *dict, struct ssrc_hash *ht) {
static void ng_stats_ssrc(const ng_parser_t *parser, parser_arg dict, struct ssrc_hash *ht) {
GList *ll = g_hash_table_get_values(ht->ht);
for (GList *l = ll; l; l = l->next) {
@ -2632,7 +2632,7 @@ static void ng_stats_ssrc(const ng_parser_t *parser, bencode_item_t *dict, struc
if (!se->stats_blocks.length || !se->lowest_mos || !se->highest_mos)
continue;
bencode_item_t *ent = parser->dict_add_dict_dup(dict, tmp);
parser_arg ent = parser->dict_add_dict_dup(dict, tmp);
parser->dict_add_int(ent, "cumulative loss", se->packets_lost);
@ -2642,7 +2642,7 @@ static void ng_stats_ssrc(const ng_parser_t *parser, bencode_item_t *dict, struc
ng_stats_ssrc_mos_entry_dict(parser, ent, "lowest MOS", se->lowest_mos);
ng_stats_ssrc_mos_entry_dict(parser, ent, "highest MOS", se->highest_mos);
bencode_item_t *progdict = parser->dict_add_dict(ent, "MOS progression");
parser_arg progdict = parser->dict_add_dict(ent, "MOS progression");
// aim for about 10 entries to the list
GList *listent = se->stats_blocks.head;
struct ssrc_stats_block *sb = listent->data;
@ -2652,14 +2652,14 @@ static void ng_stats_ssrc(const ng_parser_t *parser, bencode_item_t *dict, struc
interval /= 10;
parser->dict_add_int(progdict, "interval", interval);
time_t next_step = sb->reported.tv_sec;
bencode_item_t *entlist = parser->dict_add_list(progdict, "entries");
parser_arg entlist = parser->dict_add_list(progdict, "entries");
for (; listent; listent = listent->next) {
sb = listent->data;
if (sb->reported.tv_sec < next_step)
continue;
next_step += interval;
bencode_item_t *cent = parser->list_add_dict(entlist);
parser_arg cent = parser->list_add_dict(entlist);
ng_stats_ssrc_mos_entry(parser, cent, sb);
}
}
@ -2671,11 +2671,11 @@ static void ng_stats_ssrc(const ng_parser_t *parser, bencode_item_t *dict, struc
void ng_call_stats(ng_parser_ctx_t *ctx, call_t *call, const str *fromtag, const str *totag,
struct call_stats *totals)
{
bencode_item_t *tags = NULL, *dict;
parser_arg tags = {0}, dict;
const str *match_tag;
struct call_monologue *ml;
struct call_stats t_b;
bencode_item_t *ssrc = NULL;
parser_arg ssrc = {0};
if (!totals)
totals = &t_b;
@ -2736,13 +2736,13 @@ stats:
ng_stats(ctx->parser, ctx->parser->dict_add_dict(dict, "RTCP"), &totals->totals[1], NULL);
if (call->recording) {
bencode_item_t *rec = ctx->parser->dict_add_dict(ctx->resp, "recording");
parser_arg rec = ctx->parser->dict_add_dict(ctx->resp, "recording");
ctx->parser->dict_add_int(rec, "call recording", !!CALL_ISSET(call, RECORDING_ON));
ctx->parser->dict_add_int(rec, "forwarding", !!CALL_ISSET(call, REC_FORWARDING));
}
}
static void ng_list_calls(ng_parser_ctx_t *ctx, bencode_item_t *output, long long int limit) {
static void ng_list_calls(ng_parser_ctx_t *ctx, parser_arg output, long long int limit) {
rtpe_calls_ht_iter iter;
rwlock_lock_r(&rtpe_callhash_lock);
@ -2780,7 +2780,7 @@ const char *call_query_ng(ng_parser_ctx_t *ctx) {
const char *call_list_ng(ng_parser_ctx_t *ctx) {
bencode_item_t *calls = NULL;
parser_arg calls;
long long int limit;
parser_arg input = ctx->req;
parser_arg output = ctx->resp;
@ -3750,34 +3750,34 @@ const char *call_subscribe_request_ng(ng_parser_ctx_t *ctx) {
struct call_monologue *source_ml = ms->monologue;
ctx->parser->dict_add_str_dup(output, "from-tag", &source_ml->tag);
}
bencode_item_t *tag_medias = NULL, *media_labels = NULL;
parser_arg tag_medias = {0}, media_labels = {0};
if (flags.siprec) {
tag_medias = ctx->parser->dict_add_list(output, "tag-medias");
media_labels = ctx->parser->dict_add_dict(output, "media-labels");
}
bencode_item_t *from_list = ctx->parser->dict_add_list(output, "from-tags");
parser_arg from_list = ctx->parser->dict_add_list(output, "from-tags");
for (__auto_type l = srms.head; l; l = l->next) {
struct media_subscription *ms = l->data;
struct call_monologue *source_ml = ms->monologue;
bencode_list_add_str_dup(from_list, &source_ml->tag);
if (tag_medias) {
bencode_item_t *tag_label = ctx->parser->list_add_dict(tag_medias);
ctx->parser->list_add_str_dup(from_list, &source_ml->tag);
if (tag_medias.gen) {
parser_arg tag_label = ctx->parser->list_add_dict(tag_medias);
ctx->parser->dict_add_str(tag_label, "tag", &source_ml->tag);
if (source_ml->label.len)
ctx->parser->dict_add_str(tag_label, "label", &source_ml->label);
bencode_item_t *medias = ctx->parser->dict_add_list(tag_label, "medias");
parser_arg medias = ctx->parser->dict_add_list(tag_label, "medias");
for (unsigned int i = 0; i < source_ml->medias->len; i++) {
struct call_media *media = source_ml->medias->pdata[i];
if (!media)
continue;
bencode_item_t *med_ent = ctx->parser->list_add_dict(medias);
parser_arg med_ent = ctx->parser->list_add_dict(medias);
ctx->parser->dict_add_int(med_ent, "index", media->index);
ctx->parser->dict_add_str(med_ent, "type", &media->type);
ctx->parser->dict_add_str(med_ent, "label", &media->label);
ctx->parser->dict_add_string(med_ent, "mode", sdp_get_sendrecv(media));
if (media_labels) {
bencode_item_t *label =
if (media_labels.gen) {
parser_arg label =
ctx->parser->dict_add_dict(media_labels, media->label.s);
ctx->parser->dict_add_str(label, "tag", &source_ml->tag);
ctx->parser->dict_add_int(label, "index", media->index);

39
daemon/control_ng.c
Unescape View File

@ -145,11 +145,26 @@ static parser_arg __bencode_dictionary_get_expect(bencode_item_t *arg, const cha
static bool __bencode_dictionary_contains(bencode_item_t *d, const char *ele) {
return bencode_dictionary_get(d, ele) != NULL;
}
static bencode_item_t *__bencode_dictionary_add_dictionary_dup(bencode_item_t *n, const char *e) {
static parser_arg __bencode_dictionary_add(bencode_item_t *n, const char *e, bencode_item_t *v) {
return (parser_arg) bencode_dictionary_add(n, e, v);
}
static parser_arg __bencode_dictionary_add_dictionary(bencode_item_t *n, const char *e) {
return (parser_arg) bencode_dictionary_add_dictionary(n, e);
}
static parser_arg __bencode_dictionary_add_dictionary_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 bencode_dictionary_add_dictionary(n, s);
return (parser_arg) bencode_dictionary_add_dictionary(n, s);
}
static parser_arg __bencode_dictionary_add_list(bencode_item_t *n, const char *e) {
return (parser_arg) bencode_dictionary_add_list(n, e);
}
static parser_arg __bencode_list_add(bencode_item_t *l, bencode_item_t *e) {
return (parser_arg) bencode_list_add(l, e);
}
static parser_arg __bencode_list_add_dictionary(bencode_item_t *l) {
return (parser_arg) bencode_list_add_dictionary(l);
}
static bool json_is_dict(JsonNode *n) {
@ -341,17 +356,17 @@ const ng_parser_t ng_parser_native = {
.dict_get_int_str = bencode_dictionary_get_int_str,
.dict_get_expect = __bencode_dictionary_get_expect,
.dict_contains = __bencode_dictionary_contains,
.dict_add = bencode_dictionary_add,
.dict_add = __bencode_dictionary_add,
.dict_add_string = bencode_dictionary_add_string,
.dict_add_str = bencode_dictionary_add_str,
.dict_add_str_dup = bencode_dictionary_add_str_dup,
.dict_add_int = bencode_dictionary_add_integer,
.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_list = bencode_dictionary_add_list,
.dict_add_list = __bencode_dictionary_add_list,
.list = __bencode_list,
.list_add = bencode_list_add,
.list_add_dict = bencode_list_add_dictionary,
.list_add = __bencode_list_add,
.list_add_dict = __bencode_list_add_dictionary,
.list_add_string = bencode_list_add_string,
.list_add_str_dup = bencode_list_add_str_dup,
.pretty_print = bencode_pretty_print,
@ -372,17 +387,17 @@ const ng_parser_t ng_parser_json = {
.dict_get_int_str = json_dict_get_int_str,
.dict_get_expect = json_dict_get_expect,
.dict_contains = json_dict_contains,
.dict_add = bencode_dictionary_add,
.dict_add = __bencode_dictionary_add,
.dict_add_string = bencode_dictionary_add_string,
.dict_add_str = bencode_dictionary_add_str,
.dict_add_str_dup = bencode_dictionary_add_str_dup,
.dict_add_int = bencode_dictionary_add_integer,
.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_list = bencode_dictionary_add_list,
.dict_add_list = __bencode_dictionary_add_list,
.list = __bencode_list,
.list_add = bencode_list_add,
.list_add_dict = bencode_list_add_dictionary,
.list_add = __bencode_list_add,
.list_add_dict = __bencode_list_add_dictionary,
.list_add_string = bencode_list_add_string,
.list_add_str_dup = bencode_list_add_str_dup,
.pretty_print = json_pretty_print,

2
daemon/recording.c
Unescape View File

@ -759,7 +759,7 @@ static void response_pcap(struct recording *recording, const ng_parser_t *parser
if (!recording->pcap.recording_path)
return;
bencode_item_t *recordings = parser->dict_add_list(output, "recordings");
parser_arg recordings = parser->dict_add_list(output, "recordings");
parser->list_add_string(recordings, recording->pcap.recording_path);
}

14
include/control_ng.h
Unescape View File

@ -134,19 +134,19 @@ struct ng_parser {
long long (*dict_get_int_str)(parser_arg, const char *, long long def);
parser_arg (*dict_get_expect)(parser_arg, const char *, bencode_type_t);
bool (*dict_contains)(parser_arg, const char *);
bencode_item_t *(*dict_add)(parser_arg, const char *, parser_arg);
parser_arg (*dict_add)(parser_arg, const char *, parser_arg);
void (*dict_add_string)(parser_arg, const char *, const char *);
void (*dict_add_str)(parser_arg, const char *, const str *);
void (*dict_add_str_dup)(parser_arg, const char *, const str *);
void (*dict_add_int)(parser_arg, const char *, long long);
bencode_item_t *(*dict_add_dict)(parser_arg, const char *);
bencode_item_t *(*dict_add_dict_dup)(parser_arg, const char *);
bencode_item_t *(*dict_add_list)(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_list)(parser_arg, const char *);
parser_arg (*list)(ng_parser_ctx_t *);
bencode_item_t *(*list_add)(parser_arg, parser_arg);
bencode_item_t *(*list_add_dict)(bencode_item_t *);
parser_arg (*list_add)(parser_arg, parser_arg);
parser_arg (*list_add_dict)(parser_arg);
void (*list_add_str_dup)(parser_arg, const str *);
void (*list_add_string)(bencode_item_t *, const char *);
void (*list_add_string)(parser_arg , const char *);
void (*pretty_print)(parser_arg, GString *);
};
struct ng_parser_ctx {

Write Preview
Loading…
Cancel
Save