Merge github.com:grpc/grpc into we-dont-need-no-backup

Conflicts:
	test/core/bad_client/bad_client.c
	test/core/httpcli/httpcli_test.c

build.json

@@ -1353,7 +1353,6 @@
     {
       "name": "httpcli_test",
       "build": "test",
-      "run": false,
       "language": "c",
       "src": [
         "test/core/httpcli/httpcli_test.c"

src/core/httpcli/httpcli.c

@@ -62,6 +62,7 @@ typedef struct {
   void *user_data;
   grpc_httpcli_context *context;
   grpc_pollset *pollset;
+  grpc_iomgr_object iomgr_obj;
 } internal_request;
 
 static grpc_httpcli_get_override g_get_override = NULL;
@@ -89,6 +90,7 @@ static void finish(internal_request *req, int success) {
   }
   gpr_slice_unref(req->request_text);
   gpr_free(req->host);
+  grpc_iomgr_unregister_object(&req->iomgr_obj);
   gpr_free(req);
 }
 
@@ -230,6 +232,7 @@ void grpc_httpcli_get(grpc_httpcli_context *context, grpc_pollset *pollset,
                       gpr_timespec deadline,
                       grpc_httpcli_response_cb on_response, void *user_data) {
   internal_request *req;
+  char *name;
   if (g_get_override &&
       g_get_override(request, deadline, on_response, user_data)) {
     return;
@@ -244,6 +247,9 @@ void grpc_httpcli_get(grpc_httpcli_context *context, grpc_pollset *pollset,
   req->use_ssl = request->use_ssl;
   req->context = context;
   req->pollset = pollset;
+  gpr_asprintf(&name, "HTTP:GET:%s:%s", request->host, request->path);
+  grpc_iomgr_register_object(&req->iomgr_obj, name);
+  gpr_free(name);
   if (req->use_ssl) {
     req->host = gpr_strdup(request->host);
   }
@@ -259,6 +265,7 @@ void grpc_httpcli_post(grpc_httpcli_context *context, grpc_pollset *pollset,
                        gpr_timespec deadline,
                        grpc_httpcli_response_cb on_response, void *user_data) {
   internal_request *req;
+  char *name;
   if (g_post_override && g_post_override(request, body_bytes, body_size,
                                          deadline, on_response, user_data)) {
     return;
@@ -274,10 +281,14 @@ void grpc_httpcli_post(grpc_httpcli_context *context, grpc_pollset *pollset,
   req->use_ssl = request->use_ssl;
   req->context = context;
   req->pollset = pollset;
+  gpr_asprintf(&name, "HTTP:GET:%s:%s", request->host, request->path);
+  grpc_iomgr_register_object(&req->iomgr_obj, name);
+  gpr_free(name);
   if (req->use_ssl) {
     req->host = gpr_strdup(request->host);
   }
 
+  grpc_pollset_set_add_pollset(&req->context->pollset_set, req->pollset);
   grpc_resolve_address(request->host, req->use_ssl ? "https" : "http",
                        on_resolved, req);
 }

src/core/transport/chttp2_transport.c

@@ -1588,12 +1588,21 @@ static int init_goaway_parser(transport *t) {
 }
 
 static int init_settings_frame_parser(transport *t) {
-  int ok = GRPC_CHTTP2_PARSE_OK ==
+  int ok;
+
+  if (t->incoming_stream_id != 0) {
+    gpr_log(GPR_ERROR, "settings frame received for stream %d", t->incoming_stream_id);
+    drop_connection(t);
+    return 0;
+  }
+
+  ok = GRPC_CHTTP2_PARSE_OK ==
            grpc_chttp2_settings_parser_begin_frame(
                &t->simple_parsers.settings, t->incoming_frame_size,
                t->incoming_frame_flags, t->settings[PEER_SETTINGS]);
   if (!ok) {
     drop_connection(t);
+    return 0;
   }
   if (t->incoming_frame_flags & GRPC_CHTTP2_FLAG_ACK) {
     memcpy(t->settings[ACKED_SETTINGS], t->settings[SENT_SETTINGS],

test/core/bad_client/bad_client.c

@@ -38,6 +38,7 @@
 #include "src/core/iomgr/endpoint_pair.h"
 #include "src/core/surface/completion_queue.h"
 #include "src/core/surface/server.h"
+#include "src/core/support/string.h"
 #include "src/core/transport/chttp2_transport.h"
 
 #include <grpc/support/sync.h>
@@ -72,17 +73,21 @@ static grpc_transport_setup_result server_setup_transport(
                                      grpc_server_get_channel_args(a->server));
 }
 
-void grpc_run_bad_client_test(const char *name, const char *client_payload,
-                              size_t client_payload_length,
-                              grpc_bad_client_server_side_validator validator) {
+void grpc_run_bad_client_test(grpc_bad_client_server_side_validator validator,
+                              const char *client_payload,
+                              size_t client_payload_length, gpr_uint32 flags) {
   grpc_endpoint_pair sfd;
   thd_args a;
   gpr_thd_id id;
+  char *hex;
   gpr_slice slice =
       gpr_slice_from_copied_buffer(client_payload, client_payload_length);
 
+  hex =
+      gpr_hexdump(client_payload, client_payload_length, GPR_HEXDUMP_PLAINTEXT);
+
   /* Add a debug log */
-  gpr_log(GPR_INFO, "TEST: %s", name);
+  gpr_log(GPR_INFO, "TEST: %s", hex);
 
   /* Init grpc */
   grpc_init();
@@ -126,10 +131,18 @@ void grpc_run_bad_client_test(const char *name, const char *client_payload,
   /* Await completion */
   GPR_ASSERT(
       gpr_event_wait(&a.done_write, GRPC_TIMEOUT_SECONDS_TO_DEADLINE(5)));
+
+  if (flags & GRPC_BAD_CLIENT_DISCONNECT) {
+    grpc_endpoint_destroy(sfd.client);
+    sfd.client = NULL;
+  }
+
   GPR_ASSERT(gpr_event_wait(&a.done_thd, GRPC_TIMEOUT_SECONDS_TO_DEADLINE(5)));
 
   /* Shutdown */
-  grpc_endpoint_destroy(sfd.client);
+  if (sfd.client) {
+    grpc_endpoint_destroy(sfd.client);
+  }
   grpc_server_shutdown_and_notify(a.server, a.cq, NULL);
   GPR_ASSERT(grpc_completion_queue_pluck(a.cq, NULL,
                                          GRPC_TIMEOUT_SECONDS_TO_DEADLINE(1))

test/core/bad_client/bad_client.h

@@ -40,13 +40,18 @@
 typedef void (*grpc_bad_client_server_side_validator)(
     grpc_server *server, grpc_completion_queue *cq);
 
+#define GRPC_BAD_CLIENT_DISCONNECT 1
+
 /* Test runner.
 
    Create a server, and send client_payload to it as bytes from a client.
    Execute validator in a separate thread to assert that the bytes are
    handled as expected. */
-void grpc_run_bad_client_test(const char *name, const char *client_payload,
-                              size_t client_payload_length,
-                              grpc_bad_client_server_side_validator validator);
+void grpc_run_bad_client_test(grpc_bad_client_server_side_validator validator,
+                              const char *client_payload,
+                              size_t client_payload_length, gpr_uint32 flags);
+
+#define GRPC_RUN_BAD_CLIENT_TEST(validator, payload, flags) \
+  grpc_run_bad_client_test(validator, payload, sizeof(payload) - 1, flags)
 
 #endif /* GRPC_TEST_CORE_BAD_CLIENT_BAD_CLIENT_H */

test/core/bad_client/gen_build_json.py

@@ -41,6 +41,7 @@ default_test_options = TestOptions(False)
 # maps test names to options
 BAD_CLIENT_TESTS = {
     'connection_prefix': default_test_options,
+    'initial_settings_frame': default_test_options,
 }
 
 def main():

test/core/bad_client/tests/connection_prefix.c

@@ -36,44 +36,38 @@
 
 static void verifier(grpc_server *server, grpc_completion_queue *cq) {
   while (grpc_server_has_open_connections(server)) {
-    GPR_ASSERT(grpc_completion_queue_next(
-                   cq, GRPC_TIMEOUT_MILLIS_TO_DEADLINE(20)).type ==
-               GRPC_QUEUE_TIMEOUT);
+    GPR_ASSERT(
+        grpc_completion_queue_next(cq, GRPC_TIMEOUT_MILLIS_TO_DEADLINE(20))
+            .type == GRPC_QUEUE_TIMEOUT);
   }
 }
 
 int main(int argc, char **argv) {
   grpc_test_init(argc, argv);
 
-  grpc_run_bad_client_test("conpfx_1", "X", 1, verifier);
-  grpc_run_bad_client_test("conpfx_2", "PX", 2, verifier);
-  grpc_run_bad_client_test("conpfx_3", "PRX", 3, verifier);
-  grpc_run_bad_client_test("conpfx_4", "PRIX", 4, verifier);
-  grpc_run_bad_client_test("conpfx_5", "PRI X", 5, verifier);
-  grpc_run_bad_client_test("conpfx_6", "PRI *X", 6, verifier);
-  grpc_run_bad_client_test("conpfx_7", "PRI * X", 7, verifier);
-  grpc_run_bad_client_test("conpfx_8", "PRI * HX", 8, verifier);
-  grpc_run_bad_client_test("conpfx_9", "PRI * HTX", 9, verifier);
-  grpc_run_bad_client_test("conpfx_10", "PRI * HTTX", 10, verifier);
-  grpc_run_bad_client_test("conpfx_11", "PRI * HTTPX", 11, verifier);
-  grpc_run_bad_client_test("conpfx_12", "PRI * HTTP/X", 12, verifier);
-  grpc_run_bad_client_test("conpfx_13", "PRI * HTTP/2X", 13, verifier);
-  grpc_run_bad_client_test("conpfx_14", "PRI * HTTP/2.X", 14, verifier);
-  grpc_run_bad_client_test("conpfx_15", "PRI * HTTP/2.0X", 15, verifier);
-  grpc_run_bad_client_test("conpfx_16", "PRI * HTTP/2.0\rX", 16, verifier);
-  grpc_run_bad_client_test("conpfx_17", "PRI * HTTP/2.0\r\nX", 17, verifier);
-  grpc_run_bad_client_test("conpfx_18", "PRI * HTTP/2.0\r\n\rX", 18, verifier);
-  grpc_run_bad_client_test("conpfx_19", "PRI * HTTP/2.0\r\n\r\nX", 19,
-                           verifier);
-  grpc_run_bad_client_test("conpfx_20", "PRI * HTTP/2.0\r\n\r\nSX", 20,
-                           verifier);
-  grpc_run_bad_client_test("conpfx_21", "PRI * HTTP/2.0\r\n\r\nSMX", 21,
-                           verifier);
-  grpc_run_bad_client_test("conpfx_22", "PRI * HTTP/2.0\r\n\r\nSM\rX", 22,
-                           verifier);
-  grpc_run_bad_client_test("conpfx_23", "PRI * HTTP/2.0\r\n\r\nSM\r\nX", 23,
-                           verifier);
-  grpc_run_bad_client_test("conpfx_24", "PRI * HTTP/2.0\r\n\r\nSM\r\n\rX", 24,
-                           verifier);
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, "X", 0);
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, "PX", 0);
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, "PRX", 0);
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, "PRIX", 0);
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, "PRI X", 0);
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, "PRI *X", 0);
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, "PRI * X", 0);
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, "PRI * HX", 0);
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, "PRI * HTX", 0);
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, "PRI * HTTX", 0);
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, "PRI * HTTPX", 0);
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, "PRI * HTTP/X", 0);
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, "PRI * HTTP/2X", 0);
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, "PRI * HTTP/2.X", 0);
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, "PRI * HTTP/2.0X", 0);
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, "PRI * HTTP/2.0\rX", 0);
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, "PRI * HTTP/2.0\r\nX", 0);
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, "PRI * HTTP/2.0\r\n\rX", 0);
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, "PRI * HTTP/2.0\r\n\r\nX", 0);
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, "PRI * HTTP/2.0\r\n\r\nSX", 0);
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, "PRI * HTTP/2.0\r\n\r\nSMX", 0);
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, "PRI * HTTP/2.0\r\n\r\nSM\rX", 0);
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, "PRI * HTTP/2.0\r\n\r\nSM\r\nX", 0);
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, "PRI * HTTP/2.0\r\n\r\nSM\r\n\rX", 0);
   return 0;
 }

test/core/bad_client/tests/initial_settings_frame.c

@@ -0,0 +1,95 @@
+/*
+ *
+ * Copyright 2015, 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 "test/core/bad_client/bad_client.h"
+#include "src/core/surface/server.h"
+
+#define PFX_STR "PRI * HTTP/2.0\r\n\r\nSM\r\n\r\n"
+
+static void verifier(grpc_server *server, grpc_completion_queue *cq) {
+  while (grpc_server_has_open_connections(server)) {
+    GPR_ASSERT(
+        grpc_completion_queue_next(cq, GRPC_TIMEOUT_MILLIS_TO_DEADLINE(20))
+            .type == GRPC_QUEUE_TIMEOUT);
+  }
+}
+
+int main(int argc, char **argv) {
+  grpc_test_init(argc, argv);
+
+  /* various partial prefixes */
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, PFX_STR "\x00",
+                           GRPC_BAD_CLIENT_DISCONNECT);
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, PFX_STR "\x00\x00",
+                           GRPC_BAD_CLIENT_DISCONNECT);
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, PFX_STR "\x00\x00\x00",
+                           GRPC_BAD_CLIENT_DISCONNECT);
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, PFX_STR "\x06",
+                           GRPC_BAD_CLIENT_DISCONNECT);
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, PFX_STR "\x00\x06",
+                           GRPC_BAD_CLIENT_DISCONNECT);
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, PFX_STR "\x00\x00\x06",
+                           GRPC_BAD_CLIENT_DISCONNECT);
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, PFX_STR "\x00\x00\x00\x04",
+                           GRPC_BAD_CLIENT_DISCONNECT);
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, PFX_STR "\x00\x00\x00\x04\x00",
+                           GRPC_BAD_CLIENT_DISCONNECT);
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, PFX_STR "\x00\x00\x00\x04\x01",
+                           GRPC_BAD_CLIENT_DISCONNECT);
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, PFX_STR "\x00\x00\x00\x04\xff",
+                           GRPC_BAD_CLIENT_DISCONNECT);
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, PFX_STR "\x00\x00\x00\x04\x00\x00",
+                           GRPC_BAD_CLIENT_DISCONNECT);
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, PFX_STR "\x00\x00\x00\x04\x00\x00\x00",
+                           GRPC_BAD_CLIENT_DISCONNECT);
+  GRPC_RUN_BAD_CLIENT_TEST(verifier, PFX_STR "\x00\x00\x00\x04\x00\x00\x00\x00",
+                           GRPC_BAD_CLIENT_DISCONNECT);
+  /* must not send frames with stream id != 0 */
+  GRPC_RUN_BAD_CLIENT_TEST(verifier,
+                           PFX_STR "\x00\x00\x00\x04\x00\x00\x00\x00\x01", 0);
+  GRPC_RUN_BAD_CLIENT_TEST(verifier,
+                           PFX_STR "\x00\x00\x00\x04\x00\x40\x00\x00\x00", 0);
+  /* settings frame must be a multiple of six bytes long */
+  GRPC_RUN_BAD_CLIENT_TEST(verifier,
+                           PFX_STR "\x00\x00\x01\x04\x00\x00\x00\x00\x00", 0);
+  GRPC_RUN_BAD_CLIENT_TEST(verifier,
+                           PFX_STR "\x00\x00\x02\x04\x00\x00\x00\x00\x00", 0);
+  GRPC_RUN_BAD_CLIENT_TEST(verifier,
+                           PFX_STR "\x00\x00\x03\x04\x00\x00\x00\x00\x00", 0);
+  GRPC_RUN_BAD_CLIENT_TEST(verifier,
+                           PFX_STR "\x00\x00\x04\x04\x00\x00\x00\x00\x00", 0);
+  GRPC_RUN_BAD_CLIENT_TEST(verifier,
+                           PFX_STR "\x00\x00\x05\x04\x00\x00\x00\x00\x00", 0);
+
+  return 0;
+}

test/core/httpcli/httpcli_test.c

@@ -35,12 +35,16 @@
 
 #include <string.h>
 
+#include <grpc/grpc.h>
 #include "src/core/iomgr/iomgr.h"
+#include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
+#include <grpc/support/string_util.h>
+#include <grpc/support/subprocess.h>
 #include <grpc/support/sync.h>
+#include "test/core/util/port.h"
 #include "test/core/util/test_config.h"
 
-static gpr_mu g_mu;
 static int g_done = 0;
 static grpc_httpcli_context g_context;
 static grpc_pollset g_pollset;
@@ -50,69 +54,114 @@ static gpr_timespec n_seconds_time(int seconds) {
 }
 
 static void on_finish(void *arg, const grpc_httpcli_response *response) {
+  const char *expect = 
+      "<html><head><title>Hello world!</title></head>"
+      "<body><p>This is a test</p></body></html>";
   GPR_ASSERT(arg == (void *)42);
   GPR_ASSERT(response);
   GPR_ASSERT(response->status == 200);
-  gpr_mu_lock(&g_mu);
+  GPR_ASSERT(response->body_length == strlen(expect));
+  GPR_ASSERT(0 == memcmp(expect, response->body, response->body_length));
+  gpr_mu_lock(GRPC_POLLSET_MU(&g_pollset));
   g_done = 1;
-  gpr_mu_unlock(&g_mu);
+  grpc_pollset_kick(&g_pollset);
+  gpr_mu_unlock(GRPC_POLLSET_MU(&g_pollset));
 }
 
-static void test_get(int use_ssl) {
+static void test_get(int use_ssl, int port) {
   grpc_httpcli_request req;
+  char* host;
 
   g_done = 0;
   gpr_log(GPR_INFO, "running %s with use_ssl=%d.", "test_get", use_ssl);
 
+  gpr_asprintf(&host, "localhost:%d", port);
+  gpr_log(GPR_INFO, "requesting from %s", host);
+
   memset(&req, 0, sizeof(req));
-  req.host = "www.google.com";
-  req.path = "/";
+  req.host = host;
+  req.path = "/get";
   req.use_ssl = use_ssl;
 
   grpc_httpcli_get(&g_context, &g_pollset, &req, n_seconds_time(15), on_finish,
                    (void *)42);
-  gpr_mu_lock(&g_mu);
+  gpr_mu_lock(GRPC_POLLSET_MU(&g_pollset));
   while (!g_done) {
     grpc_pollset_work(&g_pollset, n_seconds_time(20));
   }
-  gpr_mu_unlock(&g_mu);
+  gpr_mu_unlock(GRPC_POLLSET_MU(&g_pollset));
+  gpr_free(host);
 }
 
-/*
-static void test_post(int use_ssl) {
+static void test_post(int use_ssl, int port) {
   grpc_httpcli_request req;
+  char* host;
 
+  g_done = 0;
   gpr_log(GPR_INFO, "running %s with use_ssl=%d.", "test_post", (int)use_ssl);
 
-  gpr_event_init(&g_done);
+  gpr_asprintf(&host, "localhost:%d", port);
+  gpr_log(GPR_INFO, "posting to %s", host);
+
   memset(&req, 0, sizeof(req));
-  req.host = "requestb.in";
-  req.path = "/1eamwr21";
+  req.host = host;
+  req.path = "/post";
   req.use_ssl = use_ssl;
 
-  grpc_httpcli_post(&req, NULL, 0, n_seconds_time(15), on_finish,
+  grpc_httpcli_post(&g_context, &g_pollset, &req, "hello", 5, n_seconds_time(15), on_finish,
                     (void *)42);
-  GPR_ASSERT(gpr_event_wait(&g_done, n_seconds_time(20)));
+  gpr_mu_lock(GRPC_POLLSET_MU(&g_pollset));
+  while (!g_done) {
+    grpc_pollset_work(&g_pollset, n_seconds_time(20));
+  }
+  gpr_mu_unlock(GRPC_POLLSET_MU(&g_pollset));
+  gpr_free(host);
+}
+
+static void destroy_pollset(void* ignored) {
+  grpc_pollset_destroy(&g_pollset);
 }
-*/
 
 int main(int argc, char **argv) {
+  gpr_subprocess* server;
+  char *me = argv[0];
+  char *lslash = strrchr(me, '/');
+  char* args[4];
+  char root[1024];
+  int port = grpc_pick_unused_port_or_die();
+
+  /* figure out where we are */
+  if (lslash) {
+    memcpy(root, me, lslash - me);
+    root[lslash - me] = 0;
+  } else {
+    strcpy(root, ".");
+  }
+
+  /* start the server */
+  gpr_asprintf(&args[0], "%s/../../test/core/httpcli/test_server.py", root);
+  args[1] = "--port";
+  gpr_asprintf(&args[2], "%d", port);
+  server = gpr_subprocess_create(3, (const char**)args);
+  GPR_ASSERT(server);
+  gpr_free(args[0]);
+  gpr_free(args[2]);
+
+  gpr_sleep_until(gpr_time_add(gpr_now(), gpr_time_from_seconds(5)));
+
   grpc_test_init(argc, argv);
-  grpc_iomgr_init();
+  grpc_init();
   grpc_httpcli_context_init(&g_context);
   grpc_pollset_init(&g_pollset);
-  gpr_mu_init(&g_mu);
-
-  test_get(0);
-  test_get(1);
 
-  /* test_post(0); */
-  /* test_post(1); */
+  test_get(0, port);
+  test_post(0, port);
 
   grpc_httpcli_context_destroy(&g_context);
-  grpc_pollset_destroy(&g_pollset);
-  grpc_iomgr_shutdown();
-  gpr_mu_destroy(&g_mu);
+  grpc_pollset_shutdown(&g_pollset, destroy_pollset, NULL);
+  grpc_shutdown();
+
+  gpr_subprocess_destroy(server);
 
   return 0;
 }

test/core/httpcli/test_server.py

@@ -0,0 +1,31 @@
+#!/usr/bin/env python
+
+"""Server for httpcli_test"""
+
+import argparse
+import BaseHTTPServer
+
+argp = argparse.ArgumentParser(description='Server for httpcli_test')
+argp.add_argument('-p', '--port', default=10080, type=int)
+args = argp.parse_args()
+
+print 'server running on port %d' % args.port
+
+class Handler(BaseHTTPServer.BaseHTTPRequestHandler):
+	def good(self):
+		self.send_response(200)
+		self.send_header('Content-Type', 'text/html')
+		self.end_headers()
+		self.wfile.write('<html><head><title>Hello world!</title></head>')
+		self.wfile.write('<body><p>This is a test</p></body></html>')
+
+	def do_GET(self):
+		if self.path == '/get':
+			self.good()
+
+	def do_POST(self):
+		content = self.rfile.read(int(self.headers.getheader('content-length')))
+		if self.path == '/post' and content == 'hello':
+			self.good()
+
+BaseHTTPServer.HTTPServer(('', args.port), Handler).serve_forever()

tools/run_tests/tests.json

@@ -348,6 +348,15 @@
       "posix"
     ]
   }, 
+  {
+    "flaky": false, 
+    "language": "c", 
+    "name": "httpcli_test", 
+    "platforms": [
+      "windows", 
+      "posix"
+    ]
+  }, 
   {
     "flaky": false, 
     "language": "c", 
@@ -4673,6 +4682,15 @@
       "windows", 
       "posix"
     ]
+  }, 
+  {
+    "flaky": false, 
+    "language": "c", 
+    "name": "initial_settings_frame_bad_client_test", 
+    "platforms": [
+      "windows", 
+      "posix"
+    ]
   }
 ]