RTC: Remove dead code. Fix DTLS empty ctx issue

trunk/src/app/srs_app_rtc_conn.cpp

@@ -89,10 +89,13 @@ srs_error_t SrsSecurityTransport::start_active_handshake()
 srs_error_t SrsSecurityTransport::write_dtls_data(void* data, int size) 
 {
     srs_error_t err = srs_success;
-    if (size) {
+
-        if ((err = session_->sendonly_skt->sendto(data, size, 0)) != srs_success) {
+    if (!size) {
-            return srs_error_wrap(err, "send dtls packet");
+        return err;
-        }
+    }
+
+    if ((err = session_->sendonly_skt->sendto(data, size, 0)) != srs_success) {
+        return srs_error_wrap(err, "send dtls packet");
     }
 
     if (_srs_blackhole->blackhole) {
@@ -114,13 +117,13 @@ srs_error_t SrsSecurityTransport::on_dtls_handshake_done()
     if (handshake_done) {
         return err;
     }
+    handshake_done = true;
 
     // TODO: FIXME: Add cost for DTLS.
     srs_trace("RTC: DTLS handshake done.");
 
-    handshake_done = true;
     if ((err = srtp_initialize()) != srs_success) {
-        return srs_error_wrap(err, "srtp init failed");
+        return srs_error_wrap(err, "srtp init");
     }
 
     return session_->on_connection_established();
@@ -147,7 +150,7 @@ srs_error_t SrsSecurityTransport::srtp_initialize()
     }
     
     if ((err = srtp_->initialize(recv_key, send_key)) != srs_success) {
-        return srs_error_wrap(err, "srtp init failed");
+        return srs_error_wrap(err, "srtp init");
     }
 
     return err;
@@ -155,56 +158,32 @@ srs_error_t SrsSecurityTransport::srtp_initialize()
 
 srs_error_t SrsSecurityTransport::protect_rtp(const char* plaintext, char* cipher, int& nb_cipher)
 {
-    if (!srtp_) {
-        return srs_error_new(ERROR_RTC_SRTP_PROTECT, "rtp protect failed");
-    }
-
     return srtp_->protect_rtp(plaintext, cipher, nb_cipher);
 }
 
 srs_error_t SrsSecurityTransport::protect_rtcp(const char* plaintext, char* cipher, int& nb_cipher)
 {
-    if (!srtp_) {
-        return srs_error_new(ERROR_RTC_SRTP_PROTECT, "rtcp protect failed");
-    }
-
     return srtp_->protect_rtcp(plaintext, cipher, nb_cipher);
 }
 
 // TODO: FIXME: Merge with protect_rtp.
 srs_error_t SrsSecurityTransport::protect_rtp2(void* rtp_hdr, int* len_ptr)
 {
-    if (!srtp_) {
-        return srs_error_new(ERROR_RTC_SRTP_PROTECT, "rtp protect");
-    }
-
     return srtp_->protect_rtp2(rtp_hdr, len_ptr);
 }
 
 srs_error_t SrsSecurityTransport::unprotect_rtp(const char* cipher, char* plaintext, int& nb_plaintext)
 {
-    if (!srtp_) {
-        return srs_error_new(ERROR_RTC_SRTP_UNPROTECT, "rtp unprotect failed");
-    }
-    
     return srtp_->unprotect_rtp(cipher, plaintext, nb_plaintext);
 }
 
 srs_error_t SrsSecurityTransport::unprotect_rtcp(const char* cipher, char* plaintext, int& nb_plaintext)
 {
-    if (!srtp_) {
-        return srs_error_new(ERROR_RTC_SRTP_UNPROTECT, "rtcp unprotect failed");
-    }
-
     return srtp_->unprotect_rtcp(cipher, plaintext, nb_plaintext);
 }
 
 SrsRtcPlayStreamStatistic::SrsRtcPlayStreamStatistic()
 {
-#if defined(SRS_DEBUG)
-    debug_id = 0;
-#endif
-
     nn_rtp_pkts = 0;
     nn_audios = nn_extras = 0;
     nn_videos = nn_samples = 0;
@@ -353,18 +332,18 @@ srs_error_t SrsRtcPlayStream::cycle()
     SrsRequest* req = session_->req;
 
     if ((err = _srs_rtc_sources->fetch_or_create(req, &source)) != srs_success) {
-        return srs_error_wrap(err, "rtc fetch source failed");
+        return srs_error_wrap(err, "fetch source");
     }
 
     SrsRtcConsumer* consumer = NULL;
     SrsAutoFree(SrsRtcConsumer, consumer);
     if ((err = source->create_consumer(consumer)) != srs_success) {
-        return srs_error_wrap(err, "rtc create consumer, source url=%s", req->get_stream_url().c_str());
+        return srs_error_wrap(err, "create consumer, source=%s", req->get_stream_url().c_str());
     }
 
     // TODO: FIXME: Dumps the SPS/PPS from gop cache, without other frames.
     if ((err = source->consumer_dumps(consumer)) != srs_success) {
-        return srs_error_wrap(err, "dumps consumer, source url=%s", req->get_stream_url().c_str());
+        return srs_error_wrap(err, "dumps consumer, url=%s", req->get_stream_url().c_str());
     }
 
     realtime = _srs_config->get_realtime_enabled(req->vhost, true);
@@ -447,11 +426,6 @@ srs_error_t SrsRtcPlayStream::send_packets(SrsRtcStream* source, const vector<Sr
 {
     srs_error_t err = srs_success;
 
-    // If DTLS is not OK, drop all messages.
-    if (!session_->transport_) {
-        return err;
-    }
-
     vector<SrsRtpPacket2*> send_pkts;
     // Covert kernel messages to RTP packets.
     for (int i = 0; i < (int)pkts.size(); i++) {

trunk/src/app/srs_app_rtc_conn.hpp

@@ -131,11 +131,6 @@ private:
 // A group of RTP packets for outgoing(send to players).
 class SrsRtcPlayStreamStatistic
 {
-public:
-#if defined(SRS_DEBUG)
-    // Debug id.
-    uint32_t debug_id;
-#endif
 public:
     // The total bytes of AVFrame packets.
     int nn_bytes;

trunk/src/app/srs_app_rtc_dtls.cpp

@@ -35,6 +35,7 @@ using namespace std;
 
 #include <srtp2/srtp.h>
 #include <openssl/ssl.h>
+#include <openssl/err.h>
 
 // The return value of verify_callback controls the strategy of the further verification process. If verify_callback
 // returns 0, the verification process is immediately stopped with "verification failed" state. If SSL_VERIFY_PEER is
@@ -161,7 +162,7 @@ srs_error_t SrsDtlsCertificate::initialize()
         int serial = rand();
         ASN1_INTEGER_set(X509_get_serialNumber(dtls_cert), serial);
 
-        const std::string& aor = "ossrs.net";
+        const std::string& aor = RTMP_SIG_SRS_DOMAIN;
         X509_NAME_add_entry_by_txt(subject, "CN", MBSTRING_ASC, (unsigned char *) aor.data(), aor.size(), -1, 0);
 
         X509_set_issuer_name(dtls_cert, subject);
@@ -385,10 +386,6 @@ srs_error_t SrsDtls::do_handshake()
 {
     srs_error_t err = srs_success;
 
-    if (!callback) {
-        return srs_error_new(ERROR_RTC_DTLS, "no callback");
-    }
-
     int ret = SSL_do_handshake(dtls);
 
     unsigned char *out_bio_data;
@@ -419,7 +416,7 @@ srs_error_t SrsDtls::do_handshake()
 
     if (out_bio_len) {
         if ((err = callback->write_dtls_data(out_bio_data, out_bio_len)) != srs_success) {
-            return srs_error_wrap(err, "dtls send");
+            return srs_error_wrap(err, "dtls send size=%u", out_bio_len);
         }
     }
 
@@ -450,7 +447,7 @@ srs_error_t SrsDtls::on_dtls(char* data, int nb_data)
 
             if (nb > 0 && callback) {
                 if ((err = callback->on_dtls_application_data(dtls_read_buf, nb)) != srs_success) {
-                    return srs_error_wrap(err, "dtls application data process");
+                    return srs_error_wrap(err, "on DTLS data, size=%u", nb);
                 }
             }
         }
@@ -477,7 +474,7 @@ srs_error_t SrsDtls::get_srtp_key(std::string& recv_key, std::string& send_key)
     unsigned char material[SRTP_MASTER_KEY_LEN * 2] = {0};  // client(SRTP_MASTER_KEY_KEY_LEN + SRTP_MASTER_KEY_SALT_LEN) + server
     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");
+        return srs_error_new(ERROR_RTC_SRTP_INIT, "SSL export key r0=%u", ERR_get_error());
     }
 
     size_t offset = 0;
@@ -544,8 +541,9 @@ srs_error_t SrsSRTP::initialize(string recv_key, std::string send_key)
     memcpy(rkey, recv_key.data(), recv_key.size());
     policy.key = rkey;
 
-    if (srtp_create(&recv_ctx_, &policy) != srtp_err_status_ok) {
+    srtp_err_status_t r0 = srtp_err_status_ok;
-        return srs_error_new(ERROR_RTC_SRTP_INIT, "srtp_create recv failed");
+    if ((r0 = srtp_create(&recv_ctx_, &policy)) != srtp_err_status_ok) {
+        return srs_error_new(ERROR_RTC_SRTP_INIT, "srtp create r0=%u", r0);
     }
 
     policy.ssrc.type = ssrc_any_outbound;
@@ -554,8 +552,8 @@ srs_error_t SrsSRTP::initialize(string recv_key, std::string send_key)
     memcpy(skey, send_key.data(), send_key.size());
     policy.key = skey;
 
-    if (srtp_create(&send_ctx_, &policy) != srtp_err_status_ok) {
+    if ((r0 = srtp_create(&send_ctx_, &policy)) != srtp_err_status_ok) {
-        return srs_error_new(ERROR_RTC_SRTP_INIT, "srtp_create recv failed");
+        return srs_error_new(ERROR_RTC_SRTP_INIT, "srtp create r0=%u", r0);
     }
 
     return err;
@@ -565,10 +563,16 @@ srs_error_t SrsSRTP::protect_rtp(const char* plaintext, char* cipher, int& nb_ci
 {
     srs_error_t err = srs_success;
 
+    // If DTLS/SRTP is not ready, fail.
+    if (!send_ctx_) {
+        return srs_error_new(ERROR_RTC_SRTP_PROTECT, "not ready");
+    }
+
     memcpy(cipher, plaintext, nb_cipher);
-    // TODO: FIXME: Wrap error code.
+
-    if (srtp_protect(send_ctx_, cipher, &nb_cipher) != 0) {
+    srtp_err_status_t r0 = srtp_err_status_ok;
-        return srs_error_new(ERROR_RTC_SRTP_PROTECT, "rtp protect failed");
+    if ((r0 = srtp_protect(send_ctx_, cipher, &nb_cipher)) != srtp_err_status_ok) {
+        return srs_error_new(ERROR_RTC_SRTP_PROTECT, "rtp protect r0=%u", r0);
     }
 
     return err;
@@ -578,10 +582,16 @@ srs_error_t SrsSRTP::protect_rtcp(const char* plaintext, char* cipher, int& nb_c
 {
     srs_error_t err = srs_success;
 
+    // If DTLS/SRTP is not ready, fail.
+    if (!send_ctx_) {
+        return srs_error_new(ERROR_RTC_SRTP_PROTECT, "not ready");
+    }
+
     memcpy(cipher, plaintext, nb_cipher);
-    // TODO: FIXME: Wrap error code.
+
-    if (srtp_protect_rtcp(send_ctx_, cipher, &nb_cipher) != 0) {
+    srtp_err_status_t r0 = srtp_err_status_ok;
-        return srs_error_new(ERROR_RTC_SRTP_PROTECT, "rtcp protect failed");
+    if ((r0 = srtp_protect_rtcp(send_ctx_, cipher, &nb_cipher)) != srtp_err_status_ok) {
+        return srs_error_new(ERROR_RTC_SRTP_PROTECT, "rtcp protect r0=%u", r0);
     }
 
     return err;
@@ -591,9 +601,14 @@ srs_error_t SrsSRTP::protect_rtp2(void* rtp_hdr, int* len_ptr)
 {
     srs_error_t err = srs_success;
 
-    // TODO: FIXME: Wrap error code.
+    // If DTLS/SRTP is not ready, fail.
-    if (srtp_protect(send_ctx_, rtp_hdr, len_ptr) != 0) {
+    if (!send_ctx_) {
-        return srs_error_new(ERROR_RTC_SRTP_PROTECT, "rtp protect");
+        return srs_error_new(ERROR_RTC_SRTP_PROTECT, "not ready");
+    }
+
+    srtp_err_status_t r0 = srtp_err_status_ok;
+    if ((r0 = srtp_protect(send_ctx_, rtp_hdr, len_ptr)) != srtp_err_status_ok) {
+        return srs_error_new(ERROR_RTC_SRTP_PROTECT, "rtp protect r0=%u", r0);
     }
 
     return err;
@@ -603,10 +618,16 @@ srs_error_t SrsSRTP::unprotect_rtp(const char* cipher, char* plaintext, int& nb_
 {
     srs_error_t err = srs_success;
 
+    // If DTLS/SRTP is not ready, fail.
+    if (!recv_ctx_) {
+        return srs_error_new(ERROR_RTC_SRTP_UNPROTECT, "not ready");
+    }
+
     memcpy(plaintext, cipher, nb_plaintext);
-    srtp_err_status_t r0 = srtp_unprotect(recv_ctx_, plaintext, &nb_plaintext);
+
-    if (r0 != srtp_err_status_ok) {
+    srtp_err_status_t r0 = srtp_err_status_ok;
-        return srs_error_new(ERROR_RTC_SRTP_UNPROTECT, "unprotect r0=%u", r0);
+    if ((r0 = srtp_unprotect(recv_ctx_, plaintext, &nb_plaintext)) != srtp_err_status_ok) {
+        return srs_error_new(ERROR_RTC_SRTP_UNPROTECT, "rtp unprotect r0=%u", r0);
     }
 
     return err;
@@ -616,11 +637,18 @@ srs_error_t SrsSRTP::unprotect_rtcp(const char* cipher, char* plaintext, int& nb
 {
     srs_error_t err = srs_success;
 
+    // If DTLS/SRTP is not ready, fail.
+    if (!recv_ctx_) {
+        return srs_error_new(ERROR_RTC_SRTP_UNPROTECT, "not ready");
+    }
+
     memcpy(plaintext, cipher, nb_plaintext);
-    // TODO: FIXME: Wrap error code.
+
-    if (srtp_unprotect_rtcp(recv_ctx_, plaintext, &nb_plaintext) != srtp_err_status_ok) {
+    srtp_err_status_t r0 = srtp_err_status_ok;
-        return srs_error_new(ERROR_RTC_SRTP_UNPROTECT, "rtcp unprotect failed");
+    if ((r0 = srtp_unprotect_rtcp(recv_ctx_, plaintext, &nb_plaintext)) != srtp_err_status_ok) {
+        return srs_error_new(ERROR_RTC_SRTP_UNPROTECT, "rtcp unprotect r0=%u", r0);
     }
 
     return err;
-}
+}
+

trunk/src/app/srs_app_rtc_source.cpp

@@ -1627,11 +1627,6 @@ srs_error_t SrsRtcRecvTrack::on_nack(SrsRtpPacket2* pkt)
     return err;
 }
 
-srs_error_t SrsRtcRecvTrack::on_rtp(SrsRtcStream* source, SrsRtpPacket2* pkt)
-{
-    return srs_success;
-}
-
 SrsRtcAudioRecvTrack::SrsRtcAudioRecvTrack(SrsRtcConnection* session, SrsRtcTrackDescription* track_desc)
     : SrsRtcRecvTrack(session, track_desc, true)
 {
@@ -1765,16 +1760,6 @@ std::string SrsRtcSendTrack::get_track_id()
     return track_desc_->id_;
 }
 
-srs_error_t SrsRtcSendTrack::on_rtp(SrsRtpPacket2* pkt, SrsRtcPlayStreamStatistic& info)
-{
-    return srs_success;
-}
-
-srs_error_t SrsRtcSendTrack::on_rtcp(SrsRtpPacket2* pkt)
-{
-    return srs_success;
-}
-
 void SrsRtcSendTrack::on_recv_nack()
 {
     SrsRtcTrackStatistic* statistic = statistic_;

trunk/src/app/srs_app_rtc_source.hpp

@@ -471,7 +471,7 @@ public:
 protected:
     srs_error_t on_nack(SrsRtpPacket2* pkt);
 public:
-    virtual srs_error_t on_rtp(SrsRtcStream* source, SrsRtpPacket2* pkt);
+    virtual srs_error_t on_rtp(SrsRtcStream* source, SrsRtpPacket2* pkt) = 0;
 };
 
 class SrsRtcAudioRecvTrack : public SrsRtcRecvTrack
@@ -517,8 +517,8 @@ public:
     bool get_track_status();
     std::string get_track_id();
 public:
-    virtual srs_error_t on_rtp(SrsRtpPacket2* pkt, SrsRtcPlayStreamStatistic& info);
+    virtual srs_error_t on_rtp(SrsRtpPacket2* pkt, SrsRtcPlayStreamStatistic& info) = 0;
-    virtual srs_error_t on_rtcp(SrsRtpPacket2* pkt);
+    virtual srs_error_t on_rtcp(SrsRtpPacket2* pkt) = 0;
     virtual void on_recv_nack();
 };
 

trunk/src/core/srs_core.hpp

@@ -46,6 +46,7 @@
 #define RTMP_SIG_SRS_AUTHORS "Winlin,Wenjie,Runner365,John,B.P.Y,Lixin"
 #define RTMP_SIG_SRS_VERSION SRS_XSTR(VERSION_MAJOR) "." SRS_XSTR(VERSION_MINOR) "." SRS_XSTR(VERSION_REVISION)
 #define RTMP_SIG_SRS_SERVER RTMP_SIG_SRS_KEY "/" RTMP_SIG_SRS_VERSION "(" RTMP_SIG_SRS_CODE ")"
+#define RTMP_SIG_SRS_DOMAIN "ossrs.net"
 
 // The current stable release.
 #define VERSION_STABLE 3