aboutsummaryrefslogtreecommitdiffhomepage
path: root/src/core/lib/channel
diff options
context:
space:
mode:
Diffstat (limited to 'src/core/lib/channel')
-rw-r--r--src/core/lib/channel/channel_args.cc152
-rw-r--r--src/core/lib/channel/channel_args.h74
-rw-r--r--src/core/lib/channel/channel_stack.cc131
-rw-r--r--src/core/lib/channel/channel_stack.h144
-rw-r--r--src/core/lib/channel/channel_stack_builder.cc156
-rw-r--r--src/core/lib/channel/channel_stack_builder.h88
-rw-r--r--src/core/lib/channel/connected_channel.cc130
-rw-r--r--src/core/lib/channel/connected_channel.h8
-rw-r--r--src/core/lib/channel/context.h4
-rw-r--r--src/core/lib/channel/handshaker_factory.cc6
-rw-r--r--src/core/lib/channel/handshaker_factory.h20
11 files changed, 456 insertions, 457 deletions
diff --git a/src/core/lib/channel/channel_args.cc b/src/core/lib/channel/channel_args.cc
index 30248b3c60..23a604301e 100644
--- a/src/core/lib/channel/channel_args.cc
+++ b/src/core/lib/channel/channel_args.cc
@@ -31,7 +31,7 @@
#include "src/core/lib/channel/channel_args.h"
#include "src/core/lib/support/string.h"
-static grpc_arg copy_arg(const grpc_arg *src) {
+static grpc_arg copy_arg(const grpc_arg* src) {
grpc_arg dst;
dst.type = src->type;
dst.key = gpr_strdup(src->key);
@@ -51,21 +51,21 @@ static grpc_arg copy_arg(const grpc_arg *src) {
return dst;
}
-grpc_channel_args *grpc_channel_args_copy_and_add(const grpc_channel_args *src,
- const grpc_arg *to_add,
+grpc_channel_args* grpc_channel_args_copy_and_add(const grpc_channel_args* src,
+ const grpc_arg* to_add,
size_t num_to_add) {
return grpc_channel_args_copy_and_add_and_remove(src, NULL, 0, to_add,
num_to_add);
}
-grpc_channel_args *grpc_channel_args_copy_and_remove(
- const grpc_channel_args *src, const char **to_remove,
+grpc_channel_args* grpc_channel_args_copy_and_remove(
+ const grpc_channel_args* src, const char** to_remove,
size_t num_to_remove) {
return grpc_channel_args_copy_and_add_and_remove(src, to_remove,
num_to_remove, NULL, 0);
}
-static bool should_remove_arg(const grpc_arg *arg, const char **to_remove,
+static bool should_remove_arg(const grpc_arg* arg, const char** to_remove,
size_t num_to_remove) {
for (size_t i = 0; i < num_to_remove; ++i) {
if (strcmp(arg->key, to_remove[i]) == 0) return true;
@@ -73,9 +73,9 @@ static bool should_remove_arg(const grpc_arg *arg, const char **to_remove,
return false;
}
-grpc_channel_args *grpc_channel_args_copy_and_add_and_remove(
- const grpc_channel_args *src, const char **to_remove, size_t num_to_remove,
- const grpc_arg *to_add, size_t num_to_add) {
+grpc_channel_args* grpc_channel_args_copy_and_add_and_remove(
+ const grpc_channel_args* src, const char** to_remove, size_t num_to_remove,
+ const grpc_arg* to_add, size_t num_to_add) {
// Figure out how many args we'll be copying.
size_t num_args_to_copy = 0;
if (src != NULL) {
@@ -86,14 +86,14 @@ grpc_channel_args *grpc_channel_args_copy_and_add_and_remove(
}
}
// Create result.
- grpc_channel_args *dst =
- (grpc_channel_args *)gpr_malloc(sizeof(grpc_channel_args));
+ grpc_channel_args* dst =
+ (grpc_channel_args*)gpr_malloc(sizeof(grpc_channel_args));
dst->num_args = num_args_to_copy + num_to_add;
if (dst->num_args == 0) {
dst->args = NULL;
return dst;
}
- dst->args = (grpc_arg *)gpr_malloc(sizeof(grpc_arg) * dst->num_args);
+ dst->args = (grpc_arg*)gpr_malloc(sizeof(grpc_arg) * dst->num_args);
// Copy args from src that are not being removed.
size_t dst_idx = 0;
if (src != NULL) {
@@ -111,30 +111,30 @@ grpc_channel_args *grpc_channel_args_copy_and_add_and_remove(
return dst;
}
-grpc_channel_args *grpc_channel_args_copy(const grpc_channel_args *src) {
+grpc_channel_args* grpc_channel_args_copy(const grpc_channel_args* src) {
return grpc_channel_args_copy_and_add(src, NULL, 0);
}
-grpc_channel_args *grpc_channel_args_union(const grpc_channel_args *a,
- const grpc_channel_args *b) {
+grpc_channel_args* grpc_channel_args_union(const grpc_channel_args* a,
+ const grpc_channel_args* b) {
const size_t max_out = (a->num_args + b->num_args);
- grpc_arg *uniques = (grpc_arg *)gpr_malloc(sizeof(*uniques) * max_out);
+ grpc_arg* uniques = (grpc_arg*)gpr_malloc(sizeof(*uniques) * max_out);
for (size_t i = 0; i < a->num_args; ++i) uniques[i] = a->args[i];
size_t uniques_idx = a->num_args;
for (size_t i = 0; i < b->num_args; ++i) {
- const char *b_key = b->args[i].key;
+ const char* b_key = b->args[i].key;
if (grpc_channel_args_find(a, b_key) == NULL) { // not found
uniques[uniques_idx++] = b->args[i];
}
}
- grpc_channel_args *result =
+ grpc_channel_args* result =
grpc_channel_args_copy_and_add(NULL, uniques, uniques_idx);
gpr_free(uniques);
return result;
}
-static int cmp_arg(const grpc_arg *a, const grpc_arg *b) {
+static int cmp_arg(const grpc_arg* a, const grpc_arg* b) {
int c = GPR_ICMP(a->type, b->type);
if (c != 0) return c;
c = strcmp(a->key, b->key);
@@ -160,26 +160,26 @@ static int cmp_arg(const grpc_arg *a, const grpc_arg *b) {
/* stabilizing comparison function: since channel_args ordering matters for
* keys with the same name, we need to preserve that ordering */
-static int cmp_key_stable(const void *ap, const void *bp) {
- const grpc_arg *const *a = (const grpc_arg *const *)ap;
- const grpc_arg *const *b = (const grpc_arg *const *)bp;
+static int cmp_key_stable(const void* ap, const void* bp) {
+ const grpc_arg* const* a = (const grpc_arg* const*)ap;
+ const grpc_arg* const* b = (const grpc_arg* const*)bp;
int c = strcmp((*a)->key, (*b)->key);
if (c == 0) c = GPR_ICMP(*a, *b);
return c;
}
-grpc_channel_args *grpc_channel_args_normalize(const grpc_channel_args *a) {
- grpc_arg **args = (grpc_arg **)gpr_malloc(sizeof(grpc_arg *) * a->num_args);
+grpc_channel_args* grpc_channel_args_normalize(const grpc_channel_args* a) {
+ grpc_arg** args = (grpc_arg**)gpr_malloc(sizeof(grpc_arg*) * a->num_args);
for (size_t i = 0; i < a->num_args; i++) {
args[i] = &a->args[i];
}
if (a->num_args > 1)
- qsort(args, a->num_args, sizeof(grpc_arg *), cmp_key_stable);
+ qsort(args, a->num_args, sizeof(grpc_arg*), cmp_key_stable);
- grpc_channel_args *b =
- (grpc_channel_args *)gpr_malloc(sizeof(grpc_channel_args));
+ grpc_channel_args* b =
+ (grpc_channel_args*)gpr_malloc(sizeof(grpc_channel_args));
b->num_args = a->num_args;
- b->args = (grpc_arg *)gpr_malloc(sizeof(grpc_arg) * b->num_args);
+ b->args = (grpc_arg*)gpr_malloc(sizeof(grpc_arg) * b->num_args);
for (size_t i = 0; i < a->num_args; i++) {
b->args[i] = copy_arg(args[i]);
}
@@ -188,7 +188,7 @@ grpc_channel_args *grpc_channel_args_normalize(const grpc_channel_args *a) {
return b;
}
-void grpc_channel_args_destroy(grpc_exec_ctx *exec_ctx, grpc_channel_args *a) {
+void grpc_channel_args_destroy(grpc_exec_ctx* exec_ctx, grpc_channel_args* a) {
size_t i;
if (!a) return;
for (i = 0; i < a->num_args; i++) {
@@ -210,7 +210,7 @@ void grpc_channel_args_destroy(grpc_exec_ctx *exec_ctx, grpc_channel_args *a) {
}
grpc_compression_algorithm grpc_channel_args_get_compression_algorithm(
- const grpc_channel_args *a) {
+ const grpc_channel_args* a) {
size_t i;
if (a == NULL) return GRPC_COMPRESS_NONE;
for (i = 0; i < a->num_args; ++i) {
@@ -224,7 +224,7 @@ grpc_compression_algorithm grpc_channel_args_get_compression_algorithm(
}
grpc_stream_compression_algorithm
-grpc_channel_args_get_stream_compression_algorithm(const grpc_channel_args *a) {
+grpc_channel_args_get_stream_compression_algorithm(const grpc_channel_args* a) {
size_t i;
if (a == NULL) return GRPC_STREAM_COMPRESS_NONE;
for (i = 0; i < a->num_args; ++i) {
@@ -238,22 +238,22 @@ grpc_channel_args_get_stream_compression_algorithm(const grpc_channel_args *a) {
return GRPC_STREAM_COMPRESS_NONE;
}
-grpc_channel_args *grpc_channel_args_set_compression_algorithm(
- grpc_channel_args *a, grpc_compression_algorithm algorithm) {
+grpc_channel_args* grpc_channel_args_set_compression_algorithm(
+ grpc_channel_args* a, grpc_compression_algorithm algorithm) {
GPR_ASSERT(algorithm < GRPC_COMPRESS_ALGORITHMS_COUNT);
grpc_arg tmp;
tmp.type = GRPC_ARG_INTEGER;
- tmp.key = (char *)GRPC_COMPRESSION_CHANNEL_DEFAULT_ALGORITHM;
+ tmp.key = (char*)GRPC_COMPRESSION_CHANNEL_DEFAULT_ALGORITHM;
tmp.value.integer = algorithm;
return grpc_channel_args_copy_and_add(a, &tmp, 1);
}
-grpc_channel_args *grpc_channel_args_set_stream_compression_algorithm(
- grpc_channel_args *a, grpc_stream_compression_algorithm algorithm) {
+grpc_channel_args* grpc_channel_args_set_stream_compression_algorithm(
+ grpc_channel_args* a, grpc_stream_compression_algorithm algorithm) {
GPR_ASSERT(algorithm < GRPC_STREAM_COMPRESS_ALGORITHMS_COUNT);
grpc_arg tmp;
tmp.type = GRPC_ARG_INTEGER;
- tmp.key = (char *)GRPC_STREAM_COMPRESSION_CHANNEL_DEFAULT_ALGORITHM;
+ tmp.key = (char*)GRPC_STREAM_COMPRESSION_CHANNEL_DEFAULT_ALGORITHM;
tmp.value.integer = algorithm;
return grpc_channel_args_copy_and_add(a, &tmp, 1);
}
@@ -261,8 +261,8 @@ grpc_channel_args *grpc_channel_args_set_stream_compression_algorithm(
/** Returns 1 if the argument for compression algorithm's enabled states bitset
* was found in \a a, returning the arg's value in \a states. Otherwise, returns
* 0. */
-static int find_compression_algorithm_states_bitset(const grpc_channel_args *a,
- int **states_arg) {
+static int find_compression_algorithm_states_bitset(const grpc_channel_args* a,
+ int** states_arg) {
if (a != NULL) {
size_t i;
for (i = 0; i < a->num_args; ++i) {
@@ -282,7 +282,7 @@ static int find_compression_algorithm_states_bitset(const grpc_channel_args *a,
* was found in \a a, returning the arg's value in \a states. Otherwise, returns
* 0. */
static int find_stream_compression_algorithm_states_bitset(
- const grpc_channel_args *a, int **states_arg) {
+ const grpc_channel_args* a, int** states_arg) {
if (a != NULL) {
size_t i;
for (i = 0; i < a->num_args; ++i) {
@@ -298,17 +298,17 @@ static int find_stream_compression_algorithm_states_bitset(
return 0; /* GPR_FALSE */
}
-grpc_channel_args *grpc_channel_args_compression_algorithm_set_state(
- grpc_exec_ctx *exec_ctx, grpc_channel_args **a,
+grpc_channel_args* grpc_channel_args_compression_algorithm_set_state(
+ grpc_exec_ctx* exec_ctx, grpc_channel_args** a,
grpc_compression_algorithm algorithm, int state) {
- int *states_arg = NULL;
- grpc_channel_args *result = *a;
+ int* states_arg = NULL;
+ grpc_channel_args* result = *a;
const int states_arg_found =
find_compression_algorithm_states_bitset(*a, &states_arg);
if (grpc_channel_args_get_compression_algorithm(*a) == algorithm &&
state == 0) {
- const char *algo_name = NULL;
+ const char* algo_name = NULL;
GPR_ASSERT(grpc_compression_algorithm_name(algorithm, &algo_name) != 0);
gpr_log(GPR_ERROR,
"Tried to disable default compression algorithm '%s'. The "
@@ -316,21 +316,21 @@ grpc_channel_args *grpc_channel_args_compression_algorithm_set_state(
algo_name);
} else if (states_arg_found) {
if (state != 0) {
- GPR_BITSET((unsigned *)states_arg, algorithm);
+ GPR_BITSET((unsigned*)states_arg, algorithm);
} else if (algorithm != GRPC_COMPRESS_NONE) {
- GPR_BITCLEAR((unsigned *)states_arg, algorithm);
+ GPR_BITCLEAR((unsigned*)states_arg, algorithm);
}
} else {
/* create a new arg */
grpc_arg tmp;
tmp.type = GRPC_ARG_INTEGER;
- tmp.key = (char *)GRPC_COMPRESSION_CHANNEL_ENABLED_ALGORITHMS_BITSET;
+ tmp.key = (char*)GRPC_COMPRESSION_CHANNEL_ENABLED_ALGORITHMS_BITSET;
/* all enabled by default */
tmp.value.integer = (1u << GRPC_COMPRESS_ALGORITHMS_COUNT) - 1;
if (state != 0) {
- GPR_BITSET((unsigned *)&tmp.value.integer, algorithm);
+ GPR_BITSET((unsigned*)&tmp.value.integer, algorithm);
} else if (algorithm != GRPC_COMPRESS_NONE) {
- GPR_BITCLEAR((unsigned *)&tmp.value.integer, algorithm);
+ GPR_BITCLEAR((unsigned*)&tmp.value.integer, algorithm);
}
result = grpc_channel_args_copy_and_add(*a, &tmp, 1);
grpc_channel_args_destroy(exec_ctx, *a);
@@ -339,17 +339,17 @@ grpc_channel_args *grpc_channel_args_compression_algorithm_set_state(
return result;
}
-grpc_channel_args *grpc_channel_args_stream_compression_algorithm_set_state(
- grpc_exec_ctx *exec_ctx, grpc_channel_args **a,
+grpc_channel_args* grpc_channel_args_stream_compression_algorithm_set_state(
+ grpc_exec_ctx* exec_ctx, grpc_channel_args** a,
grpc_stream_compression_algorithm algorithm, int state) {
- int *states_arg = NULL;
- grpc_channel_args *result = *a;
+ int* states_arg = NULL;
+ grpc_channel_args* result = *a;
const int states_arg_found =
find_stream_compression_algorithm_states_bitset(*a, &states_arg);
if (grpc_channel_args_get_stream_compression_algorithm(*a) == algorithm &&
state == 0) {
- const char *algo_name = NULL;
+ const char* algo_name = NULL;
GPR_ASSERT(grpc_stream_compression_algorithm_name(algorithm, &algo_name) !=
0);
gpr_log(GPR_ERROR,
@@ -358,21 +358,21 @@ grpc_channel_args *grpc_channel_args_stream_compression_algorithm_set_state(
algo_name);
} else if (states_arg_found) {
if (state != 0) {
- GPR_BITSET((unsigned *)states_arg, algorithm);
+ GPR_BITSET((unsigned*)states_arg, algorithm);
} else if (algorithm != GRPC_STREAM_COMPRESS_NONE) {
- GPR_BITCLEAR((unsigned *)states_arg, algorithm);
+ GPR_BITCLEAR((unsigned*)states_arg, algorithm);
}
} else {
/* create a new arg */
grpc_arg tmp;
tmp.type = GRPC_ARG_INTEGER;
- tmp.key = (char *)GRPC_STREAM_COMPRESSION_CHANNEL_ENABLED_ALGORITHMS_BITSET;
+ tmp.key = (char*)GRPC_STREAM_COMPRESSION_CHANNEL_ENABLED_ALGORITHMS_BITSET;
/* all enabled by default */
tmp.value.integer = (1u << GRPC_STREAM_COMPRESS_ALGORITHMS_COUNT) - 1;
if (state != 0) {
- GPR_BITSET((unsigned *)&tmp.value.integer, algorithm);
+ GPR_BITSET((unsigned*)&tmp.value.integer, algorithm);
} else if (algorithm != GRPC_STREAM_COMPRESS_NONE) {
- GPR_BITCLEAR((unsigned *)&tmp.value.integer, algorithm);
+ GPR_BITCLEAR((unsigned*)&tmp.value.integer, algorithm);
}
result = grpc_channel_args_copy_and_add(*a, &tmp, 1);
grpc_channel_args_destroy(exec_ctx, *a);
@@ -382,8 +382,8 @@ grpc_channel_args *grpc_channel_args_stream_compression_algorithm_set_state(
}
uint32_t grpc_channel_args_compression_algorithm_get_states(
- const grpc_channel_args *a) {
- int *states_arg;
+ const grpc_channel_args* a) {
+ int* states_arg;
if (find_compression_algorithm_states_bitset(a, &states_arg)) {
return (uint32_t)*states_arg;
} else {
@@ -392,8 +392,8 @@ uint32_t grpc_channel_args_compression_algorithm_get_states(
}
uint32_t grpc_channel_args_stream_compression_algorithm_get_states(
- const grpc_channel_args *a) {
- int *states_arg;
+ const grpc_channel_args* a) {
+ int* states_arg;
if (find_stream_compression_algorithm_states_bitset(a, &states_arg)) {
return (uint32_t)*states_arg;
} else {
@@ -402,14 +402,14 @@ uint32_t grpc_channel_args_stream_compression_algorithm_get_states(
}
}
-grpc_channel_args *grpc_channel_args_set_socket_mutator(
- grpc_channel_args *a, grpc_socket_mutator *mutator) {
+grpc_channel_args* grpc_channel_args_set_socket_mutator(
+ grpc_channel_args* a, grpc_socket_mutator* mutator) {
grpc_arg tmp = grpc_socket_mutator_to_arg(mutator);
return grpc_channel_args_copy_and_add(a, &tmp, 1);
}
-int grpc_channel_args_compare(const grpc_channel_args *a,
- const grpc_channel_args *b) {
+int grpc_channel_args_compare(const grpc_channel_args* a,
+ const grpc_channel_args* b) {
int c = GPR_ICMP(a->num_args, b->num_args);
if (c != 0) return c;
for (size_t i = 0; i < a->num_args; i++) {
@@ -419,8 +419,8 @@ int grpc_channel_args_compare(const grpc_channel_args *a,
return 0;
}
-const grpc_arg *grpc_channel_args_find(const grpc_channel_args *args,
- const char *name) {
+const grpc_arg* grpc_channel_args_find(const grpc_channel_args* args,
+ const char* name) {
if (args != NULL) {
for (size_t i = 0; i < args->num_args; ++i) {
if (strcmp(args->args[i].key, name) == 0) {
@@ -431,7 +431,7 @@ const grpc_arg *grpc_channel_args_find(const grpc_channel_args *args,
return NULL;
}
-int grpc_channel_arg_get_integer(const grpc_arg *arg,
+int grpc_channel_arg_get_integer(const grpc_arg* arg,
const grpc_integer_options options) {
if (arg == NULL) return options.default_value;
if (arg->type != GRPC_ARG_INTEGER) {
@@ -451,7 +451,7 @@ int grpc_channel_arg_get_integer(const grpc_arg *arg,
return arg->value.integer;
}
-bool grpc_channel_arg_get_bool(const grpc_arg *arg, bool default_value) {
+bool grpc_channel_arg_get_bool(const grpc_arg* arg, bool default_value) {
if (arg == NULL) return default_value;
if (arg->type != GRPC_ARG_INTEGER) {
gpr_log(GPR_ERROR, "%s ignored: it must be an integer", arg->key);
@@ -469,12 +469,12 @@ bool grpc_channel_arg_get_bool(const grpc_arg *arg, bool default_value) {
}
}
-bool grpc_channel_args_want_minimal_stack(const grpc_channel_args *args) {
+bool grpc_channel_args_want_minimal_stack(const grpc_channel_args* args) {
return grpc_channel_arg_get_bool(
grpc_channel_args_find(args, GRPC_ARG_MINIMAL_STACK), false);
}
-grpc_arg grpc_channel_arg_string_create(char *name, char *value) {
+grpc_arg grpc_channel_arg_string_create(char* name, char* value) {
grpc_arg arg;
arg.type = GRPC_ARG_STRING;
arg.key = name;
@@ -482,7 +482,7 @@ grpc_arg grpc_channel_arg_string_create(char *name, char *value) {
return arg;
}
-grpc_arg grpc_channel_arg_integer_create(char *name, int value) {
+grpc_arg grpc_channel_arg_integer_create(char* name, int value) {
grpc_arg arg;
arg.type = GRPC_ARG_INTEGER;
arg.key = name;
@@ -491,7 +491,7 @@ grpc_arg grpc_channel_arg_integer_create(char *name, int value) {
}
grpc_arg grpc_channel_arg_pointer_create(
- char *name, void *value, const grpc_arg_pointer_vtable *vtable) {
+ char* name, void* value, const grpc_arg_pointer_vtable* vtable) {
grpc_arg arg;
arg.type = GRPC_ARG_POINTER;
arg.key = name;
diff --git a/src/core/lib/channel/channel_args.h b/src/core/lib/channel/channel_args.h
index 1896d35cf4..d36761da57 100644
--- a/src/core/lib/channel/channel_args.h
+++ b/src/core/lib/channel/channel_args.h
@@ -30,56 +30,56 @@ extern "C" {
// Channel args are intentionally immutable, to avoid the need for locking.
/** Copy the arguments in \a src into a new instance */
-grpc_channel_args *grpc_channel_args_copy(const grpc_channel_args *src);
+grpc_channel_args* grpc_channel_args_copy(const grpc_channel_args* src);
/** Copy the arguments in \a src into a new instance, stably sorting keys */
-grpc_channel_args *grpc_channel_args_normalize(const grpc_channel_args *src);
+grpc_channel_args* grpc_channel_args_normalize(const grpc_channel_args* src);
/** Copy the arguments in \a src and append \a to_add. If \a to_add is NULL, it
* is equivalent to calling \a grpc_channel_args_copy. */
-grpc_channel_args *grpc_channel_args_copy_and_add(const grpc_channel_args *src,
- const grpc_arg *to_add,
+grpc_channel_args* grpc_channel_args_copy_and_add(const grpc_channel_args* src,
+ const grpc_arg* to_add,
size_t num_to_add);
/** Copies the arguments in \a src except for those whose keys are in
\a to_remove. */
-grpc_channel_args *grpc_channel_args_copy_and_remove(
- const grpc_channel_args *src, const char **to_remove, size_t num_to_remove);
+grpc_channel_args* grpc_channel_args_copy_and_remove(
+ const grpc_channel_args* src, const char** to_remove, size_t num_to_remove);
/** Copies the arguments from \a src except for those whose keys are in
\a to_remove and appends the arguments in \a to_add. */
-grpc_channel_args *grpc_channel_args_copy_and_add_and_remove(
- const grpc_channel_args *src, const char **to_remove, size_t num_to_remove,
- const grpc_arg *to_add, size_t num_to_add);
+grpc_channel_args* grpc_channel_args_copy_and_add_and_remove(
+ const grpc_channel_args* src, const char** to_remove, size_t num_to_remove,
+ const grpc_arg* to_add, size_t num_to_add);
/** Perform the union of \a a and \a b, prioritizing \a a entries */
-grpc_channel_args *grpc_channel_args_union(const grpc_channel_args *a,
- const grpc_channel_args *b);
+grpc_channel_args* grpc_channel_args_union(const grpc_channel_args* a,
+ const grpc_channel_args* b);
/** Destroy arguments created by \a grpc_channel_args_copy */
-void grpc_channel_args_destroy(grpc_exec_ctx *exec_ctx, grpc_channel_args *a);
+void grpc_channel_args_destroy(grpc_exec_ctx* exec_ctx, grpc_channel_args* a);
/** Returns the compression algorithm set in \a a. */
grpc_compression_algorithm grpc_channel_args_get_compression_algorithm(
- const grpc_channel_args *a);
+ const grpc_channel_args* a);
/** Returns the stream compression algorithm set in \a a. */
grpc_stream_compression_algorithm
-grpc_channel_args_get_stream_compression_algorithm(const grpc_channel_args *a);
+grpc_channel_args_get_stream_compression_algorithm(const grpc_channel_args* a);
/** Returns a channel arg instance with compression enabled. If \a a is
* non-NULL, its args are copied. N.B. GRPC_COMPRESS_NONE disables compression
* for the channel. */
-grpc_channel_args *grpc_channel_args_set_compression_algorithm(
- grpc_channel_args *a, grpc_compression_algorithm algorithm);
+grpc_channel_args* grpc_channel_args_set_compression_algorithm(
+ grpc_channel_args* a, grpc_compression_algorithm algorithm);
/** Returns a channel arg instance with stream compression enabled. If \a a is
* non-NULL, its args are copied. N.B. GRPC_STREAM_COMPRESS_NONE disables
* stream compression for the channel. If a value other than
* GRPC_STREAM_COMPRESS_NONE is set, it takes precedence over message-wise
* compression algorithms. */
-grpc_channel_args *grpc_channel_args_set_stream_compression_algorithm(
- grpc_channel_args *a, grpc_stream_compression_algorithm algorithm);
+grpc_channel_args* grpc_channel_args_set_stream_compression_algorithm(
+ grpc_channel_args* a, grpc_stream_compression_algorithm algorithm);
/** Sets the support for the given compression algorithm. By default, all
* compression algorithms are enabled. It's an error to disable an algorithm set
@@ -88,8 +88,8 @@ grpc_channel_args *grpc_channel_args_set_stream_compression_algorithm(
* Returns an instance with the updated algorithm states. The \a a pointer is
* modified to point to the returned instance (which may be different from the
* input value of \a a). */
-grpc_channel_args *grpc_channel_args_compression_algorithm_set_state(
- grpc_exec_ctx *exec_ctx, grpc_channel_args **a,
+grpc_channel_args* grpc_channel_args_compression_algorithm_set_state(
+ grpc_exec_ctx* exec_ctx, grpc_channel_args** a,
grpc_compression_algorithm algorithm, int enabled);
/** Sets the support for the given stream compression algorithm. By default, all
@@ -99,8 +99,8 @@ grpc_channel_args *grpc_channel_args_compression_algorithm_set_state(
* Returns an instance with the updated algorithm states. The \a a pointer is
* modified to point to the returned instance (which may be different from the
* input value of \a a). */
-grpc_channel_args *grpc_channel_args_stream_compression_algorithm_set_state(
- grpc_exec_ctx *exec_ctx, grpc_channel_args **a,
+grpc_channel_args* grpc_channel_args_stream_compression_algorithm_set_state(
+ grpc_exec_ctx* exec_ctx, grpc_channel_args** a,
grpc_stream_compression_algorithm algorithm, int enabled);
/** Returns the bitset representing the support state (true for enabled, false
@@ -109,7 +109,7 @@ grpc_channel_args *grpc_channel_args_stream_compression_algorithm_set_state(
* The i-th bit of the returned bitset corresponds to the i-th entry in the
* grpc_compression_algorithm enum. */
uint32_t grpc_channel_args_compression_algorithm_get_states(
- const grpc_channel_args *a);
+ const grpc_channel_args* a);
/** Returns the bitset representing the support state (true for enabled, false
* for disabled) for stream compression algorithms.
@@ -117,23 +117,23 @@ uint32_t grpc_channel_args_compression_algorithm_get_states(
* The i-th bit of the returned bitset corresponds to the i-th entry in the
* grpc_stream_compression_algorithm enum. */
uint32_t grpc_channel_args_stream_compression_algorithm_get_states(
- const grpc_channel_args *a);
+ const grpc_channel_args* a);
-int grpc_channel_args_compare(const grpc_channel_args *a,
- const grpc_channel_args *b);
+int grpc_channel_args_compare(const grpc_channel_args* a,
+ const grpc_channel_args* b);
/** Returns a channel arg instance with socket mutator added. The socket mutator
* will perform its mutate_fd method on all file descriptors used by the
* channel.
* If \a a is non-MULL, its args are copied. */
-grpc_channel_args *grpc_channel_args_set_socket_mutator(
- grpc_channel_args *a, grpc_socket_mutator *mutator);
+grpc_channel_args* grpc_channel_args_set_socket_mutator(
+ grpc_channel_args* a, grpc_socket_mutator* mutator);
/** Returns the value of argument \a name from \a args, or NULL if not found. */
-const grpc_arg *grpc_channel_args_find(const grpc_channel_args *args,
- const char *name);
+const grpc_arg* grpc_channel_args_find(const grpc_channel_args* args,
+ const char* name);
-bool grpc_channel_args_want_minimal_stack(const grpc_channel_args *args);
+bool grpc_channel_args_want_minimal_stack(const grpc_channel_args* args);
typedef struct grpc_integer_options {
int default_value; // Return this if value is outside of expected bounds.
@@ -142,16 +142,16 @@ typedef struct grpc_integer_options {
} grpc_integer_options;
/** Returns the value of \a arg, subject to the contraints in \a options. */
-int grpc_channel_arg_get_integer(const grpc_arg *arg,
+int grpc_channel_arg_get_integer(const grpc_arg* arg,
const grpc_integer_options options);
-bool grpc_channel_arg_get_bool(const grpc_arg *arg, bool default_value);
+bool grpc_channel_arg_get_bool(const grpc_arg* arg, bool default_value);
// Helpers for creating channel args.
-grpc_arg grpc_channel_arg_string_create(char *name, char *value);
-grpc_arg grpc_channel_arg_integer_create(char *name, int value);
-grpc_arg grpc_channel_arg_pointer_create(char *name, void *value,
- const grpc_arg_pointer_vtable *vtable);
+grpc_arg grpc_channel_arg_string_create(char* name, char* value);
+grpc_arg grpc_channel_arg_integer_create(char* name, int value);
+grpc_arg grpc_channel_arg_pointer_create(char* name, void* value,
+ const grpc_arg_pointer_vtable* vtable);
#ifdef __cplusplus
}
diff --git a/src/core/lib/channel/channel_stack.cc b/src/core/lib/channel/channel_stack.cc
index 775c8bc667..3ab2e33d6d 100644
--- a/src/core/lib/channel/channel_stack.cc
+++ b/src/core/lib/channel/channel_stack.cc
@@ -45,7 +45,7 @@ grpc_tracer_flag grpc_trace_channel = GRPC_TRACER_INITIALIZER(false, "channel");
#define ROUND_UP_TO_ALIGNMENT_SIZE(x) \
(((x) + GPR_MAX_ALIGNMENT - 1u) & ~(GPR_MAX_ALIGNMENT - 1u))
-size_t grpc_channel_stack_size(const grpc_channel_filter **filters,
+size_t grpc_channel_stack_size(const grpc_channel_filter** filters,
size_t filter_count) {
/* always need the header, and size for the channel elements */
size_t size =
@@ -64,52 +64,51 @@ size_t grpc_channel_stack_size(const grpc_channel_filter **filters,
return size;
}
-#define CHANNEL_ELEMS_FROM_STACK(stk) \
- ((grpc_channel_element *)((char *)(stk) + ROUND_UP_TO_ALIGNMENT_SIZE( \
- sizeof(grpc_channel_stack))))
+#define CHANNEL_ELEMS_FROM_STACK(stk) \
+ ((grpc_channel_element*)((char*)(stk) + ROUND_UP_TO_ALIGNMENT_SIZE( \
+ sizeof(grpc_channel_stack))))
-#define CALL_ELEMS_FROM_STACK(stk) \
- ((grpc_call_element *)((char *)(stk) + \
- ROUND_UP_TO_ALIGNMENT_SIZE(sizeof(grpc_call_stack))))
+#define CALL_ELEMS_FROM_STACK(stk) \
+ ((grpc_call_element*)((char*)(stk) + \
+ ROUND_UP_TO_ALIGNMENT_SIZE(sizeof(grpc_call_stack))))
-grpc_channel_element *grpc_channel_stack_element(
- grpc_channel_stack *channel_stack, size_t index) {
+grpc_channel_element* grpc_channel_stack_element(
+ grpc_channel_stack* channel_stack, size_t index) {
return CHANNEL_ELEMS_FROM_STACK(channel_stack) + index;
}
-grpc_channel_element *grpc_channel_stack_last_element(
- grpc_channel_stack *channel_stack) {
+grpc_channel_element* grpc_channel_stack_last_element(
+ grpc_channel_stack* channel_stack) {
return grpc_channel_stack_element(channel_stack, channel_stack->count - 1);
}
-grpc_call_element *grpc_call_stack_element(grpc_call_stack *call_stack,
+grpc_call_element* grpc_call_stack_element(grpc_call_stack* call_stack,
size_t index) {
return CALL_ELEMS_FROM_STACK(call_stack) + index;
}
-grpc_error *grpc_channel_stack_init(
- grpc_exec_ctx *exec_ctx, int initial_refs, grpc_iomgr_cb_func destroy,
- void *destroy_arg, const grpc_channel_filter **filters, size_t filter_count,
- const grpc_channel_args *channel_args, grpc_transport *optional_transport,
- const char *name, grpc_channel_stack *stack) {
+grpc_error* grpc_channel_stack_init(
+ grpc_exec_ctx* exec_ctx, int initial_refs, grpc_iomgr_cb_func destroy,
+ void* destroy_arg, const grpc_channel_filter** filters, size_t filter_count,
+ const grpc_channel_args* channel_args, grpc_transport* optional_transport,
+ const char* name, grpc_channel_stack* stack) {
size_t call_size =
ROUND_UP_TO_ALIGNMENT_SIZE(sizeof(grpc_call_stack)) +
ROUND_UP_TO_ALIGNMENT_SIZE(filter_count * sizeof(grpc_call_element));
- grpc_channel_element *elems;
+ grpc_channel_element* elems;
grpc_channel_element_args args;
- char *user_data;
+ char* user_data;
size_t i;
stack->count = filter_count;
GRPC_STREAM_REF_INIT(&stack->refcount, initial_refs, destroy, destroy_arg,
name);
elems = CHANNEL_ELEMS_FROM_STACK(stack);
- user_data =
- ((char *)elems) +
- ROUND_UP_TO_ALIGNMENT_SIZE(filter_count * sizeof(grpc_channel_element));
+ user_data = ((char*)elems) + ROUND_UP_TO_ALIGNMENT_SIZE(
+ filter_count * sizeof(grpc_channel_element));
/* init per-filter data */
- grpc_error *first_error = GRPC_ERROR_NONE;
+ grpc_error* first_error = GRPC_ERROR_NONE;
for (i = 0; i < filter_count; i++) {
args.channel_stack = stack;
args.channel_args = channel_args;
@@ -118,7 +117,7 @@ grpc_error *grpc_channel_stack_init(
args.is_last = i == (filter_count - 1);
elems[i].filter = filters[i];
elems[i].channel_data = user_data;
- grpc_error *error =
+ grpc_error* error =
elems[i].filter->init_channel_elem(exec_ctx, &elems[i], &args);
if (error != GRPC_ERROR_NONE) {
if (first_error == GRPC_ERROR_NONE) {
@@ -131,17 +130,17 @@ grpc_error *grpc_channel_stack_init(
call_size += ROUND_UP_TO_ALIGNMENT_SIZE(filters[i]->sizeof_call_data);
}
- GPR_ASSERT(user_data > (char *)stack);
- GPR_ASSERT((uintptr_t)(user_data - (char *)stack) ==
+ GPR_ASSERT(user_data > (char*)stack);
+ GPR_ASSERT((uintptr_t)(user_data - (char*)stack) ==
grpc_channel_stack_size(filters, filter_count));
stack->call_stack_size = call_size;
return first_error;
}
-void grpc_channel_stack_destroy(grpc_exec_ctx *exec_ctx,
- grpc_channel_stack *stack) {
- grpc_channel_element *channel_elems = CHANNEL_ELEMS_FROM_STACK(stack);
+void grpc_channel_stack_destroy(grpc_exec_ctx* exec_ctx,
+ grpc_channel_stack* stack) {
+ grpc_channel_element* channel_elems = CHANNEL_ELEMS_FROM_STACK(stack);
size_t count = stack->count;
size_t i;
@@ -151,31 +150,31 @@ void grpc_channel_stack_destroy(grpc_exec_ctx *exec_ctx,
}
}
-grpc_error *grpc_call_stack_init(grpc_exec_ctx *exec_ctx,
- grpc_channel_stack *channel_stack,
+grpc_error* grpc_call_stack_init(grpc_exec_ctx* exec_ctx,
+ grpc_channel_stack* channel_stack,
int initial_refs, grpc_iomgr_cb_func destroy,
- void *destroy_arg,
- const grpc_call_element_args *elem_args) {
- grpc_channel_element *channel_elems = CHANNEL_ELEMS_FROM_STACK(channel_stack);
+ void* destroy_arg,
+ const grpc_call_element_args* elem_args) {
+ grpc_channel_element* channel_elems = CHANNEL_ELEMS_FROM_STACK(channel_stack);
size_t count = channel_stack->count;
- grpc_call_element *call_elems;
- char *user_data;
+ grpc_call_element* call_elems;
+ char* user_data;
size_t i;
elem_args->call_stack->count = count;
GRPC_STREAM_REF_INIT(&elem_args->call_stack->refcount, initial_refs, destroy,
destroy_arg, "CALL_STACK");
call_elems = CALL_ELEMS_FROM_STACK(elem_args->call_stack);
- user_data = ((char *)call_elems) +
+ user_data = ((char*)call_elems) +
ROUND_UP_TO_ALIGNMENT_SIZE(count * sizeof(grpc_call_element));
/* init per-filter data */
- grpc_error *first_error = GRPC_ERROR_NONE;
+ grpc_error* first_error = GRPC_ERROR_NONE;
for (i = 0; i < count; i++) {
call_elems[i].filter = channel_elems[i].filter;
call_elems[i].channel_data = channel_elems[i].channel_data;
call_elems[i].call_data = user_data;
- grpc_error *error = call_elems[i].filter->init_call_elem(
+ grpc_error* error = call_elems[i].filter->init_call_elem(
exec_ctx, &call_elems[i], elem_args);
if (error != GRPC_ERROR_NONE) {
if (first_error == GRPC_ERROR_NONE) {
@@ -190,16 +189,16 @@ grpc_error *grpc_call_stack_init(grpc_exec_ctx *exec_ctx,
return first_error;
}
-void grpc_call_stack_set_pollset_or_pollset_set(grpc_exec_ctx *exec_ctx,
- grpc_call_stack *call_stack,
- grpc_polling_entity *pollent) {
+void grpc_call_stack_set_pollset_or_pollset_set(grpc_exec_ctx* exec_ctx,
+ grpc_call_stack* call_stack,
+ grpc_polling_entity* pollent) {
size_t count = call_stack->count;
- grpc_call_element *call_elems;
- char *user_data;
+ grpc_call_element* call_elems;
+ char* user_data;
size_t i;
call_elems = CALL_ELEMS_FROM_STACK(call_stack);
- user_data = ((char *)call_elems) +
+ user_data = ((char*)call_elems) +
ROUND_UP_TO_ALIGNMENT_SIZE(count * sizeof(grpc_call_element));
/* init per-filter data */
@@ -212,13 +211,13 @@ void grpc_call_stack_set_pollset_or_pollset_set(grpc_exec_ctx *exec_ctx,
}
void grpc_call_stack_ignore_set_pollset_or_pollset_set(
- grpc_exec_ctx *exec_ctx, grpc_call_element *elem,
- grpc_polling_entity *pollent) {}
+ grpc_exec_ctx* exec_ctx, grpc_call_element* elem,
+ grpc_polling_entity* pollent) {}
-void grpc_call_stack_destroy(grpc_exec_ctx *exec_ctx, grpc_call_stack *stack,
- const grpc_call_final_info *final_info,
- grpc_closure *then_schedule_closure) {
- grpc_call_element *elems = CALL_ELEMS_FROM_STACK(stack);
+void grpc_call_stack_destroy(grpc_exec_ctx* exec_ctx, grpc_call_stack* stack,
+ const grpc_call_final_info* final_info,
+ grpc_closure* then_schedule_closure) {
+ grpc_call_element* elems = CALL_ELEMS_FROM_STACK(stack);
size_t count = stack->count;
size_t i;
@@ -230,33 +229,33 @@ void grpc_call_stack_destroy(grpc_exec_ctx *exec_ctx, grpc_call_stack *stack,
}
}
-void grpc_call_next_op(grpc_exec_ctx *exec_ctx, grpc_call_element *elem,
- grpc_transport_stream_op_batch *op) {
- grpc_call_element *next_elem = elem + 1;
+void grpc_call_next_op(grpc_exec_ctx* exec_ctx, grpc_call_element* elem,
+ grpc_transport_stream_op_batch* op) {
+ grpc_call_element* next_elem = elem + 1;
GRPC_CALL_LOG_OP(GPR_INFO, next_elem, op);
next_elem->filter->start_transport_stream_op_batch(exec_ctx, next_elem, op);
}
-void grpc_channel_next_get_info(grpc_exec_ctx *exec_ctx,
- grpc_channel_element *elem,
- const grpc_channel_info *channel_info) {
- grpc_channel_element *next_elem = elem + 1;
+void grpc_channel_next_get_info(grpc_exec_ctx* exec_ctx,
+ grpc_channel_element* elem,
+ const grpc_channel_info* channel_info) {
+ grpc_channel_element* next_elem = elem + 1;
next_elem->filter->get_channel_info(exec_ctx, next_elem, channel_info);
}
-void grpc_channel_next_op(grpc_exec_ctx *exec_ctx, grpc_channel_element *elem,
- grpc_transport_op *op) {
- grpc_channel_element *next_elem = elem + 1;
+void grpc_channel_next_op(grpc_exec_ctx* exec_ctx, grpc_channel_element* elem,
+ grpc_transport_op* op) {
+ grpc_channel_element* next_elem = elem + 1;
next_elem->filter->start_transport_op(exec_ctx, next_elem, op);
}
-grpc_channel_stack *grpc_channel_stack_from_top_element(
- grpc_channel_element *elem) {
- return (grpc_channel_stack *)((char *)(elem)-ROUND_UP_TO_ALIGNMENT_SIZE(
+grpc_channel_stack* grpc_channel_stack_from_top_element(
+ grpc_channel_element* elem) {
+ return (grpc_channel_stack*)((char*)(elem)-ROUND_UP_TO_ALIGNMENT_SIZE(
sizeof(grpc_channel_stack)));
}
-grpc_call_stack *grpc_call_stack_from_top_element(grpc_call_element *elem) {
- return (grpc_call_stack *)((char *)(elem)-ROUND_UP_TO_ALIGNMENT_SIZE(
+grpc_call_stack* grpc_call_stack_from_top_element(grpc_call_element* elem) {
+ return (grpc_call_stack*)((char*)(elem)-ROUND_UP_TO_ALIGNMENT_SIZE(
sizeof(grpc_call_stack)));
}
diff --git a/src/core/lib/channel/channel_stack.h b/src/core/lib/channel/channel_stack.h
index 5c00c09889..aa993112a0 100644
--- a/src/core/lib/channel/channel_stack.h
+++ b/src/core/lib/channel/channel_stack.h
@@ -56,23 +56,23 @@ typedef struct grpc_channel_stack grpc_channel_stack;
typedef struct grpc_call_stack grpc_call_stack;
typedef struct {
- grpc_channel_stack *channel_stack;
- const grpc_channel_args *channel_args;
+ grpc_channel_stack* channel_stack;
+ const grpc_channel_args* channel_args;
/** Transport, iff it is known */
- grpc_transport *optional_transport;
+ grpc_transport* optional_transport;
int is_first;
int is_last;
} grpc_channel_element_args;
typedef struct {
- grpc_call_stack *call_stack;
- const void *server_transport_data;
- grpc_call_context_element *context;
+ grpc_call_stack* call_stack;
+ const void* server_transport_data;
+ grpc_call_context_element* context;
grpc_slice path;
gpr_timespec start_time;
grpc_millis deadline;
- gpr_arena *arena;
- grpc_call_combiner *call_combiner;
+ gpr_arena* arena;
+ grpc_call_combiner* call_combiner;
} grpc_call_element_args;
typedef struct {
@@ -99,14 +99,14 @@ typedef struct {
typedef struct {
/* Called to eg. send/receive data on a call.
See grpc_call_next_op on how to call the next element in the stack */
- void (*start_transport_stream_op_batch)(grpc_exec_ctx *exec_ctx,
- grpc_call_element *elem,
- grpc_transport_stream_op_batch *op);
+ void (*start_transport_stream_op_batch)(grpc_exec_ctx* exec_ctx,
+ grpc_call_element* elem,
+ grpc_transport_stream_op_batch* op);
/* Called to handle channel level operations - e.g. new calls, or transport
closure.
See grpc_channel_next_op on how to call the next element in the stack */
- void (*start_transport_op)(grpc_exec_ctx *exec_ctx,
- grpc_channel_element *elem, grpc_transport_op *op);
+ void (*start_transport_op)(grpc_exec_ctx* exec_ctx,
+ grpc_channel_element* elem, grpc_transport_op* op);
/* sizeof(per call data) */
size_t sizeof_call_data;
@@ -119,21 +119,21 @@ typedef struct {
transport and is on the server. Most filters want to ignore this
argument.
Implementations may assume that elem->call_data is all zeros. */
- grpc_error *(*init_call_elem)(grpc_exec_ctx *exec_ctx,
- grpc_call_element *elem,
- const grpc_call_element_args *args);
- void (*set_pollset_or_pollset_set)(grpc_exec_ctx *exec_ctx,
- grpc_call_element *elem,
- grpc_polling_entity *pollent);
+ grpc_error* (*init_call_elem)(grpc_exec_ctx* exec_ctx,
+ grpc_call_element* elem,
+ const grpc_call_element_args* args);
+ void (*set_pollset_or_pollset_set)(grpc_exec_ctx* exec_ctx,
+ grpc_call_element* elem,
+ grpc_polling_entity* pollent);
/* Destroy per call data.
The filter does not need to do any chaining.
The bottom filter of a stack will be passed a non-NULL pointer to
\a then_schedule_closure that should be passed to GRPC_CLOSURE_SCHED when
destruction is complete. \a final_info contains data about the completed
call, mainly for reporting purposes. */
- void (*destroy_call_elem)(grpc_exec_ctx *exec_ctx, grpc_call_element *elem,
- const grpc_call_final_info *final_info,
- grpc_closure *then_schedule_closure);
+ void (*destroy_call_elem)(grpc_exec_ctx* exec_ctx, grpc_call_element* elem,
+ const grpc_call_final_info* final_info,
+ grpc_closure* then_schedule_closure);
/* sizeof(per channel data) */
size_t sizeof_channel_data;
@@ -144,36 +144,36 @@ typedef struct {
useful for asserting correct configuration by upper layer code.
The filter does not need to do any chaining.
Implementations may assume that elem->call_data is all zeros. */
- grpc_error *(*init_channel_elem)(grpc_exec_ctx *exec_ctx,
- grpc_channel_element *elem,
- grpc_channel_element_args *args);
+ grpc_error* (*init_channel_elem)(grpc_exec_ctx* exec_ctx,
+ grpc_channel_element* elem,
+ grpc_channel_element_args* args);
/* Destroy per channel data.
The filter does not need to do any chaining */
- void (*destroy_channel_elem)(grpc_exec_ctx *exec_ctx,
- grpc_channel_element *elem);
+ void (*destroy_channel_elem)(grpc_exec_ctx* exec_ctx,
+ grpc_channel_element* elem);
/* Implement grpc_channel_get_info() */
- void (*get_channel_info)(grpc_exec_ctx *exec_ctx, grpc_channel_element *elem,
- const grpc_channel_info *channel_info);
+ void (*get_channel_info)(grpc_exec_ctx* exec_ctx, grpc_channel_element* elem,
+ const grpc_channel_info* channel_info);
/* The name of this filter */
- const char *name;
+ const char* name;
} grpc_channel_filter;
/* A channel_element tracks its filter and the filter requested memory within
a channel allocation */
struct grpc_channel_element {
- const grpc_channel_filter *filter;
- void *channel_data;
+ const grpc_channel_filter* filter;
+ void* channel_data;
};
/* A call_element tracks its filter, the filter requested memory within
a channel allocation, and the filter requested memory within a call
allocation */
struct grpc_call_element {
- const grpc_channel_filter *filter;
- void *channel_data;
- void *call_data;
+ const grpc_channel_filter* filter;
+ void* channel_data;
+ void* call_data;
};
/* A channel stack tracks a set of related filters for one channel, and
@@ -198,40 +198,40 @@ struct grpc_call_stack {
};
/* Get a channel element given a channel stack and its index */
-grpc_channel_element *grpc_channel_stack_element(grpc_channel_stack *stack,
+grpc_channel_element* grpc_channel_stack_element(grpc_channel_stack* stack,
size_t i);
/* Get the last channel element in a channel stack */
-grpc_channel_element *grpc_channel_stack_last_element(
- grpc_channel_stack *stack);
+grpc_channel_element* grpc_channel_stack_last_element(
+ grpc_channel_stack* stack);
/* Get a call stack element given a call stack and an index */
-grpc_call_element *grpc_call_stack_element(grpc_call_stack *stack, size_t i);
+grpc_call_element* grpc_call_stack_element(grpc_call_stack* stack, size_t i);
/* Determine memory required for a channel stack containing a set of filters */
-size_t grpc_channel_stack_size(const grpc_channel_filter **filters,
+size_t grpc_channel_stack_size(const grpc_channel_filter** filters,
size_t filter_count);
/* Initialize a channel stack given some filters */
-grpc_error *grpc_channel_stack_init(
- grpc_exec_ctx *exec_ctx, int initial_refs, grpc_iomgr_cb_func destroy,
- void *destroy_arg, const grpc_channel_filter **filters, size_t filter_count,
- const grpc_channel_args *args, grpc_transport *optional_transport,
- const char *name, grpc_channel_stack *stack);
+grpc_error* grpc_channel_stack_init(
+ grpc_exec_ctx* exec_ctx, int initial_refs, grpc_iomgr_cb_func destroy,
+ void* destroy_arg, const grpc_channel_filter** filters, size_t filter_count,
+ const grpc_channel_args* args, grpc_transport* optional_transport,
+ const char* name, grpc_channel_stack* stack);
/* Destroy a channel stack */
-void grpc_channel_stack_destroy(grpc_exec_ctx *exec_ctx,
- grpc_channel_stack *stack);
+void grpc_channel_stack_destroy(grpc_exec_ctx* exec_ctx,
+ grpc_channel_stack* stack);
/* Initialize a call stack given a channel stack. transport_server_data is
expected to be NULL on a client, or an opaque transport owned pointer on the
server. */
-grpc_error *grpc_call_stack_init(grpc_exec_ctx *exec_ctx,
- grpc_channel_stack *channel_stack,
+grpc_error* grpc_call_stack_init(grpc_exec_ctx* exec_ctx,
+ grpc_channel_stack* channel_stack,
int initial_refs, grpc_iomgr_cb_func destroy,
- void *destroy_arg,
- const grpc_call_element_args *elem_args);
+ void* destroy_arg,
+ const grpc_call_element_args* elem_args);
/* Set a pollset or a pollset_set for a call stack: must occur before the first
* op is started */
-void grpc_call_stack_set_pollset_or_pollset_set(grpc_exec_ctx *exec_ctx,
- grpc_call_stack *call_stack,
- grpc_polling_entity *pollent);
+void grpc_call_stack_set_pollset_or_pollset_set(grpc_exec_ctx* exec_ctx,
+ grpc_call_stack* call_stack,
+ grpc_polling_entity* pollent);
#ifndef NDEBUG
#define GRPC_CALL_STACK_REF(call_stack, reason) \
@@ -254,36 +254,36 @@ void grpc_call_stack_set_pollset_or_pollset_set(grpc_exec_ctx *exec_ctx,
#endif
/* Destroy a call stack */
-void grpc_call_stack_destroy(grpc_exec_ctx *exec_ctx, grpc_call_stack *stack,
- const grpc_call_final_info *final_info,
- grpc_closure *then_schedule_closure);
+void grpc_call_stack_destroy(grpc_exec_ctx* exec_ctx, grpc_call_stack* stack,
+ const grpc_call_final_info* final_info,
+ grpc_closure* then_schedule_closure);
/* Ignore set pollset{_set} - used by filters if they don't care about pollsets
* at all. Does nothing. */
void grpc_call_stack_ignore_set_pollset_or_pollset_set(
- grpc_exec_ctx *exec_ctx, grpc_call_element *elem,
- grpc_polling_entity *pollent);
+ grpc_exec_ctx* exec_ctx, grpc_call_element* elem,
+ grpc_polling_entity* pollent);
/* Call the next operation in a call stack */
-void grpc_call_next_op(grpc_exec_ctx *exec_ctx, grpc_call_element *elem,
- grpc_transport_stream_op_batch *op);
+void grpc_call_next_op(grpc_exec_ctx* exec_ctx, grpc_call_element* elem,
+ grpc_transport_stream_op_batch* op);
/* Call the next operation (depending on call directionality) in a channel
stack */
-void grpc_channel_next_op(grpc_exec_ctx *exec_ctx, grpc_channel_element *elem,
- grpc_transport_op *op);
+void grpc_channel_next_op(grpc_exec_ctx* exec_ctx, grpc_channel_element* elem,
+ grpc_transport_op* op);
/* Pass through a request to get_channel_info() to the next child element */
-void grpc_channel_next_get_info(grpc_exec_ctx *exec_ctx,
- grpc_channel_element *elem,
- const grpc_channel_info *channel_info);
+void grpc_channel_next_get_info(grpc_exec_ctx* exec_ctx,
+ grpc_channel_element* elem,
+ const grpc_channel_info* channel_info);
/* Given the top element of a channel stack, get the channel stack itself */
-grpc_channel_stack *grpc_channel_stack_from_top_element(
- grpc_channel_element *elem);
+grpc_channel_stack* grpc_channel_stack_from_top_element(
+ grpc_channel_element* elem);
/* Given the top element of a call stack, get the call stack itself */
-grpc_call_stack *grpc_call_stack_from_top_element(grpc_call_element *elem);
+grpc_call_stack* grpc_call_stack_from_top_element(grpc_call_element* elem);
-void grpc_call_log_op(const char *file, int line, gpr_log_severity severity,
- grpc_call_element *elem,
- grpc_transport_stream_op_batch *op);
+void grpc_call_log_op(const char* file, int line, gpr_log_severity severity,
+ grpc_call_element* elem,
+ grpc_transport_stream_op_batch* op);
extern grpc_tracer_flag grpc_trace_channel;
diff --git a/src/core/lib/channel/channel_stack_builder.cc b/src/core/lib/channel/channel_stack_builder.cc
index b663ebfb52..83748db3c2 100644
--- a/src/core/lib/channel/channel_stack_builder.cc
+++ b/src/core/lib/channel/channel_stack_builder.cc
@@ -27,11 +27,11 @@ grpc_tracer_flag grpc_trace_channel_stack_builder =
GRPC_TRACER_INITIALIZER(false, "channel_stack_builder");
typedef struct filter_node {
- struct filter_node *next;
- struct filter_node *prev;
- const grpc_channel_filter *filter;
+ struct filter_node* next;
+ struct filter_node* prev;
+ const grpc_channel_filter* filter;
grpc_post_filter_create_init_func init;
- void *init_arg;
+ void* init_arg;
} filter_node;
struct grpc_channel_stack_builder {
@@ -39,20 +39,20 @@ struct grpc_channel_stack_builder {
filter_node begin;
filter_node end;
// various set/get-able parameters
- grpc_channel_args *args;
- grpc_transport *transport;
- char *target;
- const char *name;
+ grpc_channel_args* args;
+ grpc_transport* transport;
+ char* target;
+ const char* name;
};
struct grpc_channel_stack_builder_iterator {
- grpc_channel_stack_builder *builder;
- filter_node *node;
+ grpc_channel_stack_builder* builder;
+ filter_node* node;
};
-grpc_channel_stack_builder *grpc_channel_stack_builder_create(void) {
- grpc_channel_stack_builder *b =
- (grpc_channel_stack_builder *)gpr_zalloc(sizeof(*b));
+grpc_channel_stack_builder* grpc_channel_stack_builder_create(void) {
+ grpc_channel_stack_builder* b =
+ (grpc_channel_stack_builder*)gpr_zalloc(sizeof(*b));
b->begin.filter = NULL;
b->end.filter = NULL;
@@ -64,76 +64,76 @@ grpc_channel_stack_builder *grpc_channel_stack_builder_create(void) {
return b;
}
-void grpc_channel_stack_builder_set_target(grpc_channel_stack_builder *b,
- const char *target) {
+void grpc_channel_stack_builder_set_target(grpc_channel_stack_builder* b,
+ const char* target) {
gpr_free(b->target);
b->target = gpr_strdup(target);
}
-const char *grpc_channel_stack_builder_get_target(
- grpc_channel_stack_builder *b) {
+const char* grpc_channel_stack_builder_get_target(
+ grpc_channel_stack_builder* b) {
return b->target;
}
-static grpc_channel_stack_builder_iterator *create_iterator_at_filter_node(
- grpc_channel_stack_builder *builder, filter_node *node) {
- grpc_channel_stack_builder_iterator *it =
- (grpc_channel_stack_builder_iterator *)gpr_malloc(sizeof(*it));
+static grpc_channel_stack_builder_iterator* create_iterator_at_filter_node(
+ grpc_channel_stack_builder* builder, filter_node* node) {
+ grpc_channel_stack_builder_iterator* it =
+ (grpc_channel_stack_builder_iterator*)gpr_malloc(sizeof(*it));
it->builder = builder;
it->node = node;
return it;
}
void grpc_channel_stack_builder_iterator_destroy(
- grpc_channel_stack_builder_iterator *it) {
+ grpc_channel_stack_builder_iterator* it) {
gpr_free(it);
}
-grpc_channel_stack_builder_iterator *
+grpc_channel_stack_builder_iterator*
grpc_channel_stack_builder_create_iterator_at_first(
- grpc_channel_stack_builder *builder) {
+ grpc_channel_stack_builder* builder) {
return create_iterator_at_filter_node(builder, &builder->begin);
}
-grpc_channel_stack_builder_iterator *
+grpc_channel_stack_builder_iterator*
grpc_channel_stack_builder_create_iterator_at_last(
- grpc_channel_stack_builder *builder) {
+ grpc_channel_stack_builder* builder) {
return create_iterator_at_filter_node(builder, &builder->end);
}
bool grpc_channel_stack_builder_iterator_is_end(
- grpc_channel_stack_builder_iterator *iterator) {
+ grpc_channel_stack_builder_iterator* iterator) {
return iterator->node == &iterator->builder->end;
}
-const char *grpc_channel_stack_builder_iterator_filter_name(
- grpc_channel_stack_builder_iterator *iterator) {
+const char* grpc_channel_stack_builder_iterator_filter_name(
+ grpc_channel_stack_builder_iterator* iterator) {
if (iterator->node->filter == NULL) return NULL;
return iterator->node->filter->name;
}
bool grpc_channel_stack_builder_move_next(
- grpc_channel_stack_builder_iterator *iterator) {
+ grpc_channel_stack_builder_iterator* iterator) {
if (iterator->node == &iterator->builder->end) return false;
iterator->node = iterator->node->next;
return true;
}
bool grpc_channel_stack_builder_move_prev(
- grpc_channel_stack_builder_iterator *iterator) {
+ grpc_channel_stack_builder_iterator* iterator) {
if (iterator->node == &iterator->builder->begin) return false;
iterator->node = iterator->node->prev;
return true;
}
-grpc_channel_stack_builder_iterator *grpc_channel_stack_builder_iterator_find(
- grpc_channel_stack_builder *builder, const char *filter_name) {
+grpc_channel_stack_builder_iterator* grpc_channel_stack_builder_iterator_find(
+ grpc_channel_stack_builder* builder, const char* filter_name) {
GPR_ASSERT(filter_name != NULL);
- grpc_channel_stack_builder_iterator *it =
+ grpc_channel_stack_builder_iterator* it =
grpc_channel_stack_builder_create_iterator_at_first(builder);
while (grpc_channel_stack_builder_move_next(it)) {
if (grpc_channel_stack_builder_iterator_is_end(it)) break;
- const char *filter_name_at_it =
+ const char* filter_name_at_it =
grpc_channel_stack_builder_iterator_filter_name(it);
if (strcmp(filter_name, filter_name_at_it) == 0) break;
}
@@ -141,17 +141,17 @@ grpc_channel_stack_builder_iterator *grpc_channel_stack_builder_iterator_find(
}
bool grpc_channel_stack_builder_move_prev(
- grpc_channel_stack_builder_iterator *iterator);
+ grpc_channel_stack_builder_iterator* iterator);
-void grpc_channel_stack_builder_set_name(grpc_channel_stack_builder *builder,
- const char *name) {
+void grpc_channel_stack_builder_set_name(grpc_channel_stack_builder* builder,
+ const char* name) {
GPR_ASSERT(builder->name == NULL);
builder->name = name;
}
void grpc_channel_stack_builder_set_channel_arguments(
- grpc_exec_ctx *exec_ctx, grpc_channel_stack_builder *builder,
- const grpc_channel_args *args) {
+ grpc_exec_ctx* exec_ctx, grpc_channel_stack_builder* builder,
+ const grpc_channel_args* args) {
if (builder->args != NULL) {
grpc_channel_args_destroy(exec_ctx, builder->args);
}
@@ -159,25 +159,25 @@ void grpc_channel_stack_builder_set_channel_arguments(
}
void grpc_channel_stack_builder_set_transport(
- grpc_channel_stack_builder *builder, grpc_transport *transport) {
+ grpc_channel_stack_builder* builder, grpc_transport* transport) {
GPR_ASSERT(builder->transport == NULL);
builder->transport = transport;
}
-grpc_transport *grpc_channel_stack_builder_get_transport(
- grpc_channel_stack_builder *builder) {
+grpc_transport* grpc_channel_stack_builder_get_transport(
+ grpc_channel_stack_builder* builder) {
return builder->transport;
}
-const grpc_channel_args *grpc_channel_stack_builder_get_channel_arguments(
- grpc_channel_stack_builder *builder) {
+const grpc_channel_args* grpc_channel_stack_builder_get_channel_arguments(
+ grpc_channel_stack_builder* builder) {
return builder->args;
}
bool grpc_channel_stack_builder_append_filter(
- grpc_channel_stack_builder *builder, const grpc_channel_filter *filter,
- grpc_post_filter_create_init_func post_init_func, void *user_data) {
- grpc_channel_stack_builder_iterator *it =
+ grpc_channel_stack_builder* builder, const grpc_channel_filter* filter,
+ grpc_post_filter_create_init_func post_init_func, void* user_data) {
+ grpc_channel_stack_builder_iterator* it =
grpc_channel_stack_builder_create_iterator_at_last(builder);
bool ok = grpc_channel_stack_builder_add_filter_before(
it, filter, post_init_func, user_data);
@@ -186,8 +186,8 @@ bool grpc_channel_stack_builder_append_filter(
}
bool grpc_channel_stack_builder_remove_filter(
- grpc_channel_stack_builder *builder, const char *filter_name) {
- grpc_channel_stack_builder_iterator *it =
+ grpc_channel_stack_builder* builder, const char* filter_name) {
+ grpc_channel_stack_builder_iterator* it =
grpc_channel_stack_builder_iterator_find(builder, filter_name);
if (grpc_channel_stack_builder_iterator_is_end(it)) {
grpc_channel_stack_builder_iterator_destroy(it);
@@ -201,9 +201,9 @@ bool grpc_channel_stack_builder_remove_filter(
}
bool grpc_channel_stack_builder_prepend_filter(
- grpc_channel_stack_builder *builder, const grpc_channel_filter *filter,
- grpc_post_filter_create_init_func post_init_func, void *user_data) {
- grpc_channel_stack_builder_iterator *it =
+ grpc_channel_stack_builder* builder, const grpc_channel_filter* filter,
+ grpc_post_filter_create_init_func post_init_func, void* user_data) {
+ grpc_channel_stack_builder_iterator* it =
grpc_channel_stack_builder_create_iterator_at_first(builder);
bool ok = grpc_channel_stack_builder_add_filter_after(
it, filter, post_init_func, user_data);
@@ -211,10 +211,10 @@ bool grpc_channel_stack_builder_prepend_filter(
return ok;
}
-static void add_after(filter_node *before, const grpc_channel_filter *filter,
+static void add_after(filter_node* before, const grpc_channel_filter* filter,
grpc_post_filter_create_init_func post_init_func,
- void *user_data) {
- filter_node *new_node = (filter_node *)gpr_malloc(sizeof(*new_node));
+ void* user_data) {
+ filter_node* new_node = (filter_node*)gpr_malloc(sizeof(*new_node));
new_node->next = before->next;
new_node->prev = before;
new_node->next->prev = new_node->prev->next = new_node;
@@ -224,28 +224,28 @@ static void add_after(filter_node *before, const grpc_channel_filter *filter,
}
bool grpc_channel_stack_builder_add_filter_before(
- grpc_channel_stack_builder_iterator *iterator,
- const grpc_channel_filter *filter,
- grpc_post_filter_create_init_func post_init_func, void *user_data) {
+ grpc_channel_stack_builder_iterator* iterator,
+ const grpc_channel_filter* filter,
+ grpc_post_filter_create_init_func post_init_func, void* user_data) {
if (iterator->node == &iterator->builder->begin) return false;
add_after(iterator->node->prev, filter, post_init_func, user_data);
return true;
}
bool grpc_channel_stack_builder_add_filter_after(
- grpc_channel_stack_builder_iterator *iterator,
- const grpc_channel_filter *filter,
- grpc_post_filter_create_init_func post_init_func, void *user_data) {
+ grpc_channel_stack_builder_iterator* iterator,
+ const grpc_channel_filter* filter,
+ grpc_post_filter_create_init_func post_init_func, void* user_data) {
if (iterator->node == &iterator->builder->end) return false;
add_after(iterator->node, filter, post_init_func, user_data);
return true;
}
-void grpc_channel_stack_builder_destroy(grpc_exec_ctx *exec_ctx,
- grpc_channel_stack_builder *builder) {
- filter_node *p = builder->begin.next;
+void grpc_channel_stack_builder_destroy(grpc_exec_ctx* exec_ctx,
+ grpc_channel_stack_builder* builder) {
+ filter_node* p = builder->begin.next;
while (p != &builder->end) {
- filter_node *next = p->next;
+ filter_node* next = p->next;
gpr_free(p);
p = next;
}
@@ -256,21 +256,21 @@ void grpc_channel_stack_builder_destroy(grpc_exec_ctx *exec_ctx,
gpr_free(builder);
}
-grpc_error *grpc_channel_stack_builder_finish(
- grpc_exec_ctx *exec_ctx, grpc_channel_stack_builder *builder,
+grpc_error* grpc_channel_stack_builder_finish(
+ grpc_exec_ctx* exec_ctx, grpc_channel_stack_builder* builder,
size_t prefix_bytes, int initial_refs, grpc_iomgr_cb_func destroy,
- void *destroy_arg, void **result) {
+ void* destroy_arg, void** result) {
// count the number of filters
size_t num_filters = 0;
- for (filter_node *p = builder->begin.next; p != &builder->end; p = p->next) {
+ for (filter_node* p = builder->begin.next; p != &builder->end; p = p->next) {
num_filters++;
}
// create an array of filters
- const grpc_channel_filter **filters =
- (const grpc_channel_filter **)gpr_malloc(sizeof(*filters) * num_filters);
+ const grpc_channel_filter** filters =
+ (const grpc_channel_filter**)gpr_malloc(sizeof(*filters) * num_filters);
size_t i = 0;
- for (filter_node *p = builder->begin.next; p != &builder->end; p = p->next) {
+ for (filter_node* p = builder->begin.next; p != &builder->end; p = p->next) {
filters[i++] = p->filter;
}
@@ -280,10 +280,10 @@ grpc_error *grpc_channel_stack_builder_finish(
// allocate memory, with prefix_bytes followed by channel_stack_size
*result = gpr_zalloc(prefix_bytes + channel_stack_size);
// fetch a pointer to the channel stack
- grpc_channel_stack *channel_stack =
- (grpc_channel_stack *)((char *)(*result) + prefix_bytes);
+ grpc_channel_stack* channel_stack =
+ (grpc_channel_stack*)((char*)(*result) + prefix_bytes);
// and initialize it
- grpc_error *error = grpc_channel_stack_init(
+ grpc_error* error = grpc_channel_stack_init(
exec_ctx, initial_refs, destroy,
destroy_arg == NULL ? *result : destroy_arg, filters, num_filters,
builder->args, builder->transport, builder->name, channel_stack);
@@ -295,7 +295,7 @@ grpc_error *grpc_channel_stack_builder_finish(
} else {
// run post-initialization functions
i = 0;
- for (filter_node *p = builder->begin.next; p != &builder->end;
+ for (filter_node* p = builder->begin.next; p != &builder->end;
p = p->next) {
if (p->init != NULL) {
p->init(channel_stack, grpc_channel_stack_element(channel_stack, i),
@@ -306,7 +306,7 @@ grpc_error *grpc_channel_stack_builder_finish(
}
grpc_channel_stack_builder_destroy(exec_ctx, builder);
- gpr_free((grpc_channel_filter **)filters);
+ gpr_free((grpc_channel_filter**)filters);
return error;
}
diff --git a/src/core/lib/channel/channel_stack_builder.h b/src/core/lib/channel/channel_stack_builder.h
index fdff2a2b6d..23134b7d10 100644
--- a/src/core/lib/channel/channel_stack_builder.h
+++ b/src/core/lib/channel/channel_stack_builder.h
@@ -35,130 +35,130 @@ typedef struct grpc_channel_stack_builder_iterator
grpc_channel_stack_builder_iterator;
/// Create a new channel stack builder
-grpc_channel_stack_builder *grpc_channel_stack_builder_create(void);
+grpc_channel_stack_builder* grpc_channel_stack_builder_create(void);
/// Assign a name to the channel stack: \a name must be statically allocated
-void grpc_channel_stack_builder_set_name(grpc_channel_stack_builder *builder,
- const char *name);
+void grpc_channel_stack_builder_set_name(grpc_channel_stack_builder* builder,
+ const char* name);
/// Set the target uri
-void grpc_channel_stack_builder_set_target(grpc_channel_stack_builder *b,
- const char *target);
+void grpc_channel_stack_builder_set_target(grpc_channel_stack_builder* b,
+ const char* target);
-const char *grpc_channel_stack_builder_get_target(
- grpc_channel_stack_builder *b);
+const char* grpc_channel_stack_builder_get_target(
+ grpc_channel_stack_builder* b);
/// Attach \a transport to the builder (does not take ownership)
void grpc_channel_stack_builder_set_transport(
- grpc_channel_stack_builder *builder, grpc_transport *transport);
+ grpc_channel_stack_builder* builder, grpc_transport* transport);
/// Fetch attached transport
-grpc_transport *grpc_channel_stack_builder_get_transport(
- grpc_channel_stack_builder *builder);
+grpc_transport* grpc_channel_stack_builder_get_transport(
+ grpc_channel_stack_builder* builder);
/// Set channel arguments: copies args
void grpc_channel_stack_builder_set_channel_arguments(
- grpc_exec_ctx *exec_ctx, grpc_channel_stack_builder *builder,
- const grpc_channel_args *args);
+ grpc_exec_ctx* exec_ctx, grpc_channel_stack_builder* builder,
+ const grpc_channel_args* args);
/// Return a borrowed pointer to the channel arguments
-const grpc_channel_args *grpc_channel_stack_builder_get_channel_arguments(
- grpc_channel_stack_builder *builder);
+const grpc_channel_args* grpc_channel_stack_builder_get_channel_arguments(
+ grpc_channel_stack_builder* builder);
/// Begin iterating over already defined filters in the builder at the beginning
-grpc_channel_stack_builder_iterator *
+grpc_channel_stack_builder_iterator*
grpc_channel_stack_builder_create_iterator_at_first(
- grpc_channel_stack_builder *builder);
+ grpc_channel_stack_builder* builder);
/// Begin iterating over already defined filters in the builder at the end
-grpc_channel_stack_builder_iterator *
+grpc_channel_stack_builder_iterator*
grpc_channel_stack_builder_create_iterator_at_last(
- grpc_channel_stack_builder *builder);
+ grpc_channel_stack_builder* builder);
/// Is an iterator at the first element?
bool grpc_channel_stack_builder_iterator_is_first(
- grpc_channel_stack_builder_iterator *iterator);
+ grpc_channel_stack_builder_iterator* iterator);
/// Is an iterator at the end?
bool grpc_channel_stack_builder_iterator_is_end(
- grpc_channel_stack_builder_iterator *iterator);
+ grpc_channel_stack_builder_iterator* iterator);
/// What is the name of the filter at this iterator position?
-const char *grpc_channel_stack_builder_iterator_filter_name(
- grpc_channel_stack_builder_iterator *iterator);
+const char* grpc_channel_stack_builder_iterator_filter_name(
+ grpc_channel_stack_builder_iterator* iterator);
/// Move an iterator to the next item
bool grpc_channel_stack_builder_move_next(
- grpc_channel_stack_builder_iterator *iterator);
+ grpc_channel_stack_builder_iterator* iterator);
/// Move an iterator to the previous item
bool grpc_channel_stack_builder_move_prev(
- grpc_channel_stack_builder_iterator *iterator);
+ grpc_channel_stack_builder_iterator* iterator);
/// Return an iterator at \a filter_name, or at the end of the list if not
/// found.
-grpc_channel_stack_builder_iterator *grpc_channel_stack_builder_iterator_find(
- grpc_channel_stack_builder *builder, const char *filter_name);
+grpc_channel_stack_builder_iterator* grpc_channel_stack_builder_iterator_find(
+ grpc_channel_stack_builder* builder, const char* filter_name);
typedef void (*grpc_post_filter_create_init_func)(
- grpc_channel_stack *channel_stack, grpc_channel_element *elem, void *arg);
+ grpc_channel_stack* channel_stack, grpc_channel_element* elem, void* arg);
/// Add \a filter to the stack, after \a iterator.
/// Call \a post_init_func(..., \a user_data) once the channel stack is
/// created.
bool grpc_channel_stack_builder_add_filter_after(
- grpc_channel_stack_builder_iterator *iterator,
- const grpc_channel_filter *filter,
+ grpc_channel_stack_builder_iterator* iterator,
+ const grpc_channel_filter* filter,
grpc_post_filter_create_init_func post_init_func,
- void *user_data) GRPC_MUST_USE_RESULT;
+ void* user_data) GRPC_MUST_USE_RESULT;
/// Add \a filter to the stack, before \a iterator.
/// Call \a post_init_func(..., \a user_data) once the channel stack is
/// created.
bool grpc_channel_stack_builder_add_filter_before(
- grpc_channel_stack_builder_iterator *iterator,
- const grpc_channel_filter *filter,
+ grpc_channel_stack_builder_iterator* iterator,
+ const grpc_channel_filter* filter,
grpc_post_filter_create_init_func post_init_func,
- void *user_data) GRPC_MUST_USE_RESULT;
+ void* user_data) GRPC_MUST_USE_RESULT;
/// Add \a filter to the beginning of the filter list.
/// Call \a post_init_func(..., \a user_data) once the channel stack is
/// created.
bool grpc_channel_stack_builder_prepend_filter(
- grpc_channel_stack_builder *builder, const grpc_channel_filter *filter,
+ grpc_channel_stack_builder* builder, const grpc_channel_filter* filter,
grpc_post_filter_create_init_func post_init_func,
- void *user_data) GRPC_MUST_USE_RESULT;
+ void* user_data) GRPC_MUST_USE_RESULT;
/// Add \a filter to the end of the filter list.
/// Call \a post_init_func(..., \a user_data) once the channel stack is
/// created.
bool grpc_channel_stack_builder_append_filter(
- grpc_channel_stack_builder *builder, const grpc_channel_filter *filter,
+ grpc_channel_stack_builder* builder, const grpc_channel_filter* filter,
grpc_post_filter_create_init_func post_init_func,
- void *user_data) GRPC_MUST_USE_RESULT;
+ void* user_data) GRPC_MUST_USE_RESULT;
/// Remove any filter whose name is \a filter_name from \a builder. Returns true
/// if \a filter_name was not found.
bool grpc_channel_stack_builder_remove_filter(
- grpc_channel_stack_builder *builder, const char *filter_name);
+ grpc_channel_stack_builder* builder, const char* filter_name);
/// Terminate iteration and destroy \a iterator
void grpc_channel_stack_builder_iterator_destroy(
- grpc_channel_stack_builder_iterator *iterator);
+ grpc_channel_stack_builder_iterator* iterator);
/// Destroy the builder, return the freshly minted channel stack in \a result.
/// Allocates \a prefix_bytes bytes before the channel stack
/// Returns the base pointer of the allocated block
/// \a initial_refs, \a destroy, \a destroy_arg are as per
/// grpc_channel_stack_init
-grpc_error *grpc_channel_stack_builder_finish(
- grpc_exec_ctx *exec_ctx, grpc_channel_stack_builder *builder,
+grpc_error* grpc_channel_stack_builder_finish(
+ grpc_exec_ctx* exec_ctx, grpc_channel_stack_builder* builder,
size_t prefix_bytes, int initial_refs, grpc_iomgr_cb_func destroy,
- void *destroy_arg, void **result);
+ void* destroy_arg, void** result);
/// Destroy the builder without creating a channel stack
-void grpc_channel_stack_builder_destroy(grpc_exec_ctx *exec_ctx,
- grpc_channel_stack_builder *builder);
+void grpc_channel_stack_builder_destroy(grpc_exec_ctx* exec_ctx,
+ grpc_channel_stack_builder* builder);
extern grpc_tracer_flag grpc_trace_channel_stack_builder;
diff --git a/src/core/lib/channel/connected_channel.cc b/src/core/lib/channel/connected_channel.cc
index 4f37908958..49b9f140c0 100644
--- a/src/core/lib/channel/connected_channel.cc
+++ b/src/core/lib/channel/connected_channel.cc
@@ -33,41 +33,41 @@
#define MAX_BUFFER_LENGTH 8192
typedef struct connected_channel_channel_data {
- grpc_transport *transport;
+ grpc_transport* transport;
} channel_data;
typedef struct {
grpc_closure closure;
- grpc_closure *original_closure;
- grpc_call_combiner *call_combiner;
- const char *reason;
+ grpc_closure* original_closure;
+ grpc_call_combiner* call_combiner;
+ const char* reason;
} callback_state;
typedef struct connected_channel_call_data {
- grpc_call_combiner *call_combiner;
+ grpc_call_combiner* call_combiner;
// Closures used for returning results on the call combiner.
callback_state on_complete[6]; // Max number of pending batches.
callback_state recv_initial_metadata_ready;
callback_state recv_message_ready;
} call_data;
-static void run_in_call_combiner(grpc_exec_ctx *exec_ctx, void *arg,
- grpc_error *error) {
- callback_state *state = (callback_state *)arg;
+static void run_in_call_combiner(grpc_exec_ctx* exec_ctx, void* arg,
+ grpc_error* error) {
+ callback_state* state = (callback_state*)arg;
GRPC_CALL_COMBINER_START(exec_ctx, state->call_combiner,
state->original_closure, GRPC_ERROR_REF(error),
state->reason);
}
-static void run_cancel_in_call_combiner(grpc_exec_ctx *exec_ctx, void *arg,
- grpc_error *error) {
+static void run_cancel_in_call_combiner(grpc_exec_ctx* exec_ctx, void* arg,
+ grpc_error* error) {
run_in_call_combiner(exec_ctx, arg, error);
gpr_free(arg);
}
-static void intercept_callback(call_data *calld, callback_state *state,
- bool free_when_done, const char *reason,
- grpc_closure **original_closure) {
+static void intercept_callback(call_data* calld, callback_state* state,
+ bool free_when_done, const char* reason,
+ grpc_closure** original_closure) {
state->original_closure = *original_closure;
state->call_combiner = calld->call_combiner;
state->reason = reason;
@@ -77,8 +77,8 @@ static void intercept_callback(call_data *calld, callback_state *state,
state, grpc_schedule_on_exec_ctx);
}
-static callback_state *get_state_for_batch(
- call_data *calld, grpc_transport_stream_op_batch *batch) {
+static callback_state* get_state_for_batch(
+ call_data* calld, grpc_transport_stream_op_batch* batch) {
if (batch->send_initial_metadata) return &calld->on_complete[0];
if (batch->send_message) return &calld->on_complete[1];
if (batch->send_trailing_metadata) return &calld->on_complete[2];
@@ -91,25 +91,25 @@ static callback_state *get_state_for_batch(
/* We perform a small hack to locate transport data alongside the connected
channel data in call allocations, to allow everything to be pulled in minimal
cache line requests */
-#define TRANSPORT_STREAM_FROM_CALL_DATA(calld) ((grpc_stream *)((calld) + 1))
+#define TRANSPORT_STREAM_FROM_CALL_DATA(calld) ((grpc_stream*)((calld) + 1))
#define CALL_DATA_FROM_TRANSPORT_STREAM(transport_stream) \
- (((call_data *)(transport_stream)) - 1)
+ (((call_data*)(transport_stream)) - 1)
/* Intercept a call operation and either push it directly up or translate it
into transport stream operations */
static void con_start_transport_stream_op_batch(
- grpc_exec_ctx *exec_ctx, grpc_call_element *elem,
- grpc_transport_stream_op_batch *batch) {
- call_data *calld = (call_data *)elem->call_data;
- channel_data *chand = (channel_data *)elem->channel_data;
+ grpc_exec_ctx* exec_ctx, grpc_call_element* elem,
+ grpc_transport_stream_op_batch* batch) {
+ call_data* calld = (call_data*)elem->call_data;
+ channel_data* chand = (channel_data*)elem->channel_data;
if (batch->recv_initial_metadata) {
- callback_state *state = &calld->recv_initial_metadata_ready;
+ callback_state* state = &calld->recv_initial_metadata_ready;
intercept_callback(
calld, state, false, "recv_initial_metadata_ready",
&batch->payload->recv_initial_metadata.recv_initial_metadata_ready);
}
if (batch->recv_message) {
- callback_state *state = &calld->recv_message_ready;
+ callback_state* state = &calld->recv_message_ready;
intercept_callback(calld, state, false, "recv_message_ready",
&batch->payload->recv_message.recv_message_ready);
}
@@ -119,11 +119,11 @@ static void con_start_transport_stream_op_batch(
// calld->on_complete like we can for the other ops. However,
// cancellation isn't in the fast path, so we just allocate a new
// closure for each one.
- callback_state *state = (callback_state *)gpr_malloc(sizeof(*state));
+ callback_state* state = (callback_state*)gpr_malloc(sizeof(*state));
intercept_callback(calld, state, true, "on_complete (cancel_stream)",
&batch->on_complete);
} else {
- callback_state *state = get_state_for_batch(calld, batch);
+ callback_state* state = get_state_for_batch(calld, batch);
intercept_callback(calld, state, false, "on_complete", &batch->on_complete);
}
grpc_transport_perform_stream_op(exec_ctx, chand->transport,
@@ -133,19 +133,19 @@ static void con_start_transport_stream_op_batch(
"passed batch to transport");
}
-static void con_start_transport_op(grpc_exec_ctx *exec_ctx,
- grpc_channel_element *elem,
- grpc_transport_op *op) {
- channel_data *chand = (channel_data *)elem->channel_data;
+static void con_start_transport_op(grpc_exec_ctx* exec_ctx,
+ grpc_channel_element* elem,
+ grpc_transport_op* op) {
+ channel_data* chand = (channel_data*)elem->channel_data;
grpc_transport_perform_op(exec_ctx, chand->transport, op);
}
/* Constructor for call_data */
-static grpc_error *init_call_elem(grpc_exec_ctx *exec_ctx,
- grpc_call_element *elem,
- const grpc_call_element_args *args) {
- call_data *calld = (call_data *)elem->call_data;
- channel_data *chand = (channel_data *)elem->channel_data;
+static grpc_error* init_call_elem(grpc_exec_ctx* exec_ctx,
+ grpc_call_element* elem,
+ const grpc_call_element_args* args) {
+ call_data* calld = (call_data*)elem->call_data;
+ channel_data* chand = (channel_data*)elem->channel_data;
calld->call_combiner = args->call_combiner;
int r = grpc_transport_init_stream(
exec_ctx, chand->transport, TRANSPORT_STREAM_FROM_CALL_DATA(calld),
@@ -155,49 +155,49 @@ static grpc_error *init_call_elem(grpc_exec_ctx *exec_ctx,
"transport stream initialization failed");
}
-static void set_pollset_or_pollset_set(grpc_exec_ctx *exec_ctx,
- grpc_call_element *elem,
- grpc_polling_entity *pollent) {
- call_data *calld = (call_data *)elem->call_data;
- channel_data *chand = (channel_data *)elem->channel_data;
+static void set_pollset_or_pollset_set(grpc_exec_ctx* exec_ctx,
+ grpc_call_element* elem,
+ grpc_polling_entity* pollent) {
+ call_data* calld = (call_data*)elem->call_data;
+ channel_data* chand = (channel_data*)elem->channel_data;
grpc_transport_set_pops(exec_ctx, chand->transport,
TRANSPORT_STREAM_FROM_CALL_DATA(calld), pollent);
}
/* Destructor for call_data */
-static void destroy_call_elem(grpc_exec_ctx *exec_ctx, grpc_call_element *elem,
- const grpc_call_final_info *final_info,
- grpc_closure *then_schedule_closure) {
- call_data *calld = (call_data *)elem->call_data;
- channel_data *chand = (channel_data *)elem->channel_data;
+static void destroy_call_elem(grpc_exec_ctx* exec_ctx, grpc_call_element* elem,
+ const grpc_call_final_info* final_info,
+ grpc_closure* then_schedule_closure) {
+ call_data* calld = (call_data*)elem->call_data;
+ channel_data* chand = (channel_data*)elem->channel_data;
grpc_transport_destroy_stream(exec_ctx, chand->transport,
TRANSPORT_STREAM_FROM_CALL_DATA(calld),
then_schedule_closure);
}
/* Constructor for channel_data */
-static grpc_error *init_channel_elem(grpc_exec_ctx *exec_ctx,
- grpc_channel_element *elem,
- grpc_channel_element_args *args) {
- channel_data *cd = (channel_data *)elem->channel_data;
+static grpc_error* init_channel_elem(grpc_exec_ctx* exec_ctx,
+ grpc_channel_element* elem,
+ grpc_channel_element_args* args) {
+ channel_data* cd = (channel_data*)elem->channel_data;
GPR_ASSERT(args->is_last);
cd->transport = NULL;
return GRPC_ERROR_NONE;
}
/* Destructor for channel_data */
-static void destroy_channel_elem(grpc_exec_ctx *exec_ctx,
- grpc_channel_element *elem) {
- channel_data *cd = (channel_data *)elem->channel_data;
+static void destroy_channel_elem(grpc_exec_ctx* exec_ctx,
+ grpc_channel_element* elem) {
+ channel_data* cd = (channel_data*)elem->channel_data;
if (cd->transport) {
grpc_transport_destroy(exec_ctx, cd->transport);
}
}
/* No-op. */
-static void con_get_channel_info(grpc_exec_ctx *exec_ctx,
- grpc_channel_element *elem,
- const grpc_channel_info *channel_info) {}
+static void con_get_channel_info(grpc_exec_ctx* exec_ctx,
+ grpc_channel_element* elem,
+ const grpc_channel_info* channel_info) {}
const grpc_channel_filter grpc_connected_filter = {
con_start_transport_stream_op_batch,
@@ -213,12 +213,12 @@ const grpc_channel_filter grpc_connected_filter = {
"connected",
};
-static void bind_transport(grpc_channel_stack *channel_stack,
- grpc_channel_element *elem, void *t) {
- channel_data *cd = (channel_data *)elem->channel_data;
+static void bind_transport(grpc_channel_stack* channel_stack,
+ grpc_channel_element* elem, void* t) {
+ channel_data* cd = (channel_data*)elem->channel_data;
GPR_ASSERT(elem->filter == &grpc_connected_filter);
GPR_ASSERT(cd->transport == NULL);
- cd->transport = (grpc_transport *)t;
+ cd->transport = (grpc_transport*)t;
/* HACK(ctiller): increase call stack size for the channel to make space
for channel data. We need a cleaner (but performant) way to do this,
@@ -227,20 +227,20 @@ static void bind_transport(grpc_channel_stack *channel_stack,
the last call element, and the last call element MUST be the connected
channel. */
channel_stack->call_stack_size +=
- grpc_transport_stream_size((grpc_transport *)t);
+ grpc_transport_stream_size((grpc_transport*)t);
}
-bool grpc_add_connected_filter(grpc_exec_ctx *exec_ctx,
- grpc_channel_stack_builder *builder,
- void *arg_must_be_null) {
+bool grpc_add_connected_filter(grpc_exec_ctx* exec_ctx,
+ grpc_channel_stack_builder* builder,
+ void* arg_must_be_null) {
GPR_ASSERT(arg_must_be_null == NULL);
- grpc_transport *t = grpc_channel_stack_builder_get_transport(builder);
+ grpc_transport* t = grpc_channel_stack_builder_get_transport(builder);
GPR_ASSERT(t != NULL);
return grpc_channel_stack_builder_append_filter(
builder, &grpc_connected_filter, bind_transport, t);
}
-grpc_stream *grpc_connected_channel_get_stream(grpc_call_element *elem) {
- call_data *calld = (call_data *)elem->call_data;
+grpc_stream* grpc_connected_channel_get_stream(grpc_call_element* elem) {
+ call_data* calld = (call_data*)elem->call_data;
return TRANSPORT_STREAM_FROM_CALL_DATA(calld);
}
diff --git a/src/core/lib/channel/connected_channel.h b/src/core/lib/channel/connected_channel.h
index 4615727baa..cca19737dc 100644
--- a/src/core/lib/channel/connected_channel.h
+++ b/src/core/lib/channel/connected_channel.h
@@ -27,12 +27,12 @@ extern "C" {
extern const grpc_channel_filter grpc_connected_filter;
-bool grpc_add_connected_filter(grpc_exec_ctx *exec_ctx,
- grpc_channel_stack_builder *builder,
- void *arg_must_be_null);
+bool grpc_add_connected_filter(grpc_exec_ctx* exec_ctx,
+ grpc_channel_stack_builder* builder,
+ void* arg_must_be_null);
/* Debug helper to dig the transport stream out of a call element */
-grpc_stream *grpc_connected_channel_get_stream(grpc_call_element *elem);
+grpc_stream* grpc_connected_channel_get_stream(grpc_call_element* elem);
#ifdef __cplusplus
}
diff --git a/src/core/lib/channel/context.h b/src/core/lib/channel/context.h
index 191bd63351..5daf48a9a9 100644
--- a/src/core/lib/channel/context.h
+++ b/src/core/lib/channel/context.h
@@ -42,8 +42,8 @@ typedef enum {
} grpc_context_index;
typedef struct {
- void *value;
- void (*destroy)(void *);
+ void* value;
+ void (*destroy)(void*);
} grpc_call_context_element;
#endif /* GRPC_CORE_LIB_CHANNEL_CONTEXT_H */
diff --git a/src/core/lib/channel/handshaker_factory.cc b/src/core/lib/channel/handshaker_factory.cc
index 4deb280c60..bf1188dbb9 100644
--- a/src/core/lib/channel/handshaker_factory.cc
+++ b/src/core/lib/channel/handshaker_factory.cc
@@ -21,8 +21,8 @@
#include <grpc/support/log.h>
void grpc_handshaker_factory_add_handshakers(
- grpc_exec_ctx *exec_ctx, grpc_handshaker_factory *handshaker_factory,
- const grpc_channel_args *args, grpc_handshake_manager *handshake_mgr) {
+ grpc_exec_ctx* exec_ctx, grpc_handshaker_factory* handshaker_factory,
+ const grpc_channel_args* args, grpc_handshake_manager* handshake_mgr) {
if (handshaker_factory != NULL) {
GPR_ASSERT(handshaker_factory->vtable != NULL);
handshaker_factory->vtable->add_handshakers(exec_ctx, handshaker_factory,
@@ -31,7 +31,7 @@ void grpc_handshaker_factory_add_handshakers(
}
void grpc_handshaker_factory_destroy(
- grpc_exec_ctx *exec_ctx, grpc_handshaker_factory *handshaker_factory) {
+ grpc_exec_ctx* exec_ctx, grpc_handshaker_factory* handshaker_factory) {
if (handshaker_factory != NULL) {
GPR_ASSERT(handshaker_factory->vtable != NULL);
handshaker_factory->vtable->destroy(exec_ctx, handshaker_factory);
diff --git a/src/core/lib/channel/handshaker_factory.h b/src/core/lib/channel/handshaker_factory.h
index 59008adf05..63d9b5af72 100644
--- a/src/core/lib/channel/handshaker_factory.h
+++ b/src/core/lib/channel/handshaker_factory.h
@@ -33,24 +33,24 @@ extern "C" {
typedef struct grpc_handshaker_factory grpc_handshaker_factory;
typedef struct {
- void (*add_handshakers)(grpc_exec_ctx *exec_ctx,
- grpc_handshaker_factory *handshaker_factory,
- const grpc_channel_args *args,
- grpc_handshake_manager *handshake_mgr);
- void (*destroy)(grpc_exec_ctx *exec_ctx,
- grpc_handshaker_factory *handshaker_factory);
+ void (*add_handshakers)(grpc_exec_ctx* exec_ctx,
+ grpc_handshaker_factory* handshaker_factory,
+ const grpc_channel_args* args,
+ grpc_handshake_manager* handshake_mgr);
+ void (*destroy)(grpc_exec_ctx* exec_ctx,
+ grpc_handshaker_factory* handshaker_factory);
} grpc_handshaker_factory_vtable;
struct grpc_handshaker_factory {
- const grpc_handshaker_factory_vtable *vtable;
+ const grpc_handshaker_factory_vtable* vtable;
};
void grpc_handshaker_factory_add_handshakers(
- grpc_exec_ctx *exec_ctx, grpc_handshaker_factory *handshaker_factory,
- const grpc_channel_args *args, grpc_handshake_manager *handshake_mgr);
+ grpc_exec_ctx* exec_ctx, grpc_handshaker_factory* handshaker_factory,
+ const grpc_channel_args* args, grpc_handshake_manager* handshake_mgr);
void grpc_handshaker_factory_destroy(
- grpc_exec_ctx *exec_ctx, grpc_handshaker_factory *handshaker_factory);
+ grpc_exec_ctx* exec_ctx, grpc_handshaker_factory* handshaker_factory);
#ifdef __cplusplus
}
generated by cgit v1.2.3 (git 2.39.1) at 2024-07-02 07:29:10 +0000