From 3ec821ced5e10a25bb0e8b7245fc257dac5016f4 Mon Sep 17 00:00:00 2001 From: baseballyama Date: Fri, 2 Oct 2026 17:18:07 +0900 Subject: [PATCH] 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 (cherry picked from commit afb98f00d32286b6af06b97a2490fbb3070ecbbc) --- daemon/redis.c | 125 ++++---- t/Makefile | 9 +- t/auto-daemon-tests-redis-srtp-index.pl | 374 ++++++++++++++++++++++++ 3 files changed, 453 insertions(+), 55 deletions(-) create mode 100755 t/auto-daemon-tests-redis-srtp-index.pl diff --git a/daemon/redis.c b/daemon/redis.c index 5624e4918..e8e9d7a69 100644 --- a/daemon/redis.c +++ b/daemon/redis.c @@ -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); diff --git a/t/Makefile b/t/Makefile index 4a658e830..1b97b19e0 100644 --- a/t/Makefile +++ b/t/Makefile @@ -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 diff --git a/t/auto-daemon-tests-redis-srtp-index.pl b/t/auto-daemon-tests-redis-srtp-index.pl new file mode 100755 index 000000000..d76621834 --- /dev/null +++ b/t/auto-daemon-tests-redis-srtp-index.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;