grpc 1.7.3 → 1.8.0

data/src/core/lib/http/httpcli.h

@@ -32,19 +32,23 @@
 /* User agent this library reports */
 #define GRPC_HTTPCLI_USER_AGENT "grpc-httpcli/0.0"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /* Tracks in-progress http requests
    TODO(ctiller): allow caching and capturing multiple requests for the
                   same content and combining them */
 typedef struct grpc_httpcli_context {
-  grpc_pollset_set *pollset_set;
+  grpc_pollset_set* pollset_set;
 } grpc_httpcli_context;
 
 typedef struct {
-  const char *default_port;
-  void (*handshake)(grpc_exec_ctx *exec_ctx, void *arg, grpc_endpoint *endpoint,
-                    const char *host, gpr_timespec deadline,
-                    void (*on_done)(grpc_exec_ctx *exec_ctx, void *arg,
-                                    grpc_endpoint *endpoint));
+  const char* default_port;
+  void (*handshake)(grpc_exec_ctx* exec_ctx, void* arg, grpc_endpoint* endpoint,
+                    const char* host, grpc_millis deadline,
+                    void (*on_done)(grpc_exec_ctx* exec_ctx, void* arg,
+                                    grpc_endpoint* endpoint));
 } grpc_httpcli_handshaker;
 
 extern const grpc_httpcli_handshaker grpc_httpcli_plaintext;
@@ -53,23 +57,23 @@ extern const grpc_httpcli_handshaker grpc_httpcli_ssl;
 /* A request */
 typedef struct grpc_httpcli_request {
   /* The host name to connect to */
-  char *host;
+  char* host;
   /* The host to verify in the SSL handshake (or NULL) */
-  char *ssl_host_override;
+  char* ssl_host_override;
   /* The main part of the request
      The following headers are supplied automatically and MUST NOT be set here:
      Host, Connection, User-Agent */
   grpc_http_request http;
   /* handshaker to use ssl for the request */
-  const grpc_httpcli_handshaker *handshaker;
+  const grpc_httpcli_handshaker* handshaker;
 } grpc_httpcli_request;
 
 /* Expose the parser response type as a httpcli response too */
 typedef struct grpc_http_response grpc_httpcli_response;
 
-void grpc_httpcli_context_init(grpc_httpcli_context *context);
-void grpc_httpcli_context_destroy(grpc_exec_ctx *exec_ctx,
-                                  grpc_httpcli_context *context);
+void grpc_httpcli_context_init(grpc_httpcli_context* context);
+void grpc_httpcli_context_destroy(grpc_exec_ctx* exec_ctx,
+                                  grpc_httpcli_context* context);
 
 /* Asynchronously perform a HTTP GET.
    'context' specifies the http context under which to do the get
@@ -80,12 +84,12 @@ void grpc_httpcli_context_destroy(grpc_exec_ctx *exec_ctx,
      destroyed once the call returns
    'deadline' contains a deadline for the request (or gpr_inf_future)
    'on_response' is a callback to report results to */
-void grpc_httpcli_get(grpc_exec_ctx *exec_ctx, grpc_httpcli_context *context,
-                      grpc_polling_entity *pollent,
-                      grpc_resource_quota *resource_quota,
-                      const grpc_httpcli_request *request,
-                      gpr_timespec deadline, grpc_closure *on_complete,
-                      grpc_httpcli_response *response);
+void grpc_httpcli_get(grpc_exec_ctx* exec_ctx, grpc_httpcli_context* context,
+                      grpc_polling_entity* pollent,
+                      grpc_resource_quota* resource_quota,
+                      const grpc_httpcli_request* request, grpc_millis deadline,
+                      grpc_closure* on_complete,
+                      grpc_httpcli_response* response);
 
 /* Asynchronously perform a HTTP POST.
    'context' specifies the http context under which to do the post
@@ -101,26 +105,30 @@ void grpc_httpcli_get(grpc_exec_ctx *exec_ctx, grpc_httpcli_context *context,
      lifetime of the request
    'on_response' is a callback to report results to
    Does not support ?var1=val1&var2=val2 in the path. */
-void grpc_httpcli_post(grpc_exec_ctx *exec_ctx, grpc_httpcli_context *context,
-                       grpc_polling_entity *pollent,
-                       grpc_resource_quota *resource_quota,
-                       const grpc_httpcli_request *request,
-                       const char *body_bytes, size_t body_size,
-                       gpr_timespec deadline, grpc_closure *on_complete,
-                       grpc_httpcli_response *response);
+void grpc_httpcli_post(grpc_exec_ctx* exec_ctx, grpc_httpcli_context* context,
+                       grpc_polling_entity* pollent,
+                       grpc_resource_quota* resource_quota,
+                       const grpc_httpcli_request* request,
+                       const char* body_bytes, size_t body_size,
+                       grpc_millis deadline, grpc_closure* on_complete,
+                       grpc_httpcli_response* response);
 
 /* override functions return 1 if they handled the request, 0 otherwise */
-typedef int (*grpc_httpcli_get_override)(grpc_exec_ctx *exec_ctx,
-                                         const grpc_httpcli_request *request,
-                                         gpr_timespec deadline,
-                                         grpc_closure *on_complete,
-                                         grpc_httpcli_response *response);
+typedef int (*grpc_httpcli_get_override)(grpc_exec_ctx* exec_ctx,
+                                         const grpc_httpcli_request* request,
+                                         grpc_millis deadline,
+                                         grpc_closure* on_complete,
+                                         grpc_httpcli_response* response);
 typedef int (*grpc_httpcli_post_override)(
-    grpc_exec_ctx *exec_ctx, const grpc_httpcli_request *request,
-    const char *body_bytes, size_t body_size, gpr_timespec deadline,
-    grpc_closure *on_complete, grpc_httpcli_response *response);
+    grpc_exec_ctx* exec_ctx, const grpc_httpcli_request* request,
+    const char* body_bytes, size_t body_size, grpc_millis deadline,
+    grpc_closure* on_complete, grpc_httpcli_response* response);
 
 void grpc_httpcli_set_override(grpc_httpcli_get_override get,
                                grpc_httpcli_post_override post);
 
+#ifdef __cplusplus
+}
+#endif
+
 #endif /* GRPC_CORE_LIB_HTTP_HTTPCLI_H */

data/src/core/lib/http/{httpcli_security_connector.c → httpcli_security_connector.cc}

@@ -34,29 +34,29 @@
 
 typedef struct {
   grpc_channel_security_connector base;
-  tsi_ssl_client_handshaker_factory *handshaker_factory;
-  char *secure_peer_name;
+  tsi_ssl_client_handshaker_factory* handshaker_factory;
+  char* secure_peer_name;
 } grpc_httpcli_ssl_channel_security_connector;
 
-static void httpcli_ssl_destroy(grpc_exec_ctx *exec_ctx,
-                                grpc_security_connector *sc) {
-  grpc_httpcli_ssl_channel_security_connector *c =
-      (grpc_httpcli_ssl_channel_security_connector *)sc;
-  if (c->handshaker_factory != NULL) {
+static void httpcli_ssl_destroy(grpc_exec_ctx* exec_ctx,
+                                grpc_security_connector* sc) {
+  grpc_httpcli_ssl_channel_security_connector* c =
+      (grpc_httpcli_ssl_channel_security_connector*)sc;
+  if (c->handshaker_factory != nullptr) {
     tsi_ssl_client_handshaker_factory_unref(c->handshaker_factory);
-    c->handshaker_factory = NULL;
+    c->handshaker_factory = nullptr;
   }
-  if (c->secure_peer_name != NULL) gpr_free(c->secure_peer_name);
+  if (c->secure_peer_name != nullptr) gpr_free(c->secure_peer_name);
   gpr_free(sc);
 }
 
-static void httpcli_ssl_add_handshakers(grpc_exec_ctx *exec_ctx,
-                                        grpc_channel_security_connector *sc,
-                                        grpc_handshake_manager *handshake_mgr) {
-  grpc_httpcli_ssl_channel_security_connector *c =
-      (grpc_httpcli_ssl_channel_security_connector *)sc;
-  tsi_handshaker *handshaker = NULL;
-  if (c->handshaker_factory != NULL) {
+static void httpcli_ssl_add_handshakers(grpc_exec_ctx* exec_ctx,
+                                        grpc_channel_security_connector* sc,
+                                        grpc_handshake_manager* handshake_mgr) {
+  grpc_httpcli_ssl_channel_security_connector* c =
+      (grpc_httpcli_ssl_channel_security_connector*)sc;
+  tsi_handshaker* handshaker = nullptr;
+  if (c->handshaker_factory != nullptr) {
     tsi_result result = tsi_ssl_client_handshaker_factory_create_handshaker(
         c->handshaker_factory, c->secure_peer_name, &handshaker);
     if (result != TSI_OK) {
@@ -70,18 +70,18 @@ static void httpcli_ssl_add_handshakers(grpc_exec_ctx *exec_ctx,
           exec_ctx, tsi_create_adapter_handshaker(handshaker), &sc->base));
 }
 
-static void httpcli_ssl_check_peer(grpc_exec_ctx *exec_ctx,
-                                   grpc_security_connector *sc, tsi_peer peer,
-                                   grpc_auth_context **auth_context,
-                                   grpc_closure *on_peer_checked) {
-  grpc_httpcli_ssl_channel_security_connector *c =
-      (grpc_httpcli_ssl_channel_security_connector *)sc;
-  grpc_error *error = GRPC_ERROR_NONE;
+static void httpcli_ssl_check_peer(grpc_exec_ctx* exec_ctx,
+                                   grpc_security_connector* sc, tsi_peer peer,
+                                   grpc_auth_context** auth_context,
+                                   grpc_closure* on_peer_checked) {
+  grpc_httpcli_ssl_channel_security_connector* c =
+      (grpc_httpcli_ssl_channel_security_connector*)sc;
+  grpc_error* error = GRPC_ERROR_NONE;
 
   /* Check the peer name. */
-  if (c->secure_peer_name != NULL &&
+  if (c->secure_peer_name != nullptr &&
       !tsi_ssl_peer_matches_name(&peer, c->secure_peer_name)) {
-    char *msg;
+    char* msg;
     gpr_asprintf(&msg, "Peer name %s is not in peer certificate",
                  c->secure_peer_name);
     error = GRPC_ERROR_CREATE_FROM_COPIED_STRING(msg);
@@ -91,37 +91,51 @@ static void httpcli_ssl_check_peer(grpc_exec_ctx *exec_ctx,
   tsi_peer_destruct(&peer);
 }
 
+static int httpcli_ssl_cmp(grpc_security_connector* sc1,
+                           grpc_security_connector* sc2) {
+  grpc_httpcli_ssl_channel_security_connector* c1 =
+      (grpc_httpcli_ssl_channel_security_connector*)sc1;
+  grpc_httpcli_ssl_channel_security_connector* c2 =
+      (grpc_httpcli_ssl_channel_security_connector*)sc2;
+  return strcmp(c1->secure_peer_name, c2->secure_peer_name);
+}
+
 static grpc_security_connector_vtable httpcli_ssl_vtable = {
-    httpcli_ssl_destroy, httpcli_ssl_check_peer};
+    httpcli_ssl_destroy, httpcli_ssl_check_peer, httpcli_ssl_cmp};
 
 static grpc_security_status httpcli_ssl_channel_security_connector_create(
-    grpc_exec_ctx *exec_ctx, const char *pem_root_certs,
-    const char *secure_peer_name, grpc_channel_security_connector **sc) {
+    grpc_exec_ctx* exec_ctx, const char* pem_root_certs,
+    const char* secure_peer_name, grpc_channel_security_connector** sc) {
   tsi_result result = TSI_OK;
-  grpc_httpcli_ssl_channel_security_connector *c;
+  grpc_httpcli_ssl_channel_security_connector* c;
 
-  if (secure_peer_name != NULL && pem_root_certs == NULL) {
+  if (secure_peer_name != nullptr && pem_root_certs == nullptr) {
     gpr_log(GPR_ERROR,
             "Cannot assert a secure peer name without a trust root.");
     return GRPC_SECURITY_ERROR;
   }
 
-  c = gpr_zalloc(sizeof(grpc_httpcli_ssl_channel_security_connector));
+  c = (grpc_httpcli_ssl_channel_security_connector*)gpr_zalloc(
+      sizeof(grpc_httpcli_ssl_channel_security_connector));
 
   gpr_ref_init(&c->base.base.refcount, 1);
   c->base.base.vtable = &httpcli_ssl_vtable;
-  if (secure_peer_name != NULL) {
+  if (secure_peer_name != nullptr) {
     c->secure_peer_name = gpr_strdup(secure_peer_name);
   }
   result = tsi_create_ssl_client_handshaker_factory(
-      NULL, pem_root_certs, NULL, NULL, 0, &c->handshaker_factory);
+      nullptr, pem_root_certs, nullptr, nullptr, 0, &c->handshaker_factory);
   if (result != TSI_OK) {
     gpr_log(GPR_ERROR, "Handshaker factory creation failed with %s.",
             tsi_result_to_string(result));
     httpcli_ssl_destroy(exec_ctx, &c->base.base);
-    *sc = NULL;
+    *sc = nullptr;
     return GRPC_SECURITY_ERROR;
   }
+  // We don't actually need a channel credentials object in this case,
+  // but we set it to a non-NULL address so that we don't trigger
+  // assertions in grpc_channel_security_connector_cmp().
+  c->base.channel_creds = (grpc_channel_credentials*)1;
   c->base.add_handshakers = httpcli_ssl_add_handshakers;
   *sc = &c->base;
   return GRPC_SECURITY_OK;
@@ -130,20 +144,20 @@ static grpc_security_status httpcli_ssl_channel_security_connector_create(
 /* handshaker */
 
 typedef struct {
-  void (*func)(grpc_exec_ctx *exec_ctx, void *arg, grpc_endpoint *endpoint);
-  void *arg;
-  grpc_handshake_manager *handshake_mgr;
+  void (*func)(grpc_exec_ctx* exec_ctx, void* arg, grpc_endpoint* endpoint);
+  void* arg;
+  grpc_handshake_manager* handshake_mgr;
 } on_done_closure;
 
-static void on_handshake_done(grpc_exec_ctx *exec_ctx, void *arg,
-                              grpc_error *error) {
-  grpc_handshaker_args *args = arg;
-  on_done_closure *c = args->user_data;
+static void on_handshake_done(grpc_exec_ctx* exec_ctx, void* arg,
+                              grpc_error* error) {
+  grpc_handshaker_args* args = (grpc_handshaker_args*)arg;
+  on_done_closure* c = (on_done_closure*)args->user_data;
   if (error != GRPC_ERROR_NONE) {
-    const char *msg = grpc_error_string(error);
+    const char* msg = grpc_error_string(error);
     gpr_log(GPR_ERROR, "Secure transport setup failed: %s", msg);
 
-    c->func(exec_ctx, c->arg, NULL);
+    c->func(exec_ctx, c->arg, nullptr);
   } else {
     grpc_channel_args_destroy(exec_ctx, args->args);
     grpc_slice_buffer_destroy_internal(exec_ctx, args->read_buffer);
@@ -154,22 +168,22 @@ static void on_handshake_done(grpc_exec_ctx *exec_ctx, void *arg,
   gpr_free(c);
 }
 
-static void ssl_handshake(grpc_exec_ctx *exec_ctx, void *arg,
-                          grpc_endpoint *tcp, const char *host,
-                          gpr_timespec deadline,
-                          void (*on_done)(grpc_exec_ctx *exec_ctx, void *arg,
-                                          grpc_endpoint *endpoint)) {
-  on_done_closure *c = gpr_malloc(sizeof(*c));
-  const char *pem_root_certs = grpc_get_default_ssl_roots();
-  if (pem_root_certs == NULL) {
+static void ssl_handshake(grpc_exec_ctx* exec_ctx, void* arg,
+                          grpc_endpoint* tcp, const char* host,
+                          grpc_millis deadline,
+                          void (*on_done)(grpc_exec_ctx* exec_ctx, void* arg,
+                                          grpc_endpoint* endpoint)) {
+  on_done_closure* c = (on_done_closure*)gpr_malloc(sizeof(*c));
+  const char* pem_root_certs = grpc_get_default_ssl_roots();
+  if (pem_root_certs == nullptr) {
     gpr_log(GPR_ERROR, "Could not get default pem root certs.");
-    on_done(exec_ctx, arg, NULL);
+    on_done(exec_ctx, arg, nullptr);
     gpr_free(c);
     return;
   }
   c->func = on_done;
   c->arg = arg;
-  grpc_channel_security_connector *sc = NULL;
+  grpc_channel_security_connector* sc = nullptr;
   GPR_ASSERT(httpcli_ssl_channel_security_connector_create(
                  exec_ctx, pem_root_certs, host, &sc) == GRPC_SECURITY_OK);
   grpc_arg channel_arg = grpc_security_connector_to_arg(&sc->base);
@@ -177,8 +191,8 @@ static void ssl_handshake(grpc_exec_ctx *exec_ctx, void *arg,
   c->handshake_mgr = grpc_handshake_manager_create();
   grpc_handshakers_add(exec_ctx, HANDSHAKER_CLIENT, &args, c->handshake_mgr);
   grpc_handshake_manager_do_handshake(
-      exec_ctx, c->handshake_mgr, tcp, NULL /* channel_args */, deadline,
-      NULL /* acceptor */, on_handshake_done, c /* user_data */);
+      exec_ctx, c->handshake_mgr, tcp, nullptr /* channel_args */, deadline,
+      nullptr /* acceptor */, on_handshake_done, c /* user_data */);
   GRPC_SECURITY_CONNECTOR_UNREF(exec_ctx, &sc->base, "httpcli");
 }
 

data/src/core/lib/http/{parser.c → parser.cc}

@@ -25,19 +25,19 @@
 #include <grpc/support/log.h>
 #include <grpc/support/useful.h>
 
-grpc_tracer_flag grpc_http1_trace = GRPC_TRACER_INITIALIZER(false, "http1");
+grpc_core::TraceFlag grpc_http1_trace(false, "http1");
 
-static char *buf2str(void *buffer, size_t length) {
-  char *out = (char *)gpr_malloc(length + 1);
+static char* buf2str(void* buffer, size_t length) {
+  char* out = (char*)gpr_malloc(length + 1);
   memcpy(out, buffer, length);
   out[length] = 0;
   return out;
 }
 
-static grpc_error *handle_response_line(grpc_http_parser *parser) {
-  uint8_t *beg = parser->cur_line;
-  uint8_t *cur = beg;
-  uint8_t *end = beg + parser->cur_line_length;
+static grpc_error* handle_response_line(grpc_http_parser* parser) {
+  uint8_t* beg = parser->cur_line;
+  uint8_t* cur = beg;
+  uint8_t* end = beg + parser->cur_line_length;
 
   if (cur == end || *cur++ != 'H')
     return GRPC_ERROR_CREATE_FROM_STATIC_STRING("Expected 'H'");
@@ -75,10 +75,10 @@ static grpc_error *handle_response_line(grpc_http_parser *parser) {
   return GRPC_ERROR_NONE;
 }
 
-static grpc_error *handle_request_line(grpc_http_parser *parser) {
-  uint8_t *beg = parser->cur_line;
-  uint8_t *cur = beg;
-  uint8_t *end = beg + parser->cur_line_length;
+static grpc_error* handle_request_line(grpc_http_parser* parser) {
+  uint8_t* beg = parser->cur_line;
+  uint8_t* cur = beg;
+  uint8_t* end = beg + parser->cur_line_length;
   uint8_t vers_major = 0;
   uint8_t vers_minor = 0;
 
@@ -137,7 +137,7 @@ static grpc_error *handle_request_line(grpc_http_parser *parser) {
   return GRPC_ERROR_NONE;
 }
 
-static grpc_error *handle_first_line(grpc_http_parser *parser) {
+static grpc_error* handle_first_line(grpc_http_parser* parser) {
   switch (parser->type) {
     case GRPC_HTTP_REQUEST:
       return handle_request_line(parser);
@@ -148,14 +148,14 @@ static grpc_error *handle_first_line(grpc_http_parser *parser) {
       return GRPC_ERROR_CREATE_FROM_STATIC_STRING("Should never reach here"));
 }
 
-static grpc_error *add_header(grpc_http_parser *parser) {
-  uint8_t *beg = parser->cur_line;
-  uint8_t *cur = beg;
-  uint8_t *end = beg + parser->cur_line_length;
-  size_t *hdr_count = NULL;
-  grpc_http_header **hdrs = NULL;
-  grpc_http_header hdr = {NULL, NULL};
-  grpc_error *error = GRPC_ERROR_NONE;
+static grpc_error* add_header(grpc_http_parser* parser) {
+  uint8_t* beg = parser->cur_line;
+  uint8_t* cur = beg;
+  uint8_t* end = beg + parser->cur_line_length;
+  size_t* hdr_count = nullptr;
+  grpc_http_header** hdrs = nullptr;
+  grpc_http_header hdr = {nullptr, nullptr};
+  grpc_error* error = GRPC_ERROR_NONE;
 
   GPR_ASSERT(cur != end);
 
@@ -197,7 +197,7 @@ static grpc_error *add_header(grpc_http_parser *parser) {
   if (*hdr_count == parser->hdr_capacity) {
     parser->hdr_capacity =
         GPR_MAX(parser->hdr_capacity + 1, parser->hdr_capacity * 3 / 2);
-    *hdrs = (grpc_http_header *)gpr_realloc(
+    *hdrs = (grpc_http_header*)gpr_realloc(
         *hdrs, parser->hdr_capacity * sizeof(**hdrs));
   }
   (*hdrs)[(*hdr_count)++] = hdr;
@@ -210,9 +210,9 @@ done:
   return error;
 }
 
-static grpc_error *finish_line(grpc_http_parser *parser,
-                               bool *found_body_start) {
-  grpc_error *err;
+static grpc_error* finish_line(grpc_http_parser* parser,
+                               bool* found_body_start) {
+  grpc_error* err;
   switch (parser->state) {
     case GRPC_HTTP_FIRST_LINE:
       err = handle_first_line(parser);
@@ -239,9 +239,9 @@ static grpc_error *finish_line(grpc_http_parser *parser,
   return GRPC_ERROR_NONE;
 }
 
-static grpc_error *addbyte_body(grpc_http_parser *parser, uint8_t byte) {
-  size_t *body_length = NULL;
-  char **body = NULL;
+static grpc_error* addbyte_body(grpc_http_parser* parser, uint8_t byte) {
+  size_t* body_length = nullptr;
+  char** body = nullptr;
 
   if (parser->type == GRPC_HTTP_RESPONSE) {
     body_length = &parser->http.response->body_length;
@@ -256,7 +256,7 @@ static grpc_error *addbyte_body(grpc_http_parser *parser, uint8_t byte) {
 
   if (*body_length == parser->body_capacity) {
     parser->body_capacity = GPR_MAX(8, parser->body_capacity * 3 / 2);
-    *body = (char *)gpr_realloc((void *)*body, parser->body_capacity);
+    *body = (char*)gpr_realloc((void*)*body, parser->body_capacity);
   }
   (*body)[*body_length] = (char)byte;
   (*body_length)++;
@@ -264,7 +264,7 @@ static grpc_error *addbyte_body(grpc_http_parser *parser, uint8_t byte) {
   return GRPC_ERROR_NONE;
 }
 
-static bool check_line(grpc_http_parser *parser) {
+static bool check_line(grpc_http_parser* parser) {
   if (parser->cur_line_length >= 2 &&
       parser->cur_line[parser->cur_line_length - 2] == '\r' &&
       parser->cur_line[parser->cur_line_length - 1] == '\n') {
@@ -288,13 +288,13 @@ static bool check_line(grpc_http_parser *parser) {
   return false;
 }
 
-static grpc_error *addbyte(grpc_http_parser *parser, uint8_t byte,
-                           bool *found_body_start) {
+static grpc_error* addbyte(grpc_http_parser* parser, uint8_t byte,
+                           bool* found_body_start) {
   switch (parser->state) {
     case GRPC_HTTP_FIRST_LINE:
     case GRPC_HTTP_HEADERS:
       if (parser->cur_line_length >= GRPC_HTTP_PARSER_MAX_HEADER_LENGTH) {
-        if (GRPC_TRACER_ON(grpc_http1_trace))
+        if (grpc_http1_trace.enabled())
           gpr_log(GPR_ERROR, "HTTP header max line length (%d) exceeded",
                   GRPC_HTTP_PARSER_MAX_HEADER_LENGTH);
         return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
@@ -312,8 +312,8 @@ static grpc_error *addbyte(grpc_http_parser *parser, uint8_t byte,
   GPR_UNREACHABLE_CODE(return GRPC_ERROR_NONE);
 }
 
-void grpc_http_parser_init(grpc_http_parser *parser, grpc_http_type type,
-                           void *request_or_response) {
+void grpc_http_parser_init(grpc_http_parser* parser, grpc_http_type type,
+                           void* request_or_response) {
   memset(parser, 0, sizeof(*parser));
   parser->state = GRPC_HTTP_FIRST_LINE;
   parser->type = type;
@@ -321,9 +321,9 @@ void grpc_http_parser_init(grpc_http_parser *parser, grpc_http_type type,
   parser->cur_line_end_length = 2;
 }
 
-void grpc_http_parser_destroy(grpc_http_parser *parser) {}
+void grpc_http_parser_destroy(grpc_http_parser* parser) {}
 
-void grpc_http_request_destroy(grpc_http_request *request) {
+void grpc_http_request_destroy(grpc_http_request* request) {
   size_t i;
   gpr_free(request->body);
   for (i = 0; i < request->hdr_count; i++) {
@@ -335,7 +335,7 @@ void grpc_http_request_destroy(grpc_http_request *request) {
   gpr_free(request->path);
 }
 
-void grpc_http_response_destroy(grpc_http_response *response) {
+void grpc_http_response_destroy(grpc_http_response* response) {
   size_t i;
   gpr_free(response->body);
   for (i = 0; i < response->hdr_count; i++) {
@@ -345,19 +345,19 @@ void grpc_http_response_destroy(grpc_http_response *response) {
   gpr_free(response->hdrs);
 }
 
-grpc_error *grpc_http_parser_parse(grpc_http_parser *parser, grpc_slice slice,
-                                   size_t *start_of_body) {
+grpc_error* grpc_http_parser_parse(grpc_http_parser* parser, grpc_slice slice,
+                                   size_t* start_of_body) {
   for (size_t i = 0; i < GRPC_SLICE_LENGTH(slice); i++) {
     bool found_body_start = false;
-    grpc_error *err =
+    grpc_error* err =
         addbyte(parser, GRPC_SLICE_START_PTR(slice)[i], &found_body_start);
     if (err != GRPC_ERROR_NONE) return err;
-    if (found_body_start && start_of_body != NULL) *start_of_body = i + 1;
+    if (found_body_start && start_of_body != nullptr) *start_of_body = i + 1;
   }
   return GRPC_ERROR_NONE;
 }
 
-grpc_error *grpc_http_parser_eof(grpc_http_parser *parser) {
+grpc_error* grpc_http_parser_eof(grpc_http_parser* parser) {
   if (parser->state != GRPC_HTTP_BODY) {
     return GRPC_ERROR_CREATE_FROM_STATIC_STRING("Did not finish headers");
   }