Chiebot-Mirror
/
grpc
mirror of https://github.com/grpc/grpc.git
8
0
Fork 0
Code Issues Projects Releases Wiki Activity

All core tests compile without grpc_mdstr

Browse Source
reviewable/pr8842/r1
Craig Tiller 8 years ago
parent 0451c3dbfc
commit 7d4116fa44
49 changed files with 488 additions and 386 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 4
      grpc.def
  2. 9
      include/grpc/grpc.h
  3. 10
      include/grpc/slice.h
  4. 2
      src/core/ext/transport/chttp2/transport/hpack_encoder.c
  5. 5
      src/core/ext/transport/chttp2/transport/hpack_parser.c
  6. 2
      src/core/lib/iomgr/ev_posix.c
  7. 6
      src/core/lib/security/credentials/plugin/plugin_credentials.c
  8. 46
      src/core/lib/slice/slice.c
  9. 2
      src/core/lib/slice/slice_intern.c
  10. 2
      src/core/lib/slice/slice_internal.h
  11. 5
      src/core/lib/slice/slice_string_helpers.c
  12. 6
      src/core/lib/surface/call.c
  13. 26
      src/core/lib/surface/validate_metadata.c
  14. 3
      src/core/lib/transport/metadata.c
  15. 8
      src/ruby/ext/grpc/rb_grpc_imports.generated.c
  16. 18
      src/ruby/ext/grpc/rb_grpc_imports.generated.h
  17. 18
      test/core/bad_client/tests/large_metadata.c
  18. 4
      test/core/bad_client/tests/simple_request.c
  19. 11
      test/core/bad_ssl/bad_ssl_test.c
  20. 6
      test/core/channel/channel_args_test.c
  21. 5
      test/core/channel/channel_stack_test.c
  22. 31
      test/core/client_channel/lb_policies_test.c
  23. 6
      test/core/client_channel/set_initial_connect_string_test.c
  24. 33
      test/core/compression/algorithm_test.c
  25. 4
      test/core/compression/compression_test.c
  26. 16
      test/core/end2end/bad_server_response_test.c
  27. 18
      test/core/end2end/connection_refused_test.c
  28. 20
      test/core/end2end/dualstack_socket_test.c
  29. 4
      test/core/end2end/fixtures/h2_oauth2.c
  30. 3
      test/core/end2end/fixtures/h2_ssl_cert.c
  31. 108
      test/core/end2end/fuzzers/api_fuzzer.c
  32. 16
      test/core/end2end/fuzzers/client_fuzzer.c
  33. 3
      test/core/end2end/fuzzers/server_fuzzer.c
  34. 27
      test/core/end2end/goaway_server_test.c
  35. 36
      test/core/end2end/invalid_call_argument_test.c
  36. 10
      test/core/end2end/no_server_test.c
  37. 20
      test/core/fling/client.c
  38. 8
      test/core/fling/server.c
  39. 5
      test/core/security/credentials_test.c
  40. 6
      test/core/security/ssl_server_fuzzer.c
  41. 6
      test/core/slice/slice_test.c
  42. 9
      test/core/surface/lame_client_test.c
  43. 4
      test/core/transport/chttp2/bin_encoder_test.c
  44. 10
      test/core/transport/chttp2/hpack_encoder_test.c
  45. 3
      test/core/transport/chttp2/hpack_parser_fuzzer_test.c
  46. 4
      test/core/transport/chttp2/hpack_parser_test.c
  47. 27
      test/core/transport/chttp2/hpack_table_test.c
  48. 212
      test/core/transport/metadata_test.c
  49. 27
      test/core/transport/timeout_encoding_test.c

4
grpc.def
Unescape View File

@ -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

9
include/grpc/grpc.h
Unescape View File

@ -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);

10
include/grpc/slice.h
Unescape View File

@ -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);

2
src/core/ext/transport/chttp2/transport/hpack_encoder.c
Unescape View File

@ -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);
}

5
src/core/ext/transport/chttp2/transport/hpack_parser.c
Unescape View File

@ -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;
}

2
src/core/lib/iomgr/ev_posix.c
Unescape View File

@ -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;

6
src/core/lib/security/credentials/plugin/plugin_credentials.c
Unescape View File

@ -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;

46
src/core/lib/slice/slice.c
Unescape View File

@ -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;
}

2
src/core/lib/slice/slice_intern.c
Unescape View File

@ -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;
}

2
src/core/lib/slice/slice_internal.h
Unescape View File

@ -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 */

5
src/core/lib/slice/slice_string_helpers.c
Unescape View File

@ -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;
}

6
src/core/lib/surface/call.c
Unescape View File

@ -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);

26
src/core/lib/surface/validate_metadata.c
Unescape View File

@ -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);
}

3
src/core/lib/transport/metadata.c
Unescape View File

@ -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;

8
src/ruby/ext/grpc/rb_grpc_imports.generated.c
Unescape View File

@ -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");

18
src/ruby/ext/grpc/rb_grpc_imports.generated.h
Unescape View File

@ -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

18
test/core/bad_client/tests/large_metadata.c
Unescape View File

@ -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);

4
test/core/bad_client/tests/simple_request.c
Unescape View File

@ -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);

11
test/core/bad_ssl/bad_ssl_test.c
Unescape View File

@ -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);

6
test/core/channel/channel_args_test.c
Unescape View File

@ -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) {

5
test/core/channel/channel_stack_test.c
Unescape View File

@ -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);
}

31
test/core/client_channel/lb_policies_test.c
Unescape View File

@ -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),

6
test/core/client_channel/set_initial_connect_string_test.c
Unescape View File

@ -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;

33
test/core/compression/algorithm_test.c
Unescape View File

@ -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);
}

4
test/core/compression/compression_test.c
Unescape View File

@ -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 */
}

16
test/core/end2end/bad_server_response_test.c
Unescape View File

@ -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);
}

18
test/core/end2end/connection_refused_test.c
Unescape View File

@ -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);
{

20
test/core/end2end/dualstack_socket_test.c
Unescape View File

@ -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);
}

4
test/core/end2end/fixtures/h2_oauth2.c
Unescape View File

@ -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];
}
}

3
test/core/end2end/fixtures/h2_ssl_cert.c
Unescape View File

@ -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);

108
test/core/end2end/fuzzers/api_fuzzer.c
Unescape View File

@ -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);

16
test/core/end2end/fuzzers/client_fuzzer.c
Unescape View File

@ -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);

3
test/core/end2end/fuzzers/server_fuzzer.c
Unescape View File

@ -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();

27
test/core/end2end/goaway_server_test.c
Unescape View File

@ -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);

36
test/core/end2end/invalid_call_argument_test.c
Unescape View File

@ -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++;

10
test/core/end2end/no_server_test.c
Unescape View File

@ -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();

20
test/core/fling/client.c
Unescape View File

@ -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;

8
test/core/fling/server.c
Unescape View File

@ -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();

5
test/core/security/credentials_test.c
Unescape View File

@ -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);
}

6
test/core/security/ssl_server_fuzzer.c
Unescape View File

@ -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);

6
test/core/slice/slice_test.c
Unescape View File

@ -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++) {

9
test/core/surface/lame_client_test.c
Unescape View File

@ -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();

4
test/core/transport/chttp2/bin_encoder_test.c
Unescape View File

@ -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;

10
test/core/transport/chttp2/hpack_encoder_test.c
Unescape View File

@ -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);

3
test/core/transport/chttp2/hpack_parser_fuzzer_test.c
Unescape View File

@ -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;

4
test/core/transport/chttp2/hpack_parser_test.c
Unescape View File

@ -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);
}

27
test/core/transport/chttp2/hpack_table_test.c
Unescape View File

@ -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);
}

212
test/core/transport/metadata_test.c
Unescape View File

@ -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;

27
test/core/transport/timeout_encoding_test.c
Unescape View File

@ -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) {

Write Preview
Loading…
Cancel
Save