grpc 1.7.3 → 1.8.0

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

@@ -25,13 +25,13 @@
 #include "src/core/lib/support/env.h"
 #include "src/core/lib/support/string.h"
 
-char *grpc_get_well_known_google_credentials_file_path_impl(void) {
-  char *result = NULL;
-  char *base = gpr_getenv(GRPC_GOOGLE_CREDENTIALS_PATH_ENV_VAR);
-  if (base == NULL) {
+char* grpc_get_well_known_google_credentials_file_path_impl(void) {
+  char* result = nullptr;
+  char* base = gpr_getenv(GRPC_GOOGLE_CREDENTIALS_PATH_ENV_VAR);
+  if (base == nullptr) {
     gpr_log(GPR_ERROR, "Could not get " GRPC_GOOGLE_CREDENTIALS_ENV_VAR
                        " environment variable.");
-    return NULL;
+    return nullptr;
   }
   gpr_asprintf(&result, "%s/%s", base, GRPC_GOOGLE_CREDENTIALS_PATH_SUFFIX);
   gpr_free(base);

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

@@ -28,6 +28,7 @@
 #include "src/core/lib/http/parser.h"
 #include "src/core/lib/iomgr/load_file.h"
 #include "src/core/lib/iomgr/polling_entity.h"
+#include "src/core/lib/security/credentials/google_default/google_default_credentials.h"
 #include "src/core/lib/security/credentials/jwt/jwt_credentials.h"
 #include "src/core/lib/security/credentials/oauth2/oauth2_credentials.h"
 #include "src/core/lib/slice/slice_internal.h"
@@ -42,10 +43,10 @@
 
 /* -- Default credentials. -- */
 
-static grpc_channel_credentials *default_credentials = NULL;
+static grpc_channel_credentials* default_credentials = nullptr;
 static int compute_engine_detection_done = 0;
 static gpr_mu g_state_mu;
-static gpr_mu *g_polling_mu;
+static gpr_mu* g_polling_mu;
 static gpr_once g_once = GPR_ONCE_INIT;
 
 static void init_default_credentials(void) { gpr_mu_init(&g_state_mu); }
@@ -57,17 +58,17 @@ typedef struct {
   grpc_http_response response;
 } compute_engine_detector;
 
-static void on_compute_engine_detection_http_response(grpc_exec_ctx *exec_ctx,
-                                                      void *user_data,
-                                                      grpc_error *error) {
-  compute_engine_detector *detector = (compute_engine_detector *)user_data;
+static void on_compute_engine_detection_http_response(grpc_exec_ctx* exec_ctx,
+                                                      void* user_data,
+                                                      grpc_error* error) {
+  compute_engine_detector* detector = (compute_engine_detector*)user_data;
   if (error == GRPC_ERROR_NONE && detector->response.status == 200 &&
       detector->response.hdr_count > 0) {
     /* Internet providers can return a generic response to all requests, so
        it is necessary to check that metadata header is present also. */
     size_t i;
     for (i = 0; i < detector->response.hdr_count; i++) {
-      grpc_http_header *header = &detector->response.hdrs[i];
+      grpc_http_header* header = &detector->response.hdrs[i];
       if (strcmp(header->key, "Metadata-Flavor") == 0 &&
           strcmp(header->value, "Google") == 0) {
         detector->success = 1;
@@ -79,16 +80,16 @@ static void on_compute_engine_detection_http_response(grpc_exec_ctx *exec_ctx,
   detector->is_done = 1;
   GRPC_LOG_IF_ERROR(
       "Pollset kick",
-      grpc_pollset_kick(exec_ctx,
-                        grpc_polling_entity_pollset(&detector->pollent), NULL));
+      grpc_pollset_kick(
+          exec_ctx, grpc_polling_entity_pollset(&detector->pollent), nullptr));
   gpr_mu_unlock(g_polling_mu);
 }
 
-static void destroy_pollset(grpc_exec_ctx *exec_ctx, void *p, grpc_error *e) {
-  grpc_pollset_destroy(exec_ctx, p);
+static void destroy_pollset(grpc_exec_ctx* exec_ctx, void* p, grpc_error* e) {
+  grpc_pollset_destroy(exec_ctx, (grpc_pollset*)p);
 }
 
-static int is_stack_running_on_compute_engine(grpc_exec_ctx *exec_ctx) {
+static int is_stack_running_on_compute_engine(grpc_exec_ctx* exec_ctx) {
   compute_engine_detector detector;
   grpc_httpcli_request request;
   grpc_httpcli_context context;
@@ -96,9 +97,9 @@ static int is_stack_running_on_compute_engine(grpc_exec_ctx *exec_ctx) {
 
   /* The http call is local. If it takes more than one sec, it is for sure not
      on compute engine. */
-  gpr_timespec max_detection_delay = gpr_time_from_seconds(1, GPR_TIMESPAN);
+  grpc_millis max_detection_delay = GPR_MS_PER_SEC;
 
-  grpc_pollset *pollset = gpr_zalloc(grpc_pollset_size());
+  grpc_pollset* pollset = (grpc_pollset*)gpr_zalloc(grpc_pollset_size());
   grpc_pollset_init(pollset, &g_polling_mu);
   detector.pollent = grpc_polling_entity_create_from_pollset(pollset);
   detector.is_done = 0;
@@ -106,16 +107,16 @@ static int is_stack_running_on_compute_engine(grpc_exec_ctx *exec_ctx) {
 
   memset(&detector.response, 0, sizeof(detector.response));
   memset(&request, 0, sizeof(grpc_httpcli_request));
-  request.host = GRPC_COMPUTE_ENGINE_DETECTION_HOST;
-  request.http.path = "/";
+  request.host = (char*)GRPC_COMPUTE_ENGINE_DETECTION_HOST;
+  request.http.path = (char*)"/";
 
   grpc_httpcli_context_init(&context);
 
-  grpc_resource_quota *resource_quota =
+  grpc_resource_quota* resource_quota =
       grpc_resource_quota_create("google_default_credentials");
   grpc_httpcli_get(
       exec_ctx, &context, &detector.pollent, resource_quota, &request,
-      gpr_time_add(gpr_now(GPR_CLOCK_REALTIME), max_detection_delay),
+      grpc_exec_ctx_now(exec_ctx) + max_detection_delay,
       GRPC_CLOSURE_CREATE(on_compute_engine_detection_http_response, &detector,
                           grpc_schedule_on_exec_ctx),
       &detector.response);
@@ -127,13 +128,12 @@ static int is_stack_running_on_compute_engine(grpc_exec_ctx *exec_ctx) {
      called once for the lifetime of the process by the default credentials. */
   gpr_mu_lock(g_polling_mu);
   while (!detector.is_done) {
-    grpc_pollset_worker *worker = NULL;
+    grpc_pollset_worker* worker = nullptr;
     if (!GRPC_LOG_IF_ERROR(
             "pollset_work",
             grpc_pollset_work(exec_ctx,
                               grpc_polling_entity_pollset(&detector.pollent),
-                              &worker, gpr_now(GPR_CLOCK_MONOTONIC),
-                              gpr_inf_future(GPR_CLOCK_MONOTONIC)))) {
+                              &worker, GRPC_MILLIS_INF_FUTURE))) {
       detector.is_done = 1;
       detector.success = 0;
     }
@@ -147,7 +147,7 @@ static int is_stack_running_on_compute_engine(grpc_exec_ctx *exec_ctx) {
   grpc_pollset_shutdown(exec_ctx,
                         grpc_polling_entity_pollset(&detector.pollent),
                         &destroy_closure);
-  g_polling_mu = NULL;
+  g_polling_mu = nullptr;
   grpc_exec_ctx_flush(exec_ctx);
 
   gpr_free(grpc_polling_entity_pollset(&detector.pollent));
@@ -157,15 +157,15 @@ static int is_stack_running_on_compute_engine(grpc_exec_ctx *exec_ctx) {
 }
 
 /* Takes ownership of creds_path if not NULL. */
-static grpc_error *create_default_creds_from_path(
-    grpc_exec_ctx *exec_ctx, char *creds_path, grpc_call_credentials **creds) {
-  grpc_json *json = NULL;
+static grpc_error* create_default_creds_from_path(
+    grpc_exec_ctx* exec_ctx, char* creds_path, grpc_call_credentials** creds) {
+  grpc_json* json = nullptr;
   grpc_auth_json_key key;
   grpc_auth_refresh_token token;
-  grpc_call_credentials *result = NULL;
+  grpc_call_credentials* result = nullptr;
   grpc_slice creds_data = grpc_empty_slice();
-  grpc_error *error = GRPC_ERROR_NONE;
-  if (creds_path == NULL) {
+  grpc_error* error = GRPC_ERROR_NONE;
+  if (creds_path == nullptr) {
     error = GRPC_ERROR_CREATE_FROM_STATIC_STRING("creds_path unset");
     goto end;
   }
@@ -174,8 +174,8 @@ static grpc_error *create_default_creds_from_path(
     goto end;
   }
   json = grpc_json_parse_string_with_len(
-      (char *)GRPC_SLICE_START_PTR(creds_data), GRPC_SLICE_LENGTH(creds_data));
-  if (json == NULL) {
+      (char*)GRPC_SLICE_START_PTR(creds_data), GRPC_SLICE_LENGTH(creds_data));
+  if (json == nullptr) {
     error = grpc_error_set_str(
         GRPC_ERROR_CREATE_FROM_STATIC_STRING("Failed to parse JSON"),
         GRPC_ERROR_STR_RAW_BYTES, grpc_slice_ref_internal(creds_data));
@@ -188,7 +188,7 @@ static grpc_error *create_default_creds_from_path(
     result =
         grpc_service_account_jwt_access_credentials_create_from_auth_json_key(
             exec_ctx, key, grpc_max_auth_token_lifetime());
-    if (result == NULL) {
+    if (result == nullptr) {
       error = GRPC_ERROR_CREATE_FROM_STATIC_STRING(
           "grpc_service_account_jwt_access_credentials_create_from_auth_json_"
           "key failed");
@@ -201,7 +201,7 @@ static grpc_error *create_default_creds_from_path(
   if (grpc_auth_refresh_token_is_valid(&token)) {
     result =
         grpc_refresh_token_credentials_create_from_auth_refresh_token(token);
-    if (result == NULL) {
+    if (result == nullptr) {
       error = GRPC_ERROR_CREATE_FROM_STATIC_STRING(
           "grpc_refresh_token_credentials_create_from_auth_refresh_token "
           "failed");
@@ -210,20 +210,20 @@ static grpc_error *create_default_creds_from_path(
   }
 
 end:
-  GPR_ASSERT((result == NULL) + (error == GRPC_ERROR_NONE) == 1);
-  if (creds_path != NULL) gpr_free(creds_path);
+  GPR_ASSERT((result == nullptr) + (error == GRPC_ERROR_NONE) == 1);
+  if (creds_path != nullptr) gpr_free(creds_path);
   grpc_slice_unref_internal(exec_ctx, creds_data);
-  if (json != NULL) grpc_json_destroy(json);
+  if (json != nullptr) grpc_json_destroy(json);
   *creds = result;
   return error;
 }
 
-grpc_channel_credentials *grpc_google_default_credentials_create(void) {
-  grpc_channel_credentials *result = NULL;
-  grpc_call_credentials *call_creds = NULL;
-  grpc_error *error = GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+grpc_channel_credentials* grpc_google_default_credentials_create(void) {
+  grpc_channel_credentials* result = nullptr;
+  grpc_call_credentials* call_creds = nullptr;
+  grpc_error* error = GRPC_ERROR_CREATE_FROM_STATIC_STRING(
       "Failed to create Google credentials");
-  grpc_error *err;
+  grpc_error* err;
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
 
   GRPC_API_TRACE("grpc_google_default_credentials_create(void)", 0, ());
@@ -232,7 +232,7 @@ grpc_channel_credentials *grpc_google_default_credentials_create(void) {
 
   gpr_mu_lock(&g_state_mu);
 
-  if (default_credentials != NULL) {
+  if (default_credentials != nullptr) {
     result = grpc_channel_credentials_ref(default_credentials);
     goto end;
   }
@@ -257,8 +257,8 @@ grpc_channel_credentials *grpc_google_default_credentials_create(void) {
         is_stack_running_on_compute_engine(&exec_ctx);
     compute_engine_detection_done = 1;
     if (need_compute_engine_creds) {
-      call_creds = grpc_google_compute_engine_credentials_create(NULL);
-      if (call_creds == NULL) {
+      call_creds = grpc_google_compute_engine_credentials_create(nullptr);
+      if (call_creds == nullptr) {
         error = grpc_error_add_child(
             error, GRPC_ERROR_CREATE_FROM_STATIC_STRING(
                        "Failed to get credentials from network"));
@@ -267,17 +267,17 @@ grpc_channel_credentials *grpc_google_default_credentials_create(void) {
   }
 
 end:
-  if (result == NULL) {
-    if (call_creds != NULL) {
+  if (result == nullptr) {
+    if (call_creds != nullptr) {
       /* Blend with default ssl credentials and add a global reference so that
          it
          can be cached and re-served. */
-      grpc_channel_credentials *ssl_creds =
-          grpc_ssl_credentials_create(NULL, NULL, NULL);
+      grpc_channel_credentials* ssl_creds =
+          grpc_ssl_credentials_create(nullptr, nullptr, nullptr);
       default_credentials = grpc_channel_credentials_ref(
           grpc_composite_channel_credentials_create(ssl_creds, call_creds,
-                                                    NULL));
-      GPR_ASSERT(default_credentials != NULL);
+                                                    nullptr));
+      GPR_ASSERT(default_credentials != nullptr);
       grpc_channel_credentials_unref(&exec_ctx, ssl_creds);
       grpc_call_credentials_unref(&exec_ctx, call_creds);
       result = default_credentials;
@@ -286,7 +286,7 @@ end:
     }
   }
   gpr_mu_unlock(&g_state_mu);
-  if (result == NULL) {
+  if (result == nullptr) {
     GRPC_LOG_IF_ERROR("grpc_google_default_credentials_create", error);
   } else {
     GRPC_ERROR_UNREF(error);
@@ -299,9 +299,9 @@ void grpc_flush_cached_google_default_credentials(void) {
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   gpr_once_init(&g_once, init_default_credentials);
   gpr_mu_lock(&g_state_mu);
-  if (default_credentials != NULL) {
+  if (default_credentials != nullptr) {
     grpc_channel_credentials_unref(&exec_ctx, default_credentials);
-    default_credentials = NULL;
+    default_credentials = nullptr;
   }
   compute_engine_detection_done = 0;
   gpr_mu_unlock(&g_state_mu);
@@ -310,10 +310,10 @@ void grpc_flush_cached_google_default_credentials(void) {
 
 /* -- Well known credentials path. -- */
 
-static grpc_well_known_credentials_path_getter creds_path_getter = NULL;
+static grpc_well_known_credentials_path_getter creds_path_getter = nullptr;
 
-char *grpc_get_well_known_google_credentials_file_path(void) {
-  if (creds_path_getter != NULL) return creds_path_getter();
+char* grpc_get_well_known_google_credentials_file_path(void) {
+  if (creds_path_getter != nullptr) return creds_path_getter();
   return grpc_get_well_known_google_credentials_file_path_impl();
 }
 

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

@@ -23,6 +23,10 @@
 
 #include "src/core/lib/security/credentials/credentials.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 #define GRPC_GOOGLE_CLOUD_SDK_CONFIG_DIRECTORY "gcloud"
 #define GRPC_GOOGLE_WELL_KNOWN_CREDENTIALS_FILE \
   "application_default_credentials.json"
@@ -41,5 +45,9 @@
 
 void grpc_flush_cached_google_default_credentials(void);
 
+#ifdef __cplusplus
+}
+#endif
+
 #endif /* GRPC_CORE_LIB_SECURITY_CREDENTIALS_GOOGLE_DEFAULT_GOOGLE_DEFAULT_CREDENTIALS_H \
-          */
+        */

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

@@ -27,44 +27,45 @@
 #include <grpc/support/string_util.h>
 #include <grpc/support/sync.h>
 
-static void iam_destruct(grpc_exec_ctx *exec_ctx,
-                         grpc_call_credentials *creds) {
-  grpc_google_iam_credentials *c = (grpc_google_iam_credentials *)creds;
+static void iam_destruct(grpc_exec_ctx* exec_ctx,
+                         grpc_call_credentials* creds) {
+  grpc_google_iam_credentials* c = (grpc_google_iam_credentials*)creds;
   grpc_credentials_mdelem_array_destroy(exec_ctx, &c->md_array);
 }
 
-static bool iam_get_request_metadata(grpc_exec_ctx *exec_ctx,
-                                     grpc_call_credentials *creds,
-                                     grpc_polling_entity *pollent,
+static bool iam_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_google_iam_credentials *c = (grpc_google_iam_credentials *)creds;
+                                     grpc_credentials_mdelem_array* md_array,
+                                     grpc_closure* on_request_metadata,
+                                     grpc_error** error) {
+  grpc_google_iam_credentials* c = (grpc_google_iam_credentials*)creds;
   grpc_credentials_mdelem_array_append(md_array, &c->md_array);
   return true;
 }
 
 static void iam_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);
 }
 
 static grpc_call_credentials_vtable iam_vtable = {
     iam_destruct, iam_get_request_metadata, iam_cancel_get_request_metadata};
 
-grpc_call_credentials *grpc_google_iam_credentials_create(
-    const char *token, const char *authority_selector, void *reserved) {
+grpc_call_credentials* grpc_google_iam_credentials_create(
+    const char* token, const char* authority_selector, void* reserved) {
   grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   GRPC_API_TRACE(
       "grpc_iam_credentials_create(token=%s, authority_selector=%s, "
       "reserved=%p)",
       3, (token, authority_selector, reserved));
-  GPR_ASSERT(reserved == NULL);
-  GPR_ASSERT(token != NULL);
-  GPR_ASSERT(authority_selector != NULL);
-  grpc_google_iam_credentials *c = gpr_zalloc(sizeof(*c));
+  GPR_ASSERT(reserved == nullptr);
+  GPR_ASSERT(token != nullptr);
+  GPR_ASSERT(authority_selector != nullptr);
+  grpc_google_iam_credentials* c =
+      (grpc_google_iam_credentials*)gpr_zalloc(sizeof(*c));
   c->base.type = GRPC_CALL_CREDENTIALS_TYPE_IAM;
   c->base.vtable = &iam_vtable;
   gpr_ref_init(&c->base.refcount, 1);

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

@@ -20,6 +20,7 @@
 
 #include <string.h>
 
+#include <grpc/grpc_security.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 #include <grpc/support/string_util.h>
@@ -29,9 +30,11 @@
 #include "src/core/lib/slice/b64.h"
 #include "src/core/lib/support/string.h"
 
+extern "C" {
 #include <openssl/bio.h>
 #include <openssl/evp.h>
 #include <openssl/pem.h>
+}
 
 /* --- Constants. --- */
 
@@ -49,30 +52,31 @@ gpr_timespec grpc_max_auth_token_lifetime() {
 
 /* --- Override for testing. --- */
 
-static grpc_jwt_encode_and_sign_override g_jwt_encode_and_sign_override = NULL;
+static grpc_jwt_encode_and_sign_override g_jwt_encode_and_sign_override =
+    nullptr;
 
 /* --- grpc_auth_json_key. --- */
 
-int grpc_auth_json_key_is_valid(const grpc_auth_json_key *json_key) {
-  return (json_key != NULL) &&
+int grpc_auth_json_key_is_valid(const grpc_auth_json_key* json_key) {
+  return (json_key != nullptr) &&
          strcmp(json_key->type, GRPC_AUTH_JSON_TYPE_INVALID);
 }
 
-grpc_auth_json_key grpc_auth_json_key_create_from_json(const grpc_json *json) {
+grpc_auth_json_key grpc_auth_json_key_create_from_json(const grpc_json* json) {
   grpc_auth_json_key result;
-  BIO *bio = NULL;
-  const char *prop_value;
+  BIO* bio = nullptr;
+  const char* prop_value;
   int success = 0;
 
   memset(&result, 0, sizeof(grpc_auth_json_key));
   result.type = GRPC_AUTH_JSON_TYPE_INVALID;
-  if (json == NULL) {
+  if (json == nullptr) {
     gpr_log(GPR_ERROR, "Invalid json.");
     goto end;
   }
 
   prop_value = grpc_json_get_string_property(json, "type");
-  if (prop_value == NULL ||
+  if (prop_value == nullptr ||
       strcmp(prop_value, GRPC_AUTH_JSON_TYPE_SERVICE_ACCOUNT)) {
     goto end;
   }
@@ -87,7 +91,7 @@ grpc_auth_json_key grpc_auth_json_key_create_from_json(const grpc_json *json) {
   }
 
   prop_value = grpc_json_get_string_property(json, "private_key");
-  if (prop_value == NULL) {
+  if (prop_value == nullptr) {
     goto end;
   }
   bio = BIO_new(BIO_s_mem());
@@ -96,56 +100,57 @@ grpc_auth_json_key grpc_auth_json_key_create_from_json(const grpc_json *json) {
     gpr_log(GPR_ERROR, "Could not write into openssl BIO.");
     goto end;
   }
-  result.private_key = PEM_read_bio_RSAPrivateKey(bio, NULL, NULL, "");
-  if (result.private_key == NULL) {
+  result.private_key =
+      PEM_read_bio_RSAPrivateKey(bio, nullptr, nullptr, (void*)"");
+  if (result.private_key == nullptr) {
     gpr_log(GPR_ERROR, "Could not deserialize private key.");
     goto end;
   }
   success = 1;
 
 end:
-  if (bio != NULL) BIO_free(bio);
+  if (bio != nullptr) BIO_free(bio);
   if (!success) grpc_auth_json_key_destruct(&result);
   return result;
 }
 
 grpc_auth_json_key grpc_auth_json_key_create_from_string(
-    const char *json_string) {
-  char *scratchpad = gpr_strdup(json_string);
-  grpc_json *json = grpc_json_parse_string(scratchpad);
+    const char* json_string) {
+  char* scratchpad = gpr_strdup(json_string);
+  grpc_json* json = grpc_json_parse_string(scratchpad);
   grpc_auth_json_key result = grpc_auth_json_key_create_from_json(json);
-  if (json != NULL) grpc_json_destroy(json);
+  if (json != nullptr) grpc_json_destroy(json);
   gpr_free(scratchpad);
   return result;
 }
 
-void grpc_auth_json_key_destruct(grpc_auth_json_key *json_key) {
-  if (json_key == NULL) return;
+void grpc_auth_json_key_destruct(grpc_auth_json_key* json_key) {
+  if (json_key == nullptr) return;
   json_key->type = GRPC_AUTH_JSON_TYPE_INVALID;
-  if (json_key->client_id != NULL) {
+  if (json_key->client_id != nullptr) {
     gpr_free(json_key->client_id);
-    json_key->client_id = NULL;
+    json_key->client_id = nullptr;
   }
-  if (json_key->private_key_id != NULL) {
+  if (json_key->private_key_id != nullptr) {
     gpr_free(json_key->private_key_id);
-    json_key->private_key_id = NULL;
+    json_key->private_key_id = nullptr;
   }
-  if (json_key->client_email != NULL) {
+  if (json_key->client_email != nullptr) {
     gpr_free(json_key->client_email);
-    json_key->client_email = NULL;
+    json_key->client_email = nullptr;
   }
-  if (json_key->private_key != NULL) {
+  if (json_key->private_key != nullptr) {
     RSA_free(json_key->private_key);
-    json_key->private_key = NULL;
+    json_key->private_key = nullptr;
   }
 }
 
 /* --- jwt encoding and signature. --- */
 
-static grpc_json *create_child(grpc_json *brother, grpc_json *parent,
-                               const char *key, const char *value,
+static grpc_json* create_child(grpc_json* brother, grpc_json* parent,
+                               const char* key, const char* value,
                                grpc_json_type type) {
-  grpc_json *child = grpc_json_create(type);
+  grpc_json* child = grpc_json_create(type);
   if (brother) brother->next = child;
   if (!parent->child) parent->child = child;
   child->parent = parent;
@@ -154,13 +159,13 @@ static grpc_json *create_child(grpc_json *brother, grpc_json *parent,
   return child;
 }
 
-static char *encoded_jwt_header(const char *key_id, const char *algorithm) {
-  grpc_json *json = grpc_json_create(GRPC_JSON_OBJECT);
-  grpc_json *child = NULL;
-  char *json_str = NULL;
-  char *result = NULL;
+static char* encoded_jwt_header(const char* key_id, const char* algorithm) {
+  grpc_json* json = grpc_json_create(GRPC_JSON_OBJECT);
+  grpc_json* child = nullptr;
+  char* json_str = nullptr;
+  char* result = nullptr;
 
-  child = create_child(NULL, json, "alg", algorithm, GRPC_JSON_STRING);
+  child = create_child(nullptr, json, "alg", algorithm, GRPC_JSON_STRING);
   child = create_child(child, json, "typ", GRPC_JWT_TYPE, GRPC_JSON_STRING);
   create_child(child, json, "kid", key_id, GRPC_JSON_STRING);
 
@@ -171,13 +176,13 @@ static char *encoded_jwt_header(const char *key_id, const char *algorithm) {
   return result;
 }
 
-static char *encoded_jwt_claim(const grpc_auth_json_key *json_key,
-                               const char *audience,
-                               gpr_timespec token_lifetime, const char *scope) {
-  grpc_json *json = grpc_json_create(GRPC_JSON_OBJECT);
-  grpc_json *child = NULL;
-  char *json_str = NULL;
-  char *result = NULL;
+static char* encoded_jwt_claim(const grpc_auth_json_key* json_key,
+                               const char* audience,
+                               gpr_timespec token_lifetime, const char* scope) {
+  grpc_json* json = grpc_json_create(GRPC_JSON_OBJECT);
+  grpc_json* child = nullptr;
+  char* json_str = nullptr;
+  char* result = nullptr;
   gpr_timespec now = gpr_now(GPR_CLOCK_REALTIME);
   gpr_timespec expiration = gpr_time_add(now, token_lifetime);
   char now_str[GPR_LTOA_MIN_BUFSIZE];
@@ -189,9 +194,9 @@ static char *encoded_jwt_claim(const grpc_auth_json_key *json_key,
   int64_ttoa(now.tv_sec, now_str);
   int64_ttoa(expiration.tv_sec, expiration_str);
 
-  child =
-      create_child(NULL, json, "iss", json_key->client_email, GRPC_JSON_STRING);
-  if (scope != NULL) {
+  child = create_child(nullptr, json, "iss", json_key->client_email,
+                       GRPC_JSON_STRING);
+  if (scope != nullptr) {
     child = create_child(child, json, "scope", scope, GRPC_JSON_STRING);
   } else {
     /* Unscoped JWTs need a sub field. */
@@ -210,12 +215,12 @@ static char *encoded_jwt_claim(const grpc_auth_json_key *json_key,
   return result;
 }
 
-static char *dot_concat_and_free_strings(char *str1, char *str2) {
+static char* dot_concat_and_free_strings(char* str1, char* str2) {
   size_t str1_len = strlen(str1);
   size_t str2_len = strlen(str2);
   size_t result_len = str1_len + 1 /* dot */ + str2_len;
-  char *result = gpr_malloc(result_len + 1 /* NULL terminated */);
-  char *current = result;
+  char* result = (char*)gpr_malloc(result_len + 1 /* NULL terminated */);
+  char* current = result;
   memcpy(current, str1, str1_len);
   current += str1_len;
   *(current++) = '.';
@@ -229,32 +234,32 @@ static char *dot_concat_and_free_strings(char *str1, char *str2) {
   return result;
 }
 
-const EVP_MD *openssl_digest_from_algorithm(const char *algorithm) {
+const EVP_MD* openssl_digest_from_algorithm(const char* algorithm) {
   if (strcmp(algorithm, GRPC_JWT_RSA_SHA256_ALGORITHM) == 0) {
     return EVP_sha256();
   } else {
     gpr_log(GPR_ERROR, "Unknown algorithm %s.", algorithm);
-    return NULL;
+    return nullptr;
   }
 }
 
-char *compute_and_encode_signature(const grpc_auth_json_key *json_key,
-                                   const char *signature_algorithm,
-                                   const char *to_sign) {
-  const EVP_MD *md = openssl_digest_from_algorithm(signature_algorithm);
-  EVP_MD_CTX *md_ctx = NULL;
-  EVP_PKEY *key = EVP_PKEY_new();
+char* compute_and_encode_signature(const grpc_auth_json_key* json_key,
+                                   const char* signature_algorithm,
+                                   const char* to_sign) {
+  const EVP_MD* md = openssl_digest_from_algorithm(signature_algorithm);
+  EVP_MD_CTX* md_ctx = nullptr;
+  EVP_PKEY* key = EVP_PKEY_new();
   size_t sig_len = 0;
-  unsigned char *sig = NULL;
-  char *result = NULL;
-  if (md == NULL) return NULL;
+  unsigned char* sig = nullptr;
+  char* result = nullptr;
+  if (md == nullptr) return nullptr;
   md_ctx = EVP_MD_CTX_create();
-  if (md_ctx == NULL) {
+  if (md_ctx == nullptr) {
     gpr_log(GPR_ERROR, "Could not create MD_CTX");
     goto end;
   }
   EVP_PKEY_set1_RSA(key, json_key->private_key);
-  if (EVP_DigestSignInit(md_ctx, NULL, md, NULL, key) != 1) {
+  if (EVP_DigestSignInit(md_ctx, nullptr, md, nullptr, key) != 1) {
     gpr_log(GPR_ERROR, "DigestInit failed.");
     goto end;
   }
@@ -262,11 +267,11 @@ char *compute_and_encode_signature(const grpc_auth_json_key *json_key,
     gpr_log(GPR_ERROR, "DigestUpdate failed.");
     goto end;
   }
-  if (EVP_DigestSignFinal(md_ctx, NULL, &sig_len) != 1) {
+  if (EVP_DigestSignFinal(md_ctx, nullptr, &sig_len) != 1) {
     gpr_log(GPR_ERROR, "DigestFinal (get signature length) failed.");
     goto end;
   }
-  sig = gpr_malloc(sig_len);
+  sig = (unsigned char*)gpr_malloc(sig_len);
   if (EVP_DigestSignFinal(md_ctx, sig, &sig_len) != 1) {
     gpr_log(GPR_ERROR, "DigestFinal (signature compute) failed.");
     goto end;
@@ -274,27 +279,27 @@ char *compute_and_encode_signature(const grpc_auth_json_key *json_key,
   result = grpc_base64_encode(sig, sig_len, 1, 0);
 
 end:
-  if (key != NULL) EVP_PKEY_free(key);
-  if (md_ctx != NULL) EVP_MD_CTX_destroy(md_ctx);
-  if (sig != NULL) gpr_free(sig);
+  if (key != nullptr) EVP_PKEY_free(key);
+  if (md_ctx != nullptr) EVP_MD_CTX_destroy(md_ctx);
+  if (sig != nullptr) gpr_free(sig);
   return result;
 }
 
-char *grpc_jwt_encode_and_sign(const grpc_auth_json_key *json_key,
-                               const char *audience,
-                               gpr_timespec token_lifetime, const char *scope) {
-  if (g_jwt_encode_and_sign_override != NULL) {
+char* grpc_jwt_encode_and_sign(const grpc_auth_json_key* json_key,
+                               const char* audience,
+                               gpr_timespec token_lifetime, const char* scope) {
+  if (g_jwt_encode_and_sign_override != nullptr) {
     return g_jwt_encode_and_sign_override(json_key, audience, token_lifetime,
                                           scope);
   } else {
-    const char *sig_algo = GRPC_JWT_RSA_SHA256_ALGORITHM;
-    char *to_sign = dot_concat_and_free_strings(
+    const char* sig_algo = GRPC_JWT_RSA_SHA256_ALGORITHM;
+    char* to_sign = dot_concat_and_free_strings(
         encoded_jwt_header(json_key->private_key_id, sig_algo),
         encoded_jwt_claim(json_key, audience, token_lifetime, scope));
-    char *sig = compute_and_encode_signature(json_key, sig_algo, to_sign);
-    if (sig == NULL) {
+    char* sig = compute_and_encode_signature(json_key, sig_algo, to_sign);
+    if (sig == nullptr) {
       gpr_free(to_sign);
-      return NULL;
+      return nullptr;
     }
     return dot_concat_and_free_strings(to_sign, sig);
   }