MT#55283 move srtp_index into shm

Use the already existing ext_seq (in shm) in place of srtp_index as
these carry duplicate information.

Kernel still tracks its own index in the crypto context at this point.

Change data type from 64-bit to (unsigned) int as we don't need that
many bits.

Change-Id: I2468c6a814964eb64a19d84c918d3a37c2494b66

daemon/call.c

@@ -1011,7 +1011,7 @@ void call_stream_crypto_reset(struct packet_stream *ps) {
 		for (unsigned int u = 0; u < G_N_ELEMENTS(ps->ssrc_in); u++) {
 			if (!ps->ssrc_in[u]) // end of list
 				break;
-			ps->ssrc_in[u]->srtp_index = 0;
+			atomic_set_na(&ps->ssrc_in[u]->stats->ext_seq, 0);
 		}
 		mutex_unlock(&ps->in_lock);
 
@@ -1019,7 +1019,7 @@ void call_stream_crypto_reset(struct packet_stream *ps) {
 		for (unsigned int u = 0; u < G_N_ELEMENTS(ps->ssrc_out); u++) {
 			if (!ps->ssrc_out[u]) // end of list
 				break;
-			ps->ssrc_out[u]->srtp_index = 0;
+			atomic_set_na(&ps->ssrc_out[u]->stats->ext_seq, 0);
 		}
 		mutex_unlock(&ps->out_lock);
 	}

daemon/media_socket.c

@@ -1352,7 +1352,7 @@ static int __k_srtp_crypt(struct rtpengine_srtp *s, struct crypto_context *c,
 		.rtcp_auth_tag_len= c->params.crypto_suite->srtcp_auth_tag,
 	};
 	for (unsigned int i = 0; i < RTPE_NUM_SSRC_TRACKING; i++) {
-		s->last_rtp_index[i] = ssrc_ctx[i] ? ssrc_ctx[i]->srtp_index : 0;
+		s->last_rtp_index[i] = ssrc_ctx[i] ? atomic_get_na(&ssrc_ctx[i]->stats->ext_seq) : 0;
 		s->last_rtcp_index[i] = ssrc_ctx[i] ? ssrc_ctx[i]->srtcp_index : 0;
 	}
 	if (c->params.mki_len)
@@ -3500,13 +3500,13 @@ enum thread_looper_action kernel_stats_updater(void) {
 						payload_tracker_add(&ctx->tracker,
 								atomic_get_na(&ps->stats_in->last_pt));
 					if (sink->crypto.params.crypto_suite
-							&& o->encrypt.last_rtp_index[u] - ctx->srtp_index > 0x4000)
+							&& o->encrypt.last_rtp_index[u] - atomic_get_na(&ctx->stats->ext_seq) > 0x4000)
 					{
-						ilog(LOG_DEBUG, "Updating SRTP encryption index from %" PRIu64
+						ilog(LOG_DEBUG, "Updating SRTP encryption index from %u"
 								" to %" PRIu64,
-								ctx->srtp_index,
+								atomic_get_na(&ctx->stats->ext_seq),
 								o->encrypt.last_rtp_index[u]);
-						ctx->srtp_index = o->encrypt.last_rtp_index[u];
+						atomic_set_na(&ctx->stats->ext_seq, o->encrypt.last_rtp_index[u]);
 						update = true;
 					}
 					if (ctx->srtcp_index != o->encrypt.last_rtcp_index[u]) {
@@ -3535,12 +3535,12 @@ enum thread_looper_action kernel_stats_updater(void) {
 
 				if (sfd->crypto.params.crypto_suite
 						&& ke->target.decrypt.last_rtp_index[u]
-						- ctx->srtp_index > 0x4000) {
-					ilog(LOG_DEBUG, "Updating SRTP decryption index from %" PRIu64
+						- atomic_get_na(&ctx->stats->ext_seq) > 0x4000) {
+					ilog(LOG_DEBUG, "Updating SRTP decryption index from %u"
 							" to %" PRIu64,
-							ctx->srtp_index,
+							atomic_get_na(&ctx->stats->ext_seq),
 							ke->target.decrypt.last_rtp_index[u]);
-					ctx->srtp_index = ke->target.decrypt.last_rtp_index[u];
+					atomic_set_na(&ctx->stats->ext_seq, ke->target.decrypt.last_rtp_index[u]);
 					update = true;
 				}
 			}

daemon/redis.c

@@ -1927,10 +1927,10 @@ static int json_build_ssrc(struct call_monologue *ml, JsonReader *root_reader) {
 		struct ssrc_entry_call *se = get_ssrc(ssrc, ml->ssrc_hash);
 		if (!se)
 			goto next;
-		se->input_ctx.srtp_index = json_reader_get_ll(root_reader, "in_srtp_index");
+		atomic_set_na(&se->input_ctx.stats->ext_seq, json_reader_get_ll(root_reader, "in_srtp_index"));
 		se->input_ctx.srtcp_index = json_reader_get_ll(root_reader, "in_srtcp_index");
 		payload_tracker_add(&se->input_ctx.tracker, json_reader_get_ll(root_reader, "in_payload_type"));
-		se->output_ctx.srtp_index = json_reader_get_ll(root_reader, "out_srtp_index");
+		atomic_set_na(&se->output_ctx.stats->ext_seq, json_reader_get_ll(root_reader, "out_srtp_index"));
 		se->output_ctx.srtcp_index = json_reader_get_ll(root_reader, "out_srtcp_index");
 		payload_tracker_add(&se->output_ctx.tracker, json_reader_get_ll(root_reader, "out_payload_type"));
 
@@ -2552,10 +2552,10 @@ char* redis_encode_json(call_t *c) {
 
 				JSON_SET_SIMPLE("ssrc", "%" PRIu32, se->h.ssrc);
 				// XXX use function for in/out
-				JSON_SET_SIMPLE("in_srtp_index", "%" PRIu64, se->input_ctx.srtp_index);
+				JSON_SET_SIMPLE("in_srtp_index", "%u", atomic_get_na(&se->input_ctx.stats->ext_seq));
 				JSON_SET_SIMPLE("in_srtcp_index", "%" PRIu64, se->input_ctx.srtcp_index);
 				JSON_SET_SIMPLE("in_payload_type", "%i", se->input_ctx.tracker.most[0]);
-				JSON_SET_SIMPLE("out_srtp_index", "%" PRIu64, se->output_ctx.srtp_index);
+				JSON_SET_SIMPLE("out_srtp_index", "%u", atomic_get_na(&se->output_ctx.stats->ext_seq));
 				JSON_SET_SIMPLE("out_srtcp_index", "%" PRIu64, se->output_ctx.srtcp_index);
 				JSON_SET_SIMPLE("out_payload_type", "%i", se->output_ctx.tracker.most[0]);
 				// XXX add rest of info

daemon/rtp.c

@@ -52,16 +52,17 @@ static uint64_t packet_index(struct ssrc_ctx *ssrc_ctx, struct rtp_header *rtp)
 	crypto_debug_printf("SSRC %" PRIx32 ", seq %" PRIu16, ssrc_ctx->parent->h.ssrc, seq);
 
 	/* rfc 3711 section 3.3.1 */
-	if (G_UNLIKELY(!ssrc_ctx->srtp_index))
-		ssrc_ctx->srtp_index = seq;
+	unsigned int srtp_index = atomic_get_na(&ssrc_ctx->stats->ext_seq);
+	if (G_UNLIKELY(!srtp_index))
+		atomic_set_na(&ssrc_ctx->stats->ext_seq, srtp_index = seq);
 
 	/* rfc 3711 appendix A, modified, and sections 3.3 and 3.3.1 */
-	uint16_t s_l = (ssrc_ctx->srtp_index & 0x00000000ffffULL);
-	uint32_t roc = (ssrc_ctx->srtp_index & 0xffffffff0000ULL) >> 16;
+	uint16_t s_l = (srtp_index & 0x00000000ffffULL);
+	uint32_t roc = (srtp_index & 0xffffffff0000ULL) >> 16;
 	uint32_t v = 0;
 
-	crypto_debug_printf(", prev seq %" PRIu64 ", s_l %" PRIu16 ", ROC %" PRIu32,
-			ssrc_ctx->srtp_index, s_l, roc);
+	crypto_debug_printf(", prev seq %u, s_l %" PRIu16 ", ROC %" PRIu32,
+			srtp_index, s_l, roc);
 
 	if (s_l < 0x8000) {
 		if (((seq - s_l) > 0x8000) && roc > 0)
@@ -75,11 +76,12 @@ static uint64_t packet_index(struct ssrc_ctx *ssrc_ctx, struct rtp_header *rtp)
 			v = roc;
 	}
 
-	ssrc_ctx->srtp_index = (uint64_t)(((v << 16) | seq) & 0xffffffffffffULL);
+	srtp_index = (uint64_t)(((v << 16) | seq) & 0xffffffffffffULL);
+	atomic_set_na(&ssrc_ctx->stats->ext_seq, srtp_index);
 
-	crypto_debug_printf(", v %" PRIu32 ", ext seq %" PRIu64, v, ssrc_ctx->srtp_index);
+	crypto_debug_printf(", v %" PRIu32 ", ext seq %u", v, srtp_index);
 
-	return ssrc_ctx->srtp_index;
+	return srtp_index;
 }
 
 void rtp_append_mki(str *s, struct crypto_context *c) {
@@ -143,7 +145,7 @@ int rtp_avp2savp(str *s, struct crypto_context *c, struct ssrc_ctx *ssrc_ctx) {
 /* rfc 3711, section 3.3 */
 int rtp_savp2avp(str *s, struct crypto_context *c, struct ssrc_ctx *ssrc_ctx) {
 	struct rtp_header *rtp;
-	uint64_t index;
+	unsigned int index;
 	str payload, to_auth, to_decrypt, auth_tag;
 	char hmac[20];
 
@@ -211,9 +213,9 @@ int rtp_savp2avp(str *s, struct crypto_context *c, struct ssrc_ctx *ssrc_ctx) {
 	goto error;
 
 decrypt_idx:
-	ilog(LOG_DEBUG, "Detected unexpected SRTP ROC reset (from %" PRIu64 " to %" PRIu64 ")",
-			ssrc_ctx->srtp_index, index);
-	ssrc_ctx->srtp_index = index;
+	ilog(LOG_DEBUG, "Detected unexpected SRTP ROC reset (from %u to %u)",
+			atomic_get_na(&ssrc_ctx->stats->ext_seq), index);
+	atomic_set_na(&ssrc_ctx->stats->ext_seq, index);
 decrypt:;
 	int prev_len = to_decrypt.len;
 	if (c->params.session_params.unencrypted_srtp)
@@ -247,9 +249,9 @@ decrypt:;
 			return -1;
 		}
 		if (guess != 0) {
-			ilog(LOG_DEBUG, "Detected unexpected SRTP ROC reset (from %" PRIu64 " to %" PRIu64 ")",
-					ssrc_ctx->srtp_index, index);
-			ssrc_ctx->srtp_index = index;
+			ilog(LOG_DEBUG, "Detected unexpected SRTP ROC reset (from %u to %u)",
+					atomic_get_na(&ssrc_ctx->stats->ext_seq), index);
+			atomic_set_na(&ssrc_ctx->stats->ext_seq, index);
 		}
 	}
 

include/ssrc.h

@@ -41,9 +41,7 @@ struct ssrc_ctx {
 	struct payload_tracker tracker;
 	void *ref; // points to the call_monologue but is opaque
 
-	// XXX lock this?
-	uint64_t srtp_index,
-		  srtcp_index;
+	uint64_t srtcp_index;
 	// XXX move entire crypto context in here?
 
 	// for transcoding