Merge branch 'vjpai-poisson' into poisson

.travis.yml

@@ -2,13 +2,19 @@ language: cpp
 before_install:
   - sudo add-apt-repository ppa:yjwong/gflags -y
   - sudo add-apt-repository ppa:h-rayflood/llvm -y
+  - sudo apt-key adv --keyserver keyserver.ubuntu.com --recv-keys 3FA7E0328081BFF6A14DA29AA6A19B38D3D831EF
+  - echo "deb http://download.mono-project.com/repo/debian wheezy main" | sudo tee /etc/apt/sources.list.d/mono-xamarin.list
+  - echo "deb http://download.mono-project.com/repo/debian wheezy-libtiff-compat main" | sudo tee -a /etc/apt/sources.list.d/mono-xamarin.list
   - sudo apt-get update -qq
   - sudo apt-get install -qq libgtest-dev libgflags-dev python-virtualenv clang-3.5
   - sudo pip install cpp-coveralls mako simplejson
+  - sudo apt-get install -qq mono-devel nunit
+  - wget www.nuget.org/NuGet.exe -O nuget.exe
 env:
   global:
     - RUBY_VERSION=2.1
     - COVERALLS_PARALLEL=true
+    - NUGET="mono nuget.exe"
   matrix:
     - CONFIG=opt TEST=sanity
     - CONFIG=dbg TEST=c
@@ -18,6 +24,7 @@ env:
     - CONFIG=opt TEST=node
     - CONFIG=opt TEST=ruby
     - CONFIG=opt TEST=python
+    - CONFIG=opt TEST=csharp
     - CONFIG=gcov TEST=c
     - CONFIG=gcov TEST=c++
     - USE_GCC=4.4 CONFIG=opt TEST=build

BUILD

@@ -1,5 +1,7 @@
 # GRPC Bazel BUILD file.
 # This currently builds C and C++ code.
+# This file has been automatically generated from a template file.
+# Please look at the templates directory instead.
 
 # Copyright 2015, Google Inc.
 # All rights reserved.
@@ -124,7 +126,7 @@ cc_library(
   srcs = [
     "src/core/httpcli/format_request.h",
     "src/core/httpcli/httpcli.h",
-    "src/core/httpcli/httpcli_security_context.h",
+    "src/core/httpcli/httpcli_security_connector.h",
     "src/core/httpcli/parser.h",
     "src/core/security/auth.h",
     "src/core/security/base64.h",
@@ -132,7 +134,7 @@ cc_library(
     "src/core/security/json_token.h",
     "src/core/security/secure_endpoint.h",
     "src/core/security/secure_transport_setup.h",
-    "src/core/security/security_context.h",
+    "src/core/security/security_connector.h",
     "src/core/tsi/fake_transport_security.h",
     "src/core/tsi/ssl_transport_security.h",
     "src/core/tsi/transport_security.h",
@@ -147,7 +149,6 @@ cc_library(
     "src/core/channel/http_client_filter.h",
     "src/core/channel/http_filter.h",
     "src/core/channel/http_server_filter.h",
-    "src/core/channel/metadata_buffer.h",
     "src/core/channel/noop_filter.h",
     "src/core/compression/algorithm.h",
     "src/core/compression/message_compress.h",
@@ -228,19 +229,18 @@ cc_library(
     "src/core/transport/transport_impl.h",
     "src/core/httpcli/format_request.c",
     "src/core/httpcli/httpcli.c",
-    "src/core/httpcli/httpcli_security_context.c",
+    "src/core/httpcli/httpcli_security_connector.c",
     "src/core/httpcli/parser.c",
     "src/core/security/auth.c",
     "src/core/security/base64.c",
     "src/core/security/credentials.c",
     "src/core/security/credentials_posix.c",
     "src/core/security/credentials_win32.c",
-    "src/core/security/factories.c",
     "src/core/security/google_default_credentials.c",
     "src/core/security/json_token.c",
     "src/core/security/secure_endpoint.c",
     "src/core/security/secure_transport_setup.c",
-    "src/core/security/security_context.c",
+    "src/core/security/security_connector.c",
     "src/core/security/server_secure_chttp2.c",
     "src/core/surface/init_secure.c",
     "src/core/surface/secure_channel_create.c",
@@ -258,7 +258,6 @@ cc_library(
     "src/core/channel/http_client_filter.c",
     "src/core/channel/http_filter.c",
     "src/core/channel/http_server_filter.c",
-    "src/core/channel/metadata_buffer.c",
     "src/core/channel/noop_filter.c",
     "src/core/compression/algorithm.c",
     "src/core/compression/message_compress.c",
@@ -378,7 +377,6 @@ cc_library(
     "src/core/channel/http_client_filter.h",
     "src/core/channel/http_filter.h",
     "src/core/channel/http_server_filter.h",
-    "src/core/channel/metadata_buffer.h",
     "src/core/channel/noop_filter.h",
     "src/core/compression/algorithm.h",
     "src/core/compression/message_compress.h",
@@ -469,7 +467,6 @@ cc_library(
     "src/core/channel/http_client_filter.c",
     "src/core/channel/http_filter.c",
     "src/core/channel/http_server_filter.c",
-    "src/core/channel/metadata_buffer.c",
     "src/core/channel/noop_filter.c",
     "src/core/compression/algorithm.c",
     "src/core/compression/message_compress.c",
@@ -582,7 +579,6 @@ cc_library(
     "src/cpp/client/channel.h",
     "src/cpp/proto/proto_utils.h",
     "src/cpp/server/thread_pool.h",
-    "src/cpp/util/time.h",
     "src/cpp/client/secure_credentials.cc",
     "src/cpp/server/secure_server_credentials.cc",
     "src/cpp/client/channel.cc",
@@ -624,6 +620,7 @@ cc_library(
     "include/grpc++/generic_stub.h",
     "include/grpc++/impl/call.h",
     "include/grpc++/impl/client_unary_call.h",
+    "include/grpc++/impl/grpc_library.h",
     "include/grpc++/impl/internal_stub.h",
     "include/grpc++/impl/rpc_method.h",
     "include/grpc++/impl/rpc_service_method.h",
@@ -643,6 +640,7 @@ cc_library(
     "include/grpc++/status_code_enum.h",
     "include/grpc++/stream.h",
     "include/grpc++/thread_pool_interface.h",
+    "include/grpc++/time.h",
   ],
   includes = [
     "include",
@@ -662,7 +660,6 @@ cc_library(
     "src/cpp/client/channel.h",
     "src/cpp/proto/proto_utils.h",
     "src/cpp/server/thread_pool.h",
-    "src/cpp/util/time.h",
     "src/cpp/client/channel.cc",
     "src/cpp/client/channel_arguments.cc",
     "src/cpp/client/client_context.cc",
@@ -702,6 +699,7 @@ cc_library(
     "include/grpc++/generic_stub.h",
     "include/grpc++/impl/call.h",
     "include/grpc++/impl/client_unary_call.h",
+    "include/grpc++/impl/grpc_library.h",
     "include/grpc++/impl/internal_stub.h",
     "include/grpc++/impl/rpc_method.h",
     "include/grpc++/impl/rpc_service_method.h",
@@ -721,6 +719,7 @@ cc_library(
     "include/grpc++/status_code_enum.h",
     "include/grpc++/stream.h",
     "include/grpc++/thread_pool_interface.h",
+    "include/grpc++/time.h",
   ],
   includes = [
     "include",

CONTRIBUTING.md

@@ -51,3 +51,4 @@ re-generate the project files using the following command:
 
 `./tools/buildgen/generate_projects.sh`
 
+You'll find more information about this in the [templates](templates) folder.

build.json

@@ -1,4 +1,7 @@
 {
+  "#1": "This file describes the list of targets and dependencies.",
+  "#2": "It is used among other things to generate all of our project files.",
+  "#3": "Please refer to the templates directory for more information.",
   "settings": {
     "#": "The public version number of the library.",
     "version": {
@@ -25,6 +28,7 @@
         "include/grpc++/generic_stub.h",
         "include/grpc++/impl/call.h",
         "include/grpc++/impl/client_unary_call.h",
+        "include/grpc++/impl/grpc_library.h",
         "include/grpc++/impl/internal_stub.h",
         "include/grpc++/impl/rpc_method.h",
         "include/grpc++/impl/rpc_service_method.h",
@@ -43,13 +47,13 @@
         "include/grpc++/status.h",
         "include/grpc++/status_code_enum.h",
         "include/grpc++/stream.h",
-        "include/grpc++/thread_pool_interface.h"
+        "include/grpc++/thread_pool_interface.h",
+        "include/grpc++/time.h"
       ],
       "headers": [
         "src/cpp/client/channel.h",
         "src/cpp/proto/proto_utils.h",
-        "src/cpp/server/thread_pool.h",
-        "src/cpp/util/time.h"
+        "src/cpp/server/thread_pool.h"
       ],
       "src": [
         "src/cpp/client/channel.cc",
@@ -98,7 +102,6 @@
         "src/core/channel/http_client_filter.h",
         "src/core/channel/http_filter.h",
         "src/core/channel/http_server_filter.h",
-        "src/core/channel/metadata_buffer.h",
         "src/core/channel/noop_filter.h",
         "src/core/compression/algorithm.h",
         "src/core/compression/message_compress.h",
@@ -190,7 +193,6 @@
         "src/core/channel/http_client_filter.c",
         "src/core/channel/http_filter.c",
         "src/core/channel/http_server_filter.c",
-        "src/core/channel/metadata_buffer.c",
         "src/core/channel/noop_filter.c",
         "src/core/compression/algorithm.c",
         "src/core/compression/message_compress.c",
@@ -278,6 +280,19 @@
         "src/core/transport/stream_op.c",
         "src/core/transport/transport.c"
       ]
+    },
+    {
+      "name": "grpc_test_util_base",
+      "src": [
+        "test/core/end2end/cq_verifier.c",
+        "test/core/iomgr/endpoint_tests.c",
+        "test/core/statistics/census_log_tests.c",
+        "test/core/util/grpc_profiler.c",
+        "test/core/util/parse_hexstring.c",
+        "test/core/util/port_posix.c",
+        "test/core/util/port_windows.c",
+        "test/core/util/slice_splitter.c"
+      ]
     }
   ],
   "libs": [
@@ -374,6 +389,7 @@
       "deps": [
         "gpr"
       ],
+      "secure": "no",
       "vs_project_guid": "{EAB0A629-17A9-44DB-B5FF-E91A721FE037}"
     },
     {
@@ -386,7 +402,7 @@
       "headers": [
         "src/core/httpcli/format_request.h",
         "src/core/httpcli/httpcli.h",
-        "src/core/httpcli/httpcli_security_context.h",
+        "src/core/httpcli/httpcli_security_connector.h",
         "src/core/httpcli/parser.h",
         "src/core/security/auth.h",
         "src/core/security/base64.h",
@@ -394,7 +410,7 @@
         "src/core/security/json_token.h",
         "src/core/security/secure_endpoint.h",
         "src/core/security/secure_transport_setup.h",
-        "src/core/security/security_context.h",
+        "src/core/security/security_connector.h",
         "src/core/tsi/fake_transport_security.h",
         "src/core/tsi/ssl_transport_security.h",
         "src/core/tsi/transport_security.h",
@@ -403,19 +419,18 @@
       "src": [
         "src/core/httpcli/format_request.c",
         "src/core/httpcli/httpcli.c",
-        "src/core/httpcli/httpcli_security_context.c",
+        "src/core/httpcli/httpcli_security_connector.c",
         "src/core/httpcli/parser.c",
         "src/core/security/auth.c",
         "src/core/security/base64.c",
         "src/core/security/credentials.c",
         "src/core/security/credentials_posix.c",
         "src/core/security/credentials_win32.c",
-        "src/core/security/factories.c",
         "src/core/security/google_default_credentials.c",
         "src/core/security/json_token.c",
         "src/core/security/secure_endpoint.c",
         "src/core/security/secure_transport_setup.c",
-        "src/core/security/security_context.c",
+        "src/core/security/security_connector.c",
         "src/core/security/server_secure_chttp2.c",
         "src/core/surface/init_secure.c",
         "src/core/surface/secure_channel_create.c",
@@ -438,26 +453,35 @@
       "build": "private",
       "language": "c",
       "src": [
-        "test/core/end2end/cq_verifier.c",
         "test/core/end2end/data/server1_cert.c",
         "test/core/end2end/data/server1_key.c",
-        "test/core/end2end/data/test_root_cert.c",
-        "test/core/iomgr/endpoint_tests.c",
-        "test/core/statistics/census_log_tests.c",
-        "test/core/transport/transport_end2end_tests.c",
-        "test/core/util/grpc_profiler.c",
-        "test/core/util/parse_hexstring.c",
-        "test/core/util/port_posix.c",
-        "test/core/util/port_windows.c",
-        "test/core/util/slice_splitter.c"
+        "test/core/end2end/data/test_root_cert.c"
       ],
       "deps": [
         "gpr",
         "gpr_test_util",
         "grpc"
       ],
+      "filegroups": [
+        "grpc_test_util_base"
+      ],
       "vs_project_guid": "{17BCAFC0-5FDC-4C94-AEB9-95F3E220614B}"
     },
+    {
+      "name": "grpc_test_util_unsecure",
+      "build": "private",
+      "language": "c",
+      "deps": [
+        "gpr",
+        "gpr_test_util",
+        "grpc"
+      ],
+      "filegroups": [
+        "grpc_test_util_base"
+      ],
+      "secure": "no",
+      "vs_project_guid": "{0A7E7F92-FDEA-40F1-A9EC-3BA484F98BBF}"
+    },
     {
       "name": "grpc_unsecure",
       "build": "all",
@@ -666,6 +690,10 @@
         "test/cpp/qps/server_async.cc",
         "test/cpp/qps/server_sync.cc",
         "test/cpp/qps/timer.cc"
+      ],
+      "deps": [
+        "grpc_test_util",
+        "grpc++_test_util"
       ]
     },
     {
@@ -784,6 +812,7 @@
     },
     {
       "name": "census_statistics_multiple_writers_test",
+      "flaky": true,
       "build": "test",
       "language": "c",
       "src": [
@@ -798,6 +827,7 @@
     },
     {
       "name": "census_statistics_performance_test",
+      "flaky": true,
       "build": "test",
       "language": "c",
       "src": [
@@ -812,6 +842,7 @@
     },
     {
       "name": "census_statistics_quick_test",
+      "flaky": true,
       "build": "test",
       "language": "c",
       "src": [
@@ -937,20 +968,6 @@
         "gpr"
       ]
     },
-    {
-      "name": "chttp2_transport_end2end_test",
-      "build": "test",
-      "language": "c",
-      "src": [
-        "test/core/transport/chttp2_transport_end2end_test.c"
-      ],
-      "deps": [
-        "grpc_test_util",
-        "grpc",
-        "gpr_test_util",
-        "gpr"
-      ]
-    },
     {
       "name": "dualstack_socket_test",
       "build": "test",
@@ -1585,20 +1602,6 @@
         "gpr"
       ]
     },
-    {
-      "name": "metadata_buffer_test",
-      "build": "test",
-      "language": "c",
-      "src": [
-        "test/core/channel/metadata_buffer_test.c"
-      ],
-      "deps": [
-        "grpc_test_util",
-        "grpc",
-        "gpr_test_util",
-        "gpr"
-      ]
-    },
     {
       "name": "multi_init_test",
       "build": "test",

doc/interop-test-descriptions.md

@@ -2,7 +2,7 @@ Interoperability Test Case Descriptions
 =======================================
 
 Client and server use
-[test.proto](https://github.com/grpc/grpc/blob/master/test/cpp/interop/test.proto)
+[test.proto](https://github.com/grpc/grpc/blob/master/test/proto/test.proto)
 and the [gRPC over HTTP/2 v2
 protocol](https://github.com/grpc/grpc-common/blob/master/PROTOCOL-HTTP2.md).
 
@@ -30,6 +30,14 @@ Clients should accept these arguments:
     * Whether to replace platform root CAs with
       [ca.pem](https://github.com/grpc/grpc/blob/master/src/core/tsi/test_creds/ca.pem)
       as the CA root
+* --default_service_account=ACCOUNT_EMAIL
+    * Email of the GCE default service account. Only applicable
+      for compute_engine_creds test.
+* --oauth_scope=SCOPE
+    * OAuth scope. For example, "https://www.googleapis.com/auth/xapi.zoo"
+* --service_account_key_file=PATH
+    * The path to the service account JSON key file generated from GCE developer
+    console.
 
 Clients must support TLS with ALPN. Clients must not disable certificate
 checking.
@@ -259,25 +267,26 @@ Asserts:
 
 ### compute_engine_creds
 
-Status: Not yet implementable
-
 This test is only for cloud-to-prod path.
 
 This test verifies unary calls succeed in sending messages while using Service
 Credentials from GCE metadata server. The client instance needs to be created
 with desired oauth scope.
 
+The test uses `--default_service_account` with GCE service account email and
+`--oauth_scope` with the OAuth scope to use. For testing against
+grpc-test.sandbox.google.com, "https://www.googleapis.com/auth/xapi.zoo" should
+be passed in as `--oauth_scope`.
+
 Server features:
 * [UnaryCall][]
 * [Compressable Payload][]
-* SimpeResponse.username
-* SimpleResponse.oauth_scope
+* [Echo Authenticated Username][]
+* [Echo OAuth Scope][]
 
 Procedure:
- 1. Client sets flags default_service_account with GCE service account name and
-    oauth_scope with the oauth scope to use.
- 2. Client configures channel to use GCECredentials
- 3. Client calls UnaryCall on the channel with:
+ 1. Client configures channel to use GCECredentials
+ 2. Client calls UnaryCall on the channel with:
 
     ```
     {
@@ -293,32 +302,34 @@ Procedure:
 
 Asserts:
 * call was successful
-* received SimpleResponse.username equals FLAGS_default_service_account
-* received SimpleResponse.oauth_scope is in FLAGS_oauth_scope
+* received SimpleResponse.username equals the value of `--default_service_account` flag
+* received SimpleResponse.oauth_scope is in `--oauth_scope`
 * response payload body is 314159 bytes in size
 * clients are free to assert that the response payload body contents are zero
   and comparing the entire response message against a golden response
 
 ### service_account_creds
 
-Status: Not yet implementable
-
 This test is only for cloud-to-prod path.
 
 This test verifies unary calls succeed in sending messages while using JWT
 signing keys (redeemed for OAuth2 access tokens by the auth implementation)
 
+The test uses `--service_account_key_file` with the path to a json key file
+downloaded from https://console.developers.google.com, and `--oauth_scope`
+to the oauth scope. For testing against grpc-test.sandbox.google.com,
+"https://www.googleapis.com/auth/xapi.zoo" should be passed in
+as `--oauth_scope`.
+
 Server features:
 * [UnaryCall][]
 * [Compressable Payload][]
-* SimpleResponse.username
-* SimpleResponse.oauth_scope
+* [Echo Authenticated Username][]
+* [Echo OAuth Scope][]
 
 Procedure:
- 1. Client sets flags service_account_key_file with the path to json key file,
-    oauth_scope to the oauth scope.
- 2. Client configures the channel to use ServiceAccountCredentials.
- 3. Client calls UnaryCall with:
+ 1. Client configures the channel to use ServiceAccountCredentials.
+ 2. Client calls UnaryCall with:
 
     ```
     {
@@ -335,31 +346,32 @@ Procedure:
 Asserts:
 * call was successful
 * received SimpleResponse.username is in the json key file read from
-  FLAGS_service_account_key_file
-* received SimpleResponse.oauth_scope is in FLAGS_oauth_scope
+   `--service_account_key_file`
+* received SimpleResponse.oauth_scope is in `--oauth_scope`
 * response payload body is 314159 bytes in size
 * clients are free to assert that the response payload body contents are zero
   and comparing the entire response message against a golden response
 
 ### jwt_token_creds
 
-Status: Not yet implementable
-
 This test is only for cloud-to-prod path.
 
 This test verifies unary calls succeed in sending messages while using JWT
 token (created by the project's key file)
 
+Test caller should set flag `--service_account_key_file` with the
+path to json key file downloaded from
+https://console.developers.google.com.
+
 Server features:
 * [UnaryCall][]
 * [Compressable Payload][]
-* SimpleResponse.username
-* SimpleResponse.oauth_scope
+* [Echo Authenticated Username][]
+* [Echo OAuth Scope][]
 
 Procedure:
- 1. Client sets flags service_account_key_file with the path to json key file
- 2. Client configures the channel to use JWTTokenCredentials.
- 3. Client calls UnaryCall with:
+ 1. Client configures the channel to use JWTTokenCredentials.
+ 2. Client calls UnaryCall with:
 
     ```
     {
@@ -375,7 +387,7 @@ Procedure:
 Asserts:
 * call was successful
 * received SimpleResponse.username is in the json key file read from
-  FLAGS_service_account_key_file
+  `--service_account_key_file`
 * response payload body is 314159 bytes in size
 * clients are free to assert that the response payload body contents are zero
   and comparing the entire response message against a golden response
@@ -394,7 +406,8 @@ Server features:
   back to client in both header and trailer. (TODO: this is not defined)
 
 Procedure:
- 1. While sending custom metadata (ascii + binary) in the header, client calls UnaryCall with:
+ 1. While sending custom metadata (ascii + binary) in the header, client calls
+ UnaryCall with:
 
     ```
     {
@@ -619,11 +632,6 @@ payload body of size SimpleRequest.response_size bytes and type as appropriate
 for the SimpleRequest.response_type. If the server does not support the
 response_type, then it should fail the RPC with INVALID_ARGUMENT.
 
-If the request sets fill_username, the server should return the client username
-it sees in field SimpleResponse.username. If the request sets fill_oauth_scope,
-the server should return the oauth scope of the rpc in the form of "xapi_zoo"
-in field SimpleResponse.oauth_scope.
-
 ### StreamingInputCall
 [StreamingInputCall]: #streaminginputcall
 
@@ -672,14 +680,30 @@ Interaction with flow control is unspecified.
 
 Status: Pending
 
+#### Echo Authenticated Username
+[Echo Authenticated Username]: #echo-authenticated-username
+
 If a SimpleRequest has fill_username=true and that request was successfully
 authenticated, then the SimpleResponse should have username filled with the
 canonical form of the authenticated source. The canonical form is dependent on
 the authentication method, but is likely to be a base 10 integer identifier or
 an email address.
 
+#### Echo OAuth scope
+[Echo OAuth Scope]: #echo-oauth-scope
+
+If a SimpleRequest has fill_oauth_scope=true and that request was successfully
+authenticated via OAuth, then the SimpleResponse should have oauth_scope filled
+with the scope of the method being invoked.
+
+Although a general server-side feature, most test servers won't implement this
+feature. The TLS server grpc-test.sandbox.google.com:443 supports this feature.
+It requires at least the OAuth scope
+`https://www.googleapis.com/auth/xapi.zoo` for authentication to succeed.
+
 Discussion:
 
 Ideally, this would be communicated via metadata and not in the
 request/response, but we want to use this test in code paths that don't yet
 fully communicate metadata.
+

examples/pubsub/main.cc

@@ -31,7 +31,6 @@
  *
  */
 
-#include <chrono>
 #include <fstream>
 #include <memory>
 #include <sstream>
@@ -65,7 +64,6 @@ const char kMessageData[] = "Test Data";
 }  // namespace
 
 int main(int argc, char** argv) {
-  grpc_init();
   grpc::testing::InitTest(&argc, &argv, true);
   gpr_log(GPR_INFO, "Start PUBSUB client");
 
@@ -146,7 +144,5 @@ int main(int argc, char** argv) {
 
   subscriber.Shutdown();
   publisher.Shutdown();
-  channel.reset();
-  grpc_shutdown();
   return 0;
 }

examples/pubsub/publisher_test.cc

@@ -148,10 +148,8 @@ TEST_F(PublisherTest, TestPublisher) {
 
 int main(int argc, char** argv) {
   grpc_test_init(argc, argv);
-  grpc_init();
   ::testing::InitGoogleTest(&argc, argv);
   gpr_log(GPR_INFO, "Start test ...");
   int result = RUN_ALL_TESTS();
-  grpc_shutdown();
   return result;
 }

examples/pubsub/subscriber_test.cc

@@ -147,10 +147,8 @@ TEST_F(SubscriberTest, TestSubscriber) {
 
 int main(int argc, char** argv) {
   grpc_test_init(argc, argv);
-  grpc_init();
   ::testing::InitGoogleTest(&argc, argv);
   gpr_log(GPR_INFO, "Start test ...");
   int result = RUN_ALL_TESTS();
-  grpc_shutdown();
   return result;
 }

gRPC.podspec

@@ -0,0 +1,88 @@
+Pod::Spec.new do |s|
+  s.name     = 'gRPC'
+  s.version  = '0.0.1'
+  s.summary  = 'Generic gRPC client library for iOS'
+  s.homepage = 'https://www.grpc.io'
+  s.license  = 'New BSD'
+  s.authors  = { 'Jorge Canizales' => 'jcanizales@google.com' }
+
+  # s.source = { :git => 'https://github.com/grpc/grpc.git',  :tag => 'release-0_5_0' }
+
+  s.platform = :ios
+  s.ios.deployment_target = '6.0'
+  s.requires_arc = true
+
+  s.subspec 'RxLibrary' do |rs|
+    rs.summary  = 'Reactive Extensions library for iOS.'
+    rs.authors  = { 'Jorge Canizales' => 'jcanizales@google.com' }
+
+    rs.source_files = 'src/objective-c/RxLibrary/*.{h,m}', 'src/objective-c/RxLibrary/transformations/*.{h,m}', 'src/objective-c/RxLibrary/private/*.{h,m}'
+    rs.private_header_files = 'src/objective-c/RxLibrary/private/*.h'
+  end
+
+  s.subspec 'C-Core' do |cs|
+    cs.summary  = 'Core cross-platform gRPC library, written in C.'
+    cs.authors = { 'Craig Tiller'   => 'ctiller@google.com',
+                   'David Klempner' => 'klempner@google.com',
+                   'Nicolas Noble'  => 'nnoble@google.com',
+                   'Vijay Pai'      => 'vpai@google.com',
+                   'Yang Gao'       => 'yangg@google.com' }
+
+    cs.source_files = 'src/core/**/*.{h,c}', 'include/grpc/*.h', 'include/grpc/**/*.h'
+    cs.private_header_files = 'src/core/**/*.h'
+    cs.header_mappings_dir = '.'
+    cs.xcconfig = { 'HEADER_SEARCH_PATHS' => '"$(PODS_ROOT)/Headers/Build/gRPC" "$(PODS_ROOT)/Headers/Build/gRPC/include"' }
+
+    cs.requires_arc = false
+    cs.libraries = 'z'
+    cs.dependency 'OpenSSL', '~> 1.0.200'
+
+    # This is a workaround for Cocoapods Issue #1437.
+    # It renames time.h and string.h to grpc_time.h and grpc_string.h.
+    cs.prepare_command = <<-CMD
+      DIR_TIME="grpc/support"
+      BAD_TIME="$DIR_TIME/time.h"
+      GOOD_TIME="$DIR_TIME/grpc_time.h"
+      if [ -f "include/$BAD_TIME" ];
+      then
+        grep -rl "$BAD_TIME" include/grpc src/core | xargs sed -i '' -e s@$BAD_TIME@$GOOD_TIME@g
+        mv "include/$BAD_TIME" "include/$GOOD_TIME"
+      fi
+
+      DIR_STRING="src/core/support"
+      BAD_STRING="$DIR_STRING/string.h"
+      GOOD_STRING="$DIR_STRING/grpc_string.h"
+      if [ -f "$BAD_STRING" ];
+      then
+        grep -rl "$BAD_STRING" include/grpc src/core | xargs sed -i '' -e s@$BAD_STRING@$GOOD_STRING@g
+        mv "$BAD_STRING" "$GOOD_STRING"
+      fi
+    CMD
+  end
+
+  s.subspec 'GRPCClient' do |gs|
+    gs.summary = 'Objective-C wrapper around the core gRPC library.'
+    gs.authors  = { 'Jorge Canizales' => 'jcanizales@google.com' }
+
+    gs.source_files = 'src/objective-c/GRPCClient/*.{h,m}', 'src/objective-c/GRPCClient/private/*.{h,m}'
+    gs.private_header_files = 'src/objective-c/GRPCClient/private/*.h'
+
+    gs.dependency 'gRPC/C-Core'
+    # Is this needed in all dependents?
+    gs.xcconfig = { 'HEADER_SEARCH_PATHS' => '"$(PODS_ROOT)/Headers/Public/gRPC/include"' }
+    gs.dependency 'gRPC/RxLibrary'
+
+    # Certificates, to be able to establish TLS connections:
+    gs.resource_bundles = { 'gRPC' => ['etc/roots.pem'] }
+  end
+
+  s.subspec 'ProtoRPC' do |ps|
+    ps.summary  = 'RPC library for ProtocolBuffers, based on gRPC'
+    ps.authors  = { 'Jorge Canizales' => 'jcanizales@google.com' }
+
+    ps.source_files = 'src/objective-c/ProtoRPC/*.{h,m}'
+
+    ps.dependency 'gRPC/GRPCClient'
+    ps.dependency 'gRPC/RxLibrary'
+  end
+end

include/grpc++/client_context.h

@@ -34,15 +34,14 @@
 #ifndef GRPCXX_CLIENT_CONTEXT_H
 #define GRPCXX_CLIENT_CONTEXT_H
 
-#include <chrono>
 #include <map>
+#include <memory>
 #include <string>
 
 #include <grpc/support/log.h>
 #include <grpc/support/time.h>
 #include <grpc++/config.h>
-
-using std::chrono::system_clock;
+#include <grpc++/time.h>
 
 struct grpc_call;
 struct grpc_completion_queue;
@@ -87,8 +86,19 @@ class ClientContext {
     return trailing_metadata_;
   }
 
-  void set_absolute_deadline(const system_clock::time_point& deadline);
-  system_clock::time_point absolute_deadline();
+  template <typename T>
+  void set_deadline(const T& deadline) {
+    TimePoint<T> deadline_tp(deadline);
+    deadline_ = deadline_tp.raw_time();
+  }
+
+#ifndef GRPC_CXX0X_NO_CHRONO
+  std::chrono::system_clock::time_point deadline() {
+    return Timespec2Timepoint(deadline_);
+  }
+#endif  // !GRPC_CXX0X_NO_CHRONO
+
+  gpr_timespec raw_deadline() { return deadline_; }
 
   void set_authority(const grpc::string& authority) { authority_ = authority; }
 
@@ -117,22 +127,22 @@ class ClientContext {
   friend class ::grpc::ClientAsyncResponseReader;
 
   grpc_call* call() { return call_; }
-  void set_call(grpc_call* call) {
+  void set_call(grpc_call* call, const std::shared_ptr<ChannelInterface>& channel) {
     GPR_ASSERT(call_ == nullptr);
     call_ = call;
+    channel_ = channel;
   }
 
   grpc_completion_queue* cq() { return cq_; }
   void set_cq(grpc_completion_queue* cq) { cq_ = cq; }
 
-  gpr_timespec RawDeadline() { return absolute_deadline_; }
-
   grpc::string authority() { return authority_; }
 
   bool initial_metadata_received_;
+  std::shared_ptr<ChannelInterface> channel_;
   grpc_call* call_;
   grpc_completion_queue* cq_;
-  gpr_timespec absolute_deadline_;
+  gpr_timespec deadline_;
   grpc::string authority_;
   std::multimap<grpc::string, grpc::string> send_initial_metadata_;
   std::multimap<grpc::string, grpc::string> recv_initial_metadata_;

include/grpc++/completion_queue.h

@@ -34,9 +34,10 @@
 #ifndef GRPCXX_COMPLETION_QUEUE_H
 #define GRPCXX_COMPLETION_QUEUE_H
 
-#include <chrono>
-#include <grpc++/impl/client_unary_call.h>
 #include <grpc/support/time.h>
+#include <grpc++/impl/client_unary_call.h>
+#include <grpc++/impl/grpc_library.h>
+#include <grpc++/time.h>
 
 struct grpc_completion_queue;
 
@@ -71,21 +72,24 @@ class CompletionQueueTag {
 };
 
 // grpc_completion_queue wrapper class
-class CompletionQueue {
+class CompletionQueue : public GrpcLibrary {
  public:
   CompletionQueue();
   explicit CompletionQueue(grpc_completion_queue* take);
-  ~CompletionQueue();
+  ~CompletionQueue() GRPC_OVERRIDE;
 
   // Tri-state return for AsyncNext: SHUTDOWN, GOT_EVENT, TIMEOUT
   enum NextStatus { SHUTDOWN, GOT_EVENT, TIMEOUT };
 
   // Nonblocking (until deadline) read from queue.
   // Cannot rely on result of tag or ok if return is TIMEOUT
-  NextStatus AsyncNext(void** tag, bool* ok,
-                       std::chrono::system_clock::time_point deadline);
+  template<typename T>
+  NextStatus AsyncNext(void** tag, bool* ok, const T& deadline) {
+    TimePoint<T> deadline_tp(deadline);
+    return AsyncNextInternal(tag, ok, deadline_tp.raw_time());
+  }
 
-  // Blocking (until deadline) read from queue.
+  // Blocking read from queue.
   // Returns false if the queue is ready for destruction, true if event
 
   bool Next(void** tag, bool* ok) {

include/grpc++/credentials.h

@@ -34,19 +34,19 @@
 #ifndef GRPCXX_CREDENTIALS_H
 #define GRPCXX_CREDENTIALS_H
 
-#include <chrono>
 #include <memory>
 
 #include <grpc++/config.h>
+#include <grpc++/impl/grpc_library.h>
 
 namespace grpc {
 class ChannelArguments;
 class ChannelInterface;
 class SecureCredentials;
 
-class Credentials {
+class Credentials : public GrpcLibrary {
  public:
-  virtual ~Credentials();
+  ~Credentials() GRPC_OVERRIDE;
 
  protected:
   friend std::unique_ptr<Credentials> CompositeCredentials(
@@ -98,20 +98,20 @@ std::unique_ptr<Credentials> ComputeEngineCredentials();
 // Builds service account credentials.
 // json_key is the JSON key string containing the client's private key.
 // scope is a space-delimited list of the requested permissions.
-// token_lifetime is the lifetime of each token acquired through this service
-// account credentials. It should be positive and should not exceed
-// grpc_max_auth_token_lifetime or will be cropped to this value.
+// token_lifetime_seconds is the lifetime in seconds of each token acquired
+// through this service account credentials. It should be positive and should
+// not exceed grpc_max_auth_token_lifetime or will be cropped to this value.
 std::unique_ptr<Credentials> ServiceAccountCredentials(
     const grpc::string& json_key, const grpc::string& scope,
-    std::chrono::seconds token_lifetime);
+    long token_lifetime_seconds);
 
 // Builds JWT credentials.
 // json_key is the JSON key string containing the client's private key.
-// token_lifetime is the lifetime of each Json Web Token (JWT) created with
-// this credentials.  It should not exceed grpc_max_auth_token_lifetime or
-// will be cropped to this value.
+// token_lifetime_seconds is the lifetime in seconds of each Json Web Token
+// (JWT) created with this credentials. It should not exceed
+// grpc_max_auth_token_lifetime or will be cropped to this value.
 std::unique_ptr<Credentials> JWTCredentials(
-    const grpc::string& json_key, std::chrono::seconds token_lifetime);
+    const grpc::string& json_key, long token_lifetime_seconds);
 
 // Builds refresh token credentials.
 // json_refresh_token is the JSON string containing the refresh token along

src/cpp/util/time.h → include/grpc++/impl/grpc_library.h

@@ -31,21 +31,20 @@
  *
  */
 
-#ifndef GRPC_INTERNAL_CPP_UTIL_TIME_H
-#define GRPC_INTERNAL_CPP_UTIL_TIME_H
+#ifndef GRPCXX_IMPL_GRPC_LIBRARY_H
+#define GRPCXX_IMPL_GRPC_LIBRARY_H
 
-#include <chrono>
-
-#include <grpc/support/time.h>
+#include <grpc/grpc.h>
 
 namespace grpc {
 
-// from and to should be absolute time.
-void Timepoint2Timespec(const std::chrono::system_clock::time_point& from,
-                        gpr_timespec* to);
-
-std::chrono::system_clock::time_point Timespec2Timepoint(gpr_timespec t);
+class GrpcLibrary {
+ public:
+  GrpcLibrary() { grpc_init(); }
+  virtual ~GrpcLibrary() { grpc_shutdown(); }
+};
 
 }  // namespace grpc
 
-#endif  // GRPC_INTERNAL_CPP_UTIL_TIME_H
+
+#endif  // GRPCXX_IMPL_GRPC_LIBRARY_H

include/grpc++/server.h

@@ -40,6 +40,7 @@
 #include <grpc++/completion_queue.h>
 #include <grpc++/config.h>
 #include <grpc++/impl/call.h>
+#include <grpc++/impl/grpc_library.h>
 #include <grpc++/impl/service_type.h>
 #include <grpc++/impl/sync.h>
 #include <grpc++/status.h>
@@ -56,7 +57,8 @@ class ServerCredentials;
 class ThreadPoolInterface;
 
 // Currently it only supports handling rpcs in a single thread.
-class Server GRPC_FINAL : private CallHook,
+class Server GRPC_FINAL : public GrpcLibrary,
+                          private CallHook,
                           private AsynchronousService::DispatchImpl {
  public:
   ~Server();

include/grpc++/server_context.h

@@ -34,10 +34,11 @@
 #ifndef GRPCXX_SERVER_CONTEXT_H
 #define GRPCXX_SERVER_CONTEXT_H
 
-#include <chrono>
 #include <map>
 
+#include <grpc/support/time.h>
 #include <grpc++/config.h>
+#include <grpc++/time.h>
 
 struct gpr_timespec;
 struct grpc_metadata;
@@ -71,9 +72,13 @@ class ServerContext {
   ServerContext();  // for async calls
   ~ServerContext();
 
-  std::chrono::system_clock::time_point absolute_deadline() {
-    return deadline_;
+#ifndef GRPC_CXX0X_NO_CHRONO
+  std::chrono::system_clock::time_point deadline() {
+    return Timespec2Timepoint(deadline_);
   }
+#endif  // !GRPC_CXX0X_NO_CHRONO
+
+  gpr_timespec raw_deadline() { return deadline_; }
 
   void AddInitialMetadata(const grpc::string& key, const grpc::string& value);
   void AddTrailingMetadata(const grpc::string& key, const grpc::string& value);
@@ -110,7 +115,7 @@ class ServerContext {
 
   CompletionOp* completion_op_;
 
-  std::chrono::system_clock::time_point deadline_;
+  gpr_timespec deadline_;
   grpc_call* call_;
   CompletionQueue* cq_;
   bool sent_initial_metadata_;

include/grpc++/stream.h

@@ -173,7 +173,7 @@ class ClientWriter GRPC_FINAL : public ClientStreamingInterface,
     buf.AddRecvMessage(response_);
     buf.AddClientRecvStatus(context_, &status);
     call_.PerformOps(&buf);
-    GPR_ASSERT(cq_.Pluck(&buf) && buf.got_message);
+    GPR_ASSERT(cq_.Pluck(&buf));
     return status;
   }
 

include/grpc++/time.h

@@ -0,0 +1,106 @@
+/*
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPCXX_TIME_H
+#define GRPCXX_TIME_H
+
+#include <grpc++/config.h>
+
+namespace grpc {
+
+/* If you are trying to use CompletionQueue::AsyncNext with a time class that
+   isn't either gpr_timespec or std::chrono::system_clock::time_point, you
+   will most likely be looking at this comment as your compiler will have
+   fired an error below. In order to fix this issue, you have two potential
+   solutions:
+
+     1. Use gpr_timespec or std::chrono::system_clock::time_point instead
+     2. Specialize the TimePoint class with whichever time class that you
+        want to use here. See below for two examples of how to do this.
+ */
+
+template <typename T>
+class TimePoint {
+ public:
+  TimePoint(const T& time) {
+    you_need_a_specialization_of_TimePoint();
+  }
+  gpr_timespec raw_time() {
+    gpr_timespec t;
+    return t;
+  }
+ private:
+  void you_need_a_specialization_of_TimePoint();
+};
+
+template<>
+class TimePoint<gpr_timespec> {
+ public:
+  TimePoint(const gpr_timespec& time) : time_(time) { }
+  gpr_timespec raw_time() { return time_; }
+ private:
+  gpr_timespec time_;
+};
+
+}  // namespace grpc
+
+#ifndef GRPC_CXX0X_NO_CHRONO
+
+#include <chrono>
+
+#include <grpc/support/time.h>
+
+namespace grpc {
+
+// from and to should be absolute time.
+void Timepoint2Timespec(const std::chrono::system_clock::time_point& from,
+                        gpr_timespec* to);
+
+std::chrono::system_clock::time_point Timespec2Timepoint(gpr_timespec t);
+
+template <>
+class TimePoint<std::chrono::system_clock::time_point> {
+ public:
+  TimePoint(const std::chrono::system_clock::time_point& time) {
+	Timepoint2Timespec(time, &time_);
+  }
+  gpr_timespec raw_time() const { return time_; }
+ private:
+  gpr_timespec time_;
+};
+
+}  // namespace grpc
+
+#endif  // !GRPC_CXX0X_NO_CHRONO
+
+#endif  // GRPCXX_TIME_H

include/grpc/grpc.h

@@ -186,6 +186,13 @@ typedef struct grpc_metadata {
   const char *key;
   const char *value;
   size_t value_length;
+
+  /* The following fields are reserved for grpc internal use.
+     There is no need to initialize them, and they will be set to garbage during
+     calls to grpc. */
+  struct {
+    void *obfuscated[3];
+  } internal_data;
 } grpc_metadata;
 
 typedef enum grpc_completion_type {
@@ -295,7 +302,7 @@ typedef struct grpc_op {
   union {
     struct {
       size_t count;
-      const grpc_metadata *metadata;
+      grpc_metadata *metadata;
     } send_initial_metadata;
     grpc_byte_buffer *send_message;
     struct {

include/grpc/support/atm_win32.h

@@ -73,7 +73,7 @@ static __inline int gpr_atm_no_barrier_cas(gpr_atm *p, gpr_atm o, gpr_atm n) {
 
 static __inline int gpr_atm_acq_cas(gpr_atm *p, gpr_atm o, gpr_atm n) {
 #ifdef GPR_ARCH_64
-  return o == (gpr_atm)InterlockedCompareExchangeAcquire64((volatile LONGLONG) p,
+  return o == (gpr_atm)InterlockedCompareExchangeAcquire64((volatile LONGLONG *) p,
                                                            (LONGLONG) n, (LONGLONG) o);
 #else
   return o == (gpr_atm)InterlockedCompareExchangeAcquire((volatile LONG *) p,

include/grpc/support/port_platform.h

@@ -45,8 +45,10 @@
 #define GPR_WINSOCK_SOCKET 1
 #ifdef __GNUC__
 #define GPR_GCC_ATOMIC 1
+#define GPR_GCC_TLS 1
 #else
 #define GPR_WIN32_ATOMIC 1
+#define GPR_MSVC_TLS 1
 #endif
 #elif defined(_WIN32) || defined(WIN32)
 #define GPR_ARCH_32 1
@@ -233,7 +235,7 @@
 #endif
 
 #if defined(GPR_MSVC_TLS) + defined(GPR_GCC_TLS) + defined(GPR_PTHREAD_TLS) + defined(GPR_CUSTOM_TLS) != 1
-#error Must define exactly one of GPR_MSVC_TLS, GPR_GCC_TLS, GPR_PTHREAD_TLS, defined(GPR_CUSTOM_TLS)
+#error Must define exactly one of GPR_MSVC_TLS, GPR_GCC_TLS, GPR_PTHREAD_TLS, GPR_CUSTOM_TLS
 #endif
 
 typedef int16_t gpr_int16;

include/grpc/support/tls.h

@@ -44,7 +44,7 @@
    Thread locals have type gpr_intptr.
 
    Declaring a thread local variable 'foo':
-     GPR_TLS_DECL(foo, initial_value);
+     GPR_TLS_DECL(foo);
    Thread locals always have static scope.
 
    Initializing a thread local (must be done at library initialization 

src/core/channel/call_op_string.c

@@ -43,12 +43,27 @@
 
 static void put_metadata(gpr_strvec *b, grpc_mdelem *md) {
   gpr_strvec_add(b, gpr_strdup(" key="));
-  gpr_strvec_add(b, gpr_hexdump((char *)GPR_SLICE_START_PTR(md->key->slice),
-                    GPR_SLICE_LENGTH(md->key->slice), GPR_HEXDUMP_PLAINTEXT));
+  gpr_strvec_add(
+      b, gpr_hexdump((char *)GPR_SLICE_START_PTR(md->key->slice),
+                     GPR_SLICE_LENGTH(md->key->slice), GPR_HEXDUMP_PLAINTEXT));
 
   gpr_strvec_add(b, gpr_strdup(" value="));
   gpr_strvec_add(b, gpr_hexdump((char *)GPR_SLICE_START_PTR(md->value->slice),
-                    GPR_SLICE_LENGTH(md->value->slice), GPR_HEXDUMP_PLAINTEXT));
+                                GPR_SLICE_LENGTH(md->value->slice),
+                                GPR_HEXDUMP_PLAINTEXT));
+}
+
+static void put_metadata_list(gpr_strvec *b, grpc_metadata_batch md) {
+  grpc_linked_mdelem *m;
+  for (m = md.list.head; m != NULL; m = m->next) {
+    put_metadata(b, m->md);
+  }
+  if (gpr_time_cmp(md.deadline, gpr_inf_future) != 0) {
+    char *tmp;
+    gpr_asprintf(&tmp, " deadline=%d.%09d", md.deadline.tv_sec,
+                 md.deadline.tv_nsec);
+    gpr_strvec_add(b, tmp);
+  }
 }
 
 char *grpc_call_op_string(grpc_call_op *op) {
@@ -69,16 +84,7 @@ char *grpc_call_op_string(grpc_call_op *op) {
   switch (op->type) {
     case GRPC_SEND_METADATA:
       gpr_strvec_add(&b, gpr_strdup("SEND_METADATA"));
-      put_metadata(&b, op->data.metadata);
-      break;
-    case GRPC_SEND_DEADLINE:
-      gpr_asprintf(&tmp, "SEND_DEADLINE %d.%09d", op->data.deadline.tv_sec,
-              op->data.deadline.tv_nsec);
-      gpr_strvec_add(&b, tmp);
-      break;
-    case GRPC_SEND_START:
-      gpr_asprintf(&tmp, "SEND_START pollset=%p", op->data.start.pollset);
-      gpr_strvec_add(&b, tmp);
+      put_metadata_list(&b, op->data.metadata);
       break;
     case GRPC_SEND_MESSAGE:
       gpr_strvec_add(&b, gpr_strdup("SEND_MESSAGE"));
@@ -94,15 +100,7 @@ char *grpc_call_op_string(grpc_call_op *op) {
       break;
     case GRPC_RECV_METADATA:
       gpr_strvec_add(&b, gpr_strdup("RECV_METADATA"));
-      put_metadata(&b, op->data.metadata);
-      break;
-    case GRPC_RECV_DEADLINE:
-      gpr_asprintf(&tmp, "RECV_DEADLINE %d.%09d", op->data.deadline.tv_sec,
-              op->data.deadline.tv_nsec);
-      gpr_strvec_add(&b, tmp);
-      break;
-    case GRPC_RECV_END_OF_INITIAL_METADATA:
-      gpr_strvec_add(&b, gpr_strdup("RECV_END_OF_INITIAL_METADATA"));
+      put_metadata_list(&b, op->data.metadata);
       break;
     case GRPC_RECV_MESSAGE:
       gpr_strvec_add(&b, gpr_strdup("RECV_MESSAGE"));
@@ -113,12 +111,21 @@ char *grpc_call_op_string(grpc_call_op *op) {
     case GRPC_RECV_FINISH:
       gpr_strvec_add(&b, gpr_strdup("RECV_FINISH"));
       break;
+    case GRPC_RECV_SYNTHETIC_STATUS:
+      gpr_asprintf(&tmp, "RECV_SYNTHETIC_STATUS status=%d message='%s'",
+                   op->data.synthetic_status.status,
+                   op->data.synthetic_status.message);
+      gpr_strvec_add(&b, tmp);
+      break;
     case GRPC_CANCEL_OP:
       gpr_strvec_add(&b, gpr_strdup("CANCEL_OP"));
       break;
   }
   gpr_asprintf(&tmp, " flags=0x%08x", op->flags);
   gpr_strvec_add(&b, tmp);
+  if (op->bind_pollset) {
+    gpr_strvec_add(&b, gpr_strdup("bind_pollset"));
+  }
 
   out = gpr_strvec_flatten(&b, NULL);
   gpr_strvec_destroy(&b);

src/core/channel/census_filter.c

@@ -62,11 +62,13 @@ static void init_rpc_stats(census_rpc_stats* stats) {
 
 static void extract_and_annotate_method_tag(grpc_call_op* op, call_data* calld,
                                             channel_data* chand) {
-  if (op->data.metadata->key == chand->path_str) {
-    gpr_log(GPR_DEBUG,
-            (const char*)GPR_SLICE_START_PTR(op->data.metadata->value->slice));
-    census_add_method_tag(calld->op_id, (const char*)GPR_SLICE_START_PTR(
-                                            op->data.metadata->value->slice));
+  grpc_linked_mdelem* m;
+  for (m = op->data.metadata.list.head; m != NULL; m = m->next) {
+    if (m->md->key == chand->path_str) {
+      gpr_log(GPR_DEBUG, "%s", (const char*)GPR_SLICE_START_PTR(m->md->value->slice));
+      census_add_method_tag(
+          calld->op_id, (const char*)GPR_SLICE_START_PTR(m->md->value->slice));
+    }
   }
 }
 
@@ -178,11 +180,11 @@ static void destroy_channel_elem(grpc_channel_element* elem) {
 }
 
 const grpc_channel_filter grpc_client_census_filter = {
-    client_call_op,        channel_op,               sizeof(call_data),
-    client_init_call_elem, client_destroy_call_elem, sizeof(channel_data),
-    init_channel_elem,     destroy_channel_elem,     "census-client"};
+    client_call_op, channel_op, sizeof(call_data), client_init_call_elem,
+    client_destroy_call_elem, sizeof(channel_data), init_channel_elem,
+    destroy_channel_elem, "census-client"};
 
 const grpc_channel_filter grpc_server_census_filter = {
-    server_call_op,        channel_op,               sizeof(call_data),
-    server_init_call_elem, server_destroy_call_elem, sizeof(channel_data),
-    init_channel_elem,     destroy_channel_elem,     "census-server"};
+    server_call_op, channel_op, sizeof(call_data), server_init_call_elem,
+    server_destroy_call_elem, sizeof(channel_data), init_channel_elem,
+    destroy_channel_elem, "census-server"};

src/core/channel/channel_stack.c

@@ -77,9 +77,9 @@ size_t grpc_channel_stack_size(const grpc_channel_filter **filters,
   return size;
 }
 
-#define CHANNEL_ELEMS_FROM_STACK(stk) \
-  ((grpc_channel_element *)(          \
-      (char *)(stk) + ROUND_UP_TO_ALIGNMENT_SIZE(sizeof(grpc_channel_stack))))
+#define CHANNEL_ELEMS_FROM_STACK(stk)                                   \
+  ((grpc_channel_element *)((char *)(stk) + ROUND_UP_TO_ALIGNMENT_SIZE( \
+                                                sizeof(grpc_channel_stack))))
 
 #define CALL_ELEMS_FROM_STACK(stk)       \
   ((grpc_call_element *)((char *)(stk) + \
@@ -183,6 +183,9 @@ void grpc_call_stack_destroy(grpc_call_stack *stack) {
 
 void grpc_call_next_op(grpc_call_element *elem, grpc_call_op *op) {
   grpc_call_element *next_elem = elem + op->dir;
+  if (op->type == GRPC_SEND_METADATA || op->type == GRPC_RECV_METADATA) {
+    grpc_metadata_batch_assert_ok(&op->data.metadata);
+  }
   next_elem->filter->call_op(next_elem, elem, op);
 }
 
@@ -193,42 +196,17 @@ void grpc_channel_next_op(grpc_channel_element *elem, grpc_channel_op *op) {
 
 grpc_channel_stack *grpc_channel_stack_from_top_element(
     grpc_channel_element *elem) {
-  return (grpc_channel_stack *)((char *)(elem) -
-                                ROUND_UP_TO_ALIGNMENT_SIZE(
-                                    sizeof(grpc_channel_stack)));
+  return (grpc_channel_stack *)((char *)(elem)-ROUND_UP_TO_ALIGNMENT_SIZE(
+      sizeof(grpc_channel_stack)));
 }
 
 grpc_call_stack *grpc_call_stack_from_top_element(grpc_call_element *elem) {
-  return (grpc_call_stack *)((char *)(elem) - ROUND_UP_TO_ALIGNMENT_SIZE(
-                                                  sizeof(grpc_call_stack)));
+  return (grpc_call_stack *)((char *)(elem)-ROUND_UP_TO_ALIGNMENT_SIZE(
+      sizeof(grpc_call_stack)));
 }
 
 static void do_nothing(void *user_data, grpc_op_error error) {}
 
-void grpc_call_element_recv_metadata(grpc_call_element *cur_elem,
-    grpc_mdelem *mdelem) {
-  grpc_call_op metadata_op;
-  metadata_op.type = GRPC_RECV_METADATA;
-  metadata_op.dir = GRPC_CALL_UP;
-  metadata_op.done_cb = do_nothing;
-  metadata_op.user_data = NULL;
-  metadata_op.flags = 0;
-  metadata_op.data.metadata = mdelem;
-  grpc_call_next_op(cur_elem, &metadata_op);
-}
-
-void grpc_call_element_send_metadata(grpc_call_element *cur_elem,
-                                     grpc_mdelem *mdelem) {
-  grpc_call_op metadata_op;
-  metadata_op.type = GRPC_SEND_METADATA;
-  metadata_op.dir = GRPC_CALL_DOWN;
-  metadata_op.done_cb = do_nothing;
-  metadata_op.user_data = NULL;
-  metadata_op.flags = 0;
-  metadata_op.data.metadata = mdelem;
-  grpc_call_next_op(cur_elem, &metadata_op);
-}
-
 void grpc_call_element_send_cancel(grpc_call_element *cur_elem) {
   grpc_call_op cancel_op;
   cancel_op.type = GRPC_CANCEL_OP;
@@ -236,6 +214,7 @@ void grpc_call_element_send_cancel(grpc_call_element *cur_elem) {
   cancel_op.done_cb = do_nothing;
   cancel_op.user_data = NULL;
   cancel_op.flags = 0;
+  cancel_op.bind_pollset = NULL;
   grpc_call_next_op(cur_elem, &cancel_op);
 }
 
@@ -246,5 +225,19 @@ void grpc_call_element_send_finish(grpc_call_element *cur_elem) {
   finish_op.done_cb = do_nothing;
   finish_op.user_data = NULL;
   finish_op.flags = 0;
+  finish_op.bind_pollset = NULL;
   grpc_call_next_op(cur_elem, &finish_op);
 }
+
+void grpc_call_element_recv_status(grpc_call_element *cur_elem,
+                                   grpc_status_code status,
+                                   const char *message) {
+  grpc_call_op op;
+  op.type = GRPC_RECV_SYNTHETIC_STATUS;
+  op.dir = GRPC_CALL_UP;
+  op.done_cb = do_nothing;
+  op.user_data = NULL;
+  op.data.synthetic_status.status = status;
+  op.data.synthetic_status.message = message;
+  grpc_call_next_op(cur_elem, &op);
+}

src/core/channel/channel_stack.h

@@ -62,10 +62,6 @@ typedef struct grpc_call_element grpc_call_element;
 typedef enum {
   /* send metadata to the channels peer */
   GRPC_SEND_METADATA,
-  /* send a deadline */
-  GRPC_SEND_DEADLINE,
-  /* start a connection (corresponds to start_invoke/accept) */
-  GRPC_SEND_START,
   /* send a message to the channels peer */
   GRPC_SEND_MESSAGE,
   /* send a pre-formatted message to the channels peer */
@@ -76,16 +72,14 @@ typedef enum {
   GRPC_REQUEST_DATA,
   /* metadata was received from the channels peer */
   GRPC_RECV_METADATA,
-  /* receive a deadline */
-  GRPC_RECV_DEADLINE,
-  /* the end of the first batch of metadata was received */
-  GRPC_RECV_END_OF_INITIAL_METADATA,
   /* a message was received from the channels peer */
   GRPC_RECV_MESSAGE,
   /* half-close was received from the channels peer */
   GRPC_RECV_HALF_CLOSE,
   /* full close was received from the channels peer */
   GRPC_RECV_FINISH,
+  /* a status has been sythesized locally */
+  GRPC_RECV_SYNTHETIC_STATUS,
   /* the call has been abnormally terminated */
   GRPC_CANCEL_OP
 } grpc_call_op_type;
@@ -109,14 +103,16 @@ typedef struct {
 
   /* Argument data, matching up with grpc_call_op_type names */
   union {
-    struct {
-      grpc_pollset *pollset;
-    } start;
     grpc_byte_buffer *message;
-    grpc_mdelem *metadata;
-    gpr_timespec deadline;
+    grpc_metadata_batch metadata;
+    struct {
+      grpc_status_code status;
+      const char *message;
+    } synthetic_status;
   } data;
 
+  grpc_pollset *bind_pollset;
+
   /* Must be called when processing of this call-op is complete.
      Signature chosen to match transport flow control callbacks */
   void (*done_cb)(void *user_data, grpc_op_error error);
@@ -291,16 +287,15 @@ grpc_call_stack *grpc_call_stack_from_top_element(grpc_call_element *elem);
 void grpc_call_log_op(char *file, int line, gpr_log_severity severity,
                       grpc_call_element *elem, grpc_call_op *op);
 
-void grpc_call_element_send_metadata(grpc_call_element *cur_elem,
-                                     grpc_mdelem *elem);
-void grpc_call_element_recv_metadata(grpc_call_element *cur_elem,
-                                     grpc_mdelem *elem);
 void grpc_call_element_send_cancel(grpc_call_element *cur_elem);
 void grpc_call_element_send_finish(grpc_call_element *cur_elem);
+void grpc_call_element_recv_status(grpc_call_element *cur_elem,
+                                   grpc_status_code status,
+                                   const char *message);
 
 extern int grpc_trace_channel;
 
 #define GRPC_CALL_LOG_OP(sev, elem, op) \
   if (grpc_trace_channel) grpc_call_log_op(sev, elem, op)
 
-#endif  /* GRPC_INTERNAL_CORE_CHANNEL_CHANNEL_STACK_H */
+#endif /* GRPC_INTERNAL_CORE_CHANNEL_CHANNEL_STACK_H */

src/core/channel/client_channel.c

@@ -38,7 +38,6 @@
 #include "src/core/channel/channel_args.h"
 #include "src/core/channel/child_channel.h"
 #include "src/core/channel/connected_channel.h"
-#include "src/core/channel/metadata_buffer.h"
 #include "src/core/iomgr/iomgr.h"
 #include "src/core/support/string.h"
 #include <grpc/support/alloc.h>
@@ -70,9 +69,6 @@ typedef struct {
   int transport_setup_initiated;
 
   grpc_channel_args *args;
-
-  /* metadata cache */
-  grpc_mdelem *cancel_status;
 } channel_data;
 
 typedef enum {
@@ -86,20 +82,16 @@ struct call_data {
   /* owning element */
   grpc_call_element *elem;
 
+  gpr_uint8 got_first_send;
+
   call_state state;
-  grpc_metadata_buffer pending_metadata;
   gpr_timespec deadline;
   union {
     struct {
       /* our child call stack */
       grpc_child_call *child_call;
     } active;
-    struct {
-      void (*on_complete)(void *user_data, grpc_op_error error);
-      void *on_complete_user_data;
-      gpr_uint32 start_flags;
-      grpc_pollset *pollset;
-    } waiting;
+    grpc_call_op waiting_op;
   } s;
 };
 
@@ -127,20 +119,6 @@ static void complete_activate(grpc_call_element *elem, grpc_call_op *op) {
 
   GPR_ASSERT(calld->state == CALL_ACTIVE);
 
-  /* sending buffered metadata down the stack before the start call */
-  grpc_metadata_buffer_flush(&calld->pending_metadata, child_elem);
-
-  if (gpr_time_cmp(calld->deadline, gpr_inf_future) != 0) {
-    grpc_call_op dop;
-    dop.type = GRPC_SEND_DEADLINE;
-    dop.dir = GRPC_CALL_DOWN;
-    dop.flags = 0;
-    dop.data.deadline = calld->deadline;
-    dop.done_cb = do_nothing;
-    dop.user_data = NULL;
-    child_elem->filter->call_op(child_elem, elem, &dop);
-  }
-
   /* continue the start call down the stack, this nees to happen after metadata
      are flushed*/
   child_elem->filter->call_op(child_elem, elem, op);
@@ -152,6 +130,7 @@ static void start_rpc(grpc_call_element *elem, grpc_call_op *op) {
   gpr_mu_lock(&chand->mu);
   if (calld->state == CALL_CANCELLED) {
     gpr_mu_unlock(&chand->mu);
+    grpc_metadata_batch_destroy(&op->data.metadata);
     op->done_cb(op->user_data, GRPC_OP_ERROR);
     return;
   }
@@ -184,10 +163,7 @@ static void start_rpc(grpc_call_element *elem, grpc_call_op *op) {
           gpr_realloc(chand->waiting_children,
                       chand->waiting_child_capacity * sizeof(call_data *));
     }
-    calld->s.waiting.on_complete = op->done_cb;
-    calld->s.waiting.on_complete_user_data = op->user_data;
-    calld->s.waiting.start_flags = op->flags;
-    calld->s.waiting.pollset = op->data.start.pollset;
+    calld->s.waiting_op = *op;
     chand->waiting_children[chand->waiting_child_count++] = calld;
     gpr_mu_unlock(&chand->mu);
 
@@ -212,15 +188,8 @@ static void remove_waiting_child(channel_data *chand, call_data *calld) {
 
 static void send_up_cancelled_ops(grpc_call_element *elem) {
   grpc_call_op finish_op;
-  channel_data *chand = elem->channel_data;
   /* send up a synthesized status */
-  finish_op.type = GRPC_RECV_METADATA;
-  finish_op.dir = GRPC_CALL_UP;
-  finish_op.flags = 0;
-  finish_op.data.metadata = grpc_mdelem_ref(chand->cancel_status);
-  finish_op.done_cb = do_nothing;
-  finish_op.user_data = NULL;
-  grpc_call_next_op(elem, &finish_op);
+  grpc_call_element_recv_status(elem, GRPC_STATUS_CANCELLED, "Cancelled");
   /* send up a finish */
   finish_op.type = GRPC_RECV_FINISH;
   finish_op.dir = GRPC_CALL_UP;
@@ -243,12 +212,12 @@ static void cancel_rpc(grpc_call_element *elem, grpc_call_op *op) {
       child_elem->filter->call_op(child_elem, elem, op);
       return; /* early out */
     case CALL_WAITING:
+      grpc_metadata_batch_destroy(&calld->s.waiting_op.data.metadata);
       remove_waiting_child(chand, calld);
       calld->state = CALL_CANCELLED;
       gpr_mu_unlock(&chand->mu);
       send_up_cancelled_ops(elem);
-      calld->s.waiting.on_complete(calld->s.waiting.on_complete_user_data,
-                                   GRPC_OP_ERROR);
+      calld->s.waiting_op.done_cb(calld->s.waiting_op.user_data, GRPC_OP_ERROR);
       return; /* early out */
     case CALL_CREATED:
       calld->state = CALL_CANCELLED;
@@ -271,15 +240,13 @@ static void call_op(grpc_call_element *elem, grpc_call_element *from_elem,
 
   switch (op->type) {
     case GRPC_SEND_METADATA:
-      grpc_metadata_buffer_queue(&calld->pending_metadata, op);
-      break;
-    case GRPC_SEND_DEADLINE:
-      calld->deadline = op->data.deadline;
-      op->done_cb(op->user_data, GRPC_OP_OK);
-      break;
-    case GRPC_SEND_START:
-      /* filter out the start event to find which child to send on */
-      start_rpc(elem, op);
+      if (!calld->got_first_send) {
+        /* filter out the start event to find which child to send on */
+        calld->got_first_send = 1;
+        start_rpc(elem, op);
+      } else {
+        grpc_call_next_op(elem, op);
+      }
       break;
     case GRPC_CANCEL_OP:
       cancel_rpc(elem, op);
@@ -382,12 +349,6 @@ static void channel_op(grpc_channel_element *elem,
   }
 }
 
-static void error_bad_on_complete(void *arg, grpc_op_error error) {
-  gpr_log(GPR_ERROR,
-          "Waiting finished but not started? Bad on_complete callback");
-  abort();
-}
-
 /* Constructor for call_data */
 static void init_call_elem(grpc_call_element *elem,
                            const void *server_transport_data) {
@@ -398,23 +359,22 @@ static void init_call_elem(grpc_call_element *elem,
   calld->elem = elem;
   calld->state = CALL_CREATED;
   calld->deadline = gpr_inf_future;
-  calld->s.waiting.on_complete = error_bad_on_complete;
-  calld->s.waiting.on_complete_user_data = NULL;
-  grpc_metadata_buffer_init(&calld->pending_metadata);
+  calld->got_first_send = 0;
 }
 
 /* Destructor for call_data */
 static void destroy_call_elem(grpc_call_element *elem) {
   call_data *calld = elem->call_data;
 
-  /* if the metadata buffer is not flushed, destroy it here. */
-  grpc_metadata_buffer_destroy(&calld->pending_metadata, GRPC_OP_OK);
   /* if the call got activated, we need to destroy the child stack also, and
      remove it from the in-flight requests tracked by the child_entry we
      picked */
   if (calld->state == CALL_ACTIVE) {
     grpc_child_call_destroy(calld->s.active.child_call);
   }
+  if (calld->state == CALL_WAITING) {
+    grpc_metadata_batch_destroy(&calld->s.waiting_op.data.metadata);
+  }
 }
 
 /* Constructor for channel_data */
@@ -423,7 +383,6 @@ static void init_channel_elem(grpc_channel_element *elem,
                               grpc_mdctx *metadata_context, int is_first,
                               int is_last) {
   channel_data *chand = elem->channel_data;
-  char temp[GPR_LTOA_MIN_BUFSIZE];
 
   GPR_ASSERT(!is_first);
   GPR_ASSERT(is_last);
@@ -437,10 +396,6 @@ static void init_channel_elem(grpc_channel_element *elem,
   chand->transport_setup = NULL;
   chand->transport_setup_initiated = 0;
   chand->args = grpc_channel_args_copy(args);
-
-  gpr_ltoa(GRPC_STATUS_CANCELLED, temp);
-  chand->cancel_status =
-      grpc_mdelem_from_strings(metadata_context, "grpc-status", temp);
 }
 
 /* Destructor for channel_data */
@@ -455,7 +410,6 @@ static void destroy_channel_elem(grpc_channel_element *elem) {
   }
 
   grpc_channel_args_destroy(chand->args);
-  grpc_mdelem_unref(chand->cancel_status);
 
   gpr_mu_destroy(&chand->mu);
   GPR_ASSERT(chand->waiting_child_count == 0);
@@ -463,9 +417,10 @@ static void destroy_channel_elem(grpc_channel_element *elem) {
 }
 
 const grpc_channel_filter grpc_client_channel_filter = {
-    call_op,           channel_op,           sizeof(call_data),
-    init_call_elem,    destroy_call_elem,    sizeof(channel_data),
-    init_channel_elem, destroy_channel_elem, "client-channel", };
+    call_op, channel_op, sizeof(call_data), init_call_elem, destroy_call_elem,
+    sizeof(channel_data), init_channel_elem, destroy_channel_elem,
+    "client-channel",
+};
 
 grpc_transport_setup_result grpc_client_channel_transport_setup_complete(
     grpc_channel_stack *channel_stack, grpc_transport *transport,
@@ -520,13 +475,7 @@ grpc_transport_setup_result grpc_client_channel_transport_setup_complete(
   call_ops = gpr_malloc(sizeof(grpc_call_op) * waiting_child_count);
 
   for (i = 0; i < waiting_child_count; i++) {
-    call_ops[i].type = GRPC_SEND_START;
-    call_ops[i].dir = GRPC_CALL_DOWN;
-    call_ops[i].flags = waiting_children[i]->s.waiting.start_flags;
-    call_ops[i].done_cb = waiting_children[i]->s.waiting.on_complete;
-    call_ops[i].user_data =
-        waiting_children[i]->s.waiting.on_complete_user_data;
-    call_ops[i].data.start.pollset = waiting_children[i]->s.waiting.pollset;
+    call_ops[i] = waiting_children[i]->s.waiting_op;
     if (!prepare_activate(waiting_children[i]->elem, chand->active_child)) {
       waiting_children[i] = NULL;
       call_ops[i].done_cb(call_ops[i].user_data, GRPC_OP_ERROR);

src/core/channel/connected_channel.c

@@ -60,7 +60,6 @@ typedef struct connected_channel_call_data {
   gpr_uint32 max_message_length;
   gpr_uint32 incoming_message_length;
   gpr_uint8 reading_message;
-  gpr_uint8 got_metadata_boundary;
   gpr_uint8 got_read_close;
   gpr_slice_buffer incoming_message;
   gpr_uint32 outgoing_buffer_length_estimate;
@@ -120,27 +119,20 @@ static void call_op(grpc_call_element *elem, grpc_call_element *from_elem,
   GPR_ASSERT(elem->filter == &grpc_connected_channel_filter);
   GRPC_CALL_LOG_OP(GPR_INFO, elem, op);
 
+  if (op->bind_pollset) {
+    grpc_transport_add_to_pollset(chand->transport, op->bind_pollset);
+  }
+
   switch (op->type) {
     case GRPC_SEND_METADATA:
       grpc_sopb_add_metadata(&calld->outgoing_sopb, op->data.metadata);
-      grpc_sopb_add_flow_ctl_cb(&calld->outgoing_sopb, op->done_cb,
-                                op->user_data);
-      break;
-    case GRPC_SEND_DEADLINE:
-      grpc_sopb_add_deadline(&calld->outgoing_sopb, op->data.deadline);
-      grpc_sopb_add_flow_ctl_cb(&calld->outgoing_sopb, op->done_cb,
-                                op->user_data);
-      break;
-    case GRPC_SEND_START:
-      grpc_transport_add_to_pollset(chand->transport, op->data.start.pollset);
-      grpc_sopb_add_metadata_boundary(&calld->outgoing_sopb);
       end_bufferable_op(op, chand, calld, 0);
       break;
     case GRPC_SEND_MESSAGE:
       grpc_sopb_add_begin_message(&calld->outgoing_sopb,
                                   grpc_byte_buffer_length(op->data.message),
                                   op->flags);
-      /* fall-through */
+    /* fall-through */
     case GRPC_SEND_PREFORMATTED_MESSAGE:
       copy_byte_buffer_to_stream_ops(op->data.message, &calld->outgoing_sopb);
       calld->outgoing_buffer_length_estimate +=
@@ -200,7 +192,6 @@ static void init_call_elem(grpc_call_element *elem,
   grpc_sopb_init(&calld->outgoing_sopb);
 
   calld->reading_message = 0;
-  calld->got_metadata_boundary = 0;
   calld->got_read_close = 0;
   calld->outgoing_buffer_length_estimate = 0;
   calld->max_message_length = chand->max_message_length;
@@ -259,9 +250,9 @@ static void destroy_channel_elem(grpc_channel_element *elem) {
 }
 
 const grpc_channel_filter grpc_connected_channel_filter = {
-    call_op,           channel_op,           sizeof(call_data),
-    init_call_elem,    destroy_call_elem,    sizeof(channel_data),
-    init_channel_elem, destroy_channel_elem, "connected", };
+    call_op, channel_op, sizeof(call_data), init_call_elem, destroy_call_elem,
+    sizeof(channel_data), init_channel_elem, destroy_channel_elem, "connected",
+};
 
 static gpr_slice alloc_recv_buffer(void *user_data, grpc_transport *transport,
                                    grpc_stream *stream, size_t size_hint) {
@@ -307,8 +298,8 @@ static void finish_message(channel_data *chand, call_data *calld) {
   call_op.type = GRPC_RECV_MESSAGE;
   call_op.done_cb = do_nothing;
   /* TODO(ctiller): this could be a lot faster if coded directly */
-  call_op.data.message = grpc_byte_buffer_create(
-      calld->incoming_message.slices, calld->incoming_message.count);
+  call_op.data.message = grpc_byte_buffer_create(calld->incoming_message.slices,
+                                                 calld->incoming_message.count);
   gpr_slice_buffer_reset_and_unref(&calld->incoming_message);
 
   /* disable window updates until we get a request more from above */
@@ -320,6 +311,19 @@ static void finish_message(channel_data *chand, call_data *calld) {
   grpc_call_next_op(elem, &call_op);
 }
 
+static void got_metadata(grpc_call_element *elem,
+                         grpc_metadata_batch metadata) {
+  grpc_call_op op;
+  op.type = GRPC_RECV_METADATA;
+  op.dir = GRPC_CALL_UP;
+  op.flags = 0;
+  op.data.metadata = metadata;
+  op.done_cb = do_nothing;
+  op.user_data = NULL;
+
+  grpc_call_next_op(elem, &op);
+}
+
 /* Handle incoming stream ops from the transport, translating them into
    call_ops to pass up the call stack */
 static void recv_batch(void *user_data, grpc_transport *transport,
@@ -339,40 +343,12 @@ static void recv_batch(void *user_data, grpc_transport *transport,
     stream_op = ops + i;
     switch (stream_op->type) {
       case GRPC_OP_FLOW_CTL_CB:
-        gpr_log(GPR_ERROR,
-                "should not receive flow control ops from transport");
-        abort();
+        stream_op->data.flow_ctl_cb.cb(stream_op->data.flow_ctl_cb.arg, 1);
         break;
       case GRPC_NO_OP:
         break;
       case GRPC_OP_METADATA:
-        call_op.type = GRPC_RECV_METADATA;
-        call_op.dir = GRPC_CALL_UP;
-        call_op.flags = 0;
-        call_op.data.metadata = stream_op->data.metadata;
-        call_op.done_cb = do_nothing;
-        call_op.user_data = NULL;
-        grpc_call_next_op(elem, &call_op);
-        break;
-      case GRPC_OP_DEADLINE:
-        call_op.type = GRPC_RECV_DEADLINE;
-        call_op.dir = GRPC_CALL_UP;
-        call_op.flags = 0;
-        call_op.data.deadline = stream_op->data.deadline;
-        call_op.done_cb = do_nothing;
-        call_op.user_data = NULL;
-        grpc_call_next_op(elem, &call_op);
-        break;
-      case GRPC_OP_METADATA_BOUNDARY:
-        if (!calld->got_metadata_boundary) {
-          calld->got_metadata_boundary = 1;
-          call_op.type = GRPC_RECV_END_OF_INITIAL_METADATA;
-          call_op.dir = GRPC_CALL_UP;
-          call_op.flags = 0;
-          call_op.done_cb = do_nothing;
-          call_op.user_data = NULL;
-          grpc_call_next_op(elem, &call_op);
-        }
+        got_metadata(elem, stream_op->data.metadata);
         break;
       case GRPC_OP_BEGIN_MESSAGE:
         /* can't begin a message when we're still reading a message */
@@ -495,7 +471,8 @@ static void transport_closed(void *user_data, grpc_transport *transport) {
 
 const grpc_transport_callbacks connected_channel_transport_callbacks = {
     alloc_recv_buffer, accept_stream,    recv_batch,
-    transport_goaway,  transport_closed, };
+    transport_goaway,  transport_closed,
+};
 
 grpc_transport_setup_result grpc_connected_channel_bind_transport(
     grpc_channel_stack *channel_stack, grpc_transport *transport) {

src/core/channel/http_client_filter.c

@@ -35,7 +35,10 @@
 #include <grpc/support/log.h>
 
 typedef struct call_data {
-  int sent_headers;
+  grpc_linked_mdelem method;
+  grpc_linked_mdelem scheme;
+  grpc_linked_mdelem te_trailers;
+  grpc_linked_mdelem content_type;
 } call_data;
 
 typedef struct channel_data {
@@ -49,6 +52,18 @@ typedef struct channel_data {
 /* used to silence 'variable not used' warnings */
 static void ignore_unused(void *ignored) {}
 
+static grpc_mdelem *client_filter(void *user_data, grpc_mdelem *md) {
+  grpc_call_element *elem = user_data;
+  channel_data *channeld = elem->channel_data;
+  if (md == channeld->status) {
+    return NULL;
+  } else if (md->key == channeld->status->key) {
+    grpc_call_element_send_cancel(elem);
+    return NULL;
+  }
+  return md;
+}
+
 /* Called either:
      - in response to an API call (or similar) from above, to send something
      - a network event (or similar) from below, to receive something
@@ -61,42 +76,23 @@ static void call_op(grpc_call_element *elem, grpc_call_element *from_elem,
   channel_data *channeld = elem->channel_data;
   GRPC_CALL_LOG_OP(GPR_INFO, elem, op);
 
-  ignore_unused(calld);
-
   switch (op->type) {
     case GRPC_SEND_METADATA:
-      if (!calld->sent_headers) {
-        /* Send : prefixed headers, which have to be before any application
-         * layer headers. */
-        calld->sent_headers = 1;
-        grpc_call_element_send_metadata(elem, grpc_mdelem_ref(channeld->method));
-        grpc_call_element_send_metadata(elem, grpc_mdelem_ref(channeld->scheme));
-      }
-      grpc_call_next_op(elem, op);
-      break;
-    case GRPC_SEND_START:
-      if (!calld->sent_headers) {
-        /* Send : prefixed headers, if we haven't already */
-        calld->sent_headers = 1;
-        grpc_call_element_send_metadata(elem, grpc_mdelem_ref(channeld->method));
-        grpc_call_element_send_metadata(elem, grpc_mdelem_ref(channeld->scheme));
-      }
-      /* Send non : prefixed headers */
-      grpc_call_element_send_metadata(elem, grpc_mdelem_ref(channeld->te_trailers));
-      grpc_call_element_send_metadata(elem, grpc_mdelem_ref(channeld->content_type));
+      /* Send : prefixed headers, which have to be before any application
+       * layer headers. */
+      grpc_metadata_batch_add_head(&op->data.metadata, &calld->method,
+                                   grpc_mdelem_ref(channeld->method));
+      grpc_metadata_batch_add_head(&op->data.metadata, &calld->scheme,
+                                   grpc_mdelem_ref(channeld->scheme));
+      grpc_metadata_batch_add_tail(&op->data.metadata, &calld->te_trailers,
+                                   grpc_mdelem_ref(channeld->te_trailers));
+      grpc_metadata_batch_add_tail(&op->data.metadata, &calld->content_type,
+                                   grpc_mdelem_ref(channeld->content_type));
       grpc_call_next_op(elem, op);
       break;
     case GRPC_RECV_METADATA:
-      if (op->data.metadata == channeld->status) {
-        grpc_mdelem_unref(op->data.metadata);
-        op->done_cb(op->user_data, GRPC_OP_OK);
-      } else if (op->data.metadata->key == channeld->status->key) {
-        grpc_mdelem_unref(op->data.metadata);
-        op->done_cb(op->user_data, GRPC_OP_OK);
-        grpc_call_element_send_cancel(elem);
-      } else {
-        grpc_call_next_op(elem, op);
-      }
+      grpc_metadata_batch_filter(&op->data.metadata, client_filter, elem);
+      grpc_call_next_op(elem, op);
       break;
     default:
       /* pass control up or down the stack depending on op->dir */
@@ -124,16 +120,7 @@ static void channel_op(grpc_channel_element *elem,
 
 /* Constructor for call_data */
 static void init_call_elem(grpc_call_element *elem,
-                           const void *server_transport_data) {
-  /* grab pointers to our data from the call element */
-  call_data *calld = elem->call_data;
-  channel_data *channeld = elem->channel_data;
-
-  ignore_unused(channeld);
-
-  /* initialize members */
-  calld->sent_headers = 0;
-}
+                           const void *server_transport_data) {}
 
 /* Destructor for call_data */
 static void destroy_call_elem(grpc_call_element *elem) {
@@ -194,6 +181,6 @@ static void destroy_channel_elem(grpc_channel_element *elem) {
 }
 
 const grpc_channel_filter grpc_http_client_filter = {
-    call_op,           channel_op,           sizeof(call_data),
-    init_call_elem,    destroy_call_elem,    sizeof(channel_data),
-    init_channel_elem, destroy_channel_elem, "http-client"};
+    call_op, channel_op, sizeof(call_data), init_call_elem, destroy_call_elem,
+    sizeof(channel_data), init_channel_elem, destroy_channel_elem,
+    "http-client"};

src/core/channel/http_server_filter.c

@@ -38,8 +38,6 @@
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 
-typedef enum { NOT_RECEIVED, POST, GET } known_method_type;
-
 typedef struct {
   grpc_mdelem *path;
   grpc_mdelem *content_type;
@@ -47,16 +45,17 @@ typedef struct {
 } gettable;
 
 typedef struct call_data {
-  known_method_type seen_method;
+  gpr_uint8 got_initial_metadata;
+  gpr_uint8 seen_path;
+  gpr_uint8 seen_post;
   gpr_uint8 sent_status;
   gpr_uint8 seen_scheme;
   gpr_uint8 seen_te_trailers;
-  grpc_mdelem *path;
+  grpc_linked_mdelem status;
 } call_data;
 
 typedef struct channel_data {
   grpc_mdelem *te_trailers;
-  grpc_mdelem *method_get;
   grpc_mdelem *method_post;
   grpc_mdelem *http_scheme;
   grpc_mdelem *https_scheme;
@@ -78,38 +77,70 @@ typedef struct channel_data {
 /* used to silence 'variable not used' warnings */
 static void ignore_unused(void *ignored) {}
 
-/* Handle 'GET': not technically grpc, so probably a web browser hitting
-   us */
-static void payload_done(void *elem, grpc_op_error error) {
-  if (error == GRPC_OP_OK) {
-    grpc_call_element_send_finish(elem);
-  }
-}
-
-static void handle_get(grpc_call_element *elem) {
+static grpc_mdelem *server_filter(void *user_data, grpc_mdelem *md) {
+  grpc_call_element *elem = user_data;
   channel_data *channeld = elem->channel_data;
   call_data *calld = elem->call_data;
-  grpc_call_op op;
-  size_t i;
 
-  for (i = 0; i < channeld->gettable_count; i++) {
-    if (channeld->gettables[i].path == calld->path) {
-      grpc_call_element_send_metadata(elem,
-                                      grpc_mdelem_ref(channeld->status_ok));
-      grpc_call_element_send_metadata(
-          elem, grpc_mdelem_ref(channeld->gettables[i].content_type));
-      op.type = GRPC_SEND_PREFORMATTED_MESSAGE;
-      op.dir = GRPC_CALL_DOWN;
-      op.flags = 0;
-      op.data.message = channeld->gettables[i].content;
-      op.done_cb = payload_done;
-      op.user_data = elem;
-      grpc_call_next_op(elem, &op);
+  /* Check if it is one of the headers we care about. */
+  if (md == channeld->te_trailers || md == channeld->method_post ||
+      md == channeld->http_scheme || md == channeld->https_scheme ||
+      md == channeld->grpc_scheme || md == channeld->content_type) {
+    /* swallow it */
+    if (md == channeld->method_post) {
+      calld->seen_post = 1;
+    } else if (md->key == channeld->http_scheme->key) {
+      calld->seen_scheme = 1;
+    } else if (md == channeld->te_trailers) {
+      calld->seen_te_trailers = 1;
     }
+    /* TODO(klempner): Track that we've seen all the headers we should
+       require */
+    return NULL;
+  } else if (md->key == channeld->content_type->key) {
+    if (strncmp(grpc_mdstr_as_c_string(md->value), "application/grpc+", 17) ==
+        0) {
+      /* Although the C implementation doesn't (currently) generate them,
+         any custom +-suffix is explicitly valid. */
+      /* TODO(klempner): We should consider preallocating common values such
+         as +proto or +json, or at least stashing them if we see them. */
+      /* TODO(klempner): Should we be surfacing this to application code? */
+    } else {
+      /* TODO(klempner): We're currently allowing this, but we shouldn't
+         see it without a proxy so log for now. */
+      gpr_log(GPR_INFO, "Unexpected content-type %s",
+              channeld->content_type->key);
+    }
+    return NULL;
+  } else if (md->key == channeld->te_trailers->key ||
+             md->key == channeld->method_post->key ||
+             md->key == channeld->http_scheme->key ||
+             md->key == channeld->content_type->key) {
+    gpr_log(GPR_ERROR, "Invalid %s: header: '%s'",
+            grpc_mdstr_as_c_string(md->key), grpc_mdstr_as_c_string(md->value));
+    /* swallow it and error everything out. */
+    /* TODO(klempner): We ought to generate more descriptive error messages
+       on the wire here. */
+    grpc_call_element_send_cancel(elem);
+    return NULL;
+  } else if (md->key == channeld->path_key) {
+    if (calld->seen_path) {
+      gpr_log(GPR_ERROR, "Received :path twice");
+      return NULL;
+    }
+    calld->seen_path = 1;
+    return md;
+  } else if (md->key == channeld->host_key) {
+    /* translate host to :authority since :authority may be
+       omitted */
+    grpc_mdelem *authority = grpc_mdelem_from_metadata_strings(
+        channeld->mdctx, grpc_mdstr_ref(channeld->authority_key),
+        grpc_mdstr_ref(md->value));
+    grpc_mdelem_unref(md);
+    return authority;
+  } else {
+    return md;
   }
-  grpc_call_element_send_metadata(elem,
-                                  grpc_mdelem_ref(channeld->status_not_found));
-  grpc_call_element_send_finish(elem);
 }
 
 /* Called either:
@@ -126,115 +157,44 @@ static void call_op(grpc_call_element *elem, grpc_call_element *from_elem,
 
   switch (op->type) {
     case GRPC_RECV_METADATA:
-      /* Check if it is one of the headers we care about. */
-      if (op->data.metadata == channeld->te_trailers ||
-          op->data.metadata == channeld->method_get ||
-          op->data.metadata == channeld->method_post ||
-          op->data.metadata == channeld->http_scheme ||
-          op->data.metadata == channeld->https_scheme ||
-          op->data.metadata == channeld->grpc_scheme ||
-          op->data.metadata == channeld->content_type) {
-        /* swallow it */
-        if (op->data.metadata == channeld->method_get) {
-          calld->seen_method = GET;
-        } else if (op->data.metadata == channeld->method_post) {
-          calld->seen_method = POST;
-        } else if (op->data.metadata->key == channeld->http_scheme->key) {
-          calld->seen_scheme = 1;
-        } else if (op->data.metadata == channeld->te_trailers) {
-          calld->seen_te_trailers = 1;
-        }
-        /* TODO(klempner): Track that we've seen all the headers we should
-           require */
-        grpc_mdelem_unref(op->data.metadata);
-        op->done_cb(op->user_data, GRPC_OP_OK);
-      } else if (op->data.metadata->key == channeld->content_type->key) {
-        if (strncmp(grpc_mdstr_as_c_string(op->data.metadata->value),
-                    "application/grpc+", 17) == 0) {
-          /* Although the C implementation doesn't (currently) generate them,
-             any
-             custom +-suffix is explicitly valid. */
-          /* TODO(klempner): We should consider preallocating common values such
-             as +proto or +json, or at least stashing them if we see them. */
-          /* TODO(klempner): Should we be surfacing this to application code? */
+      grpc_metadata_batch_filter(&op->data.metadata, server_filter, elem);
+      if (!calld->got_initial_metadata) {
+        calld->got_initial_metadata = 1;
+        /* Have we seen the required http2 transport headers?
+           (:method, :scheme, content-type, with :path and :authority covered
+           at the channel level right now) */
+        if (calld->seen_post && calld->seen_scheme && calld->seen_te_trailers &&
+            calld->seen_path) {
+          grpc_call_next_op(elem, op);
         } else {
-          /* TODO(klempner): We're currently allowing this, but we shouldn't
-             see it without a proxy so log for now. */
-          gpr_log(GPR_INFO, "Unexpected content-type %s",
-                  channeld->content_type->key);
-        }
-        grpc_mdelem_unref(op->data.metadata);
-        op->done_cb(op->user_data, GRPC_OP_OK);
-      } else if (op->data.metadata->key == channeld->te_trailers->key ||
-                 op->data.metadata->key == channeld->method_post->key ||
-                 op->data.metadata->key == channeld->http_scheme->key ||
-                 op->data.metadata->key == channeld->content_type->key) {
-        gpr_log(GPR_ERROR, "Invalid %s: header: '%s'",
-                grpc_mdstr_as_c_string(op->data.metadata->key),
-                grpc_mdstr_as_c_string(op->data.metadata->value));
-        /* swallow it and error everything out. */
-        /* TODO(klempner): We ought to generate more descriptive error messages
-           on the wire here. */
-        grpc_mdelem_unref(op->data.metadata);
-        op->done_cb(op->user_data, GRPC_OP_OK);
-        grpc_call_element_send_cancel(elem);
-      } else if (op->data.metadata->key == channeld->path_key) {
-        if (calld->path != NULL) {
-          gpr_log(GPR_ERROR, "Received :path twice");
-          grpc_mdelem_unref(calld->path);
+          if (!calld->seen_path) {
+            gpr_log(GPR_ERROR, "Missing :path header");
+          }
+          if (!calld->seen_post) {
+            gpr_log(GPR_ERROR, "Missing :method header");
+          }
+          if (!calld->seen_scheme) {
+            gpr_log(GPR_ERROR, "Missing :scheme header");
+          }
+          if (!calld->seen_te_trailers) {
+            gpr_log(GPR_ERROR, "Missing te trailers header");
+          }
+          /* Error this call out */
+          grpc_metadata_batch_destroy(&op->data.metadata);
+          op->done_cb(op->user_data, GRPC_OP_OK);
+          grpc_call_element_send_cancel(elem);
         }
-        calld->path = op->data.metadata;
-        op->done_cb(op->user_data, GRPC_OP_OK);
-      } else if (op->data.metadata->key == channeld->host_key) {
-        /* translate host to :authority since :authority may be
-           omitted */
-        grpc_mdelem *authority = grpc_mdelem_from_metadata_strings(
-            channeld->mdctx, grpc_mdstr_ref(channeld->authority_key),
-            grpc_mdstr_ref(op->data.metadata->value));
-        grpc_mdelem_unref(op->data.metadata);
-        op->data.metadata = authority;
-        /* pass the event up */
-        grpc_call_next_op(elem, op);
       } else {
-        /* pass the event up */
         grpc_call_next_op(elem, op);
       }
       break;
-    case GRPC_RECV_END_OF_INITIAL_METADATA:
-      /* Have we seen the required http2 transport headers?
-         (:method, :scheme, content-type, with :path and :authority covered
-         at the channel level right now) */
-      if (calld->seen_method == POST && calld->seen_scheme &&
-          calld->seen_te_trailers && calld->path) {
-        grpc_call_element_recv_metadata(elem, calld->path);
-        calld->path = NULL;
-        grpc_call_next_op(elem, op);
-      } else if (calld->seen_method == GET) {
-        handle_get(elem);
-      } else {
-        if (calld->seen_method == NOT_RECEIVED) {
-          gpr_log(GPR_ERROR, "Missing :method header");
-        }
-        if (!calld->seen_scheme) {
-          gpr_log(GPR_ERROR, "Missing :scheme header");
-        }
-        if (!calld->seen_te_trailers) {
-          gpr_log(GPR_ERROR, "Missing te trailers header");
-        }
-        /* Error this call out */
-        op->done_cb(op->user_data, GRPC_OP_OK);
-        grpc_call_element_send_cancel(elem);
-      }
-      break;
-    case GRPC_SEND_START:
     case GRPC_SEND_METADATA:
       /* If we haven't sent status 200 yet, we need to so so because it needs to
          come before any non : prefixed metadata. */
       if (!calld->sent_status) {
         calld->sent_status = 1;
-        /* status is reffed by grpc_call_element_send_metadata */
-        grpc_call_element_send_metadata(elem,
-                                        grpc_mdelem_ref(channeld->status_ok));
+        grpc_metadata_batch_add_head(&op->data.metadata, &calld->status,
+                                     grpc_mdelem_ref(channeld->status_ok));
       }
       grpc_call_next_op(elem, op);
       break;
@@ -272,25 +232,11 @@ static void init_call_elem(grpc_call_element *elem,
   ignore_unused(channeld);
 
   /* initialize members */
-  calld->path = NULL;
-  calld->sent_status = 0;
-  calld->seen_scheme = 0;
-  calld->seen_method = NOT_RECEIVED;
-  calld->seen_te_trailers = 0;
+  memset(calld, 0, sizeof(*calld));
 }
 
 /* Destructor for call_data */
-static void destroy_call_elem(grpc_call_element *elem) {
-  /* grab pointers to our data from the call element */
-  call_data *calld = elem->call_data;
-  channel_data *channeld = elem->channel_data;
-
-  ignore_unused(channeld);
-
-  if (calld->path) {
-    grpc_mdelem_unref(calld->path);
-  }
-}
+static void destroy_call_elem(grpc_call_element *elem) {}
 
 /* Constructor for channel_data */
 static void init_channel_elem(grpc_channel_element *elem,
@@ -314,7 +260,6 @@ static void init_channel_elem(grpc_channel_element *elem,
   channeld->status_not_found =
       grpc_mdelem_from_strings(mdctx, ":status", "404");
   channeld->method_post = grpc_mdelem_from_strings(mdctx, ":method", "POST");
-  channeld->method_get = grpc_mdelem_from_strings(mdctx, ":method", "GET");
   channeld->http_scheme = grpc_mdelem_from_strings(mdctx, ":scheme", "http");
   channeld->https_scheme = grpc_mdelem_from_strings(mdctx, ":scheme", "https");
   channeld->grpc_scheme = grpc_mdelem_from_strings(mdctx, ":scheme", "grpc");
@@ -369,7 +314,6 @@ static void destroy_channel_elem(grpc_channel_element *elem) {
   grpc_mdelem_unref(channeld->status_ok);
   grpc_mdelem_unref(channeld->status_not_found);
   grpc_mdelem_unref(channeld->method_post);
-  grpc_mdelem_unref(channeld->method_get);
   grpc_mdelem_unref(channeld->http_scheme);
   grpc_mdelem_unref(channeld->https_scheme);
   grpc_mdelem_unref(channeld->grpc_scheme);

src/core/channel/metadata_buffer.c

@@ -1,149 +0,0 @@
-/*
- *
- * 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 "src/core/channel/metadata_buffer.h"
-#include <grpc/support/alloc.h>
-#include <grpc/support/log.h>
-#include <grpc/support/useful.h>
-
-#include <string.h>
-
-#define INITIAL_ELEM_CAP 8
-
-/* One queued call; we track offsets to string data in a shared buffer to
-   reduce allocations. See grpc_metadata_buffer_impl for the memory use
-   strategy */
-typedef struct {
-  grpc_mdelem *md;
-  void (*cb)(void *user_data, grpc_op_error error);
-  void *user_data;
-  gpr_uint32 flags;
-} qelem;
-
-/* Memory layout:
-
-  grpc_metadata_buffer_impl
-  followed by an array of qelem  */
-struct grpc_metadata_buffer_impl {
-  /* number of elements in q */
-  size_t elems;
-  /* capacity of q */
-  size_t elem_cap;
-};
-
-#define ELEMS(buffer) ((qelem *)((buffer) + 1))
-
-void grpc_metadata_buffer_init(grpc_metadata_buffer *buffer) {
-  /* start buffer as NULL, indicating no elements */
-  *buffer = NULL;
-}
-
-void grpc_metadata_buffer_destroy(grpc_metadata_buffer *buffer,
-                                  grpc_op_error error) {
-  size_t i;
-  qelem *qe;
-  if (*buffer) {
-    for (i = 0; i < (*buffer)->elems; i++) {
-      qe = &ELEMS(*buffer)[i];
-      grpc_mdelem_unref(qe->md);
-      qe->cb(qe->user_data, error);
-    }
-    gpr_free(*buffer);
-  }
-}
-
-void grpc_metadata_buffer_queue(grpc_metadata_buffer *buffer,
-                                grpc_call_op *op) {
-  grpc_metadata_buffer_impl *impl = *buffer;
-  qelem *qe;
-  size_t bytes;
-
-  GPR_ASSERT(op->type == GRPC_SEND_METADATA || op->type == GRPC_RECV_METADATA);
-
-  if (!impl) {
-    /* this is the first element: allocate enough space to hold the
-       header object and the initial element capacity of qelems */
-    bytes =
-        sizeof(grpc_metadata_buffer_impl) + INITIAL_ELEM_CAP * sizeof(qelem);
-    impl = gpr_malloc(bytes);
-    /* initialize the header object */
-    impl->elems = 0;
-    impl->elem_cap = INITIAL_ELEM_CAP;
-  } else if (impl->elems == impl->elem_cap) {
-    /* more qelems than what we can deal with: grow by doubling size */
-    impl->elem_cap *= 2;
-    bytes = sizeof(grpc_metadata_buffer_impl) + impl->elem_cap * sizeof(qelem);
-    impl = gpr_realloc(impl, bytes);
-  }
-
-  /* append an element to the queue */
-  qe = &ELEMS(impl)[impl->elems];
-  impl->elems++;
-
-  qe->md = op->data.metadata;
-  qe->cb = op->done_cb;
-  qe->user_data = op->user_data;
-  qe->flags = op->flags;
-
-  /* header object may have changed location: store it back */
-  *buffer = impl;
-}
-
-void grpc_metadata_buffer_flush(grpc_metadata_buffer *buffer,
-                                grpc_call_element *elem) {
-  grpc_metadata_buffer_impl *impl = *buffer;
-  grpc_call_op op;
-  qelem *qe;
-  size_t i;
-
-  if (!impl) {
-    /* nothing to send */
-    return;
-  }
-
-  /* construct call_op's, and push them down the stack */
-  op.type = GRPC_SEND_METADATA;
-  op.dir = GRPC_CALL_DOWN;
-  for (i = 0; i < impl->elems; i++) {
-    qe = &ELEMS(impl)[i];
-    op.done_cb = qe->cb;
-    op.user_data = qe->user_data;
-    op.flags = qe->flags;
-    op.data.metadata = qe->md;
-    grpc_call_next_op(elem, &op);
-  }
-
-  /* free data structures and reset to NULL: we can only flush once */
-  gpr_free(impl);
-  *buffer = NULL;
-}

src/core/channel/metadata_buffer.h

@@ -1,70 +0,0 @@
-/*
- *
- * 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.
- *
- */
-
-#ifndef GRPC_INTERNAL_CORE_CHANNEL_METADATA_BUFFER_H
-#define GRPC_INTERNAL_CORE_CHANNEL_METADATA_BUFFER_H
-
-#include "src/core/channel/channel_stack.h"
-
-/* Utility code to buffer GRPC_SEND_METADATA calls and pass them down the stack
-   all at once at some otherwise-determined time. Useful for implementing
-   filters that want to queue metadata until a START event chooses some
-   underlying filter stack to send an rpc on. */
-
-/* Clients should declare a member of grpc_metadata_buffer. This may at some
-   point become a typedef for a struct, but for now a pointer suffices */
-typedef struct grpc_metadata_buffer_impl grpc_metadata_buffer_impl;
-typedef grpc_metadata_buffer_impl *grpc_metadata_buffer;
-
-/* Initializes the metadata buffer. Allocates no memory. */
-void grpc_metadata_buffer_init(grpc_metadata_buffer *buffer);
-/* Destroy the metadata buffer. */
-void grpc_metadata_buffer_destroy(grpc_metadata_buffer *buffer,
-                                  grpc_op_error error);
-/* Append a call to the end of a metadata buffer: may allocate memory */
-void grpc_metadata_buffer_queue(grpc_metadata_buffer *buffer, grpc_call_op *op);
-/* Flush all queued operations from the metadata buffer to the element below
-   self */
-void grpc_metadata_buffer_flush(grpc_metadata_buffer *buffer,
-                                grpc_call_element *self);
-/* Count the number of queued elements in the buffer. */
-size_t grpc_metadata_buffer_count(const grpc_metadata_buffer *buffer);
-/* Extract elements as a grpc_metadata*, for presentation to applications.
-   The returned buffer must be freed with
-   grpc_metadata_buffer_cleanup_elements.
-   Clears the metadata buffer (this is a one-shot operation) */
-grpc_metadata *grpc_metadata_buffer_extract_elements(
-    grpc_metadata_buffer *buffer);
-void grpc_metadata_buffer_cleanup_elements(void *elements, grpc_op_error error);
-
-#endif  /* GRPC_INTERNAL_CORE_CHANNEL_METADATA_BUFFER_H */

src/core/httpcli/httpcli.c

@@ -40,9 +40,8 @@
 #include "src/core/iomgr/resolve_address.h"
 #include "src/core/iomgr/tcp_client.h"
 #include "src/core/httpcli/format_request.h"
-#include "src/core/httpcli/httpcli_security_context.h"
+#include "src/core/httpcli/httpcli_security_connector.h"
 #include "src/core/httpcli/parser.h"
-#include "src/core/security/security_context.h"
 #include "src/core/security/secure_transport_setup.h"
 #include "src/core/support/string.h"
 #include <grpc/support/alloc.h>
@@ -180,7 +179,7 @@ static void on_connected(void *arg, grpc_endpoint *tcp) {
   }
   req->ep = tcp;
   if (req->use_ssl) {
-    grpc_channel_security_context *ctx = NULL;
+    grpc_channel_security_connector *sc = NULL;
     const unsigned char *pem_root_certs = NULL;
     size_t pem_root_certs_size = grpc_get_default_ssl_roots(&pem_root_certs);
     if (pem_root_certs == NULL || pem_root_certs_size == 0) {
@@ -188,12 +187,12 @@ static void on_connected(void *arg, grpc_endpoint *tcp) {
       finish(req, 0);
       return;
     }
-    GPR_ASSERT(grpc_httpcli_ssl_channel_security_context_create(
-                   pem_root_certs, pem_root_certs_size, req->host, &ctx) ==
+    GPR_ASSERT(grpc_httpcli_ssl_channel_security_connector_create(
+                   pem_root_certs, pem_root_certs_size, req->host, &sc) ==
                GRPC_SECURITY_OK);
-    grpc_setup_secure_transport(&ctx->base, tcp, on_secure_transport_setup_done,
+    grpc_setup_secure_transport(&sc->base, tcp, on_secure_transport_setup_done,
                                 req);
-    grpc_security_context_unref(&ctx->base);
+    grpc_security_connector_unref(&sc->base);
   } else {
     start_write(req);
   }

src/core/httpcli/httpcli_security_context.c → src/core/httpcli/httpcli_security_connector.c

@@ -31,7 +31,7 @@
  *
  */
 
-#include "src/core/httpcli/httpcli_security_context.h"
+#include "src/core/httpcli/httpcli_security_connector.h"
 
 #include <string.h>
 
@@ -42,25 +42,25 @@
 #include "src/core/tsi/ssl_transport_security.h"
 
 typedef struct {
-  grpc_channel_security_context base;
+  grpc_channel_security_connector base;
   tsi_ssl_handshaker_factory *handshaker_factory;
   char *secure_peer_name;
-} grpc_httpcli_ssl_channel_security_context;
+} grpc_httpcli_ssl_channel_security_connector;
 
-static void httpcli_ssl_destroy(grpc_security_context *ctx) {
-  grpc_httpcli_ssl_channel_security_context *c =
-      (grpc_httpcli_ssl_channel_security_context *)ctx;
+static void httpcli_ssl_destroy(grpc_security_connector *sc) {
+  grpc_httpcli_ssl_channel_security_connector *c =
+      (grpc_httpcli_ssl_channel_security_connector *)sc;
   if (c->handshaker_factory != NULL) {
     tsi_ssl_handshaker_factory_destroy(c->handshaker_factory);
   }
   if (c->secure_peer_name != NULL) gpr_free(c->secure_peer_name);
-  gpr_free(ctx);
+  gpr_free(sc);
 }
 
 static grpc_security_status httpcli_ssl_create_handshaker(
-    grpc_security_context *ctx, tsi_handshaker **handshaker) {
-  grpc_httpcli_ssl_channel_security_context *c =
-      (grpc_httpcli_ssl_channel_security_context *)ctx;
+    grpc_security_connector *sc, tsi_handshaker **handshaker) {
+  grpc_httpcli_ssl_channel_security_connector *c =
+      (grpc_httpcli_ssl_channel_security_connector *)sc;
   tsi_result result = TSI_OK;
   if (c->handshaker_factory == NULL) return GRPC_SECURITY_ERROR;
   result = tsi_ssl_handshaker_factory_create_handshaker(
@@ -73,12 +73,12 @@ static grpc_security_status httpcli_ssl_create_handshaker(
   return GRPC_SECURITY_OK;
 }
 
-static grpc_security_status httpcli_ssl_check_peer(grpc_security_context *ctx,
+static grpc_security_status httpcli_ssl_check_peer(grpc_security_connector *sc,
                                                    tsi_peer peer,
                                                    grpc_security_check_cb cb,
                                                    void *user_data) {
-  grpc_httpcli_ssl_channel_security_context *c =
-      (grpc_httpcli_ssl_channel_security_context *)ctx;
+  grpc_httpcli_ssl_channel_security_connector *c =
+      (grpc_httpcli_ssl_channel_security_connector *)sc;
   grpc_security_status status = GRPC_SECURITY_OK;
 
   /* Check the peer name. */
@@ -92,14 +92,14 @@ static grpc_security_status httpcli_ssl_check_peer(grpc_security_context *ctx,
   return status;
 }
 
-static grpc_security_context_vtable httpcli_ssl_vtable = {
+static grpc_security_connector_vtable httpcli_ssl_vtable = {
     httpcli_ssl_destroy, httpcli_ssl_create_handshaker, httpcli_ssl_check_peer};
 
-grpc_security_status grpc_httpcli_ssl_channel_security_context_create(
+grpc_security_status grpc_httpcli_ssl_channel_security_connector_create(
     const unsigned char *pem_root_certs, size_t pem_root_certs_size,
-    const char *secure_peer_name, grpc_channel_security_context **ctx) {
+    const char *secure_peer_name, grpc_channel_security_connector **sc) {
   tsi_result result = TSI_OK;
-  grpc_httpcli_ssl_channel_security_context *c;
+  grpc_httpcli_ssl_channel_security_connector *c;
 
   if (secure_peer_name != NULL && pem_root_certs == NULL) {
     gpr_log(GPR_ERROR,
@@ -107,8 +107,8 @@ grpc_security_status grpc_httpcli_ssl_channel_security_context_create(
     return GRPC_SECURITY_ERROR;
   }
 
-  c = gpr_malloc(sizeof(grpc_httpcli_ssl_channel_security_context));
-  memset(c, 0, sizeof(grpc_httpcli_ssl_channel_security_context));
+  c = gpr_malloc(sizeof(grpc_httpcli_ssl_channel_security_connector));
+  memset(c, 0, sizeof(grpc_httpcli_ssl_channel_security_connector));
 
   gpr_ref_init(&c->base.base.refcount, 1);
   c->base.base.is_client_side = 1;
@@ -123,9 +123,9 @@ grpc_security_status grpc_httpcli_ssl_channel_security_context_create(
     gpr_log(GPR_ERROR, "Handshaker factory creation failed with %s.",
             tsi_result_to_string(result));
     httpcli_ssl_destroy(&c->base.base);
-    *ctx = NULL;
+    *sc = NULL;
     return GRPC_SECURITY_ERROR;
   }
-  *ctx = &c->base;
+  *sc = &c->base;
   return GRPC_SECURITY_OK;
 }

src/core/httpcli/httpcli_security_context.h → src/core/httpcli/httpcli_security_connector.h

@@ -31,13 +31,13 @@
  *
  */
 
-#ifndef GRPC_INTERNAL_CORE_HTTPCLI_HTTPCLI_SECURITY_CONTEXT_H
-#define GRPC_INTERNAL_CORE_HTTPCLI_HTTPCLI_SECURITY_CONTEXT_H
+#ifndef GRPC_INTERNAL_CORE_HTTPCLI_HTTPCLI_SECURITY_CONNECTOR_H
+#define GRPC_INTERNAL_CORE_HTTPCLI_HTTPCLI_SECURITY_CONNECTOR_H
 
-#include "src/core/security/security_context.h"
+#include "src/core/security/security_connector.h"
 
-grpc_security_status grpc_httpcli_ssl_channel_security_context_create(
+grpc_security_status grpc_httpcli_ssl_channel_security_connector_create(
     const unsigned char *pem_root_certs, size_t pem_root_certs_size,
-    const char *secure_peer_name, grpc_channel_security_context **ctx);
+    const char *secure_peer_name, grpc_channel_security_connector **sc);
 
-#endif  /* GRPC_INTERNAL_CORE_HTTPCLI_HTTPCLI_SECURITY_CONTEXT_H */
+#endif  /* GRPC_INTERNAL_CORE_HTTPCLI_HTTPCLI_SECURITY_CONNECTOR_H */

src/core/iomgr/iocp_windows.c

@@ -78,7 +78,6 @@ static void do_iocp_work() {
   if (overlapped == &g_iocp_custom_overlap) {
     if (completion_key == (ULONG_PTR) &g_iocp_kick_token) {
       /* We were awoken from a kick. */
-      gpr_log(GPR_DEBUG, "do_iocp_work - got a kick");
       return;
     }
     gpr_log(GPR_ERROR, "Unknown custom completion key.");
@@ -87,10 +86,8 @@ static void do_iocp_work() {
 
   socket = (grpc_winsocket*) completion_key;
   if (overlapped == &socket->write_info.overlapped) {
-    gpr_log(GPR_DEBUG, "do_iocp_work - got write packet");
     info = &socket->write_info;
   } else if (overlapped == &socket->read_info.overlapped) {
-    gpr_log(GPR_DEBUG, "do_iocp_work - got read packet");
     info = &socket->read_info;
   } else {
     gpr_log(GPR_ERROR, "Unknown IOCP operation");
@@ -98,8 +95,6 @@ static void do_iocp_work() {
   }
   success = WSAGetOverlappedResult(socket->socket, &info->overlapped, &bytes,
                                    FALSE, &flags);
-  gpr_log(GPR_DEBUG, "bytes: %u, flags: %u - op %s %s", bytes, flags,
-          success ? "succeeded" : "failed", socket->orphan ? "orphan" : "");
   if (socket->orphan) {
     grpc_winsocket_destroy(socket);
     gpr_atm_full_fetch_add(&g_orphans, -1);
@@ -189,11 +184,9 @@ static void socket_notify_on_iocp(grpc_winsocket *socket,
   if (info->has_pending_iocp) {
     run_now = 1;
     info->has_pending_iocp = 0;
-    gpr_log(GPR_DEBUG, "socket_notify_on_iocp - runs now");
   } else {
     info->cb = cb;
     info->opaque = opaque;
-    gpr_log(GPR_DEBUG, "socket_notify_on_iocp - queued");
   }
   gpr_mu_unlock(&socket->state_mu);
   if (run_now) cb(opaque, 1);
@@ -201,13 +194,11 @@ static void socket_notify_on_iocp(grpc_winsocket *socket,
 
 void grpc_socket_notify_on_write(grpc_winsocket *socket,
                                  void(*cb)(void *, int), void *opaque) {
-  gpr_log(GPR_DEBUG, "grpc_socket_notify_on_write");
   socket_notify_on_iocp(socket, cb, opaque, &socket->write_info);
 }
 
 void grpc_socket_notify_on_read(grpc_winsocket *socket,
                                 void(*cb)(void *, int), void *opaque) {
-  gpr_log(GPR_DEBUG, "grpc_socket_notify_on_read");
   socket_notify_on_iocp(socket, cb, opaque, &socket->read_info);
 }
 

src/core/iomgr/pollset_multipoller_with_poll_posix.c

@@ -203,7 +203,7 @@ static int multipoll_with_poll_pollset_maybe_work(
 }
 
 static void multipoll_with_poll_pollset_kick(grpc_pollset *p) {
-  grpc_pollset_kick_kick(&p->kick_state);
+  grpc_pollset_force_kick(p);
 }
 
 static void multipoll_with_poll_pollset_destroy(grpc_pollset *pollset) {

src/core/iomgr/pollset_posix.c

@@ -47,9 +47,11 @@
 #include "src/core/iomgr/fd_posix.h"
 #include "src/core/iomgr/iomgr_internal.h"
 #include "src/core/iomgr/socket_utils_posix.h"
+#include "src/core/profiling/timers.h"
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 #include <grpc/support/thd.h>
+#include <grpc/support/tls.h>
 #include <grpc/support/useful.h>
 
 static grpc_pollset g_backup_pollset;
@@ -57,6 +59,8 @@ static int g_shutdown_backup_poller;
 static gpr_event g_backup_poller_done;
 static gpr_event g_backup_pollset_shutdown_done;
 
+GPR_TLS_DECL(g_current_thread_poller);
+
 static void backup_poller(void *p) {
   gpr_timespec delta = gpr_time_from_millis(100);
   gpr_timespec last_poll = gpr_now();
@@ -76,17 +80,21 @@ static void backup_poller(void *p) {
 }
 
 void grpc_pollset_kick(grpc_pollset *p) {
-  if (p->counter) {
+  if (gpr_tls_get(&g_current_thread_poller) != (gpr_intptr)p && p->counter) {
     p->vtable->kick(p);
   }
 }
 
 void grpc_pollset_force_kick(grpc_pollset *p) {
-  grpc_pollset_kick_kick(&p->kick_state);
+  if (gpr_tls_get(&g_current_thread_poller) != (gpr_intptr)p) {
+    grpc_pollset_kick_kick(&p->kick_state);
+  }
 }
 
 static void kick_using_pollset_kick(grpc_pollset *p) {
-  grpc_pollset_kick_kick(&p->kick_state);
+  if (gpr_tls_get(&g_current_thread_poller) != (gpr_intptr)p) {
+    grpc_pollset_kick_kick(&p->kick_state);
+  }
 }
 
 /* global state management */
@@ -96,6 +104,8 @@ grpc_pollset *grpc_backup_pollset(void) { return &g_backup_pollset; }
 void grpc_pollset_global_init(void) {
   gpr_thd_id id;
 
+  gpr_tls_init(&g_current_thread_poller);
+
   /* Initialize kick fd state */
   grpc_pollset_kick_global_init();
 
@@ -129,6 +139,8 @@ void grpc_pollset_global_shutdown(void) {
 
   /* destroy the kick pipes */
   grpc_pollset_kick_global_destroy();
+
+  gpr_tls_destroy(&g_current_thread_poller);
 }
 
 /* main interface */
@@ -161,8 +173,8 @@ void grpc_pollset_del_fd(grpc_pollset *pollset, grpc_fd *fd) {
 
 int grpc_pollset_work(grpc_pollset *pollset, gpr_timespec deadline) {
   /* pollset->mu already held */
-  gpr_timespec now;
-  now = gpr_now();
+  gpr_timespec now = gpr_now();
+  int r;
   if (gpr_time_cmp(now, deadline) > 0) {
     return 0;
   }
@@ -172,7 +184,10 @@ int grpc_pollset_work(grpc_pollset *pollset, gpr_timespec deadline) {
   if (grpc_alarm_check(&pollset->mu, now, &deadline)) {
     return 1;
   }
-  return pollset->vtable->maybe_work(pollset, deadline, now, 1);
+  gpr_tls_set(&g_current_thread_poller, (gpr_intptr)pollset);
+  r = pollset->vtable->maybe_work(pollset, deadline, now, 1);
+  gpr_tls_set(&g_current_thread_poller, 0);
+  return r;
 }
 
 void grpc_pollset_shutdown(grpc_pollset *pollset,
@@ -396,6 +411,7 @@ static int unary_poll_pollset_maybe_work(grpc_pollset *pollset,
   pfd[1].events = grpc_fd_begin_poll(fd, pollset, POLLIN, POLLOUT, &fd_watcher);
 
   r = poll(pfd, GPR_ARRAY_SIZE(pfd), timeout);
+  GRPC_TIMER_MARK(POLL_FINISHED, r);
 
   grpc_fd_end_poll(&fd_watcher);
 

src/core/iomgr/resolve_address_windows.c

@@ -65,7 +65,6 @@ grpc_resolved_addresses *grpc_blocking_resolve_address(
   int s;
   size_t i;
   grpc_resolved_addresses *addrs = NULL;
-  const gpr_timespec start_time = gpr_now();
 
   /* parse name, splitting it into host and port parts */
   gpr_split_host_port(name, &host, &port);
@@ -107,18 +106,11 @@ grpc_resolved_addresses *grpc_blocking_resolve_address(
     i++;
   }
 
-  /* Temporary logging, to help identify flakiness in dualstack_socket_test. */
   {
-    const gpr_timespec delay = gpr_time_sub(gpr_now(), start_time);
-    const int delay_ms =
-        delay.tv_sec * GPR_MS_PER_SEC + delay.tv_nsec / GPR_NS_PER_MS;
-    gpr_log(GPR_INFO, "logspam: getaddrinfo(%s, %s) resolved %d addrs in %dms:",
-            host, port, addrs->naddrs, delay_ms);
     for (i = 0; i < addrs->naddrs; i++) {
       char *buf;
       grpc_sockaddr_to_string(&buf, (struct sockaddr *)&addrs->addrs[i].addr,
                               0);
-      gpr_log(GPR_INFO, "logspam:   [%d] %s", i, buf);
       gpr_free(buf);
     }
   }

src/core/iomgr/socket_windows.c

@@ -46,7 +46,6 @@
 
 grpc_winsocket *grpc_winsocket_create(SOCKET socket) {
   grpc_winsocket *r = gpr_malloc(sizeof(grpc_winsocket));
-  gpr_log(GPR_DEBUG, "grpc_winsocket_create");
   memset(r, 0, sizeof(grpc_winsocket));
   r->socket = socket;
   gpr_mu_init(&r->state_mu);
@@ -61,13 +60,11 @@ static void shutdown_op(grpc_winsocket_callback_info *info) {
 }
 
 void grpc_winsocket_shutdown(grpc_winsocket *socket) {
-  gpr_log(GPR_DEBUG, "grpc_winsocket_shutdown");
   shutdown_op(&socket->read_info);
   shutdown_op(&socket->write_info);
 }
 
 void grpc_winsocket_orphan(grpc_winsocket *socket) {
-  gpr_log(GPR_DEBUG, "grpc_winsocket_orphan");
   grpc_iocp_socket_orphan(socket);
   socket->orphan = 1;
   grpc_iomgr_unref();

src/core/iomgr/tcp_client_windows.c

@@ -102,7 +102,6 @@ static void on_connect(void *acp, int success) {
       gpr_free(utf8_message);
       goto finish;
     } else {
-      gpr_log(GPR_DEBUG, "on_connect: connection established");
       ep = grpc_tcp_create(ac->socket);
       goto finish;
     }
@@ -179,9 +178,7 @@ void grpc_tcp_client_connect(void(*cb)(void *arg, grpc_endpoint *tcp),
   info = &socket->write_info;
   success = ConnectEx(sock, addr, addr_len, NULL, 0, NULL, &info->overlapped);
 
-  if (success) {
-    gpr_log(GPR_DEBUG, "connected immediately - but we still go to sleep");
-  } else {
+  if (!success) {
     int error = WSAGetLastError();
     if (error != ERROR_IO_PENDING) {
       message = "ConnectEx failed: %s";
@@ -189,7 +186,6 @@ void grpc_tcp_client_connect(void(*cb)(void *arg, grpc_endpoint *tcp),
     }
   }
 
-  gpr_log(GPR_DEBUG, "grpc_tcp_client_connect: connection pending");
   ac = gpr_malloc(sizeof(async_connect));
   ac->cb = cb;
   ac->cb_arg = arg;

src/core/iomgr/tcp_server_windows.c

@@ -191,13 +191,13 @@ static void start_accept(server_port *port) {
     goto failure;
   }
 
+  /* TODO(jtattermusch): probably a race here, we regularly get use-after-free on server shutdown */
+  GPR_ASSERT(port->socket != (grpc_winsocket*)0xfeeefeee);
   success = port->AcceptEx(port->socket->socket, sock, port->addresses, 0,
                            addrlen, addrlen, &bytes_received,
                            &port->socket->read_info.overlapped);
 
-  if (success) {
-    gpr_log(GPR_DEBUG, "accepted immediately - but we still go to sleep");
-  } else {
+  if (!success) {
     int error = WSAGetLastError();
     if (error != ERROR_IO_PENDING) {
       message = "AcceptEx failed: %s";
@@ -234,11 +234,9 @@ static void on_accept(void *arg, int success) {
       gpr_free(utf8_message);
       closesocket(sock);
     } else {
-      gpr_log(GPR_DEBUG, "on_accept: accepted connection");
       ep = grpc_tcp_create(grpc_winsocket_create(sock));
     }
   } else {
-    gpr_log(GPR_DEBUG, "on_accept: shutting down");
     closesocket(sock);
     gpr_mu_lock(&sp->server->mu);
     if (0 == --sp->server->active_ports) {
@@ -248,7 +246,9 @@ static void on_accept(void *arg, int success) {
   }
 
   if (ep) sp->server->cb(sp->server->cb_arg, ep);
-  start_accept(sp);
+  if (success) {
+    start_accept(sp);
+  }
 }
 
 static int add_socket_to_server(grpc_tcp_server *s, SOCKET sock,

src/core/iomgr/tcp_windows.c

@@ -93,14 +93,11 @@ typedef struct grpc_tcp {
 } grpc_tcp;
 
 static void tcp_ref(grpc_tcp *tcp) {
-  gpr_log(GPR_DEBUG, "tcp_ref");
   gpr_ref(&tcp->refcount);
 }
 
 static void tcp_unref(grpc_tcp *tcp) {
-  gpr_log(GPR_DEBUG, "tcp_unref");
   if (gpr_unref(&tcp->refcount)) {
-    gpr_log(GPR_DEBUG, "tcp_unref: destroying");
     gpr_slice_buffer_destroy(&tcp->write_slices);
     grpc_winsocket_orphan(tcp->socket);
     gpr_free(tcp);
@@ -126,24 +123,20 @@ static void on_read(void *tcpp, int success) {
     return;
   }
 
-  gpr_log(GPR_DEBUG, "on_read");
   tcp->outstanding_read = 0;
 
   if (socket->read_info.wsa_error != 0) {
     char *utf8_message = gpr_format_message(info->wsa_error);
-    __debugbreak();
     gpr_log(GPR_ERROR, "ReadFile overlapped error: %s", utf8_message);
     gpr_free(utf8_message);
     status = GRPC_ENDPOINT_CB_ERROR;
   } else {
     if (info->bytes_transfered != 0) {
       sub = gpr_slice_sub(tcp->read_slice, 0, info->bytes_transfered);
-      gpr_log(GPR_DEBUG, "on_read: calling callback");
       status = GRPC_ENDPOINT_CB_OK;
       slice = ⊂
       nslices = 1;
     } else {
-      gpr_log(GPR_DEBUG, "on_read: closed socket");
       gpr_slice_unref(tcp->read_slice);
       status = GRPC_ENDPOINT_CB_EOF;
     }
@@ -174,27 +167,22 @@ static void win_notify_on_read(grpc_endpoint *ep,
   buffer.len = GPR_SLICE_LENGTH(tcp->read_slice);
   buffer.buf = (char *)GPR_SLICE_START_PTR(tcp->read_slice);
 
-  gpr_log(GPR_DEBUG, "win_notify_on_read: calling WSARecv without overlap");
   status = WSARecv(tcp->socket->socket, &buffer, 1, &bytes_read, &flags,
                    NULL, NULL);
   info->wsa_error = status == 0 ? 0 : WSAGetLastError();
 
   if (info->wsa_error != WSAEWOULDBLOCK) {
-    gpr_log(GPR_DEBUG, "got response immediately, calling on_read");
     info->bytes_transfered = bytes_read;
     /* This might heavily recurse. */
     on_read(tcp, 1);
     return;
   }
 
-  gpr_log(GPR_DEBUG, "got WSAEWOULDBLOCK - calling WSARecv with overlap");
-
   memset(&tcp->socket->read_info.overlapped, 0, sizeof(OVERLAPPED));
   status = WSARecv(tcp->socket->socket, &buffer, 1, &bytes_read, &flags,
                    &info->overlapped, NULL);
 
   if (status == 0) {
-    gpr_log(GPR_DEBUG, "got response immediately, but we're going to sleep");
     grpc_socket_notify_on_read(tcp->socket, on_read, tcp);
     return;
   }
@@ -213,7 +201,6 @@ static void win_notify_on_read(grpc_endpoint *ep,
     return;
   }
 
-  gpr_log(GPR_DEBUG, "waiting on the IO completion port now");
   grpc_socket_notify_on_read(tcp->socket, on_read, tcp);
 }
 
@@ -227,8 +214,6 @@ static void on_write(void *tcpp, int success) {
 
   GPR_ASSERT(tcp->outstanding_write);
 
-  gpr_log(GPR_DEBUG, "on_write");
-
   if (!success) {
     tcp_unref(tcp);
     cb(opaque, GRPC_ENDPOINT_CB_SHUTDOWN);
@@ -265,13 +250,9 @@ static grpc_endpoint_write_status win_write(grpc_endpoint *ep,
   WSABUF *allocated = NULL;
   WSABUF *buffers = local_buffers;
 
-  GPR_ASSERT(nslices != 0);
-  GPR_ASSERT(GPR_SLICE_LENGTH(slices[0]) != 0);
   GPR_ASSERT(!tcp->outstanding_write);
   tcp_ref(tcp);
 
-  gpr_log(GPR_DEBUG, "win_write");
-
   tcp->outstanding_write = 1;
   tcp->write_cb = cb;
   tcp->write_user_data = arg;
@@ -287,14 +268,12 @@ static grpc_endpoint_write_status win_write(grpc_endpoint *ep,
     buffers[i].buf = (char *)GPR_SLICE_START_PTR(tcp->write_slices.slices[i]);
   }
 
-  gpr_log(GPR_DEBUG, "win_write: calling WSASend without overlap");
   status = WSASend(socket->socket, buffers, tcp->write_slices.count,
                    &bytes_sent, 0, NULL, NULL);
   info->wsa_error = status == 0 ? 0 : WSAGetLastError();
 
   if (info->wsa_error != WSAEWOULDBLOCK) {
     grpc_endpoint_write_status ret = GRPC_ENDPOINT_WRITE_ERROR;
-    gpr_log(GPR_DEBUG, "got response immediately, cleaning up and leaving");
     if (status == 0) {
       ret = GRPC_ENDPOINT_WRITE_DONE;
       GPR_ASSERT(bytes_sent == tcp->write_slices.length);
@@ -310,8 +289,6 @@ static grpc_endpoint_write_status win_write(grpc_endpoint *ep,
     return ret;
   }
 
-  gpr_log(GPR_DEBUG, "got WSAEWOULDBLOCK - calling WSASend with overlap");
-
   memset(&socket->write_info, 0, sizeof(OVERLAPPED));
   status = WSASend(socket->socket, buffers, tcp->write_slices.count,
                    &bytes_sent, 0, &socket->write_info.overlapped, NULL);
@@ -329,9 +306,6 @@ static grpc_endpoint_write_status win_write(grpc_endpoint *ep,
       tcp_unref(tcp);
       return GRPC_ENDPOINT_WRITE_ERROR;
     }
-    gpr_log(GPR_DEBUG, "win_write: got pending op");
-  } else {
-    gpr_log(GPR_DEBUG, "wrote data immediately - but we're going to sleep");
   }
 
   grpc_socket_notify_on_write(socket, on_write, tcp);
@@ -340,19 +314,16 @@ static grpc_endpoint_write_status win_write(grpc_endpoint *ep,
 
 static void win_add_to_pollset(grpc_endpoint *ep, grpc_pollset *pollset) {
   grpc_tcp *tcp = (grpc_tcp *) ep;
-  gpr_log(GPR_DEBUG, "win_add_to_pollset");
   grpc_iocp_add_socket(tcp->socket);
 }
 
 static void win_shutdown(grpc_endpoint *ep) {
   grpc_tcp *tcp = (grpc_tcp *) ep;
-  gpr_log(GPR_DEBUG, "win_shutdown");
   grpc_winsocket_shutdown(tcp->socket);
 }
 
 static void win_destroy(grpc_endpoint *ep) {
   grpc_tcp *tcp = (grpc_tcp *) ep;
-  gpr_log(GPR_DEBUG, "win_destroy");
   tcp_unref(tcp);
 }
 

src/core/security/auth.c

@@ -40,21 +40,24 @@
 
 #include "src/core/support/string.h"
 #include "src/core/channel/channel_stack.h"
-#include "src/core/security/security_context.h"
+#include "src/core/security/security_connector.h"
 #include "src/core/security/credentials.h"
 #include "src/core/surface/call.h"
 
+#define MAX_CREDENTIALS_METADATA_COUNT 4
+
 /* We can have a per-call credentials. */
 typedef struct {
   grpc_credentials *creds;
   grpc_mdstr *host;
   grpc_mdstr *method;
   grpc_call_op op;
+  grpc_linked_mdelem md_links[MAX_CREDENTIALS_METADATA_COUNT];
 } call_data;
 
 /* We can have a per-channel credentials. */
 typedef struct {
-  grpc_channel_security_context *security_context;
+  grpc_channel_security_connector *security_connector;
   grpc_mdctx *md_ctx;
   grpc_mdstr *authority_string;
   grpc_mdstr *path_string;
@@ -62,30 +65,8 @@ typedef struct {
   grpc_mdstr *status_key;
 } channel_data;
 
-static void do_nothing(void *ignored, grpc_op_error error) {}
-
 static void bubbleup_error(grpc_call_element *elem, const char *error_msg) {
-  grpc_call_op finish_op;
-  channel_data *channeld = elem->channel_data;
-  char status[GPR_LTOA_MIN_BUFSIZE];
-
-  gpr_log(GPR_ERROR, "%s", error_msg);
-  finish_op.type = GRPC_RECV_METADATA;
-  finish_op.dir = GRPC_CALL_UP;
-  finish_op.flags = 0;
-  finish_op.data.metadata = grpc_mdelem_from_metadata_strings(
-      channeld->md_ctx, grpc_mdstr_ref(channeld->error_msg_key),
-      grpc_mdstr_from_string(channeld->md_ctx, error_msg));
-  finish_op.done_cb = do_nothing;
-  finish_op.user_data = NULL;
-  grpc_call_next_op(elem, &finish_op);
-
-  gpr_ltoa(GRPC_STATUS_UNAUTHENTICATED, status);
-  finish_op.data.metadata = grpc_mdelem_from_metadata_strings(
-      channeld->md_ctx, grpc_mdstr_ref(channeld->status_key),
-      grpc_mdstr_from_string(channeld->md_ctx, status));
-  grpc_call_next_op(elem, &finish_op);
-
+  grpc_call_element_recv_status(elem, GRPC_STATUS_UNAUTHENTICATED, error_msg);
   grpc_call_element_send_cancel(elem);
 }
 
@@ -93,11 +74,15 @@ static void on_credentials_metadata(void *user_data, grpc_mdelem **md_elems,
                                     size_t num_md,
                                     grpc_credentials_status status) {
   grpc_call_element *elem = (grpc_call_element *)user_data;
+  call_data *calld = elem->call_data;
+  grpc_call_op op = calld->op;
   size_t i;
+  GPR_ASSERT(num_md <= MAX_CREDENTIALS_METADATA_COUNT);
   for (i = 0; i < num_md; i++) {
-    grpc_call_element_send_metadata(elem, grpc_mdelem_ref(md_elems[i]));
+    grpc_metadata_batch_add_tail(&op.data.metadata, &calld->md_links[i],
+                                 grpc_mdelem_ref(md_elems[i]));
   }
-  grpc_call_next_op(elem, &((call_data *)elem->call_data)->op);
+  grpc_call_next_op(elem, &op);
 }
 
 static char *build_service_url(const char *url_scheme, call_data *calld) {
@@ -126,7 +111,7 @@ static void send_security_metadata(grpc_call_element *elem, grpc_call_op *op) {
   channel_data *channeld = elem->channel_data;
 
   grpc_credentials *channel_creds =
-      channeld->security_context->request_metadata_creds;
+      channeld->security_connector->request_metadata_creds;
   /* TODO(jboeuf):
      Decide on the policy in this case:
      - populate both channel and call?
@@ -138,7 +123,7 @@ static void send_security_metadata(grpc_call_element *elem, grpc_call_op *op) {
   if (channel_creds != NULL &&
       grpc_credentials_has_request_metadata(channel_creds)) {
     char *service_url =
-        build_service_url(channeld->security_context->base.url_scheme, calld);
+        build_service_url(channeld->security_connector->base.url_scheme, calld);
     calld->op = *op; /* Copy op (originates from the caller's stack). */
     grpc_credentials_get_request_metadata(channel_creds, service_url,
                                           on_credentials_metadata, elem);
@@ -159,6 +144,7 @@ static void on_host_checked(void *user_data, grpc_security_status status) {
     gpr_asprintf(&error_msg, "Invalid host %s set in :authority metadata.",
                  grpc_mdstr_as_c_string(calld->host));
     bubbleup_error(elem, error_msg);
+    grpc_metadata_batch_destroy(&calld->op.data.metadata);
     gpr_free(error_msg);
     calld->op.done_cb(calld->op.user_data, GRPC_OP_ERROR);
   }
@@ -174,27 +160,28 @@ static void call_op(grpc_call_element *elem, grpc_call_element *from_elem,
   /* grab pointers to our data from the call element */
   call_data *calld = elem->call_data;
   channel_data *channeld = elem->channel_data;
+  grpc_linked_mdelem *l;
 
   switch (op->type) {
     case GRPC_SEND_METADATA:
-      /* Pointer comparison is OK for md_elems created from the same context. */
-      if (op->data.metadata->key == channeld->authority_string) {
-        if (calld->host != NULL) grpc_mdstr_unref(calld->host);
-        calld->host = grpc_mdstr_ref(op->data.metadata->value);
-      } else if (op->data.metadata->key == channeld->path_string) {
-        if (calld->method != NULL) grpc_mdstr_unref(calld->method);
-        calld->method = grpc_mdstr_ref(op->data.metadata->value);
+      for (l = op->data.metadata.list.head; l != NULL; l = l->next) {
+        grpc_mdelem *md = l->md;
+        /* Pointer comparison is OK for md_elems created from the same context.
+         */
+        if (md->key == channeld->authority_string) {
+          if (calld->host != NULL) grpc_mdstr_unref(calld->host);
+          calld->host = grpc_mdstr_ref(md->value);
+        } else if (md->key == channeld->path_string) {
+          if (calld->method != NULL) grpc_mdstr_unref(calld->method);
+          calld->method = grpc_mdstr_ref(md->value);
+        }
       }
-      grpc_call_next_op(elem, op);
-      break;
-
-    case GRPC_SEND_START:
       if (calld->host != NULL) {
         grpc_security_status status;
         const char *call_host = grpc_mdstr_as_c_string(calld->host);
         calld->op = *op; /* Copy op (originates from the caller's stack). */
-        status = grpc_channel_security_context_check_call_host(
-            channeld->security_context, call_host, on_host_checked, elem);
+        status = grpc_channel_security_connector_check_call_host(
+            channeld->security_connector, call_host, on_host_checked, elem);
         if (status != GRPC_SECURITY_OK) {
           if (status == GRPC_SECURITY_ERROR) {
             char *error_msg;
@@ -202,6 +189,7 @@ static void call_op(grpc_call_element *elem, grpc_call_element *from_elem,
                          "Invalid host %s set in :authority metadata.",
                          call_host);
             bubbleup_error(elem, error_msg);
+            grpc_metadata_batch_destroy(&calld->op.data.metadata);
             gpr_free(error_msg);
             op->done_cb(op->user_data, GRPC_OP_ERROR);
           }
@@ -210,7 +198,6 @@ static void call_op(grpc_call_element *elem, grpc_call_element *from_elem,
       }
       send_security_metadata(elem, op);
       break;
-
     default:
       /* pass control up or down the stack depending on op->dir */
       grpc_call_next_op(elem, op);
@@ -255,7 +242,7 @@ static void init_channel_elem(grpc_channel_element *elem,
                               const grpc_channel_args *args,
                               grpc_mdctx *metadata_context, int is_first,
                               int is_last) {
-  grpc_security_context *ctx = grpc_find_security_context_in_args(args);
+  grpc_security_connector *ctx = grpc_find_security_connector_in_args(args);
   /* grab pointers to our data from the channel element */
   channel_data *channeld = elem->channel_data;
 
@@ -268,23 +255,24 @@ static void init_channel_elem(grpc_channel_element *elem,
 
   /* initialize members */
   GPR_ASSERT(ctx->is_client_side);
-  channeld->security_context =
-      (grpc_channel_security_context *)grpc_security_context_ref(ctx);
+  channeld->security_connector =
+      (grpc_channel_security_connector *)grpc_security_connector_ref(ctx);
   channeld->md_ctx = metadata_context;
   channeld->authority_string =
       grpc_mdstr_from_string(channeld->md_ctx, ":authority");
   channeld->path_string = grpc_mdstr_from_string(channeld->md_ctx, ":path");
   channeld->error_msg_key =
       grpc_mdstr_from_string(channeld->md_ctx, "grpc-message");
-  channeld->status_key = grpc_mdstr_from_string(channeld->md_ctx, "grpc-status");
+  channeld->status_key =
+      grpc_mdstr_from_string(channeld->md_ctx, "grpc-status");
 }
 
 /* Destructor for channel data */
 static void destroy_channel_elem(grpc_channel_element *elem) {
   /* grab pointers to our data from the channel element */
   channel_data *channeld = elem->channel_data;
-  grpc_channel_security_context *ctx = channeld->security_context;
-  if (ctx != NULL) grpc_security_context_unref(&ctx->base);
+  grpc_channel_security_connector *ctx = channeld->security_connector;
+  if (ctx != NULL) grpc_security_connector_unref(&ctx->base);
   if (channeld->authority_string != NULL) {
     grpc_mdstr_unref(channeld->authority_string);
   }
@@ -300,6 +288,5 @@ static void destroy_channel_elem(grpc_channel_element *elem) {
 }
 
 const grpc_channel_filter grpc_client_auth_filter = {
-    call_op,           channel_op,           sizeof(call_data),
-    init_call_elem,    destroy_call_elem,    sizeof(channel_data),
-    init_channel_elem, destroy_channel_elem, "auth"};
+    call_op, channel_op, sizeof(call_data), init_call_elem, destroy_call_elem,
+    sizeof(channel_data), init_channel_elem, destroy_channel_elem, "auth"};

src/core/security/credentials.c

@@ -36,11 +36,14 @@
 #include <string.h>
 #include <stdio.h>
 
+#include "src/core/channel/channel_args.h"
+#include "src/core/channel/http_client_filter.h"
 #include "src/core/json/json.h"
 #include "src/core/httpcli/httpcli.h"
 #include "src/core/iomgr/iomgr.h"
 #include "src/core/security/json_token.h"
 #include "src/core/support/string.h"
+
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 #include <grpc/support/sync.h>
@@ -111,9 +114,33 @@ void grpc_credentials_get_request_metadata(grpc_credentials *creds,
   creds->vtable->get_request_metadata(creds, service_url, cb, user_data);
 }
 
-grpc_mdctx *grpc_credentials_get_metadata_context(grpc_credentials *creds) {
-  if (creds == NULL) return NULL;
-  return creds->vtable->get_metadata_context(creds);
+grpc_mdctx *grpc_credentials_get_or_create_metadata_context(
+    grpc_credentials *creds) {
+  grpc_mdctx *mdctx = NULL;
+  if (creds != NULL && creds->vtable->get_metadata_context != NULL) {
+    mdctx = creds->vtable->get_metadata_context(creds);
+  }
+  if (mdctx == NULL) {
+    return grpc_mdctx_create();
+  } else {
+    grpc_mdctx_ref(mdctx);
+    return mdctx;
+  }
+}
+
+grpc_security_status grpc_credentials_create_security_connector(
+    grpc_credentials *creds, const char *target, const grpc_channel_args *args,
+    grpc_credentials *request_metadata_creds,
+    grpc_channel_security_connector **sc, grpc_channel_args **new_args) {
+  *new_args = NULL;
+  if (creds == NULL || creds->vtable->create_security_connector == NULL ||
+      grpc_credentials_has_request_metadata_only(creds)) {
+    gpr_log(GPR_ERROR,
+            "Invalid credentials for creating a security connector.");
+    return GRPC_SECURITY_ERROR;
+  }
+  return creds->vtable->create_security_connector(
+      creds, target, args, request_metadata_creds, sc, new_args);
 }
 
 void grpc_server_credentials_release(grpc_server_credentials *creds) {
@@ -121,6 +148,15 @@ void grpc_server_credentials_release(grpc_server_credentials *creds) {
   creds->vtable->destroy(creds);
 }
 
+grpc_security_status grpc_server_credentials_create_security_connector(
+    grpc_server_credentials *creds, grpc_security_connector **sc) {
+  if (creds == NULL || creds->vtable->create_security_connector == NULL) {
+    gpr_log(GPR_ERROR, "Server credentials cannot create security context.");
+    return GRPC_SECURITY_ERROR;
+  }
+  return creds->vtable->create_security_connector(creds, sc);
+}
+
 /* -- Ssl credentials. -- */
 
 typedef struct {
@@ -176,32 +212,49 @@ static grpc_mdctx *ssl_get_metadata_context(grpc_credentials *creds) {
   return NULL;
 }
 
-static grpc_credentials_vtable ssl_vtable = {
-    ssl_destroy, ssl_has_request_metadata, ssl_has_request_metadata_only,
-    ssl_get_metadata_context, NULL};
-
-static grpc_server_credentials_vtable ssl_server_vtable = {ssl_server_destroy};
-
-const grpc_ssl_config *grpc_ssl_credentials_get_config(
-    const grpc_credentials *creds) {
-  if (creds == NULL || strcmp(creds->type, GRPC_CREDENTIALS_TYPE_SSL)) {
-    return NULL;
-  } else {
-    grpc_ssl_credentials *c = (grpc_ssl_credentials *)creds;
-    return &c->config;
+static grpc_security_status ssl_create_security_connector(
+    grpc_credentials *creds, const char *target, const grpc_channel_args *args,
+    grpc_credentials *request_metadata_creds,
+    grpc_channel_security_connector **sc, grpc_channel_args **new_args) {
+  grpc_ssl_credentials *c = (grpc_ssl_credentials *)creds;
+  grpc_security_status status = GRPC_SECURITY_OK;
+  size_t i = 0;
+  const char *overridden_target_name = NULL;
+  grpc_arg arg;
+
+  for (i = 0; args && i < args->num_args; i++) {
+    grpc_arg *arg = &args->args[i];
+    if (strcmp(arg->key, GRPC_SSL_TARGET_NAME_OVERRIDE_ARG) == 0 &&
+        arg->type == GRPC_ARG_STRING) {
+      overridden_target_name = arg->value.string;
+      break;
+    }
+  }
+  status = grpc_ssl_channel_security_connector_create(
+      request_metadata_creds, &c->config, target, overridden_target_name, sc);
+  if (status != GRPC_SECURITY_OK) {
+    return status;
   }
+  arg.type = GRPC_ARG_STRING;
+  arg.key = GRPC_ARG_HTTP2_SCHEME;
+  arg.value.string = "https";
+  *new_args = grpc_channel_args_copy_and_add(args, &arg);
+  return status;
 }
 
-const grpc_ssl_server_config *grpc_ssl_server_credentials_get_config(
-    const grpc_server_credentials *creds) {
-  if (creds == NULL || strcmp(creds->type, GRPC_CREDENTIALS_TYPE_SSL)) {
-    return NULL;
-  } else {
-    grpc_ssl_server_credentials *c = (grpc_ssl_server_credentials *)creds;
-    return &c->config;
-  }
+static grpc_security_status ssl_server_create_security_connector(
+    grpc_server_credentials *creds, grpc_security_connector **sc) {
+  grpc_ssl_server_credentials *c = (grpc_ssl_server_credentials *)creds;
+  return grpc_ssl_server_security_connector_create(&c->config, sc);
 }
 
+static grpc_credentials_vtable ssl_vtable = {
+    ssl_destroy, ssl_has_request_metadata, ssl_has_request_metadata_only,
+    ssl_get_metadata_context, NULL, ssl_create_security_connector};
+
+static grpc_server_credentials_vtable ssl_server_vtable = {
+    ssl_server_destroy, ssl_server_create_security_connector};
+
 static void ssl_copy_key_material(const char *input, unsigned char **output,
                                   size_t *output_size) {
   *output_size = strlen(input);
@@ -388,7 +441,7 @@ static grpc_mdctx *jwt_get_metadata_context(grpc_credentials *creds) {
 
 static grpc_credentials_vtable jwt_vtable = {
     jwt_destroy, jwt_has_request_metadata, jwt_has_request_metadata_only,
-    jwt_get_metadata_context, jwt_get_request_metadata};
+    jwt_get_metadata_context, jwt_get_request_metadata, NULL};
 
 grpc_credentials *grpc_jwt_credentials_create(const char *json_key,
                                               gpr_timespec token_lifetime) {
@@ -613,7 +666,7 @@ static grpc_credentials_vtable compute_engine_vtable = {
     oauth2_token_fetcher_destroy, oauth2_token_fetcher_has_request_metadata,
     oauth2_token_fetcher_has_request_metadata_only,
     oauth2_token_fetcher_get_metadata_context,
-    oauth2_token_fetcher_get_request_metadata};
+    oauth2_token_fetcher_get_request_metadata, NULL};
 
 static void compute_engine_fetch_oauth2(
     grpc_credentials_metadata_request *metadata_req,
@@ -657,7 +710,7 @@ static grpc_credentials_vtable service_account_vtable = {
     service_account_destroy, oauth2_token_fetcher_has_request_metadata,
     oauth2_token_fetcher_has_request_metadata_only,
     oauth2_token_fetcher_get_metadata_context,
-    oauth2_token_fetcher_get_request_metadata};
+    oauth2_token_fetcher_get_request_metadata, NULL};
 
 static void service_account_fetch_oauth2(
     grpc_credentials_metadata_request *metadata_req,
@@ -731,7 +784,7 @@ static grpc_credentials_vtable refresh_token_vtable = {
     refresh_token_destroy, oauth2_token_fetcher_has_request_metadata,
     oauth2_token_fetcher_has_request_metadata_only,
     oauth2_token_fetcher_get_metadata_context,
-    oauth2_token_fetcher_get_request_metadata};
+    oauth2_token_fetcher_get_request_metadata, NULL};
 
 static void refresh_token_fetch_oauth2(
     grpc_credentials_metadata_request *metadata_req,
@@ -834,7 +887,7 @@ static grpc_mdctx *fake_oauth2_get_metadata_context(grpc_credentials *creds) {
 static grpc_credentials_vtable fake_oauth2_vtable = {
     fake_oauth2_destroy, fake_oauth2_has_request_metadata,
     fake_oauth2_has_request_metadata_only, fake_oauth2_get_metadata_context,
-    fake_oauth2_get_request_metadata};
+    fake_oauth2_get_request_metadata, NULL};
 
 grpc_credentials *grpc_fake_oauth2_credentials_create(
     const char *token_md_value, int is_async) {
@@ -878,15 +931,33 @@ static grpc_mdctx *fake_transport_security_get_metadata_context(
   return NULL;
 }
 
+static grpc_security_status
+fake_transport_security_create_security_connector(
+    grpc_credentials *c, const char *target, const grpc_channel_args *args,
+    grpc_credentials *request_metadata_creds,
+    grpc_channel_security_connector **sc, grpc_channel_args **new_args) {
+  *sc = grpc_fake_channel_security_connector_create(request_metadata_creds, 1);
+  return GRPC_SECURITY_OK;
+}
+
+static grpc_security_status
+fake_transport_security_server_create_security_connector(
+    grpc_server_credentials *c, grpc_security_connector **sc) {
+  *sc = grpc_fake_server_security_connector_create();
+  return GRPC_SECURITY_OK;
+}
+
 static grpc_credentials_vtable fake_transport_security_credentials_vtable = {
     fake_transport_security_credentials_destroy,
     fake_transport_security_has_request_metadata,
     fake_transport_security_has_request_metadata_only,
-    fake_transport_security_get_metadata_context, NULL};
+    fake_transport_security_get_metadata_context, NULL,
+    fake_transport_security_create_security_connector};
 
 static grpc_server_credentials_vtable
     fake_transport_security_server_credentials_vtable = {
-        fake_transport_security_server_credentials_destroy};
+        fake_transport_security_server_credentials_destroy,
+        fake_transport_security_server_create_security_connector};
 
 grpc_credentials *grpc_fake_transport_security_credentials_create(void) {
   grpc_credentials *c = gpr_malloc(sizeof(grpc_credentials));
@@ -911,6 +982,7 @@ grpc_server_credentials *grpc_fake_transport_security_server_credentials_create(
 typedef struct {
   grpc_credentials base;
   grpc_credentials_array inner;
+  grpc_credentials *connector_creds;
 } grpc_composite_credentials;
 
 typedef struct {
@@ -1038,7 +1110,10 @@ static grpc_mdctx *composite_get_metadata_context(grpc_credentials *creds) {
   size_t i;
   for (i = 0; i < c->inner.num_creds; i++) {
     grpc_credentials *inner_creds = c->inner.creds_array[i];
-    grpc_mdctx *inner_ctx = grpc_credentials_get_metadata_context(inner_creds);
+    grpc_mdctx *inner_ctx = NULL;
+    if (inner_creds->vtable->get_metadata_context != NULL) {
+      inner_ctx = inner_creds->vtable->get_metadata_context(inner_creds);
+    }
     if (inner_ctx) {
       GPR_ASSERT(ctx == NULL &&
                  "can only have one metadata context per composite credential");
@@ -1048,10 +1123,24 @@ static grpc_mdctx *composite_get_metadata_context(grpc_credentials *creds) {
   return ctx;
 }
 
+static grpc_security_status composite_create_security_connector(
+    grpc_credentials *creds, const char *target, const grpc_channel_args *args,
+    grpc_credentials *request_metadata_creds,
+    grpc_channel_security_connector **sc, grpc_channel_args **new_args) {
+  grpc_composite_credentials *c = (grpc_composite_credentials *)creds;
+  if (c->connector_creds == NULL) {
+    gpr_log(GPR_ERROR,
+            "Cannot create security connector, missing connector credentials.");
+    return GRPC_SECURITY_ERROR;
+  }
+  return grpc_credentials_create_security_connector(c->connector_creds, target,
+                                                    args, creds, sc, new_args);
+}
+
 static grpc_credentials_vtable composite_credentials_vtable = {
     composite_destroy, composite_has_request_metadata,
     composite_has_request_metadata_only, composite_get_metadata_context,
-    composite_get_request_metadata};
+    composite_get_request_metadata, composite_create_security_connector};
 
 static grpc_credentials_array get_creds_array(grpc_credentials **creds_addr) {
   grpc_credentials_array result;
@@ -1067,6 +1156,7 @@ static grpc_credentials_array get_creds_array(grpc_credentials **creds_addr) {
 grpc_credentials *grpc_composite_credentials_create(grpc_credentials *creds1,
                                                     grpc_credentials *creds2) {
   size_t i;
+  size_t creds_array_byte_size;
   grpc_credentials_array creds1_array;
   grpc_credentials_array creds2_array;
   grpc_composite_credentials *c;
@@ -1080,16 +1170,39 @@ grpc_credentials *grpc_composite_credentials_create(grpc_credentials *creds1,
   creds1_array = get_creds_array(&creds1);
   creds2_array = get_creds_array(&creds2);
   c->inner.num_creds = creds1_array.num_creds + creds2_array.num_creds;
-  c->inner.creds_array =
-      gpr_malloc(c->inner.num_creds * sizeof(grpc_credentials *));
+  creds_array_byte_size = c->inner.num_creds * sizeof(grpc_credentials *);
+  c->inner.creds_array = gpr_malloc(creds_array_byte_size);
+  memset(c->inner.creds_array, 0, creds_array_byte_size);
   for (i = 0; i < creds1_array.num_creds; i++) {
-    c->inner.creds_array[i] = grpc_credentials_ref(creds1_array.creds_array[i]);
+    grpc_credentials *cur_creds = creds1_array.creds_array[i];
+    if (!grpc_credentials_has_request_metadata_only(cur_creds)) {
+      if (c->connector_creds == NULL) {
+        c->connector_creds = cur_creds;
+      } else {
+        gpr_log(GPR_ERROR, "Cannot compose multiple connector credentials.");
+        goto fail;
+      }
+    }
+    c->inner.creds_array[i] = grpc_credentials_ref(cur_creds);
   }
   for (i = 0; i < creds2_array.num_creds; i++) {
+    grpc_credentials *cur_creds = creds2_array.creds_array[i];
+    if (!grpc_credentials_has_request_metadata_only(cur_creds)) {
+      if (c->connector_creds == NULL) {
+        c->connector_creds = cur_creds;
+      } else {
+        gpr_log(GPR_ERROR, "Cannot compose multiple connector credentials.");
+        goto fail;
+      }
+    }
     c->inner.creds_array[i + creds1_array.num_creds] =
-        grpc_credentials_ref(creds2_array.creds_array[i]);
+        grpc_credentials_ref(cur_creds);
   }
   return &c->base;
+
+fail:
+  grpc_credentials_unref(&c->base);
+  return NULL;
 }
 
 const grpc_credentials_array *grpc_composite_credentials_get_credentials(
@@ -1163,7 +1276,7 @@ static grpc_mdctx *iam_get_metadata_context(grpc_credentials *creds) {
 
 static grpc_credentials_vtable iam_vtable = {
     iam_destroy, iam_has_request_metadata, iam_has_request_metadata_only,
-    iam_get_metadata_context, iam_get_request_metadata};
+    iam_get_metadata_context, iam_get_request_metadata, NULL};
 
 grpc_credentials *grpc_iam_credentials_create(const char *token,
                                               const char *authority_selector) {

src/core/security/credentials.h

@@ -39,6 +39,8 @@
 #include <grpc/grpc_security.h>
 #include <grpc/support/sync.h>
 
+#include "src/core/security/security_connector.h"
+
 struct grpc_httpcli_response;
 
 /* --- Constants. --- */
@@ -99,6 +101,11 @@ typedef struct {
                                const char *service_url,
                                grpc_credentials_metadata_cb cb,
                                void *user_data);
+  grpc_security_status (*create_security_connector)(
+      grpc_credentials *c, const char *target, const grpc_channel_args *args,
+      grpc_credentials *request_metadata_creds,
+      grpc_channel_security_connector **sc, grpc_channel_args **new_args);
+
 } grpc_credentials_vtable;
 
 struct grpc_credentials {
@@ -115,19 +122,20 @@ void grpc_credentials_get_request_metadata(grpc_credentials *creds,
                                            const char *service_url,
                                            grpc_credentials_metadata_cb cb,
                                            void *user_data);
-grpc_mdctx *grpc_credentials_get_metadata_context(grpc_credentials *creds);
 
-typedef struct {
-  unsigned char *pem_private_key;
-  size_t pem_private_key_size;
-  unsigned char *pem_cert_chain;
-  size_t pem_cert_chain_size;
-  unsigned char *pem_root_certs;
-  size_t pem_root_certs_size;
-} grpc_ssl_config;
+/* Gets the mdctx from the credentials and increase the refcount if it exists,
+   otherwise, create a new one. */
+grpc_mdctx *grpc_credentials_get_or_create_metadata_context(
+    grpc_credentials *creds);
 
-const grpc_ssl_config *grpc_ssl_credentials_get_config(
-    const grpc_credentials *ssl_creds);
+/* Creates a security connector for the channel. May also create new channel
+   args for the channel to be used in place of the passed in const args if
+   returned non NULL. In that case the caller is responsible for destroying
+   new_args after channel creation. */
+grpc_security_status grpc_credentials_create_security_connector(
+    grpc_credentials *creds, const char *target, const grpc_channel_args *args,
+    grpc_credentials *request_metadata_creds,
+    grpc_channel_security_connector **sc, grpc_channel_args **new_args);
 
 typedef struct {
   grpc_credentials **creds_array;
@@ -159,6 +167,8 @@ grpc_credentials *grpc_fake_oauth2_credentials_create(
 
 typedef struct {
   void (*destroy)(grpc_server_credentials *c);
+  grpc_security_status (*create_security_connector)(
+      grpc_server_credentials *c, grpc_security_connector **sc);
 } grpc_server_credentials_vtable;
 
 struct grpc_server_credentials {
@@ -166,17 +176,7 @@ struct grpc_server_credentials {
   const char *type;
 };
 
-typedef struct {
-  unsigned char **pem_private_keys;
-  size_t *pem_private_keys_sizes;
-  unsigned char **pem_cert_chains;
-  size_t *pem_cert_chains_sizes;
-  size_t num_key_cert_pairs;
-  unsigned char *pem_root_certs;
-  size_t pem_root_certs_size;
-} grpc_ssl_server_config;
-
-const grpc_ssl_server_config *grpc_ssl_server_credentials_get_config(
-    const grpc_server_credentials *ssl_creds);
+grpc_security_status grpc_server_credentials_create_security_connector(
+    grpc_server_credentials *creds, grpc_security_connector **sc);
 
 #endif  /* GRPC_INTERNAL_CORE_SECURITY_CREDENTIALS_H */

src/core/security/secure_transport_setup.c

@@ -43,7 +43,7 @@
 #define GRPC_INITIAL_HANDSHAKE_BUFFER_SIZE 256
 
 typedef struct {
-  grpc_security_context *ctx;
+  grpc_security_connector *connector;
   tsi_handshaker *handshaker;
   unsigned char *handshake_buffer;
   size_t handshake_buffer_size;
@@ -74,7 +74,7 @@ static void secure_transport_setup_done(grpc_secure_transport_setup *s,
   if (s->handshaker != NULL) tsi_handshaker_destroy(s->handshaker);
   if (s->handshake_buffer != NULL) gpr_free(s->handshake_buffer);
   gpr_slice_buffer_destroy(&s->left_overs);
-  grpc_security_context_unref(s->ctx);
+  grpc_security_connector_unref(s->connector);
   gpr_free(s);
 }
 
@@ -112,8 +112,8 @@ static void check_peer(grpc_secure_transport_setup *s) {
     secure_transport_setup_done(s, 0);
     return;
   }
-  peer_status =
-      grpc_security_context_check_peer(s->ctx, peer, on_peer_checked, s);
+  peer_status = grpc_security_connector_check_peer(s->connector, peer,
+                                                   on_peer_checked, s);
   if (peer_status == GRPC_SECURITY_ERROR) {
     gpr_log(GPR_ERROR, "Peer check failed.");
     secure_transport_setup_done(s, 0);
@@ -262,7 +262,7 @@ static void on_handshake_data_sent_to_peer(void *setup,
   }
 }
 
-void grpc_setup_secure_transport(grpc_security_context *ctx,
+void grpc_setup_secure_transport(grpc_security_connector *connector,
                                  grpc_endpoint *nonsecure_endpoint,
                                  grpc_secure_transport_setup_done_cb cb,
                                  void *user_data) {
@@ -270,12 +270,12 @@ void grpc_setup_secure_transport(grpc_security_context *ctx,
   grpc_secure_transport_setup *s =
       gpr_malloc(sizeof(grpc_secure_transport_setup));
   memset(s, 0, sizeof(grpc_secure_transport_setup));
-  result = grpc_security_context_create_handshaker(ctx, &s->handshaker);
+  result = grpc_security_connector_create_handshaker(connector, &s->handshaker);
   if (result != GRPC_SECURITY_OK) {
     secure_transport_setup_done(s, 0);
     return;
   }
-  s->ctx = grpc_security_context_ref(ctx);
+  s->connector = grpc_security_connector_ref(connector);
   s->handshake_buffer_size = GRPC_INITIAL_HANDSHAKE_BUFFER_SIZE;
   s->handshake_buffer = gpr_malloc(s->handshake_buffer_size);
   s->endpoint = nonsecure_endpoint;

src/core/security/secure_transport_setup.h

@@ -35,7 +35,7 @@
 #define GRPC_INTERNAL_CORE_SECURITY_SECURE_TRANSPORT_SETUP_H
 
 #include "src/core/iomgr/endpoint.h"
-#include "src/core/security/security_context.h"
+#include "src/core/security/security_connector.h"
 
 /* --- Secure transport setup --- */
 
@@ -45,7 +45,7 @@ typedef void (*grpc_secure_transport_setup_done_cb)(
     grpc_endpoint *secure_endpoint);
 
 /* Calls the callback upon completion. */
-void grpc_setup_secure_transport(grpc_security_context *ctx,
+void grpc_setup_secure_transport(grpc_security_connector *connector,
                                  grpc_endpoint *nonsecure_endpoint,
                                  grpc_secure_transport_setup_done_cb cb,
                                  void *user_data);

src/core/security/security_context.c → src/core/security/security_connector.c

@@ -31,12 +31,10 @@
  *
  */
 
-#include "src/core/security/security_context.h"
+#include "src/core/security/security_connector.h"
 
 #include <string.h>
 
-#include "src/core/channel/channel_args.h"
-#include "src/core/channel/http_client_filter.h"
 #include "src/core/security/credentials.h"
 #include "src/core/security/secure_endpoint.h"
 #include "src/core/support/env.h"
@@ -56,7 +54,8 @@
 #ifndef INSTALL_PREFIX
 static const char *installed_roots_path = "/usr/share/grpc/roots.pem";
 #else
-static const char *installed_roots_path = INSTALL_PREFIX "/share/grpc/roots.pem";
+static const char *installed_roots_path =
+    INSTALL_PREFIX "/share/grpc/roots.pem";
 #endif
 
 /* -- Cipher suites. -- */
@@ -82,75 +81,77 @@ static const char *ssl_cipher_suites(void) {
 
 /* -- Common methods. -- */
 
-grpc_security_status grpc_security_context_create_handshaker(
-    grpc_security_context *ctx, tsi_handshaker **handshaker) {
-  if (ctx == NULL || handshaker == NULL) return GRPC_SECURITY_ERROR;
-  return ctx->vtable->create_handshaker(ctx, handshaker);
+grpc_security_status grpc_security_connector_create_handshaker(
+    grpc_security_connector *sc, tsi_handshaker **handshaker) {
+  if (sc == NULL || handshaker == NULL) return GRPC_SECURITY_ERROR;
+  return sc->vtable->create_handshaker(sc, handshaker);
 }
 
-grpc_security_status grpc_security_context_check_peer(
-    grpc_security_context *ctx, tsi_peer peer, grpc_security_check_cb cb,
+grpc_security_status grpc_security_connector_check_peer(
+    grpc_security_connector *sc, tsi_peer peer, grpc_security_check_cb cb,
     void *user_data) {
-  if (ctx == NULL) {
+  if (sc == NULL) {
     tsi_peer_destruct(&peer);
     return GRPC_SECURITY_ERROR;
   }
-  return ctx->vtable->check_peer(ctx, peer, cb, user_data);
+  return sc->vtable->check_peer(sc, peer, cb, user_data);
 }
 
-grpc_security_status grpc_channel_security_context_check_call_host(
-    grpc_channel_security_context *ctx, const char *host,
+grpc_security_status grpc_channel_security_connector_check_call_host(
+    grpc_channel_security_connector *sc, const char *host,
     grpc_security_check_cb cb, void *user_data) {
-  if (ctx == NULL || ctx->check_call_host == NULL) return GRPC_SECURITY_ERROR;
-  return ctx->check_call_host(ctx, host, cb, user_data);
+  if (sc == NULL || sc->check_call_host == NULL) return GRPC_SECURITY_ERROR;
+  return sc->check_call_host(sc, host, cb, user_data);
 }
 
-void grpc_security_context_unref(grpc_security_context *ctx) {
-  if (ctx == NULL) return;
-  if (gpr_unref(&ctx->refcount)) ctx->vtable->destroy(ctx);
+void grpc_security_connector_unref(grpc_security_connector *sc) {
+  if (sc == NULL) return;
+  if (gpr_unref(&sc->refcount)) sc->vtable->destroy(sc);
 }
 
-grpc_security_context *grpc_security_context_ref(grpc_security_context *ctx) {
-  if (ctx == NULL) return NULL;
-  gpr_ref(&ctx->refcount);
-  return ctx;
+grpc_security_connector *grpc_security_connector_ref(
+    grpc_security_connector *sc) {
+  if (sc == NULL) return NULL;
+  gpr_ref(&sc->refcount);
+  return sc;
 }
 
-static void context_pointer_arg_destroy(void *p) {
-  grpc_security_context_unref(p);
+static void connector_pointer_arg_destroy(void *p) {
+  grpc_security_connector_unref(p);
 }
 
-static void *context_pointer_arg_copy(void *p) {
-  return grpc_security_context_ref(p);
+static void *connector_pointer_arg_copy(void *p) {
+  return grpc_security_connector_ref(p);
 }
 
-grpc_arg grpc_security_context_to_arg(grpc_security_context *ctx) {
+grpc_arg grpc_security_connector_to_arg(grpc_security_connector *sc) {
   grpc_arg result;
   result.type = GRPC_ARG_POINTER;
-  result.key = GRPC_SECURITY_CONTEXT_ARG;
-  result.value.pointer.destroy = context_pointer_arg_destroy;
-  result.value.pointer.copy = context_pointer_arg_copy;
-  result.value.pointer.p = ctx;
+  result.key = GRPC_SECURITY_CONNECTOR_ARG;
+  result.value.pointer.destroy = connector_pointer_arg_destroy;
+  result.value.pointer.copy = connector_pointer_arg_copy;
+  result.value.pointer.p = sc;
   return result;
 }
 
-grpc_security_context *grpc_security_context_from_arg(const grpc_arg *arg) {
-  if (strcmp(arg->key, GRPC_SECURITY_CONTEXT_ARG)) return NULL;
+grpc_security_connector *grpc_security_connector_from_arg(const grpc_arg *arg) {
+  if (strcmp(arg->key, GRPC_SECURITY_CONNECTOR_ARG)) return NULL;
   if (arg->type != GRPC_ARG_POINTER) {
     gpr_log(GPR_ERROR, "Invalid type %d for arg %s", arg->type,
-            GRPC_SECURITY_CONTEXT_ARG);
+            GRPC_SECURITY_CONNECTOR_ARG);
     return NULL;
   }
   return arg->value.pointer.p;
 }
 
-grpc_security_context *grpc_find_security_context_in_args(
+grpc_security_connector *grpc_find_security_connector_in_args(
     const grpc_channel_args *args) {
   size_t i;
   if (args == NULL) return NULL;
   for (i = 0; i < args->num_args; i++) {
-    grpc_security_context *ctx = grpc_security_context_from_arg(&args->args[i]);
-    if (ctx != NULL) return ctx;
+    grpc_security_connector *sc =
+        grpc_security_connector_from_arg(&args->args[i]);
+    if (sc != NULL) return sc;
   }
   return NULL;
 }
@@ -158,51 +159,41 @@ grpc_security_context *grpc_find_security_context_in_args(
 static int check_request_metadata_creds(grpc_credentials *creds) {
   if (creds != NULL && !grpc_credentials_has_request_metadata(creds)) {
     gpr_log(GPR_ERROR,
-            "Incompatible credentials for channel security context: needs to "
+            "Incompatible credentials for channel security connector: needs to "
             "set request metadata.");
     return 0;
   }
   return 1;
 }
 
-static grpc_mdctx *get_or_create_mdctx(grpc_credentials *creds) {
-  grpc_mdctx *mdctx = grpc_credentials_get_metadata_context(creds);
-  if (mdctx == NULL) {
-    mdctx = grpc_mdctx_create();
-  } else {
-    grpc_mdctx_ref(mdctx);
-  }
-  return mdctx;
-}
-
 /* -- Fake implementation. -- */
 
 typedef struct {
-  grpc_channel_security_context base;
+  grpc_channel_security_connector base;
   int call_host_check_is_async;
-} grpc_fake_channel_security_context;
+} grpc_fake_channel_security_connector;
 
-static void fake_channel_destroy(grpc_security_context *ctx) {
-  grpc_channel_security_context *c = (grpc_channel_security_context *)ctx;
+static void fake_channel_destroy(grpc_security_connector *sc) {
+  grpc_channel_security_connector *c = (grpc_channel_security_connector *)sc;
   grpc_credentials_unref(c->request_metadata_creds);
-  gpr_free(ctx);
+  gpr_free(sc);
 }
 
-static void fake_server_destroy(grpc_security_context *ctx) { gpr_free(ctx); }
+static void fake_server_destroy(grpc_security_connector *sc) { gpr_free(sc); }
 
 static grpc_security_status fake_channel_create_handshaker(
-    grpc_security_context *ctx, tsi_handshaker **handshaker) {
+    grpc_security_connector *sc, tsi_handshaker **handshaker) {
   *handshaker = tsi_create_fake_handshaker(1);
   return GRPC_SECURITY_OK;
 }
 
 static grpc_security_status fake_server_create_handshaker(
-    grpc_security_context *ctx, tsi_handshaker **handshaker) {
+    grpc_security_connector *sc, tsi_handshaker **handshaker) {
   *handshaker = tsi_create_fake_handshaker(0);
   return GRPC_SECURITY_OK;
 }
 
-static grpc_security_status fake_check_peer(grpc_security_context *ctx,
+static grpc_security_status fake_check_peer(grpc_security_connector *sc,
                                             tsi_peer peer,
                                             grpc_security_check_cb cb,
                                             void *user_data) {
@@ -238,10 +229,10 @@ end:
 }
 
 static grpc_security_status fake_channel_check_call_host(
-    grpc_channel_security_context *ctx, const char *host,
+    grpc_channel_security_connector *sc, const char *host,
     grpc_security_check_cb cb, void *user_data) {
-  grpc_fake_channel_security_context *c =
-      (grpc_fake_channel_security_context *)ctx;
+  grpc_fake_channel_security_connector *c =
+      (grpc_fake_channel_security_connector *)sc;
   if (c->call_host_check_is_async) {
     cb(user_data, GRPC_SECURITY_OK);
     return GRPC_SECURITY_PENDING;
@@ -250,16 +241,16 @@ static grpc_security_status fake_channel_check_call_host(
   }
 }
 
-static grpc_security_context_vtable fake_channel_vtable = {
+static grpc_security_connector_vtable fake_channel_vtable = {
     fake_channel_destroy, fake_channel_create_handshaker, fake_check_peer};
 
-static grpc_security_context_vtable fake_server_vtable = {
+static grpc_security_connector_vtable fake_server_vtable = {
     fake_server_destroy, fake_server_create_handshaker, fake_check_peer};
 
-grpc_channel_security_context *grpc_fake_channel_security_context_create(
+grpc_channel_security_connector *grpc_fake_channel_security_connector_create(
     grpc_credentials *request_metadata_creds, int call_host_check_is_async) {
-  grpc_fake_channel_security_context *c =
-      gpr_malloc(sizeof(grpc_fake_channel_security_context));
+  grpc_fake_channel_security_connector *c =
+      gpr_malloc(sizeof(grpc_fake_channel_security_connector));
   gpr_ref_init(&c->base.base.refcount, 1);
   c->base.base.is_client_side = 1;
   c->base.base.url_scheme = GRPC_FAKE_SECURITY_URL_SCHEME;
@@ -271,8 +262,8 @@ grpc_channel_security_context *grpc_fake_channel_security_context_create(
   return &c->base;
 }
 
-grpc_security_context *grpc_fake_server_security_context_create(void) {
-  grpc_security_context *c = gpr_malloc(sizeof(grpc_security_context));
+grpc_security_connector *grpc_fake_server_security_connector_create(void) {
+  grpc_security_connector *c = gpr_malloc(sizeof(grpc_security_connector));
   gpr_ref_init(&c->refcount, 1);
   c->vtable = &fake_server_vtable;
   c->url_scheme = GRPC_FAKE_SECURITY_URL_SCHEME;
@@ -282,21 +273,21 @@ grpc_security_context *grpc_fake_server_security_context_create(void) {
 /* --- Ssl implementation. --- */
 
 typedef struct {
-  grpc_channel_security_context base;
+  grpc_channel_security_connector base;
   tsi_ssl_handshaker_factory *handshaker_factory;
   char *target_name;
   char *overridden_target_name;
   tsi_peer peer;
-} grpc_ssl_channel_security_context;
+} grpc_ssl_channel_security_connector;
 
 typedef struct {
-  grpc_security_context base;
+  grpc_security_connector base;
   tsi_ssl_handshaker_factory *handshaker_factory;
-} grpc_ssl_server_security_context;
+} grpc_ssl_server_security_connector;
 
-static void ssl_channel_destroy(grpc_security_context *ctx) {
-  grpc_ssl_channel_security_context *c =
-      (grpc_ssl_channel_security_context *)ctx;
+static void ssl_channel_destroy(grpc_security_connector *sc) {
+  grpc_ssl_channel_security_connector *c =
+      (grpc_ssl_channel_security_connector *)sc;
   grpc_credentials_unref(c->base.request_metadata_creds);
   if (c->handshaker_factory != NULL) {
     tsi_ssl_handshaker_factory_destroy(c->handshaker_factory);
@@ -304,15 +295,16 @@ static void ssl_channel_destroy(grpc_security_context *ctx) {
   if (c->target_name != NULL) gpr_free(c->target_name);
   if (c->overridden_target_name != NULL) gpr_free(c->overridden_target_name);
   tsi_peer_destruct(&c->peer);
-  gpr_free(ctx);
+  gpr_free(sc);
 }
 
-static void ssl_server_destroy(grpc_security_context *ctx) {
-  grpc_ssl_server_security_context *c = (grpc_ssl_server_security_context *)ctx;
+static void ssl_server_destroy(grpc_security_connector *sc) {
+  grpc_ssl_server_security_connector *c =
+      (grpc_ssl_server_security_connector *)sc;
   if (c->handshaker_factory != NULL) {
     tsi_ssl_handshaker_factory_destroy(c->handshaker_factory);
   }
-  gpr_free(ctx);
+  gpr_free(sc);
 }
 
 static grpc_security_status ssl_create_handshaker(
@@ -331,9 +323,9 @@ static grpc_security_status ssl_create_handshaker(
 }
 
 static grpc_security_status ssl_channel_create_handshaker(
-    grpc_security_context *ctx, tsi_handshaker **handshaker) {
-  grpc_ssl_channel_security_context *c =
-      (grpc_ssl_channel_security_context *)ctx;
+    grpc_security_connector *sc, tsi_handshaker **handshaker) {
+  grpc_ssl_channel_security_connector *c =
+      (grpc_ssl_channel_security_connector *)sc;
   return ssl_create_handshaker(c->handshaker_factory, 1,
                                c->overridden_target_name != NULL
                                    ? c->overridden_target_name
@@ -342,13 +334,13 @@ static grpc_security_status ssl_channel_create_handshaker(
 }
 
 static grpc_security_status ssl_server_create_handshaker(
-    grpc_security_context *ctx, tsi_handshaker **handshaker) {
-  grpc_ssl_server_security_context *c = (grpc_ssl_server_security_context *)ctx;
+    grpc_security_connector *sc, tsi_handshaker **handshaker) {
+  grpc_ssl_server_security_connector *c =
+      (grpc_ssl_server_security_connector *)sc;
   return ssl_create_handshaker(c->handshaker_factory, 0, NULL, handshaker);
 }
 
-static int ssl_host_matches_name(const tsi_peer *peer,
-                                 const char *peer_name) {
+static int ssl_host_matches_name(const tsi_peer *peer, const char *peer_name) {
   char *allocated_name = NULL;
   int r;
 
@@ -384,8 +376,7 @@ static grpc_security_status ssl_check_peer(const char *peer_name,
   }
 
   /* Check the peer name if specified. */
-  if (peer_name != NULL &&
-      !ssl_host_matches_name(peer, peer_name)) {
+  if (peer_name != NULL && !ssl_host_matches_name(peer, peer_name)) {
     gpr_log(GPR_ERROR, "Peer name %s is not in peer certificate", peer_name);
     return GRPC_SECURITY_ERROR;
   }
@@ -393,12 +384,12 @@ static grpc_security_status ssl_check_peer(const char *peer_name,
   return GRPC_SECURITY_OK;
 }
 
-static grpc_security_status ssl_channel_check_peer(grpc_security_context *ctx,
+static grpc_security_status ssl_channel_check_peer(grpc_security_connector *sc,
                                                    tsi_peer peer,
                                                    grpc_security_check_cb cb,
                                                    void *user_data) {
-  grpc_ssl_channel_security_context *c =
-      (grpc_ssl_channel_security_context *)ctx;
+  grpc_ssl_channel_security_connector *c =
+      (grpc_ssl_channel_security_connector *)sc;
   grpc_security_status status;
   tsi_peer_destruct(&c->peer);
   c->peer = peer;
@@ -409,7 +400,7 @@ static grpc_security_status ssl_channel_check_peer(grpc_security_context *ctx,
   return status;
 }
 
-static grpc_security_status ssl_server_check_peer(grpc_security_context *ctx,
+static grpc_security_status ssl_server_check_peer(grpc_security_connector *sc,
                                                   tsi_peer peer,
                                                   grpc_security_check_cb cb,
                                                   void *user_data) {
@@ -420,10 +411,10 @@ static grpc_security_status ssl_server_check_peer(grpc_security_context *ctx,
 }
 
 static grpc_security_status ssl_channel_check_call_host(
-    grpc_channel_security_context *ctx, const char *host,
+    grpc_channel_security_connector *sc, const char *host,
     grpc_security_check_cb cb, void *user_data) {
-  grpc_ssl_channel_security_context *c =
-      (grpc_ssl_channel_security_context *)ctx;
+  grpc_ssl_channel_security_connector *c =
+      (grpc_ssl_channel_security_connector *)sc;
 
   if (ssl_host_matches_name(&c->peer, host)) return GRPC_SECURITY_OK;
 
@@ -437,10 +428,10 @@ static grpc_security_status ssl_channel_check_call_host(
   }
 }
 
-static grpc_security_context_vtable ssl_channel_vtable = {
+static grpc_security_connector_vtable ssl_channel_vtable = {
     ssl_channel_destroy, ssl_channel_create_handshaker, ssl_channel_check_peer};
 
-static grpc_security_context_vtable ssl_server_vtable = {
+static grpc_security_connector_vtable ssl_server_vtable = {
     ssl_server_destroy, ssl_server_create_handshaker, ssl_server_check_peer};
 
 static gpr_slice default_pem_root_certs;
@@ -471,17 +462,17 @@ size_t grpc_get_default_ssl_roots(const unsigned char **pem_root_certs) {
   return GPR_SLICE_LENGTH(default_pem_root_certs);
 }
 
-grpc_security_status grpc_ssl_channel_security_context_create(
+grpc_security_status grpc_ssl_channel_security_connector_create(
     grpc_credentials *request_metadata_creds, const grpc_ssl_config *config,
     const char *target_name, const char *overridden_target_name,
-    grpc_channel_security_context **ctx) {
+    grpc_channel_security_connector **sc) {
   size_t num_alpn_protocols = grpc_chttp2_num_alpn_versions();
   const unsigned char **alpn_protocol_strings =
       gpr_malloc(sizeof(const char *) * num_alpn_protocols);
   unsigned char *alpn_protocol_string_lengths =
       gpr_malloc(sizeof(unsigned char) * num_alpn_protocols);
   tsi_result result = TSI_OK;
-  grpc_ssl_channel_security_context *c;
+  grpc_ssl_channel_security_connector *c;
   size_t i;
   const unsigned char *pem_root_certs;
   size_t pem_root_certs_size;
@@ -502,8 +493,8 @@ grpc_security_status grpc_ssl_channel_security_context_create(
     goto error;
   }
 
-  c = gpr_malloc(sizeof(grpc_ssl_channel_security_context));
-  memset(c, 0, sizeof(grpc_ssl_channel_security_context));
+  c = gpr_malloc(sizeof(grpc_ssl_channel_security_connector));
+  memset(c, 0, sizeof(grpc_ssl_channel_security_connector));
 
   gpr_ref_init(&c->base.base.refcount, 1);
   c->base.base.vtable = &ssl_channel_vtable;
@@ -535,10 +526,10 @@ grpc_security_status grpc_ssl_channel_security_context_create(
     gpr_log(GPR_ERROR, "Handshaker factory creation failed with %s.",
             tsi_result_to_string(result));
     ssl_channel_destroy(&c->base.base);
-    *ctx = NULL;
+    *sc = NULL;
     goto error;
   }
-  *ctx = &c->base;
+  *sc = &c->base;
   gpr_free(alpn_protocol_strings);
   gpr_free(alpn_protocol_string_lengths);
   return GRPC_SECURITY_OK;
@@ -549,15 +540,15 @@ error:
   return GRPC_SECURITY_ERROR;
 }
 
-grpc_security_status grpc_ssl_server_security_context_create(
-    const grpc_ssl_server_config *config, grpc_security_context **ctx) {
+grpc_security_status grpc_ssl_server_security_connector_create(
+    const grpc_ssl_server_config *config, grpc_security_connector **sc) {
   size_t num_alpn_protocols = grpc_chttp2_num_alpn_versions();
   const unsigned char **alpn_protocol_strings =
       gpr_malloc(sizeof(const char *) * num_alpn_protocols);
   unsigned char *alpn_protocol_string_lengths =
       gpr_malloc(sizeof(unsigned char) * num_alpn_protocols);
   tsi_result result = TSI_OK;
-  grpc_ssl_server_security_context *c;
+  grpc_ssl_server_security_connector *c;
   size_t i;
 
   for (i = 0; i < num_alpn_protocols; i++) {
@@ -571,8 +562,8 @@ grpc_security_status grpc_ssl_server_security_context_create(
     gpr_log(GPR_ERROR, "An SSL server needs a key and a cert.");
     goto error;
   }
-  c = gpr_malloc(sizeof(grpc_ssl_server_security_context));
-  memset(c, 0, sizeof(grpc_ssl_server_security_context));
+  c = gpr_malloc(sizeof(grpc_ssl_server_security_connector));
+  memset(c, 0, sizeof(grpc_ssl_server_security_connector));
 
   gpr_ref_init(&c->base.refcount, 1);
   c->base.url_scheme = GRPC_SSL_URL_SCHEME;
@@ -582,17 +573,17 @@ grpc_security_status grpc_ssl_server_security_context_create(
       config->pem_private_keys_sizes,
       (const unsigned char **)config->pem_cert_chains,
       config->pem_cert_chains_sizes, config->num_key_cert_pairs,
-      config->pem_root_certs, config->pem_root_certs_size,
-      ssl_cipher_suites(), alpn_protocol_strings,
-      alpn_protocol_string_lengths, num_alpn_protocols, &c->handshaker_factory);
+      config->pem_root_certs, config->pem_root_certs_size, ssl_cipher_suites(),
+      alpn_protocol_strings, alpn_protocol_string_lengths, num_alpn_protocols,
+      &c->handshaker_factory);
   if (result != TSI_OK) {
     gpr_log(GPR_ERROR, "Handshaker factory creation failed with %s.",
             tsi_result_to_string(result));
     ssl_server_destroy(&c->base);
-    *ctx = NULL;
+    *sc = NULL;
     goto error;
   }
-  *ctx = &c->base;
+  *sc = &c->base;
   gpr_free(alpn_protocol_strings);
   gpr_free(alpn_protocol_string_lengths);
   return GRPC_SECURITY_OK;
@@ -603,84 +594,3 @@ error:
   return GRPC_SECURITY_ERROR;
 }
 
-/* -- High level objects. -- */
-
-grpc_channel *grpc_ssl_channel_create(grpc_credentials *ssl_creds,
-                                      grpc_credentials *request_metadata_creds,
-                                      const char *target,
-                                      const grpc_channel_args *args) {
-  grpc_channel_security_context *ctx = NULL;
-  grpc_channel *channel = NULL;
-  grpc_security_status status = GRPC_SECURITY_OK;
-  size_t i = 0;
-  const char *overridden_target_name = NULL;
-  grpc_arg arg;
-  grpc_channel_args *new_args;
-
-  for (i = 0; args && i < args->num_args; i++) {
-    grpc_arg *arg = &args->args[i];
-    if (strcmp(arg->key, GRPC_SSL_TARGET_NAME_OVERRIDE_ARG) == 0 &&
-        arg->type == GRPC_ARG_STRING) {
-      overridden_target_name = arg->value.string;
-      break;
-    }
-  }
-  status = grpc_ssl_channel_security_context_create(
-      request_metadata_creds, grpc_ssl_credentials_get_config(ssl_creds),
-      target, overridden_target_name, &ctx);
-  if (status != GRPC_SECURITY_OK) {
-    return grpc_lame_client_channel_create();
-  }
-  arg.type = GRPC_ARG_STRING;
-  arg.key = GRPC_ARG_HTTP2_SCHEME;
-  arg.value.string = "https";
-  new_args = grpc_channel_args_copy_and_add(args, &arg);
-  channel = grpc_secure_channel_create_internal(
-      target, new_args, ctx, get_or_create_mdctx(request_metadata_creds));
-  grpc_security_context_unref(&ctx->base);
-  grpc_channel_args_destroy(new_args);
-  return channel;
-}
-
-grpc_channel *grpc_fake_transport_security_channel_create(
-    grpc_credentials *fake_creds, grpc_credentials *request_metadata_creds,
-    const char *target, const grpc_channel_args *args) {
-  grpc_channel_security_context *ctx =
-      grpc_fake_channel_security_context_create(request_metadata_creds, 1);
-  grpc_channel *channel = grpc_secure_channel_create_internal(
-      target, args, ctx, get_or_create_mdctx(request_metadata_creds));
-  grpc_security_context_unref(&ctx->base);
-  return channel;
-}
-
-grpc_channel *grpc_secure_channel_create_with_factories(
-    const grpc_secure_channel_factory *factories, size_t num_factories,
-    grpc_credentials *creds, const char *target,
-    const grpc_channel_args *args) {
-  size_t i;
-  if (creds == NULL) {
-    gpr_log(GPR_ERROR, "No credentials to create a secure channel.");
-    return grpc_lame_client_channel_create();
-  }
-  if (grpc_credentials_has_request_metadata_only(creds)) {
-    gpr_log(GPR_ERROR,
-            "Credentials is insufficient to create a secure channel.");
-    return grpc_lame_client_channel_create();
-  }
-
-  for (i = 0; i < num_factories; i++) {
-    grpc_credentials *composite_creds = NULL;
-    grpc_credentials *transport_security_creds = NULL;
-    transport_security_creds = grpc_credentials_contains_type(
-        creds, factories[i].creds_type, &composite_creds);
-    if (transport_security_creds != NULL) {
-      return factories[i].factory(transport_security_creds, composite_creds,
-                                  target, args);
-    }
-  }
-
-  gpr_log(GPR_ERROR,
-          "Unknown credentials type %s for creating a secure channel.",
-          creds->type);
-  return grpc_lame_client_channel_create();
-}

src/core/security/security_connector.h

@@ -0,0 +1,201 @@
+/*
+ *
+ * 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.
+ *
+ */
+
+#ifndef GRPC_INTERNAL_CORE_SECURITY_SECURITY_CONNECTOR_H
+#define GRPC_INTERNAL_CORE_SECURITY_SECURITY_CONNECTOR_H
+
+#include <grpc/grpc_security.h>
+#include "src/core/iomgr/endpoint.h"
+#include "src/core/tsi/transport_security_interface.h"
+
+/* --- status enum. --- */
+
+typedef enum {
+  GRPC_SECURITY_OK = 0,
+  GRPC_SECURITY_PENDING,
+  GRPC_SECURITY_ERROR
+} grpc_security_status;
+
+/* --- URL schemes. --- */
+
+#define GRPC_SSL_URL_SCHEME "https"
+#define GRPC_FAKE_SECURITY_URL_SCHEME "http+fake_security"
+
+/* --- security_connector object. ---
+
+    A security connector object represents away to configure the underlying
+    transport security mechanism and check the resulting trusted peer.  */
+
+typedef struct grpc_security_connector grpc_security_connector;
+
+#define GRPC_SECURITY_CONNECTOR_ARG "grpc.security_connector"
+
+typedef void (*grpc_security_check_cb)(void *user_data,
+                                       grpc_security_status status);
+
+typedef struct {
+  void (*destroy)(grpc_security_connector *sc);
+  grpc_security_status (*create_handshaker)(grpc_security_connector *sc,
+                                            tsi_handshaker **handshaker);
+  grpc_security_status (*check_peer)(grpc_security_connector *sc, tsi_peer peer,
+                                     grpc_security_check_cb cb,
+                                     void *user_data);
+} grpc_security_connector_vtable;
+
+struct grpc_security_connector {
+  const grpc_security_connector_vtable *vtable;
+  gpr_refcount refcount;
+  int is_client_side;
+  const char *url_scheme;
+};
+
+/* Increments the refcount. */
+grpc_security_connector *grpc_security_connector_ref(
+    grpc_security_connector *sc);
+
+/* Decrements the refcount and destroys the object if it reaches 0. */
+void grpc_security_connector_unref(grpc_security_connector *sc);
+
+/* Handshake creation. */
+grpc_security_status grpc_security_connector_create_handshaker(
+    grpc_security_connector *sc, tsi_handshaker **handshaker);
+
+/* Check the peer.
+   Implementations can choose to check the peer either synchronously or
+   asynchronously. In the first case, a successful call will return
+   GRPC_SECURITY_OK. In the asynchronous case, the call will return
+   GRPC_SECURITY_PENDING unless an error is detected early on.
+   Ownership of the peer is transfered.
+*/
+grpc_security_status grpc_security_connector_check_peer(
+    grpc_security_connector *sc, tsi_peer peer, grpc_security_check_cb cb,
+    void *user_data);
+
+/* Util to encapsulate the connector in a channel arg. */
+grpc_arg grpc_security_connector_to_arg(grpc_security_connector *sc);
+
+/* Util to get the connector from a channel arg. */
+grpc_security_connector *grpc_security_connector_from_arg(const grpc_arg *arg);
+
+/* Util to find the connector from channel args. */
+grpc_security_connector *grpc_find_security_connector_in_args(
+    const grpc_channel_args *args);
+
+/* --- channel_security_connector object. ---
+
+    A channel security connector object represents away to configure the
+    underlying transport security mechanism on the client side.  */
+
+typedef struct grpc_channel_security_connector grpc_channel_security_connector;
+
+struct grpc_channel_security_connector {
+  grpc_security_connector base; /* requires is_client_side to be non 0. */
+  grpc_credentials *request_metadata_creds;
+  grpc_security_status (*check_call_host)(grpc_channel_security_connector *sc,
+                                          const char *host,
+                                          grpc_security_check_cb cb,
+                                          void *user_data);
+};
+
+/* Checks that the host that will be set for a call is acceptable.
+   Implementations can choose do the check either synchronously or
+   asynchronously. In the first case, a successful call will return
+   GRPC_SECURITY_OK. In the asynchronous case, the call will return
+   GRPC_SECURITY_PENDING unless an error is detected early on. */
+grpc_security_status grpc_channel_security_connector_check_call_host(
+    grpc_channel_security_connector *sc, const char *host,
+    grpc_security_check_cb cb, void *user_data);
+
+/* --- Creation security connectors. --- */
+
+/* For TESTING ONLY!
+   Creates a fake connector that emulates real channel security.  */
+grpc_channel_security_connector *grpc_fake_channel_security_connector_create(
+    grpc_credentials *request_metadata_creds, int call_host_check_is_async);
+
+/* For TESTING ONLY!
+   Creates a fake connector that emulates real server security.  */
+grpc_security_connector *grpc_fake_server_security_connector_create(void);
+
+/* Config for ssl clients. */
+typedef struct {
+  unsigned char *pem_private_key;
+  size_t pem_private_key_size;
+  unsigned char *pem_cert_chain;
+  size_t pem_cert_chain_size;
+  unsigned char *pem_root_certs;
+  size_t pem_root_certs_size;
+} grpc_ssl_config;
+
+/* Creates an SSL channel_security_connector.
+   - request_metadata_creds is the credentials object which metadata
+     will be sent with each request. This parameter can be NULL.
+   - config is the SSL config to be used for the SSL channel establishment.
+   - is_client should be 0 for a server or a non-0 value for a client.
+   - secure_peer_name is the secure peer name that should be checked in
+     grpc_channel_security_connector_check_peer. This parameter may be NULL in
+     which case the peer name will not be checked. Note that if this parameter
+     is not NULL, then, pem_root_certs should not be NULL either.
+   - sc is a pointer on the connector to be created.
+  This function returns GRPC_SECURITY_OK in case of success or a
+  specific error code otherwise.
+*/
+grpc_security_status grpc_ssl_channel_security_connector_create(
+    grpc_credentials *request_metadata_creds,
+    const grpc_ssl_config *config, const char *target_name,
+    const char *overridden_target_name, grpc_channel_security_connector **sc);
+
+/* Gets the default ssl roots. */
+size_t grpc_get_default_ssl_roots(const unsigned char **pem_root_certs);
+
+/* Config for ssl servers. */
+typedef struct {
+  unsigned char **pem_private_keys;
+  size_t *pem_private_keys_sizes;
+  unsigned char **pem_cert_chains;
+  size_t *pem_cert_chains_sizes;
+  size_t num_key_cert_pairs;
+  unsigned char *pem_root_certs;
+  size_t pem_root_certs_size;
+} grpc_ssl_server_config;
+
+/* Creates an SSL server_security_connector.
+   - config is the SSL config to be used for the SSL channel establishment.
+   - sc is a pointer on the connector to be created.
+  This function returns GRPC_SECURITY_OK in case of success or a
+  specific error code otherwise.
+*/
+grpc_security_status grpc_ssl_server_security_connector_create(
+    const grpc_ssl_server_config *config, grpc_security_connector **sc);
+
+#endif /* GRPC_INTERNAL_CORE_SECURITY_SECURITY_CONNECTOR_H */

src/core/security/security_context.h

@@ -1,214 +0,0 @@
-/*
- *
- * 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.
- *
- */
-
-#ifndef GRPC_INTERNAL_CORE_SECURITY_SECURITY_CONTEXT_H
-#define GRPC_INTERNAL_CORE_SECURITY_SECURITY_CONTEXT_H
-
-#include <grpc/grpc_security.h>
-#include "src/core/iomgr/endpoint.h"
-#include "src/core/security/credentials.h"
-#include "src/core/tsi/transport_security_interface.h"
-
-/* --- status enum. --- */
-
-typedef enum {
-  GRPC_SECURITY_OK = 0,
-  GRPC_SECURITY_PENDING,
-  GRPC_SECURITY_ERROR
-} grpc_security_status;
-
-/* --- URL schemes. --- */
-
-#define GRPC_SSL_URL_SCHEME "https"
-#define GRPC_FAKE_SECURITY_URL_SCHEME "http+fake_security"
-
-/* --- security_context object. ---
-
-    A security context object represents away to configure the underlying
-    transport security mechanism and check the resulting trusted peer.  */
-
-typedef struct grpc_security_context grpc_security_context;
-
-#define GRPC_SECURITY_CONTEXT_ARG "grpc.security_context"
-
-typedef void (*grpc_security_check_cb)(void *user_data,
-                                       grpc_security_status status);
-
-typedef struct {
-  void (*destroy)(grpc_security_context *ctx);
-  grpc_security_status (*create_handshaker)(grpc_security_context *ctx,
-                                            tsi_handshaker **handshaker);
-  grpc_security_status (*check_peer)(grpc_security_context *ctx, tsi_peer peer,
-                                     grpc_security_check_cb cb,
-                                     void *user_data);
-} grpc_security_context_vtable;
-
-struct grpc_security_context {
-  const grpc_security_context_vtable *vtable;
-  gpr_refcount refcount;
-  int is_client_side;
-  const char *url_scheme;
-};
-
-/* Increments the refcount. */
-grpc_security_context *grpc_security_context_ref(grpc_security_context *ctx);
-
-/* Decrements the refcount and destroys the object if it reaches 0. */
-void grpc_security_context_unref(grpc_security_context *ctx);
-
-/* Handshake creation. */
-grpc_security_status grpc_security_context_create_handshaker(
-    grpc_security_context *ctx, tsi_handshaker **handshaker);
-
-/* Check the peer.
-   Implementations can choose to check the peer either synchronously or
-   asynchronously. In the first case, a successful call will return
-   GRPC_SECURITY_OK. In the asynchronous case, the call will return
-   GRPC_SECURITY_PENDING unless an error is detected early on.
-   Ownership of the peer is transfered.
-*/
-grpc_security_status grpc_security_context_check_peer(
-    grpc_security_context *ctx, tsi_peer peer,
-    grpc_security_check_cb cb, void *user_data);
-
-/* Util to encapsulate the context in a channel arg. */
-grpc_arg grpc_security_context_to_arg(grpc_security_context *ctx);
-
-/* Util to get the context from a channel arg. */
-grpc_security_context *grpc_security_context_from_arg(const grpc_arg *arg);
-
-/* Util to find the context from channel args. */
-grpc_security_context *grpc_find_security_context_in_args(
-    const grpc_channel_args *args);
-
-/* --- channel_security_context object. ---
-
-    A channel security context object represents away to configure the
-    underlying transport security mechanism on the client side.  */
-
-typedef struct grpc_channel_security_context grpc_channel_security_context;
-
-struct grpc_channel_security_context {
-  grpc_security_context base; /* requires is_client_side to be non 0. */
-  grpc_credentials *request_metadata_creds;
-  grpc_security_status (*check_call_host)(
-      grpc_channel_security_context *ctx, const char *host,
-      grpc_security_check_cb cb, void *user_data);
-};
-
-/* Checks that the host that will be set for a call is acceptable.
-   Implementations can choose do the check either synchronously or
-   asynchronously. In the first case, a successful call will return
-   GRPC_SECURITY_OK. In the asynchronous case, the call will return
-   GRPC_SECURITY_PENDING unless an error is detected early on. */
-grpc_security_status grpc_channel_security_context_check_call_host(
-    grpc_channel_security_context *ctx, const char *host,
-    grpc_security_check_cb cb, void *user_data);
-
-/* --- Creation security contexts. --- */
-
-/* For TESTING ONLY!
-   Creates a fake context that emulates real channel security.  */
-grpc_channel_security_context *grpc_fake_channel_security_context_create(
-    grpc_credentials *request_metadata_creds, int call_host_check_is_async);
-
-/* For TESTING ONLY!
-   Creates a fake context that emulates real server security.  */
-grpc_security_context *grpc_fake_server_security_context_create(void);
-
-/* Creates an SSL channel_security_context.
-   - request_metadata_creds is the credentials object which metadata
-     will be sent with each request. This parameter can be NULL.
-   - config is the SSL config to be used for the SSL channel establishment.
-   - is_client should be 0 for a server or a non-0 value for a client.
-   - secure_peer_name is the secure peer name that should be checked in
-     grpc_channel_security_context_check_peer. This parameter may be NULL in
-     which case the peer name will not be checked. Note that if this parameter
-     is not NULL, then, pem_root_certs should not be NULL either.
-   - ctx is a pointer on the context to be created.
-  This function returns GRPC_SECURITY_OK in case of success or a
-  specific error code otherwise.
-*/
-grpc_security_status grpc_ssl_channel_security_context_create(
-    grpc_credentials *request_metadata_creds, const grpc_ssl_config *config,
-    const char *target_name, const char *overridden_target_name,
-    grpc_channel_security_context **ctx);
-
-/* Creates an SSL server_security_context.
-   - config is the SSL config to be used for the SSL channel establishment.
-   - ctx is a pointer on the context to be created.
-  This function returns GRPC_SECURITY_OK in case of success or a
-  specific error code otherwise.
-*/
-grpc_security_status grpc_ssl_server_security_context_create(
-    const grpc_ssl_server_config *config, grpc_security_context **ctx);
-
-/* --- Creation of high level objects. --- */
-
-/* Secure client channel creation. */
-
-size_t grpc_get_default_ssl_roots(const unsigned char **pem_root_certs);
-
-grpc_channel *grpc_ssl_channel_create(grpc_credentials *ssl_creds,
-                                      grpc_credentials *request_metadata_creds,
-                                      const char *target,
-                                      const grpc_channel_args *args);
-
-grpc_channel *grpc_fake_transport_security_channel_create(
-    grpc_credentials *fake_creds, grpc_credentials *request_metadata_creds,
-    const char *target, const grpc_channel_args *args);
-
-grpc_channel *grpc_secure_channel_create_internal(
-    const char *target, const grpc_channel_args *args,
-    grpc_channel_security_context *ctx, grpc_mdctx *mdctx);
-
-typedef grpc_channel *(*grpc_secure_channel_factory_func)(
-    grpc_credentials *transport_security_creds,
-    grpc_credentials *request_metadata_creds, const char *target,
-    const grpc_channel_args *args);
-
-typedef struct {
-  const char *creds_type;
-  grpc_secure_channel_factory_func factory;
-} grpc_secure_channel_factory;
-
-grpc_channel *grpc_secure_channel_create_with_factories(
-    const grpc_secure_channel_factory *factories, size_t num_factories,
-    grpc_credentials *creds, const char *target, const grpc_channel_args *args);
-
-/* Secure server context creation. */
-
-grpc_security_status grpc_server_security_context_create(
-    grpc_server_credentials *creds, grpc_security_context **ctx);
-
-#endif  /* GRPC_INTERNAL_CORE_SECURITY_SECURITY_CONTEXT_H */

src/core/security/server_secure_chttp2.c

@@ -40,7 +40,8 @@
 #include "src/core/iomgr/endpoint.h"
 #include "src/core/iomgr/resolve_address.h"
 #include "src/core/iomgr/tcp_server.h"
-#include "src/core/security/security_context.h"
+#include "src/core/security/credentials.h"
+#include "src/core/security/security_connector.h"
 #include "src/core/security/secure_transport_setup.h"
 #include "src/core/surface/server.h"
 #include "src/core/transport/chttp2_transport.h"
@@ -52,7 +53,7 @@
 typedef struct grpc_server_secure_state {
   grpc_server *server;
   grpc_tcp_server *tcp;
-  grpc_security_context *ctx;
+  grpc_security_connector *sc;
   int is_shutdown;
   gpr_mu mu;
   gpr_refcount refcount;
@@ -64,7 +65,7 @@ static void state_ref(grpc_server_secure_state *state) {
 
 static void state_unref(grpc_server_secure_state *state) {
   if (gpr_unref(&state->refcount)) {
-    grpc_security_context_unref(state->ctx);
+    grpc_security_connector_unref(state->sc);
     gpr_free(state);
   }
 }
@@ -104,7 +105,7 @@ static void on_secure_transport_setup_done(void *statep,
 static void on_accept(void *statep, grpc_endpoint *tcp) {
   grpc_server_secure_state *state = statep;
   state_ref(state);
-  grpc_setup_secure_transport(state->ctx, tcp, on_secure_transport_setup_done,
+  grpc_setup_secure_transport(state->sc, tcp, on_secure_transport_setup_done,
                               state);
 }
 
@@ -137,11 +138,11 @@ int grpc_server_add_secure_http2_port(grpc_server *server, const char *addr,
   int port_num = -1;
   int port_temp;
   grpc_security_status status = GRPC_SECURITY_ERROR;
-  grpc_security_context *ctx = NULL;
+  grpc_security_connector *sc = NULL;
 
   /* create security context */
   if (creds == NULL) goto error;
-  status = grpc_server_security_context_create(creds, &ctx);
+  status = grpc_server_credentials_create_security_connector(creds, &sc);
   if (status != GRPC_SECURITY_OK) {
     gpr_log(GPR_ERROR,
             "Unable to create secure server with credentials of type %s.",
@@ -188,7 +189,7 @@ int grpc_server_add_secure_http2_port(grpc_server *server, const char *addr,
   state = gpr_malloc(sizeof(*state));
   state->server = server;
   state->tcp = tcp;
-  state->ctx = ctx;
+  state->sc = sc;
   state->is_shutdown = 0;
   gpr_mu_init(&state->mu);
   gpr_ref_init(&state->refcount, 1);
@@ -200,8 +201,8 @@ int grpc_server_add_secure_http2_port(grpc_server *server, const char *addr,
 
 /* Error path: cleanup and return */
 error:
-  if (ctx) {
-    grpc_security_context_unref(ctx);
+  if (sc) {
+    grpc_security_connector_unref(sc);
   }
   if (resolved) {
     grpc_resolved_addresses_destroy(resolved);

src/core/surface/call.c

@@ -33,7 +33,6 @@
 
 #include "src/core/surface/call.h"
 #include "src/core/channel/channel_stack.h"
-#include "src/core/channel/metadata_buffer.h"
 #include "src/core/iomgr/alarm.h"
 #include "src/core/support/string.h"
 #include "src/core/surface/byte_buffer_queue.h"
@@ -41,6 +40,7 @@
 #include "src/core/surface/completion_queue.h"
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
+#include <assert.h>
 
 #include <stdio.h>
 #include <stdlib.h>
@@ -68,8 +68,10 @@ typedef struct {
 } completed_request;
 
 /* See request_set in grpc_call below for a description */
-#define REQSET_EMPTY 255
-#define REQSET_DONE 254
+#define REQSET_EMPTY 'X'
+#define REQSET_DONE 'Y'
+
+#define MAX_SEND_INITIAL_METADATA_COUNT 3
 
 typedef struct {
   /* Overall status of the operation: starts OK, may degrade to
@@ -92,6 +94,8 @@ typedef enum {
   /* Status came from the application layer overriding whatever
      the wire says */
   STATUS_FROM_API_OVERRIDE = 0,
+  /* Status was created by some internal channel stack operation */
+  STATUS_FROM_CORE,
   /* Status came from 'the wire' - or somewhere below the surface
      layer */
   STATUS_FROM_WIRE,
@@ -204,12 +208,18 @@ struct grpc_call {
   /* Call refcount - to keep the call alive during asynchronous operations */
   gpr_refcount internal_refcount;
 
+  grpc_linked_mdelem send_initial_metadata[MAX_SEND_INITIAL_METADATA_COUNT];
+  grpc_linked_mdelem status_link;
+  grpc_linked_mdelem details_link;
+  size_t send_initial_metadata_count;
+  gpr_timespec send_deadline;
+
   /* Data that the legacy api needs to track. To be deleted at some point
      soon */
   legacy_state *legacy_state;
 };
 
-#define CALL_STACK_FROM_CALL(call) ((grpc_call_stack *)((call)+1))
+#define CALL_STACK_FROM_CALL(call) ((grpc_call_stack *)((call) + 1))
 #define CALL_FROM_CALL_STACK(call_stack) (((grpc_call *)(call_stack)) - 1)
 #define CALL_ELEM_FROM_CALL(call, idx) \
   grpc_call_stack_element(CALL_STACK_FROM_CALL(call), idx)
@@ -226,9 +236,13 @@ struct grpc_call {
 static void do_nothing(void *ignored, grpc_op_error also_ignored) {}
 static send_action choose_send_action(grpc_call *call);
 static void enact_send_action(grpc_call *call, send_action sa);
+static void set_deadline_alarm(grpc_call *call, gpr_timespec deadline);
 
 grpc_call *grpc_call_create(grpc_channel *channel, grpc_completion_queue *cq,
-                            const void *server_transport_data) {
+                            const void *server_transport_data,
+                            grpc_mdelem **add_initial_metadata,
+                            size_t add_initial_metadata_count,
+                            gpr_timespec send_deadline) {
   size_t i;
   grpc_channel_stack *channel_stack = grpc_channel_get_channel_stack(channel);
   grpc_call *call =
@@ -245,6 +259,12 @@ grpc_call *grpc_call_create(grpc_channel *channel, grpc_completion_queue *cq,
     call->request_set[GRPC_IOREQ_SEND_TRAILING_METADATA] = REQSET_DONE;
     call->request_set[GRPC_IOREQ_SEND_STATUS] = REQSET_DONE;
   }
+  GPR_ASSERT(add_initial_metadata_count < MAX_SEND_INITIAL_METADATA_COUNT);
+  for (i = 0; i < add_initial_metadata_count; i++) {
+    call->send_initial_metadata[i].md = add_initial_metadata[i];
+  }
+  call->send_initial_metadata_count = add_initial_metadata_count;
+  call->send_deadline = send_deadline;
   grpc_channel_internal_ref(channel);
   call->metadata_context = grpc_channel_get_metadata_context(channel);
   /* one ref is dropped in response to destroy, the other in
@@ -252,6 +272,9 @@ grpc_call *grpc_call_create(grpc_channel *channel, grpc_completion_queue *cq,
   gpr_ref_init(&call->internal_refcount, 2);
   grpc_call_stack_init(channel_stack, server_transport_data,
                        CALL_STACK_FROM_CALL(call));
+  if (gpr_time_cmp(send_deadline, gpr_inf_future) != 0) {
+    set_deadline_alarm(call, send_deadline);
+  }
   return call;
 }
 
@@ -284,6 +307,9 @@ static void destroy_call(void *call, int ignored_success) {
   for (i = 0; i < GPR_ARRAY_SIZE(c->buffered_metadata); i++) {
     gpr_free(c->buffered_metadata[i].metadata);
   }
+  for (i = 0; i < c->send_initial_metadata_count; i++) {
+    grpc_mdelem_unref(c->send_initial_metadata[i].md);
+  }
   if (c->legacy_state) {
     destroy_legacy_state(c->legacy_state);
   }
@@ -342,6 +368,7 @@ static void request_more_data(grpc_call *call) {
   op.flags = 0;
   op.done_cb = do_nothing;
   op.user_data = NULL;
+  op.bind_pollset = NULL;
 
   grpc_call_execute_op(call, &op);
 }
@@ -587,15 +614,29 @@ static send_action choose_send_action(grpc_call *call) {
   return SEND_NOTHING;
 }
 
-static void send_metadata(grpc_call *call, grpc_mdelem *elem) {
-  grpc_call_op op;
-  op.type = GRPC_SEND_METADATA;
-  op.dir = GRPC_CALL_DOWN;
-  op.flags = GRPC_WRITE_BUFFER_HINT;
-  op.data.metadata = elem;
-  op.done_cb = do_nothing;
-  op.user_data = NULL;
-  grpc_call_execute_op(call, &op);
+static grpc_mdelem_list chain_metadata_from_app(grpc_call *call, size_t count,
+                                                grpc_metadata *metadata) {
+  size_t i;
+  grpc_mdelem_list out;
+  if (count == 0) {
+    out.head = out.tail = NULL;
+    return out;
+  }
+  for (i = 0; i < count; i++) {
+    grpc_metadata *md = &metadata[i];
+    grpc_metadata *next_md = (i == count - 1) ? NULL : &metadata[i + 1];
+    grpc_metadata *prev_md = (i == 0) ? NULL : &metadata[i - 1];
+    grpc_linked_mdelem *l = (grpc_linked_mdelem *)&md->internal_data;
+    GPR_ASSERT(sizeof(grpc_linked_mdelem) == sizeof(md->internal_data));
+    l->md = grpc_mdelem_from_string_and_buffer(call->metadata_context, md->key,
+                                               (const gpr_uint8 *)md->value,
+                                               md->value_length);
+    l->next = next_md ? (grpc_linked_mdelem *)&next_md->internal_data : NULL;
+    l->prev = prev_md ? (grpc_linked_mdelem *)&prev_md->internal_data : NULL;
+  }
+  out.head = (grpc_linked_mdelem *)&(metadata[0].internal_data);
+  out.tail = (grpc_linked_mdelem *)&(metadata[count - 1].internal_data);
+  return out;
 }
 
 static void enact_send_action(grpc_call *call, send_action sa) {
@@ -614,19 +655,21 @@ static void enact_send_action(grpc_call *call, send_action sa) {
     /* fallthrough */
     case SEND_INITIAL_METADATA:
       data = call->request_data[GRPC_IOREQ_SEND_INITIAL_METADATA];
-      for (i = 0; i < data.send_metadata.count; i++) {
-        const grpc_metadata *md = &data.send_metadata.metadata[i];
-        send_metadata(call,
-                      grpc_mdelem_from_string_and_buffer(
-                          call->metadata_context, md->key,
-                          (const gpr_uint8 *)md->value, md->value_length));
-      }
-      op.type = GRPC_SEND_START;
+      op.type = GRPC_SEND_METADATA;
       op.dir = GRPC_CALL_DOWN;
       op.flags = flags;
-      op.data.start.pollset = grpc_cq_pollset(call->cq);
+      op.data.metadata.list = chain_metadata_from_app(
+          call, data.send_metadata.count, data.send_metadata.metadata);
+      op.data.metadata.garbage.head = op.data.metadata.garbage.tail = NULL;
+      op.data.metadata.deadline = call->send_deadline;
+      for (i = 0; i < call->send_initial_metadata_count; i++) {
+        grpc_metadata_batch_link_head(&op.data.metadata,
+                                      &call->send_initial_metadata[i]);
+      }
+      call->send_initial_metadata_count = 0;
       op.done_cb = finish_start_step;
       op.user_data = call;
+      op.bind_pollset = grpc_cq_pollset(call->cq);
       grpc_call_execute_op(call, &op);
       break;
     case SEND_BUFFERED_MESSAGE:
@@ -640,37 +683,42 @@ static void enact_send_action(grpc_call *call, send_action sa) {
       op.data.message = data.send_message;
       op.done_cb = finish_write_step;
       op.user_data = call;
+      op.bind_pollset = NULL;
       grpc_call_execute_op(call, &op);
       break;
     case SEND_TRAILING_METADATA_AND_FINISH:
       /* send trailing metadata */
       data = call->request_data[GRPC_IOREQ_SEND_TRAILING_METADATA];
-      for (i = 0; i < data.send_metadata.count; i++) {
-        const grpc_metadata *md = &data.send_metadata.metadata[i];
-        send_metadata(call,
-                      grpc_mdelem_from_string_and_buffer(
-                          call->metadata_context, md->key,
-                          (const gpr_uint8 *)md->value, md->value_length));
-      }
+      op.type = GRPC_SEND_METADATA;
+      op.dir = GRPC_CALL_DOWN;
+      op.flags = flags;
+      op.data.metadata.list = chain_metadata_from_app(
+          call, data.send_metadata.count, data.send_metadata.metadata);
+      op.data.metadata.garbage.head = op.data.metadata.garbage.tail = NULL;
+      op.data.metadata.deadline = call->send_deadline;
+      op.bind_pollset = NULL;
       /* send status */
       /* TODO(ctiller): cache common status values */
       data = call->request_data[GRPC_IOREQ_SEND_STATUS];
       gpr_ltoa(data.send_status.code, status_str);
-      send_metadata(
-          call,
+      grpc_metadata_batch_add_tail(
+          &op.data.metadata, &call->status_link,
           grpc_mdelem_from_metadata_strings(
               call->metadata_context,
               grpc_mdstr_ref(grpc_channel_get_status_string(call->channel)),
               grpc_mdstr_from_string(call->metadata_context, status_str)));
       if (data.send_status.details) {
-        send_metadata(
-            call,
+        grpc_metadata_batch_add_tail(
+            &op.data.metadata, &call->details_link,
             grpc_mdelem_from_metadata_strings(
                 call->metadata_context,
                 grpc_mdstr_ref(grpc_channel_get_message_string(call->channel)),
                 grpc_mdstr_from_string(call->metadata_context,
                                        data.send_status.details)));
       }
+      op.done_cb = do_nothing;
+      op.user_data = NULL;
+      grpc_call_execute_op(call, &op);
     /* fallthrough: see choose_send_action for details */
     case SEND_FINISH:
       op.type = GRPC_SEND_FINISH;
@@ -678,6 +726,7 @@ static void enact_send_action(grpc_call *call, send_action sa) {
       op.flags = 0;
       op.done_cb = finish_finish_step;
       op.user_data = call;
+      op.bind_pollset = NULL;
       grpc_call_execute_op(call, &op);
       break;
   }
@@ -831,6 +880,7 @@ grpc_call_error grpc_call_cancel(grpc_call *c) {
   op.flags = 0;
   op.done_cb = do_nothing;
   op.user_data = NULL;
+  op.bind_pollset = NULL;
 
   elem = CALL_ELEM_FROM_CALL(c, 0);
   elem->filter->call_op(elem, NULL, &op);
@@ -875,9 +925,7 @@ static void call_alarm(void *arg, int success) {
   grpc_call_internal_unref(call, 1);
 }
 
-void grpc_call_set_deadline(grpc_call_element *elem, gpr_timespec deadline) {
-  grpc_call *call = CALL_FROM_TOP_ELEM(elem);
-
+static void set_deadline_alarm(grpc_call *call, gpr_timespec deadline) {
   if (call->have_alarm) {
     gpr_log(GPR_ERROR, "Attempt to set deadline alarm twice");
   }
@@ -886,11 +934,15 @@ void grpc_call_set_deadline(grpc_call_element *elem, gpr_timespec deadline) {
   grpc_alarm_init(&call->alarm, deadline, call_alarm, call, gpr_now());
 }
 
-static void set_read_state(grpc_call *call, read_state state) {
-  lock(call);
+static void set_read_state_locked(grpc_call *call, read_state state) {
   GPR_ASSERT(call->read_state < state);
   call->read_state = state;
   finish_read_ops(call);
+}
+
+static void set_read_state(grpc_call *call, read_state state) {
+  lock(call);
+  set_read_state_locked(call, state);
   unlock(call);
 }
 
@@ -914,7 +966,7 @@ static gpr_uint32 decode_status(grpc_mdelem *md) {
   gpr_uint32 status;
   void *user_data = grpc_mdelem_get_user_data(md, destroy_status);
   if (user_data) {
-    status = ((gpr_uint32)(gpr_intptr) user_data) - STATUS_OFFSET;
+    status = ((gpr_uint32)(gpr_intptr)user_data) - STATUS_OFFSET;
   } else {
     if (!gpr_parse_bytes_to_uint32(grpc_mdstr_as_c_string(md->value),
                                    GPR_SLICE_LENGTH(md->value->slice),
@@ -936,52 +988,81 @@ void grpc_call_recv_message(grpc_call_element *elem,
   unlock(call);
 }
 
-void grpc_call_recv_metadata(grpc_call_element *elem, grpc_mdelem *md) {
+void grpc_call_recv_synthetic_status(grpc_call_element *elem,
+                                     grpc_status_code status,
+                                     const char *message) {
   grpc_call *call = CALL_FROM_TOP_ELEM(elem);
-  grpc_mdstr *key = md->key;
+  lock(call);
+  set_status_code(call, STATUS_FROM_CORE, status);
+  set_status_details(call, STATUS_FROM_CORE,
+                     grpc_mdstr_from_string(call->metadata_context, message));
+  unlock(call);
+}
+
+int grpc_call_recv_metadata(grpc_call_element *elem, grpc_metadata_batch *md) {
+  grpc_call *call = CALL_FROM_TOP_ELEM(elem);
+  grpc_linked_mdelem *l;
   grpc_metadata_array *dest;
   grpc_metadata *mdusr;
+  int is_trailing;
+  grpc_mdctx *mdctx = call->metadata_context;
 
   lock(call);
-  if (key == grpc_channel_get_status_string(call->channel)) {
-    set_status_code(call, STATUS_FROM_WIRE, decode_status(md));
-    grpc_mdelem_unref(md);
-  } else if (key == grpc_channel_get_message_string(call->channel)) {
-    set_status_details(call, STATUS_FROM_WIRE, grpc_mdstr_ref(md->value));
-    grpc_mdelem_unref(md);
-  } else {
-    dest = &call->buffered_metadata[call->read_state >=
-                                    READ_STATE_GOT_INITIAL_METADATA];
-    if (dest->count == dest->capacity) {
-      dest->capacity = GPR_MAX(dest->capacity + 8, dest->capacity * 2);
-      dest->metadata =
-          gpr_realloc(dest->metadata, sizeof(grpc_metadata) * dest->capacity);
-    }
-    mdusr = &dest->metadata[dest->count++];
-    mdusr->key = grpc_mdstr_as_c_string(md->key);
-    mdusr->value = grpc_mdstr_as_c_string(md->value);
-    mdusr->value_length = GPR_SLICE_LENGTH(md->value->slice);
-    if (call->owned_metadata_count == call->owned_metadata_capacity) {
-      call->owned_metadata_capacity = GPR_MAX(
-          call->owned_metadata_capacity + 8, call->owned_metadata_capacity * 2);
-      call->owned_metadata =
-          gpr_realloc(call->owned_metadata,
-                      sizeof(grpc_mdelem *) * call->owned_metadata_capacity);
+  is_trailing = call->read_state >= READ_STATE_GOT_INITIAL_METADATA;
+  for (l = md->list.head; l != NULL; l = l->next) {
+    grpc_mdelem *md = l->md;
+    grpc_mdstr *key = md->key;
+    if (key == grpc_channel_get_status_string(call->channel)) {
+      set_status_code(call, STATUS_FROM_WIRE, decode_status(md));
+    } else if (key == grpc_channel_get_message_string(call->channel)) {
+      set_status_details(call, STATUS_FROM_WIRE, grpc_mdstr_ref(md->value));
+    } else {
+      dest = &call->buffered_metadata[is_trailing];
+      if (dest->count == dest->capacity) {
+        dest->capacity = GPR_MAX(dest->capacity + 8, dest->capacity * 2);
+        dest->metadata =
+            gpr_realloc(dest->metadata, sizeof(grpc_metadata) * dest->capacity);
+      }
+      mdusr = &dest->metadata[dest->count++];
+      mdusr->key = grpc_mdstr_as_c_string(md->key);
+      mdusr->value = grpc_mdstr_as_c_string(md->value);
+      mdusr->value_length = GPR_SLICE_LENGTH(md->value->slice);
+      if (call->owned_metadata_count == call->owned_metadata_capacity) {
+        call->owned_metadata_capacity =
+            GPR_MAX(call->owned_metadata_capacity + 8,
+                    call->owned_metadata_capacity * 2);
+        call->owned_metadata =
+            gpr_realloc(call->owned_metadata,
+                        sizeof(grpc_mdelem *) * call->owned_metadata_capacity);
+      }
+      call->owned_metadata[call->owned_metadata_count++] = md;
+      l->md = 0;
     }
-    call->owned_metadata[call->owned_metadata_count++] = md;
+  }
+  if (gpr_time_cmp(md->deadline, gpr_inf_future) != 0) {
+    set_deadline_alarm(call, md->deadline);
+  }
+  if (!is_trailing) {
+    set_read_state_locked(call, READ_STATE_GOT_INITIAL_METADATA);
   }
   unlock(call);
+
+  grpc_mdctx_lock(mdctx);
+  for (l = md->list.head; l; l = l->next) {
+    if (l->md) grpc_mdctx_locked_mdelem_unref(mdctx, l->md);
+  }
+  for (l = md->garbage.head; l; l = l->next) {
+    grpc_mdctx_locked_mdelem_unref(mdctx, l->md);
+  }
+  grpc_mdctx_unlock(mdctx);
+
+  return !is_trailing;
 }
 
 grpc_call_stack *grpc_call_get_call_stack(grpc_call *call) {
   return CALL_STACK_FROM_CALL(call);
 }
 
-void grpc_call_initial_metadata_complete(grpc_call_element *surface_element) {
-  grpc_call *call = grpc_call_from_top_element(surface_element);
-  set_read_state(call, READ_STATE_GOT_INITIAL_METADATA);
-}
-
 /*
  * BATCH API IMPLEMENTATION
  */

src/core/surface/call.h

@@ -35,7 +35,6 @@
 #define GRPC_INTERNAL_CORE_SURFACE_CALL_H
 
 #include "src/core/channel/channel_stack.h"
-#include "src/core/channel/metadata_buffer.h"
 #include <grpc/grpc.h>
 
 /* Primitive operation types - grpc_op's get rewritten into these */
@@ -67,7 +66,7 @@ typedef union {
   } recv_status_details;
   struct {
     size_t count;
-    const grpc_metadata *metadata;
+    grpc_metadata *metadata;
   } send_metadata;
   grpc_byte_buffer *send_message;
   struct {
@@ -86,7 +85,10 @@ typedef void (*grpc_ioreq_completion_func)(grpc_call *call,
                                            void *user_data);
 
 grpc_call *grpc_call_create(grpc_channel *channel, grpc_completion_queue *cq,
-                            const void *server_transport_data);
+                            const void *server_transport_data,
+                            grpc_mdelem **add_initial_metadata,
+                            size_t add_initial_metadata_count,
+                            gpr_timespec send_deadline);
 
 void grpc_call_set_completion_queue(grpc_call *call, grpc_completion_queue *cq);
 grpc_completion_queue *grpc_call_get_completion_queue(grpc_call *call);
@@ -96,8 +98,9 @@ void grpc_call_internal_unref(grpc_call *call, int allow_immediate_deletion);
 
 /* Helpers for grpc_client, grpc_server filters to publish received data to
    the completion queue/surface layer */
-void grpc_call_recv_metadata(grpc_call_element *surface_element,
-                             grpc_mdelem *md);
+/* receive metadata - returns 1 if this was initial metadata */
+int grpc_call_recv_metadata(grpc_call_element *surface_element,
+                            grpc_metadata_batch *md);
 void grpc_call_recv_message(grpc_call_element *surface_element,
                             grpc_byte_buffer *message);
 void grpc_call_read_closed(grpc_call_element *surface_element);
@@ -108,14 +111,12 @@ grpc_call_error grpc_call_start_ioreq_and_call_back(
     grpc_call *call, const grpc_ioreq *reqs, size_t nreqs,
     grpc_ioreq_completion_func on_complete, void *user_data);
 
-/* Called when it's known that the initial batch of metadata is complete */
-void grpc_call_initial_metadata_complete(grpc_call_element *surface_element);
-
-void grpc_call_set_deadline(grpc_call_element *surface_element,
-                            gpr_timespec deadline);
-
 grpc_call_stack *grpc_call_get_call_stack(grpc_call *call);
 
+void grpc_call_recv_synthetic_status(grpc_call_element *elem,
+                                     grpc_status_code status,
+                                     const char *message);
+
 /* Given the top call_element, get the call object. */
 grpc_call *grpc_call_from_top_element(grpc_call_element *surface_element);
 
@@ -128,4 +129,4 @@ void grpc_call_log_batch(char *file, int line, gpr_log_severity severity,
 #define GRPC_CALL_LOG_BATCH(sev, call, ops, nops, tag) \
   if (grpc_trace_batch) grpc_call_log_batch(sev, call, ops, nops, tag)
 
-#endif  /* GRPC_INTERNAL_CORE_SURFACE_CALL_H */
+#endif /* GRPC_INTERNAL_CORE_SURFACE_CALL_H */

src/core/surface/channel.c

@@ -62,7 +62,7 @@ struct grpc_channel {
   registered_call *registered_calls;
 };
 
-#define CHANNEL_STACK_FROM_CHANNEL(c) ((grpc_channel_stack *)((c)+1))
+#define CHANNEL_STACK_FROM_CHANNEL(c) ((grpc_channel_stack *)((c) + 1))
 #define CHANNEL_FROM_CHANNEL_STACK(channel_stack) \
   (((grpc_channel *)(channel_stack)) - 1)
 #define CHANNEL_FROM_TOP_ELEM(top_elem) \
@@ -91,44 +91,25 @@ grpc_channel *grpc_channel_create_from_filters(
   return channel;
 }
 
-static void do_nothing(void *ignored, grpc_op_error error) {}
-
 static grpc_call *grpc_channel_create_call_internal(
     grpc_channel *channel, grpc_completion_queue *cq, grpc_mdelem *path_mdelem,
     grpc_mdelem *authority_mdelem, gpr_timespec deadline) {
-  grpc_call *call;
-  grpc_call_op op;
+  grpc_mdelem *send_metadata[2];
 
-  if (!channel->is_client) {
-    gpr_log(GPR_ERROR, "Cannot create a call on the server.");
-    return NULL;
-  }
+  GPR_ASSERT(channel->is_client);
 
-  call = grpc_call_create(channel, cq, NULL);
+  send_metadata[0] = path_mdelem;
+  send_metadata[1] = authority_mdelem;
 
-  /* Add :path and :authority headers. */
-  op.type = GRPC_SEND_METADATA;
-  op.dir = GRPC_CALL_DOWN;
-  op.flags = 0;
-  op.data.metadata = path_mdelem;
-  op.done_cb = do_nothing;
-  op.user_data = NULL;
-  grpc_call_execute_op(call, &op);
-
-  op.data.metadata = authority_mdelem;
-  grpc_call_execute_op(call, &op);
-
-  if (0 != gpr_time_cmp(deadline, gpr_inf_future)) {
-    op.type = GRPC_SEND_DEADLINE;
-    op.dir = GRPC_CALL_DOWN;
-    op.flags = 0;
-    op.data.deadline = deadline;
-    op.done_cb = do_nothing;
-    op.user_data = NULL;
-    grpc_call_execute_op(call, &op);
-  }
+  return grpc_call_create(channel, cq, NULL, send_metadata,
+                          GPR_ARRAY_SIZE(send_metadata), deadline);
+}
 
-  return call;
+grpc_call *grpc_channel_create_call_old(grpc_channel *channel,
+                                        const char *method, const char *host,
+                                        gpr_timespec absolute_deadline) {
+  return grpc_channel_create_call(channel, NULL, method, host,
+                                  absolute_deadline);
 }
 
 grpc_call *grpc_channel_create_call(grpc_channel *channel,
@@ -146,13 +127,6 @@ grpc_call *grpc_channel_create_call(grpc_channel *channel,
       deadline);
 }
 
-grpc_call *grpc_channel_create_call_old(grpc_channel *channel,
-                                        const char *method, const char *host,
-                                        gpr_timespec absolute_deadline) {
-  return grpc_channel_create_call(channel, NULL, method, host,
-                                  absolute_deadline);
-}
-
 void *grpc_channel_register_call(grpc_channel *channel, const char *method,
                                  const char *host) {
   registered_call *rc = gpr_malloc(sizeof(registered_call));

src/core/surface/client.c

@@ -39,28 +39,17 @@
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 
-typedef struct {
-  void *unused;
-} call_data;
+typedef struct { void *unused; } call_data;
 
-typedef struct {
-  void *unused;
-} channel_data;
+typedef struct { void *unused; } channel_data;
 
 static void call_op(grpc_call_element *elem, grpc_call_element *from_elem,
                     grpc_call_op *op) {
   GRPC_CALL_LOG_OP(GPR_INFO, elem, op);
 
   switch (op->type) {
-    case GRPC_SEND_DEADLINE:
-      grpc_call_set_deadline(elem, op->data.deadline);
-      grpc_call_next_op(elem, op);
-      break;
     case GRPC_RECV_METADATA:
-      grpc_call_recv_metadata(elem, op->data.metadata);
-      break;
-    case GRPC_RECV_DEADLINE:
-      gpr_log(GPR_ERROR, "Deadline received by client (ignored)");
+      grpc_call_recv_metadata(elem, &op->data.metadata);
       break;
     case GRPC_RECV_MESSAGE:
       grpc_call_recv_message(elem, op->data.message);
@@ -72,8 +61,9 @@ static void call_op(grpc_call_element *elem, grpc_call_element *from_elem,
     case GRPC_RECV_FINISH:
       grpc_call_stream_closed(elem);
       break;
-    case GRPC_RECV_END_OF_INITIAL_METADATA:
-      grpc_call_initial_metadata_complete(elem);
+    case GRPC_RECV_SYNTHETIC_STATUS:
+      grpc_call_recv_synthetic_status(elem, op->data.synthetic_status.status,
+                                      op->data.synthetic_status.message);
       break;
     default:
       GPR_ASSERT(op->dir == GRPC_CALL_DOWN);
@@ -114,6 +104,6 @@ static void init_channel_elem(grpc_channel_element *elem,
 static void destroy_channel_elem(grpc_channel_element *elem) {}
 
 const grpc_channel_filter grpc_client_surface_filter = {
-    call_op,           channel_op,           sizeof(call_data),
-    init_call_elem,    destroy_call_elem,    sizeof(channel_data),
-    init_channel_elem, destroy_channel_elem, "client", };
+    call_op, channel_op, sizeof(call_data), init_call_elem, destroy_call_elem,
+    sizeof(channel_data), init_channel_elem, destroy_channel_elem, "client",
+};

src/core/surface/lame_client.c

@@ -42,28 +42,20 @@
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 
-typedef struct {
-  void *unused;
-} call_data;
+typedef struct { void *unused; } call_data;
 
-typedef struct {
-  grpc_mdelem *status;
-  grpc_mdelem *message;
-} channel_data;
+typedef struct { void *unused; } channel_data;
 
 static void call_op(grpc_call_element *elem, grpc_call_element *from_elem,
                     grpc_call_op *op) {
-  channel_data *channeld = elem->channel_data;
   GRPC_CALL_LOG_OP(GPR_INFO, elem, op);
 
   switch (op->type) {
-    case GRPC_SEND_START:
-      grpc_call_recv_metadata(elem, grpc_mdelem_ref(channeld->status));
-      grpc_call_recv_metadata(elem, grpc_mdelem_ref(channeld->message));
-      grpc_call_stream_closed(elem);
-      break;
     case GRPC_SEND_METADATA:
-      grpc_mdelem_unref(op->data.metadata);
+      grpc_metadata_batch_destroy(&op->data.metadata);
+      grpc_call_recv_synthetic_status(elem, GRPC_STATUS_UNKNOWN,
+                                      "Rpc sent on a lame channel.");
+      grpc_call_stream_closed(elem);
       break;
     default:
       break;
@@ -94,29 +86,17 @@ static void destroy_call_elem(grpc_call_element *elem) {}
 static void init_channel_elem(grpc_channel_element *elem,
                               const grpc_channel_args *args, grpc_mdctx *mdctx,
                               int is_first, int is_last) {
-  channel_data *channeld = elem->channel_data;
-  char status[12];
-
   GPR_ASSERT(is_first);
   GPR_ASSERT(is_last);
-
-  channeld->message = grpc_mdelem_from_strings(mdctx, "grpc-message",
-                                               "Rpc sent on a lame channel.");
-  gpr_ltoa(GRPC_STATUS_UNKNOWN, status);
-  channeld->status = grpc_mdelem_from_strings(mdctx, "grpc-status", status);
 }
 
-static void destroy_channel_elem(grpc_channel_element *elem) {
-  channel_data *channeld = elem->channel_data;
-
-  grpc_mdelem_unref(channeld->message);
-  grpc_mdelem_unref(channeld->status);
-}
+static void destroy_channel_elem(grpc_channel_element *elem) {}
 
 static const grpc_channel_filter lame_filter = {
-    call_op,           channel_op,           sizeof(call_data),
-    init_call_elem,    destroy_call_elem,    sizeof(channel_data),
-    init_channel_elem, destroy_channel_elem, "lame-client", };
+    call_op, channel_op, sizeof(call_data), init_call_elem, destroy_call_elem,
+    sizeof(channel_data), init_channel_elem, destroy_channel_elem,
+    "lame-client",
+};
 
 grpc_channel *grpc_lame_client_channel_create(void) {
   static const grpc_channel_filter *filters[] = {&lame_filter};

src/core/surface/secure_channel_create.c

@@ -48,7 +48,7 @@
 #include "src/core/iomgr/resolve_address.h"
 #include "src/core/iomgr/tcp_client.h"
 #include "src/core/security/auth.h"
-#include "src/core/security/security_context.h"
+#include "src/core/security/credentials.h"
 #include "src/core/security/secure_transport_setup.h"
 #include "src/core/support/string.h"
 #include "src/core/surface/channel.h"
@@ -74,7 +74,7 @@ typedef struct {
 } request;
 
 struct setup {
-  grpc_channel_security_context *security_context;
+  grpc_channel_security_connector *security_connector;
   const char *target;
   grpc_transport_setup_callback setup_callback;
   void *setup_user_data;
@@ -130,7 +130,7 @@ static void on_connect(void *rp, grpc_endpoint *tcp) {
       return;
     }
   } else {
-    grpc_setup_secure_transport(&r->setup->security_context->base, tcp,
+    grpc_setup_secure_transport(&r->setup->security_connector->base, tcp,
                                 on_secure_transport_setup_done, r);
   }
 }
@@ -185,7 +185,7 @@ static void initiate_setup(void *sp, grpc_client_setup_request *cs_request) {
 static void done_setup(void *sp) {
   setup *s = sp;
   gpr_free((void *)s->target);
-  grpc_security_context_unref(&s->security_context->base);
+  grpc_security_connector_unref(&s->security_connector->base);
   gpr_free(s);
 }
 
@@ -203,23 +203,37 @@ static grpc_transport_setup_result complete_setup(void *channel_stack,
    Asynchronously: - resolve target
                    - connect to it (trying alternatives as presented)
                    - perform handshakes */
-grpc_channel *grpc_secure_channel_create_internal(
-    const char *target, const grpc_channel_args *args,
-    grpc_channel_security_context *context, grpc_mdctx *mdctx) {
+grpc_channel *grpc_secure_channel_create(grpc_credentials *creds,
+                                         const char *target,
+                                         const grpc_channel_args *args) {
   setup *s;
   grpc_channel *channel;
-  grpc_arg context_arg;
+  grpc_arg connector_arg;
   grpc_channel_args *args_copy;
+  grpc_channel_args *new_args_from_connector;
+  grpc_channel_security_connector* connector;
+  grpc_mdctx *mdctx;
 #define MAX_FILTERS 3
   const grpc_channel_filter *filters[MAX_FILTERS];
   int n = 0;
-  if (grpc_find_security_context_in_args(args) != NULL) {
+
+  if (grpc_find_security_connector_in_args(args) != NULL) {
     gpr_log(GPR_ERROR, "Cannot set security context in channel args.");
+    return grpc_lame_client_channel_create();
+  }
+
+  if (grpc_credentials_create_security_connector(
+          creds, target, args, NULL, &connector, &new_args_from_connector) !=
+      GRPC_SECURITY_OK) {
+    return grpc_lame_client_channel_create();
   }
+  mdctx = grpc_credentials_get_or_create_metadata_context(creds);
 
   s = gpr_malloc(sizeof(setup));
-  context_arg = grpc_security_context_to_arg(&context->base);
-  args_copy = grpc_channel_args_copy_and_add(args, &context_arg);
+  connector_arg = grpc_security_connector_to_arg(&connector->base);
+  args_copy = grpc_channel_args_copy_and_add(
+      new_args_from_connector != NULL ? new_args_from_connector : args,
+      &connector_arg);
   filters[n++] = &grpc_client_surface_filter;
   if (grpc_channel_args_is_census_enabled(args)) {
     filters[n++] = &grpc_client_census_filter;
@@ -228,13 +242,14 @@ grpc_channel *grpc_secure_channel_create_internal(
   GPR_ASSERT(n <= MAX_FILTERS);
   channel = grpc_channel_create_from_filters(filters, n, args_copy, mdctx, 1);
   grpc_channel_args_destroy(args_copy);
+  if (new_args_from_connector != NULL) {
+    grpc_channel_args_destroy(new_args_from_connector);
+  }
 
   s->target = gpr_strdup(target);
   s->setup_callback = complete_setup;
   s->setup_user_data = grpc_channel_get_channel_stack(channel);
-  s->security_context =
-      (grpc_channel_security_context *)grpc_security_context_ref(
-          &context->base);
+  s->security_connector = connector;
   grpc_client_setup_create_and_attach(grpc_channel_get_channel_stack(channel),
                                       args, mdctx, initiate_setup, done_setup,
                                       s);

src/core/surface/server.c

@@ -411,29 +411,32 @@ static void read_closed(grpc_call_element *elem) {
   gpr_mu_unlock(&chand->server->mu);
 }
 
+static grpc_mdelem *server_filter(void *user_data, grpc_mdelem *md) {
+  grpc_call_element *elem = user_data;
+  channel_data *chand = elem->channel_data;
+  call_data *calld = elem->call_data;
+  if (md->key == chand->path_key) {
+    calld->path = grpc_mdstr_ref(md->value);
+    return NULL;
+  } else if (md->key == chand->authority_key) {
+    calld->host = grpc_mdstr_ref(md->value);
+    return NULL;
+  }
+  return md;
+}
+
 static void call_op(grpc_call_element *elem, grpc_call_element *from_elemn,
                     grpc_call_op *op) {
-  channel_data *chand = elem->channel_data;
   call_data *calld = elem->call_data;
-  grpc_mdelem *md;
   GRPC_CALL_LOG_OP(GPR_INFO, elem, op);
   switch (op->type) {
     case GRPC_RECV_METADATA:
-      md = op->data.metadata;
-      if (md->key == chand->path_key) {
-        calld->path = grpc_mdstr_ref(md->value);
-        grpc_mdelem_unref(md);
-      } else if (md->key == chand->authority_key) {
-        calld->host = grpc_mdstr_ref(md->value);
-        grpc_mdelem_unref(md);
-      } else {
-        grpc_call_recv_metadata(elem, md);
+      grpc_metadata_batch_filter(&op->data.metadata, server_filter, elem);
+      if (grpc_call_recv_metadata(elem, &op->data.metadata)) {
+        calld->deadline = op->data.metadata.deadline;
+        start_new_rpc(elem);
       }
       break;
-    case GRPC_RECV_END_OF_INITIAL_METADATA:
-      start_new_rpc(elem);
-      grpc_call_initial_metadata_complete(elem);
-      break;
     case GRPC_RECV_MESSAGE:
       grpc_call_recv_message(elem, op->data.message);
       op->done_cb(op->user_data, GRPC_OP_OK);
@@ -444,10 +447,6 @@ static void call_op(grpc_call_element *elem, grpc_call_element *from_elemn,
     case GRPC_RECV_FINISH:
       stream_closed(elem);
       break;
-    case GRPC_RECV_DEADLINE:
-      grpc_call_set_deadline(elem, op->data.deadline);
-      ((call_data *)elem->call_data)->deadline = op->data.deadline;
-      break;
     default:
       GPR_ASSERT(op->dir == GRPC_CALL_DOWN);
       grpc_call_next_op(elem, op);
@@ -464,7 +463,8 @@ static void channel_op(grpc_channel_element *elem,
     case GRPC_ACCEPT_CALL:
       /* create a call */
       grpc_call_create(chand->channel, NULL,
-                       op->data.accept_call.transport_server_data);
+                       op->data.accept_call.transport_server_data, NULL, 0,
+                       gpr_inf_future);
       break;
     case GRPC_TRANSPORT_CLOSED:
       /* if the transport is closed for a server channel, we destroy the
@@ -1083,6 +1083,7 @@ static void begin_call(grpc_server *server, call_data *calld,
             &rc->data.batch.details->host_capacity, calld->host);
       cpstr(&rc->data.batch.details->method,
             &rc->data.batch.details->method_capacity, calld->path);
+      rc->data.batch.details->deadline = calld->deadline;
       grpc_call_set_completion_queue(calld->call, rc->data.batch.cq_bind);
       *rc->data.batch.call = calld->call;
       r->op = GRPC_IOREQ_RECV_INITIAL_METADATA;

src/core/transport/chttp2/frame.h

@@ -54,6 +54,7 @@ typedef struct {
   gpr_uint8 process_ping_reply;
   gpr_uint8 goaway;
 
+  gpr_int64 initial_window_update;
   gpr_uint32 window_update;
   gpr_uint32 goaway_last_stream_index;
   gpr_uint32 goaway_error;

src/core/transport/chttp2/frame_settings.c

@@ -218,6 +218,14 @@ grpc_chttp2_parse_error grpc_chttp2_settings_parser_parse(
                 return GRPC_CHTTP2_CONNECTION_ERROR;
             }
           }
+          if (parser->id == GRPC_CHTTP2_SETTINGS_INITIAL_WINDOW_SIZE &&
+              parser->incoming_settings[parser->id] != parser->value) {
+            state->initial_window_update =
+                (gpr_int64)parser->value -
+                parser->incoming_settings[parser->id];
+            gpr_log(GPR_DEBUG, "adding %d for initial_window change",
+                    (int)state->initial_window_update);
+          }
           parser->incoming_settings[parser->id] = parser->value;
           if (grpc_http_trace) {
             gpr_log(GPR_DEBUG, "CHTTP2: got setting %d = %d", parser->id,

src/core/transport/chttp2/stream_encoder.c

@@ -43,7 +43,7 @@
 #include "src/core/transport/chttp2/timeout_encoding.h"
 #include "src/core/transport/chttp2/varint.h"
 
-#define HASH_FRAGMENT_1(x) ((x) & 255)
+#define HASH_FRAGMENT_1(x) ((x)&255)
 #define HASH_FRAGMENT_2(x) ((x >> 8) & 255)
 #define HASH_FRAGMENT_3(x) ((x >> 16) & 255)
 #define HASH_FRAGMENT_4(x) ((x >> 24) & 255)
@@ -479,10 +479,9 @@ gpr_uint32 grpc_chttp2_preencode(grpc_stream_op *inops, size_t *inops_count,
         /* skip */
         curop++;
         break;
-      case GRPC_OP_FLOW_CTL_CB:
-      case GRPC_OP_DEADLINE:
       case GRPC_OP_METADATA:
-      case GRPC_OP_METADATA_BOUNDARY:
+        grpc_metadata_batch_assert_ok(&op->data.metadata);
+      case GRPC_OP_FLOW_CTL_CB:
         /* these just get copied as they don't impact the number of flow
            controlled bytes */
         grpc_sopb_append(outops, op, 1);
@@ -529,6 +528,12 @@ exit_loop:
   *inops_count -= curop;
   memmove(inops, inops + curop, *inops_count * sizeof(grpc_stream_op));
 
+  for (curop = 0; curop < *inops_count; curop++) {
+    if (inops[curop].type == GRPC_OP_METADATA) {
+      grpc_metadata_batch_assert_ok(&inops[curop].data.metadata);
+    }
+  }
+
   return flow_controlled_bytes_taken;
 }
 
@@ -543,6 +548,7 @@ void grpc_chttp2_encode(grpc_stream_op *ops, size_t ops_count, int eof,
   gpr_uint32 curop = 0;
   gpr_uint32 unref_op;
   grpc_mdctx *mdctx = compressor->mdctx;
+  grpc_linked_mdelem *l;
   int need_unref = 0;
 
   GPR_ASSERT(stream_id != 0);
@@ -566,19 +572,19 @@ void grpc_chttp2_encode(grpc_stream_op *ops, size_t ops_count, int eof,
         curop++;
         break;
       case GRPC_OP_METADATA:
-        /* Encode a metadata element; store the returned value, representing
+        /* Encode a metadata batch; store the returned values, representing
            a metadata element that needs to be unreffed back into the metadata
            slot. THIS MAY NOT BE THE SAME ELEMENT (if a decoder table slot got
            updated). After this loop, we'll do a batch unref of elements. */
-        op->data.metadata = hpack_enc(compressor, op->data.metadata, &st);
-        need_unref |= op->data.metadata != NULL;
-        curop++;
-        break;
-      case GRPC_OP_DEADLINE:
-        deadline_enc(compressor, op->data.deadline, &st);
-        curop++;
-        break;
-      case GRPC_OP_METADATA_BOUNDARY:
+        need_unref |= op->data.metadata.garbage.head != NULL;
+        grpc_metadata_batch_assert_ok(&op->data.metadata);
+        for (l = op->data.metadata.list.head; l; l = l->next) {
+          l->md = hpack_enc(compressor, l->md, &st);
+          need_unref |= l->md != NULL;
+        }
+        if (gpr_time_cmp(op->data.metadata.deadline, gpr_inf_future) != 0) {
+          deadline_enc(compressor, op->data.metadata.deadline, &st);
+        }
         ensure_frame_type(&st, HEADER, 0);
         finish_frame(&st, 1, 0);
         st.last_was_header = 0; /* force a new header frame */
@@ -614,8 +620,12 @@ void grpc_chttp2_encode(grpc_stream_op *ops, size_t ops_count, int eof,
     for (unref_op = 0; unref_op < curop; unref_op++) {
       op = &ops[unref_op];
       if (op->type != GRPC_OP_METADATA) continue;
-      if (!op->data.metadata) continue;
-      grpc_mdctx_locked_mdelem_unref(mdctx, op->data.metadata);
+      for (l = op->data.metadata.list.head; l; l = l->next) {
+        if (l->md) grpc_mdctx_locked_mdelem_unref(mdctx, l->md);
+      }
+      for (l = op->data.metadata.garbage.head; l; l = l->next) {
+        grpc_mdctx_locked_mdelem_unref(mdctx, l->md);
+      }
     }
     grpc_mdctx_unlock(mdctx);
   }

src/core/transport/chttp2_transport.c

@@ -68,10 +68,10 @@ int grpc_http_trace = 0;
 typedef struct transport transport;
 typedef struct stream stream;
 
-#define IF_TRACING(stmt)                    \
-  if (!(grpc_http_trace))                   \
-    ;                                       \
-  else                                      \
+#define IF_TRACING(stmt)  \
+  if (!(grpc_http_trace)) \
+    ;                     \
+  else                    \
   stmt
 
 /* streams are kept in various linked lists depending on what things need to
@@ -276,8 +276,8 @@ struct transport {
 struct stream {
   gpr_uint32 id;
 
-  gpr_uint32 outgoing_window;
   gpr_uint32 incoming_window;
+  gpr_int64 outgoing_window;
   /* when the application requests writes be closed, the write_closed is
      'queued'; when the close is flow controlled into the send path, we are
      'sending' it; when the write has been performed it is 'sent' */
@@ -292,6 +292,12 @@ struct stream {
   stream_link links[STREAM_LIST_COUNT];
   gpr_uint8 included[STREAM_LIST_COUNT];
 
+  /* incoming metadata */
+  grpc_linked_mdelem *incoming_metadata;
+  size_t incoming_metadata_count;
+  size_t incoming_metadata_capacity;
+  gpr_timespec incoming_deadline;
+
   /* sops from application */
   grpc_stream_op_buffer outgoing_sopb;
   /* sops that have passed flow control to be written */
@@ -577,7 +583,7 @@ static int init_stream(grpc_transport *gt, grpc_stream *gs,
     lock(t);
     s->id = 0;
   } else {
-    s->id = (gpr_uint32)(gpr_uintptr) server_data;
+    s->id = (gpr_uint32)(gpr_uintptr)server_data;
     t->incoming_stream = s;
     grpc_chttp2_stream_map_add(&t->stream_map, s->id, s);
   }
@@ -593,6 +599,10 @@ static int init_stream(grpc_transport *gt, grpc_stream *gs,
   s->cancelled = 0;
   s->allow_window_updates = 0;
   s->published_close = 0;
+  s->incoming_metadata_count = 0;
+  s->incoming_metadata_capacity = 0;
+  s->incoming_metadata = NULL;
+  s->incoming_deadline = gpr_inf_future;
   memset(&s->links, 0, sizeof(s->links));
   memset(&s->included, 0, sizeof(s->included));
   grpc_sopb_init(&s->outgoing_sopb);
@@ -698,7 +708,8 @@ static void stream_list_add_tail(transport *t, stream *s, stream_list_id id) {
 }
 
 static void stream_list_join(transport *t, stream *s, stream_list_id id) {
-  if (id == PENDING_CALLBACKS) GPR_ASSERT(t->cb != NULL || t->error_state == ERROR_STATE_NONE);
+  if (id == PENDING_CALLBACKS)
+    GPR_ASSERT(t->cb != NULL || t->error_state == ERROR_STATE_NONE);
   if (s->included[id]) {
     return;
   }
@@ -760,7 +771,7 @@ static void unlock(transport *t) {
     if (t->error_state == ERROR_STATE_SEEN && !t->writing) {
       call_closed = 1;
       t->calling_back = 1;
-      t->cb = NULL;  /* no more callbacks */
+      t->cb = NULL; /* no more callbacks */
       t->error_state = ERROR_STATE_NOTIFIED;
     }
     if (t->num_pending_goaways) {
@@ -782,8 +793,7 @@ static void unlock(transport *t) {
 
   /* perform some callbacks if necessary */
   for (i = 0; i < num_goaways; i++) {
-    cb->goaway(t->cb_user_data, &t->base, goaways[i].status,
-               goaways[i].debug);
+    cb->goaway(t->cb_user_data, &t->base, goaways[i].status, goaways[i].debug);
   }
 
   if (perform_callbacks) {
@@ -852,7 +862,8 @@ static int prepare_write(transport *t) {
 
   /* for each stream that's become writable, frame it's data (according to
      available window sizes) and add to the output buffer */
-  while (t->outgoing_window && (s = stream_list_remove_head(t, WRITABLE))) {
+  while (t->outgoing_window && (s = stream_list_remove_head(t, WRITABLE)) &&
+         s->outgoing_window > 0) {
     window_delta = grpc_chttp2_preencode(
         s->outgoing_sopb.ops, &s->outgoing_sopb.nops,
         GPR_MIN(t->outgoing_window, s->outgoing_window), &s->writing_sopb);
@@ -867,7 +878,7 @@ static int prepare_write(transport *t) {
 
     /* if there are still writes to do and the stream still has window
        available, then schedule a further write */
-    if (s->outgoing_sopb.nops && s->outgoing_window) {
+    if (s->outgoing_sopb.nops > 0 && s->outgoing_window > 0) {
       GPR_ASSERT(!t->outgoing_window);
       stream_list_add_tail(t, s, WRITABLE);
     }
@@ -1057,6 +1068,17 @@ static void finalize_cancellations(transport *t) {
   }
 }
 
+static void add_incoming_metadata(transport *t, stream *s, grpc_mdelem *elem) {
+  if (s->incoming_metadata_capacity == s->incoming_metadata_count) {
+    s->incoming_metadata_capacity =
+        GPR_MAX(8, 2 * s->incoming_metadata_capacity);
+    s->incoming_metadata =
+        gpr_realloc(s->incoming_metadata, sizeof(*s->incoming_metadata) *
+                                              s->incoming_metadata_capacity);
+  }
+  s->incoming_metadata[s->incoming_metadata_count++].md = elem;
+}
+
 static void cancel_stream_inner(transport *t, stream *s, gpr_uint32 id,
                                 grpc_status_code local_status,
                                 grpc_chttp2_error_code error_code,
@@ -1076,9 +1098,18 @@ static void cancel_stream_inner(transport *t, stream *s, gpr_uint32 id,
       stream_list_join(t, s, CANCELLED);
 
       gpr_ltoa(local_status, buffer);
-      grpc_sopb_add_metadata(
-          &s->parser.incoming_sopb,
+      add_incoming_metadata(
+          t, s,
           grpc_mdelem_from_strings(t->metadata_context, "grpc-status", buffer));
+      switch (local_status) {
+        case GRPC_STATUS_CANCELLED:
+          add_incoming_metadata(
+              t, s, grpc_mdelem_from_strings(t->metadata_context,
+                                             "grpc-message", "Cancelled"));
+          break;
+        default:
+          break;
+      }
 
       stream_list_join(t, s, PENDING_CALLBACKS);
     }
@@ -1254,11 +1285,10 @@ static void on_header(void *tp, grpc_mdelem *md) {
       }
       grpc_mdelem_set_user_data(md, free_timeout, cached_timeout);
     }
-    grpc_sopb_add_deadline(&s->parser.incoming_sopb,
-                           gpr_time_add(gpr_now(), *cached_timeout));
+    s->incoming_deadline = gpr_time_add(gpr_now(), *cached_timeout);
     grpc_mdelem_unref(md);
   } else {
-    grpc_sopb_add_metadata(&s->parser.incoming_sopb, md);
+    add_incoming_metadata(t, s, md);
   }
 }
 
@@ -1303,7 +1333,7 @@ static int init_header_frame_parser(transport *t, int is_continuation) {
     t->incoming_stream = NULL;
     /* if stream is accepted, we set incoming_stream in init_stream */
     t->cb->accept_stream(t->cb_user_data, &t->base,
-                         (void *)(gpr_uintptr) t->incoming_stream_id);
+                         (void *)(gpr_uintptr)t->incoming_stream_id);
     s = t->incoming_stream;
     if (!s) {
       gpr_log(GPR_ERROR, "stream not accepted");
@@ -1430,8 +1460,37 @@ static int init_frame_parser(transport *t) {
   }
 }
 
-static int is_window_update_legal(gpr_uint32 window_update, gpr_uint32 window) {
-  return window_update < MAX_WINDOW - window;
+static int is_window_update_legal(gpr_int64 window_update, gpr_int64 window) {
+  return window + window_update < MAX_WINDOW;
+}
+
+static void free_md(void *p, grpc_op_error result) { gpr_free(p); }
+
+static void add_metadata_batch(transport *t, stream *s) {
+  grpc_metadata_batch b;
+  size_t i;
+
+  b.list.head = &s->incoming_metadata[0];
+  b.list.tail = &s->incoming_metadata[s->incoming_metadata_count - 1];
+  b.garbage.head = b.garbage.tail = NULL;
+  b.deadline = s->incoming_deadline;
+
+  for (i = 1; i < s->incoming_metadata_count; i++) {
+    s->incoming_metadata[i].prev = &s->incoming_metadata[i - 1];
+    s->incoming_metadata[i - 1].next = &s->incoming_metadata[i];
+  }
+  s->incoming_metadata[0].prev = NULL;
+  s->incoming_metadata[s->incoming_metadata_count - 1].next = NULL;
+
+  grpc_sopb_add_metadata(&s->parser.incoming_sopb, b);
+  grpc_sopb_add_flow_ctl_cb(&s->parser.incoming_sopb, free_md,
+                            s->incoming_metadata);
+
+  /* reset */
+  s->incoming_deadline = gpr_inf_future;
+  s->incoming_metadata = NULL;
+  s->incoming_metadata_count = 0;
+  s->incoming_metadata_capacity = 0;
 }
 
 static int parse_frame_slice(transport *t, gpr_slice slice, int is_last) {
@@ -1448,8 +1507,7 @@ static int parse_frame_slice(transport *t, gpr_slice slice, int is_last) {
         stream_list_join(t, t->incoming_stream, PENDING_CALLBACKS);
       }
       if (st.metadata_boundary) {
-        grpc_sopb_add_metadata_boundary(
-            &t->incoming_stream->parser.incoming_sopb);
+        add_metadata_batch(t, t->incoming_stream);
         stream_list_join(t, t->incoming_stream, PENDING_CALLBACKS);
       }
       if (st.ack_settings) {
@@ -1485,12 +1543,23 @@ static int parse_frame_slice(transport *t, gpr_slice slice, int is_last) {
           }
         }
       }
+      if (st.initial_window_update) {
+        for (i = 0; i < t->stream_map.count; i++) {
+          stream *s = (stream*)(t->stream_map.values[i]);
+          int was_window_empty = s->outgoing_window <= 0;
+          s->outgoing_window += st.initial_window_update;
+          if (was_window_empty && s->outgoing_window > 0 &&
+              s->outgoing_sopb.nops > 0) {
+            stream_list_join(t, s, WRITABLE);
+          }
+        }
+      }
       if (st.window_update) {
         if (t->incoming_stream_id) {
           /* if there was a stream id, this is for some stream */
           stream *s = lookup_stream(t, t->incoming_stream_id);
           if (s) {
-            int was_window_empty = s->outgoing_window == 0;
+            int was_window_empty = s->outgoing_window <= 0;
             if (!is_window_update_legal(st.window_update, s->outgoing_window)) {
               cancel_stream(t, s, grpc_chttp2_http2_error_to_grpc_status(
                                       GRPC_CHTTP2_FLOW_CONTROL_ERROR),
@@ -1568,8 +1637,8 @@ static int process_read(transport *t, gpr_slice slice) {
                   "Connect string mismatch: expected '%c' (%d) got '%c' (%d) "
                   "at byte %d",
                   CLIENT_CONNECT_STRING[t->deframe_state],
-                  (int)(gpr_uint8) CLIENT_CONNECT_STRING[t->deframe_state],
-                  *cur, (int)*cur, t->deframe_state);
+                  (int)(gpr_uint8)CLIENT_CONNECT_STRING[t->deframe_state], *cur,
+                  (int)*cur, t->deframe_state);
           drop_connection(t);
           return 0;
         }
@@ -1766,17 +1835,20 @@ static int prepare_callbacks(transport *t) {
   int n = 0;
   while ((s = stream_list_remove_head(t, PENDING_CALLBACKS))) {
     int execute = 1;
-    grpc_sopb_swap(&s->parser.incoming_sopb, &s->callback_sopb);
 
     s->callback_state = compute_state(s->sent_write_closed, s->read_closed);
     if (s->callback_state == GRPC_STREAM_CLOSED) {
       remove_from_stream_map(t, s);
       if (s->published_close) {
         execute = 0;
+      } else if (s->incoming_metadata_count) {
+        add_metadata_batch(t, s);
       }
       s->published_close = 1;
     }
 
+    grpc_sopb_swap(&s->parser.incoming_sopb, &s->callback_sopb);
+
     if (execute) {
       stream_list_add_tail(t, s, EXECUTING_CALLBACKS);
       n = 1;
@@ -1813,9 +1885,9 @@ static void add_to_pollset(grpc_transport *gt, grpc_pollset *pollset) {
  */
 
 static const grpc_transport_vtable vtable = {
-    sizeof(stream),  init_stream,    send_batch,       set_allow_window_updates,
-    add_to_pollset,  destroy_stream, abort_stream,     goaway,
-    close_transport, send_ping,      destroy_transport};
+    sizeof(stream), init_stream, send_batch, set_allow_window_updates,
+    add_to_pollset, destroy_stream, abort_stream, goaway, close_transport,
+    send_ping, destroy_transport};
 
 void grpc_create_chttp2_transport(grpc_transport_setup_callback setup,
                                   void *arg,

src/core/transport/metadata.c

@@ -120,7 +120,7 @@ static void unlock(grpc_mdctx *ctx) {
   if (ctx->refs == 0) {
     /* uncomment if you're having trouble diagnosing an mdelem leak to make
        things clearer (slows down destruction a lot, however) */
-    /* gc_mdtab(ctx); */
+    gc_mdtab(ctx);
     if (ctx->mdtab_count && ctx->mdtab_count == ctx->mdtab_free) {
       discard_metadata(ctx);
     }

src/core/transport/stream_op.c

@@ -33,11 +33,11 @@
 
 #include "src/core/transport/stream_op.h"
 
+#include <string.h>
+
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 
-#include <string.h>
-
 /* Exponential growth function: Given x, return a larger x.
    Currently we grow by 1.5 times upon reallocation. */
 #define GROW(x) (3 * (x) / 2)
@@ -79,33 +79,46 @@ void grpc_stream_ops_unref_owned_objects(grpc_stream_op *ops, size_t nops) {
         gpr_slice_unref(ops[i].data.slice);
         break;
       case GRPC_OP_METADATA:
-        grpc_mdelem_unref(ops[i].data.metadata);
+        grpc_metadata_batch_destroy(&ops[i].data.metadata);
         break;
       case GRPC_OP_FLOW_CTL_CB:
         ops[i].data.flow_ctl_cb.cb(ops[i].data.flow_ctl_cb.arg, GRPC_OP_ERROR);
         break;
       case GRPC_NO_OP:
-      case GRPC_OP_DEADLINE:
-      case GRPC_OP_METADATA_BOUNDARY:
       case GRPC_OP_BEGIN_MESSAGE:
         break;
     }
   }
 }
 
+static void assert_contained_metadata_ok(grpc_stream_op *ops, size_t nops) {
+#ifndef NDEBUG
+  size_t i;
+  for (i = 0; i < nops; i++) {
+    if (ops[i].type == GRPC_OP_METADATA) {
+      grpc_metadata_batch_assert_ok(&ops[i].data.metadata);
+    }
+  }
+#endif /* NDEBUG */
+}
+
 static void expandto(grpc_stream_op_buffer *sopb, size_t new_capacity) {
   sopb->capacity = new_capacity;
+  assert_contained_metadata_ok(sopb->ops, sopb->nops);
   if (sopb->ops == sopb->inlined_ops) {
     sopb->ops = gpr_malloc(sizeof(grpc_stream_op) * new_capacity);
     memcpy(sopb->ops, sopb->inlined_ops, sopb->nops * sizeof(grpc_stream_op));
   } else {
     sopb->ops = gpr_realloc(sopb->ops, sizeof(grpc_stream_op) * new_capacity);
   }
+  assert_contained_metadata_ok(sopb->ops, sopb->nops);
 }
 
 static grpc_stream_op *add(grpc_stream_op_buffer *sopb) {
   grpc_stream_op *out;
 
+  assert_contained_metadata_ok(sopb->ops, sopb->nops);
+
   if (sopb->nops == sopb->capacity) {
     expandto(sopb, GROW(sopb->capacity));
   }
@@ -116,6 +129,7 @@ static grpc_stream_op *add(grpc_stream_op_buffer *sopb) {
 
 void grpc_sopb_add_no_op(grpc_stream_op_buffer *sopb) {
   add(sopb)->type = GRPC_NO_OP;
+  assert_contained_metadata_ok(sopb->ops, sopb->nops);
 }
 
 void grpc_sopb_add_begin_message(grpc_stream_op_buffer *sopb, gpr_uint32 length,
@@ -124,30 +138,24 @@ void grpc_sopb_add_begin_message(grpc_stream_op_buffer *sopb, gpr_uint32 length,
   op->type = GRPC_OP_BEGIN_MESSAGE;
   op->data.begin_message.length = length;
   op->data.begin_message.flags = flags;
+  assert_contained_metadata_ok(sopb->ops, sopb->nops);
 }
 
-void grpc_sopb_add_metadata_boundary(grpc_stream_op_buffer *sopb) {
-  grpc_stream_op *op = add(sopb);
-  op->type = GRPC_OP_METADATA_BOUNDARY;
-}
-
-void grpc_sopb_add_metadata(grpc_stream_op_buffer *sopb, grpc_mdelem *md) {
+void grpc_sopb_add_metadata(grpc_stream_op_buffer *sopb,
+                            grpc_metadata_batch b) {
   grpc_stream_op *op = add(sopb);
+  grpc_metadata_batch_assert_ok(&b);
   op->type = GRPC_OP_METADATA;
-  op->data.metadata = md;
-}
-
-void grpc_sopb_add_deadline(grpc_stream_op_buffer *sopb,
-                            gpr_timespec deadline) {
-  grpc_stream_op *op = add(sopb);
-  op->type = GRPC_OP_DEADLINE;
-  op->data.deadline = deadline;
+  op->data.metadata = b;
+  grpc_metadata_batch_assert_ok(&op->data.metadata);
+  assert_contained_metadata_ok(sopb->ops, sopb->nops);
 }
 
 void grpc_sopb_add_slice(grpc_stream_op_buffer *sopb, gpr_slice slice) {
   grpc_stream_op *op = add(sopb);
   op->type = GRPC_OP_SLICE;
   op->data.slice = slice;
+  assert_contained_metadata_ok(sopb->ops, sopb->nops);
 }
 
 void grpc_sopb_add_flow_ctl_cb(grpc_stream_op_buffer *sopb,
@@ -157,6 +165,7 @@ void grpc_sopb_add_flow_ctl_cb(grpc_stream_op_buffer *sopb,
   op->type = GRPC_OP_FLOW_CTL_CB;
   op->data.flow_ctl_cb.cb = cb;
   op->data.flow_ctl_cb.arg = arg;
+  assert_contained_metadata_ok(sopb->ops, sopb->nops);
 }
 
 void grpc_sopb_append(grpc_stream_op_buffer *sopb, grpc_stream_op *ops,
@@ -164,10 +173,161 @@ void grpc_sopb_append(grpc_stream_op_buffer *sopb, grpc_stream_op *ops,
   size_t orig_nops = sopb->nops;
   size_t new_nops = orig_nops + nops;
 
+  assert_contained_metadata_ok(ops, nops);
+  assert_contained_metadata_ok(sopb->ops, sopb->nops);
   if (new_nops > sopb->capacity) {
     expandto(sopb, GPR_MAX(GROW(sopb->capacity), new_nops));
   }
 
   memcpy(sopb->ops + orig_nops, ops, sizeof(grpc_stream_op) * nops);
   sopb->nops = new_nops;
+  assert_contained_metadata_ok(sopb->ops, sopb->nops);
+}
+
+static void assert_valid_list(grpc_mdelem_list *list) {
+#ifndef NDEBUG
+  grpc_linked_mdelem *l;
+
+  GPR_ASSERT((list->head == NULL) == (list->tail == NULL));
+  if (!list->head) return;
+  GPR_ASSERT(list->head->prev == NULL);
+  GPR_ASSERT(list->tail->next == NULL);
+  GPR_ASSERT((list->head == list->tail) == (list->head->next == NULL));
+
+  for (l = list->head; l; l = l->next) {
+    GPR_ASSERT(l->md);
+    GPR_ASSERT((l->prev == NULL) == (l == list->head));
+    GPR_ASSERT((l->next == NULL) == (l == list->tail));
+    if (l->next) GPR_ASSERT(l->next->prev == l);
+    if (l->prev) GPR_ASSERT(l->prev->next == l);
+  }
+#endif /* NDEBUG */
+}
+
+#ifndef NDEBUG
+void grpc_metadata_batch_assert_ok(grpc_metadata_batch *comd) {
+  assert_valid_list(&comd->list);
+  assert_valid_list(&comd->garbage);
+}
+#endif /* NDEBUG */
+
+void grpc_metadata_batch_init(grpc_metadata_batch *comd) {
+  comd->list.head = comd->list.tail = comd->garbage.head = comd->garbage.tail =
+      NULL;
+  comd->deadline = gpr_inf_future;
+}
+
+void grpc_metadata_batch_destroy(grpc_metadata_batch *comd) {
+  grpc_linked_mdelem *l;
+  for (l = comd->list.head; l; l = l->next) {
+    grpc_mdelem_unref(l->md);
+  }
+  for (l = comd->garbage.head; l; l = l->next) {
+    grpc_mdelem_unref(l->md);
+  }
+}
+
+void grpc_metadata_batch_add_head(grpc_metadata_batch *comd,
+                                  grpc_linked_mdelem *storage,
+                                  grpc_mdelem *elem_to_add) {
+  GPR_ASSERT(elem_to_add);
+  storage->md = elem_to_add;
+  grpc_metadata_batch_link_head(comd, storage);
+}
+
+static void link_head(grpc_mdelem_list *list, grpc_linked_mdelem *storage) {
+  assert_valid_list(list);
+  GPR_ASSERT(storage->md);
+  storage->prev = NULL;
+  storage->next = list->head;
+  if (list->head != NULL) {
+    list->head->prev = storage;
+  } else {
+    list->tail = storage;
+  }
+  list->head = storage;
+  assert_valid_list(list);
+}
+
+void grpc_metadata_batch_link_head(grpc_metadata_batch *comd,
+                                   grpc_linked_mdelem *storage) {
+  link_head(&comd->list, storage);
+}
+
+void grpc_metadata_batch_add_tail(grpc_metadata_batch *comd,
+                                  grpc_linked_mdelem *storage,
+                                  grpc_mdelem *elem_to_add) {
+  GPR_ASSERT(elem_to_add);
+  storage->md = elem_to_add;
+  grpc_metadata_batch_link_tail(comd, storage);
+}
+
+static void link_tail(grpc_mdelem_list *list, grpc_linked_mdelem *storage) {
+  assert_valid_list(list);
+  GPR_ASSERT(storage->md);
+  storage->prev = list->tail;
+  storage->next = NULL;
+  if (list->tail != NULL) {
+    list->tail->next = storage;
+  } else {
+    list->head = storage;
+  }
+  list->tail = storage;
+  assert_valid_list(list);
+}
+
+void grpc_metadata_batch_link_tail(grpc_metadata_batch *comd,
+                                   grpc_linked_mdelem *storage) {
+  link_tail(&comd->list, storage);
+}
+
+void grpc_metadata_batch_merge(grpc_metadata_batch *target,
+                               grpc_metadata_batch *add) {
+  grpc_linked_mdelem *l;
+  grpc_linked_mdelem *next;
+  for (l = add->list.head; l; l = next) {
+    next = l->next;
+    link_tail(&target->list, l);
+  }
+  for (l = add->garbage.head; l; l = next) {
+    next = l->next;
+    link_tail(&target->garbage, l);
+  }
+}
+
+void grpc_metadata_batch_filter(grpc_metadata_batch *comd,
+                                grpc_mdelem *(*filter)(void *user_data,
+                                                       grpc_mdelem *elem),
+                                void *user_data) {
+  grpc_linked_mdelem *l;
+  grpc_linked_mdelem *next;
+
+  assert_valid_list(&comd->list);
+  assert_valid_list(&comd->garbage);
+  for (l = comd->list.head; l; l = next) {
+    grpc_mdelem *orig = l->md;
+    grpc_mdelem *filt = filter(user_data, orig);
+    next = l->next;
+    if (filt == NULL) {
+      if (l->prev) {
+        l->prev->next = l->next;
+      }
+      if (l->next) {
+        l->next->prev = l->prev;
+      }
+      if (comd->list.head == l) {
+        comd->list.head = l->next;
+      }
+      if (comd->list.tail == l) {
+        comd->list.tail = l->prev;
+      }
+      assert_valid_list(&comd->list);
+      link_head(&comd->garbage, l);
+    } else if (filt != orig) {
+      grpc_mdelem_unref(orig);
+      l->md = filt;
+    }
+  }
+  assert_valid_list(&comd->list);
+  assert_valid_list(&comd->garbage);
 }

src/core/transport/stream_op.h

@@ -50,8 +50,6 @@ typedef enum grpc_stream_op_code {
      Must be ignored by receivers */
   GRPC_NO_OP,
   GRPC_OP_METADATA,
-  GRPC_OP_DEADLINE,
-  GRPC_OP_METADATA_BOUNDARY,
   /* Begin a message/metadata element/status - as defined by
      grpc_message_type. */
   GRPC_OP_BEGIN_MESSAGE,
@@ -76,6 +74,51 @@ typedef struct grpc_flow_ctl_cb {
   void *arg;
 } grpc_flow_ctl_cb;
 
+typedef struct grpc_linked_mdelem {
+  grpc_mdelem *md;
+  struct grpc_linked_mdelem *next;
+  struct grpc_linked_mdelem *prev;
+} grpc_linked_mdelem;
+
+typedef struct grpc_mdelem_list {
+  grpc_linked_mdelem *head;
+  grpc_linked_mdelem *tail;
+} grpc_mdelem_list;
+
+typedef struct grpc_metadata_batch {
+  grpc_mdelem_list list;
+  grpc_mdelem_list garbage;
+  gpr_timespec deadline;
+} grpc_metadata_batch;
+
+void grpc_metadata_batch_init(grpc_metadata_batch *comd);
+void grpc_metadata_batch_destroy(grpc_metadata_batch *comd);
+void grpc_metadata_batch_merge(grpc_metadata_batch *target,
+                                 grpc_metadata_batch *add);
+
+void grpc_metadata_batch_link_head(grpc_metadata_batch *comd,
+                                     grpc_linked_mdelem *storage);
+void grpc_metadata_batch_link_tail(grpc_metadata_batch *comd,
+                                     grpc_linked_mdelem *storage);
+
+void grpc_metadata_batch_add_head(grpc_metadata_batch *comd,
+                                    grpc_linked_mdelem *storage,
+                                    grpc_mdelem *elem_to_add);
+void grpc_metadata_batch_add_tail(grpc_metadata_batch *comd,
+                                    grpc_linked_mdelem *storage,
+                                    grpc_mdelem *elem_to_add);
+
+void grpc_metadata_batch_filter(grpc_metadata_batch *comd,
+                                  grpc_mdelem *(*filter)(void *user_data,
+                                                         grpc_mdelem *elem),
+                                  void *user_data);
+
+#ifndef NDEBUG
+void grpc_metadata_batch_assert_ok(grpc_metadata_batch *comd);
+#else
+#define grpc_metadata_batch_assert_ok(comd) do {} while (0)
+#endif
+
 /* Represents a single operation performed on a stream/transport */
 typedef struct grpc_stream_op {
   /* the operation to be applied */
@@ -84,8 +127,7 @@ typedef struct grpc_stream_op {
      associated op-code */
   union {
     grpc_begin_message begin_message;
-    grpc_mdelem *metadata;
-    gpr_timespec deadline;
+    grpc_metadata_batch metadata;
     gpr_slice slice;
     grpc_flow_ctl_cb flow_ctl_cb;
   } data;
@@ -118,9 +160,7 @@ void grpc_sopb_add_no_op(grpc_stream_op_buffer *sopb);
 /* Append a GRPC_OP_BEGIN to a buffer */
 void grpc_sopb_add_begin_message(grpc_stream_op_buffer *sopb, gpr_uint32 length,
                                  gpr_uint32 flags);
-void grpc_sopb_add_metadata(grpc_stream_op_buffer *sopb, grpc_mdelem *metadata);
-void grpc_sopb_add_deadline(grpc_stream_op_buffer *sopb, gpr_timespec deadline);
-void grpc_sopb_add_metadata_boundary(grpc_stream_op_buffer *sopb);
+void grpc_sopb_add_metadata(grpc_stream_op_buffer *sopb, grpc_metadata_batch metadata);
 /* Append a GRPC_SLICE to a buffer - does not ref/unref the slice */
 void grpc_sopb_add_slice(grpc_stream_op_buffer *sopb, gpr_slice slice);
 /* Append a GRPC_OP_FLOW_CTL_CB to a buffer */

src/core/tsi/ssl_transport_security.c

@@ -34,6 +34,7 @@
 #include "src/core/tsi/ssl_transport_security.h"
 
 #include <limits.h>
+#include <string.h>
 
 #include <grpc/support/log.h>
 #include <grpc/support/sync.h>

src/cpp/client/channel.cc

@@ -33,7 +33,6 @@
 
 #include "src/cpp/client/channel.h"
 
-#include <chrono>
 #include <memory>
 
 #include <grpc/grpc.h>
@@ -65,14 +64,14 @@ Call Channel::CreateCall(const RpcMethod& method, ClientContext* context,
       method.channel_tag()
           ? grpc_channel_create_registered_call(c_channel_, cq->cq(),
                                                 method.channel_tag(),
-                                                context->RawDeadline())
+                                                context->raw_deadline())
           : grpc_channel_create_call(c_channel_, cq->cq(), method.name(),
                                      context->authority().empty()
                                          ? target_.c_str()
                                          : context->authority().c_str(),
-                                     context->RawDeadline());
+                                     context->raw_deadline());
   GRPC_TIMER_MARK(CALL_CREATED, c_call);
-  context->set_call(c_call);
+  context->set_call(c_call, shared_from_this());
   return Call(c_call, this, cq);
 }
 

src/cpp/client/channel.h

@@ -38,6 +38,7 @@
 
 #include <grpc++/channel_interface.h>
 #include <grpc++/config.h>
+#include <grpc++/impl/grpc_library.h>
 
 struct grpc_channel;
 
@@ -49,7 +50,9 @@ class CompletionQueue;
 class Credentials;
 class StreamContextInterface;
 
-class Channel GRPC_FINAL : public ChannelInterface {
+class Channel GRPC_FINAL : public GrpcLibrary,
+                           public std::enable_shared_from_this<Channel>,
+                           public ChannelInterface {
  public:
   Channel(const grpc::string& target, grpc_channel* c_channel);
   ~Channel() GRPC_OVERRIDE;

src/cpp/client/client_context.cc

@@ -34,9 +34,7 @@
 #include <grpc++/client_context.h>
 
 #include <grpc/grpc.h>
-#include "src/cpp/util/time.h"
-
-using std::chrono::system_clock;
+#include <grpc++/time.h>
 
 namespace grpc {
 
@@ -44,7 +42,7 @@ ClientContext::ClientContext()
     : initial_metadata_received_(false),
       call_(nullptr),
       cq_(nullptr),
-      absolute_deadline_(gpr_inf_future) {}
+      deadline_(gpr_inf_future) {}
 
 ClientContext::~ClientContext() {
   if (call_) {
@@ -64,15 +62,6 @@ ClientContext::~ClientContext() {
   }
 }
 
-void ClientContext::set_absolute_deadline(
-    const system_clock::time_point& deadline) {
-  Timepoint2Timespec(deadline, &absolute_deadline_);
-}
-
-system_clock::time_point ClientContext::absolute_deadline() {
-  return Timespec2Timepoint(absolute_deadline_);
-}
-
 void ClientContext::AddMetadata(const grpc::string& meta_key,
                                 const grpc::string& meta_value) {
   send_initial_metadata_.insert(std::make_pair(meta_key, meta_value));

src/cpp/client/secure_credentials.cc

@@ -81,27 +81,27 @@ std::unique_ptr<Credentials> ComputeEngineCredentials() {
 // Builds service account credentials.
 std::unique_ptr<Credentials> ServiceAccountCredentials(
     const grpc::string& json_key, const grpc::string& scope,
-    std::chrono::seconds token_lifetime) {
-  if (token_lifetime.count() <= 0) {
+    long token_lifetime_seconds) {
+  if (token_lifetime_seconds <= 0) {
     gpr_log(GPR_ERROR,
             "Trying to create ServiceAccountCredentials "
             "with non-positive lifetime");
     return WrapCredentials(nullptr);
   }
-  gpr_timespec lifetime = gpr_time_from_seconds(token_lifetime.count());
+  gpr_timespec lifetime = gpr_time_from_seconds(token_lifetime_seconds);
   return WrapCredentials(grpc_service_account_credentials_create(
       json_key.c_str(), scope.c_str(), lifetime));
 }
 
 // Builds JWT credentials.
 std::unique_ptr<Credentials> JWTCredentials(
-    const grpc::string& json_key, std::chrono::seconds token_lifetime) {
-  if (token_lifetime.count() <= 0) {
+    const grpc::string& json_key, long token_lifetime_seconds) {
+  if (token_lifetime_seconds <= 0) {
     gpr_log(GPR_ERROR,
             "Trying to create JWTCredentials with non-positive lifetime");
     return WrapCredentials(nullptr);
   }
-  gpr_timespec lifetime = gpr_time_from_seconds(token_lifetime.count());
+  gpr_timespec lifetime = gpr_time_from_seconds(token_lifetime_seconds);
   return WrapCredentials(
       grpc_jwt_credentials_create(json_key.c_str(), lifetime));
 }

src/cpp/common/completion_queue.cc

@@ -36,7 +36,7 @@
 
 #include <grpc/grpc.h>
 #include <grpc/support/log.h>
-#include "src/cpp/util/time.h"
+#include <grpc++/time.h>
 
 namespace grpc {
 
@@ -77,13 +77,6 @@ CompletionQueue::NextStatus CompletionQueue::AsyncNextInternal(
   }
 }
 
-CompletionQueue::NextStatus CompletionQueue::AsyncNext(
-    void** tag, bool* ok, std::chrono::system_clock::time_point deadline) {
-  gpr_timespec gpr_deadline;
-  Timepoint2Timespec(deadline, &gpr_deadline);
-  return AsyncNextInternal(tag, ok, gpr_deadline);
-}
-
 bool CompletionQueue::Pluck(CompletionQueueTag* tag) {
   std::unique_ptr<grpc_event, EventDeleter> ev;
 
@@ -92,7 +85,8 @@ bool CompletionQueue::Pluck(CompletionQueueTag* tag) {
   void* ignored = tag;
   GPR_ASSERT(tag->FinalizeResult(&ignored, &ok));
   GPR_ASSERT(ignored == tag);
-  return ok;
+  // Ignore mutations by FinalizeResult: Pluck returns the C API status
+  return ev->data.op_complete == GRPC_OP_OK;
 }
 
 void CompletionQueue::TryPluck(CompletionQueueTag* tag) {

src/cpp/server/server.cc

@@ -45,10 +45,10 @@
 #include <grpc++/server_context.h>
 #include <grpc++/server_credentials.h>
 #include <grpc++/thread_pool_interface.h>
+#include <grpc++/time.h>
 
 #include "src/core/profiling/timers.h"
 #include "src/cpp/proto/proto_utils.h"
-#include "src/cpp/util/time.h"
 
 namespace grpc {
 
@@ -353,7 +353,7 @@ class Server::AsyncRequest GRPC_FINAL : public CompletionQueueTag {
     ServerContext* ctx = ctx_ ? ctx_ : generic_ctx_;
     GPR_ASSERT(ctx);
     if (*status) {
-      ctx->deadline_ = Timespec2Timepoint(call_details_.deadline);
+      ctx->deadline_ = call_details_.deadline;
       for (size_t i = 0; i < array_.count; i++) {
         ctx->client_metadata_.insert(std::make_pair(
             grpc::string(array_.metadata[i].key),

src/cpp/server/server_context.cc

@@ -33,11 +33,11 @@
 
 #include <grpc++/server_context.h>
 
-#include <grpc++/impl/call.h>
-#include <grpc++/impl/sync.h>
 #include <grpc/grpc.h>
 #include <grpc/support/log.h>
-#include "src/cpp/util/time.h"
+#include <grpc++/impl/call.h>
+#include <grpc++/impl/sync.h>
+#include <grpc++/time.h>
 
 namespace grpc {
 
@@ -99,7 +99,7 @@ ServerContext::ServerContext()
 ServerContext::ServerContext(gpr_timespec deadline, grpc_metadata* metadata,
                              size_t metadata_count)
     : completion_op_(nullptr),
-      deadline_(Timespec2Timepoint(deadline)),
+      deadline_(deadline),
       call_(nullptr),
       cq_(nullptr),
       sent_initial_metadata_(false) {

src/cpp/util/byte_buffer.cc

@@ -60,7 +60,6 @@ void ByteBuffer::Dump(std::vector<Slice>* slices) {
   gpr_slice s;
   while (grpc_byte_buffer_reader_next(reader, &s)) {
     slices->push_back(Slice(s, Slice::STEAL_REF));
-    gpr_slice_unref(s);
   }
   grpc_byte_buffer_reader_destroy(reader);
 }

src/cpp/util/time.cc

@@ -31,9 +31,12 @@
  *
  */
 
-#include "src/cpp/util/time.h"
+#include <grpc++/config.h>
+
+#ifndef GRPC_CXX0X_NO_CHRONO
 
 #include <grpc/support/time.h>
+#include <grpc++/time.h>
 
 using std::chrono::duration_cast;
 using std::chrono::nanoseconds;
@@ -68,3 +71,5 @@ system_clock::time_point Timespec2Timepoint(gpr_timespec t) {
 }
 
 }  // namespace grpc
+
+#endif  // !GRPC_CXX0X_NO_CHRONO

src/csharp/Grpc.Core/.gitignore

@@ -1,2 +1,3 @@
 bin
-obj
+obj
+*.nupkg

src/csharp/Grpc.Core/Grpc.Core.csproj

@@ -1,5 +1,7 @@
 <?xml version="1.0" encoding="utf-8"?>
 <Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <Import Project="..\packages\grpc.dependencies.zlib.redist.1.2.8.9\build\portable-net45\grpc.dependencies.zlib.redist.props" Condition="Exists('..\packages\grpc.dependencies.zlib.redist.1.2.8.9\build\portable-net45\grpc.dependencies.zlib.redist.props')" />
+  <Import Project="..\packages\grpc.dependencies.openssl.redist.1.0.2.2\build\portable-net45\grpc.dependencies.openssl.redist.props" Condition="Exists('..\packages\grpc.dependencies.openssl.redist.1.0.2.2\build\portable-net45\grpc.dependencies.openssl.redist.props')" />
   <PropertyGroup>
     <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
     <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
@@ -10,6 +12,7 @@
     <RootNamespace>Grpc.Core</RootNamespace>
     <AssemblyName>Grpc.Core</AssemblyName>
     <TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
+    <NuGetPackageImportStamp>8bb563fb</NuGetPackageImportStamp>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
     <DebugSymbols>true</DebugSymbols>
@@ -31,8 +34,9 @@
   </PropertyGroup>
   <ItemGroup>
     <Reference Include="System" />
-    <Reference Include="System.Collections.Immutable">
-      <HintPath>..\packages\System.Collections.Immutable.1.1.34-rc\lib\portable-net45+win8+wp8+wpa81\System.Collections.Immutable.dll</HintPath>
+    <Reference Include="System.Collections.Immutable, Version=1.0.34.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\packages\Microsoft.Bcl.Immutable.1.0.34\lib\portable-net45+win8+wp8+wpa81\System.Collections.Immutable.dll</HintPath>
     </Reference>
   </ItemGroup>
   <ItemGroup>
@@ -92,7 +96,7 @@
          ignored, which gives us the desired effect. -->
     <When Condition=" '$(OS)' != 'Unix' ">
       <ItemGroup>
-        <Content Include="..\..\..\vsprojects\vs2013\Debug\grpc_csharp_ext.dll">
+        <Content Include="..\..\..\vsprojects\Debug\grpc_csharp_ext.dll">
           <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
         </Content>
       </ItemGroup>
@@ -100,7 +104,16 @@
     <Otherwise />
   </Choose>
   <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
-  <ItemGroup>
-    <Folder Include="Stub\" />
-  </ItemGroup>
+  <ItemGroup />
+  <Target Name="EnsureNuGetPackageBuildImports" BeforeTargets="PrepareForBuild">
+    <PropertyGroup>
+      <ErrorText>This project references NuGet package(s) that are missing on this computer. Enable NuGet Package Restore to download them.  For more information, see http://go.microsoft.com/fwlink/?LinkID=322105. The missing file is {0}.</ErrorText>
+    </PropertyGroup>
+    <Error Condition="!Exists('..\packages\grpc.dependencies.openssl.redist.1.0.2.2\build\portable-net45\grpc.dependencies.openssl.redist.props')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\grpc.dependencies.openssl.redist.1.0.2.2\build\portable-net45\grpc.dependencies.openssl.redist.props'))" />
+    <Error Condition="!Exists('..\packages\grpc.dependencies.openssl.redist.1.0.2.2\build\portable-net45\grpc.dependencies.openssl.redist.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\grpc.dependencies.openssl.redist.1.0.2.2\build\portable-net45\grpc.dependencies.openssl.redist.targets'))" />
+    <Error Condition="!Exists('..\packages\grpc.dependencies.zlib.redist.1.2.8.9\build\portable-net45\grpc.dependencies.zlib.redist.props')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\grpc.dependencies.zlib.redist.1.2.8.9\build\portable-net45\grpc.dependencies.zlib.redist.props'))" />
+    <Error Condition="!Exists('..\packages\grpc.dependencies.zlib.redist.1.2.8.9\build\portable-net45\grpc.dependencies.zlib.redist.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\grpc.dependencies.zlib.redist.1.2.8.9\build\portable-net45\grpc.dependencies.zlib.redist.targets'))" />
+  </Target>
+  <Import Project="..\packages\grpc.dependencies.openssl.redist.1.0.2.2\build\portable-net45\grpc.dependencies.openssl.redist.targets" Condition="Exists('..\packages\grpc.dependencies.openssl.redist.1.0.2.2\build\portable-net45\grpc.dependencies.openssl.redist.targets')" />
+  <Import Project="..\packages\grpc.dependencies.zlib.redist.1.2.8.9\build\portable-net45\grpc.dependencies.zlib.redist.targets" Condition="Exists('..\packages\grpc.dependencies.zlib.redist.1.2.8.9\build\portable-net45\grpc.dependencies.zlib.redist.targets')" />
 </Project>

src/csharp/Grpc.Core/Grpc.Core.nuspec

@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="utf-8"?>
-<package >
+<package>
   <metadata>
     <id>Grpc.Core</id>
     <title>gRPC Core</title>
@@ -7,7 +7,7 @@
     <description>Core C# implementation of gRPC - an RPC library and framework. See project site for more info.
      This is an experimental release, not ready to use.
     </description>
-    <version>0.2.0</version>
+    <version>0.2.1</version>
     <authors>Google Inc.</authors>
     <owners>jtattermusch</owners>
     <licenseUrl>https://github.com/grpc/grpc/blob/master/LICENSE</licenseUrl>
@@ -16,6 +16,10 @@
     <releaseNotes>The first experimental release. Not ready to use.</releaseNotes>
     <copyright>Copyright 2015, Google Inc.</copyright>
     <tags>gRPC RPC Protocol HTTP/2</tags>
+	<dependencies>
+	  <dependency id="Microsoft.Bcl.Immutable" version="1.0.34" />
+	  <dependency id="grpc.native.csharp_ext" version="0.6.0.0" />
+    </dependencies>
   </metadata>
   <files>
     <file src="bin/Release/Grpc.Core.dll" target="lib/net45" />

src/csharp/Grpc.Core/Internal/CallSafeHandle.cs

@@ -33,6 +33,7 @@ using System;
 using System.Diagnostics;
 using System.Runtime.InteropServices;
 using Grpc.Core;
+using Grpc.Core.Utils;
 
 namespace Grpc.Core.Internal
 {
@@ -180,7 +181,7 @@ namespace Grpc.Core.Internal
 
         private static void AssertCallOk(GRPCCallError callError)
         {
-            Trace.Assert(callError == GRPCCallError.GRPC_CALL_OK, "Status not GRPC_CALL_OK");
+            Preconditions.CheckState(callError == GRPCCallError.GRPC_CALL_OK, "Status not GRPC_CALL_OK");
         }
 
         private static uint GetFlags(bool buffered)

src/csharp/Grpc.Core/Internal/ServerSafeHandle.cs

@@ -35,6 +35,7 @@ using System;
 using System.Collections.Concurrent;
 using System.Diagnostics;
 using System.Runtime.InteropServices;
+using Grpc.Core.Utils;
 
 namespace Grpc.Core.Internal
 {
@@ -105,9 +106,9 @@ namespace Grpc.Core.Internal
             grpcsharp_server_shutdown_and_notify_CALLBACK(this, callback);
         }
 
-        public GRPCCallError RequestCall(CompletionQueueSafeHandle cq, CompletionCallbackDelegate callback)
+        public void RequestCall(CompletionQueueSafeHandle cq, CompletionCallbackDelegate callback)
         {
-            return grpcsharp_server_request_call(this, cq, callback);
+            AssertCallOk(grpcsharp_server_request_call(this, cq, callback));
         }
 
         protected override bool ReleaseHandle()
@@ -115,5 +116,10 @@ namespace Grpc.Core.Internal
             grpcsharp_server_destroy(handle);
             return true;
         }
+
+        private static void AssertCallOk(GRPCCallError callError)
+        {
+            Preconditions.CheckState(callError == GRPCCallError.GRPC_CALL_OK, "Status not GRPC_CALL_OK");
+        }
     }
 }

src/csharp/Grpc.Core/Server.cs

@@ -38,27 +38,29 @@ using System.Diagnostics;
 using System.Runtime.InteropServices;
 using System.Threading.Tasks;
 using Grpc.Core.Internal;
+using Grpc.Core.Utils;
 
 namespace Grpc.Core
 {
     /// <summary>
-    /// Server is implemented only to be able to do
-    /// in-process testing.
+    /// A gRPC server.
     /// </summary>
     public class Server
     {
-        // TODO: make sure the delegate doesn't get garbage collected while
+        // TODO(jtattermusch) : make sure the delegate doesn't get garbage collected while
         // native callbacks are in the completion queue.
         readonly ServerShutdownCallbackDelegate serverShutdownHandler;
         readonly CompletionCallbackDelegate newServerRpcHandler;
 
-        readonly BlockingCollection<NewRpcInfo> newRpcQueue = new BlockingCollection<NewRpcInfo>();
         readonly ServerSafeHandle handle;
+        readonly object myLock = new object();
 
         readonly Dictionary<string, IServerCallHandler> callHandlers = new Dictionary<string, IServerCallHandler>();
-
         readonly TaskCompletionSource<object> shutdownTcs = new TaskCompletionSource<object>();
 
+        bool startRequested;
+        bool shutdownRequested;
+
         public Server()
         {
             this.handle = ServerSafeHandle.NewServer(GetCompletionQueue(), IntPtr.Zero);
@@ -66,71 +68,81 @@ namespace Grpc.Core
             this.serverShutdownHandler = HandleServerShutdown;
         }
 
-        // only call this before Start()
+        /// <summary>
+        /// Adds a service definition to the server. This is how you register
+        /// handlers for a service with the server.
+        /// Only call this before Start().
+        /// </summary>
         public void AddServiceDefinition(ServerServiceDefinition serviceDefinition)
         {
-            foreach (var entry in serviceDefinition.CallHandlers)
+            lock (myLock)
             {
-                callHandlers.Add(entry.Key, entry.Value);
+                Preconditions.CheckState(!startRequested);
+                foreach (var entry in serviceDefinition.CallHandlers)
+                {
+                    callHandlers.Add(entry.Key, entry.Value);
+                }
             }
         }
 
-        // only call before Start()
+        /// <summary>
+        /// Add a non-secure port on which server should listen.
+        /// Only call this before Start().
+        /// </summary>
         public int AddListeningPort(string addr)
         {
-            return handle.AddListeningPort(addr);
-        }
-
-        // only call before Start()
-        public int AddListeningPort(string addr, ServerCredentials credentials)
-        {
-            using (var nativeCredentials = credentials.ToNativeCredentials())
+            lock (myLock)
             {
-                return handle.AddListeningPort(addr, nativeCredentials);
+                Preconditions.CheckState(!startRequested);
+                return handle.AddListeningPort(addr);
             }
         }
 
-        public void Start()
-        {
-            handle.Start();
-
-            // TODO: this basically means the server is single threaded....
-            StartHandlingRpcs();
-        }
-
         /// <summary>
-        /// Requests and handles single RPC call.
+        /// Add a secure port on which server should listen.
+        /// Only call this before Start().
         /// </summary>
-        internal void RunRpc()
+        public int AddListeningPort(string addr, ServerCredentials credentials)
         {
-            AllowOneRpc();
-
-            try
+            lock (myLock)
             {
-                var rpcInfo = newRpcQueue.Take();
-
-                // Console.WriteLine("Server received RPC " + rpcInfo.Method);
-
-                IServerCallHandler callHandler;
-                if (!callHandlers.TryGetValue(rpcInfo.Method, out callHandler))
+                Preconditions.CheckState(!startRequested);
+                using (var nativeCredentials = credentials.ToNativeCredentials())
                 {
-                    callHandler = new NoSuchMethodCallHandler();
+                    return handle.AddListeningPort(addr, nativeCredentials);
                 }
-                callHandler.StartCall(rpcInfo.Method, rpcInfo.Call, GetCompletionQueue());
             }
-            catch (Exception e)
+        }
+
+        /// <summary>
+        /// Starts the server.
+        /// </summary>
+        public void Start()
+        {
+            lock (myLock)
             {
-                Console.WriteLine("Exception while handling RPC: " + e);
+                Preconditions.CheckState(!startRequested);
+                startRequested = true;
+                
+                handle.Start();
+                AllowOneRpc();
             }
         }
 
         /// <summary>
         /// Requests server shutdown and when there are no more calls being serviced,
-        /// cleans up used resources.
+        /// cleans up used resources. The returned task finishes when shutdown procedure
+        /// is complete.
         /// </summary>
-        /// <returns>The async.</returns>
         public async Task ShutdownAsync()
         {
+            lock (myLock)
+            {
+                Preconditions.CheckState(startRequested);
+                Preconditions.CheckState(!shutdownRequested);
+                shutdownRequested = true;
+            }
+
             handle.ShutdownAndNotify(serverShutdownHandler);
             await shutdownTcs.Task;
             handle.Dispose();
@@ -152,19 +164,43 @@ namespace Grpc.Core
             handle.Dispose();
         }
 
-        private async Task StartHandlingRpcs()
+        /// <summary>
+        /// Allows one new RPC call to be received by server.
+        /// </summary>
+        private void AllowOneRpc()
         {
-            while (true)
+            lock (myLock)
             {
-                await Task.Factory.StartNew(RunRpc);
+                if (!shutdownRequested)
+                {
+                    handle.RequestCall(GetCompletionQueue(), newServerRpcHandler);
+                }
             }
         }
 
-        private void AllowOneRpc()
+        /// <summary>
+        /// Selects corresponding handler for given call and handles the call.
+        /// </summary>
+        private void InvokeCallHandler(CallSafeHandle call, string method)
         {
-            AssertCallOk(handle.RequestCall(GetCompletionQueue(), newServerRpcHandler));
+            try
+            {
+                IServerCallHandler callHandler;
+                if (!callHandlers.TryGetValue(method, out callHandler))
+                {
+                    callHandler = new NoSuchMethodCallHandler();
+                }
+                callHandler.StartCall(method, call, GetCompletionQueue());
+            }
+            catch (Exception e)
+            {
+                Console.WriteLine("Exception while handling RPC: " + e);
+            }
         }
 
+        /// <summary>
+        /// Handles the native callback.
+        /// </summary>
         private void HandleNewServerRpc(GRPCOpError error, IntPtr batchContextPtr)
         {
             try
@@ -176,13 +212,16 @@ namespace Grpc.Core
                     // TODO: handle error
                 }
 
-                var rpcInfo = new NewRpcInfo(ctx.GetServerRpcNewCall(), ctx.GetServerRpcNewMethod());
+                CallSafeHandle call = ctx.GetServerRpcNewCall();
+                string method = ctx.GetServerRpcNewMethod();
 
                 // after server shutdown, the callback returns with null call
-                if (!rpcInfo.Call.IsInvalid)
+                if (!call.IsInvalid)
                 {
-                    newRpcQueue.Add(rpcInfo);
+                    Task.Run(() => InvokeCallHandler(call, method));
                 }
+
+                AllowOneRpc();
             }
             catch (Exception e)
             {
@@ -190,6 +229,10 @@ namespace Grpc.Core
             }
         }
 
+        /// <summary>
+        /// Handles native callback.
+        /// </summary>
+        /// <param name="eventPtr"></param>
         private void HandleServerShutdown(IntPtr eventPtr)
         {
             try
@@ -202,42 +245,9 @@ namespace Grpc.Core
             }
         }
 
-        private static void AssertCallOk(GRPCCallError callError)
-        {
-            Trace.Assert(callError == GRPCCallError.GRPC_CALL_OK, "Status not GRPC_CALL_OK");
-        }
-
         private static CompletionQueueSafeHandle GetCompletionQueue()
         {
             return GrpcEnvironment.ThreadPool.CompletionQueue;
         }
-
-        private struct NewRpcInfo
-        {
-            private CallSafeHandle call;
-            private string method;
-
-            public NewRpcInfo(CallSafeHandle call, string method)
-            {
-                this.call = call;
-                this.method = method;
-            }
-
-            public CallSafeHandle Call
-            {
-                get
-                {
-                    return this.call;
-                }
-            }
-
-            public string Method
-            {
-                get
-                {
-                    return this.method;
-                }
-            }
-        }
     }
 }

src/csharp/Grpc.Core/packages.config

@@ -1,4 +1,6 @@
 <?xml version="1.0" encoding="utf-8"?>
 <packages>
-  <package id="System.Collections.Immutable" version="1.1.34-rc" targetFramework="net45" />
+  <package id="grpc.dependencies.openssl.redist" version="1.0.2.2" targetFramework="net45" />
+  <package id="grpc.dependencies.zlib.redist" version="1.2.8.9" targetFramework="net45" />
+  <package id="Microsoft.Bcl.Immutable" version="1.0.34" targetFramework="net45" />
 </packages>

src/csharp/Grpc.Examples.MathServer/MathServer.cs

@@ -40,13 +40,13 @@ namespace math
     {
         public static void Main(string[] args)
         {
-            String host = "0.0.0.0";
+            string host = "0.0.0.0";
 
             GrpcEnvironment.Initialize();
 
             Server server = new Server();
             server.AddServiceDefinition(MathGrpc.BindService(new MathServiceImpl()));
-            int port = server.AddListeningPort(host + ":0");
+            int port = server.AddListeningPort(host + ":23456");
             server.Start();
 
             Console.WriteLine("MathServer listening on port " + port);

src/csharp/Grpc.IntegrationTesting/Grpc.IntegrationTesting.csproj

@@ -39,8 +39,9 @@
     <Reference Include="Google.ProtocolBuffers">
       <HintPath>..\packages\Google.ProtocolBuffers.2.4.1.521\lib\net40\Google.ProtocolBuffers.dll</HintPath>
     </Reference>
-    <Reference Include="System.Collections.Immutable">
-      <HintPath>..\packages\System.Collections.Immutable.1.1.34-rc\lib\portable-net45+win8+wp8+wpa81\System.Collections.Immutable.dll</HintPath>
+    <Reference Include="System.Collections.Immutable, Version=1.0.34.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\packages\Microsoft.Bcl.Immutable.1.0.34\lib\portable-net45+win8+wp8+wpa81\System.Collections.Immutable.dll</HintPath>
     </Reference>
   </ItemGroup>
   <ItemGroup>
@@ -79,5 +80,7 @@
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
     </None>
   </ItemGroup>
-  <ItemGroup />
+  <ItemGroup>
+    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
+  </ItemGroup>
 </Project>

src/csharp/Grpc.IntegrationTesting/packages.config

@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="utf-8"?>
 <packages>
   <package id="Google.ProtocolBuffers" version="2.4.1.521" targetFramework="net45" />
+  <package id="Microsoft.Bcl.Immutable" version="1.0.34" targetFramework="net45" />
   <package id="NUnit" version="2.6.4" targetFramework="net45" />
-  <package id="System.Collections.Immutable" version="1.1.34-rc" targetFramework="net45" />
 </packages>

src/node/README.md

@@ -14,6 +14,12 @@ This requires `node` to be installed. If you instead have the `nodejs` executabl
  2. Follow the instructions in the `INSTALL` file in the root of that repository to install the C core library that this package depends on.
  3. Run `npm install`.
 
+If you install the gRPC C core library in a custom location, then you need to set some environment variables to install this library. The command will look like this:
+
+```sh
+CXXFLAGS=-I<custom location>/include LDFLAGS=-L<custom location>/lib npm install [grpc]
+```
+
 ## Tests
 
 To run the test suite, simply run `npm test` in the install location.

src/node/ext/completion_queue_async_worker.cc

@@ -43,6 +43,8 @@
 namespace grpc {
 namespace node {
 
+const int max_queue_threads = 2;
+
 using v8::Function;
 using v8::Handle;
 using v8::Object;
@@ -51,6 +53,9 @@ using v8::Value;
 
 grpc_completion_queue *CompletionQueueAsyncWorker::queue;
 
+int CompletionQueueAsyncWorker::current_threads;
+int CompletionQueueAsyncWorker::waiting_next_calls;
+
 CompletionQueueAsyncWorker::CompletionQueueAsyncWorker()
     : NanAsyncWorker(NULL) {}
 
@@ -67,17 +72,30 @@ grpc_completion_queue *CompletionQueueAsyncWorker::GetQueue() { return queue; }
 
 void CompletionQueueAsyncWorker::Next() {
   NanScope();
-  CompletionQueueAsyncWorker *worker = new CompletionQueueAsyncWorker();
-  NanAsyncQueueWorker(worker);
+  if (current_threads < max_queue_threads) {
+    CompletionQueueAsyncWorker *worker = new CompletionQueueAsyncWorker();
+    NanAsyncQueueWorker(worker);
+  } else {
+    waiting_next_calls += 1;
+  }
 }
 
 void CompletionQueueAsyncWorker::Init(Handle<Object> exports) {
   NanScope();
+  current_threads = 0;
+  waiting_next_calls = 0;
   queue = grpc_completion_queue_create();
 }
 
 void CompletionQueueAsyncWorker::HandleOKCallback() {
   NanScope();
+  if (waiting_next_calls > 0) {
+    waiting_next_calls -= 1;
+    CompletionQueueAsyncWorker *worker = new CompletionQueueAsyncWorker();
+    NanAsyncQueueWorker(worker);
+  } else {
+    current_threads -= 1;
+  }
   NanCallback *callback = GetTagCallback(result->tag);
   Handle<Value> argv[] = {NanNull(), GetTagNodeValue(result->tag)};
   callback->Call(2, argv);

src/node/ext/completion_queue_async_worker.h

@@ -73,6 +73,11 @@ class CompletionQueueAsyncWorker : public NanAsyncWorker {
   grpc_event *result;
 
   static grpc_completion_queue *queue;
+
+  // Number of grpc_completion_queue_next calls in the thread pool
+  static int current_threads;
+  // Number of grpc_completion_queue_next calls waiting to enter the thread pool
+  static int waiting_next_calls;
 };
 
 }  // namespace node

src/node/index.js

@@ -67,10 +67,25 @@ function loadObject(value) {
 /**
  * Load a gRPC object from a .proto file.
  * @param {string} filename The file to load
+ * @param {string=} format The file format to expect. Must be either 'proto' or
+ *     'json'. Defaults to 'proto'
  * @return {Object<string, *>} The resulting gRPC object
  */
-function load(filename) {
-  var builder = ProtoBuf.loadProtoFile(filename);
+function load(filename, format) {
+  if (!format) {
+    format = 'proto';
+  }
+  var builder;
+  switch(format) {
+    case 'proto':
+    builder = ProtoBuf.loadProtoFile(filename);
+    break;
+    case 'json':
+    builder = ProtoBuf.loadJsonFile(filename);
+    break;
+    default:
+    throw new Error('Unrecognized format "' + format + '"');
+  }
 
   return loadObject(builder.ns);
 }

src/node/package.json

@@ -1,6 +1,6 @@
 {
   "name": "grpc",
-  "version": "0.6.1",
+  "version": "0.6.2",
   "author": "Google Inc.",
   "description": "gRPC Library for Node",
   "homepage": "http://www.grpc.io/",

src/node/test/surface_test.js

@@ -47,6 +47,28 @@ var mathService = math_proto.lookup('math.Math');
 
 var capitalize = require('underscore.string/capitalize');
 
+describe('File loader', function() {
+  it('Should load a proto file by default', function() {
+    assert.doesNotThrow(function() {
+      grpc.load(__dirname + '/test_service.proto');
+    });
+  });
+  it('Should load a proto file with the proto format', function() {
+    assert.doesNotThrow(function() {
+      grpc.load(__dirname + '/test_service.proto', 'proto');
+    });
+  });
+  it('Should load a json file with the json format', function() {
+    assert.doesNotThrow(function() {
+      grpc.load(__dirname + '/test_service.json', 'json');
+    });
+  });
+  it('Should fail to load a file with an unknown format', function() {
+    assert.throws(function() {
+      grpc.load(__dirname + '/test_service.proto', 'fake_format');
+    });
+  });
+});
 describe('Surface server constructor', function() {
   it('Should fail with conflicting method names', function() {
     assert.throws(function() {

src/node/test/test_service.json

@@ -0,0 +1,55 @@
+{
+    "package": null,
+    "messages": [
+        {
+            "name": "Request",
+            "fields": [
+                {
+                    "rule": "optional",
+                    "type": "bool",
+                    "name": "error",
+                    "id": 1
+                }
+            ]
+        },
+        {
+            "name": "Response",
+            "fields": [
+                {
+                    "rule": "optional",
+                    "type": "int32",
+                    "name": "count",
+                    "id": 1
+                }
+            ]
+        }
+    ],
+    "services": [
+        {
+            "name": "TestService",
+            "options": {},
+            "rpc": {
+                "Unary": {
+                    "request": "Request",
+                    "response": "Response",
+                    "options": {}
+                },
+                "ClientStream": {
+                    "request": "Request",
+                    "response": "Response",
+                    "options": {}
+                },
+                "ServerStream": {
+                    "request": "Request",
+                    "response": "Response",
+                    "options": {}
+                },
+                "BidiStream": {
+                    "request": "Request",
+                    "response": "Response",
+                    "options": {}
+                }
+            }
+        }
+    ]
+}

src/objective-c/GRPCClient/GRPCCall.h

@@ -32,7 +32,7 @@
  */
 
 #import <Foundation/Foundation.h>
-#import <RxLibrary/GRXWriter.h>
+#import <gRPC/GRXWriter.h>
 
 @class GRPCMethodName;
 

src/objective-c/GRPCClient/GRPCCall.m

@@ -33,8 +33,8 @@
 
 #import "GRPCCall.h"
 
-#include <grpc.h>
-#include <support/time.h>
+#include <grpc/grpc.h>
+#include <grpc/support/grpc_time.h>
 
 #import "GRPCMethodName.h"
 #import "private/GRPCChannel.h"

src/objective-c/GRPCClient/GRPCClient.podspec

@@ -1,14 +0,0 @@
-Pod::Spec.new do |s|
-  s.name         = 'GRPCClient'
-  s.version      = '0.0.1'
-  s.summary      = 'Generic gRPC client library for iOS'
-  s.author = {
-    'Jorge Canizales' => 'jcanizales@google.com'
-  }
-  s.source_files = '*.{h,m}', 'private/*.{h,m}'
-  s.private_header_files = 'private/*.h'
-  s.platform = :ios
-  s.ios.deployment_target = '6.0'
-  s.requires_arc = true
-  s.dependency 'RxLibrary', '~> 0.0'
-end

src/objective-c/GRPCClient/GRPCMethodName.h

@@ -37,7 +37,8 @@
 
 // A fully-qualified gRPC method name. Full qualification is needed because a gRPC endpoint can
 // implement multiple interfaces.
-// TODO(jcanizales): Is this proto-specific, or actual part of gRPC? If the former, move one layer up.
+// TODO(jcanizales): Move to ProtoRPC package.
+// TODO(jcanizales): Rename interface -> service.
 @interface GRPCMethodName : NSObject
 @property(nonatomic, readonly) NSString *package;
 @property(nonatomic, readonly) NSString *interface;

src/objective-c/GRPCClient/private/GRPCChannel.h

@@ -45,6 +45,7 @@ struct grpc_channel;
 // Convenience constructor to allow for reuse of connections.
 + (instancetype)channelToHost:(NSString *)host;
 
-// Designated initializer
-- (instancetype)initWithHost:(NSString *)host;
+- (instancetype)initWithHost:(NSString *)host NS_DESIGNATED_INITIALIZER;
+
+- (instancetype)initWithChannel:(struct grpc_channel *)unmanagedChannel NS_DESIGNATED_INITIALIZER;
 @end

src/objective-c/GRPCClient/private/GRPCChannel.m

@@ -33,7 +33,10 @@
 
 #import "GRPCChannel.h"
 
-#import <grpc.h>
+#include <grpc/grpc.h>
+
+#import "GRPCSecureChannel.h"
+#import "GRPCUnsecuredChannel.h"
 
 @implementation GRPCChannel
 
@@ -46,20 +49,42 @@
   return [self initWithHost:nil];
 }
 
-// Designated initializer
 - (instancetype)initWithHost:(NSString *)host {
-  if (!host) {
-    [NSException raise:NSInvalidArgumentException format:@"Host can't be nil."];
+  if (![host containsString:@"://"]) {
+    // No scheme provided; assume https.
+    host = [@"https://" stringByAppendingString:host];
+  }
+  NSURL *hostURL = [NSURL URLWithString:host];
+  if (!hostURL) {
+    [NSException raise:NSInvalidArgumentException format:@"Invalid URL: %@", host];
+  }
+  if ([hostURL.scheme isEqualToString:@"https"]) {
+    host = [@[hostURL.host, hostURL.port ?: @443] componentsJoinedByString:@":"];
+    return [[GRPCSecureChannel alloc] initWithHost:host];
+  }
+  if ([hostURL.scheme isEqualToString:@"http"]) {
+    host = [@[hostURL.host, hostURL.port ?: @80] componentsJoinedByString:@":"];
+    return [[GRPCUnsecuredChannel alloc] initWithHost:host];
   }
+  [NSException raise:NSInvalidArgumentException
+              format:@"URL scheme %@ isn't supported.", hostURL.scheme];
+  return nil; // silence warning.
+}
+
+- (instancetype)initWithChannel:(struct grpc_channel *)unmanagedChannel {
   if ((self = [super init])) {
-    _unmanagedChannel = grpc_channel_create(host.UTF8String, NULL);
+    _unmanagedChannel = unmanagedChannel;
   }
   return self;
 }
 
 - (void)dealloc {
-  // TODO(jcanizales): Be sure to add a test with a server that closes the connection prematurely,
-  // as in the past that made this call to crash.
-  grpc_channel_destroy(_unmanagedChannel);
+  // _unmanagedChannel is NULL when deallocating an object of the base class (because the
+  // initializer returns a different object).
+  if (_unmanagedChannel) {
+    // TODO(jcanizales): Be sure to add a test with a server that closes the connection prematurely,
+    // as in the past that made this call to crash.
+    grpc_channel_destroy(_unmanagedChannel);
+  }
 }
 @end

src/objective-c/GRPCClient/private/GRPCCompletionQueue.m

@@ -33,7 +33,7 @@
 
 #import "GRPCCompletionQueue.h"
 
-#import <grpc.h>
+#import <grpc/grpc.h>
 
 @implementation GRPCCompletionQueue