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

Store only interesting HTTP headers in HttpHeader 

In this change, we defined HTTP header fields we are interested in.
We only store those headers in HttpHeader object.  Accessing HTTP
headers in HttpHeader object is now done through enum values.
pull/28/head
Tatsuhiro Tsujikawa 2012-09-23 20:59:34 +09:00
parent 0b4dec0250
commit dd7014a612
13 changed files with 294 additions and 219 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

109
src/HttpHeader.cc
View File

@ -37,26 +37,10 @@
#include "util.h"
#include "A2STR.h"
#include "DownloadFailureException.h"
#include "array_fun.h"
namespace aria2 {
const std::string HttpHeader::LOCATION("location");
const std::string HttpHeader::TRANSFER_ENCODING("transfer-encoding");
const std::string HttpHeader::CONTENT_ENCODING("content-encoding");
const std::string HttpHeader::CONTENT_DISPOSITION("content-disposition");
const std::string HttpHeader::SET_COOKIE("set-cookie");
const std::string HttpHeader::CONTENT_TYPE("content-type");
const std::string HttpHeader::RETRY_AFTER("retry-after");
const std::string HttpHeader::CONNECTION("connection");
const std::string HttpHeader::CONTENT_LENGTH("content-length");
const std::string HttpHeader::CONTENT_RANGE("content-range");
const std::string HttpHeader::LAST_MODIFIED("last-modified");
const std::string HttpHeader::ACCEPT_ENCODING("accept-encoding");
const std::string HttpHeader::LINK("link");
const std::string HttpHeader::DIGEST("digest");
const std::string HttpHeader::PROXY_CONNECTION("proxy-connection");
const std::string HttpHeader::AUTHORIZATION("authorization");
const std::string HttpHeader::HTTP_1_1 = "HTTP/1.1";
const std::string HttpHeader::CLOSE = "close";
const std::string HttpHeader::KEEP_ALIVE = "keep-alive";
@ -67,21 +51,20 @@ const std::string HttpHeader::DEFLATE = "deflate";
HttpHeader::HttpHeader() {}
HttpHeader::~HttpHeader() {}
void HttpHeader::put(const std::string& name, const std::string& value)
void HttpHeader::put(int hdKey, const std::string& value)
{
std::multimap<std::string, std::string>::value_type vt(name, value);
std::multimap<int, std::string>::value_type vt(hdKey, value);
table_.insert(vt);
}
bool HttpHeader::defined(const std::string& name) const
bool HttpHeader::defined(int hdKey) const
{
return table_.count(name);
return table_.count(hdKey);
}
const std::string& HttpHeader::find(const std::string& name) const
const std::string& HttpHeader::find(int hdKey) const
{
std::multimap<std::string, std::string>::const_iterator itr =
table_.find(name);
std::multimap<int, std::string>::const_iterator itr = table_.find(hdKey);
if(itr == table_.end()) {
return A2STR::NIL;
} else {
@ -89,12 +72,12 @@ const std::string& HttpHeader::find(const std::string& name) const
}
}
std::vector<std::string> HttpHeader::findAll(const std::string& name) const
std::vector<std::string> HttpHeader::findAll(int hdKey) const
{
std::vector<std::string> v;
std::pair<std::multimap<std::string, std::string>::const_iterator,
std::multimap<std::string, std::string>::const_iterator> itrpair =
table_.equal_range(name);
std::pair<std::multimap<int, std::string>::const_iterator,
std::multimap<int, std::string>::const_iterator> itrpair =
table_.equal_range(hdKey);
while(itrpair.first != itrpair.second) {
v.push_back((*itrpair.first).second);
++itrpair.first;
@ -102,16 +85,16 @@ std::vector<std::string> HttpHeader::findAll(const std::string& name) const
return v;
}
std::pair<std::multimap<std::string, std::string>::const_iterator,
std::multimap<std::string, std::string>::const_iterator>
HttpHeader::equalRange(const std::string& name) const
std::pair<std::multimap<int, std::string>::const_iterator,
std::multimap<int, std::string>::const_iterator>
HttpHeader::equalRange(int hdKey) const
{
return table_.equal_range(name);
return table_.equal_range(hdKey);
}
int32_t HttpHeader::findAsInt(const std::string& name) const
int32_t HttpHeader::findAsInt(int hdKey) const
{
const std::string& value = find(name);
const std::string& value = find(hdKey);
if(value.empty()) {
return 0;
} else {
@ -119,9 +102,9 @@ int32_t HttpHeader::findAsInt(const std::string& name) const
}
}
int64_t HttpHeader::findAsLLInt(const std::string& name) const
int64_t HttpHeader::findAsLLInt(int hdKey) const
{
const std::string& value = find(name);
const std::string& value = find(hdKey);
if(value.empty()) {
return 0;
} else {
@ -253,13 +236,12 @@ void HttpHeader::setReasonPhrase(const std::string& reasonPhrase)
reasonPhrase_ = reasonPhrase;
}
bool HttpHeader::fieldContains(const std::string& name,
const std::string& value)
bool HttpHeader::fieldContains(int hdKey, const char* value)
{
std::pair<std::multimap<std::string, std::string>::const_iterator,
std::multimap<std::string, std::string>::const_iterator> range =
equalRange(name);
for(std::multimap<std::string, std::string>::const_iterator i = range.first;
std::pair<std::multimap<int, std::string>::const_iterator,
std::multimap<int, std::string>::const_iterator> range =
equalRange(hdKey);
for(std::multimap<int, std::string>::const_iterator i = range.first;
i != range.second; ++i) {
std::vector<Scip> values;
util::splitIter((*i).second.begin(), (*i).second.end(),
@ -269,7 +251,7 @@ bool HttpHeader::fieldContains(const std::string& name,
);
for(std::vector<Scip>::const_iterator j = values.begin(),
eoj = values.end(); j != eoj; ++j) {
if(util::strieq((*j).first, (*j).second, value.begin(), value.end())) {
if(util::strieq((*j).first, (*j).second, value)) {
return true;
}
}
@ -277,4 +259,45 @@ bool HttpHeader::fieldContains(const std::string& name,
return false;
}
namespace {
const char* INTERESTING_HEADER_NAMES[] = {
"accept-encoding",
"access-control-request-headers",
"access-control-request-method",
"authorization",
"connection",
"content-disposition",
"content-encoding",
"content-length",
"content-range",
"content-type",
"digest",
"infohash",
"last-modified",
"link",
"location",
"origin",
"port",
"proxy-connection",
"retry-after",
"sec-websocket-key",
"sec-websocket-version",
"set-cookie",
"transfer-encoding",
"upgrade",
};
} // namespace
int idInterestingHeader(const char* hdName)
{
const char** i = std::lower_bound(vbegin(INTERESTING_HEADER_NAMES),
vend(INTERESTING_HEADER_NAMES),
hdName, util::strless);
if(i != vend(INTERESTING_HEADER_NAMES) && strcmp(*i, hdName) == 0 ) {
return i - vbegin(INTERESTING_HEADER_NAMES);
} else {
return HttpHeader::MAX_INTERESTING_HEADER;
}
}
} // namespace aria2

74
src/HttpHeader.h
View File

@ -49,7 +49,7 @@ class Range;
class HttpHeader {
private:
std::multimap<std::string, std::string> table_;
std::multimap<int, std::string> table_;
// HTTP status code, e.g. 200
int statusCode_;
@ -69,16 +69,47 @@ public:
HttpHeader();
~HttpHeader();
// The list of headers we are interested in. Only those header
// values are stored in table_. When updating this list, also update
// INTERESTING_HEADER_NAMES in HttpHeader.cc
enum InterestingHeader {
ACCEPT_ENCODING,
ACCESS_CONTROL_REQUEST_HEADERS,
ACCESS_CONTROL_REQUEST_METHOD,
AUTHORIZATION,
CONNECTION,
CONTENT_DISPOSITION,
CONTENT_ENCODING,
CONTENT_LENGTH,
CONTENT_RANGE,
CONTENT_TYPE,
DIGEST,
INFOHASH, // Used for BitTorrent LPD
LAST_MODIFIED,
LINK,
LOCATION,
ORIGIN,
PORT, // Used for BitTorrent LPD
PROXY_CONNECTION,
RETRY_AFTER,
SEC_WEBSOCKET_KEY,
SEC_WEBSOCKET_VERSION,
SET_COOKIE,
TRANSFER_ENCODING,
UPGRADE,
MAX_INTERESTING_HEADER
};
// For all methods, use lowercased header field name.
void put(const std::string& name, const std::string& value);
bool defined(const std::string& name) const;
const std::string& find(const std::string& name) const;
std::vector<std::string> findAll(const std::string& name) const;
std::pair<std::multimap<std::string, std::string>::const_iterator,
std::multimap<std::string, std::string>::const_iterator>
equalRange(const std::string& name) const;
int32_t findAsInt(const std::string& name) const;
int64_t findAsLLInt(const std::string& name) const;
void put(int hdKey, const std::string& value);
bool defined(int hdKey) const;
const std::string& find(int hdKey) const;
std::vector<std::string> findAll(int hdKey) const;
std::pair<std::multimap<int, std::string>::const_iterator,
std::multimap<int, std::string>::const_iterator>
equalRange(int hdKey) const;
int32_t findAsInt(int hdKey) const;
int64_t findAsLLInt(int hdKey) const;
SharedHandle<Range> getRange() const;
@ -125,24 +156,7 @@ public:
// Returns true if heder field |name| contains |value|. This method
// assumes the values of the header field is delimited by ','.
bool fieldContains(const std::string& name, const std::string& value);
static const std::string LOCATION;
static const std::string TRANSFER_ENCODING;
static const std::string CONTENT_ENCODING;
static const std::string CONTENT_DISPOSITION;
static const std::string SET_COOKIE;
static const std::string CONTENT_TYPE;
static const std::string RETRY_AFTER;
static const std::string CONNECTION;
static const std::string CONTENT_LENGTH;
static const std::string CONTENT_RANGE;
static const std::string LAST_MODIFIED;
static const std::string ACCEPT_ENCODING;
static const std::string LINK;
static const std::string DIGEST;
static const std::string AUTHORIZATION;
static const std::string PROXY_CONNECTION;
bool fieldContains(int hdKey, const char* value);
static const std::string HTTP_1_1;
static const std::string CLOSE;
@ -152,8 +166,10 @@ public:
static const std::string DEFLATE;
};
int idInterestingHeader(const char* hdName);
typedef SharedHandle<HttpHeader> HttpHeaderHandle;
} // namespace std;
} // namespace
#endif // D_HTTP_HEADER_H

32
src/HttpHeaderProcessor.cc
View File

@ -78,6 +78,7 @@ HttpHeaderProcessor::HttpHeaderProcessor(ParserMode mode)
: mode_(mode),
state_(mode == CLIENT_PARSER ? PREV_RES_VERSION : PREV_METHOD),
lastBytesProcessed_(0),
lastFieldHdKey_(HttpHeader::MAX_INTERESTING_HEADER),
result_(new HttpHeader())
{}
@ -118,6 +119,16 @@ size_t getText(std::string& buf,
}
} // namespace
namespace {
size_t ignoreText(std::string& buf,
const unsigned char* data, size_t length, size_t off)
{
size_t j;
for(j = off; j < length && !util::isCRLF(data[j]); ++j);
return j-1;
}
} // namespace
bool HttpHeaderProcessor::parse(const unsigned char* data, size_t length)
{
size_t i;
@ -276,9 +287,11 @@ bool HttpHeaderProcessor::parse(const unsigned char* data, size_t length)
state_ = FIELD_VALUE;
} else {
if(!lastFieldName_.empty()) {
util::lowercase(lastFieldName_);
result_->put(lastFieldName_, util::strip(buf_));
if(lastFieldHdKey_ != HttpHeader::MAX_INTERESTING_HEADER) {
result_->put(lastFieldHdKey_, util::strip(buf_));
}
lastFieldName_.clear();
lastFieldHdKey_ = HttpHeader::MAX_INTERESTING_HEADER;
buf_.clear();
}
if(c == '\n') {
@ -297,6 +310,8 @@ bool HttpHeaderProcessor::parse(const unsigned char* data, size_t length)
if(util::isLws(c) || util::isCRLF(c)) {
throw DL_ABORT_EX("Bad HTTP header: missing ':'");
} else if(c == ':') {
util::lowercase(lastFieldName_);
lastFieldHdKey_ = idInterestingHeader(lastFieldName_.c_str());
state_ = PREV_FIELD_VALUE;
} else {
i = getFieldNameToken(lastFieldName_, data, length, i);
@ -309,7 +324,11 @@ bool HttpHeaderProcessor::parse(const unsigned char* data, size_t length)
state_ = PREV_FIELD_NAME;
} else if(!util::isLws(c)) {
state_ = FIELD_VALUE;
i = getText(buf_, data, length, i);
if(lastFieldHdKey_ == HttpHeader::MAX_INTERESTING_HEADER) {
i = ignoreText(buf_, data, length, i);
} else {
i = getText(buf_, data, length, i);
}
}
break;
case FIELD_VALUE:
@ -318,7 +337,11 @@ bool HttpHeaderProcessor::parse(const unsigned char* data, size_t length)
} else if(c == '\n') {
state_ = PREV_FIELD_NAME;
} else {
i = getText(buf_, data, length, i);
if(lastFieldHdKey_ == HttpHeader::MAX_INTERESTING_HEADER) {
i = ignoreText(buf_, data, length, i);
} else {
i = getText(buf_, data, length, i);
}
}
break;
case PREV_EOH:
@ -363,6 +386,7 @@ void HttpHeaderProcessor::clear()
lastBytesProcessed_ = 0;
buf_.clear();
lastFieldName_.clear();
lastFieldHdKey_ = HttpHeader::MAX_INTERESTING_HEADER;
result_.reset(new HttpHeader());
headers_.clear();
}

1
src/HttpHeaderProcessor.h
View File

@ -88,6 +88,7 @@ private:
size_t lastBytesProcessed_;
std::string buf_;
std::string lastFieldName_;
int lastFieldHdKey_;
SharedHandle<HttpHeader> result_;
std::string headers_;
};

13
src/HttpResponse.cc
View File

@ -140,8 +140,8 @@ std::string HttpResponse::determinFilename() const
void HttpResponse::retrieveCookie()
{
Time now;
std::pair<std::multimap<std::string, std::string>::const_iterator,
std::multimap<std::string, std::string>::const_iterator> r =
std::pair<std::multimap<int, std::string>::const_iterator,
std::multimap<int, std::string>::const_iterator> r =
httpHeader_->equalRange(HttpHeader::SET_COOKIE);
for(; r.first != r.second; ++r.first) {
httpRequest_->getCookieStorage()->parseAndStore
@ -162,7 +162,6 @@ bool HttpResponse::isRedirect() const
void HttpResponse::processRedirect()
{
if(httpRequest_->getRequest()->redirectUri
(util::percentEncodeMini(getRedirectURI()))) {
A2_LOG_INFO(fmt(MSG_REDIRECT,
@ -375,8 +374,8 @@ void HttpResponse::getMetalinKHttpEntries
(std::vector<MetalinkHttpEntry>& result,
const SharedHandle<Option>& option) const
{
std::pair<std::multimap<std::string, std::string>::const_iterator,
std::multimap<std::string, std::string>::const_iterator> p =
std::pair<std::multimap<int, std::string>::const_iterator,
std::multimap<int, std::string>::const_iterator> p =
httpHeader_->equalRange(HttpHeader::LINK);
for(; p.first != p.second; ++p.first) {
MetalinkHttpEntry e;
@ -410,8 +409,8 @@ void HttpResponse::getMetalinKHttpEntries
void HttpResponse::getDigest(std::vector<Checksum>& result) const
{
using std::swap;
std::pair<std::multimap<std::string, std::string>::const_iterator,
std::multimap<std::string, std::string>::const_iterator> p =
std::pair<std::multimap<int, std::string>::const_iterator,
std::multimap<int, std::string>::const_iterator> p =
httpHeader_->equalRange(HttpHeader::DIGEST);
for(; p.first != p.second; ++p.first) {
const std::string& s = (*p.first).second;

8
src/HttpServerBodyCommand.cc
View File

@ -169,14 +169,14 @@ bool HttpServerBodyCommand::execute()
const SharedHandle<HttpHeader>& header =
httpServer_->getRequestHeader();
std::string accessControlHeaders;
if(!header->find("origin").empty() &&
!header->find("access-control-request-method").empty() &&
!httpServer_->getAllowOrigin().empty()) {
if(!header->find(HttpHeader::ORIGIN).empty() &&
!header->find(HttpHeader::ACCESS_CONTROL_REQUEST_METHOD).empty()
&& !httpServer_->getAllowOrigin().empty()) {
accessControlHeaders +=
"Access-Control-Allow-Methods: POST, GET, OPTIONS\r\n"
"Access-Control-Max-Age: 1728000\r\n";
const std::string& accReqHeaders =
header->find("access-control-request-headers");
header->find(HttpHeader::ACCESS_CONTROL_REQUEST_HEADERS);
if(!accReqHeaders.empty()) {
// We allow all headers requested.
accessControlHeaders += "Access-Control-Allow-Headers: ";

11
src/HttpServerCommand.cc
View File

@ -133,9 +133,9 @@ namespace {
int websocketHandshake(const SharedHandle<HttpHeader>& header)
{
if(header->getMethod() != "GET" ||
header->find("sec-websocket-key").empty()) {
header->find(HttpHeader::SEC_WEBSOCKET_KEY).empty()) {
return 400;
} else if(header->find("sec-websocket-version") != "13") {
} else if(header->find(HttpHeader::SEC_WEBSOCKET_VERSION) != "13") {
return 426;
} else if(header->getRequestPath() != "/jsonrpc") {
return 404;
@ -177,14 +177,15 @@ bool HttpServerCommand::execute()
e_->setNoWait(true);
return true;
}
if(header->fieldContains("upgrade", "websocket") &&
header->fieldContains("connection", "upgrade")) {
if(header->fieldContains(HttpHeader::UPGRADE, "websocket") &&
header->fieldContains(HttpHeader::CONNECTION, "upgrade")) {
#ifdef ENABLE_WEBSOCKET
int status = websocketHandshake(header);
Command* command;
if(status == 101) {
std::string serverKey =
createWebSocketServerKey(header->find("sec-websocket-key"));
createWebSocketServerKey
(header->find(HttpHeader::SEC_WEBSOCKET_KEY));
httpServer_->feedUpgradeResponse("websocket",
fmt("Sec-WebSocket-Accept: %s\r\n",
serverKey.c_str()));

6
src/LpdMessageReceiver.cc
View File

@ -93,10 +93,8 @@ SharedHandle<LpdMessage> LpdMessageReceiver::receiveMessage()
return msg;
}
const SharedHandle<HttpHeader>& header = proc.getResult();
static const std::string A2_INFOHASH = "infohash";
static const std::string A2_PORT = "port";
const std::string& infoHashString = header->find(A2_INFOHASH);
uint16_t port = header->findAsInt(A2_PORT);
const std::string& infoHashString = header->find(HttpHeader::INFOHASH);
uint16_t port = header->findAsInt(HttpHeader::PORT);
A2_LOG_INFO(fmt("LPD message received infohash=%s, port=%u from %s",
infoHashString.c_str(),
port,

5
src/util.cc
View File

@ -1725,6 +1725,11 @@ bool iendsWith(const std::string& a, const std::string& b)
return iendsWith(a.begin(), a.end(), b.begin(), b.end());
}
bool strless(const char* a, const char* b)
{
return strcmp(a, b) < 0;
}
} // namespace util
} // namespace aria2

3
src/util.h
View File

@ -714,6 +714,9 @@ bool iendsWith
bool iendsWith(const std::string& a, const char* b);
bool iendsWith(const std::string& a, const std::string& b);
// Returns true if strcmp(a, b) < 0
bool strless(const char* a, const char *b);
void generateRandomData(unsigned char* data, size_t length);
// Saves data to file whose name is filename. If overwrite is true,

44
test/HttpHeaderProcessorTest.cc
View File

@ -26,7 +26,7 @@ class HttpHeaderProcessorTest:public CppUnit::TestFixture {
CPPUNIT_TEST(testGetHeaderString);
CPPUNIT_TEST(testGetHttpRequestHeader);
CPPUNIT_TEST_SUITE_END();
public:
void testParse1();
void testParse2();
@ -68,27 +68,24 @@ void HttpHeaderProcessorTest::testParse3()
"GET / HTTP/1.1\r\n"
"Host: aria2.sourceforge.net\r\n"
"Connection: close \r\n" // trailing white space (BWS)
"Multi-Line: text1\r\n" // Multi-line header
"Accept-Encoding: text1\r\n" // Multi-line header
" text2\r\n"
" text3\r\n"
"Duplicate: foo\r\n"
"Duplicate: bar\r\n"
"No-value:\r\n"
"Authorization: foo\r\n"
"Authorization: bar\r\n"
"Content-Type:\r\n"
"\r\n";
CPPUNIT_ASSERT(proc.parse(s));
SharedHandle<HttpHeader> h = proc.getResult();
CPPUNIT_ASSERT_EQUAL(std::string("aria2.sourceforge.net"),
h->find("host"));
CPPUNIT_ASSERT_EQUAL(std::string("close"),
h->find("connection"));
CPPUNIT_ASSERT_EQUAL(std::string("close"), h->find(HttpHeader::CONNECTION));
CPPUNIT_ASSERT_EQUAL(std::string("text1 text2 text3"),
h->find("multi-line"));
h->find(HttpHeader::ACCEPT_ENCODING));
CPPUNIT_ASSERT_EQUAL(std::string("foo"),
h->findAll("duplicate")[0]);
h->findAll(HttpHeader::AUTHORIZATION)[0]);
CPPUNIT_ASSERT_EQUAL(std::string("bar"),
h->findAll("duplicate")[1]);
CPPUNIT_ASSERT_EQUAL(std::string(""), h->find("no-value"));
CPPUNIT_ASSERT(h->defined("no-value"));
h->findAll(HttpHeader::AUTHORIZATION)[1]);
CPPUNIT_ASSERT_EQUAL(std::string(""), h->find(HttpHeader::CONTENT_TYPE));
CPPUNIT_ASSERT(h->defined(HttpHeader::CONTENT_TYPE));
}
void HttpHeaderProcessorTest::testGetLastBytesProcessed()
@ -135,7 +132,7 @@ void HttpHeaderProcessorTest::testGetHttpResponseHeader()
"Connection: close\r\n"
"Content-Type: text/html; charset=UTF-8\r\n"
"\r\n"
"Entity: body";
"Content-Encoding: body";
CPPUNIT_ASSERT(proc.parse(hd));
@ -143,15 +140,11 @@ void HttpHeaderProcessorTest::testGetHttpResponseHeader()
CPPUNIT_ASSERT_EQUAL(404, header->getStatusCode());
CPPUNIT_ASSERT_EQUAL(std::string("Not Found"), header->getReasonPhrase());
CPPUNIT_ASSERT_EQUAL(std::string("HTTP/1.1"), header->getVersion());
CPPUNIT_ASSERT_EQUAL(std::string("Mon, 25 Jun 2007 16:04:59 GMT"),
header->find("date"));
CPPUNIT_ASSERT_EQUAL(std::string("Apache/2.2.3 (Debian)"),
header->find("server"));
CPPUNIT_ASSERT_EQUAL((int64_t)9187LL,
header->findAsLLInt("content-length"));
header->findAsLLInt(HttpHeader::CONTENT_LENGTH));
CPPUNIT_ASSERT_EQUAL(std::string("text/html; charset=UTF-8"),
header->find("content-type"));
CPPUNIT_ASSERT(!header->defined("entity"));
header->find(HttpHeader::CONTENT_TYPE));
CPPUNIT_ASSERT(!header->defined(HttpHeader::CONTENT_ENCODING));
}
void HttpHeaderProcessorTest::testGetHttpResponseHeader_statusOnly()
@ -272,7 +265,7 @@ void HttpHeaderProcessorTest::testGetHttpRequestHeader()
"Host: host\r\n"
"Connection: close\r\n"
"\r\n"
"Entity: body";
"Content-Encoding: body";
CPPUNIT_ASSERT(proc.parse(request));
@ -280,8 +273,9 @@ void HttpHeaderProcessorTest::testGetHttpRequestHeader()
CPPUNIT_ASSERT_EQUAL(std::string("GET"), httpHeader->getMethod());
CPPUNIT_ASSERT_EQUAL(std::string("/index.html"),httpHeader->getRequestPath());
CPPUNIT_ASSERT_EQUAL(std::string("HTTP/1.1"), httpHeader->getVersion());
CPPUNIT_ASSERT_EQUAL(std::string("close"),httpHeader->find("connection"));
CPPUNIT_ASSERT(!httpHeader->defined("entity"));
CPPUNIT_ASSERT_EQUAL(std::string("close"),
httpHeader->find(HttpHeader::CONNECTION));
CPPUNIT_ASSERT(!httpHeader->defined(HttpHeader::CONTENT_ENCODING));
}
} // namespace aria2

66
test/HttpHeaderTest.cc
View File

@ -15,7 +15,7 @@ class HttpHeaderTest:public CppUnit::TestFixture {
CPPUNIT_TEST(testClearField);
CPPUNIT_TEST(testFieldContains);
CPPUNIT_TEST_SUITE_END();
public:
void testGetRange();
void testFindAll();
@ -29,9 +29,9 @@ void HttpHeaderTest::testGetRange()
{
{
HttpHeader httpHeader;
httpHeader.put("content-range",
httpHeader.put(HttpHeader::CONTENT_RANGE,
"9223372036854775800-9223372036854775801/9223372036854775807");
SharedHandle<Range> range = httpHeader.getRange();
CPPUNIT_ASSERT_EQUAL((int64_t)9223372036854775800LL, range->getStartByte());
@ -40,9 +40,9 @@ void HttpHeaderTest::testGetRange()
}
{
HttpHeader httpHeader;
httpHeader.put("content-range",
httpHeader.put(HttpHeader::CONTENT_RANGE,
"9223372036854775800-9223372036854775801/9223372036854775807");
SharedHandle<Range> range = httpHeader.getRange();
CPPUNIT_ASSERT_EQUAL((int64_t)9223372036854775800LL, range->getStartByte());
@ -51,7 +51,7 @@ void HttpHeaderTest::testGetRange()
}
{
HttpHeader httpHeader;
httpHeader.put("content-range", "bytes */1024");
httpHeader.put(HttpHeader::CONTENT_RANGE, "bytes */1024");
SharedHandle<Range> range = httpHeader.getRange();
@ -61,7 +61,7 @@ void HttpHeaderTest::testGetRange()
}
{
HttpHeader httpHeader;
httpHeader.put("content-range", "bytes 0-9/*");
httpHeader.put(HttpHeader::CONTENT_RANGE, "bytes 0-9/*");
SharedHandle<Range> range = httpHeader.getRange();
@ -71,7 +71,7 @@ void HttpHeaderTest::testGetRange()
}
{
HttpHeader httpHeader;
httpHeader.put("content-range", "bytes */*");
httpHeader.put(HttpHeader::CONTENT_RANGE, "bytes */*");
SharedHandle<Range> range = httpHeader.getRange();
@ -81,7 +81,7 @@ void HttpHeaderTest::testGetRange()
}
{
HttpHeader httpHeader;
httpHeader.put("content-range", "bytes 0");
httpHeader.put(HttpHeader::CONTENT_RANGE, "bytes 0");
SharedHandle<Range> range = httpHeader.getRange();
@ -91,7 +91,7 @@ void HttpHeaderTest::testGetRange()
}
{
HttpHeader httpHeader;
httpHeader.put("content-range", "bytes 0/");
httpHeader.put(HttpHeader::CONTENT_RANGE, "bytes 0/");
SharedHandle<Range> range = httpHeader.getRange();
@ -101,7 +101,7 @@ void HttpHeaderTest::testGetRange()
}
{
HttpHeader httpHeader;
httpHeader.put("content-range", "bytes 0-/3");
httpHeader.put(HttpHeader::CONTENT_RANGE, "bytes 0-/3");
try {
httpHeader.getRange();
CPPUNIT_FAIL("Exception must be thrown");
@ -111,7 +111,7 @@ void HttpHeaderTest::testGetRange()
}
{
HttpHeader httpHeader;
httpHeader.put("content-range", "bytes -0/3");
httpHeader.put(HttpHeader::CONTENT_RANGE, "bytes -0/3");
try {
httpHeader.getRange();
CPPUNIT_FAIL("Exception must be thrown");
@ -124,11 +124,11 @@ void HttpHeaderTest::testGetRange()
void HttpHeaderTest::testFindAll()
{
HttpHeader h;
h.put("A", "100");
h.put("A", "101");
h.put("B", "200");
std::vector<std::string> r(h.findAll("A"));
h.put(HttpHeader::LINK, "100");
h.put(HttpHeader::LINK, "101");
h.put(HttpHeader::CONNECTION, "200");
std::vector<std::string> r(h.findAll(HttpHeader::LINK));
CPPUNIT_ASSERT_EQUAL((size_t)2, r.size());
CPPUNIT_ASSERT_EQUAL(std::string("100"), r[0]);
CPPUNIT_ASSERT_EQUAL(std::string("101"), r[1]);
@ -139,13 +139,13 @@ void HttpHeaderTest::testClearField()
HttpHeader h;
h.setStatusCode(200);
h.setVersion(HttpHeader::HTTP_1_1);
h.put("Foo", "Bar");
CPPUNIT_ASSERT_EQUAL(std::string("Bar"), h.find("Foo"));
h.put(HttpHeader::LINK, "Bar");
CPPUNIT_ASSERT_EQUAL(std::string("Bar"), h.find(HttpHeader::LINK));
h.clearField();
CPPUNIT_ASSERT_EQUAL(std::string(""), h.find("Foo"));
CPPUNIT_ASSERT_EQUAL(std::string(""), h.find(HttpHeader::LINK));
CPPUNIT_ASSERT_EQUAL(200, h.getStatusCode());
CPPUNIT_ASSERT_EQUAL(std::string(HttpHeader::HTTP_1_1), h.getVersion());
}
@ -153,18 +153,18 @@ void HttpHeaderTest::testClearField()
void HttpHeaderTest::testFieldContains()
{
HttpHeader h;
h.put("connection", "Keep-Alive, Upgrade");
h.put("upgrade", "WebSocket");
h.put("sec-websocket-version", "13");
h.put("sec-websocket-version", "8, 7");
CPPUNIT_ASSERT(h.fieldContains("connection", "upgrade"));
CPPUNIT_ASSERT(h.fieldContains("connection", "keep-alive"));
CPPUNIT_ASSERT(!h.fieldContains("connection", "close"));
CPPUNIT_ASSERT(h.fieldContains("upgrade", "websocket"));
CPPUNIT_ASSERT(!h.fieldContains("upgrade", "spdy"));
CPPUNIT_ASSERT(h.fieldContains("sec-websocket-version", "13"));
CPPUNIT_ASSERT(h.fieldContains("sec-websocket-version", "8"));
CPPUNIT_ASSERT(!h.fieldContains("sec-websocket-version", "6"));
h.put(HttpHeader::CONNECTION, "Keep-Alive, Upgrade");
h.put(HttpHeader::UPGRADE, "WebSocket");
h.put(HttpHeader::SEC_WEBSOCKET_VERSION, "13");
h.put(HttpHeader::SEC_WEBSOCKET_VERSION, "8, 7");
CPPUNIT_ASSERT(h.fieldContains(HttpHeader::CONNECTION, "upgrade"));
CPPUNIT_ASSERT(h.fieldContains(HttpHeader::CONNECTION, "keep-alive"));
CPPUNIT_ASSERT(!h.fieldContains(HttpHeader::CONNECTION, "close"));
CPPUNIT_ASSERT(h.fieldContains(HttpHeader::UPGRADE, "websocket"));
CPPUNIT_ASSERT(!h.fieldContains(HttpHeader::UPGRADE, "spdy"));
CPPUNIT_ASSERT(h.fieldContains(HttpHeader::SEC_WEBSOCKET_VERSION, "13"));
CPPUNIT_ASSERT(h.fieldContains(HttpHeader::SEC_WEBSOCKET_VERSION, "8"));
CPPUNIT_ASSERT(!h.fieldContains(HttpHeader::SEC_WEBSOCKET_VERSION, "6"));
}
} // namespace aria2

141
test/HttpResponseTest.cc
View File

@ -109,7 +109,7 @@ void HttpResponseTest::testGetContentLength_contentLength()
HttpResponse httpResponse;
SharedHandle<HttpHeader> httpHeader(new HttpHeader());
httpHeader->put("content-length", "4294967296");
httpHeader->put(HttpHeader::CONTENT_LENGTH, "4294967296");
httpResponse.setHttpHeader(httpHeader);
@ -121,13 +121,13 @@ void HttpResponseTest::testGetEntityLength()
HttpResponse httpResponse;
SharedHandle<HttpHeader> httpHeader(new HttpHeader());
httpHeader->put("content-length", "4294967296");
httpHeader->put(HttpHeader::CONTENT_LENGTH, "4294967296");
httpResponse.setHttpHeader(httpHeader);
CPPUNIT_ASSERT_EQUAL((int64_t)4294967296LL, httpResponse.getEntityLength());
httpHeader->put("content-range", "bytes 1-4294967296/4294967297");
httpHeader->put(HttpHeader::CONTENT_RANGE, "bytes 1-4294967296/4294967297");
CPPUNIT_ASSERT_EQUAL((int64_t)4294967297LL, httpResponse.getEntityLength());
@ -137,7 +137,8 @@ void HttpResponseTest::testGetContentType()
{
HttpResponse httpResponse;
SharedHandle<HttpHeader> httpHeader(new HttpHeader());
httpHeader->put("content-type", "application/metalink+xml; charset=UTF-8");
httpHeader->put(HttpHeader::CONTENT_TYPE,
"application/metalink+xml; charset=UTF-8");
httpResponse.setHttpHeader(httpHeader);
// See paramter is ignored.
CPPUNIT_ASSERT_EQUAL(std::string("application/metalink+xml"),
@ -165,7 +166,7 @@ void HttpResponseTest::testDeterminFilename_with_ContentDisposition_zero_length
{
HttpResponse httpResponse;
SharedHandle<HttpHeader> httpHeader(new HttpHeader());
httpHeader->put("content-disposition", "attachment; filename=\"\"");
httpHeader->put(HttpHeader::CONTENT_DISPOSITION, "attachment; filename=\"\"");
SharedHandle<HttpRequest> httpRequest(new HttpRequest());
SharedHandle<Request> request(new Request());
request->setUri("http://localhost/archives/aria2-1.0.0.tar.bz2");
@ -182,7 +183,7 @@ void HttpResponseTest::testDeterminFilename_with_ContentDisposition()
{
HttpResponse httpResponse;
SharedHandle<HttpHeader> httpHeader(new HttpHeader());
httpHeader->put("content-disposition",
httpHeader->put(HttpHeader::CONTENT_DISPOSITION,
"attachment; filename=\"aria2-current.tar.bz2\"");
SharedHandle<HttpRequest> httpRequest(new HttpRequest());
SharedHandle<Request> request(new Request());
@ -204,14 +205,14 @@ void HttpResponseTest::testGetRedirectURI_without_Location()
httpResponse.setHttpHeader(httpHeader);
CPPUNIT_ASSERT_EQUAL(std::string(""),
httpResponse.getRedirectURI());
httpResponse.getRedirectURI());
}
void HttpResponseTest::testGetRedirectURI_with_Location()
{
HttpResponse httpResponse;
SharedHandle<HttpHeader> httpHeader(new HttpHeader());
httpHeader->put("location", "http://localhost/download/aria2-1.0.0.tar.bz2");
httpHeader->put(HttpHeader::LOCATION, "http://localhost/download/aria2-1.0.0.tar.bz2");
httpResponse.setHttpHeader(httpHeader);
CPPUNIT_ASSERT_EQUAL
@ -224,7 +225,8 @@ void HttpResponseTest::testIsRedirect()
HttpResponse httpResponse;
SharedHandle<HttpHeader> httpHeader(new HttpHeader());
httpHeader->setStatusCode(200);
httpHeader->put("location", "http://localhost/download/aria2-1.0.0.tar.bz2");
httpHeader->put(HttpHeader::LOCATION,
"http://localhost/download/aria2-1.0.0.tar.bz2");
httpResponse.setHttpHeader(httpHeader);
@ -232,7 +234,7 @@ void HttpResponseTest::testIsRedirect()
httpHeader->setStatusCode(301);
CPPUNIT_ASSERT(httpResponse.isRedirect());
CPPUNIT_ASSERT(httpResponse.isRedirect());
}
void HttpResponseTest::testIsTransferEncodingSpecified()
@ -242,9 +244,9 @@ void HttpResponseTest::testIsTransferEncodingSpecified()
httpResponse.setHttpHeader(httpHeader);
CPPUNIT_ASSERT(!httpResponse.isTransferEncodingSpecified());
CPPUNIT_ASSERT(!httpResponse.isTransferEncodingSpecified());
httpHeader->put("transfer-encoding", "chunked");
httpHeader->put(HttpHeader::TRANSFER_ENCODING, "chunked");
CPPUNIT_ASSERT(httpResponse.isTransferEncodingSpecified());
}
@ -256,9 +258,9 @@ void HttpResponseTest::testGetTransferEncoding()
httpResponse.setHttpHeader(httpHeader);
CPPUNIT_ASSERT_EQUAL(std::string(""), httpResponse.getTransferEncoding());
CPPUNIT_ASSERT_EQUAL(std::string(""), httpResponse.getTransferEncoding());
httpHeader->put("transfer-encoding", "chunked");
httpHeader->put(HttpHeader::TRANSFER_ENCODING, "chunked");
CPPUNIT_ASSERT_EQUAL(std::string("chunked"),
httpResponse.getTransferEncoding());
@ -273,7 +275,7 @@ void HttpResponseTest::testGetTransferEncodingStreamFilter()
CPPUNIT_ASSERT(!httpResponse.getTransferEncodingStreamFilter());
httpHeader->put("transfer-encoding", "chunked");
httpHeader->put(HttpHeader::TRANSFER_ENCODING, "chunked");
CPPUNIT_ASSERT(httpResponse.getTransferEncodingStreamFilter());
}
@ -282,12 +284,12 @@ void HttpResponseTest::testIsContentEncodingSpecified()
{
HttpResponse httpResponse;
SharedHandle<HttpHeader> httpHeader(new HttpHeader());
httpResponse.setHttpHeader(httpHeader);
CPPUNIT_ASSERT(!httpResponse.isContentEncodingSpecified());
httpHeader->put("content-encoding", "gzip");
httpHeader->put(HttpHeader::CONTENT_ENCODING, "gzip");
CPPUNIT_ASSERT(httpResponse.isContentEncodingSpecified());
}
@ -296,12 +298,12 @@ void HttpResponseTest::testGetContentEncoding()
{
HttpResponse httpResponse;
SharedHandle<HttpHeader> httpHeader(new HttpHeader());
httpResponse.setHttpHeader(httpHeader);
CPPUNIT_ASSERT_EQUAL(A2STR::NIL, httpResponse.getContentEncoding());
httpHeader->put("content-encoding", "gzip");
httpHeader->put(HttpHeader::CONTENT_ENCODING, "gzip");
CPPUNIT_ASSERT_EQUAL(std::string("gzip"), httpResponse.getContentEncoding());
}
@ -310,13 +312,13 @@ void HttpResponseTest::testGetContentEncodingStreamFilter()
{
HttpResponse httpResponse;
SharedHandle<HttpHeader> httpHeader(new HttpHeader());
httpResponse.setHttpHeader(httpHeader);
CPPUNIT_ASSERT(!httpResponse.getContentEncodingStreamFilter());
#ifdef HAVE_ZLIB
httpHeader->put("content-encoding", "gzip");
httpHeader->put(HttpHeader::CONTENT_ENCODING, "gzip");
{
SharedHandle<StreamFilter> filter =
httpResponse.getContentEncodingStreamFilter();
@ -326,7 +328,7 @@ void HttpResponseTest::testGetContentEncodingStreamFilter()
}
httpHeader.reset(new HttpHeader());
httpResponse.setHttpHeader(httpHeader);
httpHeader->put("content-encoding", "deflate");
httpHeader->put(HttpHeader::CONTENT_ENCODING, "deflate");
{
SharedHandle<StreamFilter> filter =
httpResponse.getContentEncodingStreamFilter();
@ -337,7 +339,7 @@ void HttpResponseTest::testGetContentEncodingStreamFilter()
#endif // HAVE_ZLIB
httpHeader.reset(new HttpHeader());
httpResponse.setHttpHeader(httpHeader);
httpHeader->put("content-encoding", "bzip2");
httpHeader->put(HttpHeader::CONTENT_ENCODING, "bzip2");
{
SharedHandle<StreamFilter> filter =
httpResponse.getContentEncodingStreamFilter();
@ -359,14 +361,15 @@ void HttpResponseTest::testValidateResponse()
} catch(Exception& e) {
}
httpHeader->put("location", "http://localhost/archives/aria2-1.0.0.tar.bz2");
httpHeader->put(HttpHeader::LOCATION,
"http://localhost/archives/aria2-1.0.0.tar.bz2");
try {
httpResponse.validateResponse();
} catch(Exception& e) {
CPPUNIT_FAIL("exception must not be thrown.");
}
}
void HttpResponseTest::testValidateResponse_good_range()
{
HttpResponse httpResponse;
@ -384,8 +387,8 @@ void HttpResponseTest::testValidateResponse_good_range()
httpRequest->setRequest(request);
httpResponse.setHttpRequest(httpRequest);
httpHeader->setStatusCode(206);
httpHeader->put("content-range", "bytes 1048576-10485760/10485760");
httpHeader->put(HttpHeader::CONTENT_RANGE, "bytes 1048576-10485760/10485760");
try {
httpResponse.validateResponse();
} catch(Exception& e) {
@ -411,7 +414,7 @@ void HttpResponseTest::testValidateResponse_bad_range()
httpRequest->setRequest(request);
httpResponse.setHttpRequest(httpRequest);
httpHeader->setStatusCode(206);
httpHeader->put("content-range", "bytes 0-10485760/10485761");
httpHeader->put(HttpHeader::CONTENT_RANGE, "bytes 0-10485760/10485761");
try {
httpResponse.validateResponse();
@ -437,8 +440,8 @@ void HttpResponseTest::testValidateResponse_chunked()
httpRequest->setRequest(request);
httpResponse.setHttpRequest(httpRequest);
httpHeader->setStatusCode(206);
httpHeader->put("content-range", "bytes 0-10485760/10485761");
httpHeader->put("transfer-encoding", "chunked");
httpHeader->put(HttpHeader::CONTENT_RANGE, "bytes 0-10485760/10485761");
httpHeader->put(HttpHeader::TRANSFER_ENCODING, "chunked");
// if transfer-encoding is specified, then range validation is skipped.
try {
@ -471,7 +474,7 @@ void HttpResponseTest::testHasRetryAfter()
SharedHandle<HttpHeader> httpHeader(new HttpHeader());
httpResponse.setHttpHeader(httpHeader);
httpHeader->put("retry-after", "60");
httpHeader->put(HttpHeader::RETRY_AFTER, "60");
CPPUNIT_ASSERT(httpResponse.hasRetryAfter());
CPPUNIT_ASSERT_EQUAL((time_t)60, httpResponse.getRetryAfter());
@ -488,14 +491,14 @@ void HttpResponseTest::testProcessRedirect()
request->setUri("http://localhost/archives/aria2-1.0.0.tar.bz2");
httpRequest->setRequest(request);
httpResponse.setHttpRequest(httpRequest);
httpHeader->put("location", "http://mirror/aria2-1.0.0.tar.bz2");
httpHeader->put(HttpHeader::LOCATION, "http://mirror/aria2-1.0.0.tar.bz2");
httpResponse.processRedirect();
httpHeader->clearField();
// Test for percent-encode
httpHeader->put("location", "http://example.org/white space#aria2");
httpHeader->put(HttpHeader::LOCATION, "http://example.org/white space#aria2");
httpResponse.processRedirect();
CPPUNIT_ASSERT_EQUAL(std::string("http://example.org/white%20space"),
request->getCurrentUri());
@ -503,7 +506,8 @@ void HttpResponseTest::testProcessRedirect()
httpHeader->clearField();
// Give unsupported scheme
httpHeader->put("location", "unsupported://mirror/aria2-1.0.0.tar.bz2");
httpHeader->put(HttpHeader::LOCATION,
"unsupported://mirror/aria2-1.0.0.tar.bz2");
try {
httpResponse.processRedirect();
CPPUNIT_FAIL("DlRetryEx exception must be thrown.");
@ -528,11 +532,13 @@ void HttpResponseTest::testRetrieveCookie()
httpRequest->setCookieStorage(st);
httpResponse.setHttpRequest(httpRequest);
httpHeader->put("set-cookie", "k1=v1; expires=Sun, 10-Jun-2007 11:00:00 GMT;"
httpHeader->put(HttpHeader::SET_COOKIE,
"k1=v1; expires=Sun, 10-Jun-2007 11:00:00 GMT;"
"path=/; domain=.aria2.org;");
httpHeader->put("set-cookie", "k2=v2; expires=Sun, 01-Jan-38 00:00:00 GMT;"
httpHeader->put(HttpHeader::SET_COOKIE,
"k2=v2; expires=Sun, 01-Jan-38 00:00:00 GMT;"
"path=/; domain=.aria2.org;");
httpHeader->put("set-cookie", "k3=v3;");
httpHeader->put(HttpHeader::SET_COOKIE, "k3=v3;");
httpResponse.retrieveCookie();
@ -554,57 +560,57 @@ void HttpResponseTest::testSupportsPersistentConnection()
httpHeader->setVersion("HTTP/1.1");
CPPUNIT_ASSERT(httpResponse.supportsPersistentConnection());
httpHeader->put("connection", "close");
httpHeader->put(HttpHeader::CONNECTION, "close");
CPPUNIT_ASSERT(!httpResponse.supportsPersistentConnection());
httpHeader->clearField();
httpHeader->put("connection", "keep-alive");
httpHeader->put(HttpHeader::CONNECTION, "keep-alive");
CPPUNIT_ASSERT(httpResponse.supportsPersistentConnection());
httpHeader->clearField();
httpHeader->setVersion("HTTP/1.0");
CPPUNIT_ASSERT(!httpResponse.supportsPersistentConnection());
httpHeader->put("connection", "close");
httpHeader->put(HttpHeader::CONNECTION, "close");
CPPUNIT_ASSERT(!httpResponse.supportsPersistentConnection());
httpHeader->clearField();
httpHeader->put("connection", "keep-alive");
httpHeader->put(HttpHeader::CONNECTION, "keep-alive");
CPPUNIT_ASSERT(httpResponse.supportsPersistentConnection());
httpHeader->clearField();
// test proxy connection
SharedHandle<Request> proxyRequest(new Request());
httpRequest->setProxyRequest(proxyRequest);
httpHeader->setVersion("HTTP/1.1");
CPPUNIT_ASSERT(!httpResponse.supportsPersistentConnection());
httpHeader->put("connection", "close");
httpHeader->put(HttpHeader::CONNECTION, "close");
CPPUNIT_ASSERT(!httpResponse.supportsPersistentConnection());
httpHeader->clearField();
httpHeader->put("connection", "keep-alive");
httpHeader->put(HttpHeader::CONNECTION, "keep-alive");
CPPUNIT_ASSERT(!httpResponse.supportsPersistentConnection());
httpHeader->clearField();
httpHeader->put("proxy-connection", "keep-alive");
httpHeader->put(HttpHeader::PROXY_CONNECTION, "keep-alive");
CPPUNIT_ASSERT(httpResponse.supportsPersistentConnection());
httpHeader->put("connection", "close");
httpHeader->put(HttpHeader::CONNECTION, "close");
CPPUNIT_ASSERT(!httpResponse.supportsPersistentConnection());
httpHeader->clearField();
httpHeader->put("proxy-connection", "close");
httpHeader->put(HttpHeader::PROXY_CONNECTION, "close");
CPPUNIT_ASSERT(!httpResponse.supportsPersistentConnection());
httpHeader->clearField();
httpHeader->setVersion("HTTP/1.0");
CPPUNIT_ASSERT(!httpResponse.supportsPersistentConnection());
httpHeader->put("connection", "close");
httpHeader->put(HttpHeader::CONNECTION, "close");
CPPUNIT_ASSERT(!httpResponse.supportsPersistentConnection());
httpHeader->clearField();
httpHeader->put("connection", "keep-alive");
httpHeader->put(HttpHeader::CONNECTION, "keep-alive");
CPPUNIT_ASSERT(!httpResponse.supportsPersistentConnection());
httpHeader->put("proxy-connection", "keep-alive");
httpHeader->put(HttpHeader::PROXY_CONNECTION, "keep-alive");
CPPUNIT_ASSERT(httpResponse.supportsPersistentConnection());
httpHeader->clearField();
httpHeader->put("proxy-connection", "keep-alive");
httpHeader->put(HttpHeader::PROXY_CONNECTION, "keep-alive");
CPPUNIT_ASSERT(!httpResponse.supportsPersistentConnection());
httpHeader->clearField();
httpHeader->put("proxy-connection", "close");
httpHeader->put(HttpHeader::PROXY_CONNECTION, "close");
CPPUNIT_ASSERT(!httpResponse.supportsPersistentConnection());
httpHeader->clearField();
}
@ -616,13 +622,16 @@ void HttpResponseTest::testGetMetalinKHttpEntries()
httpResponse.setHttpHeader(httpHeader);
SharedHandle<Option> option(new Option());
httpHeader->put("link", "<http://uri1/>; rel=duplicate; pri=1; pref; geo=JP");
httpHeader->put("link", "<http://uri2/>; rel=duplicate");
httpHeader->put("link", "<http://uri3/>;;;;;;;;rel=duplicate;;;;;pri=2;;;;;");
httpHeader->put("link", "<http://uri4/>;rel=duplicate;=pri=1;pref");
httpHeader->put("link", "<http://describedby>; rel=describedby");
httpHeader->put("link", "<http://norel/>");
httpHeader->put("link", "<baduri>; rel=duplicate; pri=-1;");
httpHeader->put(HttpHeader::LINK,
"<http://uri1/>; rel=duplicate; pri=1; pref; geo=JP");
httpHeader->put(HttpHeader::LINK,
"<http://uri2/>; rel=duplicate");
httpHeader->put(HttpHeader::LINK,
"<http://uri3/>;;;;;;;;rel=duplicate;;;;;pri=2;;;;;");
httpHeader->put(HttpHeader::LINK, "<http://uri4/>;rel=duplicate;=pri=1;pref");
httpHeader->put(HttpHeader::LINK, "<http://describedby>; rel=describedby");
httpHeader->put(HttpHeader::LINK, "<http://norel/>");
httpHeader->put(HttpHeader::LINK, "<baduri>; rel=duplicate; pri=-1;");
std::vector<MetalinkHttpEntry> result;
httpResponse.getMetalinKHttpEntries(result, option);
CPPUNIT_ASSERT_EQUAL((size_t)5, result.size());
@ -667,11 +676,13 @@ void HttpResponseTest::testGetDigest()
SharedHandle<Option> option(new Option());
// Python binascii.hexlify(base64.b64decode(B64ED_HASH)) is handy to
// retrieve ascii hex hash string.
httpHeader->put("digest", "SHA-1=82AD8itGL/oYQ5BTPFANiYnp9oE=");
httpHeader->put("digest", "NOT_SUPPORTED");
httpHeader->put("digest", "SHA-224=rQdowoLHQJTMVZ3rF7vmYOIzUXlu7F+FcMbPnA==");
httpHeader->put("digest", "SHA-224=6Ik6LNZ1iPy6cbmlKO4NHfvxzaiurmHilMyhGA==");
httpHeader->put("digest",
httpHeader->put(HttpHeader::DIGEST, "SHA-1=82AD8itGL/oYQ5BTPFANiYnp9oE=");
httpHeader->put(HttpHeader::DIGEST, "NOT_SUPPORTED");
httpHeader->put(HttpHeader::DIGEST,
"SHA-224=rQdowoLHQJTMVZ3rF7vmYOIzUXlu7F+FcMbPnA==");
httpHeader->put(HttpHeader::DIGEST,
"SHA-224=6Ik6LNZ1iPy6cbmlKO4NHfvxzaiurmHilMyhGA==");
httpHeader->put(HttpHeader::DIGEST,
"SHA-256=+D8nGudz3G/kpkVKQeDrI3xD57v0UeQmzGCZOk03nsU=,"
"MD5=LJDK2+9ClF8Nz/K5WZd/+A==");
std::vector<Checksum> result;