external/srs
1
0
Fork 0
mirror of https://github.com/ossrs/srs.git synced 2025-03-09 15:49:59 +00:00
Code Issues Releases Wiki Activity

UniquePtr: Support SrsUniquePtr to replace SrsAutoFree. v6.0.136 (#4109)

Browse source 
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 2024-07-09 10:29:36 +08:00 • committed by GitHub
parent baf22d01c1
commit 23d2602c34
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
72 changed files with 1720 additions and 1669 deletions
Download patch file Download diff file Expand all files Collapse all files

82
trunk/src/protocol/srs_protocol_rtmp_handshake.cpp
View file

@ -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");
}