grpc 1.6.7 → 1.7.0.pre1

data/src/core/lib/security/transport/server_auth_filter.c

@@ -26,7 +26,15 @@
 #include "src/core/lib/security/transport/auth_filters.h"
 #include "src/core/lib/slice/slice_internal.h"
 
+typedef enum {
+  STATE_INIT = 0,
+  STATE_DONE,
+  STATE_CANCELLED,
+} 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_closure recv_initial_metadata_ready;
@@ -34,6 +42,8 @@ typedef struct call_data {
   const grpc_metadata *consumed_md;
   size_t num_consumed_md;
   grpc_auth_context *auth_context;
+  grpc_closure cancel_closure;
+  gpr_atm state;  // async_state
 } call_data;
 
 typedef struct channel_data {
@@ -78,54 +88,94 @@ static grpc_filtered_mdelem remove_consumed_md(grpc_exec_ctx *exec_ctx,
   return GRPC_FILTERED_MDELEM(md);
 }
 
-/* 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;
+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,
+                                        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_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
   /* TODO(jboeuf): Implement support for response_md. */
   if (response_md != NULL && num_response_md > 0) {
     gpr_log(GPR_INFO,
             "response_md in auth metadata processing not supported for now. "
             "Ignoring...");
   }
-  grpc_error *error = GRPC_ERROR_NONE;
-  if (status == GRPC_STATUS_OK) {
+  if (error == GRPC_ERROR_NONE) {
     calld->consumed_md = consumed_md;
     calld->num_consumed_md = num_consumed_md;
     error = grpc_metadata_batch_filter(
-        &exec_ctx, batch->payload->recv_initial_metadata.recv_initial_metadata,
+        exec_ctx, batch->payload->recv_initial_metadata.recv_initial_metadata,
         remove_consumed_md, elem, "Response metadata filtering error");
-  } else {
-    if (error_details == NULL) {
-      error_details = "Authentication metadata processing failed.";
+  }
+  GRPC_CLOSURE_SCHED(exec_ctx, calld->original_recv_initial_metadata_ready,
+                     error);
+}
+
+// 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;
+  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;
+    if (status != GRPC_STATUS_OK) {
+      if (error_details == NULL) {
+        error_details = "Authentication metadata processing failed.";
+      }
+      error = grpc_error_set_int(
+          GRPC_ERROR_CREATE_FROM_COPIED_STRING(error_details),
+          GRPC_ERROR_INT_GRPC_STATUS, status);
     }
-    error =
-        grpc_error_set_int(GRPC_ERROR_CREATE_FROM_COPIED_STRING(error_details),
-                           GRPC_ERROR_INT_GRPC_STATUS, status);
+    on_md_processing_done_inner(&exec_ctx, elem, consumed_md, num_consumed_md,
+                                response_md, num_response_md, error);
   }
+  // Clean up.
   for (size_t i = 0; i < calld->md.count; i++) {
     grpc_slice_unref_internal(&exec_ctx, calld->md.metadata[i].key);
     grpc_slice_unref_internal(&exec_ctx, calld->md.metadata[i].value);
   }
   grpc_metadata_array_destroy(&calld->md);
-  GRPC_CLOSURE_SCHED(&exec_ctx, calld->original_recv_initial_metadata_ready,
-                     error);
+  GRPC_CALL_STACK_UNREF(&exec_ctx, calld->owning_call, "server_auth_metadata");
   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;
+  // 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,
+                                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 = arg;
+  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;
   if (error == GRPC_ERROR_NONE) {
     if (chand->creds != NULL && chand->creds->processor.process != NULL) {
+      // 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");
+      GRPC_CLOSURE_INIT(&calld->cancel_closure, cancel_call, elem,
+                        grpc_schedule_on_exec_ctx);
+      grpc_call_combiner_set_notify_on_cancel(exec_ctx, calld->call_combiner,
+                                              &calld->cancel_closure);
+      GRPC_CALL_STACK_REF(calld->owning_call, "server_auth_metadata");
       calld->md = metadata_batch_to_md_array(
           batch->payload->recv_initial_metadata.recv_initial_metadata);
       chand->creds->processor.process(
@@ -159,6 +209,8 @@ static grpc_error *init_call_elem(grpc_exec_ctx *exec_ctx,
                                   const grpc_call_element_args *args) {
   call_data *calld = elem->call_data;
   channel_data *chand = elem->channel_data;
+  calld->call_combiner = args->call_combiner;
+  calld->owning_call = args->call_stack;
   GRPC_CLOSURE_INIT(&calld->recv_initial_metadata_ready,
                     recv_initial_metadata_ready, elem,
                     grpc_schedule_on_exec_ctx);
@@ -218,6 +270,5 @@ const grpc_channel_filter grpc_server_auth_filter = {
     sizeof(channel_data),
     init_channel_elem,
     destroy_channel_elem,
-    grpc_call_next_get_peer,
     grpc_channel_next_get_info,
     "server-auth"};

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

@@ -58,7 +58,7 @@ 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 = 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;
 }
@@ -75,7 +75,7 @@ size_t grpc_base64_estimate_encoded_size(size_t data_size, int url_safe,
 
 void grpc_base64_encode_core(char *result, const void *vdata, size_t data_size,
                              int url_safe, int multiline) {
-  const unsigned char *data = vdata;
+  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 =

data/src/core/lib/slice/slice.c

@@ -27,7 +27,7 @@
 #include "src/core/lib/iomgr/exec_ctx.h"
 
 char *grpc_slice_to_c_string(grpc_slice slice) {
-  char *out = gpr_malloc(GRPC_SLICE_LENGTH(slice) + 1);
+  char *out = (char *)gpr_malloc(GRPC_SLICE_LENGTH(slice) + 1);
   memcpy(out, GRPC_SLICE_START_PTR(slice), GRPC_SLICE_LENGTH(slice));
   out[GRPC_SLICE_LENGTH(slice)] = 0;
   return out;
@@ -105,12 +105,12 @@ typedef struct new_slice_refcount {
 } new_slice_refcount;
 
 static void new_slice_ref(void *p) {
-  new_slice_refcount *r = p;
+  new_slice_refcount *r = (new_slice_refcount *)p;
   gpr_ref(&r->refs);
 }
 
 static void new_slice_unref(grpc_exec_ctx *exec_ctx, void *p) {
-  new_slice_refcount *r = p;
+  new_slice_refcount *r = (new_slice_refcount *)p;
   if (gpr_unref(&r->refs)) {
     r->user_destroy(r->user_data);
     gpr_free(r);
@@ -125,7 +125,8 @@ grpc_slice grpc_slice_new_with_user_data(void *p, size_t len,
                                          void (*destroy)(void *),
                                          void *user_data) {
   grpc_slice slice;
-  new_slice_refcount *rc = gpr_malloc(sizeof(new_slice_refcount));
+  new_slice_refcount *rc =
+      (new_slice_refcount *)gpr_malloc(sizeof(new_slice_refcount));
   gpr_ref_init(&rc->refs, 1);
   rc->rc.vtable = &new_slice_vtable;
   rc->rc.sub_refcount = &rc->rc;
@@ -133,7 +134,7 @@ grpc_slice grpc_slice_new_with_user_data(void *p, size_t len,
   rc->user_data = user_data;
 
   slice.refcount = &rc->rc;
-  slice.data.refcounted.bytes = p;
+  slice.data.refcounted.bytes = (uint8_t *)p;
   slice.data.refcounted.length = len;
   return slice;
 }
@@ -154,12 +155,12 @@ typedef struct new_with_len_slice_refcount {
 } new_with_len_slice_refcount;
 
 static void new_with_len_ref(void *p) {
-  new_with_len_slice_refcount *r = p;
+  new_with_len_slice_refcount *r = (new_with_len_slice_refcount *)p;
   gpr_ref(&r->refs);
 }
 
 static void new_with_len_unref(grpc_exec_ctx *exec_ctx, void *p) {
-  new_with_len_slice_refcount *r = p;
+  new_with_len_slice_refcount *r = (new_with_len_slice_refcount *)p;
   if (gpr_unref(&r->refs)) {
     r->user_destroy(r->user_data, r->user_length);
     gpr_free(r);
@@ -173,8 +174,8 @@ static const grpc_slice_refcount_vtable new_with_len_vtable = {
 grpc_slice grpc_slice_new_with_len(void *p, size_t len,
                                    void (*destroy)(void *, size_t)) {
   grpc_slice slice;
-  new_with_len_slice_refcount *rc =
-      gpr_malloc(sizeof(new_with_len_slice_refcount));
+  new_with_len_slice_refcount *rc = (new_with_len_slice_refcount *)gpr_malloc(
+      sizeof(new_with_len_slice_refcount));
   gpr_ref_init(&rc->refs, 1);
   rc->rc.vtable = &new_with_len_vtable;
   rc->rc.sub_refcount = &rc->rc;
@@ -183,7 +184,7 @@ grpc_slice grpc_slice_new_with_len(void *p, size_t len,
   rc->user_length = len;
 
   slice.refcount = &rc->rc;
-  slice.data.refcounted.bytes = p;
+  slice.data.refcounted.bytes = (uint8_t *)p;
   slice.data.refcounted.length = len;
   return slice;
 }
@@ -205,12 +206,12 @@ typedef struct {
 } malloc_refcount;
 
 static void malloc_ref(void *p) {
-  malloc_refcount *r = p;
+  malloc_refcount *r = (malloc_refcount *)p;
   gpr_ref(&r->refs);
 }
 
 static void malloc_unref(grpc_exec_ctx *exec_ctx, void *p) {
-  malloc_refcount *r = p;
+  malloc_refcount *r = (malloc_refcount *)p;
   if (gpr_unref(&r->refs)) {
     gpr_free(r);
   }
@@ -232,7 +233,8 @@ grpc_slice grpc_slice_malloc_large(size_t length) {
      refcount is a malloc_refcount
      bytes is an array of bytes of the requested length
      Both parts are placed in the same allocation returned from gpr_malloc */
-  malloc_refcount *rc = gpr_malloc(sizeof(malloc_refcount) + length);
+  malloc_refcount *rc =
+      (malloc_refcount *)gpr_malloc(sizeof(malloc_refcount) + length);
 
   /* Initial refcount on rc is 1 - and it's up to the caller to release
      this reference. */
@@ -451,7 +453,7 @@ int grpc_slice_rchr(grpc_slice s, char c) {
 
 int grpc_slice_chr(grpc_slice s, char c) {
   const char *b = (const char *)GRPC_SLICE_START_PTR(s);
-  const char *p = memchr(b, c, GRPC_SLICE_LENGTH(s));
+  const char *p = (const char *)memchr(b, c, GRPC_SLICE_LENGTH(s));
   return p == NULL ? -1 : (int)(p - b);
 }
 

data/src/core/lib/slice/slice_buffer.c

@@ -45,11 +45,12 @@ static void maybe_embiggen(grpc_slice_buffer *sb) {
       sb->capacity = GROW(sb->capacity);
       GPR_ASSERT(sb->capacity > slice_count);
       if (sb->base_slices == sb->inlined) {
-        sb->base_slices = gpr_malloc(sb->capacity * sizeof(grpc_slice));
+        sb->base_slices =
+            (grpc_slice *)gpr_malloc(sb->capacity * sizeof(grpc_slice));
         memcpy(sb->base_slices, sb->inlined, slice_count * sizeof(grpc_slice));
       } else {
-        sb->base_slices =
-            gpr_realloc(sb->base_slices, sb->capacity * sizeof(grpc_slice));
+        sb->base_slices = (grpc_slice *)gpr_realloc(
+            sb->base_slices, sb->capacity * sizeof(grpc_slice));
       }
 
       sb->slices = sb->base_slices + slice_offset;
@@ -291,7 +292,7 @@ void grpc_slice_buffer_move_first_no_ref(grpc_slice_buffer *src, size_t n,
 void grpc_slice_buffer_move_first_into_buffer(grpc_exec_ctx *exec_ctx,
                                               grpc_slice_buffer *src, size_t n,
                                               void *dst) {
-  char *dstp = dst;
+  char *dstp = (char *)dst;
   GPR_ASSERT(src->length >= n);
 
   while (n > 0) {

data/src/core/lib/slice/slice_hash_table.c

@@ -60,14 +60,15 @@ grpc_slice_hash_table* grpc_slice_hash_table_create(
     size_t num_entries, grpc_slice_hash_table_entry* entries,
     void (*destroy_value)(grpc_exec_ctx* exec_ctx, void* value),
     int (*value_cmp)(void* a, void* b)) {
-  grpc_slice_hash_table* table = gpr_zalloc(sizeof(*table));
+  grpc_slice_hash_table* table =
+      (grpc_slice_hash_table*)gpr_zalloc(sizeof(*table));
   gpr_ref_init(&table->refs, 1);
   table->destroy_value = destroy_value;
   table->value_cmp = value_cmp;
   // Keep load factor low to improve performance of lookups.
   table->size = num_entries * 2;
   const size_t entry_size = sizeof(grpc_slice_hash_table_entry) * table->size;
-  table->entries = gpr_zalloc(entry_size);
+  table->entries = (grpc_slice_hash_table_entry*)gpr_zalloc(entry_size);
   for (size_t i = 0; i < num_entries; ++i) {
     grpc_slice_hash_table_entry* entry = &entries[i];
     grpc_slice_hash_table_add(table, entry->key, entry->value);

data/src/core/lib/slice/slice_intern.c

@@ -69,7 +69,7 @@ static uint32_t max_static_metadata_hash_probe;
 static uint32_t static_metadata_hash_values[GRPC_STATIC_MDSTR_COUNT];
 
 static void interned_slice_ref(void *p) {
-  interned_slice_refcount *s = p;
+  interned_slice_refcount *s = (interned_slice_refcount *)p;
   GPR_ASSERT(gpr_atm_no_barrier_fetch_add(&s->refcnt, 1) > 0);
 }
 
@@ -90,7 +90,7 @@ static void interned_slice_destroy(interned_slice_refcount *s) {
 }
 
 static void interned_slice_unref(grpc_exec_ctx *exec_ctx, void *p) {
-  interned_slice_refcount *s = p;
+  interned_slice_refcount *s = (interned_slice_refcount *)p;
   if (1 == gpr_atm_full_fetch_add(&s->refcnt, -1)) {
     interned_slice_destroy(s);
   }
@@ -129,7 +129,8 @@ static void grow_shard(slice_shard *shard) {
 
   GPR_TIMER_BEGIN("grow_strtab", 0);
 
-  strtab = gpr_zalloc(sizeof(interned_slice_refcount *) * capacity);
+  strtab = (interned_slice_refcount **)gpr_zalloc(
+      sizeof(interned_slice_refcount *) * capacity);
 
   for (i = 0; i < shard->capacity; i++) {
     for (s = shard->strs[i]; s; s = next) {
@@ -242,7 +243,8 @@ grpc_slice grpc_slice_intern(grpc_slice slice) {
 
   /* not found: create a new string */
   /* string data goes after the internal_string header */
-  s = gpr_malloc(sizeof(*s) + GRPC_SLICE_LENGTH(slice));
+  s = (interned_slice_refcount *)gpr_malloc(sizeof(*s) +
+                                            GRPC_SLICE_LENGTH(slice));
   gpr_atm_rel_store(&s->refcnt, 1);
   s->length = GRPC_SLICE_LENGTH(slice);
   s->hash = hash;
@@ -280,7 +282,8 @@ void grpc_slice_intern_init(void) {
     gpr_mu_init(&shard->mu);
     shard->count = 0;
     shard->capacity = INITIAL_SHARD_CAPACITY;
-    shard->strs = gpr_zalloc(sizeof(*shard->strs) * shard->capacity);
+    shard->strs = (interned_slice_refcount **)gpr_zalloc(sizeof(*shard->strs) *
+                                                         shard->capacity);
   }
   for (size_t i = 0; i < GPR_ARRAY_SIZE(static_metadata_hash); i++) {
     static_metadata_hash[i].hash = 0;

data/src/core/lib/support/block_annotate.h

@@ -19,15 +19,37 @@
 #ifndef GRPC_CORE_LIB_SUPPORT_BLOCK_ANNOTATE_H
 #define GRPC_CORE_LIB_SUPPORT_BLOCK_ANNOTATE_H
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void gpr_thd_start_blocking_region();
+void gpr_thd_end_blocking_region();
+
+#ifdef __cplusplus
+}
+#endif
+
 /* These annotations identify the beginning and end of regions where
    the code may block for reasons other than synchronization functions.
    These include poll, epoll, and getaddrinfo. */
 
+#ifdef GRPC_SCHEDULING_MARK_BLOCKING_REGION
+#define GRPC_SCHEDULING_START_BLOCKING_REGION \
+  do {                                        \
+    gpr_thd_start_blocking_region();          \
+  } while (0)
+#define GRPC_SCHEDULING_END_BLOCKING_REGION \
+  do {                                      \
+    gpr_thd_end_blocking_region();          \
+  } while (0)
+#else
 #define GRPC_SCHEDULING_START_BLOCKING_REGION \
   do {                                        \
   } while (0)
 #define GRPC_SCHEDULING_END_BLOCKING_REGION \
   do {                                      \
   } while (0)
+#endif
 
 #endif /* GRPC_CORE_LIB_SUPPORT_BLOCK_ANNOTATE_H */

data/src/core/lib/support/fork.c

@@ -0,0 +1,62 @@
+/*
+ *
+ * Copyright 2017 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include "src/core/lib/support/fork.h"
+
+#include <string.h>
+
+#include <grpc/support/alloc.h>
+#include <grpc/support/useful.h>
+
+#include "src/core/lib/support/env.h"
+
+/*
+ * NOTE: FORKING IS NOT GENERALLY SUPPORTED, THIS IS ONLY INTENDED TO WORK
+ *       AROUND VERY SPECIFIC USE CASES.
+ */
+
+static int override_fork_support_enabled = -1;
+static int fork_support_enabled;
+
+void grpc_fork_support_init() {
+#ifdef GRPC_ENABLE_FORK_SUPPORT
+  fork_support_enabled = 1;
+#else
+  fork_support_enabled = 0;
+  char *env = gpr_getenv("GRPC_ENABLE_FORK_SUPPORT");
+  if (env != NULL) {
+    static const char *truthy[] = {"yes",  "Yes",  "YES", "true",
+                                   "True", "TRUE", "1"};
+    for (size_t i = 0; i < GPR_ARRAY_SIZE(truthy); i++) {
+      if (0 == strcmp(env, truthy[i])) {
+        fork_support_enabled = 1;
+      }
+    }
+    gpr_free(env);
+  }
+#endif
+  if (override_fork_support_enabled != -1) {
+    fork_support_enabled = override_fork_support_enabled;
+  }
+}
+
+int grpc_fork_support_enabled() { return fork_support_enabled; }
+
+void grpc_enable_fork_support(int enable) {
+  override_fork_support_enabled = enable;
+}