diff options
author | Joel Galenson <jgalenson@google.com> | 2021-04-02 14:59:08 -0700 |
---|---|---|
committer | Joel Galenson <jgalenson@google.com> | 2021-04-02 15:06:51 -0700 |
commit | 23c9e5ee44d2855e2bffb5ffe6dd0f3021be3ce2 (patch) | |
tree | 9ff33245fc40085284a777f947a77028b4a715f5 /grpc/spm-core-include | |
parent | ac4642dab790b53d059713fb3d7ee44dbd605191 (diff) | |
download | grpcio-sys-23c9e5ee44d2855e2bffb5ffe6dd0f3021be3ce2.tar.gz |
Upgrade rust/crates/grpcio-sys to 0.8.1
Test: make
Change-Id: I333e35e7d00abaa92ea6beb00e9cf5b85840998f
Diffstat (limited to 'grpc/spm-core-include')
58 files changed, 6454 insertions, 0 deletions
diff --git a/grpc/spm-core-include/grpc/byte_buffer.h b/grpc/spm-core-include/grpc/byte_buffer.h new file mode 100644 index 00000000..ee740f47 --- /dev/null +++ b/grpc/spm-core-include/grpc/byte_buffer.h @@ -0,0 +1,27 @@ +/* + * + * Copyright 2015 gRPC authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#ifndef GRPC_BYTE_BUFFER_H +#define GRPC_BYTE_BUFFER_H + +#include <grpc/support/port_platform.h> + +#include <grpc/impl/codegen/byte_buffer.h> +#include <grpc/slice_buffer.h> + +#endif /* GRPC_BYTE_BUFFER_H */ diff --git a/grpc/spm-core-include/grpc/byte_buffer_reader.h b/grpc/spm-core-include/grpc/byte_buffer_reader.h new file mode 100644 index 00000000..15e06cad --- /dev/null +++ b/grpc/spm-core-include/grpc/byte_buffer_reader.h @@ -0,0 +1,26 @@ +/* + * + * Copyright 2015 gRPC authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#ifndef GRPC_BYTE_BUFFER_READER_H +#define GRPC_BYTE_BUFFER_READER_H + +#include <grpc/support/port_platform.h> + +#include <grpc/impl/codegen/byte_buffer_reader.h> + +#endif /* GRPC_BYTE_BUFFER_READER_H */ diff --git a/grpc/spm-core-include/grpc/census.h b/grpc/spm-core-include/grpc/census.h new file mode 100644 index 00000000..4894f1c0 --- /dev/null +++ b/grpc/spm-core-include/grpc/census.h @@ -0,0 +1,40 @@ +/* + * + * Copyright 2015-2016 gRPC authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#ifndef GRPC_CENSUS_H +#define GRPC_CENSUS_H + +#include <grpc/support/port_platform.h> + +#include <grpc/grpc.h> + +#ifdef __cplusplus +extern "C" { +#endif + +/** + A Census Context is a handle used by Census to represent the current tracing + and stats collection information. Contexts should be propagated across RPC's + (this is the responsibility of the local RPC system). */ +typedef struct census_context census_context; + +#ifdef __cplusplus +} +#endif + +#endif /* GRPC_CENSUS_H */ diff --git a/grpc/spm-core-include/grpc/compression.h b/grpc/spm-core-include/grpc/compression.h new file mode 100644 index 00000000..17695664 --- /dev/null +++ b/grpc/spm-core-include/grpc/compression.h @@ -0,0 +1,75 @@ +/* + * + * Copyright 2015 gRPC authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#ifndef GRPC_COMPRESSION_H +#define GRPC_COMPRESSION_H + +#include <grpc/impl/codegen/port_platform.h> + +#include <stdlib.h> + +#include <grpc/impl/codegen/compression_types.h> +#include <grpc/slice.h> + +#ifdef __cplusplus +extern "C" { +#endif + +/** Return if an algorithm is message compression algorithm. */ +GRPCAPI int grpc_compression_algorithm_is_message( + grpc_compression_algorithm algorithm); + +/** Return if an algorithm is stream compression algorithm. */ +GRPCAPI int grpc_compression_algorithm_is_stream( + grpc_compression_algorithm algorithm); + +/** Parses the \a slice as a grpc_compression_algorithm instance and updating \a + * algorithm. Returns 1 upon success, 0 otherwise. */ +GRPCAPI int grpc_compression_algorithm_parse( + grpc_slice name, grpc_compression_algorithm* algorithm); + +/** Updates \a name with the encoding name corresponding to a valid \a + * algorithm. Note that \a name is statically allocated and must *not* be freed. + * Returns 1 upon success, 0 otherwise. */ +GRPCAPI int grpc_compression_algorithm_name( + grpc_compression_algorithm algorithm, const char** name); + +/** Returns the compression algorithm corresponding to \a level for the + * compression algorithms encoded in the \a accepted_encodings bitset.*/ +GRPCAPI grpc_compression_algorithm grpc_compression_algorithm_for_level( + grpc_compression_level level, uint32_t accepted_encodings); + +GRPCAPI void grpc_compression_options_init(grpc_compression_options* opts); + +/** Mark \a algorithm as enabled in \a opts. */ +GRPCAPI void grpc_compression_options_enable_algorithm( + grpc_compression_options* opts, grpc_compression_algorithm algorithm); + +/** Mark \a algorithm as disabled in \a opts. */ +GRPCAPI void grpc_compression_options_disable_algorithm( + grpc_compression_options* opts, grpc_compression_algorithm algorithm); + +/** Returns true if \a algorithm is marked as enabled in \a opts. */ +GRPCAPI int grpc_compression_options_is_algorithm_enabled( + const grpc_compression_options* opts, grpc_compression_algorithm algorithm); + +#ifdef __cplusplus +} +#endif + +#endif /* GRPC_COMPRESSION_H */ diff --git a/grpc/spm-core-include/grpc/fork.h b/grpc/spm-core-include/grpc/fork.h new file mode 100644 index 00000000..26f9df98 --- /dev/null +++ b/grpc/spm-core-include/grpc/fork.h @@ -0,0 +1,26 @@ +/* + * + * Copyright 2017 gRPC authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#ifndef GRPC_FORK_H +#define GRPC_FORK_H + +#include <grpc/support/port_platform.h> + +#include <grpc/impl/codegen/fork.h> + +#endif /* GRPC_FORK_H */ diff --git a/grpc/spm-core-include/grpc/grpc.h b/grpc/spm-core-include/grpc/grpc.h new file mode 100644 index 00000000..09bb1061 --- /dev/null +++ b/grpc/spm-core-include/grpc/grpc.h @@ -0,0 +1,548 @@ +/* + * + * Copyright 2015-2016 gRPC authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#ifndef GRPC_GRPC_H +#define GRPC_GRPC_H + +#include <grpc/support/port_platform.h> + +#include <grpc/status.h> + +#include <grpc/byte_buffer.h> +#include <grpc/impl/codegen/connectivity_state.h> +#include <grpc/impl/codegen/grpc_types.h> +#include <grpc/impl/codegen/propagation_bits.h> +#include <grpc/slice.h> +#include <grpc/support/time.h> +#include <stddef.h> + +#ifdef __cplusplus +extern "C" { +#endif + +/*! \mainpage GRPC Core + * + * The GRPC Core library is a low-level library designed to be wrapped by higher + * level libraries. The top-level API is provided in grpc.h. Security related + * functionality lives in grpc_security.h. + */ + +GRPCAPI void grpc_metadata_array_init(grpc_metadata_array* array); +GRPCAPI void grpc_metadata_array_destroy(grpc_metadata_array* array); + +GRPCAPI void grpc_call_details_init(grpc_call_details* details); +GRPCAPI void grpc_call_details_destroy(grpc_call_details* details); + +/** Registers a plugin to be initialized and destroyed with the library. + + The \a init and \a destroy functions will be invoked as part of + \a grpc_init() and \a grpc_shutdown(), respectively. + Note that these functions can be invoked an arbitrary number of times + (and hence so will \a init and \a destroy). + It is safe to pass NULL to either argument. Plugins are destroyed in + the reverse order they were initialized. */ +GRPCAPI void grpc_register_plugin(void (*init)(void), void (*destroy)(void)); + +/** Initialize the grpc library. + + After it's called, a matching invocation to grpc_shutdown() is expected. + + It is not safe to call any other grpc functions before calling this. + (To avoid overhead, little checking is done, and some things may work. We + do not warrant that they will continue to do so in future revisions of this + library). */ +GRPCAPI void grpc_init(void); + +/** Shut down the grpc library. + + Before it's called, there should haven been a matching invocation to + grpc_init(). + + The last call to grpc_shutdown will initiate cleaning up of grpc library + internals, which can happen in another thread. Once the clean-up is done, + no memory is used by grpc, nor are any instructions executing within the + grpc library. Prior to calling, all application owned grpc objects must + have been destroyed. */ +GRPCAPI void grpc_shutdown(void); + +/** EXPERIMENTAL. Returns 1 if the grpc library has been initialized. + TODO(ericgribkoff) Decide if this should be promoted to non-experimental as + part of stabilizing the fork support API, as tracked in + https://github.com/grpc/grpc/issues/15334 */ +GRPCAPI int grpc_is_initialized(void); + +/** DEPRECATED. Recommend to use grpc_shutdown only */ +GRPCAPI void grpc_shutdown_blocking(void); + +/** Return a string representing the current version of grpc */ +GRPCAPI const char* grpc_version_string(void); + +/** Return a string specifying what the 'g' in gRPC stands for */ +GRPCAPI const char* grpc_g_stands_for(void); + +/** Returns the completion queue factory based on the attributes. MAY return a + NULL if no factory can be found */ +GRPCAPI const grpc_completion_queue_factory* +grpc_completion_queue_factory_lookup( + const grpc_completion_queue_attributes* attributes); + +/** Helper function to create a completion queue with grpc_cq_completion_type + of GRPC_CQ_NEXT and grpc_cq_polling_type of GRPC_CQ_DEFAULT_POLLING */ +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_PLUCK and grpc_cq_polling_type of GRPC_CQ_DEFAULT_POLLING */ +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_CALLBACK and grpc_cq_polling_type of GRPC_CQ_DEFAULT_POLLING. + This function is experimental. */ +GRPCAPI grpc_completion_queue* grpc_completion_queue_create_for_callback( + grpc_experimental_completion_queue_functor* shutdown_callback, + void* reserved); + +/** Create a completion queue */ +GRPCAPI grpc_completion_queue* grpc_completion_queue_create( + const grpc_completion_queue_factory* factory, + const grpc_completion_queue_attributes* attributes, void* reserved); + +/** Blocks until an event is available, the completion queue is being shut down, + or deadline is reached. + + Returns a grpc_event with type GRPC_QUEUE_TIMEOUT on timeout, + otherwise a grpc_event describing the event that occurred. + + Callers must not call grpc_completion_queue_next and + grpc_completion_queue_pluck simultaneously on the same completion queue. */ +GRPCAPI grpc_event grpc_completion_queue_next(grpc_completion_queue* cq, + gpr_timespec deadline, + void* reserved); + +/** Blocks until an event with tag 'tag' is available, the completion queue is + being shutdown or deadline is reached. + + Returns a grpc_event with type GRPC_QUEUE_TIMEOUT on timeout, + otherwise a grpc_event describing the event that occurred. + + Callers must not call grpc_completion_queue_next and + grpc_completion_queue_pluck simultaneously on the same completion queue. + + Completion queues support a maximum of GRPC_MAX_COMPLETION_QUEUE_PLUCKERS + concurrently executing plucks at any time. */ +GRPCAPI grpc_event grpc_completion_queue_pluck(grpc_completion_queue* cq, + void* tag, gpr_timespec deadline, + void* reserved); + +/** Maximum number of outstanding grpc_completion_queue_pluck executions per + completion queue */ +#define GRPC_MAX_COMPLETION_QUEUE_PLUCKERS 6 + +/** Begin destruction of a completion queue. Once all possible events are + drained then grpc_completion_queue_next will start to produce + GRPC_QUEUE_SHUTDOWN events only. At that point it's safe to call + grpc_completion_queue_destroy. + + After calling this function applications should ensure that no + NEW work is added to be published on this completion queue. */ +GRPCAPI void grpc_completion_queue_shutdown(grpc_completion_queue* cq); + +/** Destroy a completion queue. The caller must ensure that the queue is + drained and no threads are executing grpc_completion_queue_next */ +GRPCAPI void grpc_completion_queue_destroy(grpc_completion_queue* cq); + +/*********** EXPERIMENTAL API ************/ +/** Initializes a thread local cache for \a cq. + * grpc_flush_cq_tls_cache() MUST be called on the same thread, + * with the same cq. + */ +GRPCAPI void grpc_completion_queue_thread_local_cache_init( + grpc_completion_queue* cq); + +/*********** EXPERIMENTAL API ************/ +/** Flushes the thread local cache for \a cq. + * Returns 1 if there was contents in the cache. If there was an event + * in \a cq tls cache, its tag is placed in tag, and ok is set to the + * event success. + */ +GRPCAPI int grpc_completion_queue_thread_local_cache_flush( + grpc_completion_queue* cq, void** tag, int* ok); + +/** Check the connectivity state of a channel. */ +GRPCAPI grpc_connectivity_state grpc_channel_check_connectivity_state( + grpc_channel* channel, int try_to_connect); + +/** Number of active "external connectivity state watchers" attached to a + * channel. + * Useful for testing. **/ +GRPCAPI int grpc_channel_num_external_connectivity_watchers( + grpc_channel* channel); + +/** Watch for a change in connectivity state. + Once the channel connectivity state is different from last_observed_state, + tag will be enqueued on cq with success=1. + If deadline expires BEFORE the state is changed, tag will be enqueued on cq + with success=0. */ +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); + +/** Check whether a grpc channel supports connectivity watcher */ +GRPCAPI int grpc_channel_support_connectivity_watcher(grpc_channel* channel); + +/** Create a call given a grpc_channel, in order to call 'method'. All + completions are sent to 'completion_queue'. 'method' and 'host' need only + live through the invocation of this function. + If parent_call is non-NULL, it must be a server-side call. It will be used + to propagate properties from the server call to this new client call, + depending on the value of \a propagation_mask (see propagation_bits.h for + possible values). */ +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); + +/** Pre-register a method/host pair on a channel. + method and host are not owned and must remain alive while the channel is + alive. */ +GRPCAPI void* grpc_channel_register_call(grpc_channel* channel, + const char* method, const char* host, + void* reserved); + +/** Create a call given a handle returned from grpc_channel_register_call. + \sa grpc_channel_create_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); + +/** Allocate memory in the grpc_call arena: this memory is automatically + discarded at call completion */ +GRPCAPI void* grpc_call_arena_alloc(grpc_call* call, size_t size); + +/** Start a batch of operations defined in the array ops; when complete, post a + completion of type 'tag' to the completion queue bound to the call. + The order of ops specified in the batch has no significance. + Only one operation of each type can be active at once in any given + batch. + If a call to grpc_call_start_batch returns GRPC_CALL_OK you must call + grpc_completion_queue_next or grpc_completion_queue_pluck on the completion + queue associated with 'call' for work to be performed. If a call to + grpc_call_start_batch returns any value other than GRPC_CALL_OK it is + guaranteed that no state associated with 'call' is changed and it is not + appropriate to call grpc_completion_queue_next or + grpc_completion_queue_pluck consequent to the failed grpc_call_start_batch + call. + If a call to grpc_call_start_batch with an empty batch returns + GRPC_CALL_OK, the tag is put in the completion queue immediately. + THREAD SAFETY: access to grpc_call_start_batch in multi-threaded environment + needs to be synchronized. As an optimization, you may synchronize batches + containing just send operations independently from batches containing just + receive operations. Access to grpc_call_start_batch with an empty batch is + thread-compatible. */ +GRPCAPI grpc_call_error grpc_call_start_batch(grpc_call* call, + const grpc_op* ops, size_t nops, + void* tag, void* reserved); + +/** Returns a newly allocated string representing the endpoint to which this + call is communicating with. The string is in the uri format accepted by + grpc_channel_create. + The returned string should be disposed of with gpr_free(). + + WARNING: this value is never authenticated or subject to any security + related code. It must not be used for any authentication related + functionality. Instead, use grpc_auth_context. */ +GRPCAPI char* grpc_call_get_peer(grpc_call* call); + +struct census_context; + +/** Set census context for a call; Must be called before first call to + grpc_call_start_batch(). */ +GRPCAPI void grpc_census_call_set_context(grpc_call* call, + struct census_context* context); + +/** Retrieve the calls current census context. */ +GRPCAPI struct census_context* grpc_census_call_get_context(grpc_call* call); + +/** Return a newly allocated string representing the target a channel was + created for. */ +GRPCAPI char* grpc_channel_get_target(grpc_channel* channel); + +/** Request info about the channel. + \a channel_info indicates what information is being requested and + how that information will be returned. + \a channel_info is owned by the caller. */ +GRPCAPI void grpc_channel_get_info(grpc_channel* channel, + const grpc_channel_info* channel_info); + +/** EXPERIMENTAL. Resets the channel's connect backoff. + TODO(roth): When we see whether this proves useful, either promote + to non-experimental or remove it. */ +GRPCAPI void grpc_channel_reset_connect_backoff(grpc_channel* channel); + +/** Create a client channel to 'target'. Additional channel level configuration + MAY be provided by grpc_channel_args, though the expectation is that most + clients will want to simply pass NULL. The user data in 'args' need only + live through the invocation of this function. However, if any args of the + 'pointer' type are passed, then the referenced vtable must be maintained + by the caller until grpc_channel_destroy terminates. See grpc_channel_args + definition for more on this. */ +GRPCAPI grpc_channel* grpc_insecure_channel_create( + const char* target, const grpc_channel_args* args, void* reserved); + +/** Create a lame client: this client fails every operation attempted on it. */ +GRPCAPI grpc_channel* grpc_lame_client_channel_create( + const char* target, grpc_status_code error_code, const char* error_message); + +/** Close and destroy a grpc channel */ +GRPCAPI void grpc_channel_destroy(grpc_channel* channel); + +/** Error handling for grpc_call + Most grpc_call functions return a grpc_error. If the error is not GRPC_OK + then the operation failed due to some unsatisfied precondition. + If a grpc_call fails, it's guaranteed that no change to the call state + has been made. */ + +/** Cancel an RPC. + Can be called multiple times, from any thread. + THREAD-SAFETY grpc_call_cancel and grpc_call_cancel_with_status + are thread-safe, and can be called at any point before grpc_call_unref + is called.*/ +GRPCAPI grpc_call_error grpc_call_cancel(grpc_call* call, void* reserved); + +/** Cancel an RPC. + Can be called multiple times, from any thread. + If a status has not been received for the call, set it to the status code + and description passed in. + Importantly, this function does not send status nor description to the + remote endpoint. + Note that \a description doesn't need be a static string. + It doesn't need to be alive after the call to + grpc_call_cancel_with_status completes. + */ +GRPCAPI grpc_call_error grpc_call_cancel_with_status(grpc_call* call, + grpc_status_code status, + const char* description, + void* reserved); + +/** Ref a call. + THREAD SAFETY: grpc_call_ref is thread-compatible */ +GRPCAPI void grpc_call_ref(grpc_call* call); + +/** Unref a call. + THREAD SAFETY: grpc_call_unref is thread-compatible */ +GRPCAPI void grpc_call_unref(grpc_call* call); + +/** Request notification of a new call. + Once a call is received, a notification tagged with \a tag_new is added to + \a cq_for_notification. \a call, \a details and \a request_metadata are + updated with the appropriate call information. \a cq_bound_to_call is bound + to \a call, and batch operation notifications for that call will be posted + to \a cq_bound_to_call. + Note that \a cq_for_notification must have been registered to the server via + \a grpc_server_register_completion_queue. */ +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); + +/** How to handle payloads for a registered method */ +typedef enum { + /** Don't try to read the payload */ + GRPC_SRM_PAYLOAD_NONE, + /** Read the initial payload as a byte buffer */ + GRPC_SRM_PAYLOAD_READ_INITIAL_BYTE_BUFFER +} grpc_server_register_method_payload_handling; + +/** Registers a method in the server. + Methods to this (host, method) pair will not be reported by + grpc_server_request_call, but instead be reported by + grpc_server_request_registered_call when passed the appropriate + registered_method (as returned by this function). + Must be called before grpc_server_start. + Returns NULL on failure. */ +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); + +/** Request notification of a new pre-registered call. 'cq_for_notification' + must have been registered to the server via + grpc_server_register_completion_queue. */ +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); + +/** Create a server. Additional configuration for each incoming channel can + be specified with args. If no additional configuration is needed, args can + be NULL. The user data in 'args' need only live through the invocation of + this function. However, if any args of the 'pointer' type are passed, then + the referenced vtable must be maintained by the caller until + grpc_server_destroy terminates. See grpc_channel_args definition for more + on this. */ +GRPCAPI grpc_server* grpc_server_create(const grpc_channel_args* args, + void* reserved); + +/** Register a completion queue with the server. Must be done for any + notification completion queue that is passed to grpc_server_request_*_call + and to grpc_server_shutdown_and_notify. Must be performed prior to + grpc_server_start. */ +GRPCAPI void grpc_server_register_completion_queue(grpc_server* server, + grpc_completion_queue* cq, + void* reserved); + +typedef struct grpc_server_config_fetcher grpc_server_config_fetcher; + +/** EXPERIMENTAL. Creates an xDS config fetcher. */ +GRPCAPI grpc_server_config_fetcher* grpc_server_config_fetcher_xds_create(); + +/** EXPERIMENTAL. Destroys a config fetcher. */ +GRPCAPI void grpc_server_config_fetcher_destroy( + grpc_server_config_fetcher* config_fetcher); + +/** EXPERIMENTAL. Sets the server's config fetcher. Takes ownership. + Must be called before adding ports */ +GRPCAPI void grpc_server_set_config_fetcher( + grpc_server* server, grpc_server_config_fetcher* config_fetcher); + +/** Add a HTTP2 over plaintext over tcp listener. + Returns bound port number on success, 0 on failure. + REQUIRES: server not started */ +GRPCAPI int grpc_server_add_insecure_http2_port(grpc_server* server, + const char* addr); + +/** Start a server - tells all listeners to start listening */ +GRPCAPI void grpc_server_start(grpc_server* server); + +/** Begin shutting down a server. + After completion, no new calls or connections will be admitted. + Existing calls will be allowed to complete. + Send a GRPC_OP_COMPLETE event when there are no more calls being serviced. + Shutdown is idempotent, and all tags will be notified at once if multiple + grpc_server_shutdown_and_notify calls are made. 'cq' must have been + registered to this server via grpc_server_register_completion_queue. */ +GRPCAPI void grpc_server_shutdown_and_notify(grpc_server* server, + grpc_completion_queue* cq, + void* tag); + +/** Cancel all in-progress calls. + Only usable after shutdown. */ +GRPCAPI void grpc_server_cancel_all_calls(grpc_server* server); + +/** Destroy a server. + Shutdown must have completed beforehand (i.e. all tags generated by + grpc_server_shutdown_and_notify must have been received, and at least + one call to grpc_server_shutdown_and_notify must have been made). */ +GRPCAPI void grpc_server_destroy(grpc_server* server); + +/** Enable or disable a tracer. + + Tracers (usually controlled by the environment variable GRPC_TRACE) + allow printf-style debugging on GRPC internals, and are useful for + tracking down problems in the field. + + Use of this function is not strictly thread-safe, but the + thread-safety issues raised by it should not be of concern. */ +GRPCAPI int grpc_tracer_set_enabled(const char* name, int enabled); + +/** Check whether a metadata key is legal (will be accepted by core) */ +GRPCAPI int grpc_header_key_is_legal(grpc_slice slice); + +/** Check whether a non-binary metadata value is legal (will be accepted by + core) */ +GRPCAPI int grpc_header_nonbin_value_is_legal(grpc_slice slice); + +/** Check whether a metadata key corresponds to a binary value */ +GRPCAPI int grpc_is_binary_header(grpc_slice slice); + +/** Convert grpc_call_error values to a string */ +GRPCAPI const char* grpc_call_error_to_string(grpc_call_error error); + +/** Create a buffer pool */ +GRPCAPI grpc_resource_quota* grpc_resource_quota_create(const char* trace_name); + +/** Add a reference to a buffer pool */ +GRPCAPI void grpc_resource_quota_ref(grpc_resource_quota* resource_quota); + +/** Drop a reference to a buffer pool */ +GRPCAPI void grpc_resource_quota_unref(grpc_resource_quota* resource_quota); + +/** Update the size of a buffer pool */ +GRPCAPI void grpc_resource_quota_resize(grpc_resource_quota* resource_quota, + size_t new_size); + +/** Update the size of the maximum number of threads allowed */ +GRPCAPI void grpc_resource_quota_set_max_threads( + grpc_resource_quota* resource_quota, int new_max_threads); + +/** Fetch a vtable for a grpc_channel_arg that points to a grpc_resource_quota + */ +GRPCAPI const grpc_arg_pointer_vtable* grpc_resource_quota_arg_vtable(void); + +/************* CHANNELZ API *************/ +/** Channelz is under active development. The following APIs will see some + churn as the feature is implemented. This comment will be removed once + channelz is officially supported, and these APIs become stable. For now + you may track the progress by following this github issue: + https://github.com/grpc/grpc/issues/15340 + + the following APIs return allocated JSON strings that match the response + objects from the channelz proto, found here: + https://github.com/grpc/grpc/blob/master/src/proto/grpc/channelz/channelz.proto. + + For easy conversion to protobuf, The JSON is formatted according to: + https://developers.google.com/protocol-buffers/docs/proto3#json. */ + +/* Gets all root channels (i.e. channels the application has directly + created). This does not include subchannels nor non-top level channels. + The returned string is allocated and must be freed by the application. */ +GRPCAPI char* grpc_channelz_get_top_channels(intptr_t start_channel_id); + +/* Gets all servers that exist in the process. */ +GRPCAPI char* grpc_channelz_get_servers(intptr_t start_server_id); + +/* Returns a single Server, or else a NOT_FOUND code. */ +GRPCAPI char* grpc_channelz_get_server(intptr_t server_id); + +/* Gets all server sockets that exist in the server. */ +GRPCAPI char* grpc_channelz_get_server_sockets(intptr_t server_id, + intptr_t start_socket_id, + intptr_t max_results); + +/* Returns a single Channel, or else a NOT_FOUND code. The returned string + is allocated and must be freed by the application. */ +GRPCAPI char* grpc_channelz_get_channel(intptr_t channel_id); + +/* Returns a single Subchannel, or else a NOT_FOUND code. The returned string + is allocated and must be freed by the application. */ +GRPCAPI char* grpc_channelz_get_subchannel(intptr_t subchannel_id); + +/* Returns a single Socket, or else a NOT_FOUND code. The returned string + is allocated and must be freed by the application. */ +GRPCAPI char* grpc_channelz_get_socket(intptr_t socket_id); + +#ifdef __cplusplus +} +#endif + +#endif /* GRPC_GRPC_H */ diff --git a/grpc/spm-core-include/grpc/grpc_cronet.h b/grpc/spm-core-include/grpc/grpc_cronet.h new file mode 100644 index 00000000..289cfcda --- /dev/null +++ b/grpc/spm-core-include/grpc/grpc_cronet.h @@ -0,0 +1,38 @@ +/* + * + * Copyright 2016 gRPC authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#ifndef GRPC_GRPC_CRONET_H +#define GRPC_GRPC_CRONET_H + +#include <grpc/support/port_platform.h> + +#include <grpc/grpc.h> + +#ifdef __cplusplus +extern "C" { +#endif + +GRPCAPI grpc_channel* grpc_cronet_secure_channel_create( + void* engine, const char* target, const grpc_channel_args* args, + void* reserved); + +#ifdef __cplusplus +} +#endif + +#endif /* GRPC_GRPC_CRONET_H */ diff --git a/grpc/spm-core-include/grpc/grpc_posix.h b/grpc/spm-core-include/grpc/grpc_posix.h new file mode 100644 index 00000000..fbce5e13 --- /dev/null +++ b/grpc/spm-core-include/grpc/grpc_posix.h @@ -0,0 +1,59 @@ +/* + * + * Copyright 2016 gRPC authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#ifndef GRPC_GRPC_POSIX_H +#define GRPC_GRPC_POSIX_H + +#include <grpc/support/port_platform.h> + +#include <grpc/impl/codegen/grpc_types.h> + +#include <stddef.h> + +#ifdef __cplusplus +extern "C" { +#endif + +/*! \mainpage GRPC Core POSIX + * + * The GRPC Core POSIX library provides some POSIX-specific low-level + * functionality on top of GRPC Core. + */ + +/** Create a client channel to 'target' using file descriptor 'fd'. The 'target' + argument will be used to indicate the name for this channel. See the comment + for grpc_insecure_channel_create for description of 'args' argument. */ +GRPCAPI grpc_channel* grpc_insecure_channel_create_from_fd( + const char* target, int fd, const grpc_channel_args* args); + +/** Add the connected communication channel based on file descriptor 'fd' to the + 'server'. The 'fd' must be an open file descriptor corresponding to a + connected socket. Events from the file descriptor may come on any of the + server completion queues (i.e completion queues registered via the + grpc_server_register_completion_queue API). + + The 'reserved' pointer MUST be NULL. + */ +GRPCAPI void grpc_server_add_insecure_channel_from_fd(grpc_server* server, + void* reserved, int fd); + +#ifdef __cplusplus +} +#endif + +#endif /* GRPC_GRPC_POSIX_H */ diff --git a/grpc/spm-core-include/grpc/grpc_security.h b/grpc/spm-core-include/grpc/grpc_security.h new file mode 100644 index 00000000..c1d72955 --- /dev/null +++ b/grpc/spm-core-include/grpc/grpc_security.h @@ -0,0 +1,1087 @@ +/* + * + * Copyright 2015 gRPC authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#ifndef GRPC_GRPC_SECURITY_H +#define GRPC_GRPC_SECURITY_H + +#include <grpc/support/port_platform.h> + +#include <grpc/grpc.h> +#include <grpc/grpc_security_constants.h> +#include <grpc/status.h> + +#ifdef __cplusplus +extern "C" { +#endif + +/** --- Authentication Context. --- */ + +typedef struct grpc_auth_context grpc_auth_context; + +typedef struct grpc_auth_property_iterator { + const grpc_auth_context* ctx; + size_t index; + const char* name; +} grpc_auth_property_iterator; + +/** value, if not NULL, is guaranteed to be NULL terminated. */ +typedef struct grpc_auth_property { + char* name; + char* value; + size_t value_length; +} grpc_auth_property; + +/** Returns NULL when the iterator is at the end. */ +GRPCAPI const grpc_auth_property* grpc_auth_property_iterator_next( + grpc_auth_property_iterator* it); + +/** Iterates over the auth context. */ +GRPCAPI grpc_auth_property_iterator +grpc_auth_context_property_iterator(const grpc_auth_context* ctx); + +/** Gets the peer identity. Returns an empty iterator (first _next will return + NULL) if the peer is not authenticated. */ +GRPCAPI grpc_auth_property_iterator +grpc_auth_context_peer_identity(const grpc_auth_context* ctx); + +/** Finds a property in the context. May return an empty iterator (first _next + will return NULL) if no property with this name was found in the context. */ +GRPCAPI grpc_auth_property_iterator grpc_auth_context_find_properties_by_name( + const grpc_auth_context* ctx, const char* name); + +/** Gets the name of the property that indicates the peer identity. Will return + NULL if the peer is not authenticated. */ +GRPCAPI const char* grpc_auth_context_peer_identity_property_name( + const grpc_auth_context* ctx); + +/** Returns 1 if the peer is authenticated, 0 otherwise. */ +GRPCAPI int grpc_auth_context_peer_is_authenticated( + const grpc_auth_context* ctx); + +/** Gets the auth context from the call. Caller needs to call + grpc_auth_context_release on the returned context. */ +GRPCAPI grpc_auth_context* grpc_call_auth_context(grpc_call* call); + +/** Releases the auth context returned from grpc_call_auth_context. */ +GRPCAPI void grpc_auth_context_release(grpc_auth_context* context); + +/** -- + The following auth context methods should only be called by a server metadata + processor to set properties extracted from auth metadata. + -- */ + +/** Add a property. */ +GRPCAPI void grpc_auth_context_add_property(grpc_auth_context* ctx, + const char* name, const char* value, + size_t value_length); + +/** Add a C string property. */ +GRPCAPI void grpc_auth_context_add_cstring_property(grpc_auth_context* ctx, + const char* name, + const char* value); + +/** Sets the property name. Returns 1 if successful or 0 in case of failure + (which means that no property with this name exists). */ +GRPCAPI int grpc_auth_context_set_peer_identity_property_name( + grpc_auth_context* ctx, const char* name); + +/** --- SSL Session Cache. --- + + A SSL session cache object represents a way to cache client sessions + between connections. Only ticket-based resumption is supported. */ + +typedef struct grpc_ssl_session_cache grpc_ssl_session_cache; + +/** Create LRU cache for client-side SSL sessions with the given capacity. + If capacity is < 1, a default capacity is used instead. */ +GRPCAPI grpc_ssl_session_cache* grpc_ssl_session_cache_create_lru( + size_t capacity); + +/** Destroy SSL session cache. */ +GRPCAPI void grpc_ssl_session_cache_destroy(grpc_ssl_session_cache* cache); + +/** Create a channel arg with the given cache object. */ +GRPCAPI grpc_arg +grpc_ssl_session_cache_create_channel_arg(grpc_ssl_session_cache* cache); + +/** --- grpc_call_credentials object. + + A call credentials object represents a way to authenticate on a particular + call. These credentials can be composed with a channel credentials object + so that they are sent with every call on this channel. */ + +typedef struct grpc_call_credentials grpc_call_credentials; + +/** Releases a call credentials object. + The creator of the credentials object is responsible for its release. */ +GRPCAPI void grpc_call_credentials_release(grpc_call_credentials* creds); + +/** --- grpc_channel_credentials object. --- + + A channel credentials object represents a way to authenticate a client on a + channel. */ + +typedef struct grpc_channel_credentials grpc_channel_credentials; + +/** Releases a channel credentials object. + The creator of the credentials object is responsible for its release. */ +GRPCAPI void grpc_channel_credentials_release(grpc_channel_credentials* creds); + +/** Creates default credentials to connect to a google gRPC service. + WARNING: Do NOT use this credentials to connect to a non-google service as + this could result in an oauth2 token leak. The security level of the + resulting connection is GRPC_PRIVACY_AND_INTEGRITY. + + If specified, the supplied call credentials object will be attached to the + returned channel credentials object. The call_credentials object must remain + valid throughout the lifetime of the returned grpc_channel_credentials + object. It is expected that the call credentials object was generated + according to the Application Default Credentials mechanism and asserts the + identity of the default service account of the machine. Supplying any other + sort of call credential will result in undefined behavior, up to and + including the sudden and unexpected failure of RPCs. + + If nullptr is supplied, the returned channel credentials object will use a + call credentials object based on the Application Default Credentials + mechanism. +*/ +GRPCAPI grpc_channel_credentials* grpc_google_default_credentials_create( + grpc_call_credentials* call_credentials); + +/** Callback for getting the SSL roots override from the application. + In case of success, *pem_roots_certs must be set to a NULL terminated string + containing the list of PEM encoded root certificates. The ownership is passed + to the core and freed (laster by the core) with gpr_free. + If this function fails and GRPC_DEFAULT_SSL_ROOTS_FILE_PATH environment is + set to a valid path, it will override the roots specified this func */ +typedef grpc_ssl_roots_override_result (*grpc_ssl_roots_override_callback)( + char** pem_root_certs); + +/** Setup a callback to override the default TLS/SSL roots. + This function is not thread-safe and must be called at initialization time + before any ssl credentials are created to have the desired side effect. + If GRPC_DEFAULT_SSL_ROOTS_FILE_PATH environment is set to a valid path, the + callback will not be called. */ +GRPCAPI void grpc_set_ssl_roots_override_callback( + grpc_ssl_roots_override_callback cb); + +/** Object that holds a private key / certificate chain pair in PEM format. */ +typedef struct { + /** private_key is the NULL-terminated string containing the PEM encoding of + the client's private key. */ + const char* private_key; + + /** cert_chain is the NULL-terminated string containing the PEM encoding of + the client's certificate chain. */ + const char* cert_chain; +} grpc_ssl_pem_key_cert_pair; + +/** Deprecated in favor of grpc_ssl_verify_peer_options. It will be removed + after all of its call sites are migrated to grpc_ssl_verify_peer_options. + Object that holds additional peer-verification options on a secure + channel. */ +typedef struct { + /** If non-NULL this callback will be invoked with the expected + target_name, the peer's certificate (in PEM format), and whatever + userdata pointer is set below. If a non-zero value is returned by this + callback then it is treated as a verification failure. Invocation of + the callback is blocking, so any implementation should be light-weight. + */ + int (*verify_peer_callback)(const char* target_name, const char* peer_pem, + void* userdata); + /** Arbitrary userdata that will be passed as the last argument to + verify_peer_callback. */ + void* verify_peer_callback_userdata; + /** A destruct callback that will be invoked when the channel is being + cleaned up. The userdata argument will be passed to it. The intent is + to perform any cleanup associated with that userdata. */ + void (*verify_peer_destruct)(void* userdata); +} verify_peer_options; + +/** Object that holds additional peer-verification options on a secure + channel. */ +typedef struct { + /** If non-NULL this callback will be invoked with the expected + target_name, the peer's certificate (in PEM format), and whatever + userdata pointer is set below. If a non-zero value is returned by this + callback then it is treated as a verification failure. Invocation of + the callback is blocking, so any implementation should be light-weight. + */ + int (*verify_peer_callback)(const char* target_name, const char* peer_pem, + void* userdata); + /** Arbitrary userdata that will be passed as the last argument to + verify_peer_callback. */ + void* verify_peer_callback_userdata; + /** A destruct callback that will be invoked when the channel is being + cleaned up. The userdata argument will be passed to it. The intent is + to perform any cleanup associated with that userdata. */ + void (*verify_peer_destruct)(void* userdata); +} grpc_ssl_verify_peer_options; + +/** Deprecated in favor of grpc_ssl_server_credentials_create_ex. It will be + removed after all of its call sites are migrated to + grpc_ssl_server_credentials_create_ex. Creates an SSL credentials object. + The security level of the resulting connection is GRPC_PRIVACY_AND_INTEGRITY. + - pem_root_certs is the NULL-terminated string containing the PEM encoding + of the server root certificates. If this parameter is NULL, the + implementation will first try to dereference the file pointed by the + GRPC_DEFAULT_SSL_ROOTS_FILE_PATH environment variable, and if that fails, + try to get the roots set by grpc_override_ssl_default_roots. Eventually, + if all these fail, it will try to get the roots from a well-known place on + disk (in the grpc install directory). + + gRPC has implemented root cache if the underlying OpenSSL library supports + it. The gRPC root certificates cache is only applicable on the default + root certificates, which is used when this parameter is nullptr. If user + provides their own pem_root_certs, when creating an SSL credential object, + gRPC would not be able to cache it, and each subchannel will generate a + copy of the root store. So it is recommended to avoid providing large room + pem with pem_root_certs parameter to avoid excessive memory consumption, + particularly on mobile platforms such as iOS. + - pem_key_cert_pair is a pointer on the object containing client's private + key and certificate chain. This parameter can be NULL if the client does + not have such a key/cert pair. + - verify_options is an optional verify_peer_options object which holds + additional options controlling how peer certificates are verified. For + example, you can supply a callback which receives the peer's certificate + with which you can do additional verification. Can be NULL, in which + case verification will retain default behavior. Any settings in + verify_options are copied during this call, so the verify_options + object can be released afterwards. */ +GRPCAPI grpc_channel_credentials* grpc_ssl_credentials_create( + const char* pem_root_certs, grpc_ssl_pem_key_cert_pair* pem_key_cert_pair, + const verify_peer_options* verify_options, void* reserved); + +/* Creates an SSL credentials object. + The security level of the resulting connection is GRPC_PRIVACY_AND_INTEGRITY. + - pem_root_certs is the NULL-terminated string containing the PEM encoding + of the server root certificates. If this parameter is NULL, the + implementation will first try to dereference the file pointed by the + GRPC_DEFAULT_SSL_ROOTS_FILE_PATH environment variable, and if that fails, + try to get the roots set by grpc_override_ssl_default_roots. Eventually, + if all these fail, it will try to get the roots from a well-known place on + disk (in the grpc install directory). + + gRPC has implemented root cache if the underlying OpenSSL library supports + it. The gRPC root certificates cache is only applicable on the default + root certificates, which is used when this parameter is nullptr. If user + provides their own pem_root_certs, when creating an SSL credential object, + gRPC would not be able to cache it, and each subchannel will generate a + copy of the root store. So it is recommended to avoid providing large room + pem with pem_root_certs parameter to avoid excessive memory consumption, + particularly on mobile platforms such as iOS. + - pem_key_cert_pair is a pointer on the object containing client's private + key and certificate chain. This parameter can be NULL if the client does + not have such a key/cert pair. + - verify_options is an optional verify_peer_options object which holds + additional options controlling how peer certificates are verified. For + example, you can supply a callback which receives the peer's certificate + with which you can do additional verification. Can be NULL, in which + case verification will retain default behavior. Any settings in + verify_options are copied during this call, so the verify_options + object can be released afterwards. */ +GRPCAPI grpc_channel_credentials* grpc_ssl_credentials_create_ex( + const char* pem_root_certs, grpc_ssl_pem_key_cert_pair* pem_key_cert_pair, + const grpc_ssl_verify_peer_options* verify_options, void* reserved); + +/** Creates a composite channel credentials object. The security level of + * resulting connection is determined by channel_creds. */ +GRPCAPI grpc_channel_credentials* grpc_composite_channel_credentials_create( + grpc_channel_credentials* channel_creds, grpc_call_credentials* call_creds, + void* reserved); + +/** --- composite credentials. */ + +/** Creates a composite call credentials object. */ +GRPCAPI grpc_call_credentials* grpc_composite_call_credentials_create( + grpc_call_credentials* creds1, grpc_call_credentials* creds2, + void* reserved); + +/** Creates a compute engine credentials object for connecting to Google. + WARNING: Do NOT use this credentials to connect to a non-google service as + this could result in an oauth2 token leak. */ +GRPCAPI grpc_call_credentials* grpc_google_compute_engine_credentials_create( + void* reserved); + +GRPCAPI gpr_timespec grpc_max_auth_token_lifetime(void); + +/** Creates a JWT credentials object. May return NULL if the input is invalid. + - json_key is the JSON key string containing the client's private key. + - token_lifetime is the lifetime of each Json Web Token (JWT) created with + this credentials. It should not exceed grpc_max_auth_token_lifetime or + will be cropped to this value. */ +GRPCAPI grpc_call_credentials* +grpc_service_account_jwt_access_credentials_create(const char* json_key, + gpr_timespec token_lifetime, + void* reserved); + +/** Builds External Account credentials. + - json_string is the JSON string containing the credentials options. + - scopes_string contains the scopes to be binded with the credentials. + This API is used for experimental purposes for now and may change in the + future. */ +GRPCAPI grpc_call_credentials* grpc_external_account_credentials_create( + const char* json_string, const char* scopes_string); + +/** Creates an Oauth2 Refresh Token credentials object for connecting to Google. + May return NULL if the input is invalid. + WARNING: Do NOT use this credentials to connect to a non-google service as + this could result in an oauth2 token leak. + - json_refresh_token is the JSON string containing the refresh token itself + along with a client_id and client_secret. */ +GRPCAPI grpc_call_credentials* grpc_google_refresh_token_credentials_create( + const char* json_refresh_token, void* reserved); + +/** Creates an Oauth2 Access Token credentials with an access token that was + acquired by an out of band mechanism. */ +GRPCAPI grpc_call_credentials* grpc_access_token_credentials_create( + const char* access_token, void* reserved); + +/** Creates an IAM credentials object for connecting to Google. */ +GRPCAPI grpc_call_credentials* grpc_google_iam_credentials_create( + const char* authorization_token, const char* authority_selector, + void* reserved); + +/** Options for creating STS Oauth Token Exchange credentials following the IETF + draft https://tools.ietf.org/html/draft-ietf-oauth-token-exchange-16. + Optional fields may be set to NULL or empty string. It is the responsibility + of the caller to ensure that the subject and actor tokens are refreshed on + disk at the specified paths. This API is used for experimental purposes for + now and may change in the future. */ +typedef struct { + const char* token_exchange_service_uri; /* Required. */ + const char* resource; /* Optional. */ + const char* audience; /* Optional. */ + const char* scope; /* Optional. */ + const char* requested_token_type; /* Optional. */ + const char* subject_token_path; /* Required. */ + const char* subject_token_type; /* Required. */ + const char* actor_token_path; /* Optional. */ + const char* actor_token_type; /* Optional. */ +} grpc_sts_credentials_options; + +/** Creates an STS credentials following the STS Token Exchanged specifed in the + IETF draft https://tools.ietf.org/html/draft-ietf-oauth-token-exchange-16. + This API is used for experimental purposes for now and may change in the + future. */ +GRPCAPI grpc_call_credentials* grpc_sts_credentials_create( + const grpc_sts_credentials_options* options, void* reserved); + +/** Callback function to be called by the metadata credentials plugin + implementation when the metadata is ready. + - user_data is the opaque pointer that was passed in the get_metadata method + of the grpc_metadata_credentials_plugin (see below). + - creds_md is an array of credentials metadata produced by the plugin. It + may be set to NULL in case of an error. + - num_creds_md is the number of items in the creds_md array. + - status must be GRPC_STATUS_OK in case of success or another specific error + code otherwise. + - error_details contains details about the error if any. In case of success + it should be NULL and will be otherwise ignored. */ +typedef void (*grpc_credentials_plugin_metadata_cb)( + void* user_data, const grpc_metadata* creds_md, size_t num_creds_md, + grpc_status_code status, const char* error_details); + +/** Context that can be used by metadata credentials plugin in order to create + auth related metadata. */ +typedef struct { + /** The fully qualifed service url. */ + const char* service_url; + + /** The method name of the RPC being called (not fully qualified). + The fully qualified method name can be built from the service_url: + full_qualified_method_name = ctx->service_url + '/' + ctx->method_name. */ + const char* method_name; + + /** The auth_context of the channel which gives the server's identity. */ + const grpc_auth_context* channel_auth_context; + + /** Reserved for future use. */ + void* reserved; +} grpc_auth_metadata_context; + +/** Performs a deep copy from \a from to \a to. **/ +GRPCAPI void grpc_auth_metadata_context_copy(grpc_auth_metadata_context* from, + grpc_auth_metadata_context* to); + +/** Releases internal resources held by \a context. **/ +GRPCAPI void grpc_auth_metadata_context_reset( + grpc_auth_metadata_context* context); + +/** Maximum number of metadata entries returnable by a credentials plugin via + a synchronous return. */ +#define GRPC_METADATA_CREDENTIALS_PLUGIN_SYNC_MAX 4 + +/** grpc_metadata_credentials plugin is an API user provided structure used to + create grpc_credentials objects that can be set on a channel (composed) or + a call. See grpc_credentials_metadata_create_from_plugin below. + The grpc client stack will call the get_metadata method of the plugin for + every call in scope for the credentials created from it. */ +typedef struct { + /** The implementation of this method has to be non-blocking, but can + be performed synchronously or asynchronously. + + If processing occurs synchronously, returns non-zero and populates + creds_md, num_creds_md, status, and error_details. In this case, + the caller takes ownership of the entries in creds_md and of + error_details. Note that if the plugin needs to return more than + GRPC_METADATA_CREDENTIALS_PLUGIN_SYNC_MAX entries in creds_md, it must + return asynchronously. + + If processing occurs asynchronously, returns zero and invokes \a cb + when processing is completed. \a user_data will be passed as the + first parameter of the callback. NOTE: \a cb MUST be invoked in a + different thread, not from the thread in which \a get_metadata() is + invoked. + + \a context is the information that can be used by the plugin to create + auth metadata. */ + int (*get_metadata)( + void* state, grpc_auth_metadata_context context, + grpc_credentials_plugin_metadata_cb cb, void* user_data, + grpc_metadata creds_md[GRPC_METADATA_CREDENTIALS_PLUGIN_SYNC_MAX], + size_t* num_creds_md, grpc_status_code* status, + const char** error_details); + + /** Implements debug string of the given plugin. This method returns an + * allocated string that the caller needs to free using gpr_free() */ + char* (*debug_string)(void* state); + + /** Destroys the plugin state. */ + void (*destroy)(void* state); + + /** State that will be set as the first parameter of the methods above. */ + void* state; + + /** Type of credentials that this plugin is implementing. */ + const char* type; +} grpc_metadata_credentials_plugin; + +/** Creates a credentials object from a plugin with a specified minimum security + * level. */ +GRPCAPI grpc_call_credentials* grpc_metadata_credentials_create_from_plugin( + grpc_metadata_credentials_plugin plugin, + grpc_security_level min_security_level, void* reserved); + +/** --- Secure channel creation. --- */ + +/** Creates a secure channel using the passed-in credentials. Additional + channel level configuration MAY be provided by grpc_channel_args, though + the expectation is that most clients will want to simply pass NULL. The + user data in 'args' need only live through the invocation of this function. + However, if any args of the 'pointer' type are passed, then the referenced + vtable must be maintained by the caller until grpc_channel_destroy + terminates. See grpc_channel_args definition for more on this. */ +GRPCAPI grpc_channel* grpc_secure_channel_create( + grpc_channel_credentials* creds, const char* target, + const grpc_channel_args* args, void* reserved); + +/** --- grpc_server_credentials object. --- + + A server credentials object represents a way to authenticate a server. */ + +typedef struct grpc_server_credentials grpc_server_credentials; + +/** Releases a server_credentials object. + The creator of the server_credentials object is responsible for its release. + */ +GRPCAPI void grpc_server_credentials_release(grpc_server_credentials* creds); + +/** Server certificate config object holds the server's public certificates and + associated private keys, as well as any CA certificates needed for client + certificate validation (if applicable). Create using + grpc_ssl_server_certificate_config_create(). */ +typedef struct grpc_ssl_server_certificate_config + grpc_ssl_server_certificate_config; + +/** Creates a grpc_ssl_server_certificate_config object. + - pem_roots_cert is the NULL-terminated string containing the PEM encoding of + the client root certificates. This parameter may be NULL if the server does + not want the client to be authenticated with SSL. + - pem_key_cert_pairs is an array private key / certificate chains of the + server. This parameter cannot be NULL. + - num_key_cert_pairs indicates the number of items in the private_key_files + and cert_chain_files parameters. It must be at least 1. + - It is the caller's responsibility to free this object via + grpc_ssl_server_certificate_config_destroy(). */ +GRPCAPI grpc_ssl_server_certificate_config* +grpc_ssl_server_certificate_config_create( + const char* pem_root_certs, + const grpc_ssl_pem_key_cert_pair* pem_key_cert_pairs, + size_t num_key_cert_pairs); + +/** Destroys a grpc_ssl_server_certificate_config object. */ +GRPCAPI void grpc_ssl_server_certificate_config_destroy( + grpc_ssl_server_certificate_config* config); + +/** Callback to retrieve updated SSL server certificates, private keys, and + trusted CAs (for client authentication). + - user_data parameter, if not NULL, contains opaque data to be used by the + callback. + - Use grpc_ssl_server_certificate_config_create to create the config. + - The caller assumes ownership of the config. */ +typedef grpc_ssl_certificate_config_reload_status ( + *grpc_ssl_server_certificate_config_callback)( + void* user_data, grpc_ssl_server_certificate_config** config); + +/** Deprecated in favor of grpc_ssl_server_credentials_create_ex. + Creates an SSL server_credentials object. + - pem_roots_cert is the NULL-terminated string containing the PEM encoding of + the client root certificates. This parameter may be NULL if the server does + not want the client to be authenticated with SSL. + - pem_key_cert_pairs is an array private key / certificate chains of the + server. This parameter cannot be NULL. + - num_key_cert_pairs indicates the number of items in the private_key_files + and cert_chain_files parameters. It should be at least 1. + - force_client_auth, if set to non-zero will force the client to authenticate + with an SSL cert. Note that this option is ignored if pem_root_certs is + NULL. */ +GRPCAPI grpc_server_credentials* grpc_ssl_server_credentials_create( + const char* pem_root_certs, grpc_ssl_pem_key_cert_pair* pem_key_cert_pairs, + size_t num_key_cert_pairs, int force_client_auth, void* reserved); + +/** Deprecated in favor of grpc_ssl_server_credentials_create_with_options. + Same as grpc_ssl_server_credentials_create method except uses + grpc_ssl_client_certificate_request_type enum to support more ways to + authenticate client certificates.*/ +GRPCAPI grpc_server_credentials* grpc_ssl_server_credentials_create_ex( + const char* pem_root_certs, grpc_ssl_pem_key_cert_pair* pem_key_cert_pairs, + size_t num_key_cert_pairs, + grpc_ssl_client_certificate_request_type client_certificate_request, + void* reserved); + +typedef struct grpc_ssl_server_credentials_options + grpc_ssl_server_credentials_options; + +/** Creates an options object using a certificate config. Use this method when + the certificates and keys of the SSL server will not change during the + server's lifetime. + - Takes ownership of the certificate_config parameter. */ +GRPCAPI grpc_ssl_server_credentials_options* +grpc_ssl_server_credentials_create_options_using_config( + grpc_ssl_client_certificate_request_type client_certificate_request, + grpc_ssl_server_certificate_config* certificate_config); + +/** Creates an options object using a certificate config fetcher. Use this + method to reload the certificates and keys of the SSL server without + interrupting the operation of the server. Initial certificate config will be + fetched during server initialization. + - user_data parameter, if not NULL, contains opaque data which will be passed + to the fetcher (see definition of + grpc_ssl_server_certificate_config_callback). */ +GRPCAPI grpc_ssl_server_credentials_options* +grpc_ssl_server_credentials_create_options_using_config_fetcher( + grpc_ssl_client_certificate_request_type client_certificate_request, + grpc_ssl_server_certificate_config_callback cb, void* user_data); + +/** Destroys a grpc_ssl_server_credentials_options object. */ +GRPCAPI void grpc_ssl_server_credentials_options_destroy( + grpc_ssl_server_credentials_options* options); + +/** Creates an SSL server_credentials object using the provided options struct. + - Takes ownership of the options parameter. */ +GRPCAPI grpc_server_credentials* +grpc_ssl_server_credentials_create_with_options( + grpc_ssl_server_credentials_options* options); + +/** --- Server-side secure ports. --- */ + +/** Add a HTTP2 over an encrypted link over tcp listener. + Returns bound port number on success, 0 on failure. + REQUIRES: server not started */ +GRPCAPI int grpc_server_add_secure_http2_port(grpc_server* server, + const char* addr, + grpc_server_credentials* creds); + +/** --- Call specific credentials. --- */ + +/** Sets a credentials to a call. Can only be called on the client side before + grpc_call_start_batch. */ +GRPCAPI grpc_call_error grpc_call_set_credentials(grpc_call* call, + grpc_call_credentials* creds); + +/** --- Auth Metadata Processing --- */ + +/** Callback function that is called when the metadata processing is done. + - Consumed metadata will be removed from the set of metadata available on the + call. consumed_md may be NULL if no metadata has been consumed. + - Response metadata will be set on the response. response_md may be NULL. + - status is GRPC_STATUS_OK for success or a specific status for an error. + Common error status for auth metadata processing is either + GRPC_STATUS_UNAUTHENTICATED in case of an authentication failure or + GRPC_STATUS PERMISSION_DENIED in case of an authorization failure. + - error_details gives details about the error. May be NULL. */ +typedef void (*grpc_process_auth_metadata_done_cb)( + void* user_data, const grpc_metadata* consumed_md, size_t num_consumed_md, + const grpc_metadata* response_md, size_t num_response_md, + grpc_status_code status, const char* error_details); + +/** Pluggable server-side metadata processor object. */ +typedef struct { + /** The context object is read/write: it contains the properties of the + channel peer and it is the job of the process function to augment it with + properties derived from the passed-in metadata. + The lifetime of these objects is guaranteed until cb is invoked. */ + void (*process)(void* state, grpc_auth_context* context, + const grpc_metadata* md, size_t num_md, + grpc_process_auth_metadata_done_cb cb, void* user_data); + void (*destroy)(void* state); + void* state; +} grpc_auth_metadata_processor; + +GRPCAPI void grpc_server_credentials_set_auth_metadata_processor( + grpc_server_credentials* creds, grpc_auth_metadata_processor processor); + +/** --- ALTS channel/server credentials --- **/ + +/** + * Main interface for ALTS credentials options. The options will contain + * information that will be passed from grpc to TSI layer such as RPC protocol + * versions. ALTS client (channel) and server credentials will have their own + * implementation of this interface. The APIs listed in this header are + * thread-compatible. It is used for experimental purpose for now and subject + * to change. + */ +typedef struct grpc_alts_credentials_options grpc_alts_credentials_options; + +/** + * This method creates a grpc ALTS credentials client options instance. + * It is used for experimental purpose for now and subject to change. + */ +GRPCAPI grpc_alts_credentials_options* +grpc_alts_credentials_client_options_create(void); + +/** + * This method creates a grpc ALTS credentials server options instance. + * It is used for experimental purpose for now and subject to change. + */ +GRPCAPI grpc_alts_credentials_options* +grpc_alts_credentials_server_options_create(void); + +/** + * This method adds a target service account to grpc client's ALTS credentials + * options instance. It is used for experimental purpose for now and subject + * to change. + * + * - options: grpc ALTS credentials options instance. + * - service_account: service account of target endpoint. + */ +GRPCAPI void grpc_alts_credentials_client_options_add_target_service_account( + grpc_alts_credentials_options* options, const char* service_account); + +/** + * This method destroys a grpc_alts_credentials_options instance by + * de-allocating all of its occupied memory. It is used for experimental purpose + * for now and subject to change. + * + * - options: a grpc_alts_credentials_options instance that needs to be + * destroyed. + */ +GRPCAPI void grpc_alts_credentials_options_destroy( + grpc_alts_credentials_options* options); + +/** + * This method creates an ALTS channel credential object. The security + * level of the resulting connection is GRPC_PRIVACY_AND_INTEGRITY. + * It is used for experimental purpose for now and subject to change. + * + * - options: grpc ALTS credentials options instance for client. + * + * It returns the created ALTS channel credential object. + */ +GRPCAPI grpc_channel_credentials* grpc_alts_credentials_create( + const grpc_alts_credentials_options* options); + +/** + * This method creates an ALTS server credential object. It is used for + * experimental purpose for now and subject to change. + * + * - options: grpc ALTS credentials options instance for server. + * + * It returns the created ALTS server credential object. + */ +GRPCAPI grpc_server_credentials* grpc_alts_server_credentials_create( + const grpc_alts_credentials_options* options); + +/** --- Local channel/server credentials --- **/ + +/** + * This method creates a local channel credential object. The security level + * of the resulting connection is GRPC_PRIVACY_AND_INTEGRITY for UDS and + * GRPC_SECURITY_NONE for LOCAL_TCP. It is used for experimental purpose + * for now and subject to change. + * + * - type: local connection type + * + * It returns the created local channel credential object. + */ +GRPCAPI grpc_channel_credentials* grpc_local_credentials_create( + grpc_local_connect_type type); + +/** + * This method creates a local server credential object. It is used for + * experimental purpose for now and subject to change. + * + * - type: local connection type + * + * It returns the created local server credential object. + */ +GRPCAPI grpc_server_credentials* grpc_local_server_credentials_create( + grpc_local_connect_type type); + +/** --- TLS channel/server credentials --- + * It is used for experimental purpose for now and subject to change. */ + +/** Struct for indicating errors. It is used for + * experimental purpose for now and subject to change. */ +typedef struct grpc_tls_error_details grpc_tls_error_details; + +/** Config for TLS server authorization check. It is used for + * experimental purpose for now and subject to change. */ +typedef struct grpc_tls_server_authorization_check_config + grpc_tls_server_authorization_check_config; + +/** + * A struct that can be specified by callers to configure underlying TLS + * behaviors. It is used for experimental purpose for now and subject to change. + */ +typedef struct grpc_tls_credentials_options grpc_tls_credentials_options; + +/** + * A struct provides ways to gain credential data that will be used in the TLS + * handshake. It is used for experimental purpose for now and subject to change. + */ +typedef struct grpc_tls_certificate_provider grpc_tls_certificate_provider; + +/** + * A struct that stores the credential data presented to the peer in handshake + * to show local identity. It is used for experimental purpose for now and + * subject to change. + */ +typedef struct grpc_tls_identity_pairs grpc_tls_identity_pairs; + +/** + * Creates a grpc_tls_identity_pairs that stores a list of identity credential + * data, including identity private key and identity certificate chain. It is + * used for experimental purpose for now and subject to change. + */ +GRPCAPI grpc_tls_identity_pairs* grpc_tls_identity_pairs_create(); + +/** + * Adds a identity private key and a identity certificate chain to + * grpc_tls_identity_pairs. This function will make an internal copy of + * |private_key| and |cert_chain|. It is used for experimental purpose for now + * and subject to change. + */ +GRPCAPI void grpc_tls_identity_pairs_add_pair(grpc_tls_identity_pairs* pairs, + const char* private_key, + const char* cert_chain); + +/** + * Destroys a grpc_tls_identity_pairs object. If this object is passed to a + * provider initiation function, the ownership is transferred so this function + * doesn't need to be called. Otherwise the creator of the + * grpc_tls_identity_pairs object is responsible for its destruction. It is + * used for experimental purpose for now and subject to change. + */ +GRPCAPI void grpc_tls_identity_pairs_destroy(grpc_tls_identity_pairs* pairs); + +/** + * Creates a grpc_tls_certificate_provider that will load credential data from + * static string during initialization. This provider will always return the + * same cert data for all cert names. + * root_certificate and pem_key_cert_pairs can be nullptr, indicating the + * corresponding credential data is not needed. + * This function will make a copy of |root_certificate|. + * The ownership of |pem_key_cert_pairs| is transferred. + * It is used for experimental purpose for now and subject to change. + */ +GRPCAPI grpc_tls_certificate_provider* +grpc_tls_certificate_provider_static_data_create( + const char* root_certificate, grpc_tls_identity_pairs* pem_key_cert_pairs); + +/** + * Creates a grpc_tls_certificate_provider that will watch the credential + * changes on the file system. This provider will always return the up-to-date + * cert data for all the cert names callers set through + * |grpc_tls_credentials_options|. Note that this API only supports one key-cert + * file and hence one set of identity key-cert pair, so SNI(Server Name + * Indication) is not supported. + * - private_key_path is the file path of the private key. This must be set if + * |identity_certificate_path| is set. Otherwise, it could be null if no + * identity credentials are needed. + * - identity_certificate_path is the file path of the identity certificate + * chain. This must be set if |private_key_path| is set. Otherwise, it could + * be null if no identity credentials are needed. + * - root_cert_path is the file path to the root certificate bundle. This + * may be null if no root certs are needed. + * - refresh_interval_sec is the refreshing interval that we will check the + * files for updates. + * It does not take ownership of parameters. + * It is used for experimental purpose for now and subject to change. + */ +GRPCAPI grpc_tls_certificate_provider* +grpc_tls_certificate_provider_file_watcher_create( + const char* private_key_path, const char* identity_certificate_path, + const char* root_cert_path, unsigned int refresh_interval_sec); + +/** + * Releases a grpc_tls_certificate_provider object. The creator of the + * grpc_tls_certificate_provider object is responsible for its release. It is + * used for experimental purpose for now and subject to change. + */ +GRPCAPI void grpc_tls_certificate_provider_release( + grpc_tls_certificate_provider* provider); + +/** + * Creates an grpc_tls_credentials_options. + * It is used for experimental purpose for now and subject to change. + */ +GRPCAPI grpc_tls_credentials_options* grpc_tls_credentials_options_create(void); + +/** + * Sets the options of whether to request and verify client certs. This should + * be called only on the server side. It returns 1 on success and 0 on failure. + * It is used for experimental purpose for now and subject to change. + */ +GRPCAPI void grpc_tls_credentials_options_set_cert_request_type( + grpc_tls_credentials_options* options, + grpc_ssl_client_certificate_request_type type); + +/** + * Sets the options of whether to choose certain checks, e.g. certificate check, + * hostname check, etc. This should be called only on the client side. If + * |server_verification_option| is not GRPC_TLS_SERVER_VERIFICATION, use of a + * custom authorization check (grpc_tls_server_authorization_check_config) is + * mandatory. It returns 1 on success and 0 on failure. It is used for + * experimental purpose for now and subject to change. + */ +GRPCAPI void grpc_tls_credentials_options_set_server_verification_option( + grpc_tls_credentials_options* options, + grpc_tls_server_verification_option server_verification_option); + +/** + * Sets the credential provider in the options. + * The |options| will implicitly take a new ref to the |provider|. + * It returns 1 on success and 0 on failure. + * It is used for experimental purpose for now and subject to change. + */ +GRPCAPI void grpc_tls_credentials_options_set_certificate_provider( + grpc_tls_credentials_options* options, + grpc_tls_certificate_provider* provider); + +/** + * If set, gRPC stack will keep watching the root certificates with + * name |root_cert_name|. It returns 1 on success and 0 on failure. It is used + * for experimental purpose for now and subject to change. + */ +GRPCAPI void grpc_tls_credentials_options_watch_root_certs( + grpc_tls_credentials_options* options); + +/** + * Sets the name of the root certificates being watched. + * If not set, We will use a default empty string as the root certificate name. + * It is used for experimental purpose for now and subject to change. + */ +GRPCAPI void grpc_tls_credentials_options_set_root_cert_name( + grpc_tls_credentials_options* options, const char* root_cert_name); + +/** + * If set, gRPC stack will keep watching the identity key-cert pairs + * with name |identity_cert_name|. It returns 1 on success and 0 on failure. It + * is used for experimental purpose for now and subject to change. + */ +GRPCAPI void grpc_tls_credentials_options_watch_identity_key_cert_pairs( + grpc_tls_credentials_options* options); + +/** + * Sets the name of the identity certificates being watched. + * If not set, We will use a default empty string as the identity certificate + * name. It is used for experimental purpose for now and subject to change. + */ +GRPCAPI void grpc_tls_credentials_options_set_identity_cert_name( + grpc_tls_credentials_options* options, const char* identity_cert_name); + +/** + * Sets the configuration for a custom authorization check performed at the end + * of the handshake. The |options| will implicitly take a new ref to the + * |config|. It returns 1 on success and 0 on failure. It is used for + * experimental purpose for now and subject to change. + */ +GRPCAPI void grpc_tls_credentials_options_set_server_authorization_check_config( + grpc_tls_credentials_options* options, + grpc_tls_server_authorization_check_config* config); + +/** --- TLS server authorization check config. --- + * It is used for experimental purpose for now and subject to change. */ + +typedef struct grpc_tls_server_authorization_check_arg + grpc_tls_server_authorization_check_arg; + +/** callback function provided by gRPC used to handle the result of server + authorization check. It is used when schedule API is implemented + asynchronously, and serves to bring the control back to gRPC C core. It is + used for experimental purpose for now and subject to change. */ +typedef void (*grpc_tls_on_server_authorization_check_done_cb)( + grpc_tls_server_authorization_check_arg* arg); + +/** A struct containing all information necessary to schedule/cancel a server + authorization check request. + - cb and cb_user_data represent a gRPC-provided callback and an argument + passed to it. + - success will store the result of server authorization check. That is, + if success returns a non-zero value, it means the authorization check + passes and if returning zero, it means the check fails. + - target_name is the name of an endpoint the channel is connecting to. + - peer_cert represents a complete certificate chain including both + signing and leaf certificates. + - \a subject_alternative_names is an array of size + \a subject_alternative_names_size consisting of pointers to strings. + - status and error_details contain information + about errors occurred when a server authorization check request is + scheduled/cancelled. + - config is a pointer to the unique + grpc_tls_server_authorization_check_config instance that this argument + corresponds to. + - context is a pointer to a wrapped language implementation of this + grpc_tls_server_authorization_check_arg instance. + - destroy_context is a pointer to a caller-provided method that cleans + up any data associated with the context pointer. + It is used for experimental purpose for now and subject to change. +*/ +struct grpc_tls_server_authorization_check_arg { + grpc_tls_on_server_authorization_check_done_cb cb; + void* cb_user_data; + int success; + const char* target_name; + const char* peer_cert; + const char* peer_cert_full_chain; + char** subject_alternative_names; + size_t subject_alternative_names_size; + grpc_status_code status; + grpc_tls_error_details* error_details; + grpc_tls_server_authorization_check_config* config; + void* context; + void (*destroy_context)(void* ctx); +}; + +/** Create a grpc_tls_server_authorization_check_config instance. + - config_user_data is config-specific, read-only user data + that works for all channels created with a credential using the config. + - schedule is a pointer to an application-provided callback used to invoke + server authorization check API. The implementation of this method has to + be non-blocking, but can be performed synchronously or asynchronously. + 1)If processing occurs synchronously, it populates arg->result, + arg->status, and arg->error_details and returns zero. + 2) If processing occurs asynchronously, it returns a non-zero value. The + application then invokes arg->cb when processing is completed. Note that + arg->cb cannot be invoked before schedule API returns. + - cancel is a pointer to an application-provided callback used to cancel a + server authorization check request scheduled via an asynchronous schedule + API. arg is used to pinpoint an exact check request to be cancelled. The + operation may not have any effect if the request has already been + processed. + - destruct is a pointer to an application-provided callback used to clean up + any data associated with the config. + It is used for experimental purpose for now and subject to change. +*/ +GRPCAPI grpc_tls_server_authorization_check_config* +grpc_tls_server_authorization_check_config_create( + const void* config_user_data, + int (*schedule)(void* config_user_data, + grpc_tls_server_authorization_check_arg* arg), + void (*cancel)(void* config_user_data, + grpc_tls_server_authorization_check_arg* arg), + void (*destruct)(void* config_user_data)); + +/** + * Releases a grpc_tls_server_authorization_check_config object. The creator of + * the grpc_tls_server_authorization_check_config object is responsible for its + * release. It is used for experimental purpose for now and subject to change. + */ +GRPCAPI void grpc_tls_server_authorization_check_config_release( + grpc_tls_server_authorization_check_config* config); + +/** + * Creates a TLS channel credential object based on the + * grpc_tls_credentials_options specified by callers. The + * grpc_channel_credentials will take the ownership of the |options|. The + * security level of the resulting connection is GRPC_PRIVACY_AND_INTEGRITY. It + * is used for experimental purpose for now and subject to change. + */ +grpc_channel_credentials* grpc_tls_credentials_create( + grpc_tls_credentials_options* options); + +/** + * Creates a TLS server credential object based on the + * grpc_tls_credentials_options specified by callers. The + * grpc_server_credentials will take the ownership of the |options|. It + * is used for experimental purpose for now and subject to change. + */ +grpc_server_credentials* grpc_tls_server_credentials_create( + grpc_tls_credentials_options* options); + +/** + * EXPERIMENTAL API - Subject to change + * + * This method creates an insecure channel credentials object. + */ +grpc_channel_credentials* grpc_insecure_credentials_create(); + +/** + * EXPERIMENTAL API - Subject to change + * + * This method creates an insecure server credentials object. + */ +grpc_server_credentials* grpc_insecure_server_credentials_create(); + +/** + * EXPERIMENTAL API - Subject to change + * + * This method creates an xDS channel credentials object. + * + * Creating a channel with credentials of this type indicates that the channel + * should get credentials configuration from the xDS control plane. + * + * \a fallback_credentials are used if the channel target does not have the + * 'xds:///' scheme or if the xDS control plane does not provide information on + * how to fetch credentials dynamically. Does NOT take ownership of the \a + * fallback_credentials. (Internally takes a ref to the object.) + */ +GRPCAPI grpc_channel_credentials* grpc_xds_credentials_create( + grpc_channel_credentials* fallback_credentials); + +/** + * EXPERIMENTAL API - Subject to change + * + * This method creates an xDS server credentials object. + * + * \a fallback_credentials are used if the xDS control plane does not provide + * information on how to fetch credentials dynamically. + * + * Does NOT take ownership of the \a fallback_credentials. (Internally takes + * a ref to the object.) + */ +GRPCAPI grpc_server_credentials* grpc_xds_server_credentials_create( + grpc_server_credentials* fallback_credentials); + +#ifdef __cplusplus +} +#endif + +#endif /* GRPC_GRPC_SECURITY_H */ diff --git a/grpc/spm-core-include/grpc/grpc_security_constants.h b/grpc/spm-core-include/grpc/grpc_security_constants.h new file mode 100644 index 00000000..a62f7675 --- /dev/null +++ b/grpc/spm-core-include/grpc/grpc_security_constants.h @@ -0,0 +1,149 @@ +/* + * + * Copyright 2016 gRPC authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#ifndef GRPC_GRPC_SECURITY_CONSTANTS_H +#define GRPC_GRPC_SECURITY_CONSTANTS_H + +#ifdef __cplusplus +extern "C" { +#endif + +#define GRPC_TRANSPORT_SECURITY_TYPE_PROPERTY_NAME "transport_security_type" +#define GRPC_SSL_TRANSPORT_SECURITY_TYPE "ssl" + +#define GRPC_X509_CN_PROPERTY_NAME "x509_common_name" +#define GRPC_X509_SAN_PROPERTY_NAME "x509_subject_alternative_name" +#define GRPC_X509_PEM_CERT_PROPERTY_NAME "x509_pem_cert" +#define GRPC_X509_PEM_CERT_CHAIN_PROPERTY_NAME "x509_pem_cert_chain" +#define GRPC_SSL_SESSION_REUSED_PROPERTY "ssl_session_reused" +#define GRPC_TRANSPORT_SECURITY_LEVEL_PROPERTY_NAME "security_level" +#define GRPC_PEER_SPIFFE_ID_PROPERTY_NAME "peer_spiffe_id" + +/** Environment variable that points to the default SSL roots file. This file + must be a PEM encoded file with all the roots such as the one that can be + downloaded from https://pki.google.com/roots.pem. */ +#define GRPC_DEFAULT_SSL_ROOTS_FILE_PATH_ENV_VAR \ + "GRPC_DEFAULT_SSL_ROOTS_FILE_PATH" + +/** Environment variable that points to the google default application + credentials json key or refresh token. Used in the + grpc_google_default_credentials_create function. */ +#define GRPC_GOOGLE_CREDENTIALS_ENV_VAR "GOOGLE_APPLICATION_CREDENTIALS" + +/** Results for the SSL roots override callback. */ +typedef enum { + GRPC_SSL_ROOTS_OVERRIDE_OK, + GRPC_SSL_ROOTS_OVERRIDE_FAIL_PERMANENTLY, /** Do not try fallback options. */ + GRPC_SSL_ROOTS_OVERRIDE_FAIL +} grpc_ssl_roots_override_result; + +/** Callback results for dynamically loading a SSL certificate config. */ +typedef enum { + GRPC_SSL_CERTIFICATE_CONFIG_RELOAD_UNCHANGED, + GRPC_SSL_CERTIFICATE_CONFIG_RELOAD_NEW, + GRPC_SSL_CERTIFICATE_CONFIG_RELOAD_FAIL +} grpc_ssl_certificate_config_reload_status; + +typedef enum { + /** Server does not request client certificate. + The certificate presented by the client is not checked by the server at + all. (A client may present a self signed or signed certificate or not + present a certificate at all and any of those option would be accepted) */ + GRPC_SSL_DONT_REQUEST_CLIENT_CERTIFICATE, + /** Server requests client certificate but does not enforce that the client + presents a certificate. + + If the client presents a certificate, the client authentication is left to + the application (the necessary metadata will be available to the + application via authentication context properties, see grpc_auth_context). + + The client's key certificate pair must be valid for the SSL connection to + be established. */ + GRPC_SSL_REQUEST_CLIENT_CERTIFICATE_BUT_DONT_VERIFY, + /** Server requests client certificate but does not enforce that the client + presents a certificate. + + If the client presents a certificate, the client authentication is done by + the gRPC framework. (For a successful connection the client needs to either + present a certificate that can be verified against the root certificate + configured by the server or not present a certificate at all) + + The client's key certificate pair must be valid for the SSL connection to + be established. */ + GRPC_SSL_REQUEST_CLIENT_CERTIFICATE_AND_VERIFY, + /** Server requests client certificate and enforces that the client presents a + certificate. + + If the client presents a certificate, the client authentication is left to + the application (the necessary metadata will be available to the + application via authentication context properties, see grpc_auth_context). + + The client's key certificate pair must be valid for the SSL connection to + be established. */ + GRPC_SSL_REQUEST_AND_REQUIRE_CLIENT_CERTIFICATE_BUT_DONT_VERIFY, + /** Server requests client certificate and enforces that the client presents a + certificate. + + The certificate presented by the client is verified by the gRPC framework. + (For a successful connection the client needs to present a certificate that + can be verified against the root certificate configured by the server) + + The client's key certificate pair must be valid for the SSL connection to + be established. */ + GRPC_SSL_REQUEST_AND_REQUIRE_CLIENT_CERTIFICATE_AND_VERIFY +} grpc_ssl_client_certificate_request_type; + +/* Security levels of grpc transport security. It represents an inherent + * property of a backend connection and is determined by a channel credential + * used to create the connection. */ +typedef enum { + GRPC_SECURITY_MIN, + GRPC_SECURITY_NONE = GRPC_SECURITY_MIN, + GRPC_INTEGRITY_ONLY, + GRPC_PRIVACY_AND_INTEGRITY, + GRPC_SECURITY_MAX = GRPC_PRIVACY_AND_INTEGRITY, +} grpc_security_level; + +typedef enum { + /** Default option: performs server certificate verification and hostname + verification. */ + GRPC_TLS_SERVER_VERIFICATION, + /** Performs server certificate verification, but skips hostname verification + Client is responsible for verifying server's identity via + server authorization check callback. */ + GRPC_TLS_SKIP_HOSTNAME_VERIFICATION, + /** Skips both server certificate and hostname verification. + Client is responsible for verifying server's identity and + server's certificate via server authorization check callback. */ + GRPC_TLS_SKIP_ALL_SERVER_VERIFICATION +} grpc_tls_server_verification_option; + +/** + * Type of local connections for which local channel/server credentials will be + * applied. It supports UDS and local TCP connections. + */ +typedef enum { UDS = 0, LOCAL_TCP } grpc_local_connect_type; + +/** The TLS versions that are supported by the SSL stack. **/ +typedef enum { TLS1_2, TLS1_3 } grpc_tls_version; + +#ifdef __cplusplus +} +#endif + +#endif /* GRPC_GRPC_SECURITY_CONSTANTS_H */ diff --git a/grpc/spm-core-include/grpc/impl/codegen/README.md b/grpc/spm-core-include/grpc/impl/codegen/README.md new file mode 100644 index 00000000..1bafd001 --- /dev/null +++ b/grpc/spm-core-include/grpc/impl/codegen/README.md @@ -0,0 +1,22 @@ +# Welcome to `include/grpc/impl/codegen` + +## Why is this directory here? + +This directory exists so that generated C++ code can include selected files upon +which it depends without having to depend on the entire gRPC C++ library. This +directory thus exists to support `include/grpcpp/impl/codegen`. This constraint +is particularly relevant for users of bazel, particularly if they use the +multi-lingual `proto_library` target type. Generated code that uses this target +only depends on the gRPC C++ targets associated with these header files, not the +entire gRPC C++ codebase since that would make the build time of these types of +targets excessively large (particularly when they are not even C++ specific). + +## What should user code do? + +User code should *not* include anything from this directory. Only generated code +and gRPC library code should include contents from this directory. C++ user code +should instead include contents from the main `grpcpp` directory or its +accessible subcomponents like `grpcpp/support`. It is possible that we may +remove this directory altogether if the motivations for its existence are no +longer strong enough (e.g., if the gRPC C++ library no longer has a need for an +`impl/codegen` directory of its own). diff --git a/grpc/spm-core-include/grpc/impl/codegen/atm.h b/grpc/spm-core-include/grpc/impl/codegen/atm.h new file mode 100644 index 00000000..00d83f06 --- /dev/null +++ b/grpc/spm-core-include/grpc/impl/codegen/atm.h @@ -0,0 +1,95 @@ +/* + * + * Copyright 2015 gRPC authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#ifndef GRPC_IMPL_CODEGEN_ATM_H +#define GRPC_IMPL_CODEGEN_ATM_H + +/** This interface provides atomic operations and barriers. + It is internal to gpr support code and should not be used outside it. + + If an operation with acquire semantics precedes another memory access by the + same thread, the operation will precede that other access as seen by other + threads. + + If an operation with release semantics follows another memory access by the + same thread, the operation will follow that other access as seen by other + threads. + + Routines with "acq" or "full" in the name have acquire semantics. Routines + with "rel" or "full" in the name have release semantics. Routines with + "no_barrier" in the name have neither acquire not release semantics. + + The routines may be implemented as macros. + + // Atomic operations act on an intergral_type gpr_atm that is guaranteed to + // be the same size as a pointer. + typedef intptr_t gpr_atm; + + // A memory barrier, providing both acquire and release semantics, but not + // otherwise acting on memory. + void gpr_atm_full_barrier(void); + + // Atomically return *p, with acquire semantics. + gpr_atm gpr_atm_acq_load(gpr_atm *p); + gpr_atm gpr_atm_no_barrier_load(gpr_atm *p); + + // Atomically set *p = value, with release semantics. + void gpr_atm_rel_store(gpr_atm *p, gpr_atm value); + + // Atomically add delta to *p, and return the old value of *p, with + // the barriers specified. + gpr_atm gpr_atm_no_barrier_fetch_add(gpr_atm *p, gpr_atm delta); + gpr_atm gpr_atm_full_fetch_add(gpr_atm *p, gpr_atm delta); + + // Atomically, if *p==o, set *p=n and return non-zero otherwise return 0, + // with the barriers specified if the operation succeeds. + int gpr_atm_no_barrier_cas(gpr_atm *p, gpr_atm o, gpr_atm n); + int gpr_atm_acq_cas(gpr_atm *p, gpr_atm o, gpr_atm n); + int gpr_atm_rel_cas(gpr_atm *p, gpr_atm o, gpr_atm n); + int gpr_atm_full_cas(gpr_atm *p, gpr_atm o, gpr_atm n); + + // Atomically, set *p=n and return the old value of *p + gpr_atm gpr_atm_full_xchg(gpr_atm *p, gpr_atm n); +*/ + +#include <grpc/impl/codegen/port_platform.h> + +#if defined(GPR_GCC_ATOMIC) +#include <grpc/impl/codegen/atm_gcc_atomic.h> +#elif defined(GPR_GCC_SYNC) +#include <grpc/impl/codegen/atm_gcc_sync.h> +#elif defined(GPR_WINDOWS_ATOMIC) +#include <grpc/impl/codegen/atm_windows.h> +#else +#error could not determine platform for atm +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +/** Adds \a delta to \a *value, clamping the result to the range specified + by \a min and \a max. Returns the new value. */ +gpr_atm gpr_atm_no_barrier_clamped_add(gpr_atm* value, gpr_atm delta, + gpr_atm min, gpr_atm max); + +#ifdef __cplusplus +} +#endif + +#endif /* GRPC_IMPL_CODEGEN_ATM_H */ diff --git a/grpc/spm-core-include/grpc/impl/codegen/atm_gcc_atomic.h b/grpc/spm-core-include/grpc/impl/codegen/atm_gcc_atomic.h new file mode 100644 index 00000000..58797085 --- /dev/null +++ b/grpc/spm-core-include/grpc/impl/codegen/atm_gcc_atomic.h @@ -0,0 +1,91 @@ +/* + * + * Copyright 2015 gRPC authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#ifndef GRPC_IMPL_CODEGEN_ATM_GCC_ATOMIC_H +#define GRPC_IMPL_CODEGEN_ATM_GCC_ATOMIC_H + +/* atm_platform.h for gcc and gcc-like compilers with the + __atomic_* interface. */ +#include <grpc/impl/codegen/port_platform.h> + +#ifdef __cplusplus +extern "C" { +#endif + +typedef intptr_t gpr_atm; +#define GPR_ATM_MAX INTPTR_MAX +#define GPR_ATM_MIN INTPTR_MIN + +#ifdef GPR_LOW_LEVEL_COUNTERS +extern gpr_atm gpr_counter_atm_cas; +extern gpr_atm gpr_counter_atm_add; +#define GPR_ATM_INC_COUNTER(counter) \ + __atomic_fetch_add(&counter, 1, __ATOMIC_RELAXED) +#define GPR_ATM_INC_CAS_THEN(blah) \ + (GPR_ATM_INC_COUNTER(gpr_counter_atm_cas), blah) +#define GPR_ATM_INC_ADD_THEN(blah) \ + (GPR_ATM_INC_COUNTER(gpr_counter_atm_add), blah) +#else +#define GPR_ATM_INC_CAS_THEN(blah) blah +#define GPR_ATM_INC_ADD_THEN(blah) blah +#endif + +#define gpr_atm_full_barrier() (__atomic_thread_fence(__ATOMIC_SEQ_CST)) + +#define gpr_atm_acq_load(p) (__atomic_load_n((p), __ATOMIC_ACQUIRE)) +#define gpr_atm_no_barrier_load(p) (__atomic_load_n((p), __ATOMIC_RELAXED)) +#define gpr_atm_rel_store(p, value) \ + (__atomic_store_n((p), (intptr_t)(value), __ATOMIC_RELEASE)) +#define gpr_atm_no_barrier_store(p, value) \ + (__atomic_store_n((p), (intptr_t)(value), __ATOMIC_RELAXED)) + +#define gpr_atm_no_barrier_fetch_add(p, delta) \ + GPR_ATM_INC_ADD_THEN( \ + __atomic_fetch_add((p), (intptr_t)(delta), __ATOMIC_RELAXED)) +#define gpr_atm_full_fetch_add(p, delta) \ + GPR_ATM_INC_ADD_THEN( \ + __atomic_fetch_add((p), (intptr_t)(delta), __ATOMIC_ACQ_REL)) + +static __inline int gpr_atm_no_barrier_cas(gpr_atm* p, gpr_atm o, gpr_atm n) { + return GPR_ATM_INC_CAS_THEN(__atomic_compare_exchange_n( + p, &o, n, 0, __ATOMIC_RELAXED, __ATOMIC_RELAXED)); +} + +static __inline int gpr_atm_acq_cas(gpr_atm* p, gpr_atm o, gpr_atm n) { + return GPR_ATM_INC_CAS_THEN(__atomic_compare_exchange_n( + p, &o, n, 0, __ATOMIC_ACQUIRE, __ATOMIC_RELAXED)); +} + +static __inline int gpr_atm_rel_cas(gpr_atm* p, gpr_atm o, gpr_atm n) { + return GPR_ATM_INC_CAS_THEN(__atomic_compare_exchange_n( + p, &o, n, 0, __ATOMIC_RELEASE, __ATOMIC_RELAXED)); +} + +static __inline int gpr_atm_full_cas(gpr_atm* p, gpr_atm o, gpr_atm n) { + return GPR_ATM_INC_CAS_THEN(__atomic_compare_exchange_n( + p, &o, n, 0, __ATOMIC_ACQ_REL, __ATOMIC_RELAXED)); +} + +#define gpr_atm_full_xchg(p, n) \ + GPR_ATM_INC_CAS_THEN(__atomic_exchange_n((p), (n), __ATOMIC_ACQ_REL)) + +#ifdef __cplusplus +} +#endif + +#endif /* GRPC_IMPL_CODEGEN_ATM_GCC_ATOMIC_H */ diff --git a/grpc/spm-core-include/grpc/impl/codegen/atm_gcc_sync.h b/grpc/spm-core-include/grpc/impl/codegen/atm_gcc_sync.h new file mode 100644 index 00000000..728c3d54 --- /dev/null +++ b/grpc/spm-core-include/grpc/impl/codegen/atm_gcc_sync.h @@ -0,0 +1,85 @@ +/* + * + * Copyright 2015 gRPC authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#ifndef GRPC_IMPL_CODEGEN_ATM_GCC_SYNC_H +#define GRPC_IMPL_CODEGEN_ATM_GCC_SYNC_H + +/* variant of atm_platform.h for gcc and gcc-like compiers with __sync_* + interface */ +#include <grpc/impl/codegen/port_platform.h> + +typedef intptr_t gpr_atm; +#define GPR_ATM_MAX INTPTR_MAX +#define GPR_ATM_MIN INTPTR_MIN +#define GPR_ATM_INC_CAS_THEN(blah) blah +#define GPR_ATM_INC_ADD_THEN(blah) blah + +#define GPR_ATM_COMPILE_BARRIER_() __asm__ __volatile__("" : : : "memory") + +#if defined(__i386) || defined(__x86_64__) +/* All loads are acquire loads and all stores are release stores. */ +#define GPR_ATM_LS_BARRIER_() GPR_ATM_COMPILE_BARRIER_() +#else +#define GPR_ATM_LS_BARRIER_() gpr_atm_full_barrier() +#endif + +#define gpr_atm_full_barrier() (__sync_synchronize()) + +static __inline gpr_atm gpr_atm_acq_load(const gpr_atm* p) { + gpr_atm value = *p; + GPR_ATM_LS_BARRIER_(); + return value; +} + +static __inline gpr_atm gpr_atm_no_barrier_load(const gpr_atm* p) { + gpr_atm value = *p; + GPR_ATM_COMPILE_BARRIER_(); + return value; +} + +static __inline void gpr_atm_rel_store(gpr_atm* p, gpr_atm value) { + GPR_ATM_LS_BARRIER_(); + *p = value; +} + +static __inline void gpr_atm_no_barrier_store(gpr_atm* p, gpr_atm value) { + GPR_ATM_COMPILE_BARRIER_(); + *p = value; +} + +#undef GPR_ATM_LS_BARRIER_ +#undef GPR_ATM_COMPILE_BARRIER_ + +#define gpr_atm_no_barrier_fetch_add(p, delta) \ + gpr_atm_full_fetch_add((p), (delta)) +#define gpr_atm_full_fetch_add(p, delta) (__sync_fetch_and_add((p), (delta))) + +#define gpr_atm_no_barrier_cas(p, o, n) gpr_atm_acq_cas((p), (o), (n)) +#define gpr_atm_acq_cas(p, o, n) (__sync_bool_compare_and_swap((p), (o), (n))) +#define gpr_atm_rel_cas(p, o, n) gpr_atm_acq_cas((p), (o), (n)) +#define gpr_atm_full_cas(p, o, n) gpr_atm_acq_cas((p), (o), (n)) + +static __inline gpr_atm gpr_atm_full_xchg(gpr_atm* p, gpr_atm n) { + gpr_atm cur; + do { + cur = gpr_atm_acq_load(p); + } while (!gpr_atm_rel_cas(p, cur, n)); + return cur; +} + +#endif /* GRPC_IMPL_CODEGEN_ATM_GCC_SYNC_H */ diff --git a/grpc/spm-core-include/grpc/impl/codegen/atm_windows.h b/grpc/spm-core-include/grpc/impl/codegen/atm_windows.h new file mode 100644 index 00000000..36c76ab6 --- /dev/null +++ b/grpc/spm-core-include/grpc/impl/codegen/atm_windows.h @@ -0,0 +1,132 @@ +/* + * + * Copyright 2015 gRPC authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#ifndef GRPC_IMPL_CODEGEN_ATM_WINDOWS_H +#define GRPC_IMPL_CODEGEN_ATM_WINDOWS_H + +/** Win32 variant of atm_platform.h */ +#include <grpc/impl/codegen/port_platform.h> + +#ifdef GPR_WINDOWS + +typedef intptr_t gpr_atm; +#define GPR_ATM_MAX INTPTR_MAX +#define GPR_ATM_MIN INTPTR_MIN +#define GPR_ATM_INC_CAS_THEN(blah) blah +#define GPR_ATM_INC_ADD_THEN(blah) blah + +#define gpr_atm_full_barrier MemoryBarrier + +static __inline gpr_atm gpr_atm_acq_load(const gpr_atm* p) { + gpr_atm result = *p; + gpr_atm_full_barrier(); + return result; +} + +static __inline gpr_atm gpr_atm_no_barrier_load(const gpr_atm* p) { + /* TODO(dklempner): Can we implement something better here? */ + return gpr_atm_acq_load(p); +} + +static __inline void gpr_atm_rel_store(gpr_atm* p, gpr_atm value) { + gpr_atm_full_barrier(); + *p = value; +} + +static __inline void gpr_atm_no_barrier_store(gpr_atm* p, gpr_atm value) { + /* TODO(ctiller): Can we implement something better here? */ + gpr_atm_rel_store(p, value); +} + +static __inline int gpr_atm_no_barrier_cas(gpr_atm* p, gpr_atm o, gpr_atm n) { +/** InterlockedCompareExchangePointerNoFence() not available on vista or + windows7 */ +#ifdef GPR_ARCH_64 + return o == (gpr_atm)InterlockedCompareExchangeAcquire64( + (volatile LONGLONG*)p, (LONGLONG)n, (LONGLONG)o); +#else + return o == (gpr_atm)InterlockedCompareExchangeAcquire((volatile LONG*)p, + (LONG)n, (LONG)o); +#endif +} + +static __inline int gpr_atm_acq_cas(gpr_atm* p, gpr_atm o, gpr_atm n) { +#ifdef GPR_ARCH_64 + return o == (gpr_atm)InterlockedCompareExchangeAcquire64( + (volatile LONGLONG*)p, (LONGLONG)n, (LONGLONG)o); +#else + return o == (gpr_atm)InterlockedCompareExchangeAcquire((volatile LONG*)p, + (LONG)n, (LONG)o); +#endif +} + +static __inline int gpr_atm_rel_cas(gpr_atm* p, gpr_atm o, gpr_atm n) { +#ifdef GPR_ARCH_64 + return o == (gpr_atm)InterlockedCompareExchangeRelease64( + (volatile LONGLONG*)p, (LONGLONG)n, (LONGLONG)o); +#else + return o == (gpr_atm)InterlockedCompareExchangeRelease((volatile LONG*)p, + (LONG)n, (LONG)o); +#endif +} + +static __inline int gpr_atm_full_cas(gpr_atm* p, gpr_atm o, gpr_atm n) { +#ifdef GPR_ARCH_64 + return o == (gpr_atm)InterlockedCompareExchange64((volatile LONGLONG*)p, + (LONGLONG)n, (LONGLONG)o); +#else + return o == (gpr_atm)InterlockedCompareExchange((volatile LONG*)p, (LONG)n, + (LONG)o); +#endif +} + +static __inline gpr_atm gpr_atm_no_barrier_fetch_add(gpr_atm* p, + gpr_atm delta) { + /** Use the CAS operation to get pointer-sized fetch and add */ + gpr_atm old; + do { + old = *p; + } while (!gpr_atm_no_barrier_cas(p, old, old + delta)); + return old; +} + +static __inline gpr_atm gpr_atm_full_fetch_add(gpr_atm* p, gpr_atm delta) { + /** Use a CAS operation to get pointer-sized fetch and add */ + gpr_atm old; +#ifdef GPR_ARCH_64 + do { + old = *p; + } while (old != (gpr_atm)InterlockedCompareExchange64((volatile LONGLONG*)p, + (LONGLONG)old + delta, + (LONGLONG)old)); +#else + do { + old = *p; + } while (old != (gpr_atm)InterlockedCompareExchange( + (volatile LONG*)p, (LONG)old + delta, (LONG)old)); +#endif + return old; +} + +static __inline gpr_atm gpr_atm_full_xchg(gpr_atm* p, gpr_atm n) { + return (gpr_atm)InterlockedExchangePointer((PVOID*)p, (PVOID)n); +} + +#endif /* GPR_WINDOWS */ + +#endif /* GRPC_IMPL_CODEGEN_ATM_WINDOWS_H */ diff --git a/grpc/spm-core-include/grpc/impl/codegen/byte_buffer.h b/grpc/spm-core-include/grpc/impl/codegen/byte_buffer.h new file mode 100644 index 00000000..04137292 --- /dev/null +++ b/grpc/spm-core-include/grpc/impl/codegen/byte_buffer.h @@ -0,0 +1,101 @@ +/* + * + * Copyright 2015 gRPC authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#ifndef GRPC_IMPL_CODEGEN_BYTE_BUFFER_H +#define GRPC_IMPL_CODEGEN_BYTE_BUFFER_H + +#include <grpc/impl/codegen/port_platform.h> + +#include <grpc/impl/codegen/grpc_types.h> + +#ifdef __cplusplus +extern "C" { +#endif + +/** Returns a RAW byte buffer instance over the given slices (up to \a nslices). + * + * Increases the reference count for all \a slices processed. The user is + * responsible for invoking grpc_byte_buffer_destroy on the returned instance.*/ +GRPCAPI grpc_byte_buffer* grpc_raw_byte_buffer_create(grpc_slice* slices, + size_t nslices); + +/** Returns a *compressed* RAW byte buffer instance over the given slices (up to + * \a nslices). The \a compression argument defines the compression algorithm + * used to generate the data in \a slices. + * + * Increases the reference count for all \a slices processed. The user is + * responsible for invoking grpc_byte_buffer_destroy on the returned instance.*/ +GRPCAPI grpc_byte_buffer* grpc_raw_compressed_byte_buffer_create( + grpc_slice* slices, size_t nslices, grpc_compression_algorithm compression); + +/** Copies input byte buffer \a bb. + * + * Increases the reference count of all the source slices. The user is + * responsible for calling grpc_byte_buffer_destroy over the returned copy. */ +GRPCAPI grpc_byte_buffer* grpc_byte_buffer_copy(grpc_byte_buffer* bb); + +/** Returns the size of the given byte buffer, in bytes. */ +GRPCAPI size_t grpc_byte_buffer_length(grpc_byte_buffer* bb); + +/** Destroys \a byte_buffer deallocating all its memory. */ +GRPCAPI void grpc_byte_buffer_destroy(grpc_byte_buffer* bb); + +/** Reader for byte buffers. Iterates over slices in the byte buffer */ +struct grpc_byte_buffer_reader; +typedef struct grpc_byte_buffer_reader grpc_byte_buffer_reader; + +/** Initialize \a reader to read over \a buffer. + * Returns 1 upon success, 0 otherwise. */ +GRPCAPI int grpc_byte_buffer_reader_init(grpc_byte_buffer_reader* reader, + grpc_byte_buffer* buffer); + +/** Cleanup and destroy \a reader */ +GRPCAPI void grpc_byte_buffer_reader_destroy(grpc_byte_buffer_reader* reader); + +/** Updates \a slice with the next piece of data from from \a reader and returns + * 1. Returns 0 at the end of the stream. Caller is responsible for calling + * grpc_slice_unref on the result. */ +GRPCAPI int grpc_byte_buffer_reader_next(grpc_byte_buffer_reader* reader, + grpc_slice* slice); + +/** EXPERIMENTAL API - This function may be removed and changed, in the future. + * + * Updates \a slice with the next piece of data from from \a reader and returns + * 1. Returns 0 at the end of the stream. Caller is responsible for making sure + * the slice pointer remains valid when accessed. + * + * NOTE: Do not use this function unless the caller can guarantee that the + * underlying grpc_byte_buffer outlasts the use of the slice. This is only + * safe when the underlying grpc_byte_buffer remains immutable while slice + * is being accessed. */ +GRPCAPI int grpc_byte_buffer_reader_peek(grpc_byte_buffer_reader* reader, + grpc_slice** slice); + +/** Merge all data from \a reader into single slice */ +GRPCAPI grpc_slice +grpc_byte_buffer_reader_readall(grpc_byte_buffer_reader* reader); + +/** Returns a RAW byte buffer instance from the output of \a reader. */ +GRPCAPI grpc_byte_buffer* grpc_raw_byte_buffer_from_reader( + grpc_byte_buffer_reader* reader); + +#ifdef __cplusplus +} +#endif + +#endif /* GRPC_IMPL_CODEGEN_BYTE_BUFFER_H */ diff --git a/grpc/spm-core-include/grpc/impl/codegen/byte_buffer_reader.h b/grpc/spm-core-include/grpc/impl/codegen/byte_buffer_reader.h new file mode 100644 index 00000000..e06e1955 --- /dev/null +++ b/grpc/spm-core-include/grpc/impl/codegen/byte_buffer_reader.h @@ -0,0 +1,42 @@ +/* + * + * Copyright 2015 gRPC authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#ifndef GRPC_IMPL_CODEGEN_BYTE_BUFFER_READER_H +#define GRPC_IMPL_CODEGEN_BYTE_BUFFER_READER_H + +#ifdef __cplusplus +extern "C" { +#endif + +struct grpc_byte_buffer; + +struct grpc_byte_buffer_reader { + struct grpc_byte_buffer* buffer_in; + struct grpc_byte_buffer* buffer_out; + /** Different current objects correspond to different types of byte buffers */ + union grpc_byte_buffer_reader_current { + /** Index into a slice buffer's array of slices */ + unsigned index; + } current; +}; + +#ifdef __cplusplus +} +#endif + +#endif /* GRPC_IMPL_CODEGEN_BYTE_BUFFER_READER_H */ diff --git a/grpc/spm-core-include/grpc/impl/codegen/compression_types.h b/grpc/spm-core-include/grpc/impl/codegen/compression_types.h new file mode 100644 index 00000000..f778b005 --- /dev/null +++ b/grpc/spm-core-include/grpc/impl/codegen/compression_types.h @@ -0,0 +1,108 @@ +/* + * + * Copyright 2016 gRPC authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#ifndef GRPC_IMPL_CODEGEN_COMPRESSION_TYPES_H +#define GRPC_IMPL_CODEGEN_COMPRESSION_TYPES_H + +#include <grpc/impl/codegen/port_platform.h> + +#ifdef __cplusplus +extern "C" { +#endif + +/** To be used as initial metadata key for the request of a concrete compression + * algorithm */ +#define GRPC_COMPRESSION_REQUEST_ALGORITHM_MD_KEY \ + "grpc-internal-encoding-request" + +/** To be used in channel arguments. + * + * \addtogroup grpc_arg_keys + * \{ */ +/** Default compression algorithm for the channel. + * Its value is an int from the \a grpc_compression_algorithm enum. */ +#define GRPC_COMPRESSION_CHANNEL_DEFAULT_ALGORITHM \ + "grpc.default_compression_algorithm" +/** Default compression level for the channel. + * Its value is an int from the \a grpc_compression_level enum. */ +#define GRPC_COMPRESSION_CHANNEL_DEFAULT_LEVEL "grpc.default_compression_level" +/** Compression algorithms supported by the channel. + * Its value is a bitset (an int). Bits correspond to algorithms in \a + * grpc_compression_algorithm. For example, its LSB corresponds to + * GRPC_COMPRESS_NONE, the next bit to GRPC_COMPRESS_DEFLATE, etc. + * Unset bits disable support for the algorithm. By default all algorithms are + * supported. It's not possible to disable GRPC_COMPRESS_NONE (the attempt will + * be ignored). */ +#define GRPC_COMPRESSION_CHANNEL_ENABLED_ALGORITHMS_BITSET \ + "grpc.compression_enabled_algorithms_bitset" +/** \} */ + +/** The various compression algorithms supported by gRPC (not sorted by + * compression level) */ +typedef enum { + GRPC_COMPRESS_NONE = 0, + GRPC_COMPRESS_DEFLATE, + GRPC_COMPRESS_GZIP, + /* EXPERIMENTAL: Stream compression is currently experimental. */ + GRPC_COMPRESS_STREAM_GZIP, + /* TODO(ctiller): snappy */ + GRPC_COMPRESS_ALGORITHMS_COUNT +} grpc_compression_algorithm; + +/** Compression levels allow a party with knowledge of its peer's accepted + * encodings to request compression in an abstract way. The level-algorithm + * mapping is performed internally and depends on the peer's supported + * compression algorithms. */ +typedef enum { + GRPC_COMPRESS_LEVEL_NONE = 0, + GRPC_COMPRESS_LEVEL_LOW, + GRPC_COMPRESS_LEVEL_MED, + GRPC_COMPRESS_LEVEL_HIGH, + GRPC_COMPRESS_LEVEL_COUNT +} grpc_compression_level; + +typedef struct grpc_compression_options { + /** All algs are enabled by default. This option corresponds to the channel + * argument key behind \a GRPC_COMPRESSION_CHANNEL_ENABLED_ALGORITHMS_BITSET + */ + uint32_t enabled_algorithms_bitset; + + /** The default compression level. It'll be used in the absence of call + * specific settings. This option corresponds to the channel + * argument key behind \a GRPC_COMPRESSION_CHANNEL_DEFAULT_LEVEL. If present, + * takes precedence over \a default_algorithm. + * TODO(dgq): currently only available for server channels. */ + struct grpc_compression_options_default_level { + int is_set; + grpc_compression_level level; + } default_level; + + /** The default message compression algorithm. It'll be used in the absence of + * call specific settings. This option corresponds to the channel argument key + * behind \a GRPC_COMPRESSION_CHANNEL_DEFAULT_ALGORITHM. */ + struct grpc_compression_options_default_algorithm { + int is_set; + grpc_compression_algorithm algorithm; + } default_algorithm; +} grpc_compression_options; + +#ifdef __cplusplus +} +#endif + +#endif /* GRPC_IMPL_CODEGEN_COMPRESSION_TYPES_H */ diff --git a/grpc/spm-core-include/grpc/impl/codegen/connectivity_state.h b/grpc/spm-core-include/grpc/impl/codegen/connectivity_state.h new file mode 100644 index 00000000..b70dbef3 --- /dev/null +++ b/grpc/spm-core-include/grpc/impl/codegen/connectivity_state.h @@ -0,0 +1,44 @@ +/* + * + * Copyright 2016 gRPC authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#ifndef GRPC_IMPL_CODEGEN_CONNECTIVITY_STATE_H +#define GRPC_IMPL_CODEGEN_CONNECTIVITY_STATE_H + +#ifdef __cplusplus +extern "C" { +#endif + +/** Connectivity state of a channel. */ +typedef enum { + /** channel is idle */ + GRPC_CHANNEL_IDLE, + /** channel is connecting */ + GRPC_CHANNEL_CONNECTING, + /** channel is ready for work */ + GRPC_CHANNEL_READY, + /** channel has seen a failure but expects to recover */ + GRPC_CHANNEL_TRANSIENT_FAILURE, + /** channel has seen a failure that it cannot recover from */ + GRPC_CHANNEL_SHUTDOWN +} grpc_connectivity_state; + +#ifdef __cplusplus +} +#endif + +#endif /* GRPC_IMPL_CODEGEN_CONNECTIVITY_STATE_H */ diff --git a/grpc/spm-core-include/grpc/impl/codegen/fork.h b/grpc/spm-core-include/grpc/impl/codegen/fork.h new file mode 100644 index 00000000..555df349 --- /dev/null +++ b/grpc/spm-core-include/grpc/impl/codegen/fork.h @@ -0,0 +1,48 @@ +/* + * + * Copyright 2017 gRPC authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#ifndef GRPC_IMPL_CODEGEN_FORK_H +#define GRPC_IMPL_CODEGEN_FORK_H + +/** + * gRPC applications should call this before calling fork(). There should be no + * active gRPC function calls between calling grpc_prefork() and + * grpc_postfork_parent()/grpc_postfork_child(). + * + * + * Typical use: + * grpc_prefork(); + * int pid = fork(); + * if (pid) { + * grpc_postfork_parent(); + * // Parent process.. + * } else { + * grpc_postfork_child(); + * // Child process... + * } + */ + +void grpc_prefork(void); + +void grpc_postfork_parent(void); + +void grpc_postfork_child(void); + +void grpc_fork_handlers_auto_register(void); + +#endif /* GRPC_IMPL_CODEGEN_FORK_H */ diff --git a/grpc/spm-core-include/grpc/impl/codegen/gpr_slice.h b/grpc/spm-core-include/grpc/impl/codegen/gpr_slice.h new file mode 100644 index 00000000..89fa72d5 --- /dev/null +++ b/grpc/spm-core-include/grpc/impl/codegen/gpr_slice.h @@ -0,0 +1,69 @@ +/* + * + * Copyright 2016 gRPC authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ +#ifndef GRPC_IMPL_CODEGEN_GPR_SLICE_H +#define GRPC_IMPL_CODEGEN_GPR_SLICE_H + +/** WARNING: Please do not use this header. This was added as a temporary + * measure to not break some of the external projects that depend on + * gpr_slice_* functions. We are actively working on moving all the + * gpr_slice_* references to grpc_slice_* and this file will be removed + */ + +/* TODO (sreek) - Allowed by default but will be very soon turned off */ +#define GRPC_ALLOW_GPR_SLICE_FUNCTIONS 1 + +#ifdef GRPC_ALLOW_GPR_SLICE_FUNCTIONS + +#define gpr_slice_refcount grpc_slice_refcount +#define gpr_slice grpc_slice +#define gpr_slice_buffer grpc_slice_buffer + +#define gpr_slice_ref grpc_slice_ref +#define gpr_slice_unref grpc_slice_unref +#define gpr_slice_new grpc_slice_new +#define gpr_slice_new_with_user_data grpc_slice_new_with_user_data +#define gpr_slice_new_with_len grpc_slice_new_with_len +#define gpr_slice_malloc grpc_slice_malloc +#define gpr_slice_from_copied_string grpc_slice_from_copied_string +#define gpr_slice_from_copied_buffer grpc_slice_from_copied_buffer +#define gpr_slice_from_static_string grpc_slice_from_static_string +#define gpr_slice_sub grpc_slice_sub +#define gpr_slice_sub_no_ref grpc_slice_sub_no_ref +#define gpr_slice_split_tail grpc_slice_split_tail +#define gpr_slice_split_head grpc_slice_split_head +#define gpr_slice_cmp grpc_slice_cmp +#define gpr_slice_str_cmp grpc_slice_str_cmp + +#define gpr_slice_buffer grpc_slice_buffer +#define gpr_slice_buffer_init grpc_slice_buffer_init +#define gpr_slice_buffer_destroy grpc_slice_buffer_destroy +#define gpr_slice_buffer_add grpc_slice_buffer_add +#define gpr_slice_buffer_add_indexed grpc_slice_buffer_add_indexed +#define gpr_slice_buffer_addn grpc_slice_buffer_addn +#define gpr_slice_buffer_tiny_add grpc_slice_buffer_tiny_add +#define gpr_slice_buffer_pop grpc_slice_buffer_pop +#define gpr_slice_buffer_reset_and_unref grpc_slice_buffer_reset_and_unref +#define gpr_slice_buffer_swap grpc_slice_buffer_swap +#define gpr_slice_buffer_move_into grpc_slice_buffer_move_into +#define gpr_slice_buffer_trim_end grpc_slice_buffer_trim_end +#define gpr_slice_buffer_move_first grpc_slice_buffer_move_first +#define gpr_slice_buffer_take_first grpc_slice_buffer_take_first + +#endif /* GRPC_ALLOW_GPR_SLICE_FUNCTIONS */ + +#endif /* GRPC_IMPL_CODEGEN_GPR_SLICE_H */ diff --git a/grpc/spm-core-include/grpc/impl/codegen/gpr_types.h b/grpc/spm-core-include/grpc/impl/codegen/gpr_types.h new file mode 100644 index 00000000..6daf3398 --- /dev/null +++ b/grpc/spm-core-include/grpc/impl/codegen/gpr_types.h @@ -0,0 +1,59 @@ +/* + * + * Copyright 2016 gRPC authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#ifndef GRPC_IMPL_CODEGEN_GPR_TYPES_H +#define GRPC_IMPL_CODEGEN_GPR_TYPES_H + +#include <grpc/impl/codegen/port_platform.h> + +#include <stddef.h> + +#ifdef __cplusplus +extern "C" { +#endif + +/** The clocks we support. */ +typedef enum { + /** Monotonic clock. Epoch undefined. Always moves forwards. */ + GPR_CLOCK_MONOTONIC = 0, + /** Realtime clock. May jump forwards or backwards. Settable by + the system administrator. Has its epoch at 0:00:00 UTC 1 Jan 1970. */ + GPR_CLOCK_REALTIME, + /** CPU cycle time obtained by rdtsc instruction on x86 platforms. Epoch + undefined. Degrades to GPR_CLOCK_REALTIME on other platforms. */ + GPR_CLOCK_PRECISE, + /** Unmeasurable clock type: no base, created by taking the difference + between two times */ + GPR_TIMESPAN +} gpr_clock_type; + +/** Analogous to struct timespec. On some machines, absolute times may be in + * local time. */ +typedef struct gpr_timespec { + int64_t tv_sec; + int32_t tv_nsec; + /** Against which clock was this time measured? (or GPR_TIMESPAN if + this is a relative time measure) */ + gpr_clock_type clock_type; +} gpr_timespec; + +#ifdef __cplusplus +} +#endif + +#endif /* GRPC_IMPL_CODEGEN_GPR_TYPES_H */ diff --git a/grpc/spm-core-include/grpc/impl/codegen/grpc_types.h b/grpc/spm-core-include/grpc/impl/codegen/grpc_types.h new file mode 100644 index 00000000..d67a9e97 --- /dev/null +++ b/grpc/spm-core-include/grpc/impl/codegen/grpc_types.h @@ -0,0 +1,789 @@ +/* + * + * Copyright 2015 gRPC authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#ifndef GRPC_IMPL_CODEGEN_GRPC_TYPES_H +#define GRPC_IMPL_CODEGEN_GRPC_TYPES_H + +#include <grpc/impl/codegen/port_platform.h> + +#include <grpc/impl/codegen/compression_types.h> +#include <grpc/impl/codegen/gpr_types.h> +#include <grpc/impl/codegen/slice.h> +#include <grpc/impl/codegen/status.h> + +#include <stddef.h> + +#ifdef __cplusplus +extern "C" { +#endif + +typedef enum { + GRPC_BB_RAW + /** Future types may include GRPC_BB_PROTOBUF, etc. */ +} grpc_byte_buffer_type; + +typedef struct grpc_byte_buffer { + void* reserved; + grpc_byte_buffer_type type; + union grpc_byte_buffer_data { + struct /* internal */ { + void* reserved[8]; + } reserved; + struct grpc_compressed_buffer { + grpc_compression_algorithm compression; + grpc_slice_buffer slice_buffer; + } raw; + } data; +} grpc_byte_buffer; + +/** Completion Queues enable notification of the completion of + * asynchronous actions. */ +typedef struct grpc_completion_queue grpc_completion_queue; + +/** An alarm associated with a completion queue. */ +typedef struct grpc_alarm grpc_alarm; + +/** The Channel interface allows creation of Call objects. */ +typedef struct grpc_channel grpc_channel; + +/** A server listens to some port and responds to request calls */ +typedef struct grpc_server grpc_server; + +/** A Call represents an RPC. When created, it is in a configuration state + allowing properties to be set until it is invoked. After invoke, the Call + can have messages written to it and read from it. */ +typedef struct grpc_call grpc_call; + +/** The Socket Mutator interface allows changes on socket options */ +typedef struct grpc_socket_mutator grpc_socket_mutator; + +/** The Socket Factory interface creates and binds sockets */ +typedef struct grpc_socket_factory grpc_socket_factory; + +/** Type specifier for grpc_arg */ +typedef enum { + GRPC_ARG_STRING, + GRPC_ARG_INTEGER, + GRPC_ARG_POINTER +} grpc_arg_type; + +typedef struct grpc_arg_pointer_vtable { + void* (*copy)(void* p); + void (*destroy)(void* p); + int (*cmp)(void* p, void* q); +} grpc_arg_pointer_vtable; + +/** A single argument... each argument has a key and a value + + A note on naming keys: + Keys are namespaced into groups, usually grouped by library, and are + keys for module XYZ are named XYZ.key1, XYZ.key2, etc. Module names must + be restricted to the regex [A-Za-z][_A-Za-z0-9]{,15}. + Key names must be restricted to the regex [A-Za-z][_A-Za-z0-9]{,47}. + + GRPC core library keys are prefixed by grpc. + + Library authors are strongly encouraged to \#define symbolic constants for + their keys so that it's possible to change them in the future. */ +typedef struct { + grpc_arg_type type; + char* key; + union grpc_arg_value { + char* string; + int integer; + struct grpc_arg_pointer { + void* p; + const grpc_arg_pointer_vtable* vtable; + } pointer; + } value; +} grpc_arg; + +/** An array of arguments that can be passed around. + + Used to set optional channel-level configuration. + These configuration options are modelled as key-value pairs as defined + by grpc_arg; keys are strings to allow easy backwards-compatible extension + by arbitrary parties. All evaluation is performed at channel creation + time (i.e. the keys and values in this structure need only live through the + creation invocation). + + However, if one of the args has grpc_arg_type==GRPC_ARG_POINTER, then the + grpc_arg_pointer_vtable must live until the channel args are done being + used by core (i.e. when the object for use with which they were passed + is destroyed). + + See the description of the \ref grpc_arg_keys "available args" for more + details. */ +typedef struct { + size_t num_args; + grpc_arg* args; +} grpc_channel_args; + +/** \defgroup grpc_arg_keys + * Channel argument keys. + * \{ + */ +/** If non-zero, enable census for tracing and stats collection. */ +#define GRPC_ARG_ENABLE_CENSUS "grpc.census" +/** If non-zero, enable load reporting. */ +#define GRPC_ARG_ENABLE_LOAD_REPORTING "grpc.loadreporting" +/** Request that optional features default to off (regardless of what they + usually default to) - to enable tight control over what gets enabled */ +#define GRPC_ARG_MINIMAL_STACK "grpc.minimal_stack" +/** Maximum number of concurrent incoming streams to allow on a http2 + connection. Int valued. */ +#define GRPC_ARG_MAX_CONCURRENT_STREAMS "grpc.max_concurrent_streams" +/** Maximum message length that the channel can receive. Int valued, bytes. + -1 means unlimited. */ +#define GRPC_ARG_MAX_RECEIVE_MESSAGE_LENGTH "grpc.max_receive_message_length" +/** \deprecated For backward compatibility. + * Use GRPC_ARG_MAX_RECEIVE_MESSAGE_LENGTH instead. */ +#define GRPC_ARG_MAX_MESSAGE_LENGTH GRPC_ARG_MAX_RECEIVE_MESSAGE_LENGTH +/** Maximum message length that the channel can send. Int valued, bytes. + -1 means unlimited. */ +#define GRPC_ARG_MAX_SEND_MESSAGE_LENGTH "grpc.max_send_message_length" +/** Maximum time that a channel may have no outstanding rpcs, after which the + * server will close the connection. Int valued, milliseconds. INT_MAX means + * unlimited. */ +#define GRPC_ARG_MAX_CONNECTION_IDLE_MS "grpc.max_connection_idle_ms" +/** Maximum time that a channel may exist. Int valued, milliseconds. + * INT_MAX means unlimited. */ +#define GRPC_ARG_MAX_CONNECTION_AGE_MS "grpc.max_connection_age_ms" +/** Grace period after the channel reaches its max age. Int valued, + milliseconds. INT_MAX means unlimited. */ +#define GRPC_ARG_MAX_CONNECTION_AGE_GRACE_MS "grpc.max_connection_age_grace_ms" +/** Timeout after the last RPC finishes on the client channel at which the + * channel goes back into IDLE state. Int valued, milliseconds. INT_MAX means + * unlimited. The default value is 30 minutes and the min value is 1 second. */ +#define GRPC_ARG_CLIENT_IDLE_TIMEOUT_MS "grpc.client_idle_timeout_ms" +/** Enable/disable support for per-message compression. Defaults to 1, unless + GRPC_ARG_MINIMAL_STACK is enabled, in which case it defaults to 0. */ +#define GRPC_ARG_ENABLE_PER_MESSAGE_COMPRESSION "grpc.per_message_compression" +/** Experimental Arg. Enable/disable support for per-message decompression. + Defaults to 1. If disabled, decompression will not be performed and the + application will see the compressed message in the byte buffer. */ +#define GRPC_ARG_ENABLE_PER_MESSAGE_DECOMPRESSION \ + "grpc.per_message_decompression" +/** Enable/disable support for deadline checking. Defaults to 1, unless + GRPC_ARG_MINIMAL_STACK is enabled, in which case it defaults to 0 */ +#define GRPC_ARG_ENABLE_DEADLINE_CHECKS "grpc.enable_deadline_checking" +/** Initial stream ID for http2 transports. Int valued. */ +#define GRPC_ARG_HTTP2_INITIAL_SEQUENCE_NUMBER \ + "grpc.http2.initial_sequence_number" +/** Amount to read ahead on individual streams. Defaults to 64kb, larger + values can help throughput on high-latency connections. + NOTE: at some point we'd like to auto-tune this, and this parameter + will become a no-op. Int valued, bytes. */ +#define GRPC_ARG_HTTP2_STREAM_LOOKAHEAD_BYTES "grpc.http2.lookahead_bytes" +/** How much memory to use for hpack decoding. Int valued, bytes. */ +#define GRPC_ARG_HTTP2_HPACK_TABLE_SIZE_DECODER \ + "grpc.http2.hpack_table_size.decoder" +/** How much memory to use for hpack encoding. Int valued, bytes. */ +#define GRPC_ARG_HTTP2_HPACK_TABLE_SIZE_ENCODER \ + "grpc.http2.hpack_table_size.encoder" +/** How big a frame are we willing to receive via HTTP2. + Min 16384, max 16777215. Larger values give lower CPU usage for large + messages, but more head of line blocking for small messages. */ +#define GRPC_ARG_HTTP2_MAX_FRAME_SIZE "grpc.http2.max_frame_size" +/** Should BDP probing be performed? */ +#define GRPC_ARG_HTTP2_BDP_PROBE "grpc.http2.bdp_probe" +/** (DEPRECATED) Does not have any effect. + Earlier, this arg configured the minimum time between successive ping frames + without receiving any data/header frame, Int valued, milliseconds. This put + unnecessary constraints on the configuration of keepalive pings, + requiring users to set this channel arg along with + GRPC_ARG_KEEPALIVE_TIME_MS. This arg also limited the activity of the other + source of pings in gRPC Core - BDP pings, but BDP pings are only sent when + there is receive-side data activity, making this arg unuseful for BDP pings + too. */ +#define GRPC_ARG_HTTP2_MIN_SENT_PING_INTERVAL_WITHOUT_DATA_MS \ + "grpc.http2.min_time_between_pings_ms" +/** Minimum allowed time between a server receiving successive ping frames + without sending any data/header frame. Int valued, milliseconds + */ +#define GRPC_ARG_HTTP2_MIN_RECV_PING_INTERVAL_WITHOUT_DATA_MS \ + "grpc.http2.min_ping_interval_without_data_ms" +/** Channel arg to override the http2 :scheme header */ +#define GRPC_ARG_HTTP2_SCHEME "grpc.http2_scheme" +/** How many pings can we send before needing to send a + data/header frame? (0 indicates that an infinite number of + pings can be sent without sending a data frame or header frame) */ +#define GRPC_ARG_HTTP2_MAX_PINGS_WITHOUT_DATA \ + "grpc.http2.max_pings_without_data" +/** How many misbehaving pings the server can bear before sending goaway and + closing the transport? (0 indicates that the server can bear an infinite + number of misbehaving pings) */ +#define GRPC_ARG_HTTP2_MAX_PING_STRIKES "grpc.http2.max_ping_strikes" +/** How much data are we willing to queue up per stream if + GRPC_WRITE_BUFFER_HINT is set? This is an upper bound */ +#define GRPC_ARG_HTTP2_WRITE_BUFFER_SIZE "grpc.http2.write_buffer_size" +/** Should we allow receipt of true-binary data on http2 connections? + Defaults to on (1) */ +#define GRPC_ARG_HTTP2_ENABLE_TRUE_BINARY "grpc.http2.true_binary" +/** After a duration of this time the client/server pings its peer to see if the + transport is still alive. Int valued, milliseconds. */ +#define GRPC_ARG_KEEPALIVE_TIME_MS "grpc.keepalive_time_ms" +/** After waiting for a duration of this time, if the keepalive ping sender does + not receive the ping ack, it will close the transport. Int valued, + milliseconds. */ +#define GRPC_ARG_KEEPALIVE_TIMEOUT_MS "grpc.keepalive_timeout_ms" +/** Is it permissible to send keepalive pings without any outstanding streams. + Int valued, 0(false)/1(true). */ +#define GRPC_ARG_KEEPALIVE_PERMIT_WITHOUT_CALLS \ + "grpc.keepalive_permit_without_calls" +/** Default authority to pass if none specified on call construction. A string. + * */ +#define GRPC_ARG_DEFAULT_AUTHORITY "grpc.default_authority" +/** Primary user agent: goes at the start of the user-agent metadata + sent on each request. A string. */ +#define GRPC_ARG_PRIMARY_USER_AGENT_STRING "grpc.primary_user_agent" +/** Secondary user agent: goes at the end of the user-agent metadata + sent on each request. A string. */ +#define GRPC_ARG_SECONDARY_USER_AGENT_STRING "grpc.secondary_user_agent" +/** The minimum time between subsequent connection attempts, in ms */ +#define GRPC_ARG_MIN_RECONNECT_BACKOFF_MS "grpc.min_reconnect_backoff_ms" +/** The maximum time between subsequent connection attempts, in ms */ +#define GRPC_ARG_MAX_RECONNECT_BACKOFF_MS "grpc.max_reconnect_backoff_ms" +/** The time between the first and second connection attempts, in ms */ +#define GRPC_ARG_INITIAL_RECONNECT_BACKOFF_MS \ + "grpc.initial_reconnect_backoff_ms" +/** Minimum amount of time between DNS resolutions, in ms */ +#define GRPC_ARG_DNS_MIN_TIME_BETWEEN_RESOLUTIONS_MS \ + "grpc.dns_min_time_between_resolutions_ms" +/** The timeout used on servers for finishing handshaking on an incoming + connection. Defaults to 120 seconds. */ +#define GRPC_ARG_SERVER_HANDSHAKE_TIMEOUT_MS "grpc.server_handshake_timeout_ms" +/** This *should* be used for testing only. + The caller of the secure_channel_create functions may override the target + name used for SSL host name checking using this channel argument which is of + type \a GRPC_ARG_STRING. If this argument is not specified, the name used + for SSL host name checking will be the target parameter (assuming that the + secure channel is an SSL channel). If this parameter is specified and the + underlying is not an SSL channel, it will just be ignored. */ +#define GRPC_SSL_TARGET_NAME_OVERRIDE_ARG "grpc.ssl_target_name_override" +/** If non-zero, a pointer to a session cache (a pointer of type + grpc_ssl_session_cache*). (use grpc_ssl_session_cache_arg_vtable() to fetch + an appropriate pointer arg vtable) */ +#define GRPC_SSL_SESSION_CACHE_ARG "grpc.ssl_session_cache" +/** If non-zero, it will determine the maximum frame size used by TSI's frame + * protector. + * + * NOTE: Be aware that using a large "max_frame_size" is memory inefficient + * for non-zerocopy protectors. Also, increasing this value above 1MiB + * can break old binaries that don't support larger than 1MiB frame + * size. */ +#define GRPC_ARG_TSI_MAX_FRAME_SIZE "grpc.tsi.max_frame_size" +/** Maximum metadata size, in bytes. Note this limit applies to the max sum of + all metadata key-value entries in a batch of headers. */ +#define GRPC_ARG_MAX_METADATA_SIZE "grpc.max_metadata_size" +/** If non-zero, allow the use of SO_REUSEPORT if it's available (default 1) */ +#define GRPC_ARG_ALLOW_REUSEPORT "grpc.so_reuseport" +/** If non-zero, a pointer to a buffer pool (a pointer of type + * grpc_resource_quota*). (use grpc_resource_quota_arg_vtable() to fetch an + * appropriate pointer arg vtable) */ +#define GRPC_ARG_RESOURCE_QUOTA "grpc.resource_quota" +/** If non-zero, expand wildcard addresses to a list of local addresses. */ +#define GRPC_ARG_EXPAND_WILDCARD_ADDRS "grpc.expand_wildcard_addrs" +/** Service config data in JSON form. + This value will be ignored if the name resolver returns a service config. */ +#define GRPC_ARG_SERVICE_CONFIG "grpc.service_config" +/** Disable looking up the service config via the name resolver. */ +#define GRPC_ARG_SERVICE_CONFIG_DISABLE_RESOLUTION \ + "grpc.service_config_disable_resolution" +/** LB policy name. */ +#define GRPC_ARG_LB_POLICY_NAME "grpc.lb_policy_name" +/** The grpc_socket_mutator instance that set the socket options. A pointer. */ +#define GRPC_ARG_SOCKET_MUTATOR "grpc.socket_mutator" +/** The grpc_socket_factory instance to create and bind sockets. A pointer. */ +#define GRPC_ARG_SOCKET_FACTORY "grpc.socket_factory" +/** The maximum amount of memory used by trace events per channel trace node. + * Once the maximum is reached, subsequent events will evict the oldest events + * from the buffer. The unit for this knob is bytes. Setting it to zero causes + * channel tracing to be disabled. */ +#define GRPC_ARG_MAX_CHANNEL_TRACE_EVENT_MEMORY_PER_NODE \ + "grpc.max_channel_trace_event_memory_per_node" +/** If non-zero, gRPC library will track stats and information at at per channel + * level. Disabling channelz naturally disables channel tracing. The default + * is for channelz to be enabled. */ +#define GRPC_ARG_ENABLE_CHANNELZ "grpc.enable_channelz" +/** If non-zero, Cronet transport will coalesce packets to fewer frames + * when possible. */ +#define GRPC_ARG_USE_CRONET_PACKET_COALESCING \ + "grpc.use_cronet_packet_coalescing" +/** Channel arg (integer) setting how large a slice to try and read from the + wire each time recvmsg (or equivalent) is called **/ +#define GRPC_ARG_TCP_READ_CHUNK_SIZE "grpc.experimental.tcp_read_chunk_size" +/** Note this is not a "channel arg" key. This is the default slice size to use + * when trying to read from the wire if the GRPC_ARG_TCP_READ_CHUNK_SIZE + * channel arg is unspecified. */ +#define GRPC_TCP_DEFAULT_READ_SLICE_SIZE 8192 +#define GRPC_ARG_TCP_MIN_READ_CHUNK_SIZE \ + "grpc.experimental.tcp_min_read_chunk_size" +#define GRPC_ARG_TCP_MAX_READ_CHUNK_SIZE \ + "grpc.experimental.tcp_max_read_chunk_size" +/* TCP TX Zerocopy enable state: zero is disabled, non-zero is enabled. By + default, it is disabled. */ +#define GRPC_ARG_TCP_TX_ZEROCOPY_ENABLED \ + "grpc.experimental.tcp_tx_zerocopy_enabled" +/* TCP TX Zerocopy send threshold: only zerocopy if >= this many bytes sent. By + default, this is set to 16KB. */ +#define GRPC_ARG_TCP_TX_ZEROCOPY_SEND_BYTES_THRESHOLD \ + "grpc.experimental.tcp_tx_zerocopy_send_bytes_threshold" +/* TCP TX Zerocopy max simultaneous sends: limit for maximum number of pending + calls to tcp_write() using zerocopy. A tcp_write() is considered pending + until the kernel performs the zerocopy-done callback for all sendmsg() calls + issued by the tcp_write(). By default, this is set to 4. */ +#define GRPC_ARG_TCP_TX_ZEROCOPY_MAX_SIMULT_SENDS \ + "grpc.experimental.tcp_tx_zerocopy_max_simultaneous_sends" +/* Timeout in milliseconds to use for calls to the grpclb load balancer. + If 0 or unset, the balancer calls will have no deadline. */ +#define GRPC_ARG_GRPCLB_CALL_TIMEOUT_MS "grpc.grpclb_call_timeout_ms" +/* Timeout in milliseconds to wait for the serverlist from the grpclb load + balancer before using fallback backend addresses from the resolver. + If 0, enter fallback mode immediately. Default value is 10000. */ +#define GRPC_ARG_GRPCLB_FALLBACK_TIMEOUT_MS "grpc.grpclb_fallback_timeout_ms" +/* Timeout in milliseconds to wait for the child of a specific priority to + complete its initial connection attempt before the priority LB policy fails + over to the next priority. Default value is 10 seconds. */ +#define GRPC_ARG_PRIORITY_FAILOVER_TIMEOUT_MS \ + "grpc.priority_failover_timeout_ms" +/** If non-zero, grpc server's cronet compression workaround will be enabled */ +#define GRPC_ARG_WORKAROUND_CRONET_COMPRESSION \ + "grpc.workaround.cronet_compression" +/** String defining the optimization target for a channel. + Can be: "latency" - attempt to minimize latency at the cost of throughput + "blend" - try to balance latency and throughput + "throughput" - attempt to maximize throughput at the expense of + latency + Defaults to "blend". In the current implementation "blend" is equivalent to + "latency". */ +#define GRPC_ARG_OPTIMIZATION_TARGET "grpc.optimization_target" +/** If set to zero, disables retry behavior. Otherwise, transparent retries + are enabled for all RPCs, and configurable retries are enabled when they + are configured via the service config. For details, see: + https://github.com/grpc/proposal/blob/master/A6-client-retries.md + */ +#define GRPC_ARG_ENABLE_RETRIES "grpc.enable_retries" +/** Per-RPC retry buffer size, in bytes. Default is 256 KiB. */ +#define GRPC_ARG_PER_RPC_RETRY_BUFFER_SIZE "grpc.per_rpc_retry_buffer_size" +/** Channel arg that carries the bridged objective c object for custom metrics + * logging filter. */ +#define GRPC_ARG_MOBILE_LOG_CONTEXT "grpc.mobile_log_context" +/** If non-zero, client authority filter is disabled for the channel */ +#define GRPC_ARG_DISABLE_CLIENT_AUTHORITY_FILTER \ + "grpc.disable_client_authority_filter" +/** If set to zero, disables use of http proxies. Enabled by default. */ +#define GRPC_ARG_ENABLE_HTTP_PROXY "grpc.enable_http_proxy" +/** Channel arg to set http proxy per channel. If set, the channel arg + * value will be prefered over the envrionment variable settings. */ +#define GRPC_ARG_HTTP_PROXY "grpc.http_proxy" +/** If set to non zero, surfaces the user agent string to the server. User + agent is surfaced by default. */ +#define GRPC_ARG_SURFACE_USER_AGENT "grpc.surface_user_agent" +/** If set, inhibits health checking (which may be enabled via the + * service config.) */ +#define GRPC_ARG_INHIBIT_HEALTH_CHECKING "grpc.inhibit_health_checking" +/** If set, the channel's resolver is allowed to query for SRV records. + * For example, this is useful as a way to enable the "grpclb" + * load balancing policy. Note that this only works with the "ares" + * DNS resolver, and isn't supported by the "native" DNS resolver. */ +#define GRPC_ARG_DNS_ENABLE_SRV_QUERIES "grpc.dns_enable_srv_queries" +/** If set, determines an upper bound on the number of milliseconds that the + * c-ares based DNS resolver will wait on queries before cancelling them. + * The default value is 120,000. Setting this to "0" will disable the + * overall timeout entirely. Note that this doesn't include internal c-ares + * timeouts/backoff/retry logic, and so the actual DNS resolution may time out + * sooner than the value specified here. */ +#define GRPC_ARG_DNS_ARES_QUERY_TIMEOUT_MS "grpc.dns_ares_query_timeout" +/** If set, uses a local subchannel pool within the channel. Otherwise, uses the + * global subchannel pool. */ +#define GRPC_ARG_USE_LOCAL_SUBCHANNEL_POOL "grpc.use_local_subchannel_pool" +/** gRPC Objective-C channel pooling domain string. */ +#define GRPC_ARG_CHANNEL_POOL_DOMAIN "grpc.channel_pooling_domain" +/** gRPC Objective-C channel pooling id. */ +#define GRPC_ARG_CHANNEL_ID "grpc.channel_id" +/** \} */ + +/** Result of a grpc call. If the caller satisfies the prerequisites of a + particular operation, the grpc_call_error returned will be GRPC_CALL_OK. + Receiving any other value listed here is an indication of a bug in the + caller. */ +typedef enum grpc_call_error { + /** everything went ok */ + GRPC_CALL_OK = 0, + /** something failed, we don't know what */ + GRPC_CALL_ERROR, + /** this method is not available on the server */ + GRPC_CALL_ERROR_NOT_ON_SERVER, + /** this method is not available on the client */ + GRPC_CALL_ERROR_NOT_ON_CLIENT, + /** this method must be called before server_accept */ + GRPC_CALL_ERROR_ALREADY_ACCEPTED, + /** this method must be called before invoke */ + GRPC_CALL_ERROR_ALREADY_INVOKED, + /** this method must be called after invoke */ + GRPC_CALL_ERROR_NOT_INVOKED, + /** this call is already finished + (writes_done or write_status has already been called) */ + GRPC_CALL_ERROR_ALREADY_FINISHED, + /** there is already an outstanding read/write operation on the call */ + GRPC_CALL_ERROR_TOO_MANY_OPERATIONS, + /** the flags value was illegal for this call */ + GRPC_CALL_ERROR_INVALID_FLAGS, + /** invalid metadata was passed to this call */ + GRPC_CALL_ERROR_INVALID_METADATA, + /** invalid message was passed to this call */ + GRPC_CALL_ERROR_INVALID_MESSAGE, + /** completion queue for notification has not been registered + * with the server */ + GRPC_CALL_ERROR_NOT_SERVER_COMPLETION_QUEUE, + /** this batch of operations leads to more operations than allowed */ + GRPC_CALL_ERROR_BATCH_TOO_BIG, + /** payload type requested is not the type registered */ + GRPC_CALL_ERROR_PAYLOAD_TYPE_MISMATCH, + /** completion queue has been shutdown */ + GRPC_CALL_ERROR_COMPLETION_QUEUE_SHUTDOWN +} grpc_call_error; + +/** Default send/receive message size limits in bytes. -1 for unlimited. */ +/** TODO(roth) Make this match the default receive limit after next release */ +#define GRPC_DEFAULT_MAX_SEND_MESSAGE_LENGTH (-1) +#define GRPC_DEFAULT_MAX_RECV_MESSAGE_LENGTH (4 * 1024 * 1024) + +/** Write Flags: */ +/** Hint that the write may be buffered and need not go out on the wire + immediately. GRPC is free to buffer the message until the next non-buffered + write, or until writes_done, but it need not buffer completely or at all. */ +#define GRPC_WRITE_BUFFER_HINT (0x00000001u) +/** Force compression to be disabled for a particular write + (start_write/add_metadata). Illegal on invoke/accept. */ +#define GRPC_WRITE_NO_COMPRESS (0x00000002u) +/** Force this message to be written to the socket before completing it */ +#define GRPC_WRITE_THROUGH (0x00000004u) +/** Mask of all valid flags. */ +#define GRPC_WRITE_USED_MASK \ + (GRPC_WRITE_BUFFER_HINT | GRPC_WRITE_NO_COMPRESS | GRPC_WRITE_THROUGH) + +/** Initial metadata flags */ +/** Signal that the call is idempotent */ +#define GRPC_INITIAL_METADATA_IDEMPOTENT_REQUEST (0x00000010u) +/** Signal that the call should not return UNAVAILABLE before it has started */ +#define GRPC_INITIAL_METADATA_WAIT_FOR_READY (0x00000020u) +/** Signal that the call is cacheable. GRPC is free to use GET verb */ +#define GRPC_INITIAL_METADATA_CACHEABLE_REQUEST (0x00000040u) +/** Signal that GRPC_INITIAL_METADATA_WAIT_FOR_READY was explicitly set + by the calling application. */ +#define GRPC_INITIAL_METADATA_WAIT_FOR_READY_EXPLICITLY_SET (0x00000080u) +/** Signal that the initial metadata should be corked */ +#define GRPC_INITIAL_METADATA_CORKED (0x00000100u) + +/** Mask of all valid flags */ +#define GRPC_INITIAL_METADATA_USED_MASK \ + (GRPC_INITIAL_METADATA_IDEMPOTENT_REQUEST | \ + GRPC_INITIAL_METADATA_WAIT_FOR_READY | \ + GRPC_INITIAL_METADATA_CACHEABLE_REQUEST | \ + GRPC_INITIAL_METADATA_WAIT_FOR_READY_EXPLICITLY_SET | \ + GRPC_INITIAL_METADATA_CORKED | GRPC_WRITE_THROUGH) + +/** A single metadata element */ +typedef struct grpc_metadata { + /** the key, value values are expected to line up with grpc_mdelem: if + changing them, update metadata.h at the same time. */ + grpc_slice key; + grpc_slice value; + + uint32_t flags; + + /** The following fields are reserved for grpc internal use. + There is no need to initialize them, and they will be set to garbage + during calls to grpc. */ + struct /* internal */ { + void* obfuscated[4]; + } internal_data; +} grpc_metadata; + +/** The type of completion (for grpc_event) */ +typedef enum grpc_completion_type { + /** Shutting down */ + GRPC_QUEUE_SHUTDOWN, + /** No event before timeout */ + GRPC_QUEUE_TIMEOUT, + /** Operation completion */ + GRPC_OP_COMPLETE +} grpc_completion_type; + +/** The result of an operation. + + Returned by a completion queue when the operation started with tag. */ +typedef struct grpc_event { + /** The type of the completion. */ + grpc_completion_type type; + /** If the grpc_completion_type is GRPC_OP_COMPLETE, this field indicates + whether the operation was successful or not; 0 in case of failure and + non-zero in case of success. + If grpc_completion_type is GRPC_QUEUE_SHUTDOWN or GRPC_QUEUE_TIMEOUT, this + field is guaranteed to be 0 */ + int success; + /** The tag passed to grpc_call_start_batch etc to start this operation. + *Only* GRPC_OP_COMPLETE has a tag. For all other grpc_completion_type + values, tag is uninitialized. */ + void* tag; +} grpc_event; + +typedef struct { + size_t count; + size_t capacity; + grpc_metadata* metadata; +} grpc_metadata_array; + +typedef struct { + grpc_slice method; + grpc_slice host; + gpr_timespec deadline; + uint32_t flags; + void* reserved; +} grpc_call_details; + +typedef enum { + /** Send initial metadata: one and only one instance MUST be sent for each + call, unless the call was cancelled - in which case this can be skipped. + This op completes after all bytes of metadata have been accepted by + outgoing flow control. */ + GRPC_OP_SEND_INITIAL_METADATA = 0, + /** Send a message: 0 or more of these operations can occur for each call. + This op completes after all bytes for the message have been accepted by + outgoing flow control. */ + GRPC_OP_SEND_MESSAGE, + /** Send a close from the client: one and only one instance MUST be sent from + the client, unless the call was cancelled - in which case this can be + skipped. This op completes after all bytes for the call + (including the close) have passed outgoing flow control. */ + GRPC_OP_SEND_CLOSE_FROM_CLIENT, + /** Send status from the server: one and only one instance MUST be sent from + the server unless the call was cancelled - in which case this can be + skipped. This op completes after all bytes for the call + (including the status) have passed outgoing flow control. */ + GRPC_OP_SEND_STATUS_FROM_SERVER, + /** Receive initial metadata: one and only one MUST be made on the client, + must not be made on the server. + This op completes after all initial metadata has been read from the + peer. */ + GRPC_OP_RECV_INITIAL_METADATA, + /** Receive a message: 0 or more of these operations can occur for each call. + This op completes after all bytes of the received message have been + read, or after a half-close has been received on this call. */ + GRPC_OP_RECV_MESSAGE, + /** Receive status on the client: one and only one must be made on the client. + This operation always succeeds, meaning ops paired with this operation + will also appear to succeed, even though they may not have. In that case + the status will indicate some failure. + This op completes after all activity on the call has completed. */ + GRPC_OP_RECV_STATUS_ON_CLIENT, + /** Receive close on the server: one and only one must be made on the + server. This op completes after the close has been received by the + server. This operation always succeeds, meaning ops paired with + this operation will also appear to succeed, even though they may not + have. */ + GRPC_OP_RECV_CLOSE_ON_SERVER +} grpc_op_type; + +struct grpc_byte_buffer; + +/** Operation data: one field for each op type (except SEND_CLOSE_FROM_CLIENT + which has no arguments) */ +typedef struct grpc_op { + /** Operation type, as defined by grpc_op_type */ + grpc_op_type op; + /** Write flags bitset for grpc_begin_messages */ + uint32_t flags; + /** Reserved for future usage */ + void* reserved; + union grpc_op_data { + /** Reserved for future usage */ + struct /* internal */ { + void* reserved[8]; + } reserved; + struct grpc_op_send_initial_metadata { + size_t count; + grpc_metadata* metadata; + /** If \a is_set, \a compression_level will be used for the call. + * Otherwise, \a compression_level won't be considered */ + struct grpc_op_send_initial_metadata_maybe_compression_level { + uint8_t is_set; + grpc_compression_level level; + } maybe_compression_level; + } send_initial_metadata; + struct grpc_op_send_message { + /** This op takes ownership of the slices in send_message. After + * a call completes, the contents of send_message are not guaranteed + * and likely empty. The original owner should still call + * grpc_byte_buffer_destroy() on this object however. + */ + struct grpc_byte_buffer* send_message; + } send_message; + struct grpc_op_send_status_from_server { + size_t trailing_metadata_count; + grpc_metadata* trailing_metadata; + grpc_status_code status; + /** optional: set to NULL if no details need sending, non-NULL if they do + * pointer will not be retained past the start_batch call + */ + grpc_slice* status_details; + } send_status_from_server; + /** ownership of the array is with the caller, but ownership of the elements + stays with the call object (ie key, value members are owned by the call + object, recv_initial_metadata->array is owned by the caller). + After the operation completes, call grpc_metadata_array_destroy on this + value, or reuse it in a future op. */ + struct grpc_op_recv_initial_metadata { + grpc_metadata_array* recv_initial_metadata; + } recv_initial_metadata; + /** ownership of the byte buffer is moved to the caller; the caller must + call grpc_byte_buffer_destroy on this value, or reuse it in a future op. + The returned byte buffer will be NULL if trailing metadata was + received instead of a message. + */ + struct grpc_op_recv_message { + struct grpc_byte_buffer** recv_message; + } recv_message; + struct grpc_op_recv_status_on_client { + /** ownership of the array is with the caller, but ownership of the + elements stays with the call object (ie key, value members are owned + by the call object, trailing_metadata->array is owned by the caller). + After the operation completes, call grpc_metadata_array_destroy on + this value, or reuse it in a future op. */ + grpc_metadata_array* trailing_metadata; + grpc_status_code* status; + grpc_slice* status_details; + /** If this is not nullptr, it will be populated with the full fidelity + * error string for debugging purposes. The application is responsible + * for freeing the data by using gpr_free(). */ + const char** error_string; + } recv_status_on_client; + struct grpc_op_recv_close_on_server { + /** out argument, set to 1 if the call failed at the server for + a reason other than a non-OK status (cancel, deadline + exceeded, network failure, etc.), 0 otherwise (RPC processing ran to + completion and was able to provide any status from the server) */ + int* cancelled; + } recv_close_on_server; + } data; +} grpc_op; + +/** Information requested from the channel. */ +typedef struct { + /** If non-NULL, will be set to point to a string indicating the LB + * policy name. Caller takes ownership. */ + char** lb_policy_name; + /** If non-NULL, will be set to point to a string containing the + * service config used by the channel in JSON form. */ + char** service_config_json; +} grpc_channel_info; + +typedef struct grpc_resource_quota grpc_resource_quota; + +/** Completion queues internally MAY maintain a set of file descriptors in a + structure called 'pollset'. This enum specifies if a completion queue has an + associated pollset and any restrictions on the type of file descriptors that + can be present in the pollset. + + I/O progress can only be made when grpc_completion_queue_next() or + grpc_completion_queue_pluck() are called on the completion queue (unless the + grpc_cq_polling_type is GRPC_CQ_NON_POLLING) and hence it is very important + to actively call these APIs */ +typedef enum { + /** The completion queue will have an associated pollset and there is no + restriction on the type of file descriptors the pollset may contain */ + GRPC_CQ_DEFAULT_POLLING, + + /** Similar to GRPC_CQ_DEFAULT_POLLING except that the completion queues will + not contain any 'listening file descriptors' (i.e file descriptors used to + listen to incoming channels) */ + GRPC_CQ_NON_LISTENING, + + /** The completion queue will not have an associated pollset. Note that + grpc_completion_queue_next() or grpc_completion_queue_pluck() MUST still + be called to pop events from the completion queue; it is not required to + call them actively to make I/O progress */ + GRPC_CQ_NON_POLLING +} grpc_cq_polling_type; + +/** Specifies the type of APIs to use to pop events from the completion queue */ +typedef enum { + /** Events are popped out by calling grpc_completion_queue_next() API ONLY */ + GRPC_CQ_NEXT, + + /** Events are popped out by calling grpc_completion_queue_pluck() API ONLY*/ + GRPC_CQ_PLUCK, + + /** EXPERIMENTAL: Events trigger a callback specified as the tag */ + GRPC_CQ_CALLBACK +} grpc_cq_completion_type; + +/** EXPERIMENTAL: Specifies an interface class to be used as a tag + for callback-based completion queues. This can be used directly, + as the first element of a struct in C, or as a base class in C++. + Its "run" value should be assigned to some non-member function, such as + a static method. */ +typedef struct grpc_experimental_completion_queue_functor { + /** The run member specifies a function that will be called when this + tag is extracted from the completion queue. Its arguments will be a + pointer to this functor and a boolean that indicates whether the + operation succeeded (non-zero) or failed (zero) */ + void (*functor_run)(struct grpc_experimental_completion_queue_functor*, int); + + /** The inlineable member specifies whether this functor can be run inline. + This should only be used for trivial internally-defined functors. */ + int inlineable; + + /** The following fields are not API. They are meant for internal use. */ + int internal_success; + struct grpc_experimental_completion_queue_functor* internal_next; +} grpc_experimental_completion_queue_functor; + +/* The upgrade to version 2 is currently experimental. */ + +#define GRPC_CQ_CURRENT_VERSION 2 +#define GRPC_CQ_VERSION_MINIMUM_FOR_CALLBACKABLE 2 +typedef struct grpc_completion_queue_attributes { + /** The version number of this structure. More fields might be added to this + structure in future. */ + int version; /** Set to GRPC_CQ_CURRENT_VERSION */ + + grpc_cq_completion_type cq_completion_type; + + grpc_cq_polling_type cq_polling_type; + + /* END OF VERSION 1 CQ ATTRIBUTES */ + + /* EXPERIMENTAL: START OF VERSION 2 CQ ATTRIBUTES */ + /** When creating a callbackable CQ, pass in a functor to get invoked when + * shutdown is complete */ + grpc_experimental_completion_queue_functor* cq_shutdown_cb; + + /* END OF VERSION 2 CQ ATTRIBUTES */ +} grpc_completion_queue_attributes; + +/** The completion queue factory structure is opaque to the callers of grpc */ +typedef struct grpc_completion_queue_factory grpc_completion_queue_factory; + +#ifdef __cplusplus +} +#endif + +#endif /* GRPC_IMPL_CODEGEN_GRPC_TYPES_H */ diff --git a/grpc/spm-core-include/grpc/impl/codegen/log.h b/grpc/spm-core-include/grpc/impl/codegen/log.h new file mode 100644 index 00000000..9dd3a518 --- /dev/null +++ b/grpc/spm-core-include/grpc/impl/codegen/log.h @@ -0,0 +1,110 @@ +/* + * + * Copyright 2015 gRPC authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#ifndef GRPC_IMPL_CODEGEN_LOG_H +#define GRPC_IMPL_CODEGEN_LOG_H + +#include <grpc/impl/codegen/port_platform.h> + +#include <stdarg.h> +#include <stdlib.h> /* for abort() */ + +#ifdef __cplusplus +extern "C" { +#endif + +/** GPR log API. + + Usage (within grpc): + + int argument1 = 3; + char* argument2 = "hello"; + gpr_log(GPR_DEBUG, "format string %d", argument1); + gpr_log(GPR_INFO, "hello world"); + gpr_log(GPR_ERROR, "%d %s!!", argument1, argument2); */ + +/** The severity of a log message - use the #defines below when calling into + gpr_log to additionally supply file and line data */ +typedef enum gpr_log_severity { + GPR_LOG_SEVERITY_DEBUG, + GPR_LOG_SEVERITY_INFO, + GPR_LOG_SEVERITY_ERROR +} gpr_log_severity; + +/** Returns a string representation of the log severity */ +GPRAPI const char* gpr_log_severity_string(gpr_log_severity severity); + +/** Macros to build log contexts at various severity levels */ +#define GPR_DEBUG __FILE__, __LINE__, GPR_LOG_SEVERITY_DEBUG +#define GPR_INFO __FILE__, __LINE__, GPR_LOG_SEVERITY_INFO +#define GPR_ERROR __FILE__, __LINE__, GPR_LOG_SEVERITY_ERROR + +/** Log a message. It's advised to use GPR_xxx above to generate the context + * for each message */ +GPRAPI void gpr_log(const char* file, int line, gpr_log_severity severity, + const char* format, ...) GPR_PRINT_FORMAT_CHECK(4, 5); + +GPRAPI int gpr_should_log(gpr_log_severity severity); + +GPRAPI void gpr_log_message(const char* file, int line, + gpr_log_severity severity, const char* message); + +/** Set global log verbosity */ +GPRAPI void gpr_set_log_verbosity(gpr_log_severity min_severity_to_print); + +GPRAPI void gpr_log_verbosity_init(void); + +/** Log overrides: applications can use this API to intercept logging calls + and use their own implementations */ + +struct gpr_log_func_args { + const char* file; + int line; + gpr_log_severity severity; + const char* message; +}; + +typedef struct gpr_log_func_args gpr_log_func_args; + +typedef void (*gpr_log_func)(gpr_log_func_args* args); +GPRAPI void gpr_set_log_function(gpr_log_func func); + +/** abort() the process if x is zero, having written a line to the log. + + Intended for internal invariants. If the error can be recovered from, + without the possibility of corruption, or might best be reflected via + an exception in a higher-level language, consider returning error code. */ +#define GPR_ASSERT(x) \ + do { \ + if (GPR_UNLIKELY(!(x))) { \ + gpr_log(GPR_ERROR, "assertion failed: %s", #x); \ + abort(); \ + } \ + } while (0) + +#ifndef NDEBUG +#define GPR_DEBUG_ASSERT(x) GPR_ASSERT(x) +#else +#define GPR_DEBUG_ASSERT(x) +#endif + +#ifdef __cplusplus +} +#endif + +#endif /* GRPC_IMPL_CODEGEN_LOG_H */ diff --git a/grpc/spm-core-include/grpc/impl/codegen/port_platform.h b/grpc/spm-core-include/grpc/impl/codegen/port_platform.h new file mode 100644 index 00000000..c1bada11 --- /dev/null +++ b/grpc/spm-core-include/grpc/impl/codegen/port_platform.h @@ -0,0 +1,660 @@ +/* + * + * Copyright 2015 gRPC authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#ifndef GRPC_IMPL_CODEGEN_PORT_PLATFORM_H +#define GRPC_IMPL_CODEGEN_PORT_PLATFORM_H + +/* + * Define GPR_BACKWARDS_COMPATIBILITY_MODE to try harder to be ABI + * compatible with older platforms (currently only on Linux) + * Causes: + * - some libc calls to be gotten via dlsym + * - some syscalls to be made directly + */ + +/* + * Defines GPR_ABSEIL_SYNC to use synchronization features from Abseil + */ +#ifndef GPR_ABSEIL_SYNC +#if defined(__APPLE__) +// This is disabled on Apple platforms because macos/grpc_basictests_c_cpp +// fails with this. https://github.com/grpc/grpc/issues/23661 +#else +#define GPR_ABSEIL_SYNC 1 +#endif +#endif // GPR_ABSEIL_SYNC + +/* Get windows.h included everywhere (we need it) */ +#if defined(_WIN64) || defined(WIN64) || defined(_WIN32) || defined(WIN32) +#ifndef WIN32_LEAN_AND_MEAN +#define GRPC_WIN32_LEAN_AND_MEAN_WAS_NOT_DEFINED +#define WIN32_LEAN_AND_MEAN +#endif /* WIN32_LEAN_AND_MEAN */ + +#ifndef NOMINMAX +#define GRPC_NOMINMX_WAS_NOT_DEFINED +#define NOMINMAX +#endif /* NOMINMAX */ + +#include <windows.h> + +#ifndef _WIN32_WINNT +#error \ + "Please compile grpc with _WIN32_WINNT of at least 0x600 (aka Windows Vista)" +#else /* !defined(_WIN32_WINNT) */ +#if (_WIN32_WINNT < 0x0600) +#error \ + "Please compile grpc with _WIN32_WINNT of at least 0x600 (aka Windows Vista)" +#endif /* _WIN32_WINNT < 0x0600 */ +#endif /* defined(_WIN32_WINNT) */ + +#ifdef GRPC_WIN32_LEAN_AND_MEAN_WAS_NOT_DEFINED +#undef GRPC_WIN32_LEAN_AND_MEAN_WAS_NOT_DEFINED +#undef WIN32_LEAN_AND_MEAN +#endif /* GRPC_WIN32_LEAN_AND_MEAN_WAS_NOT_DEFINED */ + +#ifdef GRPC_NOMINMAX_WAS_NOT_DEFINED +#undef GRPC_NOMINMAX_WAS_NOT_DEFINED +#undef NOMINMAX +#endif /* GRPC_WIN32_LEAN_AND_MEAN_WAS_NOT_DEFINED */ +#endif /* defined(_WIN64) || defined(WIN64) || defined(_WIN32) || \ + defined(WIN32) */ + +/* Override this file with one for your platform if you need to redefine + things. */ + +#if !defined(GPR_NO_AUTODETECT_PLATFORM) +#if defined(_WIN64) || defined(WIN64) || defined(_WIN32) || defined(WIN32) +#if defined(_WIN64) || defined(WIN64) +#define GPR_ARCH_64 1 +#else +#define GPR_ARCH_32 1 +#endif +#define GPR_PLATFORM_STRING "windows" +#define GPR_WINDOWS 1 +#define GPR_WINDOWS_SUBPROCESS 1 +#define GPR_WINDOWS_ENV +#ifdef __MSYS__ +#define GPR_GETPID_IN_UNISTD_H 1 +#define GPR_MSYS_TMPFILE +#define GPR_POSIX_LOG +#define GPR_POSIX_STRING +#define GPR_POSIX_TIME +#else +#define GPR_GETPID_IN_PROCESS_H 1 +#define GPR_WINDOWS_TMPFILE +#define GPR_WINDOWS_LOG +#define GPR_WINDOWS_CRASH_HANDLER 1 +#define GPR_WINDOWS_STAT +#define GPR_WINDOWS_STRING +#define GPR_WINDOWS_TIME +#endif +#ifdef __GNUC__ +#define GPR_GCC_ATOMIC 1 +#else +#define GPR_WINDOWS_ATOMIC 1 +#endif +#define GPR_STDCPP_TLS 1 +#elif defined(ANDROID) || defined(__ANDROID__) +#define GPR_PLATFORM_STRING "android" +#define GPR_ANDROID 1 +// TODO(apolcyn): re-evaluate support for c-ares +// on android after upgrading our c-ares dependency. +// See https://github.com/grpc/grpc/issues/18038. +#define GRPC_ARES 0 +#ifdef _LP64 +#define GPR_ARCH_64 1 +#else /* _LP64 */ +#define GPR_ARCH_32 1 +#endif /* _LP64 */ +#define GPR_CPU_POSIX 1 +#define GPR_GCC_SYNC 1 +#define GPR_STDCPP_TLS 1 +#define GPR_POSIX_ENV 1 +#define GPR_POSIX_TMPFILE 1 +#define GPR_POSIX_STAT 1 +#define GPR_ANDROID_LOG 1 +#define GPR_POSIX_STRING 1 +#define GPR_POSIX_SUBPROCESS 1 +#define GPR_POSIX_SYNC 1 +#define GPR_POSIX_TIME 1 +#define GPR_HAS_PTHREAD_H 1 +#define GPR_GETPID_IN_UNISTD_H 1 +#define GPR_SUPPORT_CHANNELS_FROM_FD 1 +#elif defined(__linux__) +#define GPR_PLATFORM_STRING "linux" +#ifndef _BSD_SOURCE +#define _BSD_SOURCE +#endif +#ifndef _DEFAULT_SOURCE +#define _DEFAULT_SOURCE +#endif +#ifndef _GNU_SOURCE +#define _GNU_SOURCE +#endif +#include <features.h> +#define GPR_CPU_LINUX 1 +#define GPR_GCC_ATOMIC 1 +#define GPR_STDCPP_TLS 1 +#define GPR_LINUX 1 +#define GPR_LINUX_LOG +#define GPR_SUPPORT_CHANNELS_FROM_FD 1 +#define GPR_LINUX_ENV 1 +#define GPR_POSIX_TMPFILE 1 +#define GPR_POSIX_STAT 1 +#define GPR_POSIX_STRING 1 +#define GPR_POSIX_SUBPROCESS 1 +#define GPR_POSIX_SYNC 1 +#define GPR_POSIX_TIME 1 +#define GPR_HAS_PTHREAD_H 1 +#define GPR_GETPID_IN_UNISTD_H 1 +#ifdef _LP64 +#define GPR_ARCH_64 1 +#else /* _LP64 */ +#define GPR_ARCH_32 1 +#endif /* _LP64 */ +#ifdef __GLIBC__ +#define GPR_POSIX_CRASH_HANDLER 1 +#define GPR_LINUX_PTHREAD_NAME 1 +#include <linux/version.h> +#else /* musl libc */ +#define GPR_MUSL_LIBC_COMPAT 1 +#endif +#elif defined(__ASYLO__) +#define GPR_ARCH_64 1 +#define GPR_CPU_POSIX 1 +#define GPR_GCC_TLS 1 +#define GPR_PLATFORM_STRING "asylo" +#define GPR_GCC_SYNC 1 +#define GPR_POSIX_SYNC 1 +#define GPR_POSIX_STRING 1 +#define GPR_POSIX_LOG 1 +#define GPR_POSIX_TIME 1 +#define GPR_POSIX_ENV 1 +#define GPR_ASYLO 1 +#define GRPC_POSIX_SOCKET 1 +#define GRPC_POSIX_SOCKETADDR +#define GRPC_POSIX_SOCKETUTILS 1 +#define GRPC_TIMER_USE_GENERIC 1 +#define GRPC_POSIX_NO_SPECIAL_WAKEUP_FD 1 +#define GRPC_POSIX_WAKEUP_FD 1 +#define GRPC_ARES 0 +#define GPR_NO_AUTODETECT_PLATFORM 1 +#elif defined(__APPLE__) +#include <Availability.h> +#include <TargetConditionals.h> +#ifndef _BSD_SOURCE +#define _BSD_SOURCE +#endif +#if TARGET_OS_IPHONE +#define GPR_PLATFORM_STRING "ios" +#define GPR_CPU_IPHONE 1 +#define GRPC_CFSTREAM 1 +/* the c-ares resolver isn't safe to enable on iOS */ +#define GRPC_ARES 0 +#else /* TARGET_OS_IPHONE */ +#define GPR_PLATFORM_STRING "osx" +#define GPR_CPU_POSIX 1 +#define GPR_POSIX_CRASH_HANDLER 1 +#endif +#ifdef __has_feature +#if __has_feature(cxx_thread_local) +#define GPR_STDCPP_TLS 1 +#endif +#endif +#ifndef GPR_STDCPP_TLS +#define GPR_PTHREAD_TLS 1 +#endif +#define GPR_APPLE 1 +#define GPR_GCC_ATOMIC 1 +#define GPR_POSIX_LOG 1 +#define GPR_POSIX_ENV 1 +#define GPR_POSIX_TMPFILE 1 +#define GPR_POSIX_STAT 1 +#define GPR_POSIX_STRING 1 +#define GPR_POSIX_SUBPROCESS 1 +#define GPR_POSIX_SYNC 1 +#define GPR_POSIX_TIME 1 +#define GPR_HAS_PTHREAD_H 1 +#define GPR_GETPID_IN_UNISTD_H 1 +#ifndef GRPC_CFSTREAM +#define GPR_SUPPORT_CHANNELS_FROM_FD 1 +#endif +#ifdef _LP64 +#define GPR_ARCH_64 1 +#else /* _LP64 */ +#define GPR_ARCH_32 1 +#endif /* _LP64 */ +#elif defined(__FreeBSD__) +#define GPR_PLATFORM_STRING "freebsd" +#ifndef _BSD_SOURCE +#define _BSD_SOURCE +#endif +#define GPR_FREEBSD 1 +#define GPR_CPU_POSIX 1 +#define GPR_GCC_ATOMIC 1 +#define GPR_GCC_TLS 1 +#define GPR_POSIX_LOG 1 +#define GPR_POSIX_ENV 1 +#define GPR_POSIX_TMPFILE 1 +#define GPR_POSIX_STAT 1 +#define GPR_POSIX_STRING 1 +#define GPR_POSIX_SUBPROCESS 1 +#define GPR_POSIX_SYNC 1 +#define GPR_POSIX_TIME 1 +#define GPR_HAS_PTHREAD_H 1 +#define GPR_GETPID_IN_UNISTD_H 1 +#define GPR_SUPPORT_CHANNELS_FROM_FD 1 +#ifdef _LP64 +#define GPR_ARCH_64 1 +#else /* _LP64 */ +#define GPR_ARCH_32 1 +#endif /* _LP64 */ +#elif defined(__OpenBSD__) +#define GPR_PLATFORM_STRING "openbsd" +#ifndef _BSD_SOURCE +#define _BSD_SOURCE +#endif +#define GPR_OPENBSD 1 +#define GPR_CPU_POSIX 1 +#define GPR_GCC_ATOMIC 1 +#define GPR_GCC_TLS 1 +#define GPR_POSIX_LOG 1 +#define GPR_POSIX_ENV 1 +#define GPR_POSIX_TMPFILE 1 +#define GPR_POSIX_STAT 1 +#define GPR_POSIX_STRING 1 +#define GPR_POSIX_SUBPROCESS 1 +#define GPR_POSIX_SYNC 1 +#define GPR_POSIX_TIME 1 +#define GPR_HAS_PTHREAD_H 1 +#define GPR_GETPID_IN_UNISTD_H 1 +#define GPR_SUPPORT_CHANNELS_FROM_FD 1 +#ifdef _LP64 +#define GPR_ARCH_64 1 +#else /* _LP64 */ +#define GPR_ARCH_32 1 +#endif /* _LP64 */ +#elif defined(__sun) && defined(__SVR4) +#define GPR_PLATFORM_STRING "solaris" +#define GPR_SOLARIS 1 +#define GPR_CPU_POSIX 1 +#define GPR_GCC_ATOMIC 1 +#define GPR_GCC_TLS 1 +#define GPR_POSIX_LOG 1 +#define GPR_POSIX_ENV 1 +#define GPR_POSIX_TMPFILE 1 +#define GPR_POSIX_STAT 1 +#define GPR_POSIX_STRING 1 +#define GPR_POSIX_SUBPROCESS 1 +#define GPR_POSIX_SYNC 1 +#define GPR_POSIX_TIME 1 +#define GPR_HAS_PTHREAD_H 1 +#define GPR_GETPID_IN_UNISTD_H 1 +#ifdef _LP64 +#define GPR_ARCH_64 1 +#else /* _LP64 */ +#define GPR_ARCH_32 1 +#endif /* _LP64 */ +#elif defined(_AIX) +#define GPR_PLATFORM_STRING "aix" +#ifndef _ALL_SOURCE +#define _ALL_SOURCE +#endif +#define GPR_AIX 1 +#define GPR_CPU_POSIX 1 +#define GPR_GCC_ATOMIC 1 +#define GPR_GCC_TLS 1 +#define GPR_POSIX_LOG 1 +#define GPR_POSIX_ENV 1 +#define GPR_POSIX_TMPFILE 1 +#define GPR_POSIX_STAT 1 +#define GPR_POSIX_STRING 1 +#define GPR_POSIX_SUBPROCESS 1 +#define GPR_POSIX_SYNC 1 +#define GPR_POSIX_TIME 1 +#define GPR_HAS_PTHREAD_H 1 +#define GPR_GETPID_IN_UNISTD_H 1 +#ifdef _LP64 +#define GPR_ARCH_64 1 +#else /* _LP64 */ +#define GPR_ARCH_32 1 +#endif /* _LP64 */ +#elif defined(__native_client__) +#define GPR_PLATFORM_STRING "nacl" +#ifndef _BSD_SOURCE +#define _BSD_SOURCE +#endif +#ifndef _DEFAULT_SOURCE +#define _DEFAULT_SOURCE +#endif +#ifndef _GNU_SOURCE +#define _GNU_SOURCE +#endif +#define GPR_NACL 1 +#define GPR_CPU_POSIX 1 +#define GPR_GCC_ATOMIC 1 +#define GPR_GCC_TLS 1 +#define GPR_POSIX_LOG 1 +#define GPR_POSIX_ENV 1 +#define GPR_POSIX_TMPFILE 1 +#define GPR_POSIX_STAT 1 +#define GPR_POSIX_STRING 1 +#define GPR_POSIX_SUBPROCESS 1 +#define GPR_POSIX_SYNC 1 +#define GPR_POSIX_TIME 1 +#define GPR_HAS_PTHREAD_H 1 +#define GPR_GETPID_IN_UNISTD_H 1 +#ifdef _LP64 +#define GPR_ARCH_64 1 +#else /* _LP64 */ +#define GPR_ARCH_32 1 +#endif /* _LP64 */ +#elif defined(__Fuchsia__) +#define GPR_FUCHSIA 1 +#define GPR_ARCH_64 1 +#define GPR_PLATFORM_STRING "fuchsia" +#include <features.h> +// Specifying musl libc affects wrap_memcpy.c. It causes memmove() to be +// invoked. +#define GPR_MUSL_LIBC_COMPAT 1 +#define GPR_CPU_POSIX 1 +#define GPR_GCC_ATOMIC 1 +#define GPR_PTHREAD_TLS 1 +#define GPR_POSIX_LOG 1 +#define GPR_POSIX_SYNC 1 +#define GPR_POSIX_ENV 1 +#define GPR_POSIX_TMPFILE 1 +#define GPR_POSIX_STAT 1 +#define GPR_POSIX_SUBPROCESS 1 +#define GPR_POSIX_SYNC 1 +#define GPR_POSIX_STRING 1 +#define GPR_POSIX_TIME 1 +#define GPR_HAS_PTHREAD_H 1 +#define GPR_GETPID_IN_UNISTD_H 1 +#else +#error "Could not auto-detect platform" +#endif +#endif /* GPR_NO_AUTODETECT_PLATFORM */ + +#if defined(GPR_BACKWARDS_COMPATIBILITY_MODE) +/* + * For backward compatibility mode, reset _FORTIFY_SOURCE to prevent + * a library from having non-standard symbols such as __asprintf_chk. + * This helps non-glibc systems such as alpine using musl to find symbols. + */ +#if defined(_FORTIFY_SOURCE) && _FORTIFY_SOURCE > 0 +#undef _FORTIFY_SOURCE +#define _FORTIFY_SOURCE 0 +#endif +#endif + +#if defined(__has_include) +#if __has_include(<atomic>) +#define GRPC_HAS_CXX11_ATOMIC +#endif /* __has_include(<atomic>) */ +#endif /* defined(__has_include) */ + +#ifndef GPR_PLATFORM_STRING +#warning "GPR_PLATFORM_STRING not auto-detected" +#define GPR_PLATFORM_STRING "unknown" +#endif + +#ifdef GPR_GCOV +#undef GPR_FORBID_UNREACHABLE_CODE +#define GPR_FORBID_UNREACHABLE_CODE 1 +#endif + +#ifdef _MSC_VER +#if _MSC_VER < 1700 +typedef __int8 int8_t; +typedef __int16 int16_t; +typedef __int32 int32_t; +typedef __int64 int64_t; +typedef unsigned __int8 uint8_t; +typedef unsigned __int16 uint16_t; +typedef unsigned __int32 uint32_t; +typedef unsigned __int64 uint64_t; +#else +#include <stdint.h> +#endif /* _MSC_VER < 1700 */ +#else +#include <stdint.h> +#endif /* _MSC_VER */ + +/* Type of cycle clock implementation */ +#ifdef GPR_LINUX +/* Disable cycle clock by default. + TODO(soheil): enable when we support fallback for unstable cycle clocks. +#if defined(__i386__) +#define GPR_CYCLE_COUNTER_RDTSC_32 1 +#elif defined(__x86_64__) || defined(__amd64__) +#define GPR_CYCLE_COUNTER_RDTSC_64 1 +#else +#define GPR_CYCLE_COUNTER_FALLBACK 1 +#endif +*/ +#define GPR_CYCLE_COUNTER_FALLBACK 1 +#else +#define GPR_CYCLE_COUNTER_FALLBACK 1 +#endif /* GPR_LINUX */ + +/* Cache line alignment */ +#ifndef GPR_CACHELINE_SIZE_LOG +#if defined(__i386__) || defined(__x86_64__) +#define GPR_CACHELINE_SIZE_LOG 6 +#endif +#ifndef GPR_CACHELINE_SIZE_LOG +/* A reasonable default guess. Note that overestimates tend to waste more + space, while underestimates tend to waste more time. */ +#define GPR_CACHELINE_SIZE_LOG 6 +#endif /* GPR_CACHELINE_SIZE_LOG */ +#endif /* GPR_CACHELINE_SIZE_LOG */ + +#define GPR_CACHELINE_SIZE (1 << GPR_CACHELINE_SIZE_LOG) + +/* scrub GCC_ATOMIC if it's not available on this compiler */ +#if defined(GPR_GCC_ATOMIC) && !defined(__ATOMIC_RELAXED) +#undef GPR_GCC_ATOMIC +#define GPR_GCC_SYNC 1 +#endif + +/* Validate platform combinations */ +#if defined(GPR_GCC_ATOMIC) + defined(GPR_GCC_SYNC) + \ + defined(GPR_WINDOWS_ATOMIC) != \ + 1 +#error Must define exactly one of GPR_GCC_ATOMIC, GPR_GCC_SYNC, GPR_WINDOWS_ATOMIC +#endif + +#if defined(GPR_ARCH_32) + defined(GPR_ARCH_64) != 1 +#error Must define exactly one of GPR_ARCH_32, GPR_ARCH_64 +#endif + +#if defined(GPR_CPU_LINUX) + defined(GPR_CPU_POSIX) + defined(GPR_WINDOWS) + \ + defined(GPR_CPU_IPHONE) + defined(GPR_CPU_CUSTOM) != \ + 1 +#error Must define exactly one of GPR_CPU_LINUX, GPR_CPU_POSIX, GPR_WINDOWS, GPR_CPU_IPHONE, GPR_CPU_CUSTOM +#endif + +#if defined(GPR_MSVC_TLS) + defined(GPR_GCC_TLS) + defined(GPR_PTHREAD_TLS) + \ + defined(GPR_STDCPP_TLS) + defined(GPR_CUSTOM_TLS) != \ + 1 +#error Must define exactly one of GPR_MSVC_TLS, GPR_GCC_TLS, GPR_PTHREAD_TLS, GPR_STDCPP_TLS, GPR_CUSTOM_TLS +#endif + +/* maximum alignment needed for any type on this platform, rounded up to a + power of two */ +#define GPR_MAX_ALIGNMENT 16 + +#ifndef GRPC_ARES +#define GRPC_ARES 1 +#endif + +#ifndef GRPC_IF_NAMETOINDEX +#define GRPC_IF_NAMETOINDEX 1 +#endif + +#ifndef GRPC_MUST_USE_RESULT +#if defined(__GNUC__) && !defined(__MINGW32__) +#define GRPC_MUST_USE_RESULT __attribute__((warn_unused_result)) +#define GPR_ALIGN_STRUCT(n) __attribute__((aligned(n))) +#else +#define GRPC_MUST_USE_RESULT +#define GPR_ALIGN_STRUCT(n) +#endif +#endif + +#ifndef GRPC_UNUSED +#if defined(__GNUC__) && !defined(__MINGW32__) +#define GRPC_UNUSED __attribute__((unused)) +#else +#define GRPC_UNUSED +#endif +#endif + +#ifndef GPR_PRINT_FORMAT_CHECK +#ifdef __GNUC__ +#define GPR_PRINT_FORMAT_CHECK(FORMAT_STR, ARGS) \ + __attribute__((format(printf, FORMAT_STR, ARGS))) +#else +#define GPR_PRINT_FORMAT_CHECK(FORMAT_STR, ARGS) +#endif +#endif /* GPR_PRINT_FORMAT_CHECK */ + +#if GPR_FORBID_UNREACHABLE_CODE +#define GPR_UNREACHABLE_CODE(STATEMENT) +#else +#define GPR_UNREACHABLE_CODE(STATEMENT) \ + do { \ + gpr_log(GPR_ERROR, "Should never reach here."); \ + abort(); \ + STATEMENT; \ + } while (0) +#endif /* GPR_FORBID_UNREACHABLE_CODE */ + +#ifndef GPRAPI +#define GPRAPI +#endif + +#ifndef GRPCAPI +#define GRPCAPI GPRAPI +#endif + +#ifndef CENSUSAPI +#define CENSUSAPI GRPCAPI +#endif + +#ifndef GPR_HAS_ATTRIBUTE +#ifdef __has_attribute +#define GPR_HAS_ATTRIBUTE(a) __has_attribute(a) +#else +#define GPR_HAS_ATTRIBUTE(a) 0 +#endif +#endif /* GPR_HAS_ATTRIBUTE */ + +#ifndef GPR_HAS_FEATURE +#ifdef __has_feature +#define GPR_HAS_FEATURE(a) __has_feature(a) +#else +#define GPR_HAS_FEATURE(a) 0 +#endif +#endif /* GPR_HAS_FEATURE */ + +#ifndef GPR_ATTRIBUTE_NOINLINE +#if GPR_HAS_ATTRIBUTE(noinline) || (defined(__GNUC__) && !defined(__clang__)) +#define GPR_ATTRIBUTE_NOINLINE __attribute__((noinline)) +#define GPR_HAS_ATTRIBUTE_NOINLINE 1 +#else +#define GPR_ATTRIBUTE_NOINLINE +#endif +#endif /* GPR_ATTRIBUTE_NOINLINE */ + +#ifndef GPR_ATTRIBUTE_WEAK +/* Attribute weak is broken on LLVM/windows: + * https://bugs.llvm.org/show_bug.cgi?id=37598 */ +#if (GPR_HAS_ATTRIBUTE(weak) || (defined(__GNUC__) && !defined(__clang__))) && \ + !(defined(__llvm__) && defined(_WIN32)) +#define GPR_ATTRIBUTE_WEAK __attribute__((weak)) +#define GPR_HAS_ATTRIBUTE_WEAK 1 +#else +#define GPR_ATTRIBUTE_WEAK +#endif +#endif /* GPR_ATTRIBUTE_WEAK */ + +#ifndef GPR_ATTRIBUTE_NO_TSAN /* (1) */ +#if GPR_HAS_FEATURE(thread_sanitizer) +#define GPR_ATTRIBUTE_NO_TSAN __attribute__((no_sanitize("thread"))) +#endif /* GPR_HAS_FEATURE */ +#ifndef GPR_ATTRIBUTE_NO_TSAN /* (2) */ +#define GPR_ATTRIBUTE_NO_TSAN +#endif /* GPR_ATTRIBUTE_NO_TSAN (2) */ +#endif /* GPR_ATTRIBUTE_NO_TSAN (1) */ + +/* GRPC_TSAN_ENABLED will be defined, when compiled with thread sanitizer. */ +#ifndef GRPC_TSAN_SUPPRESSED +#if defined(__SANITIZE_THREAD__) +#define GRPC_TSAN_ENABLED +#elif GPR_HAS_FEATURE(thread_sanitizer) +#define GRPC_TSAN_ENABLED +#endif +#endif + +/* GRPC_ASAN_ENABLED will be defined, when compiled with address sanitizer. */ +#ifndef GRPC_ASAN_SUPPRESSED +#if defined(__SANITIZE_ADDRESS__) +#define GRPC_ASAN_ENABLED +#elif GPR_HAS_FEATURE(address_sanitizer) +#define GRPC_ASAN_ENABLED +#endif +#endif + +/* GRPC_ALLOW_EXCEPTIONS should be 0 or 1 if exceptions are allowed or not */ +#ifndef GRPC_ALLOW_EXCEPTIONS +#ifdef GPR_WINDOWS +#if defined(_MSC_VER) && defined(_CPPUNWIND) +#define GRPC_ALLOW_EXCEPTIONS 1 +#elif defined(__EXCEPTIONS) +#define GRPC_ALLOW_EXCEPTIONS 1 +#else +#define GRPC_ALLOW_EXCEPTIONS 0 +#endif +#else /* GPR_WINDOWS */ +#ifdef __EXCEPTIONS +#define GRPC_ALLOW_EXCEPTIONS 1 +#else /* __EXCEPTIONS */ +#define GRPC_ALLOW_EXCEPTIONS 0 +#endif /* __EXCEPTIONS */ +#endif /* __GPR_WINDOWS */ +#endif /* GRPC_ALLOW_EXCEPTIONS */ + +/* Use GPR_LIKELY only in cases where you are sure that a certain outcome is the + * most likely. Ideally, also collect performance numbers to justify the claim. + */ +#ifdef __GNUC__ +#define GPR_LIKELY(x) __builtin_expect((x), 1) +#define GPR_UNLIKELY(x) __builtin_expect((x), 0) +#else /* __GNUC__ */ +#define GPR_LIKELY(x) (x) +#define GPR_UNLIKELY(x) (x) +#endif /* __GNUC__ */ + +#ifndef __STDC_FORMAT_MACROS +#define __STDC_FORMAT_MACROS +#endif + +#endif /* GRPC_IMPL_CODEGEN_PORT_PLATFORM_H */ diff --git a/grpc/spm-core-include/grpc/impl/codegen/propagation_bits.h b/grpc/spm-core-include/grpc/impl/codegen/propagation_bits.h new file mode 100644 index 00000000..824bdbd8 --- /dev/null +++ b/grpc/spm-core-include/grpc/impl/codegen/propagation_bits.h @@ -0,0 +1,52 @@ +/* + * + * Copyright 2016 gRPC authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#ifndef GRPC_IMPL_CODEGEN_PROPAGATION_BITS_H +#define GRPC_IMPL_CODEGEN_PROPAGATION_BITS_H + +#include <grpc/impl/codegen/port_platform.h> + +#ifdef __cplusplus +extern "C" { +#endif + +/** Propagation bits: this can be bitwise or-ed to form propagation_mask for + * grpc_call */ +/** Propagate deadline */ +#define GRPC_PROPAGATE_DEADLINE ((uint32_t)1) +/** Propagate census context */ +#define GRPC_PROPAGATE_CENSUS_STATS_CONTEXT ((uint32_t)2) +#define GRPC_PROPAGATE_CENSUS_TRACING_CONTEXT ((uint32_t)4) +/** Propagate cancellation */ +#define GRPC_PROPAGATE_CANCELLATION ((uint32_t)8) + +/** Default propagation mask: clients of the core API are encouraged to encode + deltas from this in their implementations... ie write: + GRPC_PROPAGATE_DEFAULTS & ~GRPC_PROPAGATE_DEADLINE to disable deadline + propagation. Doing so gives flexibility in the future to define new + propagation types that are default inherited or not. */ +#define GRPC_PROPAGATE_DEFAULTS \ + ((uint32_t)(( \ + 0xffff | GRPC_PROPAGATE_DEADLINE | GRPC_PROPAGATE_CENSUS_STATS_CONTEXT | \ + GRPC_PROPAGATE_CENSUS_TRACING_CONTEXT | GRPC_PROPAGATE_CANCELLATION))) + +#ifdef __cplusplus +} +#endif + +#endif /* GRPC_IMPL_CODEGEN_PROPAGATION_BITS_H */ diff --git a/grpc/spm-core-include/grpc/impl/codegen/slice.h b/grpc/spm-core-include/grpc/impl/codegen/slice.h new file mode 100644 index 00000000..3567b1e8 --- /dev/null +++ b/grpc/spm-core-include/grpc/impl/codegen/slice.h @@ -0,0 +1,127 @@ +/* + * + * Copyright 2015 gRPC authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#ifndef GRPC_IMPL_CODEGEN_SLICE_H +#define GRPC_IMPL_CODEGEN_SLICE_H + +#include <grpc/impl/codegen/port_platform.h> + +#include <stddef.h> + +#include <grpc/impl/codegen/gpr_slice.h> + +typedef struct grpc_slice grpc_slice; + +/** Slice API + + A slice represents a contiguous reference counted array of bytes. + It is cheap to take references to a slice, and it is cheap to create a + slice pointing to a subset of another slice. + + The data-structure for slices is exposed here to allow non-gpr code to + build slices from whatever data they have available. + + When defining interfaces that handle slices, care should be taken to define + reference ownership semantics (who should call unref?) and mutability + constraints (is the callee allowed to modify the slice?) */ + +/* Inlined half of grpc_slice is allowed to expand the size of the overall type + by this many bytes */ +#define GRPC_SLICE_INLINE_EXTRA_SIZE sizeof(void*) + +#define GRPC_SLICE_INLINED_SIZE \ + (sizeof(size_t) + sizeof(uint8_t*) - 1 + GRPC_SLICE_INLINE_EXTRA_SIZE) + +struct grpc_slice_refcount; +/** A grpc_slice s, if initialized, represents the byte range + s.bytes[0..s.length-1]. + + It can have an associated ref count which has a destruction routine to be run + when the ref count reaches zero (see grpc_slice_new() and grp_slice_unref()). + Multiple grpc_slice values may share a ref count. + + If the slice does not have a refcount, it represents an inlined small piece + of data that is copied by value. */ +struct grpc_slice { + struct grpc_slice_refcount* refcount; + union grpc_slice_data { + struct grpc_slice_refcounted { + size_t length; + uint8_t* bytes; + } refcounted; + struct grpc_slice_inlined { + uint8_t length; + uint8_t bytes[GRPC_SLICE_INLINED_SIZE]; + } inlined; + } data; +}; + +#define GRPC_SLICE_BUFFER_INLINE_ELEMENTS 8 + +/** Represents an expandable array of slices, to be interpreted as a + single item. */ +typedef struct grpc_slice_buffer { + /** This is for internal use only. External users (i.e any code outside grpc + * core) MUST NOT use this field */ + grpc_slice* base_slices; + + /** slices in the array (Points to the first valid grpc_slice in the array) */ + grpc_slice* slices; + /** the number of slices in the array */ + size_t count; + /** the number of slices allocated in the array. External users (i.e any code + * outside grpc core) MUST NOT use this field */ + size_t capacity; + /** the combined length of all slices in the array */ + size_t length; + /** inlined elements to avoid allocations */ + grpc_slice inlined[GRPC_SLICE_BUFFER_INLINE_ELEMENTS]; +} grpc_slice_buffer; + +#define GRPC_SLICE_START_PTR(slice) \ + ((slice).refcount ? (slice).data.refcounted.bytes \ + : (slice).data.inlined.bytes) +#define GRPC_SLICE_LENGTH(slice) \ + ((slice).refcount ? (slice).data.refcounted.length \ + : (slice).data.inlined.length) +#define GRPC_SLICE_SET_LENGTH(slice, newlen) \ + ((slice).refcount ? ((slice).data.refcounted.length = (size_t)(newlen)) \ + : ((slice).data.inlined.length = (uint8_t)(newlen))) +#define GRPC_SLICE_END_PTR(slice) \ + GRPC_SLICE_START_PTR(slice) + GRPC_SLICE_LENGTH(slice) +#define GRPC_SLICE_IS_EMPTY(slice) (GRPC_SLICE_LENGTH(slice) == 0) + +#ifdef GRPC_ALLOW_GPR_SLICE_FUNCTIONS + +/* Duplicate GPR_* definitions */ +#define GPR_SLICE_START_PTR(slice) \ + ((slice).refcount ? (slice).data.refcounted.bytes \ + : (slice).data.inlined.bytes) +#define GPR_SLICE_LENGTH(slice) \ + ((slice).refcount ? (slice).data.refcounted.length \ + : (slice).data.inlined.length) +#define GPR_SLICE_SET_LENGTH(slice, newlen) \ + ((slice).refcount ? ((slice).data.refcounted.length = (size_t)(newlen)) \ + : ((slice).data.inlined.length = (uint8_t)(newlen))) +#define GPR_SLICE_END_PTR(slice) \ + GRPC_SLICE_START_PTR(slice) + GRPC_SLICE_LENGTH(slice) +#define GPR_SLICE_IS_EMPTY(slice) (GRPC_SLICE_LENGTH(slice) == 0) + +#endif /* GRPC_ALLOW_GPR_SLICE_FUNCTIONS */ + +#endif /* GRPC_IMPL_CODEGEN_SLICE_H */ diff --git a/grpc/spm-core-include/grpc/impl/codegen/status.h b/grpc/spm-core-include/grpc/impl/codegen/status.h new file mode 100644 index 00000000..dec3b8f3 --- /dev/null +++ b/grpc/spm-core-include/grpc/impl/codegen/status.h @@ -0,0 +1,154 @@ +/* + * + * Copyright 2015 gRPC authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#ifndef GRPC_IMPL_CODEGEN_STATUS_H +#define GRPC_IMPL_CODEGEN_STATUS_H + +#ifdef __cplusplus +extern "C" { +#endif + +typedef enum { + /** Not an error; returned on success */ + GRPC_STATUS_OK = 0, + + /** The operation was cancelled (typically by the caller). */ + GRPC_STATUS_CANCELLED = 1, + + /** Unknown error. An example of where this error may be returned is + if a Status value received from another address space belongs to + an error-space that is not known in this address space. Also + errors raised by APIs that do not return enough error information + may be converted to this error. */ + GRPC_STATUS_UNKNOWN = 2, + + /** Client specified an invalid argument. Note that this differs + from FAILED_PRECONDITION. INVALID_ARGUMENT indicates arguments + that are problematic regardless of the state of the system + (e.g., a malformed file name). */ + GRPC_STATUS_INVALID_ARGUMENT = 3, + + /** Deadline expired before operation could complete. For operations + that change the state of the system, this error may be returned + even if the operation has completed successfully. For example, a + successful response from a server could have been delayed long + enough for the deadline to expire. */ + GRPC_STATUS_DEADLINE_EXCEEDED = 4, + + /** Some requested entity (e.g., file or directory) was not found. */ + GRPC_STATUS_NOT_FOUND = 5, + + /** Some entity that we attempted to create (e.g., file or directory) + already exists. */ + GRPC_STATUS_ALREADY_EXISTS = 6, + + /** The caller does not have permission to execute the specified + operation. PERMISSION_DENIED must not be used for rejections + caused by exhausting some resource (use RESOURCE_EXHAUSTED + instead for those errors). PERMISSION_DENIED must not be + used if the caller can not be identified (use UNAUTHENTICATED + instead for those errors). */ + GRPC_STATUS_PERMISSION_DENIED = 7, + + /** The request does not have valid authentication credentials for the + operation. */ + GRPC_STATUS_UNAUTHENTICATED = 16, + + /** Some resource has been exhausted, perhaps a per-user quota, or + perhaps the entire file system is out of space. */ + GRPC_STATUS_RESOURCE_EXHAUSTED = 8, + + /** Operation was rejected because the system is not in a state + required for the operation's execution. For example, directory + to be deleted may be non-empty, an rmdir operation is applied to + a non-directory, etc. + + A litmus test that may help a service implementor in deciding + between FAILED_PRECONDITION, ABORTED, and UNAVAILABLE: + (a) Use UNAVAILABLE if the client can retry just the failing call. + (b) Use ABORTED if the client should retry at a higher-level + (e.g., restarting a read-modify-write sequence). + (c) Use FAILED_PRECONDITION if the client should not retry until + the system state has been explicitly fixed. E.g., if an "rmdir" + fails because the directory is non-empty, FAILED_PRECONDITION + should be returned since the client should not retry unless + they have first fixed up the directory by deleting files from it. + (d) Use FAILED_PRECONDITION if the client performs conditional + REST Get/Update/Delete on a resource and the resource on the + server does not match the condition. E.g., conflicting + read-modify-write on the same resource. */ + GRPC_STATUS_FAILED_PRECONDITION = 9, + + /** The operation was aborted, typically due to a concurrency issue + like sequencer check failures, transaction aborts, etc. + + See litmus test above for deciding between FAILED_PRECONDITION, + ABORTED, and UNAVAILABLE. */ + GRPC_STATUS_ABORTED = 10, + + /** Operation was attempted past the valid range. E.g., seeking or + reading past end of file. + + Unlike INVALID_ARGUMENT, this error indicates a problem that may + be fixed if the system state changes. For example, a 32-bit file + system will generate INVALID_ARGUMENT if asked to read at an + offset that is not in the range [0,2^32-1], but it will generate + OUT_OF_RANGE if asked to read from an offset past the current + file size. + + There is a fair bit of overlap between FAILED_PRECONDITION and + OUT_OF_RANGE. We recommend using OUT_OF_RANGE (the more specific + error) when it applies so that callers who are iterating through + a space can easily look for an OUT_OF_RANGE error to detect when + they are done. */ + GRPC_STATUS_OUT_OF_RANGE = 11, + + /** Operation is not implemented or not supported/enabled in this service. */ + GRPC_STATUS_UNIMPLEMENTED = 12, + + /** Internal errors. Means some invariants expected by underlying + system has been broken. If you see one of these errors, + something is very broken. */ + GRPC_STATUS_INTERNAL = 13, + + /** The service is currently unavailable. This is a most likely a + transient condition and may be corrected by retrying with + a backoff. Note that it is not always safe to retry non-idempotent + operations. + + WARNING: Although data MIGHT not have been transmitted when this + status occurs, there is NOT A GUARANTEE that the server has not seen + anything. So in general it is unsafe to retry on this status code + if the call is non-idempotent. + + See litmus test above for deciding between FAILED_PRECONDITION, + ABORTED, and UNAVAILABLE. */ + GRPC_STATUS_UNAVAILABLE = 14, + + /** Unrecoverable data loss or corruption. */ + GRPC_STATUS_DATA_LOSS = 15, + + /** Force users to include a default branch: */ + GRPC_STATUS__DO_NOT_USE = -1 +} grpc_status_code; + +#ifdef __cplusplus +} +#endif + +#endif /* GRPC_IMPL_CODEGEN_STATUS_H */ diff --git a/grpc/spm-core-include/grpc/impl/codegen/sync.h b/grpc/spm-core-include/grpc/impl/codegen/sync.h new file mode 100644 index 00000000..49e31947 --- /dev/null +++ b/grpc/spm-core-include/grpc/impl/codegen/sync.h @@ -0,0 +1,65 @@ +/* + * + * Copyright 2016 gRPC authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#ifndef GRPC_IMPL_CODEGEN_SYNC_H +#define GRPC_IMPL_CODEGEN_SYNC_H +/** Synchronization primitives for GPR. + + The type gpr_mu provides a non-reentrant mutex (lock). + + The type gpr_cv provides a condition variable. + + The type gpr_once provides for one-time initialization. + + The type gpr_event provides one-time-setting, reading, and + waiting of a void*, with memory barriers. + + The type gpr_refcount provides an object reference counter, + with memory barriers suitable to control + object lifetimes. + + The type gpr_stats_counter provides an atomic statistics counter. It + provides no memory barriers. + */ + +#ifdef __cplusplus +extern "C" { +#endif + +/* Platform-specific type declarations of gpr_mu and gpr_cv. */ +#include <grpc/impl/codegen/port_platform.h> + +#include <grpc/impl/codegen/sync_generic.h> + +#if defined(GPR_CUSTOM_SYNC) +#include <grpc/impl/codegen/sync_custom.h> +#elif defined(GPR_ABSEIL_SYNC) +#include <grpc/impl/codegen/sync_abseil.h> +#elif defined(GPR_POSIX_SYNC) +#include <grpc/impl/codegen/sync_posix.h> +#elif defined(GPR_WINDOWS) +#include <grpc/impl/codegen/sync_windows.h> +#else +#error Unable to determine platform for sync +#endif + +#ifdef __cplusplus +} +#endif + +#endif /* GRPC_IMPL_CODEGEN_SYNC_H */ diff --git a/grpc/spm-core-include/grpc/impl/codegen/sync_abseil.h b/grpc/spm-core-include/grpc/impl/codegen/sync_abseil.h new file mode 100644 index 00000000..38dfab32 --- /dev/null +++ b/grpc/spm-core-include/grpc/impl/codegen/sync_abseil.h @@ -0,0 +1,36 @@ +/* + * + * Copyright 2020 gRPC authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#ifndef GRPC_IMPL_CODEGEN_SYNC_ABSEIL_H +#define GRPC_IMPL_CODEGEN_SYNC_ABSEIL_H + +#include <grpc/impl/codegen/port_platform.h> + +#include <grpc/impl/codegen/sync_generic.h> + +#ifdef GPR_ABSEIL_SYNC + +typedef intptr_t gpr_mu; +typedef intptr_t gpr_cv; +typedef int32_t gpr_once; + +#define GPR_ONCE_INIT 0 + +#endif + +#endif /* GRPC_IMPL_CODEGEN_SYNC_ABSEIL_H */ diff --git a/grpc/spm-core-include/grpc/impl/codegen/sync_custom.h b/grpc/spm-core-include/grpc/impl/codegen/sync_custom.h new file mode 100644 index 00000000..69b1bf6c --- /dev/null +++ b/grpc/spm-core-include/grpc/impl/codegen/sync_custom.h @@ -0,0 +1,38 @@ +/* + * + * Copyright 2017 gRPC authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#ifndef GRPC_IMPL_CODEGEN_SYNC_CUSTOM_H +#define GRPC_IMPL_CODEGEN_SYNC_CUSTOM_H + +#include <grpc/impl/codegen/port_platform.h> + +#include <grpc/impl/codegen/sync_generic.h> + +/* Users defining GPR_CUSTOM_SYNC need to define the following macros. */ + +#ifdef GPR_CUSTOM_SYNC + +typedef GPR_CUSTOM_MU_TYPE gpr_mu; +typedef GPR_CUSTOM_CV_TYPE gpr_cv; +typedef GPR_CUSTOM_ONCE_TYPE gpr_once; + +#define GPR_ONCE_INIT GPR_CUSTOM_ONCE_INIT + +#endif + +#endif /* GRPC_IMPL_CODEGEN_SYNC_CUSTOM_H */ diff --git a/grpc/spm-core-include/grpc/impl/codegen/sync_generic.h b/grpc/spm-core-include/grpc/impl/codegen/sync_generic.h new file mode 100644 index 00000000..eabdc513 --- /dev/null +++ b/grpc/spm-core-include/grpc/impl/codegen/sync_generic.h @@ -0,0 +1,48 @@ +/* + * + * Copyright 2015 gRPC authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#ifndef GRPC_IMPL_CODEGEN_SYNC_GENERIC_H +#define GRPC_IMPL_CODEGEN_SYNC_GENERIC_H +/* Generic type definitions for gpr_sync. */ + +#include <grpc/impl/codegen/port_platform.h> + +#include <grpc/impl/codegen/atm.h> + +/* gpr_event */ +typedef struct { + gpr_atm state; +} gpr_event; + +#define GPR_EVENT_INIT \ + { 0 } + +/* gpr_refcount */ +typedef struct { + gpr_atm count; +} gpr_refcount; + +/* gpr_stats_counter */ +typedef struct { + gpr_atm value; +} gpr_stats_counter; + +#define GPR_STATS_INIT \ + { 0 } + +#endif /* GRPC_IMPL_CODEGEN_SYNC_GENERIC_H */ diff --git a/grpc/spm-core-include/grpc/impl/codegen/sync_posix.h b/grpc/spm-core-include/grpc/impl/codegen/sync_posix.h new file mode 100644 index 00000000..2aec3a3f --- /dev/null +++ b/grpc/spm-core-include/grpc/impl/codegen/sync_posix.h @@ -0,0 +1,52 @@ +/* + * + * Copyright 2015 gRPC authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#ifndef GRPC_IMPL_CODEGEN_SYNC_POSIX_H +#define GRPC_IMPL_CODEGEN_SYNC_POSIX_H + +#include <grpc/impl/codegen/port_platform.h> + +#include <grpc/impl/codegen/sync_generic.h> + +#include <pthread.h> + +#ifdef GRPC_ASAN_ENABLED +/* The member |leak_checker| is used to check whether there is a memory leak + * caused by upper layer logic that's missing the |gpr_xx_destroy| call + * to the object before freeing it. + * This issue was reported at https://github.com/grpc/grpc/issues/17563 + * and discussed at https://github.com/grpc/grpc/pull/17586 + */ +typedef struct { + pthread_mutex_t mutex; + int* leak_checker; +} gpr_mu; + +typedef struct { + pthread_cond_t cond_var; + int* leak_checker; +} gpr_cv; +#else +typedef pthread_mutex_t gpr_mu; +typedef pthread_cond_t gpr_cv; +#endif +typedef pthread_once_t gpr_once; + +#define GPR_ONCE_INIT PTHREAD_ONCE_INIT + +#endif /* GRPC_IMPL_CODEGEN_SYNC_POSIX_H */ diff --git a/grpc/spm-core-include/grpc/impl/codegen/sync_windows.h b/grpc/spm-core-include/grpc/impl/codegen/sync_windows.h new file mode 100644 index 00000000..f2ff83b3 --- /dev/null +++ b/grpc/spm-core-include/grpc/impl/codegen/sync_windows.h @@ -0,0 +1,40 @@ +/* + * + * Copyright 2015 gRPC authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#ifndef GRPC_IMPL_CODEGEN_SYNC_WINDOWS_H +#define GRPC_IMPL_CODEGEN_SYNC_WINDOWS_H + +#include <grpc/impl/codegen/port_platform.h> + +#ifdef GPR_WINDOWS + +#include <grpc/impl/codegen/sync_generic.h> + +typedef struct { + CRITICAL_SECTION cs; /* Not an SRWLock until Vista is unsupported */ + int locked; +} gpr_mu; + +typedef CONDITION_VARIABLE gpr_cv; + +typedef INIT_ONCE gpr_once; +#define GPR_ONCE_INIT INIT_ONCE_STATIC_INIT + +#endif /* GPR_WINDOWS */ + +#endif /* GRPC_IMPL_CODEGEN_SYNC_WINDOWS_H */ diff --git a/grpc/spm-core-include/grpc/load_reporting.h b/grpc/spm-core-include/grpc/load_reporting.h new file mode 100644 index 00000000..55f50ea8 --- /dev/null +++ b/grpc/spm-core-include/grpc/load_reporting.h @@ -0,0 +1,48 @@ +/* + * + * Copyright 2017 gRPC authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#ifndef GRPC_LOAD_REPORTING_H +#define GRPC_LOAD_REPORTING_H + +#include <grpc/impl/codegen/port_platform.h> + +#ifdef __cplusplus +extern "C" { +#endif + +/** Metadata key for the gRPC LB load balancer token. + * + * The value corresponding to this key is an opaque token that is given to the + * frontend as part of each pick; the frontend sends this token to the backend + * in each request it sends when using that pick. The token is used by the + * backend to verify the request and to allow the backend to report load to the + * gRPC LB system. */ +#define GRPC_LB_TOKEN_MD_KEY "lb-token" + +/** Metadata key for gRPC LB cost reporting. + * + * The value corresponding to this key is an opaque binary blob reported by the + * backend as part of its trailing metadata containing cost information for the + * call. */ +#define GRPC_LB_COST_MD_KEY "lb-cost-bin" + +#ifdef __cplusplus +} +#endif + +#endif /* GRPC_LOAD_REPORTING_H */ diff --git a/grpc/spm-core-include/grpc/module.modulemap b/grpc/spm-core-include/grpc/module.modulemap new file mode 100644 index 00000000..06c1e977 --- /dev/null +++ b/grpc/spm-core-include/grpc/module.modulemap @@ -0,0 +1,64 @@ + +framework module grpc { + umbrella header "grpc.h" + + header "impl/codegen/atm.h" + header "impl/codegen/byte_buffer.h" + header "impl/codegen/byte_buffer_reader.h" + header "impl/codegen/compression_types.h" + header "impl/codegen/connectivity_state.h" + header "impl/codegen/fork.h" + header "impl/codegen/gpr_slice.h" + header "impl/codegen/gpr_types.h" + header "impl/codegen/grpc_types.h" + header "impl/codegen/log.h" + header "impl/codegen/port_platform.h" + header "impl/codegen/propagation_bits.h" + header "impl/codegen/slice.h" + header "impl/codegen/status.h" + header "impl/codegen/sync.h" + header "impl/codegen/sync_abseil.h" + header "impl/codegen/sync_generic.h" + header "support/alloc.h" + header "support/atm.h" + header "support/cpu.h" + header "support/log.h" + header "support/log_windows.h" + header "support/port_platform.h" + header "support/string_util.h" + header "support/sync.h" + header "support/sync_abseil.h" + header "support/sync_generic.h" + header "support/thd_id.h" + header "support/time.h" + header "byte_buffer.h" + header "byte_buffer_reader.h" + header "census.h" + header "compression.h" + header "fork.h" + header "grpc.h" + header "grpc_posix.h" + header "grpc_security.h" + header "grpc_security_constants.h" + header "load_reporting.h" + header "slice.h" + header "slice_buffer.h" + header "status.h" + header "support/workaround_list.h" + + textual header "impl/codegen/atm_gcc_atomic.h" + textual header "impl/codegen/atm_gcc_sync.h" + textual header "impl/codegen/atm_windows.h" + textual header "impl/codegen/sync_custom.h" + textual header "impl/codegen/sync_posix.h" + textual header "impl/codegen/sync_windows.h" + textual header "support/atm_gcc_atomic.h" + textual header "support/atm_gcc_sync.h" + textual header "support/atm_windows.h" + textual header "support/sync_custom.h" + textual header "support/sync_posix.h" + textual header "support/sync_windows.h" + + export * + module * { export * } +} diff --git a/grpc/spm-core-include/grpc/slice.h b/grpc/spm-core-include/grpc/slice.h new file mode 100644 index 00000000..51fc62b4 --- /dev/null +++ b/grpc/spm-core-include/grpc/slice.h @@ -0,0 +1,172 @@ +/* + * + * Copyright 2015 gRPC authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#ifndef GRPC_SLICE_H +#define GRPC_SLICE_H + +#include <grpc/support/port_platform.h> + +#include <grpc/impl/codegen/slice.h> +#include <grpc/support/sync.h> + +#ifdef __cplusplus +extern "C" { +#endif + +/** Increment the refcount of s. Requires slice is initialized. + Returns s. */ +GPRAPI grpc_slice grpc_slice_ref(grpc_slice s); + +/** Decrement the ref count of s. If the ref count of s reaches zero, all + slices sharing the ref count are destroyed, and considered no longer + initialized. If s is ultimately derived from a call to grpc_slice_new(start, + len, dest) where dest!=NULL , then (*dest)(start) is called, else if s is + ultimately derived from a call to grpc_slice_new_with_len(start, len, dest) + where dest!=NULL , then (*dest)(start, len). Requires s initialized. */ +GPRAPI void grpc_slice_unref(grpc_slice s); + +/** Copy slice - create a new slice that contains the same data as s */ +GPRAPI grpc_slice grpc_slice_copy(grpc_slice s); + +/** Create a slice pointing at some data. Calls malloc to allocate a refcount + for the object, and arranges that destroy will be called with the pointer + passed in at destruction. */ +GPRAPI grpc_slice grpc_slice_new(void* p, size_t len, void (*destroy)(void*)); + +/** Equivalent to grpc_slice_new, but with a separate pointer that is + passed to the destroy function. This function can be useful when + the data is part of a larger structure that must be destroyed when + the data is no longer needed. */ +GPRAPI grpc_slice grpc_slice_new_with_user_data(void* p, size_t len, + void (*destroy)(void*), + void* user_data); + +/** Equivalent to grpc_slice_new, but with a two argument destroy function that + also takes the slice length. */ +GPRAPI grpc_slice grpc_slice_new_with_len(void* p, size_t len, + void (*destroy)(void*, size_t)); + +/** Equivalent to grpc_slice_new(malloc(len), len, free), but saves one malloc() + call. + Aborts if malloc() fails. */ +GPRAPI grpc_slice grpc_slice_malloc(size_t length); +GPRAPI grpc_slice grpc_slice_malloc_large(size_t length); + +#define GRPC_SLICE_MALLOC(len) grpc_slice_malloc(len) + +/** Intern a slice: + + The return value for two invocations of this function with the same sequence + of bytes is a slice which points to the same memory. */ +GPRAPI grpc_slice grpc_slice_intern(grpc_slice slice); + +/** Create a slice by copying a string. + Does not preserve null terminators. + Equivalent to: + size_t len = strlen(source); + grpc_slice slice = grpc_slice_malloc(len); + memcpy(slice->data, source, len); */ +GPRAPI grpc_slice grpc_slice_from_copied_string(const char* source); + +/** Create a slice by copying a buffer. + Equivalent to: + grpc_slice slice = grpc_slice_malloc(len); + memcpy(slice->data, source, len); */ +GPRAPI grpc_slice grpc_slice_from_copied_buffer(const char* source, size_t len); + +/** Create a slice pointing to constant memory */ +GPRAPI grpc_slice grpc_slice_from_static_string(const char* source); + +/** Create a slice pointing to constant memory */ +GPRAPI grpc_slice grpc_slice_from_static_buffer(const void* source, size_t len); + +/** Return a result slice derived from s, which shares a ref count with \a s, + where result.data==s.data+begin, and result.length==end-begin. The ref count + of \a s is increased by one. Do not assign result back to \a s. + Requires s initialized, begin <= end, begin <= s.length, and + end <= source->length. */ +GPRAPI grpc_slice grpc_slice_sub(grpc_slice s, size_t begin, size_t end); + +/** The same as grpc_slice_sub, but without altering the ref count */ +GPRAPI grpc_slice grpc_slice_sub_no_ref(grpc_slice s, size_t begin, size_t end); + +/** Splits s into two: modifies s to be s[0:split], and returns a new slice, + sharing a refcount with s, that contains s[split:s.length]. + Requires s initialized, split <= s.length */ +GPRAPI grpc_slice grpc_slice_split_tail(grpc_slice* s, size_t split); + +typedef enum { + GRPC_SLICE_REF_TAIL = 1, + GRPC_SLICE_REF_HEAD = 2, + GRPC_SLICE_REF_BOTH = 1 + 2 +} grpc_slice_ref_whom; + +/** The same as grpc_slice_split_tail, but with an option to skip altering + * refcounts (grpc_slice_split_tail_maybe_ref(..., true) is equivalent to + * grpc_slice_split_tail(...)) */ +GPRAPI grpc_slice grpc_slice_split_tail_maybe_ref(grpc_slice* s, size_t split, + grpc_slice_ref_whom ref_whom); + +/** Splits s into two: modifies s to be s[split:s.length], and returns a new + slice, sharing a refcount with s, that contains s[0:split]. + Requires s initialized, split <= s.length */ +GPRAPI grpc_slice grpc_slice_split_head(grpc_slice* s, size_t split); + +GPRAPI grpc_slice grpc_empty_slice(void); + +GPRAPI uint32_t grpc_slice_default_hash_impl(grpc_slice s); +GPRAPI int grpc_slice_default_eq_impl(grpc_slice a, grpc_slice b); + +GPRAPI int grpc_slice_eq(grpc_slice a, grpc_slice b); + +/** Returns <0 if a < b, ==0 if a == b, >0 if a > b + The order is arbitrary, and is not guaranteed to be stable across different + versions of the API. */ +GPRAPI int grpc_slice_cmp(grpc_slice a, grpc_slice b); +GPRAPI int grpc_slice_str_cmp(grpc_slice a, const char* b); + +/** return non-zero if the first blen bytes of a are equal to b */ +GPRAPI int grpc_slice_buf_start_eq(grpc_slice a, const void* b, size_t blen); + +/** return the index of the last instance of \a c in \a s, or -1 if not found */ +GPRAPI int grpc_slice_rchr(grpc_slice s, char c); +GPRAPI int grpc_slice_chr(grpc_slice s, char c); + +/** return the index of the first occurrence of \a needle in \a haystack, or -1 + if it's not found */ +GPRAPI int grpc_slice_slice(grpc_slice haystack, grpc_slice needle); + +GPRAPI uint32_t grpc_slice_hash(grpc_slice s); + +/** Do two slices point at the same memory, with the same length + If a or b is inlined, actually compares data */ +GPRAPI int grpc_slice_is_equivalent(grpc_slice a, grpc_slice b); + +/** Return a slice pointing to newly allocated memory that has the same contents + * as \a s */ +GPRAPI grpc_slice grpc_slice_dup(grpc_slice a); + +/** Return a copy of slice as a C string. Offers no protection against embedded + NULL's. Returned string must be freed with gpr_free. */ +GPRAPI char* grpc_slice_to_c_string(grpc_slice s); + +#ifdef __cplusplus +} +#endif + +#endif /* GRPC_SLICE_H */ diff --git a/grpc/spm-core-include/grpc/slice_buffer.h b/grpc/spm-core-include/grpc/slice_buffer.h new file mode 100644 index 00000000..d8c6b918 --- /dev/null +++ b/grpc/spm-core-include/grpc/slice_buffer.h @@ -0,0 +1,84 @@ +/* + * + * Copyright 2015 gRPC authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#ifndef GRPC_SLICE_BUFFER_H +#define GRPC_SLICE_BUFFER_H + +#include <grpc/support/port_platform.h> + +#include <grpc/slice.h> + +#ifdef __cplusplus +extern "C" { +#endif + +/** initialize a slice buffer */ +GPRAPI void grpc_slice_buffer_init(grpc_slice_buffer* sb); +/** destroy a slice buffer - unrefs any held elements */ +GPRAPI void grpc_slice_buffer_destroy(grpc_slice_buffer* sb); +/** Add an element to a slice buffer - takes ownership of the slice. + This function is allowed to concatenate the passed in slice to the end of + some other slice if desired by the slice buffer. */ +GPRAPI void grpc_slice_buffer_add(grpc_slice_buffer* sb, grpc_slice slice); +/** add an element to a slice buffer - takes ownership of the slice and returns + the index of the slice. + Guarantees that the slice will not be concatenated at the end of another + slice (i.e. the data for this slice will begin at the first byte of the + slice at the returned index in sb->slices) + The implementation MAY decide to concatenate data at the end of a small + slice added in this fashion. */ +GPRAPI size_t grpc_slice_buffer_add_indexed(grpc_slice_buffer* sb, + grpc_slice slice); +GPRAPI void grpc_slice_buffer_addn(grpc_slice_buffer* sb, grpc_slice* slices, + size_t n); +/** add a very small (less than 8 bytes) amount of data to the end of a slice + buffer: returns a pointer into which to add the data */ +GPRAPI uint8_t* grpc_slice_buffer_tiny_add(grpc_slice_buffer* sb, size_t len); +/** pop the last buffer, but don't unref it */ +GPRAPI void grpc_slice_buffer_pop(grpc_slice_buffer* sb); +/** clear a slice buffer, unref all elements */ +GPRAPI void grpc_slice_buffer_reset_and_unref(grpc_slice_buffer* sb); +/** swap the contents of two slice buffers */ +GPRAPI void grpc_slice_buffer_swap(grpc_slice_buffer* a, grpc_slice_buffer* b); +/** move all of the elements of src into dst */ +GPRAPI void grpc_slice_buffer_move_into(grpc_slice_buffer* src, + grpc_slice_buffer* dst); +/** remove n bytes from the end of a slice buffer */ +GPRAPI void grpc_slice_buffer_trim_end(grpc_slice_buffer* sb, size_t n, + grpc_slice_buffer* garbage); +/** move the first n bytes of src into dst */ +GPRAPI void grpc_slice_buffer_move_first(grpc_slice_buffer* src, size_t n, + grpc_slice_buffer* dst); +/** move the first n bytes of src into dst without adding references */ +GPRAPI void grpc_slice_buffer_move_first_no_ref(grpc_slice_buffer* src, + size_t n, + grpc_slice_buffer* dst); +/** move the first n bytes of src into dst (copying them) */ +GPRAPI void grpc_slice_buffer_move_first_into_buffer(grpc_slice_buffer* src, + size_t n, void* dst); +/** take the first slice in the slice buffer */ +GPRAPI grpc_slice grpc_slice_buffer_take_first(grpc_slice_buffer* sb); +/** undo the above with (a possibly different) \a slice */ +GPRAPI void grpc_slice_buffer_undo_take_first(grpc_slice_buffer* sb, + grpc_slice slice); + +#ifdef __cplusplus +} +#endif + +#endif /* GRPC_SLICE_BUFFER_H */ diff --git a/grpc/spm-core-include/grpc/status.h b/grpc/spm-core-include/grpc/status.h new file mode 100644 index 00000000..ecb9668b --- /dev/null +++ b/grpc/spm-core-include/grpc/status.h @@ -0,0 +1,26 @@ +/* + * + * Copyright 2015 gRPC authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#ifndef GRPC_STATUS_H +#define GRPC_STATUS_H + +#include <grpc/support/port_platform.h> + +#include <grpc/impl/codegen/status.h> + +#endif /* GRPC_STATUS_H */ diff --git a/grpc/spm-core-include/grpc/support/alloc.h b/grpc/spm-core-include/grpc/support/alloc.h new file mode 100644 index 00000000..d440e4be --- /dev/null +++ b/grpc/spm-core-include/grpc/support/alloc.h @@ -0,0 +1,52 @@ +/* + * + * Copyright 2015 gRPC authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#ifndef GRPC_SUPPORT_ALLOC_H +#define GRPC_SUPPORT_ALLOC_H + +#include <grpc/support/port_platform.h> + +#include <stddef.h> + +#ifdef __cplusplus +extern "C" { +#endif + +/** malloc. + * If size==0, always returns NULL. Otherwise this function never returns NULL. + * The pointer returned is suitably aligned for any kind of variable it could + * contain. + */ +GPRAPI void* gpr_malloc(size_t size); +/** like malloc, but zero all bytes before returning them */ +GPRAPI void* gpr_zalloc(size_t size); +/** free */ +GPRAPI void gpr_free(void* ptr); +/** realloc, never returns NULL */ +GPRAPI void* gpr_realloc(void* p, size_t size); +/** aligned malloc, never returns NULL, will align to alignment, which + * must be a power of 2. */ +GPRAPI void* gpr_malloc_aligned(size_t size, size_t alignment); +/** free memory allocated by gpr_malloc_aligned */ +GPRAPI void gpr_free_aligned(void* ptr); + +#ifdef __cplusplus +} +#endif + +#endif /* GRPC_SUPPORT_ALLOC_H */ diff --git a/grpc/spm-core-include/grpc/support/atm.h b/grpc/spm-core-include/grpc/support/atm.h new file mode 100644 index 00000000..073b0a6f --- /dev/null +++ b/grpc/spm-core-include/grpc/support/atm.h @@ -0,0 +1,26 @@ +/* + * + * Copyright 2015 gRPC authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#ifndef GRPC_SUPPORT_ATM_H +#define GRPC_SUPPORT_ATM_H + +#include <grpc/support/port_platform.h> + +#include <grpc/impl/codegen/atm.h> + +#endif /* GRPC_SUPPORT_ATM_H */ diff --git a/grpc/spm-core-include/grpc/support/atm_gcc_atomic.h b/grpc/spm-core-include/grpc/support/atm_gcc_atomic.h new file mode 100644 index 00000000..ae603db4 --- /dev/null +++ b/grpc/spm-core-include/grpc/support/atm_gcc_atomic.h @@ -0,0 +1,26 @@ +/* + * + * Copyright 2015 gRPC authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#ifndef GRPC_SUPPORT_ATM_GCC_ATOMIC_H +#define GRPC_SUPPORT_ATM_GCC_ATOMIC_H + +#include <grpc/support/port_platform.h> + +#include <grpc/impl/codegen/atm_gcc_atomic.h> + +#endif /* GRPC_SUPPORT_ATM_GCC_ATOMIC_H */ diff --git a/grpc/spm-core-include/grpc/support/atm_gcc_sync.h b/grpc/spm-core-include/grpc/support/atm_gcc_sync.h new file mode 100644 index 00000000..6f51fdb1 --- /dev/null +++ b/grpc/spm-core-include/grpc/support/atm_gcc_sync.h @@ -0,0 +1,26 @@ +/* + * + * Copyright 2015 gRPC authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#ifndef GRPC_SUPPORT_ATM_GCC_SYNC_H +#define GRPC_SUPPORT_ATM_GCC_SYNC_H + +#include <grpc/support/port_platform.h> + +#include <grpc/impl/codegen/atm_gcc_sync.h> + +#endif /* GRPC_SUPPORT_ATM_GCC_SYNC_H */ diff --git a/grpc/spm-core-include/grpc/support/atm_windows.h b/grpc/spm-core-include/grpc/support/atm_windows.h new file mode 100644 index 00000000..36955e4d --- /dev/null +++ b/grpc/spm-core-include/grpc/support/atm_windows.h @@ -0,0 +1,26 @@ +/* + * + * Copyright 2015 gRPC authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#ifndef GRPC_SUPPORT_ATM_WINDOWS_H +#define GRPC_SUPPORT_ATM_WINDOWS_H + +#include <grpc/support/port_platform.h> + +#include <grpc/impl/codegen/atm_windows.h> + +#endif /* GRPC_SUPPORT_ATM_WINDOWS_H */ diff --git a/grpc/spm-core-include/grpc/support/cpu.h b/grpc/spm-core-include/grpc/support/cpu.h new file mode 100644 index 00000000..f0e898e8 --- /dev/null +++ b/grpc/spm-core-include/grpc/support/cpu.h @@ -0,0 +1,44 @@ +/* + * + * Copyright 2015 gRPC authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#ifndef GRPC_SUPPORT_CPU_H +#define GRPC_SUPPORT_CPU_H + +#include <grpc/support/port_platform.h> + +#ifdef __cplusplus +extern "C" { +#endif + +/** Interface providing CPU information for currently running system */ + +/** Return the number of CPU cores on the current system. Will return 0 if + the information is not available. */ +GPRAPI unsigned gpr_cpu_num_cores(void); + +/** Return the CPU on which the current thread is executing; N.B. This should + be considered advisory only - it is possible that the thread is switched + to a different CPU at any time. Returns a value in range + [0, gpr_cpu_num_cores() - 1] */ +GPRAPI unsigned gpr_cpu_current_cpu(void); + +#ifdef __cplusplus +} // extern "C" +#endif + +#endif /* GRPC_SUPPORT_CPU_H */ diff --git a/grpc/spm-core-include/grpc/support/log.h b/grpc/spm-core-include/grpc/support/log.h new file mode 100644 index 00000000..8d8742b9 --- /dev/null +++ b/grpc/spm-core-include/grpc/support/log.h @@ -0,0 +1,26 @@ +/* + * + * Copyright 2015 gRPC authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#ifndef GRPC_SUPPORT_LOG_H +#define GRPC_SUPPORT_LOG_H + +#include <grpc/support/port_platform.h> + +#include <grpc/impl/codegen/log.h> + +#endif /* GRPC_SUPPORT_LOG_H */ diff --git a/grpc/spm-core-include/grpc/support/log_windows.h b/grpc/spm-core-include/grpc/support/log_windows.h new file mode 100644 index 00000000..e833f9d9 --- /dev/null +++ b/grpc/spm-core-include/grpc/support/log_windows.h @@ -0,0 +1,38 @@ +/* + * + * Copyright 2015 gRPC authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#ifndef GRPC_SUPPORT_LOG_WINDOWS_H +#define GRPC_SUPPORT_LOG_WINDOWS_H + +#include <grpc/impl/codegen/port_platform.h> + +#ifdef __cplusplus +extern "C" { +#endif + +/** Returns a string allocated with gpr_malloc that contains a UTF-8 + * formatted error message, corresponding to the error messageid. + * Use in conjunction with GetLastError() et al. + */ +GPRAPI char* gpr_format_message(int messageid); + +#ifdef __cplusplus +} +#endif + +#endif /* GRPC_SUPPORT_LOG_WINDOWS_H */ diff --git a/grpc/spm-core-include/grpc/support/port_platform.h b/grpc/spm-core-include/grpc/support/port_platform.h new file mode 100644 index 00000000..26025dcd --- /dev/null +++ b/grpc/spm-core-include/grpc/support/port_platform.h @@ -0,0 +1,24 @@ +/* + * + * Copyright 2015 gRPC authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#ifndef GRPC_SUPPORT_PORT_PLATFORM_H +#define GRPC_SUPPORT_PORT_PLATFORM_H + +#include <grpc/impl/codegen/port_platform.h> + +#endif /* GRPC_SUPPORT_PORT_PLATFORM_H */ diff --git a/grpc/spm-core-include/grpc/support/string_util.h b/grpc/spm-core-include/grpc/support/string_util.h new file mode 100644 index 00000000..2679160c --- /dev/null +++ b/grpc/spm-core-include/grpc/support/string_util.h @@ -0,0 +1,51 @@ +/* + * + * Copyright 2015 gRPC authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#ifndef GRPC_SUPPORT_STRING_UTIL_H +#define GRPC_SUPPORT_STRING_UTIL_H + +#include <grpc/support/port_platform.h> + +#include <grpc/impl/codegen/gpr_types.h> + +#ifdef __cplusplus +extern "C" { +#endif + +/** String utility functions */ + +/** Returns a copy of src that can be passed to gpr_free(). + If allocation fails or if src is NULL, returns NULL. */ +GPRAPI char* gpr_strdup(const char* src); + +/** printf to a newly-allocated string. The set of supported formats may vary + between platforms. + + On success, returns the number of bytes printed (excluding the final '\0'), + and *strp points to a string which must later be destroyed with gpr_free(). + + On error, returns -1 and sets *strp to NULL. If the format string is bad, + the result is undefined. */ +GPRAPI int gpr_asprintf(char** strp, const char* format, ...) + GPR_PRINT_FORMAT_CHECK(2, 3); + +#ifdef __cplusplus +} +#endif + +#endif /* GRPC_SUPPORT_STRING_UTIL_H */ diff --git a/grpc/spm-core-include/grpc/support/sync.h b/grpc/spm-core-include/grpc/support/sync.h new file mode 100644 index 00000000..f617322f --- /dev/null +++ b/grpc/spm-core-include/grpc/support/sync.h @@ -0,0 +1,282 @@ +/* + * + * Copyright 2015 gRPC authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#ifndef GRPC_SUPPORT_SYNC_H +#define GRPC_SUPPORT_SYNC_H + +#include <grpc/support/port_platform.h> + +#include <grpc/impl/codegen/gpr_types.h> /* for gpr_timespec */ +#include <grpc/impl/codegen/sync.h> + +#ifdef __cplusplus +extern "C" { +#endif + +/** --- Mutex interface --- + + At most one thread may hold an exclusive lock on a mutex at any given time. + Actions taken by a thread that holds a mutex exclusively happen after + actions taken by all previous holders of the mutex. Variables of type + gpr_mu are uninitialized when first declared. */ + +/** Initialize *mu. Requires: *mu uninitialized. */ +GPRAPI void gpr_mu_init(gpr_mu* mu); + +/** Cause *mu no longer to be initialized, freeing any memory in use. Requires: + *mu initialized; no other concurrent operation on *mu. */ +GPRAPI void gpr_mu_destroy(gpr_mu* mu); + +/** Wait until no thread has a lock on *mu, cause the calling thread to own an + exclusive lock on *mu, then return. May block indefinitely or crash if the + calling thread has a lock on *mu. Requires: *mu initialized. */ +GPRAPI void gpr_mu_lock(gpr_mu* mu); + +/** Release an exclusive lock on *mu held by the calling thread. Requires: *mu + initialized; the calling thread holds an exclusive lock on *mu. */ +GPRAPI void gpr_mu_unlock(gpr_mu* mu); + +/** Without blocking, attempt to acquire an exclusive lock on *mu for the + calling thread, then return non-zero iff success. Fail, if any thread holds + the lock; succeeds with high probability if no thread holds the lock. + Requires: *mu initialized. */ +GPRAPI int gpr_mu_trylock(gpr_mu* mu); + +/** --- Condition variable interface --- + + A while-loop should be used with gpr_cv_wait() when waiting for conditions + to become true. See the example below. Variables of type gpr_cv are + uninitialized when first declared. */ + +/** Initialize *cv. Requires: *cv uninitialized. */ +GPRAPI void gpr_cv_init(gpr_cv* cv); + +/** Cause *cv no longer to be initialized, freeing any memory in use. Requires: + *cv initialized; no other concurrent operation on *cv.*/ +GPRAPI void gpr_cv_destroy(gpr_cv* cv); + +/** Atomically release *mu and wait on *cv. When the calling thread is woken + from *cv or the deadline abs_deadline is exceeded, execute gpr_mu_lock(mu) + and return whether the deadline was exceeded. Use + abs_deadline==gpr_inf_future for no deadline. abs_deadline can be either + an absolute deadline, or a GPR_TIMESPAN. May return even when not + woken explicitly. Requires: *mu and *cv initialized; the calling thread + holds an exclusive lock on *mu. */ +GPRAPI int gpr_cv_wait(gpr_cv* cv, gpr_mu* mu, gpr_timespec abs_deadline); + +/** If any threads are waiting on *cv, wake at least one. + Clients may treat this as an optimization of gpr_cv_broadcast() + for use in the case where waking more than one waiter is not useful. + Requires: *cv initialized. */ +GPRAPI void gpr_cv_signal(gpr_cv* cv); + +/** Wake all threads waiting on *cv. Requires: *cv initialized. */ +GPRAPI void gpr_cv_broadcast(gpr_cv* cv); + +/** --- One-time initialization --- + + gpr_once must be declared with static storage class, and initialized with + GPR_ONCE_INIT. e.g., + static gpr_once once_var = GPR_ONCE_INIT; */ + +/** Ensure that (*init_function)() has been called exactly once (for the + specified gpr_once instance) and then return. + If multiple threads call gpr_once() on the same gpr_once instance, one of + them will call (*init_function)(), and the others will block until that call + finishes.*/ +GPRAPI void gpr_once_init(gpr_once* once, void (*init_function)(void)); + +/** --- One-time event notification --- + + These operations act on a gpr_event, which should be initialized with + gpr_ev_init(), or with GPR_EVENT_INIT if static, e.g., + static gpr_event event_var = GPR_EVENT_INIT; + It requires no destruction. */ + +/** Initialize *ev. */ +GPRAPI void gpr_event_init(gpr_event* ev); + +/** Set *ev so that gpr_event_get() and gpr_event_wait() will return value. + Requires: *ev initialized; value != NULL; no prior or concurrent calls to + gpr_event_set(ev, ...) since initialization. */ +GPRAPI void gpr_event_set(gpr_event* ev, void* value); + +/** Return the value set by gpr_event_set(ev, ...), or NULL if no such call has + completed. If the result is non-NULL, all operations that occurred prior to + the gpr_event_set(ev, ...) set will be visible after this call returns. + Requires: *ev initialized. This operation is faster than acquiring a mutex + on most platforms. */ +GPRAPI void* gpr_event_get(gpr_event* ev); + +/** Wait until *ev is set by gpr_event_set(ev, ...), or abs_deadline is + exceeded, then return gpr_event_get(ev). Requires: *ev initialized. Use + abs_deadline==gpr_inf_future for no deadline. When the event has been + signalled before the call, this operation is faster than acquiring a mutex + on most platforms. */ +GPRAPI void* gpr_event_wait(gpr_event* ev, gpr_timespec abs_deadline); + +/** --- Reference counting --- + + These calls act on the type gpr_refcount. It requires no destruction. */ + +/** Initialize *r to value n. */ +GPRAPI void gpr_ref_init(gpr_refcount* r, int n); + +/** Increment the reference count *r. Requires *r initialized. */ +GPRAPI void gpr_ref(gpr_refcount* r); + +/** Increment the reference count *r. Requires *r initialized. + Crashes if refcount is zero */ +GPRAPI void gpr_ref_non_zero(gpr_refcount* r); + +/** Increment the reference count *r by n. Requires *r initialized, n > 0. */ +GPRAPI void gpr_refn(gpr_refcount* r, int n); + +/** Decrement the reference count *r and return non-zero iff it has reached + zero. . Requires *r initialized. */ +GPRAPI int gpr_unref(gpr_refcount* r); + +/** Return non-zero iff the reference count of *r is one, and thus is owned + by exactly one object. */ +GPRAPI int gpr_ref_is_unique(gpr_refcount* r); + +/** --- Stats counters --- + + These calls act on the integral type gpr_stats_counter. It requires no + destruction. Static instances may be initialized with + gpr_stats_counter c = GPR_STATS_INIT; + Beware: These operations do not imply memory barriers. Do not use them to + synchronize other events. */ + +/** Initialize *c to the value n. */ +GPRAPI void gpr_stats_init(gpr_stats_counter* c, intptr_t n); + +/** *c += inc. Requires: *c initialized. */ +GPRAPI void gpr_stats_inc(gpr_stats_counter* c, intptr_t inc); + +/** Return *c. Requires: *c initialized. */ +GPRAPI intptr_t gpr_stats_read(const gpr_stats_counter* c); + +/** ==================Example use of interface=================== + A producer-consumer queue of up to N integers, + illustrating the use of the calls in this interface. */ +#if 0 + +#define N 4 + + typedef struct queue { + gpr_cv non_empty; /* Signalled when length becomes non-zero. */ + gpr_cv non_full; /* Signalled when length becomes non-N. */ + gpr_mu mu; /* Protects all fields below. + (That is, except during initialization or + destruction, the fields below should be accessed + only by a thread that holds mu.) */ + int head; /* Index of head of queue 0..N-1. */ + int length; /* Number of valid elements in queue 0..N. */ + int elem[N]; /* elem[head .. head+length-1] are queue elements. */ + } queue; + + /* Initialize *q. */ + void queue_init(queue *q) { + gpr_mu_init(&q->mu); + gpr_cv_init(&q->non_empty); + gpr_cv_init(&q->non_full); + q->head = 0; + q->length = 0; + } + + /* Free storage associated with *q. */ + void queue_destroy(queue *q) { + gpr_mu_destroy(&q->mu); + gpr_cv_destroy(&q->non_empty); + gpr_cv_destroy(&q->non_full); + } + + /* Wait until there is room in *q, then append x to *q. */ + void queue_append(queue *q, int x) { + gpr_mu_lock(&q->mu); + /* To wait for a predicate without a deadline, loop on the negation of the + predicate, and use gpr_cv_wait(..., gpr_inf_future) inside the loop + to release the lock, wait, and reacquire on each iteration. Code that + makes the condition true should use gpr_cv_broadcast() on the + corresponding condition variable. The predicate must be on state + protected by the lock. */ + while (q->length == N) { + gpr_cv_wait(&q->non_full, &q->mu, gpr_inf_future); + } + if (q->length == 0) { /* Wake threads blocked in queue_remove(). */ + /* It's normal to use gpr_cv_broadcast() or gpr_signal() while + holding the lock. */ + gpr_cv_broadcast(&q->non_empty); + } + q->elem[(q->head + q->length) % N] = x; + q->length++; + gpr_mu_unlock(&q->mu); + } + + /* If it can be done without blocking, append x to *q and return non-zero. + Otherwise return 0. */ + int queue_try_append(queue *q, int x) { + int result = 0; + if (gpr_mu_trylock(&q->mu)) { + if (q->length != N) { + if (q->length == 0) { /* Wake threads blocked in queue_remove(). */ + gpr_cv_broadcast(&q->non_empty); + } + q->elem[(q->head + q->length) % N] = x; + q->length++; + result = 1; + } + gpr_mu_unlock(&q->mu); + } + return result; + } + + /* Wait until the *q is non-empty or deadline abs_deadline passes. If the + queue is non-empty, remove its head entry, place it in *head, and return + non-zero. Otherwise return 0. */ + int queue_remove(queue *q, int *head, gpr_timespec abs_deadline) { + int result = 0; + gpr_mu_lock(&q->mu); + /* To wait for a predicate with a deadline, loop on the negation of the + predicate or until gpr_cv_wait() returns true. Code that makes + the condition true should use gpr_cv_broadcast() on the corresponding + condition variable. The predicate must be on state protected by the + lock. */ + while (q->length == 0 && + !gpr_cv_wait(&q->non_empty, &q->mu, abs_deadline)) { + } + if (q->length != 0) { /* Queue is non-empty. */ + result = 1; + if (q->length == N) { /* Wake threads blocked in queue_append(). */ + gpr_cv_broadcast(&q->non_full); + } + *head = q->elem[q->head]; + q->head = (q->head + 1) % N; + q->length--; + } /* else deadline exceeded */ + gpr_mu_unlock(&q->mu); + return result; + } +#endif /* 0 */ + +#ifdef __cplusplus +} // extern "C" +#endif + +#endif /* GRPC_SUPPORT_SYNC_H */ diff --git a/grpc/spm-core-include/grpc/support/sync_abseil.h b/grpc/spm-core-include/grpc/support/sync_abseil.h new file mode 100644 index 00000000..3ee73489 --- /dev/null +++ b/grpc/spm-core-include/grpc/support/sync_abseil.h @@ -0,0 +1,26 @@ +/* + * + * Copyright 2020 gRPC authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#ifndef GRPC_SUPPORT_SYNC_ABSEIL_H +#define GRPC_SUPPORT_SYNC_ABSEIL_H + +#include <grpc/support/port_platform.h> + +#include <grpc/impl/codegen/sync_abseil.h> + +#endif /* GRPC_SUPPORT_SYNC_ABSEIL_H */ diff --git a/grpc/spm-core-include/grpc/support/sync_custom.h b/grpc/spm-core-include/grpc/support/sync_custom.h new file mode 100644 index 00000000..27cf0e05 --- /dev/null +++ b/grpc/spm-core-include/grpc/support/sync_custom.h @@ -0,0 +1,26 @@ +/* + * + * Copyright 2017 gRPC authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#ifndef GRPC_SUPPORT_SYNC_CUSTOM_H +#define GRPC_SUPPORT_SYNC_CUSTOM_H + +#include <grpc/support/port_platform.h> + +#include <grpc/impl/codegen/sync_custom.h> + +#endif /* GRPC_SUPPORT_SYNC_CUSTOM_H */ diff --git a/grpc/spm-core-include/grpc/support/sync_generic.h b/grpc/spm-core-include/grpc/support/sync_generic.h new file mode 100644 index 00000000..93028c4a --- /dev/null +++ b/grpc/spm-core-include/grpc/support/sync_generic.h @@ -0,0 +1,26 @@ +/* + * + * Copyright 2015 gRPC authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#ifndef GRPC_SUPPORT_SYNC_GENERIC_H +#define GRPC_SUPPORT_SYNC_GENERIC_H + +#include <grpc/support/port_platform.h> + +#include <grpc/impl/codegen/sync_generic.h> + +#endif /* GRPC_SUPPORT_SYNC_GENERIC_H */ diff --git a/grpc/spm-core-include/grpc/support/sync_posix.h b/grpc/spm-core-include/grpc/support/sync_posix.h new file mode 100644 index 00000000..3dce7ee4 --- /dev/null +++ b/grpc/spm-core-include/grpc/support/sync_posix.h @@ -0,0 +1,26 @@ +/* + * + * Copyright 2015 gRPC authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#ifndef GRPC_SUPPORT_SYNC_POSIX_H +#define GRPC_SUPPORT_SYNC_POSIX_H + +#include <grpc/support/port_platform.h> + +#include <grpc/impl/codegen/sync_posix.h> + +#endif /* GRPC_SUPPORT_SYNC_POSIX_H */ diff --git a/grpc/spm-core-include/grpc/support/sync_windows.h b/grpc/spm-core-include/grpc/support/sync_windows.h new file mode 100644 index 00000000..a493c864 --- /dev/null +++ b/grpc/spm-core-include/grpc/support/sync_windows.h @@ -0,0 +1,26 @@ +/* + * + * Copyright 2015 gRPC authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#ifndef GRPC_SUPPORT_SYNC_WINDOWS_H +#define GRPC_SUPPORT_SYNC_WINDOWS_H + +#include <grpc/support/port_platform.h> + +#include <grpc/impl/codegen/sync_windows.h> + +#endif /* GRPC_SUPPORT_SYNC_WINDOWS_H */ diff --git a/grpc/spm-core-include/grpc/support/thd_id.h b/grpc/spm-core-include/grpc/support/thd_id.h new file mode 100644 index 00000000..e9b2b7ec --- /dev/null +++ b/grpc/spm-core-include/grpc/support/thd_id.h @@ -0,0 +1,44 @@ +/* + * + * Copyright 2018 gRPC authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#ifndef GRPC_SUPPORT_THD_ID_H +#define GRPC_SUPPORT_THD_ID_H +/** Thread ID interface for GPR. + + Used by some wrapped languages for logging purposes. + + Types + gpr_thd_id a unique opaque identifier for a thread. + */ + +#include <grpc/support/port_platform.h> + +#ifdef __cplusplus +extern "C" { +#endif + +typedef uintptr_t gpr_thd_id; + +/** Returns the identifier of the current thread. */ +GPRAPI gpr_thd_id gpr_thd_currentid(void); + +#ifdef __cplusplus +} +#endif + +#endif /* GRPC_SUPPORT_THD_ID_H */ diff --git a/grpc/spm-core-include/grpc/support/time.h b/grpc/spm-core-include/grpc/support/time.h new file mode 100644 index 00000000..44aead5e --- /dev/null +++ b/grpc/spm-core-include/grpc/support/time.h @@ -0,0 +1,92 @@ +/* + * + * Copyright 2015 gRPC authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#ifndef GRPC_SUPPORT_TIME_H +#define GRPC_SUPPORT_TIME_H + +#include <grpc/support/port_platform.h> + +#include <grpc/impl/codegen/gpr_types.h> + +#include <stddef.h> +#include <time.h> + +#ifdef __cplusplus +extern "C" { +#endif + +/** Time constants. */ +GPRAPI gpr_timespec +gpr_time_0(gpr_clock_type type); /** The zero time interval. */ +GPRAPI gpr_timespec gpr_inf_future(gpr_clock_type type); /** The far future */ +GPRAPI gpr_timespec gpr_inf_past(gpr_clock_type type); /** The far past. */ + +#define GPR_MS_PER_SEC 1000 +#define GPR_US_PER_SEC 1000000 +#define GPR_NS_PER_SEC 1000000000 +#define GPR_NS_PER_MS 1000000 +#define GPR_NS_PER_US 1000 +#define GPR_US_PER_MS 1000 + +/** initialize time subsystem */ +GPRAPI void gpr_time_init(void); + +/** Return the current time measured from the given clocks epoch. */ +GPRAPI gpr_timespec gpr_now(gpr_clock_type clock); + +/** Convert a timespec from one clock to another */ +GPRAPI gpr_timespec gpr_convert_clock_type(gpr_timespec t, + gpr_clock_type clock_type); + +/** Return -ve, 0, or +ve according to whether a < b, a == b, or a > b + respectively. */ +GPRAPI int gpr_time_cmp(gpr_timespec a, gpr_timespec b); + +GPRAPI gpr_timespec gpr_time_max(gpr_timespec a, gpr_timespec b); +GPRAPI gpr_timespec gpr_time_min(gpr_timespec a, gpr_timespec b); + +/** Add and subtract times. Calculations saturate at infinities. */ +GPRAPI gpr_timespec gpr_time_add(gpr_timespec a, gpr_timespec b); +GPRAPI gpr_timespec gpr_time_sub(gpr_timespec a, gpr_timespec b); + +/** Return a timespec representing a given number of time units. INT64_MIN is + interpreted as gpr_inf_past, and INT64_MAX as gpr_inf_future. */ +GPRAPI gpr_timespec gpr_time_from_micros(int64_t us, gpr_clock_type clock_type); +GPRAPI gpr_timespec gpr_time_from_nanos(int64_t ns, gpr_clock_type clock_type); +GPRAPI gpr_timespec gpr_time_from_millis(int64_t ms, gpr_clock_type clock_type); +GPRAPI gpr_timespec gpr_time_from_seconds(int64_t s, gpr_clock_type clock_type); +GPRAPI gpr_timespec gpr_time_from_minutes(int64_t m, gpr_clock_type clock_type); +GPRAPI gpr_timespec gpr_time_from_hours(int64_t h, gpr_clock_type clock_type); + +GPRAPI int32_t gpr_time_to_millis(gpr_timespec timespec); + +/** Return 1 if two times are equal or within threshold of each other, + 0 otherwise */ +GPRAPI int gpr_time_similar(gpr_timespec a, gpr_timespec b, + gpr_timespec threshold); + +/** Sleep until at least 'until' - an absolute timeout */ +GPRAPI void gpr_sleep_until(gpr_timespec until); + +GPRAPI double gpr_timespec_to_micros(gpr_timespec t); + +#ifdef __cplusplus +} +#endif + +#endif /* GRPC_SUPPORT_TIME_H */ diff --git a/grpc/spm-core-include/grpc/support/workaround_list.h b/grpc/spm-core-include/grpc/support/workaround_list.h new file mode 100644 index 00000000..e28dfa14 --- /dev/null +++ b/grpc/spm-core-include/grpc/support/workaround_list.h @@ -0,0 +1,31 @@ +/* + * + * Copyright 2015 gRPC authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#ifndef GRPC_SUPPORT_WORKAROUND_LIST_H +#define GRPC_SUPPORT_WORKAROUND_LIST_H + +/* The list of IDs of server workarounds currently maintained by gRPC. For + * explanation and detailed descriptions of workarounds, see + * /doc/workarounds.md + */ +typedef enum { + GRPC_WORKAROUND_ID_CRONET_COMPRESSION = 0, + GRPC_MAX_WORKAROUND_ID +} grpc_workaround_list; + +#endif /* GRPC_SUPPORT_WORKAROUND_LIST_H */ |