grpc 1.7.3 → 1.8.0

data/src/core/lib/security/transport/security_handshaker.h

@@ -23,12 +23,20 @@
 #include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/security/transport/security_connector.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /// Creates a security handshaker using \a handshaker.
-grpc_handshaker *grpc_security_handshaker_create(
-    grpc_exec_ctx *exec_ctx, tsi_handshaker *handshaker,
-    grpc_security_connector *connector);
+grpc_handshaker* grpc_security_handshaker_create(
+    grpc_exec_ctx* exec_ctx, tsi_handshaker* handshaker,
+    grpc_security_connector* connector);
 
 /// Registers security handshaker factories.
 void grpc_security_register_handshaker_factories();
 
+#ifdef __cplusplus
+}
+#endif
+
 #endif /* GRPC_CORE_LIB_SECURITY_TRANSPORT_SECURITY_HANDSHAKER_H */

data/src/core/lib/security/transport/{server_auth_filter.c → server_auth_filter.cc}

@@ -33,38 +33,38 @@ typedef enum {
 } async_state;
 
 typedef struct call_data {
-  grpc_call_combiner *call_combiner;
-  grpc_call_stack *owning_call;
-  grpc_transport_stream_op_batch *recv_initial_metadata_batch;
-  grpc_closure *original_recv_initial_metadata_ready;
+  grpc_call_combiner* call_combiner;
+  grpc_call_stack* owning_call;
+  grpc_transport_stream_op_batch* recv_initial_metadata_batch;
+  grpc_closure* original_recv_initial_metadata_ready;
   grpc_closure recv_initial_metadata_ready;
   grpc_metadata_array md;
-  const grpc_metadata *consumed_md;
+  const grpc_metadata* consumed_md;
   size_t num_consumed_md;
-  grpc_auth_context *auth_context;
+  grpc_auth_context* auth_context;
   grpc_closure cancel_closure;
   gpr_atm state;  // async_state
 } call_data;
 
 typedef struct channel_data {
-  grpc_auth_context *auth_context;
-  grpc_server_credentials *creds;
+  grpc_auth_context* auth_context;
+  grpc_server_credentials* creds;
 } channel_data;
 
 static grpc_metadata_array metadata_batch_to_md_array(
-    const grpc_metadata_batch *batch) {
-  grpc_linked_mdelem *l;
+    const grpc_metadata_batch* batch) {
+  grpc_linked_mdelem* l;
   grpc_metadata_array result;
   grpc_metadata_array_init(&result);
-  for (l = batch->list.head; l != NULL; l = l->next) {
-    grpc_metadata *usr_md = NULL;
+  for (l = batch->list.head; l != nullptr; l = l->next) {
+    grpc_metadata* usr_md = nullptr;
     grpc_mdelem md = l->md;
     grpc_slice key = GRPC_MDKEY(md);
     grpc_slice value = GRPC_MDVALUE(md);
     if (result.count == result.capacity) {
       result.capacity = GPR_MAX(result.capacity + 8, result.capacity * 2);
-      result.metadata =
-          gpr_realloc(result.metadata, result.capacity * sizeof(grpc_metadata));
+      result.metadata = (grpc_metadata*)gpr_realloc(
+          result.metadata, result.capacity * sizeof(grpc_metadata));
     }
     usr_md = &result.metadata[result.count++];
     usr_md->key = grpc_slice_ref_internal(key);
@@ -73,14 +73,14 @@ static grpc_metadata_array metadata_batch_to_md_array(
   return result;
 }
 
-static grpc_filtered_mdelem remove_consumed_md(grpc_exec_ctx *exec_ctx,
-                                               void *user_data,
+static grpc_filtered_mdelem remove_consumed_md(grpc_exec_ctx* exec_ctx,
+                                               void* user_data,
                                                grpc_mdelem md) {
-  grpc_call_element *elem = user_data;
-  call_data *calld = elem->call_data;
+  grpc_call_element* elem = (grpc_call_element*)user_data;
+  call_data* calld = (call_data*)elem->call_data;
   size_t i;
   for (i = 0; i < calld->num_consumed_md; i++) {
-    const grpc_metadata *consumed_md = &calld->consumed_md[i];
+    const grpc_metadata* consumed_md = &calld->consumed_md[i];
     if (grpc_slice_eq(GRPC_MDKEY(md), consumed_md->key) &&
         grpc_slice_eq(GRPC_MDVALUE(md), consumed_md->value))
       return GRPC_FILTERED_REMOVE();
@@ -88,17 +88,17 @@ static grpc_filtered_mdelem remove_consumed_md(grpc_exec_ctx *exec_ctx,
   return GRPC_FILTERED_MDELEM(md);
 }
 
-static void on_md_processing_done_inner(grpc_exec_ctx *exec_ctx,
-                                        grpc_call_element *elem,
-                                        const grpc_metadata *consumed_md,
+static void on_md_processing_done_inner(grpc_exec_ctx* exec_ctx,
+                                        grpc_call_element* elem,
+                                        const grpc_metadata* consumed_md,
                                         size_t num_consumed_md,
-                                        const grpc_metadata *response_md,
+                                        const grpc_metadata* response_md,
                                         size_t num_response_md,
-                                        grpc_error *error) {
-  call_data *calld = elem->call_data;
-  grpc_transport_stream_op_batch *batch = calld->recv_initial_metadata_batch;
+                                        grpc_error* error) {
+  call_data* calld = (call_data*)elem->call_data;
+  grpc_transport_stream_op_batch* batch = calld->recv_initial_metadata_batch;
   /* TODO(jboeuf): Implement support for response_md. */
-  if (response_md != NULL && num_response_md > 0) {
+  if (response_md != nullptr && num_response_md > 0) {
     gpr_log(GPR_INFO,
             "response_md in auth metadata processing not supported for now. "
             "Ignoring...");
@@ -116,18 +116,18 @@ static void on_md_processing_done_inner(grpc_exec_ctx *exec_ctx,
 
 // Called from application code.
 static void on_md_processing_done(
-    void *user_data, const grpc_metadata *consumed_md, size_t num_consumed_md,
-    const grpc_metadata *response_md, size_t num_response_md,
-    grpc_status_code status, const char *error_details) {
-  grpc_call_element *elem = user_data;
-  call_data *calld = elem->call_data;
+    void* user_data, const grpc_metadata* consumed_md, size_t num_consumed_md,
+    const grpc_metadata* response_md, size_t num_response_md,
+    grpc_status_code status, const char* error_details) {
+  grpc_call_element* elem = (grpc_call_element*)user_data;
+  call_data* calld = (call_data*)elem->call_data;
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   // If the call was not cancelled while we were in flight, process the result.
   if (gpr_atm_full_cas(&calld->state, (gpr_atm)STATE_INIT,
                        (gpr_atm)STATE_DONE)) {
-    grpc_error *error = GRPC_ERROR_NONE;
+    grpc_error* error = GRPC_ERROR_NONE;
     if (status != GRPC_STATUS_OK) {
-      if (error_details == NULL) {
+      if (error_details == nullptr) {
         error_details = "Authentication metadata processing failed.";
       }
       error = grpc_error_set_int(
@@ -147,27 +147,27 @@ static void on_md_processing_done(
   grpc_exec_ctx_finish(&exec_ctx);
 }
 
-static void cancel_call(grpc_exec_ctx *exec_ctx, void *arg, grpc_error *error) {
-  grpc_call_element *elem = (grpc_call_element *)arg;
-  call_data *calld = elem->call_data;
+static void cancel_call(grpc_exec_ctx* exec_ctx, void* arg, grpc_error* error) {
+  grpc_call_element* elem = (grpc_call_element*)arg;
+  call_data* calld = (call_data*)elem->call_data;
   // If the result was not already processed, invoke the callback now.
   if (error != GRPC_ERROR_NONE &&
       gpr_atm_full_cas(&calld->state, (gpr_atm)STATE_INIT,
                        (gpr_atm)STATE_CANCELLED)) {
-    on_md_processing_done_inner(exec_ctx, elem, NULL, 0, NULL, 0,
+    on_md_processing_done_inner(exec_ctx, elem, nullptr, 0, nullptr, 0,
                                 GRPC_ERROR_REF(error));
   }
   GRPC_CALL_STACK_UNREF(exec_ctx, calld->owning_call, "cancel_call");
 }
 
-static void recv_initial_metadata_ready(grpc_exec_ctx *exec_ctx, void *arg,
-                                        grpc_error *error) {
-  grpc_call_element *elem = (grpc_call_element *)arg;
-  channel_data *chand = elem->channel_data;
-  call_data *calld = elem->call_data;
-  grpc_transport_stream_op_batch *batch = calld->recv_initial_metadata_batch;
+static void recv_initial_metadata_ready(grpc_exec_ctx* exec_ctx, void* arg,
+                                        grpc_error* error) {
+  grpc_call_element* elem = (grpc_call_element*)arg;
+  channel_data* chand = (channel_data*)elem->channel_data;
+  call_data* calld = (call_data*)elem->call_data;
+  grpc_transport_stream_op_batch* batch = calld->recv_initial_metadata_batch;
   if (error == GRPC_ERROR_NONE) {
-    if (chand->creds != NULL && chand->creds->processor.process != NULL) {
+    if (chand->creds != nullptr && chand->creds->processor.process != nullptr) {
       // We're calling out to the application, so we need to make sure
       // to drop the call combiner early if we get cancelled.
       GRPC_CALL_STACK_REF(calld->owning_call, "cancel_call");
@@ -189,9 +189,9 @@ static void recv_initial_metadata_ready(grpc_exec_ctx *exec_ctx, void *arg,
 }
 
 static void auth_start_transport_stream_op_batch(
-    grpc_exec_ctx *exec_ctx, grpc_call_element *elem,
-    grpc_transport_stream_op_batch *batch) {
-  call_data *calld = elem->call_data;
+    grpc_exec_ctx* exec_ctx, grpc_call_element* elem,
+    grpc_transport_stream_op_batch* batch) {
+  call_data* calld = (call_data*)elem->call_data;
   if (batch->recv_initial_metadata) {
     // Inject our callback.
     calld->recv_initial_metadata_batch = batch;
@@ -204,11 +204,11 @@ static void auth_start_transport_stream_op_batch(
 }
 
 /* Constructor for call_data */
-static grpc_error *init_call_elem(grpc_exec_ctx *exec_ctx,
-                                  grpc_call_element *elem,
-                                  const grpc_call_element_args *args) {
-  call_data *calld = elem->call_data;
-  channel_data *chand = elem->channel_data;
+static grpc_error* init_call_elem(grpc_exec_ctx* exec_ctx,
+                                  grpc_call_element* elem,
+                                  const grpc_call_element_args* args) {
+  call_data* calld = (call_data*)elem->call_data;
+  channel_data* chand = (channel_data*)elem->channel_data;
   calld->call_combiner = args->call_combiner;
   calld->owning_call = args->call_stack;
   GRPC_CLOSURE_INIT(&calld->recv_initial_metadata_ready,
@@ -216,11 +216,11 @@ static grpc_error *init_call_elem(grpc_exec_ctx *exec_ctx,
                     grpc_schedule_on_exec_ctx);
   // Create server security context.  Set its auth context from channel
   // data and save it in the call context.
-  grpc_server_security_context *server_ctx =
+  grpc_server_security_context* server_ctx =
       grpc_server_security_context_create();
   server_ctx->auth_context = grpc_auth_context_create(chand->auth_context);
   calld->auth_context = server_ctx->auth_context;
-  if (args->context[GRPC_CONTEXT_SECURITY].value != NULL) {
+  if (args->context[GRPC_CONTEXT_SECURITY].value != nullptr) {
     args->context[GRPC_CONTEXT_SECURITY].destroy(
         args->context[GRPC_CONTEXT_SECURITY].value);
   }
@@ -231,31 +231,31 @@ static grpc_error *init_call_elem(grpc_exec_ctx *exec_ctx,
 }
 
 /* Destructor for call_data */
-static void destroy_call_elem(grpc_exec_ctx *exec_ctx, grpc_call_element *elem,
-                              const grpc_call_final_info *final_info,
-                              grpc_closure *ignored) {}
+static void destroy_call_elem(grpc_exec_ctx* exec_ctx, grpc_call_element* elem,
+                              const grpc_call_final_info* final_info,
+                              grpc_closure* ignored) {}
 
 /* Constructor for channel_data */
-static grpc_error *init_channel_elem(grpc_exec_ctx *exec_ctx,
-                                     grpc_channel_element *elem,
-                                     grpc_channel_element_args *args) {
+static grpc_error* init_channel_elem(grpc_exec_ctx* exec_ctx,
+                                     grpc_channel_element* elem,
+                                     grpc_channel_element_args* args) {
   GPR_ASSERT(!args->is_last);
-  channel_data *chand = elem->channel_data;
-  grpc_auth_context *auth_context =
+  channel_data* chand = (channel_data*)elem->channel_data;
+  grpc_auth_context* auth_context =
       grpc_find_auth_context_in_args(args->channel_args);
-  GPR_ASSERT(auth_context != NULL);
+  GPR_ASSERT(auth_context != nullptr);
   chand->auth_context =
       GRPC_AUTH_CONTEXT_REF(auth_context, "server_auth_filter");
-  grpc_server_credentials *creds =
+  grpc_server_credentials* creds =
       grpc_find_server_credentials_in_args(args->channel_args);
   chand->creds = grpc_server_credentials_ref(creds);
   return GRPC_ERROR_NONE;
 }
 
 /* Destructor for channel data */
-static void destroy_channel_elem(grpc_exec_ctx *exec_ctx,
-                                 grpc_channel_element *elem) {
-  channel_data *chand = elem->channel_data;
+static void destroy_channel_elem(grpc_exec_ctx* exec_ctx,
+                                 grpc_channel_element* elem) {
+  channel_data* chand = (channel_data*)elem->channel_data;
   GRPC_AUTH_CONTEXT_UNREF(chand->auth_context, "server_auth_filter");
   grpc_server_credentials_unref(exec_ctx, chand->creds);
 }

data/src/core/lib/security/transport/{tsi_error.c → tsi_error.cc}

@@ -18,7 +18,7 @@
 
 #include "src/core/lib/security/transport/tsi_error.h"
 
-grpc_error *grpc_set_tsi_error_result(grpc_error *error, tsi_result result) {
+grpc_error* grpc_set_tsi_error_result(grpc_error* error, tsi_result result) {
   return grpc_error_set_int(
       grpc_error_set_str(
           error, GRPC_ERROR_STR_TSI_ERROR,

data/src/core/lib/security/transport/tsi_error.h

@@ -22,6 +22,14 @@
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/tsi/transport_security_interface.h"
 
-grpc_error *grpc_set_tsi_error_result(grpc_error *error, tsi_result result);
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+grpc_error* grpc_set_tsi_error_result(grpc_error* error, tsi_result result);
+
+#ifdef __cplusplus
+}
+#endif
 
 #endif /* GRPC_CORE_LIB_SECURITY_TRANSPORT_TSI_ERROR_H */

data/src/core/lib/security/util/{json_util.c → json_util.cc}

@@ -23,24 +23,24 @@
 #include <grpc/support/log.h>
 #include <grpc/support/string_util.h>
 
-const char *grpc_json_get_string_property(const grpc_json *json,
-                                          const char *prop_name) {
-  grpc_json *child;
-  for (child = json->child; child != NULL; child = child->next) {
+const char* grpc_json_get_string_property(const grpc_json* json,
+                                          const char* prop_name) {
+  grpc_json* child;
+  for (child = json->child; child != nullptr; child = child->next) {
     if (strcmp(child->key, prop_name) == 0) break;
   }
-  if (child == NULL || child->type != GRPC_JSON_STRING) {
+  if (child == nullptr || child->type != GRPC_JSON_STRING) {
     gpr_log(GPR_ERROR, "Invalid or missing %s property.", prop_name);
-    return NULL;
+    return nullptr;
   }
   return child->value;
 }
 
-bool grpc_copy_json_string_property(const grpc_json *json,
-                                    const char *prop_name,
-                                    char **copied_value) {
-  const char *prop_value = grpc_json_get_string_property(json, prop_name);
-  if (prop_value == NULL) return false;
+bool grpc_copy_json_string_property(const grpc_json* json,
+                                    const char* prop_name,
+                                    char** copied_value) {
+  const char* prop_value = grpc_json_get_string_property(json, prop_name);
+  if (prop_value == nullptr) return false;
   *copied_value = gpr_strdup(prop_value);
   return true;
 }

data/src/core/lib/security/util/json_util.h

@@ -28,13 +28,21 @@
 #define GRPC_AUTH_JSON_TYPE_SERVICE_ACCOUNT "service_account"
 #define GRPC_AUTH_JSON_TYPE_AUTHORIZED_USER "authorized_user"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 // Gets a child property from a json node.
-const char *grpc_json_get_string_property(const grpc_json *json,
-                                          const char *prop_name);
+const char* grpc_json_get_string_property(const grpc_json* json,
+                                          const char* prop_name);
 
 // Copies the value of the json child property specified by prop_name.
 // Returns false if the property was not found.
-bool grpc_copy_json_string_property(const grpc_json *json,
-                                    const char *prop_name, char **copied_value);
+bool grpc_copy_json_string_property(const grpc_json* json,
+                                    const char* prop_name, char** copied_value);
+
+#ifdef __cplusplus
+}
+#endif
 
 #endif /* GRPC_CORE_LIB_SECURITY_UTIL_JSON_UTIL_H */

data/src/core/lib/slice/{b64.c → b64.cc}

@@ -54,11 +54,11 @@ static const char base64_url_safe_chars[] =
 
 /* --- base64 functions. --- */
 
-char *grpc_base64_encode(const void *vdata, size_t data_size, int url_safe,
+char* grpc_base64_encode(const void* vdata, size_t data_size, int url_safe,
                          int multiline) {
   size_t result_projected_size =
       grpc_base64_estimate_encoded_size(data_size, url_safe, multiline);
-  char *result = (char *)gpr_malloc(result_projected_size);
+  char* result = (char*)gpr_malloc(result_projected_size);
   grpc_base64_encode_core(result, vdata, data_size, url_safe, multiline);
   return result;
 }
@@ -73,15 +73,15 @@ size_t grpc_base64_estimate_encoded_size(size_t data_size, int url_safe,
   return result_projected_size;
 }
 
-void grpc_base64_encode_core(char *result, const void *vdata, size_t data_size,
+void grpc_base64_encode_core(char* result, const void* vdata, size_t data_size,
                              int url_safe, int multiline) {
-  const unsigned char *data = (const unsigned char *)vdata;
-  const char *base64_chars =
+  const unsigned char* data = (const unsigned char*)vdata;
+  const char* base64_chars =
       url_safe ? base64_url_safe_chars : base64_url_unsafe_chars;
   const size_t result_projected_size =
       grpc_base64_estimate_encoded_size(data_size, url_safe, multiline);
 
-  char *current = result;
+  char* current = result;
   size_t num_blocks = 0;
   size_t i = 0;
 
@@ -122,27 +122,27 @@ void grpc_base64_encode_core(char *result, const void *vdata, size_t data_size,
   result[current - result] = '\0';
 }
 
-grpc_slice grpc_base64_decode(grpc_exec_ctx *exec_ctx, const char *b64,
+grpc_slice grpc_base64_decode(grpc_exec_ctx* exec_ctx, const char* b64,
                               int url_safe) {
   return grpc_base64_decode_with_len(exec_ctx, b64, strlen(b64), url_safe);
 }
 
-static void decode_one_char(const unsigned char *codes, unsigned char *result,
-                            size_t *result_offset) {
+static void decode_one_char(const unsigned char* codes, unsigned char* result,
+                            size_t* result_offset) {
   uint32_t packed = ((uint32_t)codes[0] << 2) | ((uint32_t)codes[1] >> 4);
   result[(*result_offset)++] = (unsigned char)packed;
 }
 
-static void decode_two_chars(const unsigned char *codes, unsigned char *result,
-                             size_t *result_offset) {
+static void decode_two_chars(const unsigned char* codes, unsigned char* result,
+                             size_t* result_offset) {
   uint32_t packed = ((uint32_t)codes[0] << 10) | ((uint32_t)codes[1] << 4) |
                     ((uint32_t)codes[2] >> 2);
   result[(*result_offset)++] = (unsigned char)(packed >> 8);
   result[(*result_offset)++] = (unsigned char)(packed);
 }
 
-static int decode_group(const unsigned char *codes, size_t num_codes,
-                        unsigned char *result, size_t *result_offset) {
+static int decode_group(const unsigned char* codes, size_t num_codes,
+                        unsigned char* result, size_t* result_offset) {
   GPR_ASSERT(num_codes <= 4);
 
   /* Short end groups that may not have padding. */
@@ -185,10 +185,10 @@ static int decode_group(const unsigned char *codes, size_t num_codes,
   return 1;
 }
 
-grpc_slice grpc_base64_decode_with_len(grpc_exec_ctx *exec_ctx, const char *b64,
+grpc_slice grpc_base64_decode_with_len(grpc_exec_ctx* exec_ctx, const char* b64,
                                        size_t b64_len, int url_safe) {
   grpc_slice result = GRPC_SLICE_MALLOC(b64_len);
-  unsigned char *current = GRPC_SLICE_START_PTR(result);
+  unsigned char* current = GRPC_SLICE_START_PTR(result);
   size_t result_size = 0;
   unsigned char codes[4];
   size_t num_codes = 0;

data/src/core/lib/slice/b64.h

@@ -21,10 +21,14 @@
 
 #include <grpc/slice.h>
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /* Encodes data using base64. It is the caller's responsability to free
    the returned char * using gpr_free. Returns NULL on NULL input.
    TODO(makdharma) : change the flags to bool from int */
-char *grpc_base64_encode(const void *data, size_t data_size, int url_safe,
+char* grpc_base64_encode(const void* data, size_t data_size, int url_safe,
                          int multiline);
 
 /* estimate the upper bound on size of base64 encoded data. The actual size
@@ -35,16 +39,20 @@ size_t grpc_base64_estimate_encoded_size(size_t data_size, int url_safe,
 /* Encodes data using base64 and write it to memory pointed to by result. It is
  * the caller's responsiblity to allocate enough memory in |result| to fit the
  * encoded data. */
-void grpc_base64_encode_core(char *result, const void *vdata, size_t data_size,
+void grpc_base64_encode_core(char* result, const void* vdata, size_t data_size,
                              int url_safe, int multiline);
 
 /* Decodes data according to the base64 specification. Returns an empty
    slice in case of failure. */
-grpc_slice grpc_base64_decode(grpc_exec_ctx *exec_ctx, const char *b64,
+grpc_slice grpc_base64_decode(grpc_exec_ctx* exec_ctx, const char* b64,
                               int url_safe);
 
 /* Same as above except that the length is provided by the caller. */
-grpc_slice grpc_base64_decode_with_len(grpc_exec_ctx *exec_ctx, const char *b64,
+grpc_slice grpc_base64_decode_with_len(grpc_exec_ctx* exec_ctx, const char* b64,
                                        size_t b64_len, int url_safe);
 
+#ifdef __cplusplus
+}
+#endif
+
 #endif /* GRPC_CORE_LIB_SLICE_B64_H */