external/srs
1
0
Fork 0
mirror of https://github.com/ossrs/srs.git synced 2025-03-09 15:49:59 +00:00
Code Issues Releases Wiki Activity

Merge branch '4.0release' into develop

Browse source
This commit is contained in:
winlin 2022-03-19 13:21:58 +08:00
commit 9385f2b80b
10 changed files with 232 additions and 72 deletions
Download patch file Download diff file Expand all files Collapse all files

1
README.md
View file

@ -150,6 +150,7 @@ but some third-party libraries are distributed using their [own licenses](https:
## Releases
* 2022-03-19, Release [v4.0-b10](https://github.com/ossrs/srs/releases/tag/v4.0-b10), v4.0-b10, 4.0 beta10, v4.0.251, 144665 lines.
* 2022-02-15, Release [v4.0-b9](https://github.com/ossrs/srs/releases/tag/v4.0-b9), v4.0-b9, 4.0 beta9, v4.0.245, 144474 lines.
* 2022-02-11, Release [v4.0-b8](https://github.com/ossrs/srs/releases/tag/v4.0-b8), v4.0-b8, 4.0 beta8, v4.0.241, 144445 lines.
* 2022-02-09, Release [v4.0-b7](https://github.com/ossrs/srs/releases/tag/v4.0-b7), v4.0-b7, 4.0 beta7, v4.0.240, 144437 lines.

2
trunk/configure vendored
View file

@ -404,7 +404,7 @@ fi
if [ $SRS_UTEST = YES ]; then
MODULE_FILES=("srs_utest" "srs_utest_amf0" "srs_utest_protocol" "srs_utest_kernel" "srs_utest_core"
"srs_utest_config" "srs_utest_rtmp" "srs_utest_http" "srs_utest_avc" "srs_utest_reload"
"srs_utest_mp4" "srs_utest_service" "srs_utest_app" "srs_utest_rtc")
"srs_utest_mp4" "srs_utest_service" "srs_utest_app" "srs_utest_rtc" "srs_utest_srt")
ModuleLibIncs=(${SRS_OBJS_DIR} ${LibSTRoot} ${LibSSLRoot})
if [[ $SRS_RTC == YES ]]; then
ModuleLibIncs+=(${LibSrtpRoot})

2
trunk/doc/CHANGELOG.md
View file

@ -36,6 +36,8 @@ The changelog for SRS.
## SRS 4.0 Changelog
* v4.0, 2022-03-19, For [#2893](https://github.com/ossrs/srs/pull/2893): SRT: Decouple publish with play url (#2893). v4.0.251
* v4.0, 2022-03-19, Merge [#2908](https://github.com/ossrs/srs/pull/2908): SRT: url supports multiple QueryStrings (#2908). v4.0.250
* v4.0, 2022-03-17, SRT: Support debug and run with CLion. v4.0.249
* v4.0, 2022-03-15, Merge [#2966](https://github.com/ossrs/srs/pull/2966): Bugfix: Fix rtcp nack blp encode bug (#2966). v4.0.248
* v4.0, 2022-03-07, RTC: Identify the WebRTC publisher in param for hooks. v4.0.247

2
trunk/src/core/srs_core_version4.hpp
View file

@ -9,6 +9,6 @@
#define VERSION_MAJOR 4
#define VERSION_MINOR 0
#define VERSION_REVISION 249
#define VERSION_REVISION 251
#endif

145
trunk/src/srt/srt_conn.cpp
View file

@ -10,6 +10,8 @@
#include "srt_log.hpp"
#include <vector>
#include <srs_protocol_utility.hpp>
#include <srs_kernel_utility.hpp>
#include <srs_app_config.hpp>
bool is_streamid_valid(const std::string& streamid) {
@ -24,20 +26,20 @@ bool is_streamid_valid(const std::string& streamid) {
int mode;
std::string subpath;
std::string vhost;
bool ret = get_streamid_info(streamid, mode, subpath);
// Parse the stream info from streamid, see https://github.com/ossrs/srs/issues/2893
bool ret = get_streamid_info(streamid, mode, vhost, subpath);
if (!ret) {
return false;
}
if ((mode != PUSH_SRT_MODE) && (mode != PULL_SRT_MODE)) {
return false;
}
std::vector<std::string> info_vec;
string_split(subpath, "/", info_vec);
if (info_vec.size() < 2) {//it must be appname/stream at least.
// TODO: FIXME: Should fail at parsing the original SRT URL.
if (info_vec.size() != 2) {
srt_log_warn("path format must be appname/stream?key=value...");
return false;
}
@ -69,12 +71,11 @@ bool get_key_value(const std::string& info, std::string& key, std::string& value
return true;
}
//eg. streamid=#!::h:live/livestream,m:publish
bool get_streamid_info(const std::string& streamid, int& mode, std::string& url_subpath) {
std::vector<std::string> info_vec;
std::string real_streamid;
mode = PUSH_SRT_MODE;
// See streamid of https://github.com/ossrs/srs/issues/2893
// TODO: FIMXE: We should parse SRT streamid to URL object, rather than a HTTP url subpath.
bool get_streamid_info(const std::string& streamid, int& mode, std::string& vhost, std::string& url_subpath)
{
mode = PULL_SRT_MODE;
size_t pos = streamid.find("#!::");
if (pos != 0) {
@ -86,36 +87,82 @@ bool get_streamid_info(const std::string& streamid, int& mode, std::string& url_
url_subpath = streamid;
return true;
}
//SRT url supports multiple QueryStrings, which are passed to RTMP to realize authentication and other capabilities
//@see https://github.com/ossrs/srs/issues/2893
std::string params;
std::string real_streamid;
real_streamid = streamid.substr(4);
string_split(real_streamid, ",", info_vec);
if (info_vec.size() < 2) {
// Compatible with previous auth querystring, like this one:
// srt://127.0.0.1:10080?streamid=#!::h=live/livestream?secret=xxx,m=publish
real_streamid = srs_string_replace(real_streamid, "?", ",");
std::map<std::string, std::string> query;
srs_parse_query_string(real_streamid, query);
for (std::map<std::string, std::string>::iterator it = query.begin(); it != query.end(); ++it) {
if (it->first == "h") {
std::string host = it->second;
size_t r0 = host.find("/");
size_t r1 = host.rfind("/");
if (r0 != std::string::npos && r0 != std::string::npos) {
// Compatible with previous style, see https://github.com/ossrs/srs/issues/2893#compatible
// srt://127.0.0.1:10080?streamid=#!::h=live/livestream,m=publish
// srt://127.0.0.1:10080?streamid=#!::h=live/livestream,m=request
// srt://127.0.0.1:10080?streamid=#!::h=srs.srt.com.cn/live/livestream,m=publish
if (r0 != r1) {
// We got vhost in host.
url_subpath = host.substr(r0 + 1);
host = host.substr(0, r0);
params.append("vhost=");
params.append(host);
params.append("&");
vhost = host;
} else {
// Only stream in host.
url_subpath = host;
}
} else {
// New URL style, see https://github.com/ossrs/srs/issues/2893#solution
// srt://host.com:10080?streamid=#!::h=host.com,r=app/stream,key1=value1,key2=value2
// srt://1.2.3.4:10080?streamid=#!::h=host.com,r=app/stream,key1=value1,key2=value2
// srt://1.2.3.4:10080?streamid=#!::r=app/stream,key1=value1,key2=value2
params.append("vhost=");
params.append(host);
params.append("&");
vhost = host;
}
} else if (it->first == "r") {
url_subpath = it->second;
} else if (it->first == "m") {
std::string mode_str = it->second; // support m=publish or m=request
std::transform(it->second.begin(), it->second.end(), mode_str.begin(), ::tolower);
if (mode_str == "publish") {
mode = PUSH_SRT_MODE;
} else if (mode_str == "request") {
mode = PULL_SRT_MODE;
} else {
srt_log_warn("unknown mode_str:%s", mode_str.c_str());
return false;
}
} else {
params.append(it->first);
params.append("=");
params.append(it->second);
params.append("&");
}
}
if (url_subpath.empty()) {
return false;
}
for (size_t index = 0; index < info_vec.size(); index++) {
std::string key;
std::string value;
bool ret = get_key_value(info_vec[index], key, value);
if (!ret) {
continue;
}
if (key == "h") {
url_subpath = value;//eg. h=live/stream
} else if (key == "m") {
std::string mode_str = string_lower(value);//m=publish or m=request
if (mode_str == "publish") {
mode = PUSH_SRT_MODE;
} else if (mode_str == "request") {
mode = PULL_SRT_MODE;
} else {
mode = PUSH_SRT_MODE;
}
} else {//not suport
continue;
}
if (!params.empty()) {
url_subpath.append("?");
url_subpath.append(params);
url_subpath.pop_back(); // remove last '&'
}
return true;
@ -123,19 +170,16 @@ bool get_streamid_info(const std::string& streamid, int& mode, std::string& url_
srt_conn::srt_conn(SRTSOCKET conn_fd, const std::string& streamid):_conn_fd(conn_fd),
_streamid(streamid),
write_fail_cnt_(0) {
get_streamid_info(streamid, _mode, _url_subpath);
write_fail_cnt_(0)
{
get_streamid_info(streamid, _mode, _vhost, _url_subpath);
_update_timestamp = now_ms();
std::vector<std::string> path_vec;
string_split(_url_subpath, "/", path_vec);
if (path_vec.size() >= 3) {
_vhost = path_vec[0];
} else {
if (_vhost.empty()) {
_vhost = "__default_host__";
}
srt_log_trace("srt connect construct streamid:%s, mode:%d, subpath:%s, vhost:%s",
streamid.c_str(), _mode, _url_subpath.c_str(), _vhost.c_str());
}
@ -175,6 +219,17 @@ std::string srt_conn::get_streamid() {
return _streamid;
}
std::string srt_conn::get_path() {
if (!_url_path.empty()) {
return _url_path;
}
size_t pos = _url_subpath.find("?");
_url_path = (pos != std::string::npos) ? _url_subpath.substr(0, pos) : _url_subpath;
return _url_path;
}
std::string srt_conn::get_subpath() {
return _url_subpath;
}

4
trunk/src/srt/srt_conn.hpp
View file

@ -26,7 +26,7 @@
bool is_streamid_valid(const std::string& streamid);
bool get_key_value(const std::string& info, std::string& key, std::string& value);
bool get_streamid_info(const std::string& streamid, int& mode, std::string& url_subpash);
bool get_streamid_info(const std::string& streamid, int& mode, std::string& vhost, std::string& url_subpash);
class srt_conn {
public:
@ -37,6 +37,7 @@ public:
SRTSOCKET get_conn();
int get_mode();
std::string get_streamid();
std::string get_path();
std::string get_subpath();
std::string get_vhost();
int read(unsigned char* data, int len);
@ -49,6 +50,7 @@ public:
private:
SRTSOCKET _conn_fd;
std::string _streamid;
std::string _url_path;
std::string _url_subpath;
std::string _vhost;
int _mode;

37
trunk/src/srt/srt_handle.cpp
View file

@ -159,7 +159,7 @@ void srt_handle::add_newconn(SRT_CONN_PTR conn_ptr, int events) {
srt_log_trace("srt h264 sei filter is %s.", _srs_config->get_srt_sei_filter() ? "enable" : "disable");
if (conn_ptr->get_mode() == PULL_SRT_MODE) {
add_new_puller(conn_ptr, conn_ptr->get_subpath());
add_new_puller(conn_ptr, conn_ptr->get_path());
} else {
if(add_new_pusher(conn_ptr) == false) {
srt_log_trace("push connection is repeated and rejected, fd:%d, streamid:%s",
@ -178,7 +178,7 @@ void srt_handle::add_newconn(SRT_CONN_PTR conn_ptr, int events) {
return;
}
void srt_handle::handle_push_data(SRT_SOCKSTATUS status, const std::string& subpath, SRTSOCKET conn_fd) {
void srt_handle::handle_push_data(SRT_SOCKSTATUS status, const std::string& path, const std::string& subpath, SRTSOCKET conn_fd) {
SRT_CONN_PTR srt_conn_ptr;
unsigned char data[DEF_DATA_SIZE];
int ret;
@ -221,7 +221,7 @@ void srt_handle::handle_push_data(SRT_SOCKSTATUS status, const std::string& subp
//send data to subscriber(players)
//streamid, play map<SRTSOCKET, SRT_CONN_PTR>
auto streamid_iter = _streamid_map.find(subpath);
auto streamid_iter = _streamid_map.find(path);
if (streamid_iter == _streamid_map.end()) {//no puler
srt_log_info("receive data size(%d) from pusher(%d) but no puller", ret, conn_fd);
return;
@ -293,8 +293,8 @@ void srt_handle::check_alive() {
close_push_conn(conn_ptr->get_conn());
} else if (conn_ptr->get_mode() == PULL_SRT_MODE) {
srt_log_warn("check alive close pull connection fd:%d, streamid:%s",
conn_ptr->get_conn(), conn_ptr->get_subpath().c_str());
close_pull_conn(conn_ptr->get_conn(), conn_ptr->get_subpath());
conn_ptr->get_conn(), conn_ptr->get_path().c_str());
close_pull_conn(conn_ptr->get_conn(), conn_ptr->get_path());
} else {
srt_log_error("check_alive get unkown srt mode:%d, fd:%d",
conn_ptr->get_mode(), conn_ptr->get_conn());
@ -308,7 +308,7 @@ void srt_handle::close_push_conn(SRTSOCKET srtsocket) {
if (iter != _conn_map.end()) {
SRT_CONN_PTR conn_ptr = iter->second;
auto push_iter = _push_conn_map.find(conn_ptr->get_subpath());
auto push_iter = _push_conn_map.find(conn_ptr->get_path());
if (push_iter != _push_conn_map.end()) {
_push_conn_map.erase(push_iter);
}
@ -323,14 +323,14 @@ void srt_handle::close_push_conn(SRTSOCKET srtsocket) {
}
bool srt_handle::add_new_pusher(SRT_CONN_PTR conn_ptr) {
auto push_iter = _push_conn_map.find(conn_ptr->get_subpath());
auto push_iter = _push_conn_map.find(conn_ptr->get_path());
if (push_iter != _push_conn_map.end()) {
return false;
}
_push_conn_map.insert(std::make_pair(conn_ptr->get_subpath(), conn_ptr));
_push_conn_map.insert(std::make_pair(conn_ptr->get_path(), conn_ptr));
_conn_map.insert(std::make_pair(conn_ptr->get_conn(), conn_ptr));
srt_log_trace("srt_handle add new pusher streamid:%s, subpath:%s",
conn_ptr->get_streamid().c_str(), conn_ptr->get_subpath().c_str());
srt_log_trace("srt_handle add new pusher streamid:%s, subpath:%s, sid:%s",
conn_ptr->get_streamid().c_str(), conn_ptr->get_subpath().c_str(), conn_ptr->get_path().c_str());
return true;
}
@ -348,10 +348,7 @@ void srt_handle::handle_pull_data(SRT_SOCKSTATUS status, const std::string& subp
void srt_handle::handle_srt_socket(SRT_SOCKSTATUS status, SRTSOCKET conn_fd)
{
std::string subpath;
int mode;
auto conn_ptr = get_srt_conn(conn_fd);
if (!conn_ptr) {
if (status != SRTS_CLOSED) {
srt_log_error("handle_srt_socket find srt connection error, fd:%d, status:%d",
@ -359,19 +356,17 @@ void srt_handle::handle_srt_socket(SRT_SOCKSTATUS status, SRTSOCKET conn_fd)
}
return;
}
bool ret = get_streamid_info(conn_ptr->get_streamid(), mode, subpath);
if (!ret) {
conn_ptr->close();
conn_ptr = nullptr;
return;
}
std::string path = conn_ptr->get_path();
std::string subpath = conn_ptr->get_subpath();
int mode = conn_ptr->get_mode();
if (mode == PUSH_SRT_MODE) {
switch (status)
{
case SRTS_CONNECTED:
{
handle_push_data(status, subpath, conn_fd);
handle_push_data(status, path, subpath, conn_fd);
break;
}
case SRTS_BROKEN:
@ -397,7 +392,7 @@ void srt_handle::handle_srt_socket(SRT_SOCKSTATUS status, SRTSOCKET conn_fd)
{
srt_log_warn("srt pull disconnected fd:%d, streamid:%s",
conn_fd, conn_ptr->get_streamid().c_str());
close_pull_conn(conn_fd, subpath);
close_pull_conn(conn_fd, path);
break;
}
default:

2
trunk/src/srt/srt_handle.hpp
View file

@ -37,7 +37,7 @@ private:
//get srt conn object by srt socket
SRT_CONN_PTR get_srt_conn(SRTSOCKET conn_srt_socket);
void handle_push_data(SRT_SOCKSTATUS status, const std::string& subpath, SRTSOCKET conn_fd);
void handle_push_data(SRT_SOCKSTATUS status, const std::string& path, const std::string& subpath, SRTSOCKET conn_fd);
void handle_pull_data(SRT_SOCKSTATUS status, const std::string& subpath, SRTSOCKET conn_fd);
//add new puller into puller list and conn_map

89
trunk/src/utest/srs_utest_srt.cpp Normal file
View file

@ -0,0 +1,89 @@
//
// Copyright (c) 2013-2021 Winlin
//
// SPDX-License-Identifier: MIT
//
#include <srs_utest_srt.hpp>
#include <srs_kernel_error.hpp>
#include <srt_conn.hpp>
#include <vector>
using namespace std;
VOID TEST(ProtocolSrtTest, SrtGetStreamInfoNormal) {
if (true) {
int mode; string vhost; string subpath;
EXPECT_TRUE(get_streamid_info("#!::r=live/livestream,key1=value1,key2=value2", mode, vhost, subpath));
EXPECT_EQ(PULL_SRT_MODE, mode);
EXPECT_STREQ("", vhost.c_str());
EXPECT_STREQ("live/livestream?key1=value1&key2=value2", subpath.c_str());
}
if (true) {
int mode; string vhost; string subpath;
EXPECT_TRUE(get_streamid_info("#!::h=host.com,r=live/livestream,key1=value1,key2=value2", mode, vhost, subpath));
EXPECT_EQ(PULL_SRT_MODE, mode);
EXPECT_STREQ("host.com", vhost.c_str());
EXPECT_STREQ("live/livestream?vhost=host.com&key1=value1&key2=value2", subpath.c_str());
}
}
VOID TEST(ProtocolSrtTest, SrtGetStreamInfoMethod) {
if (true) {
int mode; string vhost; string subpath;
EXPECT_TRUE(get_streamid_info("#!::r=live/livestream,m=request", mode, vhost, subpath));
EXPECT_EQ(PULL_SRT_MODE, mode);
EXPECT_STREQ("live/livestream", subpath.c_str());
}
if (true) {
int mode; string vhost; string subpath;
EXPECT_TRUE(get_streamid_info("#!::r=live/livestream,m=publish", mode, vhost, subpath));
EXPECT_EQ(PUSH_SRT_MODE, mode);
EXPECT_STREQ("live/livestream", subpath.c_str());
}
}
VOID TEST(ProtocolSrtTest, SrtGetStreamInfoCompatible) {
if (true) {
int mode; string vhost; string subpath;
EXPECT_TRUE(get_streamid_info("#!::h=live/livestream,m=request", mode, vhost, subpath));
EXPECT_EQ(PULL_SRT_MODE, mode);
EXPECT_STREQ("", vhost.c_str());
EXPECT_STREQ("live/livestream", subpath.c_str());
}
if (true) {
int mode; string vhost; string subpath;
EXPECT_TRUE(get_streamid_info("#!::h=live/livestream,m=publish", mode, vhost, subpath));
EXPECT_EQ(PUSH_SRT_MODE, mode);
EXPECT_STREQ("", vhost.c_str());
EXPECT_STREQ("live/livestream", subpath.c_str());
}
if (true) {
int mode; string vhost; string subpath;
EXPECT_TRUE(get_streamid_info("#!::h=srs.srt.com.cn/live/livestream,m=request", mode, vhost, subpath));
EXPECT_EQ(PULL_SRT_MODE, mode);
EXPECT_STREQ("srs.srt.com.cn", vhost.c_str());
EXPECT_STREQ("live/livestream?vhost=srs.srt.com.cn", subpath.c_str());
}
if (true) {
int mode; string vhost; string subpath;
EXPECT_TRUE(get_streamid_info("#!::h=srs.srt.com.cn/live/livestream,m=publish", mode, vhost, subpath));
EXPECT_EQ(PUSH_SRT_MODE, mode);
EXPECT_STREQ("srs.srt.com.cn", vhost.c_str());
EXPECT_STREQ("live/livestream?vhost=srs.srt.com.cn", subpath.c_str());
}
if (true) {
int mode; string vhost; string subpath;
EXPECT_TRUE(get_streamid_info("#!::h=live/livestream?secret=d6d2be37,m=publish", mode, vhost, subpath));
EXPECT_EQ(PUSH_SRT_MODE, mode);
EXPECT_STREQ("", vhost.c_str());
EXPECT_STREQ("live/livestream?secret=d6d2be37", subpath.c_str());
}
}

16
trunk/src/utest/srs_utest_srt.hpp Normal file
View file

@ -0,0 +1,16 @@
//
// Copyright (c) 2013-2021 Winlin
//
// SPDX-License-Identifier: MIT
//
#ifndef SRS_UTEST_SRT_HPP
#define SRS_UTEST_SRT_HPP
/*
#include <srs_utest_srt.hpp>
*/
#include <srs_utest.hpp>
#endif