mirror of
https://github.com/ossrs/srs.git
synced 2025-03-09 15:49:59 +00:00
UniquePtr: Support SrsUniquePtr to replace SrsAutoFree. v6.0.136 (#4109)
To manage an object: ```cpp // Before MyClass* ptr = new MyClass(); SrsAutoFree(MyClass, ptr); ptr->do_something(); // Now SrsUniquePtr<MyClass> ptr(new MyClass()); ptr->do_something(); ``` To manage an array of objects: ```cpp // Before char* ptr = new char[10]; SrsAutoFreeA(char, ptr); ptr[0] = 0xf; // Now SrsUniquePtr<char[]> ptr(new char[10]); ptr[0] = 0xf; ``` In fact, SrsUniquePtr is a limited subset of SrsAutoFree, mainly managing pointers and arrays. SrsUniquePtr is better than SrsAutoFree because it has the same API to standard unique ptr. ```cpp SrsUniquePtr<MyClass> ptr(new MyClass()); ptr->do_something(); MyClass* p = ptr.get(); ``` SrsAutoFree actually uses a pointer to a pointer, so it can be set to NULL, allowing the pointer's value to be changed later (this usage is different from SrsUniquePtr). ```cpp // OK to free ptr correctly. MyClass* ptr; SrsAutoFree(MyClass, ptr); ptr = new MyClass(); // Crash because ptr is an invalid pointer. MyClass* ptr; SrsUniquePtr<MyClass> ptr(ptr); ptr = new MyClass(); ``` Additionally, SrsAutoFreeH can use specific release functions, which SrsUniquePtr does not support. --------- Co-authored-by: Jacob Su <suzp1984@gmail.com>
This commit is contained in:
Winlin
GitHub
parent
baf22d01c1
commit
23d2602c34
72 changed files with 1720 additions and 1669 deletions
|
|
@ -201,19 +201,18 @@ srs_error_t SrsSslClient::read(void* plaintext, size_t nn_plaintext, ssize_t* nr
|
|||
if (r0 == -1 && r1 == SSL_ERROR_WANT_READ) {
|
||||
// TODO: Can we avoid copy?
|
||||
int nn_cipher = nn_plaintext;
|
||||
char* cipher = new char[nn_cipher];
|
||||
SrsAutoFreeA(char, cipher);
|
||||
SrsUniquePtr<char[]> cipher(new char[nn_cipher]);
|
||||
|
||||
// Read the cipher from SSL.
|
||||
ssize_t nn = 0;
|
||||
if ((err = transport->read(cipher, nn_cipher, &nn)) != srs_success) {
|
||||
if ((err = transport->read(cipher.get(), nn_cipher, &nn)) != srs_success) {
|
||||
return srs_error_wrap(err, "https: read");
|
||||
}
|
||||
|
||||
int r0 = BIO_write(bio_in, cipher, nn);
|
||||
int r0 = BIO_write(bio_in, cipher.get(), nn);
|
||||
if (r0 <= 0) {
|
||||
// TODO: 0 or -1 maybe block, use BIO_should_retry to check.
|
||||
return srs_error_new(ERROR_HTTPS_READ, "BIO_write r0=%d, cipher=%p, size=%d", r0, cipher, nn);
|
||||
return srs_error_new(ERROR_HTTPS_READ, "BIO_write r0=%d, cipher=%p, size=%d", r0, cipher.get(), nn);
|
||||
}
|
||||
continue;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -421,8 +421,7 @@ srs_error_t SrsHttpFileServer::serve_file(ISrsHttpResponseWriter* w, ISrsHttpMes
|
|||
{
|
||||
srs_error_t err = srs_success;
|
||||
|
||||
SrsFileReader* fs = fs_factory->create_file_reader();
|
||||
SrsAutoFree(SrsFileReader, fs);
|
||||
SrsUniquePtr<SrsFileReader> fs(fs_factory->create_file_reader());
|
||||
|
||||
if ((err = fs->open(fullpath)) != srs_success) {
|
||||
return srs_error_wrap(err, "open file %s", fullpath.c_str());
|
||||
|
|
@ -484,7 +483,7 @@ srs_error_t SrsHttpFileServer::serve_file(ISrsHttpResponseWriter* w, ISrsHttpMes
|
|||
|
||||
// write body.
|
||||
int64_t left = length;
|
||||
if ((err = copy(w, fs, r, left)) != srs_success) {
|
||||
if ((err = copy(w, fs.get(), r, left)) != srs_success) {
|
||||
return srs_error_wrap(err, "copy file=%s size=%" PRId64, fullpath.c_str(), left);
|
||||
}
|
||||
|
||||
|
|
@ -595,18 +594,17 @@ srs_error_t SrsHttpFileServer::copy(ISrsHttpResponseWriter* w, SrsFileReader* fs
|
|||
srs_error_t err = srs_success;
|
||||
|
||||
int64_t left = size;
|
||||
char* buf = new char[SRS_HTTP_TS_SEND_BUFFER_SIZE];
|
||||
SrsAutoFreeA(char, buf);
|
||||
|
||||
SrsUniquePtr<char[]> buf(new char[SRS_HTTP_TS_SEND_BUFFER_SIZE]);
|
||||
|
||||
while (left > 0) {
|
||||
ssize_t nread = -1;
|
||||
int max_read = srs_min(left, SRS_HTTP_TS_SEND_BUFFER_SIZE);
|
||||
if ((err = fs->read(buf, max_read, &nread)) != srs_success) {
|
||||
if ((err = fs->read(buf.get(), max_read, &nread)) != srs_success) {
|
||||
return srs_error_wrap(err, "read limit=%d, left=%" PRId64, max_read, left);
|
||||
}
|
||||
|
||||
left -= nread;
|
||||
if ((err = w->write(buf, (int)nread)) != srs_success) {
|
||||
if ((err = w->write(buf.get(), (int)nread)) != srs_success) {
|
||||
return srs_error_wrap(err, "write limit=%d, bytes=%d, left=%" PRId64, max_read, (int)nread, left);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -125,11 +125,10 @@ srs_error_t SrsRawH264Stream::mux_sequence_header(string sps, string pps, string
|
|||
// Nbytes of pps:
|
||||
// pictureParameterSetNALUnit
|
||||
int nb_packet = 5 + (3 + (int)sps.length()) + (3 + (int)pps.length());
|
||||
char* packet = new char[nb_packet];
|
||||
SrsAutoFreeA(char, packet);
|
||||
|
||||
SrsUniquePtr<char[]> packet(new char[nb_packet]);
|
||||
|
||||
// use stream to generate the h264 packet.
|
||||
SrsBuffer stream(packet, nb_packet);
|
||||
SrsBuffer stream(packet.get(), nb_packet);
|
||||
|
||||
// decode the SPS:
|
||||
// @see: 7.3.2.1.1, ISO_IEC_14496-10-AVC-2012.pdf, page 62
|
||||
|
|
@ -186,7 +185,7 @@ srs_error_t SrsRawH264Stream::mux_sequence_header(string sps, string pps, string
|
|||
// 5.3.4.2.1 Syntax, ISO_IEC_14496-15-AVC-format-2012.pdf, page 16
|
||||
// profile_idc == 100 || profile_idc == 110 || profile_idc == 122 || profile_idc == 144
|
||||
|
||||
sh = string(packet, nb_packet);
|
||||
sh = string(packet.get(), nb_packet);
|
||||
|
||||
return err;
|
||||
}
|
||||
|
|
@ -200,11 +199,10 @@ srs_error_t SrsRawH264Stream::mux_ipb_frame(char* frame, int nb_frame, string& i
|
|||
// Nbytes of nalu.
|
||||
// NALUnit
|
||||
int nb_packet = 4 + nb_frame;
|
||||
char* packet = new char[nb_packet];
|
||||
SrsAutoFreeA(char, packet);
|
||||
|
||||
SrsUniquePtr<char[]> packet(new char[nb_packet]);
|
||||
|
||||
// use stream to generate the h264 packet.
|
||||
SrsBuffer stream(packet, nb_packet);
|
||||
SrsBuffer stream(packet.get(), nb_packet);
|
||||
|
||||
// 5.3.4.2.1 Syntax, ISO_IEC_14496-15-AVC-format-2012.pdf, page 16
|
||||
// lengthSizeMinusOne, or NAL_unit_length, always use 4bytes size
|
||||
|
|
@ -217,7 +215,7 @@ srs_error_t SrsRawH264Stream::mux_ipb_frame(char* frame, int nb_frame, string& i
|
|||
// NALUnit
|
||||
stream.write_bytes(frame, nb_frame);
|
||||
|
||||
ibp = string(packet, nb_packet);
|
||||
ibp = string(packet.get(), nb_packet);
|
||||
|
||||
return err;
|
||||
}
|
||||
|
|
@ -406,11 +404,10 @@ srs_error_t SrsRawHEVCStream::mux_sequence_header(std::string vps, std::string s
|
|||
}
|
||||
|
||||
int nb_packet = 23 + 5 + (int)vps.length() + 5 + (int)sps.length() + 5 + pps_size - 2;
|
||||
char* packet = new char[nb_packet];
|
||||
SrsAutoFreeA(char, packet);
|
||||
SrsUniquePtr<char[]> packet(new char[nb_packet]);
|
||||
|
||||
// use stream to generate the hevc packet.
|
||||
SrsBuffer stream(packet, nb_packet);
|
||||
SrsBuffer stream(packet.get(), nb_packet);
|
||||
|
||||
SrsFormat format;
|
||||
if ((err = format.initialize()) != srs_success) {
|
||||
|
|
@ -511,7 +508,7 @@ srs_error_t SrsRawHEVCStream::mux_sequence_header(std::string vps, std::string s
|
|||
}
|
||||
}
|
||||
|
||||
hvcC = string(packet, nb_packet);
|
||||
hvcC = string(packet.get(), nb_packet);
|
||||
|
||||
return err;
|
||||
}
|
||||
|
|
@ -525,11 +522,10 @@ srs_error_t SrsRawHEVCStream::mux_ipb_frame(char *frame, int nb_frame, std::stri
|
|||
// Nbytes of nalu.
|
||||
// NALUnit
|
||||
int nb_packet = 4 + nb_frame;
|
||||
char *packet = new char[nb_packet];
|
||||
SrsAutoFreeA(char, packet);
|
||||
SrsUniquePtr<char[]> packet(new char[nb_packet]);
|
||||
|
||||
// use stream to generate the h265 packet.
|
||||
SrsBuffer stream(packet, nb_packet);
|
||||
SrsBuffer stream(packet.get(), nb_packet);
|
||||
|
||||
// 5.3.4.2.1 Syntax, ISO_IEC_14496-15-AVC-format-2012.pdf, page 16
|
||||
// lengthSizeMinusOne, or NAL_unit_length, always use 4bytes size
|
||||
|
|
@ -542,7 +538,7 @@ srs_error_t SrsRawHEVCStream::mux_ipb_frame(char *frame, int nb_frame, std::stri
|
|||
// NALUnit
|
||||
stream.write_bytes(frame, nb_frame);
|
||||
|
||||
ibp = string(packet, nb_packet);
|
||||
ibp = string(packet.get(), nb_packet);
|
||||
|
||||
return err;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -177,8 +177,7 @@ srs_error_t SrsStunPacket::decode(const char* buf, const int nb_buf)
|
|||
{
|
||||
srs_error_t err = srs_success;
|
||||
|
||||
SrsBuffer* stream = new SrsBuffer(const_cast<char*>(buf), nb_buf);
|
||||
SrsAutoFree(SrsBuffer, stream);
|
||||
SrsUniquePtr<SrsBuffer> stream(new SrsBuffer(const_cast<char*>(buf), nb_buf));
|
||||
|
||||
if (stream->left() < 20) {
|
||||
return srs_error_new(ERROR_RTC_STUN, "invalid stun packet, size=%d", stream->size());
|
||||
|
|
@ -306,8 +305,7 @@ srs_error_t SrsStunPacket::encode_binding_response(const string& pwd, SrsBuffer*
|
|||
string SrsStunPacket::encode_username()
|
||||
{
|
||||
char buf[1460];
|
||||
SrsBuffer* stream = new SrsBuffer(buf, sizeof(buf));
|
||||
SrsAutoFree(SrsBuffer, stream);
|
||||
SrsUniquePtr<SrsBuffer> stream(new SrsBuffer(buf, sizeof(buf)));
|
||||
|
||||
string username = remote_ufrag + ":" + local_ufrag;
|
||||
|
||||
|
|
@ -326,8 +324,7 @@ string SrsStunPacket::encode_username()
|
|||
string SrsStunPacket::encode_mapped_address()
|
||||
{
|
||||
char buf[1460];
|
||||
SrsBuffer* stream = new SrsBuffer(buf, sizeof(buf));
|
||||
SrsAutoFree(SrsBuffer, stream);
|
||||
SrsUniquePtr<SrsBuffer> stream(new SrsBuffer(buf, sizeof(buf)));
|
||||
|
||||
stream->write_2bytes(XorMappedAddress);
|
||||
stream->write_2bytes(8);
|
||||
|
|
@ -342,8 +339,7 @@ string SrsStunPacket::encode_mapped_address()
|
|||
string SrsStunPacket::encode_hmac(char* hmac_buf, const int hmac_buf_len)
|
||||
{
|
||||
char buf[1460];
|
||||
SrsBuffer* stream = new SrsBuffer(buf, sizeof(buf));
|
||||
SrsAutoFree(SrsBuffer, stream);
|
||||
SrsUniquePtr<SrsBuffer> stream(new SrsBuffer(buf, sizeof(buf)));
|
||||
|
||||
stream->write_2bytes(MessageIntegrity);
|
||||
stream->write_2bytes(hmac_buf_len);
|
||||
|
|
@ -355,8 +351,7 @@ string SrsStunPacket::encode_hmac(char* hmac_buf, const int hmac_buf_len)
|
|||
string SrsStunPacket::encode_fingerprint(uint32_t crc32)
|
||||
{
|
||||
char buf[1460];
|
||||
SrsBuffer* stream = new SrsBuffer(buf, sizeof(buf));
|
||||
SrsAutoFree(SrsBuffer, stream);
|
||||
SrsUniquePtr<SrsBuffer> stream(new SrsBuffer(buf, sizeof(buf)));
|
||||
|
||||
stream->write_2bytes(Fingerprint);
|
||||
stream->write_2bytes(4);
|
||||
|
|
|
|||
|
|
@ -522,16 +522,16 @@ namespace srs_internal
|
|||
srs_error_t err = srs_success;
|
||||
|
||||
// generate digest
|
||||
char* c1_digest = NULL;
|
||||
char* c1_digest_raw = NULL;
|
||||
|
||||
if ((err = calc_c1_digest(owner, c1_digest)) != srs_success) {
|
||||
if ((err = calc_c1_digest(owner, c1_digest_raw)) != srs_success) {
|
||||
return srs_error_wrap(err, "sign c1");
|
||||
}
|
||||
|
||||
srs_assert(c1_digest != NULL);
|
||||
SrsAutoFreeA(char, c1_digest);
|
||||
|
||||
memcpy(digest.digest, c1_digest, 32);
|
||||
srs_assert(c1_digest_raw != NULL);
|
||||
SrsUniquePtr<char[]> c1_digest(c1_digest_raw);
|
||||
|
||||
memcpy(digest.digest, c1_digest.get(), 32);
|
||||
|
||||
return err;
|
||||
}
|
||||
|
|
@ -540,16 +540,16 @@ namespace srs_internal
|
|||
{
|
||||
srs_error_t err = srs_success;
|
||||
|
||||
char* c1_digest = NULL;
|
||||
char* c1_digest_raw = NULL;
|
||||
|
||||
if ((err = calc_c1_digest(owner, c1_digest)) != srs_success) {
|
||||
if ((err = calc_c1_digest(owner, c1_digest_raw)) != srs_success) {
|
||||
return srs_error_wrap(err, "validate c1");
|
||||
}
|
||||
|
||||
srs_assert(c1_digest != NULL);
|
||||
SrsAutoFreeA(char, c1_digest);
|
||||
srs_assert(c1_digest_raw != NULL);
|
||||
SrsUniquePtr<char[]> c1_digest(c1_digest_raw);
|
||||
|
||||
is_valid = srs_bytes_equals(digest.digest, c1_digest, 32);
|
||||
is_valid = srs_bytes_equals(digest.digest, c1_digest.get(), 32);
|
||||
|
||||
return err;
|
||||
}
|
||||
|
|
@ -576,15 +576,15 @@ namespace srs_internal
|
|||
// TODO: FIXME: use the actual key size.
|
||||
//srs_assert(pkey_size == 128);
|
||||
|
||||
char* s1_digest = NULL;
|
||||
if ((err = calc_s1_digest(owner, s1_digest)) != srs_success) {
|
||||
char* s1_digest_raw = NULL;
|
||||
if ((err = calc_s1_digest(owner, s1_digest_raw)) != srs_success) {
|
||||
return srs_error_wrap(err, "calc s1 digest");
|
||||
}
|
||||
|
||||
srs_assert(s1_digest != NULL);
|
||||
SrsAutoFreeA(char, s1_digest);
|
||||
|
||||
memcpy(digest.digest, s1_digest, 32);
|
||||
srs_assert(s1_digest_raw != NULL);
|
||||
SrsUniquePtr<char[]> s1_digest(s1_digest_raw);
|
||||
|
||||
memcpy(digest.digest, s1_digest.get(), 32);
|
||||
|
||||
return err;
|
||||
}
|
||||
|
|
@ -593,16 +593,16 @@ namespace srs_internal
|
|||
{
|
||||
srs_error_t err = srs_success;
|
||||
|
||||
char* s1_digest = NULL;
|
||||
char* s1_digest_raw = NULL;
|
||||
|
||||
if ((err = calc_s1_digest(owner, s1_digest)) != srs_success) {
|
||||
if ((err = calc_s1_digest(owner, s1_digest_raw)) != srs_success) {
|
||||
return srs_error_wrap(err, "validate s1");
|
||||
}
|
||||
|
||||
srs_assert(s1_digest != NULL);
|
||||
SrsAutoFreeA(char, s1_digest);
|
||||
srs_assert(s1_digest_raw != NULL);
|
||||
SrsUniquePtr<char[]> s1_digest(s1_digest_raw);
|
||||
|
||||
is_valid = srs_bytes_equals(digest.digest, s1_digest, 32);
|
||||
is_valid = srs_bytes_equals(digest.digest, s1_digest.get(), 32);
|
||||
|
||||
return err;
|
||||
}
|
||||
|
|
@ -611,21 +611,18 @@ namespace srs_internal
|
|||
{
|
||||
srs_error_t err = srs_success;
|
||||
|
||||
/**
|
||||
* c1s1 is splited by digest:
|
||||
* c1s1-part1: n bytes (time, version, key and digest-part1).
|
||||
* digest-data: 32bytes
|
||||
* c1s1-part2: (1536-n-32)bytes (digest-part2)
|
||||
* @return a new allocated bytes, user must free it.
|
||||
*/
|
||||
char* c1s1_joined_bytes = new char[1536 -32];
|
||||
SrsAutoFreeA(char, c1s1_joined_bytes);
|
||||
if ((err = copy_to(owner, c1s1_joined_bytes, 1536 - 32, false)) != srs_success) {
|
||||
// c1s1 is splited by digest:
|
||||
// c1s1-part1: n bytes (time, version, key and digest-part1).
|
||||
// digest-data: 32bytes
|
||||
// c1s1-part2: (1536-n-32)bytes (digest-part2)
|
||||
// @return a new allocated bytes, user must free it.
|
||||
SrsUniquePtr<char[]> c1s1_joined_bytes(new char[1536 -32]);
|
||||
if ((err = copy_to(owner, c1s1_joined_bytes.get(), 1536 - 32, false)) != srs_success) {
|
||||
return srs_error_wrap(err, "copy bytes");
|
||||
}
|
||||
|
||||
c1_digest = new char[SRS_OpensslHashSize];
|
||||
if ((err = openssl_HMACsha256(SrsGenuineFPKey, 30, c1s1_joined_bytes, 1536 - 32, c1_digest)) != srs_success) {
|
||||
if ((err = openssl_HMACsha256(SrsGenuineFPKey, 30, c1s1_joined_bytes.get(), 1536 - 32, c1_digest)) != srs_success) {
|
||||
srs_freepa(c1_digest);
|
||||
return srs_error_wrap(err, "calc c1 digest");
|
||||
}
|
||||
|
|
@ -637,21 +634,18 @@ namespace srs_internal
|
|||
{
|
||||
srs_error_t err = srs_success;
|
||||
|
||||
/**
|
||||
* c1s1 is splited by digest:
|
||||
* c1s1-part1: n bytes (time, version, key and digest-part1).
|
||||
* digest-data: 32bytes
|
||||
* c1s1-part2: (1536-n-32)bytes (digest-part2)
|
||||
* @return a new allocated bytes, user must free it.
|
||||
*/
|
||||
char* c1s1_joined_bytes = new char[1536 -32];
|
||||
SrsAutoFreeA(char, c1s1_joined_bytes);
|
||||
if ((err = copy_to(owner, c1s1_joined_bytes, 1536 - 32, false)) != srs_success) {
|
||||
// c1s1 is splited by digest:
|
||||
// c1s1-part1: n bytes (time, version, key and digest-part1).
|
||||
// digest-data: 32bytes
|
||||
// c1s1-part2: (1536-n-32)bytes (digest-part2)
|
||||
// @return a new allocated bytes, user must free it.
|
||||
SrsUniquePtr<char[]> c1s1_joined_bytes(new char[1536 -32]);
|
||||
if ((err = copy_to(owner, c1s1_joined_bytes.get(), 1536 - 32, false)) != srs_success) {
|
||||
return srs_error_wrap(err, "copy bytes");
|
||||
}
|
||||
|
||||
s1_digest = new char[SRS_OpensslHashSize];
|
||||
if ((err = openssl_HMACsha256(SrsGenuineFMSKey, 36, c1s1_joined_bytes, 1536 - 32, s1_digest)) != srs_success) {
|
||||
if ((err = openssl_HMACsha256(SrsGenuineFMSKey, 36, c1s1_joined_bytes.get(), 1536 - 32, s1_digest)) != srs_success) {
|
||||
srs_freepa(s1_digest);
|
||||
return srs_error_wrap(err, "calc s1 digest");
|
||||
}
|
||||
|
|
|
|||
|
|
@ -128,11 +128,9 @@ srs_error_t SrsPacket::encode(int& psize, char*& ppayload)
|
|||
|
||||
if (size > 0) {
|
||||
payload = new char[size];
|
||||
|
||||
SrsBuffer* stream = new SrsBuffer(payload, size);
|
||||
SrsAutoFree(SrsBuffer, stream);
|
||||
|
||||
if ((err = encode_packet(stream)) != srs_success) {
|
||||
SrsUniquePtr<SrsBuffer> stream(new SrsBuffer(payload, size));
|
||||
|
||||
if ((err = encode_packet(stream.get())) != srs_success) {
|
||||
srs_freepa(payload);
|
||||
return srs_error_wrap(err, "encode packet");
|
||||
}
|
||||
|
|
@ -556,22 +554,20 @@ srs_error_t SrsProtocol::do_iovs_send(iovec* iovs, int size)
|
|||
return srs_write_large_iovs(skt, iovs, size);
|
||||
}
|
||||
|
||||
srs_error_t SrsProtocol::do_send_and_free_packet(SrsPacket* packet, int stream_id)
|
||||
srs_error_t SrsProtocol::do_send_and_free_packet(SrsPacket* packet_raw, int stream_id)
|
||||
{
|
||||
srs_error_t err = srs_success;
|
||||
|
||||
srs_assert(packet);
|
||||
SrsAutoFree(SrsPacket, packet);
|
||||
srs_assert(packet_raw);
|
||||
SrsUniquePtr<SrsPacket> packet(packet_raw);
|
||||
SrsUniquePtr<SrsCommonMessage> msg(new SrsCommonMessage());
|
||||
|
||||
SrsCommonMessage* msg = new SrsCommonMessage();
|
||||
SrsAutoFree(SrsCommonMessage, msg);
|
||||
|
||||
if ((err = packet->to_msg(msg, stream_id)) != srs_success) {
|
||||
if ((err = packet->to_msg(msg.get(), stream_id)) != srs_success) {
|
||||
return srs_error_wrap(err, "to message");
|
||||
}
|
||||
|
||||
SrsSharedPtrMessage* shared_msg = new SrsSharedPtrMessage();
|
||||
if ((err = shared_msg->create(msg)) != srs_success) {
|
||||
if ((err = shared_msg->create(msg.get())) != srs_success) {
|
||||
srs_freep(shared_msg);
|
||||
return srs_error_wrap(err, "create message");
|
||||
}
|
||||
|
|
@ -580,7 +576,7 @@ srs_error_t SrsProtocol::do_send_and_free_packet(SrsPacket* packet, int stream_i
|
|||
return srs_error_wrap(err, "send packet");
|
||||
}
|
||||
|
||||
if ((err = on_send_packet(&msg->header, packet)) != srs_success) {
|
||||
if ((err = on_send_packet(&msg->header, packet.get())) != srs_success) {
|
||||
return srs_error_wrap(err, "on send packet");
|
||||
}
|
||||
|
||||
|
|
@ -1237,12 +1233,12 @@ srs_error_t SrsProtocol::on_recv_message(SrsCommonMessage* msg)
|
|||
return srs_error_wrap(err, "response ack");
|
||||
}
|
||||
|
||||
SrsPacket* packet = NULL;
|
||||
SrsPacket* packet_raw = NULL;
|
||||
switch (msg->header.message_type) {
|
||||
case RTMP_MSG_SetChunkSize:
|
||||
case RTMP_MSG_UserControlMessage:
|
||||
case RTMP_MSG_WindowAcknowledgementSize:
|
||||
if ((err = decode_message(msg, &packet)) != srs_success) {
|
||||
if ((err = decode_message(msg, &packet_raw)) != srs_success) {
|
||||
return srs_error_wrap(err, "decode message");
|
||||
}
|
||||
break;
|
||||
|
|
@ -1252,15 +1248,14 @@ srs_error_t SrsProtocol::on_recv_message(SrsCommonMessage* msg)
|
|||
default:
|
||||
return err;
|
||||
}
|
||||
|
||||
srs_assert(packet);
|
||||
|
||||
|
||||
// always free the packet.
|
||||
SrsAutoFree(SrsPacket, packet);
|
||||
|
||||
srs_assert(packet_raw);
|
||||
SrsUniquePtr<SrsPacket> packet(packet_raw);
|
||||
|
||||
switch (msg->header.message_type) {
|
||||
case RTMP_MSG_WindowAcknowledgementSize: {
|
||||
SrsSetWindowAckSizePacket* pkt = dynamic_cast<SrsSetWindowAckSizePacket*>(packet);
|
||||
SrsSetWindowAckSizePacket* pkt = dynamic_cast<SrsSetWindowAckSizePacket*>(packet.get());
|
||||
srs_assert(pkt != NULL);
|
||||
|
||||
if (pkt->ackowledgement_window_size > 0) {
|
||||
|
|
@ -1272,7 +1267,7 @@ srs_error_t SrsProtocol::on_recv_message(SrsCommonMessage* msg)
|
|||
break;
|
||||
}
|
||||
case RTMP_MSG_SetChunkSize: {
|
||||
SrsSetChunkSizePacket* pkt = dynamic_cast<SrsSetChunkSizePacket*>(packet);
|
||||
SrsSetChunkSizePacket* pkt = dynamic_cast<SrsSetChunkSizePacket*>(packet.get());
|
||||
srs_assert(pkt != NULL);
|
||||
|
||||
// for some server, the actual chunk size can greater than the max value(65536),
|
||||
|
|
@ -1292,7 +1287,7 @@ srs_error_t SrsProtocol::on_recv_message(SrsCommonMessage* msg)
|
|||
break;
|
||||
}
|
||||
case RTMP_MSG_UserControlMessage: {
|
||||
SrsUserControlPacket* pkt = dynamic_cast<SrsUserControlPacket*>(packet);
|
||||
SrsUserControlPacket* pkt = dynamic_cast<SrsUserControlPacket*>(packet.get());
|
||||
srs_assert(pkt != NULL);
|
||||
|
||||
if (pkt->event_type == SrcPCUCSetBufferLength) {
|
||||
|
|
@ -1822,9 +1817,8 @@ srs_error_t SrsRtmpClient::handshake()
|
|||
|
||||
// maybe st has problem when alloc object on stack, always alloc object at heap.
|
||||
// @see https://github.com/ossrs/srs/issues/509
|
||||
SrsComplexHandshake* complex_hs = new SrsComplexHandshake();
|
||||
SrsAutoFree(SrsComplexHandshake, complex_hs);
|
||||
|
||||
SrsUniquePtr<SrsComplexHandshake> complex_hs(new SrsComplexHandshake());
|
||||
|
||||
if ((err = complex_hs->handshake_with_server(hs_bytes, io)) != srs_success) {
|
||||
// As client, we never verify s0s1s2, because some server doesn't follow the RTMP spec.
|
||||
// So we never have chance to use simple handshake.
|
||||
|
|
@ -1922,14 +1916,15 @@ srs_error_t SrsRtmpClient::connect_app(string app, string tcUrl, SrsRequest* r,
|
|||
}
|
||||
|
||||
// expect connect _result
|
||||
SrsCommonMessage* msg = NULL;
|
||||
SrsConnectAppResPacket* pkt = NULL;
|
||||
if ((err = expect_message<SrsConnectAppResPacket>(&msg, &pkt)) != srs_success) {
|
||||
SrsCommonMessage* msg_raw = NULL;
|
||||
SrsConnectAppResPacket* pkt_raw = NULL;
|
||||
if ((err = expect_message<SrsConnectAppResPacket>(&msg_raw, &pkt_raw)) != srs_success) {
|
||||
return srs_error_wrap(err, "expect connect app response");
|
||||
}
|
||||
SrsAutoFree(SrsCommonMessage, msg);
|
||||
SrsAutoFree(SrsConnectAppResPacket, pkt);
|
||||
|
||||
|
||||
SrsUniquePtr<SrsCommonMessage> msg(msg_raw);
|
||||
SrsUniquePtr<SrsConnectAppResPacket> pkt(pkt_raw);
|
||||
|
||||
// server info
|
||||
SrsAmf0Any* data = pkt->info->get_property("data");
|
||||
if (si && data && data->is_ecma_array()) {
|
||||
|
|
@ -1989,13 +1984,14 @@ srs_error_t SrsRtmpClient::create_stream(int& stream_id)
|
|||
|
||||
// CreateStream _result.
|
||||
if (true) {
|
||||
SrsCommonMessage* msg = NULL;
|
||||
SrsCreateStreamResPacket* pkt = NULL;
|
||||
if ((err = expect_message<SrsCreateStreamResPacket>(&msg, &pkt)) != srs_success) {
|
||||
SrsCommonMessage* msg_raw = NULL;
|
||||
SrsCreateStreamResPacket* pkt_raw = NULL;
|
||||
if ((err = expect_message<SrsCreateStreamResPacket>(&msg_raw, &pkt_raw)) != srs_success) {
|
||||
return srs_error_wrap(err, "expect create stream response");
|
||||
}
|
||||
SrsAutoFree(SrsCommonMessage, msg);
|
||||
SrsAutoFree(SrsCreateStreamResPacket, pkt);
|
||||
|
||||
SrsUniquePtr<SrsCommonMessage> msg(msg_raw);
|
||||
SrsUniquePtr<SrsCreateStreamResPacket> pkt(pkt_raw);
|
||||
|
||||
stream_id = (int)pkt->stream_id;
|
||||
}
|
||||
|
|
@ -2100,13 +2096,14 @@ srs_error_t SrsRtmpClient::fmle_publish(string stream, int& stream_id)
|
|||
|
||||
// expect result of CreateStream
|
||||
if (true) {
|
||||
SrsCommonMessage* msg = NULL;
|
||||
SrsCreateStreamResPacket* pkt = NULL;
|
||||
if ((err = expect_message<SrsCreateStreamResPacket>(&msg, &pkt)) != srs_success) {
|
||||
SrsCommonMessage* msg_raw = NULL;
|
||||
SrsCreateStreamResPacket* pkt_raw = NULL;
|
||||
if ((err = expect_message<SrsCreateStreamResPacket>(&msg_raw, &pkt_raw)) != srs_success) {
|
||||
return srs_error_wrap(err, "expect create stream response message failed");
|
||||
}
|
||||
SrsAutoFree(SrsCommonMessage, msg);
|
||||
SrsAutoFree(SrsCreateStreamResPacket, pkt);
|
||||
|
||||
SrsUniquePtr<SrsCommonMessage> msg(msg_raw);
|
||||
SrsUniquePtr<SrsCreateStreamResPacket> pkt(pkt_raw);
|
||||
|
||||
stream_id = (int)pkt->stream_id;
|
||||
}
|
||||
|
|
@ -2242,14 +2239,15 @@ srs_error_t SrsRtmpServer::connect_app(SrsRequest* req)
|
|||
{
|
||||
srs_error_t err = srs_success;
|
||||
|
||||
SrsCommonMessage* msg = NULL;
|
||||
SrsConnectAppPacket* pkt = NULL;
|
||||
if ((err = expect_message<SrsConnectAppPacket>(&msg, &pkt)) != srs_success) {
|
||||
SrsCommonMessage* msg_raw = NULL;
|
||||
SrsConnectAppPacket* pkt_raw = NULL;
|
||||
if ((err = expect_message<SrsConnectAppPacket>(&msg_raw, &pkt_raw)) != srs_success) {
|
||||
return srs_error_wrap(err, "expect connect app response");
|
||||
}
|
||||
SrsAutoFree(SrsCommonMessage, msg);
|
||||
SrsAutoFree(SrsConnectAppPacket, pkt);
|
||||
|
||||
|
||||
SrsUniquePtr<SrsCommonMessage> msg(msg_raw);
|
||||
SrsUniquePtr<SrsConnectAppPacket> pkt(pkt_raw);
|
||||
|
||||
SrsAmf0Any* prop = NULL;
|
||||
|
||||
if ((prop = pkt->command_object->ensure_property_string("tcUrl")) == NULL) {
|
||||
|
|
@ -2383,16 +2381,17 @@ srs_error_t SrsRtmpServer::redirect(SrsRequest* r, string url, bool& accepted)
|
|||
// or we never know whether the client is ok to redirect.
|
||||
protocol->set_recv_timeout(SRS_RTMP_REDIRECT_TIMEOUT);
|
||||
if (true) {
|
||||
SrsCommonMessage* msg = NULL;
|
||||
SrsCallPacket* pkt = NULL;
|
||||
if ((err = expect_message<SrsCallPacket>(&msg, &pkt)) != srs_success) {
|
||||
SrsCommonMessage* msg_raw = NULL;
|
||||
SrsCallPacket* pkt_raw = NULL;
|
||||
if ((err = expect_message<SrsCallPacket>(&msg_raw, &pkt_raw)) != srs_success) {
|
||||
srs_freep(err);
|
||||
// ignore any error of redirect response.
|
||||
return srs_success;
|
||||
}
|
||||
SrsAutoFree(SrsCommonMessage, msg);
|
||||
SrsAutoFree(SrsCallPacket, pkt);
|
||||
|
||||
|
||||
SrsUniquePtr<SrsCommonMessage> msg(msg_raw);
|
||||
SrsUniquePtr<SrsCallPacket> pkt(pkt_raw);
|
||||
|
||||
string message;
|
||||
if (pkt->arguments && pkt->arguments->is_string()) {
|
||||
message = pkt->arguments->to_str();
|
||||
|
|
@ -2438,12 +2437,12 @@ srs_error_t SrsRtmpServer::identify_client(int stream_id, SrsRtmpConnType& type,
|
|||
srs_error_t err = srs_success;
|
||||
|
||||
while (true) {
|
||||
SrsCommonMessage* msg = NULL;
|
||||
if ((err = protocol->recv_message(&msg)) != srs_success) {
|
||||
SrsCommonMessage* msg_raw = NULL;
|
||||
if ((err = protocol->recv_message(&msg_raw)) != srs_success) {
|
||||
return srs_error_wrap(err, "recv identify message");
|
||||
}
|
||||
|
||||
SrsAutoFree(SrsCommonMessage, msg);
|
||||
|
||||
SrsUniquePtr<SrsCommonMessage> msg(msg_raw);
|
||||
SrsMessageHeader& h = msg->header;
|
||||
|
||||
if (h.is_ackledgement() || h.is_set_chunk_size() || h.is_window_ackledgement_size() || h.is_user_control_message()) {
|
||||
|
|
@ -2455,27 +2454,26 @@ srs_error_t SrsRtmpServer::identify_client(int stream_id, SrsRtmpConnType& type,
|
|||
continue;
|
||||
}
|
||||
|
||||
SrsPacket* pkt = NULL;
|
||||
if ((err = protocol->decode_message(msg, &pkt)) != srs_success) {
|
||||
SrsPacket* pkt_raw = NULL;
|
||||
if ((err = protocol->decode_message(msg.get(), &pkt_raw)) != srs_success) {
|
||||
return srs_error_wrap(err, "decode identify");
|
||||
}
|
||||
SrsUniquePtr<SrsPacket> pkt(pkt_raw);
|
||||
|
||||
SrsAutoFree(SrsPacket, pkt);
|
||||
|
||||
if (dynamic_cast<SrsCreateStreamPacket*>(pkt)) {
|
||||
return identify_create_stream_client(dynamic_cast<SrsCreateStreamPacket*>(pkt), stream_id, 3, type, stream_name, duration);
|
||||
if (dynamic_cast<SrsCreateStreamPacket*>(pkt.get())) {
|
||||
return identify_create_stream_client(dynamic_cast<SrsCreateStreamPacket*>(pkt.get()), stream_id, 3, type, stream_name, duration);
|
||||
}
|
||||
if (dynamic_cast<SrsFMLEStartPacket*>(pkt)) {
|
||||
return identify_fmle_publish_client(dynamic_cast<SrsFMLEStartPacket*>(pkt), type, stream_name);
|
||||
if (dynamic_cast<SrsFMLEStartPacket*>(pkt.get())) {
|
||||
return identify_fmle_publish_client(dynamic_cast<SrsFMLEStartPacket*>(pkt.get()), type, stream_name);
|
||||
}
|
||||
if (dynamic_cast<SrsPlayPacket*>(pkt)) {
|
||||
return identify_play_client(dynamic_cast<SrsPlayPacket*>(pkt), type, stream_name, duration);
|
||||
if (dynamic_cast<SrsPlayPacket*>(pkt.get())) {
|
||||
return identify_play_client(dynamic_cast<SrsPlayPacket*>(pkt.get()), type, stream_name, duration);
|
||||
}
|
||||
|
||||
// call msg,
|
||||
// support response null first,
|
||||
// TODO: FIXME: response in right way, or forward in edge mode.
|
||||
SrsCallPacket* call = dynamic_cast<SrsCallPacket*>(pkt);
|
||||
SrsCallPacket* call = dynamic_cast<SrsCallPacket*>(pkt.get());
|
||||
if (call) {
|
||||
SrsCallResPacket* res = new SrsCallResPacket(call->transaction_id);
|
||||
res->command_object = SrsAmf0Any::null();
|
||||
|
|
@ -2646,14 +2644,14 @@ srs_error_t SrsRtmpServer::start_fmle_publish(int stream_id)
|
|||
// FCPublish
|
||||
double fc_publish_tid = 0;
|
||||
if (true) {
|
||||
SrsCommonMessage* msg = NULL;
|
||||
SrsFMLEStartPacket* pkt = NULL;
|
||||
if ((err = expect_message<SrsFMLEStartPacket>(&msg, &pkt)) != srs_success) {
|
||||
SrsCommonMessage* msg_raw = NULL;
|
||||
SrsFMLEStartPacket* pkt_raw = NULL;
|
||||
if ((err = expect_message<SrsFMLEStartPacket>(&msg_raw, &pkt_raw)) != srs_success) {
|
||||
return srs_error_wrap(err, "recv FCPublish");
|
||||
}
|
||||
|
||||
SrsAutoFree(SrsCommonMessage, msg);
|
||||
SrsAutoFree(SrsFMLEStartPacket, pkt);
|
||||
|
||||
SrsUniquePtr<SrsCommonMessage> msg(msg_raw);
|
||||
SrsUniquePtr<SrsFMLEStartPacket> pkt(pkt_raw);
|
||||
|
||||
fc_publish_tid = pkt->transaction_id;
|
||||
}
|
||||
|
|
@ -2668,15 +2666,15 @@ srs_error_t SrsRtmpServer::start_fmle_publish(int stream_id)
|
|||
// createStream
|
||||
double create_stream_tid = 0;
|
||||
if (true) {
|
||||
SrsCommonMessage* msg = NULL;
|
||||
SrsCreateStreamPacket* pkt = NULL;
|
||||
if ((err = expect_message<SrsCreateStreamPacket>(&msg, &pkt)) != srs_success) {
|
||||
SrsCommonMessage* msg_raw = NULL;
|
||||
SrsCreateStreamPacket* pkt_raw = NULL;
|
||||
if ((err = expect_message<SrsCreateStreamPacket>(&msg_raw, &pkt_raw)) != srs_success) {
|
||||
return srs_error_wrap(err, "recv createStream");
|
||||
}
|
||||
|
||||
SrsAutoFree(SrsCommonMessage, msg);
|
||||
SrsAutoFree(SrsCreateStreamPacket, pkt);
|
||||
|
||||
|
||||
SrsUniquePtr<SrsCommonMessage> msg(msg_raw);
|
||||
SrsUniquePtr<SrsCreateStreamPacket> pkt(pkt_raw);
|
||||
|
||||
create_stream_tid = pkt->transaction_id;
|
||||
}
|
||||
// createStream response
|
||||
|
|
@ -2689,14 +2687,14 @@ srs_error_t SrsRtmpServer::start_fmle_publish(int stream_id)
|
|||
|
||||
// publish
|
||||
if (true) {
|
||||
SrsCommonMessage* msg = NULL;
|
||||
SrsPublishPacket* pkt = NULL;
|
||||
if ((err = expect_message<SrsPublishPacket>(&msg, &pkt)) != srs_success) {
|
||||
SrsCommonMessage* msg_raw = NULL;
|
||||
SrsPublishPacket* pkt_raw = NULL;
|
||||
if ((err = expect_message<SrsPublishPacket>(&msg_raw, &pkt_raw)) != srs_success) {
|
||||
return srs_error_wrap(err, "recv publish");
|
||||
}
|
||||
|
||||
SrsAutoFree(SrsCommonMessage, msg);
|
||||
SrsAutoFree(SrsPublishPacket, pkt);
|
||||
|
||||
SrsUniquePtr<SrsCommonMessage> msg(msg_raw);
|
||||
SrsUniquePtr<SrsPublishPacket> pkt(pkt_raw);
|
||||
}
|
||||
// publish response onFCPublish(NetStream.Publish.Start)
|
||||
if (true) {
|
||||
|
|
@ -2720,14 +2718,14 @@ srs_error_t SrsRtmpServer::start_haivision_publish(int stream_id)
|
|||
|
||||
// publish
|
||||
if (true) {
|
||||
SrsCommonMessage* msg = NULL;
|
||||
SrsPublishPacket* pkt = NULL;
|
||||
if ((err = expect_message<SrsPublishPacket>(&msg, &pkt)) != srs_success) {
|
||||
SrsCommonMessage* msg_raw = NULL;
|
||||
SrsPublishPacket* pkt_raw = NULL;
|
||||
if ((err = expect_message<SrsPublishPacket>(&msg_raw, &pkt_raw)) != srs_success) {
|
||||
return srs_error_wrap(err, "recv publish");
|
||||
}
|
||||
|
||||
SrsAutoFree(SrsCommonMessage, msg);
|
||||
SrsAutoFree(SrsPublishPacket, pkt);
|
||||
|
||||
SrsUniquePtr<SrsCommonMessage> msg(msg_raw);
|
||||
SrsUniquePtr<SrsPublishPacket> pkt(pkt_raw);
|
||||
}
|
||||
|
||||
// publish response onFCPublish(NetStream.Publish.Start)
|
||||
|
|
@ -2829,12 +2827,12 @@ srs_error_t SrsRtmpServer::identify_create_stream_client(SrsCreateStreamPacket*
|
|||
}
|
||||
|
||||
while (true) {
|
||||
SrsCommonMessage* msg = NULL;
|
||||
if ((err = protocol->recv_message(&msg)) != srs_success) {
|
||||
SrsCommonMessage* msg_raw = NULL;
|
||||
if ((err = protocol->recv_message(&msg_raw)) != srs_success) {
|
||||
return srs_error_wrap(err, "recv identify");
|
||||
}
|
||||
|
||||
SrsAutoFree(SrsCommonMessage, msg);
|
||||
SrsUniquePtr<SrsCommonMessage> msg(msg_raw);
|
||||
SrsMessageHeader& h = msg->header;
|
||||
|
||||
if (h.is_ackledgement() || h.is_set_chunk_size() || h.is_window_ackledgement_size() || h.is_user_control_message()) {
|
||||
|
|
@ -2846,24 +2844,23 @@ srs_error_t SrsRtmpServer::identify_create_stream_client(SrsCreateStreamPacket*
|
|||
continue;
|
||||
}
|
||||
|
||||
SrsPacket* pkt = NULL;
|
||||
if ((err = protocol->decode_message(msg, &pkt)) != srs_success) {
|
||||
SrsPacket* pkt_raw = NULL;
|
||||
if ((err = protocol->decode_message(msg.get(), &pkt_raw)) != srs_success) {
|
||||
return srs_error_wrap(err, "decode identify");
|
||||
}
|
||||
SrsUniquePtr<SrsPacket> pkt(pkt_raw);
|
||||
|
||||
SrsAutoFree(SrsPacket, pkt);
|
||||
|
||||
if (dynamic_cast<SrsPlayPacket*>(pkt)) {
|
||||
return identify_play_client(dynamic_cast<SrsPlayPacket*>(pkt), type, stream_name, duration);
|
||||
if (dynamic_cast<SrsPlayPacket*>(pkt.get())) {
|
||||
return identify_play_client(dynamic_cast<SrsPlayPacket*>(pkt.get()), type, stream_name, duration);
|
||||
}
|
||||
if (dynamic_cast<SrsPublishPacket*>(pkt)) {
|
||||
return identify_flash_publish_client(dynamic_cast<SrsPublishPacket*>(pkt), type, stream_name);
|
||||
if (dynamic_cast<SrsPublishPacket*>(pkt.get())) {
|
||||
return identify_flash_publish_client(dynamic_cast<SrsPublishPacket*>(pkt.get()), type, stream_name);
|
||||
}
|
||||
if (dynamic_cast<SrsCreateStreamPacket*>(pkt)) {
|
||||
return identify_create_stream_client(dynamic_cast<SrsCreateStreamPacket*>(pkt), stream_id, depth-1, type, stream_name, duration);
|
||||
if (dynamic_cast<SrsCreateStreamPacket*>(pkt.get())) {
|
||||
return identify_create_stream_client(dynamic_cast<SrsCreateStreamPacket*>(pkt.get()), stream_id, depth-1, type, stream_name, duration);
|
||||
}
|
||||
if (dynamic_cast<SrsFMLEStartPacket*>(pkt)) {
|
||||
return identify_haivision_publish_client(dynamic_cast<SrsFMLEStartPacket*>(pkt), type, stream_name);
|
||||
if (dynamic_cast<SrsFMLEStartPacket*>(pkt.get())) {
|
||||
return identify_haivision_publish_client(dynamic_cast<SrsFMLEStartPacket*>(pkt.get()), type, stream_name);
|
||||
}
|
||||
|
||||
srs_trace("ignore AMF0/AMF3 command message.");
|
||||
|
|
@ -3873,13 +3870,13 @@ srs_error_t SrsPlayPacket::decode(SrsBuffer* stream)
|
|||
return err;
|
||||
}
|
||||
|
||||
SrsAmf0Any* reset_value = NULL;
|
||||
if ((err = srs_amf0_read_any(stream, &reset_value)) != srs_success) {
|
||||
SrsAmf0Any* reset_value_raw = NULL;
|
||||
if ((err = srs_amf0_read_any(stream, &reset_value_raw)) != srs_success) {
|
||||
return srs_error_wrap(err, "reset");
|
||||
}
|
||||
SrsAutoFree(SrsAmf0Any, reset_value);
|
||||
SrsUniquePtr<SrsAmf0Any> reset_value(reset_value_raw);
|
||||
|
||||
if (reset_value) {
|
||||
if (reset_value.get()) {
|
||||
// check if the value is bool or number
|
||||
// An optional Boolean value or number that specifies whether
|
||||
// to flush any previous playlist
|
||||
|
|
@ -4274,20 +4271,19 @@ srs_error_t SrsOnMetaDataPacket::decode(SrsBuffer* stream)
|
|||
}
|
||||
|
||||
// the metadata maybe object or ecma array
|
||||
SrsAmf0Any* any = NULL;
|
||||
if ((err = srs_amf0_read_any(stream, &any)) != srs_success) {
|
||||
SrsAmf0Any* any_raw = NULL;
|
||||
if ((err = srs_amf0_read_any(stream, &any_raw)) != srs_success) {
|
||||
return srs_error_wrap(err, "metadata");
|
||||
}
|
||||
|
||||
srs_assert(any);
|
||||
if (any->is_object()) {
|
||||
srs_assert(any_raw);
|
||||
if (any_raw->is_object()) {
|
||||
srs_freep(metadata);
|
||||
metadata = any->to_object();
|
||||
metadata = any_raw->to_object();
|
||||
return err;
|
||||
}
|
||||
|
||||
SrsAutoFree(SrsAmf0Any, any);
|
||||
|
||||
SrsUniquePtr<SrsAmf0Any> any(any_raw);
|
||||
if (any->is_ecma_array()) {
|
||||
SrsAmf0EcmaArray* arr = any->to_ecma_array();
|
||||
|
||||
|
|
|
|||
|
|
@ -13,6 +13,7 @@ using namespace std;
|
|||
#include <srs_kernel_error.hpp>
|
||||
#include <srs_kernel_log.hpp>
|
||||
#include <srs_core_autofree.hpp>
|
||||
#include <srs_core_deprecated.hpp>
|
||||
|
||||
#include <srt/srt.h>
|
||||
|
||||
|
|
|
|||
|
|
@ -17,6 +17,7 @@ using namespace std;
|
|||
#include <srs_kernel_log.hpp>
|
||||
#include <srs_protocol_utility.hpp>
|
||||
#include <srs_kernel_utility.hpp>
|
||||
#include <srs_core_deprecated.hpp>
|
||||
|
||||
// nginx also set to 512
|
||||
#define SERVER_LISTEN_BACKLOG 512
|
||||
|
|
|
|||
|
|
@ -920,13 +920,12 @@ srs_error_t srs_ioutil_read_all(ISrsReader* in, std::string& content)
|
|||
srs_error_t err = srs_success;
|
||||
|
||||
// Cache to read, it might cause coroutine switch, so we use local cache here.
|
||||
char* buf = new char[SRS_HTTP_READ_CACHE_BYTES];
|
||||
SrsAutoFreeA(char, buf);
|
||||
SrsUniquePtr<char[]> buf(new char[SRS_HTTP_READ_CACHE_BYTES]);
|
||||
|
||||
// Whatever, read util EOF.
|
||||
while (true) {
|
||||
ssize_t nb_read = 0;
|
||||
if ((err = in->read(buf, SRS_HTTP_READ_CACHE_BYTES, &nb_read)) != srs_success) {
|
||||
if ((err = in->read(buf.get(), SRS_HTTP_READ_CACHE_BYTES, &nb_read)) != srs_success) {
|
||||
int code = srs_error_code(err);
|
||||
if (code == ERROR_SYSTEM_FILE_EOF || code == ERROR_HTTP_RESPONSE_EOF || code == ERROR_HTTP_REQUEST_EOF
|
||||
|| code == ERROR_HTTP_STREAM_EOF
|
||||
|
|
@ -938,7 +937,7 @@ srs_error_t srs_ioutil_read_all(ISrsReader* in, std::string& content)
|
|||
}
|
||||
|
||||
if (nb_read > 0) {
|
||||
content.append(buf, nb_read);
|
||||
content.append(buf.get(), nb_read);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue