diff --git a/trunk/src/app/srs_app_config.cpp b/trunk/src/app/srs_app_config.cpp
index d74f4b410a..b1dea34356 100644
--- a/trunk/src/app/srs_app_config.cpp
+++ b/trunk/src/app/srs_app_config.cpp
@@ -2512,22 +2512,54 @@ srs_error_t SrsConfig::check_normal_config()
// Check HTTP API and server.
////////////////////////////////////////////////////////////////////////
if (true) {
- string api = get_http_api_listen();
- string server = get_http_stream_listen();
- if (api.empty()) {
+ vector api_vec = get_http_apis_listens();
+ vector server_vec = get_http_streams_listens();
+ if (api_vec.empty()) {
return srs_error_new(ERROR_SYSTEM_CONFIG_INVALID, "http_api.listen requires params");
}
- if (server.empty()) {
+ if (server_vec.empty()) {
return srs_error_new(ERROR_SYSTEM_CONFIG_INVALID, "http_server.listen requires params");
}
- string apis = get_https_api_listen();
- string servers = get_https_stream_listen();
- if (api == server && apis != servers) {
- return srs_error_new(ERROR_SYSTEM_CONFIG_INVALID, "for same http, https api(%s) != server(%s)", apis.c_str(), servers.c_str());
+ std::sort(api_vec.begin(), api_vec.end());
+ std::sort(server_vec.begin(), server_vec.end());
+
+ std::vector intersection_result;
+ std::vector intersections_result;
+ std::set_intersection(
+ api_vec.begin(), api_vec.end(),
+ server_vec.begin(), server_vec.end(),
+ std::back_inserter(intersection_result)
+ );
+
+ bool isNotSameHttp = intersection_result.size() == 0;
+ bool isFullyContainedHttp = !isNotSameHttp && intersection_result.size() == api_vec.size();
+ if (!isNotSameHttp && !isFullyContainedHttp)
+ {
+ return srs_error_new(ERROR_SYSTEM_CONFIG_INVALID, "http api and http server intersect in functionality, but an http server does not fully encapsulate an http api");
}
- if (apis == servers && api != server) {
- return srs_error_new(ERROR_SYSTEM_CONFIG_INVALID, "for same https, http api(%s) != server(%s)", api.c_str(), server.c_str());
+ vector apis_vec = get_https_apis_listens();
+ vector servers_vec = get_https_streams_listens();
+
+ std::sort(apis_vec.begin(), apis_vec.end());
+ std::sort(servers_vec.begin(), servers_vec.end());
+ std::set_intersection(
+ apis_vec.begin(), apis_vec.end(),
+ servers_vec.begin(), servers_vec.end(),
+ std::back_inserter(intersections_result)
+ );
+
+ bool isNotSameHttps = intersections_result.size() == 0;
+ bool isFullyContainedHttps = !isNotSameHttps && intersections_result.size() == apis_vec.size();
+ if (!isNotSameHttps && !isFullyContainedHttps)
+ {
+ return srs_error_new(ERROR_SYSTEM_CONFIG_INVALID, "https api and https server intersect in functionality, but an https server does not fully encapsulate an https api");
+ }
+ if (!isNotSameHttp && isNotSameHttps) {
+ return srs_error_new(ERROR_SYSTEM_CONFIG_INVALID, "for same http, https api != server");
+ }
+ if (!isNotSameHttps && isNotSameHttp) {
+ return srs_error_new(ERROR_SYSTEM_CONFIG_INVALID, "for same https, http api != server");
}
if (get_https_api_enabled() && !get_http_api_enabled()) {
@@ -7696,6 +7728,30 @@ string SrsConfig::get_http_api_listen()
return conf->arg0();
}
+std::vector SrsConfig::get_http_apis_listens()
+{
+ std::vector ports;
+ if (!srs_getenv("srs.http_api.listen").empty()) { // SRS_LISTEN
+ return srs_string_split(srs_getenv("srs.http_api.listen"), " ");
+ }
+ string DEFAULT = "1985";
+ SrsConfDirective* conf = root->get("http_api");
+ if (!conf) {
+ ports.push_back(DEFAULT);
+ return ports;
+ }
+ conf = conf->get("listen");
+ if (!conf) {
+ ports.push_back(DEFAULT);
+ return ports;
+ }
+ for (int i = 0; i < (int)conf->args.size(); i++) {
+ ports.push_back(conf->args.at(i));
+ }
+
+ return ports;
+}
+
bool SrsConfig::get_http_api_crossdomain()
{
SRS_OVERWRITE_BY_ENV_BOOL2("srs.http_api.crossdomain"); // SRS_HTTP_API_CROSSDOMAIN
@@ -7900,6 +7956,35 @@ string SrsConfig::get_https_api_listen()
return conf->arg0();
}
+std::vector SrsConfig::get_https_apis_listens()
+{
+ std::vector ports;
+ if (!srs_getenv("srs.http_api.https.listen").empty()) { // SRS_LISTEN
+ return srs_string_split(srs_getenv("srs.http_api.https.listen"), " ");
+ }
+ static string DEFAULT = "1990";
+ if (get_http_api_listen() == get_http_stream_listen()) {
+ DEFAULT = get_https_stream_listen();
+ }
+
+ SrsConfDirective* conf = get_https_api();
+ if (!conf) {
+ ports.push_back(DEFAULT);
+ return ports;
+ }
+ conf = conf->get("listen");
+ if (!conf) {
+ ports.push_back(DEFAULT);
+ return ports;
+ }
+ for (int i = 0; i < (int)conf->args.size(); i++) {
+ ports.push_back(conf->args.at(i));
+ }
+
+ return ports;
+}
+
+
string SrsConfig::get_https_api_ssl_key()
{
SRS_OVERWRITE_BY_ENV_STRING("srs.http_api.https.key"); // SRS_HTTP_API_HTTPS_KEY
@@ -8315,6 +8400,29 @@ bool SrsConfig::get_http_stream_enabled(SrsConfDirective* conf)
return SRS_CONF_PREFER_FALSE(conf->arg0());
}
+std::vector SrsConfig::get_http_streams_listens()
+{
+ std::vector ports;
+ if (!srs_getenv("srs.http_server.listen").empty()) { // SRS_LISTEN
+ return srs_string_split(srs_getenv("srs.http_server.listen"), " ");
+ }
+ string DEFAULT = "8080";
+ SrsConfDirective* conf = root->get("http_server");
+ if (!conf) {
+ ports.push_back(DEFAULT);
+ return ports;
+ }
+ conf = conf->get("listen");
+ if (!conf) {
+ ports.push_back(DEFAULT);
+ return ports;
+ }
+ for (int i = 0; i < (int)conf->args.size(); i++) {
+ ports.push_back(conf->args.at(i));
+ }
+
+ return ports;
+}
string SrsConfig::get_http_stream_listen()
{
@@ -8421,6 +8529,30 @@ string SrsConfig::get_https_stream_listen()
return conf->arg0();
}
+std::vector SrsConfig::get_https_streams_listens()
+{
+ std::vector ports;
+ if (!srs_getenv("srs.http_server.https.listen").empty()) { // SRS_LISTEN
+ return srs_string_split(srs_getenv("srs.http_server.https.listen"), " ");
+ }
+ static string DEFAULT = "8088";
+ SrsConfDirective* conf = get_https_stream();
+ if (!conf) {
+ ports.push_back(DEFAULT);
+ return ports;
+ }
+ conf = conf->get("listen");
+ if (!conf) {
+ ports.push_back(DEFAULT);
+ return ports;
+ }
+ for (int i = 0; i < (int)conf->args.size(); i++) {
+ ports.push_back(conf->args.at(i));
+ }
+
+ return ports;
+}
+
string SrsConfig::get_https_stream_ssl_key()
{
SRS_OVERWRITE_BY_ENV_STRING("srs.http_server.https.key"); // SRS_HTTP_SERVER_HTTPS_KEY
diff --git a/trunk/src/app/srs_app_config.hpp b/trunk/src/app/srs_app_config.hpp
index bfb87445f9..fd957f660a 100644
--- a/trunk/src/app/srs_app_config.hpp
+++ b/trunk/src/app/srs_app_config.hpp
@@ -1031,6 +1031,10 @@ class SrsConfig
virtual bool get_http_api_enabled();
// Get the http api listen port.
virtual std::string get_http_api_listen();
+ // Get the http api listen port.
+ // user can specifies multiple listen ports,
+ // each args of directive is a listen port.
+ virtual std::vector get_http_apis_listens();
// Whether enable crossdomain for http api.
virtual bool get_http_api_crossdomain();
// Whether enable the HTTP RAW API.
@@ -1053,6 +1057,7 @@ class SrsConfig
public:
virtual bool get_https_api_enabled();
virtual std::string get_https_api_listen();
+ virtual std::vector get_https_apis_listens();
virtual std::string get_https_api_ssl_key();
virtual std::string get_https_api_ssl_cert();
// http stream section
@@ -1065,6 +1070,10 @@ class SrsConfig
virtual bool get_http_stream_enabled();
// Get the http stream listen port.
virtual std::string get_http_stream_listen();
+ // Get the http stream listen port.
+ // user can specifies multiple listen ports,
+ // each args of directive is a listen port.
+ virtual std::vector get_http_streams_listens();
// Get the http stream root dir.
virtual std::string get_http_stream_dir();
// Whether enable crossdomain for http static and stream server.
@@ -1075,6 +1084,7 @@ class SrsConfig
public:
virtual bool get_https_stream_enabled();
virtual std::string get_https_stream_listen();
+ virtual std::vector get_https_streams_listens();
virtual std::string get_https_stream_ssl_key();
virtual std::string get_https_stream_ssl_cert();
public:
diff --git a/trunk/src/app/srs_app_server.cpp b/trunk/src/app/srs_app_server.cpp
index 7932a90020..148456ea4c 100644
--- a/trunk/src/app/srs_app_server.cpp
+++ b/trunk/src/app/srs_app_server.cpp
@@ -336,10 +336,10 @@ SrsServer::SrsServer()
ppid = ::getppid();
rtmp_listener_ = new SrsMultipleTcpListeners(this);
- api_listener_ = new SrsTcpListener(this);
- apis_listener_ = new SrsTcpListener(this);
- http_listener_ = new SrsTcpListener(this);
- https_listener_ = new SrsTcpListener(this);
+ api_listener_ = new SrsMultipleTcpListeners(this);
+ apis_listener_ = new SrsMultipleTcpListeners(this);
+ http_listener_ = new SrsMultipleTcpListeners(this);
+ https_listener_ = new SrsMultipleTcpListeners(this);
webrtc_listener_ = new SrsTcpListener(this);
stream_caster_flv_listener_ = new SrsHttpFlvListener();
stream_caster_mpegts_ = new SrsUdpCasterListener();
@@ -491,32 +491,87 @@ srs_error_t SrsServer::initialize()
_srs_config->subscribe(this);
bool stream = _srs_config->get_http_stream_enabled();
- string http_listen = _srs_config->get_http_stream_listen();
- string https_listen = _srs_config->get_https_stream_listen();
+ vector server_vec = _srs_config->get_http_streams_listens();
+ vector servers_vec = _srs_config->get_https_streams_listens();
+ std::sort(server_vec.begin(), server_vec.end());
+ std::sort(servers_vec.begin(), servers_vec.end());
+
+
+
#ifdef SRS_RTC
bool rtc = _srs_config->get_rtc_server_enabled();
bool rtc_tcp = _srs_config->get_rtc_server_tcp_enabled();
string rtc_listen = srs_int2str(_srs_config->get_rtc_server_tcp_listen());
// If enabled and listen is the same value, resue port for WebRTC over TCP.
- if (stream && rtc && rtc_tcp && http_listen == rtc_listen) {
- srs_trace("WebRTC tcp=%s reuses http=%s server", rtc_listen.c_str(), http_listen.c_str());
- reuse_rtc_over_server_ = true;
+ for (int idx = 0; idx < server_vec.size(); idx++)
+ {
+ string http_listen = server_vec[idx];
+ if (stream && rtc && rtc_tcp && http_listen == rtc_listen) {
+ srs_trace("WebRTC tcp=%s reuses http=%s server", rtc_listen.c_str(), http_listen.c_str());
+ reuse_rtc_over_server_ = true;
+ }
}
- if (stream && rtc && rtc_tcp && https_listen == rtc_listen) {
- srs_trace("WebRTC tcp=%s reuses https=%s server", rtc_listen.c_str(), https_listen.c_str());
- reuse_rtc_over_server_ = true;
+ for (int idx = 0; idx < servers_vec.size(); idx++)
+ {
+ string https_listen = servers_vec[idx];
+ if (stream && rtc && rtc_tcp && https_listen == rtc_listen) {
+ srs_trace("WebRTC tcp=%s reuses https=%s server", rtc_listen.c_str(), https_listen.c_str());
+ reuse_rtc_over_server_ = true;
+ }
}
#endif
// If enabled and the listen is the same value, reuse port.
bool api = _srs_config->get_http_api_enabled();
- string api_listen = _srs_config->get_http_api_listen();
- string apis_listen = _srs_config->get_https_api_listen();
- if (stream && api && api_listen == http_listen && apis_listen == https_listen) {
- srs_trace("API reuses http=%s and https=%s server", http_listen.c_str(), https_listen.c_str());
+ vector api_vec = _srs_config->get_http_apis_listens();
+ vector apis_vec = _srs_config->get_https_apis_listens();
+
+ std::sort(api_vec.begin(), api_vec.end());
+ std::sort(apis_vec.begin(), apis_vec.end());
+
+ std::vector intersection_result;
+ std::vector intersections_result;
+
+ std::set_intersection(
+ api_vec.begin(), api_vec.end(),
+ server_vec.begin(), server_vec.end(),
+ std::back_inserter(intersection_result)
+ );
+ std::set_intersection(
+ apis_vec.begin(), apis_vec.end(),
+ servers_vec.begin(), servers_vec.end(),
+ std::back_inserter(intersections_result)
+ );
+ bool isNotSameHttp = intersection_result.size() == 0;
+ bool isFullyContainedHttp = !isNotSameHttp && intersection_result.size() == api_vec.size();
+ bool isNotSameHttps = intersections_result.size() == 0;
+ bool isFullyContainedHttps = !isNotSameHttps && intersections_result.size() == apis_vec.size();
+
+ if ((!isNotSameHttp && !isFullyContainedHttp) || (!isNotSameHttps && !isFullyContainedHttps))
+ {
+ return srs_error_wrap(err, "http api and http server intersect in functionality, but an http server does not fully encapsulate an http api");
+ }
+
+ if (stream && api && isFullyContainedHttp && isFullyContainedHttps)
+ {
+ srs_trace("API reuses http and https server");
+ for (int idx = 0; idx < intersection_result.size(); idx++)
+ {
+ string http_listen = intersection_result[idx];
+ srs_trace("API reuses http=%s server", http_listen.c_str());
+ }
+ for (int idx = 0; idx < intersections_result.size(); idx++)
+ {
+ string https_listen = intersections_result[idx];
+ srs_trace("API reuses https=%s server", https_listen.c_str());
+ }
reuse_api_over_server_ = true;
}
+ else if (isNotSameHttp && isNotSameHttps)
+ {
+ reuse_api_over_server_ = false;
+ }
// Only init HTTP API when not reusing HTTP server.
if (!reuse_api_over_server_) {
@@ -585,8 +640,8 @@ srs_error_t SrsServer::listen()
if (reuse_api_over_server_) {
srs_trace("HTTP-API: Reuse listen to http server %s", _srs_config->get_http_stream_listen().c_str());
} else {
- api_listener_->set_endpoint(_srs_config->get_http_api_listen())->set_label("HTTP-API");
- if ((err = api_listener_->listen()) != srs_success) {
+ api_listener_->add(_srs_config->get_http_apis_listens())->set_label("HTTP_API");
+ if ((err = api_listener_->listen()) != srs_success) {
return srs_error_wrap(err, "http api listen");
}
}
@@ -597,8 +652,8 @@ srs_error_t SrsServer::listen()
if (reuse_api_over_server_) {
srs_trace("HTTPS-API: Reuse listen to http server %s", _srs_config->get_https_stream_listen().c_str());
} else {
- apis_listener_->set_endpoint(_srs_config->get_https_api_listen())->set_label("HTTPS-API");
- if ((err = apis_listener_->listen()) != srs_success) {
+ apis_listener_->add(_srs_config->get_https_apis_listens())->set_label("HTTPS_API");
+ if ((err = apis_listener_->listen()) != srs_success) {
return srs_error_wrap(err, "https api listen");
}
}
@@ -606,7 +661,7 @@ srs_error_t SrsServer::listen()
// Create HTTP server listener.
if (_srs_config->get_http_stream_enabled()) {
- http_listener_->set_endpoint(_srs_config->get_http_stream_listen())->set_label("HTTP-Server");
+ http_listener_->add(_srs_config->get_http_streams_listens())->set_label("HTTP-Server");
if ((err = http_listener_->listen()) != srs_success) {
return srs_error_wrap(err, "http server listen");
}
@@ -614,7 +669,7 @@ srs_error_t SrsServer::listen()
// Create HTTPS server listener.
if (_srs_config->get_https_stream_enabled()) {
- https_listener_->set_endpoint(_srs_config->get_https_stream_listen())->set_label("HTTPS-Server");
+ https_listener_->add(_srs_config->get_https_streams_listens())->set_label("HTTPS-Server");
if ((err = https_listener_->listen()) != srs_success) {
return srs_error_wrap(err, "https server listen");
}
diff --git a/trunk/src/app/srs_app_server.hpp b/trunk/src/app/srs_app_server.hpp
index 78e9b8b6c4..e7f8feb596 100644
--- a/trunk/src/app/srs_app_server.hpp
+++ b/trunk/src/app/srs_app_server.hpp
@@ -116,18 +116,18 @@ class SrsServer : public ISrsReloadHandler, public ISrsLiveSourceHandler, public
bool reuse_api_over_server_;
// If reusing, WebRTC TCP use the same port of HTTP server.
bool reuse_rtc_over_server_;
- // RTMP stream listeners, over TCP.
+ // RTMP stream listeners, over TCP.
SrsMultipleTcpListeners* rtmp_listener_;
// HTTP API listener, over TCP. Please note that it might reuse with stream listener.
- SrsTcpListener* api_listener_;
+ SrsMultipleTcpListeners* api_listener_;
// HTTPS API listener, over TCP. Please note that it might reuse with stream listener.
- SrsTcpListener* apis_listener_;
+ SrsMultipleTcpListeners* apis_listener_;
// HTTP server listener, over TCP. Please note that request of both HTTP static and stream are served by this
// listener, and it might be reused by HTTP API and WebRTC TCP.
- SrsTcpListener* http_listener_;
+ SrsMultipleTcpListeners* http_listener_;
// HTTPS server listener, over TCP. Please note that request of both HTTP static and stream are served by this
// listener, and it might be reused by HTTP API and WebRTC TCP.
- SrsTcpListener* https_listener_;
+ SrsMultipleTcpListeners* https_listener_;
// WebRTC over TCP listener. Please note that there is always a UDP listener by RTC server.
SrsTcpListener* webrtc_listener_;
// Stream Caster for push over HTTP-FLV.