@routr/rtprelay 2.0.8-alpha.28

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 Fonoster Inc
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/client.d.ts

@@ -0,0 +1,5 @@
+import { MessageRequest } from "@routr/common";
+import { RTPEConfig, RTPEFunctionResult } from "./types";
+export declare function offer(config: RTPEConfig): (request: MessageRequest) => Promise<RTPEFunctionResult>;
+export declare function answer(config: RTPEConfig): (request: MessageRequest) => Promise<RTPEFunctionResult>;
+export declare function del(config: RTPEConfig): (request: MessageRequest) => Promise<RTPEFunctionResult>;

package/dist/client.js

@@ -0,0 +1,42 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.del = exports.answer = exports.offer = void 0;
+const envs_1 = require("./envs");
+const utils_1 = require("./utils");
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const Client = require("rtpengine-client").Client;
+const rtpe = new Client({ timeout: envs_1.RTPENGINE_TIMEOUT });
+function offer(config) {
+    return (request) => __awaiter(this, void 0, void 0, function* () {
+        const direction = (0, utils_1.getDirectionFromRequest)(request);
+        const sdpModifiers = (0, utils_1.getRTPEParamsByDirection)(direction);
+        return yield rtpe.offer(config, Object.assign(Object.assign({}, sdpModifiers), { sdp: request.message.body, "call-id": request.message.callId.callId, "from-tag": request.message.from.tag, "to-tag": request.message.to.tag }));
+    });
+}
+exports.offer = offer;
+function answer(config) {
+    return (request) => __awaiter(this, void 0, void 0, function* () {
+        const direction = (0, utils_1.getDirectionFromResponse)(request);
+        const sdpModifiers = (0, utils_1.getRTPEParamsByDirection)(direction);
+        return yield rtpe.answer(config, Object.assign(Object.assign({}, sdpModifiers), { sdp: request.message.body, "call-id": request.message.callId.callId, "from-tag": request.message.from.tag, "to-tag": request.message.to.tag }));
+    });
+}
+exports.answer = answer;
+function del(config) {
+    return (request) => __awaiter(this, void 0, void 0, function* () {
+        return yield rtpe.delete(config, {
+            "call-id": request.message.callId.callId,
+            "from-tag": request.message.from.tag
+        });
+    });
+}
+exports.del = del;

package/dist/envs.d.ts

@@ -0,0 +1,3 @@
+export declare const RTPENGINE_HOST: string;
+export declare const RTPENGINE_PORT: number;
+export declare const RTPENGINE_TIMEOUT: number;

package/dist/envs.js

@@ -0,0 +1,27 @@
+"use strict";
+var _a, _b;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RTPENGINE_TIMEOUT = exports.RTPENGINE_PORT = exports.RTPENGINE_HOST = void 0;
+/*
+ * Copyright (C) 2023 by Fonoster Inc (https://fonoster.com)
+ * http://github.com/fonoster
+ *
+ * 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.
+ */
+const common_1 = require("@routr/common");
+common_1.Assertions.assertEnvsAreSet(["RTPENGINE_HOST"]);
+exports.RTPENGINE_HOST = process.env.RTPENGINE_HOST;
+exports.RTPENGINE_PORT = parseInt((_a = process.env.RTPENGINE_PORT) !== null && _a !== void 0 ? _a : "22222");
+exports.RTPENGINE_TIMEOUT = parseInt((_b = process.env.RTPENGINE_TIMEOUT) !== null && _b !== void 0 ? _b : "5000");

package/dist/runner.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/runner.js

@@ -0,0 +1,112 @@
+#!/usr/bin/env node
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+/*
+ * Copyright (C) 2022 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-next-line @typescript-eslint/no-var-requires
+require("./tracer").init("dispatcher");
+const processor_1 = __importStar(require("@routr/processor"));
+const client_1 = require("./client");
+const common_1 = require("@routr/common");
+const types_1 = require("./types");
+const logger_1 = require("@fonoster/logger");
+const envs_1 = require("./envs");
+const utils_1 = require("./utils");
+const logger = (0, logger_1.getLogger)({ service: "rtprelay", filePath: __filename });
+const rtpeConfig = { host: envs_1.RTPENGINE_HOST, port: envs_1.RTPENGINE_PORT };
+new processor_1.default({
+    bindAddr: (_a = process.env.BIND_ADDR) !== null && _a !== void 0 ? _a : "0.0.0.0:51903",
+    name: "rtprelay-middleware"
+}).listen((req, res) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        if ((0, utils_1.shouldNotHandleRequest)(req)) {
+            return res.send(req);
+        }
+        const direction = processor_1.Helper.isTypeResponse(req)
+            ? (0, utils_1.getDirectionFromResponse)(req)
+            : (0, utils_1.getDirectionFromRequest)(req);
+        const sendRequest = (f) => __awaiter(void 0, void 0, void 0, function* () {
+            var _b;
+            const r = yield f(rtpeConfig)(req);
+            if (r.result === "error") {
+                throw new common_1.CommonErrors.BadRequestError(r["error-reason"]);
+            }
+            if ((0, utils_1.callInvolvesWebRTC)(direction)) {
+                req.message.body = (_b = r.sdp) === null || _b === void 0 ? void 0 : _b.replaceAll("a=crypto:", "a=ignore:").replaceAll("a=sendrecv", "a=sendrecv\na=rtcp-mux");
+            }
+            else {
+                req.message.body = r.sdp;
+            }
+            return res.send(req);
+        });
+        if (processor_1.Helper.isInviteOrAckWithSDP(req)) {
+            return yield sendRequest(client_1.offer);
+        }
+        else if (processor_1.Helper.isRinging(req) && direction === types_1.Direction.WEB_TO_PHONE) {
+            // Fixme: This was added to prevent the ringing message from being sent to the
+            // caller while the call is being established. This is a temporary fix
+            req.message.body = "";
+            return res.send(req);
+        }
+        else if (processor_1.Helper.isOkOrRingingWithSDP(req)) {
+            return yield sendRequest(client_1.answer);
+        }
+        else if (processor_1.Helper.isBye(req)) {
+            return yield sendRequest(client_1.del);
+        }
+        res.send(req);
+    }
+    catch (e) {
+        logger.error(e);
+        res.sendInternalServerError();
+    }
+}));

package/dist/tracer.d.ts

@@ -0,0 +1,7 @@
+/**
+ * This function registers the instrumentations for the service.
+ *
+ * @param {string} serviceName - The name of the service.
+ * @return {Tracer} The tracer object.
+ */
+export declare function init(serviceName: string): import("@opentelemetry/api").Tracer;

package/dist/tracer.js

@@ -0,0 +1,53 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.init = void 0;
+/*
+ * Copyright (C) 2022 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.
+ */
+const api_1 = __importDefault(require("@opentelemetry/api"));
+const instrumentation_1 = require("@opentelemetry/instrumentation");
+const sdk_trace_node_1 = require("@opentelemetry/sdk-trace-node");
+const resources_1 = require("@opentelemetry/resources");
+const semantic_conventions_1 = require("@opentelemetry/semantic-conventions");
+const sdk_trace_base_1 = require("@opentelemetry/sdk-trace-base");
+const exporter_jaeger_1 = require("@opentelemetry/exporter-jaeger");
+const instrumentation_grpc_1 = require("@opentelemetry/instrumentation-grpc");
+/**
+ * This function registers the instrumentations for the service.
+ *
+ * @param {string} serviceName - The name of the service.
+ * @return {Tracer} The tracer object.
+ */
+function init(serviceName) {
+    const provider = new sdk_trace_node_1.NodeTracerProvider({
+        resource: new resources_1.Resource({
+            [semantic_conventions_1.SemanticResourceAttributes.SERVICE_NAME]: serviceName
+        })
+    });
+    const exporter = new exporter_jaeger_1.JaegerExporter();
+    provider.addSpanProcessor(new sdk_trace_base_1.SimpleSpanProcessor(exporter));
+    provider.register();
+    (0, instrumentation_1.registerInstrumentations)({
+        instrumentations: [new instrumentation_grpc_1.GrpcInstrumentation()]
+    });
+    return api_1.default.trace.getTracer("routr-tracer");
+}
+exports.init = init;

package/dist/types.d.ts

@@ -0,0 +1,33 @@
+import { MessageRequest } from "@routr/common";
+export declare enum Direction {
+    WEB_TO_WEB = "web-to-web",
+    WEB_TO_PHONE = "web-to-phone",
+    PHONE_TO_WEB = "phone-to-web",
+    PHONE_TO_PHONE = "phone-to-phone"
+}
+export interface RTPERequest {
+    "call-id": string;
+    "from-tag": string;
+    "to-tag"?: string;
+    "DTLS-fingerprint"?: string;
+    "DTLS-passive"?: boolean;
+    "transport-protocol"?: string;
+    sdp?: string;
+    ICE?: string;
+    SDES?: string;
+}
+export interface RTPEConfig {
+    host: string;
+    port: number;
+}
+export type RTPEClient = {
+    send: (request: RTPERequest) => Promise<string>;
+};
+export type RTPEFunctionResult = {
+    result: "ok";
+    sdp: string;
+} | {
+    result: "error";
+    "error-reason": string;
+};
+export type RTPEFunction = (config: RTPEConfig) => (req: MessageRequest) => Promise<RTPEFunctionResult>;

package/dist/types.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Direction = void 0;
+/*
+ * Copyright (C) 2023 by Fonoster Inc (https://fonoster.com)
+ * http://github.com/fonoster
+ *
+ * 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.
+ */
+var Direction;
+(function (Direction) {
+    Direction["WEB_TO_WEB"] = "web-to-web";
+    Direction["WEB_TO_PHONE"] = "web-to-phone";
+    Direction["PHONE_TO_WEB"] = "phone-to-web";
+    Direction["PHONE_TO_PHONE"] = "phone-to-phone";
+})(Direction = exports.Direction || (exports.Direction = {}));

package/dist/utils.d.ts

@@ -0,0 +1,26 @@
+import { CommonTypes as CT, MessageRequest } from "@routr/common";
+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): {
+    ICE: string;
+    SDES: string;
+    flags: string;
+    "transport-protocol"?: undefined;
+    "rtcp-mux"?: undefined;
+} | {
+    "transport-protocol": string;
+    "rtcp-mux": string;
+    ICE: string;
+    flags: string;
+    SDES?: undefined;
+} | {
+    "transport-protocol": string;
+    "rtcp-mux": string;
+    ICE: string;
+    SDES: string;
+    flags: string;
+};
+export declare const callInvolvesWebRTC: (direction: Direction) => boolean;
+export declare const shouldNotHandleRequest: (req: MessageRequest) => boolean;

package/dist/utils.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.shouldNotHandleRequest = exports.callInvolvesWebRTC = exports.getRTPEParamsByDirection = exports.getDirection = exports.getDirectionFromRequest = exports.getDirectionFromResponse = void 0;
+const processor_1 = require("@routr/processor");
+const types_1 = require("./types");
+function getDirectionFromResponse(request) {
+    const srcTransport = request.sender.transport;
+    const dstTransport = request.message.via[0].transport;
+    return getDirection(srcTransport, dstTransport);
+}
+exports.getDirectionFromResponse = getDirectionFromResponse;
+// Will be able to determine the direction with Request-URI and Route header
+function getDirectionFromRequest(request) {
+    const srcTransport = request.sender.transport;
+    const dstTransport = request.message.via[0].transport;
+    return getDirection(srcTransport, dstTransport);
+}
+exports.getDirectionFromRequest = getDirectionFromRequest;
+function getDirection(srcTransport, dstTransport) {
+    if (processor_1.Helper.isWebRTC(srcTransport) && processor_1.Helper.isWebRTC(dstTransport)) {
+        return types_1.Direction.WEB_TO_WEB;
+    }
+    if (processor_1.Helper.isWebRTC(srcTransport) && !processor_1.Helper.isWebRTC(dstTransport)) {
+        return types_1.Direction.WEB_TO_PHONE;
+    }
+    if (!processor_1.Helper.isWebRTC(srcTransport) && processor_1.Helper.isWebRTC(dstTransport)) {
+        return types_1.Direction.PHONE_TO_WEB;
+    }
+    return types_1.Direction.PHONE_TO_PHONE;
+}
+exports.getDirection = getDirection;
+function getRTPEParamsByDirection(dir) {
+    switch (dir) {
+        case types_1.Direction.WEB_TO_WEB:
+            return {
+                ICE: "force",
+                SDES: "off",
+                flags: "trust-address replace-origin replace-session-connection"
+            };
+        case types_1.Direction.WEB_TO_PHONE:
+            return {
+                "transport-protocol": "RTP/AVP",
+                "rtcp-mux": "demux",
+                ICE: "remove",
+                flags: "trust-address replace-origin replace-session-connection"
+            };
+        case types_1.Direction.PHONE_TO_WEB:
+            return {
+                "transport-protocol": "UDP/TLS/RTP/SAVPF",
+                "rtcp-mux": "required",
+                ICE: "force",
+                SDES: "off",
+                flags: "trust-address replace-origin replace-session-connection generate-mid"
+            };
+        case types_1.Direction.PHONE_TO_PHONE:
+            return {
+                "transport-protocol": "RTP/AVP",
+                "rtcp-mux": "demux",
+                ICE: "remove",
+                flags: "trust-address replace-origin replace-session-connection"
+            };
+    }
+}
+exports.getRTPEParamsByDirection = getRTPEParamsByDirection;
+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) ||
+    processor_1.Helper.isOkOrRingingWithSDP(req) ||
+    processor_1.Helper.isRinging(req) ||
+    processor_1.Helper.isBye(req));
+exports.shouldNotHandleRequest = shouldNotHandleRequest;

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@routr/rtprelay",
+  "version": "2.0.8-alpha.28",
+  "description": "Media Relay for Routr using RTPengine",
+  "author": "Pedro Sanders <psanders@fonoster.com>",
+  "homepage": "https://github.com/fonoster/routr#readme",
+  "license": "MIT",
+  "main": "dist/runner",
+  "types": "dist/runner",
+  "directories": {
+    "src": "src",
+    "test": "test"
+  },
+  "scripts": {
+    "prebuild": "rimraf ./dist tsconfig.tsbuildinfo",
+    "build": "tsc -b tsconfig.json"
+  },
+  "bin": {
+    "run_rtprelay": "dist/runner.js"
+  },
+  "dependencies": {
+    "@fonoster/logger": "0.3.18",
+    "@opentelemetry/api": "^1.0.4",
+    "@opentelemetry/exporter-jaeger": "^1.0.4",
+    "@opentelemetry/instrumentation": "^0.27.0",
+    "@opentelemetry/instrumentation-grpc": "^0.27.0",
+    "@opentelemetry/resources": "^1.0.4",
+    "@opentelemetry/sdk-trace-base": "^1.0.4",
+    "@opentelemetry/sdk-trace-node": "^1.0.4",
+    "@opentelemetry/semantic-conventions": "^1.0.4",
+    "@routr/common": "^2.0.8-alpha.28",
+    "@routr/processor": "^2.0.8-alpha.28",
+    "rtpengine-client": "^0.4.11"
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/fonoster/routr.git"
+  },
+  "bugs": {
+    "url": "https://github.com/fonoster/routr/issues"
+  },
+  "gitHead": "d28aabb2fce0600aaae94aa37709e89ed7112c99"
+}