Merge branch '4.0release' into develop

README.md

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

trunk/configure

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

trunk/doc/CHANGELOG.md

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

trunk/src/core/srs_core_version4.hpp

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

trunk/src/srt/srt_conn.cpp

@@ -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,56 +87,99 @@ bool get_streamid_info(const std::string& streamid, int& mode, std::string& url_
         url_subpath = streamid;
         return true;
     }
-    real_streamid = streamid.substr(4);
-
-    string_split(real_streamid, ",", info_vec);
-    if (info_vec.size() < 2) {
-        return false;
-    }
 
-    for (size_t index = 0; index < info_vec.size(); index++) {
-        std::string key;
-        std::string value;
+    //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);
 
-        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
+    // 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") {
+            }  else if (mode_str == "request") {
                 mode = PULL_SRT_MODE;
-            } else {
-                mode = PUSH_SRT_MODE;
+            }  else {
+                srt_log_warn("unknown mode_str:%s", mode_str.c_str());
+                return false;
             }
-        } else {//not suport
-            continue;
+        } else {
+            params.append(it->first);
+            params.append("=");
+            params.append(it->second);
+            params.append("&");
         }
     }
 
+    if (url_subpath.empty()) {
+        return false;
+    }
+
+    if (!params.empty()) {
+        url_subpath.append("?");
+        url_subpath.append(params);
+        url_subpath.pop_back(); // remove last '&'
+    }
+
     return true;
 }
 
 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;
 }

trunk/src/srt/srt_conn.hpp

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

trunk/src/srt/srt_handle.cpp

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

trunk/src/srt/srt_handle.hpp

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

trunk/src/utest/srs_utest_srt.cpp

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

trunk/src/utest/srs_utest_srt.hpp

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