1 //
2 //
3 // Copyright 2016 gRPC authors.
4 //
5 // Licensed under the Apache License, Version 2.0 (the "License");
6 // you may not use this file except in compliance with the License.
7 // You may obtain a copy of the License at
8 //
9 // http://www.apache.org/licenses/LICENSE-2.0
10 //
11 // Unless required by applicable law or agreed to in writing, software
12 // distributed under the License is distributed on an "AS IS" BASIS,
13 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 // See the License for the specific language governing permissions and
15 // limitations under the License.
16 //
17 //
18
19 #include <grpc/support/port_platform.h>
20
21 #include "src/core/lib/surface/validate_metadata.h"
22
23 #include "absl/status/status.h"
24 #include "absl/strings/string_view.h"
25
26 #include <grpc/grpc.h>
27
28 #include "src/core/lib/gprpp/bitset.h"
29 #include "src/core/lib/iomgr/error.h"
30 #include "src/core/lib/slice/slice_internal.h"
31
32 namespace grpc_core {
33
34 namespace {
35 class LegalHeaderKeyBits : public BitSet<256> {
36 public:
LegalHeaderKeyBits()37 constexpr LegalHeaderKeyBits() {
38 for (int i = 'a'; i <= 'z'; i++) set(i);
39 for (int i = '0'; i <= '9'; i++) set(i);
40 set('-');
41 set('_');
42 set('.');
43 }
44 };
45 constexpr LegalHeaderKeyBits g_legal_header_key_bits;
46
ConformsTo(absl::string_view x,const BitSet<256> & legal_bits,ValidateMetadataResult error)47 ValidateMetadataResult ConformsTo(absl::string_view x,
48 const BitSet<256>& legal_bits,
49 ValidateMetadataResult error) {
50 for (uint8_t c : x) {
51 if (!legal_bits.is_set(c)) {
52 return error;
53 }
54 }
55 return ValidateMetadataResult::kOk;
56 }
57
UpgradeToStatus(ValidateMetadataResult result)58 absl::Status UpgradeToStatus(ValidateMetadataResult result) {
59 if (result == ValidateMetadataResult::kOk) return absl::OkStatus();
60 return absl::InternalError(ValidateMetadataResultToString(result));
61 }
62
63 } // namespace
64
ValidateHeaderKeyIsLegal(absl::string_view key)65 ValidateMetadataResult ValidateHeaderKeyIsLegal(absl::string_view key) {
66 if (key.empty()) {
67 return ValidateMetadataResult::kCannotBeZeroLength;
68 }
69 if (key.size() > UINT32_MAX) {
70 return ValidateMetadataResult::kTooLong;
71 }
72 return ConformsTo(key, g_legal_header_key_bits,
73 ValidateMetadataResult::kIllegalHeaderKey);
74 }
75
ValidateMetadataResultToString(ValidateMetadataResult result)76 const char* ValidateMetadataResultToString(ValidateMetadataResult result) {
77 switch (result) {
78 case ValidateMetadataResult::kOk:
79 return "Ok";
80 case ValidateMetadataResult::kCannotBeZeroLength:
81 return "Metadata keys cannot be zero length";
82 case ValidateMetadataResult::kTooLong:
83 return "Metadata keys cannot be larger than UINT32_MAX";
84 case ValidateMetadataResult::kIllegalHeaderKey:
85 return "Illegal header key";
86 case ValidateMetadataResult::kIllegalHeaderValue:
87 return "Illegal header value";
88 }
89 GPR_UNREACHABLE_CODE(return "Unknown");
90 }
91
92 } // namespace grpc_core
93
error2int(grpc_error_handle error)94 static int error2int(grpc_error_handle error) {
95 int r = (error.ok());
96 return r;
97 }
98
grpc_validate_header_key_is_legal(const grpc_slice & slice)99 grpc_error_handle grpc_validate_header_key_is_legal(const grpc_slice& slice) {
100 return grpc_core::UpgradeToStatus(grpc_core::ValidateHeaderKeyIsLegal(
101 grpc_core::StringViewFromSlice(slice)));
102 }
103
grpc_header_key_is_legal(grpc_slice slice)104 int grpc_header_key_is_legal(grpc_slice slice) {
105 return error2int(grpc_validate_header_key_is_legal(slice));
106 }
107
108 namespace {
109 class LegalHeaderNonBinValueBits : public grpc_core::BitSet<256> {
110 public:
LegalHeaderNonBinValueBits()111 constexpr LegalHeaderNonBinValueBits() {
112 for (int i = 32; i <= 126; i++) {
113 set(i);
114 }
115 }
116 };
117 constexpr LegalHeaderNonBinValueBits g_legal_header_non_bin_value_bits;
118 } // namespace
119
grpc_validate_header_nonbin_value_is_legal(const grpc_slice & slice)120 grpc_error_handle grpc_validate_header_nonbin_value_is_legal(
121 const grpc_slice& slice) {
122 return grpc_core::UpgradeToStatus(grpc_core::ConformsTo(
123 grpc_core::StringViewFromSlice(slice), g_legal_header_non_bin_value_bits,
124 grpc_core::ValidateMetadataResult::kIllegalHeaderValue));
125 }
126
grpc_header_nonbin_value_is_legal(grpc_slice slice)127 int grpc_header_nonbin_value_is_legal(grpc_slice slice) {
128 return error2int(grpc_validate_header_nonbin_value_is_legal(slice));
129 }
130
grpc_is_binary_header_internal(const grpc_slice & slice)131 int grpc_is_binary_header_internal(const grpc_slice& slice) {
132 return grpc_key_is_binary_header(GRPC_SLICE_START_PTR(slice),
133 GRPC_SLICE_LENGTH(slice));
134 }
135
grpc_is_binary_header(grpc_slice slice)136 int grpc_is_binary_header(grpc_slice slice) {
137 return grpc_is_binary_header_internal(slice);
138 }
139