Remove grpc_mdelem (#28267)
* Automated change: Fix sanity tests
* content-type
* Automated change: Fix sanity tests
* clang-format
* fix
* Move colon prefixed metadata
* Automated change: Fix sanity tests
* Automated change: Fix sanity tests
* try to fix windows failure
* try and scale sizes better
* ambiguity fix?
* wip metadatavalueasslice
* Fix status code for resource exhaustion
* Revert "Revert "Move a bunch of slice typed metadata to new system (#28107)" (#28208)"
This reverts commit 7717587063.
* fix test
* Automated change: Fix sanity tests
* Automated change: Fix sanity tests
* slice helper
* x
* noinline
* try and scale sizes better
* Automated change: Fix sanity tests
* fixes
* fix
* fix
* fixes
* fix build
* fix overflow
* progress
* Automated change: Fix sanity tests
* fix
* initial work
* progress
* fix
* fix
* Automated change: Fix sanity tests
* progress
* fix
* fix
* fix
* Automated change: Fix sanity tests
* fix
* compressor for path/authority
* Automated change: Fix sanity tests
* Automated change: Fix sanity tests
* legalize
* legalize
* status-enc
* fmt
* fix
* fix
* fix
* fix
* fix/opt
* fix
* fix
* fix
* fix
* Automated change: Fix sanity tests
* fix
* comment
* fmt
* remove arg
* Automated change: Fix sanity tests
* remove name
* Automated change: Fix sanity tests
* sketch
* Automated change: Fix sanity tests
* progress
* add specialized encoders for compression metadata
* progress
* review feedback
* fix
* missoing files
* remove crud
* xxxxx
* more
* Small improvement in memory usage and performance
* Automated change: Fix sanity tests
* Automated change: Fix sanity tests
* Fix caching
* Automated change: Fix sanity tests
* omg
* fix crash in alts
* default everything
* Automated change: Fix sanity tests
* review feedback
* fixes
* fixes
* fixes
* Automated change: Fix sanity tests
* speedup
* fix
* fix
* clang-format
* fixes
* progress
* fixes
* fixes
* Automated change: Fix sanity tests
* fix
* fix
* progress
* update timeout encoding algorithm
* Automated change: Fix sanity tests
* fix
* fix
* review feedback
* progress
* progress
* progress
* progress
* builds
* Automated change: Fix sanity tests
* remove debug code
* fix ub
* unname things
* coax compilers
* reduce failures
* fix
* fix
* fix
* fix
* cleanup
* compile fix
* preserve concatenation rule
* spew
* fix
* fix
* postfix operator++ for msvc
* fix
* fix
* remove unused code
* lower cost of hpack table construction
* fix refcounting
* review feedback
* fixes
* fixes
* support multivalued traits
* Automated change: Fix sanity tests
* fix
* clearer clear
* appeasing 4.9
Co-authored-by: ctiller <ctiller@users.noreply.github.com>
pull/28496/head
Craig Tiller
3 years ago
committed by
GitHub
parent
75ede8df91
commit
4b881c5947
159 changed files with 1245 additions and 7191 deletions
@ -1,107 +0,0 @@ |
||||
// Copyright 2021 gRPC authors.
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
#ifndef GRPC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_HPACK_ENCODER_INDEX_H |
||||
#define GRPC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_HPACK_ENCODER_INDEX_H |
||||
|
||||
#include <grpc/support/port_platform.h> |
||||
|
||||
#include "absl/types/optional.h" |
||||
|
||||
namespace grpc_core { |
||||
|
||||
// A fixed size mapping of a key to a chronologically ordered index
|
||||
template <typename Key, size_t kNumEntries> |
||||
class HPackEncoderIndex { |
||||
public: |
||||
using Index = uint32_t; |
||||
|
||||
HPackEncoderIndex() : entries_{} {} |
||||
|
||||
// If key exists in the table, update it to a new index.
|
||||
// If it does not and there is an empty slot, add it to the index.
|
||||
// Finally, if it does not and there is no empty slot, evict the oldest
|
||||
// conflicting member.
|
||||
void Insert(const Key& key, Index new_index) { |
||||
auto* const cuckoo_first = first_slot(key); |
||||
if (cuckoo_first->UpdateOrAdd(key, new_index)) return; |
||||
auto* const cuckoo_second = second_slot(key); |
||||
if (cuckoo_second->UpdateOrAdd(key, new_index)) return; |
||||
auto* const clobber = Older(cuckoo_first, cuckoo_second); |
||||
clobber->key = key.stored(); |
||||
clobber->index = new_index; |
||||
} |
||||
|
||||
// Lookup key and return its index, or return empty if it's not in this table.
|
||||
absl::optional<Index> Lookup(const Key& key) { |
||||
auto* const cuckoo_first = first_slot(key); |
||||
if (key == cuckoo_first->key) return cuckoo_first->index; |
||||
auto* const cuckoo_second = second_slot(key); |
||||
if (key == cuckoo_second->key) return cuckoo_second->index; |
||||
return {}; |
||||
} |
||||
|
||||
private: |
||||
using StoredKey = typename Key::Stored; |
||||
|
||||
// One entry in the index
|
||||
struct Entry { |
||||
Entry() : key{}, index{} {}; |
||||
|
||||
StoredKey key; |
||||
Index index; |
||||
|
||||
// Update this entry if it matches key, otherwise if it's empty add it.
|
||||
// If neither happens, return false.
|
||||
bool UpdateOrAdd(const Key& new_key, Index new_index) { |
||||
if (new_key == key) { |
||||
index = new_index; |
||||
return true; |
||||
} else if (key == StoredKey()) { |
||||
key = new_key.stored(); |
||||
index = new_index; |
||||
return true; |
||||
} else { |
||||
return false; |
||||
} |
||||
} |
||||
}; |
||||
|
||||
static Entry* Older(Entry* a, Entry* b) { |
||||
if (a->index < b->index) { |
||||
return a; |
||||
} else { |
||||
return b; |
||||
} |
||||
} |
||||
|
||||
// Return the first slot in which key could be stored.
|
||||
Entry* first_slot(const Key& key) { |
||||
return &entries_[key.hash() % kNumEntries]; |
||||
} |
||||
|
||||
// Return the second slot in which key could be stored.
|
||||
Entry* second_slot(const Key& key) { |
||||
return &entries_[(key.hash() / kNumEntries) % kNumEntries]; |
||||
} |
||||
|
||||
// Fixed size entry map.
|
||||
// We store each key/value pair in two slots based on it's hash value.
|
||||
// They can be evicted individually.
|
||||
Entry entries_[kNumEntries]; |
||||
}; |
||||
|
||||
} // namespace grpc_core
|
||||
|
||||
#endif // GRPC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_HPACK_ENCODER_INDEX_H
|
||||
@ -1,46 +0,0 @@ |
||||
// Copyright 2021 gRPC authors.
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
#include <grpc/support/port_platform.h> |
||||
|
||||
#include "src/core/ext/transport/chttp2/transport/hpack_utils.h" |
||||
|
||||
#include "src/core/lib/surface/validate_metadata.h" |
||||
|
||||
namespace grpc_core { |
||||
|
||||
namespace { |
||||
size_t Base64EncodedSize(size_t raw_length) { |
||||
static constexpr uint8_t tail_xtra[3] = {0, 2, 3}; |
||||
return raw_length / 3 * 4 + tail_xtra[raw_length % 3]; |
||||
} |
||||
} // namespace
|
||||
|
||||
// Return the size occupied by some metadata in the HPACK table.
|
||||
size_t MetadataSizeInHPackTable(grpc_mdelem elem, |
||||
bool use_true_binary_metadata) { |
||||
const uint8_t* key_buf = GRPC_SLICE_START_PTR(GRPC_MDKEY(elem)); |
||||
size_t key_len = GRPC_SLICE_LENGTH(GRPC_MDKEY(elem)); |
||||
size_t overhead_and_key = 32 + key_len; |
||||
size_t value_len = GRPC_SLICE_LENGTH(GRPC_MDVALUE(elem)); |
||||
if (grpc_key_is_binary_header(key_buf, key_len)) { |
||||
return overhead_and_key + (use_true_binary_metadata |
||||
? value_len + 1 |
||||
: Base64EncodedSize(value_len)); |
||||
} else { |
||||
return overhead_and_key + value_len; |
||||
} |
||||
} |
||||
|
||||
} // namespace grpc_core
|
||||
@ -1,30 +0,0 @@ |
||||
// Copyright 2021 gRPC authors.
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
#ifndef GRPC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_HPACK_UTILS_H |
||||
#define GRPC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_HPACK_UTILS_H |
||||
|
||||
#include <grpc/support/port_platform.h> |
||||
|
||||
#include "src/core/lib/transport/metadata.h" |
||||
|
||||
namespace grpc_core { |
||||
|
||||
// Return the size occupied by some metadata in the HPACK table.
|
||||
size_t MetadataSizeInHPackTable(grpc_mdelem elem, |
||||
bool use_true_binary_metadata); |
||||
|
||||
} // namespace grpc_core
|
||||
|
||||
#endif // GRPC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_HPACK_UTILS_H
|
||||
@ -1,60 +0,0 @@ |
||||
// Copyright 2021 gRPC authors.
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
#ifndef GRPC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_POPULARITY_COUNT_H |
||||
#define GRPC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_POPULARITY_COUNT_H |
||||
|
||||
#include <grpc/support/port_platform.h> |
||||
|
||||
namespace grpc_core { |
||||
|
||||
// filter tables for elems: this tables provides an approximate
|
||||
// popularity count for particular hashes, and are used to determine whether
|
||||
// a new literal should be added to the compression table or not.
|
||||
// They track a single integer that counts how often a particular value has
|
||||
// been seen. When that count reaches max (255), all values are halved. */
|
||||
template <uint8_t kElems> |
||||
class PopularityCount { |
||||
public: |
||||
PopularityCount() : sum_{0}, elems_{} {} |
||||
|
||||
// increment a filter count, halve all counts if one element reaches max
|
||||
// return true if this element seems to be popular, false otherwise
|
||||
bool AddElement(uint8_t idx) { |
||||
elems_[idx]++; |
||||
if (GPR_LIKELY(elems_[idx] < 255)) { |
||||
sum_++; |
||||
} else { |
||||
HalveFilter(); |
||||
} |
||||
return elems_[idx] >= 2 * sum_ / kElems; |
||||
} |
||||
|
||||
private: |
||||
// halve all counts because an element reached max
|
||||
void HalveFilter() { |
||||
sum_ = 0; |
||||
for (int i = 0; i < kElems; i++) { |
||||
elems_[i] /= 2; |
||||
sum_ += elems_[i]; |
||||
} |
||||
} |
||||
|
||||
uint32_t sum_; |
||||
uint8_t elems_[kElems]; |
||||
}; |
||||
|
||||
} // namespace grpc_core
|
||||
|
||||
#endif /* GRPC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_POPULARITY_COUNT_H */ |
||||
@ -1,61 +0,0 @@ |
||||
/*
|
||||
* |
||||
* Copyright 2015 gRPC authors. |
||||
* |
||||
* Licensed under the Apache License, Version 2.0 (the "License"); |
||||
* you may not use this file except in compliance with the License. |
||||
* You may obtain a copy of the License at |
||||
* |
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
* |
||||
* Unless required by applicable law or agreed to in writing, software |
||||
* distributed under the License is distributed on an "AS IS" BASIS, |
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
||||
* See the License for the specific language governing permissions and |
||||
* limitations under the License. |
||||
* |
||||
*/ |
||||
|
||||
#include <grpc/support/port_platform.h> |
||||
|
||||
#include <string.h> |
||||
|
||||
#include <grpc/support/alloc.h> |
||||
|
||||
#include "src/core/lib/security/credentials/credentials.h" |
||||
#include "src/core/lib/slice/slice_internal.h" |
||||
|
||||
static void mdelem_list_ensure_capacity(grpc_credentials_mdelem_array* list, |
||||
size_t additional_space_needed) { |
||||
size_t target_size = list->size + additional_space_needed; |
||||
// Find the next power of two greater than the target size (i.e.,
|
||||
// whenever we add more space, we double what we already have).
|
||||
size_t new_size = 2; |
||||
while (new_size < target_size) { |
||||
new_size *= 2; |
||||
} |
||||
list->md = static_cast<grpc_mdelem*>( |
||||
gpr_realloc(list->md, sizeof(grpc_mdelem) * new_size)); |
||||
} |
||||
|
||||
void grpc_credentials_mdelem_array_add(grpc_credentials_mdelem_array* list, |
||||
grpc_mdelem md) { |
||||
mdelem_list_ensure_capacity(list, 1); |
||||
list->md[list->size++] = GRPC_MDELEM_REF(md); |
||||
} |
||||
|
||||
void grpc_credentials_mdelem_array_append(grpc_credentials_mdelem_array* dst, |
||||
grpc_credentials_mdelem_array* src) { |
||||
mdelem_list_ensure_capacity(dst, src->size); |
||||
for (size_t i = 0; i < src->size; ++i) { |
||||
dst->md[dst->size++] = GRPC_MDELEM_REF(src->md[i]); |
||||
} |
||||
} |
||||
|
||||
void grpc_credentials_mdelem_array_destroy( |
||||
grpc_credentials_mdelem_array* list) { |
||||
for (size_t i = 0; i < list->size; ++i) { |
||||
GRPC_MDELEM_UNREF(list->md[i]); |
||||
} |
||||
gpr_free(list->md); |
||||
} |
||||
@ -1,306 +0,0 @@ |
||||
/*
|
||||
* Copyright 2015 gRPC authors. |
||||
* |
||||
* Licensed under the Apache License, Version 2.0 (the "License"); |
||||
* you may not use this file except in compliance with the License. |
||||
* You may obtain a copy of the License at |
||||
* |
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
* |
||||
* Unless required by applicable law or agreed to in writing, software |
||||
* distributed under the License is distributed on an "AS IS" BASIS, |
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
||||
* See the License for the specific language governing permissions and |
||||
* limitations under the License. |
||||
*/ |
||||
|
||||
/*
|
||||
* WARNING: Auto-generated code. |
||||
* |
||||
* To make changes to this file, change |
||||
* tools/codegen/core/gen_static_metadata.py, and then re-run it. |
||||
* |
||||
* See metadata.h for an explanation of the interface here, and metadata.cc for |
||||
* an explanation of what's going on. |
||||
*/ |
||||
|
||||
#include <grpc/support/port_platform.h> |
||||
|
||||
#include "src/core/lib/slice/static_slice.h" |
||||
|
||||
namespace grpc_core { |
||||
const uint8_t g_static_metadata_bytes[] = { |
||||
103, 114, 112, 99, 45, 116, 105, 109, 101, 111, 117, 116, 47, 103, 114, |
||||
112, 99, 46, 108, 98, 46, 118, 49, 46, 76, 111, 97, 100, 66, 97, |
||||
108, 97, 110, 99, 101, 114, 47, 66, 97, 108, 97, 110, 99, 101, 76, |
||||
111, 97, 100, 47, 101, 110, 118, 111, 121, 46, 115, 101, 114, 118, 105, |
||||
99, 101, 46, 108, 111, 97, 100, 95, 115, 116, 97, 116, 115, 46, 118, |
||||
50, 46, 76, 111, 97, 100, 82, 101, 112, 111, 114, 116, 105, 110, 103, |
||||
83, 101, 114, 118, 105, 99, 101, 47, 83, 116, 114, 101, 97, 109, 76, |
||||
111, 97, 100, 83, 116, 97, 116, 115, 47, 101, 110, 118, 111, 121, 46, |
||||
115, 101, 114, 118, 105, 99, 101, 46, 108, 111, 97, 100, 95, 115, 116, |
||||
97, 116, 115, 46, 118, 51, 46, 76, 111, 97, 100, 82, 101, 112, 111, |
||||
114, 116, 105, 110, 103, 83, 101, 114, 118, 105, 99, 101, 47, 83, 116, |
||||
114, 101, 97, 109, 76, 111, 97, 100, 83, 116, 97, 116, 115, 47, 103, |
||||
114, 112, 99, 46, 104, 101, 97, 108, 116, 104, 46, 118, 49, 46, 72, |
||||
101, 97, 108, 116, 104, 47, 87, 97, 116, 99, 104, 47, 101, 110, 118, |
||||
111, 121, 46, 115, 101, 114, 118, 105, 99, 101, 46, 100, 105, 115, 99, |
||||
111, 118, 101, 114, 121, 46, 118, 50, 46, 65, 103, 103, 114, 101, 103, |
||||
97, 116, 101, 100, 68, 105, 115, 99, 111, 118, 101, 114, 121, 83, 101, |
||||
114, 118, 105, 99, 101, 47, 83, 116, 114, 101, 97, 109, 65, 103, 103, |
||||
114, 101, 103, 97, 116, 101, 100, 82, 101, 115, 111, 117, 114, 99, 101, |
||||
115, 47, 101, 110, 118, 111, 121, 46, 115, 101, 114, 118, 105, 99, 101, |
||||
46, 100, 105, 115, 99, 111, 118, 101, 114, 121, 46, 118, 51, 46, 65, |
||||
103, 103, 114, 101, 103, 97, 116, 101, 100, 68, 105, 115, 99, 111, 118, |
||||
101, 114, 121, 83, 101, 114, 118, 105, 99, 101, 47, 83, 116, 114, 101, |
||||
97, 109, 65, 103, 103, 114, 101, 103, 97, 116, 101, 100, 82, 101, 115, |
||||
111, 117, 114, 99, 101, 115, 116, 101, 116, 114, 97, 105, 108, 101, 114, |
||||
115, 58, 97, 117, 116, 104, 111, 114, 105, 116, 121, 58, 109, 101, 116, |
||||
104, 111, 100, 71, 69, 84, 80, 79, 83, 84, 58, 112, 97, 116, 104, |
||||
47, 47, 105, 110, 100, 101, 120, 46, 104, 116, 109, 108, 58, 115, 99, |
||||
104, 101, 109, 101, 104, 116, 116, 112, 104, 116, 116, 112, 115, 58, 115, |
||||
116, 97, 116, 117, 115, 50, 48, 48, 50, 48, 52, 50, 48, 54, 51, |
||||
48, 52, 52, 48, 48, 52, 48, 52, 53, 48, 48, 97, 99, 99, 101, |
||||
112, 116, 45, 99, 104, 97, 114, 115, 101, 116, 97, 99, 99, 101, 112, |
||||
116, 45, 101, 110, 99, 111, 100, 105, 110, 103, 103, 122, 105, 112, 44, |
||||
32, 100, 101, 102, 108, 97, 116, 101, 97, 99, 99, 101, 112, 116, 45, |
||||
108, 97, 110, 103, 117, 97, 103, 101, 97, 99, 99, 101, 112, 116, 45, |
||||
114, 97, 110, 103, 101, 115, 97, 99, 99, 101, 112, 116, 97, 99, 99, |
||||
101, 115, 115, 45, 99, 111, 110, 116, 114, 111, 108, 45, 97, 108, 108, |
||||
111, 119, 45, 111, 114, 105, 103, 105, 110, 97, 103, 101, 97, 108, 108, |
||||
111, 119, 97, 117, 116, 104, 111, 114, 105, 122, 97, 116, 105, 111, 110, |
||||
99, 97, 99, 104, 101, 45, 99, 111, 110, 116, 114, 111, 108, 99, 111, |
||||
110, 116, 101, 110, 116, 45, 100, 105, 115, 112, 111, 115, 105, 116, 105, |
||||
111, 110, 99, 111, 110, 116, 101, 110, 116, 45, 101, 110, 99, 111, 100, |
||||
105, 110, 103, 99, 111, 110, 116, 101, 110, 116, 45, 108, 97, 110, 103, |
||||
117, 97, 103, 101, 99, 111, 110, 116, 101, 110, 116, 45, 108, 101, 110, |
||||
103, 116, 104, 99, 111, 110, 116, 101, 110, 116, 45, 108, 111, 99, 97, |
||||
116, 105, 111, 110, 99, 111, 110, 116, 101, 110, 116, 45, 114, 97, 110, |
||||
103, 101, 99, 111, 110, 116, 101, 110, 116, 45, 116, 121, 112, 101, 99, |
||||
111, 111, 107, 105, 101, 100, 97, 116, 101, 101, 116, 97, 103, 101, 120, |
||||
112, 101, 99, 116, 101, 120, 112, 105, 114, 101, 115, 102, 114, 111, 109, |
||||
104, 111, 115, 116, 105, 102, 45, 109, 97, 116, 99, 104, 105, 102, 45, |
||||
109, 111, 100, 105, 102, 105, 101, 100, 45, 115, 105, 110, 99, 101, 105, |
||||
102, 45, 110, 111, 110, 101, 45, 109, 97, 116, 99, 104, 105, 102, 45, |
||||
114, 97, 110, 103, 101, 105, 102, 45, 117, 110, 109, 111, 100, 105, 102, |
||||
105, 101, 100, 45, 115, 105, 110, 99, 101, 108, 97, 115, 116, 45, 109, |
||||
111, 100, 105, 102, 105, 101, 100, 108, 105, 110, 107, 108, 111, 99, 97, |
||||
116, 105, 111, 110, 109, 97, 120, 45, 102, 111, 114, 119, 97, 114, 100, |
||||
115, 112, 114, 111, 120, 121, 45, 97, 117, 116, 104, 101, 110, 116, 105, |
||||
99, 97, 116, 101, 112, 114, 111, 120, 121, 45, 97, 117, 116, 104, 111, |
||||
114, 105, 122, 97, 116, 105, 111, 110, 114, 97, 110, 103, 101, 114, 101, |
||||
102, 101, 114, 101, 114, 114, 101, 102, 114, 101, 115, 104, 114, 101, 116, |
||||
114, 121, 45, 97, 102, 116, 101, 114, 115, 101, 114, 118, 101, 114, 115, |
||||
101, 116, 45, 99, 111, 111, 107, 105, 101, 115, 116, 114, 105, 99, 116, |
||||
45, 116, 114, 97, 110, 115, 112, 111, 114, 116, 45, 115, 101, 99, 117, |
||||
114, 105, 116, 121, 116, 114, 97, 110, 115, 102, 101, 114, 45, 101, 110, |
||||
99, 111, 100, 105, 110, 103, 117, 115, 101, 114, 45, 97, 103, 101, 110, |
||||
116, 118, 97, 114, 121, 118, 105, 97, 119, 119, 119, 45, 97, 117, 116, |
||||
104, 101, 110, 116, 105, 99, 97, 116, 101, 108, 98, 45, 99, 111, 115, |
||||
116, 45, 98, 105, 110}; |
||||
|
||||
grpc_slice_refcount StaticSliceRefcount::kStaticSubRefcount; |
||||
|
||||
StaticSliceRefcount g_static_metadata_slice_refcounts[GRPC_STATIC_MDSTR_COUNT] = |
||||
{ |
||||
|
||||
StaticSliceRefcount(0), StaticSliceRefcount(1), |
||||
StaticSliceRefcount(2), StaticSliceRefcount(3), |
||||
StaticSliceRefcount(4), StaticSliceRefcount(5), |
||||
StaticSliceRefcount(6), StaticSliceRefcount(7), |
||||
StaticSliceRefcount(8), StaticSliceRefcount(9), |
||||
StaticSliceRefcount(10), StaticSliceRefcount(11), |
||||
StaticSliceRefcount(12), StaticSliceRefcount(13), |
||||
StaticSliceRefcount(14), StaticSliceRefcount(15), |
||||
StaticSliceRefcount(16), StaticSliceRefcount(17), |
||||
StaticSliceRefcount(18), StaticSliceRefcount(19), |
||||
StaticSliceRefcount(20), StaticSliceRefcount(21), |
||||
StaticSliceRefcount(22), StaticSliceRefcount(23), |
||||
StaticSliceRefcount(24), StaticSliceRefcount(25), |
||||
StaticSliceRefcount(26), StaticSliceRefcount(27), |
||||
StaticSliceRefcount(28), StaticSliceRefcount(29), |
||||
StaticSliceRefcount(30), StaticSliceRefcount(31), |
||||
StaticSliceRefcount(32), StaticSliceRefcount(33), |
||||
StaticSliceRefcount(34), StaticSliceRefcount(35), |
||||
StaticSliceRefcount(36), StaticSliceRefcount(37), |
||||
StaticSliceRefcount(38), StaticSliceRefcount(39), |
||||
StaticSliceRefcount(40), StaticSliceRefcount(41), |
||||
StaticSliceRefcount(42), StaticSliceRefcount(43), |
||||
StaticSliceRefcount(44), StaticSliceRefcount(45), |
||||
StaticSliceRefcount(46), StaticSliceRefcount(47), |
||||
StaticSliceRefcount(48), StaticSliceRefcount(49), |
||||
StaticSliceRefcount(50), StaticSliceRefcount(51), |
||||
StaticSliceRefcount(52), StaticSliceRefcount(53), |
||||
StaticSliceRefcount(54), StaticSliceRefcount(55), |
||||
StaticSliceRefcount(56), StaticSliceRefcount(57), |
||||
StaticSliceRefcount(58), StaticSliceRefcount(59), |
||||
StaticSliceRefcount(60), StaticSliceRefcount(61), |
||||
StaticSliceRefcount(62), StaticSliceRefcount(63), |
||||
StaticSliceRefcount(64), StaticSliceRefcount(65), |
||||
StaticSliceRefcount(66), StaticSliceRefcount(67), |
||||
StaticSliceRefcount(68), StaticSliceRefcount(69), |
||||
StaticSliceRefcount(70), StaticSliceRefcount(71), |
||||
StaticSliceRefcount(72), StaticSliceRefcount(73), |
||||
StaticSliceRefcount(74), StaticSliceRefcount(75), |
||||
StaticSliceRefcount(76), |
||||
}; |
||||
|
||||
const StaticMetadataSlice |
||||
g_static_metadata_slice_table[GRPC_STATIC_MDSTR_COUNT] = { |
||||
|
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[0].base, 12, |
||||
g_static_metadata_bytes + 0), |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[1].base, 0, |
||||
g_static_metadata_bytes + 12), |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[2].base, 36, |
||||
g_static_metadata_bytes + 12), |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[3].base, 65, |
||||
g_static_metadata_bytes + 48), |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[4].base, 65, |
||||
g_static_metadata_bytes + 113), |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[5].base, 28, |
||||
g_static_metadata_bytes + 178), |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[6].base, 80, |
||||
g_static_metadata_bytes + 206), |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[7].base, 80, |
||||
g_static_metadata_bytes + 286), |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[8].base, 2, |
||||
g_static_metadata_bytes + 366), |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[9].base, 8, |
||||
g_static_metadata_bytes + 368), |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[10].base, 10, |
||||
g_static_metadata_bytes + 376), |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[11].base, 7, |
||||
g_static_metadata_bytes + 386), |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[12].base, 3, |
||||
g_static_metadata_bytes + 393), |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[13].base, 4, |
||||
g_static_metadata_bytes + 396), |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[14].base, 5, |
||||
g_static_metadata_bytes + 400), |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[15].base, 1, |
||||
g_static_metadata_bytes + 405), |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[16].base, 11, |
||||
g_static_metadata_bytes + 406), |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[17].base, 7, |
||||
g_static_metadata_bytes + 417), |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[18].base, 4, |
||||
g_static_metadata_bytes + 424), |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[19].base, 5, |
||||
g_static_metadata_bytes + 428), |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[20].base, 7, |
||||
g_static_metadata_bytes + 433), |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[21].base, 3, |
||||
g_static_metadata_bytes + 440), |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[22].base, 3, |
||||
g_static_metadata_bytes + 443), |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[23].base, 3, |
||||
g_static_metadata_bytes + 446), |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[24].base, 3, |
||||
g_static_metadata_bytes + 449), |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[25].base, 3, |
||||
g_static_metadata_bytes + 452), |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[26].base, 3, |
||||
g_static_metadata_bytes + 455), |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[27].base, 3, |
||||
g_static_metadata_bytes + 458), |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[28].base, 14, |
||||
g_static_metadata_bytes + 461), |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[29].base, 15, |
||||
g_static_metadata_bytes + 475), |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[30].base, 13, |
||||
g_static_metadata_bytes + 490), |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[31].base, 15, |
||||
g_static_metadata_bytes + 503), |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[32].base, 13, |
||||
g_static_metadata_bytes + 518), |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[33].base, 6, |
||||
g_static_metadata_bytes + 531), |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[34].base, 27, |
||||
g_static_metadata_bytes + 537), |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[35].base, 3, |
||||
g_static_metadata_bytes + 564), |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[36].base, 5, |
||||
g_static_metadata_bytes + 567), |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[37].base, 13, |
||||
g_static_metadata_bytes + 572), |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[38].base, 13, |
||||
g_static_metadata_bytes + 585), |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[39].base, 19, |
||||
g_static_metadata_bytes + 598), |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[40].base, 16, |
||||
g_static_metadata_bytes + 617), |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[41].base, 16, |
||||
g_static_metadata_bytes + 633), |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[42].base, 14, |
||||
g_static_metadata_bytes + 649), |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[43].base, 16, |
||||
g_static_metadata_bytes + 663), |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[44].base, 13, |
||||
g_static_metadata_bytes + 679), |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[45].base, 12, |
||||
g_static_metadata_bytes + 692), |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[46].base, 6, |
||||
g_static_metadata_bytes + 704), |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[47].base, 4, |
||||
g_static_metadata_bytes + 710), |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[48].base, 4, |
||||
g_static_metadata_bytes + 714), |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[49].base, 6, |
||||
g_static_metadata_bytes + 718), |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[50].base, 7, |
||||
g_static_metadata_bytes + 724), |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[51].base, 4, |
||||
g_static_metadata_bytes + 731), |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[52].base, 4, |
||||
g_static_metadata_bytes + 735), |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[53].base, 8, |
||||
g_static_metadata_bytes + 739), |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[54].base, 17, |
||||
g_static_metadata_bytes + 747), |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[55].base, 13, |
||||
g_static_metadata_bytes + 764), |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[56].base, 8, |
||||
g_static_metadata_bytes + 777), |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[57].base, 19, |
||||
g_static_metadata_bytes + 785), |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[58].base, 13, |
||||
g_static_metadata_bytes + 804), |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[59].base, 4, |
||||
g_static_metadata_bytes + 817), |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[60].base, 8, |
||||
g_static_metadata_bytes + 821), |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[61].base, 12, |
||||
g_static_metadata_bytes + 829), |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[62].base, 18, |
||||
g_static_metadata_bytes + 841), |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[63].base, 19, |
||||
g_static_metadata_bytes + 859), |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[64].base, 5, |
||||
g_static_metadata_bytes + 878), |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[65].base, 7, |
||||
g_static_metadata_bytes + 883), |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[66].base, 7, |
||||
g_static_metadata_bytes + 890), |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[67].base, 11, |
||||
g_static_metadata_bytes + 897), |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[68].base, 6, |
||||
g_static_metadata_bytes + 908), |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[69].base, 10, |
||||
g_static_metadata_bytes + 914), |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[70].base, 25, |
||||
g_static_metadata_bytes + 924), |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[71].base, 17, |
||||
g_static_metadata_bytes + 949), |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[72].base, 10, |
||||
g_static_metadata_bytes + 966), |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[73].base, 4, |
||||
g_static_metadata_bytes + 976), |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[74].base, 3, |
||||
g_static_metadata_bytes + 980), |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[75].base, 16, |
||||
g_static_metadata_bytes + 983), |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[76].base, 11, |
||||
g_static_metadata_bytes + 999), |
||||
}; |
||||
} // namespace grpc_core
|
||||
@ -1,246 +0,0 @@ |
||||
/*
|
||||
* Copyright 2015 gRPC authors. |
||||
* |
||||
* Licensed under the Apache License, Version 2.0 (the "License"); |
||||
* you may not use this file except in compliance with the License. |
||||
* You may obtain a copy of the License at |
||||
* |
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
* |
||||
* Unless required by applicable law or agreed to in writing, software |
||||
* distributed under the License is distributed on an "AS IS" BASIS, |
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
||||
* See the License for the specific language governing permissions and |
||||
* limitations under the License. |
||||
*/ |
||||
|
||||
/*
|
||||
* WARNING: Auto-generated code. |
||||
* |
||||
* To make changes to this file, change |
||||
* tools/codegen/core/gen_static_metadata.py, and then re-run it. |
||||
* |
||||
* See metadata.h for an explanation of the interface here, and metadata.cc for |
||||
* an explanation of what's going on. |
||||
*/ |
||||
|
||||
#ifndef GRPC_CORE_LIB_SLICE_STATIC_SLICE_H |
||||
#define GRPC_CORE_LIB_SLICE_STATIC_SLICE_H |
||||
|
||||
#include <grpc/support/port_platform.h> |
||||
|
||||
#include <cstdint> |
||||
#include <type_traits> |
||||
|
||||
#include "src/core/lib/slice/slice_refcount_base.h" |
||||
#include "src/core/lib/slice/slice_utils.h" |
||||
|
||||
static_assert( |
||||
std::is_trivially_destructible<grpc_core::StaticMetadataSlice>::value, |
||||
"StaticMetadataSlice must be trivially destructible."); |
||||
#define GRPC_STATIC_MDSTR_COUNT 77 |
||||
/* "grpc-timeout" */ |
||||
#define GRPC_MDSTR_GRPC_TIMEOUT (::grpc_core::g_static_metadata_slice_table[0]) |
||||
/* "" */ |
||||
#define GRPC_MDSTR_EMPTY (::grpc_core::g_static_metadata_slice_table[1]) |
||||
/* "/grpc.lb.v1.LoadBalancer/BalanceLoad" */ |
||||
#define GRPC_MDSTR_SLASH_GRPC_DOT_LB_DOT_V1_DOT_LOADBALANCER_SLASH_BALANCELOAD \ |
||||
(::grpc_core::g_static_metadata_slice_table[2]) |
||||
/* "/envoy.service.load_stats.v2.LoadReportingService/StreamLoadStats" */ |
||||
#define GRPC_MDSTR_SLASH_ENVOY_DOT_SERVICE_DOT_LOAD_STATS_DOT_V2_DOT_LOADREPORTINGSERVICE_SLASH_STREAMLOADSTATS \ |
||||
(::grpc_core::g_static_metadata_slice_table[3]) |
||||
/* "/envoy.service.load_stats.v3.LoadReportingService/StreamLoadStats" */ |
||||
#define GRPC_MDSTR_SLASH_ENVOY_DOT_SERVICE_DOT_LOAD_STATS_DOT_V3_DOT_LOADREPORTINGSERVICE_SLASH_STREAMLOADSTATS \ |
||||
(::grpc_core::g_static_metadata_slice_table[4]) |
||||
/* "/grpc.health.v1.Health/Watch" */ |
||||
#define GRPC_MDSTR_SLASH_GRPC_DOT_HEALTH_DOT_V1_DOT_HEALTH_SLASH_WATCH \ |
||||
(::grpc_core::g_static_metadata_slice_table[5]) |
||||
/* "/envoy.service.discovery.v2.AggregatedDiscoveryService/StreamAggregatedResources"
|
||||
*/ |
||||
#define GRPC_MDSTR_SLASH_ENVOY_DOT_SERVICE_DOT_DISCOVERY_DOT_V2_DOT_AGGREGATEDDISCOVERYSERVICE_SLASH_STREAMAGGREGATEDRESOURCES \ |
||||
(::grpc_core::g_static_metadata_slice_table[6]) |
||||
/* "/envoy.service.discovery.v3.AggregatedDiscoveryService/StreamAggregatedResources"
|
||||
*/ |
||||
#define GRPC_MDSTR_SLASH_ENVOY_DOT_SERVICE_DOT_DISCOVERY_DOT_V3_DOT_AGGREGATEDDISCOVERYSERVICE_SLASH_STREAMAGGREGATEDRESOURCES \ |
||||
(::grpc_core::g_static_metadata_slice_table[7]) |
||||
/* "te" */ |
||||
#define GRPC_MDSTR_TE (::grpc_core::g_static_metadata_slice_table[8]) |
||||
/* "trailers" */ |
||||
#define GRPC_MDSTR_TRAILERS (::grpc_core::g_static_metadata_slice_table[9]) |
||||
/* ":authority" */ |
||||
#define GRPC_MDSTR_AUTHORITY (::grpc_core::g_static_metadata_slice_table[10]) |
||||
/* ":method" */ |
||||
#define GRPC_MDSTR_METHOD (::grpc_core::g_static_metadata_slice_table[11]) |
||||
/* "GET" */ |
||||
#define GRPC_MDSTR_GET (::grpc_core::g_static_metadata_slice_table[12]) |
||||
/* "POST" */ |
||||
#define GRPC_MDSTR_POST (::grpc_core::g_static_metadata_slice_table[13]) |
||||
/* ":path" */ |
||||
#define GRPC_MDSTR_PATH (::grpc_core::g_static_metadata_slice_table[14]) |
||||
/* "/" */ |
||||
#define GRPC_MDSTR_SLASH (::grpc_core::g_static_metadata_slice_table[15]) |
||||
/* "/index.html" */ |
||||
#define GRPC_MDSTR_SLASH_INDEX_DOT_HTML \ |
||||
(::grpc_core::g_static_metadata_slice_table[16]) |
||||
/* ":scheme" */ |
||||
#define GRPC_MDSTR_SCHEME (::grpc_core::g_static_metadata_slice_table[17]) |
||||
/* "http" */ |
||||
#define GRPC_MDSTR_HTTP (::grpc_core::g_static_metadata_slice_table[18]) |
||||
/* "https" */ |
||||
#define GRPC_MDSTR_HTTPS (::grpc_core::g_static_metadata_slice_table[19]) |
||||
/* ":status" */ |
||||
#define GRPC_MDSTR_STATUS (::grpc_core::g_static_metadata_slice_table[20]) |
||||
/* "200" */ |
||||
#define GRPC_MDSTR_200 (::grpc_core::g_static_metadata_slice_table[21]) |
||||
/* "204" */ |
||||
#define GRPC_MDSTR_204 (::grpc_core::g_static_metadata_slice_table[22]) |
||||
/* "206" */ |
||||
#define GRPC_MDSTR_206 (::grpc_core::g_static_metadata_slice_table[23]) |
||||
/* "304" */ |
||||
#define GRPC_MDSTR_304 (::grpc_core::g_static_metadata_slice_table[24]) |
||||
/* "400" */ |
||||
#define GRPC_MDSTR_400 (::grpc_core::g_static_metadata_slice_table[25]) |
||||
/* "404" */ |
||||
#define GRPC_MDSTR_404 (::grpc_core::g_static_metadata_slice_table[26]) |
||||
/* "500" */ |
||||
#define GRPC_MDSTR_500 (::grpc_core::g_static_metadata_slice_table[27]) |
||||
/* "accept-charset" */ |
||||
#define GRPC_MDSTR_ACCEPT_CHARSET \ |
||||
(::grpc_core::g_static_metadata_slice_table[28]) |
||||
/* "accept-encoding" */ |
||||
#define GRPC_MDSTR_ACCEPT_ENCODING \ |
||||
(::grpc_core::g_static_metadata_slice_table[29]) |
||||
/* "gzip, deflate" */ |
||||
#define GRPC_MDSTR_GZIP_COMMA_DEFLATE \ |
||||
(::grpc_core::g_static_metadata_slice_table[30]) |
||||
/* "accept-language" */ |
||||
#define GRPC_MDSTR_ACCEPT_LANGUAGE \ |
||||
(::grpc_core::g_static_metadata_slice_table[31]) |
||||
/* "accept-ranges" */ |
||||
#define GRPC_MDSTR_ACCEPT_RANGES \ |
||||
(::grpc_core::g_static_metadata_slice_table[32]) |
||||
/* "accept" */ |
||||
#define GRPC_MDSTR_ACCEPT (::grpc_core::g_static_metadata_slice_table[33]) |
||||
/* "access-control-allow-origin" */ |
||||
#define GRPC_MDSTR_ACCESS_CONTROL_ALLOW_ORIGIN \ |
||||
(::grpc_core::g_static_metadata_slice_table[34]) |
||||
/* "age" */ |
||||
#define GRPC_MDSTR_AGE (::grpc_core::g_static_metadata_slice_table[35]) |
||||
/* "allow" */ |
||||
#define GRPC_MDSTR_ALLOW (::grpc_core::g_static_metadata_slice_table[36]) |
||||
/* "authorization" */ |
||||
#define GRPC_MDSTR_AUTHORIZATION \ |
||||
(::grpc_core::g_static_metadata_slice_table[37]) |
||||
/* "cache-control" */ |
||||
#define GRPC_MDSTR_CACHE_CONTROL \ |
||||
(::grpc_core::g_static_metadata_slice_table[38]) |
||||
/* "content-disposition" */ |
||||
#define GRPC_MDSTR_CONTENT_DISPOSITION \ |
||||
(::grpc_core::g_static_metadata_slice_table[39]) |
||||
/* "content-encoding" */ |
||||
#define GRPC_MDSTR_CONTENT_ENCODING \ |
||||
(::grpc_core::g_static_metadata_slice_table[40]) |
||||
/* "content-language" */ |
||||
#define GRPC_MDSTR_CONTENT_LANGUAGE \ |
||||
(::grpc_core::g_static_metadata_slice_table[41]) |
||||
/* "content-length" */ |
||||
#define GRPC_MDSTR_CONTENT_LENGTH \ |
||||
(::grpc_core::g_static_metadata_slice_table[42]) |
||||
/* "content-location" */ |
||||
#define GRPC_MDSTR_CONTENT_LOCATION \ |
||||
(::grpc_core::g_static_metadata_slice_table[43]) |
||||
/* "content-range" */ |
||||
#define GRPC_MDSTR_CONTENT_RANGE \ |
||||
(::grpc_core::g_static_metadata_slice_table[44]) |
||||
/* "content-type" */ |
||||
#define GRPC_MDSTR_CONTENT_TYPE (::grpc_core::g_static_metadata_slice_table[45]) |
||||
/* "cookie" */ |
||||
#define GRPC_MDSTR_COOKIE (::grpc_core::g_static_metadata_slice_table[46]) |
||||
/* "date" */ |
||||
#define GRPC_MDSTR_DATE (::grpc_core::g_static_metadata_slice_table[47]) |
||||
/* "etag" */ |
||||
#define GRPC_MDSTR_ETAG (::grpc_core::g_static_metadata_slice_table[48]) |
||||
/* "expect" */ |
||||
#define GRPC_MDSTR_EXPECT (::grpc_core::g_static_metadata_slice_table[49]) |
||||
/* "expires" */ |
||||
#define GRPC_MDSTR_EXPIRES (::grpc_core::g_static_metadata_slice_table[50]) |
||||
/* "from" */ |
||||
#define GRPC_MDSTR_FROM (::grpc_core::g_static_metadata_slice_table[51]) |
||||
/* "host" */ |
||||
#define GRPC_MDSTR_HOST (::grpc_core::g_static_metadata_slice_table[52]) |
||||
/* "if-match" */ |
||||
#define GRPC_MDSTR_IF_MATCH (::grpc_core::g_static_metadata_slice_table[53]) |
||||
/* "if-modified-since" */ |
||||
#define GRPC_MDSTR_IF_MODIFIED_SINCE \ |
||||
(::grpc_core::g_static_metadata_slice_table[54]) |
||||
/* "if-none-match" */ |
||||
#define GRPC_MDSTR_IF_NONE_MATCH \ |
||||
(::grpc_core::g_static_metadata_slice_table[55]) |
||||
/* "if-range" */ |
||||
#define GRPC_MDSTR_IF_RANGE (::grpc_core::g_static_metadata_slice_table[56]) |
||||
/* "if-unmodified-since" */ |
||||
#define GRPC_MDSTR_IF_UNMODIFIED_SINCE \ |
||||
(::grpc_core::g_static_metadata_slice_table[57]) |
||||
/* "last-modified" */ |
||||
#define GRPC_MDSTR_LAST_MODIFIED \ |
||||
(::grpc_core::g_static_metadata_slice_table[58]) |
||||
/* "link" */ |
||||
#define GRPC_MDSTR_LINK (::grpc_core::g_static_metadata_slice_table[59]) |
||||
/* "location" */ |
||||
#define GRPC_MDSTR_LOCATION (::grpc_core::g_static_metadata_slice_table[60]) |
||||
/* "max-forwards" */ |
||||
#define GRPC_MDSTR_MAX_FORWARDS (::grpc_core::g_static_metadata_slice_table[61]) |
||||
/* "proxy-authenticate" */ |
||||
#define GRPC_MDSTR_PROXY_AUTHENTICATE \ |
||||
(::grpc_core::g_static_metadata_slice_table[62]) |
||||
/* "proxy-authorization" */ |
||||
#define GRPC_MDSTR_PROXY_AUTHORIZATION \ |
||||
(::grpc_core::g_static_metadata_slice_table[63]) |
||||
/* "range" */ |
||||
#define GRPC_MDSTR_RANGE (::grpc_core::g_static_metadata_slice_table[64]) |
||||
/* "referer" */ |
||||
#define GRPC_MDSTR_REFERER (::grpc_core::g_static_metadata_slice_table[65]) |
||||
/* "refresh" */ |
||||
#define GRPC_MDSTR_REFRESH (::grpc_core::g_static_metadata_slice_table[66]) |
||||
/* "retry-after" */ |
||||
#define GRPC_MDSTR_RETRY_AFTER (::grpc_core::g_static_metadata_slice_table[67]) |
||||
/* "server" */ |
||||
#define GRPC_MDSTR_SERVER (::grpc_core::g_static_metadata_slice_table[68]) |
||||
/* "set-cookie" */ |
||||
#define GRPC_MDSTR_SET_COOKIE (::grpc_core::g_static_metadata_slice_table[69]) |
||||
/* "strict-transport-security" */ |
||||
#define GRPC_MDSTR_STRICT_TRANSPORT_SECURITY \ |
||||
(::grpc_core::g_static_metadata_slice_table[70]) |
||||
/* "transfer-encoding" */ |
||||
#define GRPC_MDSTR_TRANSFER_ENCODING \ |
||||
(::grpc_core::g_static_metadata_slice_table[71]) |
||||
/* "user-agent" */ |
||||
#define GRPC_MDSTR_USER_AGENT (::grpc_core::g_static_metadata_slice_table[72]) |
||||
/* "vary" */ |
||||
#define GRPC_MDSTR_VARY (::grpc_core::g_static_metadata_slice_table[73]) |
||||
/* "via" */ |
||||
#define GRPC_MDSTR_VIA (::grpc_core::g_static_metadata_slice_table[74]) |
||||
/* "www-authenticate" */ |
||||
#define GRPC_MDSTR_WWW_AUTHENTICATE \ |
||||
(::grpc_core::g_static_metadata_slice_table[75]) |
||||
/* "lb-cost-bin" */ |
||||
#define GRPC_MDSTR_LB_COST_BIN (::grpc_core::g_static_metadata_slice_table[76]) |
||||
|
||||
namespace grpc_core { |
||||
extern StaticSliceRefcount |
||||
g_static_metadata_slice_refcounts[GRPC_STATIC_MDSTR_COUNT]; |
||||
extern const StaticMetadataSlice |
||||
g_static_metadata_slice_table[GRPC_STATIC_MDSTR_COUNT]; |
||||
extern const uint8_t g_static_metadata_bytes[]; |
||||
} // namespace grpc_core
|
||||
|
||||
#define GRPC_IS_STATIC_METADATA_STRING(slice) \ |
||||
((slice).refcount != NULL && \
|
||||
(slice).refcount->GetType() == grpc_slice_refcount::Type::STATIC) |
||||
|
||||
#define GRPC_STATIC_METADATA_INDEX(static_slice) \ |
||||
(reinterpret_cast<::grpc_core::StaticSliceRefcount*>( \
|
||||
(static_slice).refcount) \
|
||||
->index) |
||||
|
||||
#endif /* GRPC_CORE_LIB_SLICE_STATIC_SLICE_H */ |
||||
@ -1,714 +0,0 @@ |
||||
/*
|
||||
* |
||||
* Copyright 2015 gRPC authors. |
||||
* |
||||
* Licensed under the Apache License, Version 2.0 (the "License"); |
||||
* you may not use this file except in compliance with the License. |
||||
* You may obtain a copy of the License at |
||||
* |
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
* |
||||
* Unless required by applicable law or agreed to in writing, software |
||||
* distributed under the License is distributed on an "AS IS" BASIS, |
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
||||
* See the License for the specific language governing permissions and |
||||
* limitations under the License. |
||||
* |
||||
*/ |
||||
|
||||
#include <grpc/support/port_platform.h> |
||||
|
||||
#include "src/core/lib/transport/metadata.h" |
||||
|
||||
#include <assert.h> |
||||
#include <inttypes.h> |
||||
#include <stddef.h> |
||||
#include <string.h> |
||||
|
||||
#include <grpc/compression.h> |
||||
#include <grpc/grpc.h> |
||||
#include <grpc/support/alloc.h> |
||||
#include <grpc/support/atm.h> |
||||
#include <grpc/support/log.h> |
||||
#include <grpc/support/string_util.h> |
||||
#include <grpc/support/time.h> |
||||
|
||||
#include "src/core/lib/gpr/murmur_hash.h" |
||||
#include "src/core/lib/gpr/string.h" |
||||
#include "src/core/lib/iomgr/iomgr_internal.h" |
||||
#include "src/core/lib/profiling/timers.h" |
||||
#include "src/core/lib/slice/slice_internal.h" |
||||
#include "src/core/lib/slice/slice_string_helpers.h" |
||||
#include "src/core/lib/transport/static_metadata.h" |
||||
|
||||
using grpc_core::AllocatedMetadata; |
||||
using grpc_core::InternedMetadata; |
||||
using grpc_core::StaticMetadata; |
||||
using grpc_core::UserData; |
||||
|
||||
/* There are two kinds of mdelem and mdstr instances.
|
||||
* Static instances are declared in static_metadata.{h,c} and |
||||
* are initialized by grpc_mdctx_global_init(). |
||||
* Dynamic instances are stored in hash tables on grpc_mdctx, and are backed |
||||
* by internal_string and internal_element structures. |
||||
* Internal helper functions here-in (is_mdstr_static, is_mdelem_static) are |
||||
* used to determine which kind of element a pointer refers to. |
||||
*/ |
||||
|
||||
grpc_core::DebugOnlyTraceFlag grpc_trace_metadata(false, "metadata"); |
||||
|
||||
#ifndef NDEBUG |
||||
#define DEBUG_ARGS , const char *file, int line |
||||
#define FWD_DEBUG_ARGS file, line |
||||
|
||||
void grpc_mdelem_trace_ref(void* md, const grpc_slice& key, |
||||
const grpc_slice& value, intptr_t refcnt, |
||||
const char* file, int line) { |
||||
if (grpc_trace_metadata.enabled()) { |
||||
char* key_str = grpc_slice_to_c_string(key); |
||||
char* value_str = grpc_slice_to_c_string(value); |
||||
gpr_log(file, line, GPR_LOG_SEVERITY_DEBUG, |
||||
"mdelem REF:%p:%" PRIdPTR "->%" PRIdPTR ": '%s' = '%s'", md, |
||||
refcnt, refcnt + 1, key_str, value_str); |
||||
gpr_free(key_str); |
||||
gpr_free(value_str); |
||||
} |
||||
} |
||||
|
||||
void grpc_mdelem_trace_unref(void* md, const grpc_slice& key, |
||||
const grpc_slice& value, intptr_t refcnt, |
||||
const char* file, int line) { |
||||
if (grpc_trace_metadata.enabled()) { |
||||
char* key_str = grpc_slice_to_c_string(key); |
||||
char* value_str = grpc_slice_to_c_string(value); |
||||
gpr_log(file, line, GPR_LOG_SEVERITY_DEBUG, |
||||
"mdelem UNREF:%p:%" PRIdPTR "->%" PRIdPTR ": '%s' = '%s'", md, |
||||
refcnt, refcnt - 1, key_str, value_str); |
||||
gpr_free(key_str); |
||||
gpr_free(value_str); |
||||
} |
||||
} |
||||
|
||||
#else // ifndef NDEBUG
|
||||
#define DEBUG_ARGS |
||||
#define FWD_DEBUG_ARGS |
||||
#endif // ifndef NDEBUG
|
||||
|
||||
#define INITIAL_SHARD_CAPACITY 8 |
||||
#define LOG2_SHARD_COUNT 4 |
||||
#define SHARD_COUNT ((size_t)(1 << LOG2_SHARD_COUNT)) |
||||
|
||||
#define TABLE_IDX(hash, capacity) (((hash) >> (LOG2_SHARD_COUNT)) % (capacity)) |
||||
#define SHARD_IDX(hash) ((hash) & ((1 << (LOG2_SHARD_COUNT)) - 1)) |
||||
|
||||
void StaticMetadata::HashInit() { |
||||
uint32_t k_hash = grpc_slice_hash_internal(kv_.key); |
||||
uint32_t v_hash = grpc_slice_hash_internal(kv_.value); |
||||
hash_ = GRPC_MDSTR_KV_HASH(k_hash, v_hash); |
||||
} |
||||
|
||||
AllocatedMetadata::AllocatedMetadata(const grpc_slice& key, |
||||
const grpc_slice& value) |
||||
: RefcountedMdBase(grpc_slice_ref_internal(key), |
||||
grpc_slice_ref_internal(value)) { |
||||
#ifndef NDEBUG |
||||
TraceAtStart("ALLOC_MD"); |
||||
#endif |
||||
} |
||||
|
||||
AllocatedMetadata::AllocatedMetadata(const grpc_slice& key, |
||||
const grpc_slice& value, const NoRefKey*) |
||||
: RefcountedMdBase(key, grpc_slice_ref_internal(value)) { |
||||
#ifndef NDEBUG |
||||
TraceAtStart("ALLOC_MD_NOREF_KEY"); |
||||
#endif |
||||
} |
||||
|
||||
AllocatedMetadata::AllocatedMetadata( |
||||
const grpc_core::ManagedMemorySlice& key, |
||||
const grpc_core::UnmanagedMemorySlice& value) |
||||
: RefcountedMdBase(key, value) { |
||||
#ifndef NDEBUG |
||||
TraceAtStart("ALLOC_MD_NOREF_KEY_VAL"); |
||||
#endif |
||||
} |
||||
|
||||
AllocatedMetadata::AllocatedMetadata( |
||||
const grpc_core::ExternallyManagedSlice& key, |
||||
const grpc_core::UnmanagedMemorySlice& value) |
||||
: RefcountedMdBase(key, value) { |
||||
#ifndef NDEBUG |
||||
TraceAtStart("ALLOC_MD_NOREF_KEY_VAL"); |
||||
#endif |
||||
} |
||||
|
||||
AllocatedMetadata::~AllocatedMetadata() { |
||||
grpc_slice_unref_internal(key()); |
||||
grpc_slice_unref_internal(value()); |
||||
void* user_data = user_data_.data.load(std::memory_order_relaxed); |
||||
if (user_data) { |
||||
destroy_user_data_func destroy_user_data = |
||||
user_data_.destroy_user_data.load(std::memory_order_relaxed); |
||||
destroy_user_data(user_data); |
||||
} |
||||
} |
||||
|
||||
#ifndef NDEBUG |
||||
void grpc_core::RefcountedMdBase::TraceAtStart(const char* tag) { |
||||
if (grpc_trace_metadata.enabled()) { |
||||
char* key_str = grpc_slice_to_c_string(key()); |
||||
char* value_str = grpc_slice_to_c_string(value()); |
||||
gpr_log(GPR_DEBUG, "mdelem %s:%p:%" PRIdPTR ": '%s' = '%s'", tag, this, |
||||
RefValue(), key_str, value_str); |
||||
gpr_free(key_str); |
||||
gpr_free(value_str); |
||||
} |
||||
} |
||||
#endif |
||||
|
||||
InternedMetadata::InternedMetadata(const grpc_slice& key, |
||||
const grpc_slice& value, uint32_t hash, |
||||
InternedMetadata* next) |
||||
: RefcountedMdBase(grpc_slice_ref_internal(key), |
||||
grpc_slice_ref_internal(value), hash), |
||||
link_(next) { |
||||
#ifndef NDEBUG |
||||
TraceAtStart("INTERNED_MD"); |
||||
#endif |
||||
} |
||||
|
||||
InternedMetadata::InternedMetadata(const grpc_slice& key, |
||||
const grpc_slice& value, uint32_t hash, |
||||
InternedMetadata* next, const NoRefKey*) |
||||
: RefcountedMdBase(key, grpc_slice_ref_internal(value), hash), link_(next) { |
||||
#ifndef NDEBUG |
||||
TraceAtStart("INTERNED_MD_NOREF_KEY"); |
||||
#endif |
||||
} |
||||
|
||||
InternedMetadata::~InternedMetadata() { |
||||
grpc_slice_unref_internal(key()); |
||||
grpc_slice_unref_internal(value()); |
||||
void* user_data = user_data_.data.load(std::memory_order_relaxed); |
||||
if (user_data) { |
||||
destroy_user_data_func destroy_user_data = |
||||
user_data_.destroy_user_data.load(std::memory_order_relaxed); |
||||
destroy_user_data(user_data); |
||||
} |
||||
} |
||||
|
||||
size_t InternedMetadata::CleanupLinkedMetadata( |
||||
InternedMetadata::BucketLink* head) { |
||||
size_t num_freed = 0; |
||||
InternedMetadata::BucketLink* prev_next = head; |
||||
InternedMetadata *md, *next; |
||||
|
||||
for (md = head->next; md; md = next) { |
||||
next = md->link_.next; |
||||
if (md->AllRefsDropped()) { |
||||
prev_next->next = next; |
||||
delete md; |
||||
num_freed++; |
||||
} else { |
||||
prev_next = &md->link_; |
||||
} |
||||
} |
||||
return num_freed; |
||||
} |
||||
|
||||
typedef struct mdtab_shard { |
||||
gpr_mu mu; |
||||
InternedMetadata::BucketLink* elems; |
||||
size_t count; |
||||
size_t capacity; |
||||
/** Estimate of the number of unreferenced mdelems in the hash table.
|
||||
This will eventually converge to the exact number, but it's instantaneous |
||||
accuracy is not guaranteed */ |
||||
gpr_atm free_estimate; |
||||
} mdtab_shard; |
||||
|
||||
static mdtab_shard g_shards[SHARD_COUNT]; |
||||
|
||||
static void gc_mdtab(mdtab_shard* shard); |
||||
|
||||
void grpc_mdctx_global_init(void) { |
||||
/* initialize shards */ |
||||
for (size_t i = 0; i < SHARD_COUNT; i++) { |
||||
mdtab_shard* shard = &g_shards[i]; |
||||
gpr_mu_init(&shard->mu); |
||||
shard->count = 0; |
||||
gpr_atm_no_barrier_store(&shard->free_estimate, 0); |
||||
shard->capacity = INITIAL_SHARD_CAPACITY; |
||||
shard->elems = static_cast<InternedMetadata::BucketLink*>( |
||||
gpr_zalloc(sizeof(*shard->elems) * shard->capacity)); |
||||
} |
||||
} |
||||
|
||||
void grpc_mdctx_global_shutdown() { |
||||
for (size_t i = 0; i < SHARD_COUNT; i++) { |
||||
mdtab_shard* shard = &g_shards[i]; |
||||
gpr_mu_destroy(&shard->mu); |
||||
gc_mdtab(shard); |
||||
if (shard->count != 0) { |
||||
gpr_log(GPR_ERROR, "WARNING: %" PRIuPTR " metadata elements were leaked", |
||||
shard->count); |
||||
for (size_t i = 0; i < shard->capacity; i++) { |
||||
for (InternedMetadata* md = shard->elems[i].next; md; |
||||
md = md->bucket_next()) { |
||||
char* key_str = grpc_slice_to_c_string(md->key()); |
||||
char* value_str = grpc_slice_to_c_string(md->value()); |
||||
gpr_log(GPR_ERROR, "mdelem '%s' = '%s'", key_str, value_str); |
||||
gpr_free(key_str); |
||||
gpr_free(value_str); |
||||
} |
||||
} |
||||
if (grpc_iomgr_abort_on_leaks()) { |
||||
abort(); |
||||
} |
||||
} |
||||
// For ASAN builds, we don't want to crash here, because that will
|
||||
// prevent ASAN from providing leak detection information, which is
|
||||
// far more useful than this simple assertion.
|
||||
#ifndef GRPC_ASAN_ENABLED |
||||
GPR_DEBUG_ASSERT(shard->count == 0); |
||||
#endif |
||||
gpr_free(shard->elems); |
||||
} |
||||
} |
||||
|
||||
#ifndef NDEBUG |
||||
static int is_mdelem_static(grpc_mdelem e) { |
||||
return reinterpret_cast<grpc_core::StaticMetadata*>(GRPC_MDELEM_DATA(e)) >= |
||||
&grpc_core::g_static_mdelem_table[0] && |
||||
reinterpret_cast<grpc_core::StaticMetadata*>(GRPC_MDELEM_DATA(e)) < |
||||
&grpc_core::g_static_mdelem_table[GRPC_STATIC_MDELEM_COUNT]; |
||||
} |
||||
#endif |
||||
|
||||
void InternedMetadata::RefWithShardLocked(mdtab_shard* shard) { |
||||
#ifndef NDEBUG |
||||
if (grpc_trace_metadata.enabled()) { |
||||
char* key_str = grpc_slice_to_c_string(key()); |
||||
char* value_str = grpc_slice_to_c_string(value()); |
||||
intptr_t value = RefValue(); |
||||
gpr_log(__FILE__, __LINE__, GPR_LOG_SEVERITY_DEBUG, |
||||
"mdelem REF:%p:%" PRIdPTR "->%" PRIdPTR ": '%s' = '%s'", this, |
||||
value, value + 1, key_str, value_str); |
||||
gpr_free(key_str); |
||||
gpr_free(value_str); |
||||
} |
||||
#endif |
||||
if (FirstRef()) { |
||||
gpr_atm_no_barrier_fetch_add(&shard->free_estimate, -1); |
||||
} |
||||
} |
||||
|
||||
static void gc_mdtab(mdtab_shard* shard) { |
||||
GPR_TIMER_SCOPE("gc_mdtab", 0); |
||||
size_t num_freed = 0; |
||||
for (size_t i = 0; i < shard->capacity; ++i) { |
||||
intptr_t freed = InternedMetadata::CleanupLinkedMetadata(&shard->elems[i]); |
||||
num_freed += freed; |
||||
shard->count -= freed; |
||||
} |
||||
gpr_atm_no_barrier_fetch_add(&shard->free_estimate, |
||||
-static_cast<intptr_t>(num_freed)); |
||||
} |
||||
|
||||
static void grow_mdtab(mdtab_shard* shard) { |
||||
GPR_TIMER_SCOPE("grow_mdtab", 0); |
||||
|
||||
size_t capacity = shard->capacity * 2; |
||||
size_t i; |
||||
InternedMetadata::BucketLink* mdtab; |
||||
InternedMetadata *md, *next; |
||||
uint32_t hash; |
||||
|
||||
mdtab = static_cast<InternedMetadata::BucketLink*>( |
||||
gpr_zalloc(sizeof(InternedMetadata::BucketLink) * capacity)); |
||||
|
||||
for (i = 0; i < shard->capacity; i++) { |
||||
for (md = shard->elems[i].next; md; md = next) { |
||||
size_t idx; |
||||
hash = md->hash(); |
||||
next = md->bucket_next(); |
||||
idx = TABLE_IDX(hash, capacity); |
||||
md->set_bucket_next(mdtab[idx].next); |
||||
mdtab[idx].next = md; |
||||
} |
||||
} |
||||
gpr_free(shard->elems); |
||||
shard->elems = mdtab; |
||||
shard->capacity = capacity; |
||||
} |
||||
|
||||
static void rehash_mdtab(mdtab_shard* shard) { |
||||
if (gpr_atm_no_barrier_load(&shard->free_estimate) > |
||||
static_cast<gpr_atm>(shard->capacity / 4)) { |
||||
gc_mdtab(shard); |
||||
} else { |
||||
grow_mdtab(shard); |
||||
} |
||||
} |
||||
|
||||
template <bool key_definitely_static, bool value_definitely_static = false> |
||||
static grpc_mdelem md_create_maybe_static(const grpc_slice& key, |
||||
const grpc_slice& value); |
||||
template <bool key_definitely_static> |
||||
static grpc_mdelem md_create_must_intern(const grpc_slice& key, |
||||
const grpc_slice& value, |
||||
uint32_t hash); |
||||
|
||||
template <bool key_definitely_static, bool value_definitely_static = false> |
||||
static grpc_mdelem md_create( |
||||
const grpc_slice& key, const grpc_slice& value, |
||||
grpc_mdelem_data* compatible_external_backing_store) { |
||||
// Ensure slices are, in fact, static if we claimed they were.
|
||||
GPR_DEBUG_ASSERT(!key_definitely_static || |
||||
GRPC_IS_STATIC_METADATA_STRING(key)); |
||||
GPR_DEBUG_ASSERT(!value_definitely_static || |
||||
GRPC_IS_STATIC_METADATA_STRING(value)); |
||||
const bool key_is_interned = |
||||
key_definitely_static || grpc_slice_is_interned(key); |
||||
const bool value_is_interned = |
||||
value_definitely_static || grpc_slice_is_interned(value); |
||||
// External storage if either slice is not interned and the caller already
|
||||
// created a backing store. If no backing store, we allocate one.
|
||||
if (!key_is_interned || !value_is_interned) { |
||||
if (compatible_external_backing_store != nullptr) { |
||||
// Caller provided backing store.
|
||||
return GRPC_MAKE_MDELEM(compatible_external_backing_store, |
||||
GRPC_MDELEM_STORAGE_EXTERNAL); |
||||
} else { |
||||
// We allocate backing store.
|
||||
return key_definitely_static |
||||
? GRPC_MAKE_MDELEM( |
||||
new AllocatedMetadata( |
||||
key, value, |
||||
static_cast<const AllocatedMetadata::NoRefKey*>( |
||||
nullptr)), |
||||
GRPC_MDELEM_STORAGE_ALLOCATED) |
||||
: GRPC_MAKE_MDELEM(new AllocatedMetadata(key, value), |
||||
GRPC_MDELEM_STORAGE_ALLOCATED); |
||||
} |
||||
} |
||||
return md_create_maybe_static<key_definitely_static, value_definitely_static>( |
||||
key, value); |
||||
} |
||||
|
||||
template <bool key_definitely_static, bool value_definitely_static> |
||||
static grpc_mdelem md_create_maybe_static(const grpc_slice& key, |
||||
const grpc_slice& value) { |
||||
// Ensure slices are, in fact, static if we claimed they were.
|
||||
GPR_DEBUG_ASSERT(!key_definitely_static || |
||||
GRPC_IS_STATIC_METADATA_STRING(key)); |
||||
GPR_DEBUG_ASSERT(!value_definitely_static || |
||||
GRPC_IS_STATIC_METADATA_STRING(value)); |
||||
GPR_DEBUG_ASSERT(key.refcount != nullptr); |
||||
GPR_DEBUG_ASSERT(value.refcount != nullptr); |
||||
|
||||
const bool key_is_static_mdstr = |
||||
key_definitely_static || |
||||
key.refcount->GetType() == grpc_slice_refcount::Type::STATIC; |
||||
const bool value_is_static_mdstr = |
||||
value_definitely_static || |
||||
value.refcount->GetType() == grpc_slice_refcount::Type::STATIC; |
||||
|
||||
const intptr_t kidx = GRPC_STATIC_METADATA_INDEX(key); |
||||
|
||||
// Not all static slice input yields a statically stored metadata element.
|
||||
if (key_is_static_mdstr && value_is_static_mdstr) { |
||||
grpc_mdelem static_elem = grpc_static_mdelem_for_static_strings( |
||||
kidx, GRPC_STATIC_METADATA_INDEX(value)); |
||||
if (!GRPC_MDISNULL(static_elem)) { |
||||
return static_elem; |
||||
} |
||||
} |
||||
|
||||
uint32_t khash = key_definitely_static |
||||
? grpc_static_metadata_hash_values[kidx] |
||||
: grpc_slice_hash_refcounted(key); |
||||
|
||||
uint32_t hash = GRPC_MDSTR_KV_HASH(khash, grpc_slice_hash_refcounted(value)); |
||||
return md_create_must_intern<key_definitely_static>(key, value, hash); |
||||
} |
||||
|
||||
template <bool key_definitely_static> |
||||
static grpc_mdelem md_create_must_intern(const grpc_slice& key, |
||||
const grpc_slice& value, |
||||
uint32_t hash) { |
||||
// Here, we know both key and value are both at least interned, and both
|
||||
// possibly static. We know that anything inside the shared interned table is
|
||||
// also at least interned (and maybe static). Note that equality for a static
|
||||
// and interned slice implies that they are both the same exact slice.
|
||||
// The same applies to a pair of interned slices, or a pair of static slices.
|
||||
// Rather than run the full equality check, we can therefore just do a pointer
|
||||
// comparison of the refcounts.
|
||||
InternedMetadata* md; |
||||
mdtab_shard* shard = &g_shards[SHARD_IDX(hash)]; |
||||
size_t idx; |
||||
|
||||
GPR_TIMER_SCOPE("grpc_mdelem_from_metadata_strings", 0); |
||||
|
||||
gpr_mu_lock(&shard->mu); |
||||
|
||||
idx = TABLE_IDX(hash, shard->capacity); |
||||
/* search for an existing pair */ |
||||
for (md = shard->elems[idx].next; md; md = md->bucket_next()) { |
||||
if (grpc_slice_static_interned_equal(key, md->key()) && |
||||
grpc_slice_static_interned_equal(value, md->value())) { |
||||
md->RefWithShardLocked(shard); |
||||
gpr_mu_unlock(&shard->mu); |
||||
return GRPC_MAKE_MDELEM(md, GRPC_MDELEM_STORAGE_INTERNED); |
||||
} |
||||
} |
||||
|
||||
/* not found: create a new pair */ |
||||
md = key_definitely_static |
||||
? new InternedMetadata( |
||||
key, value, hash, shard->elems[idx].next, |
||||
static_cast<const InternedMetadata::NoRefKey*>(nullptr)) |
||||
: new InternedMetadata(key, value, hash, shard->elems[idx].next); |
||||
shard->elems[idx].next = md; |
||||
shard->count++; |
||||
|
||||
if (shard->count > shard->capacity * 2) { |
||||
rehash_mdtab(shard); |
||||
} |
||||
|
||||
gpr_mu_unlock(&shard->mu); |
||||
|
||||
return GRPC_MAKE_MDELEM(md, GRPC_MDELEM_STORAGE_INTERNED); |
||||
} |
||||
|
||||
grpc_mdelem grpc_mdelem_create( |
||||
const grpc_slice& key, const grpc_slice& value, |
||||
grpc_mdelem_data* compatible_external_backing_store) { |
||||
return md_create<false>(key, value, compatible_external_backing_store); |
||||
} |
||||
|
||||
grpc_mdelem grpc_mdelem_create( |
||||
const grpc_core::StaticMetadataSlice& key, const grpc_slice& value, |
||||
grpc_mdelem_data* compatible_external_backing_store) { |
||||
return md_create<true>(key, value, compatible_external_backing_store); |
||||
} |
||||
|
||||
/* Create grpc_mdelem from provided slices. We specify via template parameter
|
||||
whether we know that the input key is static or not. If it is, we short |
||||
circuit various comparisons and a no-op unref. */ |
||||
template <bool key_definitely_static> |
||||
static grpc_mdelem md_from_slices(const grpc_slice& key, |
||||
const grpc_slice& value) { |
||||
// Ensure key is, in fact, static if we claimed it was.
|
||||
GPR_DEBUG_ASSERT(!key_definitely_static || |
||||
GRPC_IS_STATIC_METADATA_STRING(key)); |
||||
grpc_mdelem out = md_create<key_definitely_static>(key, value, nullptr); |
||||
if (!key_definitely_static) { |
||||
grpc_slice_unref_internal(key); |
||||
} |
||||
grpc_slice_unref_internal(value); |
||||
return out; |
||||
} |
||||
|
||||
grpc_mdelem grpc_mdelem_from_slices(const grpc_slice& key, |
||||
const grpc_slice& value) { |
||||
return md_from_slices</*key_definitely_static=*/false>(key, value); |
||||
} |
||||
|
||||
grpc_mdelem grpc_mdelem_from_slices(const grpc_core::StaticMetadataSlice& key, |
||||
const grpc_slice& value) { |
||||
return md_from_slices</*key_definitely_static=*/true>(key, value); |
||||
} |
||||
|
||||
grpc_mdelem grpc_mdelem_from_slices( |
||||
const grpc_core::StaticMetadataSlice& key, |
||||
const grpc_core::StaticMetadataSlice& value) { |
||||
grpc_mdelem out = md_create_maybe_static<true, true>(key, value); |
||||
return out; |
||||
} |
||||
|
||||
grpc_mdelem grpc_mdelem_from_slices( |
||||
const grpc_core::StaticMetadataSlice& key, |
||||
const grpc_core::ManagedMemorySlice& value) { |
||||
// TODO(arjunroy): We can save the unref if md_create_maybe_static ended up
|
||||
// creating a new interned metadata. But otherwise - we need this here.
|
||||
grpc_mdelem out = md_create_maybe_static<true>(key, value); |
||||
grpc_slice_unref_internal(value); |
||||
return out; |
||||
} |
||||
|
||||
grpc_mdelem grpc_mdelem_from_slices( |
||||
const grpc_core::ManagedMemorySlice& key, |
||||
const grpc_core::ManagedMemorySlice& value) { |
||||
grpc_mdelem out = md_create_maybe_static<false>(key, value); |
||||
// TODO(arjunroy): We can save the unref if md_create_maybe_static ended up
|
||||
// creating a new interned metadata. But otherwise - we need this here.
|
||||
grpc_slice_unref_internal(key); |
||||
grpc_slice_unref_internal(value); |
||||
return out; |
||||
} |
||||
|
||||
grpc_mdelem grpc_mdelem_from_grpc_metadata(grpc_metadata* metadata) { |
||||
bool key_changed = false; |
||||
grpc_slice key_slice = |
||||
grpc_slice_maybe_static_intern(metadata->key, &key_changed); |
||||
bool value_changed = false; |
||||
grpc_slice* unref_slice = nullptr; |
||||
grpc_slice value_slice = |
||||
grpc_slice_maybe_static_intern(metadata->value, &value_changed); |
||||
// If key or value changed, but the other didn't.... AND the other is a NOP
|
||||
// refcount, then we need to convert it to a slice with a refcount else we run
|
||||
// the risk of leaving a dangling reference to that metadata on the heap via
|
||||
// this mdelem.
|
||||
if (key_changed && !value_changed && value_slice.refcount != nullptr && |
||||
value_slice.refcount->GetType() == grpc_slice_refcount::Type::NOP) { |
||||
value_slice = grpc_slice_copy(value_slice); |
||||
unref_slice = &value_slice; |
||||
value_changed = true; |
||||
} else if (!key_changed && value_changed && key_slice.refcount != nullptr && |
||||
key_slice.refcount->GetType() == grpc_slice_refcount::Type::NOP) { |
||||
key_slice = grpc_slice_copy(key_slice); |
||||
unref_slice = &key_slice; |
||||
key_changed = true; |
||||
} |
||||
auto mdelem = |
||||
grpc_mdelem_create(key_slice, value_slice, |
||||
key_changed || value_changed |
||||
? nullptr |
||||
: reinterpret_cast<grpc_mdelem_data*>(metadata)); |
||||
if (unref_slice != nullptr) grpc_slice_unref_internal(*unref_slice); |
||||
return mdelem; |
||||
} |
||||
|
||||
static void* get_user_data(UserData* user_data, void (*destroy_func)(void*)) { |
||||
if (user_data->destroy_user_data.load(std::memory_order_acquire) == |
||||
destroy_func) { |
||||
return user_data->data.load(std::memory_order_relaxed); |
||||
} else { |
||||
return nullptr; |
||||
} |
||||
} |
||||
|
||||
void* grpc_mdelem_get_user_data(grpc_mdelem md, void (*destroy_func)(void*)) { |
||||
switch (GRPC_MDELEM_STORAGE(md)) { |
||||
case GRPC_MDELEM_STORAGE_EXTERNAL: |
||||
return nullptr; |
||||
case GRPC_MDELEM_STORAGE_STATIC: |
||||
return reinterpret_cast<void*>( |
||||
grpc_static_mdelem_user_data |
||||
[reinterpret_cast<grpc_core::StaticMetadata*>( |
||||
GRPC_MDELEM_DATA(md)) - |
||||
grpc_core::g_static_mdelem_table]); |
||||
case GRPC_MDELEM_STORAGE_ALLOCATED: { |
||||
auto* am = reinterpret_cast<AllocatedMetadata*>(GRPC_MDELEM_DATA(md)); |
||||
return get_user_data(am->user_data(), destroy_func); |
||||
} |
||||
case GRPC_MDELEM_STORAGE_INTERNED: { |
||||
auto* im = reinterpret_cast<InternedMetadata*> GRPC_MDELEM_DATA(md); |
||||
return get_user_data(im->user_data(), destroy_func); |
||||
} |
||||
} |
||||
GPR_UNREACHABLE_CODE(return nullptr); |
||||
} |
||||
|
||||
static void* set_user_data(UserData* ud, void (*destroy_func)(void*), |
||||
void* data) { |
||||
GPR_ASSERT((data == nullptr) == (destroy_func == nullptr)); |
||||
grpc_core::ReleasableMutexLock lock(&ud->mu_user_data); |
||||
if (ud->destroy_user_data.load(std::memory_order_relaxed)) { |
||||
/* user data can only be set once */ |
||||
lock.Release(); |
||||
if (destroy_func != nullptr) { |
||||
destroy_func(data); |
||||
} |
||||
return ud->data.load(std::memory_order_relaxed); |
||||
} |
||||
ud->data.store(data, std::memory_order_relaxed); |
||||
ud->destroy_user_data.store(destroy_func, std::memory_order_release); |
||||
return data; |
||||
} |
||||
|
||||
void* grpc_mdelem_set_user_data(grpc_mdelem md, void (*destroy_func)(void*), |
||||
void* data) { |
||||
switch (GRPC_MDELEM_STORAGE(md)) { |
||||
case GRPC_MDELEM_STORAGE_EXTERNAL: |
||||
destroy_func(data); |
||||
return nullptr; |
||||
case GRPC_MDELEM_STORAGE_STATIC: |
||||
destroy_func(data); |
||||
return reinterpret_cast<void*>( |
||||
grpc_static_mdelem_user_data |
||||
[reinterpret_cast<grpc_core::StaticMetadata*>( |
||||
GRPC_MDELEM_DATA(md)) - |
||||
grpc_core::g_static_mdelem_table]); |
||||
case GRPC_MDELEM_STORAGE_ALLOCATED: { |
||||
auto* am = reinterpret_cast<AllocatedMetadata*>(GRPC_MDELEM_DATA(md)); |
||||
return set_user_data(am->user_data(), destroy_func, data); |
||||
} |
||||
case GRPC_MDELEM_STORAGE_INTERNED: { |
||||
auto* im = reinterpret_cast<InternedMetadata*> GRPC_MDELEM_DATA(md); |
||||
GPR_DEBUG_ASSERT(!is_mdelem_static(md)); |
||||
return set_user_data(im->user_data(), destroy_func, data); |
||||
} |
||||
} |
||||
GPR_UNREACHABLE_CODE(return nullptr); |
||||
} |
||||
|
||||
bool grpc_mdelem_eq(grpc_mdelem a, grpc_mdelem b) { |
||||
if (a.payload == b.payload) return true; |
||||
if (GRPC_MDELEM_IS_INTERNED(a) && GRPC_MDELEM_IS_INTERNED(b)) return false; |
||||
if (GRPC_MDISNULL(a) || GRPC_MDISNULL(b)) return false; |
||||
return grpc_slice_eq(GRPC_MDKEY(a), GRPC_MDKEY(b)) && |
||||
grpc_slice_eq(GRPC_MDVALUE(a), GRPC_MDVALUE(b)); |
||||
} |
||||
|
||||
static void note_disposed_interned_metadata(uint32_t hash) { |
||||
mdtab_shard* shard = &g_shards[SHARD_IDX(hash)]; |
||||
gpr_atm_no_barrier_fetch_add(&shard->free_estimate, 1); |
||||
} |
||||
|
||||
void grpc_mdelem_do_unref(grpc_mdelem gmd DEBUG_ARGS) { |
||||
switch (GRPC_MDELEM_STORAGE(gmd)) { |
||||
case GRPC_MDELEM_STORAGE_EXTERNAL: |
||||
case GRPC_MDELEM_STORAGE_STATIC: |
||||
return; |
||||
case GRPC_MDELEM_STORAGE_INTERNED: { |
||||
auto* md = reinterpret_cast<InternedMetadata*> GRPC_MDELEM_DATA(gmd); |
||||
uint32_t hash = md->hash(); |
||||
if (GPR_UNLIKELY(md->Unref(FWD_DEBUG_ARGS))) { |
||||
/* once the refcount hits zero, some other thread can come along and
|
||||
free md at any time: it's unsafe from this point on to access it */ |
||||
note_disposed_interned_metadata(hash); |
||||
} |
||||
break; |
||||
} |
||||
case GRPC_MDELEM_STORAGE_ALLOCATED: { |
||||
auto* md = reinterpret_cast<AllocatedMetadata*> GRPC_MDELEM_DATA(gmd); |
||||
if (GPR_UNLIKELY(md->Unref(FWD_DEBUG_ARGS))) { |
||||
delete md; |
||||
} |
||||
break; |
||||
} |
||||
} |
||||
} |
||||
|
||||
void grpc_mdelem_on_final_unref(grpc_mdelem_data_storage storage, void* ptr, |
||||
uint32_t hash DEBUG_ARGS) { |
||||
#ifndef NDEBUG |
||||
(void)file; |
||||
(void)line; |
||||
#endif |
||||
switch (storage) { |
||||
case GRPC_MDELEM_STORAGE_EXTERNAL: |
||||
case GRPC_MDELEM_STORAGE_STATIC: |
||||
return; |
||||
case GRPC_MDELEM_STORAGE_INTERNED: { |
||||
note_disposed_interned_metadata(hash); |
||||
break; |
||||
} |
||||
case GRPC_MDELEM_STORAGE_ALLOCATED: { |
||||
delete reinterpret_cast<AllocatedMetadata*>(ptr); |
||||
break; |
||||
} |
||||
} |
||||
} |
||||
@ -1,449 +0,0 @@ |
||||
/*
|
||||
* |
||||
* Copyright 2015 gRPC authors. |
||||
* |
||||
* Licensed under the Apache License, Version 2.0 (the "License"); |
||||
* you may not use this file except in compliance with the License. |
||||
* You may obtain a copy of the License at |
||||
* |
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
* |
||||
* Unless required by applicable law or agreed to in writing, software |
||||
* distributed under the License is distributed on an "AS IS" BASIS, |
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
||||
* See the License for the specific language governing permissions and |
||||
* limitations under the License. |
||||
* |
||||
*/ |
||||
|
||||
#ifndef GRPC_CORE_LIB_TRANSPORT_METADATA_H |
||||
#define GRPC_CORE_LIB_TRANSPORT_METADATA_H |
||||
|
||||
#include <grpc/support/port_platform.h> |
||||
|
||||
#include <atomic> |
||||
|
||||
#include <grpc/grpc.h> |
||||
#include <grpc/impl/codegen/log.h> |
||||
#include <grpc/slice.h> |
||||
|
||||
#include "src/core/lib/debug/trace.h" |
||||
#include "src/core/lib/gpr/useful.h" |
||||
#include "src/core/lib/gprpp/sync.h" |
||||
#include "src/core/lib/slice/slice_utils.h" |
||||
|
||||
extern grpc_core::DebugOnlyTraceFlag grpc_trace_metadata; |
||||
|
||||
/* This file provides a mechanism for tracking metadata through the grpc stack.
|
||||
It's not intended for consumption outside of the library. |
||||
|
||||
Metadata is tracked in the context of a sharded global grpc_mdctx. The |
||||
context tracks unique strings (grpc_mdstr) and pairs of strings |
||||
(grpc_mdelem). Any of these objects can be checked for equality by comparing |
||||
their pointers. These objects are reference counted. |
||||
|
||||
grpc_mdelem can additionally store a (non-NULL) user data pointer. This |
||||
pointer is intended to be used to cache semantic meaning of a metadata |
||||
element. For example, an OAuth token may cache the credentials it represents |
||||
and the time at which it expires in the mdelem user data. |
||||
|
||||
Combining this metadata cache and the hpack compression table allows us to |
||||
simply lookup complete preparsed objects quickly, incurring a few atomic |
||||
ops per metadata element on the fast path. |
||||
|
||||
grpc_mdelem instances MAY live longer than their refcount implies, and are |
||||
garbage collected periodically, meaning cached data can easily outlive a |
||||
single request. |
||||
|
||||
STATIC METADATA: in static_metadata.h we declare a set of static metadata. |
||||
These mdelems and mdstrs are available via pre-declared code generated macros |
||||
and are available to code anywhere between grpc_init() and grpc_shutdown(). |
||||
They are not refcounted, but can be passed to _ref and _unref functions |
||||
declared here - in which case those functions are effectively no-ops. */ |
||||
|
||||
/* Forward declarations */ |
||||
typedef struct grpc_mdelem grpc_mdelem; |
||||
|
||||
/* if changing this, make identical changes in:
|
||||
- grpc_core::{InternedMetadata, AllocatedMetadata} |
||||
- grpc_metadata in grpc_types.h */ |
||||
typedef struct grpc_mdelem_data { |
||||
const grpc_slice key; |
||||
const grpc_slice value; |
||||
/* there is a private part to this in metadata.c */ |
||||
} grpc_mdelem_data; |
||||
|
||||
/* GRPC_MDELEM_STORAGE_* enum values that can be treated as interned always have
|
||||
this bit set in their integer value */ |
||||
#define GRPC_MDELEM_STORAGE_INTERNED_BIT 1 |
||||
|
||||
/* External and static storage metadata has no refcount to ref/unref. Allocated
|
||||
* and interned metadata do have a refcount. Metadata ref and unref methods use |
||||
* a switch statement on this enum to determine which behaviour to execute. |
||||
* Keeping the no-ref cases together and the ref-cases together leads to |
||||
* slightly better code generation (9 inlined instructions rather than 10). */ |
||||
typedef enum { |
||||
/* memory pointed to by grpc_mdelem::payload is owned by an external system */ |
||||
GRPC_MDELEM_STORAGE_EXTERNAL = 0, |
||||
/* memory is in the static metadata table */ |
||||
GRPC_MDELEM_STORAGE_STATIC = GRPC_MDELEM_STORAGE_INTERNED_BIT, |
||||
/* memory pointed to by grpc_mdelem::payload is allocated by the metadata
|
||||
system */ |
||||
GRPC_MDELEM_STORAGE_ALLOCATED = 2, |
||||
/* memory pointed to by grpc_mdelem::payload is interned by the metadata
|
||||
system */ |
||||
GRPC_MDELEM_STORAGE_INTERNED = 2 | GRPC_MDELEM_STORAGE_INTERNED_BIT, |
||||
} grpc_mdelem_data_storage; |
||||
|
||||
struct grpc_mdelem { |
||||
/* a grpc_mdelem_data* generally, with the two lower bits signalling memory
|
||||
ownership as per grpc_mdelem_data_storage */ |
||||
uintptr_t payload; |
||||
}; |
||||
|
||||
#define GRPC_MDELEM_DATA(md) ((grpc_mdelem_data*)((md).payload & ~(uintptr_t)3)) |
||||
#define GRPC_MDELEM_STORAGE(md) \ |
||||
((grpc_mdelem_data_storage)((md).payload & (uintptr_t)3)) |
||||
#ifdef __cplusplus |
||||
#define GRPC_MAKE_MDELEM(data, storage) \ |
||||
(grpc_mdelem{((uintptr_t)(data)) | ((uintptr_t)(storage))}) |
||||
#else |
||||
#define GRPC_MAKE_MDELEM(data, storage) \ |
||||
((grpc_mdelem){((uintptr_t)(data)) | ((uintptr_t)(storage))}) |
||||
#endif |
||||
#define GRPC_MDELEM_IS_INTERNED(md) \ |
||||
((grpc_mdelem_data_storage)((md).payload & \
|
||||
(uintptr_t)GRPC_MDELEM_STORAGE_INTERNED_BIT)) |
||||
|
||||
/* Given arbitrary input slices, create a grpc_mdelem object. The caller refs
|
||||
* the input slices; we unref them. This method is always safe to call; however, |
||||
* if we know data about the slices in question (e.g. if we knew our key was |
||||
* static) we can call specializations that save on cycle count. */ |
||||
grpc_mdelem grpc_mdelem_from_slices(const grpc_slice& key, |
||||
const grpc_slice& value); |
||||
|
||||
/* Like grpc_mdelem_from_slices, but we know that key is a static slice. This
|
||||
saves us a few branches and a no-op call to md_unref() for the key. */ |
||||
grpc_mdelem grpc_mdelem_from_slices(const grpc_core::StaticMetadataSlice& key, |
||||
const grpc_slice& value); |
||||
|
||||
/* Like grpc_mdelem_from_slices, but key is static and val is static. */ |
||||
grpc_mdelem grpc_mdelem_from_slices( |
||||
const grpc_core::StaticMetadataSlice& key, |
||||
const grpc_core::StaticMetadataSlice& value); |
||||
|
||||
/* Like grpc_mdelem_from_slices, but key is static and val is interned. */ |
||||
grpc_mdelem grpc_mdelem_from_slices(const grpc_core::StaticMetadataSlice& key, |
||||
const grpc_core::ManagedMemorySlice& value); |
||||
|
||||
/* Like grpc_mdelem_from_slices, but key and val are interned. */ |
||||
grpc_mdelem grpc_mdelem_from_slices(const grpc_core::ManagedMemorySlice& key, |
||||
const grpc_core::ManagedMemorySlice& value); |
||||
|
||||
/* Cheaply convert a grpc_metadata to a grpc_mdelem; may use the grpc_metadata
|
||||
object as backing storage (so lifetimes should align) */ |
||||
grpc_mdelem grpc_mdelem_from_grpc_metadata(grpc_metadata* metadata); |
||||
|
||||
/* Does not unref the slices; if a new non-interned mdelem is needed, allocates
|
||||
one if compatible_external_backing_store is NULL, or uses |
||||
compatible_external_backing_store if it is non-NULL (in which case it's the |
||||
users responsibility to ensure that it outlives usage) */ |
||||
grpc_mdelem grpc_mdelem_create( |
||||
const grpc_slice& key, const grpc_slice& value, |
||||
grpc_mdelem_data* compatible_external_backing_store); |
||||
|
||||
/* Like grpc_mdelem_create, but we know that key is static. */ |
||||
grpc_mdelem grpc_mdelem_create( |
||||
const grpc_core::StaticMetadataSlice& key, const grpc_slice& value, |
||||
grpc_mdelem_data* compatible_external_backing_store); |
||||
|
||||
#define GRPC_MDKEY(md) (GRPC_MDELEM_DATA(md)->key) |
||||
#define GRPC_MDVALUE(md) (GRPC_MDELEM_DATA(md)->value) |
||||
|
||||
bool grpc_mdelem_eq(grpc_mdelem a, grpc_mdelem b); |
||||
/* Often we compare metadata where we know a-priori that the second parameter is
|
||||
* static, and that the keys match. This most commonly happens when processing |
||||
* metadata batch callouts in initial/trailing filters. In this case, fastpath |
||||
* grpc_mdelem_eq and remove unnecessary checks. */ |
||||
inline bool grpc_mdelem_static_value_eq(grpc_mdelem a, grpc_mdelem b_static) { |
||||
if (a.payload == b_static.payload) return true; |
||||
return grpc_slice_eq_static_interned(GRPC_MDVALUE(a), GRPC_MDVALUE(b_static)); |
||||
} |
||||
#define GRPC_MDISNULL(md) (GRPC_MDELEM_DATA(md) == NULL) |
||||
|
||||
inline bool grpc_mdelem_both_interned_eq(grpc_mdelem a_interned, |
||||
grpc_mdelem b_interned) { |
||||
GPR_DEBUG_ASSERT(GRPC_MDELEM_IS_INTERNED(a_interned) || |
||||
GRPC_MDISNULL(a_interned)); |
||||
GPR_DEBUG_ASSERT(GRPC_MDELEM_IS_INTERNED(b_interned) || |
||||
GRPC_MDISNULL(b_interned)); |
||||
return a_interned.payload == b_interned.payload; |
||||
} |
||||
|
||||
/* Mutator and accessor for grpc_mdelem user data. The destructor function
|
||||
is used as a type tag and is checked during user_data fetch. */ |
||||
void* grpc_mdelem_get_user_data(grpc_mdelem md, void (*if_destroy_func)(void*)); |
||||
void* grpc_mdelem_set_user_data(grpc_mdelem md, void (*destroy_func)(void*), |
||||
void* data); |
||||
|
||||
// Defined in metadata.cc.
|
||||
struct mdtab_shard; |
||||
|
||||
#ifndef NDEBUG |
||||
void grpc_mdelem_trace_ref(void* md, const grpc_slice& key, |
||||
const grpc_slice& value, intptr_t refcnt, |
||||
const char* file, int line); |
||||
void grpc_mdelem_trace_unref(void* md, const grpc_slice& key, |
||||
const grpc_slice& value, intptr_t refcnt, |
||||
const char* file, int line); |
||||
#endif |
||||
namespace grpc_core { |
||||
|
||||
typedef void (*destroy_user_data_func)(void* data); |
||||
|
||||
struct UserData { |
||||
Mutex mu_user_data; |
||||
std::atomic<destroy_user_data_func> destroy_user_data{nullptr}; |
||||
std::atomic<void*> data{nullptr}; |
||||
}; |
||||
|
||||
class StaticMetadata { |
||||
public: |
||||
StaticMetadata(const grpc_slice& key, const grpc_slice& value, uintptr_t idx) |
||||
: kv_({key, value}), hash_(0), static_idx_(idx) {} |
||||
|
||||
const grpc_mdelem_data& data() const { return kv_; } |
||||
|
||||
void HashInit(); |
||||
uint32_t hash() { return hash_; } |
||||
uintptr_t StaticIndex() { return static_idx_; } |
||||
|
||||
private: |
||||
grpc_mdelem_data kv_; |
||||
|
||||
/* private only data */ |
||||
uint32_t hash_; |
||||
uintptr_t static_idx_; |
||||
}; |
||||
|
||||
class RefcountedMdBase { |
||||
public: |
||||
RefcountedMdBase(const grpc_slice& key, const grpc_slice& value) |
||||
: key_(key), value_(value), refcnt_(1) {} |
||||
RefcountedMdBase(const grpc_slice& key, const grpc_slice& value, |
||||
uint32_t hash) |
||||
: key_(key), value_(value), refcnt_(1), hash_(hash) {} |
||||
|
||||
const grpc_slice& key() const { return key_; } |
||||
const grpc_slice& value() const { return value_; } |
||||
uint32_t hash() { return hash_; } |
||||
|
||||
#ifndef NDEBUG |
||||
void Ref(const char* file, int line) { |
||||
grpc_mdelem_trace_ref(this, key_, value_, RefValue(), file, line); |
||||
const intptr_t prior = refcnt_.fetch_add(1, std::memory_order_relaxed); |
||||
GPR_ASSERT(prior > 0); |
||||
} |
||||
bool Unref(const char* file, int line) { |
||||
grpc_mdelem_trace_unref(this, key_, value_, RefValue(), file, line); |
||||
return Unref(); |
||||
} |
||||
#endif |
||||
void Ref() { |
||||
/* we can assume the ref count is >= 1 as the application is calling
|
||||
this function - meaning that no adjustment to mdtab_free is necessary, |
||||
simplifying the logic here to be just an atomic increment */ |
||||
refcnt_.fetch_add(1, std::memory_order_relaxed); |
||||
} |
||||
bool Unref() { |
||||
const intptr_t prior = refcnt_.fetch_sub(1, std::memory_order_acq_rel); |
||||
GPR_DEBUG_ASSERT(prior > 0); |
||||
return prior == 1; |
||||
} |
||||
|
||||
protected: |
||||
#ifndef NDEBUG |
||||
void TraceAtStart(const char* tag); |
||||
#endif |
||||
|
||||
intptr_t RefValue() { return refcnt_.load(std::memory_order_relaxed); } |
||||
bool AllRefsDropped() { return refcnt_.load(std::memory_order_acquire) == 0; } |
||||
bool FirstRef() { |
||||
return refcnt_.fetch_add(1, std::memory_order_relaxed) == 0; |
||||
} |
||||
|
||||
private: |
||||
/* must be byte compatible with grpc_mdelem_data */ |
||||
grpc_slice key_; |
||||
grpc_slice value_; |
||||
std::atomic<intptr_t> refcnt_{0}; |
||||
uint32_t hash_ = 0; |
||||
}; |
||||
|
||||
class InternedMetadata : public RefcountedMdBase { |
||||
public: |
||||
// TODO(arjunroy): Change to use strongly typed slices instead.
|
||||
struct NoRefKey {}; |
||||
struct BucketLink { |
||||
explicit BucketLink(InternedMetadata* md) : next(md) {} |
||||
|
||||
InternedMetadata* next = nullptr; |
||||
}; |
||||
InternedMetadata(const grpc_slice& key, const grpc_slice& value, |
||||
uint32_t hash, InternedMetadata* next); |
||||
InternedMetadata(const grpc_slice& key, const grpc_slice& value, |
||||
uint32_t hash, InternedMetadata* next, const NoRefKey*); |
||||
|
||||
~InternedMetadata(); |
||||
void RefWithShardLocked(mdtab_shard* shard); |
||||
UserData* user_data() { return &user_data_; } |
||||
InternedMetadata* bucket_next() { return link_.next; } |
||||
void set_bucket_next(InternedMetadata* md) { link_.next = md; } |
||||
|
||||
static size_t CleanupLinkedMetadata(BucketLink* head); |
||||
|
||||
private: |
||||
UserData user_data_; |
||||
BucketLink link_; |
||||
}; |
||||
|
||||
/* Shadow structure for grpc_mdelem_data for allocated elements */ |
||||
class AllocatedMetadata : public RefcountedMdBase { |
||||
public: |
||||
// TODO(arjunroy): Change to use strongly typed slices instead.
|
||||
struct NoRefKey {}; |
||||
AllocatedMetadata(const grpc_slice& key, const grpc_slice& value); |
||||
AllocatedMetadata(const ManagedMemorySlice& key, |
||||
const UnmanagedMemorySlice& value); |
||||
AllocatedMetadata(const ExternallyManagedSlice& key, |
||||
const UnmanagedMemorySlice& value); |
||||
AllocatedMetadata(const grpc_slice& key, const grpc_slice& value, |
||||
const NoRefKey*); |
||||
~AllocatedMetadata(); |
||||
|
||||
UserData* user_data() { return &user_data_; } |
||||
|
||||
private: |
||||
UserData user_data_; |
||||
}; |
||||
|
||||
} // namespace grpc_core
|
||||
|
||||
#ifndef NDEBUG |
||||
#define GRPC_MDELEM_REF(s) grpc_mdelem_ref((s), __FILE__, __LINE__) |
||||
inline grpc_mdelem grpc_mdelem_ref(grpc_mdelem gmd, const char* file, |
||||
int line) { |
||||
#else // ifndef NDEBUG
|
||||
#define GRPC_MDELEM_REF(s) grpc_mdelem_ref((s)) |
||||
inline grpc_mdelem grpc_mdelem_ref(grpc_mdelem gmd) { |
||||
#endif // ifndef NDEBUG
|
||||
switch (GRPC_MDELEM_STORAGE(gmd)) { |
||||
case GRPC_MDELEM_STORAGE_EXTERNAL: |
||||
case GRPC_MDELEM_STORAGE_STATIC: |
||||
break; |
||||
case GRPC_MDELEM_STORAGE_INTERNED: { |
||||
auto* md = |
||||
reinterpret_cast<grpc_core::InternedMetadata*> GRPC_MDELEM_DATA(gmd); |
||||
/* use C assert to have this removed in opt builds */ |
||||
#ifndef NDEBUG |
||||
md->Ref(file, line); |
||||
#else |
||||
md->Ref(); |
||||
#endif |
||||
break; |
||||
} |
||||
case GRPC_MDELEM_STORAGE_ALLOCATED: { |
||||
auto* md = |
||||
reinterpret_cast<grpc_core::AllocatedMetadata*> GRPC_MDELEM_DATA(gmd); |
||||
#ifndef NDEBUG |
||||
md->Ref(file, line); |
||||
#else |
||||
md->Ref(); |
||||
#endif |
||||
break; |
||||
} |
||||
} |
||||
return gmd; |
||||
} |
||||
|
||||
#ifndef NDEBUG |
||||
#define GRPC_MDELEM_UNREF(s) grpc_mdelem_unref((s), __FILE__, __LINE__) |
||||
void grpc_mdelem_on_final_unref(grpc_mdelem_data_storage storage, void* ptr, |
||||
uint32_t hash, const char* file, int line); |
||||
inline void grpc_mdelem_unref(grpc_mdelem gmd, const char* file, int line) { |
||||
#else |
||||
#define GRPC_MDELEM_UNREF(s) grpc_mdelem_unref((s)) |
||||
void grpc_mdelem_on_final_unref(grpc_mdelem_data_storage storage, void* ptr, |
||||
uint32_t hash); |
||||
inline void grpc_mdelem_unref(grpc_mdelem gmd) { |
||||
#endif |
||||
const grpc_mdelem_data_storage storage = GRPC_MDELEM_STORAGE(gmd); |
||||
switch (storage) { |
||||
case GRPC_MDELEM_STORAGE_EXTERNAL: |
||||
case GRPC_MDELEM_STORAGE_STATIC: |
||||
return; |
||||
case GRPC_MDELEM_STORAGE_INTERNED: |
||||
case GRPC_MDELEM_STORAGE_ALLOCATED: |
||||
auto* md = |
||||
reinterpret_cast<grpc_core::RefcountedMdBase*> GRPC_MDELEM_DATA(gmd); |
||||
/* once the refcount hits zero, some other thread can come along and
|
||||
free an interned md at any time: it's unsafe from this point on to |
||||
access it so we read the hash now. */ |
||||
uint32_t hash = md->hash(); |
||||
#ifndef NDEBUG |
||||
if (GPR_UNLIKELY(md->Unref(file, line))) { |
||||
grpc_mdelem_on_final_unref(storage, md, hash, file, line); |
||||
#else |
||||
if (GPR_UNLIKELY(md->Unref())) { |
||||
grpc_mdelem_on_final_unref(storage, md, hash); |
||||
#endif |
||||
} |
||||
return; |
||||
} |
||||
} |
||||
|
||||
#define GRPC_MDNULL GRPC_MAKE_MDELEM(NULL, GRPC_MDELEM_STORAGE_EXTERNAL) |
||||
|
||||
/* We add 32 bytes of padding as per RFC-7540 section 6.5.2. */ |
||||
#define GRPC_MDELEM_LENGTH(e) \ |
||||
(GRPC_SLICE_LENGTH(GRPC_MDKEY((e))) + GRPC_SLICE_LENGTH(GRPC_MDVALUE((e))) + \
|
||||
32) |
||||
|
||||
#define GRPC_MDSTR_KV_HASH(k_hash, v_hash) \ |
||||
(::grpc_core::RotateLeft(size_t(k_hash), size_t(2)) ^ (v_hash)) |
||||
|
||||
void grpc_mdctx_global_init(void); |
||||
void grpc_mdctx_global_shutdown(); |
||||
|
||||
/* Like grpc_mdelem_from_slices, but we know that key is a static or interned
|
||||
slice and value is not static or interned. This gives us an inlinable |
||||
fastpath - we know we must allocate metadata now, and that we do not need to |
||||
unref the value (rather, we just transfer the ref). We can avoid a ref since: |
||||
1) the key slice is passed in already ref'd |
||||
2) We're guaranteed to create a new Allocated slice, thus meaning the |
||||
ref can be considered 'transferred'.*/ |
||||
inline grpc_mdelem grpc_mdelem_from_slices( |
||||
const grpc_core::ManagedMemorySlice& key, |
||||
const grpc_core::UnmanagedMemorySlice& value) { |
||||
using grpc_core::AllocatedMetadata; |
||||
return GRPC_MAKE_MDELEM(new AllocatedMetadata(key, value), |
||||
GRPC_MDELEM_STORAGE_ALLOCATED); |
||||
} |
||||
|
||||
inline grpc_mdelem grpc_mdelem_from_slices( |
||||
const grpc_core::ExternallyManagedSlice& key, |
||||
const grpc_core::UnmanagedMemorySlice& value) { |
||||
using grpc_core::AllocatedMetadata; |
||||
return GRPC_MAKE_MDELEM(new AllocatedMetadata(key, value), |
||||
GRPC_MDELEM_STORAGE_ALLOCATED); |
||||
} |
||||
|
||||
inline grpc_mdelem grpc_mdelem_from_slices( |
||||
const grpc_core::StaticMetadataSlice& key, |
||||
const grpc_core::UnmanagedMemorySlice& value) { |
||||
using grpc_core::AllocatedMetadata; |
||||
return GRPC_MAKE_MDELEM(new AllocatedMetadata(key, value), |
||||
GRPC_MDELEM_STORAGE_ALLOCATED); |
||||
} |
||||
|
||||
#endif /* GRPC_CORE_LIB_TRANSPORT_METADATA_H */ |
||||
@ -1,99 +0,0 @@ |
||||
/*
|
||||
* |
||||
* Copyright 2015 gRPC authors. |
||||
* |
||||
* Licensed under the Apache License, Version 2.0 (the "License"); |
||||
* you may not use this file except in compliance with the License. |
||||
* You may obtain a copy of the License at |
||||
* |
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
* |
||||
* Unless required by applicable law or agreed to in writing, software |
||||
* distributed under the License is distributed on an "AS IS" BASIS, |
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
||||
* See the License for the specific language governing permissions and |
||||
* limitations under the License. |
||||
* |
||||
*/ |
||||
|
||||
#include <grpc/support/port_platform.h> |
||||
|
||||
#include "src/core/lib/transport/metadata_batch.h" |
||||
|
||||
#include <stdbool.h> |
||||
#include <string.h> |
||||
|
||||
#include "absl/container/inlined_vector.h" |
||||
|
||||
#include <grpc/support/alloc.h> |
||||
#include <grpc/support/log.h> |
||||
|
||||
#include "src/core/lib/profiling/timers.h" |
||||
#include "src/core/lib/slice/slice_internal.h" |
||||
#include "src/core/lib/slice/slice_string_helpers.h" |
||||
|
||||
void grpc_metadata_batch_set_value(grpc_linked_mdelem* storage, |
||||
const grpc_slice& value) { |
||||
grpc_mdelem old_mdelem = storage->md; |
||||
grpc_mdelem new_mdelem = grpc_mdelem_from_slices( |
||||
grpc_slice_ref_internal(GRPC_MDKEY(old_mdelem)), value); |
||||
storage->md = new_mdelem; |
||||
GRPC_MDELEM_UNREF(old_mdelem); |
||||
} |
||||
|
||||
namespace { |
||||
|
||||
class CopySink { |
||||
public: |
||||
explicit CopySink(grpc_metadata_batch* dst) : dst_(dst) {} |
||||
|
||||
void Encode(grpc_mdelem md) { |
||||
// If the mdelem is not external, take a ref.
|
||||
// Otherwise, create a new copy, holding its own refs to the
|
||||
// underlying slices.
|
||||
if (GRPC_MDELEM_STORAGE(md) != GRPC_MDELEM_STORAGE_EXTERNAL) { |
||||
md = GRPC_MDELEM_REF(md); |
||||
} else { |
||||
md = grpc_mdelem_from_slices(grpc_slice_copy(GRPC_MDKEY(md)), |
||||
grpc_slice_copy(GRPC_MDVALUE(md))); |
||||
} |
||||
// Error unused in non-debug builds.
|
||||
grpc_error_handle GRPC_UNUSED error = dst_->Append(md); |
||||
// The only way that Append() can fail is if
|
||||
// there's a duplicate entry for a callout. However, that can't be
|
||||
// the case here, because we would not have been allowed to create
|
||||
// a source batch that had that kind of conflict.
|
||||
GPR_DEBUG_ASSERT(error == GRPC_ERROR_NONE); |
||||
} |
||||
|
||||
template <class T, class V> |
||||
void Encode(T trait, V value) { |
||||
dst_->Set(trait, value); |
||||
} |
||||
|
||||
template <class T> |
||||
void Encode(T trait, const grpc_core::Slice& value) { |
||||
dst_->Set(trait, std::move(value.AsOwned())); |
||||
} |
||||
|
||||
private: |
||||
grpc_metadata_batch* dst_; |
||||
}; |
||||
|
||||
} // namespace
|
||||
|
||||
void grpc_metadata_batch_copy(const grpc_metadata_batch* src, |
||||
grpc_metadata_batch* dst) { |
||||
dst->Clear(); |
||||
CopySink sink(dst); |
||||
src->Encode(&sink); |
||||
} |
||||
|
||||
grpc_error_handle grpc_attach_md_to_error(grpc_error_handle src, |
||||
grpc_mdelem md) { |
||||
grpc_error_handle out = grpc_error_set_str( |
||||
grpc_error_set_str(src, GRPC_ERROR_STR_KEY, |
||||
grpc_core::StringViewFromSlice(GRPC_MDKEY(md))), |
||||
GRPC_ERROR_STR_VALUE, grpc_core::StringViewFromSlice(GRPC_MDVALUE(md))); |
||||
return out; |
||||
} |
||||
File diff suppressed because it is too large
Load Diff
@ -1,778 +0,0 @@ |
||||
/*
|
||||
* Copyright 2015 gRPC authors. |
||||
* |
||||
* Licensed under the Apache License, Version 2.0 (the "License"); |
||||
* you may not use this file except in compliance with the License. |
||||
* You may obtain a copy of the License at |
||||
* |
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
* |
||||
* Unless required by applicable law or agreed to in writing, software |
||||
* distributed under the License is distributed on an "AS IS" BASIS, |
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
||||
* See the License for the specific language governing permissions and |
||||
* limitations under the License. |
||||
*/ |
||||
|
||||
/*
|
||||
* WARNING: Auto-generated code. |
||||
* |
||||
* To make changes to this file, change |
||||
* tools/codegen/core/gen_static_metadata.py, and then re-run it. |
||||
* |
||||
* See metadata.h for an explanation of the interface here, and metadata.cc for |
||||
* an explanation of what's going on. |
||||
*/ |
||||
|
||||
#include <grpc/support/port_platform.h> |
||||
|
||||
#include "src/core/lib/transport/static_metadata.h" |
||||
|
||||
#include "src/core/lib/slice/slice_internal.h" |
||||
|
||||
namespace grpc_core { |
||||
StaticMetadata g_static_mdelem_table[GRPC_STATIC_MDELEM_COUNT] = { |
||||
StaticMetadata( |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[10].base, 10, |
||||
g_static_metadata_bytes + 376), |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[1].base, 0, |
||||
g_static_metadata_bytes + 12), |
||||
0), |
||||
StaticMetadata( |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[11].base, 7, |
||||
g_static_metadata_bytes + 386), |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[12].base, 3, |
||||
g_static_metadata_bytes + 393), |
||||
1), |
||||
StaticMetadata( |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[11].base, 7, |
||||
g_static_metadata_bytes + 386), |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[13].base, 4, |
||||
g_static_metadata_bytes + 396), |
||||
2), |
||||
StaticMetadata( |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[14].base, 5, |
||||
g_static_metadata_bytes + 400), |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[15].base, 1, |
||||
g_static_metadata_bytes + 405), |
||||
3), |
||||
StaticMetadata( |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[14].base, 5, |
||||
g_static_metadata_bytes + 400), |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[16].base, 11, |
||||
g_static_metadata_bytes + 406), |
||||
4), |
||||
StaticMetadata( |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[17].base, 7, |
||||
g_static_metadata_bytes + 417), |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[18].base, 4, |
||||
g_static_metadata_bytes + 424), |
||||
5), |
||||
StaticMetadata( |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[17].base, 7, |
||||
g_static_metadata_bytes + 417), |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[19].base, 5, |
||||
g_static_metadata_bytes + 428), |
||||
6), |
||||
StaticMetadata( |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[20].base, 7, |
||||
g_static_metadata_bytes + 433), |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[21].base, 3, |
||||
g_static_metadata_bytes + 440), |
||||
7), |
||||
StaticMetadata( |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[20].base, 7, |
||||
g_static_metadata_bytes + 433), |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[22].base, 3, |
||||
g_static_metadata_bytes + 443), |
||||
8), |
||||
StaticMetadata( |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[20].base, 7, |
||||
g_static_metadata_bytes + 433), |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[23].base, 3, |
||||
g_static_metadata_bytes + 446), |
||||
9), |
||||
StaticMetadata( |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[20].base, 7, |
||||
g_static_metadata_bytes + 433), |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[24].base, 3, |
||||
g_static_metadata_bytes + 449), |
||||
10), |
||||
StaticMetadata( |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[20].base, 7, |
||||
g_static_metadata_bytes + 433), |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[25].base, 3, |
||||
g_static_metadata_bytes + 452), |
||||
11), |
||||
StaticMetadata( |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[20].base, 7, |
||||
g_static_metadata_bytes + 433), |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[26].base, 3, |
||||
g_static_metadata_bytes + 455), |
||||
12), |
||||
StaticMetadata( |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[20].base, 7, |
||||
g_static_metadata_bytes + 433), |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[27].base, 3, |
||||
g_static_metadata_bytes + 458), |
||||
13), |
||||
StaticMetadata( |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[28].base, 14, |
||||
g_static_metadata_bytes + 461), |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[1].base, 0, |
||||
g_static_metadata_bytes + 12), |
||||
14), |
||||
StaticMetadata( |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[29].base, 15, |
||||
g_static_metadata_bytes + 475), |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[30].base, 13, |
||||
g_static_metadata_bytes + 490), |
||||
15), |
||||
StaticMetadata( |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[31].base, 15, |
||||
g_static_metadata_bytes + 503), |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[1].base, 0, |
||||
g_static_metadata_bytes + 12), |
||||
16), |
||||
StaticMetadata( |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[32].base, 13, |
||||
g_static_metadata_bytes + 518), |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[1].base, 0, |
||||
g_static_metadata_bytes + 12), |
||||
17), |
||||
StaticMetadata( |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[33].base, 6, |
||||
g_static_metadata_bytes + 531), |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[1].base, 0, |
||||
g_static_metadata_bytes + 12), |
||||
18), |
||||
StaticMetadata( |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[34].base, 27, |
||||
g_static_metadata_bytes + 537), |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[1].base, 0, |
||||
g_static_metadata_bytes + 12), |
||||
19), |
||||
StaticMetadata( |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[35].base, 3, |
||||
g_static_metadata_bytes + 564), |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[1].base, 0, |
||||
g_static_metadata_bytes + 12), |
||||
20), |
||||
StaticMetadata( |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[36].base, 5, |
||||
g_static_metadata_bytes + 567), |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[1].base, 0, |
||||
g_static_metadata_bytes + 12), |
||||
21), |
||||
StaticMetadata( |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[37].base, 13, |
||||
g_static_metadata_bytes + 572), |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[1].base, 0, |
||||
g_static_metadata_bytes + 12), |
||||
22), |
||||
StaticMetadata( |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[38].base, 13, |
||||
g_static_metadata_bytes + 585), |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[1].base, 0, |
||||
g_static_metadata_bytes + 12), |
||||
23), |
||||
StaticMetadata( |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[39].base, 19, |
||||
g_static_metadata_bytes + 598), |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[1].base, 0, |
||||
g_static_metadata_bytes + 12), |
||||
24), |
||||
StaticMetadata( |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[40].base, 16, |
||||
g_static_metadata_bytes + 617), |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[1].base, 0, |
||||
g_static_metadata_bytes + 12), |
||||
25), |
||||
StaticMetadata( |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[41].base, 16, |
||||
g_static_metadata_bytes + 633), |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[1].base, 0, |
||||
g_static_metadata_bytes + 12), |
||||
26), |
||||
StaticMetadata( |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[42].base, 14, |
||||
g_static_metadata_bytes + 649), |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[1].base, 0, |
||||
g_static_metadata_bytes + 12), |
||||
27), |
||||
StaticMetadata( |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[43].base, 16, |
||||
g_static_metadata_bytes + 663), |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[1].base, 0, |
||||
g_static_metadata_bytes + 12), |
||||
28), |
||||
StaticMetadata( |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[44].base, 13, |
||||
g_static_metadata_bytes + 679), |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[1].base, 0, |
||||
g_static_metadata_bytes + 12), |
||||
29), |
||||
StaticMetadata( |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[45].base, 12, |
||||
g_static_metadata_bytes + 692), |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[1].base, 0, |
||||
g_static_metadata_bytes + 12), |
||||
30), |
||||
StaticMetadata( |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[46].base, 6, |
||||
g_static_metadata_bytes + 704), |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[1].base, 0, |
||||
g_static_metadata_bytes + 12), |
||||
31), |
||||
StaticMetadata( |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[47].base, 4, |
||||
g_static_metadata_bytes + 710), |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[1].base, 0, |
||||
g_static_metadata_bytes + 12), |
||||
32), |
||||
StaticMetadata( |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[48].base, 4, |
||||
g_static_metadata_bytes + 714), |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[1].base, 0, |
||||
g_static_metadata_bytes + 12), |
||||
33), |
||||
StaticMetadata( |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[49].base, 6, |
||||
g_static_metadata_bytes + 718), |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[1].base, 0, |
||||
g_static_metadata_bytes + 12), |
||||
34), |
||||
StaticMetadata( |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[50].base, 7, |
||||
g_static_metadata_bytes + 724), |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[1].base, 0, |
||||
g_static_metadata_bytes + 12), |
||||
35), |
||||
StaticMetadata( |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[51].base, 4, |
||||
g_static_metadata_bytes + 731), |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[1].base, 0, |
||||
g_static_metadata_bytes + 12), |
||||
36), |
||||
StaticMetadata( |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[52].base, 4, |
||||
g_static_metadata_bytes + 735), |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[1].base, 0, |
||||
g_static_metadata_bytes + 12), |
||||
37), |
||||
StaticMetadata( |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[53].base, 8, |
||||
g_static_metadata_bytes + 739), |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[1].base, 0, |
||||
g_static_metadata_bytes + 12), |
||||
38), |
||||
StaticMetadata( |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[54].base, 17, |
||||
g_static_metadata_bytes + 747), |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[1].base, 0, |
||||
g_static_metadata_bytes + 12), |
||||
39), |
||||
StaticMetadata( |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[55].base, 13, |
||||
g_static_metadata_bytes + 764), |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[1].base, 0, |
||||
g_static_metadata_bytes + 12), |
||||
40), |
||||
StaticMetadata( |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[56].base, 8, |
||||
g_static_metadata_bytes + 777), |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[1].base, 0, |
||||
g_static_metadata_bytes + 12), |
||||
41), |
||||
StaticMetadata( |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[57].base, 19, |
||||
g_static_metadata_bytes + 785), |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[1].base, 0, |
||||
g_static_metadata_bytes + 12), |
||||
42), |
||||
StaticMetadata( |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[58].base, 13, |
||||
g_static_metadata_bytes + 804), |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[1].base, 0, |
||||
g_static_metadata_bytes + 12), |
||||
43), |
||||
StaticMetadata( |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[59].base, 4, |
||||
g_static_metadata_bytes + 817), |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[1].base, 0, |
||||
g_static_metadata_bytes + 12), |
||||
44), |
||||
StaticMetadata( |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[60].base, 8, |
||||
g_static_metadata_bytes + 821), |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[1].base, 0, |
||||
g_static_metadata_bytes + 12), |
||||
45), |
||||
StaticMetadata( |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[61].base, 12, |
||||
g_static_metadata_bytes + 829), |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[1].base, 0, |
||||
g_static_metadata_bytes + 12), |
||||
46), |
||||
StaticMetadata( |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[62].base, 18, |
||||
g_static_metadata_bytes + 841), |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[1].base, 0, |
||||
g_static_metadata_bytes + 12), |
||||
47), |
||||
StaticMetadata( |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[63].base, 19, |
||||
g_static_metadata_bytes + 859), |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[1].base, 0, |
||||
g_static_metadata_bytes + 12), |
||||
48), |
||||
StaticMetadata( |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[64].base, 5, |
||||
g_static_metadata_bytes + 878), |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[1].base, 0, |
||||
g_static_metadata_bytes + 12), |
||||
49), |
||||
StaticMetadata( |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[65].base, 7, |
||||
g_static_metadata_bytes + 883), |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[1].base, 0, |
||||
g_static_metadata_bytes + 12), |
||||
50), |
||||
StaticMetadata( |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[66].base, 7, |
||||
g_static_metadata_bytes + 890), |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[1].base, 0, |
||||
g_static_metadata_bytes + 12), |
||||
51), |
||||
StaticMetadata( |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[67].base, 11, |
||||
g_static_metadata_bytes + 897), |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[1].base, 0, |
||||
g_static_metadata_bytes + 12), |
||||
52), |
||||
StaticMetadata( |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[68].base, 6, |
||||
g_static_metadata_bytes + 908), |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[1].base, 0, |
||||
g_static_metadata_bytes + 12), |
||||
53), |
||||
StaticMetadata( |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[69].base, 10, |
||||
g_static_metadata_bytes + 914), |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[1].base, 0, |
||||
g_static_metadata_bytes + 12), |
||||
54), |
||||
StaticMetadata( |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[70].base, 25, |
||||
g_static_metadata_bytes + 924), |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[1].base, 0, |
||||
g_static_metadata_bytes + 12), |
||||
55), |
||||
StaticMetadata( |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[71].base, 17, |
||||
g_static_metadata_bytes + 949), |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[1].base, 0, |
||||
g_static_metadata_bytes + 12), |
||||
56), |
||||
StaticMetadata( |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[72].base, 10, |
||||
g_static_metadata_bytes + 966), |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[1].base, 0, |
||||
g_static_metadata_bytes + 12), |
||||
57), |
||||
StaticMetadata( |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[73].base, 4, |
||||
g_static_metadata_bytes + 976), |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[1].base, 0, |
||||
g_static_metadata_bytes + 12), |
||||
58), |
||||
StaticMetadata( |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[74].base, 3, |
||||
g_static_metadata_bytes + 980), |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[1].base, 0, |
||||
g_static_metadata_bytes + 12), |
||||
59), |
||||
StaticMetadata( |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[75].base, 16, |
||||
g_static_metadata_bytes + 983), |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[1].base, 0, |
||||
g_static_metadata_bytes + 12), |
||||
60), |
||||
StaticMetadata( |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[76].base, 11, |
||||
g_static_metadata_bytes + 999), |
||||
StaticMetadataSlice(&g_static_metadata_slice_refcounts[1].base, 0, |
||||
g_static_metadata_bytes + 12), |
||||
61), |
||||
}; |
||||
|
||||
/* Warning: the core static metadata currently operates under the soft
|
||||
constraint that the first GRPC_CHTTP2_LAST_STATIC_ENTRY (61) entries must |
||||
contain metadata specified by the http2 hpack standard. The CHTTP2 transport |
||||
reads the core metadata with this assumption in mind. If the order of the core |
||||
static metadata is to be changed, then the CHTTP2 transport must be changed as |
||||
well to stop relying on the core metadata. */ |
||||
|
||||
grpc_mdelem g_static_mdelem_manifested[GRPC_STATIC_MDELEM_COUNT] = { |
||||
// clang-format off
|
||||
/* GRPC_MDELEM_AUTHORITY_EMPTY:
|
||||
":authority": "" */ |
||||
GRPC_MAKE_MDELEM( |
||||
&g_static_mdelem_table[0].data(), |
||||
GRPC_MDELEM_STORAGE_STATIC), |
||||
/* GRPC_MDELEM_METHOD_GET:
|
||||
":method": "GET" */ |
||||
GRPC_MAKE_MDELEM( |
||||
&g_static_mdelem_table[1].data(), |
||||
GRPC_MDELEM_STORAGE_STATIC), |
||||
/* GRPC_MDELEM_METHOD_POST:
|
||||
":method": "POST" */ |
||||
GRPC_MAKE_MDELEM( |
||||
&g_static_mdelem_table[2].data(), |
||||
GRPC_MDELEM_STORAGE_STATIC), |
||||
/* GRPC_MDELEM_PATH_SLASH:
|
||||
":path": "/" */ |
||||
GRPC_MAKE_MDELEM( |
||||
&g_static_mdelem_table[3].data(), |
||||
GRPC_MDELEM_STORAGE_STATIC), |
||||
/* GRPC_MDELEM_PATH_SLASH_INDEX_DOT_HTML:
|
||||
":path": "/index.html" */ |
||||
GRPC_MAKE_MDELEM( |
||||
&g_static_mdelem_table[4].data(), |
||||
GRPC_MDELEM_STORAGE_STATIC), |
||||
/* GRPC_MDELEM_SCHEME_HTTP:
|
||||
":scheme": "http" */ |
||||
GRPC_MAKE_MDELEM( |
||||
&g_static_mdelem_table[5].data(), |
||||
GRPC_MDELEM_STORAGE_STATIC), |
||||
/* GRPC_MDELEM_SCHEME_HTTPS:
|
||||
":scheme": "https" */ |
||||
GRPC_MAKE_MDELEM( |
||||
&g_static_mdelem_table[6].data(), |
||||
GRPC_MDELEM_STORAGE_STATIC), |
||||
/* GRPC_MDELEM_STATUS_200:
|
||||
":status": "200" */ |
||||
GRPC_MAKE_MDELEM( |
||||
&g_static_mdelem_table[7].data(), |
||||
GRPC_MDELEM_STORAGE_STATIC), |
||||
/* GRPC_MDELEM_STATUS_204:
|
||||
":status": "204" */ |
||||
GRPC_MAKE_MDELEM( |
||||
&g_static_mdelem_table[8].data(), |
||||
GRPC_MDELEM_STORAGE_STATIC), |
||||
/* GRPC_MDELEM_STATUS_206:
|
||||
":status": "206" */ |
||||
GRPC_MAKE_MDELEM( |
||||
&g_static_mdelem_table[9].data(), |
||||
GRPC_MDELEM_STORAGE_STATIC), |
||||
/* GRPC_MDELEM_STATUS_304:
|
||||
":status": "304" */ |
||||
GRPC_MAKE_MDELEM( |
||||
&g_static_mdelem_table[10].data(), |
||||
GRPC_MDELEM_STORAGE_STATIC), |
||||
/* GRPC_MDELEM_STATUS_400:
|
||||
":status": "400" */ |
||||
GRPC_MAKE_MDELEM( |
||||
&g_static_mdelem_table[11].data(), |
||||
GRPC_MDELEM_STORAGE_STATIC), |
||||
/* GRPC_MDELEM_STATUS_404:
|
||||
":status": "404" */ |
||||
GRPC_MAKE_MDELEM( |
||||
&g_static_mdelem_table[12].data(), |
||||
GRPC_MDELEM_STORAGE_STATIC), |
||||
/* GRPC_MDELEM_STATUS_500:
|
||||
":status": "500" */ |
||||
GRPC_MAKE_MDELEM( |
||||
&g_static_mdelem_table[13].data(), |
||||
GRPC_MDELEM_STORAGE_STATIC), |
||||
/* GRPC_MDELEM_ACCEPT_CHARSET_EMPTY:
|
||||
"accept-charset": "" */ |
||||
GRPC_MAKE_MDELEM( |
||||
&g_static_mdelem_table[14].data(), |
||||
GRPC_MDELEM_STORAGE_STATIC), |
||||
/* GRPC_MDELEM_ACCEPT_ENCODING_GZIP_COMMA_DEFLATE:
|
||||
"accept-encoding": "gzip, deflate" */ |
||||
GRPC_MAKE_MDELEM( |
||||
&g_static_mdelem_table[15].data(), |
||||
GRPC_MDELEM_STORAGE_STATIC), |
||||
/* GRPC_MDELEM_ACCEPT_LANGUAGE_EMPTY:
|
||||
"accept-language": "" */ |
||||
GRPC_MAKE_MDELEM( |
||||
&g_static_mdelem_table[16].data(), |
||||
GRPC_MDELEM_STORAGE_STATIC), |
||||
/* GRPC_MDELEM_ACCEPT_RANGES_EMPTY:
|
||||
"accept-ranges": "" */ |
||||
GRPC_MAKE_MDELEM( |
||||
&g_static_mdelem_table[17].data(), |
||||
GRPC_MDELEM_STORAGE_STATIC), |
||||
/* GRPC_MDELEM_ACCEPT_EMPTY:
|
||||
"accept": "" */ |
||||
GRPC_MAKE_MDELEM( |
||||
&g_static_mdelem_table[18].data(), |
||||
GRPC_MDELEM_STORAGE_STATIC), |
||||
/* GRPC_MDELEM_ACCESS_CONTROL_ALLOW_ORIGIN_EMPTY:
|
||||
"access-control-allow-origin": "" */ |
||||
GRPC_MAKE_MDELEM( |
||||
&g_static_mdelem_table[19].data(), |
||||
GRPC_MDELEM_STORAGE_STATIC), |
||||
/* GRPC_MDELEM_AGE_EMPTY:
|
||||
"age": "" */ |
||||
GRPC_MAKE_MDELEM( |
||||
&g_static_mdelem_table[20].data(), |
||||
GRPC_MDELEM_STORAGE_STATIC), |
||||
/* GRPC_MDELEM_ALLOW_EMPTY:
|
||||
"allow": "" */ |
||||
GRPC_MAKE_MDELEM( |
||||
&g_static_mdelem_table[21].data(), |
||||
GRPC_MDELEM_STORAGE_STATIC), |
||||
/* GRPC_MDELEM_AUTHORIZATION_EMPTY:
|
||||
"authorization": "" */ |
||||
GRPC_MAKE_MDELEM( |
||||
&g_static_mdelem_table[22].data(), |
||||
GRPC_MDELEM_STORAGE_STATIC), |
||||
/* GRPC_MDELEM_CACHE_CONTROL_EMPTY:
|
||||
"cache-control": "" */ |
||||
GRPC_MAKE_MDELEM( |
||||
&g_static_mdelem_table[23].data(), |
||||
GRPC_MDELEM_STORAGE_STATIC), |
||||
/* GRPC_MDELEM_CONTENT_DISPOSITION_EMPTY:
|
||||
"content-disposition": "" */ |
||||
GRPC_MAKE_MDELEM( |
||||
&g_static_mdelem_table[24].data(), |
||||
GRPC_MDELEM_STORAGE_STATIC), |
||||
/* GRPC_MDELEM_CONTENT_ENCODING_EMPTY:
|
||||
"content-encoding": "" */ |
||||
GRPC_MAKE_MDELEM( |
||||
&g_static_mdelem_table[25].data(), |
||||
GRPC_MDELEM_STORAGE_STATIC), |
||||
/* GRPC_MDELEM_CONTENT_LANGUAGE_EMPTY:
|
||||
"content-language": "" */ |
||||
GRPC_MAKE_MDELEM( |
||||
&g_static_mdelem_table[26].data(), |
||||
GRPC_MDELEM_STORAGE_STATIC), |
||||
/* GRPC_MDELEM_CONTENT_LENGTH_EMPTY:
|
||||
"content-length": "" */ |
||||
GRPC_MAKE_MDELEM( |
||||
&g_static_mdelem_table[27].data(), |
||||
GRPC_MDELEM_STORAGE_STATIC), |
||||
/* GRPC_MDELEM_CONTENT_LOCATION_EMPTY:
|
||||
"content-location": "" */ |
||||
GRPC_MAKE_MDELEM( |
||||
&g_static_mdelem_table[28].data(), |
||||
GRPC_MDELEM_STORAGE_STATIC), |
||||
/* GRPC_MDELEM_CONTENT_RANGE_EMPTY:
|
||||
"content-range": "" */ |
||||
GRPC_MAKE_MDELEM( |
||||
&g_static_mdelem_table[29].data(), |
||||
GRPC_MDELEM_STORAGE_STATIC), |
||||
/* GRPC_MDELEM_CONTENT_TYPE_EMPTY:
|
||||
"content-type": "" */ |
||||
GRPC_MAKE_MDELEM( |
||||
&g_static_mdelem_table[30].data(), |
||||
GRPC_MDELEM_STORAGE_STATIC), |
||||
/* GRPC_MDELEM_COOKIE_EMPTY:
|
||||
"cookie": "" */ |
||||
GRPC_MAKE_MDELEM( |
||||
&g_static_mdelem_table[31].data(), |
||||
GRPC_MDELEM_STORAGE_STATIC), |
||||
/* GRPC_MDELEM_DATE_EMPTY:
|
||||
"date": "" */ |
||||
GRPC_MAKE_MDELEM( |
||||
&g_static_mdelem_table[32].data(), |
||||
GRPC_MDELEM_STORAGE_STATIC), |
||||
/* GRPC_MDELEM_ETAG_EMPTY:
|
||||
"etag": "" */ |
||||
GRPC_MAKE_MDELEM( |
||||
&g_static_mdelem_table[33].data(), |
||||
GRPC_MDELEM_STORAGE_STATIC), |
||||
/* GRPC_MDELEM_EXPECT_EMPTY:
|
||||
"expect": "" */ |
||||
GRPC_MAKE_MDELEM( |
||||
&g_static_mdelem_table[34].data(), |
||||
GRPC_MDELEM_STORAGE_STATIC), |
||||
/* GRPC_MDELEM_EXPIRES_EMPTY:
|
||||
"expires": "" */ |
||||
GRPC_MAKE_MDELEM( |
||||
&g_static_mdelem_table[35].data(), |
||||
GRPC_MDELEM_STORAGE_STATIC), |
||||
/* GRPC_MDELEM_FROM_EMPTY:
|
||||
"from": "" */ |
||||
GRPC_MAKE_MDELEM( |
||||
&g_static_mdelem_table[36].data(), |
||||
GRPC_MDELEM_STORAGE_STATIC), |
||||
/* GRPC_MDELEM_HOST_EMPTY:
|
||||
"host": "" */ |
||||
GRPC_MAKE_MDELEM( |
||||
&g_static_mdelem_table[37].data(), |
||||
GRPC_MDELEM_STORAGE_STATIC), |
||||
/* GRPC_MDELEM_IF_MATCH_EMPTY:
|
||||
"if-match": "" */ |
||||
GRPC_MAKE_MDELEM( |
||||
&g_static_mdelem_table[38].data(), |
||||
GRPC_MDELEM_STORAGE_STATIC), |
||||
/* GRPC_MDELEM_IF_MODIFIED_SINCE_EMPTY:
|
||||
"if-modified-since": "" */ |
||||
GRPC_MAKE_MDELEM( |
||||
&g_static_mdelem_table[39].data(), |
||||
GRPC_MDELEM_STORAGE_STATIC), |
||||
/* GRPC_MDELEM_IF_NONE_MATCH_EMPTY:
|
||||
"if-none-match": "" */ |
||||
GRPC_MAKE_MDELEM( |
||||
&g_static_mdelem_table[40].data(), |
||||
GRPC_MDELEM_STORAGE_STATIC), |
||||
/* GRPC_MDELEM_IF_RANGE_EMPTY:
|
||||
"if-range": "" */ |
||||
GRPC_MAKE_MDELEM( |
||||
&g_static_mdelem_table[41].data(), |
||||
GRPC_MDELEM_STORAGE_STATIC), |
||||
/* GRPC_MDELEM_IF_UNMODIFIED_SINCE_EMPTY:
|
||||
"if-unmodified-since": "" */ |
||||
GRPC_MAKE_MDELEM( |
||||
&g_static_mdelem_table[42].data(), |
||||
GRPC_MDELEM_STORAGE_STATIC), |
||||
/* GRPC_MDELEM_LAST_MODIFIED_EMPTY:
|
||||
"last-modified": "" */ |
||||
GRPC_MAKE_MDELEM( |
||||
&g_static_mdelem_table[43].data(), |
||||
GRPC_MDELEM_STORAGE_STATIC), |
||||
/* GRPC_MDELEM_LINK_EMPTY:
|
||||
"link": "" */ |
||||
GRPC_MAKE_MDELEM( |
||||
&g_static_mdelem_table[44].data(), |
||||
GRPC_MDELEM_STORAGE_STATIC), |
||||
/* GRPC_MDELEM_LOCATION_EMPTY:
|
||||
"location": "" */ |
||||
GRPC_MAKE_MDELEM( |
||||
&g_static_mdelem_table[45].data(), |
||||
GRPC_MDELEM_STORAGE_STATIC), |
||||
/* GRPC_MDELEM_MAX_FORWARDS_EMPTY:
|
||||
"max-forwards": "" */ |
||||
GRPC_MAKE_MDELEM( |
||||
&g_static_mdelem_table[46].data(), |
||||
GRPC_MDELEM_STORAGE_STATIC), |
||||
/* GRPC_MDELEM_PROXY_AUTHENTICATE_EMPTY:
|
||||
"proxy-authenticate": "" */ |
||||
GRPC_MAKE_MDELEM( |
||||
&g_static_mdelem_table[47].data(), |
||||
GRPC_MDELEM_STORAGE_STATIC), |
||||
/* GRPC_MDELEM_PROXY_AUTHORIZATION_EMPTY:
|
||||
"proxy-authorization": "" */ |
||||
GRPC_MAKE_MDELEM( |
||||
&g_static_mdelem_table[48].data(), |
||||
GRPC_MDELEM_STORAGE_STATIC), |
||||
/* GRPC_MDELEM_RANGE_EMPTY:
|
||||
"range": "" */ |
||||
GRPC_MAKE_MDELEM( |
||||
&g_static_mdelem_table[49].data(), |
||||
GRPC_MDELEM_STORAGE_STATIC), |
||||
/* GRPC_MDELEM_REFERER_EMPTY:
|
||||
"referer": "" */ |
||||
GRPC_MAKE_MDELEM( |
||||
&g_static_mdelem_table[50].data(), |
||||
GRPC_MDELEM_STORAGE_STATIC), |
||||
/* GRPC_MDELEM_REFRESH_EMPTY:
|
||||
"refresh": "" */ |
||||
GRPC_MAKE_MDELEM( |
||||
&g_static_mdelem_table[51].data(), |
||||
GRPC_MDELEM_STORAGE_STATIC), |
||||
/* GRPC_MDELEM_RETRY_AFTER_EMPTY:
|
||||
"retry-after": "" */ |
||||
GRPC_MAKE_MDELEM( |
||||
&g_static_mdelem_table[52].data(), |
||||
GRPC_MDELEM_STORAGE_STATIC), |
||||
/* GRPC_MDELEM_SERVER_EMPTY:
|
||||
"server": "" */ |
||||
GRPC_MAKE_MDELEM( |
||||
&g_static_mdelem_table[53].data(), |
||||
GRPC_MDELEM_STORAGE_STATIC), |
||||
/* GRPC_MDELEM_SET_COOKIE_EMPTY:
|
||||
"set-cookie": "" */ |
||||
GRPC_MAKE_MDELEM( |
||||
&g_static_mdelem_table[54].data(), |
||||
GRPC_MDELEM_STORAGE_STATIC), |
||||
/* GRPC_MDELEM_STRICT_TRANSPORT_SECURITY_EMPTY:
|
||||
"strict-transport-security": "" */ |
||||
GRPC_MAKE_MDELEM( |
||||
&g_static_mdelem_table[55].data(), |
||||
GRPC_MDELEM_STORAGE_STATIC), |
||||
/* GRPC_MDELEM_TRANSFER_ENCODING_EMPTY:
|
||||
"transfer-encoding": "" */ |
||||
GRPC_MAKE_MDELEM( |
||||
&g_static_mdelem_table[56].data(), |
||||
GRPC_MDELEM_STORAGE_STATIC), |
||||
/* GRPC_MDELEM_USER_AGENT_EMPTY:
|
||||
"user-agent": "" */ |
||||
GRPC_MAKE_MDELEM( |
||||
&g_static_mdelem_table[57].data(), |
||||
GRPC_MDELEM_STORAGE_STATIC), |
||||
/* GRPC_MDELEM_VARY_EMPTY:
|
||||
"vary": "" */ |
||||
GRPC_MAKE_MDELEM( |
||||
&g_static_mdelem_table[58].data(), |
||||
GRPC_MDELEM_STORAGE_STATIC), |
||||
/* GRPC_MDELEM_VIA_EMPTY:
|
||||
"via": "" */ |
||||
GRPC_MAKE_MDELEM( |
||||
&g_static_mdelem_table[59].data(), |
||||
GRPC_MDELEM_STORAGE_STATIC), |
||||
/* GRPC_MDELEM_WWW_AUTHENTICATE_EMPTY:
|
||||
"www-authenticate": "" */ |
||||
GRPC_MAKE_MDELEM( |
||||
&g_static_mdelem_table[60].data(), |
||||
GRPC_MDELEM_STORAGE_STATIC), |
||||
/* GRPC_MDELEM_LB_COST_BIN_EMPTY:
|
||||
"lb-cost-bin": "" */ |
||||
GRPC_MAKE_MDELEM( |
||||
&g_static_mdelem_table[61].data(), |
||||
GRPC_MDELEM_STORAGE_STATIC) |
||||
// clang-format on
|
||||
}; |
||||
} // namespace grpc_core
|
||||
|
||||
uintptr_t grpc_static_mdelem_user_data[GRPC_STATIC_MDELEM_COUNT] = { |
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; |
||||
|
||||
static const int8_t elems_r[] = { |
||||
13, -11, 0, 0, -27, 0, 0, -43, 0, 0, -59, 0, 0, 0, 0, |
||||
0, 0, 0, 0, -4, -37, 0, -17, -21, -25, -29, -33, -37, -41, -45, |
||||
0, 23, 19, 15, 11, 7, 3, -1, -5, -9, -13, -17, -21, -25, -29, |
||||
-33, 0, 35, 31, 27, 23, 19, 15, 11, 7, 3, -1, -5, -9, -13, |
||||
-17, 0, 51, 47, 43, 39, 35, 31, 27, 23, 19, 0}; |
||||
static uint32_t elems_phash(uint32_t i) { |
||||
i -= 771; |
||||
uint32_t x = i % 72; |
||||
uint32_t y = i / 72; |
||||
uint32_t h = x; |
||||
if (y < GPR_ARRAY_SIZE(elems_r)) { |
||||
uint32_t delta = static_cast<uint32_t>(elems_r[y]); |
||||
h += delta; |
||||
} |
||||
return h; |
||||
} |
||||
|
||||
static const uint16_t elem_keys[] = { |
||||
1563, 1564, 1565, 1566, 1567, 859, 860, 1093, 1094, 1327, 1328, |
||||
1561, 1562, 771, 2157, 2263, 2388, 2465, 2542, 2619, 2696, 2773, |
||||
2850, 2927, 3004, 3081, 3158, 3235, 3312, 3389, 3466, 3543, 3620, |
||||
3697, 3774, 3851, 3928, 4005, 4082, 4159, 4236, 4313, 4390, 4467, |
||||
4544, 4621, 4698, 4775, 4852, 4929, 5006, 5083, 5160, 5237, 5314, |
||||
5391, 5468, 5545, 5622, 5699, 5776, 5853}; |
||||
static const uint8_t elem_idxs[] = { |
||||
9, 10, 11, 12, 13, 1, 2, 3, 4, 5, 6, 7, 8, 0, 14, 15, |
||||
16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, |
||||
32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, |
||||
48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61}; |
||||
|
||||
grpc_mdelem grpc_static_mdelem_for_static_strings(intptr_t a, intptr_t b) { |
||||
if (a == -1 || b == -1) return GRPC_MDNULL; |
||||
uint32_t k = static_cast<uint32_t>(a * 77 + b); |
||||
uint32_t h = elems_phash(k); |
||||
return h < GPR_ARRAY_SIZE(elem_keys) && elem_keys[h] == k && |
||||
elem_idxs[h] != 255 |
||||
? GRPC_MAKE_MDELEM( |
||||
&grpc_core::g_static_mdelem_table[elem_idxs[h]].data(), |
||||
GRPC_MDELEM_STORAGE_STATIC) |
||||
: GRPC_MDNULL; |
||||
} |
||||
@ -1,200 +0,0 @@ |
||||
/*
|
||||
* Copyright 2015 gRPC authors. |
||||
* |
||||
* Licensed under the Apache License, Version 2.0 (the "License"); |
||||
* you may not use this file except in compliance with the License. |
||||
* You may obtain a copy of the License at |
||||
* |
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
* |
||||
* Unless required by applicable law or agreed to in writing, software |
||||
* distributed under the License is distributed on an "AS IS" BASIS, |
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
||||
* See the License for the specific language governing permissions and |
||||
* limitations under the License. |
||||
*/ |
||||
|
||||
/*
|
||||
* WARNING: Auto-generated code. |
||||
* |
||||
* To make changes to this file, change |
||||
* tools/codegen/core/gen_static_metadata.py, and then re-run it. |
||||
* |
||||
* See metadata.h for an explanation of the interface here, and metadata.cc for |
||||
* an explanation of what's going on. |
||||
*/ |
||||
|
||||
#ifndef GRPC_CORE_LIB_TRANSPORT_STATIC_METADATA_H |
||||
#define GRPC_CORE_LIB_TRANSPORT_STATIC_METADATA_H |
||||
|
||||
#include <grpc/support/port_platform.h> |
||||
|
||||
#include <cstdint> |
||||
|
||||
#include "src/core/lib/slice/static_slice.h" |
||||
#include "src/core/lib/transport/metadata.h" |
||||
|
||||
#define GRPC_STATIC_MDELEM_COUNT 62 |
||||
|
||||
namespace grpc_core { |
||||
extern StaticMetadata g_static_mdelem_table[GRPC_STATIC_MDELEM_COUNT]; |
||||
extern grpc_mdelem g_static_mdelem_manifested[GRPC_STATIC_MDELEM_COUNT]; |
||||
} // namespace grpc_core
|
||||
|
||||
extern uintptr_t grpc_static_mdelem_user_data[GRPC_STATIC_MDELEM_COUNT]; |
||||
/* ":authority": "" */ |
||||
#define GRPC_MDELEM_AUTHORITY_EMPTY (::grpc_core::g_static_mdelem_manifested[0]) |
||||
/* ":method": "GET" */ |
||||
#define GRPC_MDELEM_METHOD_GET (::grpc_core::g_static_mdelem_manifested[1]) |
||||
/* ":method": "POST" */ |
||||
#define GRPC_MDELEM_METHOD_POST (::grpc_core::g_static_mdelem_manifested[2]) |
||||
/* ":path": "/" */ |
||||
#define GRPC_MDELEM_PATH_SLASH (::grpc_core::g_static_mdelem_manifested[3]) |
||||
/* ":path": "/index.html" */ |
||||
#define GRPC_MDELEM_PATH_SLASH_INDEX_DOT_HTML \ |
||||
(::grpc_core::g_static_mdelem_manifested[4]) |
||||
/* ":scheme": "http" */ |
||||
#define GRPC_MDELEM_SCHEME_HTTP (::grpc_core::g_static_mdelem_manifested[5]) |
||||
/* ":scheme": "https" */ |
||||
#define GRPC_MDELEM_SCHEME_HTTPS (::grpc_core::g_static_mdelem_manifested[6]) |
||||
/* ":status": "200" */ |
||||
#define GRPC_MDELEM_STATUS_200 (::grpc_core::g_static_mdelem_manifested[7]) |
||||
/* ":status": "204" */ |
||||
#define GRPC_MDELEM_STATUS_204 (::grpc_core::g_static_mdelem_manifested[8]) |
||||
/* ":status": "206" */ |
||||
#define GRPC_MDELEM_STATUS_206 (::grpc_core::g_static_mdelem_manifested[9]) |
||||
/* ":status": "304" */ |
||||
#define GRPC_MDELEM_STATUS_304 (::grpc_core::g_static_mdelem_manifested[10]) |
||||
/* ":status": "400" */ |
||||
#define GRPC_MDELEM_STATUS_400 (::grpc_core::g_static_mdelem_manifested[11]) |
||||
/* ":status": "404" */ |
||||
#define GRPC_MDELEM_STATUS_404 (::grpc_core::g_static_mdelem_manifested[12]) |
||||
/* ":status": "500" */ |
||||
#define GRPC_MDELEM_STATUS_500 (::grpc_core::g_static_mdelem_manifested[13]) |
||||
/* "accept-charset": "" */ |
||||
#define GRPC_MDELEM_ACCEPT_CHARSET_EMPTY \ |
||||
(::grpc_core::g_static_mdelem_manifested[14]) |
||||
/* "accept-encoding": "gzip, deflate" */ |
||||
#define GRPC_MDELEM_ACCEPT_ENCODING_GZIP_COMMA_DEFLATE \ |
||||
(::grpc_core::g_static_mdelem_manifested[15]) |
||||
/* "accept-language": "" */ |
||||
#define GRPC_MDELEM_ACCEPT_LANGUAGE_EMPTY \ |
||||
(::grpc_core::g_static_mdelem_manifested[16]) |
||||
/* "accept-ranges": "" */ |
||||
#define GRPC_MDELEM_ACCEPT_RANGES_EMPTY \ |
||||
(::grpc_core::g_static_mdelem_manifested[17]) |
||||
/* "accept": "" */ |
||||
#define GRPC_MDELEM_ACCEPT_EMPTY (::grpc_core::g_static_mdelem_manifested[18]) |
||||
/* "access-control-allow-origin": "" */ |
||||
#define GRPC_MDELEM_ACCESS_CONTROL_ALLOW_ORIGIN_EMPTY \ |
||||
(::grpc_core::g_static_mdelem_manifested[19]) |
||||
/* "age": "" */ |
||||
#define GRPC_MDELEM_AGE_EMPTY (::grpc_core::g_static_mdelem_manifested[20]) |
||||
/* "allow": "" */ |
||||
#define GRPC_MDELEM_ALLOW_EMPTY (::grpc_core::g_static_mdelem_manifested[21]) |
||||
/* "authorization": "" */ |
||||
#define GRPC_MDELEM_AUTHORIZATION_EMPTY \ |
||||
(::grpc_core::g_static_mdelem_manifested[22]) |
||||
/* "cache-control": "" */ |
||||
#define GRPC_MDELEM_CACHE_CONTROL_EMPTY \ |
||||
(::grpc_core::g_static_mdelem_manifested[23]) |
||||
/* "content-disposition": "" */ |
||||
#define GRPC_MDELEM_CONTENT_DISPOSITION_EMPTY \ |
||||
(::grpc_core::g_static_mdelem_manifested[24]) |
||||
/* "content-encoding": "" */ |
||||
#define GRPC_MDELEM_CONTENT_ENCODING_EMPTY \ |
||||
(::grpc_core::g_static_mdelem_manifested[25]) |
||||
/* "content-language": "" */ |
||||
#define GRPC_MDELEM_CONTENT_LANGUAGE_EMPTY \ |
||||
(::grpc_core::g_static_mdelem_manifested[26]) |
||||
/* "content-length": "" */ |
||||
#define GRPC_MDELEM_CONTENT_LENGTH_EMPTY \ |
||||
(::grpc_core::g_static_mdelem_manifested[27]) |
||||
/* "content-location": "" */ |
||||
#define GRPC_MDELEM_CONTENT_LOCATION_EMPTY \ |
||||
(::grpc_core::g_static_mdelem_manifested[28]) |
||||
/* "content-range": "" */ |
||||
#define GRPC_MDELEM_CONTENT_RANGE_EMPTY \ |
||||
(::grpc_core::g_static_mdelem_manifested[29]) |
||||
/* "content-type": "" */ |
||||
#define GRPC_MDELEM_CONTENT_TYPE_EMPTY \ |
||||
(::grpc_core::g_static_mdelem_manifested[30]) |
||||
/* "cookie": "" */ |
||||
#define GRPC_MDELEM_COOKIE_EMPTY (::grpc_core::g_static_mdelem_manifested[31]) |
||||
/* "date": "" */ |
||||
#define GRPC_MDELEM_DATE_EMPTY (::grpc_core::g_static_mdelem_manifested[32]) |
||||
/* "etag": "" */ |
||||
#define GRPC_MDELEM_ETAG_EMPTY (::grpc_core::g_static_mdelem_manifested[33]) |
||||
/* "expect": "" */ |
||||
#define GRPC_MDELEM_EXPECT_EMPTY (::grpc_core::g_static_mdelem_manifested[34]) |
||||
/* "expires": "" */ |
||||
#define GRPC_MDELEM_EXPIRES_EMPTY (::grpc_core::g_static_mdelem_manifested[35]) |
||||
/* "from": "" */ |
||||
#define GRPC_MDELEM_FROM_EMPTY (::grpc_core::g_static_mdelem_manifested[36]) |
||||
/* "host": "" */ |
||||
#define GRPC_MDELEM_HOST_EMPTY (::grpc_core::g_static_mdelem_manifested[37]) |
||||
/* "if-match": "" */ |
||||
#define GRPC_MDELEM_IF_MATCH_EMPTY (::grpc_core::g_static_mdelem_manifested[38]) |
||||
/* "if-modified-since": "" */ |
||||
#define GRPC_MDELEM_IF_MODIFIED_SINCE_EMPTY \ |
||||
(::grpc_core::g_static_mdelem_manifested[39]) |
||||
/* "if-none-match": "" */ |
||||
#define GRPC_MDELEM_IF_NONE_MATCH_EMPTY \ |
||||
(::grpc_core::g_static_mdelem_manifested[40]) |
||||
/* "if-range": "" */ |
||||
#define GRPC_MDELEM_IF_RANGE_EMPTY (::grpc_core::g_static_mdelem_manifested[41]) |
||||
/* "if-unmodified-since": "" */ |
||||
#define GRPC_MDELEM_IF_UNMODIFIED_SINCE_EMPTY \ |
||||
(::grpc_core::g_static_mdelem_manifested[42]) |
||||
/* "last-modified": "" */ |
||||
#define GRPC_MDELEM_LAST_MODIFIED_EMPTY \ |
||||
(::grpc_core::g_static_mdelem_manifested[43]) |
||||
/* "link": "" */ |
||||
#define GRPC_MDELEM_LINK_EMPTY (::grpc_core::g_static_mdelem_manifested[44]) |
||||
/* "location": "" */ |
||||
#define GRPC_MDELEM_LOCATION_EMPTY (::grpc_core::g_static_mdelem_manifested[45]) |
||||
/* "max-forwards": "" */ |
||||
#define GRPC_MDELEM_MAX_FORWARDS_EMPTY \ |
||||
(::grpc_core::g_static_mdelem_manifested[46]) |
||||
/* "proxy-authenticate": "" */ |
||||
#define GRPC_MDELEM_PROXY_AUTHENTICATE_EMPTY \ |
||||
(::grpc_core::g_static_mdelem_manifested[47]) |
||||
/* "proxy-authorization": "" */ |
||||
#define GRPC_MDELEM_PROXY_AUTHORIZATION_EMPTY \ |
||||
(::grpc_core::g_static_mdelem_manifested[48]) |
||||
/* "range": "" */ |
||||
#define GRPC_MDELEM_RANGE_EMPTY (::grpc_core::g_static_mdelem_manifested[49]) |
||||
/* "referer": "" */ |
||||
#define GRPC_MDELEM_REFERER_EMPTY (::grpc_core::g_static_mdelem_manifested[50]) |
||||
/* "refresh": "" */ |
||||
#define GRPC_MDELEM_REFRESH_EMPTY (::grpc_core::g_static_mdelem_manifested[51]) |
||||
/* "retry-after": "" */ |
||||
#define GRPC_MDELEM_RETRY_AFTER_EMPTY \ |
||||
(::grpc_core::g_static_mdelem_manifested[52]) |
||||
/* "server": "" */ |
||||
#define GRPC_MDELEM_SERVER_EMPTY (::grpc_core::g_static_mdelem_manifested[53]) |
||||
/* "set-cookie": "" */ |
||||
#define GRPC_MDELEM_SET_COOKIE_EMPTY \ |
||||
(::grpc_core::g_static_mdelem_manifested[54]) |
||||
/* "strict-transport-security": "" */ |
||||
#define GRPC_MDELEM_STRICT_TRANSPORT_SECURITY_EMPTY \ |
||||
(::grpc_core::g_static_mdelem_manifested[55]) |
||||
/* "transfer-encoding": "" */ |
||||
#define GRPC_MDELEM_TRANSFER_ENCODING_EMPTY \ |
||||
(::grpc_core::g_static_mdelem_manifested[56]) |
||||
/* "user-agent": "" */ |
||||
#define GRPC_MDELEM_USER_AGENT_EMPTY \ |
||||
(::grpc_core::g_static_mdelem_manifested[57]) |
||||
/* "vary": "" */ |
||||
#define GRPC_MDELEM_VARY_EMPTY (::grpc_core::g_static_mdelem_manifested[58]) |
||||
/* "via": "" */ |
||||
#define GRPC_MDELEM_VIA_EMPTY (::grpc_core::g_static_mdelem_manifested[59]) |
||||
/* "www-authenticate": "" */ |
||||
#define GRPC_MDELEM_WWW_AUTHENTICATE_EMPTY \ |
||||
(::grpc_core::g_static_mdelem_manifested[60]) |
||||
/* "lb-cost-bin": "" */ |
||||
#define GRPC_MDELEM_LB_COST_BIN_EMPTY \ |
||||
(::grpc_core::g_static_mdelem_manifested[61]) |
||||
|
||||
grpc_mdelem grpc_static_mdelem_for_static_strings(intptr_t a, intptr_t b); |
||||
#endif /* GRPC_CORE_LIB_TRANSPORT_STATIC_METADATA_H */ |
||||
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in new issue