github
/
aria2
mirror of https://github.com/aria2/aria2
1
0
Fork 0
Code Issues Releases Wiki Activity

Consistent naming scheme for hash type and digest.

pull/1/head
Tatsuhiro Tsujikawa 2011-07-27 21:44:54 +09:00
parent ce101f5ad2
commit 7b86b294c9
11 changed files with 154 additions and 154 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

26
src/Checksum.cc
View File

@ -37,38 +37,40 @@
namespace aria2 { namespace aria2 {
Checksum::Checksum(const std::string& algo, const std::string& messageDigest) Checksum::Checksum
: algo_(algo), (const std::string& hashType,
messageDigest_(messageDigest) const std::string& digest)
: hashType_(hashType),
digest_(digest)
{} {}
Checksum::Checksum() Checksum::Checksum()
: algo_("sha-1") : hashType_("sha-1")
{} {}
Checksum::~Checksum() {} Checksum::~Checksum() {}
bool Checksum::isEmpty() const bool Checksum::isEmpty() const
{ {
return messageDigest_.empty(); return digest_.empty();
} }
void Checksum::setMessageDigest(const std::string& md) void Checksum::setDigest(const std::string& digest)
{ {
messageDigest_ = md; digest_ = digest;
} }
void Checksum::setAlgo(const std::string& algo) void Checksum::setHashType(const std::string& hashType)
{ {
algo_ = algo; hashType_ = hashType;
} }
void Checksum::swap(Checksum& other) void Checksum::swap(Checksum& other)
{ {
using std::swap; using std::swap;
if(this != &other) { if(this != &other) {
swap(algo_, other.algo_); swap(hashType_, other.hashType_);
swap(messageDigest_, other.messageDigest_); swap(digest_, other.digest_);
} }
} }
@ -80,7 +82,7 @@ void swap(Checksum& a, Checksum& b)
bool HashTypeStronger::operator() bool HashTypeStronger::operator()
(const Checksum& lhs, const Checksum& rhs) const (const Checksum& lhs, const Checksum& rhs) const
{ {
return MessageDigest::isStronger(lhs.getAlgo(), rhs.getAlgo()); return MessageDigest::isStronger(lhs.getHashType(), rhs.getHashType());
} }
} // namespace aria2 } // namespace aria2

18
src/Checksum.h
View File

@ -43,26 +43,26 @@ namespace aria2 {
class Checksum { class Checksum {
private: private:
std::string algo_; std::string hashType_;
std::string messageDigest_; std::string digest_;
public: public:
// messageDigest_ is ascii hexadecimal notation. // messageDigest_ is ascii hexadecimal notation.
Checksum(const std::string& algo, const std::string& messageDigest); Checksum(const std::string& hashType, const std::string& digest);
Checksum(); Checksum();
~Checksum(); ~Checksum();
bool isEmpty() const; bool isEmpty() const;
void setMessageDigest(const std::string& md); void setDigest(const std::string& md);
const std::string& getMessageDigest() const const std::string& getDigest() const
{ {
return messageDigest_; return digest_;
} }
void setAlgo(const std::string& algo); void setHashType(const std::string& type);
const std::string& getAlgo() const const std::string& getHashType() const
{ {
return algo_; return hashType_;
} }
void swap(Checksum& other); void swap(Checksum& other);

45
src/ChunkChecksum.cc
View File

@ -37,55 +37,52 @@
namespace aria2 { namespace aria2 {
ChunkChecksum::ChunkChecksum():checksumLength_(0) {} ChunkChecksum::ChunkChecksum():pieceLength_(0) {}
ChunkChecksum::ChunkChecksum ChunkChecksum::ChunkChecksum
(const std::string& algo, (const std::string& hashType,
const std::vector<std::string>& checksums, const std::vector<std::string>& pieceHashes,
size_t checksumLength) size_t pieceLength)
: algo_(algo), : hashType_(hashType),
checksums_(checksums), pieceHashes_(pieceHashes),
checksumLength_(checksumLength) pieceLength_(pieceLength)
{} {}
bool ChunkChecksum::validateChunk bool ChunkChecksum::validateChunk
(const std::string& actualChecksum, (const std::string& actualDigest,
size_t checksumIndex) const size_t index) const
{ {
if(checksumIndex < checksums_.size()) { const std::string& digest = getPieceHash(index);
return actualChecksum == getChecksum(checksumIndex); return !digest.empty() && actualDigest == digest;
} else {
return false;
}
} }
uint64_t ChunkChecksum::getEstimatedDataLength() const uint64_t ChunkChecksum::getEstimatedDataLength() const
{ {
return static_cast<uint64_t>(checksumLength_)*checksums_.size(); return static_cast<uint64_t>(pieceLength_)*pieceHashes_.size();
} }
size_t ChunkChecksum::countChecksum() const size_t ChunkChecksum::countPieceHash() const
{ {
return checksums_.size(); return pieceHashes_.size();
} }
const std::string& ChunkChecksum::getChecksum(size_t index) const const std::string& ChunkChecksum::getPieceHash(size_t index) const
{ {
if(index < checksums_.size()) { if(index < pieceHashes_.size()) {
return checksums_[index]; return pieceHashes_[index];
} else { } else {
return A2STR::NIL; return A2STR::NIL;
} }
} }
void ChunkChecksum::setAlgo(const std::string& algo) void ChunkChecksum::setHashType(const std::string& hashType)
{ {
algo_ = algo; hashType_ = hashType;
} }
void ChunkChecksum::setChecksums(const std::vector<std::string>& mds) void ChunkChecksum::setPieceHashes(const std::vector<std::string>& pieceHashes)
{ {
checksums_ = mds; pieceHashes_ = pieceHashes;
} }
} // namespace aria2 } // namespace aria2

41
src/ChunkChecksum.h
View File

@ -46,45 +46,46 @@ namespace aria2 {
class ChunkChecksum { class ChunkChecksum {
private: private:
std::string algo_; std::string hashType_;
std::vector<std::string> checksums_; std::vector<std::string> pieceHashes_;
size_t checksumLength_; size_t pieceLength_;
public: public:
ChunkChecksum(); ChunkChecksum();
ChunkChecksum(const std::string& algo, ChunkChecksum
const std::vector<std::string>& checksums, (const std::string& hashType,
size_t checksumLength); const std::vector<std::string>& pieceHashes,
size_t pieceLength);
bool validateChunk(const std::string& actualChecksum, bool validateChunk(const std::string& actualDigest,
size_t checksumIndex) const; size_t index) const;
uint64_t getEstimatedDataLength() const; uint64_t getEstimatedDataLength() const;
size_t countChecksum() const; size_t countPieceHash() const;
const std::string& getChecksum(size_t index) const; const std::string& getPieceHash(size_t index) const;
void setChecksums(const std::vector<std::string>& mds); void setPieceHashes(const std::vector<std::string>& pieceHashes);
const std::vector<std::string>& getChecksums() const const std::vector<std::string>& getPieceHashes() const
{ {
return checksums_; return pieceHashes_;
} }
size_t getChecksumLength() const void setHashType(const std::string& hashType);
const std::string& getHashType() const
{ {
return checksumLength_; return hashType_;
} }
void setAlgo(const std::string& algo); size_t getPieceLength() const
const std::string& getAlgo() const
{ {
return algo_; return pieceLength_;
} }
void setChecksumLength(size_t length) void setPieceLength(size_t length)
{ {
checksumLength_ = length; pieceLength_ = length;
} }
}; };

4
src/HttpResponse.cc
View File

@ -424,10 +424,10 @@ void HttpResponse::getDigest(std::vector<Checksum>& result) const
bool ok = true; bool ok = true;
std::vector<Checksum>::iterator j = i+1; std::vector<Checksum>::iterator j = i+1;
for(; j != eoi; ++j) { for(; j != eoi; ++j) {
if((*i).getAlgo() != (*j).getAlgo()) { if((*i).getHashType() != (*j).getHashType()) {
break; break;
} }
if((*i).getMessageDigest() != (*j).getMessageDigest()) { if((*i).getDigest() != (*j).getDigest()) {
ok = false; ok = false;
} }
} }

12
src/HttpResponseCommand.cc
View File

@ -215,10 +215,10 @@ bool HttpResponseCommand::executeInternal()
eoi = checksums.end(); i != eoi; ++i) { eoi = checksums.end(); i != eoi; ++i) {
if(getDownloadContext()->getChecksumHashAlgo().empty()) { if(getDownloadContext()->getChecksumHashAlgo().empty()) {
A2_LOG_DEBUG(fmt("Setting digest: type=%s, digest=%s", A2_LOG_DEBUG(fmt("Setting digest: type=%s, digest=%s",
(*i).getAlgo().c_str(), (*i).getHashType().c_str(),
(*i).getMessageDigest().c_str())); (*i).getDigest().c_str()));
getDownloadContext()->setChecksumHashAlgo((*i).getAlgo()); getDownloadContext()->setChecksumHashAlgo((*i).getHashType());
getDownloadContext()->setChecksum((*i).getMessageDigest()); getDownloadContext()->setChecksum((*i).getDigest());
break; break;
} else { } else {
if(checkChecksum(getDownloadContext(), *i)) { if(checkChecksum(getDownloadContext(), *i)) {
@ -559,8 +559,8 @@ bool HttpResponseCommand::checkChecksum
(const SharedHandle<DownloadContext>& dctx, (const SharedHandle<DownloadContext>& dctx,
const Checksum& checksum) const Checksum& checksum)
{ {
if(dctx->getChecksumHashAlgo() == checksum.getAlgo()) { if(dctx->getChecksumHashAlgo() == checksum.getHashType()) {
if(dctx->getChecksum() == checksum.getMessageDigest()) { if(dctx->getChecksum() == checksum.getDigest()) {
A2_LOG_INFO("Valid hash found in Digest header field."); A2_LOG_INFO("Valid hash found in Digest header field.");
return true; return true;
} else { } else {

12
src/Metalink2RequestGroup.cc
View File

@ -245,7 +245,7 @@ Metalink2RequestGroup::createRequestGroup
if(!entry->chunkChecksum) { if(!entry->chunkChecksum) {
pieceLength = option->getAsInt(PREF_SEGMENT_SIZE); pieceLength = option->getAsInt(PREF_SEGMENT_SIZE);
} else { } else {
pieceLength = entry->chunkChecksum->getChecksumLength(); pieceLength = entry->chunkChecksum->getPieceLength();
} }
#else #else
pieceLength = option->getAsInt(PREF_SEGMENT_SIZE); pieceLength = option->getAsInt(PREF_SEGMENT_SIZE);
@ -263,13 +263,13 @@ Metalink2RequestGroup::createRequestGroup
} }
#ifdef ENABLE_MESSAGE_DIGEST #ifdef ENABLE_MESSAGE_DIGEST
if(entry->checksum) { if(entry->checksum) {
dctx->setChecksum(entry->checksum->getMessageDigest()); dctx->setChecksum(entry->checksum->getDigest());
dctx->setChecksumHashAlgo(entry->checksum->getAlgo()); dctx->setChecksumHashAlgo(entry->checksum->getHashType());
} }
if(entry->chunkChecksum) { if(entry->chunkChecksum) {
dctx->setPieceHashes(entry->chunkChecksum->getChecksums().begin(), dctx->setPieceHashes(entry->chunkChecksum->getPieceHashes().begin(),
entry->chunkChecksum->getChecksums().end()); entry->chunkChecksum->getPieceHashes().end());
dctx->setPieceHashAlgo(entry->chunkChecksum->getAlgo()); dctx->setPieceHashAlgo(entry->chunkChecksum->getHashType());
} }
#endif // ENABLE_MESSAGE_DIGEST #endif // ENABLE_MESSAGE_DIGEST
dctx->setSignature(entry->getSignature()); dctx->setSignature(entry->getSignature());

44
src/MetalinkParserController.cc
View File

@ -270,7 +270,7 @@ void MetalinkParserController::setTypeOfChecksum(const std::string& type)
} }
std::string calgo = MessageDigest::getCanonicalHashType(type); std::string calgo = MessageDigest::getCanonicalHashType(type);
if(MessageDigest::supports(calgo)) { if(MessageDigest::supports(calgo)) {
tChecksum_->setAlgo(calgo); tChecksum_->setHashType(calgo);
} else { } else {
cancelChecksumTransaction(); cancelChecksumTransaction();
} }
@ -283,8 +283,8 @@ void MetalinkParserController::setHashOfChecksum(const std::string& md)
if(!tChecksum_) { if(!tChecksum_) {
return; return;
} }
if(MessageDigest::isValidHash(tChecksum_->getAlgo(), md)) { if(MessageDigest::isValidHash(tChecksum_->getHashType(), md)) {
tChecksum_->setMessageDigest(md); tChecksum_->setDigest(md);
} else { } else {
cancelChecksumTransaction(); cancelChecksumTransaction();
} }
@ -298,8 +298,8 @@ void MetalinkParserController::commitChecksumTransaction()
return; return;
} }
if(!tEntry_->checksum || if(!tEntry_->checksum ||
MessageDigest::isStronger(tChecksum_->getAlgo(), MessageDigest::isStronger(tChecksum_->getHashType(),
tEntry_->checksum->getAlgo())) { tEntry_->checksum->getHashType())) {
tEntry_->checksum = tChecksum_; tEntry_->checksum = tChecksum_;
} }
tChecksum_.reset(); tChecksum_.reset();
@ -332,7 +332,7 @@ void MetalinkParserController::setTypeOfChunkChecksumV4(const std::string& type)
} }
std::string calgo = MessageDigest::getCanonicalHashType(type); std::string calgo = MessageDigest::getCanonicalHashType(type);
if(MessageDigest::supports(calgo)) { if(MessageDigest::supports(calgo)) {
tChunkChecksumV4_->setAlgo(calgo); tChunkChecksumV4_->setHashType(calgo);
} else { } else {
cancelChunkChecksumTransactionV4(); cancelChunkChecksumTransactionV4();
} }
@ -346,7 +346,7 @@ void MetalinkParserController::setLengthOfChunkChecksumV4(size_t length)
return; return;
} }
if(length > 0) { if(length > 0) {
tChunkChecksumV4_->setChecksumLength(length); tChunkChecksumV4_->setPieceLength(length);
} else { } else {
cancelChunkChecksumTransactionV4(); cancelChunkChecksumTransactionV4();
} }
@ -359,7 +359,7 @@ void MetalinkParserController::addHashOfChunkChecksumV4(const std::string& md)
if(!tChunkChecksumV4_) { if(!tChunkChecksumV4_) {
return; return;
} }
if(MessageDigest::isValidHash(tChunkChecksumV4_->getAlgo(), md)) { if(MessageDigest::isValidHash(tChunkChecksumV4_->getHashType(), md)) {
tempChunkChecksumsV4_.push_back(md); tempChunkChecksumsV4_.push_back(md);
} else { } else {
cancelChunkChecksumTransactionV4(); cancelChunkChecksumTransactionV4();
@ -374,11 +374,11 @@ void MetalinkParserController::commitChunkChecksumTransactionV4()
return; return;
} }
if(!tEntry_->chunkChecksum || if(!tEntry_->chunkChecksum ||
MessageDigest::isStronger(tChunkChecksumV4_->getAlgo(), MessageDigest::isStronger(tChunkChecksumV4_->getHashType(),
tEntry_->chunkChecksum->getAlgo())) { tEntry_->chunkChecksum->getHashType())) {
std::vector<std::string> checksums(tempChunkChecksumsV4_.begin(), std::vector<std::string> pieceHashes(tempChunkChecksumsV4_.begin(),
tempChunkChecksumsV4_.end()); tempChunkChecksumsV4_.end());
tChunkChecksumV4_->setChecksums(checksums); tChunkChecksumV4_->setPieceHashes(pieceHashes);
tEntry_->chunkChecksum = tChunkChecksumV4_; tEntry_->chunkChecksum = tChunkChecksumV4_;
} }
tChunkChecksumV4_.reset(); tChunkChecksumV4_.reset();
@ -411,7 +411,7 @@ void MetalinkParserController::setTypeOfChunkChecksum(const std::string& type)
} }
std::string calgo = MessageDigest::getCanonicalHashType(type); std::string calgo = MessageDigest::getCanonicalHashType(type);
if(MessageDigest::supports(calgo)) { if(MessageDigest::supports(calgo)) {
tChunkChecksum_->setAlgo(calgo); tChunkChecksum_->setHashType(calgo);
} else { } else {
cancelChunkChecksumTransaction(); cancelChunkChecksumTransaction();
} }
@ -425,7 +425,7 @@ void MetalinkParserController::setLengthOfChunkChecksum(size_t length)
return; return;
} }
if(length > 0) { if(length > 0) {
tChunkChecksum_->setChecksumLength(length); tChunkChecksum_->setPieceLength(length);
} else { } else {
cancelChunkChecksumTransaction(); cancelChunkChecksumTransaction();
} }
@ -438,7 +438,7 @@ void MetalinkParserController::addHashOfChunkChecksum(size_t order, const std::s
if(!tChunkChecksum_) { if(!tChunkChecksum_) {
return; return;
} }
if(MessageDigest::isValidHash(tChunkChecksum_->getAlgo(), md)) { if(MessageDigest::isValidHash(tChunkChecksum_->getHashType(), md)) {
tempChunkChecksums_.push_back(std::make_pair(order, md)); tempChunkChecksums_.push_back(std::make_pair(order, md));
} else { } else {
cancelChunkChecksumTransaction(); cancelChunkChecksumTransaction();
@ -462,7 +462,7 @@ void MetalinkParserController::setMessageDigestOfChunkChecksum(const std::string
if(!tChunkChecksum_) { if(!tChunkChecksum_) {
return; return;
} }
if(MessageDigest::isValidHash(tChunkChecksum_->getAlgo(), md)) { if(MessageDigest::isValidHash(tChunkChecksum_->getHashType(), md)) {
tempHashPair_.second = md; tempHashPair_.second = md;
} else { } else {
cancelChunkChecksumTransaction(); cancelChunkChecksumTransaction();
@ -487,15 +487,15 @@ void MetalinkParserController::commitChunkChecksumTransaction()
return; return;
} }
if(!tEntry_->chunkChecksum || if(!tEntry_->chunkChecksum ||
MessageDigest::isStronger(tChunkChecksum_->getAlgo(), MessageDigest::isStronger(tChunkChecksum_->getHashType(),
tEntry_->chunkChecksum->getAlgo())) { tEntry_->chunkChecksum->getHashType())) {
std::sort(tempChunkChecksums_.begin(), tempChunkChecksums_.end(), std::sort(tempChunkChecksums_.begin(), tempChunkChecksums_.end(),
Ascend1st<std::pair<size_t, std::string> >()); Ascend1st<std::pair<size_t, std::string> >());
std::vector<std::string> checksums; std::vector<std::string> pieceHashes;
std::transform(tempChunkChecksums_.begin(), tempChunkChecksums_.end(), std::transform(tempChunkChecksums_.begin(), tempChunkChecksums_.end(),
std::back_inserter(checksums), std::back_inserter(pieceHashes),
select2nd<std::pair<size_t, std::string> >()); select2nd<std::pair<size_t, std::string> >());
tChunkChecksum_->setChecksums(checksums); tChunkChecksum_->setPieceHashes(pieceHashes);
tEntry_->chunkChecksum = tChunkChecksum_; tEntry_->chunkChecksum = tChunkChecksum_;
} }
tChunkChecksum_.reset(); tChunkChecksum_.reset();

8
test/HttpResponseTest.cc
View File

@ -671,14 +671,14 @@ void HttpResponseTest::testGetDigest()
CPPUNIT_ASSERT_EQUAL((size_t)3, result.size()); CPPUNIT_ASSERT_EQUAL((size_t)3, result.size());
Checksum c = result[0]; Checksum c = result[0];
CPPUNIT_ASSERT_EQUAL(std::string("sha-256"), c.getAlgo()); CPPUNIT_ASSERT_EQUAL(std::string("sha-256"), c.getHashType());
CPPUNIT_ASSERT_EQUAL(std::string("f83f271ae773dc6fe4a6454a41e0eb237c43e7bbf451e426cc60993a4d379ec5"), CPPUNIT_ASSERT_EQUAL(std::string("f83f271ae773dc6fe4a6454a41e0eb237c43e7bbf451e426cc60993a4d379ec5"),
c.getMessageDigest()); c.getDigest());
c = result[1]; c = result[1];
CPPUNIT_ASSERT_EQUAL(std::string("sha-1"), c.getAlgo()); CPPUNIT_ASSERT_EQUAL(std::string("sha-1"), c.getHashType());
CPPUNIT_ASSERT_EQUAL(std::string("f36003f22b462ffa184390533c500d8989e9f681"), CPPUNIT_ASSERT_EQUAL(std::string("f36003f22b462ffa184390533c500d8989e9f681"),
c.getMessageDigest()); c.getDigest());
} }
#endif // ENABLE_MESSAGE_DIGEST #endif // ENABLE_MESSAGE_DIGEST

32
test/MetalinkParserControllerTest.cc
View File

@ -205,9 +205,9 @@ void MetalinkParserControllerTest::testChecksumTransaction()
{ {
SharedHandle<Metalinker> m = ctrl.getResult(); SharedHandle<Metalinker> m = ctrl.getResult();
SharedHandle<Checksum> md = m->getEntries().front()->checksum; SharedHandle<Checksum> md = m->getEntries().front()->checksum;
CPPUNIT_ASSERT_EQUAL(std::string("md5"), md->getAlgo()); CPPUNIT_ASSERT_EQUAL(std::string("md5"), md->getHashType());
CPPUNIT_ASSERT_EQUAL(std::string("acbd18db4cc2f85cedef654fccc4a4d8"), CPPUNIT_ASSERT_EQUAL(std::string("acbd18db4cc2f85cedef654fccc4a4d8"),
md->getMessageDigest()); md->getDigest());
} }
ctrl.newEntryTransaction(); ctrl.newEntryTransaction();
ctrl.newChecksumTransaction(); ctrl.newChecksumTransaction();
@ -239,19 +239,19 @@ void MetalinkParserControllerTest::testChunkChecksumTransaction()
{ {
SharedHandle<Metalinker> m = ctrl.getResult(); SharedHandle<Metalinker> m = ctrl.getResult();
SharedHandle<ChunkChecksum> md = m->getEntries().front()->chunkChecksum; SharedHandle<ChunkChecksum> md = m->getEntries().front()->chunkChecksum;
CPPUNIT_ASSERT_EQUAL(std::string("md5"), md->getAlgo()); CPPUNIT_ASSERT_EQUAL(std::string("md5"), md->getHashType());
CPPUNIT_ASSERT_EQUAL((size_t)256*1024, md->getChecksumLength()); CPPUNIT_ASSERT_EQUAL((size_t)256*1024, md->getPieceLength());
CPPUNIT_ASSERT_EQUAL((size_t)5, md->countChecksum()); CPPUNIT_ASSERT_EQUAL((size_t)5, md->countPieceHash());
CPPUNIT_ASSERT_EQUAL(std::string("1cbd18db4cc2f85cedef654fccc4a4d8"), CPPUNIT_ASSERT_EQUAL(std::string("1cbd18db4cc2f85cedef654fccc4a4d8"),
md->getChecksums()[0]); md->getPieceHashes()[0]);
CPPUNIT_ASSERT_EQUAL(std::string("2cbd18db4cc2f85cedef654fccc4a4d8"), CPPUNIT_ASSERT_EQUAL(std::string("2cbd18db4cc2f85cedef654fccc4a4d8"),
md->getChecksums()[1]); md->getPieceHashes()[1]);
CPPUNIT_ASSERT_EQUAL(std::string("3cbd18db4cc2f85cedef654fccc4a4d8"), CPPUNIT_ASSERT_EQUAL(std::string("3cbd18db4cc2f85cedef654fccc4a4d8"),
md->getChecksums()[2]); md->getPieceHashes()[2]);
CPPUNIT_ASSERT_EQUAL(std::string("4cbd18db4cc2f85cedef654fccc4a4d8"), CPPUNIT_ASSERT_EQUAL(std::string("4cbd18db4cc2f85cedef654fccc4a4d8"),
md->getChecksums()[3]); md->getPieceHashes()[3]);
CPPUNIT_ASSERT_EQUAL(std::string("5cbd18db4cc2f85cedef654fccc4a4d8"), CPPUNIT_ASSERT_EQUAL(std::string("5cbd18db4cc2f85cedef654fccc4a4d8"),
md->getChecksums()[4]); md->getPieceHashes()[4]);
} }
ctrl.newEntryTransaction(); ctrl.newEntryTransaction();
ctrl.newChunkChecksumTransaction(); ctrl.newChunkChecksumTransaction();
@ -283,18 +283,18 @@ void MetalinkParserControllerTest::testChunkChecksumTransactionV4()
{ {
SharedHandle<Metalinker> m = ctrl.getResult(); SharedHandle<Metalinker> m = ctrl.getResult();
SharedHandle<ChunkChecksum> md = m->getEntries().front()->chunkChecksum; SharedHandle<ChunkChecksum> md = m->getEntries().front()->chunkChecksum;
CPPUNIT_ASSERT_EQUAL(std::string("sha-1"), md->getAlgo()); CPPUNIT_ASSERT_EQUAL(std::string("sha-1"), md->getHashType());
CPPUNIT_ASSERT_EQUAL((size_t)256*1024, md->getChecksumLength()); CPPUNIT_ASSERT_EQUAL((size_t)256*1024, md->getPieceLength());
CPPUNIT_ASSERT_EQUAL((size_t)3, md->countChecksum()); CPPUNIT_ASSERT_EQUAL((size_t)3, md->countPieceHash());
CPPUNIT_ASSERT_EQUAL CPPUNIT_ASSERT_EQUAL
(std::string("5bd9f7248df0f3a6a86ab6c95f48787d546efa14"), (std::string("5bd9f7248df0f3a6a86ab6c95f48787d546efa14"),
md->getChecksums()[0]); md->getPieceHashes()[0]);
CPPUNIT_ASSERT_EQUAL CPPUNIT_ASSERT_EQUAL
(std::string("9413ee70957a09d55704123687478e07f18c7b29"), (std::string("9413ee70957a09d55704123687478e07f18c7b29"),
md->getChecksums()[1]); md->getPieceHashes()[1]);
CPPUNIT_ASSERT_EQUAL CPPUNIT_ASSERT_EQUAL
(std::string("44213f9f4d59b557314fadcd233232eebcac8012"), (std::string("44213f9f4d59b557314fadcd233232eebcac8012"),
md->getChecksums()[2]); md->getPieceHashes()[2]);
} }
ctrl.newEntryTransaction(); ctrl.newEntryTransaction();
ctrl.newChunkChecksumTransactionV4(); ctrl.newChunkChecksumTransactionV4();

66
test/MetalinkProcessorTest.cc
View File

@ -93,33 +93,33 @@ void MetalinkProcessorTest::testParseFileV4()
CPPUNIT_ASSERT_EQUAL(-1, e->maxConnections); CPPUNIT_ASSERT_EQUAL(-1, e->maxConnections);
#ifdef ENABLE_MESSAGE_DIGEST #ifdef ENABLE_MESSAGE_DIGEST
CPPUNIT_ASSERT_EQUAL(std::string("0beec7b5ea3f0fdbc95d0dd47f3c5bc275da8a33"), CPPUNIT_ASSERT_EQUAL(std::string("0beec7b5ea3f0fdbc95d0dd47f3c5bc275da8a33"),
e->checksum->getMessageDigest()); e->checksum->getDigest());
CPPUNIT_ASSERT(e->checksum); CPPUNIT_ASSERT(e->checksum);
CPPUNIT_ASSERT_EQUAL(std::string("sha-1"), e->checksum->getAlgo()); CPPUNIT_ASSERT_EQUAL(std::string("sha-1"), e->checksum->getHashType());
CPPUNIT_ASSERT(e->chunkChecksum); CPPUNIT_ASSERT(e->chunkChecksum);
if(MessageDigest::supports("sha-256")) { if(MessageDigest::supports("sha-256")) {
CPPUNIT_ASSERT_EQUAL(std::string("sha-256"), e->chunkChecksum->getAlgo()); CPPUNIT_ASSERT_EQUAL(std::string("sha-256"), e->chunkChecksum->getHashType());
CPPUNIT_ASSERT_EQUAL((size_t)262144, e->chunkChecksum->getChecksumLength()); CPPUNIT_ASSERT_EQUAL((size_t)262144, e->chunkChecksum->getPieceLength());
CPPUNIT_ASSERT_EQUAL((size_t)3, e->chunkChecksum->countChecksum()); CPPUNIT_ASSERT_EQUAL((size_t)3, e->chunkChecksum->countPieceHash());
CPPUNIT_ASSERT_EQUAL(std::string("0245178074fd042e19b7c3885b360fc21064b30e73f5626c7e3b005d048069c5"), CPPUNIT_ASSERT_EQUAL(std::string("0245178074fd042e19b7c3885b360fc21064b30e73f5626c7e3b005d048069c5"),
e->chunkChecksum->getChecksum(0)); e->chunkChecksum->getPieceHash(0));
CPPUNIT_ASSERT_EQUAL(std::string("487ba2299be7f759d7c7bf6a4ac3a32cee81f1bb9332fc485947e32918864fb2"), CPPUNIT_ASSERT_EQUAL(std::string("487ba2299be7f759d7c7bf6a4ac3a32cee81f1bb9332fc485947e32918864fb2"),
e->chunkChecksum->getChecksum(1)); e->chunkChecksum->getPieceHash(1));
CPPUNIT_ASSERT_EQUAL(std::string("37290d74ac4d186e3a8e5785d259d2ec04fac91ae28092e7620ec8bc99e830aa"), CPPUNIT_ASSERT_EQUAL(std::string("37290d74ac4d186e3a8e5785d259d2ec04fac91ae28092e7620ec8bc99e830aa"),
e->chunkChecksum->getChecksum(2)); e->chunkChecksum->getPieceHash(2));
} else { } else {
CPPUNIT_ASSERT_EQUAL(std::string("sha-1"), e->chunkChecksum->getAlgo()); CPPUNIT_ASSERT_EQUAL(std::string("sha-1"), e->chunkChecksum->getHashType());
CPPUNIT_ASSERT_EQUAL((size_t)262144, e->chunkChecksum->getChecksumLength()); CPPUNIT_ASSERT_EQUAL((size_t)262144, e->chunkChecksum->getPieceLength());
CPPUNIT_ASSERT_EQUAL((size_t)3, e->chunkChecksum->countChecksum()); CPPUNIT_ASSERT_EQUAL((size_t)3, e->chunkChecksum->countPieceHash());
CPPUNIT_ASSERT_EQUAL CPPUNIT_ASSERT_EQUAL
(std::string("5bd9f7248df0f3a6a86ab6c95f48787d546efa14"), (std::string("5bd9f7248df0f3a6a86ab6c95f48787d546efa14"),
e->chunkChecksum->getChecksum(0)); e->chunkChecksum->getPieceHash(0));
CPPUNIT_ASSERT_EQUAL CPPUNIT_ASSERT_EQUAL
(std::string("9413ee70957a09d55704123687478e07f18c7b29"), (std::string("9413ee70957a09d55704123687478e07f18c7b29"),
e->chunkChecksum->getChecksum(1)); e->chunkChecksum->getPieceHash(1));
CPPUNIT_ASSERT_EQUAL CPPUNIT_ASSERT_EQUAL
(std::string("44213f9f4d59b557314fadcd233232eebcac8012"), (std::string("44213f9f4d59b557314fadcd233232eebcac8012"),
e->chunkChecksum->getChecksum(2)); e->chunkChecksum->getPieceHash(2));
} }
#endif // ENABLE_MESSAGE_DIGEST #endif // ENABLE_MESSAGE_DIGEST
CPPUNIT_ASSERT(e->getSignature()); CPPUNIT_ASSERT(e->getSignature());
@ -508,8 +508,8 @@ void MetalinkProcessorTest::testParseFile()
CPPUNIT_ASSERT_EQUAL(1, entry1->maxConnections); CPPUNIT_ASSERT_EQUAL(1, entry1->maxConnections);
#ifdef ENABLE_MESSAGE_DIGEST #ifdef ENABLE_MESSAGE_DIGEST
CPPUNIT_ASSERT_EQUAL(std::string("a96cf3f0266b91d87d5124cf94326422800b627d"), CPPUNIT_ASSERT_EQUAL(std::string("a96cf3f0266b91d87d5124cf94326422800b627d"),
entry1->checksum->getMessageDigest()); entry1->checksum->getDigest());
CPPUNIT_ASSERT_EQUAL(std::string("sha-1"), entry1->checksum->getAlgo()); CPPUNIT_ASSERT_EQUAL(std::string("sha-1"), entry1->checksum->getHashType());
#endif // ENABLE_MESSAGE_DIGEST #endif // ENABLE_MESSAGE_DIGEST
CPPUNIT_ASSERT(entry1->getSignature()); CPPUNIT_ASSERT(entry1->getSignature());
CPPUNIT_ASSERT_EQUAL(std::string("pgp"), entry1->getSignature()->getType()); CPPUNIT_ASSERT_EQUAL(std::string("pgp"), entry1->getSignature()->getType());
@ -557,14 +557,14 @@ void MetalinkProcessorTest::testParseFile()
CPPUNIT_ASSERT_EQUAL(-1, entry2->maxConnections); CPPUNIT_ASSERT_EQUAL(-1, entry2->maxConnections);
#ifdef ENABLE_MESSAGE_DIGEST #ifdef ENABLE_MESSAGE_DIGEST
CPPUNIT_ASSERT_EQUAL(std::string("4c255b0ed130f5ea880f0aa061c3da0487e251cc"), CPPUNIT_ASSERT_EQUAL(std::string("4c255b0ed130f5ea880f0aa061c3da0487e251cc"),
entry2->checksum->getMessageDigest()); entry2->checksum->getDigest());
CPPUNIT_ASSERT_EQUAL((size_t)2, entry2->chunkChecksum->countChecksum()); CPPUNIT_ASSERT_EQUAL((size_t)2, entry2->chunkChecksum->countPieceHash());
CPPUNIT_ASSERT_EQUAL((size_t)262144, entry2->chunkChecksum->getChecksumLength()); CPPUNIT_ASSERT_EQUAL((size_t)262144, entry2->chunkChecksum->getPieceLength());
CPPUNIT_ASSERT_EQUAL(std::string("179463a88d79cbf0b1923991708aead914f26142"), CPPUNIT_ASSERT_EQUAL(std::string("179463a88d79cbf0b1923991708aead914f26142"),
entry2->chunkChecksum->getChecksum(0)); entry2->chunkChecksum->getPieceHash(0));
CPPUNIT_ASSERT_EQUAL(std::string("fecf8bc9a1647505fe16746f94e97a477597dbf3"), CPPUNIT_ASSERT_EQUAL(std::string("fecf8bc9a1647505fe16746f94e97a477597dbf3"),
entry2->chunkChecksum->getChecksum(1)); entry2->chunkChecksum->getPieceHash(1));
CPPUNIT_ASSERT_EQUAL(std::string("sha-1"), entry2->checksum->getAlgo()); CPPUNIT_ASSERT_EQUAL(std::string("sha-1"), entry2->checksum->getHashType());
#endif // ENABLE_MESSAGE_DIGEST #endif // ENABLE_MESSAGE_DIGEST
// See that signature is null // See that signature is null
CPPUNIT_ASSERT(!entry2->getSignature()); CPPUNIT_ASSERT(!entry2->getSignature());
@ -585,10 +585,10 @@ void MetalinkProcessorTest::testParseFile()
SharedHandle<MetalinkEntry> entry4 = *entryItr; SharedHandle<MetalinkEntry> entry4 = *entryItr;
CPPUNIT_ASSERT_EQUAL(std::string("UnsupportedVerificationHashTypeIncluded"), entry4->getPath()); CPPUNIT_ASSERT_EQUAL(std::string("UnsupportedVerificationHashTypeIncluded"), entry4->getPath());
#ifdef ENABLE_MESSAGE_DIGEST #ifdef ENABLE_MESSAGE_DIGEST
CPPUNIT_ASSERT_EQUAL(std::string("sha-1"), entry4->checksum->getAlgo()); CPPUNIT_ASSERT_EQUAL(std::string("sha-1"), entry4->checksum->getHashType());
CPPUNIT_ASSERT_EQUAL(std::string("4c255b0ed130f5ea880f0aa061c3da0487e251cc"), CPPUNIT_ASSERT_EQUAL(std::string("4c255b0ed130f5ea880f0aa061c3da0487e251cc"),
entry4->checksum->getMessageDigest()); entry4->checksum->getDigest());
CPPUNIT_ASSERT_EQUAL(std::string("sha-1"),entry4->chunkChecksum->getAlgo()); CPPUNIT_ASSERT_EQUAL(std::string("sha-1"),entry4->chunkChecksum->getHashType());
#endif // ENABLE_MESSAGE_DIGEST #endif // ENABLE_MESSAGE_DIGEST
@ -898,8 +898,8 @@ void MetalinkProcessorTest::testMultiplePieces()
SharedHandle<MetalinkEntry> e = m->getEntries()[0]; SharedHandle<MetalinkEntry> e = m->getEntries()[0];
SharedHandle<ChunkChecksum> c = e->chunkChecksum; SharedHandle<ChunkChecksum> c = e->chunkChecksum;
CPPUNIT_ASSERT_EQUAL(std::string("sha-1"), c->getAlgo()); CPPUNIT_ASSERT_EQUAL(std::string("sha-1"), c->getHashType());
CPPUNIT_ASSERT_EQUAL((size_t)1024, c->getChecksumLength()); CPPUNIT_ASSERT_EQUAL((size_t)1024, c->getPieceLength());
} catch(Exception& e) { } catch(Exception& e) {
CPPUNIT_FAIL(e.stackTrace()); CPPUNIT_FAIL(e.stackTrace());
} }
@ -932,8 +932,8 @@ void MetalinkProcessorTest::testBadPieceNo()
SharedHandle<ChunkChecksum> c = e->chunkChecksum; SharedHandle<ChunkChecksum> c = e->chunkChecksum;
CPPUNIT_ASSERT(c); CPPUNIT_ASSERT(c);
CPPUNIT_ASSERT_EQUAL((size_t)1024, c->getChecksumLength()); CPPUNIT_ASSERT_EQUAL((size_t)1024, c->getPieceLength());
CPPUNIT_ASSERT_EQUAL(std::string("sha-1"), c->getAlgo()); CPPUNIT_ASSERT_EQUAL(std::string("sha-1"), c->getHashType());
} catch(Exception& e) { } catch(Exception& e) {
CPPUNIT_FAIL(e.stackTrace()); CPPUNIT_FAIL(e.stackTrace());
} }
@ -965,8 +965,8 @@ void MetalinkProcessorTest::testBadPieceLength()
SharedHandle<MetalinkEntry> e = m->getEntries()[0]; SharedHandle<MetalinkEntry> e = m->getEntries()[0];
SharedHandle<ChunkChecksum> c = e->chunkChecksum; SharedHandle<ChunkChecksum> c = e->chunkChecksum;
CPPUNIT_ASSERT(c); CPPUNIT_ASSERT(c);
CPPUNIT_ASSERT_EQUAL((size_t)1024, c->getChecksumLength()); CPPUNIT_ASSERT_EQUAL((size_t)1024, c->getPieceLength());
CPPUNIT_ASSERT_EQUAL(std::string("sha-1"), c->getAlgo()); CPPUNIT_ASSERT_EQUAL(std::string("sha-1"), c->getHashType());
} catch(Exception& e) { } catch(Exception& e) {
CPPUNIT_FAIL(e.stackTrace()); CPPUNIT_FAIL(e.stackTrace());
} }
@ -998,8 +998,8 @@ void MetalinkProcessorTest::testUnsupportedType_piece()
SharedHandle<ChunkChecksum> c = e->chunkChecksum; SharedHandle<ChunkChecksum> c = e->chunkChecksum;
CPPUNIT_ASSERT(c); CPPUNIT_ASSERT(c);
CPPUNIT_ASSERT_EQUAL((size_t)1024, c->getChecksumLength()); CPPUNIT_ASSERT_EQUAL((size_t)1024, c->getPieceLength());
CPPUNIT_ASSERT_EQUAL(std::string("sha-1"), c->getAlgo()); CPPUNIT_ASSERT_EQUAL(std::string("sha-1"), c->getHashType());
} catch(Exception& e) { } catch(Exception& e) {
CPPUNIT_FAIL(e.stackTrace()); CPPUNIT_FAIL(e.stackTrace());
} }