From e8b2bb5d2864374f0fe068296042f62433736ead Mon Sep 17 00:00:00 2001 From: HuyaJohn Date: Mon, 16 Mar 2020 07:35:24 -0700 Subject: [PATCH] process err, do error check, add some error code --- trunk/src/app/srs_app_http_api.cpp | 11 ++- trunk/src/app/srs_app_listener.cpp | 23 ++--- trunk/src/app/srs_app_listener.hpp | 3 +- trunk/src/app/srs_app_rtc_conn.cpp | 122 ++++++++++++++++---------- trunk/src/app/srs_app_rtc_conn.hpp | 4 +- trunk/src/app/srs_app_rtp.cpp | 23 ++++- trunk/src/kernel/srs_kernel_error.hpp | 14 +++ trunk/src/protocol/srs_stun_stack.cpp | 22 +++-- 8 files changed, 144 insertions(+), 78 deletions(-) diff --git a/trunk/src/app/srs_app_http_api.cpp b/trunk/src/app/srs_app_http_api.cpp index 0d3a787ff..1b4b37f45 100644 --- a/trunk/src/app/srs_app_http_api.cpp +++ b/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 != srs_success) { + if ((err = local_sdp.encode(local_sdp_str)) != srs_success) { return srs_api_response_code(w, r, SRS_CONSTS_HTTP_BadRequest); } diff --git a/trunk/src/app/srs_app_listener.cpp b/trunk/src/app/srs_app_listener.cpp index 0ba7684cd..667dd5036 100755 --- a/trunk/src/app/srs_app_listener.cpp +++ b/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) -{ - struct msghdr udphdr = {0}; - udphdr.msg_name = &from; - udphdr.msg_namelen = fromlen; - udphdr.msg_iov = iov; - udphdr.msg_iovlen = iovlen; + int nb_write = srs_sendto(lfd, data, size, (sockaddr*)&from, fromlen, timeout); - 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() diff --git a/trunk/src/app/srs_app_listener.hpp b/trunk/src/app/srs_app_listener.hpp index 605929902..81cd8a580 100644 --- a/trunk/src/app/srs_app_listener.hpp +++ b/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); - int sendtov(struct iovec* iov, size_t iovlen, srs_utime_t timeout); + srs_error_t sendto(void* data, int size, srs_utime_t timeout); char* data() { return buf; } int size() { return nread; } diff --git a/trunk/src/app/srs_app_rtc_conn.cpp b/trunk/src/app/srs_app_rtc_conn.cpp index 62ed7bf03..b20af7ce9 100644 --- a/trunk/src/app/srs_app_rtc_conn.cpp +++ b/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); - BIO_reset(bio_out); - BIO_write(bio_in, udp_mux_skt->data(), udp_mux_skt->size()); - - handshake(udp_mux_skt); + err = 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 err; + return rtc_session->on_connection_established(udp_mux_skt); } 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()); - bio_out = BIO_new(BIO_s_mem()); + if ((bio_in = BIO_new(BIO_s_mem())) == NULL) { + 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) { - return err; + if (err != srs_success) { + 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(udp_mux_skt->data()), udp_mux_skt->size())) { return on_stun(udp_mux_skt); } else if (is_dtls(reinterpret_cast(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 err; + return rtc_session->on_dtls(udp_mux_skt); } 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(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; diff --git a/trunk/src/app/srs_app_rtc_conn.hpp b/trunk/src/app/srs_app_rtc_conn.hpp index cf03ea3bd..422e6ca9d 100644 --- a/trunk/src/app/srs_app_rtc_conn.hpp +++ b/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(); } diff --git a/trunk/src/app/srs_app_rtp.cpp b/trunk/src/app/srs_app_rtp.cpp index 58d594248..f8cf2e7c5 100644 --- a/trunk/src/app/srs_app_rtp.cpp +++ b/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& 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() diff --git a/trunk/src/kernel/srs_kernel_error.hpp b/trunk/src/kernel/srs_kernel_error.hpp index 79e30ba69..7461ebbcc 100644 --- a/trunk/src/kernel/srs_kernel_error.hpp +++ b/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. diff --git a/trunk/src/protocol/srs_stun_stack.cpp b/trunk/src/protocol/srs_stun_stack.cpp index ae0f43dff..ee81f5363 100644 --- a/trunk/src/protocol/srs_stun_stack.cpp +++ b/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"); }