adding pods method of package managing
This commit is contained in:
talksik
+95
@@ -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 */
|
||||
@@ -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 */
|
||||
@@ -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 */
|
||||
+128
@@ -0,0 +1,128 @@
|
||||
/*
|
||||
*
|
||||
* 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>
|
||||
|
||||
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 /* GRPC_IMPL_CODEGEN_ATM_WINDOWS_H */
|
||||
+101
@@ -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* byte_buffer);
|
||||
|
||||
/** 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 */
|
||||
@@ -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 */
|
||||
@@ -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 */
|
||||
@@ -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 */
|
||||
+48
@@ -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 */
|
||||
@@ -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 */
|
||||
@@ -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 */
|
||||
+787
@@ -0,0 +1,787 @@
|
||||
/*
|
||||
*
|
||||
* 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"
|
||||
/** 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"
|
||||
/** Minimum time between sending successive ping frames without receiving any
|
||||
data frame, Int valued, milliseconds. */
|
||||
#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 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 frame or 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 serverlist from the xDS load
|
||||
balancer before using fallback backend addresses from the resolver.
|
||||
If 0, enter fallback mode immediately. Default value is 10000. */
|
||||
#define GRPC_ARG_XDS_FALLBACK_TIMEOUT_MS "grpc.xds_fallback_timeout_ms"
|
||||
/* Time in milliseconds to wait before a locality is deleted after it's removed
|
||||
from the received EDS update. If 0, delete the locality immediately. Default
|
||||
value is 15 minutes. */
|
||||
#define GRPC_ARG_LOCALITY_RETENTION_INTERVAL_MS \
|
||||
"grpc.xds_locality_retention_interval_ms"
|
||||
/* Timeout in milliseconds to wait for the localities of a specific priority to
|
||||
complete their initial connection attempt before xDS fails over to the next
|
||||
priority. Specifically, the connection attempt of a priority is considered
|
||||
completed when any locality of that priority is ready or all the localities
|
||||
of that priority fail to connect. If 0, failover happens immediately. Default
|
||||
value is 10 seconds. */
|
||||
#define GRPC_ARG_XDS_FAILOVER_TIMEOUT_MS "grpc.xds_failover_timeout_ms"
|
||||
/* Timeout in milliseconds to wait for a resource to be returned from
|
||||
* the xds server before assuming that it does not exist.
|
||||
* The default is 15 seconds. */
|
||||
#define GRPC_ARG_XDS_RESOURCE_DOES_NOT_EXIST_TIMEOUT_MS \
|
||||
"grpc.xds_resource_does_not_exist_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"
|
||||
/** 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 in any way (seen as a
|
||||
cancellation on the server), or 0 if the call succeeded */
|
||||
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 */
|
||||
+112
@@ -0,0 +1,112 @@
|
||||
/*
|
||||
*
|
||||
* 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;
|
||||
|
||||
#define GPR_LOG_VERBOSITY_UNSET -1
|
||||
|
||||
/** 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 */
|
||||
@@ -0,0 +1,716 @@
|
||||
/*
|
||||
*
|
||||
* 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 GRPC_USE_ABSL to use Abseil Common Libraries (C++)
|
||||
*/
|
||||
#ifndef GRPC_USE_ABSL
|
||||
#define GRPC_USE_ABSL 1
|
||||
#endif
|
||||
|
||||
/*
|
||||
* Defines GPR_ABSEIL_SYNC to use synchronization features from Abseil
|
||||
*/
|
||||
#ifndef GPR_ABSEIL_SYNC
|
||||
/* #define GPR_ABSEIL_SYNC 1 */
|
||||
#endif
|
||||
|
||||
/* 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 */
|
||||
|
||||
#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) */
|
||||
|
||||
#include <windows.h>
|
||||
|
||||
#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_STRING
|
||||
#define GPR_WINDOWS_TIME
|
||||
#endif
|
||||
#ifdef __GNUC__
|
||||
#define GPR_GCC_ATOMIC 1
|
||||
#define GPR_GCC_TLS 1
|
||||
#else
|
||||
#define GPR_WINDOWS_ATOMIC 1
|
||||
#define GPR_MSVC_TLS 1
|
||||
#endif
|
||||
#elif defined(GPR_MANYLINUX1)
|
||||
// TODO(atash): manylinux1 is just another __linux__ but with ancient
|
||||
// libraries; it should be integrated with the `__linux__` definitions below.
|
||||
#define GPR_PLATFORM_STRING "manylinux"
|
||||
#define GPR_POSIX_CRASH_HANDLER 1
|
||||
#define GPR_CPU_POSIX 1
|
||||
#define GPR_GCC_ATOMIC 1
|
||||
#define GPR_GCC_TLS 1
|
||||
#define GPR_LINUX 1
|
||||
#define GPR_LINUX_LOG 1
|
||||
#define GPR_SUPPORT_CHANNELS_FROM_FD 1
|
||||
#define GPR_LINUX_ENV 1
|
||||
#define GPR_POSIX_TMPFILE 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 */
|
||||
#include <linux/version.h>
|
||||
#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_GCC_TLS 1
|
||||
#define GPR_POSIX_ENV 1
|
||||
#define GPR_POSIX_TMPFILE 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_GCC_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_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 GPR_PTHREAD_TLS 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"
|
||||
#ifdef __MAC_OS_X_VERSION_MIN_REQUIRED
|
||||
#if __MAC_OS_X_VERSION_MIN_REQUIRED < __MAC_10_7
|
||||
#define GPR_CPU_IPHONE 1
|
||||
#define GPR_PTHREAD_TLS 1
|
||||
#else /* __MAC_OS_X_VERSION_MIN_REQUIRED < __MAC_10_7 */
|
||||
#define GPR_CPU_POSIX 1
|
||||
/* TODO(vjpai): there is a reported issue in bazel build for Mac where __thread
|
||||
in a header is currently not working (bazelbuild/bazel#4341). Remove
|
||||
the following conditional and use GPR_GCC_TLS when that is fixed */
|
||||
#ifndef GRPC_BAZEL_BUILD
|
||||
#define GPR_GCC_TLS 1
|
||||
#else /* GRPC_BAZEL_BUILD */
|
||||
#define GPR_PTHREAD_TLS 1
|
||||
#endif /* GRPC_BAZEL_BUILD */
|
||||
#define GPR_APPLE_PTHREAD_NAME 1
|
||||
#endif
|
||||
#else /* __MAC_OS_X_VERSION_MIN_REQUIRED */
|
||||
#define GPR_CPU_POSIX 1
|
||||
/* TODO(vjpai): Remove the following conditional and use only GPR_GCC_TLS
|
||||
when bazelbuild/bazel#4341 is fixed */
|
||||
#ifndef GRPC_BAZEL_BUILD
|
||||
#define GPR_GCC_TLS 1
|
||||
#else /* GRPC_BAZEL_BUILD */
|
||||
#define GPR_PTHREAD_TLS 1
|
||||
#endif /* GRPC_BAZEL_BUILD */
|
||||
#endif
|
||||
#define GPR_POSIX_CRASH_HANDLER 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_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_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_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_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_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_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_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
|
||||
|
||||
/*
|
||||
* There are platforms for which TLS should not be used even though the
|
||||
* compiler makes it seem like it's supported (Android NDK < r12b for example).
|
||||
* This is primarily because of linker problems and toolchain misconfiguration:
|
||||
* TLS isn't supported until NDK r12b per
|
||||
* https://developer.android.com/ndk/downloads/revision_history.html
|
||||
* TLS also does not work with Android NDK if GCC is being used as the compiler
|
||||
* instead of Clang.
|
||||
* Since NDK r16, `__NDK_MAJOR__` and `__NDK_MINOR__` are defined in
|
||||
* <android/ndk-version.h>. For NDK < r16, users should define these macros,
|
||||
* e.g. `-D__NDK_MAJOR__=11 -D__NKD_MINOR__=0` for NDK r11. */
|
||||
#if defined(__ANDROID__) && defined(GPR_GCC_TLS)
|
||||
#if __has_include(<android/ndk-version.h>)
|
||||
#include <android/ndk-version.h>
|
||||
#endif /* __has_include(<android/ndk-version.h>) */
|
||||
#if (defined(__clang__) && defined(__NDK_MAJOR__) && defined(__NDK_MINOR__) && \
|
||||
((__NDK_MAJOR__ < 12) || \
|
||||
((__NDK_MAJOR__ == 12) && (__NDK_MINOR__ < 1)))) || \
|
||||
(defined(__GNUC__) && !defined(__clang__))
|
||||
#undef GPR_GCC_TLS
|
||||
#define GPR_PTHREAD_TLS 1
|
||||
#endif
|
||||
#endif /*defined(__ANDROID__) && defined(GPR_GCC_TLS) */
|
||||
|
||||
#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_CUSTOM_TLS) != \
|
||||
1
|
||||
#error Must define exactly one of GPR_MSVC_TLS, GPR_GCC_TLS, GPR_PTHREAD_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. */
|
||||
#if defined(__SANITIZE_THREAD__)
|
||||
#define GRPC_TSAN_ENABLED
|
||||
#elif GPR_HAS_FEATURE(thread_sanitizer)
|
||||
#define GRPC_TSAN_ENABLED
|
||||
#endif
|
||||
|
||||
/* GRPC_ASAN_ENABLED will be defined, when compiled with address sanitizer. */
|
||||
#if defined(__SANITIZE_ADDRESS__)
|
||||
#define GRPC_ASAN_ENABLED
|
||||
#elif GPR_HAS_FEATURE(address_sanitizer)
|
||||
#define GRPC_ASAN_ENABLED
|
||||
#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 */
|
||||
@@ -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 */
|
||||
+127
@@ -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 */
|
||||
+154
@@ -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 */
|
||||
+65
@@ -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 */
|
||||
@@ -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 */
|
||||
@@ -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 */
|
||||
@@ -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 */
|
||||
@@ -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 */
|
||||
@@ -0,0 +1,36 @@
|
||||
/*
|
||||
*
|
||||
* 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>
|
||||
|
||||
#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 /* GRPC_IMPL_CODEGEN_SYNC_WINDOWS_H */
|
||||
Reference in New Issue
Block a user