grpc 1.7.3 → 1.8.0

data/src/core/lib/security/credentials/credentials.h

@@ -29,6 +29,10 @@
 #include "src/core/lib/iomgr/polling_entity.h"
 #include "src/core/lib/security/transport/security_connector.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 struct grpc_http_response;
 
 /* --- Constants. --- */
@@ -73,13 +77,13 @@ typedef enum {
 /* --- Google utils --- */
 
 /* It is the caller's responsibility to gpr_free the result if not NULL. */
-char *grpc_get_well_known_google_credentials_file_path(void);
+char* grpc_get_well_known_google_credentials_file_path(void);
 
 /* Implementation function for the different platforms. */
-char *grpc_get_well_known_google_credentials_file_path_impl(void);
+char* grpc_get_well_known_google_credentials_file_path_impl(void);
 
 /* Override for testing only. Not thread-safe */
-typedef char *(*grpc_well_known_credentials_path_getter)(void);
+typedef char* (*grpc_well_known_credentials_path_getter)(void);
 void grpc_override_well_known_credentials_path_getter(
     grpc_well_known_credentials_path_getter getter);
 
@@ -88,168 +92,172 @@ void grpc_override_well_known_credentials_path_getter(
 #define GRPC_ARG_CHANNEL_CREDENTIALS "grpc.channel_credentials"
 
 typedef struct {
-  void (*destruct)(grpc_exec_ctx *exec_ctx, grpc_channel_credentials *c);
+  void (*destruct)(grpc_exec_ctx* exec_ctx, grpc_channel_credentials* c);
 
   grpc_security_status (*create_security_connector)(
-      grpc_exec_ctx *exec_ctx, grpc_channel_credentials *c,
-      grpc_call_credentials *call_creds, const char *target,
-      const grpc_channel_args *args, grpc_channel_security_connector **sc,
-      grpc_channel_args **new_args);
+      grpc_exec_ctx* exec_ctx, grpc_channel_credentials* c,
+      grpc_call_credentials* call_creds, const char* target,
+      const grpc_channel_args* args, grpc_channel_security_connector** sc,
+      grpc_channel_args** new_args);
 
-  grpc_channel_credentials *(*duplicate_without_call_credentials)(
-      grpc_channel_credentials *c);
+  grpc_channel_credentials* (*duplicate_without_call_credentials)(
+      grpc_channel_credentials* c);
 } grpc_channel_credentials_vtable;
 
 struct grpc_channel_credentials {
-  const grpc_channel_credentials_vtable *vtable;
-  const char *type;
+  const grpc_channel_credentials_vtable* vtable;
+  const char* type;
   gpr_refcount refcount;
 };
 
-grpc_channel_credentials *grpc_channel_credentials_ref(
-    grpc_channel_credentials *creds);
-void grpc_channel_credentials_unref(grpc_exec_ctx *exec_ctx,
-                                    grpc_channel_credentials *creds);
+grpc_channel_credentials* grpc_channel_credentials_ref(
+    grpc_channel_credentials* creds);
+void grpc_channel_credentials_unref(grpc_exec_ctx* exec_ctx,
+                                    grpc_channel_credentials* creds);
 
 /* Creates a security connector for the channel. May also create new channel
    args for the channel to be used in place of the passed in const args if
    returned non NULL. In that case the caller is responsible for destroying
    new_args after channel creation. */
 grpc_security_status grpc_channel_credentials_create_security_connector(
-    grpc_exec_ctx *exec_ctx, grpc_channel_credentials *creds,
-    const char *target, const grpc_channel_args *args,
-    grpc_channel_security_connector **sc, grpc_channel_args **new_args);
+    grpc_exec_ctx* exec_ctx, grpc_channel_credentials* creds,
+    const char* target, const grpc_channel_args* args,
+    grpc_channel_security_connector** sc, grpc_channel_args** new_args);
 
 /* Creates a version of the channel credentials without any attached call
    credentials. This can be used in order to open a channel to a non-trusted
    gRPC load balancer. */
-grpc_channel_credentials *
+grpc_channel_credentials*
 grpc_channel_credentials_duplicate_without_call_credentials(
-    grpc_channel_credentials *creds);
+    grpc_channel_credentials* creds);
 
 /* Util to encapsulate the channel credentials in a channel arg. */
-grpc_arg grpc_channel_credentials_to_arg(grpc_channel_credentials *credentials);
+grpc_arg grpc_channel_credentials_to_arg(grpc_channel_credentials* credentials);
 
 /* Util to get the channel credentials from a channel arg. */
-grpc_channel_credentials *grpc_channel_credentials_from_arg(
-    const grpc_arg *arg);
+grpc_channel_credentials* grpc_channel_credentials_from_arg(
+    const grpc_arg* arg);
 
 /* Util to find the channel credentials from channel args. */
-grpc_channel_credentials *grpc_channel_credentials_find_in_args(
-    const grpc_channel_args *args);
+grpc_channel_credentials* grpc_channel_credentials_find_in_args(
+    const grpc_channel_args* args);
 
 /* --- grpc_credentials_mdelem_array. --- */
 
 typedef struct {
-  grpc_mdelem *md;
+  grpc_mdelem* md;
   size_t size;
 } grpc_credentials_mdelem_array;
 
 /// Takes a new ref to \a md.
-void grpc_credentials_mdelem_array_add(grpc_credentials_mdelem_array *list,
+void grpc_credentials_mdelem_array_add(grpc_credentials_mdelem_array* list,
                                        grpc_mdelem md);
 
 /// Appends all elements from \a src to \a dst, taking a new ref to each one.
-void grpc_credentials_mdelem_array_append(grpc_credentials_mdelem_array *dst,
-                                          grpc_credentials_mdelem_array *src);
+void grpc_credentials_mdelem_array_append(grpc_credentials_mdelem_array* dst,
+                                          grpc_credentials_mdelem_array* src);
 
-void grpc_credentials_mdelem_array_destroy(grpc_exec_ctx *exec_ctx,
-                                           grpc_credentials_mdelem_array *list);
+void grpc_credentials_mdelem_array_destroy(grpc_exec_ctx* exec_ctx,
+                                           grpc_credentials_mdelem_array* list);
 
 /* --- grpc_call_credentials. --- */
 
 typedef struct {
-  void (*destruct)(grpc_exec_ctx *exec_ctx, grpc_call_credentials *c);
-  bool (*get_request_metadata)(grpc_exec_ctx *exec_ctx,
-                               grpc_call_credentials *c,
-                               grpc_polling_entity *pollent,
+  void (*destruct)(grpc_exec_ctx* exec_ctx, grpc_call_credentials* c);
+  bool (*get_request_metadata)(grpc_exec_ctx* exec_ctx,
+                               grpc_call_credentials* c,
+                               grpc_polling_entity* pollent,
                                grpc_auth_metadata_context context,
-                               grpc_credentials_mdelem_array *md_array,
-                               grpc_closure *on_request_metadata,
-                               grpc_error **error);
-  void (*cancel_get_request_metadata)(grpc_exec_ctx *exec_ctx,
-                                      grpc_call_credentials *c,
-                                      grpc_credentials_mdelem_array *md_array,
-                                      grpc_error *error);
+                               grpc_credentials_mdelem_array* md_array,
+                               grpc_closure* on_request_metadata,
+                               grpc_error** error);
+  void (*cancel_get_request_metadata)(grpc_exec_ctx* exec_ctx,
+                                      grpc_call_credentials* c,
+                                      grpc_credentials_mdelem_array* md_array,
+                                      grpc_error* error);
 } grpc_call_credentials_vtable;
 
 struct grpc_call_credentials {
-  const grpc_call_credentials_vtable *vtable;
-  const char *type;
+  const grpc_call_credentials_vtable* vtable;
+  const char* type;
   gpr_refcount refcount;
 };
 
-grpc_call_credentials *grpc_call_credentials_ref(grpc_call_credentials *creds);
-void grpc_call_credentials_unref(grpc_exec_ctx *exec_ctx,
-                                 grpc_call_credentials *creds);
+grpc_call_credentials* grpc_call_credentials_ref(grpc_call_credentials* creds);
+void grpc_call_credentials_unref(grpc_exec_ctx* exec_ctx,
+                                 grpc_call_credentials* creds);
 
 /// Returns true if completed synchronously, in which case \a error will
 /// be set to indicate the result.  Otherwise, \a on_request_metadata will
 /// be invoked asynchronously when complete.  \a md_array will be populated
 /// with the resulting metadata once complete.
 bool grpc_call_credentials_get_request_metadata(
-    grpc_exec_ctx *exec_ctx, grpc_call_credentials *creds,
-    grpc_polling_entity *pollent, grpc_auth_metadata_context context,
-    grpc_credentials_mdelem_array *md_array, grpc_closure *on_request_metadata,
-    grpc_error **error);
+    grpc_exec_ctx* exec_ctx, grpc_call_credentials* creds,
+    grpc_polling_entity* pollent, grpc_auth_metadata_context context,
+    grpc_credentials_mdelem_array* md_array, grpc_closure* on_request_metadata,
+    grpc_error** error);
 
 /// Cancels a pending asynchronous operation started by
 /// grpc_call_credentials_get_request_metadata() with the corresponding
 /// value of \a md_array.
 void grpc_call_credentials_cancel_get_request_metadata(
-    grpc_exec_ctx *exec_ctx, grpc_call_credentials *c,
-    grpc_credentials_mdelem_array *md_array, grpc_error *error);
+    grpc_exec_ctx* exec_ctx, grpc_call_credentials* c,
+    grpc_credentials_mdelem_array* md_array, grpc_error* error);
 
 /* Metadata-only credentials with the specified key and value where
    asynchronicity can be simulated for testing. */
-grpc_call_credentials *grpc_md_only_test_credentials_create(
-    grpc_exec_ctx *exec_ctx, const char *md_key, const char *md_value,
+grpc_call_credentials* grpc_md_only_test_credentials_create(
+    grpc_exec_ctx* exec_ctx, const char* md_key, const char* md_value,
     bool is_async);
 
 /* --- grpc_server_credentials. --- */
 
 typedef struct {
-  void (*destruct)(grpc_exec_ctx *exec_ctx, grpc_server_credentials *c);
+  void (*destruct)(grpc_exec_ctx* exec_ctx, grpc_server_credentials* c);
   grpc_security_status (*create_security_connector)(
-      grpc_exec_ctx *exec_ctx, grpc_server_credentials *c,
-      grpc_server_security_connector **sc);
+      grpc_exec_ctx* exec_ctx, grpc_server_credentials* c,
+      grpc_server_security_connector** sc);
 } grpc_server_credentials_vtable;
 
 struct grpc_server_credentials {
-  const grpc_server_credentials_vtable *vtable;
-  const char *type;
+  const grpc_server_credentials_vtable* vtable;
+  const char* type;
   gpr_refcount refcount;
   grpc_auth_metadata_processor processor;
 };
 
 grpc_security_status grpc_server_credentials_create_security_connector(
-    grpc_exec_ctx *exec_ctx, grpc_server_credentials *creds,
-    grpc_server_security_connector **sc);
+    grpc_exec_ctx* exec_ctx, grpc_server_credentials* creds,
+    grpc_server_security_connector** sc);
 
-grpc_server_credentials *grpc_server_credentials_ref(
-    grpc_server_credentials *creds);
+grpc_server_credentials* grpc_server_credentials_ref(
+    grpc_server_credentials* creds);
 
-void grpc_server_credentials_unref(grpc_exec_ctx *exec_ctx,
-                                   grpc_server_credentials *creds);
+void grpc_server_credentials_unref(grpc_exec_ctx* exec_ctx,
+                                   grpc_server_credentials* creds);
 
 #define GRPC_SERVER_CREDENTIALS_ARG "grpc.server_credentials"
 
-grpc_arg grpc_server_credentials_to_arg(grpc_server_credentials *c);
-grpc_server_credentials *grpc_server_credentials_from_arg(const grpc_arg *arg);
-grpc_server_credentials *grpc_find_server_credentials_in_args(
-    const grpc_channel_args *args);
+grpc_arg grpc_server_credentials_to_arg(grpc_server_credentials* c);
+grpc_server_credentials* grpc_server_credentials_from_arg(const grpc_arg* arg);
+grpc_server_credentials* grpc_find_server_credentials_in_args(
+    const grpc_channel_args* args);
 
 /* -- Credentials Metadata Request. -- */
 
 typedef struct {
-  grpc_call_credentials *creds;
+  grpc_call_credentials* creds;
   grpc_http_response response;
 } grpc_credentials_metadata_request;
 
-grpc_credentials_metadata_request *grpc_credentials_metadata_request_create(
-    grpc_call_credentials *creds);
+grpc_credentials_metadata_request* grpc_credentials_metadata_request_create(
+    grpc_call_credentials* creds);
 
 void grpc_credentials_metadata_request_destroy(
-    grpc_exec_ctx *exec_ctx, grpc_credentials_metadata_request *r);
+    grpc_exec_ctx* exec_ctx, grpc_credentials_metadata_request* r);
+
+#ifdef __cplusplus
+}
+#endif
 
 #endif /* GRPC_CORE_LIB_SECURITY_CREDENTIALS_CREDENTIALS_H */

data/src/core/lib/security/credentials/{credentials_metadata.c → credentials_metadata.cc}

@@ -24,7 +24,7 @@
 
 #include "src/core/lib/slice/slice_internal.h"
 
-static void mdelem_list_ensure_capacity(grpc_credentials_mdelem_array *list,
+static void mdelem_list_ensure_capacity(grpc_credentials_mdelem_array* list,
                                         size_t additional_space_needed) {
   size_t target_size = list->size + additional_space_needed;
   // Find the next power of two greater than the target size (i.e.,
@@ -33,17 +33,18 @@ static void mdelem_list_ensure_capacity(grpc_credentials_mdelem_array *list,
   while (new_size < target_size) {
     new_size *= 2;
   }
-  list->md = gpr_realloc(list->md, sizeof(grpc_mdelem) * new_size);
+  list->md =
+      (grpc_mdelem*)gpr_realloc(list->md, sizeof(grpc_mdelem) * new_size);
 }
 
-void grpc_credentials_mdelem_array_add(grpc_credentials_mdelem_array *list,
+void grpc_credentials_mdelem_array_add(grpc_credentials_mdelem_array* list,
                                        grpc_mdelem md) {
   mdelem_list_ensure_capacity(list, 1);
   list->md[list->size++] = GRPC_MDELEM_REF(md);
 }
 
-void grpc_credentials_mdelem_array_append(grpc_credentials_mdelem_array *dst,
-                                          grpc_credentials_mdelem_array *src) {
+void grpc_credentials_mdelem_array_append(grpc_credentials_mdelem_array* dst,
+                                          grpc_credentials_mdelem_array* src) {
   mdelem_list_ensure_capacity(dst, src->size);
   for (size_t i = 0; i < src->size; ++i) {
     dst->md[dst->size++] = GRPC_MDELEM_REF(src->md[i]);
@@ -51,7 +52,7 @@ void grpc_credentials_mdelem_array_append(grpc_credentials_mdelem_array *dst,
 }
 
 void grpc_credentials_mdelem_array_destroy(
-    grpc_exec_ctx *exec_ctx, grpc_credentials_mdelem_array *list) {
+    grpc_exec_ctx* exec_ctx, grpc_credentials_mdelem_array* list) {
   for (size_t i = 0; i < list->size; ++i) {
     GRPC_MDELEM_UNREF(exec_ctx, list->md[i]);
   }

data/src/core/lib/security/credentials/fake/{fake_credentials.c → fake_credentials.cc}

@@ -34,42 +34,45 @@
   "grpc.fake_security.expected_targets"
 
 static grpc_security_status fake_transport_security_create_security_connector(
-    grpc_exec_ctx *exec_ctx, grpc_channel_credentials *c,
-    grpc_call_credentials *call_creds, const char *target,
-    const grpc_channel_args *args, grpc_channel_security_connector **sc,
-    grpc_channel_args **new_args) {
-  *sc = grpc_fake_channel_security_connector_create(call_creds, target, args);
+    grpc_exec_ctx* exec_ctx, grpc_channel_credentials* c,
+    grpc_call_credentials* call_creds, const char* target,
+    const grpc_channel_args* args, grpc_channel_security_connector** sc,
+    grpc_channel_args** new_args) {
+  *sc =
+      grpc_fake_channel_security_connector_create(c, call_creds, target, args);
   return GRPC_SECURITY_OK;
 }
 
 static grpc_security_status
 fake_transport_security_server_create_security_connector(
-    grpc_exec_ctx *exec_ctx, grpc_server_credentials *c,
-    grpc_server_security_connector **sc) {
-  *sc = grpc_fake_server_security_connector_create();
+    grpc_exec_ctx* exec_ctx, grpc_server_credentials* c,
+    grpc_server_security_connector** sc) {
+  *sc = grpc_fake_server_security_connector_create(c);
   return GRPC_SECURITY_OK;
 }
 
 static grpc_channel_credentials_vtable
     fake_transport_security_credentials_vtable = {
-        NULL, fake_transport_security_create_security_connector, NULL};
+        nullptr, fake_transport_security_create_security_connector, nullptr};
 
 static grpc_server_credentials_vtable
     fake_transport_security_server_credentials_vtable = {
-        NULL, fake_transport_security_server_create_security_connector};
+        nullptr, fake_transport_security_server_create_security_connector};
 
-grpc_channel_credentials *grpc_fake_transport_security_credentials_create(
+grpc_channel_credentials* grpc_fake_transport_security_credentials_create(
     void) {
-  grpc_channel_credentials *c = gpr_zalloc(sizeof(grpc_channel_credentials));
+  grpc_channel_credentials* c =
+      (grpc_channel_credentials*)gpr_zalloc(sizeof(grpc_channel_credentials));
   c->type = GRPC_CHANNEL_CREDENTIALS_TYPE_FAKE_TRANSPORT_SECURITY;
   c->vtable = &fake_transport_security_credentials_vtable;
   gpr_ref_init(&c->refcount, 1);
   return c;
 }
 
-grpc_server_credentials *grpc_fake_transport_security_server_credentials_create(
+grpc_server_credentials* grpc_fake_transport_security_server_credentials_create(
     void) {
-  grpc_server_credentials *c = gpr_malloc(sizeof(grpc_server_credentials));
+  grpc_server_credentials* c =
+      (grpc_server_credentials*)gpr_malloc(sizeof(grpc_server_credentials));
   memset(c, 0, sizeof(grpc_server_credentials));
   c->type = GRPC_CHANNEL_CREDENTIALS_TYPE_FAKE_TRANSPORT_SECURITY;
   gpr_ref_init(&c->refcount, 1);
@@ -77,36 +80,36 @@ grpc_server_credentials *grpc_fake_transport_security_server_credentials_create(
   return c;
 }
 
-grpc_arg grpc_fake_transport_expected_targets_arg(char *expected_targets) {
-  return grpc_channel_arg_string_create(GRPC_ARG_FAKE_SECURITY_EXPECTED_TARGETS,
-                                        expected_targets);
+grpc_arg grpc_fake_transport_expected_targets_arg(char* expected_targets) {
+  return grpc_channel_arg_string_create(
+      (char*)GRPC_ARG_FAKE_SECURITY_EXPECTED_TARGETS, expected_targets);
 }
 
-const char *grpc_fake_transport_get_expected_targets(
-    const grpc_channel_args *args) {
-  const grpc_arg *expected_target_arg =
+const char* grpc_fake_transport_get_expected_targets(
+    const grpc_channel_args* args) {
+  const grpc_arg* expected_target_arg =
       grpc_channel_args_find(args, GRPC_ARG_FAKE_SECURITY_EXPECTED_TARGETS);
-  if (expected_target_arg != NULL &&
+  if (expected_target_arg != nullptr &&
       expected_target_arg->type == GRPC_ARG_STRING) {
     return expected_target_arg->value.string;
   }
-  return NULL;
+  return nullptr;
 }
 
 /* -- Metadata-only test credentials. -- */
 
-static void md_only_test_destruct(grpc_exec_ctx *exec_ctx,
-                                  grpc_call_credentials *creds) {
-  grpc_md_only_test_credentials *c = (grpc_md_only_test_credentials *)creds;
+static void md_only_test_destruct(grpc_exec_ctx* exec_ctx,
+                                  grpc_call_credentials* creds) {
+  grpc_md_only_test_credentials* c = (grpc_md_only_test_credentials*)creds;
   GRPC_MDELEM_UNREF(exec_ctx, c->md);
 }
 
 static bool md_only_test_get_request_metadata(
-    grpc_exec_ctx *exec_ctx, grpc_call_credentials *creds,
-    grpc_polling_entity *pollent, grpc_auth_metadata_context context,
-    grpc_credentials_mdelem_array *md_array, grpc_closure *on_request_metadata,
-    grpc_error **error) {
-  grpc_md_only_test_credentials *c = (grpc_md_only_test_credentials *)creds;
+    grpc_exec_ctx* exec_ctx, grpc_call_credentials* creds,
+    grpc_polling_entity* pollent, grpc_auth_metadata_context context,
+    grpc_credentials_mdelem_array* md_array, grpc_closure* on_request_metadata,
+    grpc_error** error) {
+  grpc_md_only_test_credentials* c = (grpc_md_only_test_credentials*)creds;
   grpc_credentials_mdelem_array_add(md_array, c->md);
   if (c->is_async) {
     GRPC_CLOSURE_SCHED(exec_ctx, on_request_metadata, GRPC_ERROR_NONE);
@@ -116,8 +119,8 @@ static bool md_only_test_get_request_metadata(
 }
 
 static void md_only_test_cancel_get_request_metadata(
-    grpc_exec_ctx *exec_ctx, grpc_call_credentials *c,
-    grpc_credentials_mdelem_array *md_array, grpc_error *error) {
+    grpc_exec_ctx* exec_ctx, grpc_call_credentials* c,
+    grpc_credentials_mdelem_array* md_array, grpc_error* error) {
   GRPC_ERROR_UNREF(error);
 }
 
@@ -125,11 +128,11 @@ static grpc_call_credentials_vtable md_only_test_vtable = {
     md_only_test_destruct, md_only_test_get_request_metadata,
     md_only_test_cancel_get_request_metadata};
 
-grpc_call_credentials *grpc_md_only_test_credentials_create(
-    grpc_exec_ctx *exec_ctx, const char *md_key, const char *md_value,
+grpc_call_credentials* grpc_md_only_test_credentials_create(
+    grpc_exec_ctx* exec_ctx, const char* md_key, const char* md_value,
     bool is_async) {
-  grpc_md_only_test_credentials *c =
-      gpr_zalloc(sizeof(grpc_md_only_test_credentials));
+  grpc_md_only_test_credentials* c = (grpc_md_only_test_credentials*)gpr_zalloc(
+      sizeof(grpc_md_only_test_credentials));
   c->base.type = GRPC_CALL_CREDENTIALS_TYPE_OAUTH2;
   c->base.vtable = &md_only_test_vtable;
   gpr_ref_init(&c->base.refcount, 1);

data/src/core/lib/security/credentials/fake/fake_credentials.h

@@ -21,13 +21,17 @@
 
 #include "src/core/lib/security/credentials/credentials.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /* -- Fake transport security credentials. -- */
 
 /* Creates a fake transport security credentials object for testing. */
-grpc_channel_credentials *grpc_fake_transport_security_credentials_create(void);
+grpc_channel_credentials* grpc_fake_transport_security_credentials_create(void);
 
 /* Creates a fake server transport security credentials object for testing. */
-grpc_server_credentials *grpc_fake_transport_security_server_credentials_create(
+grpc_server_credentials* grpc_fake_transport_security_server_credentials_create(
     void);
 
 /* Used to verify the target names given to the fake transport security
@@ -42,11 +46,11 @@ grpc_server_credentials *grpc_fake_transport_security_server_credentials_create(
  * That is to say, LB channels have a heading list of LB targets separated from
  * the list of backend targets by a semicolon. For non-LB channels, only the
  * latter is present. */
-grpc_arg grpc_fake_transport_expected_targets_arg(char *expected_targets);
+grpc_arg grpc_fake_transport_expected_targets_arg(char* expected_targets);
 
 /* Return the value associated with the expected targets channel arg or NULL */
-const char *grpc_fake_transport_get_expected_targets(
-    const grpc_channel_args *args);
+const char* grpc_fake_transport_get_expected_targets(
+    const grpc_channel_args* args);
 
 /* --  Metadata-only Test credentials. -- */
 
@@ -56,4 +60,8 @@ typedef struct {
   bool is_async;
 } grpc_md_only_test_credentials;
 
+#ifdef __cplusplus
+}
+#endif
+
 #endif /* GRPC_CORE_LIB_SECURITY_CREDENTIALS_FAKE_FAKE_CREDENTIALS_H */