Merge github.com:grpc/grpc into optionalize_resolvers

12 files changed, 462 insertions, 1 deletions

diff --git a/test/core/client_config/resolvers/sockaddr_resolver_test.c b/test/core/client_config/resolvers/sockaddr_resolver_test.c
index 3ce98cebf3..b2c4c63b79 100644
--- a/test/core/client_config/resolvers/sockaddr_resolver_test.c
+++ b/test/core/client_config/resolvers/sockaddr_resolver_test.c
@@ -97,6 +97,7 @@ int main(int argc, char **argv) {
 
   test_fails(ipv4, "ipv4:10.2.1.1");
   test_succeeds(ipv4, "ipv4:10.2.1.1:1234");
+  test_succeeds(ipv4, "ipv4:10.2.1.1:1234,127.0.0.1:4321");
   test_fails(ipv4, "ipv4:10.2.1.1:123456");
   test_fails(ipv4, "ipv4:www.google.com");
   test_fails(ipv4, "ipv4:[");
diff --git a/test/core/client_config/uri_parser_test.c b/test/core/client_config/uri_parser_test.c
index e5d0c378ba..f87aa81ee6 100644
--- a/test/core/client_config/uri_parser_test.c
+++ b/test/core/client_config/uri_parser_test.c
@@ -56,6 +56,73 @@ static void test_fails(const char *uri_text) {
   GPR_ASSERT(NULL == grpc_uri_parse(uri_text, 0));
 }
 
+static void test_query_parts() {
+  {
+    const char *uri_text = "http://foo/path?a&b=B&c=&#frag";
+    grpc_uri *uri = grpc_uri_parse(uri_text, 0);
+    GPR_ASSERT(uri);
+
+    GPR_ASSERT(0 == strcmp("http", uri->scheme));
+    GPR_ASSERT(0 == strcmp("foo", uri->authority));
+    GPR_ASSERT(0 == strcmp("/path", uri->path));
+    GPR_ASSERT(0 == strcmp("a&b=B&c=&", uri->query));
+    GPR_ASSERT(4 == uri->num_query_parts);
+
+    GPR_ASSERT(0 == strcmp("a", uri->query_parts[0]));
+    GPR_ASSERT(NULL == uri->query_parts_values[0]);
+
+    GPR_ASSERT(0 == strcmp("b", uri->query_parts[1]));
+    GPR_ASSERT(0 == strcmp("B", uri->query_parts_values[1]));
+
+    GPR_ASSERT(0 == strcmp("c", uri->query_parts[2]));
+    GPR_ASSERT(0 == strcmp("", uri->query_parts_values[2]));
+
+    GPR_ASSERT(0 == strcmp("", uri->query_parts[3]));
+    GPR_ASSERT(NULL == uri->query_parts_values[3]);
+
+    GPR_ASSERT(NULL == grpc_uri_get_query_arg(uri, "a"));
+    GPR_ASSERT(0 == strcmp("B", grpc_uri_get_query_arg(uri, "b")));
+    GPR_ASSERT(0 == strcmp("", grpc_uri_get_query_arg(uri, "c")));
+    GPR_ASSERT(NULL == grpc_uri_get_query_arg(uri, ""));
+
+    GPR_ASSERT(0 == strcmp("frag", uri->fragment));
+    grpc_uri_destroy(uri);
+  }
+  {
+    /* test the current behavior of multiple query part values */
+    const char *uri_text = "http://auth/path?foo=bar=baz&foobar==";
+    grpc_uri *uri = grpc_uri_parse(uri_text, 0);
+    GPR_ASSERT(uri);
+
+    GPR_ASSERT(0 == strcmp("http", uri->scheme));
+    GPR_ASSERT(0 == strcmp("auth", uri->authority));
+    GPR_ASSERT(0 == strcmp("/path", uri->path));
+    GPR_ASSERT(0 == strcmp("foo=bar=baz&foobar==", uri->query));
+    GPR_ASSERT(2 == uri->num_query_parts);
+
+    GPR_ASSERT(0 == strcmp("bar", grpc_uri_get_query_arg(uri, "foo")));
+    GPR_ASSERT(0 == strcmp("", grpc_uri_get_query_arg(uri, "foobar")));
+
+    grpc_uri_destroy(uri);
+  }
+  {
+    /* empty query */
+    const char *uri_text = "http://foo/path";
+    grpc_uri *uri = grpc_uri_parse(uri_text, 0);
+    GPR_ASSERT(uri);
+
+    GPR_ASSERT(0 == strcmp("http", uri->scheme));
+    GPR_ASSERT(0 == strcmp("foo", uri->authority));
+    GPR_ASSERT(0 == strcmp("/path", uri->path));
+    GPR_ASSERT(0 == strcmp("", uri->query));
+    GPR_ASSERT(0 == uri->num_query_parts);
+    GPR_ASSERT(NULL == uri->query_parts);
+    GPR_ASSERT(NULL == uri->query_parts_values);
+    GPR_ASSERT(0 == strcmp("", uri->fragment));
+    grpc_uri_destroy(uri);
+  }
+}
+
 int main(int argc, char **argv) {
   grpc_test_init(argc, argv);
   test_succeeds("http://www.google.com", "http", "www.google.com", "", "", "");
@@ -82,5 +149,6 @@ int main(int argc, char **argv) {
   test_fails("http://foo?x[bar]");
   test_fails("http://foo?bar#lol#");
 
+  test_query_parts();
   return 0;
 }
diff --git a/test/core/end2end/goaway_server_test.c b/test/core/end2end/goaway_server_test.c
new file mode 100644
index 0000000000..5f8c2641e7
--- /dev/null
+++ b/test/core/end2end/goaway_server_test.c
@@ -0,0 +1,301 @@
+/*
+ *
+ * Copyright 2016, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include <grpc/grpc.h>
+#include <grpc/support/alloc.h>
+#include <grpc/support/log.h>
+#include <grpc/support/string_util.h>
+#include <string.h>
+#include "src/core/lib/iomgr/resolve_address.h"
+#include "src/core/lib/iomgr/sockaddr.h"
+#include "test/core/end2end/cq_verifier.h"
+#include "test/core/util/port.h"
+#include "test/core/util/test_config.h"
+
+static void *tag(intptr_t i) { return (void *)i; }
+
+static gpr_mu g_mu;
+static int g_resolve_port = -1;
+static grpc_resolved_addresses *(*iomgr_resolve_address)(
+    const char *name, const char *default_port);
+
+static void set_resolve_port(int port) {
+  gpr_mu_lock(&g_mu);
+  g_resolve_port = port;
+  gpr_mu_unlock(&g_mu);
+}
+
+static grpc_resolved_addresses *my_resolve_address(const char *name,
+                                                   const char *addr) {
+  if (0 != strcmp(name, "test")) {
+    return iomgr_resolve_address(name, addr);
+  }
+
+  gpr_mu_lock(&g_mu);
+  if (g_resolve_port < 0) {
+    gpr_mu_unlock(&g_mu);
+    return NULL;
+  } else {
+    grpc_resolved_addresses *addrs = gpr_malloc(sizeof(*addrs));
+    addrs->naddrs = 1;
+    addrs->addrs = gpr_malloc(sizeof(*addrs->addrs));
+    memset(addrs->addrs, 0, sizeof(*addrs->addrs));
+    struct sockaddr_in *sa = (struct sockaddr_in *)addrs->addrs[0].addr;
+    sa->sin_family = AF_INET;
+    sa->sin_addr.s_addr = htonl(0x7f000001);
+    sa->sin_port = htons((uint16_t)g_resolve_port);
+    addrs->addrs[0].len = sizeof(*sa);
+    gpr_mu_unlock(&g_mu);
+    return addrs;
+  }
+}
+
+int main(int argc, char **argv) {
+  grpc_completion_queue *cq;
+  cq_verifier *cqv;
+  grpc_op ops[6];
+  grpc_op *op;
+
+  grpc_test_init(argc, argv);
+
+  gpr_mu_init(&g_mu);
+  iomgr_resolve_address = grpc_blocking_resolve_address;
+  grpc_blocking_resolve_address = my_resolve_address;
+  grpc_init();
+
+  int was_cancelled1;
+  int was_cancelled2;
+
+  grpc_metadata_array trailing_metadata_recv1;
+  grpc_metadata_array request_metadata1;
+  grpc_call_details request_details1;
+  grpc_status_code status1;
+  char *details1 = NULL;
+  size_t details_capacity1 = 0;
+  grpc_metadata_array_init(&trailing_metadata_recv1);
+  grpc_metadata_array_init(&request_metadata1);
+  grpc_call_details_init(&request_details1);
+
+  grpc_metadata_array trailing_metadata_recv2;
+  grpc_metadata_array request_metadata2;
+  grpc_call_details request_details2;
+  grpc_status_code status2;
+  char *details2 = NULL;
+  size_t details_capacity2 = 0;
+  grpc_metadata_array_init(&trailing_metadata_recv2);
+  grpc_metadata_array_init(&request_metadata2);
+  grpc_call_details_init(&request_details2);
+
+  cq = grpc_completion_queue_create(NULL);
+  cqv = cq_verifier_create(cq);
+
+  /* reserve two ports */
+  int port1 = grpc_pick_unused_port_or_die();
+  int port2 = grpc_pick_unused_port_or_die();
+
+  char *addr;
+
+  /* create a channel that picks first amongst the servers */
+  grpc_channel *chan = grpc_insecure_channel_create("test", NULL, NULL);
+  /* and an initial call to them */
+  grpc_call *call1 = grpc_channel_create_call(
+      chan, NULL, GRPC_PROPAGATE_DEFAULTS, cq, "/foo", "127.0.0.1",
+      GRPC_TIMEOUT_SECONDS_TO_DEADLINE(20), NULL);
+  /* send initial metadata to probe connectivity */
+  op = ops;
+  op->op = GRPC_OP_SEND_INITIAL_METADATA;
+  op->data.send_initial_metadata.count = 0;
+  op->flags = 0;
+  op->reserved = NULL;
+  op++;
+  GPR_ASSERT(GRPC_CALL_OK == grpc_call_start_batch(call1, ops,
+                                                   (size_t)(op - ops),
+                                                   tag(0x101), NULL));
+  /* and receive status to probe termination */
+  op = ops;
+  op->op = GRPC_OP_RECV_STATUS_ON_CLIENT;
+  op->data.recv_status_on_client.trailing_metadata = &trailing_metadata_recv1;
+  op->data.recv_status_on_client.status = &status1;
+  op->data.recv_status_on_client.status_details = &details1;
+  op->data.recv_status_on_client.status_details_capacity = &details_capacity1;
+  op->flags = 0;
+  op->reserved = NULL;
+  op++;
+  GPR_ASSERT(GRPC_CALL_OK == grpc_call_start_batch(call1, ops,
+                                                   (size_t)(op - ops),
+                                                   tag(0x102), NULL));
+
+  /* bring a server up on the first port */
+  grpc_server *server1 = grpc_server_create(NULL, NULL);
+  gpr_asprintf(&addr, "127.0.0.1:%d", port1);
+  grpc_server_add_insecure_http2_port(server1, addr);
+  grpc_server_register_completion_queue(server1, cq, NULL);
+  gpr_free(addr);
+  grpc_server_start(server1);
+
+  /* request a call to the server */
+  grpc_call *server_call1;
+  GPR_ASSERT(GRPC_CALL_OK ==
+             grpc_server_request_call(server1, &server_call1, &request_details1,
+                                      &request_metadata1, cq, cq, tag(0x301)));
+
+  set_resolve_port(port1);
+
+  /* first call should now start */
+  cq_expect_completion(cqv, tag(0x101), 1);
+  cq_expect_completion(cqv, tag(0x301), 1);
+  cq_verify(cqv);
+
+  GPR_ASSERT(GRPC_CHANNEL_READY ==
+             grpc_channel_check_connectivity_state(chan, 0));
+  grpc_channel_watch_connectivity_state(chan, GRPC_CHANNEL_READY,
+                                        gpr_inf_future(GPR_CLOCK_REALTIME), cq,
+                                        tag(0x9999));
+
+  /* listen for close on the server call to probe for finishing */
+  op = ops;
+  op->op = GRPC_OP_RECV_CLOSE_ON_SERVER;
+  op->data.recv_close_on_server.cancelled = &was_cancelled1;
+  op->flags = 0;
+  op++;
+  GPR_ASSERT(GRPC_CALL_OK == grpc_call_start_batch(server_call1, ops,
+                                                   (size_t)(op - ops),
+                                                   tag(0x302), NULL));
+
+  /* shutdown first server:
+   * we should see a connectivity change and then nothing */
+  set_resolve_port(-1);
+  grpc_server_shutdown_and_notify(server1, cq, tag(0xdead1));
+  cq_expect_completion(cqv, tag(0x9999), 1);
+  cq_verify(cqv);
+  cq_verify_empty(cqv);
+
+  /* and a new call: should go through to server2 when we start it */
+  grpc_call *call2 = grpc_channel_create_call(
+      chan, NULL, GRPC_PROPAGATE_DEFAULTS, cq, "/foo", "127.0.0.1",
+      GRPC_TIMEOUT_SECONDS_TO_DEADLINE(20), NULL);
+  /* send initial metadata to probe connectivity */
+  op = ops;
+  op->op = GRPC_OP_SEND_INITIAL_METADATA;
+  op->data.send_initial_metadata.count = 0;
+  op->flags = 0;
+  op->reserved = NULL;
+  op++;
+  GPR_ASSERT(GRPC_CALL_OK == grpc_call_start_batch(call2, ops,
+                                                   (size_t)(op - ops),
+                                                   tag(0x201), NULL));
+  /* and receive status to probe termination */
+  op = ops;
+  op->op = GRPC_OP_RECV_STATUS_ON_CLIENT;
+  op->data.recv_status_on_client.trailing_metadata = &trailing_metadata_recv2;
+  op->data.recv_status_on_client.status = &status2;
+  op->data.recv_status_on_client.status_details = &details2;
+  op->data.recv_status_on_client.status_details_capacity = &details_capacity2;
+  op->flags = 0;
+  op->reserved = NULL;
+  op++;
+  GPR_ASSERT(GRPC_CALL_OK == grpc_call_start_batch(call2, ops,
+                                                   (size_t)(op - ops),
+                                                   tag(0x202), NULL));
+
+  /* and bring up second server */
+  set_resolve_port(port2);
+  grpc_server *server2 = grpc_server_create(NULL, NULL);
+  gpr_asprintf(&addr, "127.0.0.1:%d", port2);
+  grpc_server_add_insecure_http2_port(server2, addr);
+  grpc_server_register_completion_queue(server2, cq, NULL);
+  gpr_free(addr);
+  grpc_server_start(server2);
+
+  /* request a call to the server */
+  grpc_call *server_call2;
+  GPR_ASSERT(GRPC_CALL_OK ==
+             grpc_server_request_call(server2, &server_call2, &request_details2,
+                                      &request_metadata2, cq, cq, tag(0x401)));
+
+  /* second call should now start */
+  cq_expect_completion(cqv, tag(0x201), 1);
+  cq_expect_completion(cqv, tag(0x401), 1);
+  cq_verify(cqv);
+
+  /* listen for close on the server call to probe for finishing */
+  op = ops;
+  op->op = GRPC_OP_RECV_CLOSE_ON_SERVER;
+  op->data.recv_close_on_server.cancelled = &was_cancelled2;
+  op->flags = 0;
+  op++;
+  GPR_ASSERT(GRPC_CALL_OK == grpc_call_start_batch(server_call2, ops,
+                                                   (size_t)(op - ops),
+                                                   tag(0x402), NULL));
+
+  /* shutdown second server: we should see nothing */
+  grpc_server_shutdown_and_notify(server2, cq, tag(0xdead2));
+  cq_verify_empty(cqv);
+
+  grpc_call_cancel(call1, NULL);
+  grpc_call_cancel(call2, NULL);
+
+  /* now everything else should finish */
+  cq_expect_completion(cqv, tag(0x102), 1);
+  cq_expect_completion(cqv, tag(0x202), 1);
+  cq_expect_completion(cqv, tag(0x302), 1);
+  cq_expect_completion(cqv, tag(0x402), 1);
+  cq_expect_completion(cqv, tag(0xdead1), 1);
+  cq_expect_completion(cqv, tag(0xdead2), 1);
+  cq_verify(cqv);
+
+  grpc_call_destroy(call1);
+  grpc_call_destroy(call2);
+  grpc_call_destroy(server_call1);
+  grpc_call_destroy(server_call2);
+  grpc_server_destroy(server1);
+  grpc_server_destroy(server2);
+  grpc_channel_destroy(chan);
+
+  grpc_metadata_array_destroy(&trailing_metadata_recv1);
+  grpc_metadata_array_destroy(&request_metadata1);
+  grpc_call_details_destroy(&request_details1);
+  gpr_free(details1);
+  grpc_metadata_array_destroy(&trailing_metadata_recv2);
+  grpc_metadata_array_destroy(&request_metadata2);
+  grpc_call_details_destroy(&request_details2);
+  gpr_free(details2);
+
+  cq_verifier_destroy(cqv);
+  grpc_completion_queue_destroy(cq);
+
+  grpc_shutdown();
+  gpr_mu_destroy(&g_mu);
+
+  return 0;
+}
diff --git a/test/core/json/corpus/15a8f2e7f94aa00b46f1b991416aa015dd633580 b/test/core/json/corpus/15a8f2e7f94aa00b46f1b991416aa015dd633580
new file mode 100644
index 0000000000..7e613e891d
--- /dev/null
+++ b/test/core/json/corpus/15a8f2e7f94aa00b46f1b991416aa015dd633580
@@ -0,0 +1 @@
+{"":21}
\ No newline at end of file
diff --git a/test/core/json/corpus/56cd60743c2cee939f5f357905bd36ec9363f441 b/test/core/json/corpus/56cd60743c2cee939f5f357905bd36ec9363f441
new file mode 100644
index 0000000000..8d53a05e08
--- /dev/null
+++ b/test/core/json/corpus/56cd60743c2cee939f5f357905bd36ec9363f441
@@ -0,0 +1 @@
+{"":21]
\ No newline at end of file
diff --git a/test/core/json/corpus/743e89b768af4bd591ea7228118550b1bfb8e7d1 b/test/core/json/corpus/743e89b768af4bd591ea7228118550b1bfb8e7d1
new file mode 100644
index 0000000000..b232065b09
--- /dev/null
+++ b/test/core/json/corpus/743e89b768af4bd591ea7228118550b1bfb8e7d1
@@ -0,0 +1 @@
+{"":0}f'+G{)13(§!(''\!
\ No newline at end of file
diff --git a/test/core/json/corpus/775e8ffda1f5d340dba472d06dc7c8bf8159e379 b/test/core/json/corpus/775e8ffda1f5d340dba472d06dc7c8bf8159e379
new file mode 100644
index 0000000000..6f56d403bb
--- /dev/null
+++ b/test/core/json/corpus/775e8ffda1f5d340dba472d06dc7c8bf8159e379
@@ -0,0 +1 @@
+{"":0},f'+G{)23(§!''!
\ No newline at end of file
diff --git a/test/core/json/corpus/8d952ec2e33b2a6a1c7876898719a610f5546388 b/test/core/json/corpus/8d952ec2e33b2a6a1c7876898719a610f5546388
new file mode 100644
index 0000000000..fb7475be91
--- /dev/null
+++ b/test/core/json/corpus/8d952ec2e33b2a6a1c7876898719a610f5546388
@@ -0,0 +1 @@
+{"":0]f'+G{)13(§!(''\!
\ No newline at end of file
diff --git a/test/core/json/corpus/a0d4af29c6c223b48fe34d6a09b3a7466242f33c b/test/core/json/corpus/a0d4af29c6c223b48fe34d6a09b3a7466242f33c
new file mode 100644
index 0000000000..db616e9f56
--- /dev/null
+++ b/test/core/json/corpus/a0d4af29c6c223b48fe34d6a09b3a7466242f33c
@@ -0,0 +1 @@
+{"":0],f'`+G{-22(§!''!
\ No newline at end of file
diff --git a/test/core/json/fuzzer.c b/test/core/json/fuzzer.c
index a7b9e49878..044db973ab 100644
--- a/test/core/json/fuzzer.c
+++ b/test/core/json/fuzzer.c
@@ -35,16 +35,53 @@
 #include <string.h>
 
 #include <grpc/support/alloc.h>
+#include <grpc/support/log.h>
 
 #include "src/core/lib/json/json.h"
 
+static size_t g_total_size = 0;
+static gpr_allocation_functions g_old_allocs;
+
+void *guard_malloc(size_t size) {
+  size_t *ptr;
+  g_total_size += size;
+  ptr = g_old_allocs.malloc_fn(size + sizeof(size));
+  *ptr++ = size;
+  return ptr;
+}
+
+void *guard_realloc(void *vptr, size_t size) {
+  size_t *ptr = vptr;
+  --ptr;
+  g_total_size -= *ptr;
+  ptr = g_old_allocs.realloc_fn(ptr, size + sizeof(size));
+  g_total_size += size;
+  *ptr++ = size;
+  return ptr;
+}
+
+void guard_free(void *vptr) {
+  size_t *ptr = vptr;
+  --ptr;
+  g_total_size -= *ptr;
+  g_old_allocs.free_fn(ptr);
+}
+
+struct gpr_allocation_functions g_guard_allocs = {guard_malloc, guard_realloc,
+                                                  guard_free};
+
 int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
-  char *s = gpr_malloc(size);
+  char *s;
+  g_old_allocs = gpr_get_allocation_functions();
+  gpr_set_allocation_functions(g_guard_allocs);
+  s = gpr_malloc(size);
   memcpy(s, data, size);
   grpc_json *x;
   if ((x = grpc_json_parse_string_with_len(s, size))) {
     grpc_json_destroy(x);
   }
   gpr_free(s);
+  gpr_set_allocation_functions(g_old_allocs);
+  GPR_ASSERT(g_total_size == 0);
   return 0;
 }
diff --git a/test/core/json/json_test.c b/test/core/json/json_test.c
index 9775779e3b..ac1abbd8f3 100644
--- a/test/core/json/json_test.c
+++ b/test/core/json/json_test.c
@@ -89,6 +89,8 @@ static testing_pair testing_pairs[] = {
     {"{\"foo\": bar}", NULL},
     {"{\"foo\": bar\"x\"}", NULL},
     {"fals", NULL},
+    {"0,0 ", NULL},
+    {"\"foo\",[]", NULL},
     /* Testing unterminated string. */
     {"\"\\x", NULL},
     /* Testing invalid UTF-16 number. */
diff --git a/test/core/util/one_corpus_entry_fuzzer.c b/test/core/util/one_corpus_entry_fuzzer.c
new file mode 100644
index 0000000000..41f9558211
--- /dev/null
+++ b/test/core/util/one_corpus_entry_fuzzer.c
@@ -0,0 +1,46 @@
+/*
+ *
+ * Copyright 2016, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include <grpc/support/log.h>
+#include "src/core/lib/support/load_file.h"
+
+extern int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size);
+
+int main(int argc, char **argv) {
+  int ok = 0;
+  gpr_slice buffer = gpr_load_file(argv[1], 0, &ok);
+  GPR_ASSERT(ok);
+  LLVMFuzzerTestOneInput(GPR_SLICE_START_PTR(buffer), GPR_SLICE_LENGTH(buffer));
+  gpr_slice_unref(buffer);
+  return 0;
+}