external/srs
1
0
Fork 0
mirror of https://github.com/ossrs/srs.git synced 2025-02-15 04:42:04 +00:00
Code Issues Releases Wiki Activity

for bug #235, use constructor and destructor for block and digest.

Browse source
This commit is contained in:
winlin 2014-11-29 18:10:33 +08:00
parent b32d3fb6aa
commit 818000dd18
2 changed files with 115 additions and 145 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

222
trunk/src/rtmp/srs_protocol_handshake.cpp
View file

@ -292,54 +292,44 @@ namespace _srs_internal
return ret; return ret;
} }
void key_block::init() key_block::key_block()
{ {
key_block* key = this; offset = (int32_t)rand();
random0 = NULL;
random1 = NULL;
key->offset = (int32_t)rand(); int valid_offset = calc_valid_offset();
key->random0 = NULL; srs_assert(valid_offset >= 0);
key->random1 = NULL;
int offset = key->offsets(); random0_size = valid_offset;
srs_assert(offset >= 0); if (random0_size > 0) {
random0 = new char[random0_size];
key->random0_size = offset; srs_random_generate(random0, random0_size);
if (key->random0_size > 0) { snprintf(random0, random0_size, "%s", RTMP_SIG_SRS_HANDSHAKE);
key->random0 = new char[key->random0_size];
srs_random_generate(key->random0, key->random0_size);
snprintf(key->random0, key->random0_size, "%s", RTMP_SIG_SRS_HANDSHAKE);
} }
srs_random_generate(key->key, sizeof(key->key)); srs_random_generate(key, sizeof(key));
key->random1_size = 764 - offset - 128 - 4; random1_size = 764 - valid_offset - 128 - 4;
if (key->random1_size > 0) { if (random1_size > 0) {
key->random1 = new char[key->random1_size]; random1 = new char[random1_size];
srs_random_generate(key->random1, key->random1_size); srs_random_generate(random1, random1_size);
snprintf(key->random1, key->random1_size, "%s", RTMP_SIG_SRS_HANDSHAKE); snprintf(random1, random1_size, "%s", RTMP_SIG_SRS_HANDSHAKE);
} }
} }
int key_block::offsets() key_block::~key_block()
{ {
key_block* key = this; if (random0) {
srs_freep(random0);
int max_offset_size = 764 - 128 - 4; }
if (random1) {
int offset = 0; srs_freep(random1);
u_int8_t* pp = (u_int8_t*)&key->offset; }
offset += *pp++;
offset += *pp++;
offset += *pp++;
offset += *pp++;
return offset % max_offset_size;
} }
int key_block::parse(SrsStream* stream) int key_block::parse(SrsStream* stream)
{ {
key_block* key = this;
int ret = ERROR_SUCCESS; int ret = ERROR_SUCCESS;
// the key must be 764 bytes. // the key must be 764 bytes.
@ -347,148 +337,138 @@ namespace _srs_internal
// read the last offset first, 760-763 // read the last offset first, 760-763
stream->skip(764 - sizeof(int32_t)); stream->skip(764 - sizeof(int32_t));
key->offset = stream->read_4bytes(); offset = stream->read_4bytes();
// reset stream to read others. // reset stream to read others.
stream->skip(-764); stream->skip(-764);
// TODO: FIXME: free it. // TODO: FIXME: free it.
key->random0 = NULL; random0 = NULL;
key->random1 = NULL; random1 = NULL;
int offset = key->offsets(); int valid_offset = calc_valid_offset();
srs_assert(offset >= 0); srs_assert(valid_offset >= 0);
key->random0_size = offset; random0_size = valid_offset;
if (key->random0_size > 0) { if (random0_size > 0) {
key->random0 = new char[key->random0_size]; random0 = new char[random0_size];
stream->read_bytes(key->random0, key->random0_size); stream->read_bytes(random0, random0_size);
} }
stream->read_bytes(key->key, 128); stream->read_bytes(key, 128);
key->random1_size = 764 - offset - 128 - 4; random1_size = 764 - valid_offset - 128 - 4;
if (key->random1_size > 0) { if (random1_size > 0) {
key->random1 = new char[key->random1_size]; random1 = new char[random1_size];
stream->read_bytes(key->random1, key->random1_size); stream->read_bytes(random1, random1_size);
} }
return ret; return ret;
} }
void key_block::free() int key_block::calc_valid_offset()
{ {
key_block* key = this; int max_offset_size = 764 - 128 - 4;
if (key->random0) { int valid_offset = 0;
srs_freep(key->random0); u_int8_t* pp = (u_int8_t*)&offset;
valid_offset += *pp++;
valid_offset += *pp++;
valid_offset += *pp++;
valid_offset += *pp++;
return valid_offset % max_offset_size;
}
digest_block::digest_block()
{
offset = (int32_t)rand();
random0 = NULL;
random1 = NULL;
int valid_offset = calc_valid_offset();
srs_assert(valid_offset >= 0);
random0_size = valid_offset;
if (random0_size > 0) {
random0 = new char[random0_size];
srs_random_generate(random0, random0_size);
snprintf(random0, random0_size, "%s", RTMP_SIG_SRS_HANDSHAKE);
} }
if (key->random1) {
srs_freep(key->random1); srs_random_generate(digest, sizeof(digest));
random1_size = 764 - 4 - valid_offset - 32;
if (random1_size > 0) {
random1 = new char[random1_size];
srs_random_generate(random1, random1_size);
snprintf(random1, random1_size, "%s", RTMP_SIG_SRS_HANDSHAKE);
} }
} }
void digest_block::init() digest_block::~digest_block()
{ {
digest_block* digest = this; if (random0) {
srs_freep(random0);
digest->offset = (int32_t)rand();
digest->random0 = NULL;
digest->random1 = NULL;
int offset = digest->offsets();
srs_assert(offset >= 0);
digest->random0_size = offset;
if (digest->random0_size > 0) {
digest->random0 = new char[digest->random0_size];
srs_random_generate(digest->random0, digest->random0_size);
snprintf(digest->random0, digest->random0_size, "%s", RTMP_SIG_SRS_HANDSHAKE);
} }
if (random1) {
srs_random_generate(digest->digest, sizeof(digest->digest)); srs_freep(random1);
digest->random1_size = 764 - 4 - offset - 32;
if (digest->random1_size > 0) {
digest->random1 = new char[digest->random1_size];
srs_random_generate(digest->random1, digest->random1_size);
snprintf(digest->random1, digest->random1_size, "%s", RTMP_SIG_SRS_HANDSHAKE);
} }
} }
int digest_block::offsets()
{
digest_block* digest = this;
int max_offset_size = 764 - 32 - 4;
int offset = 0;
u_int8_t* pp = (u_int8_t*)&digest->offset;
offset += *pp++;
offset += *pp++;
offset += *pp++;
offset += *pp++;
return offset % max_offset_size;
}
int digest_block::parse(SrsStream* stream) int digest_block::parse(SrsStream* stream)
{ {
digest_block* digest = this;
int ret = ERROR_SUCCESS; int ret = ERROR_SUCCESS;
// the digest must be 764 bytes. // the digest must be 764 bytes.
srs_assert(stream->require(764)); srs_assert(stream->require(764));
digest->offset = stream->read_4bytes(); offset = stream->read_4bytes();
// TODO: FIXME: free it. // TODO: FIXME: free it.
digest->random0 = NULL; random0 = NULL;
digest->random1 = NULL; random1 = NULL;
int offset = digest->offsets(); int valid_offset = calc_valid_offset();
srs_assert(offset >= 0); srs_assert(valid_offset >= 0);
digest->random0_size = offset; random0_size = valid_offset;
if (digest->random0_size > 0) { if (random0_size > 0) {
digest->random0 = new char[digest->random0_size]; random0 = new char[random0_size];
stream->read_bytes(digest->random0, digest->random0_size); stream->read_bytes(random0, random0_size);
} }
stream->read_bytes(digest->digest, 32); stream->read_bytes(digest, 32);
digest->random1_size = 764 - 4 - offset - 32; random1_size = 764 - 4 - valid_offset - 32;
if (digest->random1_size > 0) { if (random1_size > 0) {
digest->random1 = new char[digest->random1_size]; random1 = new char[random1_size];
stream->read_bytes(digest->random1, digest->random1_size); stream->read_bytes(random1, random1_size);
} }
return ret; return ret;
} }
void digest_block::free() int digest_block::calc_valid_offset()
{ {
digest_block* digest = this; int max_offset_size = 764 - 32 - 4;
if (digest->random0) { int valid_offset = 0;
srs_freep(digest->random0); u_int8_t* pp = (u_int8_t*)&offset;
} valid_offset += *pp++;
if (digest->random1) { valid_offset += *pp++;
srs_freep(digest->random1); valid_offset += *pp++;
} valid_offset += *pp++;
return valid_offset % max_offset_size;
} }
c1s1_strategy::c1s1_strategy() c1s1_strategy::c1s1_strategy()
{ {
key.init();
digest.init();
} }
c1s1_strategy::~c1s1_strategy() c1s1_strategy::~c1s1_strategy()
{ {
key.free();
digest.free();
} }
char* c1s1_strategy::get_digest() char* c1s1_strategy::get_digest()

38
trunk/src/rtmp/srs_protocol_handshake.hpp
View file

@ -133,22 +133,17 @@ namespace _srs_internal
// 4bytes // 4bytes
int32_t offset; int32_t offset;
public: public:
// create new key block data. key_block();
// if created, user must free it by srs_key_block_free virtual ~key_block();
void init(); public:
// calc the offset of key,
// the key->offset cannot be used as the offset of key.
int offsets();
// parse key block from c1s1. // parse key block from c1s1.
// if created, user must free it by srs_key_block_free // if created, user must free it by srs_key_block_free
// @stream contains c1s1_key_bytes the key start bytes // @stream contains c1s1_key_bytes the key start bytes
int parse(SrsStream* stream); int parse(SrsStream* stream);
private:
// free the block data create by // calc the offset of key,
// srs_key_block_init or srs_key_block_parse // the key->offset cannot be used as the offset of key.
void free(); int calc_valid_offset();
}; };
/** /**
@ -176,22 +171,17 @@ namespace _srs_internal
char* random1; char* random1;
int random1_size; int random1_size;
public: public:
// create new digest block data. digest_block();
// if created, user must free it by srs_digest_block_free virtual ~digest_block();
void init(); public:
// calc the offset of digest,
// the key->offset cannot be used as the offset of digest.
int offsets();
// parse digest block from c1s1. // parse digest block from c1s1.
// if created, user must free it by srs_digest_block_free // if created, user must free it by srs_digest_block_free
// @stream contains c1s1_digest_bytes the digest start bytes // @stream contains c1s1_digest_bytes the digest start bytes
int parse(SrsStream* stream); int parse(SrsStream* stream);
private:
// free the block data create by // calc the offset of digest,
// srs_digest_block_init or srs_digest_block_parse // the key->offset cannot be used as the offset of digest.
void free(); int calc_valid_offset();
}; };
class c1s1; class c1s1;