From 9b8de2ebfb1c1c6a3aa19fb59e149cc4da91d2be Mon Sep 17 00:00:00 2001 From: Bryan Call Date: Fri, 24 Mar 2017 09:02:43 -0700 Subject: [PATCH] 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 bd021e4f533..23509fe1cef 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 e0c60f98eab..0c1110725f6 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 4d8c66dac21..685412d25af 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;