grpc 0.13.0 → 0.13.1.pre1

data/include/grpc/census.h

@@ -59,15 +59,15 @@ enum census_features {
  * census_initialize() will return a non-zero value. It is an error to call
  * census_initialize() more than once (without an intervening
  * census_shutdown()). */
-CENSUS_API int census_initialize(int features);
-CENSUS_API void census_shutdown(void);
+CENSUSAPI int census_initialize(int features);
+CENSUSAPI void census_shutdown(void);
 
 /** Return the features supported by the current census implementation (not all
  * features will be available on all platforms). */
-CENSUS_API int census_supported(void);
+CENSUSAPI int census_supported(void);
 
 /** Return the census features currently enabled. */
-CENSUS_API int census_enabled(void);
+CENSUSAPI int census_enabled(void);
 
 /**
   A Census Context is a handle used by Census to represent the current tracing
@@ -80,18 +80,18 @@ CENSUS_API int census_enabled(void);
   metrics will be recorded. Keys are unique within a context. */
 typedef struct census_context census_context;
 
-/* A tag is a key:value pair. The key is a non-empty, printable (UTF-8
-   encoded), nil-terminated string. The value is a binary string, that may be
-   printable. There are limits on the sizes of both keys and values (see
-   CENSUS_MAX_TAG_KB_LEN definition below), and the number of tags that can be
-   propagated (CENSUS_MAX_PROPAGATED_TAGS). Users should also remember that
-   some systems may have limits on, e.g., the number of bytes that can be
-   transmitted as metadata, and that larger tags means more memory consumed
-   and time in processing. */
+/* A tag is a key:value pair. Both keys and values are nil-terminated strings,
+   containing printable ASCII characters (decimal 32-126). Keys must be at
+   least one character in length. Both keys and values can have at most
+   CENSUS_MAX_TAG_KB_LEN characters (including the terminating nil). The
+   maximum number of tags that can be propagated is
+   CENSUS_MAX_PROPAGATED_TAGS. Users should also remember that some systems
+   may have limits on, e.g., the number of bytes that can be transmitted as
+   metadata, and that larger tags means more memory consumed and time in
+   processing. */
 typedef struct {
   const char *key;
   const char *value;
-  size_t value_len;
   uint8_t flags;
 } census_tag;
 
@@ -103,28 +103,25 @@ typedef struct {
 /* Tag flags. */
 #define CENSUS_TAG_PROPAGATE 1 /* Tag should be propagated over RPC */
 #define CENSUS_TAG_STATS 2     /* Tag will be used for statistics aggregation */
-#define CENSUS_TAG_BINARY 4    /* Tag value is not printable */
-#define CENSUS_TAG_RESERVED 8  /* Reserved for internal use. */
-/* Flag values 8,16,32,64,128 are reserved for future/internal use. Clients
+#define CENSUS_TAG_RESERVED 4  /* Reserved for internal use. */
+/* Flag values 4,8,16,32,64,128 are reserved for future/internal use. Clients
    should not use or rely on their values. */
 
 #define CENSUS_TAG_IS_PROPAGATED(flags) (flags & CENSUS_TAG_PROPAGATE)
 #define CENSUS_TAG_IS_STATS(flags) (flags & CENSUS_TAG_STATS)
-#define CENSUS_TAG_IS_BINARY(flags) (flags & CENSUS_TAG_BINARY)
 
 /* An instance of this structure is kept by every context, and records the
    basic information associated with the creation of that context. */
 typedef struct {
-  int n_propagated_tags;        /* number of propagated printable tags */
-  int n_propagated_binary_tags; /* number of propagated binary tags */
-  int n_local_tags;             /* number of non-propagated (local) tags */
-  int n_deleted_tags;           /* number of tags that were deleted */
-  int n_added_tags;             /* number of tags that were added */
-  int n_modified_tags;          /* number of tags that were modified */
-  int n_invalid_tags;           /* number of tags with bad keys or values (e.g.
-                                   longer than CENSUS_MAX_TAG_KV_LEN) */
-  int n_ignored_tags;           /* number of tags ignored because of
-                                   CENSUS_MAX_PROPAGATED_TAGS limit. */
+  int n_propagated_tags; /* number of propagated tags */
+  int n_local_tags;      /* number of non-propagated (local) tags */
+  int n_deleted_tags;    /* number of tags that were deleted */
+  int n_added_tags;      /* number of tags that were added */
+  int n_modified_tags;   /* number of tags that were modified */
+  int n_invalid_tags;    /* number of tags with bad keys or values (e.g.
+                            longer than CENSUS_MAX_TAG_KV_LEN) */
+  int n_ignored_tags;    /* number of tags ignored because of
+                            CENSUS_MAX_PROPAGATED_TAGS limit. */
 } census_context_status;
 
 /* Create a new context, adding and removing tags from an existing context.
@@ -132,10 +129,10 @@ typedef struct {
    to add as many tags in a single operation as is practical for the client.
    @param base Base context to build upon. Can be NULL.
    @param tags A set of tags to be added/changed/deleted. Tags with keys that
-   are in 'tags', but not 'base', are added to the tag set. Keys that are in
+   are in 'tags', but not 'base', are added to the context. Keys that are in
    both 'tags' and 'base' will have their value/flags modified. Tags with keys
-   in both, but with NULL or zero-length values, will be deleted from the tag
-   set. Tags with invalid (too long or short) keys or values will be ignored.
+   in both, but with NULL values, will be deleted from the context. Tags with
+   invalid (too long or short) keys or values will be ignored.
    If adding a tag will result in more than CENSUS_MAX_PROPAGATED_TAGS in either
    binary or non-binary tags, they will be ignored, as will deletions of
    tags that don't exist.
@@ -145,16 +142,16 @@ typedef struct {
    tags used in its creation.
    @return A new, valid census_context.
 */
-CENSUS_API census_context *census_context_create(
+CENSUSAPI census_context *census_context_create(
     const census_context *base, const census_tag *tags, int ntags,
     census_context_status const **status);
 
 /* Destroy a context. Once this function has been called, the context cannot
    be reused. */
-CENSUS_API void census_context_destroy(census_context *context);
+CENSUSAPI void census_context_destroy(census_context *context);
 
 /* Get a pointer to the original status from the context creation. */
-CENSUS_API const census_context_status *census_context_get_status(
+CENSUSAPI const census_context_status *census_context_get_status(
     const census_context *context);
 
 /* Structure used for iterating over the tegs in a context. API clients should
@@ -168,50 +165,36 @@ typedef struct {
 } census_context_iterator;
 
 /* Initialize a census_tag_iterator. Must be called before first use. */
-CENSUS_API void census_context_initialize_iterator(
+CENSUSAPI void census_context_initialize_iterator(
     const census_context *context, census_context_iterator *iterator);
 
 /* Get the contents of the "next" tag in the context. If there are no more
    tags, returns 0 (and 'tag' contents will be unchanged), otherwise returns 1.
    */
-CENSUS_API int census_context_next_tag(census_context_iterator *iterator,
-                                       census_tag *tag);
+CENSUSAPI int census_context_next_tag(census_context_iterator *iterator,
+                                      census_tag *tag);
 
 /* Get a context tag by key. Returns 0 if the key is not present. */
-CENSUS_API int census_context_get_tag(const census_context *context,
-                                      const char *key, census_tag *tag);
+CENSUSAPI int census_context_get_tag(const census_context *context,
+                                     const char *key, census_tag *tag);
 
 /* Tag set encode/decode functionality. These functionas are intended
    for use by RPC systems only, for purposes of transmitting/receiving contexts.
    */
 
-/* Encode a context into a buffer. The propagated tags are encoded into the
-   buffer in two regions: one for printable tags, and one for binary tags.
+/* Encode a context into a buffer.
    @param context context to be encoded
-   @param buffer pointer to buffer. This address will be used to encode the
-                 printable tags.
+   @param buffer buffer into which the context will be encoded.
    @param buf_size number of available bytes in buffer.
-   @param print_buf_size Will be set to the number of bytes consumed by
-                         printable tags.
-   @param bin_buf_size Will be set to the number of bytes used to encode the
-                       binary tags.
-   @return A pointer to the binary tag's encoded, or NULL if the buffer was
-           insufficiently large to hold the encoded tags. Thus, if successful,
-           printable tags are encoded into
-           [buffer, buffer + *print_buf_size) and binary tags into
-           [returned-ptr, returned-ptr + *bin_buf_size) (and the returned
-           pointer should be buffer + *print_buf_size) */
-CENSUS_API char *census_context_encode(const census_context *context,
-                                       char *buffer, size_t buf_size,
-                                       size_t *print_buf_size,
-                                       size_t *bin_buf_size);
-
-/* Decode context buffers encoded with census_context_encode(). Returns NULL
+   @return The number of buffer bytes consumed for the encoded context, or
+           zero if the buffer was of insufficient size. */
+CENSUSAPI size_t census_context_encode(const census_context *context,
+                                       char *buffer, size_t buf_size);
+
+/* Decode context buffer encoded with census_context_encode(). Returns NULL
    if there is an error in parsing either buffer. */
-CENSUS_API census_context *census_context_decode(const char *buffer,
-                                                 size_t size,
-                                                 const char *bin_buffer,
-                                                 size_t bin_size);
+CENSUSAPI census_context *census_context_decode(const char *buffer,
+                                                size_t size);
 
 /* Distributed traces can have a number of options. */
 enum census_trace_mask_values {
@@ -221,10 +204,10 @@ enum census_trace_mask_values {
 
 /** Get the current trace mask associated with this context. The value returned
     will be the logical or of census_trace_mask_values values. */
-CENSUS_API int census_trace_mask(const census_context *context);
+CENSUSAPI int census_trace_mask(const census_context *context);
 
 /** Set the trace mask associated with a context. */
-CENSUS_API void census_set_trace_mask(int trace_mask);
+CENSUSAPI void census_set_trace_mask(int trace_mask);
 
 /* The concept of "operation" is a fundamental concept for Census. In an RPC
    system, and operation typcially represents a single RPC, or a significant
@@ -272,7 +255,7 @@ typedef struct {
 
   @return A timestamp representing the operation start time.
 */
-CENSUS_API census_timestamp census_start_rpc_op_timestamp(void);
+CENSUSAPI census_timestamp census_start_rpc_op_timestamp(void);
 
 /**
   Represent functions to map RPC name ID to service/method names. Census
@@ -324,7 +307,7 @@ typedef struct {
 
    @return A new census context.
  */
-CENSUS_API census_context *census_start_client_rpc_op(
+CENSUSAPI census_context *census_start_client_rpc_op(
     const census_context *context, int64_t rpc_name_id,
     const census_rpc_name_info *rpc_name_info, const char *peer, int trace_mask,
     const census_timestamp *start_time);
@@ -332,8 +315,8 @@ CENSUS_API census_context *census_start_client_rpc_op(
 /**
   Add peer information to a context representing a client RPC operation.
 */
-CENSUS_API void census_set_rpc_client_peer(census_context *context,
-                                           const char *peer);
+CENSUSAPI void census_set_rpc_client_peer(census_context *context,
+                                          const char *peer);
 
 /**
    Start a server RPC operation. Returns a new context to be used in future
@@ -353,7 +336,7 @@ CENSUS_API void census_set_rpc_client_peer(census_context *context,
 
    @return A new census context.
  */
-CENSUS_API census_context *census_start_server_rpc_op(
+CENSUSAPI census_context *census_start_server_rpc_op(
     const char *buffer, int64_t rpc_name_id,
     const census_rpc_name_info *rpc_name_info, const char *peer, int trace_mask,
     census_timestamp *start_time);
@@ -383,9 +366,9 @@ CENSUS_API census_context *census_start_server_rpc_op(
 
    @return A new census context.
  */
-CENSUS_API census_context *census_start_op(census_context *context,
-                                           const char *family, const char *name,
-                                           int trace_mask);
+CENSUSAPI census_context *census_start_op(census_context *context,
+                                          const char *family, const char *name,
+                                          int trace_mask);
 
 /**
   End an operation started by any of the census_start_*_op*() calls. The
@@ -396,7 +379,7 @@ CENSUS_API census_context *census_start_op(census_context *context,
   @param status status associated with the operation. Not interpreted by
                 census.
 */
-CENSUS_API void census_end_op(census_context *context, int status);
+CENSUSAPI void census_end_op(census_context *context, int status);
 
 #define CENSUS_TRACE_RECORD_START_OP ((uint32_t)0)
 #define CENSUS_TRACE_RECORD_END_OP ((uint32_t)1)
@@ -408,8 +391,8 @@ CENSUS_API void census_end_op(census_context *context, int status);
     @param buffer Pointer to buffer to use
     @param n Number of bytes in buffer
 */
-CENSUS_API void census_trace_print(census_context *context, uint32_t type,
-                                   const char *buffer, size_t n);
+CENSUSAPI void census_trace_print(census_context *context, uint32_t type,
+                                  const char *buffer, size_t n);
 
 /** Trace record. */
 typedef struct {
@@ -430,7 +413,7 @@ typedef struct {
          while scanning is ongoing.
   @returns 0 on success, non-zero on failure (e.g. if a scan is already ongoing)
 */
-CENSUS_API int census_trace_scan_start(int consume);
+CENSUSAPI int census_trace_scan_start(int consume);
 
 /** Get a trace record. The data pointed to by the trace buffer is guaranteed
     stable until the next census_get_trace_record() call (if the consume
@@ -441,10 +424,10 @@ CENSUS_API int census_trace_scan_start(int consume);
            census_trace_scan_start()), 0 if there is no more trace data (and
            trace_record will not be modified) or 1 otherwise.
 */
-CENSUS_API int census_get_trace_record(census_trace_record *trace_record);
+CENSUSAPI int census_get_trace_record(census_trace_record *trace_record);
 
 /** End a scan previously started by census_trace_scan_start() */
-CENSUS_API void census_trace_scan_end();
+CENSUSAPI void census_trace_scan_end();
 
 /* Core stats collection API's. The following concepts are used:
    * Aggregation: A collection of values. Census supports the following
@@ -475,8 +458,8 @@ typedef struct {
 } census_value;
 
 /* Record new usage values against the given context. */
-CENSUS_API void census_record_values(census_context *context,
-                                     census_value *values, size_t nvalues);
+CENSUSAPI void census_record_values(census_context *context,
+                                    census_value *values, size_t nvalues);
 
 /** Type representing a particular aggregation */
 typedef struct census_aggregation_ops census_aggregation_ops;
@@ -508,24 +491,24 @@ typedef struct census_view census_view;
 
 /* TODO(aveitch): consider if context is the right argument type to pass in
    tags. */
-CENSUS_API census_view *census_view_create(
+CENSUSAPI census_view *census_view_create(
     uint32_t metric_id, const census_context *tags,
     const census_aggregation *aggregations, size_t naggregations);
 
 /** Destroy a previously created view. */
-CENSUS_API void census_view_delete(census_view *view);
+CENSUSAPI void census_view_delete(census_view *view);
 
 /** Metric ID associated with a view */
-CENSUS_API size_t census_view_metric(const census_view *view);
+CENSUSAPI size_t census_view_metric(const census_view *view);
 
 /** Number of aggregations associated with view. */
-CENSUS_API size_t census_view_naggregations(const census_view *view);
+CENSUSAPI size_t census_view_naggregations(const census_view *view);
 
 /** Get tags associated with view. */
-CENSUS_API const census_context *census_view_tags(const census_view *view);
+CENSUSAPI const census_context *census_view_tags(const census_view *view);
 
 /** Get aggregation descriptors associated with a view. */
-CENSUS_API const census_aggregation *census_view_aggregrations(
+CENSUSAPI const census_aggregation *census_view_aggregrations(
     const census_view *view);
 
 /** Holds all the aggregation data for a particular view instantiation. Forms
@@ -545,11 +528,10 @@ typedef struct {
   @param view View from which to get data.
   @return Full set of data for all aggregations for the view.
 */
-CENSUS_API const census_view_data *census_view_get_data(
-    const census_view *view);
+CENSUSAPI const census_view_data *census_view_get_data(const census_view *view);
 
 /** Reset all view data to zero for the specified view */
-CENSUS_API void census_view_reset(census_view *view);
+CENSUSAPI void census_view_reset(census_view *view);
 
 #ifdef __cplusplus
 }

data/include/grpc/compression.h

@@ -46,33 +46,33 @@ extern "C" {
 /** Parses the first \a name_length bytes of \a name as a
  * grpc_compression_algorithm instance, updating \a algorithm. Returns 1 upon
  * success, 0 otherwise. */
-GRPC_API int grpc_compression_algorithm_parse(
+GRPCAPI int grpc_compression_algorithm_parse(
     const char *name, size_t name_length,
     grpc_compression_algorithm *algorithm);
 
 /** Updates \a name with the encoding name corresponding to a valid \a
  * algorithm.  Returns 1 upon success, 0 otherwise. */
-GRPC_API int grpc_compression_algorithm_name(
+GRPCAPI int grpc_compression_algorithm_name(
     grpc_compression_algorithm algorithm, char **name);
 
 /** Returns the compression algorithm corresponding to \a level.
  *
  * It abort()s for unknown levels . */
-GRPC_API grpc_compression_algorithm
+GRPCAPI grpc_compression_algorithm
 grpc_compression_algorithm_for_level(grpc_compression_level level);
 
-GRPC_API void grpc_compression_options_init(grpc_compression_options *opts);
+GRPCAPI void grpc_compression_options_init(grpc_compression_options *opts);
 
 /** Mark \a algorithm as enabled in \a opts. */
-GRPC_API void grpc_compression_options_enable_algorithm(
+GRPCAPI void grpc_compression_options_enable_algorithm(
     grpc_compression_options *opts, grpc_compression_algorithm algorithm);
 
 /** Mark \a algorithm as disabled in \a opts. */
-GRPC_API void grpc_compression_options_disable_algorithm(
+GRPCAPI void grpc_compression_options_disable_algorithm(
     grpc_compression_options *opts, grpc_compression_algorithm algorithm);
 
 /** Returns true if \a algorithm is marked as enabled in \a opts. */
-GRPC_API int grpc_compression_options_is_algorithm_enabled(
+GRPCAPI int grpc_compression_options_is_algorithm_enabled(
     const grpc_compression_options *opts, grpc_compression_algorithm algorithm);
 
 #ifdef __cplusplus

data/include/grpc/grpc.h

@@ -55,11 +55,11 @@ extern "C" {
  * functionality lives in grpc_security.h.
  */
 
-GRPC_API void grpc_metadata_array_init(grpc_metadata_array *array);
-GRPC_API void grpc_metadata_array_destroy(grpc_metadata_array *array);
+GRPCAPI void grpc_metadata_array_init(grpc_metadata_array *array);
+GRPCAPI void grpc_metadata_array_destroy(grpc_metadata_array *array);
 
-GRPC_API void grpc_call_details_init(grpc_call_details *details);
-GRPC_API void grpc_call_details_destroy(grpc_call_details *details);
+GRPCAPI void grpc_call_details_init(grpc_call_details *details);
+GRPCAPI void grpc_call_details_destroy(grpc_call_details *details);
 
 /** Registers a plugin to be initialized and destroyed with the library.
 
@@ -69,7 +69,7 @@ GRPC_API void grpc_call_details_destroy(grpc_call_details *details);
     (and hence so will \a init and \a destroy).
     It is safe to pass NULL to either argument. Plugins are destroyed in
     the reverse order they were initialized. */
-GRPC_API void grpc_register_plugin(void (*init)(void), void (*destroy)(void));
+GRPCAPI void grpc_register_plugin(void (*init)(void), void (*destroy)(void));
 
 /** Initialize the grpc library.
 
@@ -77,7 +77,7 @@ GRPC_API void grpc_register_plugin(void (*init)(void), void (*destroy)(void));
     (To avoid overhead, little checking is done, and some things may work. We
     do not warrant that they will continue to do so in future revisions of this
     library). */
-GRPC_API void grpc_init(void);
+GRPCAPI void grpc_init(void);
 
 /** Shut down the grpc library.
 
@@ -85,13 +85,13 @@ GRPC_API void grpc_init(void);
     executing within the grpc library.
     Prior to calling, all application owned grpc objects must have been
     destroyed. */
-GRPC_API void grpc_shutdown(void);
+GRPCAPI void grpc_shutdown(void);
 
 /** Return a string representing the current version of grpc */
-GRPC_API const char *grpc_version_string(void);
+GRPCAPI const char *grpc_version_string(void);
 
 /** Create a completion queue */
-GRPC_API grpc_completion_queue *grpc_completion_queue_create(void *reserved);
+GRPCAPI grpc_completion_queue *grpc_completion_queue_create(void *reserved);
 
 /** Blocks until an event is available, the completion queue is being shut down,
     or deadline is reached.
@@ -101,9 +101,9 @@ GRPC_API grpc_completion_queue *grpc_completion_queue_create(void *reserved);
 
     Callers must not call grpc_completion_queue_next and
     grpc_completion_queue_pluck simultaneously on the same completion queue. */
-GRPC_API grpc_event grpc_completion_queue_next(grpc_completion_queue *cq,
-                                               gpr_timespec deadline,
-                                               void *reserved);
+GRPCAPI grpc_event grpc_completion_queue_next(grpc_completion_queue *cq,
+                                              gpr_timespec deadline,
+                                              void *reserved);
 
 /** Blocks until an event with tag 'tag' is available, the completion queue is
     being shutdown or deadline is reached.
@@ -116,9 +116,9 @@ GRPC_API grpc_event grpc_completion_queue_next(grpc_completion_queue *cq,
 
     Completion queues support a maximum of GRPC_MAX_COMPLETION_QUEUE_PLUCKERS
     concurrently executing plucks at any time. */
-GRPC_API grpc_event
-grpc_completion_queue_pluck(grpc_completion_queue *cq, void *tag,
-                            gpr_timespec deadline, void *reserved);
+GRPCAPI grpc_event grpc_completion_queue_pluck(grpc_completion_queue *cq,
+                                               void *tag, gpr_timespec deadline,
+                                               void *reserved);
 
 /** Maximum number of outstanding grpc_completion_queue_pluck executions per
     completion queue */
@@ -131,11 +131,11 @@ grpc_completion_queue_pluck(grpc_completion_queue *cq, void *tag,
 
     After calling this function applications should ensure that no
     NEW work is added to be published on this completion queue. */
-GRPC_API void grpc_completion_queue_shutdown(grpc_completion_queue *cq);
+GRPCAPI void grpc_completion_queue_shutdown(grpc_completion_queue *cq);
 
 /** Destroy a completion queue. The caller must ensure that the queue is
     drained and no threads are executing grpc_completion_queue_next */
-GRPC_API void grpc_completion_queue_destroy(grpc_completion_queue *cq);
+GRPCAPI void grpc_completion_queue_destroy(grpc_completion_queue *cq);
 
 /** Create a completion queue alarm instance associated to \a cq.
  *
@@ -143,18 +143,18 @@ GRPC_API void grpc_completion_queue_destroy(grpc_completion_queue *cq);
  * grpc_alarm_cancel), an event with tag \a tag will be added to \a cq. If the
  * alarm expired, the event's success bit will be true, false otherwise (ie,
  * upon cancellation). */
-GRPC_API grpc_alarm *grpc_alarm_create(grpc_completion_queue *cq,
-                                       gpr_timespec deadline, void *tag);
+GRPCAPI grpc_alarm *grpc_alarm_create(grpc_completion_queue *cq,
+                                      gpr_timespec deadline, void *tag);
 
 /** Cancel a completion queue alarm. Calling this function over an alarm that
  * has already fired has no effect. */
-GRPC_API void grpc_alarm_cancel(grpc_alarm *alarm);
+GRPCAPI void grpc_alarm_cancel(grpc_alarm *alarm);
 
 /** Destroy the given completion queue alarm, cancelling it in the process. */
-GRPC_API void grpc_alarm_destroy(grpc_alarm *alarm);
+GRPCAPI void grpc_alarm_destroy(grpc_alarm *alarm);
 
 /** Check the connectivity state of a channel. */
-GRPC_API grpc_connectivity_state
+GRPCAPI grpc_connectivity_state
 grpc_channel_check_connectivity_state(grpc_channel *channel,
                                       int try_to_connect);
 
@@ -163,7 +163,7 @@ grpc_channel_check_connectivity_state(grpc_channel *channel,
     tag will be enqueued on cq with success=1.
     If deadline expires BEFORE the state is changed, tag will be enqueued on cq
     with success=0. */
-GRPC_API void grpc_channel_watch_connectivity_state(
+GRPCAPI void grpc_channel_watch_connectivity_state(
     grpc_channel *channel, grpc_connectivity_state last_observed_state,
     gpr_timespec deadline, grpc_completion_queue *cq, void *tag);
 
@@ -173,24 +173,23 @@ GRPC_API void grpc_channel_watch_connectivity_state(
     If parent_call is non-NULL, it must be a server-side call. It will be used
     to propagate properties from the server call to this new client call.
     */
-GRPC_API grpc_call *grpc_channel_create_call(
+GRPCAPI grpc_call *grpc_channel_create_call(
     grpc_channel *channel, grpc_call *parent_call, uint32_t propagation_mask,
     grpc_completion_queue *completion_queue, const char *method,
     const char *host, gpr_timespec deadline, void *reserved);
 
 /** Ping the channels peer (load balanced channels will select one sub-channel
     to ping); if the channel is not connected, posts a failed. */
-GRPC_API void grpc_channel_ping(grpc_channel *channel,
-                                grpc_completion_queue *cq, void *tag,
-                                void *reserved);
+GRPCAPI void grpc_channel_ping(grpc_channel *channel, grpc_completion_queue *cq,
+                               void *tag, void *reserved);
 
 /** Pre-register a method/host pair on a channel. */
-GRPC_API void *grpc_channel_register_call(grpc_channel *channel,
-                                          const char *method, const char *host,
-                                          void *reserved);
+GRPCAPI void *grpc_channel_register_call(grpc_channel *channel,
+                                         const char *method, const char *host,
+                                         void *reserved);
 
 /** Create a call given a handle returned from grpc_channel_register_call */
-GRPC_API grpc_call *grpc_channel_create_registered_call(
+GRPCAPI grpc_call *grpc_channel_create_registered_call(
     grpc_channel *channel, grpc_call *parent_call, uint32_t propagation_mask,
     grpc_completion_queue *completion_queue, void *registered_call_handle,
     gpr_timespec deadline, void *reserved);
@@ -206,9 +205,9 @@ GRPC_API grpc_call *grpc_channel_create_registered_call(
     needs to be synchronized. As an optimization, you may synchronize batches
     containing just send operations independently from batches containing just
     receive operations. */
-GRPC_API grpc_call_error grpc_call_start_batch(grpc_call *call,
-                                               const grpc_op *ops, size_t nops,
-                                               void *tag, void *reserved);
+GRPCAPI grpc_call_error grpc_call_start_batch(grpc_call *call,
+                                              const grpc_op *ops, size_t nops,
+                                              void *tag, void *reserved);
 
 /** Returns a newly allocated string representing the endpoint to which this
     call is communicating with. The string is in the uri format accepted by
@@ -218,36 +217,36 @@ GRPC_API grpc_call_error grpc_call_start_batch(grpc_call *call,
     WARNING: this value is never authenticated or subject to any security
     related code. It must not be used for any authentication related
     functionality. Instead, use grpc_auth_context. */
-GRPC_API char *grpc_call_get_peer(grpc_call *call);
+GRPCAPI char *grpc_call_get_peer(grpc_call *call);
 
 struct census_context;
 
 /* Set census context for a call; Must be called before first call to
    grpc_call_start_batch(). */
-GRPC_API void grpc_census_call_set_context(grpc_call *call,
-                                           struct census_context *context);
+GRPCAPI void grpc_census_call_set_context(grpc_call *call,
+                                          struct census_context *context);
 
 /* Retrieve the calls current census context. */
-GRPC_API struct census_context *grpc_census_call_get_context(grpc_call *call);
+GRPCAPI struct census_context *grpc_census_call_get_context(grpc_call *call);
 
 /** Return a newly allocated string representing the target a channel was
     created for. */
-GRPC_API char *grpc_channel_get_target(grpc_channel *channel);
+GRPCAPI char *grpc_channel_get_target(grpc_channel *channel);
 
 /** Create a client channel to 'target'. Additional channel level configuration
     MAY be provided by grpc_channel_args, though the expectation is that most
     clients will want to simply pass NULL. See grpc_channel_args definition for
     more on this. The data in 'args' need only live through the invocation of
     this function. */
-GRPC_API grpc_channel *grpc_insecure_channel_create(
+GRPCAPI grpc_channel *grpc_insecure_channel_create(
     const char *target, const grpc_channel_args *args, void *reserved);
 
 /** Create a lame client: this client fails every operation attempted on it. */
-GRPC_API grpc_channel *grpc_lame_client_channel_create(
+GRPCAPI grpc_channel *grpc_lame_client_channel_create(
     const char *target, grpc_status_code error_code, const char *error_message);
 
 /** Close and destroy a grpc channel */
-GRPC_API void grpc_channel_destroy(grpc_channel *channel);
+GRPCAPI void grpc_channel_destroy(grpc_channel *channel);
 
 /* Error handling for grpc_call
    Most grpc_call functions return a grpc_error. If the error is not GRPC_OK
@@ -260,7 +259,7 @@ GRPC_API void grpc_channel_destroy(grpc_channel *channel);
     THREAD-SAFETY grpc_call_cancel and grpc_call_cancel_with_status
     are thread-safe, and can be called at any point before grpc_call_destroy
     is called.*/
-GRPC_API grpc_call_error grpc_call_cancel(grpc_call *call, void *reserved);
+GRPCAPI grpc_call_error grpc_call_cancel(grpc_call *call, void *reserved);
 
 /** Called by clients to cancel an RPC on the server.
     Can be called multiple times, from any thread.
@@ -268,13 +267,13 @@ GRPC_API grpc_call_error grpc_call_cancel(grpc_call *call, void *reserved);
     and description passed in.
     Importantly, this function does not send status nor description to the
     remote endpoint. */
-GRPC_API grpc_call_error
+GRPCAPI grpc_call_error
 grpc_call_cancel_with_status(grpc_call *call, grpc_status_code status,
                              const char *description, void *reserved);
 
 /** Destroy a call.
     THREAD SAFETY: grpc_call_destroy is thread-compatible */
-GRPC_API void grpc_call_destroy(grpc_call *call);
+GRPCAPI void grpc_call_destroy(grpc_call *call);
 
 /** Request notification of a new call.
     Once a call is received, a notification tagged with \a tag_new is added to
@@ -284,7 +283,7 @@ GRPC_API void grpc_call_destroy(grpc_call *call);
     to \a cq_bound_to_call.
     Note that \a cq_for_notification must have been registered to the server via
     \a grpc_server_register_completion_queue. */
-GRPC_API grpc_call_error
+GRPCAPI grpc_call_error
 grpc_server_request_call(grpc_server *server, grpc_call **call,
                          grpc_call_details *details,
                          grpc_metadata_array *request_metadata,
@@ -299,14 +298,13 @@ grpc_server_request_call(grpc_server *server, grpc_call **call,
     registered_method (as returned by this function).
     Must be called before grpc_server_start.
     Returns NULL on failure. */
-GRPC_API void *grpc_server_register_method(grpc_server *server,
-                                           const char *method,
-                                           const char *host);
+GRPCAPI void *grpc_server_register_method(grpc_server *server,
+                                          const char *method, const char *host);
 
 /** Request notification of a new pre-registered call. 'cq_for_notification'
     must have been registered to the server via
     grpc_server_register_completion_queue. */
-GRPC_API grpc_call_error grpc_server_request_registered_call(
+GRPCAPI grpc_call_error grpc_server_request_registered_call(
     grpc_server *server, void *registered_method, grpc_call **call,
     gpr_timespec *deadline, grpc_metadata_array *request_metadata,
     grpc_byte_buffer **optional_payload,
@@ -317,25 +315,25 @@ GRPC_API grpc_call_error grpc_server_request_registered_call(
     be specified with args. If no additional configuration is needed, args can
     be NULL. See grpc_channel_args for more. The data in 'args' need only live
     through the invocation of this function. */
-GRPC_API grpc_server *grpc_server_create(const grpc_channel_args *args,
-                                         void *reserved);
+GRPCAPI grpc_server *grpc_server_create(const grpc_channel_args *args,
+                                        void *reserved);
 
 /** Register a completion queue with the server. Must be done for any
     notification completion queue that is passed to grpc_server_request_*_call
     and to grpc_server_shutdown_and_notify. Must be performed prior to
     grpc_server_start. */
-GRPC_API void grpc_server_register_completion_queue(grpc_server *server,
-                                                    grpc_completion_queue *cq,
-                                                    void *reserved);
+GRPCAPI void grpc_server_register_completion_queue(grpc_server *server,
+                                                   grpc_completion_queue *cq,
+                                                   void *reserved);
 
 /** Add a HTTP2 over plaintext over tcp listener.
     Returns bound port number on success, 0 on failure.
     REQUIRES: server not started */
-GRPC_API int grpc_server_add_insecure_http2_port(grpc_server *server,
-                                                 const char *addr);
+GRPCAPI int grpc_server_add_insecure_http2_port(grpc_server *server,
+                                                const char *addr);
 
 /** Start a server - tells all listeners to start listening */
-GRPC_API void grpc_server_start(grpc_server *server);
+GRPCAPI void grpc_server_start(grpc_server *server);
 
 /** Begin shutting down a server.
     After completion, no new calls or connections will be admitted.
@@ -344,19 +342,19 @@ GRPC_API void grpc_server_start(grpc_server *server);
     Shutdown is idempotent, and all tags will be notified at once if multiple
     grpc_server_shutdown_and_notify calls are made. 'cq' must have been
     registered to this server via grpc_server_register_completion_queue. */
-GRPC_API void grpc_server_shutdown_and_notify(grpc_server *server,
-                                              grpc_completion_queue *cq,
-                                              void *tag);
+GRPCAPI void grpc_server_shutdown_and_notify(grpc_server *server,
+                                             grpc_completion_queue *cq,
+                                             void *tag);
 
 /** Cancel all in-progress calls.
     Only usable after shutdown. */
-GRPC_API void grpc_server_cancel_all_calls(grpc_server *server);
+GRPCAPI void grpc_server_cancel_all_calls(grpc_server *server);
 
 /** Destroy a server.
     Shutdown must have completed beforehand (i.e. all tags generated by
     grpc_server_shutdown_and_notify must have been received, and at least
     one call to grpc_server_shutdown_and_notify must have been made). */
-GRPC_API void grpc_server_destroy(grpc_server *server);
+GRPCAPI void grpc_server_destroy(grpc_server *server);
 
 /** Enable or disable a tracer.
 
@@ -366,18 +364,17 @@ GRPC_API void grpc_server_destroy(grpc_server *server);
 
     Use of this function is not strictly thread-safe, but the
     thread-safety issues raised by it should not be of concern. */
-GRPC_API int grpc_tracer_set_enabled(const char *name, int enabled);
+GRPCAPI int grpc_tracer_set_enabled(const char *name, int enabled);
 
 /** Check whether a metadata key is legal (will be accepted by core) */
-GRPC_API int grpc_header_key_is_legal(const char *key, size_t length);
+GRPCAPI int grpc_header_key_is_legal(const char *key, size_t length);
 
 /** Check whether a non-binary metadata value is legal (will be accepted by
     core) */
-GRPC_API int grpc_header_nonbin_value_is_legal(const char *value,
-                                               size_t length);
+GRPCAPI int grpc_header_nonbin_value_is_legal(const char *value, size_t length);
 
 /** Check whether a metadata key corresponds to a binary value */
-GRPC_API int grpc_is_binary_header(const char *key, size_t length);
+GRPCAPI int grpc_is_binary_header(const char *key, size_t length);
 
 #ifdef __cplusplus
 }