GRPC C++  1.50.0
grpc.h
Go to the documentation of this file.
1 /*
2  *
3  * Copyright 2015-2016 gRPC authors.
4  *
5  * Licensed under the Apache License, Version 2.0 (the "License");
6  * you may not use this file except in compliance with the License.
7  * You may obtain a copy of the License at
8  *
9  * http://www.apache.org/licenses/LICENSE-2.0
10  *
11  * Unless required by applicable law or agreed to in writing, software
12  * distributed under the License is distributed on an "AS IS" BASIS,
13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14  * See the License for the specific language governing permissions and
15  * limitations under the License.
16  *
17  */
18 
19 #ifndef GRPC_GRPC_H
20 #define GRPC_GRPC_H
21 
23 
24 #include <stddef.h>
25 
26 #include <grpc/byte_buffer.h>
27 #include <grpc/impl/codegen/connectivity_state.h> // IWYU pragma: export
28 #include <grpc/impl/codegen/grpc_types.h> // IWYU pragma: export
30 #include <grpc/slice.h>
31 #include <grpc/status.h>
32 #include <grpc/support/time.h>
33 
34 #ifdef __cplusplus
35 extern "C" {
36 #endif
37 
47 
50 
59 GRPCAPI void grpc_register_plugin(void (*init)(void), void (*destroy)(void));
60 
69 GRPCAPI void grpc_init(void);
70 
81 GRPCAPI void grpc_shutdown(void);
82 
88 
91 
93 GRPCAPI const char* grpc_version_string(void);
94 
96 GRPCAPI const char* grpc_g_stands_for(void);
97 
102  const grpc_completion_queue_attributes* attributes);
103 
107  void* reserved);
108 
112  void* reserved);
113 
118  grpc_completion_queue_functor* shutdown_callback, void* reserved);
119 
122  const grpc_completion_queue_factory* factory,
123  const grpc_completion_queue_attributes* attributes, void* reserved);
124 
134  gpr_timespec deadline,
135  void* reserved);
136 
149  void* tag, gpr_timespec deadline,
150  void* reserved);
151 
154 #define GRPC_MAX_COMPLETION_QUEUE_PLUCKERS 6
155 
164 
168 
169 /*********** EXPERIMENTAL API ************/
176 
177 /*********** EXPERIMENTAL API ************/
184  grpc_completion_queue* cq, void** tag, int* ok);
185 
188  grpc_channel* channel, int try_to_connect);
189 
194  grpc_channel* channel);
195 
202  grpc_channel* channel, grpc_connectivity_state last_observed_state,
203  gpr_timespec deadline, grpc_completion_queue* cq, void* tag);
204 
207 
216  grpc_channel* channel, grpc_call* parent_call, uint32_t propagation_mask,
217  grpc_completion_queue* completion_queue, grpc_slice method,
218  const grpc_slice* host, gpr_timespec deadline, void* reserved);
219 
224  const char* method, const char* host,
225  void* reserved);
226 
230  grpc_channel* channel, grpc_call* parent_call, uint32_t propagation_mask,
231  grpc_completion_queue* completion_queue, void* registered_call_handle,
232  gpr_timespec deadline, void* reserved);
233 
236 GRPCAPI void* grpc_call_arena_alloc(grpc_call* call, size_t size);
237 
259  const grpc_op* ops, size_t nops,
260  void* tag, void* reserved);
261 
271 
272 struct census_context;
273 
277  struct census_context* context);
278 
281 
285 
291  const grpc_channel_info* channel_info);
292 
297 
305 
310 
317 
322 
330 GRPCAPI grpc_channel* grpc_channel_create(const char* target,
332  const grpc_channel_args* args);
333 
336  const char* target, grpc_status_code error_code, const char* error_message);
337 
340 
352 GRPCAPI grpc_call_error grpc_call_cancel(grpc_call* call, void* reserved);
353 
365  grpc_status_code status,
366  const char* description,
367  void* reserved);
368 
369 /* Returns whether or not the call's receive message operation failed because of
370  * an error (as opposed to a graceful end-of-stream) */
372 
375 GRPCAPI void grpc_call_ref(grpc_call* call);
376 
379 GRPCAPI void grpc_call_unref(grpc_call* call);
380 
390  grpc_server* server, grpc_call** call, grpc_call_details* details,
391  grpc_metadata_array* request_metadata,
392  grpc_completion_queue* cq_bound_to_call,
393  grpc_completion_queue* cq_for_notification, void* tag_new);
394 
396 typedef enum {
402 
411  grpc_server* server, const char* method, const char* host,
413  uint32_t flags);
414 
419  grpc_server* server, void* registered_method, grpc_call** call,
420  gpr_timespec* deadline, grpc_metadata_array* request_metadata,
421  grpc_byte_buffer** optional_payload,
422  grpc_completion_queue* cq_bound_to_call,
423  grpc_completion_queue* cq_for_notification, void* tag_new);
424 
433  void* reserved);
434 
441  void* reserved);
442 
443 // More members might be added in later, so users should take care to memset
444 // this to 0 before using it.
445 typedef struct {
447  const char* error_message;
449 
450 // There might be more methods added later, so users should take care to memset
451 // this to 0 before using it.
452 typedef struct {
453  void (*on_serving_status_update)(void* user_data, const char* uri,
455  void* user_data;
457 
459 
462  grpc_server_xds_status_notifier notifier, const grpc_channel_args* args);
463 
466  grpc_server_config_fetcher* config_fetcher);
467 
471  grpc_server* server, grpc_server_config_fetcher* config_fetcher);
472 
476 GRPCAPI int grpc_server_add_http2_port(grpc_server* server, const char* addr,
477  grpc_server_credentials* creds);
478 
481 
491  void* tag);
492 
496 
502 
511 GRPCAPI int grpc_tracer_set_enabled(const char* name, int enabled);
512 
515 
519 
522 
525 
528 
531 
534 
537  size_t new_size);
538 
541  grpc_resource_quota* resource_quota, int new_max_threads);
542 
546 
550 
551 /************* CHANNELZ API *************/
565 /* Gets all root channels (i.e. channels the application has directly
566  created). This does not include subchannels nor non-top level channels.
567  The returned string is allocated and must be freed by the application. */
568 GRPCAPI char* grpc_channelz_get_top_channels(intptr_t start_channel_id);
569 
570 /* Gets all servers that exist in the process. */
571 GRPCAPI char* grpc_channelz_get_servers(intptr_t start_server_id);
572 
573 /* Returns a single Server, or else a NOT_FOUND code. */
574 GRPCAPI char* grpc_channelz_get_server(intptr_t server_id);
575 
576 /* Gets all server sockets that exist in the server. */
577 GRPCAPI char* grpc_channelz_get_server_sockets(intptr_t server_id,
578  intptr_t start_socket_id,
579  intptr_t max_results);
580 
581 /* Returns a single Channel, or else a NOT_FOUND code. The returned string
582  is allocated and must be freed by the application. */
583 GRPCAPI char* grpc_channelz_get_channel(intptr_t channel_id);
584 
585 /* Returns a single Subchannel, or else a NOT_FOUND code. The returned string
586  is allocated and must be freed by the application. */
587 GRPCAPI char* grpc_channelz_get_subchannel(intptr_t subchannel_id);
588 
589 /* Returns a single Socket, or else a NOT_FOUND code. The returned string
590  is allocated and must be freed by the application. */
591 GRPCAPI char* grpc_channelz_get_socket(intptr_t socket_id);
592 
600 
601 #ifdef __cplusplus
602 }
603 #endif
604 
605 #endif /* GRPC_GRPC_H */
grpc_channelz_get_top_channels
GRPCAPI char * grpc_channelz_get_top_channels(intptr_t start_channel_id)
Channelz is under active development.
census_context
struct census_context census_context
A Census Context is a handle used by Census to represent the current tracing and stats collection inf...
Definition: census.h:34
GRPC_SRM_PAYLOAD_NONE
@ GRPC_SRM_PAYLOAD_NONE
Don't try to read the payload.
Definition: grpc.h:398
grpc_channel_support_connectivity_watcher
GRPCAPI int grpc_channel_support_connectivity_watcher(grpc_channel *channel)
Check whether a grpc channel supports connectivity watcher.
grpc_call_error
grpc_call_error
Result of a grpc call.
Definition: grpc_types.h:470
grpc_call_cancel
GRPCAPI grpc_call_error grpc_call_cancel(grpc_call *call, void *reserved)
Error handling for grpc_call Most grpc_call functions return a grpc_error.
grpc_call_details_destroy
GRPCAPI void grpc_call_details_destroy(grpc_call_details *details)
grpc_call_details_init
GRPCAPI void grpc_call_details_init(grpc_call_details *details)
grpc_call_arena_alloc
GRPCAPI void * grpc_call_arena_alloc(grpc_call *call, size_t size)
Allocate memory in the grpc_call arena: this memory is automatically discarded at call completion.
grpc_channel_get_info
GRPCAPI void grpc_channel_get_info(grpc_channel *channel, const grpc_channel_info *channel_info)
Request info about the channel.
grpc_completion_queue_create_for_callback
GRPCAPI grpc_completion_queue * grpc_completion_queue_create_for_callback(grpc_completion_queue_functor *shutdown_callback, void *reserved)
Helper function to create a completion queue with grpc_cq_completion_type of GRPC_CQ_CALLBACK and grp...
grpc_status_code
grpc_status_code
Definition: status.h:28
grpc_completion_queue_create_for_pluck
GRPCAPI grpc_completion_queue * grpc_completion_queue_create_for_pluck(void *reserved)
Helper function to create a completion queue with grpc_cq_completion_type of GRPC_CQ_PLUCK and grpc_c...
grpc_resource_quota
struct grpc_resource_quota grpc_resource_quota
Definition: grpc_types.h:730
grpc_channel_reset_connect_backoff
GRPCAPI void grpc_channel_reset_connect_backoff(grpc_channel *channel)
EXPERIMENTAL.
grpc_shutdown_blocking
GRPCAPI void grpc_shutdown_blocking(void)
DEPRECATED.
grpc_call_failed_before_recv_message
GRPCAPI int grpc_call_failed_before_recv_message(const grpc_call *c)
grpc_census_call_set_context
GRPCAPI void grpc_census_call_set_context(grpc_call *call, struct census_context *context)
Set census context for a call; Must be called before first call to grpc_call_start_batch().
grpc_header_key_is_legal
GRPCAPI int grpc_header_key_is_legal(grpc_slice slice)
Check whether a metadata key is legal (will be accepted by core)
grpc_call_get_peer
GRPCAPI char * grpc_call_get_peer(grpc_call *call)
Returns a newly allocated string representing the endpoint to which this call is communicating with.
grpc_metadata_array
Definition: grpc_types.h:582
grpc_call_details
Definition: grpc_types.h:588
grpc_channelz_get_server
GRPCAPI char * grpc_channelz_get_server(intptr_t server_id)
grpc_channel_check_connectivity_state
GRPCAPI grpc_connectivity_state grpc_channel_check_connectivity_state(grpc_channel *channel, int try_to_connect)
Check the connectivity state of a channel.
grpc_lame_client_channel_create
GRPCAPI grpc_channel * grpc_lame_client_channel_create(const char *target, grpc_status_code error_code, const char *error_message)
Create a lame client: this client fails every operation attempted on it.
grpc_completion_queue_thread_local_cache_flush
GRPCAPI int grpc_completion_queue_thread_local_cache_flush(grpc_completion_queue *cq, void **tag, int *ok)
Flushes the thread local cache for cq.
grpc_server_config_fetcher_destroy
GRPCAPI void grpc_server_config_fetcher_destroy(grpc_server_config_fetcher *config_fetcher)
EXPERIMENTAL.
propagation_bits.h
grpc_server_create
GRPCAPI grpc_server * grpc_server_create(const grpc_channel_args *args, void *reserved)
Create a server.
grpc_channel_get_target
GRPCAPI char * grpc_channel_get_target(grpc_channel *channel)
Return a newly allocated string representing the target a channel was created for.
grpc_server_register_completion_queue
GRPCAPI void grpc_server_register_completion_queue(grpc_server *server, grpc_completion_queue *cq, void *reserved)
Register a completion queue with the server.
grpc_resource_quota_create
GRPCAPI grpc_resource_quota * grpc_resource_quota_create(const char *trace_name)
Create a buffer pool.
grpc_server_request_registered_call
GRPCAPI grpc_call_error grpc_server_request_registered_call(grpc_server *server, void *registered_method, grpc_call **call, gpr_timespec *deadline, grpc_metadata_array *request_metadata, grpc_byte_buffer **optional_payload, grpc_completion_queue *cq_bound_to_call, grpc_completion_queue *cq_for_notification, void *tag_new)
Request notification of a new pre-registered call.
grpc_server_config_fetcher
struct grpc_server_config_fetcher grpc_server_config_fetcher
Definition: grpc.h:458
grpc_call_ref
GRPCAPI void grpc_call_ref(grpc_call *call)
Ref a call.
grpc_completion_queue_create
GRPCAPI grpc_completion_queue * grpc_completion_queue_create(const grpc_completion_queue_factory *factory, const grpc_completion_queue_attributes *attributes, void *reserved)
Create a completion queue.
grpc_arg_pointer_vtable
Definition: grpc_types.h:85
grpc_channel_args
An array of arguments that can be passed around.
Definition: grpc_types.h:132
grpc_server_register_method_payload_handling
grpc_server_register_method_payload_handling
How to handle payloads for a registered method.
Definition: grpc.h:396
grpc_channelz_get_servers
GRPCAPI char * grpc_channelz_get_servers(intptr_t start_server_id)
grpc_authorization_policy_provider_arg_vtable
const GRPCAPI grpc_arg_pointer_vtable * grpc_authorization_policy_provider_arg_vtable(void)
EXPERIMENTAL - Subject to change.
grpc_serving_status_update::error_message
const char * error_message
Definition: grpc.h:447
grpc_channel_register_call
GRPCAPI void * grpc_channel_register_call(grpc_channel *channel, const char *method, const char *host, void *reserved)
Pre-register a method/host pair on a channel.
grpc_types.h
grpc_header_nonbin_value_is_legal
GRPCAPI int grpc_header_nonbin_value_is_legal(grpc_slice slice)
Check whether a non-binary metadata value is legal (will be accepted by core)
status.h
grpc_metadata_array_destroy
GRPCAPI void grpc_metadata_array_destroy(grpc_metadata_array *array)
grpc_completion_queue_thread_local_cache_init
GRPCAPI void grpc_completion_queue_thread_local_cache_init(grpc_completion_queue *cq)
Initializes a thread local cache for cq.
grpc_server_request_call
GRPCAPI grpc_call_error grpc_server_request_call(grpc_server *server, grpc_call **call, grpc_call_details *details, grpc_metadata_array *request_metadata, grpc_completion_queue *cq_bound_to_call, grpc_completion_queue *cq_for_notification, void *tag_new)
Request notification of a new call.
grpc_version_string
const GRPCAPI char * grpc_version_string(void)
Return a string representing the current version of grpc.
grpc_channelz_get_socket
GRPCAPI char * grpc_channelz_get_socket(intptr_t socket_id)
grpc_channel_num_external_connectivity_watchers
GRPCAPI int grpc_channel_num_external_connectivity_watchers(grpc_channel *channel)
Number of active "external connectivity state watchers" attached to a channel.
grpc_channel_credentials
struct grpc_channel_credentials grpc_channel_credentials
— grpc_channel_credentials object.
Definition: grpc.h:304
grpc_resource_quota_set_max_threads
GRPCAPI void grpc_resource_quota_set_max_threads(grpc_resource_quota *resource_quota, int new_max_threads)
Update the size of the maximum number of threads allowed.
grpc_server_config_fetcher_xds_create
GRPCAPI grpc_server_config_fetcher * grpc_server_config_fetcher_xds_create(grpc_server_xds_status_notifier notifier, const grpc_channel_args *args)
EXPERIMENTAL.
grpc_server_credentials_release
GRPCAPI void grpc_server_credentials_release(grpc_server_credentials *creds)
Releases a server_credentials object.
grpc_resource_quota_arg_vtable
const GRPCAPI grpc_arg_pointer_vtable * grpc_resource_quota_arg_vtable(void)
Fetch a vtable for a grpc_channel_arg that points to a grpc_resource_quota.
grpc_server_add_http2_port
GRPCAPI int grpc_server_add_http2_port(grpc_server *server, const char *addr, grpc_server_credentials *creds)
Add a HTTP2 over an encrypted link over tcp listener.
grpc_completion_queue_factory_lookup
const GRPCAPI grpc_completion_queue_factory * grpc_completion_queue_factory_lookup(const grpc_completion_queue_attributes *attributes)
Returns the completion queue factory based on the attributes.
grpc_call_unref
GRPCAPI void grpc_call_unref(grpc_call *call)
Unref a call.
grpc_event
The result of an operation.
Definition: grpc_types.h:567
grpc_connectivity_state
grpc_connectivity_state
Connectivity state of a channel.
Definition: connectivity_state.h:30
grpc_serving_status_update
Definition: grpc.h:445
grpc_call
struct grpc_call grpc_call
A Call represents an RPC.
Definition: grpc_types.h:70
grpc_byte_buffer
Definition: grpc_types.h:43
connectivity_state.h
grpc_channelz_get_subchannel
GRPCAPI char * grpc_channelz_get_subchannel(intptr_t subchannel_id)
grpc_op
Operation data: one field for each op type (except SEND_CLOSE_FROM_CLIENT which has no arguments)
Definition: grpc_types.h:641
grpc_slice
A grpc_slice s, if initialized, represents the byte range s.bytes[0..s.length-1].
Definition: slice.h:65
grpc_server
struct grpc_server grpc_server
A server listens to some port and responds to request calls.
Definition: grpc_types.h:65
grpc_server_destroy
GRPCAPI void grpc_server_destroy(grpc_server *server)
Destroy a server.
grpc_register_plugin
GRPCAPI void grpc_register_plugin(void(*init)(void), void(*destroy)(void))
Registers a plugin to be initialized and destroyed with the library.
grpc_completion_queue_attributes
Definition: grpc_types.h:792
grpc_server_cancel_all_calls
GRPCAPI void grpc_server_cancel_all_calls(grpc_server *server)
Cancel all in-progress calls.
grpc_channel_create_registered_call
GRPCAPI grpc_call * grpc_channel_create_registered_call(grpc_channel *channel, grpc_call *parent_call, uint32_t propagation_mask, grpc_completion_queue *completion_queue, void *registered_call_handle, gpr_timespec deadline, void *reserved)
Create a call given a handle returned from grpc_channel_register_call.
grpc_channel_credentials_release
GRPCAPI void grpc_channel_credentials_release(grpc_channel_credentials *creds)
Releases a channel credentials object.
grpc_completion_queue_factory
struct grpc_completion_queue_factory grpc_completion_queue_factory
The completion queue factory structure is opaque to the callers of grpc.
Definition: grpc_types.h:812
grpc_channel_create_call
GRPCAPI grpc_call * grpc_channel_create_call(grpc_channel *channel, grpc_call *parent_call, uint32_t propagation_mask, grpc_completion_queue *completion_queue, grpc_slice method, const grpc_slice *host, gpr_timespec deadline, void *reserved)
Create a call given a grpc_channel, in order to call 'method'.
byte_buffer.h
grpc_channelz_get_channel
GRPCAPI char * grpc_channelz_get_channel(intptr_t channel_id)
grpc_completion_queue_pluck
GRPCAPI grpc_event grpc_completion_queue_pluck(grpc_completion_queue *cq, void *tag, gpr_timespec deadline, void *reserved)
Blocks until an event with tag 'tag' is available, the completion queue is being shutdown or deadline...
grpc_channel_create
GRPCAPI grpc_channel * grpc_channel_create(const char *target, grpc_channel_credentials *creds, const grpc_channel_args *args)
Creates a secure channel using the passed-in credentials.
grpc_is_initialized
GRPCAPI int grpc_is_initialized(void)
EXPERIMENTAL.
slice.h
grpc_resource_quota_resize
GRPCAPI void grpc_resource_quota_resize(grpc_resource_quota *resource_quota, size_t new_size)
Update the size of a buffer pool.
grpc_server_xds_status_notifier
Definition: grpc.h:452
grpc_completion_queue_destroy
GRPCAPI void grpc_completion_queue_destroy(grpc_completion_queue *cq)
Destroy a completion queue.
grpc_server_xds_status_notifier::user_data
void * user_data
Definition: grpc.h:455
grpc_resource_quota_unref
GRPCAPI void grpc_resource_quota_unref(grpc_resource_quota *resource_quota)
Drop a reference to a buffer pool.
grpc_channelz_get_server_sockets
GRPCAPI char * grpc_channelz_get_server_sockets(intptr_t server_id, intptr_t start_socket_id, intptr_t max_results)
grpc_serving_status_update::code
grpc_status_code code
Definition: grpc.h:446
grpc_server_shutdown_and_notify
GRPCAPI void grpc_server_shutdown_and_notify(grpc_server *server, grpc_completion_queue *cq, void *tag)
Begin shutting down a server.
grpc_is_binary_header
GRPCAPI int grpc_is_binary_header(grpc_slice slice)
Check whether a metadata key corresponds to a binary value.
grpc_completion_queue
struct grpc_completion_queue grpc_completion_queue
Completion Queues enable notification of the completion of asynchronous actions.
Definition: grpc_types.h:59
grpc_completion_queue_next
GRPCAPI grpc_event grpc_completion_queue_next(grpc_completion_queue *cq, gpr_timespec deadline, void *reserved)
Blocks until an event is available, the completion queue is being shut down, or deadline is reached.
grpc_completion_queue_shutdown
GRPCAPI void grpc_completion_queue_shutdown(grpc_completion_queue *cq)
Begin destruction of a completion queue.
grpc_completion_queue_functor
Specifies an interface class to be used as a tag for callback-based completion queues.
Definition: grpc_types.h:774
grpc_channel_destroy
GRPCAPI void grpc_channel_destroy(grpc_channel *channel)
Close and destroy a grpc channel.
grpc_call_error_to_string
const GRPCAPI char * grpc_call_error_to_string(grpc_call_error error)
Convert grpc_call_error values to a string.
grpc_channel
struct grpc_channel grpc_channel
The Channel interface allows creation of Call objects.
Definition: grpc_types.h:62
GRPCAPI
#define GRPCAPI
Definition: port_platform.h:656
grpc_channel_watch_connectivity_state
GRPCAPI void grpc_channel_watch_connectivity_state(grpc_channel *channel, grpc_connectivity_state last_observed_state, gpr_timespec deadline, grpc_completion_queue *cq, void *tag)
Watch for a change in connectivity state.
grpc_server_set_config_fetcher
GRPCAPI void grpc_server_set_config_fetcher(grpc_server *server, grpc_server_config_fetcher *config_fetcher)
EXPERIMENTAL.
GRPC_SRM_PAYLOAD_READ_INITIAL_BYTE_BUFFER
@ GRPC_SRM_PAYLOAD_READ_INITIAL_BYTE_BUFFER
Read the initial payload as a byte buffer.
Definition: grpc.h:400
grpc_dump_xds_configs
GRPCAPI grpc_slice grpc_dump_xds_configs(void)
EXPERIMENTAL.
grpc_tracer_set_enabled
GRPCAPI int grpc_tracer_set_enabled(const char *name, int enabled)
Enable or disable a tracer.
grpc_resource_quota_ref
GRPCAPI void grpc_resource_quota_ref(grpc_resource_quota *resource_quota)
Add a reference to a buffer pool.
grpc_completion_queue_create_for_next
GRPCAPI grpc_completion_queue * grpc_completion_queue_create_for_next(void *reserved)
Helper function to create a completion queue with grpc_cq_completion_type of GRPC_CQ_NEXT and grpc_cq...
grpc_census_call_get_context
GRPCAPI struct census_context * grpc_census_call_get_context(grpc_call *call)
Retrieve the calls current census context.
gpr_timespec
Analogous to struct timespec.
Definition: gpr_types.h:50
grpc_server_credentials
struct grpc_server_credentials grpc_server_credentials
— grpc_server_credentials object.
Definition: grpc.h:316
grpc_init
GRPCAPI void grpc_init(void)
Initialize the grpc library.
grpc_server_start
GRPCAPI void grpc_server_start(grpc_server *server)
Start a server - tells all listeners to start listening.
grpc_g_stands_for
const GRPCAPI char * grpc_g_stands_for(void)
Return a string specifying what the 'g' in gRPC stands for.
grpc_channel_info
Information requested from the channel.
Definition: grpc_types.h:721
grpc_call_start_batch
GRPCAPI grpc_call_error grpc_call_start_batch(grpc_call *call, const grpc_op *ops, size_t nops, void *tag, void *reserved)
Start a batch of operations defined in the array ops; when complete, post a completion of type 'tag' ...
grpc_shutdown
GRPCAPI void grpc_shutdown(void)
Shut down the grpc library.
grpc_call_cancel_with_status
GRPCAPI grpc_call_error grpc_call_cancel_with_status(grpc_call *call, grpc_status_code status, const char *description, void *reserved)
Cancel an RPC.
time.h
grpc_metadata_array_init
GRPCAPI void grpc_metadata_array_init(grpc_metadata_array *array)
grpc_server_register_method
GRPCAPI void * grpc_server_register_method(grpc_server *server, const char *method, const char *host, grpc_server_register_method_payload_handling payload_handling, uint32_t flags)
Registers a method in the server.
port_platform.h