WebRTCServer.h

Go to the documentation of this file.

/*
 * Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 * DEALINGS IN THE SOFTWARE.
 */
 
#ifndef __WEBRTC_SERVER_H__
#define __WEBRTC_SERVER_H__
 
#include <libsoup/soup.h>
 
#include <stdint.h>
#include <string>
#include <vector>
 
 
// forward declarations
class WebRTCServer;
class Thread;
 
 
#define WEBRTC_DEFAULT_PORT 41567
 
#define WEBRTC_DEFAULT_STUN_SERVER "stun.l.google.com:19302"
 
#define LOG_WEBRTC "[webrtc] "
 
 
enum WebRTCFlags
{
        // route/stream flags
        WEBRTC_PRIVATE = 0,                             // hidden (default)             
        WEBRTC_PUBLIC  = (1 << 1),              // allow discoverability
        WEBRTC_AUDIO   = (1 << 0),              // produces/accepts video
        WEBRTC_VIDEO   = (1 << 1),              // produces/accepts audio
        WEBRTC_SEND     = (1 << 2),             // server sends to the client (outgoing)
        WEBRTC_RECEIVE = (1 << 3),              // server receives from the client (incoming)
        WEBRTC_MULTI_CLIENT = (1 << 4), // can connect with multiple clients simultaneously
        
        // state flags
        WEBRTC_PEER_CONNECTING = (1 << 5),      // the peer is connecting
        WEBRTC_PEER_CONNECTED  = (1 << 6),      // the peer is ready
        WEBRTC_PEER_STREAMING  = (1 << 7),      // the peer is streaming
        WEBRTC_PEER_CLOSED     = (1 << 8),      // the peer has closed
};
 
 
struct WebRTCPeer
{
        SoupWebsocketConnection* connection;
        SoupClientContext* client_context;
        WebRTCServer* server;
 
        uint32_t ID;                    // unique ID
        uint32_t flags;         // WebRTCFlags
 
        std::string path;       // the route the peer is connected on
        std::string ip_address; // IP address of the peer
        
        void* user_data;                // private data for the route handler
};
 
 
class WebRTCServer
{
public:
        static WebRTCServer* Create( uint16_t port=WEBRTC_DEFAULT_PORT, 
                                                    const char* stun_server=WEBRTC_DEFAULT_STUN_SERVER,
                                                    const char* ssl_cert=NULL, const char* ssl_key=NULL,
                                                    bool threaded=true );       
        
        void Release();
        
        typedef void (*WebsocketListener)( WebRTCPeer* peer, const char* message, size_t message_size, void* user_data );
 
        typedef SoupServerCallback HttpListener;
 
        void AddRoute( const char* path, HttpListener callback, void* user_data=NULL, uint32_t flags=0 );
 
        void AddRoute( const char* path, WebsocketListener callback, void* user_data=NULL, uint32_t flags=0 );
 
        inline const char* GetSTUNServer() const                { return mStunServer.c_str(); }
        
        inline bool HasHTTPS() const                                    { return mHasHTTPS; }
        
        inline bool IsThreaded() const                          { return (mThread != NULL); }
        
        bool ProcessRequests( bool blocking=false );
        
protected:
 
        WebRTCServer( uint16_t port, const char* stun_server, const char* ssl_cert_file, const char* ssl_key_file, bool threaded );
        ~WebRTCServer();
        
        bool init();
 
        static void* runThread( void* user_data );
        
        static void onHttpRequest( SoupServer* soup_server, SoupMessage* message, const char* path, GHashTable* query, SoupClientContext* client_context, void* user_data );
        static void onHttpDefault( SoupServer* soup_server, SoupMessage* message, const char* path, GHashTable* query, SoupClientContext* client_context, void* user_data );
        
        static void onWebsocketOpened( SoupServer* server, SoupWebsocketConnection* connection, const char *path, SoupClientContext* client_context, void* user_data );
        static void onWebsocketMessage( SoupWebsocketConnection* connection, SoupWebsocketDataType data_type, GBytes* message, void* user_data );
        static void onWebsocketClosed( SoupWebsocketConnection* connection, void* user_data );
        
        struct HttpRoute
        {
                std::string path;
                HttpListener callback;
                void* user_data;
                uint32_t flags;
        };
        
        struct WebsocketRoute
        {
                std::string path;
                WebsocketListener callback;
                void* user_data;
                uint32_t flags;
                std::vector<WebRTCPeer*> peers;
        };
 
        HttpRoute* findHttpRoute( const char* path ) const;
        WebsocketRoute* findWebsocketRoute( const char* path ) const;
        
        void freeRoute( HttpRoute* route );
        void freeRoute( WebsocketRoute* route );
        
        std::string printRouteInfo( WebsocketRoute* route ) const;
        //std::string printRouteList();
        
        std::vector<HttpRoute*> mHttpRoutes;
        std::vector<WebsocketRoute*> mWebsocketRoutes;
        
        SoupServer* mSoupServer;
        std::string mStunServer;
        
        std::string mSSLCertFile;
        std::string mSSLKeyFile;
        
        bool mHasHTTPS;
        
        uint16_t mPort;
        uint32_t mRefCount;
        uint32_t mPeerCount;
        
        Thread* mThread;
};
 
#endif