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

WebRTC: Extract SrsRtcNetwork layer for UDP/TCP.

Browse source
This commit is contained in:
winlin 2022-09-03 11:52:11 +08:00
parent 770d959148
commit 625069af7f
23 changed files with 698 additions and 528 deletions
Download patch file Download diff file Expand all files Collapse all files

2
trunk/src/protocol/srs_protocol_http_conn.cpp
View file

@ -220,7 +220,7 @@ int SrsHttpParser::on_url(http_parser* parser, const char* at, size_t length)
{
SrsHttpParser* obj = (SrsHttpParser*)parser->data;
srs_assert(obj);
if (length > 0) {
// Note that this function might be called for multiple times, and we got pieces of content.
obj->url.append(at, (int)length);

73
trunk/src/protocol/srs_protocol_st.cpp
View file

@ -469,19 +469,23 @@ bool srs_is_never_timeout(srs_utime_t tm)
SrsStSocket::SrsStSocket()
{
stfd = NULL;
stm = rtm = SRS_UTIME_NO_TIMEOUT;
rbytes = sbytes = 0;
init(NULL);
}
SrsStSocket::SrsStSocket(srs_netfd_t fd)
{
init(fd);
}
SrsStSocket::~SrsStSocket()
{
}
srs_error_t SrsStSocket::initialize(srs_netfd_t fd)
void SrsStSocket::init(srs_netfd_t fd)
{
stfd = fd;
return srs_success;
stfd_ = fd;
stm = rtm = SRS_UTIME_NO_TIMEOUT;
rbytes = sbytes = 0;
}
void SrsStSocket::set_recv_timeout(srs_utime_t tm)
@ -517,12 +521,14 @@ int64_t SrsStSocket::get_send_bytes()
srs_error_t SrsStSocket::read(void* buf, size_t size, ssize_t* nread)
{
srs_error_t err = srs_success;
srs_assert(stfd_);
ssize_t nb_read;
if (rtm == SRS_UTIME_NO_TIMEOUT) {
nb_read = st_read((st_netfd_t)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((st_netfd_t)stfd, buf, size, rtm);
nb_read = st_read((st_netfd_t)stfd_, buf, size, rtm);
}
if (nread) {
@ -552,12 +558,14 @@ srs_error_t SrsStSocket::read(void* buf, size_t size, ssize_t* nread)
srs_error_t SrsStSocket::read_fully(void* buf, size_t size, ssize_t* nread)
{
srs_error_t err = srs_success;
srs_assert(stfd_);
ssize_t nb_read;
if (rtm == SRS_UTIME_NO_TIMEOUT) {
nb_read = st_read_fully((st_netfd_t)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((st_netfd_t)stfd, buf, size, rtm);
nb_read = st_read_fully((st_netfd_t)stfd_, buf, size, rtm);
}
if (nread) {
@ -576,7 +584,7 @@ srs_error_t SrsStSocket::read_fully(void* buf, size_t size, ssize_t* nread)
errno = ECONNRESET;
}
return srs_error_new(ERROR_SOCKET_READ_FULLY, "read fully");
return srs_error_new(ERROR_SOCKET_READ_FULLY, "read fully, size=%d, nn=%d", size, nb_read);
}
rbytes += nb_read;
@ -587,12 +595,14 @@ srs_error_t SrsStSocket::read_fully(void* buf, size_t size, ssize_t* nread)
srs_error_t SrsStSocket::write(void* buf, size_t size, ssize_t* nwrite)
{
srs_error_t err = srs_success;
srs_assert(stfd_);
ssize_t nb_write;
if (stm == SRS_UTIME_NO_TIMEOUT) {
nb_write = st_write((st_netfd_t)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((st_netfd_t)stfd, buf, size, stm);
nb_write = st_write((st_netfd_t)stfd_, buf, size, stm);
}
if (nwrite) {
@ -617,12 +627,14 @@ srs_error_t SrsStSocket::write(void* buf, size_t size, ssize_t* nwrite)
srs_error_t SrsStSocket::writev(const iovec *iov, int iov_size, ssize_t* nwrite)
{
srs_error_t err = srs_success;
srs_assert(stfd_);
ssize_t nb_write;
if (stm == SRS_UTIME_NO_TIMEOUT) {
nb_write = st_writev((st_netfd_t)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((st_netfd_t)stfd, iov, iov_size, stm);
nb_write = st_writev((st_netfd_t)stfd_, iov, iov_size, stm);
}
if (nwrite) {
@ -646,7 +658,7 @@ srs_error_t SrsStSocket::writev(const iovec *iov, int iov_size, ssize_t* nwrite)
SrsTcpClient::SrsTcpClient(string h, int p, srs_utime_t tm)
{
stfd = NULL;
stfd_ = NULL;
io = new SrsStSocket();
host = h;
@ -656,39 +668,28 @@ SrsTcpClient::SrsTcpClient(string h, int p, srs_utime_t tm)
SrsTcpClient::~SrsTcpClient()
{
close();
srs_freep(io);
srs_close_stfd(stfd_);
}
srs_error_t SrsTcpClient::connect()
{
srs_error_t err = srs_success;
close();
srs_assert(stfd == NULL);
srs_netfd_t stfd = NULL;
if ((err = srs_tcp_connect(host, port, timeout, &stfd)) != srs_success) {
return srs_error_wrap(err, "tcp: connect %s:%d to=%dms", host.c_str(), port, srsu2msi(timeout));
}
if ((err = io->initialize(stfd)) != srs_success) {
return srs_error_wrap(err, "tcp: init socket object");
}
srs_freep(io);
io = new SrsStSocket(stfd);
srs_close_stfd(stfd_);
stfd_ = stfd;
return err;
}
void SrsTcpClient::close()
{
// Ignore when already closed.
if (!io) {
return;
}
srs_close_stfd(stfd);
}
void SrsTcpClient::set_recv_timeout(srs_utime_t tm)
{
io->set_recv_timeout(tm);

14
trunk/src/protocol/srs_protocol_st.hpp
View file

@ -127,13 +127,13 @@ private:
int64_t rbytes;
int64_t sbytes;
// The underlayer st fd.
srs_netfd_t stfd;
srs_netfd_t stfd_;
public:
SrsStSocket();
SrsStSocket(srs_netfd_t fd);
virtual ~SrsStSocket();
public:
// Initialize the socket with stfd, user must manage it.
virtual srs_error_t initialize(srs_netfd_t fd);
private:
void init(srs_netfd_t fd);
public:
virtual void set_recv_timeout(srs_utime_t tm);
virtual srs_utime_t get_recv_timeout();
@ -161,7 +161,7 @@ public:
class SrsTcpClient : public ISrsProtocolReadWriter
{
private:
srs_netfd_t stfd;
srs_netfd_t stfd_;
SrsStSocket* io;
private:
std::string host;
@ -179,10 +179,6 @@ public:
// Connect to server over TCP.
// @remark We will close the exists connection before do connect.
virtual srs_error_t connect();
private:
// Close the connection to server.
// @remark User should never use the client when close it.
virtual void close();
// Interface ISrsProtocolReadWriter
public:
virtual void set_recv_timeout(srs_utime_t tm);