From 818000dd18d9f75aae2f1b09ffd800107812a842 Mon Sep 17 00:00:00 2001 From: winlin Date: Sat, 29 Nov 2014 18:10:33 +0800 Subject: [PATCH] for bug #235, use constructor and destructor for block and digest. --- trunk/src/rtmp/srs_protocol_handshake.cpp | 222 ++++++++++------------ trunk/src/rtmp/srs_protocol_handshake.hpp | 38 ++-- 2 files changed, 115 insertions(+), 145 deletions(-) diff --git a/trunk/src/rtmp/srs_protocol_handshake.cpp b/trunk/src/rtmp/srs_protocol_handshake.cpp index 18b59aedb..6e8ff78d6 100644 --- a/trunk/src/rtmp/srs_protocol_handshake.cpp +++ b/trunk/src/rtmp/srs_protocol_handshake.cpp @@ -292,54 +292,44 @@ namespace _srs_internal 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(); - key->random0 = NULL; - key->random1 = NULL; + int valid_offset = calc_valid_offset(); + srs_assert(valid_offset >= 0); - int offset = key->offsets(); - srs_assert(offset >= 0); - - key->random0_size = offset; - if (key->random0_size > 0) { - 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); + 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); } - srs_random_generate(key->key, sizeof(key->key)); + srs_random_generate(key, sizeof(key)); - key->random1_size = 764 - offset - 128 - 4; - if (key->random1_size > 0) { - key->random1 = new char[key->random1_size]; - srs_random_generate(key->random1, key->random1_size); - snprintf(key->random1, key->random1_size, "%s", RTMP_SIG_SRS_HANDSHAKE); + random1_size = 764 - valid_offset - 128 - 4; + if (random1_size > 0) { + random1 = new char[random1_size]; + srs_random_generate(random1, random1_size); + snprintf(random1, random1_size, "%s", RTMP_SIG_SRS_HANDSHAKE); } } - int key_block::offsets() + key_block::~key_block() { - key_block* key = this; - - int max_offset_size = 764 - 128 - 4; - - int offset = 0; - u_int8_t* pp = (u_int8_t*)&key->offset; - offset += *pp++; - offset += *pp++; - offset += *pp++; - offset += *pp++; - - return offset % max_offset_size; + if (random0) { + srs_freep(random0); + } + if (random1) { + srs_freep(random1); + } } int key_block::parse(SrsStream* stream) { - key_block* key = this; - int ret = ERROR_SUCCESS; // the key must be 764 bytes. @@ -347,148 +337,138 @@ namespace _srs_internal // read the last offset first, 760-763 stream->skip(764 - sizeof(int32_t)); - key->offset = stream->read_4bytes(); + offset = stream->read_4bytes(); // reset stream to read others. stream->skip(-764); // TODO: FIXME: free it. - key->random0 = NULL; - key->random1 = NULL; + random0 = NULL; + random1 = NULL; - int offset = key->offsets(); - srs_assert(offset >= 0); + int valid_offset = calc_valid_offset(); + srs_assert(valid_offset >= 0); - key->random0_size = offset; - if (key->random0_size > 0) { - key->random0 = new char[key->random0_size]; - stream->read_bytes(key->random0, key->random0_size); + random0_size = valid_offset; + if (random0_size > 0) { + random0 = new char[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; - if (key->random1_size > 0) { - key->random1 = new char[key->random1_size]; - stream->read_bytes(key->random1, key->random1_size); + random1_size = 764 - valid_offset - 128 - 4; + if (random1_size > 0) { + random1 = new char[random1_size]; + stream->read_bytes(random1, random1_size); } 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) { - srs_freep(key->random0); + int valid_offset = 0; + 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; - - 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 (random0) { + srs_freep(random0); } - - srs_random_generate(digest->digest, sizeof(digest->digest)); - - 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); + if (random1) { + srs_freep(random1); } } - - 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) { - digest_block* digest = this; - int ret = ERROR_SUCCESS; // the digest must be 764 bytes. srs_assert(stream->require(764)); - digest->offset = stream->read_4bytes(); + offset = stream->read_4bytes(); // TODO: FIXME: free it. - digest->random0 = NULL; - digest->random1 = NULL; + random0 = NULL; + random1 = NULL; - int offset = digest->offsets(); - srs_assert(offset >= 0); + int valid_offset = calc_valid_offset(); + srs_assert(valid_offset >= 0); - digest->random0_size = offset; - if (digest->random0_size > 0) { - digest->random0 = new char[digest->random0_size]; - stream->read_bytes(digest->random0, digest->random0_size); + random0_size = valid_offset; + if (random0_size > 0) { + random0 = new char[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; - if (digest->random1_size > 0) { - digest->random1 = new char[digest->random1_size]; - stream->read_bytes(digest->random1, digest->random1_size); + random1_size = 764 - 4 - valid_offset - 32; + if (random1_size > 0) { + random1 = new char[random1_size]; + stream->read_bytes(random1, random1_size); } 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) { - srs_freep(digest->random0); - } - if (digest->random1) { - srs_freep(digest->random1); - } + int valid_offset = 0; + 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; } c1s1_strategy::c1s1_strategy() { - key.init(); - digest.init(); } c1s1_strategy::~c1s1_strategy() { - key.free(); - digest.free(); } char* c1s1_strategy::get_digest() diff --git a/trunk/src/rtmp/srs_protocol_handshake.hpp b/trunk/src/rtmp/srs_protocol_handshake.hpp index c02ceac01..82a4137d8 100644 --- a/trunk/src/rtmp/srs_protocol_handshake.hpp +++ b/trunk/src/rtmp/srs_protocol_handshake.hpp @@ -133,22 +133,17 @@ namespace _srs_internal // 4bytes int32_t offset; public: - // create new key block data. - // if created, user must free it by srs_key_block_free - void init(); - - // calc the offset of key, - // the key->offset cannot be used as the offset of key. - int offsets(); - + key_block(); + virtual ~key_block(); + public: // parse key block from c1s1. // if created, user must free it by srs_key_block_free // @stream contains c1s1_key_bytes the key start bytes int parse(SrsStream* stream); - - // free the block data create by - // srs_key_block_init or srs_key_block_parse - void free(); + private: + // calc the offset of key, + // the key->offset cannot be used as the offset of key. + int calc_valid_offset(); }; /** @@ -176,22 +171,17 @@ namespace _srs_internal char* random1; int random1_size; public: - // create new digest block data. - // if created, user must free it by srs_digest_block_free - void init(); - - // calc the offset of digest, - // the key->offset cannot be used as the offset of digest. - int offsets(); - + digest_block(); + virtual ~digest_block(); + public: // parse digest block from c1s1. // if created, user must free it by srs_digest_block_free // @stream contains c1s1_digest_bytes the digest start bytes int parse(SrsStream* stream); - - // free the block data create by - // srs_digest_block_init or srs_digest_block_parse - void free(); + private: + // calc the offset of digest, + // the key->offset cannot be used as the offset of digest. + int calc_valid_offset(); }; class c1s1;