Bumped version to 0.9.3

Fix OpenSSL recv loop quitting too early

.github/FUNDING.yml

@@ -1 +1,3 @@
+github: ['paullouisageneau']
 custom: ['https://paypal.me/paullouisageneau']
+

.github/workflows/build-gnutls.yml

@@ -16,7 +16,7 @@ jobs:
     - name: submodules
       run: git submodule update --init --recursive
     - name: cmake
-      run: cmake -B build -DUSE_GNUTLS=1
+      run: cmake -B build -DUSE_GNUTLS=1 -DWARNINGS_AS_ERRORS=1
     - name: make
       run: (cd build; make -j2)
     - name: test
@@ -30,7 +30,7 @@ jobs:
     - name: submodules
       run: git submodule update --init --recursive
     - name: cmake
-      run: cmake -B build -DUSE_GNUTLS=1
+      run: cmake -B build -DUSE_GNUTLS=1 -DWARNINGS_AS_ERRORS=1
     - name: make
       run: (cd build; make -j2)
     - name: test

.github/workflows/build-nice.yml

@@ -16,7 +16,7 @@ jobs:
     - name: submodules
       run: git submodule update --init --recursive
     - name: cmake
-      run: cmake -B build -DUSE_GNUTLS=1 -DUSE_NICE=1
+      run: cmake -B build -DUSE_GNUTLS=1 -DUSE_NICE=1 -DWARNINGS_AS_ERRORS=1
     - name: make
       run: (cd build; make -j2)
     - name: test

.github/workflows/build-openssl.yml

@@ -16,7 +16,7 @@ jobs:
     - name: submodules
       run: git submodule update --init --recursive
     - name: cmake
-      run: cmake -B build -DUSE_GNUTLS=0
+      run: cmake -B build -DUSE_GNUTLS=0 -DWARNINGS_AS_ERRORS=1
     - name: make
       run: (cd build; make -j2)
     - name: test
@@ -26,11 +26,11 @@ jobs:
     steps:
     - uses: actions/checkout@v2
     - name: install packages
-      run: brew reinstall openssl@1.1
+      run: HOMEBREW_NO_INSTALL_CLEANUP=1 brew reinstall openssl@1.1
     - name: submodules
       run: git submodule update --init --recursive
     - name: cmake
-      run: cmake -B build -DUSE_GNUTLS=0
+      run: cmake -B build -DUSE_GNUTLS=0 -WARNINGS_AS_ERRORS=1
       env:
         OPENSSL_ROOT_DIR: /usr/local/opt/openssl
         OPENSSL_LIBRARIES: /usr/local/opt/openssl/lib
@@ -48,7 +48,7 @@ jobs:
     - name: submodules
       run: git submodule update --init --recursive
     - name: cmake
-      run: cmake -B build -G "NMake Makefiles" -DUSE_GNUTLS=0
+      run: cmake -B build -G "NMake Makefiles" -DUSE_GNUTLS=0 -WARNINGS_AS_ERRORS=1
     - name: nmake
       run: |
         cd build

CMakeLists.txt

@@ -1,15 +1,16 @@
 cmake_minimum_required(VERSION 3.7)
 project(libdatachannel
 	DESCRIPTION "WebRTC Data Channels Library"
-	VERSION 0.7.1
+	VERSION 0.9.3
 	LANGUAGES CXX)
 
 # Options
 option(USE_GNUTLS "Use GnuTLS instead of OpenSSL" OFF)
 option(USE_NICE "Use libnice instead of libjuice" OFF)
-option(USE_SRTP "Enable SRTP for media support" OFF)
 option(NO_WEBSOCKET "Disable WebSocket support" OFF)
 option(NO_EXAMPLES "Disable examples" OFF)
+option(NO_TESTS "Disable tests build" OFF)
+option(WARNINGS_AS_ERRORS "Treat warnings as errors" OFF)
 
 if(USE_NICE)
 	option(USE_JUICE "Use libjuice" OFF)
@@ -47,12 +48,15 @@ set(LIBDATACHANNEL_SOURCES
 	${CMAKE_CURRENT_SOURCE_DIR}/src/icetransport.cpp
 	${CMAKE_CURRENT_SOURCE_DIR}/src/init.cpp
 	${CMAKE_CURRENT_SOURCE_DIR}/src/log.cpp
+	${CMAKE_CURRENT_SOURCE_DIR}/src/message.cpp
 	${CMAKE_CURRENT_SOURCE_DIR}/src/peerconnection.cpp
-	${CMAKE_CURRENT_SOURCE_DIR}/src/rtc.cpp
+	${CMAKE_CURRENT_SOURCE_DIR}/src/rtcp.cpp
 	${CMAKE_CURRENT_SOURCE_DIR}/src/sctptransport.cpp
-	${CMAKE_CURRENT_SOURCE_DIR}/src/tls.cpp
 	${CMAKE_CURRENT_SOURCE_DIR}/src/threadpool.cpp
+	${CMAKE_CURRENT_SOURCE_DIR}/src/tls.cpp
+	${CMAKE_CURRENT_SOURCE_DIR}/src/track.cpp
 	${CMAKE_CURRENT_SOURCE_DIR}/src/processor.cpp
+	${CMAKE_CURRENT_SOURCE_DIR}/src/capi.cpp
 )
 
 set(LIBDATACHANNEL_WEBSOCKET_SOURCES
@@ -71,6 +75,7 @@ set(LIBDATACHANNEL_HEADERS
 	${CMAKE_CURRENT_SOURCE_DIR}/include/rtc/configuration.hpp
 	${CMAKE_CURRENT_SOURCE_DIR}/include/rtc/datachannel.hpp
 	${CMAKE_CURRENT_SOURCE_DIR}/include/rtc/description.hpp
+	${CMAKE_CURRENT_SOURCE_DIR}/include/rtc/rtcp.hpp
 	${CMAKE_CURRENT_SOURCE_DIR}/include/rtc/include.hpp
 	${CMAKE_CURRENT_SOURCE_DIR}/include/rtc/init.hpp
 	${CMAKE_CURRENT_SOURCE_DIR}/include/rtc/log.hpp
@@ -80,13 +85,16 @@ set(LIBDATACHANNEL_HEADERS
 	${CMAKE_CURRENT_SOURCE_DIR}/include/rtc/reliability.hpp
 	${CMAKE_CURRENT_SOURCE_DIR}/include/rtc/rtc.h
 	${CMAKE_CURRENT_SOURCE_DIR}/include/rtc/rtc.hpp
+	${CMAKE_CURRENT_SOURCE_DIR}/include/rtc/track.hpp
 	${CMAKE_CURRENT_SOURCE_DIR}/include/rtc/websocket.hpp
 )
 
 set(TESTS_SOURCES
     ${CMAKE_CURRENT_SOURCE_DIR}/test/main.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/test/connectivity.cpp
-    ${CMAKE_CURRENT_SOURCE_DIR}/test/capi.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/test/track.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/test/capi_connectivity.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/test/capi_track.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/test/websocket.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/test/benchmark.cpp
 )
@@ -153,8 +161,8 @@ if(WIN32)
 	target_link_libraries(datachannel-static PRIVATE wsock32 ws2_32) # winsock2
 endif()
 
-if(USE_SRTP)
+find_package(SRTP)
-	find_package(SRTP REQUIRED)
+if(SRTP_FOUND)
 	if(NOT TARGET SRTP::SRTP)
 		add_library(SRTP::SRTP UNKNOWN IMPORTED)
 		set_target_properties(SRTP::SRTP PROPERTIES
@@ -162,11 +170,13 @@ if(USE_SRTP)
 			IMPORTED_LINK_INTERFACE_LANGUAGES C
 			IMPORTED_LOCATION ${SRTP_LIBRARIES})
 	endif()
+	message(STATUS "LibSRTP found, compiling with media transport")
 	target_compile_definitions(datachannel PUBLIC RTC_ENABLE_MEDIA=1)
 	target_compile_definitions(datachannel-static PUBLIC RTC_ENABLE_MEDIA=1)
 	target_link_libraries(datachannel PRIVATE SRTP::SRTP)
 	target_link_libraries(datachannel-static PRIVATE SRTP::SRTP)
 else()
+	message(STATUS "LibSRTP NOT found, compiling WITHOUT media transport")
 	target_compile_definitions(datachannel PUBLIC RTC_ENABLE_MEDIA=0)
 	target_compile_definitions(datachannel-static PUBLIC RTC_ENABLE_MEDIA=0)
 endif()
@@ -213,31 +223,48 @@ add_library(LibDataChannel::LibDataChannelStatic ALIAS datachannel-static)
 install(TARGETS datachannel LIBRARY DESTINATION lib)
 install(FILES ${LIBDATACHANNEL_HEADERS} DESTINATION include/rtc)
 
-# Tests
+if(NOT MSVC)
-add_executable(datachannel-tests ${TESTS_SOURCES})
+	target_compile_options(datachannel PRIVATE -Wall -Wextra)
-set_target_properties(datachannel-tests PROPERTIES
+	target_compile_options(datachannel-static PRIVATE -Wall -Wextra)
-	VERSION ${PROJECT_VERSION}
-	CXX_STANDARD 17)
-set_target_properties(datachannel-tests PROPERTIES OUTPUT_NAME tests)
-target_include_directories(datachannel-tests PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/src)
-if(WIN32)
-	target_link_libraries(datachannel-tests datachannel-static) # DLL exports only the C API
-else()
-	target_link_libraries(datachannel-tests datachannel)
 endif()
 
-# Benchmark
+if(WARNINGS_AS_ERRORS)
-add_executable(datachannel-benchmark test/benchmark.cpp)
+	if(MSVC)
-set_target_properties(datachannel-benchmark PROPERTIES
+		target_compile_options(datachannel PRIVATE /WX)
-	VERSION ${PROJECT_VERSION}
+		target_compile_options(datachannel-static PRIVATE /WX)
-	CXX_STANDARD 17)
+	else()
-set_target_properties(datachannel-benchmark PROPERTIES OUTPUT_NAME benchmark)
+		target_compile_options(datachannel PRIVATE -Werror)
-target_compile_definitions(datachannel-benchmark PRIVATE BENCHMARK_MAIN=1)
+		target_compile_options(datachannel-static PRIVATE -Werror)
-target_include_directories(datachannel-benchmark PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/src)
+	endif()
-if(WIN32)
+endif()
-	target_link_libraries(datachannel-benchmark datachannel-static) # DLL exports only the C API
+
-else()
+# Tests
-	target_link_libraries(datachannel-benchmark datachannel)
+if(NOT NO_TESTS)
+	add_executable(datachannel-tests ${TESTS_SOURCES})
+	set_target_properties(datachannel-tests PROPERTIES
+		VERSION ${PROJECT_VERSION}
+		CXX_STANDARD 17)
+	set_target_properties(datachannel-tests PROPERTIES OUTPUT_NAME tests)
+	target_include_directories(datachannel-tests PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/src)
+	if(WIN32)
+		target_link_libraries(datachannel-tests datachannel-static) # DLL exports only the C API
+	else()
+		target_link_libraries(datachannel-tests datachannel)
+	endif()
+
+	# Benchmark
+	add_executable(datachannel-benchmark test/benchmark.cpp)
+	set_target_properties(datachannel-benchmark PROPERTIES
+		VERSION ${PROJECT_VERSION}
+		CXX_STANDARD 17)
+	set_target_properties(datachannel-benchmark PROPERTIES OUTPUT_NAME benchmark)
+	target_compile_definitions(datachannel-benchmark PRIVATE BENCHMARK_MAIN=1)
+	target_include_directories(datachannel-benchmark PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/src)
+	if(WIN32)
+		target_link_libraries(datachannel-benchmark datachannel-static) # DLL exports only the C API
+	else()
+		target_link_libraries(datachannel-benchmark datachannel)
+	endif()
 endif()
 
 # Examples
@@ -245,6 +272,7 @@ if(NOT NO_EXAMPLES)
 	set(JSON_BuildTests OFF CACHE INTERNAL "")
 	add_subdirectory(deps/json)
 	add_subdirectory(examples/client)
+	add_subdirectory(examples/media)
 	add_subdirectory(examples/copy-paste)
 	add_subdirectory(examples/copy-paste-capi)
 endif()

README.md

@@ -1,6 +1,6 @@
 # libdatachannel - C/C++ WebRTC Data Channels
 
-libdatachannel is a standalone implementation of WebRTC Data Channels and WebSockets in C++17 with C bindings for POSIX platforms (including Linux and Apple macOS) and Microsoft Windows. It enables direct connectivity between native applications and web browsers without the pain of importing the entire WebRTC stack. The interface consists of simplified versions of the JavaScript WebRTC and WebSocket APIs present in browsers, in order to ease the design of cross-environment applications.
+libdatachannel is a standalone implementation of WebRTC Data Channels, WebRTC Media Transport, and WebSockets in C++17 with C bindings for POSIX platforms (including GNU/Linux, Android, and Apple macOS) and Microsoft Windows. It enables direct connectivity between native applications and web browsers without the pain of importing the entire WebRTC stack. The interface consists of simplified versions of the JavaScript WebRTC and WebSocket APIs present in browsers, in order to ease the design of cross-environment applications.
 It can be compiled with multiple backends:
 - The security layer can be provided through [OpenSSL](https://www.openssl.org/) or [GnuTLS](https://www.gnutls.org/).
 - The connectivity for WebRTC can be provided through my ad-hoc ICE library [libjuice](https://github.com/paullouisageneau/libjuice) as submodule or through [libnice](https://github.com/libnice/libnice).
@@ -13,12 +13,13 @@ Licensed under LGPLv2, see [LICENSE](https://github.com/paullouisageneau/libdata
 
 The library aims at implementing the following communication protocols:
 
-### WebRTC Data Channel
+### WebRTC Data Channels and Media Transport
 
 The WebRTC stack has been tested to be compatible with Firefox and Chromium.
 
 Protocol stack:
 - SCTP-based Data Channels ([draft-ietf-rtcweb-data-channel-13](https://tools.ietf.org/html/draft-ietf-rtcweb-data-channel-13))
+- SRTP-based Media Transport ([draft-ietf-rtcweb-rtp-usage-26](https://tools.ietf.org/html/draft-ietf-rtcweb-rtp-usage-26)) with [libSRTP](https://github.com/cisco/libsrtp)
 - DTLS/UDP ([RFC7350](https://tools.ietf.org/html/rfc7350) and [RFC8261](https://tools.ietf.org/html/rfc8261))
 - ICE ([RFC8445](https://tools.ietf.org/html/rfc8445)) with STUN ([RFC5389](https://tools.ietf.org/html/rfc5389))
 
@@ -26,9 +27,11 @@ Features:
 - Full IPv6 support
 - Trickle ICE ([draft-ietf-ice-trickle-21](https://tools.ietf.org/html/draft-ietf-ice-trickle-21))
 - JSEP compatible ([draft-ietf-rtcweb-jsep-26](https://tools.ietf.org/html/draft-ietf-rtcweb-jsep-26))
+- SRTP and SRTCP key derivation from DTLS ([RFC5764](https://tools.ietf.org/html/rfc5764))
 - Multicast DNS candidates ([draft-ietf-rtcweb-mdns-ice-candidates-04](https://tools.ietf.org/html/draft-ietf-rtcweb-mdns-ice-candidates-04))
 - TURN relaying ([RFC5766](https://tools.ietf.org/html/rfc5766)) with [libnice](https://github.com/libnice/libnice) as ICE backend
-- SRTP media transport ([RFC3711](https://tools.ietf.org/html/rfc3711)) with [libSRTP](https://github.com/cisco/libsrtp)
+
+Note only SDP BUNDLE mode is supported for media multiplexing ([draft-ietf-mmusic-sdp-bundle-negotiation-54](https://tools.ietf.org/html/draft-ietf-mmusic-sdp-bundle-negotiation-54)). The behavior is equivalent to the JSEP bundle-only policy: the library always negociates one unique network component, where SRTP media streams are multiplexed with SRTCP control packets ([RFC5761](https://tools.ietf.org/html/rfc5761)) and SCTP/DTLS data traffic ([RFC5764](https://tools.ietf.org/html/rfc5764)).
 
 ### WebSocket
 
@@ -104,7 +107,7 @@ $ make USE_GNUTLS=1 USE_NICE=0
 
 See [examples](https://github.com/paullouisageneau/libdatachannel/blob/master/examples/) for a complete usage example with signaling server (under GPLv2).
 
-Additionnaly, you might want to have a look at the [C API](https://github.com/paullouisageneau/libdatachannel/blob/dev/include/rtc/rtc.h).
+Additionnaly, you might want to have a look at the [C API](https://github.com/paullouisageneau/libdatachannel/blob/master/include/rtc/rtc.h).
 
 ### Signal a PeerConnection
 
@@ -118,12 +121,12 @@ config.iceServers.emplace_back("mystunserver.org:3478");
 
 auto pc = make_shared<rtc::PeerConnection>(config);
 
-pc->onLocalDescription([](const rtc::Description &sdp) {
+pc->onLocalDescription([](rtc::Description sdp) {
     // Send the SDP to the remote peer
     MY_SEND_DESCRIPTION_TO_REMOTE(string(sdp));
 });
 
-pc->onLocalCandidate([](const rtc::Candidate &candidate) {
+pc->onLocalCandidate([](rtc::Candidate candidate) {
     // Send the candidate to the remote peer
     MY_SEND_CANDIDATE_TO_REMOTE(candidate.candidate(), candidate.mid());
 });
@@ -159,7 +162,7 @@ dc->onOpen([]() {
     cout << "Open" << endl;
 });
 
-dc->onMessage([](const variant<binary, string> &message) {
+dc->onMessage([](variant<binary, string> message) {
     if (holds_alternative<string>(message)) {
         cout << "Received: " << get<string>(message) << endl;
     }
@@ -186,7 +189,7 @@ ws->onOpen([]() {
 	cout << "WebSocket open" << endl;
 });
 
-ws->onMessage([](const variant<binary, string> &message) {
+ws->onMessage([](variant<binary, string> message) {
     if (holds_alternative<string>(message)) {
         cout << "WebSocket received: " << get<string>(message) << endl;
     }
@@ -197,6 +200,7 @@ ws->open("wss://my.websocket/service");
 ```
 
 ## External resources
-- Rust wrappers for libdatachannel: [datachannel-rs](https://github.com/lerouxrgd/datachannel-rs)
+- Rust wrapper for libdatachannel: [datachannel-rs](https://github.com/lerouxrgd/datachannel-rs)
-- WebAssembly wrappers compatible with libdatachannel: [datachannel-wasm](https://github.com/paullouisageneau/datachannel-wasm)
+- Node.js wrapper for libdatachannel: [node-datachannel](https://github.com/murat-dogan/node-datachannel)
+- WebAssembly wrapper compatible with libdatachannel: [datachannel-wasm](https://github.com/paullouisageneau/datachannel-wasm)
 

examples/README.md

@@ -7,6 +7,8 @@ This directory contains different WebRTC clients and compatible WebSocket + JSON
 - [signaling-server-python](signaling-server-python) contains a similar signaling server in Python
 - [signaling-server-rust](signaling-server-rust) contains a similar signaling server in Rust (see [lerouxrgd/datachannel-rs](https://github.com/lerouxrgd/datachannel-rs) for Rust wrappers)
 
+- [media](media) is a copy/paste demo to send the webcam from your browser into gstreamer.
+
 Additionally, it contains two debugging tools for libdatachannel with copy-pasting as signaling:
 - [copy-paste](copy-paste) using the C++ API
 - [copy-paste-capi](copy-paste-capi) using the C API

examples/client/CMakeLists.txt

@@ -3,7 +3,12 @@ if(POLICY CMP0079)
 	cmake_policy(SET CMP0079 NEW)
 endif()
 
-add_executable(datachannel-client main.cpp)
+if(WIN32)
+add_executable(datachannel-client main.cpp parse_cl.cpp parse_cl.h getopt.cpp getopt.h)
+target_compile_definitions(datachannel-client PUBLIC STATIC_GETOPT)
+else()
+add_executable(datachannel-client main.cpp parse_cl.cpp parse_cl.h)
+endif()
 set_target_properties(datachannel-client PROPERTIES
 	CXX_STANDARD 17
 	OUTPUT_NAME client)

examples/client/getopt.cpp

@@ -0,0 +1,973 @@
+/* Getopt for Microsoft C
+This code is a modification of the Free Software Foundation, Inc.
+Getopt library for parsing command line argument the purpose was
+to provide a Microsoft Visual C friendly derivative. This code
+provides functionality for both Unicode and Multibyte builds.
+
+Date: 02/03/2011 - Ludvik Jerabek - Initial Release
+Version: 1.0
+Comment: Supports getopt, getopt_long, and getopt_long_only
+and POSIXLY_CORRECT environment flag
+License: LGPL
+
+Revisions:
+
+02/03/2011 - Ludvik Jerabek - Initial Release
+02/20/2011 - Ludvik Jerabek - Fixed compiler warnings at Level 4
+07/05/2011 - Ludvik Jerabek - Added no_argument, required_argument, optional_argument defs
+08/03/2011 - Ludvik Jerabek - Fixed non-argument runtime bug which caused runtime exception
+08/09/2011 - Ludvik Jerabek - Added code to export functions for DLL and LIB
+02/15/2012 - Ludvik Jerabek - Fixed _GETOPT_THROW definition missing in implementation file
+08/01/2012 - Ludvik Jerabek - Created separate functions for char and wchar_t characters so single dll can do both unicode and ansi
+10/15/2012 - Ludvik Jerabek - Modified to match latest GNU features
+06/19/2015 - Ludvik Jerabek - Fixed maximum option limitation caused by option_a (255) and option_w (65535) structure val variable
+
+**DISCLAIMER**
+THIS MATERIAL IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND,
+EITHER EXPRESS OR IMPLIED, INCLUDING, BUT Not LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
+PURPOSE, OR NON-INFRINGEMENT. SOME JURISDICTIONS DO NOT ALLOW THE
+EXCLUSION OF IMPLIED WARRANTIES, SO THE ABOVE EXCLUSION MAY NOT
+APPLY TO YOU. IN NO EVENT WILL I BE LIABLE TO ANY PARTY FOR ANY
+DIRECT, INDIRECT, SPECIAL OR OTHER CONSEQUENTIAL DAMAGES FOR ANY
+USE OF THIS MATERIAL INCLUDING, WITHOUT LIMITATION, ANY LOST
+PROFITS, BUSINESS INTERRUPTION, LOSS OF PROGRAMS OR OTHER DATA ON
+YOUR INFORMATION HANDLING SYSTEM OR OTHERWISE, EVEN If WE ARE
+EXPRESSLY ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+*/
+#define _CRT_SECURE_NO_WARNINGS
+#include <stdlib.h>
+#include <stdio.h>
+#include <malloc.h>
+#include "getopt.h"
+
+#ifdef __cplusplus
+	#define _GETOPT_THROW throw()
+#else
+	#define _GETOPT_THROW
+#endif
+
+int optind = 1;
+int opterr = 1;
+int optopt = '?';
+enum ENUM_ORDERING { REQUIRE_ORDER, PERMUTE, RETURN_IN_ORDER };
+
+//
+//
+//		Ansi structures and functions follow
+// 
+//
+
+static struct _getopt_data_a
+{
+	int optind;
+	int opterr;
+	int optopt;
+	char *optarg;
+	int __initialized;
+	char *__nextchar;
+	enum ENUM_ORDERING __ordering;
+	int __posixly_correct;
+	int __first_nonopt;
+	int __last_nonopt;
+} getopt_data_a;
+char *optarg_a;
+
+static void exchange_a(char **argv, struct _getopt_data_a *d)
+{
+	int bottom = d->__first_nonopt;
+	int middle = d->__last_nonopt;
+	int top = d->optind;
+	char *tem;
+	while (top > middle && middle > bottom)
+	{
+		if (top - middle > middle - bottom)
+		{
+			int len = middle - bottom;
+			int i;
+			for (i = 0; i < len; i++)
+			{
+				tem = argv[bottom + i];
+				argv[bottom + i] = argv[top - (middle - bottom) + i];
+				argv[top - (middle - bottom) + i] = tem;
+			}
+			top -= len;
+		}
+		else
+		{
+			int len = top - middle;
+			int i;
+			for (i = 0; i < len; i++)
+			{
+				tem = argv[bottom + i];
+				argv[bottom + i] = argv[middle + i];
+				argv[middle + i] = tem;
+			}
+			bottom += len;
+		}
+	}
+	d->__first_nonopt += (d->optind - d->__last_nonopt);
+	d->__last_nonopt = d->optind;
+}
+static const char *_getopt_initialize_a (const char *optstring, struct _getopt_data_a *d, int posixly_correct)
+{
+	d->__first_nonopt = d->__last_nonopt = d->optind;
+	d->__nextchar = NULL;
+	d->__posixly_correct = posixly_correct | !!getenv("POSIXLY_CORRECT");
+	if (optstring[0] == '-')
+	{
+		d->__ordering = RETURN_IN_ORDER;
+		++optstring;
+	}
+	else if (optstring[0] == '+')
+	{
+		d->__ordering = REQUIRE_ORDER;
+		++optstring;
+	}
+	else if (d->__posixly_correct)
+		d->__ordering = REQUIRE_ORDER;
+	else
+		d->__ordering = PERMUTE;
+	return optstring;
+}
+int _getopt_internal_r_a (int argc, char *const *argv, const char *optstring, const struct option_a *longopts, int *longind, int long_only, struct _getopt_data_a *d, int posixly_correct)
+{
+	int print_errors = d->opterr;
+	if (argc < 1)
+		return -1;
+	d->optarg = NULL;
+	if (d->optind == 0 || !d->__initialized)
+	{
+		if (d->optind == 0)
+			d->optind = 1;
+		optstring = _getopt_initialize_a (optstring, d, posixly_correct);
+		d->__initialized = 1;
+	}
+	else if (optstring[0] == '-' || optstring[0] == '+')
+		optstring++;
+	if (optstring[0] == ':')
+		print_errors = 0;
+	if (d->__nextchar == NULL || *d->__nextchar == '\0')
+	{
+		if (d->__last_nonopt > d->optind)
+			d->__last_nonopt = d->optind;
+		if (d->__first_nonopt > d->optind)
+			d->__first_nonopt = d->optind;
+		if (d->__ordering == PERMUTE)
+		{
+			if (d->__first_nonopt != d->__last_nonopt && d->__last_nonopt != d->optind)
+				exchange_a ((char **) argv, d);
+			else if (d->__last_nonopt != d->optind)
+				d->__first_nonopt = d->optind;
+			while (d->optind < argc && (argv[d->optind][0] != '-' || argv[d->optind][1] == '\0'))
+				d->optind++;
+			d->__last_nonopt = d->optind;
+		}
+		if (d->optind != argc && !strcmp(argv[d->optind], "--"))
+		{
+			d->optind++;
+			if (d->__first_nonopt != d->__last_nonopt && d->__last_nonopt != d->optind)
+				exchange_a((char **) argv, d);
+			else if (d->__first_nonopt == d->__last_nonopt)
+				d->__first_nonopt = d->optind;
+			d->__last_nonopt = argc;
+			d->optind = argc;
+		}
+		if (d->optind == argc)
+		{
+			if (d->__first_nonopt != d->__last_nonopt)
+				d->optind = d->__first_nonopt;
+			return -1;
+		}
+		if ((argv[d->optind][0] != '-' || argv[d->optind][1] == '\0'))
+		{
+			if (d->__ordering == REQUIRE_ORDER)
+				return -1;
+			d->optarg = argv[d->optind++];
+			return 1;
+		}
+		d->__nextchar = (argv[d->optind] + 1 + (longopts != NULL && argv[d->optind][1] == '-'));
+	}
+	if (longopts != NULL && (argv[d->optind][1] == '-' || (long_only && (argv[d->optind][2] || !strchr(optstring, argv[d->optind][1])))))
+	{
+		char *nameend;
+		unsigned int namelen;
+		const struct option_a *p;
+		const struct option_a *pfound = NULL;
+		struct option_list
+		{
+			const struct option_a *p;
+			struct option_list *next;
+		} *ambig_list = NULL;
+		int exact = 0;
+		int indfound = -1;
+		int option_index;
+		for (nameend = d->__nextchar; *nameend && *nameend != '='; nameend++);
+		namelen = (unsigned int)(nameend - d->__nextchar);
+		for (p = longopts, option_index = 0; p->name; p++, option_index++)
+			if (!strncmp(p->name, d->__nextchar, namelen))
+			{
+				if (namelen == (unsigned int)strlen(p->name))
+				{
+					pfound = p;
+					indfound = option_index;
+					exact = 1;
+					break;
+				}
+				else if (pfound == NULL)
+				{
+					pfound = p;
+					indfound = option_index;
+				}
+				else if (long_only || pfound->has_arg != p->has_arg || pfound->flag != p->flag || pfound->val != p->val)
+				{
+					struct option_list *newp = (struct option_list*)alloca(sizeof(*newp));
+					newp->p = p;
+					newp->next = ambig_list;
+					ambig_list = newp;
+				}
+			}
+			if (ambig_list != NULL && !exact)
+			{
+				if (print_errors)
+				{
+					struct option_list first;
+					first.p = pfound;
+					first.next = ambig_list;
+					ambig_list = &first;
+					fprintf (stderr, "%s: option '%s' is ambiguous; possibilities:", argv[0], argv[d->optind]);
+					do
+					{
+						fprintf (stderr, " '--%s'", ambig_list->p->name);
+						ambig_list = ambig_list->next;
+					}
+					while (ambig_list != NULL);
+					fputc ('\n', stderr);
+				}
+				d->__nextchar += strlen(d->__nextchar);
+				d->optind++;
+				d->optopt = 0;
+				return '?';
+			}
+			if (pfound != NULL)
+			{
+				option_index = indfound;
+				d->optind++;
+				if (*nameend)
+				{
+					if (pfound->has_arg)
+						d->optarg = nameend + 1;
+					else
+					{
+						if (print_errors)
+						{
+							if (argv[d->optind - 1][1] == '-')
+							{
+								fprintf(stderr, "%s: option '--%s' doesn't allow an argument\n",argv[0], pfound->name);
+							}
+							else
+							{
+								fprintf(stderr, "%s: option '%c%s' doesn't allow an argument\n",argv[0], argv[d->optind - 1][0],pfound->name);
+							}
+						}
+						d->__nextchar += strlen(d->__nextchar);
+						d->optopt = pfound->val;
+						return '?';
+					}
+				}
+				else if (pfound->has_arg == 1)
+				{
+					if (d->optind < argc)
+						d->optarg = argv[d->optind++];
+					else
+					{
+						if (print_errors)
+						{
+							fprintf(stderr,"%s: option '--%s' requires an argument\n",argv[0], pfound->name);
+						}
+						d->__nextchar += strlen(d->__nextchar);
+						d->optopt = pfound->val;
+						return optstring[0] == ':' ? ':' : '?';
+					}
+				}
+				d->__nextchar += strlen(d->__nextchar);
+				if (longind != NULL)
+					*longind = option_index;
+				if (pfound->flag)
+				{
+					*(pfound->flag) = pfound->val;
+					return 0;
+				}
+				return pfound->val;
+			}
+			if (!long_only || argv[d->optind][1] == '-' || strchr(optstring, *d->__nextchar) == NULL)
+			{
+				if (print_errors)
+				{
+					if (argv[d->optind][1] == '-')
+					{
+						fprintf(stderr, "%s: unrecognized option '--%s'\n",argv[0], d->__nextchar);
+					}
+					else
+					{
+						fprintf(stderr, "%s: unrecognized option '%c%s'\n",argv[0], argv[d->optind][0], d->__nextchar);
+					}
+				}
+				d->__nextchar = (char *)"";
+				d->optind++;
+				d->optopt = 0;
+				return '?';
+			}
+	}
+	{
+		char c = *d->__nextchar++;
+		char *temp = (char*)strchr(optstring, c);
+		if (*d->__nextchar == '\0')
+			++d->optind;
+		if (temp == NULL || c == ':' || c == ';')
+		{
+			if (print_errors)
+			{
+				fprintf(stderr, "%s: invalid option -- '%c'\n", argv[0], c);
+			}
+			d->optopt = c;
+			return '?';
+		}
+		if (temp[0] == 'W' && temp[1] == ';')
+		{
+			char *nameend;
+			const struct option_a *p;
+			const struct option_a *pfound = NULL;
+			int exact = 0;
+			int ambig = 0;
+			int indfound = 0;
+			int option_index;
+			if (longopts == NULL)
+				goto no_longs;
+			if (*d->__nextchar != '\0')
+			{
+				d->optarg = d->__nextchar;
+				d->optind++;
+			}
+			else if (d->optind == argc)
+			{
+				if (print_errors)
+				{
+					fprintf(stderr,"%s: option requires an argument -- '%c'\n",argv[0], c);
+				}
+				d->optopt = c;
+				if (optstring[0] == ':')
+					c = ':';
+				else
+					c = '?';
+				return c;
+			}
+			else
+				d->optarg = argv[d->optind++];
+			for (d->__nextchar = nameend = d->optarg; *nameend && *nameend != '='; nameend++);
+			for (p = longopts, option_index = 0; p->name; p++, option_index++)
+				if (!strncmp(p->name, d->__nextchar, nameend - d->__nextchar))
+				{
+					if ((unsigned int) (nameend - d->__nextchar) == strlen(p->name))
+					{
+						pfound = p;
+						indfound = option_index;
+						exact = 1;
+						break;
+					}
+					else if (pfound == NULL)
+					{
+						pfound = p;
+						indfound = option_index;
+					}
+					else if (long_only || pfound->has_arg != p->has_arg || pfound->flag != p->flag || pfound->val != p->val)
+						ambig = 1;
+				}
+				if (ambig && !exact)
+				{
+					if (print_errors)
+					{
+						fprintf(stderr, "%s: option '-W %s' is ambiguous\n",argv[0], d->optarg);
+					}
+					d->__nextchar += strlen(d->__nextchar);
+					d->optind++;
+					return '?';
+				}
+				if (pfound != NULL)
+				{
+					option_index = indfound;
+					if (*nameend)
+					{
+						if (pfound->has_arg)
+							d->optarg = nameend + 1;
+						else
+						{
+							if (print_errors)
+							{
+								fprintf(stderr, "%s: option '-W %s' doesn't allow an argument\n",argv[0], pfound->name);
+							}
+							d->__nextchar += strlen(d->__nextchar);
+							return '?';
+						}
+					}
+					else if (pfound->has_arg == 1)
+					{
+						if (d->optind < argc)
+							d->optarg = argv[d->optind++];
+						else
+						{
+							if (print_errors)
+							{
+								fprintf(stderr, "%s: option '-W %s' requires an argument\n",argv[0], pfound->name);
+							}
+							d->__nextchar += strlen(d->__nextchar);
+							return optstring[0] == ':' ? ':' : '?';
+						}
+					}
+					else
+						d->optarg = NULL;
+					d->__nextchar += strlen(d->__nextchar);
+					if (longind != NULL)
+						*longind = option_index;
+					if (pfound->flag)
+					{
+						*(pfound->flag) = pfound->val;
+						return 0;
+					}
+					return pfound->val;
+				}
+no_longs:
+				d->__nextchar = NULL;
+				return 'W';
+		}
+		if (temp[1] == ':')
+		{
+			if (temp[2] == ':')
+			{
+				if (*d->__nextchar != '\0')
+				{
+					d->optarg = d->__nextchar;
+					d->optind++;
+				}
+				else
+					d->optarg = NULL;
+				d->__nextchar = NULL;
+			}
+			else
+			{
+				if (*d->__nextchar != '\0')
+				{
+					d->optarg = d->__nextchar;
+					d->optind++;
+				}
+				else if (d->optind == argc)
+				{
+					if (print_errors)
+					{
+						fprintf(stderr,"%s: option requires an argument -- '%c'\n",argv[0], c);
+					}
+					d->optopt = c;
+					if (optstring[0] == ':')
+						c = ':';
+					else
+						c = '?';
+				}
+				else
+					d->optarg = argv[d->optind++];
+				d->__nextchar = NULL;
+			}
+		}
+		return c;
+	}
+}
+int _getopt_internal_a (int argc, char *const *argv, const char *optstring, const struct option_a *longopts, int *longind, int long_only, int posixly_correct)
+{
+	int result;
+	getopt_data_a.optind = optind;
+	getopt_data_a.opterr = opterr;
+	result = _getopt_internal_r_a (argc, argv, optstring, longopts,longind, long_only, &getopt_data_a,posixly_correct);
+	optind = getopt_data_a.optind;
+	optarg_a = getopt_data_a.optarg;
+	optopt = getopt_data_a.optopt;
+	return result;
+}
+int getopt_a (int argc, char *const *argv, const char *optstring) _GETOPT_THROW
+{
+	return _getopt_internal_a (argc, argv, optstring, (const struct option_a *) 0, (int *) 0, 0, 0);
+}
+int getopt_long_a (int argc, char *const *argv, const char *options, const struct option_a *long_options, int *opt_index) _GETOPT_THROW
+{
+	return _getopt_internal_a (argc, argv, options, long_options, opt_index, 0, 0);
+}
+int getopt_long_only_a (int argc, char *const *argv, const char *options, const struct option_a *long_options, int *opt_index) _GETOPT_THROW
+{
+	return _getopt_internal_a (argc, argv, options, long_options, opt_index, 1, 0);
+}
+int _getopt_long_r_a (int argc, char *const *argv, const char *options, const struct option_a *long_options, int *opt_index, struct _getopt_data_a *d)
+{
+	return _getopt_internal_r_a (argc, argv, options, long_options, opt_index,0, d, 0);
+}
+int _getopt_long_only_r_a (int argc, char *const *argv, const char *options, const struct option_a *long_options, int *opt_index, struct _getopt_data_a *d)
+{
+	return _getopt_internal_r_a (argc, argv, options, long_options, opt_index, 1, d, 0);
+}
+
+//
+//
+//	Unicode Structures and Functions
+// 
+//
+
+static struct _getopt_data_w
+{
+	int optind;
+	int opterr;
+	int optopt;
+	wchar_t *optarg;
+	int __initialized;
+	wchar_t *__nextchar;
+	enum ENUM_ORDERING __ordering;
+	int __posixly_correct;
+	int __first_nonopt;
+	int __last_nonopt;
+} getopt_data_w;
+wchar_t *optarg_w;
+
+static void exchange_w(wchar_t **argv, struct _getopt_data_w *d)
+{
+	int bottom = d->__first_nonopt;
+	int middle = d->__last_nonopt;
+	int top = d->optind;
+	wchar_t *tem;
+	while (top > middle && middle > bottom)
+	{
+		if (top - middle > middle - bottom)
+		{
+			int len = middle - bottom;
+			int i;
+			for (i = 0; i < len; i++)
+			{
+				tem = argv[bottom + i];
+				argv[bottom + i] = argv[top - (middle - bottom) + i];
+				argv[top - (middle - bottom) + i] = tem;
+			}
+			top -= len;
+		}
+		else
+		{
+			int len = top - middle;
+			int i;
+			for (i = 0; i < len; i++)
+			{
+				tem = argv[bottom + i];
+				argv[bottom + i] = argv[middle + i];
+				argv[middle + i] = tem;
+			}
+			bottom += len;
+		}
+	}
+	d->__first_nonopt += (d->optind - d->__last_nonopt);
+	d->__last_nonopt = d->optind;
+}
+static const wchar_t *_getopt_initialize_w (const wchar_t *optstring, struct _getopt_data_w *d, int posixly_correct)
+{
+	d->__first_nonopt = d->__last_nonopt = d->optind;
+	d->__nextchar = NULL;
+	d->__posixly_correct = posixly_correct | !!_wgetenv(L"POSIXLY_CORRECT");
+	if (optstring[0] == L'-')
+	{
+		d->__ordering = RETURN_IN_ORDER;
+		++optstring;
+	}
+	else if (optstring[0] == L'+')
+	{
+		d->__ordering = REQUIRE_ORDER;
+		++optstring;
+	}
+	else if (d->__posixly_correct)
+		d->__ordering = REQUIRE_ORDER;
+	else
+		d->__ordering = PERMUTE;
+	return optstring;
+}
+int _getopt_internal_r_w (int argc, wchar_t *const *argv, const wchar_t *optstring, const struct option_w *longopts, int *longind, int long_only, struct _getopt_data_w *d, int posixly_correct)
+{
+	int print_errors = d->opterr;
+	if (argc < 1)
+		return -1;
+	d->optarg = NULL;
+	if (d->optind == 0 || !d->__initialized)
+	{
+		if (d->optind == 0)
+			d->optind = 1;
+		optstring = _getopt_initialize_w (optstring, d, posixly_correct);
+		d->__initialized = 1;
+	}
+	else if (optstring[0] == L'-' || optstring[0] == L'+')
+		optstring++;
+	if (optstring[0] == L':')
+		print_errors = 0;
+	if (d->__nextchar == NULL || *d->__nextchar == L'\0')
+	{
+		if (d->__last_nonopt > d->optind)
+			d->__last_nonopt = d->optind;
+		if (d->__first_nonopt > d->optind)
+			d->__first_nonopt = d->optind;
+		if (d->__ordering == PERMUTE)
+		{
+			if (d->__first_nonopt != d->__last_nonopt && d->__last_nonopt != d->optind)
+				exchange_w((wchar_t **) argv, d);
+			else if (d->__last_nonopt != d->optind)
+				d->__first_nonopt = d->optind;
+			while (d->optind < argc && (argv[d->optind][0] != L'-' || argv[d->optind][1] == L'\0'))
+				d->optind++;
+			d->__last_nonopt = d->optind;
+		}
+		if (d->optind != argc && !wcscmp(argv[d->optind], L"--"))
+		{
+			d->optind++;
+			if (d->__first_nonopt != d->__last_nonopt && d->__last_nonopt != d->optind)
+				exchange_w((wchar_t **) argv, d);
+			else if (d->__first_nonopt == d->__last_nonopt)
+				d->__first_nonopt = d->optind;
+			d->__last_nonopt = argc;
+			d->optind = argc;
+		}
+		if (d->optind == argc)
+		{
+			if (d->__first_nonopt != d->__last_nonopt)
+				d->optind = d->__first_nonopt;
+			return -1;
+		}
+		if ((argv[d->optind][0] != L'-' || argv[d->optind][1] == L'\0'))
+		{
+			if (d->__ordering == REQUIRE_ORDER)
+				return -1;
+			d->optarg = argv[d->optind++];
+			return 1;
+		}
+		d->__nextchar = (argv[d->optind] + 1 + (longopts != NULL && argv[d->optind][1] == L'-'));
+	}
+	if (longopts != NULL && (argv[d->optind][1] == L'-' || (long_only && (argv[d->optind][2] || !wcschr(optstring, argv[d->optind][1])))))
+	{
+		wchar_t *nameend;
+		unsigned int namelen;
+		const struct option_w *p;
+		const struct option_w *pfound = NULL;
+		struct option_list
+		{
+			const struct option_w *p;
+			struct option_list *next;
+		} *ambig_list = NULL;
+		int exact = 0;
+		int indfound = -1;
+		int option_index;
+		for (nameend = d->__nextchar; *nameend && *nameend != L'='; nameend++);
+		namelen = (unsigned int)(nameend - d->__nextchar);
+		for (p = longopts, option_index = 0; p->name; p++, option_index++)
+			if (!wcsncmp(p->name, d->__nextchar, namelen))
+			{
+				if (namelen == (unsigned int)wcslen(p->name))
+				{
+					pfound = p;
+					indfound = option_index;
+					exact = 1;
+					break;
+				}
+				else if (pfound == NULL)
+				{
+					pfound = p;
+					indfound = option_index;
+				}
+				else if (long_only || pfound->has_arg != p->has_arg || pfound->flag != p->flag || pfound->val != p->val)
+				{
+					struct option_list *newp = (struct option_list*)alloca(sizeof(*newp));
+					newp->p = p;
+					newp->next = ambig_list;
+					ambig_list = newp;
+				}
+			}
+			if (ambig_list != NULL && !exact)
+			{
+				if (print_errors)
+				{						
+					struct option_list first;
+					first.p = pfound;
+					first.next = ambig_list;
+					ambig_list = &first;
+					fwprintf(stderr, L"%s: option '%s' is ambiguous; possibilities:", argv[0], argv[d->optind]);
+					do
+					{
+						fwprintf (stderr, L" '--%s'", ambig_list->p->name);
+						ambig_list = ambig_list->next;
+					}
+					while (ambig_list != NULL);
+					fputwc (L'\n', stderr);
+				}
+				d->__nextchar += wcslen(d->__nextchar);
+				d->optind++;
+				d->optopt = 0;
+				return L'?';
+			}
+			if (pfound != NULL)
+			{
+				option_index = indfound;
+				d->optind++;
+				if (*nameend)
+				{
+					if (pfound->has_arg)
+						d->optarg = nameend + 1;
+					else
+					{
+						if (print_errors)
+						{
+							if (argv[d->optind - 1][1] == L'-')
+							{
+								fwprintf(stderr, L"%s: option '--%s' doesn't allow an argument\n",argv[0], pfound->name);
+							}
+							else
+							{
+								fwprintf(stderr, L"%s: option '%c%s' doesn't allow an argument\n",argv[0], argv[d->optind - 1][0],pfound->name);
+							}
+						}
+						d->__nextchar += wcslen(d->__nextchar);
+						d->optopt = pfound->val;
+						return L'?';
+					}
+				}
+				else if (pfound->has_arg == 1)
+				{
+					if (d->optind < argc)
+						d->optarg = argv[d->optind++];
+					else
+					{
+						if (print_errors)
+						{
+							fwprintf(stderr,L"%s: option '--%s' requires an argument\n",argv[0], pfound->name);
+						}
+						d->__nextchar += wcslen(d->__nextchar);
+						d->optopt = pfound->val;
+						return optstring[0] == L':' ? L':' : L'?';
+					}
+				}
+				d->__nextchar += wcslen(d->__nextchar);
+				if (longind != NULL)
+					*longind = option_index;
+				if (pfound->flag)
+				{
+					*(pfound->flag) = pfound->val;
+					return 0;
+				}
+				return pfound->val;
+			}
+			if (!long_only || argv[d->optind][1] == L'-' || wcschr(optstring, *d->__nextchar) == NULL)
+			{
+				if (print_errors)
+				{
+					if (argv[d->optind][1] == L'-')
+					{
+						fwprintf(stderr, L"%s: unrecognized option '--%s'\n",argv[0], d->__nextchar);
+					}
+					else
+					{
+						fwprintf(stderr, L"%s: unrecognized option '%c%s'\n",argv[0], argv[d->optind][0], d->__nextchar);
+					}
+				}
+				d->__nextchar = (wchar_t *)L"";
+				d->optind++;
+				d->optopt = 0;
+				return L'?';
+			}
+	}
+	{
+		wchar_t c = *d->__nextchar++;
+		wchar_t *temp = (wchar_t*)wcschr(optstring, c);
+		if (*d->__nextchar == L'\0')
+			++d->optind;
+		if (temp == NULL || c == L':' || c == L';')
+		{
+			if (print_errors)
+			{
+				fwprintf(stderr, L"%s: invalid option -- '%c'\n", argv[0], c);
+			}
+			d->optopt = c;
+			return L'?';
+		}
+		if (temp[0] == L'W' && temp[1] == L';')
+		{
+			wchar_t *nameend;
+			const struct option_w *p;
+			const struct option_w *pfound = NULL;
+			int exact = 0;
+			int ambig = 0;
+			int indfound = 0;
+			int option_index;
+			if (longopts == NULL)
+				goto no_longs;
+			if (*d->__nextchar != L'\0')
+			{
+				d->optarg = d->__nextchar;
+				d->optind++;
+			}
+			else if (d->optind == argc)
+			{
+				if (print_errors)
+				{
+					fwprintf(stderr,L"%s: option requires an argument -- '%c'\n",argv[0], c);
+				}
+				d->optopt = c;
+				if (optstring[0] == L':')
+					c = L':';
+				else
+					c = L'?';
+				return c;
+			}
+			else
+				d->optarg = argv[d->optind++];
+			for (d->__nextchar = nameend = d->optarg; *nameend && *nameend != L'='; nameend++);
+			for (p = longopts, option_index = 0; p->name; p++, option_index++)
+				if (!wcsncmp(p->name, d->__nextchar, nameend - d->__nextchar))
+				{
+					if ((unsigned int) (nameend - d->__nextchar) == wcslen(p->name))
+					{
+						pfound = p;
+						indfound = option_index;
+						exact = 1;
+						break;
+					}
+					else if (pfound == NULL)
+					{
+						pfound = p;
+						indfound = option_index;
+					}
+					else if (long_only || pfound->has_arg != p->has_arg || pfound->flag != p->flag || pfound->val != p->val)
+						ambig = 1;
+				}
+				if (ambig && !exact)
+				{
+					if (print_errors)
+					{
+						fwprintf(stderr, L"%s: option '-W %s' is ambiguous\n",argv[0], d->optarg);
+					}
+					d->__nextchar += wcslen(d->__nextchar);
+					d->optind++;
+					return L'?';
+				}
+				if (pfound != NULL)
+				{
+					option_index = indfound;
+					if (*nameend)
+					{
+						if (pfound->has_arg)
+							d->optarg = nameend + 1;
+						else
+						{
+							if (print_errors)
+							{
+								fwprintf(stderr, L"%s: option '-W %s' doesn't allow an argument\n",argv[0], pfound->name);
+							}
+							d->__nextchar += wcslen(d->__nextchar);
+							return L'?';
+						}
+					}
+					else if (pfound->has_arg == 1)
+					{
+						if (d->optind < argc)
+							d->optarg = argv[d->optind++];
+						else
+						{
+							if (print_errors)
+							{
+								fwprintf(stderr, L"%s: option '-W %s' requires an argument\n",argv[0], pfound->name);
+							}
+							d->__nextchar += wcslen(d->__nextchar);
+							return optstring[0] == L':' ? L':' : L'?';
+						}
+					}
+					else
+						d->optarg = NULL;
+					d->__nextchar += wcslen(d->__nextchar);
+					if (longind != NULL)
+						*longind = option_index;
+					if (pfound->flag)
+					{
+						*(pfound->flag) = pfound->val;
+						return 0;
+					}
+					return pfound->val;
+				}
+no_longs:
+				d->__nextchar = NULL;
+				return L'W';
+		}
+		if (temp[1] == L':')
+		{
+			if (temp[2] == L':')
+			{
+				if (*d->__nextchar != L'\0')
+				{
+					d->optarg = d->__nextchar;
+					d->optind++;
+				}
+				else
+					d->optarg = NULL;
+				d->__nextchar = NULL;
+			}
+			else
+			{
+				if (*d->__nextchar != L'\0')
+				{
+					d->optarg = d->__nextchar;
+					d->optind++;
+				}
+				else if (d->optind == argc)
+				{
+					if (print_errors)
+					{
+						fwprintf(stderr,L"%s: option requires an argument -- '%c'\n",argv[0], c);
+					}
+					d->optopt = c;
+					if (optstring[0] == L':')
+						c = L':';
+					else
+						c = L'?';
+				}
+				else
+					d->optarg = argv[d->optind++];
+				d->__nextchar = NULL;
+			}
+		}
+		return c;
+	}
+}
+int _getopt_internal_w (int argc, wchar_t *const *argv, const wchar_t *optstring, const struct option_w *longopts, int *longind, int long_only, int posixly_correct)
+{
+	int result;
+	getopt_data_w.optind = optind;
+	getopt_data_w.opterr = opterr;
+	result = _getopt_internal_r_w (argc, argv, optstring, longopts,longind, long_only, &getopt_data_w,posixly_correct);
+	optind = getopt_data_w.optind;
+	optarg_w = getopt_data_w.optarg;
+	optopt = getopt_data_w.optopt;
+	return result;
+}
+int getopt_w (int argc, wchar_t *const *argv, const wchar_t *optstring) _GETOPT_THROW
+{
+	return _getopt_internal_w (argc, argv, optstring, (const struct option_w *) 0, (int *) 0, 0, 0);
+}
+int getopt_long_w (int argc, wchar_t *const *argv, const wchar_t *options, const struct option_w *long_options, int *opt_index) _GETOPT_THROW
+{
+	return _getopt_internal_w (argc, argv, options, long_options, opt_index, 0, 0);
+}
+int getopt_long_only_w (int argc, wchar_t *const *argv, const wchar_t *options, const struct option_w *long_options, int *opt_index) _GETOPT_THROW
+{
+	return _getopt_internal_w (argc, argv, options, long_options, opt_index, 1, 0);
+}
+int _getopt_long_r_w (int argc, wchar_t *const *argv, const wchar_t *options, const struct option_w *long_options, int *opt_index, struct _getopt_data_w *d)
+{
+	return _getopt_internal_r_w (argc, argv, options, long_options, opt_index,0, d, 0);
+}
+int _getopt_long_only_r_w (int argc, wchar_t *const *argv, const wchar_t *options, const struct option_w *long_options, int *opt_index, struct _getopt_data_w *d)
+{
+	return _getopt_internal_r_w (argc, argv, options, long_options, opt_index, 1, d, 0);
+}

examples/client/getopt.h

@@ -0,0 +1,136 @@
+/* Getopt for Microsoft C
+This code is a modification of the Free Software Foundation, Inc.
+Getopt library for parsing command line argument the purpose was
+to provide a Microsoft Visual C friendly derivative. This code
+provides functionality for both Unicode and Multibyte builds.
+
+Date: 02/03/2011 - Ludvik Jerabek - Initial Release
+Version: 1.0
+Comment: Supports getopt, getopt_long, and getopt_long_only
+and POSIXLY_CORRECT environment flag
+License: LGPL
+
+Revisions:
+
+02/03/2011 - Ludvik Jerabek - Initial Release
+02/20/2011 - Ludvik Jerabek - Fixed compiler warnings at Level 4
+07/05/2011 - Ludvik Jerabek - Added no_argument, required_argument, optional_argument defs
+08/03/2011 - Ludvik Jerabek - Fixed non-argument runtime bug which caused runtime exception
+08/09/2011 - Ludvik Jerabek - Added code to export functions for DLL and LIB
+02/15/2012 - Ludvik Jerabek - Fixed _GETOPT_THROW definition missing in implementation file
+08/01/2012 - Ludvik Jerabek - Created separate functions for char and wchar_t characters so single dll can do both unicode and ansi
+10/15/2012 - Ludvik Jerabek - Modified to match latest GNU features
+06/19/2015 - Ludvik Jerabek - Fixed maximum option limitation caused by option_a (255) and option_w (65535) structure val variable
+
+**DISCLAIMER**
+THIS MATERIAL IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND,
+EITHER EXPRESS OR IMPLIED, INCLUDING, BUT Not LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
+PURPOSE, OR NON-INFRINGEMENT. SOME JURISDICTIONS DO NOT ALLOW THE
+EXCLUSION OF IMPLIED WARRANTIES, SO THE ABOVE EXCLUSION MAY NOT
+APPLY TO YOU. IN NO EVENT WILL I BE LIABLE TO ANY PARTY FOR ANY
+DIRECT, INDIRECT, SPECIAL OR OTHER CONSEQUENTIAL DAMAGES FOR ANY
+USE OF THIS MATERIAL INCLUDING, WITHOUT LIMITATION, ANY LOST
+PROFITS, BUSINESS INTERRUPTION, LOSS OF PROGRAMS OR OTHER DATA ON
+YOUR INFORMATION HANDLING SYSTEM OR OTHERWISE, EVEN If WE ARE
+EXPRESSLY ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+*/
+#ifndef __GETOPT_H_
+	#define __GETOPT_H_
+
+	#ifdef _GETOPT_API
+		#undef _GETOPT_API
+	#endif
+
+	#if defined(EXPORTS_GETOPT) && defined(STATIC_GETOPT)
+		#error "The preprocessor definitions of EXPORTS_GETOPT and STATIC_GETOPT can only be used individually"
+	#elif defined(STATIC_GETOPT)
+		#pragma message("Warning static builds of getopt violate the Lesser GNU Public License")
+		#define _GETOPT_API
+	#elif defined(EXPORTS_GETOPT)
+		#pragma message("Exporting getopt library")
+		#define _GETOPT_API __declspec(dllexport)
+	#else
+		#pragma message("Importing getopt library")
+		#define _GETOPT_API __declspec(dllimport)
+	#endif
+
+	// Change behavior for C\C++
+	#ifdef __cplusplus
+		#define _BEGIN_EXTERN_C extern "C" {
+		#define _END_EXTERN_C }
+		#define _GETOPT_THROW throw()
+	#else
+		#define _BEGIN_EXTERN_C
+		#define _END_EXTERN_C
+		#define _GETOPT_THROW
+	#endif
+
+	// Standard GNU options
+	#define	null_argument		0	/*Argument Null*/
+	#define	no_argument			0	/*Argument Switch Only*/
+	#define required_argument	1	/*Argument Required*/
+	#define optional_argument	2	/*Argument Optional*/	
+
+	// Shorter Options
+	#define ARG_NULL	0	/*Argument Null*/
+	#define ARG_NONE	0	/*Argument Switch Only*/
+	#define ARG_REQ		1	/*Argument Required*/
+	#define ARG_OPT		2	/*Argument Optional*/
+
+	#include <string.h>
+	#include <wchar.h>
+
+_BEGIN_EXTERN_C
+
+	extern _GETOPT_API int optind;
+	extern _GETOPT_API int opterr;
+	extern _GETOPT_API int optopt;
+
+	// Ansi
+	struct option_a
+	{
+		const char* name;
+		int has_arg;
+		int *flag;
+		int val;
+	};
+	extern _GETOPT_API char *optarg_a;
+	extern _GETOPT_API int getopt_a(int argc, char *const *argv, const char *optstring) _GETOPT_THROW;
+	extern _GETOPT_API int getopt_long_a(int argc, char *const *argv, const char *options, const struct option_a *long_options, int *opt_index) _GETOPT_THROW;
+	extern _GETOPT_API int getopt_long_only_a(int argc, char *const *argv, const char *options, const struct option_a *long_options, int *opt_index) _GETOPT_THROW;
+
+	// Unicode
+	struct option_w
+	{
+		const wchar_t* name;
+		int has_arg;
+		int *flag;
+		int val;
+	};
+	extern _GETOPT_API wchar_t *optarg_w;
+	extern _GETOPT_API int getopt_w(int argc, wchar_t *const *argv, const wchar_t *optstring) _GETOPT_THROW;
+	extern _GETOPT_API int getopt_long_w(int argc, wchar_t *const *argv, const wchar_t *options, const struct option_w *long_options, int *opt_index) _GETOPT_THROW;
+	extern _GETOPT_API int getopt_long_only_w(int argc, wchar_t *const *argv, const wchar_t *options, const struct option_w *long_options, int *opt_index) _GETOPT_THROW;	
+	
+_END_EXTERN_C
+
+	#undef _BEGIN_EXTERN_C
+	#undef _END_EXTERN_C
+	#undef _GETOPT_THROW
+	#undef _GETOPT_API
+
+	#ifdef _UNICODE
+		#define getopt getopt_w
+		#define getopt_long getopt_long_w
+		#define getopt_long_only getopt_long_only_w
+		#define option option_w
+		#define optarg optarg_w
+	#else
+		#define getopt getopt_a
+		#define getopt_long getopt_long_a
+		#define getopt_long_only getopt_long_only_a
+		#define option option_a
+		#define optarg optarg_a
+	#endif
+#endif  // __GETOPT_H_

examples/client/main.cpp

@@ -5,6 +5,7 @@
  * Copyright (c) 2020 Will Munn
  * Copyright (c) 2020 Nico Chatzi
  * Copyright (c) 2020 Lara Mackey
+ * Copyright (c) 2020 Erik Cota-Robles
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License
@@ -30,6 +31,7 @@
 #include <random>
 #include <thread>
 #include <unordered_map>
+#include "parse_cl.h"
 
 using namespace rtc;
 using namespace std;
@@ -43,20 +45,45 @@ unordered_map<string, shared_ptr<PeerConnection>> peerConnectionMap;
 unordered_map<string, shared_ptr<DataChannel>> dataChannelMap;
 
 string localId;
+bool echoDataChannelMessages = false;
 
 shared_ptr<PeerConnection> createPeerConnection(const Configuration &config,
                                                 weak_ptr<WebSocket> wws, string id);
+void confirmOnStdout(bool echoed, string id, string type, size_t length);
 string randomId(size_t length);
 
 int main(int argc, char **argv) {
+	Cmdline *params = nullptr;
+	try {
+		params = new Cmdline(argc, argv);
+	} catch (const std::range_error&e) {
+		std::cout<< e.what() << '\n';
+		delete params;
+		return -1;
+	}
+
 	rtc::InitLogger(LogLevel::Debug);
 
 	Configuration config;
-	config.iceServers.emplace_back("stun:stun.l.google.com:19302"); // change to your STUN server
+	string stunServer = "";
+	if (params->noStun()) {
+		cout << "No stun server is configured.  Only local hosts and public IP addresses suported." << endl;
+	} else {
+		if (params->stunServer().substr(0,5).compare("stun:") != 0) {
+			stunServer = "stun:";
+		}
+		stunServer += params->stunServer() + ":" + to_string(params->stunPort());
+		cout << "Stun server is " << stunServer << endl;
+		config.iceServers.emplace_back(stunServer);
+	}
 
 	localId = randomId(4);
 	cout << "The local ID is: " << localId << endl;
 
+	echoDataChannelMessages = params->echoDataChannelMessages();
+	cout << "Received data channel messages will be "
+	     << (echoDataChannelMessages ? "echoed back to sender" : "printed to stdout") << endl;
+
 	auto ws = make_shared<WebSocket>();
 
 	ws->onOpen([]() { cout << "WebSocket connected, signaling ready" << endl; });
@@ -65,7 +92,7 @@ int main(int argc, char **argv) {
 
 	ws->onError([](const string &error) { cout << "WebSocket failed: " << error << endl; });
 
-	ws->onMessage([&](const variant<binary, string> &data) {
+	ws->onMessage([&](variant<binary, string> data) {
 		if (!holds_alternative<string>(data))
 			return;
 
@@ -101,7 +128,13 @@ int main(int argc, char **argv) {
 		}
 	});
 
-	const string url = "ws://localhost:8000/" + localId;
+	string wsPrefix = "";
+	if (params->webSocketServer().substr(0,5).compare("ws://") != 0) {
+		wsPrefix = "ws://";
+	}
+	const string url = wsPrefix + params->webSocketServer() + ":" +
+		to_string(params->webSocketPort()) + "/" + localId;
+	cout << "Url is " << url << endl;
 	ws->open(url);
 
 	cout << "Waiting for signaling to be connected..." << endl;
@@ -137,11 +170,20 @@ int main(int argc, char **argv) {
 
 		dc->onClosed([id]() { cout << "DataChannel from " << id << " closed" << endl; });
 
-		dc->onMessage([id](const variant<binary, string> &message) {
+		dc->onMessage([id, wdc = make_weak_ptr(dc)](const variant<binary, string> &message) {
-			if (!holds_alternative<string>(message))
+			static bool firstMessage = true;
-				return;
+			if (holds_alternative<string>(message) && (!echoDataChannelMessages || firstMessage)) {
-
+				cout << "Message from " << id << " received: " << get<string>(message) << endl;
-			cout << "Message from " << id << " received: " << get<string>(message) << endl;
+				firstMessage = false;
+			} else if (echoDataChannelMessages) {
+				bool echoed = false;
+				if (auto dc = wdc.lock()) {
+					dc->send(message);
+					echoed = true;
+				}
+				confirmOnStdout(echoed, id, (holds_alternative<string>(message) ? "text" : "binary"),
+						get<string>(message).length());
+			}
 		});
 
 		dataChannelMap.emplace(id, dc);
@@ -153,6 +195,7 @@ int main(int argc, char **argv) {
 
 	dataChannelMap.clear();
 	peerConnectionMap.clear();
+	delete params;
 	return 0;
 }
 
@@ -166,7 +209,7 @@ shared_ptr<PeerConnection> createPeerConnection(const Configuration &config,
 	pc->onGatheringStateChange(
 	    [](PeerConnection::GatheringState state) { cout << "Gathering State: " << state << endl; });
 
-	pc->onLocalDescription([wws, id](const Description &description) {
+	pc->onLocalDescription([wws, id](Description description) {
 		json message = {
 		    {"id", id}, {"type", description.typeString()}, {"description", string(description)}};
 
@@ -174,7 +217,7 @@ shared_ptr<PeerConnection> createPeerConnection(const Configuration &config,
 			ws->send(message.dump());
 	});
 
-	pc->onLocalCandidate([wws, id](const Candidate &candidate) {
+	pc->onLocalCandidate([wws, id](Candidate candidate) {
 		json message = {{"id", id},
 		                {"type", "candidate"},
 		                {"candidate", string(candidate)},
@@ -190,11 +233,20 @@ shared_ptr<PeerConnection> createPeerConnection(const Configuration &config,
 
 		dc->onClosed([id]() { cout << "DataChannel from " << id << " closed" << endl; });
 
-		dc->onMessage([id](const variant<binary, string> &message) {
+		dc->onMessage([id, wdc = make_weak_ptr(dc)](const variant<binary, string> &message) {
-			if (!holds_alternative<string>(message))
+			static bool firstMessage = true;
-				return;
+			if (holds_alternative<string>(message) && (!echoDataChannelMessages || firstMessage)) {
-
+				cout << "Message from " << id << " received: " << get<string>(message) << endl;
-			cout << "Message from " << id << " received: " << get<string>(message) << endl;
+				firstMessage = false;
+			} else if (echoDataChannelMessages) {
+				bool echoed = false;
+				if (auto dc = wdc.lock()) {
+					dc->send(message);
+					echoed = true;
+				}
+				confirmOnStdout(echoed, id, (holds_alternative<string>(message) ? "text" : "binary"),
+						get<string>(message).length());
+			}
 		});
 
 		dc->send("Hello from " + localId);
@@ -206,6 +258,19 @@ shared_ptr<PeerConnection> createPeerConnection(const Configuration &config,
 	return pc;
 };
 
+void confirmOnStdout(bool echoed, string id, string type, size_t length) {
+	static long count = 0;
+	static long freq = 100;
+	if (!(++count%freq)) {
+		cout << "Received " << count << " pings in total from host " << id << ", most recent of type "
+		     << type << " and " << (echoed ? "" : "un") << "successfully echoed most recent ping of size "
+		     << length << " back to " << id << endl;
+		if (count >= (freq * 10) && freq < 1000000) {
+			freq *= 10;
+		}
+	}
+}
+
 // Helper function to generate a random ID
 string randomId(size_t length) {
 	static const string characters(

examples/client/parse_cl.cpp

@@ -0,0 +1,182 @@
+/******************************************************************************
+**
+** parse_cl.cpp
+**
+** Thu Aug  6 19:42:25 2020
+** Linux 5.4.0-42-generic (#46-Ubuntu SMP Fri Jul 10 00:24:02 UTC 2020) x86_64
+** cerik@Erik-VBox-Ubuntu (Erik Cota-Robles)
+**
+** Copyright (c) 2020 Erik Cota-Robles
+**
+** Definition of command line parser class
+**
+** Automatically created by genparse v0.9.3
+**
+** See http://genparse.sourceforge.net for details and updates
+**
+**
+******************************************************************************/
+
+#include <stdlib.h>
+
+#if defined(_WIN32) || defined(WIN32)
+#include "getopt.h"
+#else
+#include <getopt.h>
+#endif
+
+#include "parse_cl.h"
+
+/*----------------------------------------------------------------------------
+**
+** Cmdline::Cmdline ()
+**
+** Constructor method.
+**
+**--------------------------------------------------------------------------*/
+
+Cmdline::Cmdline (int argc, char *argv[]) // ISO C++17 not allowed: throw (std::string )
+{
+  extern char *optarg;
+  extern int optind;
+  int c;
+
+  static struct option long_options[] =
+  {
+    {"echo", no_argument, NULL, 'e'},
+    {"noStun", no_argument, NULL, 'n'},
+    {"stunServer", required_argument, NULL, 's'},
+    {"stunPort", required_argument, NULL, 't'},
+    {"webSocketServer", required_argument, NULL, 'w'},
+    {"webSocketPort", required_argument, NULL, 'x'},
+    {"help", no_argument, NULL, 'h'},
+    {"version", no_argument, NULL, 'v'},
+    {NULL, 0, NULL, 0}
+  };
+
+  _program_name += argv[0];
+
+  /* default values */
+  _e = false;
+  _n = false;
+  _s = "stun.l.google.com";
+  _t = 19302;
+  _w = "localhost";
+  _x = 8000;
+  _h = false;
+  _v = false;
+
+  optind = 0;
+  while ((c = getopt_long (argc, argv, "s:t:w:x:enhv", long_options, &optind)) != - 1)
+    {
+      switch (c)
+        {
+        case 'e': 
+          _e = true;
+          break;
+
+        case 'n': 
+          _n = true;
+          break;
+
+        case 's': 
+          _s = optarg;
+          break;
+
+        case 't': 
+          _t = atoi (optarg);
+          if (_t < 0)
+            {
+              std::string err;
+              err += "parameter range error: t must be >= 0";
+              throw (std::range_error(err));
+            }
+          if (_t > 65535)
+            {
+              std::string err;
+              err += "parameter range error: t must be <= 65535";
+              throw (std::range_error(err));
+            }
+          break;
+
+        case 'w': 
+          _w = optarg;
+          break;
+
+        case 'x': 
+          _x = atoi (optarg);
+          if (_x < 0)
+            {
+              std::string err;
+              err += "parameter range error: x must be >= 0";
+              throw (std::range_error(err));
+            }
+          if (_x > 65535)
+            {
+              std::string err;
+              err += "parameter range error: x must be <= 65535";
+              throw (std::range_error(err));
+            }
+          break;
+
+        case 'h': 
+          _h = true;
+          this->usage (EXIT_SUCCESS);
+          break;
+
+        case 'v': 
+          _v = true;
+          this->version (EXIT_SUCCESS);
+          break;
+
+        default:
+          this->usage (EXIT_FAILURE);
+
+        }
+    } /* while */
+
+  _optind = optind;
+}
+
+/*----------------------------------------------------------------------------
+**
+** Cmdline::usage () and version()
+**
+** Print out usage (or version) information, then exit.
+**
+**--------------------------------------------------------------------------*/
+
+void Cmdline::usage (int status)
+{
+  if (status != EXIT_SUCCESS)
+    std::cerr << "Try `" << _program_name << " --help' for more information.\n";
+  else
+    {
+      std::cout << "\
+usage: " << _program_name << " [ -enstwxhv ] \n\
+libdatachannel client implementing WebRTC Data Channels with WebSocket signaling\n\
+   [ -e ] [ --echo ] (type=FLAG)\n\
+          Echo data channel messages back to sender rather than putting to stdout.\n\
+   [ -n ] [ --noStun ] (type=FLAG)\n\
+          Do NOT use a stun server (overrides -s and -t).\n\
+   [ -s ] [ --stunServer ] (type=STRING, default=stun.l.google.com)\n\
+          Stun server URL or IP address.\n\
+   [ -t ] [ --stunPort ] (type=INTEGER, range=0...65535, default=19302)\n\
+          Stun server port.\n\
+   [ -w ] [ --webSocketServer ] (type=STRING, default=localhost)\n\
+          Web socket server URL or IP address.\n\
+   [ -x ] [ --webSocketPort ] (type=INTEGER, range=0...65535, default=8000)\n\
+          Web socket server port.\n\
+   [ -h ] [ --help ] (type=FLAG)\n\
+          Display this help and exit.\n\
+   [ -v ] [ --version ] (type=FLAG)\n\
+          Output version information and exit.\n";
+    }
+  exit (status);
+}
+
+void Cmdline::version (int status)
+{
+  std::cout << _program_name << " v0.5\n";
+  exit (status);
+}

examples/client/parse_cl.h

@@ -0,0 +1,74 @@
+/******************************************************************************
+**
+** parse_cl.h
+**
+** Thu Aug  6 19:42:25 2020
+** Linux 5.4.0-42-generic (#46-Ubuntu SMP Fri Jul 10 00:24:02 UTC 2020) x86_64
+** cerik@Erik-VBox-Ubuntu (Erik Cota-Robles)
+**
+** Copyright (c) 2020 Erik Cota-Robles
+**
+** Header file for command line parser class
+**
+** Automatically created by genparse v0.9.3
+**
+** See http://genparse.sourceforge.net for details and updates
+**
+******************************************************************************/
+
+#ifndef CMDLINE_H
+#define CMDLINE_H
+
+#include <iostream>
+#include <string>
+
+/*----------------------------------------------------------------------------
+**
+** class Cmdline
+**
+** command line parser class
+**
+**--------------------------------------------------------------------------*/
+
+class Cmdline
+{
+private:
+  /* parameters */
+  bool _e;
+  bool _n;
+  std::string _s;
+  int _t;
+  std::string _w;
+  int _x;
+  bool _h;
+  bool _v;
+
+  /* other stuff to keep track of */
+  std::string _program_name;
+  int _optind;
+
+public:
+  /* constructor and destructor */
+  Cmdline (int, char **); // ISO C++17 not allowed: throw (std::string);
+  ~Cmdline (){}
+
+  /* usage function */
+  void usage (int status);
+
+  /* version function */
+  void version (int status);
+
+  /* return next (non-option) parameter */
+  int next_param () { return _optind; }
+
+  bool echoDataChannelMessages () const { return _e; }
+  bool noStun () const { return _n; }
+  std::string stunServer () const { return _s; }
+  int stunPort () const { return _t; }
+  std::string webSocketServer () const { return _w; }
+  int webSocketPort () const { return _x; }
+  bool h () const { return _h; }
+  bool v () const { return _v; }
+};
+
+#endif

examples/copy-paste/answerer.cpp

@@ -36,12 +36,12 @@ int main(int argc, char **argv) {
 
 	auto pc = std::make_shared<PeerConnection>(config);
 
-	pc->onLocalDescription([](const Description &description) {
+	pc->onLocalDescription([](Description description) {
 		cout << "Local Description (Paste this to the other peer):" << endl;
 		cout << string(description) << endl;
 	});
 
-	pc->onLocalCandidate([](const Candidate &candidate) {
+	pc->onLocalCandidate([](Candidate candidate) {
 		cout << "Local Candidate (Paste this to the other peer after the local description):"
 		     << endl;
 		cout << string(candidate) << endl << endl;
@@ -60,7 +60,7 @@ int main(int argc, char **argv) {
 
 		dc->onClosed([&]() { cout << "[DataChannel closed: " << dc->label() << "]" << endl; });
 
-		dc->onMessage([](const variant<binary, string> &message) {
+		dc->onMessage([](variant<binary, string> message) {
 			if (holds_alternative<string>(message)) {
 				cout << "[Received message: " << get<string>(message) << "]" << endl;
 			}

examples/copy-paste/offerer.cpp

@@ -36,12 +36,12 @@ int main(int argc, char **argv) {
 
 	auto pc = std::make_shared<PeerConnection>(config);
 
-	pc->onLocalDescription([](const Description &description) {
+	pc->onLocalDescription([](Description description) {
 		cout << "Local Description (Paste this to the other peer):" << endl;
 		cout << string(description) << endl;
 	});
 
-	pc->onLocalCandidate([](const Candidate &candidate) {
+	pc->onLocalCandidate([](Candidate candidate) {
 		cout << "Local Candidate (Paste this to the other peer after the local description):"
 		     << endl;
 		cout << string(candidate) << endl << endl;
@@ -60,7 +60,7 @@ int main(int argc, char **argv) {
 
 	dc->onClosed([&]() { cout << "[DataChannel closed: " << dc->label() << "]" << endl; });
 
-	dc->onMessage([](const variant<binary, string> &message) {
+	dc->onMessage([](variant<binary, string> message) {
 		if (holds_alternative<string>(message)) {
 			cout << "[Received: " << get<string>(message) << "]" << endl;
 		}

examples/media/CMakeLists.txt

@@ -0,0 +1,14 @@
+cmake_minimum_required(VERSION 3.7)
+
+add_executable(datachannel-media main.cpp)
+set_target_properties(datachannel-media PROPERTIES
+        CXX_STANDARD 17
+        OUTPUT_NAME media)
+
+if(WIN32)
+    target_link_libraries(datachannel-media datachannel-static) # DLL exports only the C API
+else()
+    target_link_libraries(datachannel-media datachannel)
+endif()
+
+target_link_libraries(datachannel-media datachannel nlohmann_json)

examples/media/README.md

@@ -0,0 +1,19 @@
+# Example Webcam from Browser to Port 5000
+This is an example copy/paste demo to send your webcam from your browser and out port 5000 through the demo application.
+
+## How to use
+Open main.html in your browser (you must open it either as HTTPS or as a domain of http://localhost).
+
+Start the application and copy it's offer into the text box of the web page.
+
+Copy the answer of the webpage back into the application.
+
+You will now see RTP traffic on `localhost:5000` of the computer that the application is running on.
+
+Use the following gstreamer demo pipeline to display the traffic
+(you might need to wave your hand in front of your camera to force an I-frame).
+
+```
+$ gst-launch-1.0 udpsrc address=127.0.0.1 port=5000 caps="application/x-rtp" ! queue ! rtph264depay ! video/x-h264,stream-format=byte-stream ! queue ! avdec_h264 ! queue ! autovideosink
+```
+

examples/media/main.cpp

@@ -0,0 +1,97 @@
+/*
+ * libdatachannel client example
+ * Copyright (c) 2020 Staz M
+ * Copyright (c) 2020 Paul-Louis Ageneau
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#define _WINSOCK_DEPRECATED_NO_WARNINGS
+
+#include "rtc/rtc.hpp"
+
+#include <iostream>
+#include <memory>
+#include <utility>
+
+#include <nlohmann/json.hpp>
+
+#ifdef _WIN32
+#include <winsock2.h>
+#else
+#include <arpa/inet.h>
+typedef int SOCKET;
+#endif
+
+using nlohmann::json;
+
+int main() {
+	try {
+		rtc::InitLogger(rtc::LogLevel::Debug);
+		auto pc = std::make_shared<rtc::PeerConnection>();
+
+		pc->onStateChange(
+		    [](rtc::PeerConnection::State state) { std::cout << "State: " << state << std::endl; });
+
+		pc->onGatheringStateChange([pc](rtc::PeerConnection::GatheringState state) {
+			std::cout << "Gathering State: " << state << std::endl;
+			if (state == rtc::PeerConnection::GatheringState::Complete) {
+				auto description = pc->localDescription();
+				json message = {{"type", description->typeString()},
+				                {"sdp", std::string(description.value())}};
+				std::cout << message << std::endl;
+			}
+		});
+
+		SOCKET sock = socket(AF_INET, SOCK_DGRAM, 0);
+		sockaddr_in addr;
+		addr.sin_addr.s_addr = inet_addr("127.0.0.1");
+		addr.sin_port = htons(5000);
+		addr.sin_family = AF_INET;
+
+		rtc::Description::Video media("video", rtc::Description::Direction::RecvOnly);
+		media.addH264Codec(96);
+		media.setBitrate(
+		    3000); // Request 3Mbps (Browsers do not encode more than 2.5MBps from a webcam)
+
+		auto track = pc->addTrack(media);
+
+		auto session = std::make_shared<rtc::RtcpSession>();
+		track->setRtcpHandler(session);
+
+		track->onMessage(
+		    [session, sock, addr](rtc::binary message) {
+			    // This is an RTP packet
+			    sendto(sock, reinterpret_cast<const char *>(message.data()), int(message.size()), 0,
+			           reinterpret_cast<const struct sockaddr *>(&addr), sizeof(addr));
+		    },
+		    nullptr);
+
+		pc->setLocalDescription();
+
+		std::cout << "Expect RTP video traffic on localhost:5000" << std::endl;
+		std::cout << "Please copy/paste the answer provided by the browser: " << std::endl;
+		std::string sdp;
+		std::getline(std::cin, sdp);
+		std::cout << "Got answer" << sdp << std::endl;
+		json j = json::parse(sdp);
+		rtc::Description answer(j["sdp"].get<std::string>(), j["type"].get<std::string>());
+		pc->setRemoteDescription(answer);
+		std::cout << "Press any key to exit." << std::endl;
+		std::cin >> sdp;
+
+	} catch (const std::exception &e) {
+		std::cerr << "Error: " << e.what() << std::endl;
+	}
+}

examples/media/main.html

@@ -0,0 +1,45 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <title>libdatachannel media example</title>
+</head>
+<body>
+
+<p>Please enter the offer provided to you by the application: </p>
+<textarea cols="50" rows="50"></textarea>
+<button>Submit</button>
+
+<script>
+    document.querySelector('button').addEventListener('click',  async () => {
+        let offer = JSON.parse(document.querySelector('textarea').value);
+        rtc = new RTCPeerConnection({
+            // Recommended for libdatachannel
+            bundlePolicy: "max-bundle",
+        });
+
+        rtc.onicegatheringstatechange = (state) => {
+            if (rtc.iceGatheringState === 'complete') {
+                // We only want to provide an answer once all of our candidates have been added to the SDP.
+                let answer = rtc.localDescription;
+                document.querySelector('textarea').value = JSON.stringify({"type": answer.type, sdp: answer.sdp});
+                document.querySelector('p').value = 'Please paste the answer in the application.';
+                alert('Please paste the answer in the application.');
+            }
+        }
+        await rtc.setRemoteDescription(offer);
+
+        let media = await navigator.mediaDevices.getUserMedia({
+            video: {
+                width: 1280,
+                height: 720
+            }
+        });
+        media.getTracks().forEach(track => rtc.addTrack(track, media));
+        let answer = await rtc.createAnswer();
+        await rtc.setLocalDescription(answer);
+    })
+</script>
+
+</body>
+</html>

examples/signaling-server-python/signaling-server.py

@@ -63,16 +63,20 @@ async def handle_websocket(websocket, path):
             print('Client {} disconnected'.format(client_id))
 
 if __name__ == '__main__':
-    port = int(sys.argv[1]) if len(sys.argv) > 1 else 8000
+    # Usage: ./server.py [[host:]port] [SSL certificate file]
+    endpoint_or_port = sys.argv[1] if len(sys.argv) > 1 else "8000"
     ssl_cert = sys.argv[2] if len(sys.argv) > 2 else None
 
+    endpoint = endpoint_or_port if ':' in endpoint_or_port else "127.0.0.1:" + endpoint_or_port
+
     if ssl_cert:
         ssl_context = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
         ssl_context.load_cert_chain(ssl_cert)
     else:
         ssl_context = None
 
-    print('Listening on port {}'.format(port))
+    print('Listening on {}'.format(endpoint))
-    start_server = websockets.serve(handle_websocket, '127.0.0.1', port, ssl=ssl_context)
+    host, port = endpoint.rsplit(':', 1)
+    start_server = websockets.serve(handle_websocket, host, int(port), ssl=ssl_context)
     asyncio.get_event_loop().run_until_complete(start_server)
     asyncio.get_event_loop().run_forever()

examples/signaling-server-rust/Cargo.lock

@@ -348,7 +348,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a9f8082297d534141b30c8d39e9b1773713ab50fdbe4ff30f750d063b3bfd701"
 
 [[package]]
-name = "libdatachannel_signaling_example"
+name = "libdatachannel_signaling_server_example"
 version = "0.1.0"
 dependencies = [
  "futures-channel",

examples/signaling-server-rust/src/main.rs

@@ -92,7 +92,9 @@ async fn handle(clients: ClientsMap, stream: TcpStream) {
 #[tokio::main]
 async fn main() -> Result<(), std::io::Error> {
     let service = env::args().nth(1).unwrap_or("8000".to_string());
-    let endpoint = format!("127.0.0.1:{}", service);
+    let endpoint = if service.contains(':') { service } else { format!("127.0.0.1:{}", service) };
+
+	println!("Listening on {}", endpoint);
 
     let mut listener = TcpListener::bind(endpoint)
     	.await.expect("Listener binding failed");

examples/web/package-lock.json

@@ -4,6 +4,14 @@
   "lockfileVersion": 1,
   "requires": true,
   "dependencies": {
+    "bufferutil": {
+      "version": "4.0.1",
+      "resolved": "https://registry.npmjs.org/bufferutil/-/bufferutil-4.0.1.tgz",
+      "integrity": "sha512-xowrxvpxojqkagPcWRQVXZl0YXhRhAtBEIq3VoER1NH5Mw1n1o0ojdspp+GS2J//2gCVyrzQDApQ4unGF+QOoA==",
+      "requires": {
+        "node-gyp-build": "~3.7.0"
+      }
+    },
     "d": {
       "version": "1.0.1",
       "resolved": "https://registry.npmjs.org/d/-/d-1.0.1.tgz",
@@ -59,9 +67,9 @@
       },
       "dependencies": {
         "type": {
-          "version": "2.0.0",
+          "version": "2.1.0",
-          "resolved": "https://registry.npmjs.org/type/-/type-2.0.0.tgz",
+          "resolved": "https://registry.npmjs.org/type/-/type-2.1.0.tgz",
-          "integrity": "sha512-KBt58xCHry4Cejnc2ISQAF7QY+ORngsWfxezO68+12hKV6lQY8P/psIkcbjeHWn7MqcgciWJyCCevFMJdIXpow=="
+          "integrity": "sha512-G9absDWvhAWCV2gmF1zKud3OyC61nZDwWvBL2DApaVFogI07CprggiQAOOjvp2NRjYWFzPyu7vwtDrQFq8jeSA=="
         }
       }
     },
@@ -75,16 +83,16 @@
       "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz",
       "integrity": "sha1-VgiurfwAvmwpAd9fmGF4jeDVl8g="
     },
-    "nan": {
-      "version": "2.14.1",
-      "resolved": "https://registry.npmjs.org/nan/-/nan-2.14.1.tgz",
-      "integrity": "sha512-isWHgVjnFjh2x2yuJ/tj3JbwoHu3UC2dX5G/88Cm24yB6YopVgxvBObDY7n5xW6ExmFhJpSEQqFPvq9zaXc8Jw=="
-    },
     "next-tick": {
       "version": "1.0.0",
       "resolved": "https://registry.npmjs.org/next-tick/-/next-tick-1.0.0.tgz",
       "integrity": "sha1-yobR/ogoFpsBICCOPchCS524NCw="
     },
+    "node-gyp-build": {
+      "version": "3.7.0",
+      "resolved": "https://registry.npmjs.org/node-gyp-build/-/node-gyp-build-3.7.0.tgz",
+      "integrity": "sha512-L/Eg02Epx6Si2NXmedx+Okg+4UHqmaf3TNcxd50SF9NQGcJaON3AtU++kax69XV7YWz4tUspqZSAsVofhFKG2w=="
+    },
     "type": {
       "version": "1.2.0",
       "resolved": "https://registry.npmjs.org/type/-/type-1.2.0.tgz",
@@ -98,15 +106,24 @@
         "is-typedarray": "^1.0.0"
       }
     },
-    "websocket": {
+    "utf-8-validate": {
-      "version": "1.0.31",
+      "version": "5.0.2",
-      "resolved": "https://registry.npmjs.org/websocket/-/websocket-1.0.31.tgz",
+      "resolved": "https://registry.npmjs.org/utf-8-validate/-/utf-8-validate-5.0.2.tgz",
-      "integrity": "sha512-VAouplvGKPiKFDTeCCO65vYHsyay8DqoBSlzIO3fayrfOgU94lQN5a1uWVnFrMLceTJw/+fQXR5PGbUVRaHshQ==",
+      "integrity": "sha512-SwV++i2gTD5qh2XqaPzBnNX88N6HdyhQrNNRykvcS0QKvItV9u3vPEJr+X5Hhfb1JC0r0e1alL0iB09rY8+nmw==",
       "requires": {
+        "node-gyp-build": "~3.7.0"
+      }
+    },
+    "websocket": {
+      "version": "1.0.32",
+      "resolved": "https://registry.npmjs.org/websocket/-/websocket-1.0.32.tgz",
+      "integrity": "sha512-i4yhcllSP4wrpoPMU2N0TQ/q0O94LRG/eUQjEAamRltjQ1oT1PFFKOG4i877OlJgCG8rw6LrrowJp+TYCEWF7Q==",
+      "requires": {
+        "bufferutil": "^4.0.1",
         "debug": "^2.2.0",
         "es5-ext": "^0.10.50",
-        "nan": "^2.14.0",
         "typedarray-to-buffer": "^3.1.5",
+        "utf-8-validate": "^5.0.2",
         "yaeti": "^0.0.6"
       }
     },

examples/web/package.json

@@ -18,6 +18,6 @@
   },
   "homepage": "https://github.com/paullouisageneau/libdatachannel#readme",
   "dependencies": {
-    "websocket": "^1.0.31"
+    "websocket": "^1.0.32"
   }
 }

examples/web/server.js

@@ -98,5 +98,12 @@ wsServer.on('request', (req) => {
   clients[id] = conn;
 });
 
-httpServer.listen(8000);
+const endpoint = process.env.PORT || '8000';
+const splitted = endpoint.split(':');
+const port = splitted.pop();
+const hostname = splitted.join(':') || '127.0.0.1';
+
+httpServer.listen(port, hostname, () => {
+  console.log(`Server listening on ${hostname}:${port}`);
+});
 

include/rtc/channel.hpp

@@ -20,6 +20,7 @@
 #define RTC_CHANNEL_H
 
 #include "include.hpp"
+#include "message.hpp"
 
 #include <atomic>
 #include <functional>
@@ -33,7 +34,7 @@ public:
 	virtual ~Channel() = default;
 
 	virtual void close() = 0;
-	virtual bool send(const std::variant<binary, string> &data) = 0; // returns false if buffered
+	virtual bool send(message_variant data) = 0; // returns false if buffered
 
 	virtual bool isOpen() const = 0;
 	virtual bool isClosed() const = 0;
@@ -42,24 +43,24 @@ public:
 
 	void onOpen(std::function<void()> callback);
 	void onClosed(std::function<void()> callback);
-	void onError(std::function<void(const string &error)> callback);
+	void onError(std::function<void(string error)> callback);
 
-	void onMessage(std::function<void(const std::variant<binary, string> &data)> callback);
+	void onMessage(std::function<void(message_variant data)> callback);
-	void onMessage(std::function<void(const binary &data)> binaryCallback,
+	void onMessage(std::function<void(binary data)> binaryCallback,
-	               std::function<void(const string &data)> stringCallback);
+	               std::function<void(string data)> stringCallback);
 
 	void onBufferedAmountLow(std::function<void()> callback);
 	void setBufferedAmountLowThreshold(size_t amount);
 
 	// Extended API
-	virtual std::optional<std::variant<binary, string>> receive() = 0; // only if onMessage unset
+	virtual std::optional<message_variant> receive() = 0; // only if onMessage unset
 	virtual size_t availableAmount() const; // total size available to receive
 	void onAvailable(std::function<void()> callback);
 
 protected:
 	virtual void triggerOpen();
 	virtual void triggerClosed();
-	virtual void triggerError(const string &error);
+	virtual void triggerError(string error);
 	virtual void triggerAvailable(size_t count);
 	virtual void triggerBufferedAmount(size_t amount);
 
@@ -68,8 +69,8 @@ protected:
 private:
 	synchronized_callback<> mOpenCallback;
 	synchronized_callback<> mClosedCallback;
-	synchronized_callback<const string &> mErrorCallback;
+	synchronized_callback<string> mErrorCallback;
-	synchronized_callback<const std::variant<binary, string> &> mMessageCallback;
+	synchronized_callback<message_variant> mMessageCallback;
 	synchronized_callback<> mAvailableCallback;
 	synchronized_callback<> mBufferedAmountLowCallback;
 

include/rtc/datachannel.hpp

@@ -50,7 +50,7 @@ public:
 	Reliability reliability() const;
 
 	void close(void) override;
-	bool send(const std::variant<binary, string> &data) override;
+	bool send(message_variant data) override;
 	bool send(const byte *data, size_t size);
 	template <typename Buffer> bool sendBuffer(const Buffer &buf);
 	template <typename Iterator> bool sendBuffer(Iterator first, Iterator last);
@@ -61,7 +61,7 @@ public:
 
 	// Extended API
 	size_t availableAmount() const override;
-	std::optional<std::variant<binary, string>> receive() override;
+	std::optional<message_variant> receive() override;
 
 private:
 	void remoteClose();

include/rtc/description.hpp

@@ -1,5 +1,6 @@
 /**
- * Copyright (c) 2019 Paul-Louis Ageneau
+ * Copyright (c) 2019-2020 Paul-Louis Ageneau
+ * Copyright (c) 2020 Staz M
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
@@ -24,7 +25,9 @@
 
 #include <iostream>
 #include <map>
+#include <memory>
 #include <optional>
+#include <variant>
 #include <vector>
 
 namespace rtc {
@@ -33,6 +36,7 @@ class Description {
 public:
 	enum class Type { Unspec = 0, Offer = 1, Answer = 2 };
 	enum class Role { ActPass = 0, Passive = 1, Active = 2 };
+	enum class Direction { SendOnly, RecvOnly, SendRecv, Inactive, Unknown };
 
 	Description(const string &sdp, const string &typeString = "");
 	Description(const string &sdp, Type type);
@@ -42,52 +46,168 @@ public:
 	string typeString() const;
 	Role role() const;
 	string roleString() const;
-	string dataMid() const;
+	string bundleMid() const;
+	string iceUfrag() const;
+	string icePwd() const;
 	std::optional<string> fingerprint() const;
-	std::optional<uint16_t> sctpPort() const;
-	std::optional<size_t> maxMessageSize() const;
 	bool ended() const;
 
 	void hintType(Type type);
-	void setDataMid(string mid);
 	void setFingerprint(string fingerprint);
-	void setSctpPort(uint16_t port);
-	void setMaxMessageSize(size_t size);
 
 	void addCandidate(Candidate candidate);
 	void endCandidates();
 	std::vector<Candidate> extractCandidates();
 
-	bool hasMedia() const;
-	void addMedia(const Description &source);
-
 	operator string() const;
-	string generateSdp(const string &eol) const;
+	string generateSdp(string_view eol) const;
+	string generateApplicationSdp(string_view eol) const;
+
+	class Entry {
+	public:
+		virtual ~Entry() = default;
+
+		virtual string type() const { return mType; }
+		virtual string description() const { return mDescription; }
+		virtual string mid() const { return mMid; }
+		Direction direction() const { return mDirection; }
+		void setDirection(Direction dir);
+
+		operator string() const;
+		string generateSdp(string_view eol) const;
+
+		virtual void parseSdpLine(string_view line);
+
+	protected:
+		Entry(const string &mline, string mid, Direction dir = Direction::Unknown);
+		virtual string generateSdpLines(string_view eol) const;
+
+		std::vector<string> mAttributes;
+
+	private:
+		string mType;
+		string mDescription;
+		string mMid;
+		Direction mDirection;
+	};
+
+	struct Application : public Entry {
+	public:
+		Application(string mid = "data");
+		Application(const Application &other) = default;
+		Application(Application &&other) = default;
+
+		string description() const override;
+		Application reciprocate() const;
+
+		void setSctpPort(uint16_t port) { mSctpPort = port; }
+		void hintSctpPort(uint16_t port) { mSctpPort = mSctpPort.value_or(port); }
+		void setMaxMessageSize(size_t size) { mMaxMessageSize = size; }
+
+		std::optional<uint16_t> sctpPort() const { return mSctpPort; }
+		std::optional<size_t> maxMessageSize() const { return mMaxMessageSize; }
+
+		virtual void parseSdpLine(string_view line) override;
+
+	private:
+		virtual string generateSdpLines(string_view eol) const override;
+
+		std::optional<uint16_t> mSctpPort;
+		std::optional<size_t> mMaxMessageSize;
+	};
+
+	// Media (non-data)
+	class Media : public Entry {
+	public:
+		Media(const string &sdp);
+		Media(const string &mline, string mid, Direction dir = Direction::SendOnly);
+		Media(const Media &other) = default;
+		Media(Media &&other) = default;
+		virtual ~Media() = default;
+
+		string description() const override;
+		Media reciprocate() const;
+
+		void removeFormat(const string &fmt);
+
+		void addVideoCodec(int payloadType, const string &codec);
+		void addH264Codec(int payloadType);
+		void addVP8Codec(int payloadType);
+		void addVP9Codec(int payloadType);
+
+		void setBitrate(int bitrate);
+		int getBitrate() const;
+
+		bool hasPayloadType(int payloadType) const;
+
+		virtual void parseSdpLine(string_view line) override;
+
+	private:
+		virtual string generateSdpLines(string_view eol) const override;
+
+		int mBas = -1;
+
+		struct RTPMap {
+			RTPMap(string_view mline);
+
+			void removeFB(const string &string);
+			void addFB(const string &string);
+
+			int pt;
+			string format;
+			int clockRate;
+			string encParams;
+
+			std::vector<string> rtcpFbs;
+			std::vector<string> fmtps;
+		};
+
+		Media::RTPMap &getFormat(int fmt);
+		Media::RTPMap &getFormat(const string &fmt);
+
+		std::map<int, RTPMap> mRtpMap;
+	};
+
+	class Audio : public Media {
+	public:
+		Audio(string mid = "audio", Direction dir = Direction::SendOnly);
+	};
+
+	class Video : public Media {
+	public:
+		Video(string mid = "video", Direction dir = Direction::SendOnly);
+	};
+
+	bool hasApplication() const;
+	bool hasAudioOrVideo() const;
+
+	int addMedia(Media media);
+	int addMedia(Application application);
+	int addApplication(string mid = "data");
+	int addVideo(string mid = "video", Direction dir = Direction::SendOnly);
+	int addAudio(string mid = "audio", Direction dir = Direction::SendOnly);
+
+	std::variant<Media *, Application *> media(int index);
+	std::variant<const Media *, const Application *> media(int index) const;
+	int mediaCount() const;
+
+	Application *application();
 
 private:
+	std::shared_ptr<Entry> createEntry(string mline, string mid, Direction dir);
+	void removeApplication();
+
 	Type mType;
+
+	// Session-level attributes
 	Role mRole;
 	string mSessionId;
 	string mIceUfrag, mIcePwd;
 	std::optional<string> mFingerprint;
 
-	// Data
+	// Entries
-	struct Data {
+	std::vector<std::shared_ptr<Entry>> mEntries;
-		string mid;
+	std::shared_ptr<Application> mApplication;
-		std::optional<uint16_t> sctpPort;
-		std::optional<size_t> maxMessageSize;
-	};
-	Data mData;
-
-	// Media (non-data)
-	struct Media {
-		Media(const string &mline);
-		string type;
-		string description;
-		string mid;
-		std::vector<string> attributes;
-	};
-	std::map<int, Media> mMedia; // by m-line index
 
 	// Candidates
 	std::vector<Candidate> mCandidates;

include/rtc/include.hpp

@@ -41,12 +41,14 @@
 #include <mutex>
 #include <optional>
 #include <string>
+#include <string_view>
 #include <vector>
 
 namespace rtc {
 
 using std::byte;
 using std::string;
+using std::string_view;
 using binary = std::vector<byte>;
 
 using std::nullopt;
@@ -64,6 +66,8 @@ const uint16_t DEFAULT_SCTP_PORT = 5000; // SCTP port to use by default
 const size_t DEFAULT_MAX_MESSAGE_SIZE = 65536;    // Remote max message size if not specified in SDP
 const size_t LOCAL_MAX_MESSAGE_SIZE = 256 * 1024; // Local max message size
 
+const size_t RECV_QUEUE_LIMIT = 1024 * 1024; // Max per-channel queue size
+
 const int THREADPOOL_SIZE = 4; // Number of threads in the global thread pool
 
 // overloaded helper

include/rtc/message.hpp

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2019 Paul-Louis Ageneau
+ * Copyright (c) 2019-2020 Paul-Louis Ageneau
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
@@ -24,6 +24,8 @@
 
 #include <functional>
 #include <memory>
+#include <optional>
+#include <variant>
 
 namespace rtc {
 
@@ -46,8 +48,9 @@ struct Message : binary {
 
 using message_ptr = std::shared_ptr<Message>;
 using message_callback = std::function<void(message_ptr message)>;
+using message_variant = std::variant<binary, string>;
 
-constexpr auto message_size_func = [](const message_ptr &m) -> size_t {
+inline size_t message_size_func(const message_ptr &m) {
 	return m->type == Message::Binary || m->type == Message::String ? m->size() : 0;
 };
 
@@ -61,23 +64,16 @@ message_ptr make_message(Iterator begin, Iterator end, Message::Type type = Mess
 	return message;
 }
 
-inline message_ptr make_message(size_t size, Message::Type type = Message::Binary,
+message_ptr make_message(size_t size, Message::Type type = Message::Binary, unsigned int stream = 0,
-                                unsigned int stream = 0,
+                         std::shared_ptr<Reliability> reliability = nullptr);
-                                std::shared_ptr<Reliability> reliability = nullptr) {
-	auto message = std::make_shared<Message>(size, type);
-	message->stream = stream;
-	message->reliability = reliability;
-	return message;
-}
 
-inline message_ptr make_message(binary &&data, Message::Type type = Message::Binary,
+message_ptr make_message(binary &&data, Message::Type type = Message::Binary,
-                                unsigned int stream = 0,
+                         unsigned int stream = 0,
-                                std::shared_ptr<Reliability> reliability = nullptr) {
+                         std::shared_ptr<Reliability> reliability = nullptr);
-	auto message = std::make_shared<Message>(std::move(data), type);
+
-	message->stream = stream;
+message_ptr make_message(message_variant data);
-	message->reliability = reliability;
+
-	return message;
+message_variant to_variant(Message &&message);
-}
 
 } // namespace rtc
 

include/rtc/peerconnection.hpp

@@ -28,6 +28,7 @@
 #include "message.hpp"
 #include "reliability.hpp"
 #include "rtc.hpp"
+#include "track.hpp"
 
 #include <atomic>
 #include <functional>
@@ -75,21 +76,28 @@ public:
 	const Configuration *config() const;
 	State state() const;
 	GatheringState gatheringState() const;
+	bool hasLocalDescription() const;
+	bool hasRemoteDescription() const;
+	bool hasMedia() const;
 	std::optional<Description> localDescription() const;
 	std::optional<Description> remoteDescription() const;
 	std::optional<string> localAddress() const;
 	std::optional<string> remoteAddress() const;
 
-	void setLocalDescription(std::optional<Description> description = nullopt);
+	void setLocalDescription();
 	void setRemoteDescription(Description description);
 	void addRemoteCandidate(Candidate candidate);
 
-	std::shared_ptr<DataChannel> createDataChannel(const string &label, const string &protocol = "",
+	std::shared_ptr<DataChannel> addDataChannel(string label, string protocol = "",
-	                                               const Reliability &reliability = {});
+	                                            Reliability reliability = {});
+
+	// Equivalent to calling addDataChannel() and setLocalDescription()
+	std::shared_ptr<DataChannel> createDataChannel(string label, string protocol = "",
+	                                               Reliability reliability = {});
 
 	void onDataChannel(std::function<void(std::shared_ptr<DataChannel> dataChannel)> callback);
-	void onLocalDescription(std::function<void(const Description &description)> callback);
+	void onLocalDescription(std::function<void(Description description)> callback);
-	void onLocalCandidate(std::function<void(const Candidate &candidate)> callback);
+	void onLocalCandidate(std::function<void(Candidate candidate)> callback);
 	void onStateChange(std::function<void(State state)> callback);
 	void onGatheringStateChange(std::function<void(GatheringState state)> callback);
 
@@ -99,12 +107,9 @@ public:
 	size_t bytesReceived();
 	std::optional<std::chrono::milliseconds> rtt();
 
-	// Media
+	// Track media support requires compiling with libSRTP
-	bool hasMedia() const;
+	std::shared_ptr<Track> addTrack(Description::Media description);
-	void sendMedia(const binary &packet);
+	void onTrack(std::function<void(std::shared_ptr<Track> track)> callback);
-	void sendMedia(const byte *packet, size_t size);
-
-	void onMedia(std::function<void(const binary &packet)> callback);
 
 	// libnice only
 	bool getSelectedCandidatePair(CandidateInfo *local, CandidateInfo *remote);
@@ -121,18 +126,21 @@ private:
 	void forwardMedia(message_ptr message);
 	void forwardBufferedAmount(uint16_t stream, size_t amount);
 
-	std::shared_ptr<DataChannel> emplaceDataChannel(Description::Role role, const string &label,
+	std::shared_ptr<DataChannel> emplaceDataChannel(Description::Role role, string label,
-	                                                const string &protocol,
+	                                                string protocol, Reliability reliability);
-	                                                const Reliability &reliability);
 	std::shared_ptr<DataChannel> findDataChannel(uint16_t stream);
 	void iterateDataChannels(std::function<void(std::shared_ptr<DataChannel> channel)> func);
 	void openDataChannels();
 	void closeDataChannels();
 	void remoteCloseDataChannels();
 
+	void incomingTrack(Description::Media description);
+	void openTracks();
+
 	void processLocalDescription(Description description);
 	void processLocalCandidate(Candidate candidate);
 	void triggerDataChannel(std::weak_ptr<DataChannel> weakDataChannel);
+	void triggerTrack(std::shared_ptr<Track> track);
 	bool changeState(State state);
 	bool changeGatheringState(GatheringState state);
 
@@ -152,18 +160,21 @@ private:
 	std::shared_ptr<DtlsTransport> mDtlsTransport;
 	std::shared_ptr<SctpTransport> mSctpTransport;
 
-	std::unordered_map<unsigned int, std::weak_ptr<DataChannel>> mDataChannels;
+	std::unordered_map<unsigned int, std::weak_ptr<DataChannel>> mDataChannels; // by stream ID
-	std::shared_mutex mDataChannelsMutex;
+	std::unordered_map<string, std::weak_ptr<Track>> mTracks;                   // by mid
+	std::shared_mutex mDataChannelsMutex, mTracksMutex;
+
+	std::unordered_map<unsigned int, string> mMidFromPayloadType; // cache
 
 	std::atomic<State> mState;
 	std::atomic<GatheringState> mGatheringState;
 
 	synchronized_callback<std::shared_ptr<DataChannel>> mDataChannelCallback;
-	synchronized_callback<const Description &> mLocalDescriptionCallback;
+	synchronized_callback<Description> mLocalDescriptionCallback;
-	synchronized_callback<const Candidate &> mLocalCandidateCallback;
+	synchronized_callback<Candidate> mLocalCandidateCallback;
 	synchronized_callback<State> mStateChangeCallback;
 	synchronized_callback<GatheringState> mGatheringStateChangeCallback;
-	synchronized_callback<const binary &> mMediaCallback;
+	synchronized_callback<std::shared_ptr<Track>> mTrackCallback;
 };
 
 } // namespace rtc

include/rtc/queue.hpp

@@ -38,16 +38,22 @@ public:
 	~Queue();
 
 	void stop();
+	bool running() const;
 	bool empty() const;
+	bool full() const;
 	size_t size() const;   // elements
 	size_t amount() const; // amount
 	void push(T element);
 	std::optional<T> pop();
+	std::optional<T> tryPop();
 	std::optional<T> peek();
 	std::optional<T> exchange(T element);
 	bool wait(const std::optional<std::chrono::milliseconds> &duration = nullopt);
 
 private:
+	void pushImpl(T element);
+	std::optional<T> popImpl();
+
 	const size_t mLimit;
 	size_t mAmount;
 	std::queue<T> mQueue;
@@ -75,11 +81,21 @@ template <typename T> void Queue<T>::stop() {
 	mPushCondition.notify_all();
 }
 
+template <typename T> bool Queue<T>::running() const {
+	std::lock_guard lock(mMutex);
+	return !mQueue.empty() || !mStopping;
+}
+
 template <typename T> bool Queue<T>::empty() const {
 	std::lock_guard lock(mMutex);
 	return mQueue.empty();
 }
 
+template <typename T> bool Queue<T>::full() const {
+	std::lock_guard lock(mMutex);
+	return mQueue.size() >= mLimit;
+}
+
 template <typename T> size_t Queue<T>::size() const {
 	std::lock_guard lock(mMutex);
 	return mQueue.size();
@@ -93,43 +109,32 @@ template <typename T> size_t Queue<T>::amount() const {
 template <typename T> void Queue<T>::push(T element) {
 	std::unique_lock lock(mMutex);
 	mPushCondition.wait(lock, [this]() { return !mLimit || mQueue.size() < mLimit || mStopping; });
-	if (!mStopping) {
+	pushImpl(std::move(element));
-		mAmount += mAmountFunction(element);
-		mQueue.emplace(std::move(element));
-		mPopCondition.notify_one();
-	}
 }
 
 template <typename T> std::optional<T> Queue<T>::pop() {
 	std::unique_lock lock(mMutex);
 	mPopCondition.wait(lock, [this]() { return !mQueue.empty() || mStopping; });
-	if (!mQueue.empty()) {
+	return popImpl();
-		mAmount -= mAmountFunction(mQueue.front());
+}
-		std::optional<T> element{std::move(mQueue.front())};
+
-		mQueue.pop();
+template <typename T> std::optional<T> Queue<T>::tryPop() {
-		return element;
+	std::unique_lock lock(mMutex);
-	} else {
+	return popImpl();
-		return nullopt;
-	}
 }
 
 template <typename T> std::optional<T> Queue<T>::peek() {
 	std::unique_lock lock(mMutex);
-	if (!mQueue.empty()) {
+	return !mQueue.empty() ? std::make_optional(mQueue.front()) : nullopt;
-		return std::optional<T>{mQueue.front()};
-	} else {
-		return nullopt;
-	}
 }
 
 template <typename T> std::optional<T> Queue<T>::exchange(T element) {
 	std::unique_lock lock(mMutex);
-	if (!mQueue.empty()) {
+	if (mQueue.empty())
-		std::swap(mQueue.front(), element);
-		return std::optional<T>{element};
-	} else {
 		return nullopt;
-	}
+
+	std::swap(mQueue.front(), element);
+	return std::make_optional(std::move(element));
 }
 
 template <typename T>
@@ -139,7 +144,27 @@ bool Queue<T>::wait(const std::optional<std::chrono::milliseconds> &duration) {
 		mPopCondition.wait_for(lock, *duration, [this]() { return !mQueue.empty() || mStopping; });
 	else
 		mPopCondition.wait(lock, [this]() { return !mQueue.empty() || mStopping; });
-	return !mStopping;
+
+	return !mQueue.empty();
+}
+
+template <typename T> void Queue<T>::pushImpl(T element) {
+	if (mStopping)
+		return;
+
+	mAmount += mAmountFunction(element);
+	mQueue.emplace(std::move(element));
+	mPopCondition.notify_one();
+}
+
+template <typename T> std::optional<T> Queue<T>::popImpl() {
+	if (mQueue.empty())
+		return nullopt;
+
+	mAmount -= mAmountFunction(mQueue.front());
+	std::optional<T> element{std::move(mQueue.front())};
+	mQueue.pop();
+	return element;
 }
 
 } // namespace rtc

include/rtc/reliability.hpp

@@ -27,13 +27,9 @@
 namespace rtc {
 
 struct Reliability {
-	enum Type : uint8_t {
+	enum class Type { Reliable = 0, Rexmit, Timed };
-		TYPE_RELIABLE = 0x00,
-		TYPE_PARTIAL_RELIABLE_REXMIT = 0x01,
-		TYPE_PARTIAL_RELIABLE_TIMED = 0x02,
-	};
 
-	Type type = TYPE_RELIABLE;
+	Type type = Type::Reliable;
 	bool unordered = false;
 	std::variant<int, std::chrono::milliseconds> rexmit = 0;
 };

include/rtc/rtc.h

@@ -29,10 +29,6 @@ extern "C" {
 #define RTC_EXPORT
 #endif
 
-#ifndef RTC_ENABLE_MEDIA
-#define RTC_ENABLE_MEDIA 1
-#endif
-
 #ifndef RTC_ENABLE_WEBSOCKET
 #define RTC_ENABLE_WEBSOCKET 1
 #endif
@@ -78,12 +74,20 @@ typedef struct {
 	uint16_t portRangeEnd;
 } rtcConfiguration;
 
+typedef struct {
+	bool unordered;
+	bool unreliable;
+	unsigned int maxPacketLifeTime; // ignored if reliable
+	unsigned int maxRetransmits;    // ignored if reliable
+} rtcReliability;
+
 typedef void (*rtcLogCallbackFunc)(rtcLogLevel level, const char *message);
-typedef void (*rtcDataChannelCallbackFunc)(int dc, void *ptr);
 typedef void (*rtcDescriptionCallbackFunc)(const char *sdp, const char *type, void *ptr);
 typedef void (*rtcCandidateCallbackFunc)(const char *cand, const char *mid, void *ptr);
 typedef void (*rtcStateChangeCallbackFunc)(rtcState state, void *ptr);
 typedef void (*rtcGatheringStateCallbackFunc)(rtcGatheringState state, void *ptr);
+typedef void (*rtcDataChannelCallbackFunc)(int dc, void *ptr);
+typedef void (*rtcTrackCallbackFunc)(int tr, void *ptr);
 typedef void (*rtcOpenCallbackFunc)(void *ptr);
 typedef void (*rtcClosedCallbackFunc)(void *ptr);
 typedef void (*rtcErrorCallbackFunc)(const char *error, void *ptr);
@@ -101,12 +105,12 @@ RTC_EXPORT void rtcSetUserPointer(int id, void *ptr);
 RTC_EXPORT int rtcCreatePeerConnection(const rtcConfiguration *config); // returns pc id
 RTC_EXPORT int rtcDeletePeerConnection(int pc);
 
-RTC_EXPORT int rtcSetDataChannelCallback(int pc, rtcDataChannelCallbackFunc cb);
 RTC_EXPORT int rtcSetLocalDescriptionCallback(int pc, rtcDescriptionCallbackFunc cb);
 RTC_EXPORT int rtcSetLocalCandidateCallback(int pc, rtcCandidateCallbackFunc cb);
 RTC_EXPORT int rtcSetStateChangeCallback(int pc, rtcStateChangeCallbackFunc cb);
 RTC_EXPORT int rtcSetGatheringStateChangeCallback(int pc, rtcGatheringStateCallbackFunc cb);
 
+RTC_EXPORT int rtcSetLocalDescription(int pc);
 RTC_EXPORT int rtcSetRemoteDescription(int pc, const char *sdp, const char *type);
 RTC_EXPORT int rtcAddRemoteCandidate(int pc, const char *cand, const char *mid);
 
@@ -114,10 +118,26 @@ RTC_EXPORT int rtcGetLocalAddress(int pc, char *buffer, int size);
 RTC_EXPORT int rtcGetRemoteAddress(int pc, char *buffer, int size);
 
 // DataChannel
+RTC_EXPORT int rtcSetDataChannelCallback(int pc, rtcDataChannelCallbackFunc cb);
+RTC_EXPORT int rtcAddDataChannel(int pc, const char *label); // returns dc id
+RTC_EXPORT int rtcAddDataChannelExt(int pc, const char *label, const char *protocol,
+                                    const rtcReliability *reliability); // returns dc id
+// Equivalent to calling rtcAddDataChannel() and rtcSetLocalDescription()
 RTC_EXPORT int rtcCreateDataChannel(int pc, const char *label); // returns dc id
+RTC_EXPORT int rtcCreateDataChannelExt(int pc, const char *label, const char *protocol,
+                                       const rtcReliability *reliability); // returns dc id
 RTC_EXPORT int rtcDeleteDataChannel(int dc);
 
 RTC_EXPORT int rtcGetDataChannelLabel(int dc, char *buffer, int size);
+RTC_EXPORT int rtcGetDataChannelProtocol(int dc, char *buffer, int size);
+RTC_EXPORT int rtcGetDataChannelReliability(int dc, rtcReliability *reliability);
+
+// Track
+RTC_EXPORT int rtcSetTrackCallback(int pc, rtcTrackCallbackFunc cb);
+RTC_EXPORT int rtcAddTrack(int pc, const char *mediaDescriptionSdp); // returns tr id
+RTC_EXPORT int rtcDeleteTrack(int tr);
+
+RTC_EXPORT int rtcGetTrackDescription(int tr, char *buffer, int size);
 
 // WebSocket
 #if RTC_ENABLE_WEBSOCKET
@@ -130,7 +150,7 @@ RTC_EXPORT int rtcCreateWebSocketEx(const char *url, const rtcWsConfiguration *c
 RTC_EXPORT int rtcDeleteWebsocket(int ws);
 #endif
 
-// DataChannel and WebSocket common API
+// DataChannel, Track, and WebSocket common API
 RTC_EXPORT int rtcSetOpenCallback(int id, rtcOpenCallbackFunc cb);
 RTC_EXPORT int rtcSetClosedCallback(int id, rtcClosedCallbackFunc cb);
 RTC_EXPORT int rtcSetErrorCallback(int id, rtcErrorCallbackFunc cb);
@@ -141,7 +161,7 @@ RTC_EXPORT int rtcGetBufferedAmount(int id); // total size buffered to send
 RTC_EXPORT int rtcSetBufferedAmountLowThreshold(int id, int amount);
 RTC_EXPORT int rtcSetBufferedAmountLowCallback(int id, rtcBufferedAmountLowCallbackFunc cb);
 
-// DataChannel and WebSocket common extended API
+// DataChannel, Track, and WebSocket common extended API
 RTC_EXPORT int rtcGetAvailableAmount(int id); // total size available to receive
 RTC_EXPORT int rtcSetAvailableCallback(int id, rtcAvailableCallbackFunc cb);
 RTC_EXPORT int rtcReceiveMessage(int id, char *buffer, int *size);

include/rtc/rtcp.hpp

@@ -0,0 +1,59 @@
+/**
+ * Copyright (c) 2020 Staz M
+ * Copyright (c) 2020 Paul-Louis Ageneau
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#ifndef RTC_RTCP_H
+#define RTC_RTCP_H
+
+#include "include.hpp"
+#include "log.hpp"
+#include "message.hpp"
+
+namespace rtc {
+
+typedef uint32_t SSRC;
+
+class RtcpHandler {
+public:
+	virtual void onOutgoing(std::function<void(rtc::message_ptr)> cb) = 0;
+	virtual std::optional<rtc::message_ptr> incoming(rtc::message_ptr ptr) = 0;
+};
+
+// An RtcpSession can be plugged into a Track to handle the whole RTCP session
+class RtcpSession : public RtcpHandler {
+public:
+	void onOutgoing(std::function<void(rtc::message_ptr)> cb) override;
+
+	std::optional<rtc::message_ptr> incoming(rtc::message_ptr ptr) override;
+	void requestBitrate(unsigned int newBitrate);
+
+private:
+	void pushREMB(unsigned int bitrate);
+	void pushRR(unsigned int lastSR_delay);
+	void tx(message_ptr msg);
+
+	unsigned int mRequestedBitrate = 0;
+	synchronized_callback<rtc::message_ptr> mTxCallback;
+	SSRC mSsrc = 0;
+	uint32_t mGreatestSeqNo = 0;
+	uint64_t mSyncRTPTS, mSyncNTPTS;
+};
+
+} // namespace rtc
+
+#endif // RTC_RTCP_H

include/rtc/track.hpp

@@ -0,0 +1,82 @@
+/**
+ * Copyright (c) 2020 Paul-Louis Ageneau
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#ifndef RTC_TRACK_H
+#define RTC_TRACK_H
+
+#include "channel.hpp"
+#include "description.hpp"
+#include "include.hpp"
+#include "message.hpp"
+#include "queue.hpp"
+#include "rtcp.hpp"
+
+#include <atomic>
+#include <variant>
+
+namespace rtc {
+
+#if RTC_ENABLE_MEDIA
+class DtlsSrtpTransport;
+#endif
+
+class Track final : public std::enable_shared_from_this<Track>, public Channel {
+public:
+	Track(Description::Media description);
+	~Track() = default;
+
+	string mid() const;
+	Description::Media description() const;
+
+	void close(void) override;
+	bool send(message_variant data) override;
+	bool send(const byte *data, size_t size);
+
+	bool isOpen(void) const override;
+	bool isClosed(void) const override;
+	size_t maxMessageSize() const override;
+
+	// Extended API
+	size_t availableAmount() const override;
+	std::optional<message_variant> receive() override;
+
+	// RTCP handler
+	void setRtcpHandler(std::shared_ptr<RtcpHandler> handler);
+
+private:
+#if RTC_ENABLE_MEDIA
+	void open(std::shared_ptr<DtlsSrtpTransport> transport);
+	std::weak_ptr<DtlsSrtpTransport> mDtlsSrtpTransport;
+#endif
+
+	bool outgoing(message_ptr message);
+	void incoming(message_ptr message);
+
+	Description::Media mMediaDescription;
+	std::atomic<bool> mIsClosed = false;
+
+	Queue<message_ptr> mRecvQueue;
+	std::shared_ptr<RtcpHandler> mRtcpHandler;
+
+	friend class PeerConnection;
+};
+
+} // namespace rtc
+
+#endif
+

include/rtc/websocket.hpp

@@ -58,14 +58,14 @@ public:
 
 	void open(const string &url);
 	void close() override;
-	bool send(const std::variant<binary, string> &data) override;
+	bool send(const message_variant data) override;
 
 	bool isOpen() const override;
 	bool isClosed() const override;
 	size_t maxMessageSize() const override;
 
 	// Extended API
-	std::optional<std::variant<binary, string>> receive() override;
+	std::optional<message_variant> receive() override;
 	size_t availableAmount() const override; // total size available to receive
 
 private:

src/candidate.cpp

@@ -49,7 +49,7 @@ namespace rtc {
 
 Candidate::Candidate(string candidate, string mid) : mIsResolved(false) {
 	const std::array prefixes{"a=", "candidate:"};
-	for (string prefix : prefixes)
+	for (const string &prefix : prefixes)
 		if (hasprefix(candidate, prefix))
 			candidate.erase(0, prefix.size());
 
@@ -94,7 +94,7 @@ bool Candidate::resolve(ResolveMode mode) {
 
 		struct addrinfo *result = nullptr;
 		if (getaddrinfo(node.c_str(), service.c_str(), &hints, &result) == 0) {
-			for (auto p = result; p; p = p->ai_next)
+			for (auto p = result; p; p = p->ai_next) {
 				if (p->ai_family == AF_INET || p->ai_family == AF_INET6) {
 					// Rewrite the candidate
 					char nodebuffer[MAX_NUMERICNODE_LEN];
@@ -113,9 +113,10 @@ bool Candidate::resolve(ResolveMode mode) {
 						break;
 					}
 				}
-		}
+			}
 
-		freeaddrinfo(result);
+			freeaddrinfo(result);
+		}
 	}
 
 	return mIsResolved;

src/capi.cpp

@@ -29,6 +29,7 @@
 
 #include "plog/Formatters/FuncMessageFormatter.h"
 
+#include <chrono>
 #include <exception>
 #include <mutex>
 #include <type_traits>
@@ -43,11 +44,13 @@
 using namespace rtc;
 using std::shared_ptr;
 using std::string;
+using std::chrono::milliseconds;
 
 namespace {
 
 std::unordered_map<int, shared_ptr<PeerConnection>> peerConnectionMap;
 std::unordered_map<int, shared_ptr<DataChannel>> dataChannelMap;
+std::unordered_map<int, shared_ptr<Track>> trackMap;
 #if RTC_ENABLE_WEBSOCKET
 std::unordered_map<int, shared_ptr<WebSocket>> webSocketMap;
 #endif
@@ -82,6 +85,14 @@ shared_ptr<DataChannel> getDataChannel(int id) {
 		throw std::invalid_argument("DataChannel ID does not exist");
 }
 
+shared_ptr<Track> getTrack(int id) {
+	std::lock_guard lock(mutex);
+	if (auto it = trackMap.find(id); it != trackMap.end())
+		return it->second;
+	else
+		throw std::invalid_argument("Track ID does not exist");
+}
+
 int emplacePeerConnection(shared_ptr<PeerConnection> ptr) {
 	std::lock_guard lock(mutex);
 	int pc = ++lastId;
@@ -98,6 +109,14 @@ int emplaceDataChannel(shared_ptr<DataChannel> ptr) {
 	return dc;
 }
 
+int emplaceTrack(shared_ptr<Track> ptr) {
+	std::lock_guard lock(mutex);
+	int tr = ++lastId;
+	trackMap.emplace(std::make_pair(tr, ptr));
+	userPointerMap.emplace(std::make_pair(tr, nullptr));
+	return tr;
+}
+
 void erasePeerConnection(int pc) {
 	std::lock_guard lock(mutex);
 	if (peerConnectionMap.erase(pc) == 0)
@@ -112,6 +131,13 @@ void eraseDataChannel(int dc) {
 	userPointerMap.erase(dc);
 }
 
+void eraseTrack(int tr) {
+	std::lock_guard lock(mutex);
+	if (trackMap.erase(tr) == 0)
+		throw std::invalid_argument("Track ID does not exist");
+	userPointerMap.erase(tr);
+}
+
 #if RTC_ENABLE_WEBSOCKET
 shared_ptr<WebSocket> getWebSocket(int id) {
 	std::lock_guard lock(mutex);
@@ -141,11 +167,13 @@ shared_ptr<Channel> getChannel(int id) {
 	std::lock_guard lock(mutex);
 	if (auto it = dataChannelMap.find(id); it != dataChannelMap.end())
 		return it->second;
+	if (auto it = trackMap.find(id); it != trackMap.end())
+		return it->second;
 #if RTC_ENABLE_WEBSOCKET
 	if (auto it = webSocketMap.find(id); it != webSocketMap.end())
 		return it->second;
 #endif
-	throw std::invalid_argument("DataChannel or WebSocket ID does not exist");
+	throw std::invalid_argument("DataChannel, Track, or WebSocket ID does not exist");
 }
 
 template <typename F> int wrap(F func) {
@@ -240,16 +268,48 @@ int rtcDeletePeerConnection(int pc) {
 	});
 }
 
-int rtcCreateDataChannel(int pc, const char *label) {
+int rtcAddDataChannel(int pc, const char *label) {
+	return rtcAddDataChannelExt(pc, label, nullptr, nullptr);
+}
+
+int rtcAddDataChannelExt(int pc, const char *label, const char *protocol,
+                         const rtcReliability *reliability) {
 	return WRAP({
+		Reliability r = {};
+		if (reliability) {
+			r.unordered = reliability->unordered;
+			if (reliability->unreliable) {
+				if (reliability->maxPacketLifeTime > 0) {
+					r.type = Reliability::Type::Timed;
+					r.rexmit = milliseconds(reliability->maxPacketLifeTime);
+				} else {
+					r.type = Reliability::Type::Rexmit;
+					r.rexmit = int(reliability->maxRetransmits);
+				}
+			} else {
+				r.type = Reliability::Type::Reliable;
+			}
+		}
 		auto peerConnection = getPeerConnection(pc);
-		int dc = emplaceDataChannel(peerConnection->createDataChannel(string(label)));
+		int dc = emplaceDataChannel(peerConnection->addDataChannel(
+		    string(label ? label : ""), string(protocol ? protocol : ""), r));
 		if (auto ptr = getUserPointer(pc))
 			rtcSetUserPointer(dc, *ptr);
 		return dc;
 	});
 }
 
+int rtcCreateDataChannel(int pc, const char *label) {
+	return rtcCreateDataChannelExt(pc, label, nullptr, nullptr);
+}
+
+int rtcCreateDataChannelExt(int pc, const char *label, const char *protocol,
+                            const rtcReliability *reliability) {
+	int dc = rtcAddDataChannelExt(pc, label, protocol, reliability);
+	rtcSetLocalDescription(pc);
+	return dc;
+}
+
 int rtcDeleteDataChannel(int dc) {
 	return WRAP({
 		auto dataChannel = getDataChannel(dc);
@@ -264,6 +324,53 @@ int rtcDeleteDataChannel(int dc) {
 	});
 }
 
+int rtcAddTrack(int pc, const char *mediaDescriptionSdp) {
+	return WRAP({
+		if (!mediaDescriptionSdp)
+			throw std::invalid_argument("Unexpected null pointer for track media description");
+
+		auto peerConnection = getPeerConnection(pc);
+		Description::Media media{string(mediaDescriptionSdp)};
+		int tr = emplaceTrack(peerConnection->addTrack(std::move(media)));
+		if (auto ptr = getUserPointer(pc))
+			rtcSetUserPointer(tr, *ptr);
+		return tr;
+	});
+}
+
+int rtcDeleteTrack(int tr) {
+	return WRAP({
+		auto track = getTrack(tr);
+		track->onOpen(nullptr);
+		track->onClosed(nullptr);
+		track->onError(nullptr);
+		track->onMessage(nullptr);
+		track->onBufferedAmountLow(nullptr);
+		track->onAvailable(nullptr);
+
+		eraseTrack(tr);
+	});
+}
+
+int rtcGetTrackDescription(int tr, char *buffer, int size) {
+	return WRAP({
+		auto track = getTrack(tr);
+
+		if (size <= 0)
+			return 0;
+
+		if (!buffer)
+			throw std::invalid_argument("Unexpected null pointer for buffer");
+
+		string description(track->description());
+		const char *data = description.data();
+		size = std::min(size - 1, int(description.size()));
+		std::copy(data, data + size, buffer);
+		buffer[size] = '\0';
+		return int(size + 1);
+	});
+}
+
 #if RTC_ENABLE_WEBSOCKET
 int rtcCreateWebSocket(const char *url) {
 	return WRAP({
@@ -298,27 +405,11 @@ int rtcDeleteWebsocket(int ws) {
 }
 #endif
 
-int rtcSetDataChannelCallback(int pc, rtcDataChannelCallbackFunc cb) {
-	return WRAP({
-		auto peerConnection = getPeerConnection(pc);
-		if (cb)
-			peerConnection->onDataChannel([pc, cb](std::shared_ptr<DataChannel> dataChannel) {
-				int dc = emplaceDataChannel(dataChannel);
-				if (auto ptr = getUserPointer(pc)) {
-					rtcSetUserPointer(dc, *ptr);
-					cb(dc, *ptr);
-				}
-			});
-		else
-			peerConnection->onDataChannel(nullptr);
-	});
-}
-
 int rtcSetLocalDescriptionCallback(int pc, rtcDescriptionCallbackFunc cb) {
 	return WRAP({
 		auto peerConnection = getPeerConnection(pc);
 		if (cb)
-			peerConnection->onLocalDescription([pc, cb](const Description &desc) {
+			peerConnection->onLocalDescription([pc, cb](Description desc) {
 				if (auto ptr = getUserPointer(pc))
 					cb(string(desc).c_str(), desc.typeString().c_str(), *ptr);
 			});
@@ -331,7 +422,7 @@ int rtcSetLocalCandidateCallback(int pc, rtcCandidateCallbackFunc cb) {
 	return WRAP({
 		auto peerConnection = getPeerConnection(pc);
 		if (cb)
-			peerConnection->onLocalCandidate([pc, cb](const Candidate &cand) {
+			peerConnection->onLocalCandidate([pc, cb](Candidate cand) {
 				if (auto ptr = getUserPointer(pc))
 					cb(cand.candidate().c_str(), cand.mid().c_str(), *ptr);
 			});
@@ -366,12 +457,51 @@ int rtcSetGatheringStateChangeCallback(int pc, rtcGatheringStateCallbackFunc cb)
 	});
 }
 
+int rtcSetDataChannelCallback(int pc, rtcDataChannelCallbackFunc cb) {
+	return WRAP({
+		auto peerConnection = getPeerConnection(pc);
+		if (cb)
+			peerConnection->onDataChannel([pc, cb](std::shared_ptr<DataChannel> dataChannel) {
+				int dc = emplaceDataChannel(dataChannel);
+				if (auto ptr = getUserPointer(pc)) {
+					rtcSetUserPointer(dc, *ptr);
+					cb(dc, *ptr);
+				}
+			});
+		else
+			peerConnection->onDataChannel(nullptr);
+	});
+}
+
+int rtcSetTrackCallback(int pc, rtcTrackCallbackFunc cb) {
+	return WRAP({
+		auto peerConnection = getPeerConnection(pc);
+		if (cb)
+			peerConnection->onTrack([pc, cb](std::shared_ptr<Track> track) {
+				int tr = emplaceTrack(track);
+				if (auto ptr = getUserPointer(pc)) {
+					rtcSetUserPointer(tr, *ptr);
+					cb(tr, *ptr);
+				}
+			});
+		else
+			peerConnection->onTrack(nullptr);
+	});
+}
+
+int rtcSetLocalDescription(int pc) {
+	return WRAP({
+		auto peerConnection = getPeerConnection(pc);
+		peerConnection->setLocalDescription();
+	});
+}
+
 int rtcSetRemoteDescription(int pc, const char *sdp, const char *type) {
 	return WRAP({
 		auto peerConnection = getPeerConnection(pc);
 
 		if (!sdp)
-			throw std::invalid_argument("Unexpected null pointer");
+			throw std::invalid_argument("Unexpected null pointer for remote description");
 
 		peerConnection->setRemoteDescription({string(sdp), type ? string(type) : ""});
 	});
@@ -382,7 +512,7 @@ int rtcAddRemoteCandidate(int pc, const char *cand, const char *mid) {
 		auto peerConnection = getPeerConnection(pc);
 
 		if (!cand)
-			throw std::invalid_argument("Unexpected null pointer");
+			throw std::invalid_argument("Unexpected null pointer for remote candidate");
 
 		peerConnection->addRemoteCandidate({string(cand), mid ? string(mid) : ""});
 	});
@@ -392,12 +522,12 @@ int rtcGetLocalAddress(int pc, char *buffer, int size) {
 	return WRAP({
 		auto peerConnection = getPeerConnection(pc);
 
-		if (!buffer)
-			throw std::invalid_argument("Unexpected null pointer");
-
 		if (size <= 0)
 			return 0;
 
+		if (!buffer)
+			throw std::invalid_argument("Unexpected null pointer for buffer");
+
 		if (auto addr = peerConnection->localAddress()) {
 			const char *data = addr->data();
 			size = std::min(size - 1, int(addr->size()));
@@ -412,12 +542,12 @@ int rtcGetRemoteAddress(int pc, char *buffer, int size) {
 	return WRAP({
 		auto peerConnection = getPeerConnection(pc);
 
-		if (!buffer)
-			throw std::invalid_argument("Unexpected null pointer");
-
 		if (size <= 0)
 			return 0;
 
+		if (!buffer)
+			throw std::invalid_argument("Unexpected null pointer for buffer");
+
 		if (auto addr = peerConnection->remoteAddress()) {
 			const char *data = addr->data();
 			size = std::min(size - 1, int(addr->size()));
@@ -432,12 +562,12 @@ int rtcGetDataChannelLabel(int dc, char *buffer, int size) {
 	return WRAP({
 		auto dataChannel = getDataChannel(dc);
 
-		if (!buffer)
-			throw std::invalid_argument("Unexpected null pointer");
-
 		if (size <= 0)
 			return 0;
 
+		if (!buffer)
+			throw std::invalid_argument("Unexpected null pointer for buffer");
+
 		string label = dataChannel->label();
 		const char *data = label.data();
 		size = std::min(size - 1, int(label.size()));
@@ -447,6 +577,48 @@ int rtcGetDataChannelLabel(int dc, char *buffer, int size) {
 	});
 }
 
+int rtcGetDataChannelProtocol(int dc, char *buffer, int size) {
+	return WRAP({
+		auto dataChannel = getDataChannel(dc);
+
+		if (size <= 0)
+			return 0;
+
+		if (!buffer)
+			throw std::invalid_argument("Unexpected null pointer for buffer");
+
+		string protocol = dataChannel->protocol();
+		const char *data = protocol.data();
+		size = std::min(size - 1, int(protocol.size()));
+		std::copy(data, data + size, buffer);
+		buffer[size] = '\0';
+		return int(size + 1);
+	});
+}
+
+int rtcGetDataChannelReliability(int dc, rtcReliability *reliability) {
+	return WRAP({
+		auto dataChannel = getDataChannel(dc);
+
+		if (!reliability)
+			throw std::invalid_argument("Unexpected null pointer for reliability");
+
+		Reliability r = dataChannel->reliability();
+		std::memset(reliability, 0, sizeof(*reliability));
+		reliability->unordered = r.unordered;
+		if (r.type == Reliability::Type::Timed) {
+			reliability->unreliable = true;
+			reliability->maxPacketLifeTime = unsigned(std::get<milliseconds>(r.rexmit).count());
+		} else if (r.type == Reliability::Type::Rexmit) {
+			reliability->unreliable = true;
+			reliability->maxRetransmits = unsigned(std::get<int>(r.rexmit));
+		} else {
+			reliability->unreliable = false;
+		}
+		return 0;
+	});
+}
+
 int rtcSetOpenCallback(int id, rtcOpenCallbackFunc cb) {
 	return WRAP({
 		auto channel = getChannel(id);
@@ -477,7 +649,7 @@ int rtcSetErrorCallback(int id, rtcErrorCallbackFunc cb) {
 	return WRAP({
 		auto channel = getChannel(id);
 		if (cb)
-			channel->onError([id, cb](const string &error) {
+			channel->onError([id, cb](string error) {
 				if (auto ptr = getUserPointer(id))
 					cb(error.c_str(), *ptr);
 			});
@@ -491,11 +663,11 @@ int rtcSetMessageCallback(int id, rtcMessageCallbackFunc cb) {
 		auto channel = getChannel(id);
 		if (cb)
 			channel->onMessage(
-			    [id, cb](const binary &b) {
+			    [id, cb](binary b) {
 				    if (auto ptr = getUserPointer(id))
 					    cb(reinterpret_cast<const char *>(b.data()), int(b.size()), *ptr);
 			    },
-			    [id, cb](const string &s) {
+			    [id, cb](string s) {
 				    if (auto ptr = getUserPointer(id))
 					    cb(s.c_str(), -int(s.size() + 1), *ptr);
 			    });
@@ -508,8 +680,8 @@ int rtcSendMessage(int id, const char *data, int size) {
 	return WRAP({
 		auto channel = getChannel(id);
 
-		if (!data)
+		if (!data && size != 0)
-			throw std::invalid_argument("Unexpected null pointer");
+			throw std::invalid_argument("Unexpected null pointer for data");
 
 		if (size >= 0) {
 			auto b = reinterpret_cast<const byte *>(data);
@@ -572,25 +744,32 @@ int rtcReceiveMessage(int id, char *buffer, int *size) {
 	return WRAP({
 		auto channel = getChannel(id);
 
-		if (!buffer || !size)
+		if (!size)
-			throw std::invalid_argument("Unexpected null pointer");
+			throw std::invalid_argument("Unexpected null pointer for size");
+
+		if (!buffer && *size != 0)
+			throw std::invalid_argument("Unexpected null pointer for buffer");
 
 		if (auto message = channel->receive())
 			return std::visit( //
 			    overloaded{    //
-			               [&](const binary &b) {
+			               [&](binary b) {
-				               *size = std::min(*size, int(b.size()));
+				               if (*size > 0) {
-				               auto data = reinterpret_cast<const char *>(b.data());
+					               *size = std::min(*size, int(b.size()));
-				               std::copy(data, data + *size, buffer);
+					               auto data = reinterpret_cast<const char *>(b.data());
+					               std::copy(data, data + *size, buffer);
+				               }
 				               return 1;
 			               },
-			               [&](const string &s) {
+			               [&](string s) {
-				               int len = std::min(*size - 1, int(s.size()));
+				               if (*size > 0) {
-				               if (len >= 0) {
+					               int len = std::min(*size - 1, int(s.size()));
-					               std::copy(s.data(), s.data() + len, buffer);
+					               if (len >= 0) {
-					               buffer[len] = '\0';
+						               std::copy(s.data(), s.data() + len, buffer);
+						               buffer[len] = '\0';
+					               }
+					               *size = -(len + 1);
 				               }
-				               *size = -(len + 1);
 				               return 1;
 			               }},
 			    *message);

src/channel.cpp

@@ -34,11 +34,9 @@ void Channel::onClosed(std::function<void()> callback) {
 	mClosedCallback = callback;
 }
 
-void Channel::onError(std::function<void(const string &error)> callback) {
+void Channel::onError(std::function<void(string error)> callback) { mErrorCallback = callback; }
-	mErrorCallback = callback;
-}
 
-void Channel::onMessage(std::function<void(const std::variant<binary, string> &data)> callback) {
+void Channel::onMessage(std::function<void(message_variant data)> callback) {
 	mMessageCallback = callback;
 
 	// Pass pending messages
@@ -46,10 +44,10 @@ void Channel::onMessage(std::function<void(const std::variant<binary, string> &d
 		mMessageCallback(*message);
 }
 
-void Channel::onMessage(std::function<void(const binary &data)> binaryCallback,
+void Channel::onMessage(std::function<void(binary data)> binaryCallback,
-                        std::function<void(const string &data)> stringCallback) {
+                        std::function<void(string data)> stringCallback) {
-	onMessage([binaryCallback, stringCallback](const std::variant<binary, string> &data) {
+	onMessage([binaryCallback, stringCallback](std::variant<binary, string> data) {
-		std::visit(overloaded{binaryCallback, stringCallback}, data);
+		std::visit(overloaded{binaryCallback, stringCallback}, std::move(data));
 	});
 }
 
@@ -67,7 +65,7 @@ void Channel::triggerOpen() { mOpenCallback(); }
 
 void Channel::triggerClosed() { mClosedCallback(); }
 
-void Channel::triggerError(const string &error) { mErrorCallback(error); }
+void Channel::triggerError(string error) { mErrorCallback(error); }
 
 void Channel::triggerAvailable(size_t count) {
 	if (count == 1)

src/datachannel.cpp

@@ -31,6 +31,7 @@ namespace rtc {
 
 using std::shared_ptr;
 using std::weak_ptr;
+using std::chrono::milliseconds;
 
 // Messages for the DataChannel establishment protocol
 // See https://tools.ietf.org/html/draft-ietf-rtcweb-data-protocol-09
@@ -43,6 +44,12 @@ enum MessageType : uint8_t {
 	MESSAGE_CLOSE = 0x04
 };
 
+enum ChannelType : uint8_t {
+	CHANNEL_RELIABLE = 0x00,
+	CHANNEL_PARTIAL_RELIABLE_REXMIT = 0x01,
+	CHANNEL_PARTIAL_RELIABLE_TIMED = 0x02
+};
+
 #pragma pack(push, 1)
 struct OpenMessage {
 	uint8_t type = MESSAGE_OPEN;
@@ -65,8 +72,6 @@ struct CloseMessage {
 };
 #pragma pack(pop)
 
-const size_t RECV_QUEUE_LIMIT = 1024 * 1024; // 1 MiB
-
 DataChannel::DataChannel(weak_ptr<PeerConnection> pc, unsigned int stream, string label,
                          string protocol, Reliability reliability)
     : mPeerConnection(pc), mStream(stream), mLabel(std::move(label)),
@@ -110,39 +115,21 @@ void DataChannel::remoteClose() {
 	mSctpTransport.reset();
 }
 
-bool DataChannel::send(const std::variant<binary, string> &data) {
+bool DataChannel::send(message_variant data) { return outgoing(make_message(std::move(data))); }
-	return std::visit(
-	    [&](const auto &d) {
-		    using T = std::decay_t<decltype(d)>;
-		    constexpr auto type = std::is_same_v<T, string> ? Message::String : Message::Binary;
-		    auto *b = reinterpret_cast<const byte *>(d.data());
-		    return outgoing(std::make_shared<Message>(b, b + d.size(), type));
-	    },
-	    data);
-}
 
 bool DataChannel::send(const byte *data, size_t size) {
 	return outgoing(std::make_shared<Message>(data, data + size, Message::Binary));
 }
 
-std::optional<std::variant<binary, string>> DataChannel::receive() {
+std::optional<message_variant> DataChannel::receive() {
-	while (!mRecvQueue.empty()) {
+	while (auto next = mRecvQueue.tryPop()) {
-		auto message = *mRecvQueue.pop();
+		message_ptr message = std::move(*next);
-		switch (message->type) {
+		if (message->type == Message::Control) {
-		case Message::Control: {
 			auto raw = reinterpret_cast<const uint8_t *>(message->data());
-			if (raw[0] == MESSAGE_CLOSE)
+			if (!message->empty() && raw[0] == MESSAGE_CLOSE)
 				remoteClose();
-			break;
+		} else {
-		}
+			return to_variant(std::move(*message));
-		case Message::String:
-			return std::make_optional(
-			    string(reinterpret_cast<const char *>(message->data()), message->size()));
-		case Message::Binary:
-			return std::make_optional(std::move(*message));
-		default:
-			// Ignore
-			break;
 		}
 	}
 
@@ -157,8 +144,9 @@ size_t DataChannel::maxMessageSize() const {
 	size_t remoteMax = DEFAULT_MAX_MESSAGE_SIZE;
 	if (auto pc = mPeerConnection.lock())
 		if (auto description = pc->remoteDescription())
-			if (auto maxMessageSize = description->maxMessageSize())
+			if (auto *application = description->application())
-				remoteMax = *maxMessageSize > 0 ? *maxMessageSize : LOCAL_MAX_MESSAGE_SIZE;
+				if (auto maxMessageSize = application->maxMessageSize())
+					remoteMax = *maxMessageSize > 0 ? *maxMessageSize : LOCAL_MAX_MESSAGE_SIZE;
 
 	return std::min(remoteMax, LOCAL_MAX_MESSAGE_SIZE);
 }
@@ -168,22 +156,33 @@ size_t DataChannel::availableAmount() const { return mRecvQueue.amount(); }
 void DataChannel::open(shared_ptr<SctpTransport> transport) {
 	mSctpTransport = transport;
 
-	uint8_t channelType = static_cast<uint8_t>(mReliability->type);
+	uint8_t channelType;
-	if (mReliability->unordered)
+	uint32_t reliabilityParameter;
-		channelType &= 0x80;
+	switch (mReliability->type) {
-
+	case Reliability::Type::Rexmit:
-	using std::chrono::milliseconds;
+		channelType = CHANNEL_PARTIAL_RELIABLE_REXMIT;
-	uint32_t reliabilityParameter = 0;
-	if (mReliability->type == Reliability::TYPE_PARTIAL_RELIABLE_REXMIT)
 		reliabilityParameter = uint32_t(std::get<int>(mReliability->rexmit));
-	else if (mReliability->type == Reliability::TYPE_PARTIAL_RELIABLE_TIMED)
+		break;
+
+	case Reliability::Type::Timed:
+		channelType = CHANNEL_PARTIAL_RELIABLE_TIMED;
 		reliabilityParameter = uint32_t(std::get<milliseconds>(mReliability->rexmit).count());
+		break;
+
+	default:
+		channelType = CHANNEL_RELIABLE;
+		reliabilityParameter = 0;
+		break;
+	}
+
+	if (mReliability->unordered)
+		channelType |= 0x80;
 
 	const size_t len = sizeof(OpenMessage) + mLabel.size() + mProtocol.size();
 	binary buffer(len, byte(0));
 	auto &open = *reinterpret_cast<OpenMessage *>(buffer.data());
 	open.type = MESSAGE_OPEN;
-	open.channelType = mReliability->type;
+	open.channelType = channelType;
 	open.priority = htons(0);
 	open.reliabilityParameter = htonl(reliabilityParameter);
 	open.labelLength = htons(uint16_t(mLabel.size()));
@@ -205,7 +204,7 @@ bool DataChannel::outgoing(message_ptr message) {
 
 	auto transport = mSctpTransport.lock();
 	if (!transport)
-		throw std::runtime_error("DataChannel has no transport");
+		throw std::runtime_error("DataChannel transport is not open");
 
 	// Before the ACK has been received on a DataChannel, all messages must be sent ordered
 	message->reliability = mIsOpen ? mReliability : nullptr;
@@ -219,6 +218,8 @@ void DataChannel::incoming(message_ptr message) {
 
 	switch (message->type) {
 	case Message::Control: {
+		if (message->size() == 0)
+			break; // Ignore
 		auto raw = reinterpret_cast<const uint8_t *>(message->data());
 		switch (raw[0]) {
 		case MESSAGE_OPEN:
@@ -272,19 +273,18 @@ void DataChannel::processOpenMessage(message_ptr message) {
 	mLabel.assign(end, open.labelLength);
 	mProtocol.assign(end + open.labelLength, open.protocolLength);
 
-	using std::chrono::milliseconds;
 	mReliability->unordered = (open.reliabilityParameter & 0x80) != 0;
 	switch (open.channelType & 0x7F) {
-	case Reliability::TYPE_PARTIAL_RELIABLE_REXMIT:
+	case CHANNEL_PARTIAL_RELIABLE_REXMIT:
-		mReliability->type = Reliability::TYPE_PARTIAL_RELIABLE_REXMIT;
+		mReliability->type = Reliability::Type::Rexmit;
 		mReliability->rexmit = int(open.reliabilityParameter);
 		break;
-	case Reliability::TYPE_PARTIAL_RELIABLE_TIMED:
+	case CHANNEL_PARTIAL_RELIABLE_TIMED:
-		mReliability->type = Reliability::TYPE_PARTIAL_RELIABLE_TIMED;
+		mReliability->type = Reliability::Type::Timed;
 		mReliability->rexmit = milliseconds(open.reliabilityParameter);
 		break;
 	default:
-		mReliability->type = Reliability::TYPE_RELIABLE;
+		mReliability->type = Reliability::Type::Reliable;
 		mReliability->rexmit = int(0);
 	}
 

src/description.cpp

@@ -1,5 +1,6 @@
 /**
- * Copyright (c) 2019 Paul-Louis Ageneau
+ * Copyright (c) 2019-2020 Paul-Louis Ageneau
+ * Copyright (c) 2020 Staz M
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
@@ -19,18 +20,22 @@
 #include "description.hpp"
 
 #include <algorithm>
+#include <array>
 #include <cctype>
 #include <chrono>
+#include <iostream>
 #include <random>
 #include <sstream>
 
+using std::shared_ptr;
 using std::size_t;
 using std::string;
+using std::string_view;
 using std::chrono::system_clock;
 
 namespace {
 
-inline bool match_prefix(const string &str, const string &prefix) {
+inline bool match_prefix(string_view str, string_view prefix) {
 	return str.size() >= prefix.size() &&
 	       std::mismatch(prefix.begin(), prefix.end(), str.begin()).first == prefix.end();
 }
@@ -41,6 +46,21 @@ inline void trim_end(string &str) {
 	    str.end());
 }
 
+inline std::pair<string_view, string_view> parse_pair(string_view attr) {
+	string_view key, value;
+	if (size_t separator = attr.find(':'); separator != string::npos) {
+		key = attr.substr(0, separator);
+		value = attr.substr(separator + 1);
+	} else {
+		key = attr;
+	}
+	return std::make_pair(std::move(key), std::move(value));
+}
+
+template <typename T> T to_integer(string_view s) {
+	return std::is_signed<T>::value ? T(std::stol(string(s))) : T(std::stoul(string(s)));
+}
+
 } // namespace
 
 namespace rtc {
@@ -52,7 +72,6 @@ Description::Description(const string &sdp, Type type) : Description(sdp, type,
 
 Description::Description(const string &sdp, Type type, Role role)
     : mType(Type::Unspec), mRole(role) {
-	mData.mid = "data";
 	hintType(type);
 
 	auto seed = static_cast<unsigned int>(system_clock::now().time_since_epoch().count());
@@ -60,51 +79,28 @@ Description::Description(const string &sdp, Type type, Role role)
 	std::uniform_int_distribution<uint32_t> uniform;
 	mSessionId = std::to_string(uniform(generator));
 
+	int index = -1;
+	std::shared_ptr<Entry> current;
 	std::istringstream ss(sdp);
-	std::optional<Media> currentMedia;
+	while (ss) {
-
-	int mlineIndex = 0;
-	bool finished;
-	do {
 		string line;
-		finished = !std::getline(ss, line) && line.empty();
+		std::getline(ss, line);
 		trim_end(line);
+		if (line.empty())
+			continue;
 
 		// Media description line (aka m-line)
-		if (finished || match_prefix(line, "m=")) {
+		if (match_prefix(line, "m=")) {
-			if (currentMedia) {
+			++index;
-				if (!currentMedia->mid.empty()) {
+			string mline = line.substr(2);
-					if (currentMedia->type == "application")
+			current = createEntry(std::move(mline), std::to_string(index), Direction::Unknown);
-						mData.mid = currentMedia->mid;
-					else
-						mMedia.emplace(mlineIndex, std::move(*currentMedia));
-
-					++mlineIndex;
-
-				} else if (line.find(" ICE/SDP") != string::npos) {
-					PLOG_WARNING << "SDP \"m=\" line has no corresponding mid, ignoring";
-				}
-			}
-			if (!finished)
-				currentMedia.emplace(Media(line.substr(2)));
 
 			// Attribute line
 		} else if (match_prefix(line, "a=")) {
 			string attr = line.substr(2);
+			auto [key, value] = parse_pair(attr);
 
-			string key, value;
+			if (key == "setup") {
-			if (size_t separator = attr.find(':'); separator != string::npos) {
-				key = attr.substr(0, separator);
-				value = attr.substr(separator + 1);
-			} else {
-				key = attr;
-			}
-
-			if (key == "mid") {
-				if (currentMedia)
-					currentMedia->mid = value;
-
-			} else if (key == "setup") {
 				if (value == "active")
 					mRole = Role::Active;
 				else if (value == "passive")
@@ -125,19 +121,24 @@ Description::Description(const string &sdp, Type type, Role role)
 				mIceUfrag = value;
 			} else if (key == "ice-pwd") {
 				mIcePwd = value;
-			} else if (key == "sctp-port") {
-				mData.sctpPort = uint16_t(std::stoul(value));
-			} else if (key == "max-message-size") {
-				mData.maxMessageSize = size_t(std::stoul(value));
 			} else if (key == "candidate") {
-				addCandidate(Candidate(attr, currentMedia ? currentMedia->mid : mData.mid));
+				addCandidate(Candidate(attr, bundleMid()));
 			} else if (key == "end-of-candidates") {
 				mEnded = true;
-			} else if (currentMedia) {
+			} else if (current) {
-				currentMedia->attributes.emplace_back(line.substr(2));
+				current->parseSdpLine(std::move(line));
 			}
+
+		} else if (current) {
+			current->parseSdpLine(std::move(line));
 		}
-	} while (!finished);
+	}
+
+	if (mIceUfrag.empty())
+		throw std::invalid_argument("Missing ice-ufrag parameter in SDP description");
+
+	if (mIcePwd.empty())
+		throw std::invalid_argument("Missing ice-pwd parameter in SDP description");
 }
 
 Description::Type Description::type() const { return mType; }
@@ -148,14 +149,17 @@ Description::Role Description::role() const { return mRole; }
 
 string Description::roleString() const { return roleToString(mRole); }
 
-string Description::dataMid() const { return mData.mid; }
+string Description::bundleMid() const {
+	// Get the mid of the first media
+	return !mEntries.empty() ? mEntries[0]->mid() : "0";
+}
+
+string Description::iceUfrag() const { return mIceUfrag; }
+
+string Description::icePwd() const { return mIcePwd; }
 
 std::optional<string> Description::fingerprint() const { return mFingerprint; }
 
-std::optional<uint16_t> Description::sctpPort() const { return mData.sctpPort; }
-
-std::optional<size_t> Description::maxMessageSize() const { return mData.maxMessageSize; }
-
 bool Description::ended() const { return mEnded; }
 
 void Description::hintType(Type type) {
@@ -166,16 +170,10 @@ void Description::hintType(Type type) {
 	}
 }
 
-void Description::setDataMid(string mid) { mData.mid = mid; }
-
 void Description::setFingerprint(string fingerprint) {
 	mFingerprint.emplace(std::move(fingerprint));
 }
 
-void Description::setSctpPort(uint16_t port) { mData.sctpPort.emplace(port); }
-
-void Description::setMaxMessageSize(size_t size) { mData.maxMessageSize.emplace(size); }
-
 void Description::addCandidate(Candidate candidate) {
 	mCandidates.emplace_back(std::move(candidate));
 }
@@ -189,19 +187,9 @@ std::vector<Candidate> Description::extractCandidates() {
 	return result;
 }
 
-bool Description::hasMedia() const { return !mMedia.empty(); }
-
-void Description::addMedia(const Description &source) {
-	for (auto p : source.mMedia)
-		mMedia.emplace(p);
-}
-
 Description::operator string() const { return generateSdp("\r\n"); }
 
-string Description::generateSdp(const string &eol) const {
+string Description::generateSdp(string_view eol) const {
-	if (!mFingerprint)
-		throw std::logic_error("Fingerprint must be set to generate an SDP string");
-
 	std::ostringstream sdp;
 
 	// Header
@@ -214,59 +202,70 @@ string Description::generateSdp(const string &eol) const {
 	// see Negotiating Media Multiplexing Using the Session Description Protocol
 	// https://tools.ietf.org/html/draft-ietf-mmusic-sdp-bundle-negotiation-54
 	sdp << "a=group:BUNDLE";
-	for (int i = 0; i < int(mMedia.size() + 1); ++i)
+	for (const auto &entry : mEntries)
-		if (auto it = mMedia.find(i); it != mMedia.end())
+		sdp << ' ' << entry->mid();
-			sdp << ' ' << it->second.mid;
-		else
-			sdp << ' ' << mData.mid;
 	sdp << eol;
 
-	sdp << "a=msid-semantic: WMS" << eol;
+	// Lip-sync
+	std::ostringstream lsGroup;
+	for (const auto &entry : mEntries)
+		if (entry != mApplication)
+			lsGroup << ' ' << entry->mid();
 
-	// Non-data media
+	if (!lsGroup.str().empty())
-	if (!mMedia.empty()) {
+		sdp << "a=group:LS" << lsGroup.str() << eol;
-		// Lip-sync
-		sdp << "a=group:LS";
-		for (const auto &p : mMedia)
-			sdp << " " << p.second.mid;
-		sdp << eol;
-	}
 
-	// Descriptions and attributes
+	// Session-level attributes
-	for (int i = 0; i < int(mMedia.size() + 1); ++i) {
+	sdp << "a=msid-semantic:WMS *" << eol;
-		if (auto it = mMedia.find(i); it != mMedia.end()) {
+	sdp << "a=setup:" << roleToString(mRole) << eol;
-			// Non-data media
+	sdp << "a=ice-ufrag:" << mIceUfrag << eol;
-			const auto &media = it->second;
+	sdp << "a=ice-pwd:" << mIcePwd << eol;
-			sdp << "m=" << media.type << ' ' << 0 << ' ' << media.description << eol;
-			sdp << "c=IN IP4 0.0.0.0" << eol;
-			sdp << "a=bundle-only" << eol;
-			sdp << "a=mid:" << media.mid << eol;
-			for (const auto &attr : media.attributes)
-				sdp << "a=" << attr << eol;
 
-		} else {
-			// Data
-			const string description = "UDP/DTLS/SCTP webrtc-datachannel";
-			sdp << "m=application" << ' ' << (!mMedia.empty() ? 0 : 9) << ' ' << description << eol;
-			sdp << "c=IN IP4 0.0.0.0" << eol;
-			if (!mMedia.empty())
-				sdp << "a=bundle-only" << eol;
-			sdp << "a=mid:" << mData.mid << eol;
-			if (mData.sctpPort)
-				sdp << "a=sctp-port:" << *mData.sctpPort << eol;
-			if (mData.maxMessageSize)
-				sdp << "a=max-message-size:" << *mData.maxMessageSize << eol;
-		}
-	}
-
-	// Common
 	if (!mEnded)
 		sdp << "a=ice-options:trickle" << eol;
 
+	if (mFingerprint)
+		sdp << "a=fingerprint:sha-256 " << *mFingerprint << eol;
+
+	// Entries
+	bool first = true;
+	for (const auto &entry : mEntries) {
+		sdp << entry->generateSdp(eol);
+
+		if (std::exchange(first, false)) {
+			// Candidates
+			for (const auto &candidate : mCandidates)
+				sdp << string(candidate) << eol;
+
+			if (mEnded)
+				sdp << "a=end-of-candidates" << eol;
+		}
+	}
+
+	return sdp.str();
+}
+
+string Description::generateApplicationSdp(string_view eol) const {
+	std::ostringstream sdp;
+
+	// Header
+	sdp << "v=0" << eol;
+	sdp << "o=- " << mSessionId << " 0 IN IP4 127.0.0.1" << eol;
+	sdp << "s=-" << eol;
+	sdp << "t=0 0" << eol;
+
+	// Application
+	auto app = mApplication ? mApplication : std::make_shared<Application>();
+	sdp << app->generateSdp(eol);
+
+	// Session-level attributes
+	sdp << "a=msid-semantic:WMS *" << eol;
+	sdp << "a=setup:" << roleToString(mRole) << eol;
 	sdp << "a=ice-ufrag:" << mIceUfrag << eol;
 	sdp << "a=ice-pwd:" << mIcePwd << eol;
-	sdp << "a=setup:" << roleToString(mRole) << eol;
+
-	sdp << "a=tls-id:1" << eol;
+	if (!mEnded)
+		sdp << "a=ice-options:trickle" << eol;
 
 	if (mFingerprint)
 		sdp << "a=fingerprint:sha-256 " << *mFingerprint << eol;
@@ -274,20 +273,465 @@ string Description::generateSdp(const string &eol) const {
 	// Candidates
 	for (const auto &candidate : mCandidates)
 		sdp << string(candidate) << eol;
+
 	if (mEnded)
 		sdp << "a=end-of-candidates" << eol;
 
 	return sdp.str();
 }
 
-Description::Media::Media(const string &mline) {
+shared_ptr<Description::Entry> Description::createEntry(string mline, string mid, Direction dir) {
-	size_t p = mline.find(' ');
+	string type = mline.substr(0, mline.find(' '));
-	this->type = mline.substr(0, p);
+	if (type == "application") {
-	if (p != string::npos)
+		removeApplication();
-		if (size_t q = mline.find(' ', p + 1); q != string::npos)
+		mApplication = std::make_shared<Application>(std::move(mid));
-			this->description = mline.substr(q + 1);
+		mEntries.emplace_back(mApplication);
+		return mApplication;
+	} else {
+		auto media = std::make_shared<Media>(std::move(mline), std::move(mid), dir);
+		mEntries.emplace_back(media);
+		return media;
+	}
 }
 
+void Description::removeApplication() {
+	if (!mApplication)
+		return;
+
+	auto it = std::find(mEntries.begin(), mEntries.end(), mApplication);
+	if (it != mEntries.end())
+		mEntries.erase(it);
+
+	mApplication.reset();
+}
+
+bool Description::hasApplication() const { return mApplication != nullptr; }
+
+bool Description::hasAudioOrVideo() const {
+	for (auto entry : mEntries)
+		if (entry != mApplication)
+			return true;
+
+	return false;
+}
+
+int Description::addMedia(Media media) {
+	mEntries.emplace_back(std::make_shared<Media>(std::move(media)));
+	return int(mEntries.size()) - 1;
+}
+
+int Description::addMedia(Application application) {
+	removeApplication();
+	mApplication = std::make_shared<Application>(std::move(application));
+	mEntries.emplace_back(mApplication);
+	return int(mEntries.size()) - 1;
+}
+
+int Description::addApplication(string mid) { return addMedia(Application(std::move(mid))); }
+
+Description::Application *Description::application() { return mApplication.get(); }
+
+int Description::addVideo(string mid, Direction dir) {
+	return addMedia(Video(std::move(mid), dir));
+}
+
+int Description::addAudio(string mid, Direction dir) {
+	return addMedia(Audio(std::move(mid), dir));
+}
+
+std::variant<Description::Media *, Description::Application *> Description::media(int index) {
+	if (index < 0 || index >= int(mEntries.size()))
+		throw std::out_of_range("Media index out of range");
+
+	const auto &entry = mEntries[index];
+	if (entry == mApplication) {
+		auto result = dynamic_cast<Application *>(entry.get());
+		if (!result)
+			throw std::logic_error("Bad type of application in description");
+		return result;
+	} else {
+		auto result = dynamic_cast<Media *>(entry.get());
+		if (!result)
+			throw std::logic_error("Bad type of media in description");
+		return result;
+	}
+}
+
+std::variant<const Description::Media *, const Description::Application *>
+Description::media(int index) const {
+	if (index < 0 || index >= int(mEntries.size()))
+		throw std::out_of_range("Media index out of range");
+
+	const auto &entry = mEntries[index];
+	if (entry == mApplication) {
+		auto result = dynamic_cast<Application *>(entry.get());
+		if (!result)
+			throw std::logic_error("Bad type of application in description");
+		return result;
+	} else {
+		auto result = dynamic_cast<Media *>(entry.get());
+		if (!result)
+			throw std::logic_error("Bad type of media in description");
+		return result;
+	}
+}
+
+int Description::mediaCount() const { return int(mEntries.size()); }
+
+Description::Entry::Entry(const string &mline, string mid, Direction dir)
+    : mMid(std::move(mid)), mDirection(dir) {
+
+	unsigned int port;
+	std::istringstream ss(mline);
+	ss >> mType;
+	ss >> port; // ignored
+	ss >> mDescription;
+}
+
+void Description::Entry::setDirection(Direction dir) { mDirection = dir; }
+
+Description::Entry::operator string() const { return generateSdp("\r\n"); }
+
+string Description::Entry::generateSdp(string_view eol) const {
+	std::ostringstream sdp;
+	// Port 9 is the discard protocol
+	sdp << "m=" << type() << ' ' << 9 << ' ' << description() << eol;
+	sdp << "c=IN IP4 0.0.0.0" << eol;
+	sdp << generateSdpLines(eol);
+
+	return sdp.str();
+}
+
+string Description::Entry::generateSdpLines(string_view eol) const {
+	std::ostringstream sdp;
+	sdp << "a=bundle-only" << eol;
+	sdp << "a=mid:" << mMid << eol;
+
+	switch (mDirection) {
+	case Direction::SendOnly:
+		sdp << "a=sendonly" << eol;
+		break;
+	case Direction::RecvOnly:
+		sdp << "a=recvonly" << eol;
+		break;
+	case Direction::SendRecv:
+		sdp << "a=sendrecv" << eol;
+		break;
+	case Direction::Inactive:
+		sdp << "a=inactive" << eol;
+		break;
+	default:
+		// Ignore
+		break;
+	}
+
+	for (const auto &attr : mAttributes)
+		sdp << "a=" << attr << eol;
+
+	return sdp.str();
+}
+
+void Description::Entry::parseSdpLine(string_view line) {
+	if (match_prefix(line, "a=")) {
+		string_view attr = line.substr(2);
+		auto [key, value] = parse_pair(attr);
+
+		if (key == "mid")
+			mMid = value;
+		else if (attr == "sendonly")
+			mDirection = Direction::SendOnly;
+		else if (attr == "recvonly")
+			mDirection = Direction::RecvOnly;
+		else if (key == "sendrecv")
+			mDirection = Direction::SendRecv;
+		else if (key == "inactive")
+			mDirection = Direction::Inactive;
+		else if (key == "bundle-only") {
+			// always added
+		} else
+			mAttributes.emplace_back(line.substr(2));
+	}
+}
+
+Description::Application::Application(string mid)
+    : Entry("application 9 UDP/DTLS/SCTP", std::move(mid), Direction::SendRecv) {}
+
+string Description::Application::description() const {
+	return Entry::description() + " webrtc-datachannel";
+}
+
+Description::Application Description::Application::reciprocate() const {
+	Application reciprocated(*this);
+
+	reciprocated.mMaxMessageSize.reset();
+
+	return reciprocated;
+}
+
+string Description::Application::generateSdpLines(string_view eol) const {
+	std::ostringstream sdp;
+	sdp << Entry::generateSdpLines(eol);
+
+	if (mSctpPort)
+		sdp << "a=sctp-port:" << *mSctpPort << eol;
+
+	if (mMaxMessageSize)
+		sdp << "a=max-message-size:" << *mMaxMessageSize << eol;
+
+	return sdp.str();
+}
+
+void Description::Application::parseSdpLine(string_view line) {
+	if (match_prefix(line, "a=")) {
+		string_view attr = line.substr(2);
+		auto [key, value] = parse_pair(attr);
+
+		if (key == "sctp-port") {
+			mSctpPort = to_integer<uint16_t>(value);
+		} else if (key == "max-message-size") {
+			mMaxMessageSize = to_integer<size_t>(value);
+		} else {
+			Entry::parseSdpLine(line);
+		}
+	} else {
+		Entry::parseSdpLine(line);
+	}
+}
+
+Description::Media::Media(const string &sdp) : Entry(sdp, "", Direction::Unknown) {
+	std::istringstream ss(sdp);
+	while (ss) {
+		string line;
+		std::getline(ss, line);
+		trim_end(line);
+		if (line.empty())
+			continue;
+
+		parseSdpLine(line);
+	}
+
+	if (mid().empty())
+		throw std::invalid_argument("Missing mid in media SDP");
+}
+
+Description::Media::Media(const string &mline, string mid, Direction dir)
+    : Entry(mline, std::move(mid), dir) {
+}
+
+string Description::Media::description() const {
+	std::ostringstream desc;
+	desc << Entry::description();
+	for (auto it = mRtpMap.begin(); it != mRtpMap.end(); ++it)
+		desc << ' ' << it->first;
+
+	return desc.str();
+}
+
+Description::Media Description::Media::reciprocate() const {
+	Media reciprocated(*this);
+
+	// Invert direction
+	switch (direction()) {
+	case Direction::RecvOnly:
+		reciprocated.setDirection(Direction::SendOnly);
+		break;
+	case Direction::SendOnly:
+		reciprocated.setDirection(Direction::RecvOnly);
+		break;
+	default:
+		// We are good
+		break;
+	}
+
+	return reciprocated;
+}
+
+Description::Media::RTPMap &Description::Media::getFormat(int fmt) {
+	auto it = mRtpMap.find(fmt);
+	if (it != mRtpMap.end())
+		return it->second;
+
+	throw std::invalid_argument("m-line index is out of bounds");
+}
+
+Description::Media::RTPMap &Description::Media::getFormat(const string &fmt) {
+	for (auto it = mRtpMap.begin(); it != mRtpMap.end(); ++it)
+		if (it->second.format == fmt)
+			return it->second;
+
+	throw std::invalid_argument("format was not found");
+}
+
+void Description::Media::removeFormat(const string &fmt) {
+	auto it = mRtpMap.begin();
+	std::vector<int> remed;
+
+	// Remove the actual formats
+	while (it != mRtpMap.end()) {
+		if (it->second.format == fmt) {
+			remed.emplace_back(it->first);
+			it = mRtpMap.erase(it);
+		} else {
+			it++;
+		}
+	}
+
+	// Remove any other rtpmaps that depend on the formats we just removed
+	it = mRtpMap.begin();
+	while (it != mRtpMap.end()) {
+		auto it2 = it->second.fmtps.begin();
+		bool rem = false;
+		while (it2 != it->second.fmtps.end()) {
+			if (it2->find("apt=") == 0) {
+				for (auto remid : remed) {
+					if (it2->find(std::to_string(remid)) != string::npos) {
+						std::cout << *it2 << ' ' << remid << std::endl;
+						it = mRtpMap.erase(it);
+						rem = true;
+						break;
+					}
+				}
+				break;
+			}
+			it2++;
+		}
+		if (!rem)
+			it++;
+	}
+}
+
+void Description::Media::addVideoCodec(int payloadType, const string &codec) {
+	RTPMap map(std::to_string(payloadType) + ' ' + codec + "/90000");
+	map.addFB("nack");
+	map.addFB("goog-remb");
+	if (codec == "H264") {
+		// Use Constrained Baseline profile Level 4.2 (necessary for Firefox)
+		// https://developer.mozilla.org/en-US/docs/Web/Media/Formats/WebRTC_codecs#Supported_video_codecs
+		// TODO: Should be 42E0 but 42C0 appears to be more compatible. Investigate this.
+		map.fmtps.emplace_back("profile-level-id=42E02A;level-asymmetry-allowed=1");
+	}
+	mRtpMap.emplace(map.pt, map);
+}
+
+void Description::Media::addH264Codec(int pt) { addVideoCodec(pt, "H264"); }
+
+void Description::Media::addVP8Codec(int payloadType) { addVideoCodec(payloadType, "VP8"); }
+
+void Description::Media::addVP9Codec(int payloadType) { addVideoCodec(payloadType, "VP9"); }
+
+void Description::Media::setBitrate(int bitrate) { mBas = bitrate; }
+
+int Description::Media::getBitrate() const { return mBas; }
+
+bool Description::Media::hasPayloadType(int payloadType) const {
+	return mRtpMap.find(payloadType) != mRtpMap.end();
+}
+
+string Description::Media::generateSdpLines(string_view eol) const {
+	std::ostringstream sdp;
+	if (mBas >= 0)
+		sdp << "b=AS:" << mBas << eol;
+
+	sdp << Entry::generateSdpLines(eol);
+	sdp << "a=rtcp-mux" << eol;
+
+	for (auto it = mRtpMap.begin(); it != mRtpMap.end(); ++it) {
+		auto &map = it->second;
+
+		// Create the a=rtpmap
+		sdp << "a=rtpmap:" << map.pt << ' ' << map.format << '/' << map.clockRate;
+		if (!map.encParams.empty())
+			sdp << '/' << map.encParams;
+		sdp << eol;
+
+		for (const auto &val : map.rtcpFbs)
+			sdp << "a=rtcp-fb:" << map.pt << ' ' << val << eol;
+		for (const auto &val : map.fmtps)
+			sdp << "a=fmtp:" << map.pt << ' ' << val << eol;
+	}
+
+	return sdp.str();
+}
+
+void Description::Media::parseSdpLine(string_view line) {
+	if (match_prefix(line, "a=")) {
+		string_view attr = line.substr(2);
+		auto [key, value] = parse_pair(attr);
+
+		if (key == "rtpmap") {
+			Description::Media::RTPMap map(value);
+			int pt = map.pt;
+			mRtpMap.emplace(pt, std::move(map));
+		} else if (key == "rtcp-fb") {
+			size_t p = value.find(' ');
+			int pt = to_integer<int>(value.substr(0, p));
+			auto it = mRtpMap.find(pt);
+			if (it == mRtpMap.end()) {
+				PLOG_WARNING << "rtcp-fb applied before the corresponding rtpmap, ignoring";
+			} else {
+				it->second.rtcpFbs.emplace_back(value.substr(p + 1));
+			}
+		} else if (key == "fmtp") {
+			size_t p = value.find(' ');
+			int pt = to_integer<int>(value.substr(0, p));
+			auto it = mRtpMap.find(pt);
+			if (it == mRtpMap.end()) {
+				PLOG_WARNING << "fmtp applied before the corresponding rtpmap, ignoring";
+			} else {
+				it->second.fmtps.emplace_back(value.substr(p + 1));
+			}
+		} else if (key == "rtcp-mux") {
+			// always added
+		} else {
+			Entry::parseSdpLine(line);
+		}
+	} else if (match_prefix(line, "b=AS")) {
+		mBas = to_integer<int>(line.substr(line.find(':') + 1));
+	} else {
+		Entry::parseSdpLine(line);
+	}
+}
+
+Description::Media::RTPMap::RTPMap(string_view mline) {
+	size_t p = mline.find(' ');
+
+	this->pt = to_integer<int>(mline.substr(0, p));
+
+	string_view line = mline.substr(p + 1);
+	size_t spl = line.find('/');
+	this->format = line.substr(0, spl);
+
+	line = line.substr(spl + 1);
+	spl = line.find('/');
+	if (spl == string::npos) {
+		spl = line.find(' ');
+	}
+	if (spl == string::npos)
+		this->clockRate = to_integer<int>(line);
+	else {
+		this->clockRate = to_integer<int>(line.substr(0, spl));
+		this->encParams = line.substr(spl);
+	}
+}
+
+void Description::Media::RTPMap::removeFB(const string &str) {
+	auto it = rtcpFbs.begin();
+	while (it != rtcpFbs.end()) {
+		if (it->find(str) != std::string::npos) {
+			it = rtcpFbs.erase(it);
+		} else
+			it++;
+	}
+}
+
+void Description::Media::RTPMap::addFB(const string &str) { rtcpFbs.emplace_back(str); }
+
+Description::Audio::Audio(string mid, Direction dir)
+    : Media("audio 9 UDP/TLS/RTP/SAVPF", std::move(mid), dir) {}
+
+Description::Video::Video(string mid, Direction dir)
+    : Media("video 9 UDP/TLS/RTP/SAVPF", std::move(mid), dir) {}
+
 Description::Type Description::stringToType(const string &typeString) {
 	if (typeString == "offer")
 		return Type::Offer;
@@ -324,4 +768,3 @@ string Description::roleToString(Role role) {
 std::ostream &operator<<(std::ostream &out, const rtc::Description &description) {
 	return out << std::string(description);
 }
-

src/dtlssrtptransport.cpp

@@ -45,6 +45,18 @@ DtlsSrtpTransport::DtlsSrtpTransport(std::shared_ptr<IceTransport> lower,
 
 	PLOG_DEBUG << "Initializing DTLS-SRTP transport";
 
+#if USE_GNUTLS
+	PLOG_DEBUG << "Setting SRTP profile (GnuTLS)";
+	gnutls::check(gnutls_srtp_set_profile(mSession, GNUTLS_SRTP_AES128_CM_HMAC_SHA1_80),
+	              "Failed to set SRTP profile");
+#else
+	PLOG_DEBUG << "Setting SRTP profile (OpenSSL)";
+	// returns 0 on success, 1 on error
+	if (SSL_set_tlsext_use_srtp(mSsl, "SRTP_AES128_CM_SHA1_80"))
+		throw std::runtime_error("Failed to set SRTP profile: " +
+		                         openssl::error_string(ERR_get_error()));
+#endif
+
 	if (srtp_err_status_t err = srtp_create(&mSrtpIn, nullptr)) {
 		throw std::runtime_error("SRTP create failed, status=" + to_string(static_cast<int>(err)));
 	}
@@ -55,7 +67,7 @@ DtlsSrtpTransport::DtlsSrtpTransport(std::shared_ptr<IceTransport> lower,
 }
 
 DtlsSrtpTransport::~DtlsSrtpTransport() {
-	stop();
+	stop(); // stop before deallocating
 
 	srtp_dealloc(mSrtpIn);
 	srtp_dealloc(mSrtpOut);
@@ -74,7 +86,8 @@ bool DtlsSrtpTransport::sendMedia(message_ptr message) {
 	PLOG_VERBOSE << "Send size=" << size;
 
 	// The RTP header has a minimum size of 12 bytes
-	if (size < 12)
+	// An RTCP packet can have a minimum size of 8 bytes
+	if (size < 8)
 		throw std::runtime_error("RTP/RTCP packet too short");
 
 	// srtp_protect() and srtp_protect_rtcp() assume that they can write SRTP_MAX_TRAILER_LEN (for
@@ -86,6 +99,7 @@ bool DtlsSrtpTransport::sendMedia(message_ptr message) {
 	             << unsigned(value2);
 
 	// RFC 5761 Multiplexing RTP and RTCP 4. Distinguishable RTP and RTCP Packets
+	// https://tools.ietf.org/html/rfc5761#section-4
 	// It is RECOMMENDED to follow the guidelines in the RTP/AVP profile for the choice of RTP
 	// payload type values, with the additional restriction that payload type values in the
 	// range 64-95 MUST NOT be used. Specifically, dynamic RTP payload types SHOULD be chosen in
@@ -112,8 +126,8 @@ bool DtlsSrtpTransport::sendMedia(message_ptr message) {
 	}
 
 	message->resize(size);
-	outgoing(message);
+	return outgoing(message);
-	return true;
+//	return DtlsTransport::send(message);
 }
 
 void DtlsSrtpTransport::incoming(message_ptr message) {
@@ -128,6 +142,7 @@ void DtlsSrtpTransport::incoming(message_ptr message) {
 		return;
 
 	// RFC 5764 5.1.2. Reception
+	// https://tools.ietf.org/html/rfc5764#section-5.1.2
 	// The process for demultiplexing a packet is as follows. The receiver looks at the first byte
 	// of the packet. [...] If the value is in between 128 and 191 (inclusive), then the packet is
 	// RTP (or RTCP [...]). If the value is between 20 and 63 (inclusive), the packet is DTLS.
@@ -141,7 +156,8 @@ void DtlsSrtpTransport::incoming(message_ptr message) {
 
 	} else if (value1 >= 128 && value1 <= 191) {
 		// The RTP header has a minimum size of 12 bytes
-		if (size < 12) {
+		// An RTCP packet can have a minimum size of 8 bytes
+		if (size < 8) {
 			PLOG_WARNING << "Incoming SRTP/SRTCP packet too short, size=" << size;
 			return;
 		}
@@ -156,21 +172,29 @@ void DtlsSrtpTransport::incoming(message_ptr message) {
 			if (srtp_err_status_t err = srtp_unprotect_rtcp(mSrtpIn, message->data(), &size)) {
 				if (err == srtp_err_status_replay_fail)
 					PLOG_WARNING << "Incoming SRTCP packet is a replay";
+				else if (err == srtp_err_status_auth_fail)
+					PLOG_WARNING << "Incoming SRTCP packet failed authentication check";
 				else
 					PLOG_WARNING << "SRTCP unprotect error, status=" << err;
 				return;
 			}
 			PLOG_VERBOSE << "Unprotected SRTCP packet, size=" << size;
+			message->type = Message::Type::Control;
+			message->stream = to_integer<uint8_t>(*(message->begin() + 1)); // Payload Type
 		} else {
 			PLOG_VERBOSE << "Incoming SRTP packet, size=" << size;
 			if (srtp_err_status_t err = srtp_unprotect(mSrtpIn, message->data(), &size)) {
 				if (err == srtp_err_status_replay_fail)
 					PLOG_WARNING << "Incoming SRTP packet is a replay";
+				else if (err == srtp_err_status_auth_fail)
+					PLOG_WARNING << "Incoming SRTP packet failed authentication check";
 				else
 					PLOG_WARNING << "SRTP unprotect error, status=" << err;
 				return;
 			}
 			PLOG_VERBOSE << "Unprotected SRTP packet, size=" << size;
+			message->type = Message::Type::Binary;
+			message->stream = value2; // Payload Type
 		}
 
 		message->resize(size);
@@ -181,19 +205,6 @@ void DtlsSrtpTransport::incoming(message_ptr message) {
 	}
 }
 
-void DtlsSrtpTransport::postCreation() {
-#if USE_GNUTLS
-	PLOG_DEBUG << "Setting SRTP profile (GnuTLS)";
-	gnutls::check(gnutls_srtp_set_profile(mSession, GNUTLS_SRTP_AES128_CM_HMAC_SHA1_80),
-	              "Failed to set SRTP profile");
-#else
-	PLOG_DEBUG << "Setting SRTP profile (OpenSSL)";
-	// returns 0 on success, 1 on error
-	if (SSL_set_tlsext_use_srtp(mSsl, "SRTP_AES128_CM_SHA1_80"), "Failed to set SRTP profile")
-		throw std::runtime_error("Failed to set SRTP profile: " + openssl::error_string(ERR_get_error()));
-#endif
-}
-
 void DtlsSrtpTransport::postHandshake() {
 	if (mInitDone)
 		return;
@@ -239,11 +250,11 @@ void DtlsSrtpTransport::postHandshake() {
 		throw std::runtime_error("Failed to derive SRTP keys: " +
 		                         openssl::error_string(ERR_get_error()));
 
+	// Order is client key, server key, client salt, and server salt
 	clientKey = material;
-	clientSalt = clientKey + SRTP_AES_128_KEY_LEN;
+	serverKey = clientKey + SRTP_AES_128_KEY_LEN;
-
+	clientSalt = serverKey + SRTP_AES_128_KEY_LEN;
-	serverKey = material + SRTP_AES_ICM_128_KEY_LEN_WSALT;
+	serverSalt = clientSalt + SRTP_SALT_LEN;
-	serverSalt = serverKey + SRTP_AES_128_KEY_LEN;
 #endif
 
 	unsigned char clientSessionKey[SRTP_AES_ICM_128_KEY_LEN_WSALT];

src/dtlssrtptransport.hpp

@@ -42,7 +42,6 @@ public:
 
 private:
 	void incoming(message_ptr message) override;
-	void postCreation() override;
 	void postHandshake() override;
 
 	message_callback mSrtpRecvCallback;

src/dtlstransport.cpp

@@ -85,11 +85,6 @@ DtlsTransport::DtlsTransport(shared_ptr<IceTransport> lower, certificate_ptr cer
 		gnutls_transport_set_pull_function(mSession, ReadCallback);
 		gnutls_transport_set_pull_timeout_function(mSession, TimeoutCallback);
 
-		postCreation();
-
-		mRecvThread = std::thread(&DtlsTransport::runRecvLoop, this);
-		registerIncoming();
-
 	} catch (...) {
 		gnutls_deinit(mSession);
 		throw;
@@ -102,6 +97,15 @@ DtlsTransport::~DtlsTransport() {
 	gnutls_deinit(mSession);
 }
 
+void DtlsTransport::start() {
+	Transport::start();
+
+	registerIncoming();
+
+	PLOG_DEBUG << "Starting DTLS recv thread";
+	mRecvThread = std::thread(&DtlsTransport::runRecvLoop, this);
+}
+
 bool DtlsTransport::stop() {
 	if (!Transport::stop())
 		return false;
@@ -139,17 +143,12 @@ void DtlsTransport::incoming(message_ptr message) {
 	mIncomingQueue.push(message);
 }
 
-void DtlsTransport::postCreation() {
-	// Dummy
-}
-
 void DtlsTransport::postHandshake() {
 	// Dummy
 }
 
 void DtlsTransport::runRecvLoop() {
 	const size_t maxMtu = 4096;
-
 	// Handshake loop
 	try {
 		changeState(State::Connecting);
@@ -259,7 +258,7 @@ ssize_t DtlsTransport::WriteCallback(gnutls_transport_ptr_t ptr, const void *dat
 ssize_t DtlsTransport::ReadCallback(gnutls_transport_ptr_t ptr, void *data, size_t maxlen) {
 	DtlsTransport *t = static_cast<DtlsTransport *>(ptr);
 	if (auto next = t->mIncomingQueue.pop()) {
-		auto message = *next;
+		message_ptr message = std::move(*next);
 		ssize_t len = std::min(maxlen, message->size());
 		std::memcpy(data, message->data(), len);
 		gnutls_transport_set_errno(t->mSession, 0);
@@ -272,9 +271,9 @@ ssize_t DtlsTransport::ReadCallback(gnutls_transport_ptr_t ptr, void *data, size
 
 int DtlsTransport::TimeoutCallback(gnutls_transport_ptr_t ptr, unsigned int ms) {
 	DtlsTransport *t = static_cast<DtlsTransport *>(ptr);
-	t->mIncomingQueue.wait(ms != GNUTLS_INDEFINITE_TIMEOUT ? std::make_optional(milliseconds(ms))
+	bool notEmpty = t->mIncomingQueue.wait(
-	                                                       : nullopt);
+	    ms != GNUTLS_INDEFINITE_TIMEOUT ? std::make_optional(milliseconds(ms)) : nullopt);
-	return !t->mIncomingQueue.empty() ? 1 : 0;
+	return notEmpty ? 1 : 0;
 }
 
 #else // USE_GNUTLS==0
@@ -364,9 +363,6 @@ DtlsTransport::DtlsTransport(shared_ptr<IceTransport> lower, shared_ptr<Certific
 		SSL_set_options(mSsl, SSL_OP_SINGLE_ECDH_USE);
 		SSL_set_tmp_ecdh(mSsl, ecdh.get());
 
-		mRecvThread = std::thread(&DtlsTransport::runRecvLoop, this);
-		registerIncoming();
-
 	} catch (...) {
 		if (mSsl)
 			SSL_free(mSsl);
@@ -383,6 +379,15 @@ DtlsTransport::~DtlsTransport() {
 	SSL_CTX_free(mCtx);
 }
 
+void DtlsTransport::start() {
+	Transport::start();
+
+	registerIncoming();
+
+	PLOG_DEBUG << "Starting DTLS recv thread";
+	mRecvThread = std::thread(&DtlsTransport::runRecvLoop, this);
+}
+
 bool DtlsTransport::stop() {
 	if (!Transport::stop())
 		return false;
@@ -414,10 +419,6 @@ void DtlsTransport::incoming(message_ptr message) {
 	mIncomingQueue.push(message);
 }
 
-void DtlsTransport::postCreation() {
-	// Dummy
-}
-
 void DtlsTransport::postHandshake() {
 	// Dummy
 }
@@ -434,10 +435,10 @@ void DtlsTransport::runRecvLoop() {
 
 		const size_t bufferSize = maxMtu;
 		byte buffer[bufferSize];
-		while (true) {
+		while (mIncomingQueue.running()) {
 			// Process pending messages
-			while (!mIncomingQueue.empty()) {
+			while (auto next = mIncomingQueue.tryPop()) {
-				auto message = *mIncomingQueue.pop();
+				message_ptr message = std::move(*next);
 				BIO_write(mInBio, message->data(), int(message->size()));
 
 				if (state() == State::Connecting) {
@@ -491,8 +492,7 @@ void DtlsTransport::runRecvLoop() {
 				}
 			}
 
-			if (!mIncomingQueue.wait(duration))
+			mIncomingQueue.wait(duration);
-				break; // queue is stopped
 		}
 	} catch (const std::exception &e) {
 		PLOG_ERROR << "DTLS recv: " << e.what();

src/dtlstransport.hpp

@@ -47,12 +47,12 @@ public:
 	              verifier_callback verifierCallback, state_callback stateChangeCallback);
 	~DtlsTransport();
 
+	virtual void start() override;
 	virtual bool stop() override;
 	virtual bool send(message_ptr message) override; // false if dropped
 
 protected:
 	virtual void incoming(message_ptr message) override;
-	virtual void postCreation();
 	virtual void postHandshake();
 	void runRecvLoop();
 

src/icetransport.cpp

@@ -58,8 +58,31 @@ IceTransport::IceTransport(const Configuration &config, Description::Role role,
 	if (config.enableIceTcp) {
 		PLOG_WARNING << "ICE-TCP is not supported with libjuice";
 	}
+
+	juice_log_level_t level;
+	switch (plog::get()->getMaxSeverity()) {
+	case plog::none:
+		level = JUICE_LOG_LEVEL_NONE;
+		break;
+	case plog::fatal:
+		level = JUICE_LOG_LEVEL_VERBOSE;
+		break;
+	case plog::error:
+		level = JUICE_LOG_LEVEL_ERROR;
+		break;
+	case plog::warning:
+		level = JUICE_LOG_LEVEL_WARN;
+		break;
+	case plog::info:
+	case plog::debug: // juice debug is output as verbose
+		level = JUICE_LOG_LEVEL_INFO;
+		break;
+	default:
+		level = JUICE_LOG_LEVEL_VERBOSE;
+		break;
+	}
 	juice_set_log_handler(IceTransport::LogCallback);
-	juice_set_log_level(JUICE_LOG_LEVEL_VERBOSE);
+	juice_set_log_level(level);
 
 	juice_config_t jconfig = {};
 	jconfig.cb_state_changed = IceTransport::StateChangeCallback;
@@ -123,9 +146,10 @@ Description IceTransport::getLocalDescription(Description::Type type) const {
 void IceTransport::setRemoteDescription(const Description &description) {
 	mRole = description.role() == Description::Role::Active ? Description::Role::Passive
 	                                                        : Description::Role::Active;
-	mMid = description.dataMid();
+	mMid = description.bundleMid();
-	if (juice_set_remote_description(mAgent.get(), string(description).c_str()) < 0)
+	if (juice_set_remote_description(mAgent.get(),
-		throw std::runtime_error("Failed to parse remote SDP");
+	                                 description.generateApplicationSdp("\r\n").c_str()) < 0)
+		throw std::runtime_error("Failed to parse ICE settings from remote SDP");
 }
 
 bool IceTransport::addRemoteCandidate(const Candidate &candidate) {
@@ -356,8 +380,11 @@ IceTransport::IceTransport(const Configuration &config, Description::Role role,
 		hints.ai_protocol = IPPROTO_UDP;
 		hints.ai_flags = AI_ADDRCONFIG;
 		struct addrinfo *result = nullptr;
-		if (getaddrinfo(server.hostname.c_str(), server.service.c_str(), &hints, &result) != 0)
+		if (getaddrinfo(server.hostname.c_str(), server.service.c_str(), &hints, &result) != 0) {
+			PLOG_WARNING << "Unable to resolve STUN server address: " << server.hostname << ':'
+			             << server.service;
 			continue;
+		}
 
 		for (auto p = result; p; p = p->ai_next) {
 			if (p->ai_family == AF_INET) {
@@ -399,8 +426,11 @@ IceTransport::IceTransport(const Configuration &config, Description::Role role,
 		    server.relayType == IceServer::RelayType::TurnUdp ? IPPROTO_UDP : IPPROTO_TCP;
 		hints.ai_flags = AI_ADDRCONFIG;
 		struct addrinfo *result = nullptr;
-		if (getaddrinfo(server.hostname.c_str(), server.service.c_str(), &hints, &result) != 0)
+		if (getaddrinfo(server.hostname.c_str(), server.service.c_str(), &hints, &result) != 0) {
+			PLOG_WARNING << "Unable to resolve TURN server address: " << server.hostname << ':'
+			             << server.service;
 			continue;
+		}
 
 		for (auto p = result; p; p = p->ai_next) {
 			if (p->ai_family == AF_INET || p->ai_family == AF_INET6) {
@@ -483,12 +513,13 @@ Description IceTransport::getLocalDescription(Description::Type type) const {
 void IceTransport::setRemoteDescription(const Description &description) {
 	mRole = description.role() == Description::Role::Active ? Description::Role::Passive
 	                                                        : Description::Role::Active;
-	mMid = description.dataMid();
+	mMid = description.bundleMid();
 	mTrickleTimeout = !description.ended() ? 30s : 0s;
 
 	// Warning: libnice expects "\n" as end of line
-	if (nice_agent_parse_remote_sdp(mNiceAgent.get(), description.generateSdp("\n").c_str()) < 0)
+	if (nice_agent_parse_remote_sdp(mNiceAgent.get(),
-		throw std::runtime_error("Failed to parse remote SDP");
+	                                description.generateApplicationSdp("\n").c_str()) < 0)
+		throw std::runtime_error("Failed to parse ICE settings from remote SDP");
 }
 
 bool IceTransport::addRemoteCandidate(const Candidate &candidate) {
@@ -622,7 +653,8 @@ void IceTransport::CandidateCallback(NiceAgent *agent, NiceCandidate *candidate,
 	g_free(cand);
 }
 
-void IceTransport::GatheringDoneCallback(NiceAgent *agent, guint streamId, gpointer userData) {
+void IceTransport::GatheringDoneCallback(NiceAgent * /*agent*/, guint /*streamId*/,
+                                         gpointer userData) {
 	auto iceTransport = static_cast<rtc::IceTransport *>(userData);
 	try {
 		iceTransport->processGatheringDone();
@@ -631,8 +663,8 @@ void IceTransport::GatheringDoneCallback(NiceAgent *agent, guint streamId, gpoin
 	}
 }
 
-void IceTransport::StateChangeCallback(NiceAgent *agent, guint streamId, guint componentId,
+void IceTransport::StateChangeCallback(NiceAgent * /*agent*/, guint /*streamId*/,
-                                       guint state, gpointer userData) {
+                                       guint /*componentId*/, guint state, gpointer userData) {
 	auto iceTransport = static_cast<rtc::IceTransport *>(userData);
 	try {
 		iceTransport->processStateChange(state);
@@ -641,8 +673,8 @@ void IceTransport::StateChangeCallback(NiceAgent *agent, guint streamId, guint c
 	}
 }
 
-void IceTransport::RecvCallback(NiceAgent *agent, guint streamId, guint componentId, guint len,
+void IceTransport::RecvCallback(NiceAgent * /*agent*/, guint /*streamId*/, guint /*componentId*/,
-                                gchar *buf, gpointer userData) {
+                                guint len, gchar *buf, gpointer userData) {
 	auto iceTransport = static_cast<rtc::IceTransport *>(userData);
 	try {
 		PLOG_VERBOSE << "Incoming size=" << len;
@@ -663,8 +695,8 @@ gboolean IceTransport::TimeoutCallback(gpointer userData) {
 	return FALSE;
 }
 
-void IceTransport::LogCallback(const gchar *logDomain, GLogLevelFlags logLevel,
+void IceTransport::LogCallback(const gchar * /*logDomain*/, GLogLevelFlags logLevel,
-                               const gchar *message, gpointer userData) {
+                               const gchar *message, gpointer /*userData*/) {
 	plog::Severity severity;
 	unsigned int flags = logLevel & G_LOG_LEVEL_MASK;
 	if (flags & G_LOG_LEVEL_ERROR)
@@ -708,7 +740,7 @@ bool IceTransport::getSelectedCandidatePair(CandidateInfo *localInfo, CandidateI
 	return true;
 }
 
-const CandidateType IceTransport::NiceTypeToCandidateType(NiceCandidateType type) {
+CandidateType IceTransport::NiceTypeToCandidateType(NiceCandidateType type) {
 	switch (type) {
 	case NiceCandidateType::NICE_CANDIDATE_TYPE_PEER_REFLEXIVE:
 		return CandidateType::PeerReflexive;
@@ -721,7 +753,7 @@ const CandidateType IceTransport::NiceTypeToCandidateType(NiceCandidateType type
 	}
 }
 
-const CandidateTransportType
+CandidateTransportType
 IceTransport::NiceTransportTypeToCandidateTransportType(NiceCandidateTransport type) {
 	switch (type) {
 	case NiceCandidateTransport::NICE_CANDIDATE_TRANSPORT_TCP_ACTIVE:

src/icetransport.hpp

@@ -113,8 +113,9 @@ private:
 	static gboolean TimeoutCallback(gpointer userData);
 	static void LogCallback(const gchar *log_domain, GLogLevelFlags log_level, const gchar *message,
 	                        gpointer user_data);
-	static const CandidateType NiceTypeToCandidateType(NiceCandidateType type);
+	static CandidateType NiceTypeToCandidateType(NiceCandidateType type);
-	static const CandidateTransportType NiceTransportTypeToCandidateTransportType(NiceCandidateTransport type);
+	static CandidateTransportType
+	NiceTransportTypeToCandidateTransportType(NiceCandidateTransport type);
 #endif
 };
 

src/message.cpp

@@ -0,0 +1,60 @@
+/**
+ * Copyright (c) 2019-2020 Paul-Louis Ageneau
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include "message.hpp"
+
+namespace rtc {
+
+message_ptr make_message(size_t size, Message::Type type, unsigned int stream,
+                         std::shared_ptr<Reliability> reliability) {
+	auto message = std::make_shared<Message>(size, type);
+	message->stream = stream;
+	message->reliability = reliability;
+	return message;
+}
+
+message_ptr make_message(binary &&data, Message::Type type, unsigned int stream,
+                         std::shared_ptr<Reliability> reliability) {
+	auto message = std::make_shared<Message>(std::move(data), type);
+	message->stream = stream;
+	message->reliability = reliability;
+	return message;
+}
+
+message_ptr make_message(message_variant data) {
+	return std::visit( //
+	    overloaded{
+	        [&](binary data) { return make_message(std::move(data), Message::Binary); },
+	        [&](string data) {
+		        auto b = reinterpret_cast<const byte *>(data.data());
+		        return make_message(b, b + data.size(), Message::String);
+	        },
+	    },
+	    std::move(data));
+}
+
+message_variant to_variant(Message &&message) {
+	switch (message.type) {
+	case Message::String:
+		return string(reinterpret_cast<const char *>(message.data()), message.size());
+	default:
+		return std::move(message);
+	}
+}
+
+} // namespace rtc

src/peerconnection.cpp

@@ -30,6 +30,7 @@
 #include "dtlssrtptransport.hpp"
 #endif
 
+#include <iomanip>
 #include <thread>
 
 namespace rtc {
@@ -81,26 +82,84 @@ std::optional<Description> PeerConnection::remoteDescription() const {
 	return mRemoteDescription;
 }
 
-void PeerConnection::setLocalDescription(std::optional<Description> description) {
+bool PeerConnection::hasLocalDescription() const {
-	if (auto iceTransport = std::atomic_load(&mIceTransport)) {
+	std::lock_guard lock(mLocalDescriptionMutex);
-		throw std::logic_error("Local description is already set");
+	return bool(mLocalDescription);
-	} else {
+}
-		// RFC 5763: The endpoint that is the offerer MUST use the setup attribute value of
+
-		// setup:actpass.
+bool PeerConnection::hasRemoteDescription() const {
-		// See https://tools.ietf.org/html/rfc5763#section-5
+	std::lock_guard lock(mRemoteDescriptionMutex);
-		iceTransport = initIceTransport(Description::Role::ActPass);
+	return bool(mRemoteDescription);
-		Description localDescription = iceTransport->getLocalDescription(Description::Type::Offer);
+}
-		if (description)
+
-			localDescription.addMedia(*description);
+bool PeerConnection::hasMedia() const {
-		processLocalDescription(localDescription);
+	auto local = localDescription();
-		iceTransport->gatherLocalCandidates();
+	return local && local->hasAudioOrVideo();
+}
+
+void PeerConnection::setLocalDescription() {
+	PLOG_VERBOSE << "Setting local description";
+
+	if (std::atomic_load(&mIceTransport)) {
+		PLOG_DEBUG << "Local description is already set, ignoring";
+		return;
 	}
+
+	// RFC 5763: The endpoint that is the offerer MUST use the setup attribute value of
+	// setup:actpass.
+	// See https://tools.ietf.org/html/rfc5763#section-5
+	auto iceTransport = initIceTransport(Description::Role::ActPass);
+	Description localDescription = iceTransport->getLocalDescription(Description::Type::Offer);
+	processLocalDescription(localDescription);
+	iceTransport->gatherLocalCandidates();
 }
 
 void PeerConnection::setRemoteDescription(Description description) {
-	description.hintType(localDescription() ? Description::Type::Answer : Description::Type::Offer);
+	PLOG_VERBOSE << "Setting remote description: " << string(description);
-	auto type = description.type();
+
-	auto remoteCandidates = description.extractCandidates(); // Candidates will be added at the end
+	if (hasRemoteDescription())
+		throw std::logic_error("Remote description is already set");
+
+	if (description.mediaCount() == 0)
+		throw std::invalid_argument("Remote description has no media line");
+
+	int activeMediaCount = 0;
+	for (int i = 0; i < description.mediaCount(); ++i)
+		std::visit( // reciprocate each media
+		    rtc::overloaded{[&](Description::Application *) { ++activeMediaCount; },
+		                    [&](Description::Media *media) {
+			                    if (media->direction() != Description::Direction::Inactive)
+				                    ++activeMediaCount;
+		                    }},
+		    description.media(i));
+
+	if (activeMediaCount == 0)
+		throw std::invalid_argument("Remote description has no active media");
+
+	if (!description.fingerprint())
+		throw std::invalid_argument("Remote description has no fingerprint");
+
+	description.hintType(hasLocalDescription() ? Description::Type::Answer
+	                                           : Description::Type::Offer);
+
+	if (description.type() == Description::Type::Offer) {
+		if (hasLocalDescription()) {
+			PLOG_ERROR << "Got a remote offer description while an answer was expected";
+			throw std::logic_error("Got an unexpected remote offer description");
+		}
+	} else { // Answer
+		if (auto local = localDescription()) {
+			if (description.iceUfrag() == local->iceUfrag() &&
+			    description.icePwd() == local->icePwd())
+				throw std::logic_error("Got the local description as remote description");
+		} else {
+			PLOG_ERROR << "Got a remote answer description while an offer was expected";
+			throw std::logic_error("Got an unexpected remote answer description");
+		}
+	}
+
+	// Candidates will be added at the end, extract them for now
+	auto remoteCandidates = description.extractCandidates();
 
 	auto iceTransport = std::atomic_load(&mIceTransport);
 	if (!iceTransport)
@@ -108,14 +167,14 @@ void PeerConnection::setRemoteDescription(Description description) {
 	iceTransport->setRemoteDescription(description);
 
 	{
+		// Set as remote description
 		std::lock_guard lock(mRemoteDescriptionMutex);
 		mRemoteDescription.emplace(std::move(description));
 	}
 
-	if (type == Description::Type::Offer) {
+	if (description.type() == Description::Type::Offer) {
 		// This is an offer and we are the answerer.
 		Description localDescription = iceTransport->getLocalDescription(Description::Type::Answer);
-		localDescription.addMedia(description); // blindly accept media
 		processLocalDescription(localDescription);
 		iceTransport->gatherLocalCandidates();
 	} else {
@@ -143,6 +202,7 @@ void PeerConnection::setRemoteDescription(Description description) {
 }
 
 void PeerConnection::addRemoteCandidate(Candidate candidate) {
+	PLOG_VERBOSE << "Adding remote candidate: " << string(candidate);
 
 	auto iceTransport = std::atomic_load(&mIceTransport);
 	if (!mRemoteDescription || !iceTransport)
@@ -176,9 +236,13 @@ std::optional<string> PeerConnection::remoteAddress() const {
 	return iceTransport ? iceTransport->getRemoteAddress() : nullopt;
 }
 
-shared_ptr<DataChannel> PeerConnection::createDataChannel(const string &label,
+shared_ptr<DataChannel> PeerConnection::addDataChannel(string label, string protocol,
-                                                          const string &protocol,
+                                                       Reliability reliability) {
-                                                          const Reliability &reliability) {
+	if (auto local = localDescription(); local && !local->hasApplication()) {
+		PLOG_ERROR << "The PeerConnection was negociated without DataChannel support.";
+		throw std::runtime_error("No DataChannel support on the PeerConnection");
+	}
+
 	// RFC 5763: The answerer MUST use either a setup attribute value of setup:active or
 	// setup:passive. [...] Thus, setup:active is RECOMMENDED.
 	// See https://tools.ietf.org/html/rfc5763#section-5
@@ -186,20 +250,20 @@ shared_ptr<DataChannel> PeerConnection::createDataChannel(const string &label,
 	auto iceTransport = std::atomic_load(&mIceTransport);
 	auto role = iceTransport ? iceTransport->role() : Description::Role::Passive;
 
-	auto channel = emplaceDataChannel(role, label, protocol, reliability);
+	auto channel =
+	    emplaceDataChannel(role, std::move(label), std::move(protocol), std::move(reliability));
 
-	if (!iceTransport) {
+	if (auto transport = std::atomic_load(&mSctpTransport))
-		// RFC 5763: The endpoint that is the offerer MUST use the setup attribute value of
+		if (transport->state() == SctpTransport::State::Connected)
-		// setup:actpass.
+			channel->open(transport);
-		// See https://tools.ietf.org/html/rfc5763#section-5
+
-		iceTransport = initIceTransport(Description::Role::ActPass);
+	return channel;
-		processLocalDescription(iceTransport->getLocalDescription(Description::Type::Offer));
+}
-		iceTransport->gatherLocalCandidates();
+
-	} else {
+shared_ptr<DataChannel> PeerConnection::createDataChannel(string label, string protocol,
-		if (auto transport = std::atomic_load(&mSctpTransport))
+                                                          Reliability reliability) {
-			if (transport->state() == SctpTransport::State::Connected)
+	auto channel = addDataChannel(label, protocol, reliability);
-				channel->open(transport);
+	setLocalDescription();
-	}
 	return channel;
 }
 
@@ -208,12 +272,11 @@ void PeerConnection::onDataChannel(
 	mDataChannelCallback = callback;
 }
 
-void PeerConnection::onLocalDescription(
+void PeerConnection::onLocalDescription(std::function<void(Description description)> callback) {
-    std::function<void(const Description &description)> callback) {
 	mLocalDescriptionCallback = callback;
 }
 
-void PeerConnection::onLocalCandidate(std::function<void(const Candidate &candidate)> callback) {
+void PeerConnection::onLocalCandidate(std::function<void(Candidate candidate)> callback) {
 	mLocalCandidateCallback = callback;
 }
 
@@ -225,37 +288,26 @@ void PeerConnection::onGatheringStateChange(std::function<void(GatheringState st
 	mGatheringStateChangeCallback = callback;
 }
 
-bool PeerConnection::hasMedia() const {
+std::shared_ptr<Track> PeerConnection::addTrack(Description::Media description) {
-	auto local = localDescription();
+	if (hasLocalDescription())
-	auto remote = remoteDescription();
+		throw std::logic_error("Tracks must be created before local description");
-	return (local && local->hasMedia()) || (remote && remote->hasMedia());
-}
 
-void PeerConnection::sendMedia(const binary &packet) {
+	if (auto it = mTracks.find(description.mid()); it != mTracks.end())
-	outgoingMedia(make_message(packet.begin(), packet.end(), Message::Binary));
+		if (auto track = it->second.lock())
-}
+			return track;
 
-void PeerConnection::sendMedia(const byte *packet, size_t size) {
+#if !RTC_ENABLE_MEDIA
-	outgoingMedia(make_message(packet, packet + size, Message::Binary));
+	if (mTracks.empty()) {
-}
+		PLOG_WARNING << "Tracks will be inative (not compiled with SRTP support)";
-
+	}
-void PeerConnection::onMedia(std::function<void(const binary &packet)> callback) {
-	mMediaCallback = callback;
-}
-
-void PeerConnection::outgoingMedia(message_ptr message) {
-	if (!hasMedia())
-		throw std::runtime_error("PeerConnection has no media support");
-
-#if RTC_ENABLE_MEDIA
-	auto transport = std::atomic_load(&mDtlsTransport);
-	if (!transport)
-		throw std::runtime_error("PeerConnection is not open");
-
-	std::dynamic_pointer_cast<DtlsSrtpTransport>(transport)->sendMedia(message);
-#else
-	PLOG_WARNING << "Ignoring sent media (not compiled with SRTP support)";
 #endif
+	auto track = std::make_shared<Track>(std::move(description));
+	mTracks.emplace(std::make_pair(track->mid(), track));
+	return track;
+}
+
+void PeerConnection::onTrack(std::function<void(std::shared_ptr<Track>)> callback) {
+	mTrackCallback = callback;
 }
 
 shared_ptr<IceTransport> PeerConnection::initIceTransport(Description::Role role) {
@@ -308,9 +360,9 @@ shared_ptr<IceTransport> PeerConnection::initIceTransport(Description::Role role
 		std::atomic_store(&mIceTransport, transport);
 		if (mState == State::Closed) {
 			mIceTransport.reset();
-			transport->stop();
 			throw std::runtime_error("Connection is closed");
 		}
+		transport->start();
 		return transport;
 
 	} catch (const std::exception &e) {
@@ -336,7 +388,12 @@ shared_ptr<DtlsTransport> PeerConnection::initDtlsTransport() {
 
 			switch (state) {
 			case DtlsTransport::State::Connected:
-				initSctpTransport();
+				if (auto local = localDescription(); local && local->hasApplication())
+					initSctpTransport();
+				else
+					changeState(State::Connected);
+
+				openTracks();
 				break;
 			case DtlsTransport::State::Failed:
 				changeState(State::Failed);
@@ -373,9 +430,9 @@ shared_ptr<DtlsTransport> PeerConnection::initDtlsTransport() {
 		std::atomic_store(&mDtlsTransport, transport);
 		if (mState == State::Closed) {
 			mDtlsTransport.reset();
-			transport->stop();
 			throw std::runtime_error("Connection is closed");
 		}
+		transport->start();
 		return transport;
 
 	} catch (const std::exception &e) {
@@ -390,7 +447,11 @@ shared_ptr<SctpTransport> PeerConnection::initSctpTransport() {
 		if (auto transport = std::atomic_load(&mSctpTransport))
 			return transport;
 
-		uint16_t sctpPort = remoteDescription()->sctpPort().value_or(DEFAULT_SCTP_PORT);
+		auto remote = remoteDescription();
+		if (!remote || !remote->application())
+			throw std::logic_error("Initializing SCTP transport without application description");
+
+		uint16_t sctpPort = remote->application()->sctpPort().value_or(DEFAULT_SCTP_PORT);
 		auto lower = std::atomic_load(&mDtlsTransport);
 		auto transport = std::make_shared<SctpTransport>(
 		    lower, sctpPort, weak_bind(&PeerConnection::forwardMessage, this, _1),
@@ -407,13 +468,7 @@ shared_ptr<SctpTransport> PeerConnection::initSctpTransport() {
 			    case SctpTransport::State::Failed:
 				    LOG_WARNING << "SCTP transport failed";
 				    remoteCloseDataChannels();
-#if RTC_ENABLE_MEDIA
-				    // Ignore SCTP failure if media is present
-				    if (!hasMedia())
-					    changeState(State::Failed);
-#else
 				    changeState(State::Failed);
-#endif
 				    break;
 			    case SctpTransport::State::Disconnected:
 				    remoteCloseDataChannels();
@@ -428,9 +483,9 @@ shared_ptr<SctpTransport> PeerConnection::initSctpTransport() {
 		std::atomic_store(&mSctpTransport, transport);
 		if (mState == State::Closed) {
 			mSctpTransport.reset();
-			transport->stop();
 			throw std::runtime_error("Connection is closed");
 		}
+		transport->start();
 		return transport;
 
 	} catch (const std::exception &e) {
@@ -492,17 +547,17 @@ void PeerConnection::forwardMessage(message_ptr message) {
 	}
 
 	auto channel = findDataChannel(uint16_t(message->stream));
-
-	auto iceTransport = std::atomic_load(&mIceTransport);
-	auto sctpTransport = std::atomic_load(&mSctpTransport);
-	if (!iceTransport || !sctpTransport)
-		return;
-
 	if (!channel) {
+		auto iceTransport = std::atomic_load(&mIceTransport);
+		auto sctpTransport = std::atomic_load(&mSctpTransport);
+		if (!iceTransport || !sctpTransport)
+			return;
+
 		const byte dataChannelOpenMessage{0x03};
 		unsigned int remoteParity = (iceTransport->role() == Description::Role::Active) ? 1 : 0;
 		if (message->type == Message::Control && *message->data() == dataChannelOpenMessage &&
 		    message->stream % 2 == remoteParity) {
+
 			channel =
 			    std::make_shared<DataChannel>(shared_from_this(), sctpTransport, message->stream);
 			channel->onOpen(weak_bind(&PeerConnection::triggerDataChannel, this,
@@ -519,8 +574,56 @@ void PeerConnection::forwardMessage(message_ptr message) {
 }
 
 void PeerConnection::forwardMedia(message_ptr message) {
-	if (message)
+	if (!message)
-		mMediaCallback(*message);
+		return;
+
+	if (message->type == Message::Type::Control) {
+		std::shared_lock lock(mTracksMutex); // read-only
+		for (auto it = mTracks.begin(); it != mTracks.end(); ++it)
+			if (auto track = it->second.lock())
+				return track->incoming(message);
+
+		PLOG_WARNING << "No track available to receive control, dropping";
+		return;
+	}
+
+	unsigned int payloadType = message->stream;
+	std::optional<string> mid;
+	if (auto it = mMidFromPayloadType.find(payloadType); it != mMidFromPayloadType.end()) {
+		mid = it->second;
+	} else {
+		std::lock_guard lock(mLocalDescriptionMutex);
+		if (!mLocalDescription)
+			return;
+
+		for (int i = 0; i < mLocalDescription->mediaCount(); ++i) {
+			if (auto found = std::visit(
+			        rtc::overloaded{[&](Description::Application *) -> std::optional<string> {
+				                        return std::nullopt;
+			                        },
+			                        [&](Description::Media *media) -> std::optional<string> {
+				                        return media->hasPayloadType(payloadType)
+				                                   ? std::make_optional(media->mid())
+				                                   : nullopt;
+			                        }},
+			        mLocalDescription->media(i))) {
+
+				mMidFromPayloadType.emplace(payloadType, *found);
+				mid = *found;
+				break;
+			}
+		}
+	}
+
+	if (!mid) {
+		PLOG_WARNING << "Track not found for payload type " << payloadType << ", dropping";
+		return;
+	}
+
+	std::shared_lock lock(mTracksMutex); // read-only
+	if (auto it = mTracks.find(*mid); it != mTracks.end())
+		if (auto track = it->second.lock())
+			track->incoming(message);
 }
 
 void PeerConnection::forwardBufferedAmount(uint16_t stream, size_t amount) {
@@ -528,10 +631,9 @@ void PeerConnection::forwardBufferedAmount(uint16_t stream, size_t amount) {
 		channel->triggerBufferedAmount(amount);
 }
 
-shared_ptr<DataChannel> PeerConnection::emplaceDataChannel(Description::Role role,
+shared_ptr<DataChannel> PeerConnection::emplaceDataChannel(Description::Role role, string label,
-                                                           const string &label,
+                                                           string protocol,
-                                                           const string &protocol,
+                                                           Reliability reliability) {
-                                                           const Reliability &reliability) {
 	// The active side must use streams with even identifiers, whereas the passive side must use
 	// streams with odd identifiers.
 	// See https://tools.ietf.org/html/draft-ietf-rtcweb-data-protocol-09#section-6
@@ -542,8 +644,8 @@ shared_ptr<DataChannel> PeerConnection::emplaceDataChannel(Description::Role rol
 		if (stream >= 65535)
 			throw std::runtime_error("Too many DataChannels");
 	}
-	auto channel =
+	auto channel = std::make_shared<DataChannel>(shared_from_this(), stream, std::move(label),
-	    std::make_shared<DataChannel>(shared_from_this(), stream, label, protocol, reliability);
+	                                             std::move(protocol), std::move(reliability));
 	mDataChannels.emplace(std::make_pair(stream, channel));
 	return channel;
 }
@@ -600,28 +702,132 @@ void PeerConnection::remoteCloseDataChannels() {
 	iterateDataChannels([&](shared_ptr<DataChannel> channel) { channel->remoteClose(); });
 }
 
+void PeerConnection::incomingTrack(Description::Media description) {
+	std::unique_lock lock(mTracksMutex); // we are going to emplace
+#if !RTC_ENABLE_MEDIA
+	if (mTracks.empty()) {
+		PLOG_WARNING << "Tracks will be inative (not compiled with SRTP support)";
+	}
+#endif
+	if (mTracks.find(description.mid()) == mTracks.end()) {
+		auto track = std::make_shared<Track>(std::move(description));
+		mTracks.emplace(std::make_pair(track->mid(), track));
+		triggerTrack(std::move(track));
+	}
+}
+
+void PeerConnection::openTracks() {
+#if RTC_ENABLE_MEDIA
+	if (auto transport = std::atomic_load(&mDtlsTransport)) {
+		auto srtpTransport = std::reinterpret_pointer_cast<DtlsSrtpTransport>(transport);
+		std::shared_lock lock(mTracksMutex); // read-only
+		for (auto it = mTracks.begin(); it != mTracks.end(); ++it)
+			if (auto track = it->second.lock())
+				track->open(srtpTransport);
+	}
+#endif
+}
+
+
 void PeerConnection::processLocalDescription(Description description) {
-	std::optional<uint16_t> remoteSctpPort;
+	int activeMediaCount = 0;
-	std::optional<string> remoteDataMid;
+
+	if (hasLocalDescription())
+		throw std::logic_error("Local description is already set");
+
 	if (auto remote = remoteDescription()) {
-		remoteDataMid = remote->dataMid();
+		// Reciprocate remote description
-	    remoteSctpPort = remote->sctpPort();
+		for (int i = 0; i < remote->mediaCount(); ++i)
+			std::visit( // reciprocate each media
+			    rtc::overloaded{
+			        [&](Description::Application *app) {
+				        auto reciprocated = app->reciprocate();
+				        reciprocated.hintSctpPort(DEFAULT_SCTP_PORT);
+				        reciprocated.setMaxMessageSize(LOCAL_MAX_MESSAGE_SIZE);
+				        ++activeMediaCount;
+
+				        PLOG_DEBUG << "Reciprocating application in local description, mid=\""
+				                   << reciprocated.mid() << "\"";
+
+				        description.addMedia(std::move(reciprocated));
+			        },
+			        [&](Description::Media *media) {
+				        auto reciprocated = media->reciprocate();
+#if RTC_ENABLE_MEDIA
+				        if (reciprocated.direction() != Description::Direction::Inactive)
+					        ++activeMediaCount;
+#else
+				        // No media support, mark as inactive
+				        reciprocated.setDirection(Description::Direction::Inactive);
+#endif
+				        incomingTrack(reciprocated);
+
+				        PLOG_DEBUG
+				            << "Reciprocating media in local description, mid=\""
+				            << reciprocated.mid() << "\", active=" << std::boolalpha
+				            << (reciprocated.direction() != Description::Direction::Inactive);
+
+				        description.addMedia(std::move(reciprocated));
+			        },
+			    },
+			    remote->media(i));
+	} else {
+		// Add application for data channels
+		{
+			std::shared_lock lock(mDataChannelsMutex);
+			if (!mDataChannels.empty()) {
+				Description::Application app("data");
+				app.setSctpPort(DEFAULT_SCTP_PORT);
+				app.setMaxMessageSize(LOCAL_MAX_MESSAGE_SIZE);
+				++activeMediaCount;
+
+				PLOG_DEBUG << "Adding application to local description, mid=\"" << app.mid()
+				           << "\"";
+
+				description.addMedia(std::move(app));
+			}
+		}
+
+		// Add media for local tracks
+		{
+			std::shared_lock lock(mTracksMutex);
+			for (auto it = mTracks.begin(); it != mTracks.end(); ++it) {
+				if (auto track = it->second.lock()) {
+					auto media = track->description();
+#if RTC_ENABLE_MEDIA
+					if (media.direction() != Description::Direction::Inactive)
+						++activeMediaCount;
+#else
+					// No media support, mark as inactive
+					media.setDirection(Description::Direction::Inactive);
+#endif
+					PLOG_DEBUG << "Adding media to local description, mid=\"" << media.mid()
+					           << "\", active=" << std::boolalpha
+					           << (media.direction() != Description::Direction::Inactive);
+
+					description.addMedia(std::move(media));
+				}
+			}
+		}
 	}
 
-	auto certificate = mCertificate.get(); // wait for certificate if not ready
+	// There must be at least one active media to negociate
+	if (activeMediaCount == 0)
+		throw std::runtime_error("Nothing to negociate");
+
+	// Set local fingerprint (wait for certificate if necessary)
+	description.setFingerprint(mCertificate.get()->fingerprint());
 
 	{
+		// Set as local description
 		std::lock_guard lock(mLocalDescriptionMutex);
 		mLocalDescription.emplace(std::move(description));
-		if (remoteDataMid)
-			mLocalDescription->setDataMid(*remoteDataMid);
-
-		mLocalDescription->setFingerprint(certificate->fingerprint());
-		mLocalDescription->setSctpPort(remoteSctpPort.value_or(DEFAULT_SCTP_PORT));
-		mLocalDescription->setMaxMessageSize(LOCAL_MAX_MESSAGE_SIZE);
 	}
 
-	mProcessor->enqueue([this]() { mLocalDescriptionCallback(*mLocalDescription); });
+	mProcessor->enqueue([this, description = *mLocalDescription]() {
+		PLOG_VERBOSE << "Issuing local description: " << description;
+		mLocalDescriptionCallback(std::move(description));
+	});
 }
 
 void PeerConnection::processLocalCandidate(Candidate candidate) {
@@ -631,8 +837,10 @@ void PeerConnection::processLocalCandidate(Candidate candidate) {
 
 	mLocalDescription->addCandidate(candidate);
 
-	mProcessor->enqueue(
+	mProcessor->enqueue([this, candidate = std::move(candidate)]() {
-	    [this, candidate = std::move(candidate)]() { mLocalCandidateCallback(candidate); });
+		PLOG_VERBOSE << "Issuing local candidate: " << candidate;
+		mLocalCandidateCallback(std::move(candidate));
+	});
 }
 
 void PeerConnection::triggerDataChannel(weak_ptr<DataChannel> weakDataChannel) {
@@ -644,6 +852,10 @@ void PeerConnection::triggerDataChannel(weak_ptr<DataChannel> weakDataChannel) {
 	    [this, dataChannel = std::move(dataChannel)]() { mDataChannelCallback(dataChannel); });
 }
 
+void PeerConnection::triggerTrack(std::shared_ptr<Track> track) {
+	mProcessor->enqueue([this, track = std::move(track)]() { mTrackCallback(track); });
+}
+
 bool PeerConnection::changeState(State state) {
 	State current;
 	do {
@@ -657,7 +869,7 @@ bool PeerConnection::changeState(State state) {
 
 	if (state == State::Closed)
 		// This is the last state change, so we may steal the callback
-		mProcessor->enqueue([this, cb = std::move(mStateChangeCallback)]() { cb(State::Closed); });
+		mProcessor->enqueue([cb = std::move(mStateChangeCallback)]() { cb(State::Closed); });
 	else
 		mProcessor->enqueue([this, state]() { mStateChangeCallback(state); });
 

src/rtcp.cpp

@@ -0,0 +1,426 @@
+/**
+ * Copyright (c) 2020 Staz M
+ * Copyright (c) 2020 Paul-Louis Ageneau
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include "rtcp.hpp"
+
+#include <cmath>
+#include <utility>
+
+#ifdef _WIN32
+#include <winsock2.h>
+#else
+#include <arpa/inet.h>
+#endif
+
+#ifndef htonll
+#define htonll(x)                                                                                  \
+	((uint64_t)htonl(((uint64_t)(x)&0xFFFFFFFF) << 32) | (uint64_t)htonl((uint64_t)(x) >> 32))
+#endif
+#ifndef ntohll
+#define ntohll(x) htonll(x)
+#endif
+
+namespace rtc {
+
+#pragma pack(push, 1)
+
+struct RTP {
+private:
+	uint8_t _first;
+	uint8_t _payloadType;
+	uint16_t _seqNumber;
+	uint32_t _timestamp;
+
+public:
+	SSRC ssrc;
+	SSRC csrc[16];
+
+	inline uint8_t version() const { return _first >> 6; }
+	inline bool padding() const { return (_first >> 5) & 0x01; }
+	inline uint8_t csrcCount() const { return _first & 0x0F; }
+	inline uint8_t payloadType() const { return _payloadType; }
+	inline uint16_t seqNumber() const { return ntohs(_seqNumber); }
+	inline uint32_t timestamp() const { return ntohl(_timestamp); }
+};
+
+struct RTCP_ReportBlock {
+	SSRC ssrc;
+
+private:
+	uint32_t _fractionLostAndPacketsLost; // fraction lost is 8-bit, packets lost is 24-bit
+	uint16_t _seqNoCycles;
+	uint16_t _highestSeqNo;
+	uint32_t _jitter;
+	uint32_t _lastReport;
+	uint32_t _delaySinceLastReport;
+
+public:
+	inline void preparePacket(SSRC ssrc_, [[maybe_unused]] unsigned int packetsLost,
+	                          [[maybe_unused]] unsigned int totalPackets, uint16_t highestSeqNo,
+	                          uint16_t seqNoCycles, uint32_t jitter, uint64_t lastSR_NTP,
+	                          uint64_t lastSR_DELAY) {
+		setSeqNo(highestSeqNo, seqNoCycles);
+		setJitter(jitter);
+		setSSRC(ssrc_);
+
+		// Middle 32 bits of NTP Timestamp
+		// _lastReport = lastSR_NTP >> 16u;
+		setNTPOfSR(uint32_t(lastSR_NTP));
+		setDelaySinceSR(uint32_t(lastSR_DELAY));
+
+		// The delay, expressed in units of 1/65536 seconds
+		// _delaySinceLastReport = lastSR_DELAY;
+	}
+
+	inline void setSSRC(SSRC ssrc_) { ssrc = htonl(ssrc_); }
+	inline SSRC getSSRC() const { return ntohl(ssrc); }
+
+	inline void setPacketsLost([[maybe_unused]] unsigned int packetsLost,
+	                           [[maybe_unused]] unsigned int totalPackets) {
+		// TODO Implement loss percentages.
+		_fractionLostAndPacketsLost = 0;
+	}
+	inline unsigned int getLossPercentage() const {
+		// TODO Implement loss percentages.
+		return 0;
+	}
+	inline unsigned int getPacketLostCount() const {
+		// TODO Implement total packets lost.
+		return 0;
+	}
+
+	inline uint16_t seqNoCycles() const { return ntohs(_seqNoCycles); }
+	inline uint16_t highestSeqNo() const { return ntohs(_highestSeqNo); }
+	inline uint32_t jitter() const { return ntohl(_jitter); }
+
+	inline void setSeqNo(uint16_t highestSeqNo, uint16_t seqNoCycles) {
+		_highestSeqNo = htons(highestSeqNo);
+		_seqNoCycles = htons(seqNoCycles);
+	}
+
+	inline void setJitter(uint32_t jitter) { _jitter = htonl(jitter); }
+
+	inline void setNTPOfSR(uint32_t ntp) { _lastReport = htonl(ntp >> 16u); }
+	inline uint32_t getNTPOfSR() const { return ntohl(_lastReport) << 16u; }
+
+	inline void setDelaySinceSR(uint32_t sr) {
+		// The delay, expressed in units of 1/65536 seconds
+		_delaySinceLastReport = htonl(sr);
+	}
+	inline uint32_t getDelaySinceSR() const { return ntohl(_delaySinceLastReport); }
+
+	inline void log() const {
+		PLOG_DEBUG << "RTCP report block: "
+		           << "ssrc="
+		           << ntohl(ssrc)
+		           // TODO: Implement these reports
+		           //	<< ", fractionLost=" << fractionLost
+		           //	<< ", packetsLost=" << packetsLost
+		           << ", highestSeqNo=" << highestSeqNo() << ", seqNoCycles=" << seqNoCycles()
+		           << ", jitter=" << jitter() << ", lastSR=" << getNTPOfSR()
+		           << ", lastSRDelay=" << getDelaySinceSR();
+	}
+};
+
+struct RTCP_HEADER {
+private:
+	uint8_t _first;
+	uint8_t _payloadType;
+	uint16_t _length;
+
+public:
+	inline uint8_t version() const { return _first >> 6; }
+	inline bool padding() const { return (_first >> 5) & 0x01; }
+	inline uint8_t reportCount() const { return _first & 0x0F; }
+	inline uint8_t payloadType() const { return _payloadType; }
+	inline uint16_t length() const { return ntohs(_length); }
+
+	inline void setPayloadType(uint8_t type) { _payloadType = type; }
+	inline void setReportCount(uint8_t count) { _first = (_first & 0xF0) | (count & 0x0F); }
+	inline void setLength(uint16_t length) { _length = htons(length); }
+
+	inline void prepareHeader(uint8_t payloadType, uint8_t reportCount, uint16_t length) {
+		_first = 0x02 << 6; // version 2, no padding
+		setReportCount(reportCount);
+		setPayloadType(payloadType);
+		setLength(length);
+	}
+
+	inline void log() const {
+		PLOG_DEBUG << "RTCP header: "
+		           << "version=" << unsigned(version()) << ", padding=" << padding()
+		           << ", reportCount=" << unsigned(reportCount())
+		           << ", payloadType=" << unsigned(payloadType()) << ", length=" << length();
+	}
+};
+
+struct RTCP_SR {
+	RTCP_HEADER header;
+	SSRC senderSsrc;
+
+private:
+	uint64_t _ntpTimestamp;
+	uint32_t _rtpTimestamp;
+	uint32_t _packetCount;
+	uint32_t _octetCount;
+
+	RTCP_ReportBlock _reportBlocks;
+
+public:
+	inline void preparePacket(SSRC senderSsrc_, uint8_t reportCount) {
+		unsigned int length =
+		    ((sizeof(header) + 24 + reportCount * sizeof(RTCP_ReportBlock)) / 4) - 1;
+		header.prepareHeader(200, reportCount, uint16_t(length));
+		senderSsrc = htonl(senderSsrc_);
+	}
+
+	inline RTCP_ReportBlock *getReportBlock(int num) { return &_reportBlocks + num; }
+	inline const RTCP_ReportBlock *getReportBlock(int num) const { return &_reportBlocks + num; }
+
+	[[nodiscard]] inline size_t getSize() const {
+		// "length" in packet is one less than the number of 32 bit words in the packet.
+		return sizeof(uint32_t) * (1 + size_t(header.length()));
+	}
+
+	inline uint32_t ntpTimestamp() const { return ntohll(_ntpTimestamp); }
+	inline uint32_t rtpTimestamp() const { return ntohl(_rtpTimestamp); }
+	inline uint32_t packetCount() const { return ntohl(_packetCount); }
+	inline uint32_t octetCount() const { return ntohl(_octetCount); }
+
+	inline void setNtpTimestamp(uint32_t ts) { _ntpTimestamp = htonll(ts); }
+	inline void setRtpTimestamp(uint32_t ts) { _rtpTimestamp = htonl(ts); }
+
+	inline void log() const {
+		header.log();
+		PLOG_DEBUG << "RTCP SR: "
+		           << " SSRC=" << ntohl(senderSsrc) << ", NTP_TS=" << ntpTimestamp()
+		           << ", RTP_TS=" << rtpTimestamp() << ", packetCount=" << packetCount()
+		           << ", octetCount=" << octetCount();
+
+		for (unsigned i = 0; i < unsigned(header.reportCount()); i++) {
+			getReportBlock(i)->log();
+		}
+	}
+};
+
+struct RTCP_RR {
+	RTCP_HEADER header;
+	SSRC senderSsrc;
+
+private:
+	RTCP_ReportBlock _reportBlocks;
+
+public:
+	inline RTCP_ReportBlock *getReportBlock(int num) { return &_reportBlocks + num; }
+	inline const RTCP_ReportBlock *getReportBlock(int num) const { return &_reportBlocks + num; }
+
+	inline SSRC getSenderSSRC() const { return ntohl(senderSsrc); }
+	inline void setSenderSSRC(SSRC ssrc) { senderSsrc = htonl(ssrc); }
+
+	[[nodiscard]] inline size_t getSize() const {
+		// "length" in packet is one less than the number of 32 bit words in the packet.
+		return sizeof(uint32_t) * (1 + size_t(header.length()));
+	}
+
+	inline void preparePacket(SSRC ssrc, uint8_t reportCount) {
+		// "length" in packet is one less than the number of 32 bit words in the packet.
+		size_t length = (sizeWithReportBlocks(reportCount) / 4) - 1;
+		header.prepareHeader(201, reportCount, uint16_t(length));
+		senderSsrc = htonl(ssrc);
+	}
+
+	inline static size_t sizeWithReportBlocks(uint8_t reportCount) {
+		return sizeof(header) + 4 + size_t(reportCount) * sizeof(RTCP_ReportBlock);
+	}
+
+	inline void log() const {
+		header.log();
+		PLOG_DEBUG << "RTCP RR: "
+		           << " SSRC=" << ntohl(senderSsrc);
+
+		for (unsigned i = 0; i < unsigned(header.reportCount()); i++) {
+			getReportBlock(i)->log();
+		}
+	}
+};
+
+struct RTCP_REMB {
+	RTCP_HEADER header;
+	SSRC senderSsrc;
+	SSRC mediaSourceSSRC;
+
+	// Unique identifier
+	const char id[4] = {'R', 'E', 'M', 'B'};
+
+	// Num SSRC, Br Exp, Br Mantissa (bit mask)
+	uint32_t bitrate;
+
+	SSRC ssrc[1];
+
+	[[nodiscard]] inline size_t getSize() const {
+		// "length" in packet is one less than the number of 32 bit words in the packet.
+		return sizeof(uint32_t) * (1 + size_t(header.length()));
+	}
+
+	inline void preparePacket(SSRC senderSsrc_, unsigned int numSSRC, unsigned int br) {
+		// Report Count becomes the format here.
+		header.prepareHeader(206, 15, 0);
+
+		// Always zero.
+		mediaSourceSSRC = 0;
+
+		senderSsrc = htonl(senderSsrc_);
+		setBitrate(numSSRC, br);
+	}
+
+	inline void setBitrate(unsigned int numSSRC, unsigned int br) {
+		unsigned int exp = 0;
+		while (br > pow(2, 18) - 1) {
+			exp++;
+			br /= 2;
+		}
+
+		// "length" in packet is one less than the number of 32 bit words in the packet.
+		header.setLength(uint16_t(((sizeof(header) + 4 * 2 + 4 + 4) / 4) - 1 + numSSRC));
+
+		bitrate = htonl((numSSRC << (32u - 8u)) | (exp << (32u - 8u - 6u)) | br);
+	}
+
+	// TODO Make this work
+	//	  uint64_t getBitrate() const{
+	//		  uint32_t ntohed = ntohl(bitrate);
+	//		  uint64_t bitrate = ntohed & (unsigned int)(pow(2, 18)-1);
+	//		  unsigned int exp = ntohed & ((unsigned int)( (pow(2, 6)-1)) << (32u-8u-6u));
+	//		  return bitrate * pow(2,exp);
+	//	  }
+	//
+	//	  uint8_t getNumSSRCS() const {
+	//		  return ntohl(bitrate) & (((unsigned int) pow(2,8)-1) << (32u-8u));
+	//	  }
+
+	inline void setSSRC(uint8_t iterator, SSRC ssrc_) { ssrc[iterator] = htonl(ssrc_); }
+
+	inline void log() const {
+		header.log();
+		PLOG_DEBUG << "RTCP REMB: "
+		           << " SSRC=" << ntohl(senderSsrc);
+	}
+
+	static unsigned int sizeWithSSRCs(int numSSRC) {
+		return (sizeof(header) + 4 * 2 + 4 + 4) + sizeof(SSRC) * numSSRC;
+	}
+};
+
+#pragma pack(pop)
+
+void RtcpSession::onOutgoing(std::function<void(rtc::message_ptr)> cb) { mTxCallback = cb; }
+
+std::optional<rtc::message_ptr> RtcpSession::incoming(rtc::message_ptr ptr) {
+	if (ptr->type == rtc::Message::Type::Binary) {
+		auto rtp = reinterpret_cast<const RTP *>(ptr->data());
+
+		// https://tools.ietf.org/html/rfc3550#appendix-A.1
+		if (rtp->version() != 2) {
+			PLOG_WARNING << "RTP packet is not version 2";
+
+			return std::nullopt;
+		}
+		if (rtp->payloadType() == 201 || rtp->payloadType() == 200) {
+			PLOG_WARNING << "RTP packet has a payload type indicating RR/SR";
+
+			return std::nullopt;
+		}
+
+		// TODO Implement the padding bit
+		if (rtp->padding()) {
+			PLOG_WARNING << "Padding processing not implemented";
+		}
+
+		mSsrc = ntohl(rtp->ssrc);
+
+		uint32_t seqNo = rtp->seqNumber();
+		// uint32_t rtpTS = rtp->getTS();
+
+		if (mGreatestSeqNo < seqNo)
+			mGreatestSeqNo = seqNo;
+
+		return ptr;
+	}
+
+	assert(ptr->type == rtc::Message::Type::Control);
+	auto rr = reinterpret_cast<const RTCP_RR *>(ptr->data());
+	if (rr->header.payloadType() == 201) {
+		// RR
+		mSsrc = rr->getSenderSSRC();
+		rr->log();
+	} else if (rr->header.payloadType() == 200) {
+		// SR
+		mSsrc = rr->getSenderSSRC();
+		auto sr = reinterpret_cast<const RTCP_SR *>(ptr->data());
+		mSyncRTPTS = sr->rtpTimestamp();
+		mSyncNTPTS = sr->ntpTimestamp();
+		sr->log();
+
+		// TODO For the time being, we will send RR's/REMB's when we get an SR
+		pushRR(0);
+		if (mRequestedBitrate > 0)
+			pushREMB(mRequestedBitrate);
+	}
+	return std::nullopt;
+}
+
+void RtcpSession::requestBitrate(unsigned int newBitrate) {
+	mRequestedBitrate = newBitrate;
+
+	PLOG_DEBUG << "[GOOG-REMB] Requesting bitrate: " << newBitrate << std::endl;
+	pushREMB(newBitrate);
+}
+
+void RtcpSession::pushREMB(unsigned int bitrate) {
+	rtc::message_ptr msg =
+	    rtc::make_message(RTCP_REMB::sizeWithSSRCs(1), rtc::Message::Type::Control);
+	auto remb = reinterpret_cast<RTCP_REMB *>(msg->data());
+	remb->preparePacket(mSsrc, 1, bitrate);
+	remb->setSSRC(0, mSsrc);
+	remb->log();
+
+	tx(msg);
+}
+
+void RtcpSession::pushRR(unsigned int lastSR_delay) {
+	auto msg = rtc::make_message(RTCP_RR::sizeWithReportBlocks(1), rtc::Message::Type::Control);
+	auto rr = reinterpret_cast<RTCP_RR *>(msg->data());
+	rr->preparePacket(mSsrc, 1);
+	rr->getReportBlock(0)->preparePacket(mSsrc, 0, 0, uint16_t(mGreatestSeqNo), 0, 0, mSyncNTPTS,
+	                                     lastSR_delay);
+	rr->log();
+
+	tx(msg);
+}
+
+void RtcpSession::tx(message_ptr msg) {
+	try {
+		mTxCallback(msg);
+	} catch (const std::exception &e) {
+		LOG_DEBUG << "RTCP tx failed: " << e.what();
+	}
+}
+
+} // namespace rtc
+

src/sctptransport.cpp

@@ -187,9 +187,6 @@ SctpTransport::SctpTransport(std::shared_ptr<Transport> lower, uint16_t port,
 	if (usrsctp_setsockopt(mSock, SOL_SOCKET, SO_SNDBUF, &bufferSize, sizeof(bufferSize)))
 		throw std::runtime_error("Could not set SCTP send buffer size, errno=" +
 		                         std::to_string(errno));
-
-	registerIncoming();
-	connect();
 }
 
 SctpTransport::~SctpTransport() {
@@ -203,6 +200,13 @@ SctpTransport::~SctpTransport() {
 	}
 }
 
+void SctpTransport::start() {
+	Transport::start();
+
+	registerIncoming();
+	connect();
+}
+
 bool SctpTransport::stop() {
 	// Transport::stop() will unregister incoming() from the lower layer, therefore we need to make
 	// sure the thread from lower layers is not blocked in incoming() by the WrittenOnce condition.
@@ -230,7 +234,7 @@ void SctpTransport::connect() {
 	if (!mSock)
 		return;
 
-	PLOG_DEBUG << "SCTP connect";
+	PLOG_DEBUG << "SCTP connecting";
 	changeState(State::Connecting);
 
 	struct sockaddr_conn sconn = {};
@@ -318,7 +322,7 @@ void SctpTransport::incoming(message_ptr message) {
 bool SctpTransport::trySendQueue() {
 	// Requires mSendMutex to be locked
 	while (auto next = mSendQueue.peek()) {
-		auto message = *next;
+		message_ptr message = std::move(*next);
 		if (!trySendMessage(message))
 			return false;
 		mSendQueue.pop();
@@ -372,12 +376,12 @@ bool SctpTransport::trySendMessage(message_ptr message) {
 		spa.sendv_sndinfo.snd_flags |= SCTP_UNORDERED;
 
 	switch (reliability.type) {
-	case Reliability::TYPE_PARTIAL_RELIABLE_REXMIT:
+	case Reliability::Type::Rexmit:
 		spa.sendv_flags |= SCTP_SEND_PRINFO_VALID;
 		spa.sendv_prinfo.pr_policy = SCTP_PR_SCTP_RTX;
 		spa.sendv_prinfo.pr_value = uint32_t(std::get<int>(reliability.rexmit));
 		break;
-	case Reliability::TYPE_PARTIAL_RELIABLE_TIMED:
+	case Reliability::Type::Timed:
 		spa.sendv_flags |= SCTP_SEND_PRINFO_VALID;
 		spa.sendv_prinfo.pr_policy = SCTP_PR_SCTP_TTL;
 		spa.sendv_prinfo.pr_value = uint32_t(std::get<milliseconds>(reliability.rexmit).count());
@@ -472,8 +476,6 @@ int SctpTransport::handleRecv(struct socket * /*sock*/, union sctp_sockstore /*a
                               const byte *data, size_t len, struct sctp_rcvinfo info, int flags) {
 	try {
 		PLOG_VERBOSE << "Handle recv, len=" << len;
-		if (!len)
-			return 0; // Ignore
 
 		// SCTP_FRAGMENT_INTERLEAVE does not seem to work as expected for messages > 64KB,
 		// therefore partial notifications and messages need to be handled separately.
@@ -493,7 +495,7 @@ int SctpTransport::handleRecv(struct socket * /*sock*/, union sctp_sockstore /*a
 			if (flags & MSG_EOR) {
 				// Message is complete, process it
 				processData(std::move(mPartialMessage), info.rcv_sid,
-				            PayloadId(htonl(info.rcv_ppid)));
+				            PayloadId(ntohl(info.rcv_ppid)));
 				mPartialMessage.clear();
 			}
 		}
@@ -596,7 +598,7 @@ void SctpTransport::processNotification(const union sctp_notification *notify, s
 	}
 
 	auto type = notify->sn_header.sn_type;
-	PLOG_VERBOSE << "Process notification, type=" << type;
+	PLOG_VERBOSE << "Processing notification, type=" << type;
 
 	switch (type) {
 	case SCTP_ASSOC_CHANGE: {
@@ -618,7 +620,8 @@ void SctpTransport::processNotification(const union sctp_notification *notify, s
 	}
 
 	case SCTP_SENDER_DRY_EVENT: {
-		// It not should be necessary since the send callback should have been called already,
+		PLOG_VERBOSE << "SCTP dry event";
+		// It should not be necessary since the send callback should have been called already,
 		// but to be sure, let's try to send now.
 		safeFlush();
 		break;
@@ -629,6 +632,28 @@ void SctpTransport::processNotification(const union sctp_notification *notify, s
 		const int count = (reset_event.strreset_length - sizeof(reset_event)) / sizeof(uint16_t);
 		const uint16_t flags = reset_event.strreset_flags;
 
+		IF_PLOG(plog::verbose) {
+			std::ostringstream desc;
+			desc << "flags=";
+			if (flags & SCTP_STREAM_RESET_OUTGOING_SSN && flags & SCTP_STREAM_RESET_INCOMING_SSN)
+				desc << "outgoing|incoming";
+			else if (flags & SCTP_STREAM_RESET_OUTGOING_SSN)
+				desc << "outgoing";
+			else if (flags & SCTP_STREAM_RESET_INCOMING_SSN)
+				desc << "incoming";
+			else
+				desc << "0";
+
+			desc << ", streams=[";
+			for (int i = 0; i < count; ++i) {
+				uint16_t streamId = reset_event.strreset_stream_list[i];
+				desc << (i != 0 ? "," : "") << streamId;
+			}
+			desc << "]";
+
+			PLOG_VERBOSE << "SCTP reset event, " << desc.str();
+		}
+
 		if (flags & SCTP_STREAM_RESET_OUTGOING_SSN) {
 			for (int i = 0; i < count; ++i) {
 				uint16_t streamId = reset_event.strreset_stream_list[i];
@@ -675,25 +700,25 @@ std::optional<milliseconds> SctpTransport::rtt() {
 }
 
 int SctpTransport::RecvCallback(struct socket *sock, union sctp_sockstore addr, void *data,
-                                size_t len, struct sctp_rcvinfo recv_info, int flags, void *ptr) {
+                                size_t len, struct sctp_rcvinfo recv_info, int flags,
-	int ret = static_cast<SctpTransport *>(ptr)->handleRecv(
+                                void *ulp_info) {
-	    sock, addr, static_cast<const byte *>(data), len, recv_info, flags);
+	auto *transport = static_cast<SctpTransport *>(ulp_info);
+
+	std::shared_lock lock(InstancesMutex);
+	if (Instances.find(transport) == Instances.end()) {
+		free(data);
+		return -1;
+	}
+
+	int ret =
+	    transport->handleRecv(sock, addr, static_cast<const byte *>(data), len, recv_info, flags);
 	free(data);
 	return ret;
 }
 
-int SctpTransport::SendCallback(struct socket *sock, uint32_t sb_free) {
+int SctpTransport::SendCallback(struct socket *, uint32_t sb_free, void *ulp_info) {
-	struct sctp_paddrinfo paddrinfo = {};
+	auto *transport = static_cast<SctpTransport *>(ulp_info);
-	socklen_t len = sizeof(paddrinfo);
-	if (usrsctp_getsockopt(sock, IPPROTO_SCTP, SCTP_GET_PEER_ADDR_INFO, &paddrinfo, &len))
-		return -1;
 
-	auto sconn = reinterpret_cast<struct sockaddr_conn *>(&paddrinfo.spinfo_address);
-	void *ptr = sconn->sconn_addr;
-	auto *transport = static_cast<SctpTransport *>(ptr);
-
-	// Workaround for sctplab/usrsctp#405: Send callback is invoked on already closed socket
-	// https://github.com/sctplab/usrsctp/issues/405
 	std::shared_lock lock(InstancesMutex);
 	if (Instances.find(transport) == Instances.end())
 		return -1;
@@ -702,8 +727,15 @@ int SctpTransport::SendCallback(struct socket *sock, uint32_t sb_free) {
 }
 
 int SctpTransport::WriteCallback(void *ptr, void *data, size_t len, uint8_t tos, uint8_t set_df) {
-	return static_cast<SctpTransport *>(ptr)->handleWrite(static_cast<byte *>(data), len, tos,
+	auto *transport = static_cast<SctpTransport *>(ptr);
-	                                                      set_df);
+
+	// Workaround for sctplab/usrsctp#405: Send callback is invoked on already closed socket
+	// https://github.com/sctplab/usrsctp/issues/405
+	std::shared_lock lock(InstancesMutex);
+	if (Instances.find(transport) == Instances.end())
+		return -1;
+
+	return transport->handleWrite(static_cast<byte *>(data), len, tos, set_df);
 }
 
 } // namespace rtc

src/sctptransport.hpp

@@ -46,6 +46,7 @@ public:
 	              amount_callback bufferedAmountCallback, state_callback stateChangeCallback);
 	~SctpTransport();
 
+	void start() override;
 	bool stop() override;
 	bool send(message_ptr message) override; // false if buffered
 	void closeStream(unsigned int stream);
@@ -109,8 +110,8 @@ private:
 	std::atomic<size_t> mBytesSent = 0, mBytesReceived = 0;
 
 	static int RecvCallback(struct socket *sock, union sctp_sockstore addr, void *data, size_t len,
-	                        struct sctp_rcvinfo recv_info, int flags, void *user_data);
+	                        struct sctp_rcvinfo recv_info, int flags, void *ulp_info);
-	static int SendCallback(struct socket *sock, uint32_t sb_free);
+	static int SendCallback(struct socket *sock, uint32_t sb_free, void *ulp_info);
 	static int WriteCallback(void *sctp_ptr, void *data, size_t len, uint8_t tos, uint8_t set_df);
 
 	static std::unordered_set<SctpTransport *> Instances;

src/tcptransport.cpp

@@ -54,7 +54,7 @@ SelectInterrupter::~SelectInterrupter() {
 #endif
 }
 
-int SelectInterrupter::prepare(fd_set &readfds, fd_set &writefds) {
+int SelectInterrupter::prepare(fd_set &readfds, [[maybe_unused]] fd_set &writefds) {
 	std::lock_guard lock(mMutex);
 #ifdef _WIN32
 	if (mDummySock == INVALID_SOCKET)
@@ -86,11 +86,15 @@ TcpTransport::TcpTransport(const string &hostname, const string &service, state_
     : Transport(nullptr, std::move(callback)), mHostname(hostname), mService(service) {
 
 	PLOG_DEBUG << "Initializing TCP transport";
-	mThread = std::thread(&TcpTransport::runLoop, this);
 }
 
-TcpTransport::~TcpTransport() {
+TcpTransport::~TcpTransport() { stop(); }
-	stop();
+
+void TcpTransport::start() {
+	Transport::start();
+
+	PLOG_DEBUG << "Starting TCP recv thread";
+	mThread = std::thread(&TcpTransport::runLoop, this);
 }
 
 bool TcpTransport::stop() {
@@ -208,36 +212,42 @@ void TcpTransport::connect(const sockaddr *addr, socklen_t addrlen) {
 			throw std::runtime_error(msg.str());
 		}
 
-		fd_set writefds;
+		while (true) {
-		FD_ZERO(&writefds);
+			fd_set writefds;
-		FD_SET(mSock, &writefds);
+			FD_ZERO(&writefds);
-		struct timeval tv;
+			FD_SET(mSock, &writefds);
-		tv.tv_sec = 10; // TODO
+			struct timeval tv;
-		tv.tv_usec = 0;
+			tv.tv_sec = 10; // TODO: Make the timeout configurable
-		ret = ::select(SOCKET_TO_INT(mSock) + 1, NULL, &writefds, NULL, &tv);
+			tv.tv_usec = 0;
+			ret = ::select(SOCKET_TO_INT(mSock) + 1, NULL, &writefds, NULL, &tv);
 
-		if (ret < 0)
+			if (ret < 0) {
-			throw std::runtime_error("Failed to wait for socket connection");
+				if (sockerrno == SEINTR || sockerrno == SEAGAIN) // interrupted
+					continue;
+				else
+					throw std::runtime_error("Failed to wait for socket connection");
+			}
 
-		if (ret == 0) {
+			if (ret == 0) {
-			std::ostringstream msg;
+				std::ostringstream msg;
-			msg << "TCP connection to " << node << ":" << serv << " timed out";
+				msg << "TCP connection to " << node << ":" << serv << " timed out";
-			throw std::runtime_error(msg.str());
+				throw std::runtime_error(msg.str());
+			}
+
+			int error = 0;
+			socklen_t errorlen = sizeof(error);
+			if (::getsockopt(mSock, SOL_SOCKET, SO_ERROR, (char *)&error, &errorlen) != 0)
+				throw std::runtime_error("Failed to get socket error code");
+
+			if (error != 0) {
+				std::ostringstream msg;
+				msg << "TCP connection to " << node << ":" << serv << " failed, errno=" << error;
+				throw std::runtime_error(msg.str());
+			}
+
+			PLOG_DEBUG << "TCP connection to " << node << ":" << serv << " succeeded";
+			break;
 		}
-
-		int error = 0;
-		socklen_t errorlen = sizeof(error);
-		if (::getsockopt(mSock, SOL_SOCKET, SO_ERROR, (char *)&error, &errorlen) != 0)
-			throw std::runtime_error("Failed to get socket error code");
-
-		if (error != 0) {
-			std::ostringstream msg;
-			msg << "TCP connection to " << node << ":" << serv << " failed, errno=" << error;
-			throw std::runtime_error(msg.str());
-		}
-
-		PLOG_DEBUG << "TCP connection to " << node << ":" << serv << " succeeded";
-
 	} catch (...) {
 		if (mSock != INVALID_SOCKET) {
 			::closesocket(mSock);
@@ -261,7 +271,7 @@ void TcpTransport::close() {
 bool TcpTransport::trySendQueue() {
 	// mSockMutex must be locked
 	while (auto next = mSendQueue.peek()) {
-		auto message = *next;
+		message_ptr message = std::move(*next);
 		if (!trySendMessage(message)) {
 			mSendQueue.exchange(message);
 			return false;

src/tcptransport.hpp

@@ -56,6 +56,7 @@ public:
 	TcpTransport(const string &hostname, const string &service, state_callback callback);
 	~TcpTransport();
 
+	void start() override;
 	bool stop() override;
 	bool send(message_ptr message) override;
 

src/tls.cpp

@@ -85,10 +85,9 @@ void init() {
 	static bool done = false;
 
 	std::lock_guard lock(mutex);
-	if (!done) {
+	if (!std::exchange(done, true)) {
 		OPENSSL_init_ssl(OPENSSL_INIT_LOAD_SSL_STRINGS | OPENSSL_INIT_LOAD_CRYPTO_STRINGS, nullptr);
 		OPENSSL_init_crypto(OPENSSL_INIT_LOAD_CRYPTO_STRINGS, nullptr);
-		done = true;
 	}
 }
 

src/tlstransport.cpp

@@ -71,11 +71,6 @@ TlsTransport::TlsTransport(shared_ptr<TcpTransport> lower, string host, state_ca
 		gnutls_transport_set_pull_function(mSession, ReadCallback);
 		gnutls_transport_set_pull_timeout_function(mSession, TimeoutCallback);
 
-		postCreation();
-
-		mRecvThread = std::thread(&TlsTransport::runRecvLoop, this);
-		registerIncoming();
-
 	} catch (...) {
 		gnutls_deinit(mSession);
 		gnutls_certificate_free_credentials(mCreds);
@@ -90,6 +85,15 @@ TlsTransport::~TlsTransport() {
 	gnutls_certificate_free_credentials(mCreds);
 }
 
+void TlsTransport::start() {
+	Transport::start();
+
+	registerIncoming();
+
+	PLOG_DEBUG << "Starting TLS recv thread";
+	mRecvThread = std::thread(&TlsTransport::runRecvLoop, this);
+}
+
 bool TlsTransport::stop() {
 	if (!Transport::stop())
 		return false;
@@ -124,10 +128,6 @@ void TlsTransport::incoming(message_ptr message) {
 		mIncomingQueue.stop();
 }
 
-void TlsTransport::postCreation() {
-	// Dummy
-}
-
 void TlsTransport::postHandshake() {
 	// Dummy
 }
@@ -238,11 +238,9 @@ ssize_t TlsTransport::ReadCallback(gnutls_transport_ptr_t ptr, void *data, size_
 
 int TlsTransport::TimeoutCallback(gnutls_transport_ptr_t ptr, unsigned int ms) {
 	TlsTransport *t = static_cast<TlsTransport *>(ptr);
-	if (ms != GNUTLS_INDEFINITE_TIMEOUT)
+	bool notEmpty = t->mIncomingQueue.wait(
-		t->mIncomingQueue.wait(milliseconds(ms));
+	    ms != GNUTLS_INDEFINITE_TIMEOUT ? std::make_optional(milliseconds(ms)) : nullopt);
-	else
+	return notEmpty ? 1 : 0;
-		t->mIncomingQueue.wait();
-	return !t->mIncomingQueue.empty() ? 1 : 0;
 }
 
 #else // USE_GNUTLS==0
@@ -309,11 +307,6 @@ TlsTransport::TlsTransport(shared_ptr<TcpTransport> lower, string host, state_ca
 		SSL_set_options(mSsl, SSL_OP_SINGLE_ECDH_USE);
 		SSL_set_tmp_ecdh(mSsl, ecdh.get());
 
-		postCreation();
-
-		mRecvThread = std::thread(&TlsTransport::runRecvLoop, this);
-		registerIncoming();
-
 	} catch (...) {
 		if (mSsl)
 			SSL_free(mSsl);
@@ -330,6 +323,15 @@ TlsTransport::~TlsTransport() {
 	SSL_CTX_free(mCtx);
 }
 
+void TlsTransport::start() {
+	Transport::start();
+
+	registerIncoming();
+
+	PLOG_DEBUG << "Starting TLS recv thread";
+	mRecvThread = std::thread(&TlsTransport::runRecvLoop, this);
+}
+
 bool TlsTransport::stop() {
 	if (!Transport::stop())
 		return false;
@@ -369,10 +371,6 @@ void TlsTransport::incoming(message_ptr message) {
 		mIncomingQueue.stop();
 }
 
-void TlsTransport::postCreation() {
-	// Dummy
-}
-
 void TlsTransport::postHandshake() {
 	// Dummy
 }
@@ -413,7 +411,7 @@ void TlsTransport::runRecvLoop() {
 			if (!next)
 				break;
 
-			message_ptr message = *next;
+			message_ptr message = std::move(*next);
 			if (message->size() > 0)
 				BIO_write(mInBio, message->data(), int(message->size())); // Input
 			else

src/tlstransport.hpp

@@ -40,12 +40,12 @@ public:
 	TlsTransport(std::shared_ptr<TcpTransport> lower, string host, state_callback callback);
 	virtual ~TlsTransport();
 
+	void start() override;
 	bool stop() override;
 	bool send(message_ptr message) override;
 
 protected:
 	virtual void incoming(message_ptr message) override;
-	virtual void postCreation();
 	virtual void postHandshake();
 	void runRecvLoop();
 

src/track.cpp

@@ -0,0 +1,148 @@
+/**
+ * Copyright (c) 2020 Paul-Louis Ageneau
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include "track.hpp"
+#include "dtlssrtptransport.hpp"
+#include "include.hpp"
+
+namespace rtc {
+
+using std::shared_ptr;
+using std::weak_ptr;
+
+Track::Track(Description::Media description)
+    : mMediaDescription(std::move(description)), mRecvQueue(RECV_QUEUE_LIMIT, message_size_func) {}
+
+string Track::mid() const { return mMediaDescription.mid(); }
+
+Description::Media Track::description() const { return mMediaDescription; }
+
+void Track::close() {
+	mIsClosed = true;
+	resetCallbacks();
+	setRtcpHandler(nullptr);
+}
+
+bool Track::send(message_variant data) { return outgoing(make_message(std::move(data))); }
+
+bool Track::send(const byte *data, size_t size) {
+	return outgoing(std::make_shared<Message>(data, data + size, Message::Binary));
+}
+
+std::optional<message_variant> Track::receive() {
+	if (auto next = mRecvQueue.tryPop())
+		return to_variant(std::move(**next));
+
+	return nullopt;
+}
+
+bool Track::isOpen(void) const {
+#if RTC_ENABLE_MEDIA
+	return !mIsClosed && mDtlsSrtpTransport.lock();
+#else
+	return !mIsClosed;
+#endif
+}
+
+bool Track::isClosed(void) const { return mIsClosed; }
+
+size_t Track::maxMessageSize() const {
+	return 65535 - 12 - 4; // SRTP/UDP
+}
+
+size_t Track::availableAmount() const {
+	return mRecvQueue.amount();
+}
+
+#if RTC_ENABLE_MEDIA
+void Track::open(shared_ptr<DtlsSrtpTransport> transport) {
+	mDtlsSrtpTransport = transport;
+	triggerOpen();
+}
+#endif
+
+bool Track::outgoing(message_ptr message) {
+	auto direction = mMediaDescription.direction();
+	if (direction == Description::Direction::RecvOnly ||
+	    direction == Description::Direction::Inactive)
+		throw std::runtime_error("Track media direction does not allow sending");
+
+	if (mIsClosed)
+		throw std::runtime_error("Track is closed");
+
+	if (message->size() > maxMessageSize())
+		throw std::runtime_error("Message size exceeds limit");
+
+#if RTC_ENABLE_MEDIA
+	auto transport = mDtlsSrtpTransport.lock();
+	if (!transport)
+		throw std::runtime_error("Track transport is not open");
+
+	return transport->sendMedia(message);
+#else
+	PLOG_WARNING << "Ignoring track send (not compiled with SRTP support)";
+	return false;
+#endif
+}
+
+void Track::incoming(message_ptr message) {
+	if (!message)
+		return;
+
+	if (mRtcpHandler) {
+		auto opt = mRtcpHandler->incoming(message);
+		if (!opt)
+			return;
+
+		message = *opt;
+	}
+
+	auto direction = mMediaDescription.direction();
+	if ((direction == Description::Direction::SendOnly ||
+	     direction == Description::Direction::Inactive) &&
+	    message->type != Message::Control) {
+		PLOG_WARNING << "Track media direction does not allow reception, dropping";
+	}
+
+	// Tail drop if queue is full
+	if (mRecvQueue.full())
+		return;
+
+	mRecvQueue.push(message);
+	triggerAvailable(mRecvQueue.size());
+}
+
+void Track::setRtcpHandler(std::shared_ptr<RtcpHandler> handler) {
+	if (mRtcpHandler)
+		mRtcpHandler->onOutgoing(nullptr);
+
+	mRtcpHandler = std::move(handler);
+	if (mRtcpHandler) {
+		mRtcpHandler->onOutgoing([&]([[maybe_unused]] message_ptr message) {
+#if RTC_ENABLE_MEDIA
+			if (auto transport = mDtlsSrtpTransport.lock())
+				transport->sendMedia(message);
+#else
+			PLOG_WARNING << "Ignoring RTCP send (not compiled with SRTP support)";
+#endif
+		});
+	}
+}
+
+} // namespace rtc
+

src/transport.hpp

@@ -39,12 +39,12 @@ public:
 	    : mLower(std::move(lower)), mStateChangeCallback(std::move(callback)) {
 	}
 
-	virtual ~Transport() {
+	virtual ~Transport() { stop(); }
-		stop();
+
-	}
+	virtual void start() { mStopped = false; }
 
 	virtual bool stop() {
-		if (mShutdown.exchange(true))
+		if (mStopped.exchange(true))
 			return false;
 
 		// We don't want incoming() to be called by the lower layer anymore
@@ -95,7 +95,7 @@ private:
 	synchronized_callback<message_ptr> mRecvCallback;
 
 	std::atomic<State> mState = State::Disconnected;
-	std::atomic<bool> mShutdown = false;
+	std::atomic<bool> mStopped = true;
 };
 
 } // namespace rtc

src/verifiedtlstransport.cpp

@@ -28,43 +28,24 @@ using std::weak_ptr;
 
 namespace rtc {
 
-#if USE_GNUTLS
 
 VerifiedTlsTransport::VerifiedTlsTransport(shared_ptr<TcpTransport> lower, string host,
                                            state_callback callback)
-    : TlsTransport(std::move(lower), std::move(host), std::move(callback)) {}
+    : TlsTransport(std::move(lower), std::move(host), std::move(callback)) {
 
-VerifiedTlsTransport::~VerifiedTlsTransport() {}
+#if USE_GNUTLS
-
-void VerifiedTlsTransport::postCreation() {
 	PLOG_DEBUG << "Setting up TLS certificate verification";
 	gnutls_session_set_verify_cert(mSession, mHost.c_str(), 0);
-}
+#else
-
-void VerifiedTlsTransport::postHandshake() {
-	// Nothing to do
-}
-
-#else // USE_GNUTLS==0
-
-VerifiedTlsTransport::VerifiedTlsTransport(shared_ptr<TcpTransport> lower, string host,
-                                           state_callback callback)
-    : TlsTransport(std::move(lower), std::move(host), std::move(callback)) {}
-
-VerifiedTlsTransport::~VerifiedTlsTransport() {}
-
-void VerifiedTlsTransport::postCreation() {
 	PLOG_DEBUG << "Setting up TLS certificate verification";
 	SSL_set_verify(mSsl, SSL_VERIFY_PEER, NULL);
 	SSL_set_verify_depth(mSsl, 4);
-}
-
-void VerifiedTlsTransport::postHandshake() {
-	// Nothing to do
-}
-
 #endif
+}
+
+VerifiedTlsTransport::~VerifiedTlsTransport() {}
 
 } // namespace rtc
 
 #endif
+

src/verifiedtlstransport.hpp

@@ -29,10 +29,6 @@ class VerifiedTlsTransport final : public TlsTransport {
 public:
 	VerifiedTlsTransport(std::shared_ptr<TcpTransport> lower, string host, state_callback callback);
 	~VerifiedTlsTransport();
-
-protected:
-	void postCreation() override;
-	void postHandshake() override;
 };
 
 } // namespace rtc

src/websocket.cpp

@@ -38,7 +38,8 @@ namespace rtc {
 using std::shared_ptr;
 
 WebSocket::WebSocket(std::optional<Configuration> config)
-    : mConfig(config ? std::move(*config) : Configuration()) {
+    : mConfig(config ? std::move(*config) : Configuration()),
+      mRecvQueue(RECV_QUEUE_LIMIT, message_size_func) {
 	PLOG_VERBOSE << "Creating WebSocket";
 }
 
@@ -100,16 +101,7 @@ void WebSocket::remoteClose() {
 	}
 }
 
-bool WebSocket::send(const std::variant<binary, string> &data) {
+bool WebSocket::send(message_variant data) { return outgoing(make_message(std::move(data))); }
-	return std::visit(
-	    [&](const auto &d) {
-		    using T = std::decay_t<decltype(d)>;
-		    constexpr auto type = std::is_same_v<T, string> ? Message::String : Message::Binary;
-		    auto *b = reinterpret_cast<const byte *>(d.data());
-		    return outgoing(std::make_shared<Message>(b, b + d.size(), type));
-	    },
-	    data);
-}
 
 bool WebSocket::isOpen() const { return mState == State::Open; }
 
@@ -117,19 +109,11 @@ bool WebSocket::isClosed() const { return mState == State::Closed; }
 
 size_t WebSocket::maxMessageSize() const { return DEFAULT_MAX_MESSAGE_SIZE; }
 
-std::optional<std::variant<binary, string>> WebSocket::receive() {
+std::optional<message_variant> WebSocket::receive() {
-	while (!mRecvQueue.empty()) {
+	while (auto next = mRecvQueue.tryPop()) {
-		auto message = *mRecvQueue.pop();
+		message_ptr message = std::move(*next);
-		switch (message->type) {
+		if (message->type != Message::Control)
-		case Message::String:
+			return to_variant(std::move(*message));
-			return std::make_optional(
-			    string(reinterpret_cast<const char *>(message->data()), message->size()));
-		case Message::Binary:
-			return std::make_optional(std::move(*message));
-		default:
-			// Ignore
-			break;
-		}
 	}
 	return nullopt;
 }
@@ -149,6 +133,11 @@ bool WebSocket::outgoing(message_ptr message) {
 }
 
 void WebSocket::incoming(message_ptr message) {
+	if (!message) {
+		remoteClose();
+		return;
+	}
+
 	if (message->type == Message::String || message->type == Message::Binary) {
 		mRecvQueue.push(message);
 		triggerAvailable(mRecvQueue.size());
@@ -189,10 +178,11 @@ shared_ptr<TcpTransport> WebSocket::initTcpTransport() {
 		std::atomic_store(&mTcpTransport, transport);
 		if (mState == WebSocket::State::Closed) {
 			mTcpTransport.reset();
-			transport->stop();
 			throw std::runtime_error("Connection is closed");
 		}
+		transport->start();
 		return transport;
+
 	} catch (const std::exception &e) {
 		PLOG_ERROR << e.what();
 		remoteClose();
@@ -245,10 +235,11 @@ shared_ptr<TlsTransport> WebSocket::initTlsTransport() {
 		std::atomic_store(&mTlsTransport, transport);
 		if (mState == WebSocket::State::Closed) {
 			mTlsTransport.reset();
-			transport->stop();
 			throw std::runtime_error("Connection is closed");
 		}
+		transport->start();
 		return transport;
+
 	} catch (const std::exception &e) {
 		PLOG_ERROR << e.what();
 		remoteClose();
@@ -295,9 +286,9 @@ shared_ptr<WsTransport> WebSocket::initWsTransport() {
 		std::atomic_store(&mWsTransport, transport);
 		if (mState == WebSocket::State::Closed) {
 			mWsTransport.reset();
-			transport->stop();
 			throw std::runtime_error("Connection is closed");
 		}
+		transport->start();
 		return transport;
 	} catch (const std::exception &e) {
 		PLOG_ERROR << e.what();
@@ -335,6 +326,6 @@ void WebSocket::closeTransports() {
 	});
 }
 
-} // namespace rtc
+	} // namespace rtc
 
 #endif

src/wstransport.cpp

@@ -58,13 +58,17 @@ WsTransport::WsTransport(std::shared_ptr<Transport> lower, string host, string p
 	onRecv(recvCallback);
 
 	PLOG_DEBUG << "Initializing WebSocket transport";
+}
+
+WsTransport::~WsTransport() { stop(); }
+
+void WsTransport::start() {
+	Transport::start();
 
 	registerIncoming();
 	sendHttpRequest();
 }
 
-WsTransport::~WsTransport() { stop(); }
-
 bool WsTransport::stop() {
 	if (!Transport::stop())
 		return false;
@@ -143,6 +147,7 @@ void WsTransport::close() {
 }
 
 bool WsTransport::sendHttpRequest() {
+	PLOG_DEBUG << "Sending WebSocket HTTP request";
 	changeState(State::Connecting);
 
 	auto seed = static_cast<unsigned int>(system_clock::now().time_since_epoch().count());

src/wstransport.hpp

@@ -35,6 +35,7 @@ public:
 	            message_callback recvCallback, state_callback stateCallback);
 	~WsTransport();
 
+	void start() override;
 	bool stop() override;
 	bool send(message_ptr message) override;
 

test/benchmark.cpp

@@ -48,20 +48,20 @@ size_t benchmark(milliseconds duration) {
 
 	auto pc2 = std::make_shared<PeerConnection>(config2);
 
-	pc1->onLocalDescription([wpc2 = make_weak_ptr(pc2)](const Description &sdp) {
+	pc1->onLocalDescription([wpc2 = make_weak_ptr(pc2)](Description sdp) {
 		auto pc2 = wpc2.lock();
 		if (!pc2)
 			return;
 		cout << "Description 1: " << sdp << endl;
-		pc2->setRemoteDescription(sdp);
+		pc2->setRemoteDescription(std::move(sdp));
 	});
 
-	pc1->onLocalCandidate([wpc2 = make_weak_ptr(pc2)](const Candidate &candidate) {
+	pc1->onLocalCandidate([wpc2 = make_weak_ptr(pc2)](Candidate candidate) {
 		auto pc2 = wpc2.lock();
 		if (!pc2)
 			return;
 		cout << "Candidate 1: " << candidate << endl;
-		pc2->addRemoteCandidate(candidate);
+		pc2->addRemoteCandidate(std::move(candidate));
 	});
 
 	pc1->onStateChange([](PeerConnection::State state) { cout << "State 1: " << state << endl; });
@@ -69,20 +69,20 @@ size_t benchmark(milliseconds duration) {
 		cout << "Gathering state 1: " << state << endl;
 	});
 
-	pc2->onLocalDescription([wpc1 = make_weak_ptr(pc1)](const Description &sdp) {
+	pc2->onLocalDescription([wpc1 = make_weak_ptr(pc1)](Description sdp) {
 		auto pc1 = wpc1.lock();
 		if (!pc1)
 			return;
 		cout << "Description 2: " << sdp << endl;
-		pc1->setRemoteDescription(sdp);
+		pc1->setRemoteDescription(std::move(sdp));
 	});
 
-	pc2->onLocalCandidate([wpc1 = make_weak_ptr(pc1)](const Candidate &candidate) {
+	pc2->onLocalCandidate([wpc1 = make_weak_ptr(pc1)](Candidate candidate) {
 		auto pc1 = wpc1.lock();
 		if (!pc1)
 			return;
 		cout << "Candidate 2: " << candidate << endl;
-		pc1->addRemoteCandidate(candidate);
+		pc1->addRemoteCandidate(std::move(candidate));
 	});
 
 	pc2->onStateChange([](PeerConnection::State state) { cout << "State 2: " << state << endl; });
@@ -99,21 +99,20 @@ size_t benchmark(milliseconds duration) {
 	steady_clock::time_point startTime, openTime, receivedTime, endTime;
 
 	shared_ptr<DataChannel> dc2;
-	pc2->onDataChannel(
+	pc2->onDataChannel([&dc2, &receivedSize, &receivedTime](shared_ptr<DataChannel> dc) {
-	    [&dc2, &receivedSize, &receivedTime](shared_ptr<DataChannel> dc) {
+		dc->onMessage([&receivedTime, &receivedSize](variant<binary, string> message) {
-		    dc->onMessage([&receivedTime, &receivedSize](const variant<binary, string> &message) {
+			if (holds_alternative<binary>(message)) {
-			    if (holds_alternative<binary>(message)) {
+				const auto &bin = get<binary>(message);
-				    const auto &bin = get<binary>(message);
+				if (receivedSize == 0)
-				    if (receivedSize == 0)
+					receivedTime = steady_clock::now();
-					    receivedTime = steady_clock::now();
+				receivedSize += bin.size();
-				    receivedSize += bin.size();
+			}
-			    }
+		});
-		    });
 
-		    dc->onClosed([]() { cout << "DataChannel closed." << endl; });
+		dc->onClosed([]() { cout << "DataChannel closed." << endl; });
 
-		    std::atomic_store(&dc2, dc);
+		std::atomic_store(&dc2, dc);
-	    });
+	});
 
 	startTime = steady_clock::now();
 	auto dc1 = pc1->createDataChannel("benchmark");
@@ -156,7 +155,8 @@ size_t benchmark(milliseconds duration) {
 
 	endTime = steady_clock::now();
 
-	auto connectDuration = duration_cast<milliseconds>(openTime - startTime);
+	auto connectDuration = duration_cast<milliseconds>(dc1->isOpen() ? openTime - startTime
+	                                                                 : steady_clock::duration(0));
 	auto transferDuration = duration_cast<milliseconds>(endTime - receivedTime);
 
 	cout << "Test duration: " << duration.count() << " ms" << endl;

test/capi_connectivity.cpp

@@ -37,8 +37,8 @@ typedef struct {
 	bool connected;
 } Peer;
 
-Peer *peer1 = NULL;
+static Peer *peer1 = NULL;
-Peer *peer2 = NULL;
+static Peer *peer2 = NULL;
 
 static void descriptionCallback(const char *sdp, const char *type, void *ptr) {
 	Peer *peer = (Peer *)ptr;
@@ -132,7 +132,7 @@ static void deletePeer(Peer *peer) {
 	}
 }
 
-int test_capi_main() {
+int test_capi_connectivity_main() {
 	int attempts;
 
 	rtcInitLogger(RTC_LOG_DEBUG, nullptr);
@@ -170,7 +170,7 @@ int test_capi_main() {
 	rtcSetMessageCallback(peer1->dc, messageCallback);
 
 	attempts = 10;
-	while (!peer2->connected && !peer1->connected && attempts--)
+	while ((!peer2->connected || !peer1->connected) && attempts--)
 		sleep(1);
 
 	if (peer1->state != RTC_CONNECTED || peer2->state != RTC_CONNECTED) {
@@ -213,7 +213,7 @@ error:
 
 #include <stdexcept>
 
-void test_capi() {
+void test_capi_connectivity() {
-	if (test_capi_main())
+	if (test_capi_connectivity_main())
 		throw std::runtime_error("Connection failed");
 }

test/capi_track.cpp

@@ -0,0 +1,198 @@
+/**
+ * Copyright (c) 2020 Paul-Louis Ageneau
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include <rtc/rtc.h>
+
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+
+#ifdef _WIN32
+#include <windows.h>
+static void sleep(unsigned int secs) { Sleep(secs * 1000); }
+#else
+#include <unistd.h> // for sleep
+#endif
+
+typedef struct {
+	rtcState state;
+	rtcGatheringState gatheringState;
+	int pc;
+	int tr;
+	bool connected;
+} Peer;
+
+static Peer *peer1 = NULL;
+static Peer *peer2 = NULL;
+
+static const char *mediaDescription = "video 9 UDP/TLS/RTP/SAVPF\r\n"
+                                      "a=mid:video\r\n";
+
+static void descriptionCallback(const char *sdp, const char *type, void *ptr) {
+	Peer *peer = (Peer *)ptr;
+	printf("Description %d:\n%s\n", peer == peer1 ? 1 : 2, sdp);
+	Peer *other = peer == peer1 ? peer2 : peer1;
+	rtcSetRemoteDescription(other->pc, sdp, type);
+}
+
+static void candidateCallback(const char *cand, const char *mid, void *ptr) {
+	Peer *peer = (Peer *)ptr;
+	printf("Candidate %d: %s\n", peer == peer1 ? 1 : 2, cand);
+	Peer *other = peer == peer1 ? peer2 : peer1;
+	rtcAddRemoteCandidate(other->pc, cand, mid);
+}
+
+static void stateChangeCallback(rtcState state, void *ptr) {
+	Peer *peer = (Peer *)ptr;
+	peer->state = state;
+	printf("State %d: %d\n", peer == peer1 ? 1 : 2, (int)state);
+}
+
+static void gatheringStateCallback(rtcGatheringState state, void *ptr) {
+	Peer *peer = (Peer *)ptr;
+	peer->gatheringState = state;
+	printf("Gathering state %d: %d\n", peer == peer1 ? 1 : 2, (int)state);
+}
+
+static void openCallback(void *ptr) {
+	Peer *peer = (Peer *)ptr;
+	peer->connected = true;
+	printf("Track %d: Open\n", peer == peer1 ? 1 : 2);
+}
+
+static void closedCallback(void *ptr) {
+	Peer *peer = (Peer *)ptr;
+	peer->connected = false;
+}
+
+static void trackCallback(int tr, void *ptr) {
+	Peer *peer = (Peer *)ptr;
+	peer->tr = tr;
+	peer->connected = true;
+	rtcSetClosedCallback(tr, closedCallback);
+
+	char buffer[1024];
+	if (rtcGetTrackDescription(tr, buffer, 1024) >= 0)
+		printf("Track %d: Received with media description: \n%s\n", peer == peer1 ? 1 : 2, buffer);
+}
+
+static Peer *createPeer(const rtcConfiguration *config) {
+	Peer *peer = (Peer *)malloc(sizeof(Peer));
+	if (!peer)
+		return nullptr;
+	memset(peer, 0, sizeof(Peer));
+
+	// Create peer connection
+	peer->pc = rtcCreatePeerConnection(config);
+	rtcSetUserPointer(peer->pc, peer);
+	rtcSetTrackCallback(peer->pc, trackCallback);
+	rtcSetLocalDescriptionCallback(peer->pc, descriptionCallback);
+	rtcSetLocalCandidateCallback(peer->pc, candidateCallback);
+	rtcSetStateChangeCallback(peer->pc, stateChangeCallback);
+	rtcSetGatheringStateChangeCallback(peer->pc, gatheringStateCallback);
+
+	return peer;
+}
+
+static void deletePeer(Peer *peer) {
+	if (peer) {
+		if (peer->tr)
+			rtcDeleteTrack(peer->tr);
+		if (peer->pc)
+			rtcDeletePeerConnection(peer->pc);
+		free(peer);
+	}
+}
+
+int test_capi_track_main() {
+	int attempts;
+
+	rtcInitLogger(RTC_LOG_DEBUG, nullptr);
+
+	// Create peer 1
+	rtcConfiguration config1;
+	memset(&config1, 0, sizeof(config1));
+	// STUN server example
+	// const char *iceServers[1] = {"stun:stun.l.google.com:19302"};
+	// config1.iceServers = iceServers;
+	// config1.iceServersCount = 1;
+
+	peer1 = createPeer(&config1);
+	if (!peer1)
+		goto error;
+
+	// Create peer 2
+	rtcConfiguration config2;
+	memset(&config2, 0, sizeof(config2));
+	// STUN server example
+	// config2.iceServers = iceServers;
+	// config2.iceServersCount = 1;
+	// Port range example
+	config2.portRangeBegin = 5000;
+	config2.portRangeEnd = 6000;
+
+	peer2 = createPeer(&config2);
+	if (!peer2)
+		goto error;
+
+	// Peer 1: Create track
+	peer1->tr = rtcAddTrack(peer1->pc, mediaDescription);
+	rtcSetOpenCallback(peer1->tr, openCallback);
+	rtcSetClosedCallback(peer1->tr, closedCallback);
+
+	// Initiate the handshake
+	rtcSetLocalDescription(peer1->pc);
+
+	attempts = 10;
+	while ((!peer2->connected || !peer1->connected) && attempts--)
+		sleep(1);
+
+	if (peer1->state != RTC_CONNECTED || peer2->state != RTC_CONNECTED) {
+		fprintf(stderr, "PeerConnection is not connected\n");
+		goto error;
+	}
+
+	if (!peer1->connected || !peer2->connected) {
+		fprintf(stderr, "Track is not connected\n");
+		goto error;
+	}
+
+	deletePeer(peer1);
+	sleep(1);
+	deletePeer(peer2);
+	sleep(1);
+
+	// You may call rtcCleanup() when finished to free static resources
+	rtcCleanup();
+	sleep(2);
+
+	printf("Success\n");
+	return 0;
+
+error:
+	deletePeer(peer1);
+	deletePeer(peer2);
+	return -1;
+}
+
+#include <stdexcept>
+
+void test_capi_track() {
+	if (test_capi_track_main())
+		throw std::runtime_error("Connection failed");
+}

test/connectivity.cpp

@@ -47,20 +47,20 @@ void test_connectivity() {
 
 	auto pc2 = std::make_shared<PeerConnection>(config2);
 
-	pc1->onLocalDescription([wpc2 = make_weak_ptr(pc2)](const Description &sdp) {
+	pc1->onLocalDescription([wpc2 = make_weak_ptr(pc2)](Description sdp) {
 		auto pc2 = wpc2.lock();
 		if (!pc2)
 			return;
 		cout << "Description 1: " << sdp << endl;
-		pc2->setRemoteDescription(sdp);
+		pc2->setRemoteDescription(string(sdp));
 	});
 
-	pc1->onLocalCandidate([wpc2 = make_weak_ptr(pc2)](const Candidate &candidate) {
+	pc1->onLocalCandidate([wpc2 = make_weak_ptr(pc2)](Candidate candidate) {
 		auto pc2 = wpc2.lock();
 		if (!pc2)
 			return;
 		cout << "Candidate 1: " << candidate << endl;
-		pc2->addRemoteCandidate(candidate);
+		pc2->addRemoteCandidate(string(candidate));
 	});
 
 	pc1->onStateChange([](PeerConnection::State state) { cout << "State 1: " << state << endl; });
@@ -69,20 +69,20 @@ void test_connectivity() {
 		cout << "Gathering state 1: " << state << endl;
 	});
 
-	pc2->onLocalDescription([wpc1 = make_weak_ptr(pc1)](const Description &sdp) {
+	pc2->onLocalDescription([wpc1 = make_weak_ptr(pc1)](Description sdp) {
 		auto pc1 = wpc1.lock();
 		if (!pc1)
 			return;
 		cout << "Description 2: " << sdp << endl;
-		pc1->setRemoteDescription(sdp);
+		pc1->setRemoteDescription(string(sdp));
 	});
 
-	pc2->onLocalCandidate([wpc1 = make_weak_ptr(pc1)](const Candidate &candidate) {
+	pc2->onLocalCandidate([wpc1 = make_weak_ptr(pc1)](Candidate candidate) {
 		auto pc1 = wpc1.lock();
 		if (!pc1)
 			return;
 		cout << "Candidate 2: " << candidate << endl;
-		pc1->addRemoteCandidate(candidate);
+		pc1->addRemoteCandidate(string(candidate));
 	});
 
 	pc2->onStateChange([](PeerConnection::State state) { cout << "State 2: " << state << endl; });
@@ -94,8 +94,12 @@ void test_connectivity() {
 	shared_ptr<DataChannel> dc2;
 	pc2->onDataChannel([&dc2](shared_ptr<DataChannel> dc) {
 		cout << "DataChannel 2: Received with label \"" << dc->label() << "\"" << endl;
+		if (dc->label() != "test") {
+			cerr << "Wrong DataChannel label" << endl;
+			return;
+		}
 
-		dc->onMessage([](const variant<binary, string> &message) {
+		dc->onMessage([](variant<binary, string> message) {
 			if (holds_alternative<string>(message)) {
 				cout << "Message 2: " << get<string>(message) << endl;
 			}
@@ -121,6 +125,7 @@ void test_connectivity() {
 		}
 	});
 
+	// Wait a bit
 	int attempts = 10;
 	shared_ptr<DataChannel> adc2;
 	while ((!(adc2 = std::atomic_load(&dc2)) || !adc2->isOpen() || !dc1->isOpen()) && attempts--)
@@ -142,6 +147,49 @@ void test_connectivity() {
 	if (auto addr = pc2->remoteAddress())
 		cout << "Remote address 2: " << *addr << endl;
 
+	// Try to open a second data channel with another label
+	shared_ptr<DataChannel> second2;
+	pc2->onDataChannel([&second2](shared_ptr<DataChannel> dc) {
+		cout << "Second DataChannel 2: Received with label \"" << dc->label() << "\"" << endl;
+		if (dc->label() != "second") {
+			cerr << "Wrong second DataChannel label" << endl;
+			return;
+		}
+
+		dc->onMessage([](variant<binary, string> message) {
+			if (holds_alternative<string>(message)) {
+				cout << "Second Message 2: " << get<string>(message) << endl;
+			}
+		});
+
+		dc->send("Send hello from 2");
+
+		std::atomic_store(&second2, dc);
+	});
+
+	auto second1 = pc1->createDataChannel("second");
+	second1->onOpen([wsecond1 = make_weak_ptr(dc1)]() {
+		auto second1 = wsecond1.lock();
+		if (!second1)
+			return;
+
+		cout << "Second DataChannel 1: Open" << endl;
+		second1->send("Second hello from 1");
+	});
+	dc1->onMessage([](const variant<binary, string> &message) {
+		if (holds_alternative<string>(message)) {
+			cout << "Second Message 1: " << get<string>(message) << endl;
+		}
+	});
+
+	// Wait a bit
+	attempts = 10;
+	shared_ptr<DataChannel> asecond2;
+	while (
+	    (!(asecond2 = std::atomic_load(&second2)) || !asecond2->isOpen() || !second1->isOpen()) &&
+	    attempts--)
+		this_thread::sleep_for(1s);
+
 	// Delay close of peer 2 to check closing works properly
 	pc1->close();
 	this_thread::sleep_for(1s);

test/main.cpp

@@ -24,7 +24,9 @@ using namespace std;
 using namespace chrono_literals;
 
 void test_connectivity();
-void test_capi();
+void test_track();
+void test_capi_connectivity();
+void test_capi_track();
 void test_websocket();
 size_t benchmark(chrono::milliseconds duration);
 
@@ -49,13 +51,31 @@ int main(int argc, char **argv) {
 		return -1;
 	}
 	try {
-		cout << endl << "*** Running WebRTC C API test..." << endl;
+		cout << endl << "*** Running WebRTC C API connectivity test..." << endl;
-		test_capi();
+		test_capi_connectivity();
-		cout << "*** Finished WebRTC C API test" << endl;
+		cout << "*** Finished WebRTC C API connectivity test" << endl;
 	} catch (const exception &e) {
-		cerr << "WebRTC C API test failed: " << e.what() << endl;
+		cerr << "WebRTC C API connectivity test failed: " << e.what() << endl;
 		return -1;
 	}
+#if RTC_ENABLE_MEDIA
+	try {
+		cout << endl << "*** Running WebRTC Track test..." << endl;
+		test_track();
+		cout << "*** Finished WebRTC Track test" << endl;
+	} catch (const exception &e) {
+		cerr << "WebRTC Track test failed: " << e.what() << endl;
+		return -1;
+	}
+	try {
+		cout << endl << "*** Running WebRTC C API track test..." << endl;
+		test_capi_track();
+		cout << "*** Finished WebRTC C API track test" << endl;
+	} catch (const exception &e) {
+		cerr << "WebRTC C API track test failed: " << e.what() << endl;
+		return -1;
+	}
+#endif
 #if RTC_ENABLE_WEBSOCKET
 	try {
 		cout << endl << "*** Running WebSocket test..." << endl;

test/track.cpp

@@ -0,0 +1,134 @@
+/**
+ * Copyright (c) 2019 Paul-Louis Ageneau
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include "rtc/rtc.hpp"
+
+#include <atomic>
+#include <chrono>
+#include <iostream>
+#include <memory>
+#include <thread>
+
+using namespace rtc;
+using namespace std;
+
+template <class T> weak_ptr<T> make_weak_ptr(shared_ptr<T> ptr) { return ptr; }
+
+void test_track() {
+	InitLogger(LogLevel::Debug);
+
+	Configuration config1;
+	// STUN server example
+	// config1.iceServers.emplace_back("stun:stun.l.google.com:19302");
+
+	auto pc1 = std::make_shared<PeerConnection>(config1);
+
+	Configuration config2;
+	// STUN server example
+	// config2.iceServers.emplace_back("stun:stun.l.google.com:19302");
+	// Port range example
+	config2.portRangeBegin = 5000;
+	config2.portRangeEnd = 6000;
+
+	auto pc2 = std::make_shared<PeerConnection>(config2);
+
+	pc1->onLocalDescription([wpc2 = make_weak_ptr(pc2)](Description sdp) {
+		auto pc2 = wpc2.lock();
+		if (!pc2)
+			return;
+		cout << "Description 1: " << sdp << endl;
+		pc2->setRemoteDescription(string(sdp));
+	});
+
+	pc1->onLocalCandidate([wpc2 = make_weak_ptr(pc2)](Candidate candidate) {
+		auto pc2 = wpc2.lock();
+		if (!pc2)
+			return;
+		cout << "Candidate 1: " << candidate << endl;
+		pc2->addRemoteCandidate(string(candidate));
+	});
+
+	pc1->onStateChange([](PeerConnection::State state) { cout << "State 1: " << state << endl; });
+
+	pc1->onGatheringStateChange([](PeerConnection::GatheringState state) {
+		cout << "Gathering state 1: " << state << endl;
+	});
+
+	pc2->onLocalDescription([wpc1 = make_weak_ptr(pc1)](Description sdp) {
+		auto pc1 = wpc1.lock();
+		if (!pc1)
+			return;
+		cout << "Description 2: " << sdp << endl;
+		pc1->setRemoteDescription(string(sdp));
+	});
+
+	pc2->onLocalCandidate([wpc1 = make_weak_ptr(pc1)](Candidate candidate) {
+		auto pc1 = wpc1.lock();
+		if (!pc1)
+			return;
+		cout << "Candidate 2: " << candidate << endl;
+		pc1->addRemoteCandidate(string(candidate));
+	});
+
+	pc2->onStateChange([](PeerConnection::State state) { cout << "State 2: " << state << endl; });
+
+	pc2->onGatheringStateChange([](PeerConnection::GatheringState state) {
+		cout << "Gathering state 2: " << state << endl;
+	});
+
+	shared_ptr<Track> t2;
+	pc2->onTrack([&t2](shared_ptr<Track> t) {
+		cout << "Track 2: Received with mid \"" << t->mid() << "\"" << endl;
+		if (t->mid() != "test") {
+			cerr << "Wrong track mid" << endl;
+			return;
+		}
+
+		std::atomic_store(&t2, t);
+	});
+
+	auto t1 = pc1->addTrack(Description::Video("test"));
+
+	pc1->setLocalDescription();
+
+	int attempts = 10;
+	shared_ptr<Track> at2;
+	while ((!(at2 = std::atomic_load(&t2)) || !at2->isOpen() || !t1->isOpen()) && attempts--)
+		this_thread::sleep_for(1s);
+
+	if (pc1->state() != PeerConnection::State::Connected &&
+	    pc2->state() != PeerConnection::State::Connected)
+		throw runtime_error("PeerConnection is not connected");
+
+	if (!at2 || !at2->isOpen() || !t1->isOpen())
+		throw runtime_error("Track is not open");
+
+	// TODO: Test sending RTP packets in track
+
+	// Delay close of peer 2 to check closing works properly
+	pc1->close();
+	this_thread::sleep_for(1s);
+	pc2->close();
+	this_thread::sleep_for(1s);
+
+	// You may call rtc::Cleanup() when finished to free static resources
+	rtc::Cleanup();
+	this_thread::sleep_for(2s);
+
+	cout << "Success" << endl;
+}

test/websocket.cpp

@@ -53,9 +53,9 @@ void test_websocket() {
 	ws->onClosed([]() { cout << "WebSocket: Closed" << endl; });
 
 	std::atomic<bool> received = false;
-	ws->onMessage([&received, &myMessage](const variant<binary, string> &message) {
+	ws->onMessage([&received, &myMessage](variant<binary, string> message) {
 		if (holds_alternative<string>(message)) {
-			string str = get<string>(message);
+			string str = std::move(get<string>(message));
 			if((received = (str == myMessage)))
 				cout << "WebSocket: Received expected message" << endl;
 			else