diff --git a/grpc.def b/grpc.def
index a4989ada582214db0c3142b50894092b6e3538cf..c54d798f3672d655b35223bcefeefdd047cc1325 100644
--- a/grpc.def
+++ b/grpc.def
@@ -92,11 +92,8 @@ EXPORTS
grpc_server_destroy
grpc_tracer_set_enabled
grpc_header_key_is_legal
- grpc_header_key_slice_is_legal
grpc_header_nonbin_value_is_legal
- grpc_header_nonbin_value_slice_is_legal
grpc_is_binary_header
- grpc_slice_is_binary_header
grpc_call_error_to_string
grpc_resource_quota_create
grpc_resource_quota_ref
@@ -153,6 +150,7 @@ EXPORTS
grpc_slice_split_tail
grpc_slice_split_head
grpc_empty_slice
+ grpc_slice_default_hash_impl
grpc_slice_cmp
grpc_slice_str_cmp
grpc_slice_buf_cmp
diff --git a/include/grpc/grpc.h b/include/grpc/grpc.h
index a3015340ee028555637d60aa0e684b250001af60..2f3b37ad805b1c9da07da0c7b1e5b487abfc0a56 100644
--- a/include/grpc/grpc.h
+++ b/include/grpc/grpc.h
@@ -396,17 +396,14 @@ GRPCAPI void grpc_server_destroy(grpc_server *server);
GRPCAPI int grpc_tracer_set_enabled(const char *name, int enabled);
/** Check whether a metadata key is legal (will be accepted by core) */
-GRPCAPI int grpc_header_key_is_legal(const char *key, size_t length);
-GRPCAPI int grpc_header_key_slice_is_legal(grpc_slice slice);
+GRPCAPI int grpc_header_key_is_legal(grpc_slice slice);
/** Check whether a non-binary metadata value is legal (will be accepted by
core) */
-GRPCAPI int grpc_header_nonbin_value_is_legal(const char *value, size_t length);
-GRPCAPI int grpc_header_nonbin_value_slice_is_legal(grpc_slice slice);
+GRPCAPI int grpc_header_nonbin_value_is_legal(grpc_slice slice);
/** Check whether a metadata key corresponds to a binary value */
-GRPCAPI int grpc_is_binary_header(const char *key, size_t length);
-GRPCAPI int grpc_slice_is_binary_header(grpc_slice slice);
+GRPCAPI int grpc_is_binary_header(grpc_slice slice);
/** Convert grpc_call_error values to a string */
GRPCAPI const char *grpc_call_error_to_string(grpc_call_error error);
diff --git a/include/grpc/slice.h b/include/grpc/slice.h
index 514592e79b329dfc627ab0017433c04c965e1aef..711124d86598f5d47135b27dafb620603b9536b1 100644
--- a/include/grpc/slice.h
+++ b/include/grpc/slice.h
@@ -99,6 +99,9 @@ GPRAPI grpc_slice grpc_slice_from_copied_buffer(const char *source, size_t len);
/* Create a slice pointing to constant memory */
GPRAPI grpc_slice grpc_slice_from_static_string(const char *source);
+/* Create a slice pointing to constant memory */
+GPRAPI grpc_slice grpc_slice_from_static_buffer(const void *source, size_t len);
+
/* Return a result slice derived from s, which shares a ref count with s, where
result.data==s.data+begin, and result.length==end-begin.
The ref count of s is increased by one.
@@ -130,9 +133,16 @@ GPRAPI int grpc_slice_cmp(grpc_slice a, grpc_slice b);
GPRAPI int grpc_slice_str_cmp(grpc_slice a, const char *b);
GPRAPI int grpc_slice_buf_cmp(grpc_slice a, const void *b, size_t blen);
+/* return non-zero if the first blen bytes of a are equal to b */
GPRAPI int grpc_slice_buf_start_eq(grpc_slice a, const void *b, size_t blen);
+/* return the index of the last instance of \a c in \a s, or -1 if not found */
GPRAPI int grpc_slice_rchr(grpc_slice s, char c);
+GPRAPI int grpc_slice_chr(grpc_slice s, char c);
+
+/* return the index of the first occurance of \a needle in \a haystack, or -1 if
+ * it's not found */
+GPRAPI int grpc_slice_slice(grpc_slice haystack, grpc_slice needle);
GPRAPI uint32_t grpc_slice_hash(grpc_slice s);
diff --git a/src/core/ext/transport/chttp2/transport/hpack_encoder.c b/src/core/ext/transport/chttp2/transport/hpack_encoder.c
index 651f813c7e6113c39272450313cbc293f7e77c8f..471c4cf5496086de35c12d101a40293fb8ebd879 100644
--- a/src/core/ext/transport/chttp2/transport/hpack_encoder.c
+++ b/src/core/ext/transport/chttp2/transport/hpack_encoder.c
@@ -286,7 +286,7 @@ static void emit_indexed(grpc_chttp2_hpack_compressor *c, uint32_t elem_index,
}
static grpc_slice get_wire_value(grpc_mdelem *elem, uint8_t *huffman_prefix) {
- if (grpc_slice_is_binary_header(elem->key)) {
+ if (grpc_is_binary_header(elem->key)) {
*huffman_prefix = 0x80;
return grpc_chttp2_base64_encode_and_huffman_compress(elem->value);
}
diff --git a/src/core/ext/transport/chttp2/transport/hpack_parser.c b/src/core/ext/transport/chttp2/transport/hpack_parser.c
index 86c65d4b5ae739a9c8144aaca571f69151b1e253..61227a0105d73dd67c328a988e3bc38d7de5ea20 100644
--- a/src/core/ext/transport/chttp2/transport/hpack_parser.c
+++ b/src/core/ext/transport/chttp2/transport/hpack_parser.c
@@ -1494,7 +1494,8 @@ static grpc_error *parse_key_string(grpc_exec_ctx *exec_ctx,
/* check if a key represents a binary header or not */
static bool is_binary_literal_header(grpc_chttp2_hpack_parser *p) {
- return grpc_is_binary_header(p->key.str, p->key.length);
+ return grpc_is_binary_header(
+ grpc_slice_from_static_buffer(p->key.str, p->key.length));
}
static grpc_error *is_binary_indexed_header(grpc_chttp2_hpack_parser *p,
@@ -1506,7 +1507,7 @@ static grpc_error *is_binary_indexed_header(grpc_chttp2_hpack_parser *p,
GRPC_ERROR_INT_INDEX, (intptr_t)p->index),
GRPC_ERROR_INT_SIZE, (intptr_t)p->table.num_ents);
}
- *is = grpc_slice_is_binary_header(elem->key);
+ *is = grpc_is_binary_header(elem->key);
return GRPC_ERROR_NONE;
}
diff --git a/src/core/lib/iomgr/ev_posix.c b/src/core/lib/iomgr/ev_posix.c
index ab139895fdc873a7271026a45c839cbf44adc171..e1484167602d959c80360d676de3de68ad89f877 100644
--- a/src/core/lib/iomgr/ev_posix.c
+++ b/src/core/lib/iomgr/ev_posix.c
@@ -52,6 +52,8 @@
* tests */
grpc_poll_function_type grpc_poll_function = poll;
+grpc_wakeup_fd grpc_global_wakeup_fd;
+
static const grpc_event_engine_vtable *g_event_engine;
static const char *g_poll_strategy_name = NULL;
diff --git a/src/core/lib/security/credentials/plugin/plugin_credentials.c b/src/core/lib/security/credentials/plugin/plugin_credentials.c
index 4fc02b2659b1fa86e7fe4aee07aff712b91f849e..66e501cffc38bad6e033615f4c324368eefd3a3d 100644
--- a/src/core/lib/security/credentials/plugin/plugin_credentials.c
+++ b/src/core/lib/security/credentials/plugin/plugin_credentials.c
@@ -78,14 +78,14 @@ static void plugin_md_request_metadata_ready(void *request,
bool seen_illegal_header = false;
grpc_credentials_md *md_array = NULL;
for (i = 0; i < num_md; i++) {
- if (!grpc_header_key_slice_is_legal(md[i].key)) {
+ if (!grpc_header_key_is_legal(md[i].key)) {
char *key = grpc_dump_slice(md[i].key, GPR_DUMP_ASCII);
gpr_log(GPR_ERROR, "Plugin added invalid metadata key: %s", key);
gpr_free(key);
seen_illegal_header = true;
break;
- } else if (!grpc_slice_is_binary_header(md[i].key) &&
- !grpc_header_nonbin_value_slice_is_legal(md[i].value)) {
+ } else if (!grpc_is_binary_header(md[i].key) &&
+ !grpc_header_nonbin_value_is_legal(md[i].value)) {
gpr_log(GPR_ERROR, "Plugin added invalid metadata value.");
seen_illegal_header = true;
break;
diff --git a/src/core/lib/slice/slice.c b/src/core/lib/slice/slice.c
index f2c09d60e5f523dfc9bdb2c62570261ac98ab2e5..c377edd349e1bceeff51c087bbaf4a4536e6b894 100644
--- a/src/core/lib/slice/slice.c
+++ b/src/core/lib/slice/slice.c
@@ -82,14 +82,18 @@ static const grpc_slice_refcount_vtable noop_refcount_vtable = {
noop_ref, noop_unref, grpc_slice_default_hash_impl};
static grpc_slice_refcount noop_refcount = {&noop_refcount_vtable};
-grpc_slice grpc_slice_from_static_string(const char *s) {
+grpc_slice grpc_slice_from_static_buffer(const void *s, size_t len) {
grpc_slice slice;
slice.refcount = &noop_refcount;
slice.data.refcounted.bytes = (uint8_t *)s;
- slice.data.refcounted.length = strlen(s);
+ slice.data.refcounted.length = len;
return slice;
}
+grpc_slice grpc_slice_from_static_string(const char *s) {
+ return grpc_slice_from_static_buffer(s, strlen(s));
+}
+
/* grpc_slice_new support structures - we create a refcount object extended
with the user provided data pointer & destroy function */
typedef struct new_slice_refcount {
@@ -384,3 +388,41 @@ int grpc_slice_is_equivalent(grpc_slice a, grpc_slice b) {
return a.data.refcounted.length == b.data.refcounted.length &&
a.data.refcounted.bytes == b.data.refcounted.bytes;
}
+
+int grpc_slice_buf_start_eq(grpc_slice a, const void *b, size_t len) {
+ if (GRPC_SLICE_LENGTH(a) < len) return 0;
+ return 0 == memcmp(GRPC_SLICE_START_PTR(a), b, len);
+}
+
+int grpc_slice_rchr(grpc_slice s, char c) {
+ const char *b = (const char *)GRPC_SLICE_START_PTR(s);
+ int i;
+ for (i = (int)GRPC_SLICE_LENGTH(s) - 1; i != -1 && b[i] != c; i--)
+ ;
+ return i;
+}
+
+int grpc_slice_chr(grpc_slice s, char c) {
+ const char *b = (const char *)GRPC_SLICE_START_PTR(s);
+ const char *p = memchr(b, c, GRPC_SLICE_LENGTH(s));
+ return p == NULL ? -1 : (int)(p - b);
+}
+
+int grpc_slice_slice(grpc_slice haystack, grpc_slice needle) {
+ size_t haystack_len = GRPC_SLICE_LENGTH(haystack);
+ const uint8_t *haystack_bytes = GRPC_SLICE_START_PTR(haystack);
+ size_t needle_len = GRPC_SLICE_LENGTH(needle);
+ const uint8_t *needle_bytes = GRPC_SLICE_START_PTR(needle);
+
+ if (haystack_len == 0 || needle_len == 0) return -1;
+ if (haystack_len < needle_len) return -1;
+ if (needle_len == 1) return grpc_slice_chr(haystack, (char)*needle_bytes);
+
+ const uint8_t *last = haystack_bytes + haystack_len - needle_len;
+ for (const uint8_t *cur = haystack_bytes; cur != last; ++cur) {
+ if (0 == memcmp(cur, needle_bytes, needle_len)) {
+ return (int)(cur - haystack_bytes);
+ }
+ }
+ return -1;
+}
diff --git a/src/core/lib/slice/slice_intern.c b/src/core/lib/slice/slice_intern.c
index a7e17527c36d063c6b945bd82a1a387a6fe90e37..b5e00a38d7ee5e9d65ef11aa1bfe94ef4148a507 100644
--- a/src/core/lib/slice/slice_intern.c
+++ b/src/core/lib/slice/slice_intern.c
@@ -206,7 +206,7 @@ grpc_slice grpc_slice_intern(grpc_slice slice) {
return materialize(s);
}
-void grpc_test_only_set_slice_interning_hash_seed(uint32_t seed) {
+void grpc_test_only_set_slice_hash_seed(uint32_t seed) {
g_hash_seed = seed;
g_forced_hash_seed = 1;
}
diff --git a/src/core/lib/slice/slice_internal.h b/src/core/lib/slice/slice_internal.h
index 8bfe066fdb43d55cea961612804d2f5a95ea6147..bf9117c74e0bda8eba115a28fa634fe676510059 100644
--- a/src/core/lib/slice/slice_internal.h
+++ b/src/core/lib/slice/slice_internal.h
@@ -48,6 +48,6 @@ void grpc_slice_buffer_destroy_internal(grpc_exec_ctx *exec_ctx,
void grpc_slice_intern_init(void);
void grpc_slice_intern_shutdown(void);
-void grpc_test_only_set_slice_interning_hash_seed(uint32_t key);
+void grpc_test_only_set_slice_hash_seed(uint32_t key);
#endif /* GRPC_CORE_LIB_SLICE_SLICE_INTERNAL_H */
diff --git a/src/core/lib/slice/slice_string_helpers.c b/src/core/lib/slice/slice_string_helpers.c
index 839c366b32d0dcf29ffa2bdef85fbbc59c08ecb7..99695007cca63c1802dffee1eebfe53804ace820 100644
--- a/src/core/lib/slice/slice_string_helpers.c
+++ b/src/core/lib/slice/slice_string_helpers.c
@@ -88,3 +88,8 @@ void grpc_slice_split(grpc_slice str, const char *sep, grpc_slice_buffer *dst) {
grpc_slice_buffer_add_indexed(dst, grpc_slice_ref_internal(str));
}
}
+
+bool grpc_parse_slice_to_uint32(grpc_slice str, uint32_t *result) {
+ return gpr_parse_bytes_to_uint32((const char *)GRPC_SLICE_START_PTR(str),
+ GRPC_SLICE_LENGTH(str), result) != 0;
+}
diff --git a/src/core/lib/surface/call.c b/src/core/lib/surface/call.c
index 38aa99372e84180fa51acaf5798f418c91cffc1f..6ffe37e300ee6fbee398af83908606b050fa4669 100644
--- a/src/core/lib/surface/call.c
+++ b/src/core/lib/surface/call.c
@@ -596,13 +596,13 @@ static int prepare_application_metadata(
grpc_linked_mdelem *l = (grpc_linked_mdelem *)&md->internal_data;
GPR_ASSERT(sizeof(grpc_linked_mdelem) == sizeof(md->internal_data));
l->md = grpc_mdelem_from_slices(exec_ctx, md->key, md->value);
- if (!grpc_header_key_slice_is_legal(l->md->key)) {
+ if (!grpc_header_key_is_legal(l->md->key)) {
char *str = grpc_dump_slice(md->key, GPR_DUMP_ASCII);
gpr_log(GPR_ERROR, "attempt to send invalid metadata key: %s", str);
gpr_free(str);
break;
- } else if (!grpc_slice_is_binary_header(l->md->key) &&
- !grpc_header_nonbin_value_slice_is_legal(l->md->value)) {
+ } else if (!grpc_is_binary_header(l->md->key) &&
+ !grpc_header_nonbin_value_is_legal(l->md->value)) {
char *str = grpc_dump_slice(md->value, GPR_DUMP_HEX | GPR_DUMP_ASCII);
gpr_log(GPR_ERROR, "attempt to send invalid metadata value: %s", str);
gpr_free(str);
diff --git a/src/core/lib/surface/validate_metadata.c b/src/core/lib/surface/validate_metadata.c
index 84f0a083bc165fa79d21aba70a340295fb413005..c9ff30bf8a8b141fb3b0a6939ff582f1ac130db0 100644
--- a/src/core/lib/surface/validate_metadata.c
+++ b/src/core/lib/surface/validate_metadata.c
@@ -34,13 +34,14 @@
#include <stdlib.h>
#include <string.h>
+#include <grpc/grpc.h>
#include <grpc/support/port_platform.h>
-static int conforms_to(const char *s, size_t len, const uint8_t *legal_bits) {
- const char *p = s;
- const char *e = s + len;
+static int conforms_to(grpc_slice slice, const uint8_t *legal_bits) {
+ const uint8_t *p = GRPC_SLICE_START_PTR(slice);
+ const uint8_t *e = GRPC_SLICE_END_PTR(slice);
for (; p != e; p++) {
- int idx = (uint8_t)*p;
+ int idx = *p;
int byte = idx / 8;
int bit = idx % 8;
if ((legal_bits[byte] & (1 << bit)) == 0) return 0;
@@ -48,26 +49,23 @@ static int conforms_to(const char *s, size_t len, const uint8_t *legal_bits) {
return 1;
}
-int grpc_header_key_is_legal(const char *key, size_t length) {
+int grpc_header_key_is_legal(grpc_slice slice) {
static const uint8_t legal_header_bits[256 / 8] = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0xff, 0x03, 0x00, 0x00, 0x00,
0x80, 0xfe, 0xff, 0xff, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
- if (length == 0) {
- return 0;
- }
- return conforms_to(key, length, legal_header_bits);
+ return GRPC_SLICE_LENGTH(slice) != 0 && conforms_to(slice, legal_header_bits);
}
-int grpc_header_nonbin_value_is_legal(const char *value, size_t length) {
+int grpc_header_nonbin_value_is_legal(grpc_slice slice) {
static const uint8_t legal_header_bits[256 / 8] = {
0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff, 0x7f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
- return conforms_to(value, length, legal_header_bits);
+ return conforms_to(slice, legal_header_bits);
}
-int grpc_is_binary_header(const char *key, size_t length) {
- if (length < 5) return 0;
- return 0 == memcmp(key + length - 4, "-bin", 4);
+int grpc_is_binary_header(grpc_slice slice) {
+ if (GRPC_SLICE_LENGTH(slice) < 5) return 0;
+ return 0 == memcmp(GRPC_SLICE_END_PTR(slice) - 4, "-bin", 4);
}
diff --git a/src/core/lib/transport/metadata.c b/src/core/lib/transport/metadata.c
index cedf9170b7c2cfc19abe360c9e52c1e2f26a1c2f..6ec1518e93b7081e18bb1f176647b619c7ddf592 100644
--- a/src/core/lib/transport/metadata.c
+++ b/src/core/lib/transport/metadata.c
@@ -375,8 +375,7 @@ static size_t get_base64_encoded_size(size_t raw_length) {
size_t grpc_mdelem_get_size_in_hpack_table(grpc_mdelem *elem) {
size_t overhead_and_key = 32 + GRPC_SLICE_LENGTH(elem->key);
size_t value_len = GRPC_SLICE_LENGTH(elem->value);
- if (grpc_is_binary_header((const char *)GRPC_SLICE_START_PTR(elem->key),
- GRPC_SLICE_LENGTH(elem->key))) {
+ if (grpc_is_binary_header(elem->key)) {
return overhead_and_key + get_base64_encoded_size(value_len);
} else {
return overhead_and_key + value_len;
diff --git a/src/ruby/ext/grpc/rb_grpc_imports.generated.c b/src/ruby/ext/grpc/rb_grpc_imports.generated.c
index 665903e22c45d980e671537426b66f44b2859a36..1d5f70e53457c09e611b9da9616796173c543b8f 100644
--- a/src/ruby/ext/grpc/rb_grpc_imports.generated.c
+++ b/src/ruby/ext/grpc/rb_grpc_imports.generated.c
@@ -130,11 +130,8 @@ grpc_server_cancel_all_calls_type grpc_server_cancel_all_calls_import;
grpc_server_destroy_type grpc_server_destroy_import;
grpc_tracer_set_enabled_type grpc_tracer_set_enabled_import;
grpc_header_key_is_legal_type grpc_header_key_is_legal_import;
-grpc_header_key_slice_is_legal_type grpc_header_key_slice_is_legal_import;
grpc_header_nonbin_value_is_legal_type grpc_header_nonbin_value_is_legal_import;
-grpc_header_nonbin_value_slice_is_legal_type grpc_header_nonbin_value_slice_is_legal_import;
grpc_is_binary_header_type grpc_is_binary_header_import;
-grpc_slice_is_binary_header_type grpc_slice_is_binary_header_import;
grpc_call_error_to_string_type grpc_call_error_to_string_import;
grpc_resource_quota_create_type grpc_resource_quota_create_import;
grpc_resource_quota_ref_type grpc_resource_quota_ref_import;
@@ -191,6 +188,7 @@ grpc_slice_sub_no_ref_type grpc_slice_sub_no_ref_import;
grpc_slice_split_tail_type grpc_slice_split_tail_import;
grpc_slice_split_head_type grpc_slice_split_head_import;
grpc_empty_slice_type grpc_empty_slice_import;
+grpc_slice_default_hash_impl_type grpc_slice_default_hash_impl_import;
grpc_slice_cmp_type grpc_slice_cmp_import;
grpc_slice_str_cmp_type grpc_slice_str_cmp_import;
grpc_slice_buf_cmp_type grpc_slice_buf_cmp_import;
@@ -414,11 +412,8 @@ void grpc_rb_load_imports(HMODULE library) {
grpc_server_destroy_import = (grpc_server_destroy_type) GetProcAddress(library, "grpc_server_destroy");
grpc_tracer_set_enabled_import = (grpc_tracer_set_enabled_type) GetProcAddress(library, "grpc_tracer_set_enabled");
grpc_header_key_is_legal_import = (grpc_header_key_is_legal_type) GetProcAddress(library, "grpc_header_key_is_legal");
- grpc_header_key_slice_is_legal_import = (grpc_header_key_slice_is_legal_type) GetProcAddress(library, "grpc_header_key_slice_is_legal");
grpc_header_nonbin_value_is_legal_import = (grpc_header_nonbin_value_is_legal_type) GetProcAddress(library, "grpc_header_nonbin_value_is_legal");
- grpc_header_nonbin_value_slice_is_legal_import = (grpc_header_nonbin_value_slice_is_legal_type) GetProcAddress(library, "grpc_header_nonbin_value_slice_is_legal");
grpc_is_binary_header_import = (grpc_is_binary_header_type) GetProcAddress(library, "grpc_is_binary_header");
- grpc_slice_is_binary_header_import = (grpc_slice_is_binary_header_type) GetProcAddress(library, "grpc_slice_is_binary_header");
grpc_call_error_to_string_import = (grpc_call_error_to_string_type) GetProcAddress(library, "grpc_call_error_to_string");
grpc_resource_quota_create_import = (grpc_resource_quota_create_type) GetProcAddress(library, "grpc_resource_quota_create");
grpc_resource_quota_ref_import = (grpc_resource_quota_ref_type) GetProcAddress(library, "grpc_resource_quota_ref");
@@ -475,6 +470,7 @@ void grpc_rb_load_imports(HMODULE library) {
grpc_slice_split_tail_import = (grpc_slice_split_tail_type) GetProcAddress(library, "grpc_slice_split_tail");
grpc_slice_split_head_import = (grpc_slice_split_head_type) GetProcAddress(library, "grpc_slice_split_head");
grpc_empty_slice_import = (grpc_empty_slice_type) GetProcAddress(library, "grpc_empty_slice");
+ grpc_slice_default_hash_impl_import = (grpc_slice_default_hash_impl_type) GetProcAddress(library, "grpc_slice_default_hash_impl");
grpc_slice_cmp_import = (grpc_slice_cmp_type) GetProcAddress(library, "grpc_slice_cmp");
grpc_slice_str_cmp_import = (grpc_slice_str_cmp_type) GetProcAddress(library, "grpc_slice_str_cmp");
grpc_slice_buf_cmp_import = (grpc_slice_buf_cmp_type) GetProcAddress(library, "grpc_slice_buf_cmp");
diff --git a/src/ruby/ext/grpc/rb_grpc_imports.generated.h b/src/ruby/ext/grpc/rb_grpc_imports.generated.h
index 14d5835201ac8586034f8a3d235c9da807e7191e..7fee273bb50ea43aeb22dce3a263aa9b5914bab4 100644
--- a/src/ruby/ext/grpc/rb_grpc_imports.generated.h
+++ b/src/ruby/ext/grpc/rb_grpc_imports.generated.h
@@ -338,24 +338,15 @@ extern grpc_server_destroy_type grpc_server_destroy_import;
typedef int(*grpc_tracer_set_enabled_type)(const char *name, int enabled);
extern grpc_tracer_set_enabled_type grpc_tracer_set_enabled_import;
#define grpc_tracer_set_enabled grpc_tracer_set_enabled_import
-typedef int(*grpc_header_key_is_legal_type)(const char *key, size_t length);
+typedef int(*grpc_header_key_is_legal_type)(grpc_slice slice);
extern grpc_header_key_is_legal_type grpc_header_key_is_legal_import;
#define grpc_header_key_is_legal grpc_header_key_is_legal_import
-typedef int(*grpc_header_key_slice_is_legal_type)(grpc_slice slice);
-extern grpc_header_key_slice_is_legal_type grpc_header_key_slice_is_legal_import;
-#define grpc_header_key_slice_is_legal grpc_header_key_slice_is_legal_import
-typedef int(*grpc_header_nonbin_value_is_legal_type)(const char *value, size_t length);
+typedef int(*grpc_header_nonbin_value_is_legal_type)(grpc_slice slice);
extern grpc_header_nonbin_value_is_legal_type grpc_header_nonbin_value_is_legal_import;
#define grpc_header_nonbin_value_is_legal grpc_header_nonbin_value_is_legal_import
-typedef int(*grpc_header_nonbin_value_slice_is_legal_type)(grpc_slice slice);
-extern grpc_header_nonbin_value_slice_is_legal_type grpc_header_nonbin_value_slice_is_legal_import;
-#define grpc_header_nonbin_value_slice_is_legal grpc_header_nonbin_value_slice_is_legal_import
-typedef int(*grpc_is_binary_header_type)(const char *key, size_t length);
+typedef int(*grpc_is_binary_header_type)(grpc_slice slice);
extern grpc_is_binary_header_type grpc_is_binary_header_import;
#define grpc_is_binary_header grpc_is_binary_header_import
-typedef int(*grpc_slice_is_binary_header_type)(grpc_slice slice);
-extern grpc_slice_is_binary_header_type grpc_slice_is_binary_header_import;
-#define grpc_slice_is_binary_header grpc_slice_is_binary_header_import
typedef const char *(*grpc_call_error_to_string_type)(grpc_call_error error);
extern grpc_call_error_to_string_type grpc_call_error_to_string_import;
#define grpc_call_error_to_string grpc_call_error_to_string_import
@@ -524,6 +515,9 @@ extern grpc_slice_split_head_type grpc_slice_split_head_import;
typedef grpc_slice(*grpc_empty_slice_type)(void);
extern grpc_empty_slice_type grpc_empty_slice_import;
#define grpc_empty_slice grpc_empty_slice_import
+typedef uint32_t(*grpc_slice_default_hash_impl_type)(void *, grpc_slice s);
+extern grpc_slice_default_hash_impl_type grpc_slice_default_hash_impl_import;
+#define grpc_slice_default_hash_impl grpc_slice_default_hash_impl_import
typedef int(*grpc_slice_cmp_type)(grpc_slice a, grpc_slice b);
extern grpc_slice_cmp_type grpc_slice_cmp_import;
#define grpc_slice_cmp grpc_slice_cmp_import
diff --git a/test/core/bad_client/tests/large_metadata.c b/test/core/bad_client/tests/large_metadata.c
index 9c804e78c1066aeb3fdf716ab8949dc78bd8e407..f9255be1dc04661adc8efc00aef77099cf7165b5 100644
--- a/test/core/bad_client/tests/large_metadata.c
+++ b/test/core/bad_client/tests/large_metadata.c
@@ -126,8 +126,8 @@ static void server_verifier(grpc_server *server, grpc_completion_queue *cq,
CQ_EXPECT_COMPLETION(cqv, tag(101), 1);
cq_verify(cqv);
- GPR_ASSERT(0 == strcmp(call_details.host, "localhost"));
- GPR_ASSERT(0 == strcmp(call_details.method, "/foo/bar"));
+ GPR_ASSERT(0 == grpc_slice_str_cmp(call_details.host, "localhost"));
+ GPR_ASSERT(0 == grpc_slice_str_cmp(call_details.method, "/foo/bar"));
grpc_metadata_array_destroy(&request_metadata_recv);
grpc_call_details_destroy(&call_details);
@@ -153,16 +153,14 @@ static void server_verifier_sends_too_much_metadata(grpc_server *server,
CQ_EXPECT_COMPLETION(cqv, tag(101), 1);
cq_verify(cqv);
- GPR_ASSERT(0 == strcmp(call_details.host, "localhost"));
- GPR_ASSERT(0 == strcmp(call_details.method, "/foo/bar"));
+ GPR_ASSERT(0 == grpc_slice_str_cmp(call_details.host, "localhost"));
+ GPR_ASSERT(0 == grpc_slice_str_cmp(call_details.method, "/foo/bar"));
const size_t metadata_value_size = 16 * 1024;
grpc_metadata meta;
- meta.key = "key";
- meta.value = gpr_malloc(metadata_value_size + 1);
- memset((char *)meta.value, 'a', metadata_value_size);
- ((char *)meta.value)[metadata_value_size] = 0;
- meta.value_length = metadata_value_size;
+ meta.key = grpc_slice_from_static_string("key");
+ meta.value = grpc_slice_malloc(metadata_value_size);
+ memset(GRPC_SLICE_START_PTR(meta.value), 'a', metadata_value_size);
grpc_op op;
memset(&op, 0, sizeof(op));
@@ -176,7 +174,7 @@ static void server_verifier_sends_too_much_metadata(grpc_server *server,
CQ_EXPECT_COMPLETION(cqv, tag(102), 0); // Operation fails.
cq_verify(cqv);
- gpr_free((char *)meta.value);
+ grpc_slice_unref(meta.value);
grpc_metadata_array_destroy(&request_metadata_recv);
grpc_call_details_destroy(&call_details);
grpc_call_destroy(s);
diff --git a/test/core/bad_client/tests/simple_request.c b/test/core/bad_client/tests/simple_request.c
index c08aa40a0a7e6b373696b06c7d2be2ca8e7e3439..db31ba6fb3cb35d1b92736214ba27c24960edcc3 100644
--- a/test/core/bad_client/tests/simple_request.c
+++ b/test/core/bad_client/tests/simple_request.c
@@ -117,8 +117,8 @@ static void verifier(grpc_server *server, grpc_completion_queue *cq,
CQ_EXPECT_COMPLETION(cqv, tag(101), 1);
cq_verify(cqv);
- GPR_ASSERT(0 == strcmp(call_details.host, "localhost"));
- GPR_ASSERT(0 == strcmp(call_details.method, "/foo/bar"));
+ GPR_ASSERT(0 == grpc_slice_str_cmp(call_details.host, "localhost"));
+ GPR_ASSERT(0 == grpc_slice_str_cmp(call_details.method, "/foo/bar"));
grpc_metadata_array_destroy(&request_metadata_recv);
grpc_call_details_destroy(&call_details);
diff --git a/test/core/bad_ssl/bad_ssl_test.c b/test/core/bad_ssl/bad_ssl_test.c
index f8a9fe6caca9e7a098ba1f96f06ce29e39bc8d31..9cce77e71ab933058f13d6890b63d46012a6a500 100644
--- a/test/core/bad_ssl/bad_ssl_test.c
+++ b/test/core/bad_ssl/bad_ssl_test.c
@@ -57,8 +57,7 @@ static void run_test(const char *target, size_t nops) {
grpc_metadata_array initial_metadata_recv;
grpc_metadata_array trailing_metadata_recv;
- char *details = NULL;
- size_t details_capacity = 0;
+ grpc_slice details;
grpc_status_code status;
grpc_call_error error;
gpr_timespec deadline = GRPC_TIMEOUT_SECONDS_TO_DEADLINE(5);
@@ -80,9 +79,10 @@ static void run_test(const char *target, size_t nops) {
grpc_metadata_array_init(&trailing_metadata_recv);
channel = grpc_secure_channel_create(ssl_creds, target, &args, NULL);
+ grpc_slice host = grpc_slice_from_static_string("foo.test.google.fr:1234");
c = grpc_channel_create_call(channel, NULL, GRPC_PROPAGATE_DEFAULTS, cq,
- "/foo", "foo.test.google.fr:1234", deadline,
- NULL);
+ grpc_slice_from_static_string("/foo"), &host,
+ deadline, NULL);
memset(ops, 0, sizeof(ops));
op = ops;
@@ -95,7 +95,6 @@ static void run_test(const char *target, size_t nops) {
op->data.recv_status_on_client.trailing_metadata = &trailing_metadata_recv;
op->data.recv_status_on_client.status = &status;
op->data.recv_status_on_client.status_details = &details;
- op->data.recv_status_on_client.status_details_capacity = &details_capacity;
op->flags = 0;
op->reserved = NULL;
op++;
@@ -117,7 +116,7 @@ static void run_test(const char *target, size_t nops) {
GPR_ASSERT(status != GRPC_STATUS_OK);
grpc_call_destroy(c);
- gpr_free(details);
+ grpc_slice_unref(details);
grpc_metadata_array_destroy(&initial_metadata_recv);
grpc_metadata_array_destroy(&trailing_metadata_recv);
diff --git a/test/core/channel/channel_args_test.c b/test/core/channel/channel_args_test.c
index 6a325bc12fbed8622ef0406d7e51cc66a9426fcc..b2c41652a49a9e04d4b46d616681138cd37c6b1d 100644
--- a/test/core/channel/channel_args_test.c
+++ b/test/core/channel/channel_args_test.c
@@ -151,7 +151,11 @@ static void test_set_socket_mutator(void) {
GPR_ASSERT(strcmp(ch_args->args[0].key, GRPC_ARG_SOCKET_MUTATOR) == 0);
GPR_ASSERT(ch_args->args[0].type == GRPC_ARG_POINTER);
- grpc_channel_args_destroy(ch_args);
+ {
+ grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
+ grpc_channel_args_destroy(&exec_ctx, ch_args);
+ grpc_exec_ctx_finish(&exec_ctx);
+ }
}
int main(int argc, char **argv) {
diff --git a/test/core/channel/channel_stack_test.c b/test/core/channel/channel_stack_test.c
index 54575ae499dc5e72cb53264903acc60984d5292b..ab5a50304dc9a6d81d080cdf12d5ecd510699e6d 100644
--- a/test/core/channel/channel_stack_test.c
+++ b/test/core/channel/channel_stack_test.c
@@ -39,6 +39,7 @@
#include <grpc/support/log.h>
#include <grpc/support/string_util.h>
+#include "src/core/lib/slice/slice_internal.h"
#include "test/core/util/test_config.h"
static void channel_init_func(grpc_exec_ctx *exec_ctx,
@@ -119,7 +120,7 @@ static void test_create_channel_stack(void) {
int *channel_data;
int *call_data;
grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
- grpc_mdstr *path = grpc_mdstr_from_string("/service/method");
+ grpc_slice path = grpc_slice_from_static_string("/service/method");
arg.type = GRPC_ARG_INTEGER;
arg.key = "test_key";
@@ -156,7 +157,7 @@ static void test_create_channel_stack(void) {
GRPC_CHANNEL_STACK_UNREF(&exec_ctx, channel_stack, "done");
- GRPC_MDSTR_UNREF(&exec_ctx, path);
+ grpc_slice_unref_internal(&exec_ctx, path);
grpc_exec_ctx_finish(&exec_ctx);
}
diff --git a/test/core/client_channel/lb_policies_test.c b/test/core/client_channel/lb_policies_test.c
index c373505dd769b77637c8cc8d3f98b5d443fb5346..0a5c543a55b00887f7943aa0cee8f6d2b8a413ea 100644
--- a/test/core/client_channel/lb_policies_test.c
+++ b/test/core/client_channel/lb_policies_test.c
@@ -154,8 +154,7 @@ static void kill_server(const servers_fixture *f, size_t i) {
typedef struct request_data {
grpc_metadata_array initial_metadata_recv;
grpc_metadata_array trailing_metadata_recv;
- char *details;
- size_t details_capacity;
+ grpc_slice details;
grpc_status_code status;
grpc_call_details *call_details;
} request_data;
@@ -267,8 +266,6 @@ static request_sequences perform_request(servers_fixture *f,
for (iter_num = 0; iter_num < spec->num_iters; iter_num++) {
cq_verifier *cqv = cq_verifier_create(f->cq);
- rdata->details = NULL;
- rdata->details_capacity = 0;
was_cancelled = 2;
for (i = 0; i < f->num_servers; i++) {
@@ -289,8 +286,9 @@ static request_sequences perform_request(servers_fixture *f,
}
memset(s_valid, 0, f->num_servers * sizeof(int));
+ grpc_slice host = grpc_slice_from_static_string("foo.test.google.fr");
c = grpc_channel_create_call(client, NULL, GRPC_PROPAGATE_DEFAULTS, f->cq,
- "/foo", "foo.test.google.fr",
+ grpc_slice_from_static_string("/foo"), &host,
gpr_inf_future(GPR_CLOCK_REALTIME), NULL);
GPR_ASSERT(c);
completed_client = 0;
@@ -316,8 +314,6 @@ static request_sequences perform_request(servers_fixture *f,
&rdata->trailing_metadata_recv;
op->data.recv_status_on_client.status = &rdata->status;
op->data.recv_status_on_client.status_details = &rdata->details;
- op->data.recv_status_on_client.status_details_capacity =
- &rdata->details_capacity;
op->flags = 0;
op->reserved = NULL;
op++;
@@ -360,7 +356,8 @@ static request_sequences perform_request(servers_fixture *f,
op->op = GRPC_OP_SEND_STATUS_FROM_SERVER;
op->data.send_status_from_server.trailing_metadata_count = 0;
op->data.send_status_from_server.status = GRPC_STATUS_UNIMPLEMENTED;
- op->data.send_status_from_server.status_details = "xyz";
+ grpc_slice status_details = grpc_slice_from_static_string("xyz");
+ op->data.send_status_from_server.status_details = &status_details;
op->flags = 0;
op->reserved = NULL;
op++;
@@ -379,12 +376,12 @@ static request_sequences perform_request(servers_fixture *f,
}
cq_verify(cqv);
- gpr_log(GPR_DEBUG, "status=%d; %s", rdata->status, rdata->details);
GPR_ASSERT(rdata->status == GRPC_STATUS_UNIMPLEMENTED);
- GPR_ASSERT(0 == strcmp(rdata->details, "xyz"));
- GPR_ASSERT(0 == strcmp(rdata->call_details[s_idx].method, "/foo"));
+ GPR_ASSERT(0 == grpc_slice_str_cmp(rdata->details, "xyz"));
GPR_ASSERT(0 ==
- strcmp(rdata->call_details[s_idx].host, "foo.test.google.fr"));
+ grpc_slice_str_cmp(rdata->call_details[s_idx].method, "/foo"));
+ GPR_ASSERT(0 == grpc_slice_str_cmp(rdata->call_details[s_idx].host,
+ "foo.test.google.fr"));
GPR_ASSERT(was_cancelled == 1);
grpc_call_destroy(f->server_calls[s_idx]);
@@ -417,7 +414,7 @@ static request_sequences perform_request(servers_fixture *f,
for (i = 0; i < f->num_servers; i++) {
grpc_call_details_destroy(&rdata->call_details[i]);
}
- gpr_free(rdata->details);
+ grpc_slice_unref(rdata->details);
}
gpr_free(s_valid);
@@ -449,10 +446,12 @@ static grpc_call **perform_multirequest(servers_fixture *f,
op->flags = 0;
op->reserved = NULL;
+ grpc_slice host = grpc_slice_from_static_string("foo.test.google.fr");
for (i = 0; i < concurrent_calls; i++) {
- calls[i] = grpc_channel_create_call(
- client, NULL, GRPC_PROPAGATE_DEFAULTS, f->cq, "/foo",
- "foo.test.google.fr", gpr_inf_future(GPR_CLOCK_REALTIME), NULL);
+ calls[i] =
+ grpc_channel_create_call(client, NULL, GRPC_PROPAGATE_DEFAULTS, f->cq,
+ grpc_slice_from_static_string("/foo"), &host,
+ gpr_inf_future(GPR_CLOCK_REALTIME), NULL);
GPR_ASSERT(calls[i]);
GPR_ASSERT(GRPC_CALL_OK == grpc_call_start_batch(calls[i], ops,
(size_t)(op - ops), tag(1),
diff --git a/test/core/client_channel/set_initial_connect_string_test.c b/test/core/client_channel/set_initial_connect_string_test.c
index d12e1c3e415ab4d607b2f63e75e3efd1ac0a5579..e816347123df853bfc06c0dcf108dda544f2f7e6 100644
--- a/test/core/client_channel/set_initial_connect_string_test.c
+++ b/test/core/client_channel/set_initial_connect_string_test.c
@@ -140,9 +140,11 @@ static void start_rpc(int use_creds, int target_port) {
} else {
state.channel = grpc_insecure_channel_create(state.target, NULL, NULL);
}
+ grpc_slice host = grpc_slice_from_static_string("localhost");
state.call = grpc_channel_create_call(
- state.channel, NULL, GRPC_PROPAGATE_DEFAULTS, state.cq, "/Service/Method",
- "localhost", gpr_inf_future(GPR_CLOCK_REALTIME), NULL);
+ state.channel, NULL, GRPC_PROPAGATE_DEFAULTS, state.cq,
+ grpc_slice_from_static_string("/Service/Method"), &host,
+ gpr_inf_future(GPR_CLOCK_REALTIME), NULL);
memset(&state.op, 0, sizeof(state.op));
state.op.op = GRPC_OP_SEND_INITIAL_METADATA;
state.op.data.send_initial_metadata.count = 0;
diff --git a/test/core/compression/algorithm_test.c b/test/core/compression/algorithm_test.c
index 4b85489044ba6bfaf5365e4b12c5e21abf0f307a..48e16c001eea45a9b5f874a1e7a75220d194094e 100644
--- a/test/core/compression/algorithm_test.c
+++ b/test/core/compression/algorithm_test.c
@@ -40,6 +40,7 @@
#include <grpc/support/log.h>
#include <grpc/support/useful.h>
+#include "src/core/lib/slice/slice_internal.h"
#include "src/core/lib/transport/static_metadata.h"
#include "test/core/util/test_config.h"
@@ -51,20 +52,22 @@ static void test_algorithm_mesh(void) {
for (i = 0; i < GRPC_COMPRESS_ALGORITHMS_COUNT; i++) {
char *name;
grpc_compression_algorithm parsed;
- grpc_mdstr *mdstr;
+ grpc_slice mdstr;
grpc_mdelem *mdelem;
grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
GPR_ASSERT(
grpc_compression_algorithm_name((grpc_compression_algorithm)i, &name));
- GPR_ASSERT(grpc_compression_algorithm_parse(name, strlen(name), &parsed));
+ GPR_ASSERT(grpc_compression_algorithm_parse(
+ grpc_slice_from_static_string(name), &parsed));
GPR_ASSERT((int)parsed == i);
- mdstr = grpc_mdstr_from_string(name);
- GPR_ASSERT(mdstr == grpc_compression_algorithm_slice(parsed));
+ mdstr = grpc_slice_from_copied_string(name);
+ GPR_ASSERT(0 ==
+ grpc_slice_cmp(mdstr, grpc_compression_algorithm_slice(parsed)));
GPR_ASSERT(parsed == grpc_compression_algorithm_from_slice(mdstr));
mdelem = grpc_compression_encoding_mdelem(parsed);
- GPR_ASSERT(mdelem->value == mdstr);
- GPR_ASSERT(mdelem->key == GRPC_MDSTR_GRPC_ENCODING);
- GRPC_MDSTR_UNREF(&exec_ctx, mdstr);
+ GPR_ASSERT(0 == grpc_slice_cmp(mdelem->value, mdstr));
+ GPR_ASSERT(0 == grpc_slice_cmp(mdelem->key, GRPC_MDSTR_GRPC_ENCODING));
+ grpc_slice_unref_internal(&exec_ctx, mdstr);
GRPC_MDELEM_UNREF(&exec_ctx, mdelem);
grpc_exec_ctx_finish(&exec_ctx);
}
@@ -76,7 +79,7 @@ static void test_algorithm_mesh(void) {
static void test_algorithm_failure(void) {
grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
- grpc_mdstr *mdstr;
+ grpc_slice mdstr;
gpr_log(GPR_DEBUG, "test_algorithm_failure");
@@ -84,14 +87,16 @@ static void test_algorithm_failure(void) {
NULL) == 0);
GPR_ASSERT(grpc_compression_algorithm_name(GRPC_COMPRESS_ALGORITHMS_COUNT + 1,
NULL) == 0);
- mdstr = grpc_mdstr_from_string("this-is-an-invalid-algorithm");
+ mdstr = grpc_slice_from_static_string("this-is-an-invalid-algorithm");
GPR_ASSERT(grpc_compression_algorithm_from_slice(mdstr) ==
GRPC_COMPRESS_ALGORITHMS_COUNT);
- GPR_ASSERT(grpc_compression_algorithm_slice(GRPC_COMPRESS_ALGORITHMS_COUNT) ==
- NULL);
- GPR_ASSERT(grpc_compression_algorithm_slice(GRPC_COMPRESS_ALGORITHMS_COUNT +
- 1) == NULL);
- GRPC_MDSTR_UNREF(&exec_ctx, mdstr);
+ GPR_ASSERT(0 == grpc_slice_cmp(grpc_compression_algorithm_slice(
+ GRPC_COMPRESS_ALGORITHMS_COUNT),
+ grpc_empty_slice()));
+ GPR_ASSERT(0 == grpc_slice_cmp(grpc_compression_algorithm_slice(
+ GRPC_COMPRESS_ALGORITHMS_COUNT + 1),
+ grpc_empty_slice()));
+ grpc_slice_unref_internal(&exec_ctx, mdstr);
grpc_exec_ctx_finish(&exec_ctx);
}
diff --git a/test/core/compression/compression_test.c b/test/core/compression/compression_test.c
index 4c43746e335243bcb9f2608b6472d6ab6c5a03b9..7b2e56dc018b603aa6574466e59f8d02623555ae 100644
--- a/test/core/compression/compression_test.c
+++ b/test/core/compression/compression_test.c
@@ -54,7 +54,7 @@ static void test_compression_algorithm_parse(void) {
const char *valid_name = valid_names[i];
grpc_compression_algorithm algorithm;
const int success = grpc_compression_algorithm_parse(
- valid_name, strlen(valid_name), &algorithm);
+ grpc_slice_from_static_string(valid_name), &algorithm);
GPR_ASSERT(success != 0);
GPR_ASSERT(algorithm == valid_algorithms[i]);
}
@@ -64,7 +64,7 @@ static void test_compression_algorithm_parse(void) {
grpc_compression_algorithm algorithm;
int success;
success = grpc_compression_algorithm_parse(
- invalid_name, strlen(invalid_name), &algorithm);
+ grpc_slice_from_static_string(invalid_name), &algorithm);
GPR_ASSERT(success == 0);
/* the value of "algorithm" is undefined upon failure */
}
diff --git a/test/core/end2end/bad_server_response_test.c b/test/core/end2end/bad_server_response_test.c
index 84db87f9f345131ecef11001f5e15d10f3a1dbe3..496bb4de0f060a74946f90e29ead2b354f50f0a8 100644
--- a/test/core/end2end/bad_server_response_test.c
+++ b/test/core/end2end/bad_server_response_test.c
@@ -171,16 +171,17 @@ static void start_rpc(int target_port, grpc_status_code expected_status,
grpc_status_code status;
grpc_call_error error;
cq_verifier *cqv;
- char *details = NULL;
- size_t details_capacity = 0;
+ grpc_slice details;
state.cq = grpc_completion_queue_create(NULL);
cqv = cq_verifier_create(state.cq);
gpr_join_host_port(&state.target, "127.0.0.1", target_port);
state.channel = grpc_insecure_channel_create(state.target, NULL, NULL);
+ grpc_slice host = grpc_slice_from_static_string("localhost");
state.call = grpc_channel_create_call(
- state.channel, NULL, GRPC_PROPAGATE_DEFAULTS, state.cq, "/Service/Method",
- "localhost", gpr_inf_future(GPR_CLOCK_REALTIME), NULL);
+ state.channel, NULL, GRPC_PROPAGATE_DEFAULTS, state.cq,
+ grpc_slice_from_static_string("/Service/Method"), &host,
+ gpr_inf_future(GPR_CLOCK_REALTIME), NULL);
grpc_metadata_array_init(&initial_metadata_recv);
grpc_metadata_array_init(&trailing_metadata_recv);
@@ -205,7 +206,6 @@ static void start_rpc(int target_port, grpc_status_code expected_status,
op->data.recv_status_on_client.trailing_metadata = &trailing_metadata_recv;
op->data.recv_status_on_client.status = &status;
op->data.recv_status_on_client.status_details = &details;
- op->data.recv_status_on_client.status_details_capacity = &details_capacity;
op->flags = 0;
op->reserved = NULL;
op++;
@@ -217,13 +217,13 @@ static void start_rpc(int target_port, grpc_status_code expected_status,
CQ_EXPECT_COMPLETION(cqv, tag(1), 1);
cq_verify(cqv);
- gpr_log(GPR_DEBUG, "Rpc status: %d, details: %s", status, details);
GPR_ASSERT(status == expected_status);
- GPR_ASSERT(NULL != strstr(details, expected_detail));
+ GPR_ASSERT(-1 != grpc_slice_slice(details, grpc_slice_from_static_string(
+ expected_detail)));
grpc_metadata_array_destroy(&initial_metadata_recv);
grpc_metadata_array_destroy(&trailing_metadata_recv);
- gpr_free(details);
+ grpc_slice_unref(details);
cq_verifier_destroy(cqv);
}
diff --git a/test/core/end2end/connection_refused_test.c b/test/core/end2end/connection_refused_test.c
index d57eaf5a6501edbcadd43c886f9b42080327c030..a74294892209731ef58059c38a25613899294efa 100644
--- a/test/core/end2end/connection_refused_test.c
+++ b/test/core/end2end/connection_refused_test.c
@@ -40,6 +40,7 @@
#include <grpc/support/string_util.h>
#include "src/core/lib/channel/channel_args.h"
+#include "src/core/lib/slice/slice_internal.h"
#include "src/core/lib/transport/metadata.h"
#include "src/core/lib/transport/method_config.h"
@@ -59,8 +60,7 @@ static void run_test(bool wait_for_ready, bool use_service_config) {
grpc_op *op;
grpc_metadata_array trailing_metadata_recv;
grpc_status_code status;
- char *details = NULL;
- size_t details_capacity = 0;
+ grpc_slice details;
gpr_log(GPR_INFO, "TEST: wait_for_ready=%d use_service_config=%d",
wait_for_ready, use_service_config);
@@ -78,12 +78,12 @@ static void run_test(bool wait_for_ready, bool use_service_config) {
grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
GPR_ASSERT(wait_for_ready);
grpc_method_config_table_entry entry = {
- grpc_mdstr_from_string("/service/method"),
+ grpc_slice_from_static_string("/service/method"),
grpc_method_config_create(&wait_for_ready, NULL, NULL, NULL),
};
grpc_method_config_table *method_config_table =
grpc_method_config_table_create(1, &entry);
- GRPC_MDSTR_UNREF(&exec_ctx, entry.method_name);
+ grpc_slice_unref_internal(&exec_ctx, entry.method_name);
grpc_method_config_unref(&exec_ctx, entry.method_config);
grpc_arg arg =
grpc_method_config_table_create_channel_arg(method_config_table);
@@ -98,9 +98,10 @@ static void run_test(bool wait_for_ready, bool use_service_config) {
gpr_join_host_port(&addr, "127.0.0.1", port);
gpr_log(GPR_INFO, "server: %s", addr);
chan = grpc_insecure_channel_create(addr, args, NULL);
- call = grpc_channel_create_call(chan, NULL, GRPC_PROPAGATE_DEFAULTS, cq,
- "/service/method", "nonexistant", deadline,
- NULL);
+ grpc_slice host = grpc_slice_from_static_string("nonexistant");
+ call = grpc_channel_create_call(
+ chan, NULL, GRPC_PROPAGATE_DEFAULTS, cq,
+ grpc_slice_from_static_string("/service/method"), &host, deadline, NULL);
gpr_free(addr);
@@ -117,7 +118,6 @@ static void run_test(bool wait_for_ready, bool use_service_config) {
op->data.recv_status_on_client.trailing_metadata = &trailing_metadata_recv;
op->data.recv_status_on_client.status = &status;
op->data.recv_status_on_client.status_details = &details;
- op->data.recv_status_on_client.status_details_capacity = &details_capacity;
op->flags = 0;
op->reserved = NULL;
op++;
@@ -143,7 +143,7 @@ static void run_test(bool wait_for_ready, bool use_service_config) {
grpc_channel_destroy(chan);
cq_verifier_destroy(cqv);
- gpr_free(details);
+ grpc_slice_unref(details);
grpc_metadata_array_destroy(&trailing_metadata_recv);
{
diff --git a/test/core/end2end/dualstack_socket_test.c b/test/core/end2end/dualstack_socket_test.c
index 11e8604f56a21c34853ca2ba9e0bbc94a958f0e7..76d2747c9cf3b3f7d9d642e526c37d2480e05f5b 100644
--- a/test/core/end2end/dualstack_socket_test.c
+++ b/test/core/end2end/dualstack_socket_test.c
@@ -88,8 +88,7 @@ void test_connect(const char *server_host, const char *client_host, int port,
grpc_metadata_array request_metadata_recv;
grpc_status_code status;
grpc_call_error error;
- char *details = NULL;
- size_t details_capacity = 0;
+ grpc_slice details;
int was_cancelled = 2;
grpc_call_details call_details;
char *peer;
@@ -168,8 +167,10 @@ void test_connect(const char *server_host, const char *client_host, int port,
}
/* Send a trivial request. */
+ grpc_slice host = grpc_slice_from_static_string("foo.test.google.fr");
c = grpc_channel_create_call(client, NULL, GRPC_PROPAGATE_DEFAULTS, cq,
- "/foo", "foo.test.google.fr", deadline, NULL);
+ grpc_slice_from_static_string("/foo"), &host,
+ deadline, NULL);
GPR_ASSERT(c);
memset(ops, 0, sizeof(ops));
@@ -192,7 +193,6 @@ void test_connect(const char *server_host, const char *client_host, int port,
op->data.recv_status_on_client.trailing_metadata = &trailing_metadata_recv;
op->data.recv_status_on_client.status = &status;
op->data.recv_status_on_client.status_details = &details;
- op->data.recv_status_on_client.status_details_capacity = &details_capacity;
op->flags = 0;
op->reserved = NULL;
op++;
@@ -216,7 +216,8 @@ void test_connect(const char *server_host, const char *client_host, int port,
op->op = GRPC_OP_SEND_STATUS_FROM_SERVER;
op->data.send_status_from_server.trailing_metadata_count = 0;
op->data.send_status_from_server.status = GRPC_STATUS_UNIMPLEMENTED;
- op->data.send_status_from_server.status_details = "xyz";
+ grpc_slice status_details = grpc_slice_from_static_string("xyz");
+ op->data.send_status_from_server.status_details = &status_details;
op->flags = 0;
op++;
op->op = GRPC_OP_RECV_CLOSE_ON_SERVER;
@@ -235,9 +236,10 @@ void test_connect(const char *server_host, const char *client_host, int port,
gpr_free(peer);
GPR_ASSERT(status == GRPC_STATUS_UNIMPLEMENTED);
- GPR_ASSERT(0 == strcmp(details, "xyz"));
- GPR_ASSERT(0 == strcmp(call_details.method, "/foo"));
- GPR_ASSERT(0 == strcmp(call_details.host, "foo.test.google.fr"));
+ GPR_ASSERT(0 == grpc_slice_str_cmp(details, "xyz"));
+ GPR_ASSERT(0 == grpc_slice_str_cmp(call_details.method, "/foo"));
+ GPR_ASSERT(0 ==
+ grpc_slice_str_cmp(call_details.host, "foo.test.google.fr"));
GPR_ASSERT(was_cancelled == 1);
grpc_call_destroy(s);
@@ -271,7 +273,7 @@ void test_connect(const char *server_host, const char *client_host, int port,
grpc_metadata_array_destroy(&request_metadata_recv);
grpc_call_details_destroy(&call_details);
- gpr_free(details);
+ grpc_slice_unref(details);
if (picked_port) {
grpc_recycle_unused_port(port);
}
diff --git a/test/core/end2end/fixtures/h2_oauth2.c b/test/core/end2end/fixtures/h2_oauth2.c
index 83f759ce2dd6499053602d24db06d02af5297d75..28011be787268d25527cef9234d9cd54f5026165 100644
--- a/test/core/end2end/fixtures/h2_oauth2.c
+++ b/test/core/end2end/fixtures/h2_oauth2.c
@@ -59,8 +59,8 @@ static const grpc_metadata *find_metadata(const grpc_metadata *md,
const char *value) {
size_t i;
for (i = 0; i < md_count; i++) {
- if (strcmp(key, md[i].key) == 0 && strlen(value) == md[i].value_length &&
- memcmp(md[i].value, value, md[i].value_length) == 0) {
+ if (grpc_slice_str_cmp(md[i].key, key) == 0 &&
+ grpc_slice_str_cmp(md[i].value, value) == 0) {
return &md[i];
}
}
diff --git a/test/core/end2end/fixtures/h2_ssl_cert.c b/test/core/end2end/fixtures/h2_ssl_cert.c
index ae49cc859aff1903b7029b5f552ae94747ac6ebc..92fac10d49aafb5b27244a02e68aaf6cb13d4fe3 100644
--- a/test/core/end2end/fixtures/h2_ssl_cert.c
+++ b/test/core/end2end/fixtures/h2_ssl_cert.c
@@ -321,8 +321,9 @@ static void simple_request_body(grpc_end2end_test_fixture f,
grpc_op *op;
grpc_call_error error;
+ grpc_slice host = grpc_slice_from_static_string("foo.test.google.fr:1234");
c = grpc_channel_create_call(f.client, NULL, GRPC_PROPAGATE_DEFAULTS, f.cq,
- "/foo", "foo.test.google.fr:1234", deadline,
+ grpc_slice_from_static_string("/foo"), &host, deadline,
NULL);
GPR_ASSERT(c);
diff --git a/test/core/end2end/fuzzers/api_fuzzer.c b/test/core/end2end/fuzzers/api_fuzzer.c
index 90ad0654c7b80062dd413bd1bf186b8d785c9435..a43941b396ae86ce8261f380bc5bcc1ea04c7655 100644
--- a/test/core/end2end/fuzzers/api_fuzzer.c
+++ b/test/core/end2end/fuzzers/api_fuzzer.c
@@ -44,6 +44,7 @@
#include "src/core/lib/iomgr/resolve_address.h"
#include "src/core/lib/iomgr/tcp_client.h"
#include "src/core/lib/iomgr/timer.h"
+#include "src/core/lib/slice/slice_internal.h"
#include "src/core/lib/surface/server.h"
#include "src/core/lib/transport/metadata.h"
#include "test/core/end2end/data/ssl_test_data.h"
@@ -90,7 +91,7 @@ static uint8_t next_byte(input_stream *inp) {
static void end(input_stream *inp) { inp->cur = inp->end; }
-static char *read_string(input_stream *inp) {
+static char *read_string(input_stream *inp, bool *special) {
char *str = NULL;
size_t cap = 0;
size_t sz = 0;
@@ -102,18 +103,53 @@ static char *read_string(input_stream *inp) {
}
c = (char)next_byte(inp);
str[sz++] = c;
- } while (c != 0);
+ } while (c != 0 && c != 1);
+ if (special != NULL) {
+ *special = (c == 1);
+ }
return str;
}
-static void read_buffer(input_stream *inp, char **buffer, size_t *length) {
+static void read_buffer(input_stream *inp, char **buffer, size_t *length,
+ bool *special) {
*length = next_byte(inp);
+ if (*length == 255) {
+ if (special != NULL) *special = true;
+ *length = next_byte(inp);
+ } else {
+ if (special != NULL) *special = false;
+ }
*buffer = gpr_malloc(*length);
for (size_t i = 0; i < *length; i++) {
(*buffer)[i] = (char)next_byte(inp);
}
}
+static grpc_slice maybe_intern(grpc_slice s, bool intern) {
+ grpc_slice r = intern ? grpc_slice_intern(s) : grpc_slice_ref(s);
+ grpc_slice_unref(s);
+ return r;
+}
+
+static grpc_slice read_string_like_slice(input_stream *inp) {
+ bool special;
+ char *s = read_string(inp, &special);
+ grpc_slice r = maybe_intern(grpc_slice_from_copied_string(s), special);
+ gpr_free(s);
+ return r;
+}
+
+static grpc_slice read_buffer_like_slice(input_stream *inp) {
+ char *buffer;
+ size_t length;
+ bool special;
+ read_buffer(inp, &buffer, &length, &special);
+ grpc_slice r =
+ maybe_intern(grpc_slice_from_copied_buffer(buffer, length), special);
+ gpr_free(buffer);
+ return r;
+}
+
static uint32_t read_uint22(input_stream *inp) {
uint8_t b = next_byte(inp);
uint32_t x = b & 0x7f;
@@ -170,12 +206,12 @@ static grpc_channel_args *read_args(input_stream *inp) {
switch (next_byte(inp)) {
case 1:
args[i].type = GRPC_ARG_STRING;
- args[i].key = read_string(inp);
- args[i].value.string = read_string(inp);
+ args[i].key = read_string(inp, NULL);
+ args[i].value.string = read_string(inp, NULL);
break;
case 2:
args[i].type = GRPC_ARG_INTEGER;
- args[i].key = read_string(inp);
+ args[i].key = read_string(inp, NULL);
args[i].value.integer = read_int(inp);
break;
case 3:
@@ -217,7 +253,7 @@ static const char *read_cred_artifact(cred_artifact_ctx *ctx, input_stream *inp,
size_t num_builtins) {
uint8_t b = next_byte(inp);
if (b == 0) return NULL;
- if (b == 1) return ctx->release[ctx->num_release++] = read_string(inp);
+ if (b == 1) return ctx->release[ctx->num_release++] = read_string(inp, NULL);
if (b >= num_builtins + 1) {
end(inp);
return NULL;
@@ -504,8 +540,7 @@ typedef struct call_state {
grpc_status_code status;
grpc_metadata_array recv_initial_metadata;
grpc_metadata_array recv_trailing_metadata;
- char *recv_status_details;
- size_t recv_status_details_capacity;
+ grpc_slice recv_status_details;
int cancelled;
int pending_ops;
grpc_call_details call_details;
@@ -519,6 +554,11 @@ typedef struct call_state {
size_t cap_to_free;
void **to_free;
+ // array of slices to unref
+ size_t num_slices_to_unref;
+ size_t cap_slices_to_unref;
+ grpc_slice *slices_to_unref;
+
struct call_state *next;
struct call_state *prev;
} call_state;
@@ -554,12 +594,15 @@ static call_state *maybe_delete_call_state(call_state *call) {
call->next->prev = call->prev;
grpc_metadata_array_destroy(&call->recv_initial_metadata);
grpc_metadata_array_destroy(&call->recv_trailing_metadata);
- gpr_free(call->recv_status_details);
+ grpc_slice_unref(call->recv_status_details);
grpc_call_details_destroy(&call->call_details);
for (size_t i = 0; i < call->num_to_free; i++) {
gpr_free(call->to_free[i]);
}
+ for (size_t i = 0; i < call->num_slices_to_unref; i++) {
+ grpc_slice_unref(call->slices_to_unref[i]);
+ }
gpr_free(call->to_free);
gpr_free(call);
@@ -576,6 +619,17 @@ static void add_to_free(call_state *call, void *p) {
call->to_free[call->num_to_free++] = p;
}
+static grpc_slice *add_to_slice_unref(call_state *call, grpc_slice s) {
+ if (call->num_slices_to_unref == call->cap_slices_to_unref) {
+ call->cap_slices_to_unref = GPR_MAX(8, 2 * call->cap_slices_to_unref);
+ call->slices_to_unref =
+ gpr_realloc(call->slices_to_unref,
+ sizeof(*call->slices_to_unref) * call->cap_slices_to_unref);
+ }
+ call->slices_to_unref[call->num_to_free++] = s;
+ return &call->slices_to_unref[call->num_to_free - 1];
+}
+
static void read_metadata(input_stream *inp, size_t *count,
grpc_metadata **metadata, call_state *cs) {
*count = next_byte(inp);
@@ -583,12 +637,11 @@ static void read_metadata(input_stream *inp, size_t *count,
*metadata = gpr_malloc(*count * sizeof(**metadata));
memset(*metadata, 0, *count * sizeof(**metadata));
for (size_t i = 0; i < *count; i++) {
- (*metadata)[i].key = read_string(inp);
- read_buffer(inp, (char **)&(*metadata)[i].value,
- &(*metadata)[i].value_length);
+ (*metadata)[i].key = read_string_like_slice(inp);
+ (*metadata)[i].value = read_buffer_like_slice(inp);
(*metadata)[i].flags = read_uint32(inp);
- add_to_free(cs, (void *)(*metadata)[i].key);
- add_to_free(cs, (void *)(*metadata)[i].value);
+ add_to_slice_unref(cs, (*metadata)[i].key);
+ add_to_slice_unref(cs, (*metadata)[i].value);
}
} else {
*metadata = gpr_malloc(1);
@@ -652,7 +705,7 @@ static validator *make_finished_batch_validator(call_state *cs,
}
int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
- grpc_test_only_set_metadata_hash_seed(0);
+ grpc_test_only_set_slice_hash_seed(0);
if (squelch) gpr_set_log_function(dont_log);
input_stream inp = {data, data + size};
grpc_resolve_address = my_resolve_address;
@@ -738,7 +791,7 @@ int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
// create an insecure channel
case 2: {
if (g_channel == NULL) {
- char *target = read_string(&inp);
+ char *target = read_string(&inp, NULL);
char *target_uri;
gpr_asprintf(&target_uri, "dns:%s", target);
grpc_channel_args *args = read_args(&inp);
@@ -867,8 +920,8 @@ int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
parent_call = g_active_call->call;
}
uint32_t propagation_mask = read_uint32(&inp);
- char *method = read_string(&inp);
- char *host = read_string(&inp);
+ grpc_slice method = read_string_like_slice(&inp);
+ grpc_slice host = read_string_like_slice(&inp);
gpr_timespec deadline =
gpr_time_add(gpr_now(GPR_CLOCK_REALTIME),
gpr_time_from_micros(read_uint32(&inp), GPR_TIMESPAN));
@@ -877,12 +930,12 @@ int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
call_state *cs = new_call(g_active_call, CLIENT);
cs->call =
grpc_channel_create_call(g_channel, parent_call, propagation_mask,
- cq, method, host, deadline, NULL);
+ cq, method, &host, deadline, NULL);
} else {
end(&inp);
}
- gpr_free(method);
- gpr_free(host);
+ grpc_slice_unref(method);
+ grpc_slice_unref(host);
break;
}
// switch the 'current' call
@@ -947,7 +1000,8 @@ int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
g_active_call);
op->data.send_status_from_server.status = next_byte(&inp);
op->data.send_status_from_server.status_details =
- read_string(&inp);
+ add_to_slice_unref(g_active_call,
+ read_buffer_like_slice(&inp));
break;
case GRPC_OP_RECV_INITIAL_METADATA:
op->op = GRPC_OP_RECV_INITIAL_METADATA;
@@ -967,8 +1021,6 @@ int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
&g_active_call->recv_trailing_metadata;
op->data.recv_status_on_client.status_details =
&g_active_call->recv_status_details;
- op->data.recv_status_on_client.status_details_capacity =
- &g_active_call->recv_status_details_capacity;
break;
case GRPC_OP_RECV_CLOSE_ON_SERVER:
op->op = GRPC_OP_RECV_CLOSE_ON_SERVER;
@@ -1056,14 +1108,14 @@ int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
}
// enable a tracer
case 17: {
- char *tracer = read_string(&inp);
+ char *tracer = read_string(&inp, NULL);
grpc_tracer_set_enabled(tracer, 1);
gpr_free(tracer);
break;
}
// disable a tracer
case 18: {
- char *tracer = read_string(&inp);
+ char *tracer = read_string(&inp, NULL);
grpc_tracer_set_enabled(tracer, 0);
gpr_free(tracer);
break;
@@ -1105,7 +1157,7 @@ int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
// create a secure channel
case 22: {
if (g_channel == NULL) {
- char *target = read_string(&inp);
+ char *target = read_string(&inp, NULL);
char *target_uri;
gpr_asprintf(&target_uri, "dns:%s", target);
grpc_channel_args *args = read_args(&inp);
diff --git a/test/core/end2end/fuzzers/client_fuzzer.c b/test/core/end2end/fuzzers/client_fuzzer.c
index 26b520885bb1fd6f4a74df77f64c08d5508df0f6..0972a4c8e7d17a35c8ebbc05b2e9374b5831a174 100644
--- a/test/core/end2end/fuzzers/client_fuzzer.c
+++ b/test/core/end2end/fuzzers/client_fuzzer.c
@@ -37,6 +37,7 @@
#include <grpc/support/alloc.h>
#include "src/core/ext/transport/chttp2/transport/chttp2_transport.h"
+#include "src/core/lib/slice/slice_internal.h"
#include "src/core/lib/surface/channel.h"
#include "test/core/util/memory_counters.h"
#include "test/core/util/mock_endpoint.h"
@@ -51,7 +52,7 @@ static void *tag(int n) { return (void *)(uintptr_t)n; }
static void dont_log(gpr_log_func_args *args) {}
int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
- grpc_test_only_set_metadata_hash_seed(0);
+ grpc_test_only_set_slice_hash_seed(0);
struct grpc_memory_counters counters;
if (squelch) gpr_set_log_function(dont_log);
if (leak_check) grpc_memory_counters_init();
@@ -71,9 +72,10 @@ int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
grpc_channel *channel = grpc_channel_create(
&exec_ctx, "test-target", NULL, GRPC_CLIENT_DIRECT_CHANNEL, transport);
- grpc_call *call =
- grpc_channel_create_call(channel, NULL, 0, cq, "/foo", "localhost",
- gpr_inf_future(GPR_CLOCK_REALTIME), NULL);
+ grpc_slice host = grpc_slice_from_static_string("localhost");
+ grpc_call *call = grpc_channel_create_call(
+ channel, NULL, 0, cq, grpc_slice_from_static_string("/foo"), &host,
+ gpr_inf_future(GPR_CLOCK_REALTIME), NULL);
grpc_metadata_array initial_metadata_recv;
grpc_metadata_array_init(&initial_metadata_recv);
@@ -81,8 +83,7 @@ int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
grpc_metadata_array trailing_metadata_recv;
grpc_metadata_array_init(&trailing_metadata_recv);
grpc_status_code status;
- char *details = NULL;
- size_t details_capacity = 0;
+ grpc_slice details;
grpc_op ops[6];
memset(ops, 0, sizeof(ops));
@@ -110,7 +111,6 @@ int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
op->data.recv_status_on_client.trailing_metadata = &trailing_metadata_recv;
op->data.recv_status_on_client.status = &status;
op->data.recv_status_on_client.status_details = &details;
- op->data.recv_status_on_client.status_details_capacity = &details_capacity;
op->flags = 0;
op->reserved = NULL;
op++;
@@ -155,7 +155,7 @@ done:
grpc_completion_queue_destroy(cq);
grpc_metadata_array_destroy(&initial_metadata_recv);
grpc_metadata_array_destroy(&trailing_metadata_recv);
- gpr_free(details);
+ grpc_slice_unref(details);
grpc_channel_destroy(channel);
if (response_payload_recv != NULL) {
grpc_byte_buffer_destroy(response_payload_recv);
diff --git a/test/core/end2end/fuzzers/server_fuzzer.c b/test/core/end2end/fuzzers/server_fuzzer.c
index 115fb0692526c6a2f182b40a8caee59299b0922a..186542d4b2d97367fe1a5b06ddaf0163000bd520 100644
--- a/test/core/end2end/fuzzers/server_fuzzer.c
+++ b/test/core/end2end/fuzzers/server_fuzzer.c
@@ -34,6 +34,7 @@
#include <grpc/grpc.h>
#include "src/core/ext/transport/chttp2/transport/chttp2_transport.h"
+#include "src/core/lib/slice/slice_internal.h"
#include "src/core/lib/surface/server.h"
#include "test/core/util/memory_counters.h"
#include "test/core/util/mock_endpoint.h"
@@ -49,7 +50,7 @@ static int detag(void *p) { return (int)(uintptr_t)p; }
static void dont_log(gpr_log_func_args *args) {}
int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
- grpc_test_only_set_metadata_hash_seed(0);
+ grpc_test_only_set_slice_hash_seed(0);
struct grpc_memory_counters counters;
if (squelch) gpr_set_log_function(dont_log);
if (leak_check) grpc_memory_counters_init();
diff --git a/test/core/end2end/goaway_server_test.c b/test/core/end2end/goaway_server_test.c
index a8c7b2be5ac41bb58adb2e2b8b2e1cfdd4691c7e..b5187b048ae61dc3caefb120d545959773b70a56 100644
--- a/test/core/end2end/goaway_server_test.c
+++ b/test/core/end2end/goaway_server_test.c
@@ -101,8 +101,7 @@ int main(int argc, char **argv) {
grpc_metadata_array request_metadata1;
grpc_call_details request_details1;
grpc_status_code status1;
- char *details1 = NULL;
- size_t details_capacity1 = 0;
+ grpc_slice details1;
grpc_metadata_array_init(&trailing_metadata_recv1);
grpc_metadata_array_init(&request_metadata1);
grpc_call_details_init(&request_details1);
@@ -111,8 +110,7 @@ int main(int argc, char **argv) {
grpc_metadata_array request_metadata2;
grpc_call_details request_details2;
grpc_status_code status2;
- char *details2 = NULL;
- size_t details_capacity2 = 0;
+ grpc_slice details2;
grpc_metadata_array_init(&trailing_metadata_recv2);
grpc_metadata_array_init(&request_metadata2);
grpc_call_details_init(&request_details2);
@@ -129,9 +127,11 @@ int main(int argc, char **argv) {
/* create a channel that picks first amongst the servers */
grpc_channel *chan = grpc_insecure_channel_create("test", NULL, NULL);
/* and an initial call to them */
- grpc_call *call1 = grpc_channel_create_call(
- chan, NULL, GRPC_PROPAGATE_DEFAULTS, cq, "/foo", "127.0.0.1",
- GRPC_TIMEOUT_SECONDS_TO_DEADLINE(20), NULL);
+ grpc_slice host = grpc_slice_from_static_string("127.0.0.1");
+ grpc_call *call1 =
+ grpc_channel_create_call(chan, NULL, GRPC_PROPAGATE_DEFAULTS, cq,
+ grpc_slice_from_static_string("/foo"), &host,
+ GRPC_TIMEOUT_SECONDS_TO_DEADLINE(20), NULL);
/* send initial metadata to probe connectivity */
memset(ops, 0, sizeof(ops));
op = ops;
@@ -150,7 +150,6 @@ int main(int argc, char **argv) {
op->data.recv_status_on_client.trailing_metadata = &trailing_metadata_recv1;
op->data.recv_status_on_client.status = &status1;
op->data.recv_status_on_client.status_details = &details1;
- op->data.recv_status_on_client.status_details_capacity = &details_capacity1;
op->flags = 0;
op->reserved = NULL;
op++;
@@ -205,9 +204,10 @@ int main(int argc, char **argv) {
cq_verify_empty(cqv);
/* and a new call: should go through to server2 when we start it */
- grpc_call *call2 = grpc_channel_create_call(
- chan, NULL, GRPC_PROPAGATE_DEFAULTS, cq, "/foo", "127.0.0.1",
- GRPC_TIMEOUT_SECONDS_TO_DEADLINE(20), NULL);
+ grpc_call *call2 =
+ grpc_channel_create_call(chan, NULL, GRPC_PROPAGATE_DEFAULTS, cq,
+ grpc_slice_from_static_string("/foo"), &host,
+ GRPC_TIMEOUT_SECONDS_TO_DEADLINE(20), NULL);
/* send initial metadata to probe connectivity */
memset(ops, 0, sizeof(ops));
op = ops;
@@ -226,7 +226,6 @@ int main(int argc, char **argv) {
op->data.recv_status_on_client.trailing_metadata = &trailing_metadata_recv2;
op->data.recv_status_on_client.status = &status2;
op->data.recv_status_on_client.status_details = &details2;
- op->data.recv_status_on_client.status_details_capacity = &details_capacity2;
op->flags = 0;
op->reserved = NULL;
op++;
@@ -292,11 +291,11 @@ int main(int argc, char **argv) {
grpc_metadata_array_destroy(&trailing_metadata_recv1);
grpc_metadata_array_destroy(&request_metadata1);
grpc_call_details_destroy(&request_details1);
- gpr_free(details1);
+ grpc_slice_unref(details1);
grpc_metadata_array_destroy(&trailing_metadata_recv2);
grpc_metadata_array_destroy(&request_metadata2);
grpc_call_details_destroy(&request_details2);
- gpr_free(details2);
+ grpc_slice_unref(details2);
cq_verifier_destroy(cqv);
grpc_completion_queue_destroy(cq);
diff --git a/test/core/end2end/invalid_call_argument_test.c b/test/core/end2end/invalid_call_argument_test.c
index 765b6ad1bee8ab67418a4086d13ad65f323ece01..3b26ddb6d08fc2ffeeb8c3d1a010aa2ebcc972b4 100644
--- a/test/core/end2end/invalid_call_argument_test.c
+++ b/test/core/end2end/invalid_call_argument_test.c
@@ -56,8 +56,7 @@ struct test_state {
grpc_metadata_array initial_metadata_recv;
grpc_metadata_array trailing_metadata_recv;
grpc_status_code status;
- char *details;
- size_t details_capacity;
+ grpc_slice details;
grpc_call *server_call;
grpc_server *server;
grpc_metadata_array server_initial_metadata_recv;
@@ -76,17 +75,16 @@ static void prepare_test(int is_client) {
g_state.deadline = GRPC_TIMEOUT_SECONDS_TO_DEADLINE(2);
g_state.cq = grpc_completion_queue_create(NULL);
g_state.cqv = cq_verifier_create(g_state.cq);
- g_state.details = NULL;
- g_state.details_capacity = 0;
memset(g_state.ops, 0, sizeof(g_state.ops));
if (is_client) {
/* create a call, channel to a non existant server */
g_state.chan =
grpc_insecure_channel_create("nonexistant:54321", NULL, NULL);
+ grpc_slice host = grpc_slice_from_static_string("nonexistant");
g_state.call = grpc_channel_create_call(
- g_state.chan, NULL, GRPC_PROPAGATE_DEFAULTS, g_state.cq, "/Foo",
- "nonexistant", g_state.deadline, NULL);
+ g_state.chan, NULL, GRPC_PROPAGATE_DEFAULTS, g_state.cq,
+ grpc_slice_from_static_string("/Foo"), &host, g_state.deadline, NULL);
} else {
g_state.server = grpc_server_create(NULL, NULL);
grpc_server_register_completion_queue(g_state.server, g_state.cq, NULL);
@@ -97,9 +95,10 @@ static void prepare_test(int is_client) {
gpr_join_host_port(&server_hostport, "localhost", port);
g_state.chan = grpc_insecure_channel_create(server_hostport, NULL, NULL);
gpr_free(server_hostport);
+ grpc_slice host = grpc_slice_from_static_string("bar");
g_state.call = grpc_channel_create_call(
- g_state.chan, NULL, GRPC_PROPAGATE_DEFAULTS, g_state.cq, "/Foo", "bar",
- g_state.deadline, NULL);
+ g_state.chan, NULL, GRPC_PROPAGATE_DEFAULTS, g_state.cq,
+ grpc_slice_from_static_string("/Foo"), &host, g_state.deadline, NULL);
grpc_metadata_array_init(&g_state.server_initial_metadata_recv);
grpc_call_details_init(&g_state.call_details);
op = g_state.ops;
@@ -126,7 +125,7 @@ static void cleanup_test() {
grpc_call_destroy(g_state.call);
cq_verifier_destroy(g_state.cqv);
grpc_channel_destroy(g_state.chan);
- gpr_free(g_state.details);
+ grpc_slice_unref(g_state.details);
grpc_metadata_array_destroy(&g_state.initial_metadata_recv);
grpc_metadata_array_destroy(&g_state.trailing_metadata_recv);
@@ -289,7 +288,8 @@ static void test_send_server_status_from_client() {
op->op = GRPC_OP_SEND_STATUS_FROM_SERVER;
op->data.send_status_from_server.trailing_metadata_count = 0;
op->data.send_status_from_server.status = GRPC_STATUS_UNIMPLEMENTED;
- op->data.send_status_from_server.status_details = "xyz";
+ grpc_slice status_details = grpc_slice_from_static_string("xyz");
+ op->data.send_status_from_server.status_details = &status_details;
op->flags = 0;
op->reserved = NULL;
op++;
@@ -398,8 +398,6 @@ static void test_recv_status_on_client_twice() {
&g_state.trailing_metadata_recv;
op->data.recv_status_on_client.status = &g_state.status;
op->data.recv_status_on_client.status_details = &g_state.details;
- op->data.recv_status_on_client.status_details_capacity =
- &g_state.details_capacity;
op->flags = 0;
op->reserved = NULL;
op++;
@@ -414,7 +412,6 @@ static void test_recv_status_on_client_twice() {
op->data.recv_status_on_client.trailing_metadata = NULL;
op->data.recv_status_on_client.status = NULL;
op->data.recv_status_on_client.status_details = NULL;
- op->data.recv_status_on_client.status_details_capacity = NULL;
op->flags = 0;
op->reserved = NULL;
op++;
@@ -453,8 +450,6 @@ static void test_recv_status_on_client_from_server() {
&g_state.trailing_metadata_recv;
op->data.recv_status_on_client.status = &g_state.status;
op->data.recv_status_on_client.status_details = &g_state.details;
- op->data.recv_status_on_client.status_details_capacity =
- &g_state.details_capacity;
op->flags = 0;
op->reserved = NULL;
op++;
@@ -474,7 +469,8 @@ static void test_send_status_from_server_with_invalid_flags() {
op->op = GRPC_OP_SEND_STATUS_FROM_SERVER;
op->data.send_status_from_server.trailing_metadata_count = 0;
op->data.send_status_from_server.status = GRPC_STATUS_UNIMPLEMENTED;
- op->data.send_status_from_server.status_details = "xyz";
+ grpc_slice status_details = grpc_slice_from_static_string("xyz");
+ op->data.send_status_from_server.status_details = &status_details;
op->flags = 1;
op->reserved = NULL;
op++;
@@ -495,7 +491,8 @@ static void test_too_many_trailing_metadata() {
op->data.send_status_from_server.trailing_metadata_count =
(size_t)INT_MAX + 1;
op->data.send_status_from_server.status = GRPC_STATUS_UNIMPLEMENTED;
- op->data.send_status_from_server.status_details = "xyz";
+ grpc_slice status_details = grpc_slice_from_static_string("xyz");
+ op->data.send_status_from_server.status_details = &status_details;
op->flags = 0;
op->reserved = NULL;
op++;
@@ -515,14 +512,15 @@ static void test_send_server_status_twice() {
op->op = GRPC_OP_SEND_STATUS_FROM_SERVER;
op->data.send_status_from_server.trailing_metadata_count = 0;
op->data.send_status_from_server.status = GRPC_STATUS_UNIMPLEMENTED;
- op->data.send_status_from_server.status_details = "xyz";
+ grpc_slice status_details = grpc_slice_from_static_string("xyz");
+ op->data.send_status_from_server.status_details = &status_details;
op->flags = 0;
op->reserved = NULL;
op++;
op->op = GRPC_OP_SEND_STATUS_FROM_SERVER;
op->data.send_status_from_server.trailing_metadata_count = 0;
op->data.send_status_from_server.status = GRPC_STATUS_UNIMPLEMENTED;
- op->data.send_status_from_server.status_details = "xyz";
+ op->data.send_status_from_server.status_details = &status_details;
op->flags = 0;
op->reserved = NULL;
op++;
diff --git a/test/core/end2end/no_server_test.c b/test/core/end2end/no_server_test.c
index 03ff70a1881f29db18c21e33459cb1123ef27798..5c0f7a0f488ec9c6401cb6b7bcf9da75c4e172a4 100644
--- a/test/core/end2end/no_server_test.c
+++ b/test/core/end2end/no_server_test.c
@@ -52,8 +52,7 @@ int main(int argc, char **argv) {
grpc_op *op;
grpc_metadata_array trailing_metadata_recv;
grpc_status_code status;
- char *details = NULL;
- size_t details_capacity = 0;
+ grpc_slice details;
grpc_test_init(argc, argv);
grpc_init();
@@ -65,8 +64,10 @@ int main(int argc, char **argv) {
/* create a call, channel to a non existant server */
chan = grpc_insecure_channel_create("nonexistant:54321", NULL, NULL);
+ grpc_slice host = grpc_slice_from_static_string("nonexistant");
call = grpc_channel_create_call(chan, NULL, GRPC_PROPAGATE_DEFAULTS, cq,
- "/Foo", "nonexistant", deadline, NULL);
+ grpc_slice_from_static_string("/Foo"), &host,
+ deadline, NULL);
memset(ops, 0, sizeof(ops));
op = ops;
@@ -79,7 +80,6 @@ int main(int argc, char **argv) {
op->data.recv_status_on_client.trailing_metadata = &trailing_metadata_recv;
op->data.recv_status_on_client.status = &status;
op->data.recv_status_on_client.status_details = &details;
- op->data.recv_status_on_client.status_details_capacity = &details_capacity;
op->flags = 0;
op->reserved = NULL;
op++;
@@ -101,7 +101,7 @@ int main(int argc, char **argv) {
grpc_channel_destroy(chan);
cq_verifier_destroy(cqv);
- gpr_free(details);
+ grpc_slice_unref(details);
grpc_metadata_array_destroy(&trailing_metadata_recv);
grpc_shutdown();
diff --git a/test/core/fling/client.c b/test/core/fling/client.c
index e717b7f7fedf24e56e79ca34492110d1cb962a72..bb44320f34bc73929b13868ba560a8f3b2ba995d 100644
--- a/test/core/fling/client.c
+++ b/test/core/fling/client.c
@@ -57,8 +57,7 @@ static grpc_metadata_array initial_metadata_recv;
static grpc_metadata_array trailing_metadata_recv;
static grpc_byte_buffer *response_payload_recv = NULL;
static grpc_status_code status;
-static char *details = NULL;
-static size_t details_capacity = 0;
+static grpc_slice details;
static grpc_op *op;
static void init_ping_pong_request(void) {
@@ -86,15 +85,16 @@ static void init_ping_pong_request(void) {
op->data.recv_status_on_client.trailing_metadata = &trailing_metadata_recv;
op->data.recv_status_on_client.status = &status;
op->data.recv_status_on_client.status_details = &details;
- op->data.recv_status_on_client.status_details_capacity = &details_capacity;
op++;
}
static void step_ping_pong_request(void) {
GPR_TIMER_BEGIN("ping_pong", 1);
- call = grpc_channel_create_call(channel, NULL, GRPC_PROPAGATE_DEFAULTS, cq,
- "/Reflector/reflectUnary", "localhost",
- gpr_inf_future(GPR_CLOCK_REALTIME), NULL);
+ grpc_slice host = grpc_slice_from_static_string("localhost");
+ call = grpc_channel_create_call(
+ channel, NULL, GRPC_PROPAGATE_DEFAULTS, cq,
+ grpc_slice_from_static_string("/Reflector/reflectUnary"), &host,
+ gpr_inf_future(GPR_CLOCK_REALTIME), NULL);
GPR_ASSERT(GRPC_CALL_OK == grpc_call_start_batch(call, ops,
(size_t)(op - ops),
(void *)1, NULL));
@@ -109,9 +109,11 @@ static void init_ping_pong_stream(void) {
grpc_metadata_array_init(&initial_metadata_recv);
grpc_call_error error;
- call = grpc_channel_create_call(channel, NULL, GRPC_PROPAGATE_DEFAULTS, cq,
- "/Reflector/reflectStream", "localhost",
- gpr_inf_future(GPR_CLOCK_REALTIME), NULL);
+ grpc_slice host = grpc_slice_from_static_string("localhost");
+ call = grpc_channel_create_call(
+ channel, NULL, GRPC_PROPAGATE_DEFAULTS, cq,
+ grpc_slice_from_static_string("/Reflector/reflectStream"), &host,
+ gpr_inf_future(GPR_CLOCK_REALTIME), NULL);
stream_init_ops[0].op = GRPC_OP_SEND_INITIAL_METADATA;
stream_init_ops[0].data.send_initial_metadata.count = 0;
stream_init_ops[1].op = GRPC_OP_RECV_INITIAL_METADATA;
diff --git a/test/core/fling/server.c b/test/core/fling/server.c
index fd446f1128e20fafdf6dab5fbfd79e2eead76c40..d4849e3bbe97e9405c763d2187edcc870aa173d7 100644
--- a/test/core/fling/server.c
+++ b/test/core/fling/server.c
@@ -118,7 +118,7 @@ static void handle_unary_method(void) {
op->op = GRPC_OP_SEND_STATUS_FROM_SERVER;
op->data.send_status_from_server.status = GRPC_STATUS_OK;
op->data.send_status_from_server.trailing_metadata_count = 0;
- op->data.send_status_from_server.status_details = "";
+ op->data.send_status_from_server.status_details = NULL;
op++;
op->op = GRPC_OP_RECV_CLOSE_ON_SERVER;
op->data.recv_close_on_server.cancelled = &was_cancelled;
@@ -168,7 +168,7 @@ static void start_send_status(void) {
status_op[0].op = GRPC_OP_SEND_STATUS_FROM_SERVER;
status_op[0].data.send_status_from_server.status = GRPC_STATUS_OK;
status_op[0].data.send_status_from_server.trailing_metadata_count = 0;
- status_op[0].data.send_status_from_server.status_details = "";
+ status_op[0].data.send_status_from_server.status_details = NULL;
status_op[1].op = GRPC_OP_RECV_CLOSE_ON_SERVER;
status_op[1].data.recv_close_on_server.cancelled = &was_cancelled;
@@ -259,8 +259,8 @@ int main(int argc, char **argv) {
switch ((intptr_t)s) {
case FLING_SERVER_NEW_REQUEST:
if (call != NULL) {
- if (0 ==
- strcmp(call_details.method, "/Reflector/reflectStream")) {
+ if (0 == grpc_slice_str_cmp(call_details.method,
+ "/Reflector/reflectStream")) {
/* Received streaming call. Send metadata here. */
start_read_op(FLING_SERVER_READ_FOR_STREAMING);
send_initial_metadata();
diff --git a/test/core/security/credentials_test.c b/test/core/security/credentials_test.c
index 8fd4737c8fa8dd52b695cfd00c0a7b1d659bffd2..c8c6eebd601e7139cec6bc95d4546ae03bbceb90 100644
--- a/test/core/security/credentials_test.c
+++ b/test/core/security/credentials_test.c
@@ -1065,9 +1065,8 @@ static void plugin_get_metadata_success(void *state,
*s = PLUGIN_GET_METADATA_CALLED_STATE;
for (i = 0; i < GPR_ARRAY_SIZE(plugin_md); i++) {
memset(&md[i], 0, sizeof(grpc_metadata));
- md[i].key = plugin_md[i].key;
- md[i].value = plugin_md[i].value;
- md[i].value_length = strlen(plugin_md[i].value);
+ md[i].key = grpc_slice_from_copied_string(plugin_md[i].key);
+ md[i].value = grpc_slice_from_copied_string(plugin_md[i].value);
}
cb(user_data, md, GPR_ARRAY_SIZE(md), GRPC_STATUS_OK, NULL);
}
diff --git a/test/core/security/ssl_server_fuzzer.c b/test/core/security/ssl_server_fuzzer.c
index 04969765f59f59212db1c81f4ab9c9a4ae08acfb..dd81c5276253644ddcaee972ff35625844e75010 100644
--- a/test/core/security/ssl_server_fuzzer.c
+++ b/test/core/security/ssl_server_fuzzer.c
@@ -82,7 +82,7 @@ int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
grpc_resource_quota_create("ssl_server_fuzzer");
grpc_endpoint *mock_endpoint =
grpc_mock_endpoint_create(discard_write, resource_quota);
- grpc_resource_quota_internal_unref(&exec_ctx, resource_quota);
+ grpc_resource_quota_unref_internal(&exec_ctx, resource_quota);
grpc_mock_endpoint_put_read(
&exec_ctx, mock_endpoint,
@@ -106,7 +106,7 @@ int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
// Create security connector
grpc_server_security_connector *sc = NULL;
grpc_security_status status =
- grpc_server_credentials_create_security_connector(creds, &sc);
+ grpc_server_credentials_create_security_connector(&exec_ctx, creds, &sc);
GPR_ASSERT(status == GRPC_SECURITY_OK);
sc->channel_args = NULL;
gpr_timespec deadline = gpr_time_add(gpr_now(GPR_CLOCK_MONOTONIC),
@@ -129,7 +129,7 @@ int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
GPR_ASSERT(state.done_callback_called);
- GRPC_SECURITY_CONNECTOR_UNREF(&sc->base, "test");
+ GRPC_SECURITY_CONNECTOR_UNREF(&exec_ctx, &sc->base, "test");
grpc_server_credentials_release(creds);
grpc_slice_unref(cert_slice);
grpc_slice_unref(key_slice);
diff --git a/test/core/slice/slice_test.c b/test/core/slice/slice_test.c
index a14f15ccfa3aac958c720d5294e3658dcea80695..ddb66f9deac187a66282265adb1adc986a84ed91 100644
--- a/test/core/slice/slice_test.c
+++ b/test/core/slice/slice_test.c
@@ -62,8 +62,10 @@ static void test_slice_malloc_returns_something_sensible(void) {
GPR_ASSERT(GRPC_SLICE_LENGTH(slice) == length);
/* If the slice has a refcount, it must be destroyable. */
if (slice.refcount) {
- GPR_ASSERT(slice.refcount->ref != NULL);
- GPR_ASSERT(slice.refcount->unref != NULL);
+ GPR_ASSERT(slice.refcount->vtable != NULL);
+ GPR_ASSERT(slice.refcount->vtable->ref != NULL);
+ GPR_ASSERT(slice.refcount->vtable->unref != NULL);
+ GPR_ASSERT(slice.refcount->vtable->hash != NULL);
}
/* We must be able to write to every byte of the data */
for (i = 0; i < length; i++) {
diff --git a/test/core/surface/lame_client_test.c b/test/core/surface/lame_client_test.c
index 6afcefca9236c000e4482323fc96ab9ae9e2342f..4ab8715f706ece687cd6ab16982efb3f4ea6110e 100644
--- a/test/core/surface/lame_client_test.c
+++ b/test/core/surface/lame_client_test.c
@@ -88,8 +88,7 @@ int main(int argc, char **argv) {
grpc_metadata_array trailing_metadata_recv;
grpc_status_code status;
grpc_call_error error;
- char *details = NULL;
- size_t details_capacity = 0;
+ grpc_slice details;
char *peer;
grpc_test_init(argc, argv);
@@ -109,8 +108,9 @@ int main(int argc, char **argv) {
cq = grpc_completion_queue_create(NULL);
+ grpc_slice host = grpc_slice_from_static_string("anywhere");
call = grpc_channel_create_call(chan, NULL, GRPC_PROPAGATE_DEFAULTS, cq,
- "/Foo", "anywhere",
+ grpc_slice_from_static_string("/Foo"), &host,
GRPC_TIMEOUT_SECONDS_TO_DEADLINE(100), NULL);
GPR_ASSERT(call);
cqv = cq_verifier_create(cq);
@@ -140,7 +140,6 @@ int main(int argc, char **argv) {
op->data.recv_status_on_client.trailing_metadata = &trailing_metadata_recv;
op->data.recv_status_on_client.status = &status;
op->data.recv_status_on_client.status_details = &details;
- op->data.recv_status_on_client.status_details_capacity = &details_capacity;
op->flags = 0;
op->reserved = NULL;
op++;
@@ -162,7 +161,7 @@ int main(int argc, char **argv) {
grpc_metadata_array_destroy(&initial_metadata_recv);
grpc_metadata_array_destroy(&trailing_metadata_recv);
- gpr_free(details);
+ grpc_slice_unref(details);
grpc_shutdown();
diff --git a/test/core/transport/chttp2/bin_encoder_test.c b/test/core/transport/chttp2/bin_encoder_test.c
index 53b55a301e2921f371756999659b772028b054ec..778606a78cb4a56be875726ab5d0de5757127470 100644
--- a/test/core/transport/chttp2/bin_encoder_test.c
+++ b/test/core/transport/chttp2/bin_encoder_test.c
@@ -84,7 +84,7 @@ static void expect_combined_equiv(const char *s, size_t len, int line) {
grpc_slice input = grpc_slice_from_copied_buffer(s, len);
grpc_slice base64 = grpc_chttp2_base64_encode(input);
grpc_slice expect = grpc_chttp2_huffman_compress(base64);
- grpc_slice got = grpc_chttp2_base64_encode_and_huffman_compress_impl(input);
+ grpc_slice got = grpc_chttp2_base64_encode_and_huffman_compress(input);
if (0 != grpc_slice_cmp(expect, got)) {
char *t = grpc_dump_slice(input, GPR_DUMP_HEX | GPR_DUMP_ASCII);
char *e = grpc_dump_slice(expect, GPR_DUMP_HEX | GPR_DUMP_ASCII);
@@ -106,7 +106,7 @@ static void expect_combined_equiv(const char *s, size_t len, int line) {
expect_combined_equiv(x, sizeof(x) - 1, __LINE__)
static void expect_binary_header(const char *hdr, int binary) {
- if (grpc_is_binary_header(hdr, strlen(hdr)) != binary) {
+ if (grpc_is_binary_header(grpc_slice_from_static_string(hdr)) != binary) {
gpr_log(GPR_ERROR, "FAILED: expected header '%s' to be %s", hdr,
binary ? "binary" : "not binary");
all_ok = 0;
diff --git a/test/core/transport/chttp2/hpack_encoder_test.c b/test/core/transport/chttp2/hpack_encoder_test.c
index 1fd2540d652620114260fe8c686e94f49fd54f2a..817a9636bfab19f0e9852fc100bcc987058d73cb 100644
--- a/test/core/transport/chttp2/hpack_encoder_test.c
+++ b/test/core/transport/chttp2/hpack_encoder_test.c
@@ -81,7 +81,9 @@ static void verify(grpc_exec_ctx *exec_ctx, size_t window_available, int eof,
e[i - 1].next = &e[i];
e[i].prev = &e[i - 1];
}
- e[i].md = grpc_mdelem_from_strings(exec_ctx, key, value);
+ e[i].md =
+ grpc_mdelem_from_slices(exec_ctx, grpc_slice_from_copied_string(key),
+ grpc_slice_from_copied_string(value));
}
e[0].prev = NULL;
e[nheaders - 1].next = NULL;
@@ -193,7 +195,9 @@ static void verify_table_size_change_match_elem_size(grpc_exec_ctx *exec_ctx,
const char *key,
const char *value) {
grpc_slice_buffer output;
- grpc_mdelem *elem = grpc_mdelem_from_strings(exec_ctx, key, value);
+ grpc_mdelem *elem =
+ grpc_mdelem_from_slices(exec_ctx, grpc_slice_from_copied_string(key),
+ grpc_slice_from_copied_string(value));
size_t elem_size = grpc_mdelem_get_size_in_hpack_table(elem);
size_t initial_table_size = g_compressor.table_size;
grpc_linked_mdelem *e = gpr_malloc(sizeof(*e));
@@ -233,7 +237,7 @@ static void run_test(void (*test)(grpc_exec_ctx *exec_ctx), const char *name) {
int main(int argc, char **argv) {
size_t i;
- grpc_test_only_set_metadata_hash_seed(0);
+ grpc_test_only_set_slice_hash_seed(0);
grpc_test_init(argc, argv);
grpc_init();
TEST(test_basic_headers);
diff --git a/test/core/transport/chttp2/hpack_parser_fuzzer_test.c b/test/core/transport/chttp2/hpack_parser_fuzzer_test.c
index 4e00f49b66466472b433e86a0f4d9424add130b5..b3b3f7ac7c4d1c69cb879500f397b44eb59d2364 100644
--- a/test/core/transport/chttp2/hpack_parser_fuzzer_test.c
+++ b/test/core/transport/chttp2/hpack_parser_fuzzer_test.c
@@ -39,6 +39,7 @@
#include <grpc/support/log.h>
#include "src/core/ext/transport/chttp2/transport/hpack_parser.h"
+#include "src/core/lib/slice/slice_internal.h"
bool squelch = true;
bool leak_check = true;
@@ -49,7 +50,7 @@ static void onhdr(grpc_exec_ctx *exec_ctx, void *ud, grpc_mdelem *md) {
static void dont_log(gpr_log_func_args *args) {}
int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
- grpc_test_only_set_metadata_hash_seed(0);
+ grpc_test_only_set_slice_hash_seed(0);
if (squelch) gpr_set_log_function(dont_log);
grpc_init();
grpc_chttp2_hpack_parser parser;
diff --git a/test/core/transport/chttp2/hpack_parser_test.c b/test/core/transport/chttp2/hpack_parser_test.c
index 8f48849c974777ea28157d86400445965bb3307c..6d2b4111c2e5455f157794ca1e48c9aba84052e8 100644
--- a/test/core/transport/chttp2/hpack_parser_test.c
+++ b/test/core/transport/chttp2/hpack_parser_test.c
@@ -52,8 +52,8 @@ static void onhdr(grpc_exec_ctx *exec_ctx, void *ud, grpc_mdelem *md) {
GPR_ASSERT(ekey);
evalue = va_arg(chk->args, char *);
GPR_ASSERT(evalue);
- GPR_ASSERT(grpc_slice_str_cmp(md->key->slice, ekey) == 0);
- GPR_ASSERT(grpc_slice_str_cmp(md->value->slice, evalue) == 0);
+ GPR_ASSERT(grpc_slice_str_cmp(md->key, ekey) == 0);
+ GPR_ASSERT(grpc_slice_str_cmp(md->value, evalue) == 0);
GRPC_MDELEM_UNREF(exec_ctx, md);
}
diff --git a/test/core/transport/chttp2/hpack_table_test.c b/test/core/transport/chttp2/hpack_table_test.c
index ef2ad66b5ca84c3958ed483405561c13b5290c73..695846399eeb756ecaee00b1690ec00ca8563590 100644
--- a/test/core/transport/chttp2/hpack_table_test.c
+++ b/test/core/transport/chttp2/hpack_table_test.c
@@ -46,9 +46,9 @@
#define LOG_TEST(x) gpr_log(GPR_INFO, "%s", x)
-static void assert_str(const grpc_chttp2_hptbl *tbl, grpc_mdstr *mdstr,
+static void assert_str(const grpc_chttp2_hptbl *tbl, grpc_slice mdstr,
const char *str) {
- GPR_ASSERT(grpc_slice_str_cmp(mdstr->slice, str) == 0);
+ GPR_ASSERT(grpc_slice_str_cmp(mdstr, str) == 0);
}
static void assert_index(const grpc_chttp2_hptbl *tbl, uint32_t idx,
@@ -146,7 +146,9 @@ static void test_many_additions(void) {
grpc_mdelem *elem;
gpr_asprintf(&key, "K:%d", i);
gpr_asprintf(&value, "VALUE:%d", i);
- elem = grpc_mdelem_from_strings(&exec_ctx, key, value);
+ elem =
+ grpc_mdelem_from_slices(&exec_ctx, grpc_slice_from_copied_string(key),
+ grpc_slice_from_copied_string(value));
GPR_ASSERT(grpc_chttp2_hptbl_add(&exec_ctx, &tbl, elem) == GRPC_ERROR_NONE);
GRPC_MDELEM_UNREF(&exec_ctx, elem);
assert_index(&tbl, 1 + GRPC_CHTTP2_LAST_STATIC_ENTRY, key, value);
@@ -169,7 +171,9 @@ static grpc_chttp2_hptbl_find_result find_simple(grpc_chttp2_hptbl *tbl,
const char *key,
const char *value) {
grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
- grpc_mdelem *md = grpc_mdelem_from_strings(&exec_ctx, key, value);
+ grpc_mdelem *md =
+ grpc_mdelem_from_slices(&exec_ctx, grpc_slice_from_copied_string(key),
+ grpc_slice_from_copied_string(value));
grpc_chttp2_hptbl_find_result r = grpc_chttp2_hptbl_find(tbl, md);
GRPC_MDELEM_UNREF(&exec_ctx, md);
grpc_exec_ctx_finish(&exec_ctx);
@@ -187,13 +191,18 @@ static void test_find(void) {
LOG_TEST("test_find");
grpc_chttp2_hptbl_init(&exec_ctx, &tbl);
- elem = grpc_mdelem_from_strings(&exec_ctx, "abc", "xyz");
+ elem =
+ grpc_mdelem_from_slices(&exec_ctx, grpc_slice_from_static_string("abc"),
+ grpc_slice_from_static_string("xyz"));
GPR_ASSERT(grpc_chttp2_hptbl_add(&exec_ctx, &tbl, elem) == GRPC_ERROR_NONE);
GRPC_MDELEM_UNREF(&exec_ctx, elem);
- elem = grpc_mdelem_from_strings(&exec_ctx, "abc", "123");
+ elem =
+ grpc_mdelem_from_slices(&exec_ctx, grpc_slice_from_static_string("abc"),
+ grpc_slice_from_static_string("123"));
GPR_ASSERT(grpc_chttp2_hptbl_add(&exec_ctx, &tbl, elem) == GRPC_ERROR_NONE);
GRPC_MDELEM_UNREF(&exec_ctx, elem);
- elem = grpc_mdelem_from_strings(&exec_ctx, "x", "1");
+ elem = grpc_mdelem_from_slices(&exec_ctx, grpc_slice_from_static_string("x"),
+ grpc_slice_from_static_string("1"));
GPR_ASSERT(grpc_chttp2_hptbl_add(&exec_ctx, &tbl, elem) == GRPC_ERROR_NONE);
GRPC_MDELEM_UNREF(&exec_ctx, elem);
@@ -244,7 +253,9 @@ static void test_find(void) {
/* overflow the string buffer, check find still works */
for (i = 0; i < 10000; i++) {
int64_ttoa(i, buffer);
- elem = grpc_mdelem_from_strings(&exec_ctx, "test", buffer);
+ elem = grpc_mdelem_from_slices(&exec_ctx,
+ grpc_slice_from_static_string("test"),
+ grpc_slice_from_copied_string(buffer));
GPR_ASSERT(grpc_chttp2_hptbl_add(&exec_ctx, &tbl, elem) == GRPC_ERROR_NONE);
GRPC_MDELEM_UNREF(&exec_ctx, elem);
}
diff --git a/test/core/transport/metadata_test.c b/test/core/transport/metadata_test.c
index 3625043d0774e986d0f1b6f9a81e174f28c62e7f..bbe31f9c9e7bf27a49314d9ee0ecab65cc643a6f 100644
--- a/test/core/transport/metadata_test.c
+++ b/test/core/transport/metadata_test.c
@@ -47,55 +47,45 @@
#include "src/core/lib/transport/static_metadata.h"
#include "test/core/util/test_config.h"
-#define LOG_TEST(x) gpr_log(GPR_INFO, "%s", x)
-
/* a large number */
#define MANY 10000
static void test_no_op(void) {
- LOG_TEST("test_no_op");
+ gpr_log(GPR_INFO, "test_no_op");
grpc_init();
grpc_shutdown();
}
-static void test_create_string(void) {
- grpc_mdstr *s1, *s2, *s3;
-
- LOG_TEST("test_create_string");
-
- grpc_init();
- grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
- s1 = grpc_mdstr_from_string("hello");
- s2 = grpc_mdstr_from_string("hello");
- s3 = grpc_mdstr_from_string("very much not hello");
- GPR_ASSERT(s1 == s2);
- GPR_ASSERT(s3 != s1);
- GPR_ASSERT(grpc_slice_str_cmp(s1->slice, "hello") == 0);
- GPR_ASSERT(grpc_slice_str_cmp(s3->slice, "very much not hello") == 0);
- GRPC_MDSTR_UNREF(&exec_ctx, s1);
- GRPC_MDSTR_UNREF(&exec_ctx, s2);
- GRPC_MDSTR_UNREF(&exec_ctx, s3);
- grpc_exec_ctx_finish(&exec_ctx);
- grpc_shutdown();
+static grpc_slice maybe_intern(grpc_slice in, bool intern) {
+ grpc_slice out = intern ? grpc_slice_intern(in) : grpc_slice_ref(in);
+ grpc_slice_unref(in);
+ return out;
}
-static void test_create_metadata(void) {
+static void test_create_metadata(bool intern_keys, bool intern_values) {
grpc_mdelem *m1, *m2, *m3;
- LOG_TEST("test_create_metadata");
+ gpr_log(GPR_INFO, "test_create_metadata: intern_keys=%d intern_values=%d",
+ intern_keys, intern_values);
grpc_init();
grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
- m1 = grpc_mdelem_from_strings(&exec_ctx, "a", "b");
- m2 = grpc_mdelem_from_strings(&exec_ctx, "a", "b");
- m3 = grpc_mdelem_from_strings(&exec_ctx, "a", "c");
+ m1 = grpc_mdelem_from_slices(
+ &exec_ctx, maybe_intern(grpc_slice_from_static_string("a"), intern_keys),
+ maybe_intern(grpc_slice_from_static_string("b"), intern_values));
+ m2 = grpc_mdelem_from_slices(
+ &exec_ctx, maybe_intern(grpc_slice_from_static_string("a"), intern_keys),
+ maybe_intern(grpc_slice_from_static_string("b"), intern_values));
+ m3 = grpc_mdelem_from_slices(
+ &exec_ctx, maybe_intern(grpc_slice_from_static_string("a"), intern_keys),
+ maybe_intern(grpc_slice_from_static_string("c"), intern_values));
GPR_ASSERT(m1 == m2);
GPR_ASSERT(m3 != m1);
- GPR_ASSERT(m3->key == m1->key);
- GPR_ASSERT(m3->value != m1->value);
- GPR_ASSERT(grpc_slice_str_cmp(m1->key->slice, "a") == 0);
- GPR_ASSERT(grpc_slice_str_cmp(m1->value->slice, "b") == 0);
- GPR_ASSERT(grpc_slice_str_cmp(m3->value->slice, "c") == 0);
+ GPR_ASSERT(grpc_slice_cmp(m3->key, m1->key) == 0);
+ GPR_ASSERT(grpc_slice_cmp(m3->value, m1->value) != 0);
+ GPR_ASSERT(grpc_slice_str_cmp(m1->key, "a") == 0);
+ GPR_ASSERT(grpc_slice_str_cmp(m1->value, "b") == 0);
+ GPR_ASSERT(grpc_slice_str_cmp(m3->value, "c") == 0);
GRPC_MDELEM_UNREF(&exec_ctx, m1);
GRPC_MDELEM_UNREF(&exec_ctx, m2);
GRPC_MDELEM_UNREF(&exec_ctx, m3);
@@ -103,19 +93,28 @@ static void test_create_metadata(void) {
grpc_shutdown();
}
-static void test_create_many_ephemeral_metadata(void) {
+static void test_create_many_ephemeral_metadata(bool intern_keys,
+ bool intern_values) {
char buffer[GPR_LTOA_MIN_BUFSIZE];
long i;
- LOG_TEST("test_create_many_ephemeral_metadata");
+ gpr_log(
+ GPR_INFO,
+ "test_create_many_ephemeral_metadata: intern_keys=%d intern_values=%d",
+ intern_keys, intern_values);
grpc_init();
grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
/* add, and immediately delete a bunch of different elements */
for (i = 0; i < MANY; i++) {
gpr_ltoa(i, buffer);
- GRPC_MDELEM_UNREF(&exec_ctx,
- grpc_mdelem_from_strings(&exec_ctx, "a", buffer));
+ GRPC_MDELEM_UNREF(
+ &exec_ctx,
+ grpc_mdelem_from_slices(
+ &exec_ctx,
+ maybe_intern(grpc_slice_from_static_string("a"), intern_keys),
+ maybe_intern(grpc_slice_from_copied_string(buffer),
+ intern_values)));
}
grpc_exec_ctx_finish(&exec_ctx);
grpc_shutdown();
@@ -127,19 +126,23 @@ static void test_create_many_persistant_metadata(void) {
grpc_mdelem **created = gpr_malloc(sizeof(grpc_mdelem *) * MANY);
grpc_mdelem *md;
- LOG_TEST("test_create_many_persistant_metadata");
+ gpr_log(GPR_INFO, "test_create_many_persistant_metadata");
grpc_init();
grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
/* add phase */
for (i = 0; i < MANY; i++) {
gpr_ltoa(i, buffer);
- created[i] = grpc_mdelem_from_strings(&exec_ctx, "a", buffer);
+ created[i] = grpc_mdelem_from_slices(
+ &exec_ctx, grpc_slice_intern(grpc_slice_from_static_string("a")),
+ grpc_slice_intern(grpc_slice_from_copied_string(buffer)));
}
/* verify phase */
for (i = 0; i < MANY; i++) {
gpr_ltoa(i, buffer);
- md = grpc_mdelem_from_strings(&exec_ctx, "a", buffer);
+ md = grpc_mdelem_from_slices(
+ &exec_ctx, grpc_slice_intern(grpc_slice_from_static_string("a")),
+ grpc_slice_intern(grpc_slice_from_copied_string(buffer)));
GPR_ASSERT(md == created[i]);
GRPC_MDELEM_UNREF(&exec_ctx, md);
}
@@ -153,14 +156,32 @@ static void test_create_many_persistant_metadata(void) {
gpr_free(created);
}
-static void test_spin_creating_the_same_thing(void) {
- LOG_TEST("test_spin_creating_the_same_thing");
+static void test_spin_creating_the_same_thing(bool intern_keys,
+ bool intern_values) {
+ gpr_log(GPR_INFO,
+ "test_spin_creating_the_same_thing: intern_keys=%d intern_values=%d",
+ intern_keys, intern_values);
grpc_init();
grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
- GRPC_MDELEM_UNREF(&exec_ctx, grpc_mdelem_from_strings(&exec_ctx, "a", "b"));
- GRPC_MDELEM_UNREF(&exec_ctx, grpc_mdelem_from_strings(&exec_ctx, "a", "b"));
- GRPC_MDELEM_UNREF(&exec_ctx, grpc_mdelem_from_strings(&exec_ctx, "a", "b"));
+ GRPC_MDELEM_UNREF(
+ &exec_ctx,
+ grpc_mdelem_from_slices(
+ &exec_ctx,
+ maybe_intern(grpc_slice_from_static_string("a"), intern_keys),
+ maybe_intern(grpc_slice_from_static_string("b"), intern_values)));
+ GRPC_MDELEM_UNREF(
+ &exec_ctx,
+ grpc_mdelem_from_slices(
+ &exec_ctx,
+ maybe_intern(grpc_slice_from_static_string("a"), intern_keys),
+ maybe_intern(grpc_slice_from_static_string("b"), intern_values)));
+ GRPC_MDELEM_UNREF(
+ &exec_ctx,
+ grpc_mdelem_from_slices(
+ &exec_ctx,
+ maybe_intern(grpc_slice_from_static_string("a"), intern_keys),
+ maybe_intern(grpc_slice_from_static_string("b"), intern_values)));
grpc_exec_ctx_finish(&exec_ctx);
grpc_shutdown();
}
@@ -169,25 +190,25 @@ static void test_things_stick_around(void) {
size_t i, j;
char *buffer;
size_t nstrs = 1000;
- grpc_mdstr **strs = gpr_malloc(sizeof(grpc_mdstr *) * nstrs);
+ grpc_slice *strs = gpr_malloc(sizeof(grpc_slice *) * nstrs);
size_t *shuf = gpr_malloc(sizeof(size_t) * nstrs);
- grpc_mdstr *test;
+ grpc_slice test;
- LOG_TEST("test_things_stick_around");
+ gpr_log(GPR_INFO, "test_things_stick_around");
grpc_init();
grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
for (i = 0; i < nstrs; i++) {
gpr_asprintf(&buffer, "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%" PRIuPTR "x", i);
- strs[i] = grpc_mdstr_from_string(buffer);
+ strs[i] = grpc_slice_intern(grpc_slice_from_static_string(buffer));
shuf[i] = i;
gpr_free(buffer);
}
for (i = 0; i < nstrs; i++) {
- GRPC_MDSTR_REF(strs[i]);
- GRPC_MDSTR_UNREF(&exec_ctx, strs[i]);
+ grpc_slice_ref_internal(strs[i]);
+ grpc_slice_unref_internal(&exec_ctx, strs[i]);
}
for (i = 0; i < nstrs; i++) {
@@ -199,13 +220,13 @@ static void test_things_stick_around(void) {
}
for (i = 0; i < nstrs; i++) {
- GRPC_MDSTR_UNREF(&exec_ctx, strs[shuf[i]]);
+ grpc_slice_unref_internal(&exec_ctx, strs[shuf[i]]);
for (j = i + 1; j < nstrs; j++) {
gpr_asprintf(&buffer, "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx%" PRIuPTR "x",
shuf[j]);
- test = grpc_mdstr_from_string(buffer);
- GPR_ASSERT(test == strs[shuf[j]]);
- GRPC_MDSTR_UNREF(&exec_ctx, test);
+ test = grpc_slice_intern(grpc_slice_from_static_string(buffer));
+ GPR_ASSERT(grpc_slice_is_equivalent(test, strs[shuf[j]]));
+ grpc_slice_unref_internal(&exec_ctx, test);
gpr_free(buffer);
}
}
@@ -216,57 +237,11 @@ static void test_things_stick_around(void) {
gpr_free(shuf);
}
-static void test_slices_work(void) {
- /* ensure no memory leaks when switching representation from mdstr to slice */
- grpc_mdstr *str;
- grpc_slice slice;
-
- LOG_TEST("test_slices_work");
-
- grpc_init();
- grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-
- str = grpc_mdstr_from_string(
- "123456789012345678901234567890123456789012345678901234567890");
- slice = grpc_slice_ref(str->slice);
- GRPC_MDSTR_UNREF(&exec_ctx, str);
- grpc_slice_unref_internal(&exec_ctx, slice);
-
- str = grpc_mdstr_from_string(
- "123456789012345678901234567890123456789012345678901234567890");
- slice = grpc_slice_ref(str->slice);
- grpc_slice_unref_internal(&exec_ctx, slice);
- GRPC_MDSTR_UNREF(&exec_ctx, str);
-
- grpc_exec_ctx_finish(&exec_ctx);
- grpc_shutdown();
-}
-
-static void test_base64_and_huffman_works(void) {
- grpc_mdstr *str;
- grpc_slice slice1;
- grpc_slice slice2;
-
- LOG_TEST("test_base64_and_huffman_works");
-
- grpc_init();
- grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
- str = grpc_mdstr_from_string("abcdefg");
- slice1 = grpc_mdstr_as_base64_encoded_and_huffman_compressed(str);
- slice2 = grpc_chttp2_base64_encode_and_huffman_compress(str->slice);
- GPR_ASSERT(0 == grpc_slice_cmp(slice1, slice2));
-
- grpc_slice_unref_internal(&exec_ctx, slice2);
- GRPC_MDSTR_UNREF(&exec_ctx, str);
- grpc_exec_ctx_finish(&exec_ctx);
- grpc_shutdown();
-}
-
static void test_user_data_works(void) {
int *ud1;
int *ud2;
grpc_mdelem *md;
- LOG_TEST("test_user_data_works");
+ gpr_log(GPR_INFO, "test_user_data_works");
grpc_init();
grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
@@ -274,7 +249,9 @@ static void test_user_data_works(void) {
*ud1 = 1;
ud2 = gpr_malloc(sizeof(int));
*ud2 = 2;
- md = grpc_mdelem_from_strings(&exec_ctx, "abc", "123");
+ md = grpc_mdelem_from_slices(
+ &exec_ctx, grpc_slice_intern(grpc_slice_from_static_string("abc")),
+ grpc_slice_intern(grpc_slice_from_static_string("123")));
grpc_mdelem_set_user_data(md, gpr_free, ud1);
grpc_mdelem_set_user_data(md, gpr_free, ud2);
GPR_ASSERT(grpc_mdelem_get_user_data(md, gpr_free) == ud1);
@@ -285,7 +262,9 @@ static void test_user_data_works(void) {
static void verify_ascii_header_size(grpc_exec_ctx *exec_ctx, const char *key,
const char *value) {
- grpc_mdelem *elem = grpc_mdelem_from_strings(exec_ctx, key, value);
+ grpc_mdelem *elem = grpc_mdelem_from_slices(
+ exec_ctx, grpc_slice_intern(grpc_slice_from_static_string(key)),
+ grpc_slice_intern(grpc_slice_from_static_string(value)));
size_t elem_size = grpc_mdelem_get_size_in_hpack_table(elem);
size_t expected_size = 32 + strlen(key) + strlen(value);
GPR_ASSERT(expected_size == elem_size);
@@ -294,9 +273,10 @@ static void verify_ascii_header_size(grpc_exec_ctx *exec_ctx, const char *key,
static void verify_binary_header_size(grpc_exec_ctx *exec_ctx, const char *key,
const uint8_t *value, size_t value_len) {
- grpc_mdelem *elem =
- grpc_mdelem_from_string_and_buffer(exec_ctx, key, value, value_len);
- GPR_ASSERT(grpc_is_binary_header(key, strlen(key)));
+ grpc_mdelem *elem = grpc_mdelem_from_slices(
+ exec_ctx, grpc_slice_intern(grpc_slice_from_static_string(key)),
+ grpc_slice_intern(grpc_slice_from_static_buffer(value, value_len)));
+ GPR_ASSERT(grpc_is_binary_header(elem->key));
size_t elem_size = grpc_mdelem_get_size_in_hpack_table(elem);
grpc_slice value_slice =
grpc_slice_from_copied_buffer((const char *)value, value_len);
@@ -310,7 +290,7 @@ static void verify_binary_header_size(grpc_exec_ctx *exec_ctx, const char *key,
#define BUFFER_SIZE 64
static void test_mdelem_sizes_in_hpack(void) {
- LOG_TEST("test_mdelem_size");
+ gpr_log(GPR_INFO, "test_mdelem_size");
grpc_init();
grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
@@ -328,11 +308,6 @@ static void test_mdelem_sizes_in_hpack(void) {
verify_binary_header_size(&exec_ctx, "hello-bin", binary_value, i);
}
- const char *static_metadata = grpc_static_metadata_strings[0];
- memcpy(binary_value, static_metadata, strlen(static_metadata));
- verify_binary_header_size(&exec_ctx, "hello-bin", binary_value,
- strlen(static_metadata));
-
grpc_exec_ctx_finish(&exec_ctx);
grpc_shutdown();
}
@@ -340,14 +315,15 @@ static void test_mdelem_sizes_in_hpack(void) {
int main(int argc, char **argv) {
grpc_test_init(argc, argv);
test_no_op();
- test_create_string();
- test_create_metadata();
- test_create_many_ephemeral_metadata();
+ for (int k = 0; k <= 1; k++) {
+ for (int v = 0; v <= 1; v++) {
+ test_create_metadata(k, v);
+ test_create_many_ephemeral_metadata(k, v);
+ test_spin_creating_the_same_thing(k, v);
+ }
+ }
test_create_many_persistant_metadata();
- test_spin_creating_the_same_thing();
test_things_stick_around();
- test_slices_work();
- test_base64_and_huffman_works();
test_user_data_works();
test_mdelem_sizes_in_hpack();
return 0;
diff --git a/test/core/transport/timeout_encoding_test.c b/test/core/transport/timeout_encoding_test.c
index b6004af7b479fd0f2f409c61ff8da061b7e6c491..23b1eb577b01ba248b658a525de0f0ab56027f61 100644
--- a/test/core/transport/timeout_encoding_test.c
+++ b/test/core/transport/timeout_encoding_test.c
@@ -88,7 +88,8 @@ void test_encoding(void) {
static void assert_decodes_as(const char *buffer, gpr_timespec expected) {
gpr_timespec got;
gpr_log(GPR_INFO, "check decoding '%s'", buffer);
- GPR_ASSERT(1 == grpc_http2_decode_timeout(buffer, &got));
+ GPR_ASSERT(1 == grpc_http2_decode_timeout((const uint8_t *)buffer,
+ strlen(buffer), &got));
GPR_ASSERT(0 == gpr_time_cmp(got, expected));
}
@@ -134,18 +135,22 @@ void test_decoding(void) {
assert_decodes_as("9999999999S", gpr_inf_future(GPR_TIMESPAN));
}
-void test_decoding_fails(void) {
+static void assert_decoding_fails(const char *s) {
gpr_timespec x;
+ GPR_ASSERT(0 == grpc_http2_decode_timeout((const uint8_t *)s, strlen(s), &x));
+}
+
+void test_decoding_fails(void) {
LOG_TEST("test_decoding_fails");
- GPR_ASSERT(0 == grpc_http2_decode_timeout("", &x));
- GPR_ASSERT(0 == grpc_http2_decode_timeout(" ", &x));
- GPR_ASSERT(0 == grpc_http2_decode_timeout("x", &x));
- GPR_ASSERT(0 == grpc_http2_decode_timeout("1", &x));
- GPR_ASSERT(0 == grpc_http2_decode_timeout("1x", &x));
- GPR_ASSERT(0 == grpc_http2_decode_timeout("1ux", &x));
- GPR_ASSERT(0 == grpc_http2_decode_timeout("!", &x));
- GPR_ASSERT(0 == grpc_http2_decode_timeout("n1", &x));
- GPR_ASSERT(0 == grpc_http2_decode_timeout("-1u", &x));
+ assert_decoding_fails("");
+ assert_decoding_fails(" ");
+ assert_decoding_fails("x");
+ assert_decoding_fails("1");
+ assert_decoding_fails("1x");
+ assert_decoding_fails("1ux");
+ assert_decoding_fails("!");
+ assert_decoding_fails("n1");
+ assert_decoding_fails("-1u");
}
int main(int argc, char **argv) {