MT#55283 redis: preserve legacy SSRC restore and test SRTP takeover

Share SSRC dump and restore helpers between ingress and egress, keeping
ssrc_out_table as the outbound list name. Scope each hash lock to its
dump rather than holding both locks throughout media serialization.

Restore records without an outbound list through the original combined
in/out path, including records written before the SSRC hash split.

Adapt the takeover regression test from kbinetruy's PR #2188 to exercise
native and JSON records, sequence rollover, encryption after restart,
and both legacy record layouts. Follow the existing Redis helper,
initializer, iteration, and daemon-test patterns.

Ref #2185

Change-Id: I0ac7e6b351fd3e2bcab38d0318d1787e5332c442
Co-authored-by: Kevin Binetruy <kevin.binetruy@ovhcloud.com>
(cherry picked from commit afb98f00d3)
pull/2228/head
baseballyama 1 month ago committed by Richard Fuchs
parent 52de132c69
commit 3ec821ced5

@ -2134,52 +2134,73 @@ static int json_link_maps(call_t *c, struct redis_list *maps,
return 0;
}
static const char *json_build_ssrc_iter(const ng_parser_t *parser, parser_arg dict, helper_arg arg) {
struct call_media *md = arg.md;
uint32_t ssrc = parser_get_ll(dict, "ssrc");
struct ssrc_entry_call *se_in = get_ssrc(ssrc, &md->ssrc_hash_in);
struct ssrc_table_keys {
const char *list;
const char *srtp_index;
const char *srtcp_index;
const char *payload_type;
};
static const struct ssrc_table_keys ssrc_table_keys_in = {
.list = "ssrc_table",
.srtp_index = "in_srtp_index",
.srtcp_index = "in_srtcp_index",
.payload_type = "in_payload_type",
};
static const struct ssrc_table_keys ssrc_table_keys_out = {
.list = "ssrc_out_table",
.srtp_index = "out_srtp_index",
.srtcp_index = "out_srtcp_index",
.payload_type = "out_payload_type",
};
if (se_in) {
atomic_set_na(&se_in->stats->ext_seq, parser_get_ll(dict, "in_srtp_index"));
atomic_set_na(&se_in->stats->rtcp_seq, parser_get_ll(dict, "in_srtcp_index"));
payload_tracker_add(&se_in->tracker, parser_get_ll(dict, "in_payload_type"));
obj_put(&se_in->h);
}
static void json_build_ssrc_entry(struct ssrc_hash *ht, parser_arg dict, uint32_t ssrc,
const struct ssrc_table_keys *k)
{
struct ssrc_entry_call *se = get_ssrc(ssrc, ht);
if (!se)
return;
atomic_set_na(&se->stats->ext_seq, parser_get_ll(dict, k->srtp_index));
atomic_set_na(&se->stats->rtcp_seq, parser_get_ll(dict, k->srtcp_index));
payload_tracker_add(&se->tracker, parser_get_ll(dict, k->payload_type));
obj_put(&se->h);
}
static const char *json_build_ssrc_in_iter(const ng_parser_t *parser, parser_arg dict, helper_arg arg) {
json_build_ssrc_entry(&arg.md->ssrc_hash_in, dict, parser_get_ll(dict, "ssrc"),
&ssrc_table_keys_in);
return NULL;
}
static const char *json_build_ssrc_out_iter(const ng_parser_t *parser, parser_arg dict, helper_arg arg) {
struct call_media *md = arg.md;
json_build_ssrc_entry(&arg.md->ssrc_hash_out, dict, parser_get_ll(dict, "ssrc"),
&ssrc_table_keys_out);
return NULL;
}
// records without an "ssrc_out_table" list: each entry is restored into both hashes
static const char *json_build_ssrc_legacy_iter(const ng_parser_t *parser, parser_arg dict, helper_arg arg) {
uint32_t ssrc = parser_get_ll(dict, "ssrc");
struct ssrc_entry_call *se_out = get_ssrc(ssrc, &md->ssrc_hash_out);
if (se_out) {
atomic_set_na(&se_out->stats->ext_seq, parser_get_ll(dict, "out_srtp_index"));
atomic_set_na(&se_out->stats->rtcp_seq, parser_get_ll(dict, "out_srtcp_index"));
payload_tracker_add(&se_out->tracker, parser_get_ll(dict, "out_payload_type"));
obj_put(&se_out->h);
}
json_build_ssrc_entry(&arg.md->ssrc_hash_in, dict, ssrc, &ssrc_table_keys_in);
json_build_ssrc_entry(&arg.md->ssrc_hash_out, dict, ssrc, &ssrc_table_keys_out);
return NULL;
}
static int json_build_ssrc(struct call_media *md, parser_arg arg) {
char tmp[2048];
snprintf(tmp, sizeof(tmp), "ssrc_table-%u", md->unique_id);
snprintf(tmp, sizeof(tmp), "%s-%u", ssrc_table_keys_out.list, md->unique_id);
parser_arg out_list = redis_parser->dict_get_expect(arg, tmp, BENCODE_LIST);
if (out_list.gen)
redis_parser->list_iter(redis_parser, out_list, NULL, json_build_ssrc_out_iter, md);
snprintf(tmp, sizeof(tmp), "%s-%u", ssrc_table_keys_in.list, md->unique_id);
parser_arg list = redis_parser->dict_get_expect(arg, tmp, BENCODE_LIST);
if (!list.gen) {
// non-fatal for backwards compatibility
return 0;
}
redis_parser->list_iter(redis_parser, list, NULL, json_build_ssrc_iter, md);
snprintf(tmp, sizeof(tmp), "ssrc_out_table-%u", md->unique_id);
list = redis_parser->dict_get_expect(arg, tmp, BENCODE_LIST);
if (list.gen)
redis_parser->list_iter(redis_parser, list, NULL, json_build_ssrc_out_iter, md);
redis_parser->list_iter(redis_parser, list, NULL,
out_list.gen ? json_build_ssrc_in_iter : json_build_ssrc_legacy_iter, md);
return 0;
}
@ -2788,42 +2809,38 @@ static void redis_encode_ml_basic(struct call_monologue *ml, const ng_parser_t *
}
static parser_arg redis_encode_media_basic(struct call_media *media, const ng_parser_t *parser, parser_arg root) {
static void redis_encode_ssrc_table(const ng_parser_t *parser, parser_arg root, unsigned int media_id,
struct ssrc_hash *ht, const struct ssrc_table_keys *k)
{
char tmp[128];
snprintf(tmp, sizeof(tmp), "payload_types-%u", media->unique_id);
parser_arg inner = parser->dict_add_list_dup(root, tmp);
redis_encode_codec_store(parser, inner, &media->codecs);
// SSRC table dump
// XXX needs fixing
LOCK(&media->ssrc_hash_in.lock);
snprintf(tmp, sizeof(tmp), "ssrc_table-%u", media->unique_id);
LOCK(&ht->lock);
snprintf(tmp, sizeof(tmp), "%s-%u", k->list, media_id);
parser_arg list = parser->dict_add_list_dup(root, tmp);
for (GList *m = media->ssrc_hash_in.nq.head; m; m = m->next) {
for (__auto_type m = ht->nq.head; m; m = m->next) {
struct ssrc_entry_call *se = m->data;
inner = parser->list_add_dict(list);
parser_arg inner = parser->list_add_dict(list);
JSON_SET_SIMPLE("ssrc", "%" PRIu32, se->h.ssrc);
// XXX use function for in/out
JSON_SET_SIMPLE("in_srtp_index", "%u", atomic_get_na(&se->stats->ext_seq));
JSON_SET_SIMPLE("in_srtcp_index", "%u", atomic_get_na(&se->stats->rtcp_seq));
JSON_SET_SIMPLE("in_payload_type", "%i", se->tracker.most[0]);
JSON_SET_SIMPLE(k->srtp_index, "%u", atomic_get_na(&se->stats->ext_seq));
JSON_SET_SIMPLE(k->srtcp_index, "%u", atomic_get_na(&se->stats->rtcp_seq));
JSON_SET_SIMPLE(k->payload_type, "%i", se->tracker.most[0]);
// XXX add rest of info
}
}
LOCK(&media->ssrc_hash_out.lock);
snprintf(tmp, sizeof(tmp), "ssrc_out_table-%u", media->unique_id);
list = parser->dict_add_list_dup(root, tmp);
for (GList *m = media->ssrc_hash_out.nq.head; m; m = m->next) {
struct ssrc_entry_call *se = m->data;
inner = parser->list_add_dict(list);
static parser_arg redis_encode_media_basic(struct call_media *media, const ng_parser_t *parser, parser_arg root) {
char tmp[128];
JSON_SET_SIMPLE("ssrc", "%" PRIu32, se->h.ssrc);
JSON_SET_SIMPLE("out_srtp_index", "%u", atomic_get_na(&se->stats->ext_seq));
JSON_SET_SIMPLE("out_srtcp_index", "%u", atomic_get_na(&se->stats->rtcp_seq));
JSON_SET_SIMPLE("out_payload_type", "%i", se->tracker.most[0]);
}
snprintf(tmp, sizeof(tmp), "payload_types-%u", media->unique_id);
parser_arg inner = parser->dict_add_list_dup(root, tmp);
redis_encode_codec_store(parser, inner, &media->codecs);
// SSRC table dump
redis_encode_ssrc_table(parser, root, media->unique_id, &media->ssrc_hash_in,
&ssrc_table_keys_in);
redis_encode_ssrc_table(parser, root, media->unique_id, &media->ssrc_hash_out,
&ssrc_table_keys_out);
snprintf(tmp, sizeof(tmp), "media-%u", media->unique_id);
inner = parser->dict_add_dict_dup(root, tmp);

@ -88,7 +88,7 @@ include ../lib/common.Makefile
daemon-tests-transform daemon-tests-http daemon-tests-heuristic daemon-tests-asymmetric \
daemon-tests-dtx-no-shift daemon-tests-rtcp daemon-tests-redis-subscribe daemon-tests-rtp-ext daemon-tests-ssrc \
daemon-tests-bundle daemon-tests-dtls daemon-tests-rollback \
daemon-tests-rollback-redis \
daemon-tests-rollback-redis daemon-tests-redis-srtp-index \
daemon-tests-recording daemon-tests-create daemon-tests-alias \
daemon-tests-kernel-api \
daemon-tests-video daemon-tests-inject
@ -141,6 +141,7 @@ daemon-tests: daemon-tests-main daemon-tests-jb daemon-tests-pubsub daemon-tests
daemon-tests-transcode-config daemon-tests-codec-prefs daemon-tests-http daemon-tests-heuristic \
daemon-tests-asymmetric daemon-tests-rtcp daemon-tests-redis-subscribe daemon-tests-rtp-ext daemon-tests-ssrc \
daemon-tests-bundle daemon-tests-dtls daemon-tests-rollback daemon-tests-rollback-redis \
daemon-tests-redis-srtp-index \
daemon-tests-recording daemon-tests-create \
daemon-tests-dtx daemon-tests-dtx-cn daemon-tests-dtx-no-shift \
daemon-tests-alias \
@ -162,6 +163,12 @@ daemon-tests-rollback-redis: daemon-test-deps
RTPE_REDIS_FORMAT=json ./auto-test-helper "$@-json" \
perl -I../perl auto-daemon-tests-rollback-redis.pl
daemon-tests-redis-srtp-index: daemon-test-deps
RTPE_REDIS_FORMAT=native ./auto-test-helper "$@-native" \
perl -I../perl auto-daemon-tests-redis-srtp-index.pl
RTPE_REDIS_FORMAT=json ./auto-test-helper "$@-json" \
perl -I../perl auto-daemon-tests-redis-srtp-index.pl
daemon-tests-jb: daemon-test-deps
./auto-test-helper "$@" perl -I../perl auto-daemon-tests-jb.pl

@ -0,0 +1,374 @@
#!/usr/bin/perl
# The SRTP and SRTCP indexes of egress SSRCs must survive a Redis takeover.
#
# rtpengine keeps one SSRC context per egress SSRC in the sink media's
# ssrc_hash_out. When it terminates SDES toward an endpoint, the SRTP index in
# that context (ROC << 16 | seq) is what it encrypts with. A node that takes
# the call over from Redis must carry on with the same ROC, or every packet it
# sends fails authentication at the endpoint once the ROC is non-zero.
use strict;
use warnings;
use Bencode;
use JSON;
use NGCP::Rtpengine::AutoTest;
use NGCP::Rtpclient::SRTP;
use File::Temp ();
use IO::Select;
use POSIX ();
use Socket qw(AF_INET SOCK_STREAM sockaddr_in inet_aton);
use Test::More;
use Time::HiRes;
my $redis_format = $ENV{RTPE_REDIS_FORMAT} // 'json';
# Fake Redis server, run in a forked child.
#
# The daemon writes to Redis from the poller thread as well as after a signalling
# request, so a test servicing it only between requests eventually leaves a write
# unanswered, which blocks the daemon in redis_consume(). A separate process
# always answers; the parent reads what was stored through the files below.
#
# $state/seq number of SETs the child has serviced
# $state/last value of the most recent SET
# $state/override if present, served in place of the next GET, then removed
my $redis_listener;
socket($redis_listener, AF_INET, SOCK_STREAM, 0) or die;
bind($redis_listener, sockaddr_in(6379, inet_aton('203.0.113.42'))) or die;
listen($redis_listener, 10) or die;
my $state = File::Temp::tempdir("redis-srtp-index-XXXXXX", TMPDIR => 1, CLEANUP => 1);
write_file("$state/seq", "0");
sub write_file {
my ($path, $content) = @_;
open(my $fh, '>', "$path.tmp") or die "$path: $!";
binmode($fh);
print $fh $content;
close($fh) or die;
rename("$path.tmp", $path) or die "$path: $!";
}
sub read_file {
my ($path) = @_;
open(my $fh, '<', $path) or return;
binmode($fh);
local $/ = undef;
my $content = <$fh>;
close($fh);
return $content;
}
sub server_read_exact {
my ($fd, $len) = @_;
my $buf = '';
while (length($buf) < $len) {
my $part;
defined(recv($fd, $part, $len - length($buf), 0)) or return;
length($part) or return;
$buf .= $part;
}
return $buf;
}
sub server_read_line {
my ($fd) = @_;
my $buf = '';
while ($buf !~ /\r\n\z/) {
my $byte = server_read_exact($fd, 1);
defined($byte) or return;
$buf .= $byte;
}
$buf =~ s/\r\n\z//;
return $buf;
}
sub server_read_command {
my ($fd) = @_;
my $intro = server_read_line($fd);
(defined($intro) && $intro =~ /^\*(\d+)\z/) or return;
my @args;
for (1 .. $1) {
my $bulk = server_read_line($fd);
(defined($bulk) && $bulk =~ /^\$(\d+)\z/) or return;
my $arg = server_read_exact($fd, $1);
defined($arg) or return;
server_read_exact($fd, 2);
push @args, $arg;
}
return \@args;
}
# Answer every command the daemon can send, so it is never left waiting.
sub redis_server {
my %store;
my $sets = 0;
my $select = IO::Select->new($redis_listener);
while (1) {
for my $fh ($select->can_read(1)) {
if ($fh == $redis_listener) {
my $client;
accept($client, $redis_listener) or next;
$select->add($client);
next;
}
my $command = server_read_command($fh);
if (!$command) {
$select->remove($fh);
close($fh);
next;
}
my $verb = uc($command->[0]);
if ($verb eq 'PING') {
send($fh, "+PONG\r\n", 0);
}
elsif ($verb eq 'INFO') {
my $info = "role:master\r\n";
send($fh, '$' . length($info) . "\r\n$info\r\n", 0);
}
elsif ($verb eq 'TYPE') {
send($fh, "+none\r\n", 0);
}
elsif ($verb eq 'KEYS') {
my @keys = keys %store;
my $reply = '*' . scalar(@keys) . "\r\n";
$reply .= '$' . length($_) . "\r\n$_\r\n" for @keys;
send($fh, $reply, 0);
}
elsif ($verb eq 'GET') {
my $value = read_file("$state/override");
if (defined $value) {
unlink("$state/override");
}
else {
$value = $store{$command->[1]};
}
if (defined $value) {
send($fh, '$' . length($value) . "\r\n$value\r\n", 0);
}
else {
send($fh, "\$-1\r\n", 0);
}
}
elsif ($verb eq 'SET') {
$store{$command->[1]} = $command->[2];
write_file("$state/last", $command->[2]);
write_file("$state/seq", ++$sets);
send($fh, "+OK\r\n", 0);
}
elsif ($verb eq 'DEL') {
delete $store{$command->[1]};
send($fh, ":1\r\n", 0);
}
else {
send($fh, "+OK\r\n", 0);
}
}
}
}
my $redis_pid = fork();
defined($redis_pid) or die "cannot fork Redis server";
if (!$redis_pid) {
$SIG{TERM} = sub { POSIX::_exit(0) }; ## no critic (Variables::RequireLocalizedPunctuationVars)
redis_server();
POSIX::_exit(0);
}
# The listener stays open here: under the preload's fake network, closing it in
# the parent removes the socket the child is accepting on.
END { kill('TERM', $redis_pid) if $redis_pid }
sub redis_sets_seen {
return int(read_file("$state/seq") // 0);
}
# The daemon writes to Redis before it answers, so the record is normally there
# already; poll briefly to cover the child not having flushed it yet.
sub redis_record_after {
my ($before) = @_;
for (1 .. 500) {
return read_file("$state/last") if redis_sets_seen() > $before;
Time::HiRes::sleep(0.01);
}
die 'no Redis update seen after the daemon answered';
}
sub serve_next_get {
my ($record) = @_;
write_file("$state/override", $record);
}
sub decode_record {
my ($record) = @_;
return $redis_format eq 'json' ? decode_json($record) : Bencode::bdecode($record, 1);
}
sub encode_record {
my ($record) = @_;
return encode_json($record) if $redis_format eq 'json';
my $as_strings;
$as_strings = sub {
my ($value) = @_;
return { map { $_ => $as_strings->($value->{$_}) } keys %$value }
if ref($value) eq 'HASH';
return [ map { $as_strings->($_) } @$value ] if ref($value) eq 'ARRAY';
my $copy = $value;
return \$copy;
};
return Bencode::bencode($as_strings->($record));
}
# All entries for one SSRC in the record's lists whose name matches $prefix.
sub ssrc_entries {
my ($decoded, $prefix, $ssrc) = @_;
my @ret;
for my $key (sort keys %$decoded) {
next unless $key =~ /^\Q$prefix\E-\d+$/;
for my $ent (@{$decoded->{$key}}) {
push(@ret, { list => $key, %$ent }) if $ent->{ssrc} == $ssrc;
}
}
return @ret;
}
sub egress_ssrcs {
my ($query, $tag) = @_;
return [ map { $_->{SSRC} } @{$query->{tags}{$tag}{medias}[0]{'egress SSRCs'} // []} ];
}
sub redis_rtpe_req {
my (@request) = @_;
my $before = redis_sets_seen();
my $response = rtpe_req(@request);
return ($response, redis_record_after($before));
}
my @daemon_args = (qw(--config-file=none -t -1 -i 203.0.113.1 -n 2234 -f -L 7 -E
--redis-num-threads=1),
"--redis=203.0.113.42:6379/14", "--redis-format=$redis_format");
$NGCP::Rtpengine::AutoTest::port = 2234;
autotest_start(@daemon_args) or die;
# SDES toward A, plain RTP toward B: rtpengine encrypts B's media toward A
# with its own key and its own SRTP index.
my ($sock_a, $sock_b) = new_call([qw(198.51.100.1 7300)], [qw(198.51.100.3 7302)]);
my ($call_id, $from_tag, $to_tag) = (cid(), ft(), tt());
my $ssrc = 0x5ec0de01;
my $sdp_a = "v=0\r\no=- 1 1 IN IP4 198.51.100.1\r\ns=tester\r\nc=IN IP4 198.51.100.1\r\nt=0 0\r\n"
. "m=audio 7300 RTP/SAVP 8\r\na=rtpmap:8 PCMA/8000\r\na=sendrecv\r\n"
. "a=crypto:1 AES_CM_128_HMAC_SHA1_80 inline:QjnnaukLn7iwASAs0YLzPUplJkjOhTZK2dvOwo6c\r\n";
my $sdp_b = "v=0\r\no=- 2 1 IN IP4 198.51.100.3\r\ns=tester\r\nc=IN IP4 198.51.100.3\r\nt=0 0\r\n"
. "m=audio 7302 RTP/AVP 8\r\na=rtpmap:8 PCMA/8000\r\na=sendrecv\r\n";
my %offer = ('call-id' => $call_id, 'from-tag' => $from_tag, 'transport-protocol' => 'RTP/AVP',
sdp => $sdp_a);
my %answer = ('call-id' => $call_id, 'from-tag' => $from_tag, 'to-tag' => $to_tag, sdp => $sdp_b);
my ($resp) = redis_rtpe_req('offer', 'SDES <> RTP offer', \%offer);
my ($port_a) = $resp->{sdp} =~ /^m=audio (\d+) RTP\/AVP /m or die;
($resp) = redis_rtpe_req('answer', 'SDES <> RTP answer', \%answer);
my ($port_b) = $resp->{sdp} =~ /^m=audio (\d+) RTP\/SAVP /m or die;
my ($key_to_a) = $resp->{sdp} =~ /^a=crypto:\d+ AES_CM_128_HMAC_SHA1_80 inline:(\S+)/m or die;
my $srtp_ctx_a = {
cs => $NGCP::Rtpclient::SRTP::crypto_suites{AES_CM_128_HMAC_SHA1_80},
key => $key_to_a,
};
# B's sequence numbers wrap: the egress context toward A goes to ROC 1.
my $ts = 1000;
for my $seq (65533, 65534, 65535, 0, 1, 2) {
snd($sock_b, $port_a, rtp(8, $seq, $ts, $ssrc, "\x00" x 160));
srtp_rcv($sock_a, $port_b, rtpm(8, $seq, $ts, $ssrc, "\x00" x 160), $srtp_ctx_a);
$ts += 160;
}
is($srtp_ctx_a->{roc}, 1, 'receiver at ROC 1 after the wrap');
# A re-INVITE writes the call to Redis with the media state as it is now.
my $record;
($resp, $record) = redis_rtpe_req('offer', 're-offer', { %offer, 'to-tag' => $to_tag });
is($resp->{result}, 'ok', 're-offer ok');
($resp, $record) = redis_rtpe_req('answer', 're-answer', \%answer);
is($resp->{result}, 'ok', 're-answer ok');
my $decoded = decode_record($record);
my @out = ssrc_entries($decoded, 'ssrc_out_table', $ssrc);
is(scalar(@out), 1, "$redis_format egress SSRC stored once");
my %out = %{$out[0] // {}};
is($out{out_srtp_index}, 0x10002, "$redis_format egress SRTP index stored, ROC 1");
is($out{out_payload_type}, 8, "$redis_format egress payload type stored");
ok(defined($out{out_srtcp_index}), "$redis_format egress SRTCP index stored");
my @in = ssrc_entries($decoded, 'ssrc_table', $ssrc);
is(scalar(@in), 1, "$redis_format ingress SSRC stored once");
my %in = %{$in[0] // {}};
ok(defined($in{in_srtp_index}), "$redis_format ingress SRTP index stored");
ok(defined($in{list}) && defined($out{list})
&& $in{list} ne ('ssrc_table-' . ($out{list} =~ /(\d+)$/)[0]),
"$redis_format ingress and egress entries belong to different medias");
# ssrc_table list of A's media: the one that does not hold B's ingress SSRC
my ($table_a) = grep { /^ssrc_table-\d+$/ && !grep { $_->{ssrc} == $ssrc } @{$decoded->{$_}} }
sort keys %$decoded;
ok(defined($table_a), "$redis_format ssrc_table of A's media present");
# Takeover: a fresh daemon restores the call from that record.
NGCP::Rtpengine::AutoTest::shut_rtpe();
autotest_start(@daemon_args) or die;
my $query = rtpe_req('query', 'query restored call', { 'call-id' => $call_id });
is_deeply(egress_ssrcs($query, $from_tag), [$ssrc], 'egress SSRC toward A restored');
is_deeply(egress_ssrcs($query, $to_tag), [], 'no egress SSRC created toward B');
# The restored node must encrypt toward A with ROC 1.
snd($sock_b, $port_a, rtp(8, 3, $ts, $ssrc, "\x00" x 160));
srtp_rcv($sock_a, $port_b, rtpm(8, 3, $ts, $ssrc, "\x00" x 160), $srtp_ctx_a);
is($srtp_ctx_a->{roc}, 1, 'receiver still at ROC 1');
# A record written by a node without ssrc_out_table lists restores as before:
# each ingress entry is looked up in both hashes of its media.
my %legacy = %$decoded;
delete @legacy{grep { /^ssrc_out_table-/ } keys %legacy};
NGCP::Rtpengine::AutoTest::shut_rtpe();
serve_next_get(encode_record(\%legacy));
autotest_start(@daemon_args) or die;
$query = rtpe_req('query', 'query call restored from legacy record', { 'call-id' => $call_id });
is_deeply([ map { $_->{SSRC} } @{$query->{tags}{$to_tag}{medias}[0]{'ingress SSRCs'} // []} ],
[$ssrc], 'legacy record: ingress SSRC from B restored');
# documents unchanged legacy behaviour: the ingress entry is mirrored into the egress hash
is_deeply(egress_ssrcs($query, $to_tag), [$ssrc],
'legacy record: ingress SSRC also looked up in egress hash (legacy behaviour kept)');
is_deeply(egress_ssrcs($query, $from_tag), [], 'legacy record: no egress SSRC toward A');
# A record in the format used before 19af8034: one combined entry per SSRC, in
# the ssrc_table of the media it belongs to, with both in_* and out_* fields.
# The egress index toward A is restored through the legacy path.
my %combined = %legacy;
$combined{$table_a} = [ { ssrc => $ssrc, in_srtp_index => 0, in_srtcp_index => 0,
in_payload_type => 8, out_srtp_index => 0x10002, out_srtcp_index => 0,
out_payload_type => 8 } ];
NGCP::Rtpengine::AutoTest::shut_rtpe();
serve_next_get(encode_record(\%combined));
autotest_start(@daemon_args) or die;
$query = rtpe_req('query', 'query call restored from combined record', { 'call-id' => $call_id });
is_deeply(egress_ssrcs($query, $from_tag), [$ssrc], 'combined record: egress SSRC toward A restored');
$ts += 160;
snd($sock_b, $port_a, rtp(8, 4, $ts, $ssrc, "\x00" x 160));
srtp_rcv($sock_a, $port_b, rtpm(8, 4, $ts, $ssrc, "\x00" x 160), $srtp_ctx_a);
is($srtp_ctx_a->{roc}, 1, 'combined record: receiver still at ROC 1');
NGCP::Rtpengine::AutoTest::shut_rtpe();
done_testing;
Loading…
Cancel
Save