For #907, Wrap ST, only use in service ST.

trunk/src/service/srs_service_log.cpp

@@ -25,6 +25,7 @@
 
 #include <stdarg.h>
 #include <sys/time.h>
+#include <unistd.h>
 using namespace std;
 
 #include <srs_kernel_error.hpp>
@@ -45,18 +46,18 @@ int SrsThreadContext::generate_id()
     static int id = 100;
     
     int gid = id++;
-    cache[st_thread_self()] = gid;
+    cache[srs_thread_self()] = gid;
     return gid;
 }
 
 int SrsThreadContext::get_id()
 {
-    return cache[st_thread_self()];
+    return cache[srs_thread_self()];
 }
 
 int SrsThreadContext::set_id(int v)
 {
-    st_thread_t self = st_thread_self();
+    srs_thread_t self = srs_thread_self();
     
     int ov = 0;
     if (cache.find(self) != cache.end()) {
@@ -70,8 +71,8 @@ int SrsThreadContext::set_id(int v)
 
 void SrsThreadContext::clear_cid()
 {
-    st_thread_t self = st_thread_self();
-    std::map<st_thread_t, int>::iterator it = cache.find(self);
+    srs_thread_t self = srs_thread_self();
+    std::map<srs_thread_t, int>::iterator it = cache.find(self);
     if (it != cache.end()) {
         cache.erase(it);
     }

trunk/src/service/srs_service_log.hpp

@@ -38,7 +38,7 @@
 class SrsThreadContext : public ISrsThreadContext
 {
 private:
-    std::map<st_thread_t, int> cache;
+    std::map<srs_thread_t, int> cache;
 public:
     SrsThreadContext();
     virtual ~SrsThreadContext();

trunk/src/service/srs_service_rtmp_conn.cpp

@@ -23,6 +23,7 @@
 
 #include <srs_service_rtmp_conn.hpp>
 
+#include <unistd.h>
 using namespace std;
 
 #include <srs_protocol_kbps.hpp>

trunk/src/service/srs_service_st.cpp

@@ -23,6 +23,7 @@
 
 #include <srs_service_st.hpp>
 
+#include <st.h>
 #include <fcntl.h>
 #include <sys/socket.h>
 using namespace std;
@@ -30,6 +31,7 @@ using namespace std;
 #include <srs_kernel_error.hpp>
 #include <srs_kernel_log.hpp>
 #include <srs_service_utility.hpp>
+#include <srs_kernel_utility.hpp>
 
 #ifdef __linux__
 #include <sys/epoll.h>
@@ -80,11 +82,11 @@ int srs_st_init()
     return ret;
 }
 
-void srs_close_stfd(st_netfd_t& stfd)
+void srs_close_stfd(srs_netfd_t& stfd)
 {
     if (stfd) {
         // we must ensure the close is ok.
-        int err = st_netfd_close(stfd);
+        int err = st_netfd_close((st_netfd_t)stfd);
         srs_assert(err != -1);
         stfd = NULL;
     }
@@ -103,6 +105,150 @@ void srs_socket_reuse_addr(int fd)
     setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &v, sizeof(int));
 }
 
+srs_thread_t srs_thread_self()
+{
+    return (srs_thread_t)st_thread_self();
+}
+
+int srs_socket_connect(string server, int port, int64_t tm, srs_netfd_t* pstfd)
+{
+    int ret = ERROR_SUCCESS;
+    
+    st_utime_t timeout = ST_UTIME_NO_TIMEOUT;
+    if (tm != SRS_CONSTS_NO_TMMS) {
+        timeout = (st_utime_t)(tm * 1000);
+    }
+    
+    *pstfd = NULL;
+    srs_netfd_t stfd = NULL;
+    sockaddr_in addr;
+    
+    int sock = socket(AF_INET, SOCK_STREAM, 0);
+    if(sock == -1){
+        ret = ERROR_SOCKET_CREATE;
+        srs_error("create socket error. ret=%d", ret);
+        return ret;
+    }
+    
+    srs_fd_close_exec(sock);
+    
+    srs_assert(!stfd);
+    stfd = st_netfd_open_socket(sock);
+    if(stfd == NULL){
+        ret = ERROR_ST_OPEN_SOCKET;
+        srs_error("st_netfd_open_socket failed. ret=%d", ret);
+        return ret;
+    }
+    
+    // connect to server.
+    std::string ip = srs_dns_resolve(server);
+    if (ip.empty()) {
+        ret = ERROR_SYSTEM_IP_INVALID;
+        srs_error("dns resolve server error, ip empty. ret=%d", ret);
+        goto failed;
+    }
+    
+    addr.sin_family = AF_INET;
+    addr.sin_port = htons(port);
+    addr.sin_addr.s_addr = inet_addr(ip.c_str());
+    
+    if (st_connect((st_netfd_t)stfd, (const struct sockaddr*)&addr, sizeof(sockaddr_in), timeout) == -1){
+        ret = ERROR_ST_CONNECT;
+        srs_error("connect to server error. ip=%s, port=%d, ret=%d", ip.c_str(), port, ret);
+        goto failed;
+    }
+    srs_info("connect ok. server=%s, ip=%s, port=%d", server.c_str(), ip.c_str(), port);
+    
+    *pstfd = stfd;
+    return ret;
+    
+failed:
+    if (stfd) {
+        srs_close_stfd(stfd);
+    }
+    return ret;
+}
+
+srs_cond_t srs_cond_new()
+{
+    return (srs_cond_t)st_cond_new();
+}
+
+int srs_cond_destroy(srs_cond_t cond)
+{
+    return st_cond_destroy((st_cond_t)cond);
+}
+
+int srs_cond_wait(srs_cond_t cond)
+{
+    return st_cond_wait((st_cond_t)cond);
+}
+
+int srs_cond_timedwait(srs_cond_t cond, srs_utime_t timeout)
+{
+    return st_cond_timedwait((st_cond_t)cond, (st_utime_t)timeout);
+}
+
+int srs_cond_signal(srs_cond_t cond)
+{
+    return st_cond_signal((st_cond_t)cond);
+}
+
+srs_mutex_t srs_mutex_new()
+{
+    return (srs_mutex_t)st_mutex_new();
+}
+
+int srs_mutex_destroy(srs_mutex_t mutex)
+{
+    return st_mutex_destroy((st_mutex_t)mutex);
+}
+
+int srs_mutex_lock(srs_mutex_t mutex)
+{
+    return st_mutex_lock((st_mutex_t)mutex);
+}
+
+int srs_mutex_unlock(srs_mutex_t mutex)
+{
+    return st_mutex_unlock((st_mutex_t)mutex);
+}
+
+int srs_netfd_fileno(srs_netfd_t stfd)
+{
+    return st_netfd_fileno((st_netfd_t)stfd);
+}
+
+int srs_usleep(srs_utime_t usecs)
+{
+    return st_usleep((st_utime_t)usecs);
+}
+
+srs_netfd_t srs_netfd_open_socket(int osfd)
+{
+    return (srs_netfd_t)st_netfd_open_socket(osfd);
+}
+
+srs_netfd_t srs_netfd_open(int osfd)
+{
+    return (srs_netfd_t)st_netfd_open(osfd);
+}
+
+int srs_recvfrom(srs_netfd_t stfd, void *buf, int len, struct sockaddr *from, int *fromlen, srs_utime_t timeout)
+{
+    return st_recvfrom((st_netfd_t)stfd, buf, len, from, fromlen, (st_utime_t)timeout);
+}
+
+srs_netfd_t srs_accept(srs_netfd_t stfd, struct sockaddr *addr, int *addrlen, srs_utime_t timeout)
+{
+    return (srs_netfd_t)st_accept((st_netfd_t)stfd, addr, addrlen, (st_utime_t)timeout);
+}
+
+ssize_t srs_read(srs_netfd_t stfd, void *buf, size_t nbyte, srs_utime_t timeout)
+{
+    return st_read((st_netfd_t)stfd, buf, nbyte, (st_utime_t)timeout);
+}
+
 SrsStSocket::SrsStSocket()
 {
     stfd = NULL;
@@ -114,7 +260,7 @@ SrsStSocket::~SrsStSocket()
 {
 }
 
-int SrsStSocket::initialize(st_netfd_t fd)
+int SrsStSocket::initialize(srs_netfd_t fd)
 {
     stfd = fd;
     return ERROR_SUCCESS;
@@ -161,9 +307,9 @@ int SrsStSocket::read(void* buf, size_t size, ssize_t* nread)
     
     ssize_t nb_read;
     if (rtm == SRS_CONSTS_NO_TMMS) {
-        nb_read = st_read(stfd, buf, size, ST_UTIME_NO_TIMEOUT);
+        nb_read = st_read((st_netfd_t)stfd, buf, size, ST_UTIME_NO_TIMEOUT);
     } else {
-        nb_read = st_read(stfd, buf, size, rtm * 1000);
+        nb_read = st_read((st_netfd_t)stfd, buf, size, rtm * 1000);
     }
     
     if (nread) {
@@ -197,9 +343,9 @@ int SrsStSocket::read_fully(void* buf, size_t size, ssize_t* nread)
     
     ssize_t nb_read;
     if (rtm == SRS_CONSTS_NO_TMMS) {
-        nb_read = st_read_fully(stfd, buf, size, ST_UTIME_NO_TIMEOUT);
+        nb_read = st_read_fully((st_netfd_t)stfd, buf, size, ST_UTIME_NO_TIMEOUT);
     } else {
-        nb_read = st_read_fully(stfd, buf, size, rtm * 1000);
+        nb_read = st_read_fully((st_netfd_t)stfd, buf, size, rtm * 1000);
     }
     
     if (nread) {
@@ -233,9 +379,9 @@ int SrsStSocket::write(void* buf, size_t size, ssize_t* nwrite)
     
     ssize_t nb_write;
     if (stm == SRS_CONSTS_NO_TMMS) {
-        nb_write = st_write(stfd, buf, size, ST_UTIME_NO_TIMEOUT);
+        nb_write = st_write((st_netfd_t)stfd, buf, size, ST_UTIME_NO_TIMEOUT);
     } else {
-        nb_write = st_write(stfd, buf, size, stm * 1000);
+        nb_write = st_write((st_netfd_t)stfd, buf, size, stm * 1000);
     }
     
     if (nwrite) {
@@ -264,9 +410,9 @@ int SrsStSocket::writev(const iovec *iov, int iov_size, ssize_t* nwrite)
     
     ssize_t nb_write;
     if (stm == SRS_CONSTS_NO_TMMS) {
-        nb_write = st_writev(stfd, iov, iov_size, ST_UTIME_NO_TIMEOUT);
+        nb_write = st_writev((st_netfd_t)stfd, iov, iov_size, ST_UTIME_NO_TIMEOUT);
     } else {
-        nb_write = st_writev(stfd, iov, iov_size, stm * 1000);
+        nb_write = st_writev((st_netfd_t)stfd, iov, iov_size, stm * 1000);
     }
     
     if (nwrite) {

trunk/src/service/srs_service_st.hpp

@@ -27,16 +27,24 @@
 #include <srs_core.hpp>
 
 #include <string>
-#include <st.h>
 
 #include <srs_protocol_io.hpp>
 
+// Wrap for coroutine.
+typedef void* srs_netfd_t;
+typedef void* srs_thread_t;
+typedef void* srs_cond_t;
+typedef void* srs_mutex_t;
+typedef uint64_t srs_utime_t;
+
+#define SRS_UTIME_NO_TIMEOUT ((srs_utime_t) -1LL)
+
 // initialize st, requires epoll.
 extern int srs_st_init();
 
 // close the netfd, and close the underlayer fd.
 // @remark when close, user must ensure io completed.
-extern void srs_close_stfd(st_netfd_t& stfd);
+extern void srs_close_stfd(srs_netfd_t& stfd);
 
 // Set the FD_CLOEXEC of FD.
 extern void srs_fd_close_exec(int fd);
@@ -44,6 +52,38 @@ extern void srs_fd_close_exec(int fd);
 // Set the SO_REUSEADDR of socket.
 extern void srs_socket_reuse_addr(int fd);
 
+// Get current coroutine/thread.
+extern srs_thread_t srs_thread_self();
+
+// client open socket and connect to server.
+// @param tm The timeout in ms.
+extern int srs_socket_connect(std::string server, int port, int64_t tm, srs_netfd_t* pstfd);
+
+// Wrap for coroutine.
+extern srs_cond_t srs_cond_new();
+extern int srs_cond_destroy(srs_cond_t cond);
+extern int srs_cond_wait(srs_cond_t cond);
+extern int srs_cond_timedwait(srs_cond_t cond, srs_utime_t timeout);
+extern int srs_cond_signal(srs_cond_t cond);
+
+extern srs_mutex_t srs_mutex_new();
+extern int srs_mutex_destroy(srs_mutex_t mutex);
+extern int srs_mutex_lock(srs_mutex_t mutex);
+extern int srs_mutex_unlock(srs_mutex_t mutex);
+
+extern int srs_netfd_fileno(srs_netfd_t stfd);
+
+extern int srs_usleep(srs_utime_t usecs);
+
+extern srs_netfd_t srs_netfd_open_socket(int osfd);
+extern srs_netfd_t srs_netfd_open(int osfd);
+
+extern int srs_recvfrom(srs_netfd_t stfd, void *buf, int len, struct sockaddr *from, int *fromlen, srs_utime_t timeout);
+
+extern srs_netfd_t srs_accept(srs_netfd_t stfd, struct sockaddr *addr, int *addrlen, srs_utime_t timeout);
+
+extern ssize_t srs_read(srs_netfd_t stfd, void *buf, size_t nbyte, srs_utime_t timeout);
+
 /**
  * the socket provides TCP socket over st,
  * that is, the sync socket mechanism.
@@ -59,13 +99,13 @@ private:
     int64_t rbytes;
     int64_t sbytes;
     // The underlayer st fd.
-    st_netfd_t stfd;
+    srs_netfd_t stfd;
 public:
     SrsStSocket();
     virtual ~SrsStSocket();
 public:
     // Initialize the socket with stfd, user must manage it.
-    virtual int initialize(st_netfd_t fd);
+    virtual int initialize(srs_netfd_t fd);
 public:
     virtual bool is_never_timeout(int64_t tm);
     virtual void set_recv_timeout(int64_t tm);
@@ -100,7 +140,7 @@ public:
 class SrsTcpClient : public ISrsProtocolReaderWriter
 {
 private:
-    st_netfd_t stfd;
+    srs_netfd_t stfd;
     SrsStSocket* io;
 private:
     std::string host;

trunk/src/service/srs_service_utility.cpp

@@ -36,65 +36,6 @@ using namespace std;
 #include <srs_kernel_log.hpp>
 #include <srs_kernel_utility.hpp>
 
-int srs_socket_connect(string server, int port, int64_t tm, st_netfd_t* pstfd)
-{
-    int ret = ERROR_SUCCESS;
-    
-    st_utime_t timeout = ST_UTIME_NO_TIMEOUT;
-    if (tm != SRS_CONSTS_NO_TMMS) {
-        timeout = (st_utime_t)(tm * 1000);
-    }
-    
-    *pstfd = NULL;
-    st_netfd_t stfd = NULL;
-    sockaddr_in addr;
-    
-    int sock = socket(AF_INET, SOCK_STREAM, 0);
-    if(sock == -1){
-        ret = ERROR_SOCKET_CREATE;
-        srs_error("create socket error. ret=%d", ret);
-        return ret;
-    }
-    
-    srs_fd_close_exec(sock);
-    
-    srs_assert(!stfd);
-    stfd = st_netfd_open_socket(sock);
-    if(stfd == NULL){
-        ret = ERROR_ST_OPEN_SOCKET;
-        srs_error("st_netfd_open_socket failed. ret=%d", ret);
-        return ret;
-    }
-    
-    // connect to server.
-    std::string ip = srs_dns_resolve(server);
-    if (ip.empty()) {
-        ret = ERROR_SYSTEM_IP_INVALID;
-        srs_error("dns resolve server error, ip empty. ret=%d", ret);
-        goto failed;
-    }
-    
-    addr.sin_family = AF_INET;
-    addr.sin_port = htons(port);
-    addr.sin_addr.s_addr = inet_addr(ip.c_str());
-    
-    if (st_connect(stfd, (const struct sockaddr*)&addr, sizeof(sockaddr_in), timeout) == -1){
-        ret = ERROR_ST_CONNECT;
-        srs_error("connect to server error. ip=%s, port=%d, ret=%d", ip.c_str(), port, ret);
-        goto failed;
-    }
-    srs_info("connect ok. server=%s, ip=%s, port=%d", server.c_str(), ip.c_str(), port);
-    
-    *pstfd = stfd;
-    return ret;
-    
-failed:
-    if (stfd) {
-        srs_close_stfd(stfd);
-    }
-    return ret;
-}
-
 bool srs_string_is_http(string url)
 {
     return srs_string_starts_with(url, "http://", "https://");

trunk/src/service/srs_service_utility.hpp

@@ -32,10 +32,6 @@
 
 #include <srs_service_st.hpp>
 
-// client open socket and connect to server.
-// @param tm The timeout in ms.
-extern int srs_socket_connect(std::string server, int port, int64_t tm, st_netfd_t* pstfd);
-
 // whether the url is starts with http:// or https://
 extern bool srs_string_is_http(std::string url);
 extern bool srs_string_is_rtmp(std::string url);