You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@trafficserver.apache.org by bc...@apache.org on 2017/03/28 14:21:10 UTC
[trafficserver] branch master updated: Convert HPACK enums to enum
classes
This is an automated email from the ASF dual-hosted git repository.
bcall pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/trafficserver.git
The following commit(s) were added to refs/heads/master by this push:
new f2a7beb Convert HPACK enums to enum classes
f2a7beb is described below
commit f2a7bebd2b94cd300d93eb365f056abb5c1ace79
Author: Bryan Call <bc...@apache.org>
AuthorDate: Fri Mar 24 09:02:43 2017 -0700
Convert HPACK enums to enum classes
---
proxy/http2/HPACK.cc | 74 +++++++++++++++++++++---------------------
proxy/http2/HPACK.h | 38 +++++++++++-----------
proxy/http2/RegressionHPACK.cc | 40 +++++++++++------------
3 files changed, 76 insertions(+), 76 deletions(-)
diff --git a/proxy/http2/HPACK.cc b/proxy/http2/HPACK.cc
index bd021e4..23509fe 100644
--- a/proxy/http2/HPACK.cc
+++ b/proxy/http2/HPACK.cc
@@ -165,9 +165,9 @@ const static struct {
* Local functions
******************/
static inline bool
-hpack_field_is_literal(HpackFieldType ftype)
+hpack_field_is_literal(HpackField ftype)
{
- return ftype == HPACK_FIELD_INDEXED_LITERAL || ftype == HPACK_FIELD_NOINDEX_LITERAL || ftype == HPACK_FIELD_NEVERINDEX_LITERAL;
+ return ftype == HpackField::INDEXED_LITERAL || ftype == HpackField::NOINDEX_LITERAL || ftype == HpackField::NEVERINDEX_LITERAL;
}
//
@@ -175,27 +175,27 @@ hpack_field_is_literal(HpackFieldType ftype)
// kind of field it is. Field types are specified in the high 4 bits
// and all bits are defined, so there's no way to get an invalid field type.
//
-HpackFieldType
+HpackField
hpack_parse_field_type(uint8_t ftype)
{
if (ftype & 0x80) {
- return HPACK_FIELD_INDEX;
+ return HpackField::INDEX;
}
if (ftype & 0x40) {
- return HPACK_FIELD_INDEXED_LITERAL;
+ return HpackField::INDEXED_LITERAL;
}
if (ftype & 0x20) {
- return HPACK_FIELD_TABLESIZE_UPDATE;
+ return HpackField::TABLESIZE_UPDATE;
}
if (ftype & 0x10) {
- return HPACK_FIELD_NEVERINDEX_LITERAL;
+ return HpackField::NEVERINDEX_LITERAL;
}
ink_assert((ftype & 0xf0) == 0x0);
- return HPACK_FIELD_NOINDEX_LITERAL;
+ return HpackField::NOINDEX_LITERAL;
}
/************************
@@ -238,19 +238,19 @@ HpackIndexingTable::lookup(const char *name, int name_len, const char *value, in
if (ptr_len_casecmp(name, name_len, table_name, table_name_len) == 0) {
if ((value_len == table_value_len) && (memcmp(value, table_value, value_len) == 0)) {
result.index = index;
- result.match_type = HPACK_EXACT_MATCH;
+ result.match_type = HpackMatch::EXACT;
break;
} else if (!result.index) {
result.index = index;
- result.match_type = HPACK_NAME_MATCH;
+ result.match_type = HpackMatch::NAME;
}
}
}
- if (result.match_type != HPACK_NO_MATCH) {
+ if (result.match_type != HpackMatch::NONE) {
if (result.index < TS_HPACK_STATIC_TABLE_ENTRY_NUM) {
- result.index_type = HPACK_INDEX_TYPE_STATIC;
+ result.index_type = HpackIndex::STATIC;
} else {
- result.index_type = HPACK_INDEX_TYPE_DYNAMIC;
+ result.index_type = HpackIndex::DYNAMIC;
}
}
@@ -507,7 +507,7 @@ encode_indexed_header_field(uint8_t *buf_start, const uint8_t *buf_end, uint32_t
int64_t
encode_literal_header_field_with_indexed_name(uint8_t *buf_start, const uint8_t *buf_end, const MIMEFieldWrapper &header,
- uint32_t index, HpackIndexingTable &indexing_table, HpackFieldType type)
+ uint32_t index, HpackIndexingTable &indexing_table, HpackField type)
{
uint8_t *p = buf_start;
int64_t len;
@@ -516,16 +516,16 @@ encode_literal_header_field_with_indexed_name(uint8_t *buf_start, const uint8_t
ink_assert(hpack_field_is_literal(type));
switch (type) {
- case HPACK_FIELD_INDEXED_LITERAL:
+ case HpackField::INDEXED_LITERAL:
indexing_table.add_header_field(header.field_get());
prefix = 6;
flag = 0x40;
break;
- case HPACK_FIELD_NOINDEX_LITERAL:
+ case HpackField::NOINDEX_LITERAL:
prefix = 4;
flag = 0x00;
break;
- case HPACK_FIELD_NEVERINDEX_LITERAL:
+ case HpackField::NEVERINDEX_LITERAL:
prefix = 4;
flag = 0x10;
break;
@@ -561,7 +561,7 @@ encode_literal_header_field_with_indexed_name(uint8_t *buf_start, const uint8_t
int64_t
encode_literal_header_field_with_new_name(uint8_t *buf_start, const uint8_t *buf_end, const MIMEFieldWrapper &header,
- HpackIndexingTable &indexing_table, HpackFieldType type)
+ HpackIndexingTable &indexing_table, HpackField type)
{
uint8_t *p = buf_start;
int64_t len;
@@ -570,14 +570,14 @@ encode_literal_header_field_with_new_name(uint8_t *buf_start, const uint8_t *buf
ink_assert(hpack_field_is_literal(type));
switch (type) {
- case HPACK_FIELD_INDEXED_LITERAL:
+ case HpackField::INDEXED_LITERAL:
indexing_table.add_header_field(header.field_get());
flag = 0x40;
break;
- case HPACK_FIELD_NOINDEX_LITERAL:
+ case HpackField::NOINDEX_LITERAL:
flag = 0x00;
break;
- case HPACK_FIELD_NEVERINDEX_LITERAL:
+ case HpackField::NEVERINDEX_LITERAL:
flag = 0x10;
break;
default:
@@ -744,16 +744,16 @@ decode_literal_header_field(MIMEFieldWrapper &header, const uint8_t *buf_start,
bool isIncremental = false;
uint32_t index = 0;
int64_t len = 0;
- HpackFieldType ftype = hpack_parse_field_type(*p);
+ HpackField ftype = hpack_parse_field_type(*p);
bool has_http2_violation = false;
- if (ftype == HPACK_FIELD_INDEXED_LITERAL) {
+ if (ftype == HpackField::INDEXED_LITERAL) {
len = decode_integer(index, p, buf_end, 6);
isIncremental = true;
- } else if (ftype == HPACK_FIELD_NEVERINDEX_LITERAL) {
+ } else if (ftype == HpackField::NEVERINDEX_LITERAL) {
len = decode_integer(index, p, buf_end, 4);
} else {
- ink_assert(ftype == HPACK_FIELD_NOINDEX_LITERAL);
+ ink_assert(ftype == HpackField::NOINDEX_LITERAL);
len = decode_integer(index, p, buf_end, 4);
}
@@ -868,10 +868,10 @@ hpack_decode_header_block(HpackIndexingTable &indexing_table, HTTPHdr *hdr, cons
// decode a header field encoded by HPACK
MIMEField *field = mime_field_create(heap, hh->m_fields_impl);
MIMEFieldWrapper header(field, heap, hh->m_fields_impl);
- HpackFieldType ftype = hpack_parse_field_type(*cursor);
+ HpackField ftype = hpack_parse_field_type(*cursor);
switch (ftype) {
- case HPACK_FIELD_INDEX:
+ case HpackField::INDEX:
read_bytes = decode_indexed_header_field(header, cursor, in_buf_end, indexing_table);
if (read_bytes == HPACK_ERROR_COMPRESSION_ERROR) {
return HPACK_ERROR_COMPRESSION_ERROR;
@@ -879,9 +879,9 @@ hpack_decode_header_block(HpackIndexingTable &indexing_table, HTTPHdr *hdr, cons
cursor += read_bytes;
header_field_started = true;
break;
- case HPACK_FIELD_INDEXED_LITERAL:
- case HPACK_FIELD_NOINDEX_LITERAL:
- case HPACK_FIELD_NEVERINDEX_LITERAL:
+ case HpackField::INDEXED_LITERAL:
+ case HpackField::NOINDEX_LITERAL:
+ case HpackField::NEVERINDEX_LITERAL:
read_bytes = decode_literal_header_field(header, cursor, in_buf_end, indexing_table);
if (read_bytes == HPACK_ERROR_COMPRESSION_ERROR) {
return HPACK_ERROR_COMPRESSION_ERROR;
@@ -893,7 +893,7 @@ hpack_decode_header_block(HpackIndexingTable &indexing_table, HTTPHdr *hdr, cons
cursor += read_bytes;
header_field_started = true;
break;
- case HPACK_FIELD_TABLESIZE_UPDATE:
+ case HpackField::TABLESIZE_UPDATE:
if (header_field_started) {
return HPACK_ERROR_COMPRESSION_ERROR;
}
@@ -938,7 +938,7 @@ hpack_encode_header_block(HpackIndexingTable &indexing_table, uint8_t *out_buf,
MIMEFieldIter field_iter;
for (MIMEField *field = hdr->iter_get_first(&field_iter); field != nullptr; field = hdr->iter_get_next(&field_iter)) {
- HpackFieldType field_type;
+ HpackField field_type;
MIMEFieldWrapper header(field, hdr->m_heap, hdr->m_http->m_fields_impl);
int name_len;
int value_len;
@@ -949,20 +949,20 @@ hpack_encode_header_block(HpackIndexingTable &indexing_table, uint8_t *out_buf,
// - Short Cookie header should not be indexed because of low entropy
if ((ptr_len_casecmp(name, name_len, MIME_FIELD_COOKIE, MIME_LEN_COOKIE) == 0 && value_len < 20) ||
(ptr_len_casecmp(name, name_len, MIME_FIELD_AUTHORIZATION, MIME_LEN_AUTHORIZATION) == 0)) {
- field_type = HPACK_FIELD_NEVERINDEX_LITERAL;
+ field_type = HpackField::NEVERINDEX_LITERAL;
} else {
- field_type = HPACK_FIELD_INDEXED_LITERAL;
+ field_type = HpackField::INDEXED_LITERAL;
}
const HpackLookupResult result = indexing_table.lookup(header);
switch (result.match_type) {
- case HPACK_NO_MATCH:
+ case HpackMatch::NONE:
written = encode_literal_header_field_with_new_name(cursor, out_buf_end, header, indexing_table, field_type);
break;
- case HPACK_NAME_MATCH:
+ case HpackMatch::NAME:
written =
encode_literal_header_field_with_indexed_name(cursor, out_buf_end, header, result.index, indexing_table, field_type);
break;
- case HPACK_EXACT_MATCH:
+ case HpackMatch::EXACT:
written = encode_indexed_header_field(cursor, out_buf_end, result.index);
break;
default:
diff --git a/proxy/http2/HPACK.h b/proxy/http2/HPACK.h
index e0c60f9..0c11107 100644
--- a/proxy/http2/HPACK.h
+++ b/proxy/http2/HPACK.h
@@ -33,32 +33,32 @@
const static int HPACK_ERROR_COMPRESSION_ERROR = -1;
const static int HPACK_ERROR_SIZE_EXCEEDED_ERROR = -2;
-enum HpackFieldType {
- HPACK_FIELD_INDEX, // [RFC 7541] 6.1. Indexed Header Field Representation
- HPACK_FIELD_INDEXED_LITERAL, // [RFC 7541] 6.2.1. Literal Header Field with Incremental Indexing
- HPACK_FIELD_NOINDEX_LITERAL, // [RFC 7541] 6.2.2. Literal Header Field without Indexing
- HPACK_FIELD_NEVERINDEX_LITERAL, // [RFC 7541] 6.2.3. Literal Header Field never Indexed
- HPACK_FIELD_TABLESIZE_UPDATE, // [RFC 7541] 6.3. Dynamic Table Size Update
+enum class HpackField {
+ INDEX, // [RFC 7541] 6.1. Indexed Header Field Representation
+ INDEXED_LITERAL, // [RFC 7541] 6.2.1. Literal Header Field with Incremental Indexing
+ NOINDEX_LITERAL, // [RFC 7541] 6.2.2. Literal Header Field without Indexing
+ NEVERINDEX_LITERAL, // [RFC 7541] 6.2.3. Literal Header Field never Indexed
+ TABLESIZE_UPDATE, // [RFC 7541] 6.3. Dynamic Table Size Update
};
-enum HpackIndexType {
- HPACK_INDEX_TYPE_NONE,
- HPACK_INDEX_TYPE_STATIC,
- HPACK_INDEX_TYPE_DYNAMIC,
+enum class HpackIndex {
+ NONE,
+ STATIC,
+ DYNAMIC,
};
-enum HpackMatchType {
- HPACK_NO_MATCH,
- HPACK_NAME_MATCH,
- HPACK_EXACT_MATCH,
+enum class HpackMatch {
+ NONE,
+ NAME,
+ EXACT,
};
// Result of looking for a header field in IndexingTable
struct HpackLookupResult {
- HpackLookupResult() : index(0), index_type(HPACK_INDEX_TYPE_NONE), match_type(HPACK_NO_MATCH) {}
+ HpackLookupResult() : index(0), index_type(HpackIndex::NONE), match_type(HpackMatch::NONE) {}
int index;
- HpackIndexType index_type;
- HpackMatchType match_type;
+ HpackIndex index_type;
+ HpackMatch match_type;
};
class MIMEFieldWrapper
@@ -160,9 +160,9 @@ int64_t encode_string(uint8_t *buf_start, const uint8_t *buf_end, const char *va
int64_t decode_string(Arena &arena, char **str, uint32_t &str_length, const uint8_t *buf_start, const uint8_t *buf_end);
int64_t encode_indexed_header_field(uint8_t *buf_start, const uint8_t *buf_end, uint32_t index);
int64_t encode_literal_header_field_with_indexed_name(uint8_t *buf_start, const uint8_t *buf_end, const MIMEFieldWrapper &header,
- uint32_t index, HpackIndexingTable &indexing_table, HpackFieldType type);
+ uint32_t index, HpackIndexingTable &indexing_table, HpackField type);
int64_t encode_literal_header_field_with_new_name(uint8_t *buf_start, const uint8_t *buf_end, const MIMEFieldWrapper &header,
- HpackIndexingTable &indexing_table, HpackFieldType type);
+ HpackIndexingTable &indexing_table, HpackField type);
int64_t decode_indexed_header_field(MIMEFieldWrapper &header, const uint8_t *buf_start, const uint8_t *buf_end,
HpackIndexingTable &indexing_table);
int64_t decode_literal_header_field(MIMEFieldWrapper &header, const uint8_t *buf_start, const uint8_t *buf_end,
diff --git a/proxy/http2/RegressionHPACK.cc b/proxy/http2/RegressionHPACK.cc
index 4d8c66d..685412d 100644
--- a/proxy/http2/RegressionHPACK.cc
+++ b/proxy/http2/RegressionHPACK.cc
@@ -81,78 +81,78 @@ const static struct {
char *raw_name;
char *raw_value;
int index;
- HpackFieldType type;
+ HpackField type;
uint8_t *encoded_field;
int encoded_field_len;
} literal_test_case[] = {
- {(char *)"custom-key", (char *)"custom-header", 0, HPACK_FIELD_INDEXED_LITERAL, (uint8_t *)"\x40\x0a"
+ {(char *)"custom-key", (char *)"custom-header", 0, HpackField::INDEXED_LITERAL, (uint8_t *)"\x40\x0a"
"custom-key\x0d"
"custom-header",
26},
- {(char *)"custom-key", (char *)"custom-header", 0, HPACK_FIELD_NOINDEX_LITERAL, (uint8_t *)"\x00\x0a"
+ {(char *)"custom-key", (char *)"custom-header", 0, HpackField::NOINDEX_LITERAL, (uint8_t *)"\x00\x0a"
"custom-key\x0d"
"custom-header",
26},
- {(char *)"custom-key", (char *)"custom-header", 0, HPACK_FIELD_NEVERINDEX_LITERAL, (uint8_t *)"\x10\x0a"
+ {(char *)"custom-key", (char *)"custom-header", 0, HpackField::NEVERINDEX_LITERAL, (uint8_t *)"\x10\x0a"
"custom-key\x0d"
"custom-header",
26},
- {(char *)":path", (char *)"/sample/path", 4, HPACK_FIELD_INDEXED_LITERAL, (uint8_t *)"\x44\x0c"
+ {(char *)":path", (char *)"/sample/path", 4, HpackField::INDEXED_LITERAL, (uint8_t *)"\x44\x0c"
"/sample/path",
14},
- {(char *)":path", (char *)"/sample/path", 4, HPACK_FIELD_NOINDEX_LITERAL, (uint8_t *)"\x04\x0c"
+ {(char *)":path", (char *)"/sample/path", 4, HpackField::NOINDEX_LITERAL, (uint8_t *)"\x04\x0c"
"/sample/path",
14},
- {(char *)":path", (char *)"/sample/path", 4, HPACK_FIELD_NEVERINDEX_LITERAL, (uint8_t *)"\x14\x0c"
+ {(char *)":path", (char *)"/sample/path", 4, HpackField::NEVERINDEX_LITERAL, (uint8_t *)"\x14\x0c"
"/sample/path",
14},
- {(char *)"password", (char *)"secret", 0, HPACK_FIELD_INDEXED_LITERAL, (uint8_t *)"\x40\x08"
+ {(char *)"password", (char *)"secret", 0, HpackField::INDEXED_LITERAL, (uint8_t *)"\x40\x08"
"password\x06"
"secret",
17},
- {(char *)"password", (char *)"secret", 0, HPACK_FIELD_NOINDEX_LITERAL, (uint8_t *)"\x00\x08"
+ {(char *)"password", (char *)"secret", 0, HpackField::NOINDEX_LITERAL, (uint8_t *)"\x00\x08"
"password\x06"
"secret",
17},
- {(char *)"password", (char *)"secret", 0, HPACK_FIELD_NEVERINDEX_LITERAL, (uint8_t *)"\x10\x08"
+ {(char *)"password", (char *)"secret", 0, HpackField::NEVERINDEX_LITERAL, (uint8_t *)"\x10\x08"
"password\x06"
"secret",
17},
// with Huffman Coding
- {(char *)"custom-key", (char *)"custom-header", 0, HPACK_FIELD_INDEXED_LITERAL,
+ {(char *)"custom-key", (char *)"custom-header", 0, HpackField::INDEXED_LITERAL,
(uint8_t *)"\x40"
"\x88\x25\xa8\x49\xe9\x5b\xa9\x7d\x7f"
"\x89\x25\xa8\x49\xe9\x5a\x72\x8e\x42\xd9",
20},
- {(char *)"custom-key", (char *)"custom-header", 0, HPACK_FIELD_NOINDEX_LITERAL,
+ {(char *)"custom-key", (char *)"custom-header", 0, HpackField::NOINDEX_LITERAL,
(uint8_t *)"\x00"
"\x88\x25\xa8\x49\xe9\x5b\xa9\x7d\x7f"
"\x89\x25\xa8\x49\xe9\x5a\x72\x8e\x42\xd9",
20},
- {(char *)"custom-key", (char *)"custom-header", 0, HPACK_FIELD_NEVERINDEX_LITERAL,
+ {(char *)"custom-key", (char *)"custom-header", 0, HpackField::NEVERINDEX_LITERAL,
(uint8_t *)"\x10"
"\x88\x25\xa8\x49\xe9\x5b\xa9\x7d\x7f"
"\x89\x25\xa8\x49\xe9\x5a\x72\x8e\x42\xd9",
20},
- {(char *)":path", (char *)"/sample/path", 4, HPACK_FIELD_INDEXED_LITERAL, (uint8_t *)"\x44"
+ {(char *)":path", (char *)"/sample/path", 4, HpackField::INDEXED_LITERAL, (uint8_t *)"\x44"
"\x89\x61\x03\xa6\xba\x0a\xc5\x63\x4c\xff",
11},
- {(char *)":path", (char *)"/sample/path", 4, HPACK_FIELD_NOINDEX_LITERAL, (uint8_t *)"\x04"
+ {(char *)":path", (char *)"/sample/path", 4, HpackField::NOINDEX_LITERAL, (uint8_t *)"\x04"
"\x89\x61\x03\xa6\xba\x0a\xc5\x63\x4c\xff",
11},
- {(char *)":path", (char *)"/sample/path", 4, HPACK_FIELD_NEVERINDEX_LITERAL,
+ {(char *)":path", (char *)"/sample/path", 4, HpackField::NEVERINDEX_LITERAL,
(uint8_t *)"\x14"
"\x89\x61\x03\xa6\xba\x0a\xc5\x63\x4c\xff",
11},
- {(char *)"password", (char *)"secret", 0, HPACK_FIELD_INDEXED_LITERAL, (uint8_t *)"\x40"
+ {(char *)"password", (char *)"secret", 0, HpackField::INDEXED_LITERAL, (uint8_t *)"\x40"
"\x86\xac\x68\x47\x83\xd9\x27"
"\x84\x41\x49\x61\x53",
13},
- {(char *)"password", (char *)"secret", 0, HPACK_FIELD_NOINDEX_LITERAL, (uint8_t *)"\x00"
+ {(char *)"password", (char *)"secret", 0, HpackField::NOINDEX_LITERAL, (uint8_t *)"\x00"
"\x86\xac\x68\x47\x83\xd9\x27"
"\x84\x41\x49\x61\x53",
13},
- {(char *)"password", (char *)"secret", 0, HPACK_FIELD_NEVERINDEX_LITERAL, (uint8_t *)"\x10"
+ {(char *)"password", (char *)"secret", 0, HpackField::NEVERINDEX_LITERAL, (uint8_t *)"\x10"
"\x86\xac\x68\x47\x83\xd9\x27"
"\x84\x41\x49\x61\x53",
13}};
@@ -441,7 +441,7 @@ REGRESSION_TEST(HPACK_Encode)(RegressionTest *t, int, int *pstatus)
}
HpackLookupResult lookupResult = indexing_table.lookup(expected_name, expected_name_len, expected_value, expected_value_len);
- box.check(lookupResult.match_type == HPACK_EXACT_MATCH && lookupResult.index_type == HPACK_INDEX_TYPE_DYNAMIC,
+ box.check(lookupResult.match_type == HpackMatch::EXACT && lookupResult.index_type == HpackIndex::DYNAMIC,
"the header field is not indexed");
expected_dynamic_table_size += dynamic_table_response_test_case[i][j].size;
--
To stop receiving notification emails like this one, please contact
['"commits@trafficserver.apache.org" <co...@trafficserver.apache.org>'].