@routr/rtprelay 2.20.0 → 2.22.0

package/dist/client.js

@@ -28,14 +28,14 @@ function query(config) {
 function offer(config, invertTags = false) {
     return (request) => __awaiter(this, void 0, void 0, function* () {
         const direction = (0, utils_1.getDirectionFromRequest)(request);
-        const sdpModifiers = (0, utils_1.getRTPEParamsByDirection)(direction);
+        const sdpModifiers = (0, utils_1.getRTPEParams)(request, direction);
         return yield rtpe.offer(config, Object.assign(Object.assign({}, sdpModifiers), { sdp: request.message.body, "call-id": request.message.callId.callId, "from-tag": invertTags ? request.message.to.tag : request.message.from.tag }));
     });
 }
 function answer(config, invertTags = false) {
     return (request) => __awaiter(this, void 0, void 0, function* () {
         const direction = (0, utils_1.getDirectionFromResponse)(request);
-        const sdpModifiers = (0, utils_1.getRTPEParamsByDirection)(direction);
+        const sdpModifiers = (0, utils_1.getRTPEParams)(request, direction);
         return yield rtpe.answer(config, Object.assign(Object.assign({}, sdpModifiers), { sdp: request.message.body, "call-id": request.message.callId.callId, "from-tag": invertTags
                 ? request.message.to.tag
                 : request.message.from.tag, "to-tag": invertTags ? request.message.from.tag : request.message.to.tag }));

package/dist/utils.d.ts

@@ -3,7 +3,34 @@ import { Direction } from "./types";
 export declare function getDirectionFromResponse(request: MessageRequest): Direction;
 export declare function getDirectionFromRequest(request: MessageRequest): Direction;
 export declare function getDirection(srcTransport: CT.Transport, dstTransport: CT.Transport): Direction;
-export declare function getRTPEParamsByDirection(dir: Direction): {
+export declare const isSecurePhone: (transport: CT.Transport) => boolean;
+export declare const getDestinationTransport: (request: MessageRequest) => CT.Transport;
+export declare function getRTPEParamsByDirection(dir: Direction, secureCallee?: boolean): {
+    ICE: string;
+    SDES: string[];
+    flags: string[];
+    "transport-protocol"?: undefined;
+    DTLS?: undefined;
+    "rtcp-mux"?: undefined;
+    replace?: undefined;
+} | {
+    "transport-protocol": string;
+    DTLS: string;
+    ICE: string;
+    "rtcp-mux": string[];
+    replace: string[];
+    flags: string[];
+    SDES?: undefined;
+} | {
+    "transport-protocol": string;
+    "rtcp-mux": string;
+    ICE: string;
+    flags: string[];
+    SDES?: undefined;
+    DTLS?: undefined;
+    replace?: undefined;
+};
+export declare const getRTPEParams: (request: MessageRequest, direction: Direction) => {
     ICE: string;
     SDES: string[];
     flags: string[];

package/dist/utils.js

@@ -1,10 +1,30 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.shouldNotHandleRequest = exports.callInvolvesWebRTC = void 0;
+exports.shouldNotHandleRequest = exports.callInvolvesWebRTC = exports.getRTPEParams = exports.getDestinationTransport = exports.isSecurePhone = void 0;
 exports.getDirectionFromResponse = getDirectionFromResponse;
 exports.getDirectionFromRequest = getDirectionFromRequest;
 exports.getDirection = getDirection;
 exports.getRTPEParamsByDirection = getRTPEParamsByDirection;
+/*
+ * Copyright (C) 2026 by Fonoster Inc (https://fonoster.com)
+ * http://github.com/fonoster/routr
+ *
+ * This file is part of Routr.
+ *
+ * Licensed under the MIT License (the "License");
+ * you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *    https://opensource.org/licenses/MIT
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/* eslint-disable require-jsdoc */
+const common_1 = require("@routr/common");
 const processor_1 = require("@routr/processor");
 const types_1 = require("./types");
 function getDirectionFromResponse(request) {
@@ -31,7 +51,19 @@ function getDirection(srcTransport, dstTransport) {
     }
     return types_1.Direction.PHONE_TO_PHONE;
 }
-function getRTPEParamsByDirection(dir) {
+// A phone leg reached over TLS, which is how a carrier that requires secure
+// trunking is configured. SRTP follows the transport: such a leg gets SDES-SRTP.
+const isSecurePhone = (transport) => (transport === null || transport === void 0 ? void 0 : transport.toUpperCase()) === common_1.CommonTypes.Transport.TLS;
+exports.isSecurePhone = isSecurePhone;
+// The leg a message is being sent to. For a request the EdgePort has already
+// put its own Via on top, facing the next hop; for a response the top Via is
+// the party the response goes back to.
+const getDestinationTransport = (request) => { var _a; return (_a = request.message.via[0]) === null || _a === void 0 ? void 0 : _a.transport; };
+exports.getDestinationTransport = getDestinationTransport;
+// The RTPEngine parameters for the leg the message is sent to. With
+// secureCallee the phone leg negotiates SDES-SRTP (RTP/SAVP) instead of plain
+// RTP; RTPEngine then encrypts toward the carrier and bridges to the other leg.
+function getRTPEParamsByDirection(dir, secureCallee = false) {
     switch (dir) {
         case types_1.Direction.WEB_TO_WEB:
             return {
@@ -41,12 +73,12 @@ function getRTPEParamsByDirection(dir) {
             };
         case types_1.Direction.WEB_TO_PHONE:
             return {
-                "transport-protocol": "RTP/AVP",
+                "transport-protocol": secureCallee ? "RTP/SAVP" : "RTP/AVP",
                 DTLS: "off",
                 ICE: "remove",
                 "rtcp-mux": ["demux"],
                 replace: ["origin", "session-connection"],
-                flags: ["trust-address", "SDES-no"]
+                flags: secureCallee ? ["trust-address"] : ["trust-address", "SDES-no"]
             };
         case types_1.Direction.PHONE_TO_WEB:
             return {
@@ -59,13 +91,17 @@ function getRTPEParamsByDirection(dir) {
             };
         case types_1.Direction.PHONE_TO_PHONE:
             return {
-                "transport-protocol": "RTP/AVP",
+                "transport-protocol": secureCallee ? "RTP/SAVP" : "RTP/AVP",
                 "rtcp-mux": "demux",
                 ICE: "remove",
                 flags: ["trust-address", "replace-origin", "replace-session-connection"]
             };
     }
 }
+// The RTPEngine parameters for a message, from its direction and the transport
+// of the leg it is sent to.
+const getRTPEParams = (request, direction) => getRTPEParamsByDirection(direction, (0, exports.isSecurePhone)((0, exports.getDestinationTransport)(request)));
+exports.getRTPEParams = getRTPEParams;
 const callInvolvesWebRTC = (direction) => direction == types_1.Direction.WEB_TO_PHONE || direction == types_1.Direction.PHONE_TO_WEB;
 exports.callInvolvesWebRTC = callInvolvesWebRTC;
 const shouldNotHandleRequest = (req) => !(processor_1.Helper.isInviteOrAckWithSDP(req) ||

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@routr/rtprelay",
-  "version": "2.20.0",
+  "version": "2.22.0",
   "description": "Media Relay for Routr using RTPengine",
   "author": "Pedro Sanders <psanders@fonoster.com>",
   "homepage": "https://github.com/fonoster/routr#readme",
@@ -21,8 +21,8 @@
   "dependencies": {
     "@fonoster/logger": "0.6.0",
     "@grpc/grpc-js": "~1.14.6",
-    "@routr/common": "^2.20.0",
-    "@routr/processor": "^2.20.0",
+    "@routr/common": "^2.22.0",
+    "@routr/processor": "^2.22.0",
     "rtpengine-client": "^0.4.11"
   },
   "files": [
@@ -38,5 +38,5 @@
   "bugs": {
     "url": "https://github.com/fonoster/routr/issues"
   },
-  "gitHead": "3705573eb10fd828b0b736702eee5a5d036d7cdc"
+  "gitHead": "43868fbe7fb81a31b7eadd88d6847778d10f1754"
 }