Mark D. Roth | a6f1b98 | 2016-08-24 08:16:16 -0700 | [diff] [blame] | 1 | // |
| 2 | // Copyright 2016, Google Inc. |
| 3 | // All rights reserved. |
| 4 | // |
| 5 | // Redistribution and use in source and binary forms, with or without |
| 6 | // modification, are permitted provided that the following conditions are |
| 7 | // met: |
| 8 | // |
| 9 | // * Redistributions of source code must retain the above copyright |
| 10 | // notice, this list of conditions and the following disclaimer. |
| 11 | // * Redistributions in binary form must reproduce the above |
| 12 | // copyright notice, this list of conditions and the following disclaimer |
| 13 | // in the documentation and/or other materials provided with the |
| 14 | // distribution. |
| 15 | // * Neither the name of Google Inc. nor the names of its |
| 16 | // contributors may be used to endorse or promote products derived from |
| 17 | // this software without specific prior written permission. |
| 18 | // |
| 19 | // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
| 20 | // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
| 21 | // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
| 22 | // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
| 23 | // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| 24 | // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
| 25 | // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| 26 | // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| 27 | // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| 28 | // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| 29 | // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| 30 | // |
Mark D. Roth | af00d8b | 2016-08-23 12:48:16 -0700 | [diff] [blame] | 31 | |
| 32 | #include "src/core/lib/channel/message_size_filter.h" |
| 33 | |
Mark D. Roth | c3c6faf | 2016-08-26 09:20:49 -0700 | [diff] [blame] | 34 | #include <limits.h> |
Mark D. Roth | af00d8b | 2016-08-23 12:48:16 -0700 | [diff] [blame] | 35 | #include <string.h> |
| 36 | |
yang-g | e46de3d | 2016-11-17 15:20:02 -0800 | [diff] [blame] | 37 | #include <grpc/impl/codegen/grpc_types.h> |
Mark D. Roth | af00d8b | 2016-08-23 12:48:16 -0700 | [diff] [blame] | 38 | #include <grpc/support/alloc.h> |
| 39 | #include <grpc/support/log.h> |
| 40 | #include <grpc/support/string_util.h> |
| 41 | |
Mark D. Roth | afa8c10 | 2016-09-30 10:56:53 -0700 | [diff] [blame] | 42 | #include "src/core/lib/channel/channel_args.h" |
Mark D. Roth | c968e60 | 2016-11-02 14:07:36 -0700 | [diff] [blame] | 43 | #include "src/core/lib/support/string.h" |
Mark D. Roth | ea846a0 | 2016-11-03 11:32:54 -0700 | [diff] [blame] | 44 | #include "src/core/lib/transport/service_config.h" |
Mark D. Roth | c3c6faf | 2016-08-26 09:20:49 -0700 | [diff] [blame] | 45 | |
Mark D. Roth | 29a7f40 | 2016-10-19 13:46:38 -0700 | [diff] [blame] | 46 | typedef struct message_size_limits { |
| 47 | int max_send_size; |
| 48 | int max_recv_size; |
| 49 | } message_size_limits; |
| 50 | |
| 51 | static void* message_size_limits_copy(void* value) { |
| 52 | void* new_value = gpr_malloc(sizeof(message_size_limits)); |
| 53 | memcpy(new_value, value, sizeof(message_size_limits)); |
| 54 | return new_value; |
| 55 | } |
| 56 | |
Craig Tiller | b28c7e8 | 2016-11-18 10:29:04 -0800 | [diff] [blame] | 57 | static void message_size_limits_free(grpc_exec_ctx* exec_ctx, void* value) { |
| 58 | gpr_free(value); |
Mark D. Roth | 29a7f40 | 2016-10-19 13:46:38 -0700 | [diff] [blame] | 59 | } |
| 60 | |
Craig Tiller | 7c70b6c | 2017-01-23 07:48:42 -0800 | [diff] [blame] | 61 | static const grpc_slice_hash_table_vtable message_size_limits_vtable = { |
Craig Tiller | b28c7e8 | 2016-11-18 10:29:04 -0800 | [diff] [blame] | 62 | message_size_limits_free, message_size_limits_copy}; |
Mark D. Roth | 29a7f40 | 2016-10-19 13:46:38 -0700 | [diff] [blame] | 63 | |
Mark D. Roth | e30baeb | 2016-11-03 08:16:19 -0700 | [diff] [blame] | 64 | static void* message_size_limits_create_from_json(const grpc_json* json) { |
Mark D. Roth | c968e60 | 2016-11-02 14:07:36 -0700 | [diff] [blame] | 65 | int max_request_message_bytes = -1; |
| 66 | int max_response_message_bytes = -1; |
| 67 | for (grpc_json* field = json->child; field != NULL; field = field->next) { |
| 68 | if (field->key == NULL) continue; |
Mark D. Roth | 84c8a02 | 2016-11-10 09:39:34 -0800 | [diff] [blame] | 69 | if (strcmp(field->key, "maxRequestMessageBytes") == 0) { |
Mark D. Roth | c968e60 | 2016-11-02 14:07:36 -0700 | [diff] [blame] | 70 | if (max_request_message_bytes >= 0) return NULL; // Duplicate. |
Mark D. Roth | 40b4c78 | 2017-01-26 14:36:43 -0800 | [diff] [blame] | 71 | if (field->type != GRPC_JSON_STRING && field->type != GRPC_JSON_NUMBER) { |
| 72 | return NULL; |
| 73 | } |
Mark D. Roth | 84c8a02 | 2016-11-10 09:39:34 -0800 | [diff] [blame] | 74 | max_request_message_bytes = gpr_parse_nonnegative_int(field->value); |
Mark D. Roth | c968e60 | 2016-11-02 14:07:36 -0700 | [diff] [blame] | 75 | if (max_request_message_bytes == -1) return NULL; |
Mark D. Roth | 84c8a02 | 2016-11-10 09:39:34 -0800 | [diff] [blame] | 76 | } else if (strcmp(field->key, "maxResponseMessageBytes") == 0) { |
Mark D. Roth | c968e60 | 2016-11-02 14:07:36 -0700 | [diff] [blame] | 77 | if (max_response_message_bytes >= 0) return NULL; // Duplicate. |
Mark D. Roth | 40b4c78 | 2017-01-26 14:36:43 -0800 | [diff] [blame] | 78 | if (field->type != GRPC_JSON_STRING && field->type != GRPC_JSON_NUMBER) { |
| 79 | return NULL; |
| 80 | } |
Mark D. Roth | 84c8a02 | 2016-11-10 09:39:34 -0800 | [diff] [blame] | 81 | max_response_message_bytes = gpr_parse_nonnegative_int(field->value); |
Mark D. Roth | c968e60 | 2016-11-02 14:07:36 -0700 | [diff] [blame] | 82 | if (max_response_message_bytes == -1) return NULL; |
| 83 | } |
| 84 | } |
Mark D. Roth | 29a7f40 | 2016-10-19 13:46:38 -0700 | [diff] [blame] | 85 | message_size_limits* value = gpr_malloc(sizeof(message_size_limits)); |
Mark D. Roth | c968e60 | 2016-11-02 14:07:36 -0700 | [diff] [blame] | 86 | value->max_send_size = max_request_message_bytes; |
| 87 | value->max_recv_size = max_response_message_bytes; |
Mark D. Roth | 29a7f40 | 2016-10-19 13:46:38 -0700 | [diff] [blame] | 88 | return value; |
| 89 | } |
| 90 | |
Mark D. Roth | af00d8b | 2016-08-23 12:48:16 -0700 | [diff] [blame] | 91 | typedef struct call_data { |
Mark D. Roth | 996e95b | 2016-09-27 10:55:37 -0700 | [diff] [blame] | 92 | int max_send_size; |
| 93 | int max_recv_size; |
Mark D. Roth | af00d8b | 2016-08-23 12:48:16 -0700 | [diff] [blame] | 94 | // Receive closures are chained: we inject this closure as the |
| 95 | // recv_message_ready up-call on transport_stream_op, and remember to |
| 96 | // call our next_recv_message_ready member after handling it. |
| 97 | grpc_closure recv_message_ready; |
| 98 | // Used by recv_message_ready. |
| 99 | grpc_byte_stream** recv_message; |
| 100 | // Original recv_message_ready callback, invoked after our own. |
| 101 | grpc_closure* next_recv_message_ready; |
| 102 | } call_data; |
| 103 | |
| 104 | typedef struct channel_data { |
Mark D. Roth | 996e95b | 2016-09-27 10:55:37 -0700 | [diff] [blame] | 105 | int max_send_size; |
| 106 | int max_recv_size; |
Mark D. Roth | 29a7f40 | 2016-10-19 13:46:38 -0700 | [diff] [blame] | 107 | // Maps path names to message_size_limits structs. |
Craig Tiller | 7c70b6c | 2017-01-23 07:48:42 -0800 | [diff] [blame] | 108 | grpc_slice_hash_table* method_limit_table; |
Mark D. Roth | af00d8b | 2016-08-23 12:48:16 -0700 | [diff] [blame] | 109 | } channel_data; |
| 110 | |
| 111 | // Callback invoked when we receive a message. Here we check the max |
| 112 | // receive message size. |
| 113 | static void recv_message_ready(grpc_exec_ctx* exec_ctx, void* user_data, |
| 114 | grpc_error* error) { |
| 115 | grpc_call_element* elem = user_data; |
| 116 | call_data* calld = elem->call_data; |
Mark D. Roth | 996e95b | 2016-09-27 10:55:37 -0700 | [diff] [blame] | 117 | if (*calld->recv_message != NULL && calld->max_recv_size >= 0 && |
| 118 | (*calld->recv_message)->length > (size_t)calld->max_recv_size) { |
Mark D. Roth | af00d8b | 2016-08-23 12:48:16 -0700 | [diff] [blame] | 119 | char* message_string; |
Mark D. Roth | e425ce6 | 2016-09-23 09:29:12 -0700 | [diff] [blame] | 120 | gpr_asprintf(&message_string, |
| 121 | "Received message larger than max (%u vs. %d)", |
Mark D. Roth | 56e470e | 2016-09-28 13:20:15 -0700 | [diff] [blame] | 122 | (*calld->recv_message)->length, calld->max_recv_size); |
Mark D. Roth | 274c8ed | 2016-10-04 09:21:42 -0700 | [diff] [blame] | 123 | grpc_error* new_error = grpc_error_set_int( |
| 124 | GRPC_ERROR_CREATE(message_string), GRPC_ERROR_INT_GRPC_STATUS, |
| 125 | GRPC_STATUS_INVALID_ARGUMENT); |
| 126 | if (error == GRPC_ERROR_NONE) { |
| 127 | error = new_error; |
| 128 | } else { |
| 129 | error = grpc_error_add_child(error, new_error); |
| 130 | GRPC_ERROR_UNREF(new_error); |
| 131 | } |
Mark D. Roth | af00d8b | 2016-08-23 12:48:16 -0700 | [diff] [blame] | 132 | gpr_free(message_string); |
Mark D. Roth | af00d8b | 2016-08-23 12:48:16 -0700 | [diff] [blame] | 133 | } |
| 134 | // Invoke the next callback. |
Craig Tiller | 91031da | 2016-12-28 15:44:25 -0800 | [diff] [blame] | 135 | grpc_closure_sched(exec_ctx, calld->next_recv_message_ready, error); |
Mark D. Roth | af00d8b | 2016-08-23 12:48:16 -0700 | [diff] [blame] | 136 | } |
| 137 | |
Mark D. Roth | ec39334 | 2016-10-03 13:14:56 -0700 | [diff] [blame] | 138 | // Start transport stream op. |
Mark D. Roth | af00d8b | 2016-08-23 12:48:16 -0700 | [diff] [blame] | 139 | static void start_transport_stream_op(grpc_exec_ctx* exec_ctx, |
| 140 | grpc_call_element* elem, |
| 141 | grpc_transport_stream_op* op) { |
| 142 | call_data* calld = elem->call_data; |
Mark D. Roth | af00d8b | 2016-08-23 12:48:16 -0700 | [diff] [blame] | 143 | // Check max send message size. |
Mark D. Roth | 996e95b | 2016-09-27 10:55:37 -0700 | [diff] [blame] | 144 | if (op->send_message != NULL && calld->max_send_size >= 0 && |
| 145 | op->send_message->length > (size_t)calld->max_send_size) { |
Mark D. Roth | af00d8b | 2016-08-23 12:48:16 -0700 | [diff] [blame] | 146 | char* message_string; |
Mark D. Roth | 996e95b | 2016-09-27 10:55:37 -0700 | [diff] [blame] | 147 | gpr_asprintf(&message_string, "Sent message larger than max (%u vs. %d)", |
| 148 | op->send_message->length, calld->max_send_size); |
Craig Tiller | 7c70b6c | 2017-01-23 07:48:42 -0800 | [diff] [blame] | 149 | grpc_transport_stream_op_finish_with_failure( |
| 150 | exec_ctx, op, grpc_error_set_int(GRPC_ERROR_CREATE(message_string), |
| 151 | GRPC_ERROR_INT_GRPC_STATUS, |
| 152 | GRPC_STATUS_INVALID_ARGUMENT)); |
Mark D. Roth | af00d8b | 2016-08-23 12:48:16 -0700 | [diff] [blame] | 153 | gpr_free(message_string); |
Craig Tiller | 7c70b6c | 2017-01-23 07:48:42 -0800 | [diff] [blame] | 154 | return; |
Mark D. Roth | af00d8b | 2016-08-23 12:48:16 -0700 | [diff] [blame] | 155 | } |
| 156 | // Inject callback for receiving a message. |
Mark D. Roth | a6f1b98 | 2016-08-24 08:16:16 -0700 | [diff] [blame] | 157 | if (op->recv_message_ready != NULL) { |
Mark D. Roth | af00d8b | 2016-08-23 12:48:16 -0700 | [diff] [blame] | 158 | calld->next_recv_message_ready = op->recv_message_ready; |
| 159 | calld->recv_message = op->recv_message; |
| 160 | op->recv_message_ready = &calld->recv_message_ready; |
| 161 | } |
| 162 | // Chain to the next filter. |
| 163 | grpc_call_next_op(exec_ctx, elem, op); |
| 164 | } |
| 165 | |
| 166 | // Constructor for call_data. |
| 167 | static grpc_error* init_call_elem(grpc_exec_ctx* exec_ctx, |
| 168 | grpc_call_element* elem, |
Craig Tiller | c52ba3a | 2017-02-15 22:57:43 -0800 | [diff] [blame] | 169 | const grpc_call_element_args* args) { |
Mark D. Roth | 996e95b | 2016-09-27 10:55:37 -0700 | [diff] [blame] | 170 | channel_data* chand = elem->channel_data; |
Mark D. Roth | af00d8b | 2016-08-23 12:48:16 -0700 | [diff] [blame] | 171 | call_data* calld = elem->call_data; |
| 172 | calld->next_recv_message_ready = NULL; |
Craig Tiller | 91031da | 2016-12-28 15:44:25 -0800 | [diff] [blame] | 173 | grpc_closure_init(&calld->recv_message_ready, recv_message_ready, elem, |
| 174 | grpc_schedule_on_exec_ctx); |
Mark D. Roth | 996e95b | 2016-09-27 10:55:37 -0700 | [diff] [blame] | 175 | // Get max sizes from channel data, then merge in per-method config values. |
| 176 | // Note: Per-method config is only available on the client, so we |
| 177 | // apply the max request size to the send limit and the max response |
| 178 | // size to the receive limit. |
| 179 | calld->max_send_size = chand->max_send_size; |
| 180 | calld->max_recv_size = chand->max_recv_size; |
Mark D. Roth | 29a7f40 | 2016-10-19 13:46:38 -0700 | [diff] [blame] | 181 | if (chand->method_limit_table != NULL) { |
Craig Tiller | a59c16c | 2016-10-31 07:25:01 -0700 | [diff] [blame] | 182 | message_size_limits* limits = grpc_method_config_table_get( |
| 183 | exec_ctx, chand->method_limit_table, args->path); |
Mark D. Roth | 29a7f40 | 2016-10-19 13:46:38 -0700 | [diff] [blame] | 184 | if (limits != NULL) { |
| 185 | if (limits->max_send_size >= 0 && |
| 186 | (limits->max_send_size < calld->max_send_size || |
Mark D. Roth | 996e95b | 2016-09-27 10:55:37 -0700 | [diff] [blame] | 187 | calld->max_send_size < 0)) { |
Mark D. Roth | 29a7f40 | 2016-10-19 13:46:38 -0700 | [diff] [blame] | 188 | calld->max_send_size = limits->max_send_size; |
Mark D. Roth | 996e95b | 2016-09-27 10:55:37 -0700 | [diff] [blame] | 189 | } |
Mark D. Roth | 29a7f40 | 2016-10-19 13:46:38 -0700 | [diff] [blame] | 190 | if (limits->max_recv_size >= 0 && |
| 191 | (limits->max_recv_size < calld->max_recv_size || |
Mark D. Roth | 996e95b | 2016-09-27 10:55:37 -0700 | [diff] [blame] | 192 | calld->max_recv_size < 0)) { |
Mark D. Roth | 29a7f40 | 2016-10-19 13:46:38 -0700 | [diff] [blame] | 193 | calld->max_recv_size = limits->max_recv_size; |
Mark D. Roth | 996e95b | 2016-09-27 10:55:37 -0700 | [diff] [blame] | 194 | } |
| 195 | } |
| 196 | } |
Mark D. Roth | af00d8b | 2016-08-23 12:48:16 -0700 | [diff] [blame] | 197 | return GRPC_ERROR_NONE; |
| 198 | } |
| 199 | |
| 200 | // Destructor for call_data. |
| 201 | static void destroy_call_elem(grpc_exec_ctx* exec_ctx, grpc_call_element* elem, |
| 202 | const grpc_call_final_info* final_info, |
| 203 | void* ignored) {} |
| 204 | |
| 205 | // Constructor for channel_data. |
Mark D. Roth | 5e2566e | 2016-11-18 10:53:13 -0800 | [diff] [blame] | 206 | static grpc_error* init_channel_elem(grpc_exec_ctx* exec_ctx, |
| 207 | grpc_channel_element* elem, |
| 208 | grpc_channel_element_args* args) { |
Mark D. Roth | af00d8b | 2016-08-23 12:48:16 -0700 | [diff] [blame] | 209 | GPR_ASSERT(!args->is_last); |
| 210 | channel_data* chand = elem->channel_data; |
yang-g | e46de3d | 2016-11-17 15:20:02 -0800 | [diff] [blame] | 211 | chand->max_send_size = GRPC_DEFAULT_MAX_SEND_MESSAGE_LENGTH; |
| 212 | chand->max_recv_size = GRPC_DEFAULT_MAX_RECV_MESSAGE_LENGTH; |
Mark D. Roth | af00d8b | 2016-08-23 12:48:16 -0700 | [diff] [blame] | 213 | for (size_t i = 0; i < args->channel_args->num_args; ++i) { |
| 214 | if (strcmp(args->channel_args->args[i].key, |
| 215 | GRPC_ARG_MAX_SEND_MESSAGE_LENGTH) == 0) { |
yang-g | e46de3d | 2016-11-17 15:20:02 -0800 | [diff] [blame] | 216 | const grpc_integer_options options = { |
| 217 | GRPC_DEFAULT_MAX_SEND_MESSAGE_LENGTH, 0, INT_MAX}; |
Mark D. Roth | e425ce6 | 2016-09-23 09:29:12 -0700 | [diff] [blame] | 218 | chand->max_send_size = |
| 219 | grpc_channel_arg_get_integer(&args->channel_args->args[i], options); |
Mark D. Roth | af00d8b | 2016-08-23 12:48:16 -0700 | [diff] [blame] | 220 | } |
| 221 | if (strcmp(args->channel_args->args[i].key, |
| 222 | GRPC_ARG_MAX_RECEIVE_MESSAGE_LENGTH) == 0) { |
yang-g | e46de3d | 2016-11-17 15:20:02 -0800 | [diff] [blame] | 223 | const grpc_integer_options options = { |
| 224 | GRPC_DEFAULT_MAX_RECV_MESSAGE_LENGTH, 0, INT_MAX}; |
Mark D. Roth | e425ce6 | 2016-09-23 09:29:12 -0700 | [diff] [blame] | 225 | chand->max_recv_size = |
| 226 | grpc_channel_arg_get_integer(&args->channel_args->args[i], options); |
Mark D. Roth | af00d8b | 2016-08-23 12:48:16 -0700 | [diff] [blame] | 227 | } |
| 228 | } |
Mark D. Roth | 996e95b | 2016-09-27 10:55:37 -0700 | [diff] [blame] | 229 | // Get method config table from channel args. |
Mark D. Roth | afa8c10 | 2016-09-30 10:56:53 -0700 | [diff] [blame] | 230 | const grpc_arg* channel_arg = |
| 231 | grpc_channel_args_find(args->channel_args, GRPC_ARG_SERVICE_CONFIG); |
Mark D. Roth | 996e95b | 2016-09-27 10:55:37 -0700 | [diff] [blame] | 232 | if (channel_arg != NULL) { |
Mark D. Roth | 9ec28af | 2016-11-03 12:32:39 -0700 | [diff] [blame] | 233 | GPR_ASSERT(channel_arg->type == GRPC_ARG_STRING); |
| 234 | grpc_service_config* service_config = |
| 235 | grpc_service_config_create(channel_arg->value.string); |
Mark D. Roth | bdc58b2 | 2016-11-04 09:25:57 -0700 | [diff] [blame] | 236 | if (service_config != NULL) { |
| 237 | chand->method_limit_table = |
| 238 | grpc_service_config_create_method_config_table( |
Craig Tiller | b28c7e8 | 2016-11-18 10:29:04 -0800 | [diff] [blame] | 239 | exec_ctx, service_config, message_size_limits_create_from_json, |
Mark D. Roth | bdc58b2 | 2016-11-04 09:25:57 -0700 | [diff] [blame] | 240 | &message_size_limits_vtable); |
| 241 | grpc_service_config_destroy(service_config); |
| 242 | } |
Mark D. Roth | 996e95b | 2016-09-27 10:55:37 -0700 | [diff] [blame] | 243 | } |
Mark D. Roth | 5e2566e | 2016-11-18 10:53:13 -0800 | [diff] [blame] | 244 | return GRPC_ERROR_NONE; |
Mark D. Roth | af00d8b | 2016-08-23 12:48:16 -0700 | [diff] [blame] | 245 | } |
| 246 | |
| 247 | // Destructor for channel_data. |
| 248 | static void destroy_channel_elem(grpc_exec_ctx* exec_ctx, |
Mark D. Roth | 996e95b | 2016-09-27 10:55:37 -0700 | [diff] [blame] | 249 | grpc_channel_element* elem) { |
| 250 | channel_data* chand = elem->channel_data; |
Craig Tiller | 7c70b6c | 2017-01-23 07:48:42 -0800 | [diff] [blame] | 251 | grpc_slice_hash_table_unref(exec_ctx, chand->method_limit_table); |
Mark D. Roth | 996e95b | 2016-09-27 10:55:37 -0700 | [diff] [blame] | 252 | } |
Mark D. Roth | af00d8b | 2016-08-23 12:48:16 -0700 | [diff] [blame] | 253 | |
| 254 | const grpc_channel_filter grpc_message_size_filter = { |
| 255 | start_transport_stream_op, |
| 256 | grpc_channel_next_op, |
| 257 | sizeof(call_data), |
| 258 | init_call_elem, |
| 259 | grpc_call_stack_ignore_set_pollset_or_pollset_set, |
| 260 | destroy_call_elem, |
| 261 | sizeof(channel_data), |
| 262 | init_channel_elem, |
| 263 | destroy_channel_elem, |
| 264 | grpc_call_next_get_peer, |
Mark D. Roth | b2d2488 | 2016-10-27 15:44:07 -0700 | [diff] [blame] | 265 | grpc_channel_next_get_info, |
Mark D. Roth | af00d8b | 2016-08-23 12:48:16 -0700 | [diff] [blame] | 266 | "message_size"}; |