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

Stored hash value as raw byte string, instead of hex digest.

pull/2/head
Tatsuhiro Tsujikawa 2011-10-13 21:40:07 +09:00
parent c2eb9d791a
commit 310e58bc62
33 changed files with 107 additions and 98 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
src/BtPieceMessage.cc
View File

@ -223,11 +223,10 @@ bool BtPieceMessage::checkPieceHash(const SharedHandle<Piece>& piece)
A2_LOG_DEBUG(fmt("Hash is available!! index=%lu",
static_cast<unsigned long>(piece->getIndex())));
return
piece->getHashString()==downloadContext_->getPieceHash(piece->getIndex());
piece->getDigest() == downloadContext_->getPieceHash(piece->getIndex());
} else {
off_t offset = (off_t)piece->getIndex()*downloadContext_->getPieceLength();
return message_digest::staticSHA1DigestHexDigest
return message_digest::staticSHA1Digest
(getPieceStorage()->getDiskAdaptor(), offset, piece->getLength())
== downloadContext_->getPieceHash(piece->getIndex());
}

2
src/Checksum.h
View File

@ -46,7 +46,7 @@ private:
std::string hashType_;
std::string digest_;
public:
// messageDigest_ is ascii hexadecimal notation.
// digest_ is raw byte array of hash value, not ascii hexadecimal notation.
Checksum(const std::string& hashType, const std::string& digest);
Checksum();
~Checksum();

16
src/DownloadCommand.cc
View File

@ -231,12 +231,12 @@ bool DownloadCommand::executeInternal() {
A2_LOG_DEBUG(fmt("Hash is available! index=%lu",
static_cast<unsigned long>(segment->getIndex())));
validatePieceHash
(segment, expectedPieceHash, segment->getHashString());
(segment, expectedPieceHash, segment->getDigest());
} else {
messageDigest_->reset();
validatePieceHash
(segment, expectedPieceHash,
message_digest::hexDigest
message_digest::digest
(messageDigest_,
getPieceStorage()->getDiskAdaptor(),
segment->getPosition(),
@ -350,18 +350,18 @@ bool DownloadCommand::prepareForNextSegment() {
#ifdef ENABLE_MESSAGE_DIGEST
void DownloadCommand::validatePieceHash(const SharedHandle<Segment>& segment,
const std::string& expectedPieceHash,
const std::string& actualPieceHash)
const std::string& expectedHash,
const std::string& actualHash)
{
if(actualPieceHash == expectedPieceHash) {
A2_LOG_INFO(fmt(MSG_GOOD_CHUNK_CHECKSUM, actualPieceHash.c_str()));
if(actualHash == expectedHash) {
A2_LOG_INFO(fmt(MSG_GOOD_CHUNK_CHECKSUM, util::toHex(actualHash).c_str()));
getSegmentMan()->completeSegment(getCuid(), segment);
} else {
A2_LOG_INFO(fmt(EX_INVALID_CHUNK_CHECKSUM,
static_cast<unsigned long>(segment->getIndex()),
util::itos(segment->getPosition(), true).c_str(),
expectedPieceHash.c_str(),
actualPieceHash.c_str()));
util::toHex(expectedHash).c_str(),
util::toHex(actualHash).c_str()));
segment->clear();
getSegmentMan()->cancelSegment(getCuid());
throw DL_RETRY_EX

2
src/GrowSegment.cc
View File

@ -52,7 +52,7 @@ void GrowSegment::updateWrittenLength(size_t bytes)
#ifdef ENABLE_MESSAGE_DIGEST
std::string GrowSegment::getHashString()
std::string GrowSegment::getDigest()
{
return A2STR::NIL;
}

2
src/GrowSegment.h
View File

@ -98,7 +98,7 @@ public:
return false;
}
virtual std::string getHashString();
virtual std::string getDigest();
#endif // ENABLE_MESSAGE_DIGEST

7
src/HttpResponse.cc
View File

@ -408,11 +408,12 @@ void HttpResponse::getDigest(std::vector<Checksum>& result) const
break;
}
util::lowercase(hashType);
std::string hexDigest = util::toHex(Base64::decode(digest));
if(!MessageDigest::isValidHash(hashType, hexDigest)) {
digest = Base64::decode(digest);
if(!MessageDigest::supports(hashType) ||
MessageDigest::getDigestLength(hashType) != digest.size()) {
continue;
}
result.push_back(Checksum(hashType, hexDigest));
result.push_back(Checksum(hashType, digest));
}
}
std::sort(result.begin(), result.end(), HashTypeStronger());

5
src/IteratableChecksumValidator.cc
View File

@ -75,12 +75,13 @@ void IteratableChecksumValidator::validateChunk()
ctx_->update(buffer_, length);
currentOffset_ += length;
if(finished()) {
std::string actualDigest = ctx_->hexDigest();
std::string actualDigest = ctx_->digest();
if(dctx_->getDigest() == actualDigest) {
pieceStorage_->markAllPiecesDone();
} else {
A2_LOG_INFO(fmt("Checksum validation failed. expected=%s, actual=%s",
dctx_->getDigest().c_str(), actualDigest.c_str()));
util::toHex(dctx_->getDigest()).c_str(),
util::toHex(actualDigest).c_str()));
BitfieldMan bitfield(dctx_->getPieceLength(), dctx_->getTotalLength());
pieceStorage_->setBitfield(bitfield.getBitfield(), bitfield.getBitfieldLength());
}

13
src/IteratableChunkChecksumValidator.cc
View File

@ -82,11 +82,12 @@ void IteratableChunkChecksumValidator::validateChunk()
if(actualChecksum == dctx_->getPieceHashes()[currentIndex_]) {
bitfield_->setBit(currentIndex_);
} else {
A2_LOG_INFO(fmt(EX_INVALID_CHUNK_CHECKSUM,
static_cast<unsigned long>(currentIndex_),
util::itos(getCurrentOffset(), true).c_str(),
dctx_->getPieceHashes()[currentIndex_].c_str(),
actualChecksum.c_str()));
A2_LOG_INFO
(fmt(EX_INVALID_CHUNK_CHECKSUM,
static_cast<unsigned long>(currentIndex_),
util::itos(getCurrentOffset(), true).c_str(),
util::toHex(dctx_->getPieceHashes()[currentIndex_]).c_str(),
util::toHex(actualChecksum).c_str()));
bitfield_->unsetBit(currentIndex_);
}
} catch(RecoverableException& ex) {
@ -156,7 +157,7 @@ std::string IteratableChunkChecksumValidator::digest(off_t offset, size_t length
curoffset += r;
woffset = 0;
}
return ctx_->hexDigest();
return ctx_->digest();
}

4
src/MessageDigest.cc
View File

@ -172,12 +172,12 @@ void MessageDigest::digest(unsigned char* md)
pImpl_->digest(md);
}
std::string MessageDigest::hexDigest()
std::string MessageDigest::digest()
{
size_t length = pImpl_->getDigestLength();
array_ptr<unsigned char> buf(new unsigned char[length]);
pImpl_->digest(buf);
std::string hd = util::toHex(buf, length);
std::string hd(&buf[0], &buf[length]);
return hd;
}

6
src/MessageDigest.h
View File

@ -101,9 +101,9 @@ public:
// reset().
void digest(unsigned char* md);
// Returns hex digest. This call can only be called once. To reuse
// this object, call reset().
std::string hexDigest();
// Returns raw digest, not hex digest. This call can only be called
// once. To reuse this object, call reset().
std::string digest();
};
} // namespace aria2

6
src/MetalinkParserController.cc
View File

@ -284,7 +284,7 @@ void MetalinkParserController::setHashOfChecksum(const std::string& md)
return;
}
if(MessageDigest::isValidHash(tChecksum_->getHashType(), md)) {
tChecksum_->setDigest(md);
tChecksum_->setDigest(util::fromHex(md));
} else {
cancelChecksumTransaction();
}
@ -360,7 +360,7 @@ void MetalinkParserController::addHashOfChunkChecksumV4(const std::string& md)
return;
}
if(MessageDigest::isValidHash(tChunkChecksumV4_->getHashType(), md)) {
tempChunkChecksumsV4_.push_back(md);
tempChunkChecksumsV4_.push_back(util::fromHex(md));
} else {
cancelChunkChecksumTransactionV4();
}
@ -463,7 +463,7 @@ void MetalinkParserController::setMessageDigestOfChunkChecksum(const std::string
return;
}
if(MessageDigest::isValidHash(tChunkChecksum_->getHashType(), md)) {
tempHashPair_.second = md;
tempHashPair_.second = util::fromHex(md);
} else {
cancelChunkChecksumTransaction();
}

4
src/Piece.cc
View File

@ -218,12 +218,12 @@ bool Piece::isHashCalculated() const
return mdctx_ && nextBegin_ == length_;
}
std::string Piece::getHashString()
std::string Piece::getDigest()
{
if(!mdctx_) {
return A2STR::NIL;
} else {
std::string hash = mdctx_->hexDigest();
std::string hash = mdctx_->digest();
destroyHashContext();
return hash;
}

4
src/Piece.h
View File

@ -164,11 +164,11 @@ public:
bool isHashCalculated() const;
// Returns hash value in ASCII hexadecimal form, which is calculated
// Returns raw hash value, not hex digest, which is calculated
// by updateHash(). Please note that this function returns hash
// value only once. Second invocation without updateHash() returns
// empty string.
std::string getHashString();
std::string getDigest();
void destroyHashContext();

4
src/PiecedSegment.cc
View File

@ -102,9 +102,9 @@ bool PiecedSegment::isHashCalculated() const
return piece_->isHashCalculated();
}
std::string PiecedSegment::getHashString()
std::string PiecedSegment::getDigest()
{
return piece_->getHashString();
return piece_->getDigest();
}
#endif // ENABLE_MESSAGE_DIGEST

2
src/PiecedSegment.h
View File

@ -84,7 +84,7 @@ public:
virtual bool isHashCalculated() const;
virtual std::string getHashString();
virtual std::string getDigest();
#endif // ENABLE_MESSAGE_DIGEST

2
src/Segment.h
View File

@ -74,7 +74,7 @@ public:
virtual bool isHashCalculated() const = 0;
virtual std::string getHashString() = 0;
virtual std::string getDigest() = 0;
#endif // ENABLE_MESSAGE_DIGEST

4
src/bittorrent_helper.cc
View File

@ -119,8 +119,8 @@ void extractPieceHash(const SharedHandle<DownloadContext>& ctx,
std::vector<std::string> pieceHashes;
pieceHashes.reserve(numPieces);
for(size_t i = 0; i < numPieces; ++i) {
pieceHashes.push_back(util::toHex(hashData.data()+i*hashLength,
hashLength));
const char* p = hashData.data()+i*hashLength;
pieceHashes.push_back(std::string(p, p+hashLength));
}
ctx->setPieceHashes("sha-1", pieceHashes.begin(), pieceHashes.end());
}

2
src/download_helper.cc
View File

@ -238,7 +238,7 @@ SharedHandle<RequestGroup> createRequestGroup
util::divide(p, checksum, '=');
util::lowercase(p.first);
util::lowercase(p.second);
dctx->setDigest(p.first, p.second);
dctx->setDigest(p.first, util::fromHex(p.second));
}
#endif // ENABLE_MESSAGE_DIGEST
rg->setDownloadContext(dctx);

8
src/message_digest_helper.cc
View File

@ -65,14 +65,14 @@ void staticSHA1DigestFree()
sha1Ctx_.reset();
}
std::string staticSHA1DigestHexDigest
std::string staticSHA1Digest
(const BinaryStreamHandle& bs, off_t offset, uint64_t length)
{
sha1Ctx_->reset();
return hexDigest(sha1Ctx_, bs, offset, length);
return digest(sha1Ctx_, bs, offset, length);
}
std::string hexDigest
std::string digest
(const SharedHandle<MessageDigest>& ctx,
const SharedHandle<BinaryStream>& bs,
off_t offset, uint64_t length)
@ -97,7 +97,7 @@ std::string hexDigest
}
ctx->update(BUF, readLength);
}
return ctx->hexDigest();
return ctx->digest();
}
void digest

6
src/message_digest_helper.h
View File

@ -62,14 +62,14 @@ void staticSHA1DigestInit();
*/
void staticSHA1DigestFree();
std::string staticSHA1DigestHexDigest
std::string staticSHA1Digest
(const SharedHandle<BinaryStream>& bs, off_t offset, uint64_t length);
/**
* ctx must be initialized or reseted before calling this function.
* Returns hex digest string, not *raw* digest
* Returns raw digest string, not hex digest
*/
std::string hexDigest
std::string digest
(const SharedHandle<MessageDigest>& ctx,
const SharedHandle<BinaryStream>& bs,
off_t offset, uint64_t length);

6
test/BittorrentHelperTest.cc
View File

@ -148,11 +148,11 @@ void BittorrentHelperTest::testGetPieceHash() {
SharedHandle<DownloadContext> dctx(new DownloadContext());
load(A2_TEST_DIR"/test.torrent", dctx, option_);
CPPUNIT_ASSERT_EQUAL(util::toHex("AAAAAAAAAAAAAAAAAAAA", 20),
CPPUNIT_ASSERT_EQUAL(std::string("AAAAAAAAAAAAAAAAAAAA"),
dctx->getPieceHash(0));
CPPUNIT_ASSERT_EQUAL(util::toHex("BBBBBBBBBBBBBBBBBBBB", 20),
CPPUNIT_ASSERT_EQUAL(std::string("BBBBBBBBBBBBBBBBBBBB"),
dctx->getPieceHash(1));
CPPUNIT_ASSERT_EQUAL(util::toHex("CCCCCCCCCCCCCCCCCCCC", 20),
CPPUNIT_ASSERT_EQUAL(std::string("CCCCCCCCCCCCCCCCCCCC"),
dctx->getPieceHash(2));
CPPUNIT_ASSERT_EQUAL(std::string(""),
dctx->getPieceHash(3));

2
test/GZipDecodingStreamFilterTest.cc
View File

@ -76,7 +76,7 @@ void GZipDecodingStreamFilterTest::testTransform()
SharedHandle<MessageDigest> sha1(MessageDigest::sha1());
sha1->update(data.data(), data.size());
CPPUNIT_ASSERT_EQUAL(std::string("8b577b33c0411b2be9d4fa74c7402d54a8d21f96"),
sha1->hexDigest());
util::toHex(sha1->digest()));
#endif // ENABLE_MESSAGE_DIGEST
}

4
test/HttpResponseTest.cc
View File

@ -681,12 +681,12 @@ void HttpResponseTest::testGetDigest()
Checksum c = result[0];
CPPUNIT_ASSERT_EQUAL(std::string("sha-256"), c.getHashType());
CPPUNIT_ASSERT_EQUAL(std::string("f83f271ae773dc6fe4a6454a41e0eb237c43e7bbf451e426cc60993a4d379ec5"),
c.getDigest());
util::toHex(c.getDigest()));
c = result[1];
CPPUNIT_ASSERT_EQUAL(std::string("sha-1"), c.getHashType());
CPPUNIT_ASSERT_EQUAL(std::string("f36003f22b462ffa184390533c500d8989e9f681"),
c.getDigest());
util::toHex(c.getDigest()));
}
#endif // ENABLE_MESSAGE_DIGEST

6
test/IteratableChecksumValidatorTest.cc
View File

@ -34,7 +34,8 @@ void IteratableChecksumValidatorTest::testValidate() {
Option option;
SharedHandle<DownloadContext> dctx
(new DownloadContext(100, 250, A2_TEST_DIR"/chunkChecksumTestFile250.txt"));
dctx->setDigest("sha-1", "898a81b8e0181280ae2ee1b81e269196d91e869a");
dctx->setDigest("sha-1",
util::fromHex("898a81b8e0181280ae2ee1b81e269196d91e869a"));
SharedHandle<DefaultPieceStorage> ps(new DefaultPieceStorage(dctx, &option));
ps->initStorage();
ps->getDiskAdaptor()->enableReadOnly();
@ -53,7 +54,8 @@ void IteratableChecksumValidatorTest::testValidate_fail() {
Option option;
SharedHandle<DownloadContext> dctx
(new DownloadContext(100, 250, A2_TEST_DIR"/chunkChecksumTestFile250.txt"));
dctx->setDigest("sha-1", std::string(40, '0')); // set wrong checksum
dctx->setDigest("sha-1",
util::fromHex(std::string(40, '0'))); // set wrong checksum
SharedHandle<DefaultPieceStorage> ps(new DefaultPieceStorage(dctx, &option));
ps->initStorage();
ps->getDiskAdaptor()->enableReadOnly();

15
test/IteratableChunkChecksumValidatorTest.cc
View File

@ -19,7 +19,7 @@ class IteratableChunkChecksumValidatorTest:public CppUnit::TestFixture {
CPPUNIT_TEST_SUITE_END();
private:
static const char* csArray[];
static const std::string csArray[];
public:
void setUp() {
}
@ -31,9 +31,10 @@ public:
CPPUNIT_TEST_SUITE_REGISTRATION( IteratableChunkChecksumValidatorTest );
const char* IteratableChunkChecksumValidatorTest::csArray[] = { "29b0e7878271645fffb7eec7db4a7473a1c00bc1",
"4df75a661cb7eb2733d9cdaa7f772eae3a4e2976",
"0a4ea2f7dd7c52ddf2099a444ab2184b4d341bdb" };
const std::string IteratableChunkChecksumValidatorTest::csArray[] =
{ util::fromHex("29b0e7878271645fffb7eec7db4a7473a1c00bc1"),
util::fromHex("4df75a661cb7eb2733d9cdaa7f772eae3a4e2976"),
util::fromHex("0a4ea2f7dd7c52ddf2099a444ab2184b4d341bdb") };
void IteratableChunkChecksumValidatorTest::testValidate() {
Option option;
@ -59,7 +60,7 @@ void IteratableChunkChecksumValidatorTest::testValidate() {
// make the test fail
std::deque<std::string> badHashes(&csArray[0], &csArray[3]);
badHashes[1] = "ffffffffffffffffffffffffffffffffffffffff";
badHashes[1] = util::fromHex("ffffffffffffffffffffffffffffffffffffffff");
dctx->setPieceHashes("sha-1", badHashes.begin(), badHashes.end());
validator.init();
@ -77,8 +78,8 @@ void IteratableChunkChecksumValidatorTest::testValidate_readError() {
SharedHandle<DownloadContext> dctx
(new DownloadContext(100, 500, A2_TEST_DIR"/chunkChecksumTestFile250.txt"));
std::deque<std::string> hashes(&csArray[0], &csArray[3]);
hashes.push_back("ffffffffffffffffffffffffffffffffffffffff");
hashes.push_back("ffffffffffffffffffffffffffffffffffffffff");
hashes.push_back(util::fromHex("ffffffffffffffffffffffffffffffffffffffff"));
hashes.push_back(util::fromHex("ffffffffffffffffffffffffffffffffffffffff"));
dctx->setPieceHashes("sha-1", hashes.begin(), hashes.end());
SharedHandle<DefaultPieceStorage> ps(new DefaultPieceStorage(dctx, &option));
ps->initStorage();

14
test/MessageDigestHelperTest.cc
View File

@ -11,7 +11,7 @@ namespace aria2 {
class MessageDigestHelperTest:public CppUnit::TestFixture {
CPPUNIT_TEST_SUITE(MessageDigestHelperTest);
CPPUNIT_TEST(testHexDigestDiskWriter);
CPPUNIT_TEST(testDigestDiskWriter);
CPPUNIT_TEST_SUITE_END();
private:
@ -19,24 +19,24 @@ public:
void setUp() {
}
void testHexDigestDiskWriter();
void testDigestDiskWriter();
};
CPPUNIT_TEST_SUITE_REGISTRATION( MessageDigestHelperTest );
void MessageDigestHelperTest::testHexDigestDiskWriter() {
void MessageDigestHelperTest::testDigestDiskWriter() {
SharedHandle<DefaultDiskWriter> diskio
(new DefaultDiskWriter(A2_TEST_DIR"/4096chunk.txt"));
diskio->enableReadOnly();
diskio->openExistingFile();
CPPUNIT_ASSERT_EQUAL(std::string("608cabc0f2fa18c260cafd974516865c772363d5"),
message_digest::hexDigest
(MessageDigest::sha1(), diskio, 0, 4096));
util::toHex(message_digest::digest
(MessageDigest::sha1(), diskio, 0, 4096)));
CPPUNIT_ASSERT_EQUAL(std::string("7a4a9ae537ebbbb826b1060e704490ad0f365ead"),
message_digest::hexDigest
(MessageDigest::sha1(), diskio, 5, 100));
util::toHex(message_digest::digest
(MessageDigest::sha1(), diskio, 5, 100)));
}
} // namespace aria2

8
test/MessageDigestTest.cc
View File

@ -9,7 +9,7 @@ namespace aria2 {
class MessageDigestTest:public CppUnit::TestFixture {
CPPUNIT_TEST_SUITE(MessageDigestTest);
CPPUNIT_TEST(testHexDigest);
CPPUNIT_TEST(testDigest);
CPPUNIT_TEST(testSupports);
CPPUNIT_TEST(testGetDigestLength);
CPPUNIT_TEST(testIsStronger);
@ -24,7 +24,7 @@ public:
sha1_ = MessageDigest::sha1();
}
void testHexDigest();
void testDigest();
void testSupports();
void testGetDigestLength();
void testIsStronger();
@ -35,11 +35,11 @@ public:
CPPUNIT_TEST_SUITE_REGISTRATION( MessageDigestTest );
void MessageDigestTest::testHexDigest()
void MessageDigestTest::testDigest()
{
sha1_->update("aria2", 5);
CPPUNIT_ASSERT_EQUAL(std::string("f36003f22b462ffa184390533c500d8989e9f681"),
sha1_->hexDigest());
util::toHex(sha1_->digest()));
}
void MessageDigestTest::testSupports()

4
test/Metalink2RequestGroupTest.cc
View File

@ -63,7 +63,7 @@ void Metalink2RequestGroupTest::testGenerate()
CPPUNIT_ASSERT_EQUAL(std::string("sha-1"), dctx->getHashType());
CPPUNIT_ASSERT_EQUAL
(std::string("a96cf3f0266b91d87d5124cf94326422800b627d"),
dctx->getDigest());
util::toHex(dctx->getDigest()));
#endif // ENABLE_MESSAGE_DIGEST
CPPUNIT_ASSERT(dctx->getSignature());
CPPUNIT_ASSERT_EQUAL(std::string("pgp"), dctx->getSignature()->getType());
@ -85,7 +85,7 @@ void Metalink2RequestGroupTest::testGenerate()
CPPUNIT_ASSERT_EQUAL(std::string("sha-1"), dctx->getHashType());
CPPUNIT_ASSERT_EQUAL
(std::string("4c255b0ed130f5ea880f0aa061c3da0487e251cc"),
dctx->getDigest());
util::toHex(dctx->getDigest()));
#endif // ENABLE_MESSAGE_DIGEST
CPPUNIT_ASSERT(!dctx->getSignature());
}

8
test/MetalinkParserControllerTest.cc
View File

@ -207,7 +207,7 @@ void MetalinkParserControllerTest::testChecksumTransaction()
SharedHandle<Checksum> md = m->getEntries().front()->checksum;
CPPUNIT_ASSERT_EQUAL(std::string("md5"), md->getHashType());
CPPUNIT_ASSERT_EQUAL(std::string("acbd18db4cc2f85cedef654fccc4a4d8"),
md->getDigest());
util::toHex(md->getDigest()));
}
ctrl.newEntryTransaction();
ctrl.newChecksumTransaction();
@ -288,13 +288,13 @@ void MetalinkParserControllerTest::testChunkChecksumTransactionV4()
CPPUNIT_ASSERT_EQUAL((size_t)3, md->countPieceHash());
CPPUNIT_ASSERT_EQUAL
(std::string("5bd9f7248df0f3a6a86ab6c95f48787d546efa14"),
md->getPieceHashes()[0]);
util::toHex(md->getPieceHashes()[0]));
CPPUNIT_ASSERT_EQUAL
(std::string("9413ee70957a09d55704123687478e07f18c7b29"),
md->getPieceHashes()[1]);
util::toHex(md->getPieceHashes()[1]));
CPPUNIT_ASSERT_EQUAL
(std::string("44213f9f4d59b557314fadcd233232eebcac8012"),
md->getPieceHashes()[2]);
util::toHex(md->getPieceHashes()[2]));
}
ctrl.newEntryTransaction();
ctrl.newChunkChecksumTransactionV4();

25
test/MetalinkProcessorTest.cc
View File

@ -20,6 +20,7 @@
#include "Signature.h"
#include "fmt.h"
#include "RecoverableException.h"
#include "util.h"
namespace aria2 {
@ -93,7 +94,7 @@ void MetalinkProcessorTest::testParseFileV4()
CPPUNIT_ASSERT_EQUAL(-1, e->maxConnections);
#ifdef ENABLE_MESSAGE_DIGEST
CPPUNIT_ASSERT_EQUAL(std::string("0beec7b5ea3f0fdbc95d0dd47f3c5bc275da8a33"),
e->checksum->getDigest());
util::toHex(e->checksum->getDigest()));
CPPUNIT_ASSERT(e->checksum);
CPPUNIT_ASSERT_EQUAL(std::string("sha-1"), e->checksum->getHashType());
CPPUNIT_ASSERT(e->chunkChecksum);
@ -102,24 +103,24 @@ void MetalinkProcessorTest::testParseFileV4()
CPPUNIT_ASSERT_EQUAL((size_t)262144, e->chunkChecksum->getPieceLength());
CPPUNIT_ASSERT_EQUAL((size_t)3, e->chunkChecksum->countPieceHash());
CPPUNIT_ASSERT_EQUAL(std::string("0245178074fd042e19b7c3885b360fc21064b30e73f5626c7e3b005d048069c5"),
e->chunkChecksum->getPieceHash(0));
util::toHex(e->chunkChecksum->getPieceHash(0)));
CPPUNIT_ASSERT_EQUAL(std::string("487ba2299be7f759d7c7bf6a4ac3a32cee81f1bb9332fc485947e32918864fb2"),
e->chunkChecksum->getPieceHash(1));
util::toHex(e->chunkChecksum->getPieceHash(1)));
CPPUNIT_ASSERT_EQUAL(std::string("37290d74ac4d186e3a8e5785d259d2ec04fac91ae28092e7620ec8bc99e830aa"),
e->chunkChecksum->getPieceHash(2));
util::toHex(e->chunkChecksum->getPieceHash(2)));
} else {
CPPUNIT_ASSERT_EQUAL(std::string("sha-1"), e->chunkChecksum->getHashType());
CPPUNIT_ASSERT_EQUAL((size_t)262144, e->chunkChecksum->getPieceLength());
CPPUNIT_ASSERT_EQUAL((size_t)3, e->chunkChecksum->countPieceHash());
CPPUNIT_ASSERT_EQUAL
(std::string("5bd9f7248df0f3a6a86ab6c95f48787d546efa14"),
e->chunkChecksum->getPieceHash(0));
util::toHex(e->chunkChecksum->getPieceHash(0)));
CPPUNIT_ASSERT_EQUAL
(std::string("9413ee70957a09d55704123687478e07f18c7b29"),
e->chunkChecksum->getPieceHash(1));
util::toHex(e->chunkChecksum->getPieceHash(1)));
CPPUNIT_ASSERT_EQUAL
(std::string("44213f9f4d59b557314fadcd233232eebcac8012"),
e->chunkChecksum->getPieceHash(2));
util::toHex(e->chunkChecksum->getPieceHash(2)));
}
#endif // ENABLE_MESSAGE_DIGEST
CPPUNIT_ASSERT(e->getSignature());
@ -508,7 +509,7 @@ void MetalinkProcessorTest::testParseFile()
CPPUNIT_ASSERT_EQUAL(1, entry1->maxConnections);
#ifdef ENABLE_MESSAGE_DIGEST
CPPUNIT_ASSERT_EQUAL(std::string("a96cf3f0266b91d87d5124cf94326422800b627d"),
entry1->checksum->getDigest());
util::toHex(entry1->checksum->getDigest()));
CPPUNIT_ASSERT_EQUAL(std::string("sha-1"), entry1->checksum->getHashType());
#endif // ENABLE_MESSAGE_DIGEST
CPPUNIT_ASSERT(entry1->getSignature());
@ -557,13 +558,13 @@ void MetalinkProcessorTest::testParseFile()
CPPUNIT_ASSERT_EQUAL(-1, entry2->maxConnections);
#ifdef ENABLE_MESSAGE_DIGEST
CPPUNIT_ASSERT_EQUAL(std::string("4c255b0ed130f5ea880f0aa061c3da0487e251cc"),
entry2->checksum->getDigest());
util::toHex(entry2->checksum->getDigest()));
CPPUNIT_ASSERT_EQUAL((size_t)2, entry2->chunkChecksum->countPieceHash());
CPPUNIT_ASSERT_EQUAL((size_t)262144, entry2->chunkChecksum->getPieceLength());
CPPUNIT_ASSERT_EQUAL(std::string("179463a88d79cbf0b1923991708aead914f26142"),
entry2->chunkChecksum->getPieceHash(0));
util::toHex(entry2->chunkChecksum->getPieceHash(0)));
CPPUNIT_ASSERT_EQUAL(std::string("fecf8bc9a1647505fe16746f94e97a477597dbf3"),
entry2->chunkChecksum->getPieceHash(1));
util::toHex(entry2->chunkChecksum->getPieceHash(1)));
CPPUNIT_ASSERT_EQUAL(std::string("sha-1"), entry2->checksum->getHashType());
#endif // ENABLE_MESSAGE_DIGEST
// See that signature is null
@ -587,7 +588,7 @@ void MetalinkProcessorTest::testParseFile()
#ifdef ENABLE_MESSAGE_DIGEST
CPPUNIT_ASSERT_EQUAL(std::string("sha-1"), entry4->checksum->getHashType());
CPPUNIT_ASSERT_EQUAL(std::string("4c255b0ed130f5ea880f0aa061c3da0487e251cc"),
entry4->checksum->getDigest());
util::toHex(entry4->checksum->getDigest()));
CPPUNIT_ASSERT_EQUAL(std::string("sha-1"),entry4->chunkChecksum->getHashType());
#endif // ENABLE_MESSAGE_DIGEST

2
test/MockSegment.h
View File

@ -60,7 +60,7 @@ public:
return false;
}
virtual std::string getHashString()
virtual std::string getDigest()
{
return A2STR::NIL;
}

4
test/PieceTest.cc
View File

@ -4,6 +4,8 @@
#include <cppunit/extensions/HelperMacros.h>
#include "util.h"
namespace aria2 {
class PieceTest:public CppUnit::TestFixture {
@ -81,7 +83,7 @@ void PieceTest::testUpdateHash()
CPPUNIT_ASSERT(p.isHashCalculated());
CPPUNIT_ASSERT_EQUAL(std::string("d9189aff79e075a2e60271b9556a710dc1bc7de7"),
p.getHashString());
util::toHex(p.getDigest()));
}
#endif // ENABLE_MESSAGE_DIGEST

3
test/TestUtil.cc
View File

@ -14,6 +14,7 @@
#include "Cookie.h"
#include "DefaultDiskWriter.h"
#include "fmt.h"
#include "util.h"
#ifdef ENABLE_MESSAGE_DIGEST
# include "message_digest_helper.h"
#endif // ENABLE_MESSAGE_DIGEST
@ -81,7 +82,7 @@ std::string fileHexDigest
{
SharedHandle<DiskWriter> writer(new DefaultDiskWriter(filename));
writer->openExistingFile();
return message_digest::hexDigest(ctx, writer, 0, writer->size());
return util::toHex(message_digest::digest(ctx, writer, 0, writer->size()));
}
#endif // ENABLE_MESSAGE_DIGEST