diff --git a/trunk/conf/srt.conf b/trunk/conf/srt.conf
index 582bc005639..3ea77dd10ac 100644
--- a/trunk/conf/srt.conf
+++ b/trunk/conf/srt.conf
@@ -18,7 +18,23 @@ http_server {
 
 srt_server {
     enabled on;
-    listen 10080;
+    type push;
+    port 10080;
+    maxbw 1000000000;
+    connect_timeout 4000;
+    peerlatency 0;
+    recvlatency 0;
+    latency 0;
+    tsbpdmode off;
+    tlpktdrop off;
+    sendbuf 2000000;
+    recvbuf 2000000;
+}
+
+srt_server {
+    enabled on;
+    type pull;
+    port 10081;
     maxbw 1000000000;
     connect_timeout 4000;
     peerlatency 0;
diff --git a/trunk/conf/srt2rtc.conf b/trunk/conf/srt2rtc.conf
index 2f4ac6ba460..f263f9fe6b6 100644
--- a/trunk/conf/srt2rtc.conf
+++ b/trunk/conf/srt2rtc.conf
@@ -17,7 +17,18 @@ http_server {
 
 srt_server {
     enabled on;
-    listen 10080;
+    type push;
+    port 10080;
+    maxbw 1000000000;
+    connect_timeout 4000;
+    peerlatency 0;
+    recvlatency 0;
+}
+
+srt_server {
+    enabled on;
+    type pull;
+    port 10081;
     maxbw 1000000000;
     connect_timeout 4000;
     peerlatency 0;
diff --git a/trunk/src/app/srs_app_config.cpp b/trunk/src/app/srs_app_config.cpp
index 5fb625667c3..35c59072ba2 100644
--- a/trunk/src/app/srs_app_config.cpp
+++ b/trunk/src/app/srs_app_config.cpp
@@ -5,7 +5,6 @@
 //
 
 #include <srs_app_config.hpp>
-
 #include <unistd.h>
 #include <stdio.h>
 #include <stdlib.h>
@@ -2320,7 +2319,7 @@ srs_error_t SrsConfig::check_normal_config()
         SrsConfDirective* conf = root->get("srt_server");
         for (int i = 0; conf && i < (int)conf->directives.size(); i++) {
             string n = conf->at(i)->name;
-            if (n != "enabled" && n != "listen" && n != "maxbw"
+            if (n != "enabled" && n != "type" && n != "port" && n != "maxbw"
                 && n != "mss" && n != "latency" && n != "recvlatency"
                 && n != "peerlatency" && n != "connect_timeout"
                 && n != "sendbuf" && n != "recvbuf" && n != "payloadsize"
@@ -7777,291 +7776,314 @@ string SrsConfig::get_https_api_ssl_cert()
     return conf->arg0();
 }
 
+bool SrsConfig::is_srt_server(SrsConfDirective* srt_conf) {
+    return srt_conf && srt_conf->name == "srt_server";
+}
+
+void SrsConfig::get_srt_servers(vector<SrsConfDirective*>& servers)
+{
+    srs_assert(root);
+    
+    for (int i = 0; i < (int)root->directives.size(); i++) {
+        SrsConfDirective* conf = root->at(i);
+        if (!is_srt_server(conf)) {
+            continue;
+        }
+        servers.push_back(conf);
+    }
+}
+
 bool SrsConfig::get_srt_enabled()
 {
     SRS_OVERWRITE_BY_ENV_BOOL("srs.srt_server.enabled"); // SRS_SRT_SERVER_ENABLED
+    bool ret = false;
 
-    static bool DEFAULT = false;
-    
-    SrsConfDirective* conf = root->get("srt_server");
-    if (!conf) {
+    for (int i = 0; i < (int)root->directives.size(); i++) {
+        SrsConfDirective* conf = root->at(i);
+
+        if (!is_srt_server(conf)) {
+            continue;
+        }
+        conf = conf->get("enabled");
+        if (!conf || conf->arg0().empty()) {
+            ret = false;
+        } else {
+            ret = true;
+            break;
+        }
+    }
+
+    return ret;
+}
+
+std::string SrsConfig::get_srt_type(SrsConfDirective* srt_conf)
+{
+    SRS_OVERWRITE_BY_ENV_STRING("srs.srt_server.type");
+
+    static std::string DEFAULT("push");
+
+    if (!srt_conf) {
         return DEFAULT;
     }
-    
-    conf = conf->get("enabled");
-    if (!conf || conf->arg0().empty()) {
+    SrsConfDirective* type_conf = srt_conf->get("type");
+    if (!type_conf || type_conf->arg0().empty()) {
         return DEFAULT;
     }
-    
-    return SRS_CONF_PERFER_FALSE(conf->arg0());
+    return type_conf->arg0();
 }
 
-unsigned short SrsConfig::get_srt_listen_port()
+unsigned short SrsConfig::get_srt_port(SrsConfDirective* srt_conf)
 {
     SRS_OVERWRITE_BY_ENV_INT("srs.srt_server.listen"); // SRS_SRT_SERVER_LISTEN
 
     static unsigned short DEFAULT = 10080;
-    SrsConfDirective* conf = root->get("srt_server");
-    if (!conf) {
+
+    if (!srt_conf) {
         return DEFAULT;
     }
-    
-    conf = conf->get("listen");
-    if (!conf || conf->arg0().empty()) {
+
+    SrsConfDirective* port_conf = srt_conf->get("port");
+    if (!port_conf || port_conf->arg0().empty()) {
         return DEFAULT;
     }
-    return (unsigned short)atoi(conf->arg0().c_str());
+    return (unsigned short)atoi(port_conf->arg0().c_str());
 }
 
-int64_t SrsConfig::get_srto_maxbw()
+int64_t SrsConfig::get_srto_maxbw(SrsConfDirective* srt_conf)
 {
     SRS_OVERWRITE_BY_ENV_INT("srs.srt_server.maxbw"); // SRS_SRT_SERVER_MAXBW
 
     static int64_t DEFAULT = -1;
-    SrsConfDirective* conf = root->get("srt_server");
-    if (!conf) {
+    
+    if (!srt_conf) {
         return DEFAULT;
     }
-    
-    conf = conf->get("maxbw");
+    SrsConfDirective* conf = srt_conf->get("maxbw");
     if (!conf || conf->arg0().empty()) {
         return DEFAULT;
     }
     return atoll(conf->arg0().c_str());
 }
 
-int SrsConfig::get_srto_mss()
+int SrsConfig::get_srto_mss(SrsConfDirective* srt_conf)
 {
     SRS_OVERWRITE_BY_ENV_INT("srs.srt_server.mms"); // SRS_SRT_SERVER_MMS
 
     static int DEFAULT = 1500;
-    SrsConfDirective* conf = root->get("srt_server");
-    if (!conf) {
+
+    if (!srt_conf) {
         return DEFAULT;
     }
-    
-    conf = conf->get("mms");
+
+    SrsConfDirective* conf = srt_conf->get("mms");
     if (!conf || conf->arg0().empty()) {
         return DEFAULT;
     }
     return atoi(conf->arg0().c_str());
 }
 
-bool SrsConfig::get_srto_tsbpdmode()
+bool SrsConfig::get_srto_tsbpdmode(SrsConfDirective* srt_conf)
 {
     SRS_OVERWRITE_BY_ENV_BOOL2("srs.srt_server.tsbpdmode"); // SRS_SRT_SERVER_TSBPDMODE
 
     static bool DEFAULT = true;
-    SrsConfDirective* conf = root->get("srt_server");
-    if (!conf) {
+    
+    if (!srt_conf) {
         return DEFAULT;
     }
-    
-    conf = conf->get("tsbpdmode");
+    SrsConfDirective* conf = srt_conf->get("tsbpdmode");
     if (!conf || conf->arg0().empty()) {
         return DEFAULT;
     }
     return SRS_CONF_PERFER_TRUE(conf->arg0());
 }
 
-int SrsConfig::get_srto_latency()
+int SrsConfig::get_srto_latency(SrsConfDirective* srt_conf)
 {
     SRS_OVERWRITE_BY_ENV_INT("srs.srt_server.latency"); // SRS_SRT_SERVER_LATENCY
 
     static int DEFAULT = 120;
-    SrsConfDirective* conf = root->get("srt_server");
-    if (!conf) {
+    
+    if (!srt_conf) {
         return DEFAULT;
     }
-    
-    conf = conf->get("latency");
+    SrsConfDirective* conf = srt_conf->get("latency");
     if (!conf || conf->arg0().empty()) {
         return DEFAULT;
     }
     return atoi(conf->arg0().c_str());
 }
 
-int SrsConfig::get_srto_recv_latency()
+int SrsConfig::get_srto_recv_latency(SrsConfDirective* srt_conf)
 {
     SRS_OVERWRITE_BY_ENV_INT("srs.srt_server.recvlatency"); // SRS_SRT_SERVER_RECVLATENCY
 
     static int DEFAULT = 120;
-    SrsConfDirective* conf = root->get("srt_server");
-    if (!conf) {
+    
+    if (!srt_conf) {
         return DEFAULT;
     }
-    
-    conf = conf->get("recvlatency");
+    SrsConfDirective* conf = srt_conf->get("recvlatency");
     if (!conf || conf->arg0().empty()) {
         return DEFAULT;
     }
     return atoi(conf->arg0().c_str());
 }
 
-int SrsConfig::get_srto_peer_latency()
+int SrsConfig::get_srto_peer_latency(SrsConfDirective* srt_conf)
 {
     SRS_OVERWRITE_BY_ENV_INT("srs.srt_server.peerlatency"); // SRS_SRT_SERVER_PEERLATENCY
 
     static int DEFAULT = 0;
-    SrsConfDirective* conf = root->get("srt_server");
-    if (!conf) {
+    
+    if (!srt_conf) {
         return DEFAULT;
     }
-    
-    conf = conf->get("peerlatency");
+    SrsConfDirective* conf = srt_conf->get("peerlatency");
     if (!conf || conf->arg0().empty()) {
         return DEFAULT;
     }
     return atoi(conf->arg0().c_str());
 }
 
-bool SrsConfig::get_srt_sei_filter()
+bool SrsConfig::get_srt_sei_filter(SrsConfDirective* srt_conf)
 {
     SRS_OVERWRITE_BY_ENV_BOOL2("srs.srt_server.sei_filter"); // SRS_SRT_SERVER_SEI_FILTER
 
     static bool DEFAULT = true;
-    SrsConfDirective* conf = root->get("srt_server");
-    if (!conf) {
+    
+    if (!srt_conf) {
         return DEFAULT;
     }
-    
-    conf = conf->get("sei_filter");
+    SrsConfDirective* conf = srt_conf->get("sei_filter");
     if (!conf || conf->arg0().empty()) {
         return DEFAULT;
     }
     return SRS_CONF_PERFER_TRUE(conf->arg0());
 }
 
-bool SrsConfig::get_srto_tlpktdrop()
+bool SrsConfig::get_srto_tlpktdrop(SrsConfDirective* srt_conf)
 {
     SRS_OVERWRITE_BY_ENV_BOOL2("srs.srt_server.tlpktdrop"); // SRS_SRT_SERVER_TLPKTDROP
 
     static bool DEFAULT = true;
-    SrsConfDirective* srt_server_conf = root->get("srt_server");
-    if (!srt_server_conf) {
+
+    if (!srt_conf) {
         return DEFAULT;
     }
-
-    SrsConfDirective* conf = srt_server_conf->get("tlpktdrop");
+    SrsConfDirective* conf = srt_conf->get("tlpktdrop");
     if (!conf || conf->arg0().empty()) {
         return DEFAULT;
     }
     return SRS_CONF_PERFER_TRUE(conf->arg0());
 }
 
-srs_utime_t SrsConfig::get_srto_conntimeout()
+srs_utime_t SrsConfig::get_srto_conntimeout(SrsConfDirective* srt_conf)
 {
     SRS_OVERWRITE_BY_ENV_MILLISECONDS("srs.srt_server.connect_timeout"); // SRS_SRT_SERVER_CONNECT_TIMEOUT
 
     static srs_utime_t DEFAULT = 3 * SRS_UTIME_SECONDS;
-    SrsConfDirective* conf = root->get("srt_server");
-    if (!conf) {
-        return DEFAULT;
+
+    if (!srt_conf) {
+       return DEFAULT;
     }
-    
-    conf = conf->get("connect_timeout");
+    SrsConfDirective* conf = srt_conf->get("connect_timeout");
     if (!conf || conf->arg0().empty()) {
         return DEFAULT;
     }
     return (srs_utime_t)(::atoi(conf->arg0().c_str()) * SRS_UTIME_MILLISECONDS);
 }
 
-srs_utime_t SrsConfig::get_srto_peeridletimeout()
+srs_utime_t SrsConfig::get_srto_peeridletimeout(SrsConfDirective* srt_conf)
 {
     SRS_OVERWRITE_BY_ENV_MILLISECONDS("srs.srt_server.peer_idle_timeout"); // SRS_SRT_SERVER_PEER_IDLE_TIMEOUT
 
     static srs_utime_t DEFAULT = 10 * SRS_UTIME_SECONDS;
-    SrsConfDirective* conf = root->get("srt_server");
-    if (!conf) {
+    
+    if (!srt_conf) {
         return DEFAULT;
     }
-    
-    conf = conf->get("peer_idle_timeout");
+    SrsConfDirective* conf = srt_conf->get("peer_idle_timeout");
     if (!conf || conf->arg0().empty()) {
         return DEFAULT;
     }
     return (srs_utime_t)(::atoi(conf->arg0().c_str()) * SRS_UTIME_MILLISECONDS);
 }
 
-int SrsConfig::get_srto_sendbuf()
+int SrsConfig::get_srto_sendbuf(SrsConfDirective* srt_conf)
 {
     SRS_OVERWRITE_BY_ENV_INT("srs.srt_server.sendbuf"); // SRS_SRT_SERVER_SENDBUF
 
     static int DEFAULT = 8192 * (1500-28);
-    SrsConfDirective* conf = root->get("srt_server");
-    if (!conf) {
+    
+    if (!srt_conf) {
         return DEFAULT;
     }
-    
-    conf = conf->get("sendbuf");
+    SrsConfDirective* conf = srt_conf->get("sendbuf");
     if (!conf || conf->arg0().empty()) {
         return DEFAULT;
     }
     return atoi(conf->arg0().c_str());
 }
 
-int SrsConfig::get_srto_recvbuf()
+int SrsConfig::get_srto_recvbuf(SrsConfDirective* srt_conf)
 {
     SRS_OVERWRITE_BY_ENV_INT("srs.srt_server.recvbuf"); // SRS_SRT_SERVER_RECVBUF
 
     static int DEFAULT = 8192 * (1500-28);
-    SrsConfDirective* conf = root->get("srt_server");
-    if (!conf) {
+    
+    if (!srt_conf) {
         return DEFAULT;
     }
-    
-    conf = conf->get("recvbuf");
+    SrsConfDirective* conf = srt_conf->get("recvbuf");
     if (!conf || conf->arg0().empty()) {
         return DEFAULT;
     }
     return atoi(conf->arg0().c_str());
 }
 
-int SrsConfig::get_srto_payloadsize()
+int SrsConfig::get_srto_payloadsize(SrsConfDirective* srt_conf)
 {
     SRS_OVERWRITE_BY_ENV_INT("srs.srt_server.payloadsize"); // SRS_SRT_SERVER_PAYLOADSIZE
 
     static int DEFAULT = 1316;
-    SrsConfDirective* conf = root->get("srt_server");
-    if (!conf) {
+    
+    if (!srt_conf) {
         return DEFAULT;
     }
-    
-    conf = conf->get("payloadsize");
+    SrsConfDirective* conf = srt_conf->get("payloadsize");
     if (!conf || conf->arg0().empty()) {
         return DEFAULT;
     }
     return atoi(conf->arg0().c_str());
 }
 
-string SrsConfig::get_srto_passphrase()
+string SrsConfig::get_srto_passphrase(SrsConfDirective* srt_conf)
 {
     SRS_OVERWRITE_BY_ENV_STRING("srs.srt_server.passphrase"); // SRS_SRT_SERVER_PASSPHRASE
 
     static string DEFAULT = "";
-    SrsConfDirective* conf = root->get("srt_server");
-    if (!conf) {
+    
+    if (!srt_conf) {
         return DEFAULT;
     }
-    
-    conf = conf->get("passphrase");
+    SrsConfDirective* conf = srt_conf->get("passphrase");
     if (!conf || conf->arg0().empty()) {
         return DEFAULT;
     }
     return conf->arg0();
 }
 
-int SrsConfig::get_srto_pbkeylen()
+int SrsConfig::get_srto_pbkeylen(SrsConfDirective* srt_conf)
 {
     SRS_OVERWRITE_BY_ENV_INT("srs.srt_server.pbkeylen"); // SRS_SRT_SERVER_PBKEYLEN
 
     static int DEFAULT = 0;
-    SrsConfDirective* conf = root->get("srt_server");
-    if (!conf) {
+    
+    if (!srt_conf) {
         return DEFAULT;
     }
-    
-    conf = conf->get("pbkeylen");
+    SrsConfDirective* conf = srt_conf->get("pbkeylen");
     if (!conf || conf->arg0().empty()) {
         return DEFAULT;
     }
@@ -8072,17 +8094,21 @@ string SrsConfig::get_default_app_name()
 {
     SRS_OVERWRITE_BY_ENV_STRING("srs.srt_server.default_app"); // SRS_SRT_SERVER_DEFAULT_APP
 
-    static string DEFAULT = "live";
-    SrsConfDirective* conf = root->get("srt_server");
-    if (!conf) {
-        return DEFAULT;
-    }
+    string ret = "live";
 
-    conf = conf->get("default_app");
-    if (!conf || conf->arg0().empty()) {
-        return DEFAULT;
+    for (int i = 0; i < (int)root->directives.size(); i++) {
+        SrsConfDirective* conf = root->at(i);
+        
+        if (!is_srt_server(conf)) {
+            continue;
+        }
+        conf = conf->get("default_app");
+        if (!conf || conf->arg0().empty()) {
+            ret = conf->arg0();
+            break;
+        }
     }
-    return conf->arg0();
+    return ret;
 }
 
 SrsConfDirective* SrsConfig::get_srt(std::string vhost)
diff --git a/trunk/src/app/srs_app_config.hpp b/trunk/src/app/srs_app_config.hpp
index 469c4592540..c42fecc76f7 100644
--- a/trunk/src/app/srs_app_config.hpp
+++ b/trunk/src/app/srs_app_config.hpp
@@ -653,40 +653,43 @@ class SrsConfig
     virtual SrsConfDirective* get_forward_backend(std::string vhost);
 
 public:
+    virtual bool is_srt_server(SrsConfDirective* srt_conf);
+    virtual void get_srt_servers(std::vector<SrsConfDirective*>& servers);
     // Whether the srt sevice enabled
     virtual bool get_srt_enabled();
     // Get the srt service listen port
-    virtual unsigned short get_srt_listen_port();
+    virtual unsigned short get_srt_port(SrsConfDirective* srt_conf);
+    virtual std::string get_srt_type(SrsConfDirective* srt_conf);
     // Get the srt SRTO_MAXBW, max bandwith, default is -1.
-    virtual int64_t get_srto_maxbw();
+    virtual int64_t get_srto_maxbw(SrsConfDirective* srt_conf);
     // Get the srt SRTO_MSS, Maximum Segment Size, default is 1500.
-    virtual int get_srto_mss();
+    virtual int get_srto_mss(SrsConfDirective* srt_conf);
     // Get the srt SRTO_TSBPDMODE, timestamp base packet delivery mode, default is false.
-    virtual bool get_srto_tsbpdmode();
+    virtual bool get_srto_tsbpdmode(SrsConfDirective* srt_conf);
     // Get the srt SRTO_LATENCY, latency, default is 0 which means peer/recv latency is 120ms.
-    virtual int get_srto_latency();
+    virtual int get_srto_latency(SrsConfDirective* srt_conf);
     // Get the srt SRTO_RCVLATENCY, recv latency, default is 120ms.
-    virtual int get_srto_recv_latency();
+    virtual int get_srto_recv_latency(SrsConfDirective* srt_conf);
     // Get the srt SRTO_PEERLATENCY, peer latency, default is 0..
-    virtual int get_srto_peer_latency();
+    virtual int get_srto_peer_latency(SrsConfDirective* srt_conf);
     // Get the srt h264 sei filter, default is on, it will drop h264 sei packet.
-    virtual bool get_srt_sei_filter();
+    virtual bool get_srt_sei_filter(SrsConfDirective* srt_conf);
     // Get the srt SRTO_TLPKTDROP, Too-late Packet Drop, default is true.
-    virtual bool get_srto_tlpktdrop();
+    virtual bool get_srto_tlpktdrop(SrsConfDirective* srt_conf);
     // Get the srt SRTO_CONNTIMEO, connection timeout, default is 3000ms.
-    virtual srs_utime_t get_srto_conntimeout();
+    virtual srs_utime_t get_srto_conntimeout(SrsConfDirective* srt_conf);
     // Get the srt SRTO_PEERIDLETIMEO, peer idle timeout, default is 10000ms.
-    virtual srs_utime_t get_srto_peeridletimeout();
+    virtual srs_utime_t get_srto_peeridletimeout(SrsConfDirective* srt_conf);
     // Get the srt SRTO_SNDBUF, send buffer, default is 8192 × (1500-28).
-    virtual int get_srto_sendbuf();
+    virtual int get_srto_sendbuf(SrsConfDirective* srt_conf);
     // Get the srt SRTO_RCVBUF, recv buffer, default is 8192 × (1500-28).
-    virtual int get_srto_recvbuf();
+    virtual int get_srto_recvbuf(SrsConfDirective* srt_conf);
     // SRTO_PAYLOADSIZE
-    virtual int get_srto_payloadsize();
+    virtual int get_srto_payloadsize(SrsConfDirective* srt_conf);
     // Get the srt SRTO_PASSPHRASE, default is empty.
-    virtual std::string get_srto_passphrase();
+    virtual std::string get_srto_passphrase(SrsConfDirective* srt_conf);
     // Get the srt SRTO_PBKEYLEN, default is 0.
-    virtual int get_srto_pbkeylen();
+    virtual int get_srto_pbkeylen(SrsConfDirective* srt_conf);
     // Get the default app.
     virtual std::string get_default_app_name();
 private:
diff --git a/trunk/src/app/srs_app_srt_conn.cpp b/trunk/src/app/srs_app_srt_conn.cpp
index d3bc88aa235..62a1aec77eb 100644
--- a/trunk/src/app/srs_app_srt_conn.cpp
+++ b/trunk/src/app/srs_app_srt_conn.cpp
@@ -152,7 +152,7 @@ srs_error_t SrsSrtRecvThread::get_recv_err()
     return srs_error_copy(recv_err_);
 }
 
-SrsMpegtsSrtConn::SrsMpegtsSrtConn(SrsSrtServer* srt_server, srs_srt_t srt_fd, std::string ip, int port)
+SrsMpegtsSrtConn::SrsMpegtsSrtConn(SrsSrtServer* srt_server, srs_srt_t srt_fd, std::string ip, int port, enum SrtMode mode)
 {
     // Create a identify for this client.
     _srs_context->set_id(_srs_context->generate_id());
@@ -163,6 +163,7 @@ SrsMpegtsSrtConn::SrsMpegtsSrtConn(SrsSrtServer* srt_server, srs_srt_t srt_fd, s
     srt_conn_ = new SrsSrtConnection(srt_fd_);
     ip_ = ip;
     port_ = port;
+    mode_ = mode;
 
     kbps_ = new SrsNetworkKbps();
     kbps_->set_io(srt_conn_, srt_conn_);
@@ -264,11 +265,14 @@ srs_error_t SrsMpegtsSrtConn::do_cycle()
     }
 
     // Detect streamid of srt to request.
-    SrtMode mode = SrtModePull;
+    SrtMode mode = SrtModeUnkown;
     if (!srs_srt_streamid_to_request(streamid, mode, req_)) {
         return srs_error_new(ERROR_SRT_CONN, "invalid srt streamid=%s", streamid.c_str());
     }
 
+    if (mode == SrtModeUnkown) {
+        mode = mode_;
+    }
     // discovery vhost, resolve the vhost from config
     SrsConfDirective* parsed_vhost = _srs_config->get_vhost(req_->vhost);
     if (parsed_vhost) {
@@ -279,8 +283,9 @@ srs_error_t SrsMpegtsSrtConn::do_cycle()
         return srs_error_new(ERROR_SRT_CONN, "srt disabled, vhost=%s", req_->vhost.c_str());
     }
 
-    srs_trace("@srt, streamid=%s, stream_url=%s, vhost=%s, app=%s, stream=%s, param=%s",
-              streamid.c_str(), req_->get_stream_url().c_str(), req_->vhost.c_str(), req_->app.c_str(), req_->stream.c_str(), req_->param.c_str());
+    srs_trace("@srt, streamid=%s, mode:%s, stream_url=%s, vhost=%s, app=%s, stream=%s, param=%s",
+              streamid.c_str(), SrtMode2String(mode).c_str(), req_->get_stream_url().c_str(),
+              req_->vhost.c_str(), req_->app.c_str(), req_->stream.c_str(), req_->param.c_str());
 
     if ((err = _srs_srt_sources->fetch_or_create(req_, &srt_source_)) != srs_success) {
         return srs_error_wrap(err, "fetch srt source");
diff --git a/trunk/src/app/srs_app_srt_conn.hpp b/trunk/src/app/srs_app_srt_conn.hpp
index d651659f296..4e1388e90d2 100644
--- a/trunk/src/app/srs_app_srt_conn.hpp
+++ b/trunk/src/app/srs_app_srt_conn.hpp
@@ -74,7 +74,7 @@ class SrsSrtRecvThread : public ISrsCoroutineHandler
 class SrsMpegtsSrtConn : public ISrsConnection, public ISrsStartable, public ISrsCoroutineHandler, public ISrsExpire
 {
 public:
-    SrsMpegtsSrtConn(SrsSrtServer* srt_server, srs_srt_t srt_fd, std::string ip, int port);
+    SrsMpegtsSrtConn(SrsSrtServer* srt_server, srs_srt_t srt_fd, std::string ip, int port, enum SrtMode mode);
     virtual ~SrsMpegtsSrtConn();
 // Interface ISrsResource.
 public:
@@ -119,6 +119,7 @@ class SrsMpegtsSrtConn : public ISrsConnection, public ISrsStartable, public ISr
     SrsNetworkKbps* kbps_;
     std::string ip_;
     int port_;
+    enum SrtMode mode_;
     SrsCoroutine* trd_;
 
     SrsRequest* req_;
diff --git a/trunk/src/app/srs_app_srt_server.cpp b/trunk/src/app/srs_app_srt_server.cpp
index 5f0635e405e..b65c8bbbd34 100644
--- a/trunk/src/app/srs_app_srt_server.cpp
+++ b/trunk/src/app/srs_app_srt_server.cpp
@@ -19,11 +19,13 @@ using namespace std;
 SrsSrtEventLoop* _srt_eventloop = NULL;
 #endif
 
-SrsSrtAcceptor::SrsSrtAcceptor(SrsSrtServer* srt_server)
+SrsSrtAcceptor::SrsSrtAcceptor(SrsSrtServer* srt_server, enum SrtMode mode, SrsConfDirective* srt_conf)
 {
+    srt_conf_ = srt_conf;
     port_ = 0;
     srt_server_ = srt_server;
     listener_ = NULL;
+    mode_ = mode;
 }
 
 SrsSrtAcceptor::~SrsSrtAcceptor()
@@ -56,7 +58,8 @@ srs_error_t SrsSrtAcceptor::listen(std::string ip, int port)
         return srs_error_wrap(err, "message srt acceptor");
     }
 
-    srs_trace("srt listen at udp://%s:%d, fd=%d", ip_.c_str(), port_, listener_->fd());
+    srs_trace("srt listen at udp://%s:%d, fd=%d, mode:%s",
+            ip_.c_str(), port_, listener_->fd(), SrtMode2String(mode_).c_str());
 
     return err;
 }
@@ -65,61 +68,61 @@ srs_error_t SrsSrtAcceptor::set_srt_opt()
 {
     srs_error_t err = srs_success;
 
-    if ((err = srs_srt_set_maxbw(listener_->fd(), _srs_config->get_srto_maxbw())) != srs_success) {
-        return srs_error_wrap(err, "set opt maxbw=%" PRId64 " failed", _srs_config->get_srto_maxbw());
+    if ((err = srs_srt_set_maxbw(listener_->fd(), _srs_config->get_srto_maxbw(srt_conf_))) != srs_success) {
+        return srs_error_wrap(err, "set opt maxbw=%" PRId64 " failed", _srs_config->get_srto_maxbw(srt_conf_));
     }
 
-    if ((err = srs_srt_set_mss(listener_->fd(), _srs_config->get_srto_mss())) != srs_success) {
-        return srs_error_wrap(err, "set opt mss=%d failed", _srs_config->get_srto_mss());
+    if ((err = srs_srt_set_mss(listener_->fd(), _srs_config->get_srto_mss(srt_conf_))) != srs_success) {
+        return srs_error_wrap(err, "set opt mss=%d failed", _srs_config->get_srto_mss(srt_conf_));
     }
 
-    if ((err = srs_srt_set_tsbpdmode(listener_->fd(), _srs_config->get_srto_tsbpdmode())) != srs_success) {
-        return srs_error_wrap(err, "set opt tsbpdmode=%d failed", _srs_config->get_srto_tsbpdmode());
+    if ((err = srs_srt_set_tsbpdmode(listener_->fd(), _srs_config->get_srto_tsbpdmode(srt_conf_))) != srs_success) {
+        return srs_error_wrap(err, "set opt tsbpdmode=%d failed", _srs_config->get_srto_tsbpdmode(srt_conf_));
     }
 
-    if ((err = srs_srt_set_latency(listener_->fd(), _srs_config->get_srto_latency())) != srs_success) {
-        return srs_error_wrap(err, "set opt latency=%d failed", _srs_config->get_srto_latency());
+    if ((err = srs_srt_set_latency(listener_->fd(), _srs_config->get_srto_latency(srt_conf_))) != srs_success) {
+        return srs_error_wrap(err, "set opt latency=%d failed", _srs_config->get_srto_latency(srt_conf_));
     }
 
-    if ((err = srs_srt_set_rcv_latency(listener_->fd(), _srs_config->get_srto_recv_latency())) != srs_success) {
-        return srs_error_wrap(err, "set opt recvlatency=%d failed", _srs_config->get_srto_recv_latency());
+    if ((err = srs_srt_set_rcv_latency(listener_->fd(), _srs_config->get_srto_recv_latency(srt_conf_))) != srs_success) {
+        return srs_error_wrap(err, "set opt recvlatency=%d failed", _srs_config->get_srto_recv_latency(srt_conf_));
     }
 
-    if ((err = srs_srt_set_peer_latency(listener_->fd(), _srs_config->get_srto_peer_latency())) != srs_success) {
-        return srs_error_wrap(err, "set opt peerlatency=%d failed", _srs_config->get_srto_peer_latency());
+    if ((err = srs_srt_set_peer_latency(listener_->fd(), _srs_config->get_srto_peer_latency(srt_conf_))) != srs_success) {
+        return srs_error_wrap(err, "set opt peerlatency=%d failed", _srs_config->get_srto_peer_latency(srt_conf_));
     }
 
-    if ((err = srs_srt_set_tlpktdrop(listener_->fd(), _srs_config->get_srto_tlpktdrop())) != srs_success) {
-        return srs_error_wrap(err, "set opt tlpktdrop=%d failed", _srs_config->get_srto_tlpktdrop());
+    if ((err = srs_srt_set_tlpktdrop(listener_->fd(), _srs_config->get_srto_tlpktdrop(srt_conf_))) != srs_success) {
+        return srs_error_wrap(err, "set opt tlpktdrop=%d failed", _srs_config->get_srto_tlpktdrop(srt_conf_));
     }
 
-    if ((err = srs_srt_set_connect_timeout(listener_->fd(), srsu2msi(_srs_config->get_srto_conntimeout()))) != srs_success) {
-        return srs_error_wrap(err, "set opt connect_timeout=%d failed", _srs_config->get_srto_conntimeout());
+    if ((err = srs_srt_set_connect_timeout(listener_->fd(), srsu2msi(_srs_config->get_srto_conntimeout(srt_conf_)))) != srs_success) {
+        return srs_error_wrap(err, "set opt connect_timeout=%d failed", _srs_config->get_srto_conntimeout(srt_conf_));
     }
 
-    if ((err = srs_srt_set_peer_idle_timeout(listener_->fd(), srsu2msi(_srs_config->get_srto_peeridletimeout()))) != srs_success) {
-        return srs_error_wrap(err, "set opt peer_idle_timeout=%d failed", _srs_config->get_srto_peeridletimeout());
+    if ((err = srs_srt_set_peer_idle_timeout(listener_->fd(), srsu2msi(_srs_config->get_srto_peeridletimeout(srt_conf_)))) != srs_success) {
+        return srs_error_wrap(err, "set opt peer_idle_timeout=%d failed", _srs_config->get_srto_peeridletimeout(srt_conf_));
     }
 
-    if ((err = srs_srt_set_sndbuf(listener_->fd(), _srs_config->get_srto_sendbuf())) != srs_success) {
-        return srs_error_wrap(err, "set opt sendbuf=%d failed", _srs_config->get_srto_sendbuf());
+    if ((err = srs_srt_set_sndbuf(listener_->fd(), _srs_config->get_srto_sendbuf(srt_conf_))) != srs_success) {
+        return srs_error_wrap(err, "set opt sendbuf=%d failed", _srs_config->get_srto_sendbuf(srt_conf_));
     }
 
-    if ((err = srs_srt_set_rcvbuf(listener_->fd(), _srs_config->get_srto_recvbuf())) != srs_success) {
-        return srs_error_wrap(err, "set opt recvbuf=%d failed", _srs_config->get_srto_recvbuf());
+    if ((err = srs_srt_set_rcvbuf(listener_->fd(), _srs_config->get_srto_recvbuf(srt_conf_))) != srs_success) {
+        return srs_error_wrap(err, "set opt recvbuf=%d failed", _srs_config->get_srto_recvbuf(srt_conf_));
     }
 
-    if ((err = srs_srt_set_payload_size(listener_->fd(), _srs_config->get_srto_payloadsize())) != srs_success) {
-        return srs_error_wrap(err, "set opt payload_size=%d failed", _srs_config->get_srto_payloadsize());
+    if ((err = srs_srt_set_payload_size(listener_->fd(), _srs_config->get_srto_payloadsize(srt_conf_))) != srs_success) {
+        return srs_error_wrap(err, "set opt payload_size=%d failed", _srs_config->get_srto_payloadsize(srt_conf_));
     }
 
-    string passphrase = _srs_config->get_srto_passphrase();
+    string passphrase = _srs_config->get_srto_passphrase(srt_conf_);
     if (! passphrase.empty()) {
         if ((err = srs_srt_set_passphrase(listener_->fd(), passphrase)) != srs_success) {
             return srs_error_wrap(err, "set opt passphrase=%s failed", passphrase.c_str());
         }
 
-        int pbkeylen = _srs_config->get_srto_pbkeylen();
+        int pbkeylen = _srs_config->get_srto_pbkeylen(srt_conf_);
         if ((err = srs_srt_set_pbkeylen(listener_->fd(), pbkeylen)) != srs_success) {
             return srs_error_wrap(err, "set opt pbkeylen=%d failed", pbkeylen);
         }
@@ -133,7 +136,7 @@ srs_error_t SrsSrtAcceptor::on_srt_client(srs_srt_t srt_fd)
     srs_error_t err = srs_success;
 
     // Notify srt server to accept srt client, and create new SrsSrtConn on it.
-    if ((err = srt_server_->accept_srt_client(srt_fd)) != srs_success) {
+    if ((err = srt_server_->accept_srt_client(srt_fd, mode_)) != srs_success) {
         srs_warn("accept srt client failed, err is %s", srs_error_desc(err).c_str());
         srs_freep(err);
     }
@@ -188,6 +191,7 @@ srs_error_t SrsSrtServer::listen_srt_mpegts()
 {
     srs_error_t err = srs_success;
 
+    srs_trace("srt enable:%s", _srs_config->get_srt_enabled() ? "true" : "false");
     if (! _srs_config->get_srt_enabled()) {
         return err;
     }
@@ -195,15 +199,31 @@ srs_error_t SrsSrtServer::listen_srt_mpegts()
     // Close all listener for SRT if exists.
     close_listeners();
 
-    // Start a listener for SRT, we might need multiple listeners in the future.
-    SrsSrtAcceptor* acceptor = new SrsSrtAcceptor(this);
-    acceptors_.push_back(acceptor);
+    std::vector<SrsConfDirective*> srt_conf_vec;
 
-    int port; string ip;
-    srs_parse_endpoint(srs_int2str(_srs_config->get_srt_listen_port()), ip, port);
+    _srs_config->get_srt_servers(srt_conf_vec);
 
-    if ((err = acceptor->listen(ip, port)) != srs_success) {
-        return srs_error_wrap(err, "srt listen %s:%d", ip.c_str(), port);
+    for (auto srt_conf : srt_conf_vec) {
+        std::string srt_type = _srs_config->get_srt_type(srt_conf);
+        int port;
+        std::string ip;
+        enum SrtMode srt_mode = SrtModePush;
+
+        srs_parse_endpoint(srs_int2str(_srs_config->get_srt_port(srt_conf)), ip, port);
+        if (srt_type == "pull") {
+            srt_mode = SrtModePull;
+        } else {
+            srt_mode = SrtModePush;
+        }
+
+        SrsSrtAcceptor* acceptor = new SrsSrtAcceptor(this, srt_mode, srt_conf);
+        acceptors_.push_back(acceptor);
+        
+        if ((err =  acceptor->listen(ip, port)) != srs_success) {
+            return srs_error_wrap(err, "srt %s listen %s:%d",
+                            srt_mode == SrtModePull ? "pull" : "push",
+                            ip.c_str(), port);
+        }
     }
 
     return err;
@@ -220,12 +240,12 @@ void SrsSrtServer::close_listeners()
     }
 }
 
-srs_error_t SrsSrtServer::accept_srt_client(srs_srt_t srt_fd)
+srs_error_t SrsSrtServer::accept_srt_client(srs_srt_t srt_fd, enum SrtMode mode)
 {
     srs_error_t err = srs_success;
 
     ISrsResource* resource = NULL;
-    if ((err = fd_to_resource(srt_fd, &resource)) != srs_success) {
+    if ((err = fd_to_resource(srt_fd, mode, &resource)) != srs_success) {
         //close fd on conn error, otherwise will lead to fd leak -gs
         // TODO: FIXME: Handle error.
         srs_srt_close(srt_fd);
@@ -244,7 +264,7 @@ srs_error_t SrsSrtServer::accept_srt_client(srs_srt_t srt_fd)
     return err;
 }
 
-srs_error_t SrsSrtServer::fd_to_resource(srs_srt_t srt_fd, ISrsResource** pr)
+srs_error_t SrsSrtServer::fd_to_resource(srs_srt_t srt_fd, enum SrtMode mode, ISrsResource** pr)
 {
     srs_error_t err = srs_success;
     
@@ -260,7 +280,7 @@ srs_error_t SrsSrtServer::fd_to_resource(srs_srt_t srt_fd, ISrsResource** pr)
     SrsContextRestore(_srs_context->get_id());
 
     // Covert to SRT conection.
-    *pr = new SrsMpegtsSrtConn(this, srt_fd, ip, port);
+    *pr = new SrsMpegtsSrtConn(this, srt_fd, ip, port, mode);
     
     return err;
 }
diff --git a/trunk/src/app/srs_app_srt_server.hpp b/trunk/src/app/srs_app_srt_server.hpp
index 23332d70295..c1ddbc041d0 100644
--- a/trunk/src/app/srs_app_srt_server.hpp
+++ b/trunk/src/app/srs_app_srt_server.hpp
@@ -12,6 +12,7 @@
 #include <srs_protocol_srt.hpp>
 #include <srs_app_server.hpp>
 #include <srs_app_srt_listener.hpp>
+#include <srs_app_srt_utility.hpp>
 
 class SrsSrtServer;
 class SrsHourGlass;
@@ -20,13 +21,15 @@ class SrsHourGlass;
 class SrsSrtAcceptor : public ISrsSrtHandler
 {
 private:
+    SrsConfDirective* srt_conf_;
     std::string ip_;
     int port_;
+    enum SrtMode mode_;
     SrsSrtServer* srt_server_;
 private:
     SrsSrtListener* listener_;
 public:
-    SrsSrtAcceptor(SrsSrtServer* srt_server);
+    SrsSrtAcceptor(SrsSrtServer* srt_server, enum SrtMode mode, SrsConfDirective* srt_conf);
     virtual ~SrsSrtAcceptor();
 public:
     virtual srs_error_t listen(std::string ip, int port);
@@ -60,9 +63,9 @@ class SrsSrtServer : public ISrsResourceManager, public ISrsHourGlass
 public:
     // When listener got a fd, notice server to accept it.
     // @param srt_fd, the client fd in srt boxed, the underlayer fd.
-    virtual srs_error_t accept_srt_client(srs_srt_t srt_fd);
+    virtual srs_error_t accept_srt_client(srs_srt_t srt_fd, enum SrtMode mode);
 private:
-    virtual srs_error_t fd_to_resource(srs_srt_t srt_fd, ISrsResource** pr);
+    virtual srs_error_t fd_to_resource(srs_srt_t srt_fd, enum SrtMode mode, ISrsResource** pr);
 // Interface ISrsResourceManager
 public:
     // A callback for connection to remove itself.
diff --git a/trunk/src/app/srs_app_srt_utility.cpp b/trunk/src/app/srs_app_srt_utility.cpp
index 28a26834f32..f46fe94d475 100644
--- a/trunk/src/app/srs_app_srt_utility.cpp
+++ b/trunk/src/app/srs_app_srt_utility.cpp
@@ -20,7 +20,7 @@ using namespace std;
 // TODO: FIMXE: We should parse SRT streamid to URL object, rather than a HTTP url subpath.
 bool srs_srt_streamid_info(const std::string& streamid, SrtMode& mode, std::string& vhost, std::string& url_subpath)
 {
-    mode = SrtModePull;
+    mode = SrtModeUnkown;
 
     size_t pos = streamid.find("#!::");
     if (pos != 0) {
@@ -89,6 +89,7 @@ bool srs_srt_streamid_info(const std::string& streamid, SrtMode& mode, std::stri
             }  else if (mode_str == "request") {
                 mode = SrtModePull;
             }  else {
+                mode = SrtModeUnkown;
                 srs_warn("unknown mode_str:%s", mode_str.c_str());
                 return false;
             }
@@ -145,3 +146,15 @@ bool srs_srt_streamid_to_request(const std::string& streamid, SrtMode& mode, Srs
 
     return ret;
 }
+
+std::string SrtMode2String(enum SrtMode mode) {
+    if (mode == SrtModePull) {
+        return "srtPull";
+    }
+    
+    if (mode == SrtModePush) {
+        return "srtPush";
+    }
+
+    return "unkown";
+}
diff --git a/trunk/src/app/srs_app_srt_utility.hpp b/trunk/src/app/srs_app_srt_utility.hpp
index 74d2a912512..99806cb0b4f 100644
--- a/trunk/src/app/srs_app_srt_utility.hpp
+++ b/trunk/src/app/srs_app_srt_utility.hpp
@@ -18,8 +18,9 @@ class SrsRequest;
 
 enum SrtMode 
 {
-    SrtModePull = 1,
-    SrtModePush = 2,
+    SrtModeUnkown = 0,
+    SrtModePull   = 1,
+    SrtModePush   = 2,
 };
 
 // Get SRT streamid info.
@@ -28,5 +29,6 @@ extern bool srs_srt_streamid_info(const std::string& streamid, SrtMode& mode, st
 // SRT streamid to request.
 extern bool srs_srt_streamid_to_request(const std::string& streamid, SrtMode& mode, SrsRequest* request);
 
+extern std::string SrtMode2String(enum SrtMode mode);
 #endif
 
diff --git a/trunk/src/utest/srs_utest_config.cpp b/trunk/src/utest/srs_utest_config.cpp
index ebc0d4a04a9..b990b2447ca 100644
--- a/trunk/src/utest/srs_utest_config.cpp
+++ b/trunk/src/utest/srs_utest_config.cpp
@@ -3921,20 +3921,27 @@ VOID TEST(ConfigMainTest, SrtServerTlpktDrop)
 
     if (true) {
         MockSrsConfig conf;
+
         HELPER_ASSERT_SUCCESS(conf.parse(_MIN_OK_CONF));
-        EXPECT_TRUE(conf.get_srto_tlpktdrop());
+        EXPECT_TRUE(conf.get_srto_tlpktdrop(nullptr));
     }
 
     if (true) {
         MockSrsConfig conf;
+
         HELPER_ASSERT_SUCCESS(conf.parse(_MIN_OK_CONF "srt_server{tlpktdrop off;}"));
-        EXPECT_FALSE(conf.get_srto_tlpktdrop());
+        std::vector<SrsConfDirective*> srt_server_confs;
+        conf.get_srt_servers(srt_server_confs);
+        EXPECT_FALSE(conf.get_srto_tlpktdrop(srt_server_confs[0]));
     }
 
     if (true) {
         MockSrsConfig conf;
+
         HELPER_ASSERT_SUCCESS(conf.parse(_MIN_OK_CONF "srt_server{tlpkdrop off;}"));
-        EXPECT_FALSE(conf.get_srto_tlpktdrop());
+        std::vector<SrsConfDirective*> srt_server_confs;
+        conf.get_srt_servers(srt_server_confs);
+        EXPECT_FALSE(conf.get_srto_tlpktdrop(srt_server_confs[0]));
     }
 }
 
@@ -4197,49 +4204,49 @@ VOID TEST(ConfigEnvTest, CheckEnvValuesSrtServer)
         EXPECT_TRUE(conf.get_srt_enabled());
 
         SrsSetEnvConfig(srt_listen_port, "SRS_SRT_SERVER_LISTEN", "10000");
-        EXPECT_EQ(10000, conf.get_srt_listen_port());
+        EXPECT_EQ(10000, conf.get_srt_port(nullptr));
 
         SrsSetEnvConfig(srto_maxbw, "SRS_SRT_SERVER_MAXBW", "1000000000");
-        EXPECT_EQ(1000000000, conf.get_srto_maxbw());
+        EXPECT_EQ(1000000000, conf.get_srto_maxbw(nullptr));
 
         SrsSetEnvConfig(srto_mss, "SRS_SRT_SERVER_MMS", "1000");
-        EXPECT_EQ(1000, conf.get_srto_mss());
+        EXPECT_EQ(1000, conf.get_srto_mss(nullptr));
 
         SrsSetEnvConfig(srto_conntimeout, "SRS_SRT_SERVER_CONNECT_TIMEOUT", "2000");
-        EXPECT_EQ(2000 * SRS_UTIME_MILLISECONDS, conf.get_srto_conntimeout());
+        EXPECT_EQ(2000 * SRS_UTIME_MILLISECONDS, conf.get_srto_conntimeout(nullptr));
 
         SrsSetEnvConfig(srto_peeridletimeout, "SRS_SRT_SERVER_PEER_IDLE_TIMEOUT", "2000");
-        EXPECT_EQ(2000 * SRS_UTIME_MILLISECONDS, conf.get_srto_peeridletimeout());
+        EXPECT_EQ(2000 * SRS_UTIME_MILLISECONDS, conf.get_srto_peeridletimeout(nullptr));
 
         SrsSetEnvConfig(default_app_name, "SRS_SRT_SERVER_DEFAULT_APP", "xxx");
         EXPECT_STREQ("xxx", conf.get_default_app_name().c_str());
 
         SrsSetEnvConfig(srto_peer_latency, "SRS_SRT_SERVER_PEERLATENCY", "1");
-        EXPECT_EQ(1, conf.get_srto_peer_latency());
+        EXPECT_EQ(1, conf.get_srto_peer_latency(nullptr));
 
         SrsSetEnvConfig(srto_recv_latency, "SRS_SRT_SERVER_RECVLATENCY", "100");
-        EXPECT_EQ(100, conf.get_srto_recv_latency());
+        EXPECT_EQ(100, conf.get_srto_recv_latency(nullptr));
 
         SrsSetEnvConfig(srto_latency, "SRS_SRT_SERVER_LATENCY", "100");
-        EXPECT_EQ(100, conf.get_srto_latency());
+        EXPECT_EQ(100, conf.get_srto_latency(nullptr));
 
         SrsSetEnvConfig(srto_tsbpdmode, "SRS_SRT_SERVER_TSBPDMODE", "off");
-        EXPECT_FALSE(conf.get_srto_tsbpdmode());
+        EXPECT_FALSE(conf.get_srto_tsbpdmode(nullptr));
 
         SrsSetEnvConfig(srto_tlpktdrop, "SRS_SRT_SERVER_TLPKTDROP", "off");
-        EXPECT_FALSE(conf.get_srto_tlpktdrop());
+        EXPECT_FALSE(conf.get_srto_tlpktdrop(nullptr));
 
         SrsSetEnvConfig(srto_sendbuf, "SRS_SRT_SERVER_SENDBUF", "2100000");
-        EXPECT_EQ(2100000, conf.get_srto_sendbuf());
+        EXPECT_EQ(2100000, conf.get_srto_sendbuf(nullptr));
 
         SrsSetEnvConfig(srto_recvbuf, "SRS_SRT_SERVER_RECVBUF", "2100000");
-        EXPECT_EQ(2100000, conf.get_srto_recvbuf());
+        EXPECT_EQ(2100000, conf.get_srto_recvbuf(nullptr));
 
         SrsSetEnvConfig(srto_passphrase, "SRS_SRT_SERVER_PASSPHRASE", "xxx2");
-        EXPECT_STREQ("xxx2", conf.get_srto_passphrase().c_str());
+        EXPECT_STREQ("xxx2", conf.get_srto_passphrase(nullptr).c_str());
 
         SrsSetEnvConfig(srto_pbkeylen, "SRS_SRT_SERVER_PBKEYLEN", "16");
-        EXPECT_EQ(16, conf.get_srto_pbkeylen());
+        EXPECT_EQ(16, conf.get_srto_pbkeylen(nullptr));
     }
 }
 
diff --git a/trunk/src/utest/srs_utest_srt.cpp b/trunk/src/utest/srs_utest_srt.cpp
index dc9b154b2c9..779f479dd7e 100644
--- a/trunk/src/utest/srs_utest_srt.cpp
+++ b/trunk/src/utest/srs_utest_srt.cpp
@@ -203,12 +203,14 @@ VOID TEST(ServiceStSRTTest, ListenConnectAccept)
     // Make utest fast timeout.
     srt_server.srt_socket_->set_recv_timeout(50 * SRS_UTIME_MILLISECONDS);
     err = srt_server.accept(&srt_fd);
+
     EXPECT_EQ(srs_error_code(err), ERROR_SRT_TIMEOUT);
     EXPECT_EQ(srt_fd, srs_srt_socket_invalid());
     srs_freep(err);
 
     // Client connect to server
-    HELPER_EXPECT_SUCCESS(srt_client_socket->connect(server_ip, server_port));
+    err = srt_client_socket->connect(server_ip, server_port);
+    HELPER_EXPECT_SUCCESS(err);
 
     // Server will accept one client.
     HELPER_EXPECT_SUCCESS(srt_server.accept(&srt_fd));
@@ -352,7 +354,7 @@ VOID TEST(ProtocolSrtTest, SrtGetStreamInfoNormal)
 {
     if (true) {
         SrtMode mode; string vhost; string subpath;
-        EXPECT_TRUE(srs_srt_streamid_info("#!::r=live/livestream,key1=value1,key2=value2", mode, vhost, subpath));
+        EXPECT_TRUE(srs_srt_streamid_info("#!::r=live/livestream,key1=value1,key2=value2,m=request", mode, vhost, subpath));
         EXPECT_EQ(SrtModePull, mode);
         EXPECT_STREQ("", vhost.c_str());
         EXPECT_STREQ("live/livestream?key1=value1&key2=value2", subpath.c_str());
@@ -360,7 +362,7 @@ VOID TEST(ProtocolSrtTest, SrtGetStreamInfoNormal)
 
     if (true) {
         SrtMode mode; string vhost; string subpath;
-        EXPECT_TRUE(srs_srt_streamid_info("#!::h=host.com,r=live/livestream,key1=value1,key2=value2", mode, vhost, subpath));
+        EXPECT_TRUE(srs_srt_streamid_info("#!::h=host.com,r=live/livestream,key1=value1,key2=value2,m=request", mode, vhost, subpath));
         EXPECT_EQ(SrtModePull, mode);
         EXPECT_STREQ("host.com", vhost.c_str());
         EXPECT_STREQ("live/livestream?vhost=host.com&key1=value1&key2=value2", subpath.c_str());
@@ -432,7 +434,7 @@ VOID TEST(ProtocolSrtTest, SrtStreamIdToRequest)
     if (true) {
         SrtMode mode;
         SrsRequest req;
-        EXPECT_TRUE(srs_srt_streamid_to_request("#!::r=live/livestream?key1=val1,key2=val2", mode, &req));
+        EXPECT_TRUE(srs_srt_streamid_to_request("#!::r=live/livestream?key1=val1,key2=val2,m=request", mode, &req));
         EXPECT_EQ(mode, SrtModePull);
         EXPECT_STREQ(req.vhost.c_str(), srs_get_public_internet_address().c_str());
         EXPECT_STREQ(req.app.c_str(), "live");
@@ -443,7 +445,7 @@ VOID TEST(ProtocolSrtTest, SrtStreamIdToRequest)
     if (true) {
         SrtMode mode;
         SrsRequest req;
-        EXPECT_TRUE(srs_srt_streamid_to_request("#!::h=srs.srt.com.cn,r=live/livestream?key1=val1,key2=val2", mode, &req));
+        EXPECT_TRUE(srs_srt_streamid_to_request("#!::h=srs.srt.com.cn,r=live/livestream?key1=val1,key2=val2,m=request", mode, &req));
         EXPECT_EQ(mode, SrtModePull);
         EXPECT_STREQ(req.vhost.c_str(), "srs.srt.com.cn");
         EXPECT_STREQ(req.app.c_str(), "live");
@@ -454,7 +456,7 @@ VOID TEST(ProtocolSrtTest, SrtStreamIdToRequest)
     if (true) {
         SrtMode mode;
         SrsRequest req;
-        EXPECT_TRUE(srs_srt_streamid_to_request("#!::h=live/livestream?key1=val1,key2=val2", mode, &req));
+        EXPECT_TRUE(srs_srt_streamid_to_request("#!::h=live/livestream?key1=val1,key2=val2,m=request", mode, &req));
         EXPECT_EQ(mode, SrtModePull);
         EXPECT_STREQ(req.vhost.c_str(), srs_get_public_internet_address().c_str());
         EXPECT_STREQ(req.app.c_str(), "live");
@@ -465,7 +467,7 @@ VOID TEST(ProtocolSrtTest, SrtStreamIdToRequest)
     if (true) {
         SrtMode mode;
         SrsRequest req;
-        EXPECT_TRUE(srs_srt_streamid_to_request("#!::h=srs.srt.com.cn/live/livestream?key1=val1,key2=val2", mode, &req));
+        EXPECT_TRUE(srs_srt_streamid_to_request("#!::h=srs.srt.com.cn/live/livestream?key1=val1,key2=val2,m=request", mode, &req));
         EXPECT_EQ(mode, SrtModePull);
         EXPECT_STREQ(req.vhost.c_str(), "srs.srt.com.cn");
         EXPECT_STREQ(req.app.c_str(), "live");