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, FreeBSD, Apple macOS and iOS) and Microsoft Windows. WebRTC is a W3C and IETF standard enabling real-time peer-to-peer data and media exchange between two devices.
The library aims at being both straightforward and lightweight with minimal external dependencies, to enable direct connectivity between native applications and web browsers without the pain of importing Google's bloated reference library. The interface consists of somewhat 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 GnuTLS, Mbed TLS, or OpenSSL.
- The connectivity for WebRTC can be provided through my ad-hoc ICE library libjuice as submodule or through libnice.
The WebRTC stack is fully compatible with browsers like Firefox and Chromium, see Compatibility below. Additionally, code using Data Channels and WebSockets from the library may be compiled as is to WebAssembly for browsers with datachannel-wasm.
libdatachannel is licensed under MPL 2.0 since version 0.18, see LICENSE (previous versions were licensed under LGPLv2.1 or later).
libdatachannel is available on AUR, vcpkg, and FreeBSD ports. Bindings are available for Rust and Node.js.
- GnuTLS, Mbed TLS, or OpenSSL
- usrsctp (as submodule by default)
- plog (as submodule by default)
- libjuice (as submodule by default) or libnice as an ICE backend.
- libsrtp (as submodule by default) required if compiled with media support.
- nlohmann JSON (as submodule by default) required to build examples.
See BUILDING.md for building instructions.
See examples for complete usage examples with signaling server (under MPL 2.0).
Additionally, you might want to have a look at the C API documentation.
#include "rtc/rtc.hpp"rtc::Configuration config;
config.iceServers.emplace_back("mystunserver.org:3478");
rtc::PeerConnection pc(config);
pc.onLocalDescription([](rtc::Description sdp) {
// Send the SDP to the remote peer
MY_SEND_DESCRIPTION_TO_REMOTE(std::string(sdp));
});
pc.onLocalCandidate([](rtc::Candidate candidate) {
// Send the candidate to the remote peer
MY_SEND_CANDIDATE_TO_REMOTE(candidate.candidate(), candidate.mid());
});
MY_ON_RECV_DESCRIPTION_FROM_REMOTE([&pc](std::string sdp) {
pc.setRemoteDescription(rtc::Description(sdp));
});
MY_ON_RECV_CANDIDATE_FROM_REMOTE([&pc](std::string candidate, std::string mid) {
pc.addRemoteCandidate(rtc::Candidate(candidate, mid));
});pc.onStateChange([](rtc::PeerConnection::State state) {
std::cout << "State: " << state << std::endl;
});
pc.onGatheringStateChange([](rtc::PeerConnection::GatheringState state) {
std::cout << "Gathering state: " << state << std::endl;
});auto dc = pc.createDataChannel("test");
dc->onOpen([]() {
std::cout << "Open" << std::endl;
});
dc->onMessage([](std::variant<rtc::binary, rtc::string> message) {
if (std::holds_alternative<rtc::string>(message)) {
std::cout << "Received: " << get<rtc::string>(message) << std::endl;
}
});std::shared_ptr<rtc::DataChannel> dc;
pc.onDataChannel([&dc](std::shared_ptr<rtc::DataChannel> incoming) {
dc = incoming;
dc->send("Hello world!");
});rtc::WebSocket ws;
ws.onOpen([]() {
std::cout << "WebSocket open" << std::endl;
});
ws.onMessage([](std::variant<rtc::binary, rtc::string> message) {
if (std::holds_alternative<rtc::string>(message)) {
std::cout << "WebSocket received: " << std::get<rtc::string>(message) << endl;
}
});
ws.open("wss://my.websocket/service");The library implements the following communication protocols:
WebRTC allows real-time data and media exchange between two devices through a Peer Connection (or RTCPeerConnection), a signaled peer-to-peer connection which can carry both Data Channels and media tracks. It is compatible with browsers Firefox, Chromium, and Safari, and other WebRTC libraries (see webrtc-echoes). Media transport is optional and can be disabled at compile time.
Protocol stack:
- SCTP-based Data Channels (RFC8831)
- SRTP-based Media Transport (RFC8834)
- DTLS/UDP (RFC7350 and RFC8261)
- ICE (RFC8445) with STUN (RFC8489) and its extension TURN (RFC8656)
Features:
- Full IPv6 support (as mandated by RFC8835)
- Trickle ICE (RFC8838)
- JSEP-compatible session establishment with SDP (RFC8829)
- SCTP over DTLS with SDP offer/answer (RFC8841)
- DTLS with ECDSA or RSA keys (RFC8827)
- SRTP and SRTCP key derivation from DTLS (RFC5764)
- Differentiated Services QoS (RFC8837) where possible
- Multicast DNS candidates (draft-ietf-rtcweb-mdns-ice-candidates-04)
- Multiplexing connections on a single UDP port with libjuice as ICE backend
Note only SDP BUNDLE mode is supported for media multiplexing (RFC8843). The behavior is equivalent to the JSEP bundle-only policy: the library always negotiates one unique network component, where SRTP media streams are multiplexed with SRTCP control packets (RFC5761) and SCTP/DTLS data traffic (RFC8261).
WebSocket is the protocol of choice for WebRTC signaling. The support is optional and can be disabled at compile time.
Protocol stack:
Features:
- IPv6 and IPv4/IPv6 dual-stack support
- Keepalive with ping/pong
- Rust bindings for libdatachannel: datachannel-rs
- Node.js bindings for libdatachannel: node-datachannel
- Unity bindings for Windows 10 and Hololens: datachannel-unity
- WebAssembly wrapper compatible with libdatachannel: datachannel-wasm
- Lightweight STUN/TURN server: Violet
- Native platform (Android/iOS/macOS) wrapper for libdatachannel: datachannel-native
Thanks to Streamr, Vagon, Shiguredo, Deon Botha, and Michael Cho for sponsoring this work!