ReStreamAgent/Session.cpp at master · WebRTSP/ReStreamAgent · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
#include "Session.h"

#include <glib.h>

#include <CxxPtr/CPtr.h>

#include "RtspParser/RtspParser.h"

#include "Config.h"


Session::Session(
    const Config* config,
    Cache* cache,
    const std::function<std::unique_ptr<WebRTCPeer> (const std::string& uri)>& createPeer,
    const std::function<void (const rtsp::Request*)>& sendRequest,
    const std::function<void (const rtsp::Response*)>& sendResponse) noexcept :
    ServerSession(createPeer, sendRequest, sendResponse),
    _config(config), _cache(cache)
{
}

bool Session::onConnected() noexcept
{
    if(_cache->parameters.empty()) {
        _cache->parameters =
            "name: " + _config->name + "\r\n"
            "token: " + _config->authToken + "\r\n";
        if(!_config->description.empty())
            _cache->parameters +=
                "description: " + _config->description + "\r\n";
    }

    _authCSeq = requestSetParameter("*", "text/parameters", _cache->parameters);

    return true;
}

bool Session::onOptionsRequest(
    std::unique_ptr<rtsp::Request>& requestPtr) noexcept
{
    rtsp::Response response;
    prepareOkResponse(requestPtr->cseq, &response);

    response.headerFields.emplace("Public", "LIST, DESCRIBE, SETUP, PLAY, TEARDOWN");

    sendResponse(response);

    return true;
}

bool Session::onListRequest(
    std::unique_ptr<rtsp::Request>& requestPtr) noexcept
{
    if(_cache->list.empty()) {
        if(_config->streamers.empty())
            _cache->list = "\r\n";
        else {
            for(const auto& pair: _config->streamers) {
                _cache->list += pair.first;
                _cache->list += ": ";
                _cache->list += pair.second.description;
                _cache->list += + "\r\n";
            }
        }
    }

    sendOkResponse(requestPtr->cseq, "text/parameters", _cache->list);

    return true;
}

bool Session::onGetParameterResponse(
    const rtsp::Request& request,
    const rtsp::Response& response) noexcept
{
    if(!ServerSession::onGetParameterResponse(request, response))
        return false;

    if(_iceServerCSeq && response.cseq != _iceServerCSeq)
        return false;

    _iceServerCSeq = 0;

    rtsp::Parameters parameters;
    if(!rtsp::ParseParameters(response.body, &parameters))
        return false;

    WebRTCPeer::IceServers iceServers;

    auto stunServerIt = parameters.find("stun-server");
    if(parameters.end() != stunServerIt && !stunServerIt->second.empty())
        iceServers.push_back({"stun://" + stunServerIt->second});

    auto turnServerIt = parameters.find("turn-server");
    if(parameters.end() != turnServerIt && !turnServerIt->second.empty())
        iceServers.push_back({"turn://" + turnServerIt->second});

    auto turnsServerIt = parameters.find("turns-server");
    if(parameters.end() != turnsServerIt && !turnsServerIt->second.empty())
        iceServers.push_back({"turns://" + turnsServerIt->second});

    setIceServers(iceServers);

    return true;
}

bool Session::onSetParameterResponse(
    const rtsp::Request& request,
    const rtsp::Response& response) noexcept
{
    if(!ServerSession::onSetParameterResponse(request, response))
        return false;

    if(_authCSeq && response.cseq != _authCSeq)
        return false;

    _authCSeq = 0;

    const std::string parameters =
        "ice-servers\r\n";

    _iceServerCSeq = requestGetParameter("*", "text/list", parameters);

    return true;
}