mirror of
https://github.com/ossrs/srs.git
synced 2025-03-09 15:49:59 +00:00
process err, do error check, add some error code
This commit is contained in:
HuyaJohn
parent
c2a667cc35
commit
e8b2bb5d28
8 changed files with 144 additions and 78 deletions
|
|
@ -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);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -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()
|
||||
|
|
|
|||
|
|
@ -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; }
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
}
|
||||
|
||||
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);
|
||||
|
|
@ -1121,7 +1153,7 @@ srs_error_t SrsRtcSession::on_rtcp(SrsUdpMuxSocket* udp_mux_skt)
|
|||
}
|
||||
|
||||
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 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<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;
|
||||
|
|
|
|||
|
|
@ -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(); }
|
||||
|
|
|
|||
|
|
@ -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()
|
||||
|
|
|
|||
|
|
@ -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.
|
||||
|
|
|
|||
|
|
@ -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");
|
||||
}
|
||||
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue