Compare commits

..

167 Commits

Author SHA1 Message Date
71e5d2bf43 Define STATIC_GETOPT to client compilation on Windows 2020-09-25 12:35:14 +02:00
7188bc9d8d Minor compilation fixes 2020-09-25 11:49:01 +02:00
49180e826e Bumped version to 0.9.1 2020-09-25 11:10:05 +02:00
c6fbbb499f Updated libjuice to v0.5.0 2020-09-25 11:09:20 +02:00
7b565f0f0e Updated libjuice 2020-09-25 10:18:40 +02:00
a7cc637aa2 Fixed benchmark when connection fails 2020-09-24 20:19:26 +02:00
824bb93b0a Updated libjuice with aggressive pair nomination 2020-09-24 20:11:08 +02:00
6266e16644 Merge pull request #184 from paullouisageneau/signaling-server-endpoint
Add parameters to change servers port/endpoint
2020-09-24 15:37:39 +02:00
edd4fcfcc0 Handle optional non-localhost endpoint in rust signaling server 2020-09-24 15:24:03 +02:00
30dc229477 Handle optional non-localhost endpoint in web signaling server 2020-09-24 15:07:27 +02:00
d288885a89 Handle optional non-localhost endpoint in python signaling server 2020-09-24 14:42:26 +02:00
bd19d9d5b4 Updated libjuice 2020-09-24 14:41:40 +02:00
a284af2000 Merge pull request #182 from paullouisageneau/safe-queue-pop
Safer message queue
2020-09-24 14:35:06 +02:00
88e8d028b4 Refactored queue and introduced tryPop() 2020-09-24 12:15:45 +02:00
8cab2b9d87 Changed to const ref 2020-09-24 11:38:44 +02:00
14f8858d3d Merge pull request #172 from paullouisageneau/workaround-getline
Workaround for std::getline()
2020-09-23 17:13:37 +02:00
62f7642de9 Change getline logic to work around bug where getline does not erase 2020-09-23 16:24:21 +02:00
98048a178e Merge pull request #179 from paullouisageneau/enhance-juice-log
Enhance libjuice logging
2020-09-23 15:37:46 +02:00
26eb9bf300 Optimized libjuice logging by selecting the right level 2020-09-23 15:27:48 +02:00
d4ff4a3e0d Updated libjuice 2020-09-23 15:26:30 +02:00
488e143e1f Merge pull request #178 from paullouisageneau/update-usrsctp
Update usrsctp
2020-09-23 14:13:12 +02:00
4d5c5ef404 Connected new ulp_info parameter in usrsctp send callback 2020-09-23 13:56:54 +02:00
628742c2f3 Updated usrsctp 2020-09-23 13:52:32 +02:00
2492a42151 Merge pull request #177 from paullouisageneau/peerconnection-guards
Add guards to PeerConnection
2020-09-23 12:30:55 +02:00
4a0b6e99d4 Added guards to setRemoteDescription() 2020-09-23 12:19:52 +02:00
65946fe254 Merge pull request #173 from ecotarobles/master
Command line options for example server client
2020-09-23 11:07:57 +02:00
3286b5c05e Merge pull request #4 from paullouisageneau/master
Merge
2020-09-23 11:27:02 +03:00
ac8e02604d Swap out ancient getopt for a newer one and address review feedback. 2020-09-23 11:22:51 +03:00
ddf71ffdac Merge pull request #174 from paullouisageneau/fix-wrap-rtcaddtrack
Fix missing wrap in rtcAddTrack()
2020-09-22 14:19:57 +02:00
5dd57204dd Fixed missing wrap in rtcAddTrack() 2020-09-22 11:13:58 +02:00
9a622a5e44 Comment out illegal const #define 2020-09-22 11:47:41 +03:00
42e79ce921 Command line options for example server client:
examples/client/client -s 192.168.0.68 -t 3478 -w 192.168.0.61 -x 8000 -e

STUN server is 192.168.0.68:3478, web-socket server is 192.168.0.61:8000.
-e option echoes recd messages back to sender (useful for ping timing).
2020-09-22 11:11:20 +03:00
cdde6ad36e Merge pull request #3 from paullouisageneau/master
Update to tip.
2020-09-22 10:29:30 +03:00
78769ecde2 Fixed rtp to rtcp renaming 2020-09-20 21:54:29 +02:00
430f6dbb1a Fixed C API link 2020-09-20 14:08:57 +02:00
1c01246886 Bumped version to 0.9.0 2020-09-20 13:51:54 +02:00
1f3a0f1ba7 Some cleanup 2020-09-20 13:48:08 +02:00
5622b39ed0 Made RtcpSession print to debug log instead of cout 2020-09-20 12:44:00 +02:00
5e36364145 Moved rtc.cpp to capi.cpp 2020-09-20 12:32:50 +02:00
75b0b6dcdf Moved rtp.hpp into rtcp.hpp and rtcp.cpp 2020-09-20 12:31:28 +02:00
8e5b84ccca Updated libjuice to v0.4.6 2020-09-20 12:03:24 +02:00
a3b96e1abf Added verbose log lines when issuing local description and candidates 2020-09-19 18:55:39 +02:00
9492a6729e Updated libjuice 2020-09-19 18:52:51 +02:00
4ecf9795ee Updated libjuice 2020-09-19 12:24:18 +02:00
ada13e21d3 Merge pull request #167 from paullouisageneau/api-add
Rename createTrack to addTrack()
2020-09-18 23:13:39 +02:00
a1721268a2 Renamed createTrack() to addTrack() and added addDataChannel() 2020-09-18 23:01:50 +02:00
6a876dda49 Updated libjuice 2020-09-17 14:50:37 +02:00
6c02e7ed2b Merge pull request #164 from paullouisageneau/fix-macos-workflow
Fix MacOS workflow
2020-09-16 11:02:06 +02:00
09b8a86d8f Fixed OpenSSL 1.1 installation on macOS workflow 2020-09-16 10:52:36 +02:00
d718447e7a Updated libjuice 2020-09-16 10:27:34 +02:00
57cb6b3616 Added GitHub Sponsor to funding 2020-09-15 17:59:12 +02:00
00e6de2e15 Added Media Transport in compatiblity section 2020-09-14 22:55:31 +02:00
64e49f6e03 Changed description: 2020-09-14 22:52:55 +02:00
35933853a4 Added a few clarifications about implementation 2020-09-14 21:55:29 +02:00
d64fa4a7a7 Added links to RFCs used for demultiplexing 2020-09-14 21:37:23 +02:00
2857eb3787 Changed description 2020-09-14 20:40:10 +02:00
7c9e3c4e57 Changed description 2020-09-14 20:36:34 +02:00
5cb124f185 Updated Readme to mention media transport 2020-09-14 17:10:18 +02:00
7489e3851e Changed media example log level to warning 2020-09-14 16:53:11 +02:00
d323c40c0a Merge pull request #162 from paullouisageneau/fix-h264-firefox
Fix media example with Firefox
2020-09-14 16:46:15 +02:00
03a78aaa0c Updated libjuice 2020-09-14 16:45:27 +02:00
0e31c1d985 Some cleanup 2020-09-14 16:27:40 +02:00
bab30a06c7 Added profile-level-id when video codec is H264 2020-09-14 16:25:46 +02:00
c7d1c6ed54 Updated libjuice 2020-09-14 16:22:35 +02:00
7219b8e999 Merge pull request #161 from paullouisageneau/track-capi
Add Track C API
2020-09-13 16:30:26 +02:00
d9de5080e5 Added track C API test 2020-09-13 15:17:11 +02:00
649a5d0e88 Fixed track open callback 2020-09-13 15:16:41 +02:00
8323f6b82c Fixed duplicate attributes 2020-09-13 14:59:40 +02:00
d16f2b9e2f Added rtcSetLocalDescription() to C API 2020-09-13 14:44:54 +02:00
a43dbdd1b0 Added Track C API 2020-09-13 13:44:06 +02:00
8f9945b4b9 Merge pull request #159 from paullouisageneau/handle-eintr
Handle select interruption
2020-09-13 13:43:28 +02:00
d60ec4bf59 Fixed generated SDP description order 2020-09-11 19:08:28 +02:00
e8a4c859e6 Removed rtcp-mux-only attribute 2020-09-11 18:13:31 +02:00
359c19652b Handle select() interruption with EINTR 2020-09-11 11:57:18 +02:00
7ff0e309e5 Updated libjuice 2020-09-11 11:29:54 +02:00
b2b7bfe32a Merge pull request #157 from paullouisageneau/finish-track
Finish track API
2020-09-10 18:28:05 +02:00
96e978a8e7 Fixed compilation on macOS 2020-09-10 18:01:10 +02:00
ccbd4497ca Updated libjuice 2020-09-10 17:53:19 +02:00
d49035f361 Fixed media example page title 2020-09-10 17:47:24 +02:00
d289ccecf5 Raise error on remote description without active media 2020-09-10 15:24:31 +02:00
65d1268082 Implemented differenciated application and media handling 2020-09-10 14:37:37 +02:00
d1c798c695 Auto-detect libSRTP with cmake 2020-09-10 14:19:34 +02:00
33ff0cd7cc Added track test 2020-09-10 11:15:12 +02:00
6ddba307e6 Changed state to connected when no SCTP transport is needed 2020-09-10 09:45:01 +02:00
f720cbac0c Added media constructor from SDP 2020-09-09 21:44:37 +02:00
66e05677e4 Merge pull request #156 from paullouisageneau/incoming-tracks
Incoming tracks
2020-09-08 12:44:06 +02:00
810cafe09b Trigger track callback on new track 2020-09-08 12:35:01 +02:00
28e9cd5196 Implemented incoming tracks and media direction 2020-09-08 12:07:38 +02:00
cc954cc74c Added inactive as media direction 2020-09-08 11:23:40 +02:00
6731e46386 Updated libjuice 2020-09-07 19:17:27 +02:00
b608a192c0 Use discard port 9 instead of 0 in description media entries 2020-09-07 18:05:27 +02:00
a18e9c50c4 Merge pull request #153 from paullouisageneau/track-api
Add Track API
2020-09-07 17:39:53 +02:00
d836b95c5d Pass RTCP messages to first track and do not start SCTP without application 2020-09-07 17:32:49 +02:00
66e9b9dd8b Removed unreliable bit fields in RTP structures 2020-09-07 16:48:48 +02:00
6c3aaf8a77 Refactored description for media handling 2020-09-07 16:48:42 +02:00
31aac35d2c Finished fixing media example 2020-09-01 15:26:53 +02:00
f1b680df4a Fixes for RTP 2020-09-01 15:03:29 +02:00
4e426d75e0 Cleaned up unused stuff 2020-09-01 14:25:01 +02:00
d4f464bf89 Fixed broken byte-order-specific structs 2020-09-01 14:21:09 +02:00
d90a5d628f Refactored media API into track API 2020-09-01 12:33:18 +02:00
7775f5da4f Merge pull request #154 from paullouisageneau/dependabot/npm_and_yarn/examples/web/websocket-1.0.32
Bump websocket from 1.0.31 to 1.0.32 in /examples/web
2020-08-31 11:54:41 +02:00
f15204c370 Bump websocket from 1.0.31 to 1.0.32 in /examples/web
Bumps [websocket](https://github.com/theturtle32/WebSocket-Node) from 1.0.31 to 1.0.32.
- [Release notes](https://github.com/theturtle32/WebSocket-Node/releases)
- [Changelog](https://github.com/theturtle32/WebSocket-Node/blob/master/CHANGELOG.md)
- [Commits](https://github.com/theturtle32/WebSocket-Node/commits)

Signed-off-by: dependabot[bot] <support@github.com>
2020-08-31 06:25:23 +00:00
fdea83cdfd Fixes 2020-08-27 10:15:30 +02:00
f6be5d6db0 Merge pull request #143 from stazio/webrtc_media
Create API for WebRTC Media Streams
2020-08-27 10:14:52 +02:00
bc27393e62 Merge branch 'track-api' into webrtc_media 2020-08-27 10:14:11 +02:00
71ebf7a62e Fixed copy on return 2020-08-22 22:19:02 +02:00
24e502712f Added media description to track 2020-08-22 22:11:44 +02:00
749836b1fe Integrated Track into PeerConnection 2020-08-22 18:23:54 +02:00
0b055ac17d Added Track class 2020-08-22 16:11:21 +02:00
09db03ba02 Merge pull request #152 from paullouisageneau/prevent-message-copy
Prevent message copy
2020-08-22 12:20:17 +02:00
9c4428810c Updated Readme 2020-08-22 00:23:15 +02:00
3e559f18d9 Updated description and candidate callbacks with move semantics 2020-08-22 00:22:19 +02:00
159da088a9 Updated Readme 2020-08-22 00:10:40 +02:00
942152dd8c Updated examples to callbacks with move semantics 2020-08-22 00:04:49 +02:00
c001bb3f9d Refactored include/message.hpp 2020-08-21 23:58:47 +02:00
3c971e05dd Prevent message copy with move semantics 2020-08-21 23:46:12 +02:00
f4ceaaa31b Updated libjuice 2020-08-19 20:50:16 +02:00
e6e03d4cfd Merge pull request #151 from paullouisageneau/fix-srtp-key-openssl
Fix SRTP key derivation with OpenSSL
2020-08-19 19:34:56 +02:00
0556abd4ee Fixed SRTP key derivation with OpenSSL 2020-08-19 19:27:58 +02:00
3a3df80c2c Updated libjuice 2020-08-19 18:31:42 +02:00
ac78ba48d9 Merge pull request #150 from paullouisageneau/fix-tlsext-use-srtp-openssl
Fix SSL_set_tlsext_use_srtp() error checking
2020-08-18 12:12:53 +02:00
6ed692325f Fixed SSL_set_tlsext_use_srtp() error checking 2020-08-18 11:59:47 +02:00
bf044080e8 Added bitrate control via SDP 2020-08-17 07:21:24 -04:00
22ffaacc5c Renamed Direction enums to be inline with other enums 2020-08-17 06:31:17 -04:00
91f4c3699c Undid CMake's changes to Makefile 2020-08-17 06:27:48 -04:00
07abd640fd Added RTCP Sessions; Added copy/paste example demo to use in the browser 2020-08-16 21:01:44 -04:00
f34d2bb2fe Merge pull request #141 from paullouisageneau/fix-sdp-media
Fix media SDP generation
2020-08-15 22:56:08 +02:00
642861f3be Fixed comment 2020-08-15 22:39:18 +02:00
fcd4228b56 merged with master and changed things 2020-08-14 11:11:18 -04:00
c03e615483 Merge pull request #1 from paullouisageneau/master
Update 14.08.2020
2020-08-14 12:40:09 +03:00
fed51f354a Check remote description on setRemoteDescription() 2020-08-14 09:47:47 +02:00
29bc19aa12 Merged with master 2020-08-13 11:32:10 -04:00
0620de5e62 Merge branch 'master' into fix-sdp-media 2020-08-13 14:12:30 +02:00
672287bbcf Merge pull request #147 from paullouisageneau/transport-init
Redesign transport initialization
2020-08-13 14:11:43 +02:00
d98a056469 Prevented stopping non-started transports 2020-08-13 13:53:20 +02:00
352f640756 Redesigned transport init and moved thread start to dedicated method 2020-08-13 12:32:13 +02:00
3f5eecb2e0 Fixed SRTP not wrapping outbound packets in DTLS 2020-08-12 07:56:59 -04:00
b5f8397936 Changed onMedia to use message_ptr; Applying control/binary type to media messages 2020-08-11 23:52:43 -04:00
9a63919925 Fixed use_srtp not being requested on srtp traffic 2020-08-11 21:31:59 -04:00
e1a95c2eee Use bundle mid for candidates mid 2020-08-11 18:47:48 +02:00
b7e1481621 Compatibility fixes for SDP generation 2020-08-11 18:37:22 +02:00
3deb50e460 Generate simplified SDP for libnice 2020-08-11 14:16:04 +02:00
6e733dab0c Fixed indentation 2020-08-11 11:16:38 +02:00
4a1c866117 Merge pull request #142 from stazio/fix-sdp-media
Move comon lines before m= lines
2020-08-11 11:11:41 +02:00
9c3b3ffb08 Fixed some typos 2020-08-10 21:32:16 -04:00
7e5edd1fa6 Moved comon lines before m= line 2020-08-10 19:15:47 -04:00
48443e9e95 Moved SDP common part under the first m-line 2020-08-11 00:13:48 +02:00
152eacc22d Merge pull request #140 from paullouisageneau/media-sdp
Add optional parameter for answerer media SDP
2020-08-10 17:47:52 +02:00
a6d2729556 Added optional parameter for media SDP to setRemoteDescription() 2020-08-10 17:05:26 +02:00
3f67a10720 Bumped version to 0.8.0 2020-08-10 14:17:22 +02:00
c0ea85025b Added hostname to web example server 2020-08-10 14:14:14 +02:00
b44f90b87f Added cmake flag for warnings as errors 2020-08-10 14:04:45 +02:00
498e7246a0 Fixed compilation on MSVC 2020-08-10 11:36:41 +02:00
8b1a67760c Fixed compilation with libnice 2020-08-10 11:18:20 +02:00
381d0ead1a Fixed compilation on MacOS 2020-08-10 11:06:15 +02:00
d1f77ebb10 Set warnings as errors 2020-08-10 11:01:22 +02:00
6223967bca Merge pull request #138 from paullouisageneau/reliability-c-api
Add Data Channel reliability to C API
2020-08-10 10:24:17 +02:00
e2c42ff73b Fixed unordered flag and renamed reliability type for consistency 2020-08-10 10:13:03 +02:00
980ee303c8 Fixed conversion for maxRetransmits 2020-08-08 22:10:36 +02:00
2967444678 Added Data Channel reliability to C API 2020-08-08 22:09:13 +02:00
35cad4e916 Added link to murat-dogan/node-datachannel following #122 2020-07-31 15:33:06 +02:00
ccc4d61fd3 Added Android explicitly following #44 2020-07-31 15:33:06 +02:00
aac9b101d8 Merge pull request #135 from murat-dogan/master
add NO_TESTS option
2020-07-28 13:36:13 +02:00
8d9eeda6e5 Update CMakeLists.txt 2020-07-28 13:46:55 +03:00
5eaee49e1e add NO_TESTS option 2020-07-28 10:59:55 +03:00
68fd331a9c Fixed setLocalDescription() so it doesn't require a fingerprint 2020-07-26 18:46:03 +02:00
0bb246785b Updated libjuice to v0.4.5 2020-07-26 12:55:07 +02:00
75 changed files with 4609 additions and 788 deletions

2
.github/FUNDING.yml vendored
View File

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

View File

@ -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

View File

@ -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

View File

@ -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

View File

@ -1,15 +1,16 @@
cmake_minimum_required(VERSION 3.7)
project(libdatachannel
DESCRIPTION "WebRTC Data Channels Library"
VERSION 0.7.2
VERSION 0.9.1
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 REQUIRED)
find_package(SRTP)
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,7 +223,23 @@ add_library(LibDataChannel::LibDataChannelStatic ALIAS datachannel-static)
install(TARGETS datachannel LIBRARY DESTINATION lib)
install(FILES ${LIBDATACHANNEL_HEADERS} DESTINATION include/rtc)
if(NOT MSVC)
target_compile_options(datachannel PRIVATE -Wall -Wextra)
target_compile_options(datachannel-static PRIVATE -Wall -Wextra)
endif()
if(WARNINGS_AS_ERRORS)
if(MSVC)
target_compile_options(datachannel PRIVATE /WX)
target_compile_options(datachannel-static PRIVATE /WX)
else()
target_compile_options(datachannel PRIVATE -Werror)
target_compile_options(datachannel-static PRIVATE -Werror)
endif()
endif()
# Tests
if(NOT NO_TESTS)
add_executable(datachannel-tests ${TESTS_SOURCES})
set_target_properties(datachannel-tests PROPERTIES
VERSION ${PROJECT_VERSION}
@ -239,12 +265,14 @@ if(WIN32)
else()
target_link_libraries(datachannel-benchmark datachannel)
endif()
endif()
# Examples
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()

View File

@ -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)
- WebAssembly wrappers compatible with libdatachannel: [datachannel-wasm](https://github.com/paullouisageneau/datachannel-wasm)
- Rust wrapper for libdatachannel: [datachannel-rs](https://github.com/lerouxrgd/datachannel-rs)
- 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)

2
deps/libjuice vendored

2
deps/usrsctp vendored

View File

@ -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

View File

@ -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)

View File

@ -0,0 +1,4 @@
# getopt-for-windows
getopt.h and getopt.c is very often used in linux, to make it easy for windows user, two files were extracted from glibc. In order to make it works properly in windows, some modification was done and you may compare the change using original source files. Enjoy it!
Source: https://github.com/Chunde/getopt-for-windows. IMPORTANT: getopt.[ch] are likely not safe for Linux due to conflict with existing getopt.[ch]. They are thus NOT in CMakeFiles.txt and instead both files are #include only on Windows.

973
examples/client/getopt.cpp Normal file
View File

@ -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);
}

136
examples/client/getopt.h Normal file
View File

@ -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_

View File

@ -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,41 @@ 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->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 +88,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 +124,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 +166,20 @@ int main(int argc, char **argv) {
dc->onClosed([id]() { cout << "DataChannel from " << id << " closed" << endl; });
dc->onMessage([id](const variant<binary, string> &message) {
if (!holds_alternative<string>(message))
return;
dc->onMessage([id, wdc = make_weak_ptr(dc)](const variant<binary, string> &message) {
static bool firstMessage = true;
if (holds_alternative<string>(message) && (!echoDataChannelMessages || firstMessage)) {
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 +191,7 @@ int main(int argc, char **argv) {
dataChannelMap.clear();
peerConnectionMap.clear();
delete params;
return 0;
}
@ -166,7 +205,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 +213,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 +229,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) {
if (!holds_alternative<string>(message))
return;
dc->onMessage([id, wdc = make_weak_ptr(dc)](const variant<binary, string> &message) {
static bool firstMessage = true;
if (holds_alternative<string>(message) && (!echoDataChannelMessages || firstMessage)) {
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 +254,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(

View File

@ -0,0 +1,173 @@
/******************************************************************************
**
** 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[] =
{
{"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 */
_s = "stun.l.google.com";
_t = 19302;
_w = "localhost";
_x = 8000;
_e = false;
_h = false;
_v = false;
optind = 0;
while ((c = getopt_long (argc, argv, "s:t:w:x:ehv", long_options, &optind)) != - 1)
{
switch (c)
{
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 'e':
_e = true;
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 << " [ -estwxhv ] \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\
[ -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);
}

View File

@ -0,0 +1,72 @@
/******************************************************************************
**
** 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 */
std::string _s;
int _t;
std::string _w;
int _x;
bool _e;
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; }
std::string stunServer () const { return _s; }
int stunPort () const { return _t; }
std::string webSocketServer () const { return _w; }
int webSocketPort () const { return _x; }
bool echoDataChannelMessages () const { return _e; }
bool h () const { return _h; }
bool v () const { return _v; }
};
#endif

View File

@ -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;
}

View File

@ -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;
}

View File

@ -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)

19
examples/media/README.md Normal file
View File

@ -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
```

97
examples/media/main.cpp Normal file
View File

@ -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;
}
}

45
examples/media/main.html Normal file
View File

@ -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>

View File

@ -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))
start_server = websockets.serve(handle_websocket, '127.0.0.1', port, ssl=ssl_context)
print('Listening on {}'.format(endpoint))
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()

View File

@ -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",

View File

@ -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");

View File

@ -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",
"resolved": "https://registry.npmjs.org/type/-/type-2.0.0.tgz",
"integrity": "sha512-KBt58xCHry4Cejnc2ISQAF7QY+ORngsWfxezO68+12hKV6lQY8P/psIkcbjeHWn7MqcgciWJyCCevFMJdIXpow=="
"version": "2.1.0",
"resolved": "https://registry.npmjs.org/type/-/type-2.1.0.tgz",
"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": {
"version": "1.0.31",
"resolved": "https://registry.npmjs.org/websocket/-/websocket-1.0.31.tgz",
"integrity": "sha512-VAouplvGKPiKFDTeCCO65vYHsyay8DqoBSlzIO3fayrfOgU94lQN5a1uWVnFrMLceTJw/+fQXR5PGbUVRaHshQ==",
"utf-8-validate": {
"version": "5.0.2",
"resolved": "https://registry.npmjs.org/utf-8-validate/-/utf-8-validate-5.0.2.tgz",
"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"
}
},

View File

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

View File

@ -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}`);
});

View File

@ -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(const binary &data)> binaryCallback,
std::function<void(const string &data)> stringCallback);
void onMessage(std::function<void(message_variant data)> callback);
void onMessage(std::function<void(binary data)> binaryCallback,
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<const std::variant<binary, string> &> mMessageCallback;
synchronized_callback<string> mErrorCallback;
synchronized_callback<message_variant> mMessageCallback;
synchronized_callback<> mAvailableCallback;
synchronized_callback<> mBufferedAmountLowCallback;

View File

@ -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();

View File

@ -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(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(const string &eol) 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
struct Data {
string mid;
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
// Entries
std::vector<std::shared_ptr<Entry>> mEntries;
std::shared_ptr<Application> mApplication;
// Candidates
std::vector<Candidate> mCandidates;

View File

@ -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

View File

@ -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,
unsigned int stream = 0,
std::shared_ptr<Reliability> reliability = nullptr) {
auto message = std::make_shared<Message>(size, type);
message->stream = stream;
message->reliability = reliability;
return message;
}
message_ptr make_message(size_t size, Message::Type type = Message::Binary, unsigned int stream = 0,
std::shared_ptr<Reliability> reliability = nullptr);
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,
std::shared_ptr<Reliability> reliability = nullptr) {
auto message = std::make_shared<Message>(std::move(data), type);
message->stream = stream;
message->reliability = reliability;
return message;
}
std::shared_ptr<Reliability> reliability = nullptr);
message_ptr make_message(message_variant data);
message_variant to_variant(Message &&message);
} // namespace rtc

View File

@ -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 = "",
const Reliability &reliability = {});
std::shared_ptr<DataChannel> addDataChannel(string label, string protocol = "",
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 onLocalCandidate(std::function<void(const Candidate &candidate)> callback);
void onLocalDescription(std::function<void(Description description)> 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
bool hasMedia() const;
void sendMedia(const binary &packet);
void sendMedia(const byte *packet, size_t size);
void onMedia(std::function<void(const binary &packet)> callback);
// Track media support requires compiling with libSRTP
std::shared_ptr<Track> addTrack(Description::Media description);
void onTrack(std::function<void(std::shared_ptr<Track> track)> 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,
const string &protocol,
const Reliability &reliability);
std::shared_ptr<DataChannel> emplaceDataChannel(Description::Role role, string label,
string protocol, 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::shared_mutex mDataChannelsMutex;
std::unordered_map<unsigned int, std::weak_ptr<DataChannel>> mDataChannels; // by stream ID
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<const Candidate &> mLocalCandidateCallback;
synchronized_callback<Description> mLocalDescriptionCallback;
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

View File

@ -39,15 +39,20 @@ public:
void stop();
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;
@ -80,6 +85,11 @@ template <typename T> bool Queue<T>::empty() const {
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 +103,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) {
mAmount += mAmountFunction(element);
mQueue.emplace(std::move(element));
mPopCondition.notify_one();
}
pushImpl(std::move(element));
}
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()) {
mAmount -= mAmountFunction(mQueue.front());
std::optional<T> element{std::move(mQueue.front())};
mQueue.pop();
return element;
} else {
return nullopt;
return popImpl();
}
template <typename T> std::optional<T> Queue<T>::tryPop() {
std::unique_lock lock(mMutex);
return popImpl();
}
template <typename T> std::optional<T> Queue<T>::peek() {
std::unique_lock lock(mMutex);
if (!mQueue.empty()) {
return std::optional<T>{mQueue.front()};
} else {
return nullopt;
}
return !mQueue.empty() ? std::make_optional(mQueue.front()) : nullopt;
}
template <typename T> std::optional<T> Queue<T>::exchange(T element) {
std::unique_lock lock(mMutex);
if (!mQueue.empty()) {
std::swap(mQueue.front(), element);
return std::optional<T>{element};
} else {
if (mQueue.empty())
return nullopt;
}
std::swap(mQueue.front(), element);
return std::make_optional(std::move(element));
}
template <typename T>
@ -139,7 +138,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

View File

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

View File

@ -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);

59
include/rtc/rtcp.hpp Normal file
View File

@ -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

82
include/rtc/track.hpp Normal file
View File

@ -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

View File

@ -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:

View File

@ -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());

View File

@ -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)
throw std::invalid_argument("Unexpected null pointer");
if (!data && size != 0)
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)
throw std::invalid_argument("Unexpected null pointer");
if (!size)
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) {
if (*size > 0) {
*size = std::min(*size, int(b.size()));
auto data = reinterpret_cast<const char *>(b.data());
std::copy(data, data + *size, buffer);
}
return 1;
},
[&](const string &s) {
[&](string s) {
if (*size > 0) {
int len = std::min(*size - 1, int(s.size()));
if (len >= 0) {
std::copy(s.data(), s.data() + len, buffer);
buffer[len] = '\0';
}
*size = -(len + 1);
}
return 1;
}},
*message);

View File

@ -34,11 +34,9 @@ void Channel::onClosed(std::function<void()> callback) {
mClosedCallback = callback;
}
void Channel::onError(std::function<void(const string &error)> callback) {
mErrorCallback = callback;
}
void Channel::onError(std::function<void(string error)> 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,
std::function<void(const string &data)> stringCallback) {
onMessage([binaryCallback, stringCallback](const std::variant<binary, string> &data) {
std::visit(overloaded{binaryCallback, stringCallback}, data);
void Channel::onMessage(std::function<void(binary data)> binaryCallback,
std::function<void(string data)> stringCallback) {
onMessage([binaryCallback, stringCallback](std::variant<binary, string> 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)

View File

@ -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) {
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(message_variant data) { return outgoing(make_message(std::move(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() {
while (!mRecvQueue.empty()) {
auto message = *mRecvQueue.pop();
switch (message->type) {
case Message::Control: {
std::optional<message_variant> DataChannel::receive() {
while (auto next = mRecvQueue.tryPop()) {
message_ptr message = std::move(*next);
if (message->type == 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;
}
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;
} else {
return to_variant(std::move(*message));
}
}
@ -157,7 +144,8 @@ 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())
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);
if (mReliability->unordered)
channelType &= 0x80;
using std::chrono::milliseconds;
uint32_t reliabilityParameter = 0;
if (mReliability->type == Reliability::TYPE_PARTIAL_RELIABLE_REXMIT)
uint8_t channelType;
uint32_t reliabilityParameter;
switch (mReliability->type) {
case Reliability::Type::Rexmit:
channelType = CHANNEL_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;
@ -272,19 +271,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:
mReliability->type = Reliability::TYPE_PARTIAL_RELIABLE_REXMIT;
case CHANNEL_PARTIAL_RELIABLE_REXMIT:
mReliability->type = Reliability::Type::Rexmit;
mReliability->rexmit = int(open.reliabilityParameter);
break;
case Reliability::TYPE_PARTIAL_RELIABLE_TIMED:
mReliability->type = Reliability::TYPE_PARTIAL_RELIABLE_TIMED;
case CHANNEL_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);
}

View File

@ -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;
int mlineIndex = 0;
bool finished;
do {
while (ss) {
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 (currentMedia) {
if (!currentMedia->mid.empty()) {
if (currentMedia->type == "application")
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)));
if (match_prefix(line, "m=")) {
++index;
string mline = line.substr(2);
current = createEntry(std::move(mline), std::to_string(index), Direction::Unknown);
// Attribute line
} else if (match_prefix(line, "a=")) {
string attr = line.substr(2);
auto [key, value] = parse_pair(attr);
string key, value;
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 (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) {
currentMedia->attributes.emplace_back(line.substr(2));
} else if (current) {
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 {
if (!mFingerprint)
throw std::logic_error("Fingerprint must be set to generate an SDP string");
string Description::generateSdp(string_view eol) const {
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)
if (auto it = mMedia.find(i); it != mMedia.end())
sdp << ' ' << it->second.mid;
else
sdp << ' ' << mData.mid;
for (const auto &entry : mEntries)
sdp << ' ' << entry->mid();
sdp << eol;
sdp << "a=msid-semantic: WMS" << eol;
// Non-data media
if (!mMedia.empty()) {
// Lip-sync
sdp << "a=group:LS";
for (const auto &p : mMedia)
sdp << " " << p.second.mid;
sdp << eol;
}
std::ostringstream lsGroup;
for (const auto &entry : mEntries)
if (entry != mApplication)
lsGroup << ' ' << entry->mid();
// Descriptions and attributes
for (int i = 0; i < int(mMedia.size() + 1); ++i) {
if (auto it = mMedia.find(i); it != mMedia.end()) {
// Non-data media
const auto &media = it->second;
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;
if (!lsGroup.str().empty())
sdp << "a=group:LS" << lsGroup.str() << 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;
}
}
// 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;
// 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,19 +273,464 @@ 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) {
size_t p = mline.find(' ');
this->type = mline.substr(0, p);
if (p != string::npos)
if (size_t q = mline.find(' ', p + 1); q != string::npos)
this->description = mline.substr(q + 1);
shared_ptr<Description::Entry> Description::createEntry(string mline, string mid, Direction dir) {
string type = mline.substr(0, mline.find(' '));
if (type == "application") {
removeApplication();
mApplication = std::make_shared<Application>(std::move(mid));
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")
@ -324,4 +768,3 @@ string Description::roleToString(Role role) {
std::ostream &operator<<(std::ostream &out, const rtc::Description &description) {
return out << std::string(description);
}

View File

@ -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 true;
return outgoing(message);
// 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 = material + SRTP_AES_ICM_128_KEY_LEN_WSALT;
serverSalt = serverKey + SRTP_AES_128_KEY_LEN;
serverKey = clientKey + SRTP_AES_128_KEY_LEN;
clientSalt = serverKey + SRTP_AES_128_KEY_LEN;
serverSalt = clientSalt + SRTP_SALT_LEN;
#endif
unsigned char clientSessionKey[SRTP_AES_ICM_128_KEY_LEN_WSALT];

View File

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

View File

@ -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))
: nullopt);
return !t->mIncomingQueue.empty() ? 1 : 0;
bool notEmpty = t->mIncomingQueue.wait(
ms != GNUTLS_INDEFINITE_TIMEOUT ? std::make_optional(milliseconds(ms)) : nullopt);
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
}
@ -436,8 +437,8 @@ void DtlsTransport::runRecvLoop() {
byte buffer[bufferSize];
while (true) {
// Process pending messages
while (!mIncomingQueue.empty()) {
auto message = *mIncomingQueue.pop();
while (auto next = mIncomingQueue.tryPop()) {
message_ptr message = std::move(*next);
BIO_write(mInBio, message->data(), int(message->size()));
if (state() == State::Connecting) {

View File

@ -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();

View File

@ -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();
if (juice_set_remote_description(mAgent.get(), string(description).c_str()) < 0)
throw std::runtime_error("Failed to parse remote SDP");
mMid = description.bundleMid();
if (juice_set_remote_description(mAgent.get(),
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) {
@ -483,12 +507,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)
throw std::runtime_error("Failed to parse remote SDP");
if (nice_agent_parse_remote_sdp(mNiceAgent.get(),
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 +647,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 +657,8 @@ void IceTransport::GatheringDoneCallback(NiceAgent *agent, guint streamId, gpoin
}
}
void IceTransport::StateChangeCallback(NiceAgent *agent, guint streamId, guint componentId,
guint state, gpointer userData) {
void IceTransport::StateChangeCallback(NiceAgent * /*agent*/, guint /*streamId*/,
guint /*componentId*/, guint state, gpointer userData) {
auto iceTransport = static_cast<rtc::IceTransport *>(userData);
try {
iceTransport->processStateChange(state);
@ -641,8 +667,8 @@ void IceTransport::StateChangeCallback(NiceAgent *agent, guint streamId, guint c
}
}
void IceTransport::RecvCallback(NiceAgent *agent, guint streamId, guint componentId, guint len,
gchar *buf, gpointer userData) {
void IceTransport::RecvCallback(NiceAgent * /*agent*/, guint /*streamId*/, guint /*componentId*/,
guint len, gchar *buf, gpointer userData) {
auto iceTransport = static_cast<rtc::IceTransport *>(userData);
try {
PLOG_VERBOSE << "Incoming size=" << len;
@ -663,8 +689,8 @@ gboolean IceTransport::TimeoutCallback(gpointer userData) {
return FALSE;
}
void IceTransport::LogCallback(const gchar *logDomain, GLogLevelFlags logLevel,
const gchar *message, gpointer userData) {
void IceTransport::LogCallback(const gchar * /*logDomain*/, GLogLevelFlags logLevel,
const gchar *message, gpointer /*userData*/) {
plog::Severity severity;
unsigned int flags = logLevel & G_LOG_LEVEL_MASK;
if (flags & G_LOG_LEVEL_ERROR)
@ -708,7 +734,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 +747,7 @@ const CandidateType IceTransport::NiceTypeToCandidateType(NiceCandidateType type
}
}
const CandidateTransportType
CandidateTransportType
IceTransport::NiceTransportTypeToCandidateTransportType(NiceCandidateTransport type) {
switch (type) {
case NiceCandidateTransport::NICE_CANDIDATE_TRANSPORT_TCP_ACTIVE:

View File

@ -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 const CandidateTransportType NiceTransportTypeToCandidateTransportType(NiceCandidateTransport type);
static CandidateType NiceTypeToCandidateType(NiceCandidateType type);
static CandidateTransportType
NiceTransportTypeToCandidateTransportType(NiceCandidateTransport type);
#endif
};

60
src/message.cpp Normal file
View File

@ -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

View File

@ -30,6 +30,7 @@
#include "dtlssrtptransport.hpp"
#endif
#include <iomanip>
#include <thread>
namespace rtc {
@ -81,33 +82,83 @@ std::optional<Description> PeerConnection::remoteDescription() const {
return mRemoteDescription;
}
void PeerConnection::setLocalDescription(std::optional<Description> description) {
if (description)
PLOG_VERBOSE << "Setting local description: " << string(*description);
else
PLOG_VERBOSE << "Setting default local description";
bool PeerConnection::hasLocalDescription() const {
std::lock_guard lock(mLocalDescriptionMutex);
return bool(mLocalDescription);
}
bool PeerConnection::hasRemoteDescription() const {
std::lock_guard lock(mRemoteDescriptionMutex);
return bool(mRemoteDescription);
}
bool PeerConnection::hasMedia() const {
auto local = localDescription();
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";
}
if (auto iceTransport = std::atomic_load(&mIceTransport)) {
throw std::logic_error("Local description is already set");
} else {
// 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
iceTransport = initIceTransport(Description::Role::ActPass);
auto iceTransport = initIceTransport(Description::Role::ActPass);
Description localDescription = iceTransport->getLocalDescription(Description::Type::Offer);
if (description)
localDescription.addMedia(*description);
processLocalDescription(localDescription);
iceTransport->gatherLocalCandidates();
}
}
void PeerConnection::setRemoteDescription(Description description) {
PLOG_VERBOSE << "Setting remote description: " << string(description);
description.hintType(localDescription() ? Description::Type::Answer : Description::Type::Offer);
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)
@ -115,14 +166,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 {
@ -184,9 +235,13 @@ std::optional<string> PeerConnection::remoteAddress() const {
return iceTransport ? iceTransport->getRemoteAddress() : nullopt;
}
shared_ptr<DataChannel> PeerConnection::createDataChannel(const string &label,
const string &protocol,
const Reliability &reliability) {
shared_ptr<DataChannel> PeerConnection::addDataChannel(string label, string protocol,
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
@ -194,20 +249,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) {
// 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
iceTransport = initIceTransport(Description::Role::ActPass);
processLocalDescription(iceTransport->getLocalDescription(Description::Type::Offer));
iceTransport->gatherLocalCandidates();
} else {
if (auto transport = std::atomic_load(&mSctpTransport))
if (transport->state() == SctpTransport::State::Connected)
channel->open(transport);
return channel;
}
shared_ptr<DataChannel> PeerConnection::createDataChannel(string label, string protocol,
Reliability reliability) {
auto channel = addDataChannel(label, protocol, reliability);
setLocalDescription();
return channel;
}
@ -216,12 +271,11 @@ void PeerConnection::onDataChannel(
mDataChannelCallback = callback;
}
void PeerConnection::onLocalDescription(
std::function<void(const Description &description)> callback) {
void PeerConnection::onLocalDescription(std::function<void(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;
}
@ -233,37 +287,26 @@ void PeerConnection::onGatheringStateChange(std::function<void(GatheringState st
mGatheringStateChangeCallback = callback;
}
bool PeerConnection::hasMedia() const {
auto local = localDescription();
auto remote = remoteDescription();
return (local && local->hasMedia()) || (remote && remote->hasMedia());
std::shared_ptr<Track> PeerConnection::addTrack(Description::Media description) {
if (hasLocalDescription())
throw std::logic_error("Tracks must be created before local description");
if (auto it = mTracks.find(description.mid()); it != mTracks.end())
if (auto track = it->second.lock())
return track;
#if !RTC_ENABLE_MEDIA
if (mTracks.empty()) {
PLOG_WARNING << "Tracks will be inative (not compiled with SRTP support)";
}
void PeerConnection::sendMedia(const binary &packet) {
outgoingMedia(make_message(packet.begin(), packet.end(), Message::Binary));
}
void PeerConnection::sendMedia(const byte *packet, size_t size) {
outgoingMedia(make_message(packet, packet + size, Message::Binary));
}
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) {
@ -316,9 +359,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) {
@ -344,7 +387,12 @@ shared_ptr<DtlsTransport> PeerConnection::initDtlsTransport() {
switch (state) {
case DtlsTransport::State::Connected:
if (auto local = localDescription(); local && local->hasApplication())
initSctpTransport();
else
changeState(State::Connected);
openTracks();
break;
case DtlsTransport::State::Failed:
changeState(State::Failed);
@ -381,9 +429,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) {
@ -398,7 +446,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),
@ -415,13 +467,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();
@ -436,9 +482,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) {
@ -527,8 +573,56 @@ void PeerConnection::forwardMessage(message_ptr message) {
}
void PeerConnection::forwardMedia(message_ptr message) {
if (message)
mMediaCallback(*message);
if (!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) {
@ -536,10 +630,9 @@ void PeerConnection::forwardBufferedAmount(uint16_t stream, size_t amount) {
channel->triggerBufferedAmount(amount);
}
shared_ptr<DataChannel> PeerConnection::emplaceDataChannel(Description::Role role,
const string &label,
const string &protocol,
const Reliability &reliability) {
shared_ptr<DataChannel> PeerConnection::emplaceDataChannel(Description::Role role, string label,
string protocol,
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
@ -550,8 +643,8 @@ shared_ptr<DataChannel> PeerConnection::emplaceDataChannel(Description::Role rol
if (stream >= 65535)
throw std::runtime_error("Too many DataChannels");
}
auto channel =
std::make_shared<DataChannel>(shared_from_this(), stream, label, protocol, reliability);
auto channel = std::make_shared<DataChannel>(shared_from_this(), stream, std::move(label),
std::move(protocol), std::move(reliability));
mDataChannels.emplace(std::make_pair(stream, channel));
return channel;
}
@ -608,28 +701,132 @@ void PeerConnection::remoteCloseDataChannels() {
iterateDataChannels([&](shared_ptr<DataChannel> channel) { channel->remoteClose(); });
}
void PeerConnection::processLocalDescription(Description description) {
std::optional<uint16_t> remoteSctpPort;
std::optional<string> remoteDataMid;
if (auto remote = remoteDescription()) {
remoteDataMid = remote->dataMid();
remoteSctpPort = remote->sctpPort();
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));
}
}
auto certificate = mCertificate.get(); // wait for certificate if not ready
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) {
int activeMediaCount = 0;
if (hasLocalDescription())
throw std::logic_error("Local description is already set");
if (auto remote = remoteDescription()) {
// Reciprocate remote description
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));
}
}
}
}
// 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) {
@ -639,8 +836,10 @@ void PeerConnection::processLocalCandidate(Candidate candidate) {
mLocalDescription->addCandidate(candidate);
mProcessor->enqueue(
[this, candidate = std::move(candidate)]() { mLocalCandidateCallback(candidate); });
mProcessor->enqueue([this, candidate = std::move(candidate)]() {
PLOG_VERBOSE << "Issuing local candidate: " << candidate;
mLocalCandidateCallback(std::move(candidate));
});
}
void PeerConnection::triggerDataChannel(weak_ptr<DataChannel> weakDataChannel) {
@ -652,6 +851,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 {
@ -665,7 +868,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); });

426
src/rtcp.cpp Normal file
View File

@ -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
// this->lastReport = lastSR_NTP >> 16u;
setNTPOfSR(uint32_t(lastSR_NTP));
setDelaySinceSR(uint32_t(lastSR_DELAY));
// The delay, expressed in units of 1/65536 seconds
// this->delaySinceLastReport = lastSR_DELAY;
}
inline void setSSRC(SSRC ssrc) { this->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));
this->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) { this->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 senderSSRC, 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));
this->senderSSRC = htonl(senderSSRC);
}
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 bitrate) {
// Report Count becomes the format here.
header.prepareHeader(206, 15, 0);
// Always zero.
mediaSourceSSRC = 0;
this->senderSSRC = htonl(senderSSRC);
setBitrate(numSSRC, bitrate);
}
inline void setBitrate(unsigned int numSSRC, unsigned int bitrate) {
unsigned int exp = 0;
while (bitrate > pow(2, 18) - 1) {
exp++;
bitrate /= 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));
this->bitrate = htonl((numSSRC << (32u - 8u)) | (exp << (32u - 8u - 6u)) | bitrate);
}
// TODO Make this work
// uint64_t getBitrate() const{
// uint32_t ntohed = ntohl(this->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(this->bitrate) & (((unsigned int) pow(2,8)-1) << (32u-8u));
// }
inline void setSSRC(uint8_t iterator, SSRC ssrc) { this->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, 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

View File

@ -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());
@ -596,7 +600,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 +622,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 +634,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,8 +702,9 @@ 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) {
auto *transport = static_cast<SctpTransport *>(ptr);
size_t len, struct sctp_rcvinfo recv_info, int flags,
void *ulp_info) {
auto *transport = static_cast<SctpTransport *>(ulp_info);
std::shared_lock lock(InstancesMutex);
if (Instances.find(transport) == Instances.end()) {
@ -690,15 +718,8 @@ int SctpTransport::RecvCallback(struct socket *sock, union sctp_sockstore addr,
return ret;
}
int SctpTransport::SendCallback(struct socket *sock, uint32_t sb_free) {
struct sctp_paddrinfo paddrinfo = {};
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);
int SctpTransport::SendCallback(struct socket *, uint32_t sb_free, void *ulp_info) {
auto *transport = static_cast<SctpTransport *>(ulp_info);
std::shared_lock lock(InstancesMutex);
if (Instances.find(transport) == Instances.end())

View File

@ -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);
static int SendCallback(struct socket *sock, uint32_t sb_free);
struct sctp_rcvinfo recv_info, int flags, void *ulp_info);
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;

View File

@ -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() {
stop();
TcpTransport::~TcpTransport() { stop(); }
void TcpTransport::start() {
Transport::start();
PLOG_DEBUG << "Starting TCP recv thread";
mThread = std::thread(&TcpTransport::runLoop, this);
}
bool TcpTransport::stop() {
@ -208,16 +212,21 @@ void TcpTransport::connect(const sockaddr *addr, socklen_t addrlen) {
throw std::runtime_error(msg.str());
}
while (true) {
fd_set writefds;
FD_ZERO(&writefds);
FD_SET(mSock, &writefds);
struct timeval tv;
tv.tv_sec = 10; // TODO
tv.tv_sec = 10; // TODO: Make the timeout configurable
tv.tv_usec = 0;
ret = ::select(SOCKET_TO_INT(mSock) + 1, NULL, &writefds, NULL, &tv);
if (ret < 0)
if (ret < 0) {
if (sockerrno == SEINTR || sockerrno == SEAGAIN) // interrupted
continue;
else
throw std::runtime_error("Failed to wait for socket connection");
}
if (ret == 0) {
std::ostringstream msg;
@ -237,7 +246,8 @@ void TcpTransport::connect(const sockaddr *addr, socklen_t addrlen) {
}
PLOG_DEBUG << "TCP connection to " << node << ":" << serv << " succeeded";
break;
}
} 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;

View File

@ -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;

View File

@ -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;
}
}

View File

@ -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)
t->mIncomingQueue.wait(milliseconds(ms));
else
t->mIncomingQueue.wait();
return !t->mIncomingQueue.empty() ? 1 : 0;
bool notEmpty = t->mIncomingQueue.wait(
ms != GNUTLS_INDEFINITE_TIMEOUT ? std::make_optional(milliseconds(ms)) : nullopt);
return notEmpty ? 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

View File

@ -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();

148
src/track.cpp Normal file
View File

@ -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

View File

@ -39,12 +39,12 @@ public:
: mLower(std::move(lower)), mStateChangeCallback(std::move(callback)) {
}
virtual ~Transport() {
stop();
}
virtual ~Transport() { 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

View File

@ -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() {}
void VerifiedTlsTransport::postCreation() {
#if USE_GNUTLS
PLOG_DEBUG << "Setting up TLS certificate verification";
gnutls_session_set_verify_cert(mSession, mHost.c_str(), 0);
}
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() {
#else
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

View File

@ -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

View File

@ -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) {
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::send(message_variant data) { return outgoing(make_message(std::move(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() {
while (!mRecvQueue.empty()) {
auto message = *mRecvQueue.pop();
switch (message->type) {
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;
}
std::optional<message_variant> WebSocket::receive() {
while (auto next = mRecvQueue.tryPop()) {
message_ptr message = std::move(*next);
if (message->type != Message::Control)
return to_variant(std::move(*message));
}
return nullopt;
}
@ -189,10 +173,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 +230,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 +281,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();

View File

@ -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());

View File

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

View File

@ -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,9 +99,8 @@ size_t benchmark(milliseconds duration) {
steady_clock::time_point startTime, openTime, receivedTime, endTime;
shared_ptr<DataChannel> dc2;
pc2->onDataChannel(
[&dc2, &receivedSize, &receivedTime](shared_ptr<DataChannel> dc) {
dc->onMessage([&receivedTime, &receivedSize](const variant<binary, string> &message) {
pc2->onDataChannel([&dc2, &receivedSize, &receivedTime](shared_ptr<DataChannel> dc) {
dc->onMessage([&receivedTime, &receivedSize](variant<binary, string> message) {
if (holds_alternative<binary>(message)) {
const auto &bin = get<binary>(message);
if (receivedSize == 0)
@ -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;

View File

@ -37,8 +37,8 @@ typedef struct {
bool connected;
} Peer;
Peer *peer1 = NULL;
Peer *peer2 = NULL;
static Peer *peer1 = 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() {
if (test_capi_main())
void test_capi_connectivity() {
if (test_capi_connectivity_main())
throw std::runtime_error("Connection failed");
}

198
test/capi_track.cpp Normal file
View File

@ -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");
}

View File

@ -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;
}

View File

@ -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;
test_capi();
cout << "*** Finished WebRTC C API test" << endl;
cout << endl << "*** Running WebRTC C API connectivity test..." << endl;
test_capi_connectivity();
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;

134
test/track.cpp Normal file
View File

@ -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;
}

View File

@ -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