├── .gitignore
├── examples
    ├── web
    │   ├── favicon.ico
    │   ├── css
    │   │   └── demo.css
    │   ├── index.html
    │   └── index.js
    ├── server-owned
    │   ├── package.json
    │   └── src
    │   │   └── index.js
    ├── server-shared
    │   ├── package.json
    │   └── src
    │   │   └── index.js
    └── README.md
├── .eslintrc.js
├── LICENSE
├── eslint.config.js
├── package.json
├── README.md
└── src
    └── whep.js


/.gitignore:
--------------------------------------------------------------------------------
1 | package-lock.json
2 | node_modules/
3 | 


--------------------------------------------------------------------------------
/examples/web/favicon.ico:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/meetecho/simple-whep-server/HEAD/examples/web/favicon.ico


--------------------------------------------------------------------------------
/.eslintrc.js:
--------------------------------------------------------------------------------
 1 | module.exports = {
 2 |     "env": {
 3 |         "browser": true,
 4 |         "jquery": true,
 5 |         "node": true,
 6 |         "es2021": true
 7 |     },
 8 |     "extends": [
 9 |         "eslint:recommended"
10 |     ],
11 |     "parserOptions": {
12 |         "sourceType": "module"
13 |     },
14 |     "rules": {
15 |     }
16 | };
17 | 


--------------------------------------------------------------------------------
/examples/server-owned/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 | 	"name": "janus-whep-server-owned",
 3 | 	"description": "WHEP server where the library spawns the REST backend",
 4 | 	"type": "module",
 5 | 	"keywords": [
 6 | 		"whep",
 7 | 		"wish",
 8 | 		"janus",
 9 | 		"webrtc",
10 | 		"meetecho"
11 | 	],
12 | 	"author": {
13 | 		"name": "Lorenzo Miniero",
14 | 		"email": "lorenzo@meetecho.com"
15 | 	},
16 | 	"repository": {
17 | 		"type": "git",
18 | 		"url": "https://github.com/meetecho/simple-whep-server.git"
19 | 	},
20 | 	"license": "ISC",
21 | 	"private": true,
22 | 	"main": "src/index.js",
23 | 	"dependencies": {},
24 | 	"scripts": {
25 | 		"build": "npm install --omit=dev",
26 | 		"start": "node src/index.js"
27 | 	}
28 | }
29 | 


--------------------------------------------------------------------------------
/examples/server-shared/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 | 	"name": "janus-whep-server-shared",
 3 | 	"description": "WHEP server where the library reuses an existing REST backend",
 4 | 	"type": "module",
 5 | 	"keywords": [
 6 | 		"whep",
 7 | 		"wish",
 8 | 		"janus",
 9 | 		"webrtc",
10 | 		"meetecho"
11 | 	],
12 | 	"author": {
13 | 		"name": "Lorenzo Miniero",
14 | 		"email": "lorenzo@meetecho.com"
15 | 	},
16 | 	"repository": {
17 | 		"type": "git",
18 | 		"url": "https://github.com/meetecho/simple-whep-server.git"
19 | 	},
20 | 	"license": "ISC",
21 | 	"private": true,
22 | 	"main": "src/index.js",
23 | 	"dependencies": {},
24 | 	"scripts": {
25 | 		"build": "npm install --omit=dev",
26 | 		"start": "node src/index.js"
27 | 	}
28 | }
29 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | ISC License
 2 | 
 3 | Copyright (c) 2025, Meetecho s.r.l. <info@meetecho.com>
 4 | 
 5 | Permission to use, copy, modify, and/or distribute this software for any
 6 | purpose with or without fee is hereby granted, provided that the above
 7 | copyright notice and this permission notice appear in all copies.
 8 | 
 9 | THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
10 | REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
11 | AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
12 | INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
13 | LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
14 | OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
15 | PERFORMANCE OF THIS SOFTWARE.
16 | 


--------------------------------------------------------------------------------
/eslint.config.js:
--------------------------------------------------------------------------------
 1 | import globals from 'globals';
 2 | import js from '@eslint/js';
 3 | 
 4 | export default [
 5 | 	{
 6 | 		files: [
 7 | 			'src/**/*.js',
 8 | 			'examples/**/*.js'
 9 | 		],
10 | 		ignores: [
11 | 			'examples/web/**/*'
12 | 		],
13 | 		languageOptions: {
14 | 			ecmaVersion: 'latest',
15 | 			sourceType: 'module',
16 | 			globals: {
17 | 				...globals.browser,
18 | 				...globals.node
19 | 			}
20 | 		},
21 | 		rules: {
22 | 			...js.configs.recommended.rules,
23 | 			'no-unused-vars': [
24 | 			'warn',
25 | 			{
26 | 				'args': 'all',
27 | 				'vars': 'all',
28 | 				'caughtErrors': 'all',
29 | 				'argsIgnorePattern': '^_',
30 | 				'varsIgnorePattern': '^_',
31 | 				'caughtErrorsIgnorePattern': '^_'
32 | 			}
33 | 			],
34 | 			'indent': [
35 | 				'warn',
36 | 				'tab',
37 | 				{
38 | 					'SwitchCase': 1
39 | 				}
40 | 			],
41 | 			'quotes': [
42 | 				'warn',
43 | 				'single'
44 | 			],
45 | 			'semi': [
46 | 				'warn',
47 | 				'always'
48 | 			],
49 | 			'no-empty': 'off',
50 | 			'multiline-comment-style': 0
51 | 		}
52 | 	}
53 | ];
54 | 


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 | 	"name": "janus-whep-server",
 3 | 	"description": "Simple Janus-based WHEP server library",
 4 | 	"version": "1.0.0",
 5 | 	"type": "module",
 6 | 	"keywords": [
 7 | 		"whep",
 8 | 		"wish",
 9 | 		"janus",
10 | 		"webrtc",
11 | 		"meetecho"
12 | 	],
13 | 	"author": {
14 | 		"name": "Lorenzo Miniero",
15 | 		"email": "lorenzo@meetecho.com",
16 | 		"url": "https://www.meetecho.com"
17 | 	},
18 | 	"repository": {
19 | 		"type": "git",
20 | 		"url": "git+https://github.com/meetecho/simple-whep-server.git"
21 | 	},
22 | 	"bugs": {
23 | 		"url": "https://github.com/meetecho/simple-whep-server/issues"
24 | 	},
25 | 	"license": "ISC",
26 | 	"main": "src/whep.js",
27 | 	"exports": {
28 | 		".": "./src/whep.js"
29 | 	},
30 | 	"files": [
31 | 		"src/whep.js"
32 | 	],
33 | 	"dependencies": {
34 | 		"cors": "^2.8.5",
35 | 		"express": "^5.1.0",
36 | 		"janode": "^1.7.4"
37 | 	},
38 | 	"devDependencies": {
39 | 		"@eslint/js": "^9.4.0",
40 | 		"eslint": "^9.4.0",
41 | 		"globals": "^15.4.0"
42 | 	},
43 | 	"engines": {
44 | 		"node": " >=18.18.0"
45 | 	},
46 | 	"scripts": {
47 | 		"build": "npm install --omit=dev",
48 | 		"lint": "npx eslint --debug"
49 | 	}
50 | }
51 | 


--------------------------------------------------------------------------------
/examples/README.md:
--------------------------------------------------------------------------------
 1 | Simple WHEP Server examples
 2 | ===========================
 3 | 
 4 | This folder contains a few example applications using the Janus WHEP library.
 5 | 
 6 | * The `server-owned` folder contains an example where the application asks the library to create a new REST server to host the WHEP functionality, binding to the provided port. A separate REST server is then spawned by the application for its own purposes (e.g., listing the available endpoints). A sample endpoint is created, with a static token.
 7 | 
 8 | * The `server-shared` folder, instead, contains an example where the application pre-creates a REST server for its own needs, and then tells the library to re-use that server for the WHEP functionality too. A sample endpoint is created, with a callback function used to validate the token any time one is presented.
 9 | 
10 | Both demos subscribe to a few of the events the library can emit for debugging purposes, and serve the `web` folder as static file, which provides a basic WHEP player. Assuming the endpoint `abc123` is available at the WHEP server, you can watch it like that:
11 | 
12 | 	http://localhost:PORT/?id=abc123
13 | 
14 | where `PORT` is `7190` in the `server-owned` example, and `7090` in the `server-shared` example. Notice that, should you want Janus to send the offer (non-standard WHEP), you can do that by passing an additional `offer=false` to the query string.
15 | 


--------------------------------------------------------------------------------
/examples/server-owned/src/index.js:
--------------------------------------------------------------------------------
 1 | import express from 'express';
 2 | import http from 'http';
 3 | import { JanusWhepServer } from '../../../src/whep.js';
 4 | 
 5 | (async function main() {
 6 | 	console.log('Example: WHEP server creating a new REST backend');
 7 | 	let server = null;
 8 | 
 9 | 	// Create an HTTP server and bind to port 7190 just to list endpoints
10 | 	let myApp = express();
11 | 	myApp.get('/endpoints', async (_req, res) => {
12 | 		res.setHeader('content-type', 'application/json');
13 | 		res.status(200);
14 | 		res.send(JSON.stringify(server.listEndpoints()));
15 | 	});
16 | 	myApp.get('/subscribers', async (_req, res) => {
17 | 		res.setHeader('content-type', 'application/json');
18 | 		res.status(200);
19 | 		res.send(JSON.stringify(server.listSubscribers()));
20 | 	});
21 | 	myApp.use(express.static('../web'));
22 | 	http.createServer({}, myApp).listen(7190);
23 | 
24 | 	// Create a WHEP server, binding to port 7090 and using base path /whep
25 | 	server = new JanusWhepServer({
26 | 		janus: {
27 | 			address: 'ws://localhost:8188'
28 | 		},
29 | 		rest: {
30 | 			port: 7090,
31 | 			basePath: '/whep'
32 | 		}
33 | 	});
34 | 	// Add a couple of global event handlers
35 | 	server.on('janus-disconnected', () => {
36 | 		console.log('WHEP server lost connection to Janus');
37 | 	});
38 | 	server.on('janus-reconnected', () => {
39 | 		console.log('WHEP server reconnected to Janus');
40 | 	});
41 | 	// Start the server
42 | 	await server.start();
43 | 
44 | 	// Create a test endpoint using a static token
45 | 	let endpoint = server.createEndpoint({ id: 'abc123', mountpoint: 1, token: 'verysecret' });
46 | 	endpoint.on('new-subscriber', function() {
47 | 		console.log(this.id + ': Endpoint has a new subscriber');
48 | 	});
49 | 	endpoint.on('subscriber-gone', function() {
50 | 		console.log(this.id + ': Endpoint subscriber left');
51 | 	});
52 | }());
53 | 


--------------------------------------------------------------------------------
/examples/server-shared/src/index.js:
--------------------------------------------------------------------------------
 1 | import express from 'express';
 2 | import http from 'http';
 3 | import { JanusWhepServer } from '../../../src/whep.js';
 4 | 
 5 | (async function main() {
 6 | 	console.log('Example: WHEP server using pre-existing REST backend');
 7 | 	let server = null;
 8 | 
 9 | 	// Create an HTTP server and bind to port 7090
10 | 	let myApp = express();
11 | 	myApp.get('/endpoints', async (_req, res) => {
12 | 		res.setHeader('content-type', 'application/json');
13 | 		res.status(200);
14 | 		res.send(JSON.stringify(server.listEndpoints()));
15 | 	});
16 | 	myApp.get('/subscribers', async (_req, res) => {
17 | 		res.setHeader('content-type', 'application/json');
18 | 		res.status(200);
19 | 		res.send(JSON.stringify(server.listSubscribers()));
20 | 	});
21 | 	myApp.use(express.static('../web'));
22 | 	http.createServer({}, myApp).listen(7090);
23 | 
24 | 	// Create a WHEP server, and add it with base path /whep to the server above
25 | 	server = new JanusWhepServer({
26 | 		janus: {
27 | 			address: 'ws://localhost:8188'
28 | 		},
29 | 		rest: {
30 | 			app: myApp,
31 | 			basePath: '/whep'
32 | 		}
33 | 	});
34 | 	// Add a couple of global event handlers
35 | 	server.on('janus-disconnected', () => {
36 | 		console.log('WHEP server lost connection to Janus');
37 | 	});
38 | 	server.on('janus-reconnected', () => {
39 | 		console.log('WHEP server reconnected to Janus');
40 | 	});
41 | 	// Start the server
42 | 	await server.start();
43 | 
44 | 	// Create a test endpoint using a callback function to validate the token
45 | 	let endpoint = server.createEndpoint({ id: 'abc123', mountpoint: 1, token: function(authtoken) {
46 | 		return authtoken === 'verysecret';
47 | 	}});
48 | 	endpoint.on('new-subscriber', function() {
49 | 		console.log(this.id + ': Endpoint has a new subscriber');
50 | 	});
51 | 	endpoint.on('subscriber-gone', function() {
52 | 		console.log(this.id + ': Endpoint subscriber left');
53 | 	});
54 | }());
55 | 


--------------------------------------------------------------------------------
/examples/web/css/demo.css:
--------------------------------------------------------------------------------
  1 | .rounded {
  2 | 	border-radius: 5px;
  3 | }
  4 | 
  5 | .centered {
  6 | 	display: block;
  7 | 	margin: auto;
  8 | }
  9 | 
 10 | .relative {
 11 | 	position: relative;
 12 | }
 13 | 
 14 | .navbar-brand {
 15 | 	margin-left: 0px !important;
 16 | }
 17 | 
 18 | .navbar-default {
 19 | 	-webkit-box-shadow: 0px 3px 5px rgba(100, 100, 100, 0.49);
 20 | 	-moz-box-shadow:    0px 3px 5px rgba(100, 100, 100, 0.49);
 21 | 	box-shadow:         0px 3px 5px rgba(100, 100, 100, 0.49);
 22 | }
 23 | 
 24 | .navbar-header {
 25 | 	padding-left: 40px;
 26 | }
 27 | 
 28 | .margin-sm {
 29 | 	margin: 5px !important;
 30 | }
 31 | .margin-md {
 32 | 	margin: 10px !important;
 33 | }
 34 | .margin-xl {
 35 | 	margin: 20px !important;
 36 | }
 37 | .margin-bottom-sm {
 38 | 	margin-bottom: 5px !important;
 39 | }
 40 | .margin-bottom-md {
 41 | 	margin-bottom: 10px !important;
 42 | }
 43 | .margin-bottom-xl {
 44 | 	margin-bottom: 20px !important;
 45 | }
 46 | 
 47 | .divider {
 48 | 	width: 100%;
 49 | 	text-align: center;
 50 | }
 51 | 
 52 | .divider hr {
 53 | 	margin-left: auto;
 54 | 	margin-right: auto;
 55 | 	width: 45%;
 56 | }
 57 | 
 58 | .fa-2 {
 59 | 	font-size: 2em !important;
 60 | }
 61 | .fa-3 {
 62 | 	font-size: 4em !important;
 63 | }
 64 | .fa-4 {
 65 | 	font-size: 7em !important;
 66 | }
 67 | .fa-5 {
 68 | 	font-size: 12em !important;
 69 | }
 70 | .fa-6 {
 71 | 	font-size: 20em !important;
 72 | }
 73 | 
 74 | div.no-video-container {
 75 | 	position: relative;
 76 | }
 77 | 
 78 | .no-video-icon {
 79 | 	width: 100%;
 80 | 	height: 240px;
 81 | 	text-align: center;
 82 | }
 83 | 
 84 | .no-video-text {
 85 | 	text-align: center;
 86 | 	position: absolute;
 87 | 	bottom: 0px;
 88 | 	right: 0px;
 89 | 	left: 0px;
 90 | 	font-size: 24px;
 91 | }
 92 | 
 93 | .meetecho-logo {
 94 | 	padding: 12px !important;
 95 | }
 96 | 
 97 | .meetecho-logo > img {
 98 | 	height: 26px;
 99 | }
100 | 
101 | pre {
102 | 	white-space: pre-wrap;
103 | 	white-space: -moz-pre-wrap;
104 | 	white-space: -pre-wrap;
105 | 	white-space: -o-pre-wrap;
106 | 	word-wrap: break-word;
107 | }
108 | 
109 | .januscon {
110 | 	font-weight: bold;
111 | 	animation: pulsating 1s infinite;
112 | }
113 | @keyframes pulsating {
114 | 	30% {
115 | 		color: #FFD700;
116 | 	}
117 | }
118 | 


--------------------------------------------------------------------------------
/examples/web/index.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html xmlns="http://www.w3.org/1999/xhtml">
 3 | <head>
 4 | <meta charset="utf-8">
 5 | <meta name="viewport" content="width=device-width, initial-scale=1.0"/>
 6 | <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
 7 | <title>Simple WHEP server (Janus)</title>
 8 | <script type="text/javascript" src="https://cdnjs.cloudflare.com/ajax/libs/jquery/1.9.1/jquery.min.js" ></script>
 9 | <script type="text/javascript" src="https://cdnjs.cloudflare.com/ajax/libs/twitter-bootstrap/3.4.1/js/bootstrap.min.js"></script>
10 | <script type="text/javascript" src="https://cdnjs.cloudflare.com/ajax/libs/bootbox.js/5.4.0/bootbox.min.js"></script>
11 | <script type="text/javascript" src="https://cdnjs.cloudflare.com/ajax/libs/toastr.js/2.1.4/toastr.min.js"></script>
12 | <script type="text/javascript" src="index.js" ></script>
13 | <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/bootswatch/3.4.0/slate/bootstrap.min.css" type="text/css"/>
14 | <link rel="stylesheet" href="css/demo.css" type="text/css"/>
15 | <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/4.7.0/css/font-awesome.min.css" type="text/css"/>
16 | <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/toastr.js/2.1.4/toastr.min.css"/>
17 | </head>
18 | <body>
19 | 
20 | <nav class="navbar navbar-default navbar-static-top">
21 | 	<div class="navbar-header">
22 | 		<a class="navbar-brand" href=".">Simple WHEP server (Janus)</a>
23 | 		<button type="button" class="navbar-toggle" data-toggle="collapse" data-target=".navbar-collapse">
24 | 			<span class="icon-bar"></span>
25 | 			<span class="icon-bar"></span>
26 | 			<span class="icon-bar"></span>
27 | 		</button>
28 | 	</div>
29 | 	<div class="navbar-collapse collapse">
30 | 		<ul class="nav navbar-nav">
31 | 			<li class="active"><a href=".">Watch</a></li>
32 | 		</ul>
33 | 		<div class="navbar-header navbar-right" style="margin-right: 0px;">
34 | 			<ul class="nav navbar-nav">
35 | 				<li><a target="_blank" href="https://janus.conf.meetecho.com" class="navbar-link"><b>Janus</b></a></li>
36 | 				<li><a target="_blank" href="http://www.meetecho.com" class="navbar-link"><b>Meetecho</b></a></li>
37 | 			</ul>
38 | 		</div>
39 | 	</div>
40 | </nav>
41 | 
42 | <div class="container">
43 | 	<div class="row">
44 | 		<div class="col-md-12">
45 | 			<div id="video" class="hide">
46 | 				<div class="col-md-12">
47 | 					<div class="panel panel-default">
48 | 						<div class="panel-heading">
49 | 							<h3 class="panel-title">
50 | 								<span class="label label-info" id="wheplabel">WHEP Endpoint</span>
51 | 							</h3>
52 | 						</div>
53 | 						<div class="panel-body" id="videoremote"></div>
54 | 					</div>
55 | 				</div>
56 | 			</div>
57 | 		</div>
58 | 	</div>
59 | </div>
60 | 
61 | </body>
62 | </html>
63 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | Simple WHEP Server
  2 | ==================
  3 | 
  4 | This is a Node.js library implementation of a [WHEP server](https://datatracker.ietf.org/doc/draft-ietf-wish-whep/), developed by [Meetecho](https://www.meetecho.com), using the [Janus WebRTC Server](https://github.com/meetecho/janus-gateway/) as a WebRTC server backend and [Janode](https://github.com/meetecho/janode/) as its Janus stack. While it was initially conceived to be used mostly for testing with [Simple WHEP Client](https://github.com/meetecho/simple-whep-client) (based on [GStreamer's webrtcbin](https://gstreamer.freedesktop.org/documentation/webrtc/index.html)), as a standard WHEP implementation it's supposed to interoperate just as well with other WHEP implementations.
  5 | 
  6 | The library is available on [npm](https://www.npmjs.com/package/janus-whep-server) and the source code is on [Github](https://github.com/meetecho/simple-whep-server/).
  7 | 
  8 | > Note: this is an implementation of WHEP (WebRTC-HTTP egress protocol), **NOT** WHIP (WebRTC-HTTP ingestion protocol). If you're looking for a WHIP server to handle media ingestion, check the [Simple WHIP Server](https://github.com/meetecho/simple-whip-server) library instead. The two libraries can be used together in the same application, if you want to serve both protocols at the same time.
  9 | 
 10 | # Example of usage
 11 | 
 12 | The repo comes with a [few examples](https://github.com/meetecho/simple-whep-server/tree/master/examples) that show how you can create a new WHEP server.
 13 | 
 14 | You create a new server this way:
 15 | 
 16 | ```js
 17 | const server = new JanusWhepServer(config);
 18 | await server.start();
 19 | ```
 20 | 
 21 | where `config` is an object that may contain the following properties:
 22 | 
 23 | ```
 24 | {
 25 | 	janus: {
 26 | 		address: '<Janus backend (Janode supported transports)>'
 27 | 	},
 28 | 	rest: {
 29 | 		app: <existing Express application to add the WHEP server to, if reusing an existing REST server>
 30 | 		port: <port to bind the WHEP server to, in case a new REST server is to be created>,
 31 | 		basePath: '<base path to use for all WHEP endpoints, e.g., /whep>',
 32 | 		https: {
 33 | 			// cert, key, passphrase; in case an HTTPS server is to be created
 34 | 		}
 35 | 	},
 36 | 	allowTrickle: <whether trickle should be allowed; true by default>,
 37 | 	strictETags: <whether to be strict when checking ETags in HTTP PATCH; false by default>,
 38 | 	iceServers: [
 39 | 		// list of ICE servers to send back in Link headers by default, e.g.
 40 | 		//	{ uri: 'stun:stun.example.net' },
 41 | 		//	{ uri: 'turn:turn.example.net?transport=udp', username: 'user', credential: 'password' },
 42 | 	]
 43 | }
 44 | ```
 45 | 
 46 | The following snippet creates a WHEP server that will spawn its own REST backend on port `7090`:
 47 | 
 48 | ```js
 49 | const server = new JanusWhepServer({
 50 | 	janus: {
 51 | 		address: 'ws://localhost:8188'
 52 | 	},
 53 | 	rest: {
 54 | 		port: 7090,
 55 | 		basePath: '/whep'
 56 | 	}
 57 | });
 58 | ```
 59 | 
 60 | The following snippet reuses an existing Express app contest for the WHEP server:
 61 | 
 62 | ```js
 63 | const server = new JanusWhepServer({
 64 | 	janus: {
 65 | 		address: 'ws://localhost:8188'
 66 | 	},
 67 | 	rest: {
 68 | 		app: myApp,
 69 | 		basePath: '/whep'
 70 | 	}
 71 | });
 72 | ```
 73 | 
 74 | The `JanusWhepServer` exposes a few methods to manage endpoints that should be served by the WHEP server. This creates a new endpoint:
 75 | 
 76 | ```js
 77 | const endpoint = server.createEndpoint({ id: 'test', mountpoint: 1, token: 'verysecret' });
 78 | ```
 79 | 
 80 | which returns a `JanusWhepEndpoint` instance. You can also retrieve the same instance later on with a call to `getEndpoint(id)`, should you need it.
 81 | 
 82 | The object to pass when creating a new endpoint must refer to the following structure:
 83 | 
 84 | ```
 85 | {
 86 | 	id: "<unique ID of the endpoint to create>",
 87 | 	mountpoint: <Streaming mountpoint ID to subscribe to>,
 88 | 	pin: <Streaming mountpoint pin, if required to subscribe (optional)>,
 89 | 	label: <Label to show when subscribing (optional, only relevant in the demo)>,
 90 | 	token: "<token to require via Bearer authorization when using WHIP: can be either a string, or a callback function to validate the provided token (optional)>,
 91 | 	iceServers: [ array of STUN/TURN servers to return via Link headers (optional, overrides global ones) ]
 92 | }
 93 | ```
 94 | 
 95 | Subscribing to the WHEP endpoint via WebRTC can be done by sending either an SDP offer or (non-standard approach) an empty request to the created `/endpoint/<id>` endpoint via HTTP POST, which will interact with Janus on your behalf. Depending on what you sent, if successful, it will return an SDP answer or offer back in the 200 OK, plus an address for the allocated resource; if you sent an empty request initially, to complete the negotiation you'll have to send the SDP answer to the resource URL via PATCH. If you're using [Simple WHEP Client](https://github.com/meetecho/simple-whep-client) to test, the full HTTP path to the endpoint is all you need to provide as the WHEP url. Notice that, to be able to send an offer to the WHP endpoint you'll need to use at least the `1.1.4` version of Janus.
 96 | 
 97 | As per the specification, the response to the subscribe request will contain a `Location` header which points to the resource to use to refer to the stream. In this prototype implementation, the resource is handled by the same server instance, and is currently generated automatically as a `<basePath>/resource/<uuid>` endpoint (returned as a relative path in the header), where `uuid` is randomly generated and unique for each subscriber. That's the address used for interacting with the session, i.e., for tricking candidates, restarting ICE, and tearing down the session. The server is configured to automatically allow trickle candidates to be sent via HTTP PATCH to the `<basePath>/resource/<uuid>` endpoint: if you'd like the server to not allow trickle candidates instead (e.g., to test if your client handles a failure gracefully), you can disable them when creating the server via `allowTrickle`. ICE restarts are currently not supported. Finally, that's also the address you'll need to send the HTTP DELETE request to, in case you want to signal the intention to tear down the WebRTC PeerConnection.
 98 | 
 99 | Notice that a DELETE to the resource endpoint will only tear down the PeerConnection, but will preserve the endpoint, meaning new WHEP subscriptions on the same Janus mountpoint can still be created: to permanently destroy an existing endpoint, you need to destroy it via `destroyEndpoint`:
100 | 
101 | ```js
102 | server.destroyEndpoint({ id: 'test' });
103 | ```
104 | 
105 | This returns a list of existing endpoints the WHIP server is aware of:
106 | 
107 | ```js
108 | const list = server.listEndpoints();
109 | ```
110 | 
111 | Notice that the array will contain a list of objects only including the `id` and a `count` of the current subscribers to that endpoint. If you want more details on a specific endpoint (e.g., to access the endpoint instance and update the event emitter configuration), use `getEndpoint(id)` instead.
112 | 
113 | Both `JanusWhepServer` and `JanusWhepEndpoint` have a method called `listSubscribers()`, which returns the list of subscribers (to all endpoints in the first case, and to the specific endpoint in the second).
114 | 
115 | Both `JanusWhepServer` and `JanusWhepEndpoint` are also event emitters. At the time of writing, the supported events are:
116 | 
117 | * `janus-disconnected`
118 | * `janus-reconnected`
119 | * `new-subscriber`
120 | * `subscriber-gone`
121 | 
122 | Check the demos for an example, which includes a basic web-based WebRTC WHEP player.
123 | 


--------------------------------------------------------------------------------
/examples/web/index.js:
--------------------------------------------------------------------------------
  1 | // Base path for the REST WHEP API
  2 | const backend = 'http://localhost:7090';
  3 | const rest = '/whep';
  4 | let resource = null, token = null;
  5 | 
  6 | // PeerConnection
  7 | let pc = null;
  8 | let iceUfrag = null, icePwd = null, candidates = [];
  9 | 
 10 | // Helper function to get query string arguments
 11 | function getQueryStringValue(name) {
 12 | 	name = name.replace(/[\[]/, '\\[').replace(/[\]]/, '\\]');
 13 | 	let regex = new RegExp('[\\?&]' + name + '=([^&#]*)'),
 14 | 		results = regex.exec(location.search);
 15 | 	return results === null ? '' : decodeURIComponent(results[1].replace(/\+/g, ' '));
 16 | }
 17 | // Get the endpoint ID to subscribe to
 18 | const id = getQueryStringValue('id');
 19 | // Check if we should let the endpoint send the offer
 20 | const expectOffer = (getQueryStringValue('offer') === 'false')
 21 | 
 22 | $(document).ready(function() {
 23 | 	// Make sure WebRTC is supported by the browser
 24 | 	if(!window.RTCPeerConnection) {
 25 | 		bootbox.alert('WebRTC unsupported...');
 26 | 		return;
 27 | 	}
 28 | 	if(!id) {
 29 | 		bootbox.alert('Invalid endpoint ID...');
 30 | 		return;
 31 | 	}
 32 | 	bootbox.prompt({
 33 | 		title: 'Insert the endpoint token (leave it empty if not needed)',
 34 | 		inputType: 'password',
 35 | 		callback: function(result) {
 36 | 			token = result;
 37 | 			subscribeToEndpoint();
 38 | 		}
 39 | 	});
 40 | });
 41 | 
 42 | // Function to subscribe to the WHEP endpoint
 43 | async function subscribeToEndpoint() {
 44 | 	let headers = null, offer = null;
 45 | 	if(token)
 46 | 		headers = { Authorization: 'Bearer ' + token };
 47 | 	if(!expectOffer) {
 48 | 		// We need to prepare an offer ourselves, do it now
 49 | 		let iceServers = [{urls: "stun:stun.l.google.com:19302"}];
 50 | 		createPeerConnectionIfNeeded(iceServers);
 51 | 		let transceiver = await pc.addTransceiver('audio');
 52 | 		if(transceiver.setDirection)
 53 | 			transceiver.setDirection('recvonly');
 54 | 		else
 55 | 			transceiver.direction = 'recvonly';
 56 | 		transceiver = await pc.addTransceiver('video');
 57 | 		if(transceiver.setDirection)
 58 | 			transceiver.setDirection('recvonly');
 59 | 		else
 60 | 			transceiver.direction = 'recvonly';
 61 | 		offer = await pc.createOffer({});
 62 | 		await pc.setLocalDescription(offer);
 63 | 		// Extract ICE ufrag and pwd (for trickle)
 64 | 		iceUfrag = offer.sdp.match(/a=ice-ufrag:(.*)\r\n/)[1];
 65 | 		icePwd = offer.sdp.match(/a=ice-pwd:(.*)\r\n/)[1];
 66 | 	}
 67 | 	// Contact the WHEP endpoint
 68 | 	$.ajax({
 69 | 		url: backend + rest + '/endpoint/' + id,
 70 | 		type: 'POST',
 71 | 		headers: headers,
 72 | 		contentType: offer ? 'application/sdp' : null,
 73 | 		data: offer ? offer.sdp : {}
 74 | 	}).error(function(xhr, textStatus, errorThrown) {
 75 | 		bootbox.alert(xhr.status + ": " + xhr.responseText);
 76 | 	}).success(function(sdp, textStatus, request) {
 77 | 		console.log('Got SDP:', sdp);
 78 | 		resource = request.getResponseHeader('Location');
 79 | 		console.log('WHEP resource:', resource);
 80 | 		// TODO Parse ICE servers
 81 | 		// let ice = request.getResponseHeader('Link');
 82 | 		let iceServers = [{urls: "stun:stun.l.google.com:19302"}];
 83 | 		// Create PeerConnection, if needed
 84 | 		createPeerConnectionIfNeeded(iceServers);
 85 | 		// Pass the SDP to the PeerConnection
 86 | 		let jsep = {
 87 | 			type: expectOffer ? 'offer' : 'answer',
 88 | 			sdp: sdp
 89 | 		};
 90 | 		pc.setRemoteDescription(jsep)
 91 | 			.then(function() {
 92 | 				console.log('Remote description accepted');
 93 | 				if(!expectOffer) {
 94 | 					// We're done: just check if we have candidates to send
 95 | 					if(candidates.length > 0) {
 96 | 						// FIXME Trickle candidate
 97 | 						let headers = null;
 98 | 						if(token)
 99 | 							headers = { Authorization: 'Bearer ' + token };
100 | 						let candidate =
101 | 							'a=ice-ufrag:' + iceUfrag + '\r\n' +
102 | 							'a=ice-pwd:' + icePwd + '\r\n' +
103 | 							'm=audio 9 RTP/AVP 0\r\n';
104 | 						for(let c of candidates)
105 | 							candidate += 'a=' + c + '\r\n';
106 | 						candidates = [];
107 | 						$.ajax({
108 | 							url: backend + resource,
109 | 							type: 'PATCH',
110 | 							headers: headers,
111 | 							contentType: 'application/trickle-ice-sdpfrag',
112 | 							data: candidate
113 | 						}).error(function(xhr, textStatus, errorThrown) {
114 | 							bootbox.alert(xhr.status + ": " + xhr.responseText);
115 | 						}).done(function(response) {
116 | 							console.log('Candidate sent');
117 | 						});
118 | 					}
119 | 					return;
120 | 				}
121 | 				// If we got here, we're in the "WHEP server sends offer" mode,
122 | 				// so we have to prepare an answer to send back via a PATCH
123 | 				pc.createAnswer({})
124 | 					.then(function(answer) {
125 | 						console.log('Prepared answer:', answer.sdp);
126 | 						// Extract ICE ufrag and pwd (for trickle)
127 | 						iceUfrag = answer.sdp.match(/a=ice-ufrag:(.*)\r\n/)[1];
128 | 						icePwd = answer.sdp.match(/a=ice-pwd:(.*)\r\n/)[1];
129 | 						pc.setLocalDescription(answer)
130 | 							.then(function() {
131 | 								console.log('Sending answer to WHEP server');
132 | 								// Send the answer to the resource address
133 | 								$.ajax({
134 | 									url: backend + resource,
135 | 									type: 'PATCH',
136 | 									headers: headers,
137 | 									contentType: 'application/sdp',
138 | 									data: answer.sdp
139 | 								}).error(function(xhr, textStatus, errorThrown) {
140 | 									bootbox.alert(xhr.status + ": " + xhr.responseText);
141 | 								}).done(function(response) {
142 | 									console.log('Negotiation completed');
143 | 								});
144 | 							}, function(err) {
145 | 								bootbox.alert(err.message);
146 | 							});
147 | 					}, function(err) {
148 | 						bootbox.alert(err.message);
149 | 					});
150 | 			}, function(err) {
151 | 				bootbox.alert(err.message);
152 | 			});
153 | 	});
154 | }
155 | 
156 | // Helper function to attach a media stream to a video element
157 | function attachMediaStream(element, stream) {
158 | 	try {
159 | 		element.srcObject = stream;
160 | 	} catch (e) {
161 | 		try {
162 | 			element.src = URL.createObjectURL(stream);
163 | 		} catch (e) {
164 | 			Janus.error("Error attaching stream to element", e);
165 | 		}
166 | 	}
167 | };
168 | 
169 | // Helper function to create a PeerConnection, if needed, since we can either
170 | // expect an offer from the WHEP server, or provide one ourselves
171 | function createPeerConnectionIfNeeded(iceServers) {
172 | 	if(pc)
173 | 		return;
174 | 	let pc_config = {
175 | 		sdpSemantics: 'unified-plan',
176 | 		iceServers: iceServers
177 | 	};
178 | 	pc = new RTCPeerConnection(pc_config);
179 | 	pc.oniceconnectionstatechange = function() {
180 | 		console.log('[ICE] ', pc.iceConnectionState);
181 | 	};
182 | 	pc.onicecandidate = function(event) {
183 | 		let end = false;
184 | 		if(!event.candidate || (event.candidate.candidate && event.candidate.candidate.indexOf('endOfCandidates') > 0)) {
185 | 			console.log('End of candidates');
186 | 			end = true;
187 | 		} else {
188 | 			console.log('Got candidate:', event.candidate.candidate);
189 | 		}
190 | 		if(!resource) {
191 | 			console.log('No resource URL yet, queueing candidate');
192 | 			candidates.push(end ? 'end-of-candidates' : event.candidate.candidate);
193 | 			return;
194 | 		}
195 | 		if(!iceUfrag || !icePwd) {
196 | 			console.log('No ICE credentials yet, queueing candidate');
197 | 			candidates.push(end ? 'end-of-candidates' : event.candidate.candidate);
198 | 			return;
199 | 		}
200 | 		// FIXME Trickle candidate
201 | 		let headers = null;
202 | 		if(token)
203 | 			headers = { Authorization: 'Bearer ' + token };
204 | 		let candidate =
205 | 			'a=ice-ufrag:' + iceUfrag + '\r\n' +
206 | 			'a=ice-pwd:' + icePwd + '\r\n' +
207 | 			'm=audio 9 RTP/AVP 0\r\n' +
208 | 			'a=' + (end ? 'end-of-candidates' : event.candidate.candidate) + '\r\n';
209 | 		$.ajax({
210 | 			url: backend + resource,
211 | 			type: 'PATCH',
212 | 			headers: headers,
213 | 			contentType: 'application/trickle-ice-sdpfrag',
214 | 			data: candidate
215 | 		}).error(function(xhr, textStatus, errorThrown) {
216 | 			bootbox.alert(xhr.status + ": " + xhr.responseText);
217 | 		}).done(function(response) {
218 | 			console.log('Candidate sent');
219 | 		});
220 | 	};
221 | 	pc.ontrack = function(event) {
222 | 		console.log('Handling Remote Track', event);
223 | 		if(!event.streams)
224 | 			return;
225 | 		console.warn(event.streams[0].getTracks());
226 | 		if($('#whepvideo').length === 0) {
227 | 			$('#video').removeClass('hide').show();
228 | 			$('#videoremote').append('<video class="rounded centered" id="whepvideo" width="100%" height="100%" autoplay playsinline/>');
229 | 			$('#whepvideo').get(0).volume = 0;
230 | 		}
231 | 		attachMediaStream($('#whepvideo').get(0), event.streams[0]);
232 | 		$('#whepvideo').get(0).play();
233 | 		$('#whepvideo').get(0).volume = 1;
234 | 	};
235 | }
236 | 


--------------------------------------------------------------------------------
/src/whep.js:
--------------------------------------------------------------------------------
  1 | 'use strict';
  2 | 
  3 | /*
  4 |  * Simple WHEP server
  5 |  *
  6 |  * Author:  Lorenzo Miniero <lorenzo@meetecho.com>
  7 |  * License: ISC
  8 |  *
  9 |  * WHEP API and endpoint management
 10 |  *
 11 |  */
 12 | 
 13 | // Dependencies
 14 | import express from 'express';
 15 | import cors from 'cors';
 16 | import fs from 'fs';
 17 | import http from 'http';
 18 | import https from 'https';
 19 | import Janode from 'janode';
 20 | import StreamingPlugin from 'janode/plugins/streaming';
 21 | import { EventEmitter } from 'events';
 22 | 
 23 | // WHEP server class
 24 | class JanusWhepServer extends EventEmitter {
 25 | 
 26 | 	// Constructor
 27 | 	constructor({ janus, rest, allowTrickle = true, strictETags = false, iceServers = [], debug }) {
 28 | 		super();
 29 | 		// Parse configuration
 30 | 		if(!janus || typeof janus !== 'object')
 31 | 			throw new Error('Invalid configuration, missing parameter "janus" or not an object');
 32 | 		if(!janus.address)
 33 | 			throw new Error('Invalid configuration, missing parameter "address" in "janus"');
 34 | 		if(!rest || typeof rest !== 'object')
 35 | 			throw new Error('Invalid configuration, missing parameter "rest" or not an object');
 36 | 		if(!rest.basePath)
 37 | 			throw new Error('Invalid configuration, missing parameter "basePath" in "rest"');
 38 | 		if(!rest.port && !rest.app)
 39 | 			throw new Error('Invalid configuration, at least one of "port" and "app" should be set in "rest"');
 40 | 		const debugLevels = [ 'err', 'warn', 'info', 'verb', 'debug' ];
 41 | 		if(debug && debugLevels.indexOf(debug) === -1)
 42 | 			throw new Error('Invalid configuration, unsupported "debug" level');
 43 | 		this.config = {
 44 | 			janus: {
 45 | 				address: janus.address
 46 | 			},
 47 | 			rest: {
 48 | 				port: rest.port,
 49 | 				basePath: rest.basePath,
 50 | 				app: rest.app
 51 | 			},
 52 | 			allowTrickle: (allowTrickle === true),
 53 | 			strictETags: (strictETags === true),
 54 | 			iceServers: Array.isArray(iceServers) ? iceServers : [iceServers]
 55 | 		};
 56 | 
 57 | 		// Resources
 58 | 		this.janus = null;
 59 | 		this.endpoints = new Map();
 60 | 		this.subscribers = new Map();
 61 | 		this.logger = new JanusWhepLogger({ prefix: '[WHEP] ', level: debug ? debugLevels.indexOf(debug) : 2 });
 62 | 	}
 63 | 
 64 | 	async start() {
 65 | 		if(this.started)
 66 | 			throw new Error('WHEP server already started');
 67 | 		// Connect to Janus
 68 | 		await this._connectToJanus();
 69 | 		// WHEP REST API
 70 | 		if(!this.config.rest.app) {
 71 | 			// Spawn a new app and server
 72 | 			this.logger.verb('Spawning new Express app');
 73 | 			let app = express();
 74 | 			this._setupRest(app);
 75 | 			let options = null;
 76 | 			let useHttps = (this.config.rest.https && this.config.rest.https.cert && this.config.rest.https.key);
 77 | 			if(useHttps) {
 78 | 				options = {
 79 | 					cert: fs.readFileSync(this.config.rest.https.cert, 'utf8'),
 80 | 					key: fs.readFileSync(this.config.rest.https.key, 'utf8'),
 81 | 					passphrase: this.config.rest.https.passphrase
 82 | 				};
 83 | 			}
 84 | 			this.server = await (useHttps ? https : http).createServer(options, app);
 85 | 			await this.server.listen(this.config.rest.port);
 86 | 		} else {
 87 | 			// A server already exists, only add our endpoints to its router
 88 | 			this.logger.verb('Reusing existing Express app');
 89 | 			this._setupRest(this.config.rest.app);
 90 | 		}
 91 | 		// We're up and running
 92 | 		this.logger.info('WHEP server started');
 93 | 		this.started = true;
 94 | 		return this;
 95 | 	}
 96 | 
 97 | 	async destroy() {
 98 | 		if(!this.started)
 99 | 			throw new Error('WHEP server not started');
100 | 		if(this.janus)
101 | 			await this.janus.close();
102 | 		if(this.server)
103 | 			this.server.close();
104 | 	}
105 | 
106 | 	generateRandomString(len) {
107 | 		const charSet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
108 | 		let randomString = '';
109 | 		for(let i=0; i<len; i++) {
110 | 			let randomPoz = Math.floor(Math.random() * charSet.length);
111 | 			randomString += charSet.substring(randomPoz,randomPoz+1);
112 | 		}
113 | 		return randomString;
114 | 	}
115 | 
116 | 	createEndpoint({ id, mountpoint, pin, label, token, iceServers }) {
117 | 		if(!id || !mountpoint)
118 | 			throw new Error('Invalid arguments');
119 | 		if(this.endpoints.has(id))
120 | 			throw new Error('Endpoint already exists');
121 | 		let endpoint = new JanusWhepEndpoint({
122 | 			id: id,
123 | 			mountpoint: mountpoint,
124 | 			pin: pin,
125 | 			label: label,
126 | 			token: token,
127 | 			iceServers: iceServers
128 | 		});
129 | 		this.logger.info('[' + id + '] Created new WHEP endpoint');
130 | 		this.endpoints.set(id, endpoint);
131 | 		return endpoint;
132 | 	}
133 | 
134 | 	listEndpoints() {
135 | 		let list = [];
136 | 		this.endpoints.forEach(function(endpoint, id) {
137 | 			list.push({ id: id, subscribers: endpoint.countSubscribers() });
138 | 		});
139 | 		return list;
140 | 	}
141 | 
142 | 	getEndpoint({ id }) {
143 | 		return this.endpoints.get(id);
144 | 	}
145 | 
146 | 	async destroyEndpoint({ id }) {
147 | 		let endpoint = this.endpoints.get(id);
148 | 		if(!id || !endpoint)
149 | 			throw new Error('Invalid endpoint ID');
150 | 		// Get rid of the Janus subscribers, if there's any
151 | 		endpoint.subscribers.forEach(async function(_val, uuid) {
152 | 			let subscriber = this.subscribers.get(uuid);
153 | 			if(!subscriber)
154 | 				return;
155 | 			if(this.janus && subscriber.handle)
156 | 				await subscriber.handle.detach().catch(_err => {});
157 | 			this.subscribers.delete(uuid);
158 | 		}, this);
159 | 		this.endpoints.delete(id);
160 | 		this.logger.info('[' + id + '] Destroyed WHEP endpoint');
161 | 	}
162 | 
163 | 	countSubscribers() {
164 | 		console.log(this.subscribers);
165 | 		return this.subscribers.size;
166 | 	}
167 | 
168 | 	listSubscribers() {
169 | 		let list = [];
170 | 		this.subscribers.forEach(function(subscriber, uuid) {
171 | 			list.push({ endpoint: subscriber.whepId, uuid: uuid });
172 | 		});
173 | 		return list;
174 | 
175 | 	}
176 | 
177 | 	// Janus setup
178 | 	async _connectToJanus() {
179 | 		const connection = await Janode.connect({
180 | 			is_admin: false,
181 | 			address: {
182 | 				url: this.config.janus.address,
183 | 			},
184 | 			retry_time_secs: 3,
185 | 			max_retries: Number.MAX_VALUE
186 | 		});
187 | 		connection.once(Janode.EVENT.CONNECTION_ERROR, () => {
188 | 			this.logger.warn('Lost connectivity to Janus, reset the manager and try reconnecting');
189 | 			// Teardown existing endpoints
190 | 			this.endpoints.forEach(function(endpoint, id) {
191 | 				endpoint.subscribers.forEach(async function(_val, uuid) {
192 | 					let subscriber = this.subscribers.get(uuid);
193 | 					if(!subscriber)
194 | 						return;
195 | 					if(subscriber.handle) {
196 | 						endpoint.emit('subscriber-gone');
197 | 						this.emit('subscriber-gone', id);
198 | 					}
199 | 				}, this);
200 | 				endpoint.subscribers.clear();
201 | 				this.logger.info('[' + id + '] Terminating WHEP subscriber sessions');
202 | 				endpoint.emit('janus-disconnected');
203 | 			}, this);
204 | 			this.subscribers.clear();
205 | 			this.emit('janus-disconnected');
206 | 			// Reconnect
207 | 			this.janus = null;
208 | 			setTimeout(this._connectToJanus.bind(this), 1);
209 | 		});
210 | 		this.janus = await connection.create();
211 | 		this.logger.info('Connected to Janus:', this.config.janus.address);
212 | 		if(this.started)
213 | 			this.emit('janus-reconnected');
214 | 	}
215 | 
216 | 	// REST server setup
217 | 	_setupRest(app) {
218 | 		const router = express.Router();
219 | 
220 | 		// Just a helper to make sure this API is up and running
221 | 		router.get('/healthcheck', (_req, res) => {
222 | 			this.logger.debug('/healthcheck');
223 | 			res.sendStatus(200);
224 | 		});
225 | 
226 | 		// Subscribe to a WHEP endpoint
227 | 		router.post('/endpoint/:id', async (req, res) => {
228 | 			let id = req.params.id;
229 | 			let endpoint = this.endpoints.get(id);
230 | 			if(!id || !endpoint) {
231 | 				res.status(404);
232 | 				res.send('Invalid endpoint ID');
233 | 				return;
234 | 			}
235 | 			if(endpoint.enabled) {
236 | 				res.status(403);
237 | 				res.send('Endpoint ID already in use');
238 | 				return;
239 | 			}
240 | 			this.logger.verb('/endpoint/:', id);
241 | 			// If we received a payload, make sure it's an SDP
242 | 			this.logger.debug(req.body);
243 | 			let offer = null;
244 | 			if(req.headers['content-type']) {
245 | 				if(req.headers['content-type'] !== 'application/sdp' || req.body.indexOf('v=0') < 0) {
246 | 					res.status(406);
247 | 					res.send('Unsupported content type');
248 | 					return;
249 | 				}
250 | 				offer = req.body;
251 | 			}
252 | 			// Check the Bearer token
253 | 			let auth = req.headers['authorization'];
254 | 			if(endpoint.token) {
255 | 				if(!auth || auth.indexOf('Bearer ') < 0) {
256 | 					res.status(403);
257 | 					res.send('Unauthorized');
258 | 					return;
259 | 				}
260 | 				let authtoken = auth.split('Bearer ')[1];
261 | 				if(typeof endpoint.token === 'function') {
262 | 					if(!endpoint.token(authtoken)) {
263 | 						res.status(403);
264 | 						res.send('Unauthorized');
265 | 						return;
266 | 					}
267 | 				} else if(!authtoken || authtoken.length === 0 || authtoken !== endpoint.token) {
268 | 					res.status(403);
269 | 					res.send('Unauthorized');
270 | 					return;
271 | 				}
272 | 			}
273 | 			// Make sure Janus is up and running
274 | 			if(!this.janus) {
275 | 				res.status(503);
276 | 				res.send('Janus unavailable');
277 | 				return;
278 | 			}
279 | 			let uuid = this.generateRandomString(16);
280 | 			let subscriber = {
281 | 				uuid: uuid,
282 | 				whepId: id
283 | 			};
284 | 			this.subscribers.set(uuid, subscriber);
285 | 			// Create a new session
286 | 			this.logger.info('[' + id + '] Subscribing to WHEP endpoint');
287 | 			subscriber.enabling = true;
288 | 			try {
289 | 				// Connect to the Streaming plugin
290 | 				subscriber.handle = await this.janus.attach(StreamingPlugin);
291 | 				subscriber.handle.on(Janode.EVENT.HANDLE_DETACHED, () => {
292 | 					// Janus notified us the session is gone, tear it down
293 | 					let subscriber = this.subscribers.get(uuid);
294 | 					if(subscriber) {
295 | 						this.logger.info('[' + id + '][' + uuid + '] Handle detached');
296 | 						let endpoint = this.endpoints.get(subscriber.whepId);
297 | 						if(endpoint)
298 | 							endpoint.subscribers.delete(uuid);
299 | 						this.subscribers.delete(uuid);
300 | 					}
301 | 				});
302 | 				subscriber.handle.on(Janode.EVENT.HANDLE_HANGUP, async () => {
303 | 					// Janus notified us the session is gone, tear it down
304 | 					let subscriber = this.subscribers.get(uuid);
305 | 					if(subscriber) {
306 | 						this.logger.info('[' + id + '][' + uuid + '] PeerConnection closed');
307 | 						await subscriber.handle.detach().catch(_err => {});
308 | 						if(endpoint) {
309 | 							endpoint.subscribers.delete(uuid);
310 | 							endpoint.emit('subscriber-gone');
311 | 						}
312 | 						this.emit('subscriber-gone', id);
313 | 						this.subscribers.delete(uuid);
314 | 					}
315 | 				});
316 | 				let details = {
317 | 					id: endpoint.mountpoint,
318 | 					pin: endpoint.pin
319 | 				};
320 | 				if(offer) {
321 | 					// Client offer (we still support both modes)
322 | 					details.jsep = {
323 | 						type: 'offer',
324 | 						sdp: offer
325 | 					};
326 | 				}
327 | 				const result = await subscriber.handle.watch(details);
328 | 				subscriber.enabling = false;
329 | 				subscriber.enabled = true;
330 | 				endpoint.subscribers.set(uuid, true);
331 | 				subscriber.resource = this.config.rest.basePath + '/resource/' + uuid;
332 | 				subscriber.latestEtag = this.generateRandomString(16);
333 | 				if(offer) {
334 | 					subscriber.sdpOffer = offer;
335 | 					subscriber.ice = {
336 | 						ufrag: subscriber.sdpOffer.match(/a=ice-ufrag:(.*)\r\n/)[1],
337 | 						pwd: subscriber.sdpOffer.match(/a=ice-pwd:(.*)\r\n/)[1]
338 | 					};
339 | 				}
340 | 				// Done
341 | 				res.setHeader('Access-Control-Expose-Headers', 'Location, Link');
342 | 				res.setHeader('Accept-Patch', 'application/trickle-ice-sdpfrag');
343 | 				res.setHeader('Location', subscriber.resource);
344 | 				res.set('ETag', '"' + subscriber.latestEtag + '"');
345 | 				let iceServers = endpoint.iceServers ? endpoint.iceServers : this.config.iceServers;
346 | 				if(iceServers && iceServers.length > 0) {
347 | 					// Add a Link header for each static ICE server
348 | 					let links = [];
349 | 					for(let server of iceServers) {
350 | 						if(!server.uri || (server.uri.indexOf('stun:') !== 0 &&
351 | 								server.uri.indexOf('turn:') !== 0 &&
352 | 								server.uri.indexOf('turns:') !== 0))
353 | 							continue;
354 | 						let link = '<' + server.uri + '>; rel="ice-server"';
355 | 						if(server.username && server.credential) {
356 | 							link += ';';
357 | 							link += ' username="' + server.username + '";' +
358 | 								' credential="' + server.credential + '";' +
359 | 								' credential-type="password"';
360 | 						}
361 | 						links.push(link);
362 | 					}
363 | 					res.setHeader('Link', links);
364 | 				}
365 | 				res.writeHeader(201, { 'Content-Type': 'application/sdp' });
366 | 				res.write(result.jsep.sdp);
367 | 				res.end();
368 | 				endpoint.emit('new-subscriber');
369 | 				this.emit('new-subscriber', id);
370 | 			} catch(err) {
371 | 				this.logger.err('Error subscribing:', err);
372 | 				this.subscribers.delete(uuid);
373 | 				res.status(500);
374 | 				res.send(err.error);
375 | 			}
376 | 		});
377 | 
378 | 		// GET, HEAD and PUT on the endpoint must return a 405
379 | 		router.get('/endpoint/:id', (_req, res) => {
380 | 			res.sendStatus(405);
381 | 		});
382 | 		router.head('/endpoint/:id', (_req, res) => {
383 | 			res.sendStatus(405);
384 | 		});
385 | 		router.put('/endpoint/:id', (_req, res) => {
386 | 			res.sendStatus(405);
387 | 		});
388 | 
389 | 		// Patch can be used both for the SDP answer and to trickle a WHEP resource
390 | 		router.patch('/resource/:uuid', async (req, res) => {
391 | 			let uuid = req.params.uuid;
392 | 			let subscriber = this.subscribers.get(uuid);
393 | 			if(subscriber && subscriber.latestEtag)
394 | 				res.set('ETag', '"' + subscriber.latestEtag + '"');
395 | 			if(!uuid || !subscriber || !subscriber.handle) {
396 | 				res.status(404);
397 | 				res.send('Invalid resource ID');
398 | 				return;
399 | 			}
400 | 			let endpoint = this.endpoints.get(subscriber.whepId);
401 | 			if(!endpoint) {
402 | 				res.status(404);
403 | 				res.send('Invalid endpoint ID');
404 | 				return;
405 | 			}
406 | 			if(!this.janus) {
407 | 				res.status(503);
408 | 				res.send('Janus unavailable');
409 | 				return;
410 | 			}
411 | 			if(req.headers['content-type'] === 'application/sdp') {
412 | 				// We received an SDP answer from the client
413 | 				this.logger.verb('/resource[answer]/:', uuid);
414 | 				this.logger.debug(req.body);
415 | 				// Prepare the JSEP object
416 | 				await subscriber.handle.start({
417 | 					jsep: {
418 | 						type: 'answer',
419 | 						sdp: req.body
420 | 					}
421 | 				}).catch(err => {
422 | 					this.logger.err('Error finalizing subscription:', err);
423 | 					let endpoint = this.endpoints.get(subscriber.whepId);
424 | 					if(endpoint)
425 | 						endpoint.subscribers.delete(uuid);
426 | 					this.subscribers.delete(uuid);
427 | 					res.status(500);
428 | 					res.send(err.error);
429 | 				});
430 | 				this.logger.info('[' + uuid + '] Completed WHEP negotiation');
431 | 				res.sendStatus(204);
432 | 				return;
433 | 			}
434 | 			// If we got here, we're handling a trickle candidate
435 | 			this.logger.verb('/resource[trickle]/:', uuid);
436 | 			this.logger.debug(req.body);
437 | 			// Check the Bearer token
438 | 			let auth = req.headers['authorization'];
439 | 			if(endpoint.token) {
440 | 				if(!auth || auth.indexOf('Bearer ') < 0) {
441 | 					res.status(403);
442 | 					res.send('Unauthorized');
443 | 					return;
444 | 				}
445 | 				let authtoken = auth.split('Bearer ')[1];
446 | 				if(typeof endpoint.token === 'function') {
447 | 					if(!endpoint.token(authtoken)) {
448 | 						res.status(403);
449 | 						res.send('Unauthorized');
450 | 						return;
451 | 					}
452 | 				} else if(!authtoken || authtoken.length === 0 || authtoken !== endpoint.token) {
453 | 					res.status(403);
454 | 					res.send('Unauthorized');
455 | 					return;
456 | 				}
457 | 			}
458 | 			// Check the latest ETag
459 | 			if(req.headers['if-match'] !== '"*"' && req.headers['if-match'] !== ('"' + endpoint.latestEtag + '"')) {
460 | 				if(this.config.strictETags) {
461 | 					// Only return a failure if we're configured with strict ETag checking, ignore it otherwise
462 | 					res.status(412);
463 | 					res.send('Precondition Failed');
464 | 					return;
465 | 				}
466 | 			}
467 | 			// Make sure we received a trickle candidate
468 | 			if(req.headers['content-type'] !== 'application/trickle-ice-sdpfrag') {
469 | 				res.status(406);
470 | 				res.send('Unsupported content type');
471 | 				return;
472 | 			}
473 | 			// Parse the RFC 8840 payload
474 | 			let fragment = req.body;
475 | 			let lines = fragment.split(/\r?\n/);
476 | 			let iceUfrag = null, icePwd = null, restart = false;
477 | 			let candidates = [];
478 | 			for(let line of lines) {
479 | 				if(line.indexOf('a=ice-ufrag:') === 0) {
480 | 					iceUfrag = line.split('a=ice-ufrag:')[1];
481 | 				} else if(line.indexOf('a=ice-pwd:') === 0) {
482 | 					icePwd = line.split('a=ice-pwd:')[1];
483 | 				} else if(line.indexOf('a=candidate:') === 0) {
484 | 					let candidate = {
485 | 						sdpMLineIndex: 0,
486 | 						candidate: line.split('a=')[1]
487 | 					};
488 | 					candidates.push(candidate);
489 | 				} else if(line.indexOf('a=end-of-candidates') === 0) {
490 | 					// Signal there won't be any more candidates
491 | 					candidates.push({ completed: true });
492 | 				}
493 | 			}
494 | 			// Check if there's a restart involved
495 | 			if(iceUfrag && icePwd && subscriber.ice && (iceUfrag !== subscriber.ice.ufrag || icePwd !== subscriber.ice.pwd)) {
496 | 				// We need to restart
497 | 				restart = true;
498 | 			}
499 | 			// Do one more ETag check (make sure restarts have '*' as ETag, and only them)
500 | 			if(req.headers['if-match'] === '*' && this.config.strictETags) {
501 | 				// Only return a failure if we're configured with strict ETag checking, ignore it otherwise
502 | 				res.status(412);
503 | 				res.send('Precondition Failed');
504 | 				return;
505 | 			}
506 | 			try {
507 | 				if(!restart) {
508 | 					// Trickle the candidate(s)
509 | 					if(candidates.length > 0)
510 | 						await subscriber.handle.trickle(candidates);
511 | 					// We're done
512 | 					res.sendStatus(204);
513 | 					return;
514 | 				}
515 | 				// TODO Restarts not supported yet, throw an error
516 | 				throw new Error('Restarts not supported yet');
517 | 			} catch(err) {
518 | 				this.logger.err('Error patching:', err);
519 | 				res.status(500);
520 | 				res.send(err.error);
521 | 			}
522 | 		});
523 | 
524 | 		// Stop subscribing to a WHEP endpoint
525 | 		router.delete('/resource/:uuid', async (req, res) => {
526 | 			let uuid = req.params.uuid;
527 | 			let subscriber = this.subscribers.get(uuid);
528 | 			if(subscriber && subscriber.latestEtag)
529 | 				res.set('ETag', '"' + subscriber.latestEtag + '"');
530 | 			if(!uuid || !subscriber) {
531 | 				res.status(404);
532 | 				res.send('Invalid resource ID');
533 | 				return;
534 | 			}
535 | 			let endpoint = this.endpoints.get(subscriber.whepId);
536 | 			if(!endpoint) {
537 | 				res.status(404);
538 | 				res.send('Invalid endpoint ID');
539 | 				return;
540 | 			}
541 | 			// Check the Bearer token
542 | 			let auth = req.headers['authorization'];
543 | 			if(endpoint.token) {
544 | 				if(!auth || auth.indexOf('Bearer ') < 0) {
545 | 					res.status(403);
546 | 					res.send('Unauthorized');
547 | 					return;
548 | 				}
549 | 				let authtoken = auth.split('Bearer ')[1];
550 | 				if(typeof endpoint.token === 'function') {
551 | 					if(!endpoint.token(authtoken)) {
552 | 						res.status(403);
553 | 						res.send('Unauthorized');
554 | 						return;
555 | 					}
556 | 				} else if(!authtoken || authtoken.length === 0 || authtoken !== endpoint.token) {
557 | 					res.status(403);
558 | 					res.send('Unauthorized');
559 | 					return;
560 | 				}
561 | 			}
562 | 			this.logger.verb('/resource[delete]/:', uuid);
563 | 			// Get rid of the Janus subscriber
564 | 			if(this.janus && subscriber.handle)
565 | 				await subscriber.handle.detach().catch(_err => {});
566 | 			endpoint.subscribers.delete(uuid);
567 | 			this.subscribers.delete(uuid);
568 | 			this.logger.info('[' + uuid + '] Terminating WHEP session');
569 | 			endpoint.emit('subscriber-gone');
570 | 			this.emit('subscriber-gone', endpoint.id);
571 | 			// Done
572 | 			res.sendStatus(200);
573 | 		});
574 | 
575 | 		// GET, HEAD, POST and PUT on the resource must return a 405
576 | 		router.get('/resource/:id', (_req, res) => {
577 | 			res.sendStatus(405);
578 | 		});
579 | 		router.head('/resource/:id', (_req, res) => {
580 | 			res.sendStatus(405);
581 | 		});
582 | 		router.post('/resource/:id', (_req, res) => {
583 | 			res.sendStatus(405);
584 | 		});
585 | 		router.put('/resource/:id', (_req, res) => {
586 | 			res.sendStatus(405);
587 | 		});
588 | 
589 | 		// Setup CORS
590 | 		app.use(cors({ preflightContinue: true }));
591 | 
592 | 		// Initialize the REST API
593 | 		app.use(express.json());
594 | 		app.use(express.text({ type: 'application/sdp' }));
595 | 		app.use(express.text({ type: 'application/trickle-ice-sdpfrag' }));
596 | 		app.use(this.config.rest.basePath, router);
597 | 	}
598 | }
599 | 
600 | // WHEP endpoint class
601 | class JanusWhepEndpoint extends EventEmitter {
602 | 	constructor({ id, mountpoint, pin, label, token, iceServers }) {
603 | 		super();
604 | 		this.id = id;
605 | 		this.mountpoint = mountpoint;
606 | 		this.pin = pin;
607 | 		this.label = label;
608 | 		this.token = token;
609 | 		this.iceServers = iceServers;
610 | 		// Resources
611 | 		this.subscribers = new Map();
612 | 	}
613 | 
614 | 	countSubscribers() {
615 | 		return this.subscribers.size;
616 | 	}
617 | 
618 | 	listSubscribers() {
619 | 		let list = [];
620 | 		this.subscribers.forEach(function(_val, uuid) {
621 | 			list.push({ uuid: uuid });
622 | 		});
623 | 		return list;
624 | 
625 | 	}
626 | }
627 | 
628 | // Logger class
629 | class JanusWhepLogger {
630 | 	constructor({ prefix, level }) {
631 | 		this.prefix = prefix;
632 | 		this.debugLevel = level;
633 | 	}
634 | 
635 | 	err() {
636 | 		if(this.debugLevel < 0)
637 | 			return;
638 | 		let args = Array.prototype.slice.call(arguments);
639 | 		args.unshift(this.prefix + '[err]');
640 | 		console.log.apply(console, args);
641 | 	}
642 | 
643 | 	warn() {
644 | 		if(this.debugLevel < 1)
645 | 			return;
646 | 		let args = Array.prototype.slice.call(arguments);
647 | 		args.unshift(this.prefix + '[warn]');
648 | 		console.log.apply(console, args);
649 | 	}
650 | 
651 | 	info() {
652 | 		if(this.debugLevel < 2)
653 | 			return;
654 | 		let args = Array.prototype.slice.call(arguments);
655 | 		args.unshift(this.prefix + '[info]');
656 | 		console.log.apply(console, args);
657 | 	}
658 | 
659 | 	verb() {
660 | 		if(this.debugLevel < 3)
661 | 			return;
662 | 		let args = Array.prototype.slice.call(arguments);
663 | 		args.unshift(this.prefix + '[verb]');
664 | 		console.log.apply(console, args);
665 | 	}
666 | 
667 | 	debug() {
668 | 		if(this.debugLevel < 4)
669 | 			return;
670 | 		let args = Array.prototype.slice.call(arguments);
671 | 		args.unshift(this.prefix + '[debug]');
672 | 		console.log.apply(console, args);
673 | 	}
674 | }
675 | 
676 | // Exports
677 | export {
678 | 	JanusWhepServer,
679 | 	JanusWhepEndpoint
680 | };
681 | 


--------------------------------------------------------------------------------