process err, do error check, add some error code

trunk/src/app/srs_app_http_api.cpp

@@ -801,9 +801,15 @@ srs_error_t SrsGoApiSdp::serve_http(ISrsHttpResponseWriter* w, ISrsHttpMessage*
     // e.g. /api/v1/sdp/ args = json:{"sdp":"sdp...", "app":"webrtc", "stream":"test"}
     
     string req_json;
-    r->body_read_all(req_json);
+    if ((err = r->body_read_all(req_json)) != srs_success) {
+        return srs_api_response_code(w, r, SRS_CONSTS_HTTP_BadRequest);
+    }
 
     SrsJsonAny* json = SrsJsonAny::loads(req_json);
+    if (json == NULL) {
+        return srs_api_response_code(w, r, SRS_CONSTS_HTTP_BadRequest);
+    }
+
     SrsJsonObject* req_obj = json->to_object();
 
     SrsJsonAny* remote_sdp_obj = req_obj->get_property("sdp");
@@ -832,8 +838,7 @@ srs_error_t SrsGoApiSdp::serve_http(ISrsHttpResponseWriter* w, ISrsHttpMessage*
     SrsRtcSession* rtc_session = rtc_server->create_rtc_session(request, remote_sdp, local_sdp);
 
     string local_sdp_str = "";
-    err = local_sdp.encode(local_sdp_str);
+    if ((err = local_sdp.encode(local_sdp_str)) != srs_success) {
-    if (err != srs_success) {
         return srs_api_response_code(w, r, SRS_CONSTS_HTTP_BadRequest);
     }
 

trunk/src/app/srs_app_listener.cpp

@@ -278,20 +278,21 @@ int SrsUdpMuxSocket::recvfrom(srs_utime_t timeout)
     return nread;
 }
 
-int SrsUdpMuxSocket::sendto(void* data, int size, srs_utime_t timeout)
+srs_error_t SrsUdpMuxSocket::sendto(void* data, int size, srs_utime_t timeout)
 {
-    return srs_sendto(lfd, data, size, (sockaddr*)&from, fromlen, timeout);
+    srs_error_t err = srs_success;
-}
 
-int SrsUdpMuxSocket::sendtov(struct iovec* iov, size_t iovlen, srs_utime_t timeout)
+    int nb_write = srs_sendto(lfd, data, size, (sockaddr*)&from, fromlen, timeout);
-{
-     struct msghdr udphdr = {0};
-     udphdr.msg_name = &from;
-     udphdr.msg_namelen = fromlen;
-     udphdr.msg_iov = iov;
-     udphdr.msg_iovlen = iovlen;
 
-    return srs_sendmsg(lfd, &udphdr, 0, timeout);
+	if (nb_write <= 0) {
+        if (nb_write < 0 && errno == ETIME) {
+            return srs_error_new(ERROR_SOCKET_TIMEOUT, "sendto timeout %d ms", srsu2msi(timeout));
+        }   
+    
+        return srs_error_new(ERROR_SOCKET_WRITE, "sendto");
+    }   
+
+    return err;
 }
 
 std::string SrsUdpMuxSocket::get_peer_id()

trunk/src/app/srs_app_listener.hpp

@@ -146,8 +146,7 @@ public:
     SrsUdpMuxSocket& operator=(const SrsUdpMuxSocket& rhs);
 
     int recvfrom(srs_utime_t timeout);
-    int sendto(void* data, int size, srs_utime_t timeout);
+    srs_error_t sendto(void* data, int size, srs_utime_t timeout);
-    int sendtov(struct iovec* iov, size_t iovlen, srs_utime_t timeout);
 
     char* data() { return buf; }
     int size() { return nread; }

trunk/src/app/srs_app_rtc_conn.cpp

@@ -327,9 +327,11 @@ srs_error_t SrsDtlsSession::handshake(SrsUdpMuxSocket* udp_mux_skt)
     int ssl_err = SSL_get_error(dtls, ret); 
     switch(ssl_err) {   
         case SSL_ERROR_NONE: {   
-            err = on_dtls_handshake_done(udp_mux_skt);
+            if ((err = on_dtls_handshake_done(udp_mux_skt)) != srs_success) {
+                return srs_error_wrap(err, "dtls handshake done handle");
+            }
+            break;
         }  
-        break;
 
         case SSL_ERROR_WANT_READ: {   
             break;
@@ -345,7 +347,9 @@ srs_error_t SrsDtlsSession::handshake(SrsUdpMuxSocket* udp_mux_skt)
     }   
 
     if (out_bio_len) {   
-        udp_mux_skt->sendto(out_bio_data, out_bio_len, 0);
+        if ((err = udp_mux_skt->sendto(out_bio_data, out_bio_len, 0)) != srs_success) {
+            return srs_error_wrap(err, "send dtls packet");
+        }
     }
 
     return err;
@@ -354,23 +358,29 @@ srs_error_t SrsDtlsSession::handshake(SrsUdpMuxSocket* udp_mux_skt)
 srs_error_t SrsDtlsSession::on_dtls(SrsUdpMuxSocket* udp_mux_skt)
 {
     srs_error_t err = srs_success;
+	if (BIO_reset(bio_in) != 1) {
+        return srs_error_new(ERROR_OpenSslBIOReset, "BIO_reset");
+    }
+    if (BIO_reset(bio_out) != 1) {
+        return srs_error_new(ERROR_OpenSslBIOReset, "BIO_reset");
+    }
+
+    if (BIO_write(bio_in, udp_mux_skt->data(), udp_mux_skt->size()) <= 0) {
+        // TODO: 0 or -1 maybe block, use BIO_should_retry to check.
+        return srs_error_new(ERROR_OpenSslBIOWrite, "BIO_write");
+    }
+
     if (! handshake_done) {
-		BIO_reset(bio_in);
+        err = handshake(udp_mux_skt);
-        BIO_reset(bio_out);
-        BIO_write(bio_in, udp_mux_skt->data(), udp_mux_skt->size());
-
-        handshake(udp_mux_skt);
     } else {
-		BIO_reset(bio_in);
-        BIO_reset(bio_out);
-        BIO_write(bio_in, udp_mux_skt->data(), udp_mux_skt->size());
-
         while (BIO_ctrl_pending(bio_in) > 0) {
             char dtls_read_buf[8092];
             int nb = SSL_read(dtls, dtls_read_buf, sizeof(dtls_read_buf));
 
             if (nb > 0) {
-                on_dtls_application_data(dtls_read_buf, nb);
+                if ((err =on_dtls_application_data(dtls_read_buf, nb)) != srs_success) {
+                    return srs_error_wrap(err, "dtls application data process");
+                }
             }
         }
     }
@@ -389,33 +399,46 @@ srs_error_t SrsDtlsSession::on_dtls_handshake_done(SrsUdpMuxSocket* udp_mux_skt)
         return srs_error_wrap(err, "srtp init failed");
     }
 
-    rtc_session->on_connection_established(udp_mux_skt);
+    return rtc_session->on_connection_established(udp_mux_skt);
-
-    return err;
 }
 
 srs_error_t SrsDtlsSession::on_dtls_application_data(const char* buf, const int nb_buf)
 {
     srs_error_t err = srs_success;
 
+    // TODO: process SCTP protocol(WebRTC datachannel support)
+
     return err;
 }
 
-void SrsDtlsSession::send_client_hello(SrsUdpMuxSocket* udp_mux_skt)
+srs_error_t SrsDtlsSession::send_client_hello(SrsUdpMuxSocket* udp_mux_skt)
 {
+    srs_error_t err = srs_success;
+
     if (dtls == NULL) {    
         srs_verbose("send client hello");
 
-        dtls = SSL_new(SrsDtls::instance()->get_dtls_ctx());
+        if ((dtls = SSL_new(SrsDtls::instance()->get_dtls_ctx())) == NULL) {
+            return srs_error_new(ERROR_OpenSslCreateSSL, "SSL_new dtls");
+        }
+
         SSL_set_connect_state(dtls);
 
-        bio_in  = BIO_new(BIO_s_mem());
+        if ((bio_in = BIO_new(BIO_s_mem())) == NULL) {
-        bio_out = BIO_new(BIO_s_mem());
+            return srs_error_new(ERROR_OpenSslBIONew, "BIO_new in");
+        }
+
+        if ((bio_out = BIO_new(BIO_s_mem())) == NULL) {
+            BIO_free(bio_in);
+            return srs_error_new(ERROR_OpenSslBIONew, "BIO_new out");
+        }
 
         SSL_set_bio(dtls, bio_in, bio_out);
 
-        handshake(udp_mux_skt);
+        return handshake(udp_mux_skt);
     } 
+
+    return err;
 }
 
 srs_error_t SrsDtlsSession::srtp_initialize() 
@@ -724,7 +747,7 @@ srs_error_t SrsRtcSession::on_stun(SrsUdpMuxSocket* udp_mux_skt, SrsStunPacket*
     srs_error_t err = srs_success;
 
     if (stun_req->is_binding_request()) {
-        if (on_binding_request(udp_mux_skt, stun_req) != srs_success) {
+        if ((err = on_binding_request(udp_mux_skt, stun_req)) != srs_success) {
             return srs_error_wrap(err, "stun binding request failed");
         }
     }
@@ -758,17 +781,20 @@ srs_error_t SrsRtcSession::on_binding_request(SrsUdpMuxSocket* udp_mux_skt, SrsS
     stun_binding_response.set_mapped_address(be32toh(inet_addr(udp_mux_skt->get_peer_ip().c_str())));
     stun_binding_response.set_mapped_port(udp_mux_skt->get_peer_port());
 
-    if (stun_binding_response.encode(get_local_sdp()->get_ice_pwd(), stream) != srs_success) {
+    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 (udp_mux_skt->sendto(stream->data(), stream->pos(), 0) <= 0) {
+    if ((err = udp_mux_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) {
+        if ((err = send_client_hello(udp_mux_skt)) != srs_success) {
+            return srs_error_wrap(err, "send client hello, failed");
+        }
+
         set_session_state(DOING_DTLS_HANDSHAKE);
-        send_client_hello(udp_mux_skt);
 
         peer_id = udp_mux_skt->get_peer_id();
         rtc_server->insert_into_id_sessions(peer_id, this);
@@ -983,17 +1009,21 @@ block  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 
 srs_error_t SrsRtcSession::send_client_hello(SrsUdpMuxSocket* udp_mux_skt)
 {
+    srs_error_t err = srs_success;
+
     if (dtls_session == NULL) {
         dtls_session = new SrsDtlsSession(this);
     }
 
     dtls_session->send_client_hello(udp_mux_skt);
+
+    return err;
 }
 
-void SrsRtcSession::on_connection_established(SrsUdpMuxSocket* udp_mux_skt)
+srs_error_t SrsRtcSession::on_connection_established(SrsUdpMuxSocket* udp_mux_skt)
 {
     srs_trace("rtc session=%s, connection established", id().c_str());
-    start_play(udp_mux_skt);
+    return start_play(udp_mux_skt);
 }
 
 srs_error_t SrsRtcSession::start_play(SrsUdpMuxSocket* udp_mux_skt)
@@ -1002,7 +1032,9 @@ srs_error_t SrsRtcSession::start_play(SrsUdpMuxSocket* udp_mux_skt)
 
     srs_freep(strd);
     strd = new SrsRtcSenderThread(this, udp_mux_skt, _srs_context->get_id());
-    strd->start();
+    if ((err = strd->start()) != srs_success) {
+        return srs_error_wrap(err, "start SrsRtcSenderThread");
+    }
 
     return err;
 }
@@ -1016,12 +1048,12 @@ srs_error_t SrsRtcSession::on_rtp(SrsUdpMuxSocket* udp_mux_skt)
 {
     srs_error_t err = srs_success;
     if (dtls_session == NULL) {
-        return srs_error_wrap(err, "recv unexpect rtp packet before dtls done");
+        return srs_error_new(ERROR_RTC_RTP, "recv unexpect rtp packet before dtls done");
     }
 
     char unprotected_buf[1460];
     int nb_unprotected_buf = udp_mux_skt->size();
-    if (dtls_session->unprotect_rtp(unprotected_buf, udp_mux_skt->data(), nb_unprotected_buf) != srs_success) {
+    if ((err = dtls_session->unprotect_rtp(unprotected_buf, udp_mux_skt->data(), nb_unprotected_buf)) != srs_success) {
         return srs_error_wrap(err, "rtp unprotect failed");
     }
 
@@ -1066,12 +1098,12 @@ srs_error_t SrsRtcSession::on_rtcp(SrsUdpMuxSocket* udp_mux_skt)
     srs_error_t err = srs_success;
 
     if (dtls_session == NULL) {
-        return srs_error_wrap(err, "recv unexpect rtcp packet before dtls done");
+        return srs_error_new(ERROR_RTC_RTCP, "recv unexpect rtp packet before dtls done");
     }
 
     char unprotected_buf[1460];
     int nb_unprotected_buf = udp_mux_skt->size();
-    if (dtls_session->unprotect_rtcp(unprotected_buf, udp_mux_skt->data(), nb_unprotected_buf) != srs_success) {
+    if ((err = dtls_session->unprotect_rtcp(unprotected_buf, udp_mux_skt->data(), nb_unprotected_buf)) != srs_success) {
         return srs_error_wrap(err, "rtcp unprotect failed");
     }
 
@@ -1084,7 +1116,7 @@ srs_error_t SrsRtcSession::on_rtcp(SrsUdpMuxSocket* udp_mux_skt)
         int length = (length_4bytes + 1) * 4;
 
         if (length > nb_unprotected_buf) {
-            return srs_error_wrap(err, "invalid rtcp packet, length=%u", length);
+            return srs_error_new(ERROR_RTC_RTCP, "invalid rtcp packet, length=%u", length);
         }
 
         srs_verbose("on rtcp, payload_type=%u", payload_type);
@@ -1120,8 +1152,8 @@ srs_error_t SrsRtcSession::on_rtcp(SrsUdpMuxSocket* udp_mux_skt)
             }
         }
 
-        if (err !=  srs_success) {
+        if (err != srs_success) {
-            return err;
+            return srs_error_wrap(err, "rtcp");
         }
 
         ph += length;
@@ -1156,8 +1188,6 @@ srs_error_t SrsRtcServer::initialize()
 
 srs_error_t SrsRtcServer::on_udp_packet(SrsUdpMuxSocket* udp_mux_skt)
 {
-    srs_error_t err = srs_success;
-
     if (is_stun(reinterpret_cast<const uint8_t*>(udp_mux_skt->data()), udp_mux_skt->size())) {
         return on_stun(udp_mux_skt);
     } else if (is_dtls(reinterpret_cast<const uint8_t*>(udp_mux_skt->data()), udp_mux_skt->size())) {
@@ -1166,7 +1196,7 @@ srs_error_t SrsRtcServer::on_udp_packet(SrsUdpMuxSocket* udp_mux_skt)
         return on_rtp_or_rtcp(udp_mux_skt);
     } 
 
-    return srs_error_wrap(err, "unknown udp packet type");
+    return srs_error_new(ERROR_RTC_UDP, "unknown udp packet type");
 }
 
 SrsRtcSession* SrsRtcServer::create_rtc_session(const SrsRequest& req, const SrsSdp& remote_sdp, SrsSdp& local_sdp)
@@ -1213,14 +1243,14 @@ srs_error_t SrsRtcServer::on_stun(SrsUdpMuxSocket* udp_mux_skt)
     srs_verbose("recv stun packet from %s", udp_mux_skt->get_peer_id().c_str());
 
     SrsStunPacket stun_req;
-    if (stun_req.decode(udp_mux_skt->data(), udp_mux_skt->size()) != srs_success) {
+    if ((err = stun_req.decode(udp_mux_skt->data(), udp_mux_skt->size())) != srs_success) {
         return srs_error_wrap(err, "decode stun packet failed");
     }
 
     std::string username = stun_req.get_username();
     SrsRtcSession* rtc_session = find_rtc_session_by_username(username);
     if (rtc_session == NULL) {
-        return srs_error_wrap(err, "can not find rtc_session, stun username=%s", username.c_str());
+        return srs_error_new(ERROR_RTC_STUN, "can not find rtc_session, stun username=%s", username.c_str());
     }
 
     return rtc_session->on_stun(udp_mux_skt, &stun_req);
@@ -1233,12 +1263,10 @@ srs_error_t SrsRtcServer::on_dtls(SrsUdpMuxSocket* udp_mux_skt)
     SrsRtcSession* rtc_session = find_rtc_session_by_peer_id(udp_mux_skt->get_peer_id());
 
     if (rtc_session == NULL) {
-        return srs_error_wrap(err, "can not find rtc session by peer_id=%s", udp_mux_skt->get_peer_id().c_str());
+        return srs_error_new(ERROR_RTC_DTLS, "can not find rtc session by peer_id=%s", udp_mux_skt->get_peer_id().c_str());
     }
 
-    rtc_session->on_dtls(udp_mux_skt);
+    return rtc_session->on_dtls(udp_mux_skt);
-
-    return err;
 }
 
 srs_error_t SrsRtcServer::on_rtp_or_rtcp(SrsUdpMuxSocket* udp_mux_skt)
@@ -1248,13 +1276,13 @@ srs_error_t SrsRtcServer::on_rtp_or_rtcp(SrsUdpMuxSocket* udp_mux_skt)
     SrsRtcSession* rtc_session = find_rtc_session_by_peer_id(udp_mux_skt->get_peer_id());
 
     if (rtc_session == NULL) {
-        return srs_error_wrap(err, "can not find rtc session by peer_id=%s", udp_mux_skt->get_peer_id().c_str());
+        return srs_error_new(ERROR_RTC_RTP, "can not find rtc session by peer_id=%s", udp_mux_skt->get_peer_id().c_str());
     }
 
     if (is_rtcp(reinterpret_cast<const uint8_t*>(udp_mux_skt->data()), udp_mux_skt->size())) {
-        rtc_session->on_rtcp(udp_mux_skt);
+        err = rtc_session->on_rtcp(udp_mux_skt);
     } else {
-        rtc_session->on_rtp(udp_mux_skt);
+        err = rtc_session->on_rtp(udp_mux_skt);
     }
 
     return err;

trunk/src/app/srs_app_rtc_conn.hpp

@@ -143,7 +143,7 @@ public:
     srs_error_t on_dtls_handshake_done(SrsUdpMuxSocket* udp_mux_skt);
     srs_error_t on_dtls_application_data(const char* data, const int len);
 
-    void send_client_hello(SrsUdpMuxSocket* udp_mux_skt);
+    srs_error_t send_client_hello(SrsUdpMuxSocket* udp_mux_skt);
 public:
     srs_error_t protect_rtp(char* protected_buf, const char* ori_buf, int& nb_protected_buf);
     srs_error_t unprotect_rtp(char* unprotected_buf, const char* ori_buf, int& nb_unprotected_buf);
@@ -221,7 +221,7 @@ public:
     srs_error_t on_rtcp(SrsUdpMuxSocket* udp_mux_skt);
 public:
     srs_error_t send_client_hello(SrsUdpMuxSocket* udp_mux_skt);
-    void on_connection_established(SrsUdpMuxSocket* udp_mux_skt);
+    srs_error_t on_connection_established(SrsUdpMuxSocket* udp_mux_skt);
     srs_error_t start_play(SrsUdpMuxSocket* udp_mux_skt);
 public:
     bool is_stun_timeout() { return last_stun_time + kSrsRtcSessionStunTimeoutUs < srs_get_system_time(); }

trunk/src/app/srs_app_rtp.cpp

@@ -84,9 +84,13 @@ srs_error_t SrsRtpMuxer::frame_to_packet(SrsSharedPtrMessage* shared_frame, SrsF
         }
 
         if (sample.size <= max_payload_size) {
-            packet_single_nalu(shared_frame, format, &sample, rtp_packet_vec);
+            if ((err = packet_single_nalu(shared_frame, format, &sample, rtp_packet_vec)) != srs_success) {
+                return srs_error_wrap(err, "packet single nalu");
+            }
         } else {
-            packet_fu_a(shared_frame, format, &sample, rtp_packet_vec);
+            if ((err = packet_fu_a(shared_frame, format, &sample, rtp_packet_vec)) != srs_success) {
+                return srs_error_wrap(err, "packet fu-a");
+            }
         }
     }
 
@@ -105,7 +109,9 @@ srs_error_t SrsRtpMuxer::packet_fu_a(SrsSharedPtrMessage* shared_frame, SrsForma
     uint8_t nal_type = header & kNalTypeMask;
 
     if (nal_type == kIdr) {
-        packet_stap_a(sps, pps, shared_frame, rtp_packet_vec);
+        if ((err = packet_stap_a(sps, pps, shared_frame, rtp_packet_vec)) != srs_success) {
+            return srs_error_wrap(err, "packet stap-a");
+        }
     }
 
     int num_of_packet = (sample->size - 1 + max_payload_size) / max_payload_size;
@@ -154,6 +160,8 @@ srs_error_t SrsRtpMuxer::packet_fu_a(SrsSharedPtrMessage* shared_frame, SrsForma
 
         rtp_packet_vec.push_back(rtp_shared_pkt);
     }
+
+    return err;
 }
 
 srs_error_t SrsRtpMuxer::packet_single_nalu(SrsSharedPtrMessage* shared_frame, SrsFormat* format, SrsSample* sample, vector<SrsRtpSharedPacket*>& rtp_packet_vec)
@@ -168,7 +176,9 @@ srs_error_t SrsRtpMuxer::packet_single_nalu(SrsSharedPtrMessage* shared_frame, S
     SrsAutoFree(SrsBuffer, stream);
 
     if (nal_type == kIdr) {
-        packet_stap_a(sps, pps, shared_frame, rtp_packet_vec);
+        if ((err = packet_stap_a(sps, pps, shared_frame, rtp_packet_vec)) != srs_success) {
+            return srs_error_wrap(err, "packet stap-a");
+        }
     }
 
     // v=2,p=0,x=0,cc=0
@@ -196,6 +206,10 @@ srs_error_t SrsRtpMuxer::packet_stap_a(const string &sps, const string& pps, Srs
 {
     srs_error_t err = srs_success;
 
+    if (sps.empty() || pps.empty()) {
+        return srs_error_new(ERROR_RTC_RTP_MUXER, "sps/pps empty");
+    }
+
     uint8_t header = sps[0];
     uint8_t nal_type = header & kNalTypeMask;
 
@@ -245,6 +259,7 @@ SrsRtp::SrsRtp()
 
 SrsRtp::~SrsRtp()
 {
+    srs_freep(rtp_h264_muxer);
 }
 
 void SrsRtp::dispose()

trunk/src/kernel/srs_kernel_error.hpp

@@ -324,8 +324,22 @@
 #define ERROR_HTTP_302_INVALID              4038
 #define ERROR_BASE64_DECODE                 4039
 #define ERROR_HTTP_STREAM_EOF               4040
+
+///////////////////////////////////////////////////////
+// RTC protocol error.
+///////////////////////////////////////////////////////
 #define ERROR_RTC_PORT                      4041
 #define ERROR_RTP_PACKET_CREATE             4042
+#define ERROR_OpenSslCreateSSL              4043
+#define ERROR_OpenSslBIOReset               4044
+#define ERROR_OpenSslBIOWrite               4045
+#define ERROR_OpenSslBIONew                 4046
+#define ERROR_RTC_RTP                       4047
+#define ERROR_RTC_RTCP                      4048
+#define ERROR_RTC_STUN                      4049
+#define ERROR_RTC_DTLS                      4050
+#define ERROR_RTC_UDP                       4051
+#define ERROR_RTC_RTP_MUXER                 4052
 
 ///////////////////////////////////////////////////////
 // HTTP API error.

trunk/src/protocol/srs_stun_stack.cpp

@@ -31,23 +31,27 @@ static srs_error_t hmac_encode(const std::string& algo, const char* key, const i
     } else if(algo == "sha384") { 
         engine = EVP_sha384();
     } else { 
-        return srs_error_wrap(err, "unknown algo=%s", algo.c_str());
+        return srs_error_new(ERROR_RTC_STUN, "unknown algo=%s", algo.c_str());
     } 
 
     HMAC_CTX* ctx = HMAC_CTX_new();
+    if (ctx == NULL) {
+        return srs_error_new(ERROR_RTC_STUN, "hmac init faied");
+    }
+
     if (HMAC_Init_ex(ctx, key, key_length, engine, NULL) < 0) {
         HMAC_CTX_free(ctx);
-        return srs_error_wrap(err, "hmac init faied");
+        return srs_error_new(ERROR_RTC_STUN, "hmac init faied");
     }
 
     if (HMAC_Update(ctx, (const unsigned char*)input, input_length) < 0) {
         HMAC_CTX_free(ctx);
-        return srs_error_wrap(err, "hmac update faied");
+        return srs_error_new(ERROR_RTC_STUN, "hmac update faied");
     }
 
     if (HMAC_Final(ctx, (unsigned char*)output, &output_length) < 0) {
         HMAC_CTX_free(ctx);
-        return srs_error_wrap(err, "hmac final faied");
+        return srs_error_new(ERROR_RTC_STUN, "hmac final faied");
     }
 
     HMAC_CTX_free(ctx);
@@ -75,7 +79,7 @@ srs_error_t SrsStunPacket::decode(const char* buf, const int nb_buf)
     SrsAutoFree(SrsBuffer, stream);
 
     if (stream->left() < 20) {
-        return srs_error_wrap(err, "invalid stun packet, size=%d", stream->size());
+        return srs_error_new(ERROR_RTC_STUN, "invalid stun packet, size=%d", stream->size());
     }
 
     message_type = stream->read_2bytes();
@@ -84,7 +88,7 @@ srs_error_t SrsStunPacket::decode(const char* buf, const int nb_buf)
     transcation_id = stream->read_string(12);
 
     if (nb_buf != 20 + message_len) {
-        return srs_error_wrap(err, "invalid stun packet, message_len=%d, nb_buf=%d", message_len, nb_buf);
+        return srs_error_new(ERROR_RTC_STUN, "invalid stun packet, message_len=%d, nb_buf=%d", message_len, nb_buf);
     }
 
     while (stream->left() >= 4) {
@@ -92,7 +96,7 @@ srs_error_t SrsStunPacket::decode(const char* buf, const int nb_buf)
         uint16_t len = stream->read_2bytes();
 
         if (stream->left() < len) {
-            return srs_error_wrap(err, "invalid stun packet");
+            return srs_error_new(ERROR_RTC_STUN, "invalid stun packet");
         }
 
         string val = stream->read_string(len);
@@ -129,7 +133,7 @@ srs_error_t SrsStunPacket::encode(const string& pwd, SrsBuffer* stream)
         return encode_binding_response(pwd, stream);
     }
 
-    return srs_error_wrap(err, "unknown stun type=%d", get_message_type());
+    return srs_error_new(ERROR_RTC_STUN, "unknown stun type=%d", get_message_type());
 }
 
 // FIXME: make this function easy to read
@@ -152,7 +156,7 @@ srs_error_t SrsStunPacket::encode_binding_response(const string& pwd, SrsBuffer*
 
     char hmac_buf[20] = {0};
     unsigned int hmac_buf_len = 0;
-    if (hmac_encode("sha1", pwd.c_str(), pwd.size(), stream->data(), stream->pos(), hmac_buf, hmac_buf_len) != srs_success) {
+    if ((err = hmac_encode("sha1", pwd.c_str(), pwd.size(), stream->data(), stream->pos(), hmac_buf, hmac_buf_len)) != srs_success) {
         return srs_error_wrap(err, "hmac encode failed");
     }