github-forks
/
srs
mirror of https://github.com/ossrs/srs.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Refactor code, remove skt in param

Browse Source
pull/1753/head
winlin 5 years ago
parent 5ee5ef6ab2
commit fdcff3e6c2
3 changed files with 232 additions and 274 deletions
Show Stats Download Patch File Download Diff File

4
trunk/src/app/srs_app_listener.cpp
Unescape Escape View File

@ -460,6 +460,10 @@ srs_error_t SrsUdpMuxListener::cycle()
nn_loop++;
// TODO: FIXME: Refactor the memory cache for receiver.
// Because we have to decrypt the cipher of received packet payload,
// and the size is not determined, so we think there is at least one copy,
// and we can reuse the plaintext h264/opus with players when got plaintext.
SrsUdpMuxSocket skt(sender, lfd);
int nread = skt.recvfrom(SRS_UTIME_NO_TIMEOUT);

408
trunk/src/app/srs_app_rtc_conn.cpp
Unescape Escape View File

@ -70,17 +70,17 @@ using namespace std;
// which reserves 100 bytes for SRTP or paddings.
const int kRtpMaxPayloadSize = kRtpPacketSize - 200;
static bool is_stun(const uint8_t* data, const int size)
static bool is_stun(const uint8_t* data, const int size)
{
return data != NULL && size > 0 && (data[0] == 0 || data[0] == 1);
}
static bool is_dtls(const uint8_t* data, size_t len)
static bool is_dtls(const uint8_t* data, size_t len)
{
return (len >= 13 && (data[0] > 19 && data[0] < 64));
}
static bool is_rtp_or_rtcp(const uint8_t* data, size_t len)
static bool is_rtp_or_rtcp(const uint8_t* data, size_t len)
{
return (len >= 12 && (data[0] & 0xC0) == 0x80);
}
@ -260,7 +260,7 @@ srs_error_t SrsDtlsSession::initialize(SrsRequest* r)
return err;
}
srs_error_t SrsDtlsSession::handshake(SrsUdpMuxSocket* skt)
srs_error_t SrsDtlsSession::handshake()
{
srs_error_t err = srs_success;
@ -272,7 +272,7 @@ srs_error_t SrsDtlsSession::handshake(SrsUdpMuxSocket* skt)
int ssl_err = SSL_get_error(dtls, ret);
switch(ssl_err) {
case SSL_ERROR_NONE: {
if ((err = on_dtls_handshake_done(skt)) != srs_success) {
if ((err = on_dtls_handshake_done()) != srs_success) {
return srs_error_wrap(err, "dtls handshake done handle");
}
break;
@ -292,7 +292,7 @@ srs_error_t SrsDtlsSession::handshake(SrsUdpMuxSocket* skt)
}
if (out_bio_len) {
if ((err = skt->sendto(out_bio_data, out_bio_len, 0)) != srs_success) {
if ((err = rtc_session->sendonly_skt->sendto(out_bio_data, out_bio_len, 0)) != srs_success) {
return srs_error_wrap(err, "send dtls packet");
}
}
@ -306,7 +306,7 @@ srs_error_t SrsDtlsSession::handshake(SrsUdpMuxSocket* skt)
return err;
}
srs_error_t SrsDtlsSession::on_dtls(SrsUdpMuxSocket* skt)
srs_error_t SrsDtlsSession::on_dtls(char* data, int nb_data)
{
srs_error_t err = srs_success;
if (BIO_reset(bio_in) != 1) {
@ -316,19 +316,19 @@ srs_error_t SrsDtlsSession::on_dtls(SrsUdpMuxSocket* skt)
return srs_error_new(ERROR_OpenSslBIOReset, "BIO_reset");
}
if (BIO_write(bio_in, skt->data(), skt->size()) <= 0) {
if (BIO_write(bio_in, data, nb_data) <= 0) {
// TODO: 0 or -1 maybe block, use BIO_should_retry to check.
return srs_error_new(ERROR_OpenSslBIOWrite, "BIO_write");
}
if (rtc_session->blackhole && rtc_session->blackhole_addr && rtc_session->blackhole_stfd) {
// Ignore any error for black-hole.
void* p = skt->data(); int len = skt->size(); SrsRtcSession* s = rtc_session;
void* p = data; int len = nb_data; SrsRtcSession* s = rtc_session;
srs_sendto(s->blackhole_stfd, p, len, (sockaddr*)s->blackhole_addr, sizeof(sockaddr_in), SRS_UTIME_NO_TIMEOUT);
}
if (!handshake_done) {
err = handshake(skt);
err = handshake();
} else {
while (BIO_ctrl_pending(bio_in) > 0) {
char dtls_read_buf[8092];
@ -345,7 +345,7 @@ srs_error_t SrsDtlsSession::on_dtls(SrsUdpMuxSocket* skt)
return err;
}
srs_error_t SrsDtlsSession::on_dtls_handshake_done(SrsUdpMuxSocket* skt)
srs_error_t SrsDtlsSession::on_dtls_handshake_done()
{
srs_error_t err = srs_success;
srs_trace("rtc session=%s, DTLS handshake done.", rtc_session->id().c_str());
@ -355,7 +355,7 @@ srs_error_t SrsDtlsSession::on_dtls_handshake_done(SrsUdpMuxSocket* skt)
return srs_error_wrap(err, "srtp init failed");
}
return rtc_session->on_connection_established(skt);
return rtc_session->on_connection_established();
}
srs_error_t SrsDtlsSession::on_dtls_application_data(const char* buf, const int nb_buf)
@ -367,7 +367,7 @@ srs_error_t SrsDtlsSession::on_dtls_application_data(const char* buf, const int
return err;
}
srs_error_t SrsDtlsSession::srtp_initialize()
srs_error_t SrsDtlsSession::srtp_initialize()
{
srs_error_t err = srs_success;
@ -375,7 +375,7 @@ srs_error_t SrsDtlsSession::srtp_initialize()
static const string dtls_srtp_lable = "EXTRACTOR-dtls_srtp";
if (!SSL_export_keying_material(dtls, material, sizeof(material), dtls_srtp_lable.c_str(), dtls_srtp_lable.size(), NULL, 0, 0)) {
return srs_error_new(ERROR_RTC_SRTP_INIT, "SSL_export_keying_material failed");
}
}
size_t offset = 0;
@ -415,7 +415,7 @@ srs_error_t SrsDtlsSession::srtp_send_init()
srtp_crypto_policy_set_aes_cm_128_hmac_sha1_80(&policy.rtcp);
policy.ssrc.type = ssrc_any_outbound;
policy.ssrc.value = 0;
// TODO: adjust window_size
policy.window_size = 8192;
@ -629,15 +629,13 @@ SrsRtpPacket2* SrsRtcPackets::at(int index)
return cache + index;
}
SrsRtcSenderThread::SrsRtcSenderThread(SrsRtcSession* s, SrsUdpMuxSocket* u, int parent_cid)
: sendonly_ukt(NULL)
SrsRtcSenderThread::SrsRtcSenderThread(SrsRtcSession* s, int parent_cid)
{
_parent_cid = parent_cid;
trd = new SrsDummyCoroutine();
rtc_session = s;
sendonly_ukt = u->copy_sendonly();
sender = u->sender();
sender = NULL;
gso = false;
merge_nalus = false;
@ -660,7 +658,6 @@ SrsRtcSenderThread::~SrsRtcSenderThread()
_srs_config->unsubscribe(this);
srs_freep(trd);
srs_freep(sendonly_ukt);
}
srs_error_t SrsRtcSenderThread::initialize(const uint32_t& vssrc, const uint32_t& assrc, const uint16_t& v_pt, const uint16_t& a_pt)
@ -723,14 +720,14 @@ int SrsRtcSenderThread::cid()
srs_error_t SrsRtcSenderThread::start()
{
srs_error_t err = srs_success;
srs_freep(trd);
trd = new SrsSTCoroutine("rtc_sender", this, _parent_cid);
if ((err = trd->start()) != srs_success) {
return srs_error_wrap(err, "rtc_sender");
}
return err;
}
@ -744,16 +741,6 @@ void SrsRtcSenderThread::stop_loop()
trd->interrupt();
}
void SrsRtcSenderThread::update_sendonly_socket(SrsUdpMuxSocket* skt)
{
srs_trace("session %s address changed, update %s -> %s",
rtc_session->id().c_str(), sendonly_ukt->get_peer_id().c_str(), skt->get_peer_id().c_str());
srs_freep(sendonly_ukt);
sendonly_ukt = skt->copy_sendonly();
sender = skt->sender();
}
srs_error_t SrsRtcSenderThread::cycle()
{
srs_error_t err = srs_success;
@ -1043,8 +1030,8 @@ srs_error_t SrsRtcSenderThread::send_packets(SrsRtcPackets& packets)
packets.nn_rtp_bytes += (int)iov->iov_len;
// Set the address and control information.
sockaddr_in* addr = (sockaddr_in*)sendonly_ukt->peer_addr();
socklen_t addrlen = (socklen_t)sendonly_ukt->peer_addrlen();
sockaddr_in* addr = (sockaddr_in*)rtc_session->sendonly_skt->peer_addr();
socklen_t addrlen = (socklen_t)rtc_session->sendonly_skt->peer_addrlen();
mhdr->msg_hdr.msg_name = (sockaddr_in*)addr;
mhdr->msg_hdr.msg_namelen = (socklen_t)addrlen;
@ -1220,8 +1207,8 @@ srs_error_t SrsRtcSenderThread::send_packets_gso(SrsRtcPackets& packets)
if (do_send) {
// Set the address and control information.
sockaddr_in* addr = (sockaddr_in*)sendonly_ukt->peer_addr();
socklen_t addrlen = (socklen_t)sendonly_ukt->peer_addrlen();
sockaddr_in* addr = (sockaddr_in*)rtc_session->sendonly_skt->peer_addr();
socklen_t addrlen = (socklen_t)rtc_session->sendonly_skt->peer_addrlen();
mhdr->msg_hdr.msg_name = (sockaddr_in*)addr;
mhdr->msg_hdr.msg_namelen = (socklen_t)addrlen;
@ -1506,8 +1493,6 @@ srs_error_t SrsRtcSenderThread::package_stap_a(SrsSource* source, SrsSharedPtrMe
SrsRtcPublisher::SrsRtcPublisher(SrsRtcSession* session)
{
sendonly_ukt = NULL;
report_timer = new SrsHourGlass(this, 200 * SRS_UTIME_MILLISECONDS);
rtc_session = session;
@ -1535,12 +1520,10 @@ SrsRtcPublisher::~SrsRtcPublisher()
srs_freep(rtp_audio_queue);
}
srs_error_t SrsRtcPublisher::initialize(SrsUdpMuxSocket* skt, uint32_t vssrc, uint32_t assrc, SrsRequest* r)
srs_error_t SrsRtcPublisher::initialize(uint32_t vssrc, uint32_t assrc, SrsRequest* r)
{
srs_error_t err = srs_success;
sendonly_ukt = skt;
video_ssrc = vssrc;
audio_ssrc = assrc;
req = r;
@ -1570,7 +1553,7 @@ srs_error_t SrsRtcPublisher::initialize(SrsUdpMuxSocket* skt, uint32_t vssrc, ui
return err;
}
srs_error_t SrsRtcPublisher::on_rtcp_sender_report(char* buf, int nb_buf, SrsUdpMuxSocket* skt)
srs_error_t SrsRtcPublisher::on_rtcp_sender_report(char* buf, int nb_buf)
{
srs_error_t err = srs_success;
@ -1661,7 +1644,7 @@ block +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
return err;
}
srs_error_t SrsRtcPublisher::on_rtcp_xr(char* buf, int nb_buf, SrsUdpMuxSocket* skt)
srs_error_t SrsRtcPublisher::on_rtcp_xr(char* buf, int nb_buf)
{
srs_error_t err = srs_success;
/*
@ -1724,7 +1707,7 @@ srs_error_t SrsRtcPublisher::on_rtcp_xr(char* buf, int nb_buf, SrsUdpMuxSocket*
return err;
}
void SrsRtcPublisher::check_send_nacks(SrsRtpQueue* rtp_queue, uint32_t ssrc, SrsUdpMuxSocket* skt)
void SrsRtcPublisher::check_send_nacks(SrsRtpQueue* rtp_queue, uint32_t ssrc)
{
// If DTLS is not OK, drop all messages.
if (!rtc_session->dtls_session) {
@ -1759,14 +1742,14 @@ void SrsRtcPublisher::check_send_nacks(SrsRtpQueue* rtp_queue, uint32_t ssrc, Sr
// FIXME: Merge nack rtcp into one packets.
if (rtc_session->dtls_session->protect_rtcp(protected_buf, stream.data(), nb_protected_buf) == srs_success) {
// TODO: FIXME: Check error.
skt->sendto(protected_buf, nb_protected_buf, 0);
rtc_session->sendonly_skt->sendto(protected_buf, nb_protected_buf, 0);
}
++iter;
}
}
srs_error_t SrsRtcPublisher::send_rtcp_rr(SrsUdpMuxSocket* skt, uint32_t ssrc, SrsRtpQueue* rtp_queue)
srs_error_t SrsRtcPublisher::send_rtcp_rr(uint32_t ssrc, SrsRtpQueue* rtp_queue)
{
srs_error_t err = srs_success;
@ -1781,12 +1764,12 @@ srs_error_t SrsRtcPublisher::send_rtcp_rr(SrsUdpMuxSocket* skt, uint32_t ssrc, S
stream.write_1bytes(kRR);
stream.write_2bytes(7);
stream.write_4bytes(ssrc);
uint8_t fraction_lost = rtp_queue->get_fraction_lost();
uint32_t cumulative_number_of_packets_lost = rtp_queue->get_cumulative_number_of_packets_lost() & 0x7FFFFF;
uint32_t extended_highest_sequence = rtp_queue->get_extended_highest_sequence();
uint32_t interarrival_jitter = rtp_queue->get_interarrival_jitter();
uint32_t rr_lsr = 0;
uint32_t rr_dlsr = 0;
@ -1798,7 +1781,7 @@ srs_error_t SrsRtcPublisher::send_rtcp_rr(SrsUdpMuxSocket* skt, uint32_t ssrc, S
uint32_t dlsr = (srs_update_system_time() - lsr_systime) / 1000;
rr_dlsr = ((dlsr / 1000) << 16) | ((dlsr % 1000) * 65536 / 1000);
}
stream.write_4bytes(ssrc);
stream.write_1bytes(fraction_lost);
stream.write_3bytes(cumulative_number_of_packets_lost);
@ -1806,10 +1789,10 @@ srs_error_t SrsRtcPublisher::send_rtcp_rr(SrsUdpMuxSocket* skt, uint32_t ssrc, S
stream.write_4bytes(interarrival_jitter);
stream.write_4bytes(rr_lsr);
stream.write_4bytes(rr_dlsr);
srs_verbose("RR ssrc=%u, fraction_lost=%u, cumulative_number_of_packets_lost=%u, extended_highest_sequence=%u, interarrival_jitter=%u",
ssrc, fraction_lost, cumulative_number_of_packets_lost, extended_highest_sequence, interarrival_jitter);
char protected_buf[kRtpPacketSize];
int nb_protected_buf = stream.pos();
if ((err = rtc_session->dtls_session->protect_rtcp(protected_buf, stream.data(), nb_protected_buf)) != srs_success) {
@ -1817,11 +1800,11 @@ srs_error_t SrsRtcPublisher::send_rtcp_rr(SrsUdpMuxSocket* skt, uint32_t ssrc, S
}
// TDOO: FIXME: Check error.
skt->sendto(protected_buf, nb_protected_buf, 0);
rtc_session->sendonly_skt->sendto(protected_buf, nb_protected_buf, 0);
return err;
}
srs_error_t SrsRtcPublisher::send_rtcp_xr_rrtr(SrsUdpMuxSocket* skt, uint32_t ssrc)
srs_error_t SrsRtcPublisher::send_rtcp_xr_rrtr(uint32_t ssrc)
{
srs_error_t err = srs_success;
@ -1877,12 +1860,12 @@ srs_error_t SrsRtcPublisher::send_rtcp_xr_rrtr(SrsUdpMuxSocket* skt, uint32_t ss
}
// TDOO: FIXME: Check error.
skt->sendto(protected_buf, nb_protected_buf, 0);
rtc_session->sendonly_skt->sendto(protected_buf, nb_protected_buf, 0);
return err;
}
srs_error_t SrsRtcPublisher::send_rtcp_fb_pli(SrsUdpMuxSocket* skt, uint32_t ssrc)
srs_error_t SrsRtcPublisher::send_rtcp_fb_pli(uint32_t ssrc)
{
srs_error_t err = srs_success;
@ -1898,9 +1881,9 @@ srs_error_t SrsRtcPublisher::send_rtcp_fb_pli(SrsUdpMuxSocket* skt, uint32_t ssr
stream.write_2bytes(2);
stream.write_4bytes(ssrc);
stream.write_4bytes(ssrc);
srs_trace("RTC PLI ssrc=%u", ssrc);
char protected_buf[kRtpPacketSize];
int nb_protected_buf = stream.pos();
if ((err = rtc_session->dtls_session->protect_rtcp(protected_buf, stream.data(), nb_protected_buf)) != srs_success) {
@ -1908,12 +1891,12 @@ srs_error_t SrsRtcPublisher::send_rtcp_fb_pli(SrsUdpMuxSocket* skt, uint32_t ssr
}
// TDOO: FIXME: Check error.
skt->sendto(protected_buf, nb_protected_buf, 0);
rtc_session->sendonly_skt->sendto(protected_buf, nb_protected_buf, 0);
return err;
}
srs_error_t SrsRtcPublisher::on_rtp(SrsUdpMuxSocket* skt, char* buf, int nb_buf)
srs_error_t SrsRtcPublisher::on_rtp(char* buf, int nb_buf)
{
srs_error_t err = srs_success;
@ -1926,15 +1909,15 @@ srs_error_t SrsRtcPublisher::on_rtp(SrsUdpMuxSocket* skt, char* buf, int nb_buf)
uint32_t ssrc = pkt->rtp_header.get_ssrc();
if (ssrc == audio_ssrc) {
return on_audio(skt, pkt);
return on_audio(pkt);
} else if (ssrc == video_ssrc) {
return on_video(skt, pkt);
return on_video(pkt);
}
return srs_error_new(ERROR_RTC_RTP, "unknown ssrc=%u", ssrc);
}
srs_error_t SrsRtcPublisher::on_audio(SrsUdpMuxSocket* skt, SrsRtpSharedPacket* pkt)
srs_error_t SrsRtcPublisher::on_audio(SrsRtpSharedPacket* pkt)
{
srs_error_t err = srs_success;
@ -1948,10 +1931,10 @@ srs_error_t SrsRtcPublisher::on_audio(SrsUdpMuxSocket* skt, SrsRtpSharedPacket*
if (rtp_audio_queue->should_request_key_frame()) {
// TODO: FIXME: Check error.
send_rtcp_fb_pli(skt, audio_ssrc);
send_rtcp_fb_pli(audio_ssrc);
}
check_send_nacks(rtp_audio_queue, audio_ssrc, skt);
check_send_nacks(rtp_audio_queue, audio_ssrc);
return collect_audio_frame();
}
@ -1969,6 +1952,7 @@ srs_error_t SrsRtcPublisher::collect_audio_frame()
for (size_t j = 0; j < frames.size(); ++j) {
SrsRtpSharedPacket* pkt = frames[j];
// TODO: FIXME: Transcode OPUS to AAC.
if (pkt->rtp_payload_size() > 0) {
SrsMessageHeader header;
header.message_type = RTMP_MSG_AudioMessage;
@ -1996,7 +1980,7 @@ srs_error_t SrsRtcPublisher::collect_audio_frame()
return err;
}
srs_error_t SrsRtcPublisher::on_video(SrsUdpMuxSocket* skt, SrsRtpSharedPacket* pkt)
srs_error_t SrsRtcPublisher::on_video(SrsRtpSharedPacket* pkt)
{
srs_error_t err = srs_success;
@ -2011,10 +1995,10 @@ srs_error_t SrsRtcPublisher::on_video(SrsUdpMuxSocket* skt, SrsRtpSharedPacket*
if (rtp_video_queue->should_request_key_frame()) {
// TODO: FIXME: Check error.
send_rtcp_fb_pli(skt, video_ssrc);
send_rtcp_fb_pli(video_ssrc);
}
check_send_nacks(rtp_video_queue, video_ssrc, skt);
check_send_nacks(rtp_video_queue, video_ssrc);
return collect_video_frame();
}
@ -2028,8 +2012,8 @@ srs_error_t SrsRtcPublisher::collect_video_frame()
for (size_t i = 0; i < frames.size(); ++i) {
if (!frames[i].empty()) {
srs_verbose("collect %d video frames, seq range %u,%u",
frames.size(), frames[i].front()->rtp_header.get_sequence(),
srs_verbose("collect %d video frames, seq range %u,%u",
frames.size(), frames[i].front()->rtp_header.get_sequence(),
frames[i].back()->rtp_header.get_sequence());
}
@ -2085,7 +2069,7 @@ srs_error_t SrsRtcPublisher::collect_video_frame()
idr = true;
}
}
memcpy(frame_buffer + frame_buffer_index, frames[i][n]->rtp_payload() + rtp_h264_header->nalu_offset[j].first,
memcpy(frame_buffer + frame_buffer_index, frames[i][n]->rtp_payload() + rtp_h264_header->nalu_offset[j].first,
rtp_h264_header->nalu_offset[j].second);
frame_buffer_index += rtp_h264_header->nalu_offset[j].second;
}
@ -2167,15 +2151,6 @@ srs_error_t SrsRtcPublisher::collect_video_frame()
return err;
}
void SrsRtcPublisher::update_sendonly_socket(SrsUdpMuxSocket* skt)
{
srs_trace("session %s address changed, update %s -> %s",
rtc_session->id().c_str(), sendonly_ukt->get_peer_id().c_str(), skt->get_peer_id().c_str());
srs_freep(sendonly_ukt);
sendonly_ukt = skt->copy_sendonly();
}
void SrsRtcPublisher::request_keyframe()
{
int scid = _srs_context->get_id();
@ -2187,15 +2162,15 @@ void SrsRtcPublisher::request_keyframe()
srs_error_t SrsRtcPublisher::notify(int type, srs_utime_t interval, srs_utime_t tick)
{
if (sendonly_ukt) {
// TODO: FIXME: Check error.
send_rtcp_rr(sendonly_ukt, video_ssrc, rtp_video_queue);
send_rtcp_rr(sendonly_ukt, audio_ssrc, rtp_audio_queue);
send_rtcp_xr_rrtr(sendonly_ukt, video_ssrc);
send_rtcp_xr_rrtr(sendonly_ukt, audio_ssrc);
}
srs_error_t err = srs_success;
return srs_success;
// TODO: FIXME: Check error.
send_rtcp_rr(video_ssrc, rtp_video_queue);
send_rtcp_rr(audio_ssrc, rtp_audio_queue);
send_rtcp_xr_rrtr(video_ssrc);
send_rtcp_xr_rrtr(audio_ssrc);
return err;
}
SrsRtcSession::SrsRtcSession(SrsRtcServer* s, SrsRequest* r, const std::string& un, int context_id)
@ -2208,6 +2183,7 @@ SrsRtcSession::SrsRtcSession(SrsRtcServer* s, SrsRequest* r, const std::string&
source = NULL;
publisher = NULL;
sender = NULL;
sendonly_skt = NULL;
rtc_server = s;
dtls_session = new SrsDtlsSession(this);
@ -2228,6 +2204,7 @@ SrsRtcSession::~SrsRtcSession()
srs_freep(req);
srs_close_stfd(blackhole_stfd);
srs_freep(blackhole_addr);
srs_freep(sendonly_skt);
}
void SrsRtcSession::set_local_sdp(const SrsSdp& sdp)
@ -2279,32 +2256,31 @@ srs_error_t SrsRtcSession::initialize()
return err;
}
srs_error_t SrsRtcSession::on_stun(SrsUdpMuxSocket* skt, SrsStunPacket* stun_req)
srs_error_t SrsRtcSession::on_stun(SrsUdpMuxSocket* skt, SrsStunPacket* r)
{
srs_error_t err = srs_success;
if (stun_req->is_binding_request()) {
if ((err = on_binding_request(skt, stun_req)) != srs_success) {
return srs_error_wrap(err, "stun binding request failed");
}
if (!r->is_binding_request()) {
return err;
}
last_stun_time = srs_get_system_time();
last_stun_time = srs_get_system_time();
if (sender && sender->sendonly_ukt) {
// We are running in the ice-lite(server) mode. If client have multi network interface,
// we only choose one candidate pair which is determined by client.
if (stun_req->get_use_candidate() && sender->sendonly_ukt->get_peer_id() != skt->get_peer_id()) {
sender->update_sendonly_socket(skt);
}
}
// We are running in the ice-lite(server) mode. If client have multi network interface,
// we only choose one candidate pair which is determined by client.
if (!sendonly_skt || sendonly_skt->get_peer_id() != skt->get_peer_id()) {
update_sendonly_socket(skt);
}
if (publisher && publisher->sendonly_ukt) {
// We are running in the ice-lite(server) mode. If client have multi network interface,
// we only choose one candidate pair which is determined by client.
if (stun_req->get_use_candidate() && publisher->sendonly_ukt->get_peer_id() != skt->get_peer_id()) {
publisher->update_sendonly_socket(skt);
}
}
// Write STUN messages to blackhole.
if (blackhole && blackhole_addr && blackhole_stfd) {
// Ignore any error for black-hole.
void* p = skt->data(); int len = skt->size();
srs_sendto(blackhole_stfd, p, len, (sockaddr*)blackhole_addr, sizeof(sockaddr_in), SRS_UTIME_NO_TIMEOUT);
}
if ((err = on_binding_request(r)) != srs_success) {
return srs_error_wrap(err, "stun binding request failed");
}
return err;
@ -2317,12 +2293,12 @@ srs_error_t SrsRtcSession::on_stun(SrsUdpMuxSocket* skt, SrsStunPacket* stun_req
#define be32toh ntohl
#endif
srs_error_t SrsRtcSession::on_binding_request(SrsUdpMuxSocket* skt, SrsStunPacket* stun_req)
srs_error_t SrsRtcSession::on_binding_request(SrsStunPacket* r)
{
srs_error_t err = srs_success;
bool strict_check = _srs_config->get_rtc_stun_strict_check(req->vhost);
if (strict_check && stun_req->get_ice_controlled()) {
if (strict_check && r->get_ice_controlled()) {
// @see: https://tools.ietf.org/html/draft-ietf-ice-rfc5245bis-00#section-6.1.3.1
// TODO: Send 487 (Role Conflict) error response.
return srs_error_new(ERROR_RTC_STUN, "Peer must not in ice-controlled role in ice-lite mode.");
@ -2334,38 +2310,31 @@ srs_error_t SrsRtcSession::on_binding_request(SrsUdpMuxSocket* skt, SrsStunPacke
SrsAutoFree(SrsBuffer, stream);
stun_binding_response.set_message_type(BindingResponse);
stun_binding_response.set_local_ufrag(stun_req->get_remote_ufrag());
stun_binding_response.set_remote_ufrag(stun_req->get_local_ufrag());
stun_binding_response.set_transcation_id(stun_req->get_transcation_id());
stun_binding_response.set_local_ufrag(r->get_remote_ufrag());
stun_binding_response.set_remote_ufrag(r->get_local_ufrag());
stun_binding_response.set_transcation_id(r->get_transcation_id());
// FIXME: inet_addr is deprecated, IPV6 support
stun_binding_response.set_mapped_address(be32toh(inet_addr(skt->get_peer_ip().c_str())));
stun_binding_response.set_mapped_port(skt->get_peer_port());
stun_binding_response.set_mapped_address(be32toh(inet_addr(sendonly_skt->get_peer_ip().c_str())));
stun_binding_response.set_mapped_port(sendonly_skt->get_peer_port());
if ((err = stun_binding_response.encode(get_local_sdp()->get_ice_pwd(), stream)) != srs_success) {
return srs_error_wrap(err, "stun binding response encode failed");
}
if ((err = skt->sendto(stream->data(), stream->pos(), 0)) != srs_success) {
if ((err = sendonly_skt->sendto(stream->data(), stream->pos(), 0)) != srs_success) {
return srs_error_wrap(err, "stun binding response send failed");
}
if (get_session_state() == WAITING_STUN) {
set_session_state(DOING_DTLS_HANDSHAKE);
peer_id = skt->get_peer_id();
peer_id = sendonly_skt->get_peer_id();
rtc_server->insert_into_id_sessions(peer_id, this);
set_session_state(DOING_DTLS_HANDSHAKE);
srs_trace("rtc session=%s, STUN done, waitting DTLS handshake.", id().c_str());
}
// Write STUN messages to blackhole.
if (blackhole && blackhole_addr && blackhole_stfd) {
// Ignore any error for black-hole.
void* p = skt->data(); int len = skt->size();
srs_sendto(blackhole_stfd, p, len, (sockaddr*)blackhole_addr, sizeof(sockaddr_in), SRS_UTIME_NO_TIMEOUT);
}
if (blackhole && blackhole_addr && blackhole_stfd) {
// Ignore any error for black-hole.
void* p = stream->data(); int len = stream->pos();
@ -2375,7 +2344,7 @@ srs_error_t SrsRtcSession::on_binding_request(SrsUdpMuxSocket* skt, SrsStunPacke
return err;
}
srs_error_t SrsRtcSession::on_rtcp_feedback(char* buf, int nb_buf, SrsUdpMuxSocket* skt)
srs_error_t SrsRtcSession::on_rtcp_feedback(char* buf, int nb_buf)
{
srs_error_t err = srs_success;
@ -2457,14 +2426,14 @@ srs_error_t SrsRtcSession::on_rtcp_feedback(char* buf, int nb_buf, SrsUdpMuxSock
// TODO: FIXME: Check error.
dtls_session->protect_rtp(protected_buf, resend_pkts[i]->payload, nb_protected_buf);
skt->sendto(protected_buf, nb_protected_buf, 0);
sendonly_skt->sendto(protected_buf, nb_protected_buf, 0);
}
}
return err;
}
srs_error_t SrsRtcSession::on_rtcp_ps_feedback(char* buf, int nb_buf, SrsUdpMuxSocket* skt)
srs_error_t SrsRtcSession::on_rtcp_ps_feedback(char* buf, int nb_buf)
{
srs_error_t err = srs_success;
@ -2511,25 +2480,25 @@ srs_error_t SrsRtcSession::on_rtcp_ps_feedback(char* buf, int nb_buf, SrsUdpMuxS
return err;
}
srs_error_t SrsRtcSession::on_rtcp_xr(char* buf, int nb_buf, SrsUdpMuxSocket* skt)
srs_error_t SrsRtcSession::on_rtcp_xr(char* buf, int nb_buf)
{
if (publisher == NULL) {
return srs_error_new(ERROR_RTC_RTCP, "rtc publisher null");
}
return publisher->on_rtcp_xr(buf, nb_buf, skt);
return publisher->on_rtcp_xr(buf, nb_buf);
}
srs_error_t SrsRtcSession::on_rtcp_sender_report(char* buf, int nb_buf, SrsUdpMuxSocket* skt)
srs_error_t SrsRtcSession::on_rtcp_sender_report(char* buf, int nb_buf)
{
if (publisher == NULL) {
return srs_error_new(ERROR_RTC_RTCP, "rtc publisher null");
}
return publisher->on_rtcp_sender_report(buf, nb_buf, skt);
return publisher->on_rtcp_sender_report(buf, nb_buf);
}
srs_error_t SrsRtcSession::on_rtcp_receiver_report(char* buf, int nb_buf, SrsUdpMuxSocket* skt)
srs_error_t SrsRtcSession::on_rtcp_receiver_report(char* buf, int nb_buf)
{
srs_error_t err = srs_success;
@ -2598,7 +2567,7 @@ block +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
return err;
}
srs_error_t SrsRtcSession::on_connection_established(SrsUdpMuxSocket* skt)
srs_error_t SrsRtcSession::on_connection_established()
{
srs_error_t err = srs_success;
@ -2606,14 +2575,14 @@ srs_error_t SrsRtcSession::on_connection_established(SrsUdpMuxSocket* skt)
if (!local_sdp.media_descs_.empty() &&
(local_sdp.media_descs_.back().recvonly_ || local_sdp.media_descs_.back().sendrecv_)) {
if ((err = start_publish(skt)) != srs_success) {
if ((err = start_publish()) != srs_success) {
return srs_error_wrap(err, "start publish");
}
}
if (!local_sdp.media_descs_.empty() &&
(local_sdp.media_descs_.back().sendonly_ || local_sdp.media_descs_.back().sendrecv_)) {
if ((err = start_play(skt)) != srs_success) {
if ((err = start_play()) != srs_success) {
return srs_error_wrap(err, "start play");
}
}
@ -2621,12 +2590,13 @@ srs_error_t SrsRtcSession::on_connection_established(SrsUdpMuxSocket* skt)
return err;
}
srs_error_t SrsRtcSession::start_play(SrsUdpMuxSocket* skt)
srs_error_t SrsRtcSession::start_play()
{
srs_error_t err = srs_success;
srs_freep(sender);
sender = new SrsRtcSenderThread(this, skt, _srs_context->get_id());
sender = new SrsRtcSenderThread(this, _srs_context->get_id());
sender->update_sender(sendonly_skt->sender());
uint32_t video_ssrc = 0;
uint32_t audio_ssrc = 0;
@ -2654,7 +2624,7 @@ srs_error_t SrsRtcSession::start_play(SrsUdpMuxSocket* skt)
return err;
}
srs_error_t SrsRtcSession::start_publish(SrsUdpMuxSocket* skt)
srs_error_t SrsRtcSession::start_publish()
{
srs_error_t err = srs_success;
@ -2677,7 +2647,7 @@ srs_error_t SrsRtcSession::start_publish(SrsUdpMuxSocket* skt)
}
// FIXME: err process.
if ((err = publisher->initialize(skt, video_ssrc, audio_ssrc, req)) != srs_success) {
if ((err = publisher->initialize(video_ssrc, audio_ssrc, req)) != srs_success) {
return srs_error_wrap(err, "rtc publisher init");
}
@ -2689,12 +2659,12 @@ bool SrsRtcSession::is_stun_timeout()
return last_stun_time + sessionStunTimeout < srs_get_system_time();
}
srs_error_t SrsRtcSession::on_dtls(SrsUdpMuxSocket* skt)
srs_error_t SrsRtcSession::on_dtls(char* data, int nb_data)
{
return dtls_session->on_dtls(skt);
return dtls_session->on_dtls(data, nb_data);
}
srs_error_t SrsRtcSession::on_rtcp(SrsUdpMuxSocket* skt)
srs_error_t SrsRtcSession::on_rtcp(char* data, int nb_data)
{
srs_error_t err = srs_success;
@ -2703,8 +2673,8 @@ srs_error_t SrsRtcSession::on_rtcp(SrsUdpMuxSocket* skt)
}
char unprotected_buf[kRtpPacketSize];
int nb_unprotected_buf = skt->size();
if ((err = dtls_session->unprotect_rtcp(unprotected_buf, skt->data(), nb_unprotected_buf)) != srs_success) {
int nb_unprotected_buf = nb_data;
if ((err = dtls_session->unprotect_rtcp(unprotected_buf, data, nb_unprotected_buf)) != srs_success) {
return srs_error_wrap(err, "rtcp unprotect failed");
}
@ -2730,11 +2700,11 @@ srs_error_t SrsRtcSession::on_rtcp(SrsUdpMuxSocket* skt)
switch (payload_type) {
case kSR: {
err = on_rtcp_sender_report(ph, length, skt);
err = on_rtcp_sender_report(ph, length);
break;
}
case kRR: {
err = on_rtcp_receiver_report(ph, length, skt);
err = on_rtcp_receiver_report(ph, length);
break;
}
case kSDES: {
@ -2747,15 +2717,15 @@ srs_error_t SrsRtcSession::on_rtcp(SrsUdpMuxSocket* skt)
break;
}
case kRtpFb: {
err = on_rtcp_feedback(ph, length, skt);
err = on_rtcp_feedback(ph, length);
break;
}
case kPsFb: {
err = on_rtcp_ps_feedback(ph, length, skt);
err = on_rtcp_ps_feedback(ph, length);
break;
}
case kXR: {
err = on_rtcp_xr(ph, length, skt);
err = on_rtcp_xr(ph, length);
break;
}
default:{
@ -2775,7 +2745,7 @@ srs_error_t SrsRtcSession::on_rtcp(SrsUdpMuxSocket* skt)
return err;
}
srs_error_t SrsRtcSession::on_rtp(SrsUdpMuxSocket* skt)
srs_error_t SrsRtcSession::on_rtp(char* data, int nb_data)
{
srs_error_t err = srs_success;
@ -2788,8 +2758,8 @@ srs_error_t SrsRtcSession::on_rtp(SrsUdpMuxSocket* skt)
}
char* unprotected_buf = new char[kRtpPacketSize];
int nb_unprotected_buf = skt->size();
if ((err = dtls_session->unprotect_rtp(unprotected_buf, skt->data(), nb_unprotected_buf)) != srs_success) {
int nb_unprotected_buf = nb_data;
if ((err = dtls_session->unprotect_rtp(unprotected_buf, data, nb_unprotected_buf)) != srs_success) {
return srs_error_wrap(err, "rtp unprotect failed");
}
@ -2799,7 +2769,21 @@ srs_error_t SrsRtcSession::on_rtp(SrsUdpMuxSocket* skt)
srs_sendto(blackhole_stfd, p, len, (sockaddr*)blackhole_addr, sizeof(sockaddr_in), SRS_UTIME_NO_TIMEOUT);
}
return publisher->on_rtp(skt, unprotected_buf, nb_unprotected_buf);
return publisher->on_rtp(unprotected_buf, nb_unprotected_buf);
}
void SrsRtcSession::update_sendonly_socket(SrsUdpMuxSocket* skt)
{
if (sendonly_skt) {
srs_trace("session %s address changed, update %s -> %s",
id().c_str(), sendonly_skt->get_peer_id().c_str(), skt->get_peer_id().c_str());
}
srs_freep(sendonly_skt);
sendonly_skt = skt->copy_sendonly();
if (sender) {
sender->update_sender(skt->sender());
}
}
SrsUdpMuxSender::SrsUdpMuxSender(SrsRtcServer* s)
@ -3166,13 +3150,54 @@ srs_error_t SrsRtcServer::listen_udp()
srs_error_t SrsRtcServer::on_udp_packet(SrsUdpMuxSocket* skt)
{
if (is_stun(reinterpret_cast<const uint8_t*>(skt->data()), skt->size())) {
return on_stun(skt);
} else if (is_dtls(reinterpret_cast<const uint8_t*>(skt->data()), skt->size())) {
return on_dtls(skt);
} else if (is_rtp_or_rtcp(reinterpret_cast<const uint8_t*>(skt->data()), skt->size())) {
return on_rtp_or_rtcp(skt);
}
srs_error_t err = srs_success;
char* data = skt->data(); int size = skt->size();
SrsRtcSession* rtc_session = find_rtc_session_by_peer_id(skt->get_peer_id());
if (rtc_session) {
// Now, we got the RTC session to handle the packet, switch to its context
// to make all logs write to the "correct" pid+cid.
rtc_session->switch_to_context();
}
if (is_stun((uint8_t*)data, size)) {
SrsStunPacket sr;
if ((err = sr.decode(data, size)) != srs_success) {
return srs_error_wrap(err, "decode stun packet failed");
}
srs_verbose("recv stun packet from %s, use-candidate=%d, ice-controlled=%d, ice-controlling=%d",
skt->get_peer_id().c_str(), sr.get_use_candidate(), sr.get_ice_controlled(), sr.get_ice_controlling());
if (!rtc_session) {
rtc_session = find_rtc_session_by_username(sr.get_username());
if (rtc_session) {
rtc_session->switch_to_context();
}
}
if (rtc_session == NULL) {
return srs_error_new(ERROR_RTC_STUN, "can not find rtc_session, stun username=%s, peer_id=%s",
sr.get_username().c_str(), skt->get_peer_id().c_str());
}
return rtc_session->on_stun(skt, &sr);
} else if (is_dtls((uint8_t*)data, size)) {
if (rtc_session == NULL) {
return srs_error_new(ERROR_RTC_STUN, "can not find rtc_session, peer_id=%s", skt->get_peer_id().c_str());
}
return rtc_session->on_dtls(data, size);
} else if (is_rtp_or_rtcp((uint8_t*)data, size)) {
if (rtc_session == NULL) {
return srs_error_new(ERROR_RTC_STUN, "can not find rtc_session, peer_id=%s", skt->get_peer_id().c_str());
}
if (is_rtcp((uint8_t*)data, size)) {
return rtc_session->on_rtcp(data, size);
} else {
return rtc_session->on_rtp(data, size);
}
}
return srs_error_new(ERROR_RTC_UDP, "unknown udp packet type");
}
@ -3267,69 +3292,6 @@ SrsRtcSession* SrsRtcServer::find_rtc_session_by_peer_id(const string& peer_id)
return iter->second;
}
srs_error_t SrsRtcServer::on_stun(SrsUdpMuxSocket* skt)
{
srs_error_t err = srs_success;
SrsStunPacket stun_req;
if ((err = stun_req.decode(skt->data(), skt->size())) != srs_success) {
return srs_error_wrap(err, "decode stun packet failed");
}
srs_verbose("recv stun packet from %s, use-candidate=%d, ice-controlled=%d, ice-controlling=%d",
skt->get_peer_id().c_str(), stun_req.get_use_candidate(), stun_req.get_ice_controlled(), stun_req.get_ice_controlling());
std::string username = stun_req.get_username();
SrsRtcSession* rtc_session = find_rtc_session_by_username(username);
if (rtc_session == NULL) {
return srs_error_new(ERROR_RTC_STUN, "can not find rtc_session, stun username=%s", username.c_str());
}
// Now, we got the RTC session to handle the packet, switch to its context
// to make all logs write to the "correct" pid+cid.
rtc_session->switch_to_context();
return rtc_session->on_stun(skt, &stun_req);
}
srs_error_t SrsRtcServer::on_dtls(SrsUdpMuxSocket* skt)
{
SrsRtcSession* rtc_session = find_rtc_session_by_peer_id(skt->get_peer_id());
if (rtc_session == NULL) {
return srs_error_new(ERROR_RTC_DTLS, "can not find rtc session by peer_id=%s", skt->get_peer_id().c_str());
}
// Now, we got the RTC session to handle the packet, switch to its context
// to make all logs write to the "correct" pid+cid.
rtc_session->switch_to_context();
return rtc_session->on_dtls(skt);
}
srs_error_t SrsRtcServer::on_rtp_or_rtcp(SrsUdpMuxSocket* skt)
{
srs_error_t err = srs_success;
SrsRtcSession* rtc_session = find_rtc_session_by_peer_id(skt->get_peer_id());
if (rtc_session == NULL) {
return srs_error_new(ERROR_RTC_RTP, "can not find rtc session by peer_id=%s", skt->get_peer_id().c_str());
}
// Now, we got the RTC session to handle the packet, switch to its context
// to make all logs write to the "correct" pid+cid.
rtc_session->switch_to_context();
if (is_rtcp(reinterpret_cast<const uint8_t*>(skt->data()), skt->size())) {
err = rtc_session->on_rtcp(skt);
} else {
err = rtc_session->on_rtp(skt);
}
return err;
}
SrsRtcSession* SrsRtcServer::find_rtc_session_by_username(const std::string& username)
{
map<string, SrsRtcSession*>::iterator iter = map_username_session.find(username);

94
trunk/src/app/srs_app_rtc_conn.hpp
Unescape Escape View File

@ -122,8 +122,8 @@ public:
srs_error_t initialize(SrsRequest* r);
srs_error_t on_dtls(SrsUdpMuxSocket* skt);
srs_error_t on_dtls_handshake_done(SrsUdpMuxSocket* skt);
srs_error_t on_dtls(char* data, int nb_data);
srs_error_t on_dtls_handshake_done();
srs_error_t on_dtls_application_data(const char* data, const int len);
public:
srs_error_t protect_rtp(char* protected_buf, const char* ori_buf, int& nb_protected_buf);
@ -132,7 +132,7 @@ public:
srs_error_t protect_rtcp(char* protected_buf, const char* ori_buf, int& nb_protected_buf);
srs_error_t unprotect_rtcp(char* unprotected_buf, const char* ori_buf, int& nb_unprotected_buf);
private:
srs_error_t handshake(SrsUdpMuxSocket* skt);
srs_error_t handshake();
private:
srs_error_t srtp_initialize();
srs_error_t srtp_send_init();
@ -208,8 +208,6 @@ private:
uint16_t audio_sequence;
private:
uint16_t video_sequence;
public:
SrsUdpMuxSocket* sendonly_ukt;
private:
ISrsUdpSender* sender;
private:
@ -221,10 +219,11 @@ private:
int mw_msgs;
bool realtime;
public:
SrsRtcSenderThread(SrsRtcSession* s, SrsUdpMuxSocket* u, int parent_cid);
SrsRtcSenderThread(SrsRtcSession* s, int parent_cid);
virtual ~SrsRtcSenderThread();
public:
srs_error_t initialize(const uint32_t& vssrc, const uint32_t& assrc, const uint16_t& v_pt, const uint16_t& a_pt);
void update_sender(ISrsUdpSender* s) { sender = s; }
// interface ISrsReloadHandler
public:
virtual srs_error_t on_reload_rtc_server();
@ -236,8 +235,6 @@ public:
virtual srs_error_t start();
virtual void stop();
virtual void stop_loop();
public:
void update_sendonly_socket(SrsUdpMuxSocket* skt);
public:
virtual srs_error_t cycle();
private:
@ -258,8 +255,6 @@ class SrsRtcPublisher : virtual public ISrsHourGlass
{
private:
SrsHourGlass* report_timer;
public:
SrsUdpMuxSocket* sendonly_ukt;
private:
SrsRtcSession* rtc_session;
uint32_t video_ssrc;
@ -281,23 +276,22 @@ public:
SrsRtcPublisher(SrsRtcSession* session);
virtual ~SrsRtcPublisher();
public:
srs_error_t initialize(SrsUdpMuxSocket* skt, uint32_t vssrc, uint32_t assrc, SrsRequest* req);
srs_error_t on_rtcp_sender_report(char* buf, int nb_buf, SrsUdpMuxSocket* skt);
srs_error_t on_rtcp_xr(char* buf, int nb_buf, SrsUdpMuxSocket* skt);
srs_error_t initialize(uint32_t vssrc, uint32_t assrc, SrsRequest* req);
srs_error_t on_rtcp_sender_report(char* buf, int nb_buf);
srs_error_t on_rtcp_xr(char* buf, int nb_buf);
private:
void check_send_nacks(SrsRtpQueue* rtp_queue, uint32_t ssrc, SrsUdpMuxSocket* skt);
srs_error_t send_rtcp_rr(SrsUdpMuxSocket* skt, uint32_t ssrc, SrsRtpQueue* rtp_queue);
srs_error_t send_rtcp_xr_rrtr(SrsUdpMuxSocket* skt, uint32_t ssrc);
srs_error_t send_rtcp_fb_pli(SrsUdpMuxSocket* skt, uint32_t ssrc);
void check_send_nacks(SrsRtpQueue* rtp_queue, uint32_t ssrc);
srs_error_t send_rtcp_rr(uint32_t ssrc, SrsRtpQueue* rtp_queue);
srs_error_t send_rtcp_xr_rrtr(uint32_t ssrc);
srs_error_t send_rtcp_fb_pli(uint32_t ssrc);
public:
srs_error_t on_rtp(SrsUdpMuxSocket* skt, char* buf, int nb_buf);
srs_error_t on_rtp(char* buf, int nb_buf);
private:
srs_error_t on_audio(SrsUdpMuxSocket* skt, SrsRtpSharedPacket* pkt);
srs_error_t on_audio(SrsRtpSharedPacket* pkt);
srs_error_t collect_audio_frame();
srs_error_t on_video(SrsUdpMuxSocket* skt, SrsRtpSharedPacket* pkt);
srs_error_t on_video(SrsRtpSharedPacket* pkt);
srs_error_t collect_video_frame();
public:
void update_sendonly_socket(SrsUdpMuxSocket* skt);
void request_keyframe();
// interface ISrsHourGlass
public:
@ -311,13 +305,17 @@ class SrsRtcSession
friend class SrsRtcPublisher;
private:
SrsRtcServer* rtc_server;
SrsSdp remote_sdp;
SrsSdp local_sdp;
SrsRtcSessionStateType session_state;
SrsDtlsSession* dtls_session;
SrsRtcSenderThread* sender;
SrsRtcPublisher* publisher;
private:
SrsUdpMuxSocket* sendonly_skt;
std::string username;
std::string peer_id;
private:
// The timeout of session, keep alive by STUN ping pong.
srs_utime_t sessionStunTimeout;
srs_utime_t last_stun_time;
private:
// For each RTC session, we use a specified cid for debugging logs.
@ -327,17 +325,14 @@ private:
// Sepcifies by HTTP API, query encrypt, optional.
// TODO: FIXME: Support reload.
bool encrypt;
// The timeout of session, keep alive by STUN ping pong.
srs_utime_t sessionStunTimeout;
SrsRequest* req;
SrsSource* source;
SrsSdp remote_sdp;
SrsSdp local_sdp;
private:
bool blackhole;
sockaddr_in* blackhole_addr;
srs_netfd_t blackhole_stfd;
public:
SrsRequest* req;
SrsSource* source;
private:
SrsRtcPublisher* publisher;
public:
SrsRtcSession(SrsRtcServer* s, SrsRequest* r, const std::string& un, int context_id);
virtual ~SrsRtcSession();
@ -360,27 +355,28 @@ public:
void switch_to_context();
int context_id() { return cid; }
public:
srs_error_t initialize();
srs_error_t on_stun(SrsUdpMuxSocket* skt, SrsStunPacket* stun_req);
srs_error_t on_dtls(SrsUdpMuxSocket* skt);
srs_error_t on_rtcp(SrsUdpMuxSocket* skt);
srs_error_t on_rtp(SrsUdpMuxSocket* skt);
public:
srs_error_t send_client_hello(SrsUdpMuxSocket* skt);
srs_error_t on_connection_established(SrsUdpMuxSocket* skt);
srs_error_t start_play(SrsUdpMuxSocket* skt);
srs_error_t start_publish(SrsUdpMuxSocket* skt);
public:
// The peer address may change, we can identify that by STUN messages.
srs_error_t on_stun(SrsUdpMuxSocket* skt, SrsStunPacket* r);
srs_error_t on_dtls(char* data, int nb_data);
srs_error_t on_rtcp(char* data, int nb_data);
srs_error_t on_rtp(char* data, int nb_data);
public:
srs_error_t send_client_hello();
srs_error_t on_connection_established();
srs_error_t start_play();
srs_error_t start_publish();
bool is_stun_timeout();
void update_sendonly_socket(SrsUdpMuxSocket* skt);
private:
srs_error_t on_binding_request(SrsUdpMuxSocket* skt, SrsStunPacket* stun_req);
private:
srs_error_t on_rtcp_feedback(char* buf, int nb_buf, SrsUdpMuxSocket* skt);
srs_error_t on_rtcp_ps_feedback(char* buf, int nb_buf, SrsUdpMuxSocket* skt);
srs_error_t on_rtcp_xr(char* buf, int nb_buf, SrsUdpMuxSocket* skt);
srs_error_t on_rtcp_sender_report(char* buf, int nb_buf, SrsUdpMuxSocket* skt);
srs_error_t on_rtcp_receiver_report(char* buf, int nb_buf, SrsUdpMuxSocket* skt);
srs_error_t on_binding_request(SrsStunPacket* r);
srs_error_t on_rtcp_feedback(char* data, int nb_data);
srs_error_t on_rtcp_ps_feedback(char* data, int nb_data);
srs_error_t on_rtcp_xr(char* data, int nb_data);
srs_error_t on_rtcp_sender_report(char* data, int nb_data);
srs_error_t on_rtcp_receiver_report(char* data, int nb_data);
};
class SrsUdpMuxSender : virtual public ISrsUdpSender, virtual public ISrsCoroutineHandler, virtual public ISrsReloadHandler
@ -455,10 +451,6 @@ public:
bool insert_into_id_sessions(const std::string& peer_id, SrsRtcSession* rtc_session);
void check_and_clean_timeout_session();
int nn_sessions() { return (int)map_username_session.size(); }
private:
srs_error_t on_stun(SrsUdpMuxSocket* skt);
srs_error_t on_dtls(SrsUdpMuxSocket* skt);
srs_error_t on_rtp_or_rtcp(SrsUdpMuxSocket* skt);
private:
SrsRtcSession* find_rtc_session_by_username(const std::string& ufrag);
SrsRtcSession* find_rtc_session_by_peer_id(const std::string& peer_id);

Write Preview
Loading…
Cancel
Save