Merge branch 'master' of github.com:grpc/grpc into rr_with_registry

9 years ago · a4c43a6cbb
parent 3924fcb1c0 35fea62432
commit a4c43a6cbb
214 changed files with 2739 additions and 1760 deletions
--- a/4
+++ b/4
@ -11,12 +11,12 @@ wiki pages:

 On Linux (Debian):

- Note: you will need to add the Debian 'testing' distribution to your sources
+ Note: you will need to add the Debian 'jessie-backports' distribution to your sources
 file first.

 Add the following line to your `/etc/apt/sources.list` file:

-   deb http://ftp.us.debian.org/debian testing main contrib non-free
+   deb http://http.debian.net/debian jessie-backports main

 Install the gRPC library:

--- a/10
+++ b/10
@ -145,7 +145,7 @@ CC_tsan = clang
 CXX_tsan = clang++
 LD_tsan = clang
 LDXX_tsan = clang++
-CPPFLAGS_tsan = -O0 -fsanitize=thread -fno-omit-frame-pointer -Wno-error=unused-command-line-argument
+CPPFLAGS_tsan = -O0 -fsanitize=thread -fno-omit-frame-pointer -Wno-unused-command-line-argument
 LDFLAGS_tsan = -fsanitize=thread
 DEFINES_tsan = NDEBUG GRPC_TEST_SLOWDOWN_BUILD_FACTOR=10

@ -155,7 +155,7 @@ CC_asan = clang
 CXX_asan = clang++
 LD_asan = clang
 LDXX_asan = clang++
-CPPFLAGS_asan = -O0 -fsanitize=address -fno-omit-frame-pointer -Wno-error=unused-command-line-argument
+CPPFLAGS_asan = -O0 -fsanitize=address -fno-omit-frame-pointer -Wno-unused-command-line-argument
 LDFLAGS_asan = -fsanitize=address
 DEFINES_asan = GRPC_TEST_SLOWDOWN_BUILD_FACTOR=3

@ -165,7 +165,7 @@ CC_msan = clang
 CXX_msan = clang++-libc++
 LD_msan = clang
 LDXX_msan = clang++-libc++
-CPPFLAGS_msan = -O0 -fsanitize=memory -fsanitize-memory-track-origins -fno-omit-frame-pointer -DGTEST_HAS_TR1_TUPLE=0 -DGTEST_USE_OWN_TR1_TUPLE=1 -Wno-error=unused-command-line-argument
+CPPFLAGS_msan = -O0 -fsanitize=memory -fsanitize-memory-track-origins -fno-omit-frame-pointer -DGTEST_HAS_TR1_TUPLE=0 -DGTEST_USE_OWN_TR1_TUPLE=1 -Wno-unused-command-line-argument
 OPENSSL_CFLAGS_msan = -DPURIFY
 LDFLAGS_msan = -fsanitize=memory -DGTEST_HAS_TR1_TUPLE=0 -DGTEST_USE_OWN_TR1_TUPLE=1
 DEFINES_msan = NDEBUG GRPC_TEST_SLOWDOWN_BUILD_FACTOR=4
@ -176,7 +176,7 @@ CC_ubsan = clang
 CXX_ubsan = clang++
 LD_ubsan = clang
 LDXX_ubsan = clang++
-CPPFLAGS_ubsan = -O1 -fsanitize=undefined -fno-omit-frame-pointer -Wno-error=unused-command-line-argument
+CPPFLAGS_ubsan = -O1 -fsanitize=undefined -fno-omit-frame-pointer -Wno-unused-command-line-argument
 OPENSSL_CFLAGS_ubsan = -DPURIFY
 LDFLAGS_ubsan = -fsanitize=undefined
 DEFINES_ubsan = NDEBUG GRPC_TEST_SLOWDOWN_BUILD_FACTOR=3
@ -245,7 +245,7 @@ ifdef EXTRA_DEFINES
 DEFINES += $(EXTRA_DEFINES)
 endif

-CFLAGS += -std=c89 -pedantic
+CFLAGS += -std=c89 -pedantic -Wsign-conversion -Wconversion
 ifeq ($(HAS_CXX11),true)
 CXXFLAGS += -std=c++11
 else
--- a/doc/interop-test-descriptions.md
+++ b/doc/interop-test-descriptions.md
@ -513,7 +513,9 @@ 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.
+https://console.developers.google.com. Alternately, if using a
+usable auth implementation, she may specify the file location in the environment
+variable GOOGLE_APPLICATION_CREDENTIALS.

 Server features:
 * [UnaryCall][]
@ -540,7 +542,7 @@ Client asserts:
 * call was successful
 * received SimpleResponse.username is not empty and is in the json key file used
 by the auth library. The client can optionally check the username matches the
-email address in the key file.
+email address in the key file or equals the value of `--default_service_account` flag.
 * 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
@ -598,7 +600,7 @@ json key file or GCE default service account email.

 Similar to the other auth tests, this test is only for cloud-to-prod path.

-This test verifies unary calls succeed in sending messages using a JWT
+This test verifies unary calls succeed in sending messages using a JWT or a service account
 credentials set on the RPC.

 The test
@ -606,6 +608,10 @@ The test
 downloaded from https://console.developers.google.com. Alternately, if using a
 usable auth implementation, it may specify the file location in the environment
 variable GOOGLE_APPLICATION_CREDENTIALS
+- optionally uses the flag `--oauth_scope` for the oauth scope if implementator 
+wishes to use service account credential instead of JWT credential. For testing
+against grpc-test.sandbox.google.com, oauth scope 
+"https://www.googleapis.com/auth/xapi.zoo" should be used.

 Server features:
 * [UnaryCall][]
--- a/examples/python/helloworld/README.md
+++ b/examples/python/helloworld/README.md
@ -91,9 +91,6 @@ Which internally invokes the proto-compiler as:
 $ protoc -I ../../protos --python_out=. --grpc_out=. --plugin=protoc-gen-grpc=`which grpc_python_plugin` ../../protos/helloworld.proto
 ```

-Optionally, you can just skip the code generation step as the generated python module has already
-been generated for you (helloworld_pb2.py).
-
 ### The client

 Client-side code can be found in [greeter_client.py](greeter_client.py).
--- a/examples/python/helloworld/greeter_client.py
+++ b/examples/python/helloworld/greeter_client.py
@ -29,15 +29,18 @@

 """The Python implementation of the GRPC helloworld.Greeter client."""

+from grpc.beta import implementations
+
 import helloworld_pb2

 _TIMEOUT_SECONDS = 10


 def run():
-  with helloworld_pb2.early_adopter_create_Greeter_stub('localhost', 50051) as stub:
-    response = stub.SayHello(helloworld_pb2.HelloRequest(name='you'), _TIMEOUT_SECONDS)
-    print "Greeter client received: " + response.message
+  channel = implementations.insecure_channel('localhost', 50051)
+  stub = helloworld_pb2.beta_create_Greeter_stub(channel)
+  response = stub.SayHello(helloworld_pb2.HelloRequest(name='you'), _TIMEOUT_SECONDS)
+  print "Greeter client received: " + response.message


 if __name__ == '__main__':
--- a/examples/python/helloworld/greeter_server.py
+++ b/examples/python/helloworld/greeter_server.py
@ -36,15 +36,15 @@ import helloworld_pb2
 _ONE_DAY_IN_SECONDS = 60 * 60 * 24


-class Greeter(helloworld_pb2.EarlyAdopterGreeterServicer):
+class Greeter(helloworld_pb2.BetaGreeterServicer):

  def SayHello(self, request, context):
    return helloworld_pb2.HelloReply(message='Hello, %s!' % request.name)


 def serve():
-  server = helloworld_pb2.early_adopter_create_Greeter_server(
-      Greeter(), 50051, None, None)
+  server = helloworld_pb2.beta_create_Greeter_server(Greeter())
+  server.add_insecure_port('[::]:50051')
  server.start()
  try:
    while True:
--- a/examples/python/route_guide/README.md
+++ b/examples/python/route_guide/README.md
@ -29,7 +29,7 @@ Then change your current directory to `examples/python/route_guide`:
 $ cd examples/python/route_guide
 ```

-You also should have the relevant tools installed to generate the server and client interface code - if you don't already, follow the setup instructions in [the Python quick start guide](../python).
+You also should have the relevant tools installed to generate the server and client interface code - if you don't already, follow the setup instructions in [the Python quick start guide](../helloworld).

 ## Defining the service

@ -99,12 +99,11 @@ $ protoc -I ../../protos --python_out=. --grpc_out=. --plugin=protoc-gen-grpc=`w
 Note that as we've already provided a version of the generated code in the example repository, running this command regenerates the appropriate file rather than creates a new one. The generated code file is called `route_guide_pb2.py` and contains:
 - classes for the messages defined in route_guide.proto
 - abstract classes for the service defined in route_guide.proto
-   - `EarlyAdopterRouteGuideServicer`, which defines the interface for implementations of the RouteGuide service
-   - `EarlyAdopterRouteGuideServer`, which may be started and stopped
-   - `EarlyAdopterRouteGuideStub`, which can be used by clients to invoke RouteGuide RPCs
+   - `BetaRouteGuideServicer`, which defines the interface for implementations of the RouteGuide service
+   - `BetaRouteGuideStub`, which can be used by clients to invoke RouteGuide RPCs
 - functions for application use
-   - `early_adopter_create_RouteGuide_server`, which creates a gRPC server given an `EarlyAdopterRouteGuideServicer` object
-   - `early_adopter_create_RouteGuide_stub`, which can be used by clients to create a stub object
+   - `beta_create_RouteGuide_server`, which creates a gRPC server given a `BetaRouteGuideServicer` object
+   - `beta_create_RouteGuide_stub`, which can be used by clients to create a stub object

 <a name="server"></a>
 ## Creating the server
@ -119,11 +118,11 @@ You can find the example `RouteGuide` server in [route_guide_server.py](route_gu

 ### Implementing RouteGuide

-`route_guide_server.py` has a `RouteGuideServicer` class that implements the generated interface `route_guide_pb2.EarlyAdopterRouteGuideServicer`:
+`route_guide_server.py` has a `RouteGuideServicer` class that implements the generated interface `route_guide_pb2.BetaRouteGuideServicer`:

 ```python
 # RouteGuideServicer provides an implementation of the methods of the RouteGuide service.
-class RouteGuideServicer(route_guide_pb2.EarlyAdopterRouteGuideServicer):
+class RouteGuideServicer(route_guide_pb2.BetaRouteGuideServicer):
 ```

 `RouteGuideServicer` implements all the `RouteGuide` service methods.
@ -141,7 +140,7 @@ Let's look at the simplest type first, `GetFeature`, which just gets a `Point` f
      return feature
 ```

-The method is passed a `route_guide_pb2.Point` request for the RPC, and an `RpcContext` object that provides RPC-specific information such as timeout limits. It returns a `route_guide_pb2.Feature` response.
+The method is passed a `route_guide_pb2.Point` request for the RPC, and a `ServicerContext` object that provides RPC-specific information such as timeout limits. It returns a `route_guide_pb2.Feature` response.

 #### Response-streaming RPC

@ -212,8 +211,8 @@ Once you have implemented all the `RouteGuide` methods, the next step is to star

 ```python
 def serve():
-  server = route_guide_pb2.early_adopter_create_RouteGuide_server(
-      RouteGuideServicer(), 50051, None, None)
+  server = route_guide_pb2.beta_create_RouteGuide_server(RouteGuideServicer())
+  server.add_insecure_port('[::]:50051')
  server.start()
 ```

@ -228,17 +227,14 @@ You can see the complete example client code in [route_guide_client.py](route_gu

 To call service methods, we first need to create a *stub*.

-We use the `early_adopter_create_RouteGuide_stub` function of the `route_guide_pb2` module, generated from our .proto.
+We use the `beta_create_RouteGuide_stub` function of the `route_guide_pb2` module, generated from our .proto.

 ```python
-stub = RouteGuide::Stub.new('localhost', 50051)
+channel = implementations.insecure_channel('localhost', 50051)
+stub = beta_create_RouteGuide_stub(channel)
 ```

-The returned object implements all the methods defined by the `EarlyAdopterRouteGuideStub` interface, and is also a [context manager](https://docs.python.org/2/library/stdtypes.html#typecontextmanager). All RPCs invoked on the stub must be invoked within the stub's context, so it is common for stubs to be created and used with a [with statement](https://docs.python.org/2/reference/compound_stmts.html#the-with-statement):
-
-```python
-with route_guide_pb2.early_adopter_create_RouteGuide_stub('localhost', 50051) as stub:
-```
+The returned object implements all the methods defined by the `BetaRouteGuideStub` interface.

 ### Calling service methods

@ -255,7 +251,7 @@ feature = stub.GetFeature(point, timeout_in_seconds)
 An asynchronous call to `GetFeature` is similar, but like calling a local method asynchronously in a thread pool:

 ```python
-feature_future = stub.GetFeature.async(point, timeout_in_seconds)
+feature_future = stub.GetFeature.future(point, timeout_in_seconds)
 feature = feature_future.result()
 ```

@ -276,7 +272,7 @@ route_summary = stub.RecordRoute(point_sequence, timeout_in_seconds)
 ```

 ```python
-route_summary_future = stub.RecordRoute.async(point_sequence, timeout_in_seconds)
+route_summary_future = stub.RecordRoute.future(point_sequence, timeout_in_seconds)
 route_summary = route_summary_future.result()
 ```

--- a/examples/python/route_guide/route_guide_client.py
+++ b/examples/python/route_guide/route_guide_client.py
@ -32,6 +32,8 @@
 import random
 import time

+from grpc.beta import implementations
+
 import route_guide_pb2
 import route_guide_resources

@ -115,15 +117,16 @@ def guide_route_chat(stub):


 def run():
-  with route_guide_pb2.early_adopter_create_RouteGuide_stub('localhost', 50051) as stub:
-    print "-------------- GetFeature --------------"
-    guide_get_feature(stub)
-    print "-------------- ListFeatures --------------"
-    guide_list_features(stub)
-    print "-------------- RecordRoute --------------"
-    guide_record_route(stub)
-    print "-------------- RouteChat --------------"
-    guide_route_chat(stub)
+  channel = implementations.insecure_channel('localhost', 50051)
+  stub = route_guide_pb2.beta_create_RouteGuide_stub(channel)
+  print "-------------- GetFeature --------------"
+  guide_get_feature(stub)
+  print "-------------- ListFeatures --------------"
+  guide_list_features(stub)
+  print "-------------- RecordRoute --------------"
+  guide_record_route(stub)
+  print "-------------- RouteChat --------------"
+  guide_route_chat(stub)


 if __name__ == '__main__':
--- a/examples/python/route_guide/route_guide_pb2.py
+++ b/examples/python/route_guide/route_guide_pb2.py
@ -1,8 +1,6 @@
 # Generated by the protocol buffer compiler.  DO NOT EDIT!
 # source: route_guide.proto

-import sys
-_b=sys.version_info[0]<3 and (lambda x:x) or (lambda x:x.encode('latin1'))
 from google.protobuf import descriptor as _descriptor
 from google.protobuf import message as _message
 from google.protobuf import reflection as _reflection
@ -17,8 +15,9 @@ _sym_db = _symbol_database.Default()

 DESCRIPTOR = _descriptor.FileDescriptor(
  name='route_guide.proto',
-  package='',
-  serialized_pb=_b('\n\x11route_guide.proto\",\n\x05Point\x12\x10\n\x08latitude\x18\x01 \x01(\x05\x12\x11\n\tlongitude\x18\x02 \x01(\x05\"3\n\tRectangle\x12\x12\n\x02lo\x18\x01 \x01(\x0b\x32\x06.Point\x12\x12\n\x02hi\x18\x02 \x01(\x0b\x32\x06.Point\"1\n\x07\x46\x65\x61ture\x12\x0c\n\x04name\x18\x01 \x01(\t\x12\x18\n\x08location\x18\x02 \x01(\x0b\x32\x06.Point\"6\n\tRouteNote\x12\x18\n\x08location\x18\x01 \x01(\x0b\x32\x06.Point\x12\x0f\n\x07message\x18\x02 \x01(\t\"b\n\x0cRouteSummary\x12\x13\n\x0bpoint_count\x18\x01 \x01(\x05\x12\x15\n\rfeature_count\x18\x02 \x01(\x05\x12\x10\n\x08\x64istance\x18\x03 \x01(\x05\x12\x14\n\x0c\x65lapsed_time\x18\x04 \x01(\x05\x32\xad\x01\n\nRouteGuide\x12 \n\nGetFeature\x12\x06.Point\x1a\x08.Feature\"\x00\x12(\n\x0cListFeatures\x12\n.Rectangle\x1a\x08.Feature\"\x00\x30\x01\x12(\n\x0bRecordRoute\x12\x06.Point\x1a\r.RouteSummary\"\x00(\x01\x12)\n\tRouteChat\x12\n.RouteNote\x1a\n.RouteNote\"\x00(\x01\x30\x01')
+  package='routeguide',
+  syntax='proto3',
+  serialized_pb=b'\n\x11route_guide.proto\x12\nrouteguide\",\n\x05Point\x12\x10\n\x08latitude\x18\x01 \x01(\x05\x12\x11\n\tlongitude\x18\x02 \x01(\x05\"I\n\tRectangle\x12\x1d\n\x02lo\x18\x01 \x01(\x0b\x32\x11.routeguide.Point\x12\x1d\n\x02hi\x18\x02 \x01(\x0b\x32\x11.routeguide.Point\"<\n\x07\x46\x65\x61ture\x12\x0c\n\x04name\x18\x01 \x01(\t\x12#\n\x08location\x18\x02 \x01(\x0b\x32\x11.routeguide.Point\"A\n\tRouteNote\x12#\n\x08location\x18\x01 \x01(\x0b\x32\x11.routeguide.Point\x12\x0f\n\x07message\x18\x02 \x01(\t\"b\n\x0cRouteSummary\x12\x13\n\x0bpoint_count\x18\x01 \x01(\x05\x12\x15\n\rfeature_count\x18\x02 \x01(\x05\x12\x10\n\x08\x64istance\x18\x03 \x01(\x05\x12\x14\n\x0c\x65lapsed_time\x18\x04 \x01(\x05\x32\x85\x02\n\nRouteGuide\x12\x36\n\nGetFeature\x12\x11.routeguide.Point\x1a\x13.routeguide.Feature\"\x00\x12>\n\x0cListFeatures\x12\x15.routeguide.Rectangle\x1a\x13.routeguide.Feature\"\x00\x30\x01\x12>\n\x0bRecordRoute\x12\x11.routeguide.Point\x1a\x18.routeguide.RouteSummary\"\x00(\x01\x12?\n\tRouteChat\x12\x15.routeguide.RouteNote\x1a\x15.routeguide.RouteNote\"\x00(\x01\x30\x01\x42\x0f\n\x07\x65x.grpc\xa2\x02\x03RTGb\x06proto3'
 )
 _sym_db.RegisterFileDescriptor(DESCRIPTOR)

@ -27,20 +26,20 @@ _sym_db.RegisterFileDescriptor(DESCRIPTOR)

 _POINT = _descriptor.Descriptor(
  name='Point',
-  full_name='Point',
+  full_name='routeguide.Point',
  filename=None,
  file=DESCRIPTOR,
  containing_type=None,
  fields=[
    _descriptor.FieldDescriptor(
-      name='latitude', full_name='Point.latitude', index=0,
+      name='latitude', full_name='routeguide.Point.latitude', index=0,
      number=1, type=5, cpp_type=1, label=1,
      has_default_value=False, default_value=0,
      message_type=None, enum_type=None, containing_type=None,
      is_extension=False, extension_scope=None,
      options=None),
    _descriptor.FieldDescriptor(
-      name='longitude', full_name='Point.longitude', index=1,
+      name='longitude', full_name='routeguide.Point.longitude', index=1,
      number=2, type=5, cpp_type=1, label=1,
      has_default_value=False, default_value=0,
      message_type=None, enum_type=None, containing_type=None,
@ -54,30 +53,31 @@ _POINT = _descriptor.Descriptor(
  ],
  options=None,
  is_extendable=False,
+  syntax='proto3',
  extension_ranges=[],
  oneofs=[
  ],
-  serialized_start=21,
-  serialized_end=65,
+  serialized_start=33,
+  serialized_end=77,
 )


 _RECTANGLE = _descriptor.Descriptor(
  name='Rectangle',
-  full_name='Rectangle',
+  full_name='routeguide.Rectangle',
  filename=None,
  file=DESCRIPTOR,
  containing_type=None,
  fields=[
    _descriptor.FieldDescriptor(
-      name='lo', full_name='Rectangle.lo', index=0,
+      name='lo', full_name='routeguide.Rectangle.lo', index=0,
      number=1, type=11, cpp_type=10, label=1,
      has_default_value=False, default_value=None,
      message_type=None, enum_type=None, containing_type=None,
      is_extension=False, extension_scope=None,
      options=None),
    _descriptor.FieldDescriptor(
-      name='hi', full_name='Rectangle.hi', index=1,
+      name='hi', full_name='routeguide.Rectangle.hi', index=1,
      number=2, type=11, cpp_type=10, label=1,
      has_default_value=False, default_value=None,
      message_type=None, enum_type=None, containing_type=None,
@ -91,30 +91,31 @@ _RECTANGLE = _descriptor.Descriptor(
  ],
  options=None,
  is_extendable=False,
+  syntax='proto3',
  extension_ranges=[],
  oneofs=[
  ],
-  serialized_start=67,
-  serialized_end=118,
+  serialized_start=79,
+  serialized_end=152,
 )


 _FEATURE = _descriptor.Descriptor(
  name='Feature',
-  full_name='Feature',
+  full_name='routeguide.Feature',
  filename=None,
  file=DESCRIPTOR,
  containing_type=None,
  fields=[
    _descriptor.FieldDescriptor(
-      name='name', full_name='Feature.name', index=0,
+      name='name', full_name='routeguide.Feature.name', index=0,
      number=1, type=9, cpp_type=9, label=1,
-      has_default_value=False, default_value=_b("").decode('utf-8'),
+      has_default_value=False, default_value=b"".decode('utf-8'),
      message_type=None, enum_type=None, containing_type=None,
      is_extension=False, extension_scope=None,
      options=None),
    _descriptor.FieldDescriptor(
-      name='location', full_name='Feature.location', index=1,
+      name='location', full_name='routeguide.Feature.location', index=1,
      number=2, type=11, cpp_type=10, label=1,
      has_default_value=False, default_value=None,
      message_type=None, enum_type=None, containing_type=None,
@ -128,32 +129,33 @@ _FEATURE = _descriptor.Descriptor(
  ],
  options=None,
  is_extendable=False,
+  syntax='proto3',
  extension_ranges=[],
  oneofs=[
  ],
-  serialized_start=120,
-  serialized_end=169,
+  serialized_start=154,
+  serialized_end=214,
 )


 _ROUTENOTE = _descriptor.Descriptor(
  name='RouteNote',
-  full_name='RouteNote',
+  full_name='routeguide.RouteNote',
  filename=None,
  file=DESCRIPTOR,
  containing_type=None,
  fields=[
    _descriptor.FieldDescriptor(
-      name='location', full_name='RouteNote.location', index=0,
+      name='location', full_name='routeguide.RouteNote.location', index=0,
      number=1, type=11, cpp_type=10, label=1,
      has_default_value=False, default_value=None,
      message_type=None, enum_type=None, containing_type=None,
      is_extension=False, extension_scope=None,
      options=None),
    _descriptor.FieldDescriptor(
-      name='message', full_name='RouteNote.message', index=1,
+      name='message', full_name='routeguide.RouteNote.message', index=1,
      number=2, type=9, cpp_type=9, label=1,
-      has_default_value=False, default_value=_b("").decode('utf-8'),
+      has_default_value=False, default_value=b"".decode('utf-8'),
      message_type=None, enum_type=None, containing_type=None,
      is_extension=False, extension_scope=None,
      options=None),
@ -165,44 +167,45 @@ _ROUTENOTE = _descriptor.Descriptor(
  ],
  options=None,
  is_extendable=False,
+  syntax='proto3',
  extension_ranges=[],
  oneofs=[
  ],
-  serialized_start=171,
-  serialized_end=225,
+  serialized_start=216,
+  serialized_end=281,
 )


 _ROUTESUMMARY = _descriptor.Descriptor(
  name='RouteSummary',
-  full_name='RouteSummary',
+  full_name='routeguide.RouteSummary',
  filename=None,
  file=DESCRIPTOR,
  containing_type=None,
  fields=[
    _descriptor.FieldDescriptor(
-      name='point_count', full_name='RouteSummary.point_count', index=0,
+      name='point_count', full_name='routeguide.RouteSummary.point_count', index=0,
      number=1, type=5, cpp_type=1, label=1,
      has_default_value=False, default_value=0,
      message_type=None, enum_type=None, containing_type=None,
      is_extension=False, extension_scope=None,
      options=None),
    _descriptor.FieldDescriptor(
-      name='feature_count', full_name='RouteSummary.feature_count', index=1,
+      name='feature_count', full_name='routeguide.RouteSummary.feature_count', index=1,
      number=2, type=5, cpp_type=1, label=1,
      has_default_value=False, default_value=0,
      message_type=None, enum_type=None, containing_type=None,
      is_extension=False, extension_scope=None,
      options=None),
    _descriptor.FieldDescriptor(
-      name='distance', full_name='RouteSummary.distance', index=2,
+      name='distance', full_name='routeguide.RouteSummary.distance', index=2,
      number=3, type=5, cpp_type=1, label=1,
      has_default_value=False, default_value=0,
      message_type=None, enum_type=None, containing_type=None,
      is_extension=False, extension_scope=None,
      options=None),
    _descriptor.FieldDescriptor(
-      name='elapsed_time', full_name='RouteSummary.elapsed_time', index=3,
+      name='elapsed_time', full_name='routeguide.RouteSummary.elapsed_time', index=3,
      number=4, type=5, cpp_type=1, label=1,
      has_default_value=False, default_value=0,
      message_type=None, enum_type=None, containing_type=None,
@ -216,11 +219,12 @@ _ROUTESUMMARY = _descriptor.Descriptor(
  ],
  options=None,
  is_extendable=False,
+  syntax='proto3',
  extension_ranges=[],
  oneofs=[
  ],
-  serialized_start=227,
-  serialized_end=325,
+  serialized_start=283,
+  serialized_end=381,
 )

 _RECTANGLE.fields_by_name['lo'].message_type = _POINT
@ -236,58 +240,61 @@ DESCRIPTOR.message_types_by_name['RouteSummary'] = _ROUTESUMMARY
 Point = _reflection.GeneratedProtocolMessageType('Point', (_message.Message,), dict(
  DESCRIPTOR = _POINT,
  __module__ = 'route_guide_pb2'
-  # @@protoc_insertion_point(class_scope:Point)
+  # @@protoc_insertion_point(class_scope:routeguide.Point)
  ))
 _sym_db.RegisterMessage(Point)

 Rectangle = _reflection.GeneratedProtocolMessageType('Rectangle', (_message.Message,), dict(
  DESCRIPTOR = _RECTANGLE,
  __module__ = 'route_guide_pb2'
-  # @@protoc_insertion_point(class_scope:Rectangle)
+  # @@protoc_insertion_point(class_scope:routeguide.Rectangle)
  ))
 _sym_db.RegisterMessage(Rectangle)

 Feature = _reflection.GeneratedProtocolMessageType('Feature', (_message.Message,), dict(
  DESCRIPTOR = _FEATURE,
  __module__ = 'route_guide_pb2'
-  # @@protoc_insertion_point(class_scope:Feature)
+  # @@protoc_insertion_point(class_scope:routeguide.Feature)
  ))
 _sym_db.RegisterMessage(Feature)

 RouteNote = _reflection.GeneratedProtocolMessageType('RouteNote', (_message.Message,), dict(
  DESCRIPTOR = _ROUTENOTE,
  __module__ = 'route_guide_pb2'
-  # @@protoc_insertion_point(class_scope:RouteNote)
+  # @@protoc_insertion_point(class_scope:routeguide.RouteNote)
  ))
 _sym_db.RegisterMessage(RouteNote)

 RouteSummary = _reflection.GeneratedProtocolMessageType('RouteSummary', (_message.Message,), dict(
  DESCRIPTOR = _ROUTESUMMARY,
  __module__ = 'route_guide_pb2'
-  # @@protoc_insertion_point(class_scope:RouteSummary)
+  # @@protoc_insertion_point(class_scope:routeguide.RouteSummary)
  ))
 _sym_db.RegisterMessage(RouteSummary)


+DESCRIPTOR.has_options = True
+DESCRIPTOR._options = _descriptor._ParseOptions(descriptor_pb2.FileOptions(), b'\n\007ex.grpc\242\002\003RTG')
 import abc
-from grpc._adapter import fore
-from grpc._adapter import rear
-from grpc.framework.assembly import implementations
-from grpc.framework.assembly import utilities
+from grpc.beta import implementations as beta_implementations
+from grpc.early_adopter import implementations as early_adopter_implementations
+from grpc.framework.alpha import utilities as alpha_utilities
+from grpc.framework.common import cardinality
+from grpc.framework.interfaces.face import utilities as face_utilities
 class EarlyAdopterRouteGuideServicer(object):
  """<fill me in later!>"""
  __metaclass__ = abc.ABCMeta
  @abc.abstractmethod
-  def GetFeature(self, request):
+  def GetFeature(self, request, context):
    raise NotImplementedError()
  @abc.abstractmethod
-  def ListFeatures(self, request):
+  def ListFeatures(self, request, context):
    raise NotImplementedError()
  @abc.abstractmethod
-  def RecordRoute(self, request_iterator):
+  def RecordRoute(self, request_iterator, context):
    raise NotImplementedError()
  @abc.abstractmethod
-  def RouteChat(self, request_iterator):
+  def RouteChat(self, request_iterator, context):
    raise NotImplementedError()
 class EarlyAdopterRouteGuideServer(object):
  """<fill me in later!>"""
@ -317,54 +324,158 @@ class EarlyAdopterRouteGuideStub(object):
  def RouteChat(self, request_iterator):
    raise NotImplementedError()
  RouteChat.async = None
-def early_adopter_create_RouteGuide_server(servicer, port, root_certificates, key_chain_pairs):
-  method_implementations = {
-    "GetFeature": utilities.unary_unary_inline(servicer.GetFeature),
-    "ListFeatures": utilities.unary_stream_inline(servicer.ListFeatures),
-    "RecordRoute": utilities.stream_unary_inline(servicer.RecordRoute),
-    "RouteChat": utilities.stream_stream_inline(servicer.RouteChat),
+def early_adopter_create_RouteGuide_server(servicer, port, private_key=None, certificate_chain=None):
+  import route_guide_pb2
+  import route_guide_pb2
+  import route_guide_pb2
+  import route_guide_pb2
+  import route_guide_pb2
+  import route_guide_pb2
+  import route_guide_pb2
+  import route_guide_pb2
+  method_service_descriptions = {
+    "GetFeature": alpha_utilities.unary_unary_service_description(
+      servicer.GetFeature,
+      route_guide_pb2.Point.FromString,
+      route_guide_pb2.Feature.SerializeToString,
+    ),
+    "ListFeatures": alpha_utilities.unary_stream_service_description(
+      servicer.ListFeatures,
+      route_guide_pb2.Rectangle.FromString,
+      route_guide_pb2.Feature.SerializeToString,
+    ),
+    "RecordRoute": alpha_utilities.stream_unary_service_description(
+      servicer.RecordRoute,
+      route_guide_pb2.Point.FromString,
+      route_guide_pb2.RouteSummary.SerializeToString,
+    ),
+    "RouteChat": alpha_utilities.stream_stream_service_description(
+      servicer.RouteChat,
+      route_guide_pb2.RouteNote.FromString,
+      route_guide_pb2.RouteNote.SerializeToString,
+    ),
+  }
+  return early_adopter_implementations.server("routeguide.RouteGuide", method_service_descriptions, port, private_key=private_key, certificate_chain=certificate_chain)
+def early_adopter_create_RouteGuide_stub(host, port, metadata_transformer=None, secure=False, root_certificates=None, private_key=None, certificate_chain=None, server_host_override=None):
+  import route_guide_pb2
+  import route_guide_pb2
+  import route_guide_pb2
+  import route_guide_pb2
+  import route_guide_pb2
+  import route_guide_pb2
+  import route_guide_pb2
+  import route_guide_pb2
+  method_invocation_descriptions = {
+    "GetFeature": alpha_utilities.unary_unary_invocation_description(
+      route_guide_pb2.Point.SerializeToString,
+      route_guide_pb2.Feature.FromString,
+    ),
+    "ListFeatures": alpha_utilities.unary_stream_invocation_description(
+      route_guide_pb2.Rectangle.SerializeToString,
+      route_guide_pb2.Feature.FromString,
+    ),
+    "RecordRoute": alpha_utilities.stream_unary_invocation_description(
+      route_guide_pb2.Point.SerializeToString,
+      route_guide_pb2.RouteSummary.FromString,
+    ),
+    "RouteChat": alpha_utilities.stream_stream_invocation_description(
+      route_guide_pb2.RouteNote.SerializeToString,
+      route_guide_pb2.RouteNote.FromString,
+    ),
  }
+  return early_adopter_implementations.stub("routeguide.RouteGuide", method_invocation_descriptions, host, port, metadata_transformer=metadata_transformer, secure=secure, root_certificates=root_certificates, private_key=private_key, certificate_chain=certificate_chain, server_host_override=server_host_override)
+
+class BetaRouteGuideServicer(object):
+  """<fill me in later!>"""
+  __metaclass__ = abc.ABCMeta
+  @abc.abstractmethod
+  def GetFeature(self, request, context):
+    raise NotImplementedError()
+  @abc.abstractmethod
+  def ListFeatures(self, request, context):
+    raise NotImplementedError()
+  @abc.abstractmethod
+  def RecordRoute(self, request_iterator, context):
+    raise NotImplementedError()
+  @abc.abstractmethod
+  def RouteChat(self, request_iterator, context):
+    raise NotImplementedError()
+
+class BetaRouteGuideStub(object):
+  """The interface to which stubs will conform."""
+  __metaclass__ = abc.ABCMeta
+  @abc.abstractmethod
+  def GetFeature(self, request, timeout):
+    raise NotImplementedError()
+  GetFeature.future = None
+  @abc.abstractmethod
+  def ListFeatures(self, request, timeout):
+    raise NotImplementedError()
+  @abc.abstractmethod
+  def RecordRoute(self, request_iterator, timeout):
+    raise NotImplementedError()
+  RecordRoute.future = None
+  @abc.abstractmethod
+  def RouteChat(self, request_iterator, timeout):
+    raise NotImplementedError()
+
+def beta_create_RouteGuide_server(servicer, pool=None, pool_size=None, default_timeout=None, maximum_timeout=None):
+  import route_guide_pb2
+  import route_guide_pb2
+  import route_guide_pb2
+  import route_guide_pb2
  import route_guide_pb2
  import route_guide_pb2
  import route_guide_pb2
  import route_guide_pb2
  request_deserializers = {
-    "GetFeature": route_guide_pb2.Point.FromString,
-    "ListFeatures": route_guide_pb2.Rectangle.FromString,
-    "RecordRoute": route_guide_pb2.Point.FromString,
-    "RouteChat": route_guide_pb2.RouteNote.FromString,
+    ('routeguide.RouteGuide', 'GetFeature'): route_guide_pb2.Point.FromString,
+    ('routeguide.RouteGuide', 'ListFeatures'): route_guide_pb2.Rectangle.FromString,
+    ('routeguide.RouteGuide', 'RecordRoute'): route_guide_pb2.Point.FromString,
+    ('routeguide.RouteGuide', 'RouteChat'): route_guide_pb2.RouteNote.FromString,
  }
  response_serializers = {
-    "GetFeature": lambda x: x.SerializeToString(),
-    "ListFeatures": lambda x: x.SerializeToString(),
-    "RecordRoute": lambda x: x.SerializeToString(),
-    "RouteChat": lambda x: x.SerializeToString(),
+    ('routeguide.RouteGuide', 'GetFeature'): route_guide_pb2.Feature.SerializeToString,
+    ('routeguide.RouteGuide', 'ListFeatures'): route_guide_pb2.Feature.SerializeToString,
+    ('routeguide.RouteGuide', 'RecordRoute'): route_guide_pb2.RouteSummary.SerializeToString,
+    ('routeguide.RouteGuide', 'RouteChat'): route_guide_pb2.RouteNote.SerializeToString,
  }
-  link = fore.activated_fore_link(port, request_deserializers, response_serializers, root_certificates, key_chain_pairs)
-  return implementations.assemble_service(method_implementations, link)
-def early_adopter_create_RouteGuide_stub(host, port):
  method_implementations = {
-    "GetFeature": utilities.unary_unary_inline(None),
-    "ListFeatures": utilities.unary_stream_inline(None),
-    "RecordRoute": utilities.stream_unary_inline(None),
-    "RouteChat": utilities.stream_stream_inline(None),
+    ('routeguide.RouteGuide', 'GetFeature'): face_utilities.unary_unary_inline(servicer.GetFeature),
+    ('routeguide.RouteGuide', 'ListFeatures'): face_utilities.unary_stream_inline(servicer.ListFeatures),
+    ('routeguide.RouteGuide', 'RecordRoute'): face_utilities.stream_unary_inline(servicer.RecordRoute),
+    ('routeguide.RouteGuide', 'RouteChat'): face_utilities.stream_stream_inline(servicer.RouteChat),
  }
+  server_options = beta_implementations.server_options(request_deserializers=request_deserializers, response_serializers=response_serializers, thread_pool=pool, thread_pool_size=pool_size, default_timeout=default_timeout, maximum_timeout=maximum_timeout)
+  return beta_implementations.server(method_implementations, options=server_options)
+
+def beta_create_RouteGuide_stub(channel, host=None, metadata_transformer=None, pool=None, pool_size=None):
  import route_guide_pb2
  import route_guide_pb2
  import route_guide_pb2
  import route_guide_pb2
+  import route_guide_pb2
+  import route_guide_pb2
+  import route_guide_pb2
+  import route_guide_pb2
+  request_serializers = {
+    ('routeguide.RouteGuide', 'GetFeature'): route_guide_pb2.Point.SerializeToString,
+    ('routeguide.RouteGuide', 'ListFeatures'): route_guide_pb2.Rectangle.SerializeToString,
+    ('routeguide.RouteGuide', 'RecordRoute'): route_guide_pb2.Point.SerializeToString,
+    ('routeguide.RouteGuide', 'RouteChat'): route_guide_pb2.RouteNote.SerializeToString,
+  }
  response_deserializers = {
-    "GetFeature": route_guide_pb2.Feature.FromString,
-    "ListFeatures": route_guide_pb2.Feature.FromString,
-    "RecordRoute": route_guide_pb2.RouteSummary.FromString,
-    "RouteChat": route_guide_pb2.RouteNote.FromString,
+    ('routeguide.RouteGuide', 'GetFeature'): route_guide_pb2.Feature.FromString,
+    ('routeguide.RouteGuide', 'ListFeatures'): route_guide_pb2.Feature.FromString,
+    ('routeguide.RouteGuide', 'RecordRoute'): route_guide_pb2.RouteSummary.FromString,
+    ('routeguide.RouteGuide', 'RouteChat'): route_guide_pb2.RouteNote.FromString,
  }
-  request_serializers = {
-    "GetFeature": lambda x: x.SerializeToString(),
-    "ListFeatures": lambda x: x.SerializeToString(),
-    "RecordRoute": lambda x: x.SerializeToString(),
-    "RouteChat": lambda x: x.SerializeToString(),
+  cardinalities = {
+    'GetFeature': cardinality.Cardinality.UNARY_UNARY,
+    'ListFeatures': cardinality.Cardinality.UNARY_STREAM,
+    'RecordRoute': cardinality.Cardinality.STREAM_UNARY,
+    'RouteChat': cardinality.Cardinality.STREAM_STREAM,
  }
-  link = rear.activated_rear_link(host, port, request_serializers, response_deserializers)
-  return implementations.assemble_dynamic_inline_stub(method_implementations, link)
+  stub_options = beta_implementations.stub_options(host=host, metadata_transformer=metadata_transformer, request_serializers=request_serializers, response_deserializers=response_deserializers, thread_pool=pool, thread_pool_size=pool_size)
+  return beta_implementations.dynamic_stub(channel, 'routeguide.RouteGuide', cardinalities, options=stub_options)
 # @@protoc_insertion_point(module_scope)
--- a/examples/python/route_guide/route_guide_server.py
+++ b/examples/python/route_guide/route_guide_server.py
@ -65,7 +65,7 @@ def get_distance(start, end):
  R = 6371000; # metres
  return R * c;

-class RouteGuideServicer(route_guide_pb2.EarlyAdopterRouteGuideServicer):
+class RouteGuideServicer(route_guide_pb2.BetaRouteGuideServicer):
  """Provides methods that implement functionality of route guide server."""

  def __init__(self):
@ -121,8 +121,8 @@ class RouteGuideServicer(route_guide_pb2.EarlyAdopterRouteGuideServicer):


 def serve():
-  server = route_guide_pb2.early_adopter_create_RouteGuide_server(
-      RouteGuideServicer(), 50051, None, None)
+  server = route_guide_pb2.beta_create_RouteGuide_server(RouteGuideServicer())
+  server.add_insecure_port('[::]:50051')
  server.start()
  try:
    while True:
--- a/examples/python/route_guide/run_codegen.sh
+++ b/examples/python/route_guide/run_codegen.sh
@ -1,4 +1,4 @@
 #!/bin/bash

 # Runs the protoc with gRPC plugin to generate protocol messages and gRPC stubs.
-protoc -I . --python_out=. --grpc_out=. --plugin=protoc-gen-grpc=`which grpc_python_plugin` route_guide.proto
+protoc -I ../../protos --python_out=. --grpc_out=. --plugin=protoc-gen-grpc=`which grpc_python_plugin` ../../protos/route_guide.proto
--- a/include/grpc++/server.h
+++ b/include/grpc++/server.h
@ -37,6 +37,7 @@
 #include <list>
 #include <memory>

+#include <grpc/compression.h>
 #include <grpc++/completion_queue.h>
 #include <grpc++/impl/call.h>
 #include <grpc++/impl/grpc_library.h>
@ -99,7 +100,7 @@ class Server GRPC_FINAL : public GrpcLibrary, private CallHook {
  /// \param max_message_size Maximum message length that the channel can
  /// receive.
  Server(ThreadPoolInterface* thread_pool, bool thread_pool_owned,
-         int max_message_size);
+         int max_message_size, grpc_compression_options compression_options);

  /// Register a service. This call does not take ownership of the service.
  /// The service must exist for the lifetime of the Server instance.
--- a/include/grpc++/server_builder.h
+++ b/include/grpc++/server_builder.h
@ -37,6 +37,7 @@
 #include <memory>
 #include <vector>

+#include <grpc/compression.h>
 #include <grpc++/support/config.h>

 namespace grpc {
@ -92,6 +93,11 @@ class ServerBuilder {
    max_message_size_ = max_message_size;
  }

+  /// Set the compression options to be used by the server.
+  void SetCompressionOptions(const grpc_compression_options& options) {
+    compression_options_ = options;
+  }
+
  /// Tries to bind \a server to the given \a addr.
  ///
  /// It can be invoked multiple times.
@ -133,6 +139,7 @@ class ServerBuilder {
  };

  int max_message_size_;
+  grpc_compression_options compression_options_;
  std::vector<std::unique_ptr<NamedService<RpcService>>> services_;
  std::vector<std::unique_ptr<NamedService<AsynchronousService>>>
      async_services_;
--- a/include/grpc/support/port_platform.h
+++ b/include/grpc/support/port_platform.h
@ -179,6 +179,7 @@
 #ifndef _BSD_SOURCE
 #define _BSD_SOURCE
 #endif
+#define GPR_MSG_IOVLEN_TYPE int
 #if TARGET_OS_IPHONE
 #define GPR_PLATFORM_STRING "ios"
 #define GPR_CPU_IPHONE 1
@ -318,6 +319,7 @@ typedef uintptr_t gpr_uintptr;

 /* INT64_MAX is unavailable on some platforms. */
 #define GPR_INT64_MAX (gpr_int64)(~(gpr_uint64)0 >> 1)
+#define GPR_UINT32_MAX (~(gpr_uint32)0)

 /* maximum alignment needed for any type on this platform, rounded up to a
   power of two */
--- a/include/grpc/support/slice_buffer.h
+++ b/include/grpc/support/slice_buffer.h
@ -77,7 +77,7 @@ size_t gpr_slice_buffer_add_indexed(gpr_slice_buffer *sb, gpr_slice slice);
 void gpr_slice_buffer_addn(gpr_slice_buffer *sb, gpr_slice *slices, size_t n);
 /* add a very small (less than 8 bytes) amount of data to the end of a slice
   buffer: returns a pointer into which to add the data */
-gpr_uint8 *gpr_slice_buffer_tiny_add(gpr_slice_buffer *sb, unsigned len);
+gpr_uint8 *gpr_slice_buffer_tiny_add(gpr_slice_buffer *sb, size_t len);
 /* pop the last buffer, but don't unref it */
 void gpr_slice_buffer_pop(gpr_slice_buffer *sb);
 /* clear a slice buffer, unref all elements */
--- a/src/compiler/python_generator.cc
+++ b/src/compiler/python_generator.cc
@ -339,7 +339,7 @@ bool PrintAlphaServerFactory(const grpc::string& package_qualified_service_name,
    }
    out->Print("}\n");
    out->Print(
-        "return implementations.server("
+        "return early_adopter_implementations.server("
        "\"$PackageQualifiedServiceName$\","
        " method_service_descriptions, port, private_key=private_key,"
        " certificate_chain=certificate_chain)\n",
@ -422,7 +422,7 @@ bool PrintAlphaStubFactory(const grpc::string& package_qualified_service_name,
    }
    out->Print("}\n");
    out->Print(
-        "return implementations.stub("
+        "return early_adopter_implementations.stub("
        "\"$PackageQualifiedServiceName$\","
        " method_invocation_descriptions, host, port,"
        " metadata_transformer=metadata_transformer, secure=secure,"
@ -586,13 +586,13 @@ bool PrintBetaServerFactory(const grpc::string& package_qualified_service_name,
                 "Constructor", name_and_implementation_constructor->second);
    }
    out->Print("}\n");
-    out->Print("server_options = beta.server_options("
+    out->Print("server_options = beta_implementations.server_options("
               "request_deserializers=request_deserializers, "
               "response_serializers=response_serializers, "
               "thread_pool=pool, thread_pool_size=pool_size, "
               "default_timeout=default_timeout, "
               "maximum_timeout=maximum_timeout)\n");
-    out->Print("return beta.server(method_implementations, "
+    out->Print("return beta_implementations.server(method_implementations, "
               "options=server_options)\n");
  }
  return true;
@ -685,13 +685,13 @@ bool PrintBetaStubFactory(const grpc::string& package_qualified_service_name,
                 "Cardinality", name_and_cardinality->second);
    }
    out->Print("}\n");
-    out->Print("stub_options = beta.stub_options("
+    out->Print("stub_options = beta_implementations.stub_options("
               "host=host, metadata_transformer=metadata_transformer, "
               "request_serializers=request_serializers, "
               "response_deserializers=response_deserializers, "
               "thread_pool=pool, thread_pool_size=pool_size)\n");
    out->Print(
-        "return beta.dynamic_stub(channel, \'$PackageQualifiedServiceName$\', "
+        "return beta_implementations.dynamic_stub(channel, \'$PackageQualifiedServiceName$\', "
        "cardinalities, options=stub_options)\n",
        "PackageQualifiedServiceName", package_qualified_service_name);
  }
@ -701,9 +701,9 @@ bool PrintBetaStubFactory(const grpc::string& package_qualified_service_name,
 bool PrintPreamble(const FileDescriptor* file,
                   const GeneratorConfiguration& config, Printer* out) {
  out->Print("import abc\n");
-  out->Print("from $Package$ import beta\n",
+  out->Print("from $Package$ import implementations as beta_implementations\n",
             "Package", config.beta_package_root);
-  out->Print("from $Package$ import implementations\n",
+  out->Print("from $Package$ import implementations as early_adopter_implementations\n",
             "Package", config.early_adopter_package_root);
  out->Print("from grpc.framework.alpha import utilities as alpha_utilities\n");
  out->Print("from grpc.framework.common import cardinality\n");
--- a/src/core/channel/channel_args.c
+++ b/src/core/channel/channel_args.c
@ -132,7 +132,7 @@ grpc_compression_algorithm grpc_channel_args_get_compression_algorithm(
  for (i = 0; i < a->num_args; ++i) {
    if (a->args[i].type == GRPC_ARG_INTEGER &&
        !strcmp(GRPC_COMPRESSION_ALGORITHM_ARG, a->args[i].key)) {
-      return a->args[i].value.integer;
+      return (grpc_compression_algorithm)a->args[i].value.integer;
      break;
    }
  }
@ -177,9 +177,9 @@ grpc_channel_args *grpc_channel_args_compression_algorithm_set_state(

  if (states_arg_found) {
    if (state != 0) {
-      GPR_BITSET(states_arg, algorithm);
+      GPR_BITSET((unsigned *)states_arg, algorithm);
    } else {
-      GPR_BITCLEAR(states_arg, algorithm);
+      GPR_BITCLEAR((unsigned *)states_arg, algorithm);
    }
  } else {
    /* create a new arg */
@ -189,9 +189,9 @@ grpc_channel_args *grpc_channel_args_compression_algorithm_set_state(
    /* all enabled by default */
    tmp.value.integer = (1u << GRPC_COMPRESS_ALGORITHMS_COUNT) - 1;
    if (state != 0) {
-      GPR_BITSET(&tmp.value.integer, algorithm);
+      GPR_BITSET((unsigned *)&tmp.value.integer, algorithm);
    } else {
-      GPR_BITCLEAR(&tmp.value.integer, algorithm);
+      GPR_BITCLEAR((unsigned *)&tmp.value.integer, algorithm);
    }
    result = grpc_channel_args_copy_and_add(*a, &tmp, 1);
    grpc_channel_args_destroy(*a);
--- a/src/core/channel/channel_stack.c
+++ b/src/core/channel/channel_stack.c
@ -57,7 +57,7 @@ int grpc_trace_channel = 0;

 /* Given a size, round up to the next multiple of sizeof(void*) */
 #define ROUND_UP_TO_ALIGNMENT_SIZE(x) \
-  (((x) + GPR_MAX_ALIGNMENT - 1) & ~(GPR_MAX_ALIGNMENT - 1))
+  (((x) + GPR_MAX_ALIGNMENT - 1u) & ~(GPR_MAX_ALIGNMENT - 1u))

 size_t grpc_channel_stack_size(const grpc_channel_filter **filters,
                               size_t filter_count) {
--- a/src/core/channel/compress_filter.c
+++ b/src/core/channel/compress_filter.c
@ -48,7 +48,8 @@ typedef struct call_data {
  gpr_slice_buffer slices; /**< Buffers up input slices to be compressed */
  grpc_linked_mdelem compression_algorithm_storage;
  grpc_linked_mdelem accept_encoding_storage;
-  int remaining_slice_bytes; /**< Input data to be read, as per BEGIN_MESSAGE */
+  gpr_uint32
+      remaining_slice_bytes; /**< Input data to be read, as per BEGIN_MESSAGE */
  int written_initial_metadata; /**< Already processed initial md? */
  /** Compression algorithm we'll try to use. It may be given by incoming
   * metadata, or by the channel's default compression settings. */
@ -70,6 +71,8 @@ typedef struct channel_data {
  grpc_mdelem *mdelem_accept_encoding;
  /** The default, channel-level, compression algorithm */
  grpc_compression_algorithm default_compression_algorithm;
+  /** Compression options for the channel */
+  grpc_compression_options compression_options;
 } channel_data;

 /** Compress \a slices in place using \a algorithm. Returns 1 if compression did
@ -102,7 +105,17 @@ static grpc_mdelem *compression_md_filter(void *user_data, grpc_mdelem *md) {
    const char *md_c_str = grpc_mdstr_as_c_string(md->value);
    if (!grpc_compression_algorithm_parse(md_c_str, strlen(md_c_str),
                                          &calld->compression_algorithm)) {
-      gpr_log(GPR_ERROR, "Invalid compression algorithm: '%s'. Ignoring.",
+      gpr_log(GPR_ERROR,
+              "Invalid compression algorithm: '%s' (unknown). Ignoring.",
+              md_c_str);
+      calld->compression_algorithm = GRPC_COMPRESS_NONE;
+    }
+    if (grpc_compression_options_is_algorithm_enabled(
+            &channeld->compression_options, calld->compression_algorithm) ==
+        0) {
+      gpr_log(GPR_ERROR,
+              "Invalid compression algorithm: '%s' (previously disabled). "
+              "Ignoring.",
              md_c_str);
      calld->compression_algorithm = GRPC_COMPRESS_NONE;
    }
@ -141,8 +154,9 @@ static void finish_compressed_sopb(grpc_stream_op_buffer *send_ops,
    grpc_stream_op *sop = &send_ops->ops[i];
    switch (sop->type) {
      case GRPC_OP_BEGIN_MESSAGE:
+        GPR_ASSERT(calld->slices.length <= GPR_UINT32_MAX);
        grpc_sopb_add_begin_message(
-            &new_send_ops, calld->slices.length,
+            &new_send_ops, (gpr_uint32)calld->slices.length,
            sop->data.begin_message.flags | GRPC_WRITE_INTERNAL_COMPRESS);
        break;
      case GRPC_OP_SLICE:
@ -228,7 +242,10 @@ static void process_send_ops(grpc_call_element *elem,
        GPR_ASSERT(calld->remaining_slice_bytes > 0);
        /* Increase input ref count, gpr_slice_buffer_add takes ownership.  */
        gpr_slice_buffer_add(&calld->slices, gpr_slice_ref(sop->data.slice));
-        calld->remaining_slice_bytes -= GPR_SLICE_LENGTH(sop->data.slice);
+        GPR_ASSERT(GPR_SLICE_LENGTH(sop->data.slice) >=
+                   calld->remaining_slice_bytes);
+        calld->remaining_slice_bytes -=
+            (gpr_uint32)GPR_SLICE_LENGTH(sop->data.slice);
        if (calld->remaining_slice_bytes == 0) {
          did_compress =
              compress_send_sb(calld->compression_algorithm, &calld->slices);
@ -294,11 +311,21 @@ static void init_channel_elem(grpc_channel_element *elem, grpc_channel *master,
  channel_data *channeld = elem->channel_data;
  grpc_compression_algorithm algo_idx;
  const char *supported_algorithms_names[GRPC_COMPRESS_ALGORITHMS_COUNT - 1];
+  size_t supported_algorithms_idx = 0;
  char *accept_encoding_str;
  size_t accept_encoding_str_len;

+  grpc_compression_options_init(&channeld->compression_options);
+  channeld->compression_options.enabled_algorithms_bitset =
+      (gpr_uint32)grpc_channel_args_compression_algorithm_get_states(args);
+
  channeld->default_compression_algorithm =
      grpc_channel_args_get_compression_algorithm(args);
+  /* Make sure the default isn't disabled. */
+  GPR_ASSERT(grpc_compression_options_is_algorithm_enabled(
+      &channeld->compression_options, channeld->default_compression_algorithm));
+  channeld->compression_options.default_compression_algorithm =
+      channeld->default_compression_algorithm;

  channeld->mdstr_request_compression_algorithm_key =
      grpc_mdstr_from_string(mdctx, GRPC_COMPRESS_REQUEST_ALGORITHM_KEY, 0);
@ -311,6 +338,11 @@ static void init_channel_elem(grpc_channel_element *elem, grpc_channel *master,

  for (algo_idx = 0; algo_idx < GRPC_COMPRESS_ALGORITHMS_COUNT; ++algo_idx) {
    char *algorithm_name;
+    /* skip disabled algorithms */
+    if (grpc_compression_options_is_algorithm_enabled(
+            &channeld->compression_options, algo_idx) == 0) {
+      continue;
+    }
    GPR_ASSERT(grpc_compression_algorithm_name(algo_idx, &algorithm_name) != 0);
    channeld->mdelem_compression_algorithms[algo_idx] =
        grpc_mdelem_from_metadata_strings(
@ -318,15 +350,15 @@ static void init_channel_elem(grpc_channel_element *elem, grpc_channel *master,
            GRPC_MDSTR_REF(channeld->mdstr_outgoing_compression_algorithm_key),
            grpc_mdstr_from_string(mdctx, algorithm_name, 0));
    if (algo_idx > 0) {
-      supported_algorithms_names[algo_idx - 1] = algorithm_name;
+      supported_algorithms_names[supported_algorithms_idx++] = algorithm_name;
    }
  }

  /* TODO(dgq): gpr_strjoin_sep could be made to work with statically allocated
   * arrays, as to avoid the heap allocs */
-  accept_encoding_str = gpr_strjoin_sep(
-      supported_algorithms_names, GPR_ARRAY_SIZE(supported_algorithms_names),
-      ", ", &accept_encoding_str_len);
+  accept_encoding_str =
+      gpr_strjoin_sep(supported_algorithms_names, supported_algorithms_idx, ",",
+                      &accept_encoding_str_len);

  channeld->mdelem_accept_encoding = grpc_mdelem_from_metadata_strings(
      mdctx, GRPC_MDSTR_REF(channeld->mdstr_compression_capabilities_key),
--- a/src/core/channel/http_client_filter.c
+++ b/src/core/channel/http_client_filter.c
@ -85,16 +85,14 @@ static grpc_mdelem *client_filter(void *user_data, grpc_mdelem *md) {
 static void hc_on_recv(void *user_data, int success) {
  grpc_call_element *elem = user_data;
  call_data *calld = elem->call_data;
-  if (success) {
-    size_t i;
-    size_t nops = calld->recv_ops->nops;
-    grpc_stream_op *ops = calld->recv_ops->ops;
-    for (i = 0; i < nops; i++) {
-      grpc_stream_op *op = &ops[i];
-      if (op->type != GRPC_OP_METADATA) continue;
-      calld->got_initial_metadata = 1;
-      grpc_metadata_batch_filter(&op->data.metadata, client_filter, elem);
-    }
+  size_t i;
+  size_t nops = calld->recv_ops->nops;
+  grpc_stream_op *ops = calld->recv_ops->ops;
+  for (i = 0; i < nops; i++) {
+    grpc_stream_op *op = &ops[i];
+    if (op->type != GRPC_OP_METADATA) continue;
+    calld->got_initial_metadata = 1;
+    grpc_metadata_batch_filter(&op->data.metadata, client_filter, elem);
  }
  calld->on_done_recv->cb(calld->on_done_recv->cb_arg, success);
 }
--- a/src/core/client_config/connector.h
+++ b/src/core/client_config/connector.h
@ -50,7 +50,7 @@ typedef struct {
  grpc_pollset_set *interested_parties;
  /** address to connect to */
  const struct sockaddr *addr;
-  int addr_len;
+  size_t addr_len;
  /** deadline for connection */
  gpr_timespec deadline;
  /** channel arguments (to be passed to transport) */
--- a/src/core/client_config/lb_policies/round_robin.c
+++ b/src/core/client_config/lb_policies/round_robin.c
@ -496,29 +496,28 @@ static void round_robin_factory_ref(grpc_lb_policy_factory *factory) {}
 static void round_robin_factory_unref(grpc_lb_policy_factory *factory) {}

 static grpc_lb_policy *create_round_robin(grpc_lb_policy_factory *factory,
-                                         grpc_subchannel **subchannels,
-                                         size_t num_subchannels) {
+                                          grpc_lb_policy_args *args) {
  size_t i;
  round_robin_lb_policy *p = gpr_malloc(sizeof(*p));
-  GPR_ASSERT(num_subchannels);
+  GPR_ASSERT(args->num_subchannels > 0);
  memset(p, 0, sizeof(*p));
  grpc_lb_policy_init(&p->base, &round_robin_lb_policy_vtable);
-  p->subchannels = gpr_malloc(sizeof(grpc_subchannel *) * num_subchannels);
-  p->num_subchannels = num_subchannels;
+  p->subchannels = gpr_malloc(sizeof(grpc_subchannel *) * args->num_subchannels);
+  p->num_subchannels = args->num_subchannels;
  grpc_connectivity_state_init(&p->state_tracker, GRPC_CHANNEL_IDLE,
                               "round_robin");
-  memcpy(p->subchannels, subchannels,
-         sizeof(grpc_subchannel *) * num_subchannels);
+  memcpy(p->subchannels, args->subchannels,
+         sizeof(grpc_subchannel *) * args->num_subchannels);

  gpr_mu_init(&p->mu);
  p->connectivity_changed_cbs =
-      gpr_malloc(sizeof(grpc_iomgr_closure) * num_subchannels);
+      gpr_malloc(sizeof(grpc_iomgr_closure) * args->num_subchannels);
  p->subchannel_connectivity =
-      gpr_malloc(sizeof(grpc_connectivity_state) * num_subchannels);
+      gpr_malloc(sizeof(grpc_connectivity_state) * args->num_subchannels);

  p->cb_args =
-      gpr_malloc(sizeof(connectivity_changed_cb_arg) * num_subchannels);
-  for(i = 0; i < num_subchannels; i++) {
+      gpr_malloc(sizeof(connectivity_changed_cb_arg) * args->num_subchannels);
+  for(i = 0; i < args->num_subchannels; i++) {
    p->cb_args[i].subchannel_idx = i;
    p->cb_args[i].p = p;
    grpc_iomgr_closure_init(&p->connectivity_changed_cbs[i],
@ -532,9 +531,9 @@ static grpc_lb_policy *create_round_robin(grpc_lb_policy_factory *factory,
  p->ready_list_last_pick = &p->ready_list;

  p->subchannel_index_to_readylist_node =
-      gpr_malloc(sizeof(grpc_subchannel *) * num_subchannels);
+      gpr_malloc(sizeof(grpc_subchannel *) * args->num_subchannels);
  memset(p->subchannel_index_to_readylist_node, 0,
-         sizeof(grpc_subchannel *) * num_subchannels);
+         sizeof(grpc_subchannel *) * args->num_subchannels);
  return &p->base;
 }

--- a/src/core/client_config/resolvers/dns_resolver.c
+++ b/src/core/client_config/resolvers/dns_resolver.c
@ -140,7 +140,7 @@ static void dns_on_resolved(void *arg, grpc_resolved_addresses *addresses) {
    for (i = 0; i < addresses->naddrs; i++) {
      memset(&args, 0, sizeof(args));
      args.addr = (struct sockaddr *)(addresses->addrs[i].addr);
-      args.addr_len = addresses->addrs[i].len;
+      args.addr_len = (size_t)addresses->addrs[i].len;
      subchannels[i] = grpc_subchannel_factory_create_subchannel(
          r->subchannel_factory, &args);
    }
--- a/src/core/client_config/resolvers/sockaddr_resolver.c
+++ b/src/core/client_config/resolvers/sockaddr_resolver.c
@ -62,7 +62,7 @@ typedef struct {
  /** the addresses that we've 'resolved' */
  struct sockaddr_storage *addrs;
  /** the corresponding length of the addresses */
-  int *addrs_len;
+  size_t *addrs_len;
  /** how many elements in \a addrs */
  size_t num_addrs;

@ -161,7 +161,8 @@ static void sockaddr_destroy(grpc_resolver *gr) {
 }

 #ifdef GPR_POSIX_SOCKET
-static int parse_unix(grpc_uri *uri, struct sockaddr_storage *addr, int *len) {
+static int parse_unix(grpc_uri *uri, struct sockaddr_storage *addr,
+                      size_t *len) {
  struct sockaddr_un *un = (struct sockaddr_un *)addr;

  un->sun_family = AF_UNIX;
@ -193,7 +194,8 @@ static char *ipv6_get_default_authority(grpc_resolver_factory *factory,
  return ip_get_default_authority(uri);
 }

-static int parse_ipv4(grpc_uri *uri, struct sockaddr_storage *addr, int *len) {
+static int parse_ipv4(grpc_uri *uri, struct sockaddr_storage *addr,
+                      size_t *len) {
  const char *host_port = uri->path;
  char *host;
  char *port;
@ -220,7 +222,7 @@ static int parse_ipv4(grpc_uri *uri, struct sockaddr_storage *addr, int *len) {
      gpr_log(GPR_ERROR, "invalid ipv4 port: '%s'", port);
      goto done;
    }
-    in->sin_port = htons(port_num);
+    in->sin_port = htons((gpr_uint16)port_num);
  } else {
    gpr_log(GPR_ERROR, "no port given for ipv4 scheme");
    goto done;
@ -233,7 +235,8 @@ done:
  return result;
 }

-static int parse_ipv6(grpc_uri *uri, struct sockaddr_storage *addr, int *len) {
+static int parse_ipv6(grpc_uri *uri, struct sockaddr_storage *addr,
+                      size_t *len) {
  const char *host_port = uri->path;
  char *host;
  char *port;
@ -260,7 +263,7 @@ static int parse_ipv6(grpc_uri *uri, struct sockaddr_storage *addr, int *len) {
      gpr_log(GPR_ERROR, "invalid ipv6 port: '%s'", port);
      goto done;
    }
-    in6->sin6_port = htons(port_num);
+    in6->sin6_port = htons((gpr_uint16)port_num);
  } else {
    gpr_log(GPR_ERROR, "no port given for ipv6 scheme");
    goto done;
@ -277,7 +280,7 @@ static void do_nothing(void *ignored) {}
 static grpc_resolver *sockaddr_create(
    grpc_uri *uri, const char *default_lb_policy_name,
    grpc_subchannel_factory *subchannel_factory,
-    int parse(grpc_uri *uri, struct sockaddr_storage *dst, int *len)) {
+    int parse(grpc_uri *uri, struct sockaddr_storage *dst, size_t *len)) {
  size_t i;
  int errors_found = 0; /* GPR_FALSE */
  sockaddr_resolver *r;
@ -317,7 +320,7 @@ static grpc_resolver *sockaddr_create(
  gpr_slice_split(path_slice, ",", &path_parts);
  r->num_addrs = path_parts.count;
  r->addrs = gpr_malloc(sizeof(struct sockaddr_storage) * r->num_addrs);
-  r->addrs_len = gpr_malloc(sizeof(int) * r->num_addrs);
+  r->addrs_len = gpr_malloc(sizeof(*r->addrs_len) * r->num_addrs);

  for(i = 0; i < r->num_addrs; i++) {
    grpc_uri ith_uri = *uri;
--- a/src/core/client_config/resolvers/zookeeper_resolver.c
+++ b/src/core/client_config/resolvers/zookeeper_resolver.c
@ -244,7 +244,7 @@ static void zookeeper_dns_resolved(void *arg,
 }

 /** Parses JSON format address of a zookeeper node */
-static char *zookeeper_parse_address(const char *value, int value_len) {
+static char *zookeeper_parse_address(const char *value, size_t value_len) {
  grpc_json *json;
  grpc_json *cur;
  const char *host;
@ -294,7 +294,7 @@ static void zookeeper_get_children_node_completion(int rc, const char *value,
    return;
  }

-  address = zookeeper_parse_address(value, value_len);
+  address = zookeeper_parse_address(value, (size_t)value_len);
  if (address != NULL) {
    /** Further resolves address by DNS */
    grpc_resolve_address(address, NULL, zookeeper_dns_resolved, r);
@ -364,7 +364,7 @@ static void zookeeper_get_node_completion(int rc, const char *value,

  /** If zookeeper node of path r->name does not have address
      (i.e. service node), get its children */
-  address = zookeeper_parse_address(value, value_len);
+  address = zookeeper_parse_address(value, (size_t)value_len);
  if (address != NULL) {
    r->resolved_addrs = gpr_malloc(sizeof(grpc_resolved_addresses));
    r->resolved_addrs->addrs = NULL;
--- a/src/core/client_config/uri_parser.c
+++ b/src/core/client_config/uri_parser.c
@ -39,10 +39,13 @@
 #include <grpc/support/log.h>
 #include <grpc/support/string_util.h>

-static grpc_uri *bad_uri(const char *uri_text, int pos, const char *section,
+/** a size_t default value... maps to all 1's */
+#define NOT_SET (~(size_t)0)
+
+static grpc_uri *bad_uri(const char *uri_text, size_t pos, const char *section,
                         int suppress_errors) {
  char *line_prefix;
-  int pfx_len;
+  size_t pfx_len;

  if (!suppress_errors) {
    gpr_asprintf(&line_prefix, "bad uri.%s: '", section);
@ -61,7 +64,7 @@ static grpc_uri *bad_uri(const char *uri_text, int pos, const char *section,
 }

 /** Returns a copy of \a src[begin, end) */
-static char *copy_component(const char *src, int begin, int end) {
+static char *copy_component(const char *src, size_t begin, size_t end) {
  char *out = gpr_malloc(end - begin + 1);
  memcpy(out, src + begin, end - begin);
  out[end - begin] = 0;
@ -70,35 +73,33 @@ static char *copy_component(const char *src, int begin, int end) {

 /** Returns how many chars to advance if \a uri_text[i] begins a valid \a pchar
 * production. If \a uri_text[i] introduces an invalid \a pchar (such as percent
- * sign not followed by two hex digits), -1 is returned. */
-static int parse_pchar(const char *uri_text, int i) {
+ * sign not followed by two hex digits), NOT_SET is returned. */
+static size_t parse_pchar(const char *uri_text, size_t i) {
  /* pchar = unreserved / pct-encoded / sub-delims / ":" / "@"
   * unreserved = ALPHA / DIGIT / "-" / "." / "_" / "~"
   * pct-encoded = "%" HEXDIG HEXDIG
   * sub-delims = "!" / "$" / "&" / "'" / "(" / ")"
                / "*" / "+" / "," / ";" / "=" */
  char c = uri_text[i];
-  if ( ((c >= 'A') && (c <= 'Z')) ||
-       ((c >= 'a') && (c <= 'z')) ||
-       ((c >= '0') && (c <= '9')) ||
-       (c == '-' || c == '.' || c == '_' || c == '~') || /* unreserved */
-
-       (c == '!' || c == '$' || c == '&' || c == '\'' || c == '$' || c == '&' ||
-        c == '(' || c == ')' || c == '*' || c == '+' || c == ',' || c == ';' ||
-        c == '=') /* sub-delims */ ) {
+  if (((c >= 'A') && (c <= 'Z')) || ((c >= 'a') && (c <= 'z')) ||
+      ((c >= '0') && (c <= '9')) ||
+      (c == '-' || c == '.' || c == '_' || c == '~') || /* unreserved */
+
+      (c == '!' || c == '$' || c == '&' || c == '\'' || c == '$' || c == '&' ||
+       c == '(' || c == ')' || c == '*' || c == '+' || c == ',' || c == ';' ||
+       c == '=') /* sub-delims */) {
    return 1;
  }
  if (c == '%') { /* pct-encoded */
-    int j;
-    if (uri_text[i+1] == 0 || uri_text[i+2] == 0) {
-      return -1;
+    size_t j;
+    if (uri_text[i + 1] == 0 || uri_text[i + 2] == 0) {
+      return NOT_SET;
    }
    for (j = i + 1; j < 2; j++) {
      c = uri_text[j];
-      if (!(((c >= '0') && (c <= '9')) ||
-            ((c >= 'a') && (c <= 'f')) ||
+      if (!(((c >= '0') && (c <= '9')) || ((c >= 'a') && (c <= 'f')) ||
            ((c >= 'A') && (c <= 'F')))) {
-        return -1;
+        return NOT_SET;
      }
    }
    return 2;
@ -107,46 +108,45 @@ static int parse_pchar(const char *uri_text, int i) {
 }

 /* *( pchar / "?" / "/" ) */
-static int parse_query(const char *uri_text, int i) {
+static int parse_fragment_or_query(const char *uri_text, size_t *i) {
  char c;
-  while ((c = uri_text[i]) != 0) {
-    const int advance = parse_pchar(uri_text, i); /* pchar */
+  while ((c = uri_text[*i]) != 0) {
+    const size_t advance = parse_pchar(uri_text, *i); /* pchar */
    switch (advance) {
      case 0: /* uri_text[i] isn't in pchar */
        /* maybe it's ? or / */
-        if (uri_text[i] == '?' || uri_text[i] == '/') {
-          i++;
+        if (uri_text[*i] == '?' || uri_text[*i] == '/') {
+          (*i)++;
          break;
        } else {
-          return i;
+          return 1;
        }
-      case 1:
-      case 2:
-        i += advance;
+        gpr_log(GPR_ERROR, "should never reach here");
+        abort();
+      default:
+        (*i) += advance;
        break;
-      default: /* uri_text[i] introduces an invalid URI */
-        return -i;
+      case NOT_SET: /* uri_text[i] introduces an invalid URI */
+        return 0;
    }
  }
-  return i; /* first uri_text position past the \a query production, maybe \0 */
+  /* *i is the first uri_text position past the \a query production, maybe \0 */
+  return 1;
 }

-/* alias for consistency */
-static int (*parse_fragment)(const char *uri_text, int i) = parse_query;
-
 grpc_uri *grpc_uri_parse(const char *uri_text, int suppress_errors) {
  grpc_uri *uri;
-  int scheme_begin = 0;
-  int scheme_end = -1;
-  int authority_begin = -1;
-  int authority_end = -1;
-  int path_begin = -1;
-  int path_end = -1;
-  int query_begin = -1;
-  int query_end = -1;
-  int fragment_begin = -1;
-  int fragment_end = -1;
-  int i;
+  size_t scheme_begin = 0;
+  size_t scheme_end = NOT_SET;
+  size_t authority_begin = NOT_SET;
+  size_t authority_end = NOT_SET;
+  size_t path_begin = NOT_SET;
+  size_t path_end = NOT_SET;
+  size_t query_begin = NOT_SET;
+  size_t query_end = NOT_SET;
+  size_t fragment_begin = NOT_SET;
+  size_t fragment_end = NOT_SET;
+  size_t i;

  for (i = scheme_begin; uri_text[i] != 0; i++) {
    if (uri_text[i] == ':') {
@ -163,21 +163,22 @@ grpc_uri *grpc_uri_parse(const char *uri_text, int suppress_errors) {
    }
    break;
  }
-  if (scheme_end == -1) {
+  if (scheme_end == NOT_SET) {
    return bad_uri(uri_text, i, "scheme", suppress_errors);
  }

  if (uri_text[scheme_end + 1] == '/' && uri_text[scheme_end + 2] == '/') {
    authority_begin = scheme_end + 3;
-    for (i = authority_begin; uri_text[i] != 0 && authority_end == -1; i++) {
+    for (i = authority_begin; uri_text[i] != 0 && authority_end == NOT_SET;
+         i++) {
      if (uri_text[i] == '/' || uri_text[i] == '?' || uri_text[i] == '#') {
        authority_end = i;
      }
    }
-    if (authority_end == -1 && uri_text[i] == 0) {
+    if (authority_end == NOT_SET && uri_text[i] == 0) {
      authority_end = i;
    }
-    if (authority_end == -1) {
+    if (authority_end == NOT_SET) {
      return bad_uri(uri_text, i, "authority", suppress_errors);
    }
    /* TODO(ctiller): parse the authority correctly */
@ -192,18 +193,17 @@ grpc_uri *grpc_uri_parse(const char *uri_text, int suppress_errors) {
      break;
    }
  }
-  if (path_end == -1 && uri_text[i] == 0) {
+  if (path_end == NOT_SET && uri_text[i] == 0) {
    path_end = i;
  }
-  if (path_end == -1) {
+  if (path_end == NOT_SET) {
    return bad_uri(uri_text, i, "path", suppress_errors);
  }

  if (uri_text[i] == '?') {
-    query_begin = i + 1;
-    i = parse_query(uri_text, query_begin);
-    if (i < 0) {
-      return bad_uri(uri_text, -i, "query", suppress_errors);
+    query_begin = ++i;
+    if (!parse_fragment_or_query(uri_text, &i)) {
+      return bad_uri(uri_text, i, "query", suppress_errors);
    } else if (uri_text[i] != 0 && uri_text[i] != '#') {
      /* We must be at the end or at the beginning of a fragment */
      return bad_uri(uri_text, i, "query", suppress_errors);
@ -211,9 +211,8 @@ grpc_uri *grpc_uri_parse(const char *uri_text, int suppress_errors) {
    query_end = i;
  }
  if (uri_text[i] == '#') {
-    fragment_begin = i + 1;
-    i = parse_fragment(uri_text, fragment_begin);
-    if (i < 0) {
+    fragment_begin = ++i;
+    if (!parse_fragment_or_query(uri_text, &i)) {
      return bad_uri(uri_text, i - fragment_end, "fragment", suppress_errors);
    } else if (uri_text[i] != 0) {
      /* We must be at the end */
--- a/src/core/compression/algorithm.c
+++ b/src/core/compression/algorithm.c
@ -33,7 +33,9 @@

 #include <stdlib.h>
 #include <string.h>
+
 #include <grpc/compression.h>
+#include <grpc/support/useful.h>

 int grpc_compression_algorithm_parse(const char *name, size_t name_length,
                                     grpc_compression_algorithm *algorithm) {
@ -102,3 +104,24 @@ grpc_compression_level grpc_compression_level_for_algorithm(
  }
  abort();
 }
+
+void grpc_compression_options_init(grpc_compression_options *opts) {
+  opts->enabled_algorithms_bitset = (1u << GRPC_COMPRESS_ALGORITHMS_COUNT)-1;
+  opts->default_compression_algorithm = GRPC_COMPRESS_NONE;
+}
+
+void grpc_compression_options_enable_algorithm(
+    grpc_compression_options *opts, grpc_compression_algorithm algorithm) {
+  GPR_BITSET(&opts->enabled_algorithms_bitset, algorithm);
+}
+
+void grpc_compression_options_disable_algorithm(
+    grpc_compression_options *opts, grpc_compression_algorithm algorithm) {
+  GPR_BITCLEAR(&opts->enabled_algorithms_bitset, algorithm);
+}
+
+int grpc_compression_options_is_algorithm_enabled(
+    const grpc_compression_options *opts,
+    grpc_compression_algorithm algorithm) {
+  return GPR_BITGET(opts->enabled_algorithms_bitset, algorithm);
+}
--- a/src/core/compression/message_compress.c
+++ b/src/core/compression/message_compress.c
@ -49,19 +49,23 @@ static int zlib_body(z_stream *zs, gpr_slice_buffer *input,
  int flush;
  size_t i;
  gpr_slice outbuf = gpr_slice_malloc(OUTPUT_BLOCK_SIZE);
+  const uInt uint_max = ~(uInt)0;

-  zs->avail_out = GPR_SLICE_LENGTH(outbuf);
+  GPR_ASSERT(GPR_SLICE_LENGTH(outbuf) <= uint_max);
+  zs->avail_out = (uInt)GPR_SLICE_LENGTH(outbuf);
  zs->next_out = GPR_SLICE_START_PTR(outbuf);
  flush = Z_NO_FLUSH;
  for (i = 0; i < input->count; i++) {
    if (i == input->count - 1) flush = Z_FINISH;
-    zs->avail_in = GPR_SLICE_LENGTH(input->slices[i]);
+    GPR_ASSERT(GPR_SLICE_LENGTH(input->slices[i]) <= uint_max);
+    zs->avail_in = (uInt)GPR_SLICE_LENGTH(input->slices[i]);
    zs->next_in = GPR_SLICE_START_PTR(input->slices[i]);
    do {
      if (zs->avail_out == 0) {
        gpr_slice_buffer_add_indexed(output, outbuf);
        outbuf = gpr_slice_malloc(OUTPUT_BLOCK_SIZE);
-        zs->avail_out = GPR_SLICE_LENGTH(outbuf);
+        GPR_ASSERT(GPR_SLICE_LENGTH(outbuf) <= uint_max);
+        zs->avail_out = (uInt)GPR_SLICE_LENGTH(outbuf);
        zs->next_out = GPR_SLICE_START_PTR(outbuf);
      }
      r = flate(zs, flush);
--- a/src/core/debug/trace.c
+++ b/src/core/debug/trace.c
@ -59,9 +59,13 @@ void grpc_register_tracer(const char *name, int *flag) {
 static void add(const char *beg, const char *end, char ***ss, size_t *ns) {
  size_t n = *ns;
  size_t np = n + 1;
-  char *s = gpr_malloc(end - beg + 1);
-  memcpy(s, beg, end - beg);
-  s[end - beg] = 0;
+  char *s;
+  size_t len;
+  GPR_ASSERT(end >= beg);
+  len = (size_t)(end - beg);
+  s = gpr_malloc(len + 1);
+  memcpy(s, beg, len);
+  s[len] = 0;
  *ss = gpr_realloc(*ss, sizeof(char **) * np);
  (*ss)[n] = s;
  *ns = np;
--- a/src/core/httpcli/parser.c
+++ b/src/core/httpcli/parser.c
@ -96,13 +96,15 @@ static int add_header(grpc_httpcli_parser *parser) {
    gpr_log(GPR_ERROR, "Didn't find ':' in header string");
    goto error;
  }
-  hdr.key = buf2str(beg, cur - beg);
+  GPR_ASSERT(cur >= beg);
+  hdr.key = buf2str(beg, (size_t)(cur - beg));
  cur++; /* skip : */

  while (cur != end && (*cur == ' ' || *cur == '\t')) {
    cur++;
  }
-  hdr.value = buf2str(cur, end - cur - 2);
+  GPR_ASSERT(end - cur >= 2);
+  hdr.value = buf2str(cur, (size_t)(end - cur) - 2);

  if (parser->r.hdr_count == parser->hdr_capacity) {
    parser->hdr_capacity =
@ -171,7 +173,7 @@ static int addbyte(grpc_httpcli_parser *parser, gpr_uint8 byte) {
        parser->r.body =
            gpr_realloc((void *)parser->r.body, parser->body_capacity);
      }
-      ((char *)parser->r.body)[parser->r.body_length] = byte;
+      parser->r.body[parser->r.body_length] = (char)byte;
      parser->r.body_length++;
      return 1;
  }
--- a/src/core/iomgr/alarm.c
+++ b/src/core/iomgr/alarm.c
@ -83,7 +83,7 @@ static gpr_timespec compute_min_deadline(shard_type *shard) {
 }

 void grpc_alarm_list_init(gpr_timespec now) {
-  int i;
+  gpr_uint32 i;

  gpr_mu_init(&g_mu);
  gpr_mu_init(&g_checker_mu);
@ -123,13 +123,13 @@ static size_t shard_idx(const grpc_alarm *info) {
 }

 static double ts_to_dbl(gpr_timespec ts) {
-  return ts.tv_sec + 1e-9 * ts.tv_nsec;
+  return (double)ts.tv_sec + 1e-9 * ts.tv_nsec;
 }

 static gpr_timespec dbl_to_ts(double d) {
  gpr_timespec ts;
-  ts.tv_sec = d;
-  ts.tv_nsec = 1e9 * (d - ts.tv_sec);
+  ts.tv_sec = (time_t)d;
+  ts.tv_nsec = (int)(1e9 * (d - (double)ts.tv_sec));
  ts.clock_type = GPR_TIMESPAN;
  return ts;
 }
@ -145,7 +145,7 @@ static void list_remove(grpc_alarm *alarm) {
  alarm->prev->next = alarm->next;
 }

-static void swap_adjacent_shards_in_queue(size_t first_shard_queue_index) {
+static void swap_adjacent_shards_in_queue(gpr_uint32 first_shard_queue_index) {
  shard_type *temp;
  temp = g_shard_queue[first_shard_queue_index];
  g_shard_queue[first_shard_queue_index] =
@ -355,7 +355,7 @@ static int run_some_expired_alarms(gpr_mu *drop_mu, gpr_timespec now,
    gpr_mu_lock(drop_mu);
  }

-  return n;
+  return (int)n;
 }

 int grpc_alarm_check(gpr_mu *drop_mu, gpr_timespec now, gpr_timespec *next) {
--- a/src/core/iomgr/alarm_heap.c
+++ b/src/core/iomgr/alarm_heap.c
@ -43,9 +43,9 @@
   position. This functor is called each time immediately after modifying a
   value in the underlying container, with the offset of the modified element as
   its argument. */
-static void adjust_upwards(grpc_alarm **first, int i, grpc_alarm *t) {
+static void adjust_upwards(grpc_alarm **first, gpr_uint32 i, grpc_alarm *t) {
  while (i > 0) {
-    int parent = (i - 1) / 2;
+    gpr_uint32 parent = (gpr_uint32)(((int)i - 1) / 2);
    if (gpr_time_cmp(first[parent]->deadline, t->deadline) >= 0) break;
    first[i] = first[parent];
    first[i]->heap_index = i;
@ -58,12 +58,12 @@ static void adjust_upwards(grpc_alarm **first, int i, grpc_alarm *t) {
 /* Adjusts a heap so as to move a hole at position i farther away from the root,
   until a suitable position is found for element t.  Then, copies t into that
   position. */
-static void adjust_downwards(grpc_alarm **first, int i, int length,
-                             grpc_alarm *t) {
+static void adjust_downwards(grpc_alarm **first, gpr_uint32 i,
+                             gpr_uint32 length, grpc_alarm *t) {
  for (;;) {
-    int left_child = 1 + 2 * i;
-    int right_child;
-    int next_i;
+    gpr_uint32 left_child = 1u + 2u * i;
+    gpr_uint32 right_child;
+    gpr_uint32 next_i;
    if (left_child >= length) break;
    right_child = left_child + 1;
    next_i = right_child < length &&
@ -93,8 +93,8 @@ static void maybe_shrink(grpc_alarm_heap *heap) {
 }

 static void note_changed_priority(grpc_alarm_heap *heap, grpc_alarm *alarm) {
-  int i = alarm->heap_index;
-  int parent = (i - 1) / 2;
+  gpr_uint32 i = alarm->heap_index;
+  gpr_uint32 parent = (gpr_uint32)(((int)i - 1) / 2);
  if (gpr_time_cmp(heap->alarms[parent]->deadline, alarm->deadline) < 0) {
    adjust_upwards(heap->alarms, i, alarm);
  } else {
@ -122,7 +122,7 @@ int grpc_alarm_heap_add(grpc_alarm_heap *heap, grpc_alarm *alarm) {
 }

 void grpc_alarm_heap_remove(grpc_alarm_heap *heap, grpc_alarm *alarm) {
-  int i = alarm->heap_index;
+  gpr_uint32 i = alarm->heap_index;
  if (i == heap->alarm_count - 1) {
    heap->alarm_count--;
    maybe_shrink(heap);
--- a/src/core/iomgr/alarm_heap.h
+++ b/src/core/iomgr/alarm_heap.h
@ -38,8 +38,8 @@

 typedef struct {
  grpc_alarm **alarms;
-  int alarm_count;
-  int alarm_capacity;
+  gpr_uint32 alarm_count;
+  gpr_uint32 alarm_capacity;
 } grpc_alarm_heap;

 /* return 1 if the new alarm is the first alarm in the heap */
--- a/src/core/iomgr/pollset_multipoller_with_epoll.c
+++ b/src/core/iomgr/pollset_multipoller_with_epoll.c
@ -99,7 +99,6 @@ static void perform_delayed_add(void *arg, int iomgr_status) {
  if (da->pollset->shutting_down) {
    /* We don't care about this pollset anymore. */
    if (da->pollset->in_flight_cbs == 0 && !da->pollset->called_shutdown) {
-      GPR_ASSERT(!grpc_pollset_has_workers(da->pollset));
      da->pollset->called_shutdown = 1;
      do_shutdown_cb = 1;
    }
--- a/src/core/iomgr/pollset_multipoller_with_poll_posix.c
+++ b/src/core/iomgr/pollset_multipoller_with_poll_posix.c
@ -101,7 +101,8 @@ static void multipoll_with_poll_pollset_maybe_work(
    gpr_timespec now, int allow_synchronous_callback) {
  int timeout;
  int r;
-  size_t i, j, pfd_count, fd_count;
+  size_t i, j, fd_count;
+  nfds_t pfd_count;
  pollset_hdr *h;
  /* TODO(ctiller): inline some elements to avoid an allocation */
  grpc_fd_watcher *watchers;
@ -140,8 +141,8 @@ static void multipoll_with_poll_pollset_maybe_work(
  gpr_mu_unlock(&pollset->mu);

  for (i = 1; i < pfd_count; i++) {
-    pfds[i].events = grpc_fd_begin_poll(watchers[i].fd, pollset, POLLIN,
-                                        POLLOUT, &watchers[i]);
+    pfds[i].events = (short)grpc_fd_begin_poll(watchers[i].fd, pollset, POLLIN,
+                                               POLLOUT, &watchers[i]);
  }

  r = grpc_poll_function(pfds, pfd_count, timeout);
--- a/src/core/iomgr/pollset_posix.c
+++ b/src/core/iomgr/pollset_posix.c
@ -420,7 +420,7 @@ static void basic_pollset_maybe_work(grpc_pollset *pollset,
  grpc_fd_watcher fd_watcher;
  int timeout;
  int r;
-  int nfds;
+  nfds_t nfds;

  if (pollset->in_flight_cbs) {
    /* Give do_promote priority so we don't starve it out */
@ -443,7 +443,7 @@ static void basic_pollset_maybe_work(grpc_pollset *pollset,
    pfd[1].revents = 0;
    gpr_mu_unlock(&pollset->mu);
    pfd[1].events =
-        grpc_fd_begin_poll(fd, pollset, POLLIN, POLLOUT, &fd_watcher);
+        (short)grpc_fd_begin_poll(fd, pollset, POLLIN, POLLOUT, &fd_watcher);
    if (pfd[1].events != 0) {
      nfds++;
    }
--- a/src/core/iomgr/resolve_address.h
+++ b/src/core/iomgr/resolve_address.h
@ -40,7 +40,7 @@

 typedef struct {
  char addr[GRPC_MAX_SOCKADDR_SIZE];
-  int len;
+  size_t len;
 } grpc_resolved_address;

 typedef struct {
--- a/src/core/iomgr/sockaddr_utils.c
+++ b/src/core/iomgr/sockaddr_utils.c
@ -123,15 +123,17 @@ void grpc_sockaddr_make_wildcards(int port, struct sockaddr_in *wild4_out,
 }

 void grpc_sockaddr_make_wildcard4(int port, struct sockaddr_in *wild_out) {
+  GPR_ASSERT(port >= 0 && port < 65536);
  memset(wild_out, 0, sizeof(*wild_out));
  wild_out->sin_family = AF_INET;
-  wild_out->sin_port = htons(port);
+  wild_out->sin_port = htons((gpr_uint16)port);
 }

 void grpc_sockaddr_make_wildcard6(int port, struct sockaddr_in6 *wild_out) {
+  GPR_ASSERT(port >= 0 && port < 65536);
  memset(wild_out, 0, sizeof(*wild_out));
  wild_out->sin6_family = AF_INET6;
-  wild_out->sin6_port = htons(port);
+  wild_out->sin6_port = htons((gpr_uint16)port);
 }

 int grpc_sockaddr_to_string(char **out, const struct sockaddr *addr,
@ -215,10 +217,12 @@ int grpc_sockaddr_get_port(const struct sockaddr *addr) {
 int grpc_sockaddr_set_port(const struct sockaddr *addr, int port) {
  switch (addr->sa_family) {
    case AF_INET:
-      ((struct sockaddr_in *)addr)->sin_port = htons(port);
+      GPR_ASSERT(port >= 0 && port < 65536);
+      ((struct sockaddr_in *)addr)->sin_port = htons((gpr_uint16)port);
      return 1;
    case AF_INET6:
-      ((struct sockaddr_in6 *)addr)->sin6_port = htons(port);
+      GPR_ASSERT(port >= 0 && port < 65536);
+      ((struct sockaddr_in6 *)addr)->sin6_port = htons((gpr_uint16)port);
      return 1;
    default:
      gpr_log(GPR_ERROR, "Unknown socket family %d in grpc_sockaddr_set_port",
--- a/src/core/iomgr/socket_windows.c
+++ b/src/core/iomgr/socket_windows.c
@ -35,8 +35,12 @@

 #ifdef GPR_WINSOCK_SOCKET

+#include <winsock2.h>
+#include <mswsock.h>
+
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
+#include <grpc/support/log_win32.h>
 #include <grpc/support/string_util.h>

 #include "src/core/iomgr/iocp_windows.h"
@ -63,6 +67,24 @@ grpc_winsocket *grpc_winsocket_create(SOCKET socket, const char *name) {
   various callsites of that function, which happens to be in various
   mutex hold states, and that'd be unsafe to call them directly. */
 void grpc_winsocket_shutdown(grpc_winsocket *winsocket) {
+  /* Grab the function pointer for DisconnectEx for that specific socket.
+     It may change depending on the interface. */
+  int status;
+  GUID guid = WSAID_DISCONNECTEX;
+  LPFN_DISCONNECTEX DisconnectEx;
+  DWORD ioctl_num_bytes;
+
+  status = WSAIoctl(winsocket->socket, SIO_GET_EXTENSION_FUNCTION_POINTER,
+                    &guid, sizeof(guid), &DisconnectEx, sizeof(DisconnectEx),
+                    &ioctl_num_bytes, NULL, NULL);
+
+  if (status == 0) {
+    DisconnectEx(winsocket->socket, NULL, 0, 0);
+  } else {
+    char *utf8_message = gpr_format_message(WSAGetLastError());
+    gpr_log(GPR_ERROR, "Unable to retrieve DisconnectEx pointer : %s", utf8_message);
+    gpr_free(utf8_message);
+  }
  closesocket(winsocket->socket);
 }

--- a/src/core/iomgr/tcp_client.h
+++ b/src/core/iomgr/tcp_client.h
@ -46,7 +46,7 @@
   in this connection being established (in order to continue their work) */
 void grpc_tcp_client_connect(void (*cb)(void *arg, grpc_endpoint *tcp),
                             void *arg, grpc_pollset_set *interested_parties,
-                             const struct sockaddr *addr, int addr_len,
+                             const struct sockaddr *addr, size_t addr_len,
                             gpr_timespec deadline);

 #endif /* GRPC_INTERNAL_CORE_IOMGR_TCP_CLIENT_H */
--- a/src/core/iomgr/tcp_client_posix.c
+++ b/src/core/iomgr/tcp_client_posix.c
@ -195,7 +195,7 @@ finish:

 void grpc_tcp_client_connect(void (*cb)(void *arg, grpc_endpoint *ep),
                             void *arg, grpc_pollset_set *interested_parties,
-                             const struct sockaddr *addr, int addr_len,
+                             const struct sockaddr *addr, size_t addr_len,
                             gpr_timespec deadline) {
  int fd;
  grpc_dualstack_mode dsmode;
@ -229,7 +229,8 @@ void grpc_tcp_client_connect(void (*cb)(void *arg, grpc_endpoint *ep),
  }

  do {
-    err = connect(fd, addr, addr_len);
+    GPR_ASSERT(addr_len < ~(socklen_t)0);
+    err = connect(fd, addr, (socklen_t)addr_len);
  } while (err < 0 && errno == EINTR);

  addr_str = grpc_sockaddr_to_uri(addr);
--- a/src/core/iomgr/tcp_posix.c
+++ b/src/core/iomgr/tcp_posix.c
@ -61,14 +61,20 @@
 #define SENDMSG_FLAGS 0
 #endif

+#ifdef GPR_MSG_IOVLEN_TYPE
+typedef GPR_MSG_IOVLEN_TYPE msg_iovlen_type;
+#else
+typedef size_t msg_iovlen_type;
+#endif
+
 int grpc_tcp_trace = 0;

 typedef struct {
  grpc_endpoint base;
  grpc_fd *em_fd;
  int fd;
-  int iov_size; /* Number of slices to allocate per read attempt */
  int finished_edge;
+  msg_iovlen_type iov_size; /* Number of slices to allocate per read attempt */
  size_t slice_size;
  gpr_refcount refcount;

@ -215,8 +221,9 @@ static void tcp_continue_read(grpc_tcp *tcp) {
  } else {
    GPR_ASSERT((size_t)read_bytes <= tcp->incoming_buffer->length);
    if ((size_t)read_bytes < tcp->incoming_buffer->length) {
-      gpr_slice_buffer_trim_end(tcp->incoming_buffer,
-                                tcp->incoming_buffer->length - read_bytes);
+      gpr_slice_buffer_trim_end(
+          tcp->incoming_buffer,
+          tcp->incoming_buffer->length - (size_t)read_bytes);
    } else if (tcp->iov_size < MAX_READ_IOVEC) {
      ++tcp->iov_size;
    }
@ -264,12 +271,12 @@ static grpc_endpoint_op_status tcp_read(grpc_endpoint *ep,
 static grpc_endpoint_op_status tcp_flush(grpc_tcp *tcp) {
  struct msghdr msg;
  struct iovec iov[MAX_WRITE_IOVEC];
-  int iov_size;
+  msg_iovlen_type iov_size;
  ssize_t sent_length;
-  ssize_t sending_length;
-  ssize_t trailing;
-  ssize_t unwind_slice_idx;
-  ssize_t unwind_byte_idx;
+  size_t sending_length;
+  size_t trailing;
+  size_t unwind_slice_idx;
+  size_t unwind_byte_idx;

  for (;;) {
    sending_length = 0;
@ -319,9 +326,9 @@ static grpc_endpoint_op_status tcp_flush(grpc_tcp *tcp) {
    }

    GPR_ASSERT(tcp->outgoing_byte_idx == 0);
-    trailing = sending_length - sent_length;
+    trailing = sending_length - (size_t)sent_length;
    while (trailing > 0) {
-      ssize_t slice_length;
+      size_t slice_length;

      tcp->outgoing_slice_idx--;
      slice_length = GPR_SLICE_LENGTH(
--- a/src/core/iomgr/tcp_server.h
+++ b/src/core/iomgr/tcp_server.h
@ -62,7 +62,7 @@ void grpc_tcp_server_start(grpc_tcp_server *server, grpc_pollset **pollsets,
 /* TODO(ctiller): deprecate this, and make grpc_tcp_server_add_ports to handle
                  all of the multiple socket port matching logic in one place */
 int grpc_tcp_server_add_port(grpc_tcp_server *s, const void *addr,
-                             int addr_len);
+                             size_t addr_len);

 /* Returns the file descriptor of the Nth listening socket on this server,
   or -1 if the index is out of bounds.
--- a/src/core/iomgr/tcp_server_posix.c
+++ b/src/core/iomgr/tcp_server_posix.c
@ -83,7 +83,7 @@ typedef struct {
    struct sockaddr sockaddr;
    struct sockaddr_un un;
  } addr;
-  int addr_len;
+  size_t addr_len;
  grpc_iomgr_closure read_closure;
  grpc_iomgr_closure destroyed_closure;
 } server_port;
@ -236,7 +236,7 @@ static void init_max_accept_queue_size(void) {
    char *end;
    long i = strtol(buf, &end, 10);
    if (i > 0 && i <= INT_MAX && end && *end == 0) {
-      n = i;
+      n = (int)i;
    }
  }
  fclose(fp);
@ -256,7 +256,8 @@ static int get_max_accept_queue_size(void) {
 }

 /* Prepare a recently-created socket for listening. */
-static int prepare_socket(int fd, const struct sockaddr *addr, int addr_len) {
+static int prepare_socket(int fd, const struct sockaddr *addr,
+                          size_t addr_len) {
  struct sockaddr_storage sockname_temp;
  socklen_t sockname_len;

@ -273,7 +274,8 @@ static int prepare_socket(int fd, const struct sockaddr *addr, int addr_len) {
    goto error;
  }

-  if (bind(fd, addr, addr_len) < 0) {
+  GPR_ASSERT(addr_len < ~(socklen_t)0);
+  if (bind(fd, addr, (socklen_t)addr_len) < 0) {
    char *addr_str;
    grpc_sockaddr_to_string(&addr_str, addr, 0);
    gpr_log(GPR_ERROR, "bind addr=%s: %s", addr_str, strerror(errno));
@ -365,7 +367,7 @@ error:
 }

 static int add_socket_to_server(grpc_tcp_server *s, int fd,
-                                const struct sockaddr *addr, int addr_len) {
+                                const struct sockaddr *addr, size_t addr_len) {
  server_port *sp;
  int port;
  char *addr_str;
@ -398,7 +400,7 @@ static int add_socket_to_server(grpc_tcp_server *s, int fd,
 }

 int grpc_tcp_server_add_port(grpc_tcp_server *s, const void *addr,
-                             int addr_len) {
+                             size_t addr_len) {
  int allocated_port1 = -1;
  int allocated_port2 = -1;
  unsigned i;
--- a/src/core/iomgr/udp_server.c
+++ b/src/core/iomgr/udp_server.c
@ -78,7 +78,7 @@ typedef struct {
    struct sockaddr sockaddr;
    struct sockaddr_un un;
  } addr;
-  int addr_len;
+  size_t addr_len;
  grpc_iomgr_closure read_closure;
  grpc_iomgr_closure destroyed_closure;
  grpc_udp_server_read_cb read_cb;
@ -221,7 +221,8 @@ void grpc_udp_server_destroy(
 }

 /* Prepare a recently-created socket for listening. */
-static int prepare_socket(int fd, const struct sockaddr *addr, int addr_len) {
+static int prepare_socket(int fd, const struct sockaddr *addr,
+                          size_t addr_len) {
  struct sockaddr_storage sockname_temp;
  socklen_t sockname_len;
  int get_local_ip;
@ -241,7 +242,8 @@ static int prepare_socket(int fd, const struct sockaddr *addr, int addr_len) {
 #endif
  }

-  if (bind(fd, addr, addr_len) < 0) {
+  GPR_ASSERT(addr_len < ~(socklen_t)0);
+  if (bind(fd, addr, (socklen_t)addr_len) < 0) {
    char *addr_str;
    grpc_sockaddr_to_string(&addr_str, addr, 0);
    gpr_log(GPR_ERROR, "bind addr=%s: %s", addr_str, strerror(errno));
@ -287,7 +289,7 @@ static void on_read(void *arg, int success) {
 }

 static int add_socket_to_server(grpc_udp_server *s, int fd,
-                                const struct sockaddr *addr, int addr_len,
+                                const struct sockaddr *addr, size_t addr_len,
                                grpc_udp_server_read_cb read_cb) {
  server_port *sp;
  int port;
@ -319,8 +321,8 @@ static int add_socket_to_server(grpc_udp_server *s, int fd,
  return port;
 }

-int grpc_udp_server_add_port(grpc_udp_server *s, const void *addr, int addr_len,
-                             grpc_udp_server_read_cb read_cb) {
+int grpc_udp_server_add_port(grpc_udp_server *s, const void *addr,
+                             size_t addr_len, grpc_udp_server_read_cb read_cb) {
  int allocated_port1 = -1;
  int allocated_port2 = -1;
  unsigned i;
@ -430,7 +432,7 @@ void grpc_udp_server_start(grpc_udp_server *s, grpc_pollset **pollsets,
 /* TODO(rjshade): Add a test for this method. */
 void grpc_udp_server_write(server_port *sp, const char *buffer, size_t buf_len,
                           const struct sockaddr *peer_address) {
-  int rc;
+  ssize_t rc;
  rc = sendto(sp->fd, buffer, buf_len, 0, peer_address, sizeof(peer_address));
  if (rc < 0) {
    gpr_log(GPR_ERROR, "Unable to send data: %s", strerror(errno));
--- a/src/core/iomgr/udp_server.h
+++ b/src/core/iomgr/udp_server.h
@ -67,8 +67,8 @@ int grpc_udp_server_get_fd(grpc_udp_server *s, unsigned index);

 /* TODO(ctiller): deprecate this, and make grpc_udp_server_add_ports to handle
                  all of the multiple socket port matching logic in one place */
-int grpc_udp_server_add_port(grpc_udp_server *s, const void *addr, int addr_len,
-                             grpc_udp_server_read_cb read_cb);
+int grpc_udp_server_add_port(grpc_udp_server *s, const void *addr,
+                             size_t addr_len, grpc_udp_server_read_cb read_cb);

 void grpc_udp_server_destroy(grpc_udp_server *server,
                             void (*shutdown_done)(void *shutdown_done_arg),
--- a/src/core/iomgr/wakeup_fd_pipe.c
+++ b/src/core/iomgr/wakeup_fd_pipe.c
@ -56,7 +56,7 @@ static void pipe_init(grpc_wakeup_fd *fd_info) {

 static void pipe_consume(grpc_wakeup_fd *fd_info) {
  char buf[128];
-  int r;
+  ssize_t r;

  for (;;) {
    r = read(fd_info->read_fd, buf, sizeof(buf));
--- a/src/core/security/base64.c
+++ b/src/core/security/base64.c
@ -125,13 +125,14 @@ gpr_slice grpc_base64_decode(const char *b64, int url_safe) {

 static void decode_one_char(const unsigned char *codes, unsigned char *result,
                            size_t *result_offset) {
-  gpr_uint32 packed = (codes[0] << 2) | (codes[1] >> 4);
+  gpr_uint32 packed = ((gpr_uint32)codes[0] << 2) | ((gpr_uint32)codes[1] >> 4);
  result[(*result_offset)++] = (unsigned char)packed;
 }

 static void decode_two_chars(const unsigned char *codes, unsigned char *result,
                             size_t *result_offset) {
-  gpr_uint32 packed = (codes[0] << 10) | (codes[1] << 4) | (codes[2] >> 2);
+  gpr_uint32 packed = ((gpr_uint32)codes[0] << 10) |
+                      ((gpr_uint32)codes[1] << 4) | ((gpr_uint32)codes[2] >> 2);
  result[(*result_offset)++] = (unsigned char)(packed >> 8);
  result[(*result_offset)++] = (unsigned char)(packed);
 }
@ -171,8 +172,9 @@ static int decode_group(const unsigned char *codes, size_t num_codes,
    decode_two_chars(codes, result, result_offset);
  } else {
    /* No padding. */
-    gpr_uint32 packed =
-        (codes[0] << 18) | (codes[1] << 12) | (codes[2] << 6) | codes[3];
+    gpr_uint32 packed = ((gpr_uint32)codes[0] << 18) |
+                        ((gpr_uint32)codes[1] << 12) |
+                        ((gpr_uint32)codes[2] << 6) | codes[3];
    result[(*result_offset)++] = (unsigned char)(packed >> 16);
    result[(*result_offset)++] = (unsigned char)(packed >> 8);
    result[(*result_offset)++] = (unsigned char)(packed);
--- a/src/core/security/jwt_verifier.c
+++ b/src/core/security/jwt_verifier.c
@ -33,6 +33,7 @@

 #include "src/core/security/jwt_verifier.h"

+#include <limits.h>
 #include <string.h>

 #include "src/core/httpcli/httpcli.h"
@ -412,7 +413,9 @@ static EVP_PKEY *extract_pkey_from_x509(const char *x509_str) {
  X509 *x509 = NULL;
  EVP_PKEY *result = NULL;
  BIO *bio = BIO_new(BIO_s_mem());
-  BIO_write(bio, x509_str, strlen(x509_str));
+  size_t len = strlen(x509_str);
+  GPR_ASSERT(len < INT_MAX);
+  BIO_write(bio, x509_str, (int)len);
  x509 = PEM_read_bio_X509(bio, NULL, NULL, NULL);
  if (x509 == NULL) {
    gpr_log(GPR_ERROR, "Unable to parse x509 cert.");
@ -439,7 +442,8 @@ static BIGNUM *bignum_from_base64(const char *b64) {
    gpr_log(GPR_ERROR, "Invalid base64 for big num.");
    return NULL;
  }
-  result = BN_bin2bn(GPR_SLICE_START_PTR(bin), GPR_SLICE_LENGTH(bin), NULL);
+  result =
+      BN_bin2bn(GPR_SLICE_START_PTR(bin), (int)GPR_SLICE_LENGTH(bin), NULL);
  gpr_slice_unref(bin);
  return result;
 }
@ -769,7 +773,7 @@ void grpc_jwt_verifier_verify(grpc_jwt_verifier *verifier,
  GPR_ASSERT(verifier != NULL && jwt != NULL && audience != NULL && cb != NULL);
  dot = strchr(cur, '.');
  if (dot == NULL) goto error;
-  json = parse_json_part_from_jwt(cur, dot - cur, &header_buffer);
+  json = parse_json_part_from_jwt(cur, (size_t)(dot - cur), &header_buffer);
  if (json == NULL) goto error;
  header = jose_header_from_json(json, header_buffer);
  if (header == NULL) goto error;
@ -777,7 +781,7 @@ void grpc_jwt_verifier_verify(grpc_jwt_verifier *verifier,
  cur = dot + 1;
  dot = strchr(cur, '.');
  if (dot == NULL) goto error;
-  json = parse_json_part_from_jwt(cur, dot - cur, &claims_buffer);
+  json = parse_json_part_from_jwt(cur, (size_t)(dot - cur), &claims_buffer);
  if (json == NULL) goto error;
  claims = grpc_jwt_claims_from_json(json, claims_buffer);
  if (claims == NULL) goto error;
--- a/src/core/security/server_auth_filter.c
+++ b/src/core/security/server_auth_filter.c
@ -128,9 +128,11 @@ static void on_md_processing_done(
    calld->num_consumed_md = num_consumed_md;
    grpc_metadata_batch_filter(&calld->md_op->data.metadata, remove_consumed_md,
                               elem);
+    grpc_metadata_array_destroy(&calld->md);
    calld->on_done_recv->cb(calld->on_done_recv->cb_arg, 1);
  } else {
    gpr_slice message;
+    grpc_metadata_array_destroy(&calld->md);
    error_details = error_details != NULL
                    ? error_details
                    : "Authentication metadata processing failed.";
@ -139,7 +141,6 @@ static void on_md_processing_done(
    grpc_transport_stream_op_add_close(&calld->transport_op, status, &message);
    grpc_call_next_op(elem, &calld->transport_op);
  }
-  grpc_metadata_array_destroy(&calld->md);
 }

 static void auth_on_recv(void *user_data, int success) {
--- a/src/core/support/cpu_posix.c
+++ b/src/core/support/cpu_posix.c
@ -44,11 +44,11 @@

 static __thread char magic_thread_local;

-static int ncpus = 0;
+static long ncpus = 0;

 static void init_ncpus() {
  ncpus = sysconf(_SC_NPROCESSORS_ONLN);
-  if (ncpus < 1) {
+  if (ncpus < 1 || ncpus > GPR_UINT32_MAX) {
    gpr_log(GPR_ERROR, "Cannot determine number of CPUs: assuming 1");
    ncpus = 1;
  }
@ -57,7 +57,7 @@ static void init_ncpus() {
 unsigned gpr_cpu_num_cores(void) {
  static gpr_once once = GPR_ONCE_INIT;
  gpr_once_init(&once, init_ncpus);
-  return ncpus;
+  return (unsigned)ncpus;
 }

 /* This is a cheap, but good enough, pointer hash for sharding things: */
@ -71,7 +71,7 @@ unsigned gpr_cpu_current_cpu(void) {
     most code that's using this is using it to shard across work queues though,
     so here we use thread identity instead to achieve a similar though not
     identical effect */
-  return shard_ptr(&magic_thread_local);
+  return (unsigned)shard_ptr(&magic_thread_local);
 }

 #endif /* GPR_CPU_POSIX */
--- a/src/core/support/log_posix.c
+++ b/src/core/support/log_posix.c
@ -62,7 +62,7 @@ void gpr_log(const char *file, int line, gpr_log_severity severity,
  } else if ((size_t)ret <= sizeof(buf) - 1) {
    message = buf;
  } else {
-    message = allocated = gpr_malloc(ret + 1);
+    message = allocated = gpr_malloc((size_t)ret + 1);
    va_start(args, format);
    vsnprintf(message, ret + 1, format, args);
    va_end(args);
--- a/src/core/support/slice_buffer.c
+++ b/src/core/support/slice_buffer.c
@ -69,7 +69,7 @@ void gpr_slice_buffer_destroy(gpr_slice_buffer *sb) {
  }
 }

-gpr_uint8 *gpr_slice_buffer_tiny_add(gpr_slice_buffer *sb, unsigned n) {
+gpr_uint8 *gpr_slice_buffer_tiny_add(gpr_slice_buffer *sb, size_t n) {
  gpr_slice *back;
  gpr_uint8 *out;

--- a/src/core/support/stack_lockfree.c
+++ b/src/core/support/stack_lockfree.c
@ -79,7 +79,7 @@ struct gpr_stack_lockfree {
 #endif
 };

-gpr_stack_lockfree *gpr_stack_lockfree_create(int entries) {
+gpr_stack_lockfree *gpr_stack_lockfree_create(size_t entries) {
  gpr_stack_lockfree *stack;
  stack = gpr_malloc(sizeof(*stack));
  /* Since we only allocate 16 bits to represent an entry number,
@ -123,13 +123,13 @@ int gpr_stack_lockfree_push(gpr_stack_lockfree *stack, int entry) {
 #ifndef NDEBUG
  /* Check for double push */
  {
-    int pushed_index = entry / (8 * sizeof(gpr_atm));
-    int pushed_bit = entry % (8 * sizeof(gpr_atm));
+    int pushed_index = entry / (int)(8 * sizeof(gpr_atm));
+    int pushed_bit = entry % (int)(8 * sizeof(gpr_atm));
    gpr_atm old_val;

    old_val = gpr_atm_no_barrier_fetch_add(&stack->pushed[pushed_index],
                                           (gpr_atm)(1UL << pushed_bit));
-    GPR_ASSERT((old_val & (1UL << pushed_bit)) == 0);
+    GPR_ASSERT((old_val & (gpr_atm)(1UL << pushed_bit)) == 0);
  }
 #endif

@ -167,7 +167,7 @@ int gpr_stack_lockfree_pop(gpr_stack_lockfree *stack) {

    old_val = gpr_atm_no_barrier_fetch_add(&stack->pushed[pushed_index],
                                           -(gpr_atm)(1UL << pushed_bit));
-    GPR_ASSERT((old_val & (1UL << pushed_bit)) != 0);
+    GPR_ASSERT((old_val & (gpr_atm)(1UL << pushed_bit)) != 0);
  }
 #endif

--- a/src/core/support/stack_lockfree.h
+++ b/src/core/support/stack_lockfree.h
@ -34,11 +34,13 @@
 #ifndef GRPC_INTERNAL_CORE_SUPPORT_STACK_LOCKFREE_H
 #define GRPC_INTERNAL_CORE_SUPPORT_STACK_LOCKFREE_H

+#include <stddef.h>
+
 typedef struct gpr_stack_lockfree gpr_stack_lockfree;

 /* This stack must specify the maximum number of entries to track.
   The current implementation only allows up to 65534 entries */
-gpr_stack_lockfree* gpr_stack_lockfree_create(int entries);
+gpr_stack_lockfree* gpr_stack_lockfree_create(size_t entries);
 void gpr_stack_lockfree_destroy(gpr_stack_lockfree* stack);

 /* Pass in a valid entry number for the next stack entry */
--- a/src/core/support/time_posix.c
+++ b/src/core/support/time_posix.c
@ -108,8 +108,8 @@ gpr_timespec gpr_now(gpr_clock_type clock) {
      break;
    case GPR_CLOCK_MONOTONIC:
      now_dbl = (mach_absolute_time() - g_time_start) * g_time_scale;
-      now.tv_sec = now_dbl * 1e-9;
-      now.tv_nsec = now_dbl - now.tv_sec * 1e9;
+      now.tv_sec = (time_t)(now_dbl * 1e-9);
+      now.tv_nsec = (int)(now_dbl - ((double)now.tv_sec) * 1e9);
      break;
    case GPR_CLOCK_PRECISE:
      gpr_precise_clock_now(&now);
--- a/src/core/surface/call.c
+++ b/src/core/surface/call.c
@ -61,18 +61,6 @@
      - status/close recv (depending on client/server) */
 #define MAX_CONCURRENT_COMPLETIONS 6

-typedef enum { REQ_INITIAL = 0, REQ_READY, REQ_DONE } req_state;
-
-typedef enum {
-  SEND_NOTHING,
-  SEND_INITIAL_METADATA,
-  SEND_BUFFERED_INITIAL_METADATA,
-  SEND_MESSAGE,
-  SEND_BUFFERED_MESSAGE,
-  SEND_TRAILING_METADATA_AND_FINISH,
-  SEND_FINISH
-} send_action;
-
 typedef struct {
  grpc_ioreq_completion_func on_complete;
  void *user_data;
@ -433,7 +421,7 @@ static grpc_cq_completion *allocate_completion(grpc_call *call) {
    if (call->allocated_completions & (1u << i)) {
      continue;
    }
-    call->allocated_completions |= 1u << i;
+    call->allocated_completions |= (gpr_uint8)(1u << i);
    gpr_mu_unlock(&call->completion_mu);
    return &call->completions[i];
  }
@ -444,7 +432,8 @@ static grpc_cq_completion *allocate_completion(grpc_call *call) {
 static void done_completion(void *call, grpc_cq_completion *completion) {
  grpc_call *c = call;
  gpr_mu_lock(&c->completion_mu);
-  c->allocated_completions &= ~(1u << (completion - c->completions));
+  c->allocated_completions &=
+      (gpr_uint8) ~(1u << (completion - c->completions));
  gpr_mu_unlock(&c->completion_mu);
  GRPC_CALL_INTERNAL_UNREF(c, "completion", 1);
 }
@ -520,7 +509,7 @@ static void set_status_code(grpc_call *call, status_source source,
  if (call->status[source].is_set) return;

  call->status[source].is_set = 1;
-  call->status[source].code = status;
+  call->status[source].code = (grpc_status_code)status;
  call->error_status_set = status != GRPC_STATUS_OK;

  if (status != GRPC_STATUS_OK && !grpc_bbq_empty(&call->incoming_queue)) {
@ -545,7 +534,7 @@ static void set_encodings_accepted_by_peer(
  gpr_slice_buffer accept_encoding_parts;

  gpr_slice_buffer_init(&accept_encoding_parts);
-  gpr_slice_split(accept_encoding_slice, ", ", &accept_encoding_parts);
+  gpr_slice_split(accept_encoding_slice, ",", &accept_encoding_parts);

  /* No need to zero call->encodings_accepted_by_peer: grpc_call_create already
   * zeroes the whole grpc_call */
@ -616,7 +605,7 @@ static void unlock(grpc_call *call) {
  int completing_requests = 0;
  int start_op = 0;
  int i;
-  const gpr_uint32 MAX_RECV_PEEK_AHEAD = 65536;
+  const size_t MAX_RECV_PEEK_AHEAD = 65536;
  size_t buffered_bytes;
  int cancel_alarm = 0;

@ -755,7 +744,7 @@ static void finish_live_ioreq_op(grpc_call *call, grpc_ioreq_op op,
  size_t i;
  /* ioreq is live: we need to do something */
  master = &call->masters[master_set];
-  master->complete_mask |= 1u << op;
+  master->complete_mask |= (gpr_uint16)(1u << op);
  if (!success) {
    master->success = 0;
  }
@ -1119,10 +1108,12 @@ static int fill_send_ops(grpc_call *call, grpc_transport_stream_op *op) {
    /* fall through intended */
    case WRITE_STATE_STARTED:
      if (is_op_live(call, GRPC_IOREQ_SEND_MESSAGE)) {
+        size_t length;
        data = call->request_data[GRPC_IOREQ_SEND_MESSAGE];
        flags = call->request_flags[GRPC_IOREQ_SEND_MESSAGE];
-        grpc_sopb_add_begin_message(
-            &call->send_ops, grpc_byte_buffer_length(data.send_message), flags);
+        length = grpc_byte_buffer_length(data.send_message);
+        GPR_ASSERT(length <= GPR_UINT32_MAX);
+        grpc_sopb_add_begin_message(&call->send_ops, (gpr_uint32)length, flags);
        copy_byte_buffer_to_stream_ops(data.send_message, &call->send_ops);
        op->send_ops = &call->send_ops;
        call->last_send_contains |= 1 << GRPC_IOREQ_SEND_MESSAGE;
@ -1224,7 +1215,7 @@ static grpc_call_error start_ioreq(grpc_call *call, const grpc_ioreq *reqs,
                                   grpc_ioreq_completion_func completion,
                                   void *user_data) {
  size_t i;
-  gpr_uint32 have_ops = 0;
+  gpr_uint16 have_ops = 0;
  grpc_ioreq_op op;
  reqinfo_master *master;
  grpc_ioreq_data data;
@ -1255,13 +1246,13 @@ static grpc_call_error start_ioreq(grpc_call *call, const grpc_ioreq *reqs,
    }
    if (op == GRPC_IOREQ_SEND_STATUS) {
      set_status_code(call, STATUS_FROM_SERVER_STATUS,
-                      reqs[i].data.send_status.code);
+                      (gpr_uint32)reqs[i].data.send_status.code);
      if (reqs[i].data.send_status.details) {
        set_status_details(call, STATUS_FROM_SERVER_STATUS,
                           GRPC_MDSTR_REF(reqs[i].data.send_status.details));
      }
    }
-    have_ops |= 1u << op;
+    have_ops |= (gpr_uint16)(1u << op);

    call->request_data[op] = data;
    call->request_flags[op] = reqs[i].flags;
@ -1345,7 +1336,7 @@ static grpc_call_error cancel_with_status(grpc_call *c, grpc_status_code status,

  GPR_ASSERT(status != GRPC_STATUS_OK);

-  set_status_code(c, STATUS_FROM_API_OVERRIDE, status);
+  set_status_code(c, STATUS_FROM_API_OVERRIDE, (gpr_uint32)status);
  set_status_details(c, STATUS_FROM_API_OVERRIDE, details);

  c->cancel_with_status = status;
--- a/src/core/surface/channel.c
+++ b/src/core/surface/channel.c
@ -113,7 +113,7 @@ grpc_channel *grpc_channel_create_from_filters(
      grpc_mdstr_from_string(mdctx, "grpc-message", 0);
  for (i = 0; i < NUM_CACHED_STATUS_ELEMS; i++) {
    char buf[GPR_LTOA_MIN_BUFSIZE];
-    gpr_ltoa(i, buf);
+    gpr_ltoa((long)i, buf);
    channel->grpc_status_elem[i] = grpc_mdelem_from_metadata_strings(
        mdctx, GRPC_MDSTR_REF(channel->grpc_status_string),
        grpc_mdstr_from_string(mdctx, buf, 0));
@ -134,7 +134,7 @@ grpc_channel *grpc_channel_create_from_filters(
          gpr_log(GPR_ERROR, "%s ignored: it must be >= 0",
                  GRPC_ARG_MAX_MESSAGE_LENGTH);
        } else {
-          channel->max_message_length = args->args[i].value.integer;
+          channel->max_message_length = (gpr_uint32)args->args[i].value.integer;
        }
      } else if (0 == strcmp(args->args[i].key, GRPC_ARG_DEFAULT_AUTHORITY)) {
        if (args->args[i].type != GRPC_ARG_STRING) {
@ -193,7 +193,7 @@ static grpc_call *grpc_channel_create_call_internal(
    grpc_completion_queue *cq, grpc_mdelem *path_mdelem,
    grpc_mdelem *authority_mdelem, gpr_timespec deadline) {
  grpc_mdelem *send_metadata[2];
-  int num_metadata = 0;
+  size_t num_metadata = 0;

  GPR_ASSERT(channel->is_client);

--- a/src/core/surface/channel_create.c
+++ b/src/core/surface/channel_create.c
@ -164,7 +164,7 @@ grpc_channel *grpc_insecure_channel_create(const char *target,
  grpc_resolver *resolver;
  subchannel_factory *f;
  grpc_mdctx *mdctx = grpc_mdctx_create();
-  int n = 0;
+  size_t n = 0;
  GPR_ASSERT(!reserved);
  if (grpc_channel_args_is_census_enabled(args)) {
    filters[n++] = &grpc_client_census_filter;
--- a/src/core/surface/secure_channel_create.c
+++ b/src/core/surface/secure_channel_create.c
@ -197,7 +197,7 @@ grpc_channel *grpc_secure_channel_create(grpc_credentials *creds,
  subchannel_factory *f;
 #define MAX_FILTERS 3
  const grpc_channel_filter *filters[MAX_FILTERS];
-  int n = 0;
+  size_t n = 0;

  GPR_ASSERT(reserved == NULL);
  if (grpc_find_security_connector_in_args(args) != NULL) {
--- a/src/core/surface/server.c
+++ b/src/core/surface/server.c
@ -33,6 +33,7 @@

 #include "src/core/surface/server.h"

+#include <limits.h>
 #include <stdlib.h>
 #include <string.h>

@ -203,7 +204,7 @@ struct grpc_server {
  gpr_stack_lockfree *request_freelist;
  /** requested call backing data */
  requested_call *requested_calls;
-  int max_requested_calls;
+  size_t max_requested_calls;

  gpr_atm shutdown_flag;
  gpr_uint8 shutdown_published;
@ -298,7 +299,7 @@ static void channel_broadcaster_shutdown(channel_broadcaster *cb,
 */

 static void request_matcher_init(request_matcher *request_matcher,
-                                 int entries) {
+                                 size_t entries) {
  memset(request_matcher, 0, sizeof(*request_matcher));
  request_matcher->requests = gpr_stack_lockfree_create(entries);
 }
@ -804,7 +805,7 @@ grpc_server *grpc_server_create_from_filters(
  server->request_freelist =
      gpr_stack_lockfree_create(server->max_requested_calls);
  for (i = 0; i < (size_t)server->max_requested_calls; i++) {
-    gpr_stack_lockfree_push(server->request_freelist, i);
+    gpr_stack_lockfree_push(server->request_freelist, (int)i);
  }
  request_matcher_init(&server->unregistered_request_matcher,
                       server->max_requested_calls);
@ -817,7 +818,7 @@ grpc_server *grpc_server_create_from_filters(
     grpc_server_census_filter (optional) - for stats collection and tracing
     {passed in filter stack}
     grpc_connected_channel_filter - for interfacing with transports */
-  server->channel_filter_count = filter_count + 1 + census_enabled;
+  server->channel_filter_count = filter_count + 1u + (census_enabled ? 1u : 0u);
  server->channel_filters =
      gpr_malloc(server->channel_filter_count * sizeof(grpc_channel_filter *));
  server->channel_filters[0] = &server_surface_filter;
@ -825,7 +826,7 @@ grpc_server *grpc_server_create_from_filters(
    server->channel_filters[1] = &grpc_server_census_filter;
  }
  for (i = 0; i < filter_count; i++) {
-    server->channel_filters[i + 1 + census_enabled] = filters[i];
+    server->channel_filters[i + 1u + (census_enabled ? 1u : 0u)] = filters[i];
  }

  server->channel_args = grpc_channel_args_copy(args);
@ -896,7 +897,7 @@ void grpc_server_setup_transport(grpc_server *s, grpc_transport *transport,
  grpc_mdstr *host;
  grpc_mdstr *method;
  gpr_uint32 hash;
-  gpr_uint32 slots;
+  size_t slots;
  gpr_uint32 probes;
  gpr_uint32 max_probes = 0;
  grpc_transport_op op;
@ -949,7 +950,8 @@ void grpc_server_setup_transport(grpc_server *s, grpc_transport *transport,
      crm->host = host;
      crm->method = method;
    }
-    chand->registered_method_slots = slots;
+    GPR_ASSERT(slots <= GPR_UINT32_MAX);
+    chand->registered_method_slots = (gpr_uint32)slots;
    chand->registered_method_max_probes = max_probes;
  }

@ -970,7 +972,7 @@ void grpc_server_setup_transport(grpc_server *s, grpc_transport *transport,
  op.set_accept_stream_user_data = chand;
  op.on_connectivity_state_change = &chand->channel_connectivity_changed;
  op.connectivity_state = &chand->connectivity_state;
-  op.disconnect = gpr_atm_acq_load(&s->shutdown_flag);
+  op.disconnect = gpr_atm_acq_load(&s->shutdown_flag) != 0;
  grpc_transport_perform_op(transport, &op);
 }

@ -1246,7 +1248,8 @@ static void begin_call(grpc_server *server, call_data *calld,
  }

  GRPC_CALL_INTERNAL_REF(calld->call, "server");
-  grpc_call_start_ioreq_and_call_back(calld->call, req, r - req, publish, rc);
+  grpc_call_start_ioreq_and_call_back(calld->call, req, (size_t)(r - req),
+                                      publish, rc);
 }

 static void done_request_event(void *req, grpc_cq_completion *c) {
@ -1255,8 +1258,9 @@ static void done_request_event(void *req, grpc_cq_completion *c) {

  if (rc >= server->requested_calls &&
      rc < server->requested_calls + server->max_requested_calls) {
+    GPR_ASSERT(rc - server->requested_calls <= INT_MAX);
    gpr_stack_lockfree_push(server->request_freelist,
-                            rc - server->requested_calls);
+                            (int)(rc - server->requested_calls));
  } else {
    gpr_free(req);
  }
--- a/src/core/transport/chttp2/bin_encoder.c
+++ b/src/core/transport/chttp2/bin_encoder.c
@ -68,7 +68,7 @@ gpr_slice grpc_chttp2_base64_encode(gpr_slice input) {
  size_t output_length = input_triplets * 4 + tail_xtra[tail_case];
  gpr_slice output = gpr_slice_malloc(output_length);
  gpr_uint8 *in = GPR_SLICE_START_PTR(input);
-  gpr_uint8 *out = GPR_SLICE_START_PTR(output);
+  char *out = (char *)GPR_SLICE_START_PTR(output);
  size_t i;

  /* encode full triplets */
@ -100,7 +100,7 @@ gpr_slice grpc_chttp2_base64_encode(gpr_slice input) {
      break;
  }

-  GPR_ASSERT(out == GPR_SLICE_END_PTR(output));
+  GPR_ASSERT(out == (char *)GPR_SLICE_END_PTR(output));
  GPR_ASSERT(in == GPR_SLICE_END_PTR(input));
  return output;
 }
@ -128,12 +128,13 @@ gpr_slice grpc_chttp2_huffman_compress(gpr_slice input) {

    while (temp_length > 8) {
      temp_length -= 8;
-      *out++ = temp >> temp_length;
+      *out++ = (gpr_uint8)(temp >> temp_length);
    }
  }

  if (temp_length) {
-    *out++ = (temp << (8 - temp_length)) | (0xff >> temp_length);
+    *out++ = (gpr_uint8)(temp << (8u - temp_length)) |
+             (gpr_uint8)(0xffu >> temp_length);
  }

  GPR_ASSERT(out == GPR_SLICE_END_PTR(output));
@ -150,16 +151,16 @@ typedef struct {
 static void enc_flush_some(huff_out *out) {
  while (out->temp_length > 8) {
    out->temp_length -= 8;
-    *out->out++ = out->temp >> out->temp_length;
+    *out->out++ = (gpr_uint8)(out->temp >> out->temp_length);
  }
 }

 static void enc_add2(huff_out *out, gpr_uint8 a, gpr_uint8 b) {
  b64_huff_sym sa = huff_alphabet[a];
  b64_huff_sym sb = huff_alphabet[b];
-  out->temp =
-      (out->temp << (sa.length + sb.length)) | (sa.bits << sb.length) | sb.bits;
-  out->temp_length += sa.length + sb.length;
+  out->temp = (out->temp << (sa.length + sb.length)) |
+              ((gpr_uint32)sa.bits << sb.length) | sb.bits;
+  out->temp_length += (gpr_uint32)sa.length + (gpr_uint32)sb.length;
  enc_flush_some(out);
 }

@ -189,8 +190,9 @@ gpr_slice grpc_chttp2_base64_encode_and_huffman_compress(gpr_slice input) {

  /* encode full triplets */
  for (i = 0; i < input_triplets; i++) {
-    enc_add2(&out, in[0] >> 2, ((in[0] & 0x3) << 4) | (in[1] >> 4));
-    enc_add2(&out, ((in[1] & 0xf) << 2) | (in[2] >> 6), in[2] & 0x3f);
+    enc_add2(&out, in[0] >> 2, (gpr_uint8)((in[0] & 0x3) << 4) | (in[1] >> 4));
+    enc_add2(&out, (gpr_uint8)((in[1] & 0xf) << 2) | (in[2] >> 6),
+             (gpr_uint8)(in[2] & 0x3f));
    in += 3;
  }

@ -199,19 +201,20 @@ gpr_slice grpc_chttp2_base64_encode_and_huffman_compress(gpr_slice input) {
    case 0:
      break;
    case 1:
-      enc_add2(&out, in[0] >> 2, (in[0] & 0x3) << 4);
+      enc_add2(&out, in[0] >> 2, (gpr_uint8)((in[0] & 0x3) << 4));
      in += 1;
      break;
    case 2:
-      enc_add2(&out, in[0] >> 2, ((in[0] & 0x3) << 4) | (in[1] >> 4));
-      enc_add1(&out, (in[1] & 0xf) << 2);
+      enc_add2(&out, in[0] >> 2,
+               (gpr_uint8)((in[0] & 0x3) << 4) | (gpr_uint8)(in[1] >> 4));
+      enc_add1(&out, (gpr_uint8)((in[1] & 0xf) << 2));
      in += 2;
      break;
  }

  if (out.temp_length) {
-    *out.out++ =
-        (out.temp << (8 - out.temp_length)) | (0xff >> out.temp_length);
+    *out.out++ = (gpr_uint8)(out.temp << (8u - out.temp_length)) |
+                 (gpr_uint8)(0xffu >> out.temp_length);
  }

  GPR_ASSERT(out.out <= GPR_SLICE_END_PTR(output));
--- a/src/core/transport/chttp2/frame_data.c
+++ b/src/core/transport/chttp2/frame_data.c
@ -146,20 +146,23 @@ grpc_chttp2_parse_error grpc_chttp2_data_parser_parse(
      grpc_chttp2_list_add_parsing_seen_stream(transport_parsing,
                                               stream_parsing);
      if ((gpr_uint32)(end - cur) == p->frame_size) {
-        grpc_sopb_add_slice(&p->incoming_sopb,
-                            gpr_slice_sub(slice, cur - beg, end - beg));
+        grpc_sopb_add_slice(
+            &p->incoming_sopb,
+            gpr_slice_sub(slice, (size_t)(cur - beg), (size_t)(end - beg)));
        p->state = GRPC_CHTTP2_DATA_FH_0;
        return GRPC_CHTTP2_PARSE_OK;
      } else if ((gpr_uint32)(end - cur) > p->frame_size) {
-        grpc_sopb_add_slice(
-            &p->incoming_sopb,
-            gpr_slice_sub(slice, cur - beg, cur + p->frame_size - beg));
+        grpc_sopb_add_slice(&p->incoming_sopb,
+                            gpr_slice_sub(slice, (size_t)(cur - beg),
+                                          (size_t)(cur + p->frame_size - beg)));
        cur += p->frame_size;
        goto fh_0; /* loop */
      } else {
-        grpc_sopb_add_slice(&p->incoming_sopb,
-                            gpr_slice_sub(slice, cur - beg, end - beg));
-        p->frame_size -= (end - cur);
+        grpc_sopb_add_slice(
+            &p->incoming_sopb,
+            gpr_slice_sub(slice, (size_t)(cur - beg), (size_t)(end - beg)));
+        GPR_ASSERT(end - cur <= p->frame_size);
+        p->frame_size -= (gpr_uint32)(end - cur);
        return GRPC_CHTTP2_PARSE_OK;
      }
  }
--- a/src/core/transport/chttp2/frame_goaway.c
+++ b/src/core/transport/chttp2/frame_goaway.c
@ -136,14 +136,15 @@ grpc_chttp2_parse_error grpc_chttp2_goaway_parser_parse(
      ++cur;
    /* fallthrough */
    case GRPC_CHTTP2_GOAWAY_DEBUG:
-      memcpy(p->debug_data + p->debug_pos, cur, end - cur);
-      p->debug_pos += end - cur;
+      memcpy(p->debug_data + p->debug_pos, cur, (size_t)(end - cur));
+      GPR_ASSERT(end - cur < GPR_UINT32_MAX - p->debug_pos);
+      p->debug_pos += (gpr_uint32)(end - cur);
      p->state = GRPC_CHTTP2_GOAWAY_DEBUG;
      if (is_last) {
        transport_parsing->goaway_received = 1;
        transport_parsing->goaway_last_stream_index = p->last_stream_id;
        gpr_slice_unref(transport_parsing->goaway_text);
-        transport_parsing->goaway_error = p->error_code;
+        transport_parsing->goaway_error = (grpc_status_code)p->error_code;
        transport_parsing->goaway_text =
            gpr_slice_new(p->debug_data, p->debug_length, gpr_free);
        p->debug_data = NULL;
@ -160,12 +161,14 @@ void grpc_chttp2_goaway_append(gpr_uint32 last_stream_id, gpr_uint32 error_code,
                               gpr_slice_buffer *slice_buffer) {
  gpr_slice header = gpr_slice_malloc(9 + 4 + 4);
  gpr_uint8 *p = GPR_SLICE_START_PTR(header);
-  gpr_uint32 frame_length = 4 + 4 + GPR_SLICE_LENGTH(debug_data);
+  gpr_uint32 frame_length;
+  GPR_ASSERT(GPR_SLICE_LENGTH(debug_data) < GPR_UINT32_MAX - 4 - 4);
+  frame_length = 4 + 4 + (gpr_uint32)GPR_SLICE_LENGTH(debug_data);

  /* frame header: length */
-  *p++ = frame_length >> 16;
-  *p++ = frame_length >> 8;
-  *p++ = frame_length;
+  *p++ = (gpr_uint8)(frame_length >> 16);
+  *p++ = (gpr_uint8)(frame_length >> 8);
+  *p++ = (gpr_uint8)(frame_length);
  /* frame header: type */
  *p++ = GRPC_CHTTP2_FRAME_GOAWAY;
  /* frame header: flags */
@ -176,15 +179,15 @@ void grpc_chttp2_goaway_append(gpr_uint32 last_stream_id, gpr_uint32 error_code,
  *p++ = 0;
  *p++ = 0;
  /* payload: last stream id */
-  *p++ = last_stream_id >> 24;
-  *p++ = last_stream_id >> 16;
-  *p++ = last_stream_id >> 8;
-  *p++ = last_stream_id;
+  *p++ = (gpr_uint8)(last_stream_id >> 24);
+  *p++ = (gpr_uint8)(last_stream_id >> 16);
+  *p++ = (gpr_uint8)(last_stream_id >> 8);
+  *p++ = (gpr_uint8)(last_stream_id);
  /* payload: error code */
-  *p++ = error_code >> 24;
-  *p++ = error_code >> 16;
-  *p++ = error_code >> 8;
-  *p++ = error_code;
+  *p++ = (gpr_uint8)(error_code >> 24);
+  *p++ = (gpr_uint8)(error_code >> 16);
+  *p++ = (gpr_uint8)(error_code >> 8);
+  *p++ = (gpr_uint8)(error_code);
  GPR_ASSERT(p == GPR_SLICE_END_PTR(header));
  gpr_slice_buffer_add(slice_buffer, header);
  gpr_slice_buffer_add(slice_buffer, debug_data);
--- a/src/core/transport/chttp2/frame_rst_stream.c
+++ b/src/core/transport/chttp2/frame_rst_stream.c
@ -47,14 +47,14 @@ gpr_slice grpc_chttp2_rst_stream_create(gpr_uint32 id, gpr_uint32 code) {
  *p++ = 4;
  *p++ = GRPC_CHTTP2_FRAME_RST_STREAM;
  *p++ = 0;
-  *p++ = id >> 24;
-  *p++ = id >> 16;
-  *p++ = id >> 8;
-  *p++ = id;
-  *p++ = code >> 24;
-  *p++ = code >> 16;
-  *p++ = code >> 8;
-  *p++ = code;
+  *p++ = (gpr_uint8)(id >> 24);
+  *p++ = (gpr_uint8)(id >> 16);
+  *p++ = (gpr_uint8)(id >> 8);
+  *p++ = (gpr_uint8)(id);
+  *p++ = (gpr_uint8)(code >> 24);
+  *p++ = (gpr_uint8)(code >> 16);
+  *p++ = (gpr_uint8)(code >> 8);
+  *p++ = (gpr_uint8)(code);

  return slice;
 }
--- a/src/core/transport/chttp2/frame_settings.c
+++ b/src/core/transport/chttp2/frame_settings.c
@ -61,9 +61,9 @@ const grpc_chttp2_setting_parameters

 static gpr_uint8 *fill_header(gpr_uint8 *out, gpr_uint32 length,
                              gpr_uint8 flags) {
-  *out++ = length >> 16;
-  *out++ = length >> 8;
-  *out++ = length;
+  *out++ = (gpr_uint8)(length >> 16);
+  *out++ = (gpr_uint8)(length >> 8);
+  *out++ = (gpr_uint8)(length);
  *out++ = GRPC_CHTTP2_FRAME_SETTINGS;
  *out++ = flags;
  *out++ = 0;
@ -76,26 +76,26 @@ static gpr_uint8 *fill_header(gpr_uint8 *out, gpr_uint32 length,
 gpr_slice grpc_chttp2_settings_create(gpr_uint32 *old, const gpr_uint32 *new,
                                      gpr_uint32 force_mask, size_t count) {
  size_t i;
-  size_t n = 0;
+  gpr_uint32 n = 0;
  gpr_slice output;
  gpr_uint8 *p;

  for (i = 0; i < count; i++) {
-    n += (new[i] != old[i] || (force_mask & (1 << i)) != 0);
+    n += (new[i] != old[i] || (force_mask & (1u << i)) != 0);
  }

  output = gpr_slice_malloc(9 + 6 * n);
  p = fill_header(GPR_SLICE_START_PTR(output), 6 * n, 0);

  for (i = 0; i < count; i++) {
-    if (new[i] != old[i] || (force_mask & (1 << i)) != 0) {
+    if (new[i] != old[i] || (force_mask & (1u << i)) != 0) {
      GPR_ASSERT(i);
-      *p++ = i >> 8;
-      *p++ = i;
-      *p++ = new[i] >> 24;
-      *p++ = new[i] >> 16;
-      *p++ = new[i] >> 8;
-      *p++ = new[i];
+      *p++ = (gpr_uint8)(i >> 8);
+      *p++ = (gpr_uint8)(i);
+      *p++ = (gpr_uint8)(new[i] >> 24);
+      *p++ = (gpr_uint8)(new[i] >> 16);
+      *p++ = (gpr_uint8)(new[i] >> 8);
+      *p++ = (gpr_uint8)(new[i]);
      old[i] = new[i];
    }
  }
@ -162,7 +162,7 @@ grpc_chttp2_parse_error grpc_chttp2_settings_parser_parse(
          }
          return GRPC_CHTTP2_PARSE_OK;
        }
-        parser->id = ((gpr_uint16)*cur) << 8;
+        parser->id = (gpr_uint16)(((gpr_uint16)*cur) << 8);
        cur++;
      /* fallthrough */
      case GRPC_CHTTP2_SPS_ID1:
@ -170,7 +170,7 @@ grpc_chttp2_parse_error grpc_chttp2_settings_parser_parse(
          parser->state = GRPC_CHTTP2_SPS_ID1;
          return GRPC_CHTTP2_PARSE_OK;
        }
-        parser->id |= (*cur);
+        parser->id = (gpr_uint16)(parser->id | (*cur));
        cur++;
      /* fallthrough */
      case GRPC_CHTTP2_SPS_VAL0:
--- a/src/core/transport/chttp2/frame_window_update.c
+++ b/src/core/transport/chttp2/frame_window_update.c
@ -48,14 +48,14 @@ gpr_slice grpc_chttp2_window_update_create(gpr_uint32 id,
  *p++ = 4;
  *p++ = GRPC_CHTTP2_FRAME_WINDOW_UPDATE;
  *p++ = 0;
-  *p++ = id >> 24;
-  *p++ = id >> 16;
-  *p++ = id >> 8;
-  *p++ = id;
-  *p++ = window_update >> 24;
-  *p++ = window_update >> 16;
-  *p++ = window_update >> 8;
-  *p++ = window_update;
+  *p++ = (gpr_uint8)(id >> 24);
+  *p++ = (gpr_uint8)(id >> 16);
+  *p++ = (gpr_uint8)(id >> 8);
+  *p++ = (gpr_uint8)(id);
+  *p++ = (gpr_uint8)(window_update >> 24);
+  *p++ = (gpr_uint8)(window_update >> 16);
+  *p++ = (gpr_uint8)(window_update >> 8);
+  *p++ = (gpr_uint8)(window_update);

  return slice;
 }
--- a/src/core/transport/chttp2/hpack_parser.c
+++ b/src/core/transport/chttp2/hpack_parser.c
@ -1085,11 +1085,13 @@ static int parse_string_prefix(grpc_chttp2_hpack_parser *p,
 static void append_bytes(grpc_chttp2_hpack_parser_string *str,
                         const gpr_uint8 *data, size_t length) {
  if (length + str->length > str->capacity) {
-    str->capacity = str->length + length;
+    GPR_ASSERT(str->length + length <= GPR_UINT32_MAX);
+    str->capacity = (gpr_uint32)(str->length + length);
    str->str = gpr_realloc(str->str, str->capacity);
  }
  memcpy(str->str + str->length, data, length);
-  str->length += length;
+  GPR_ASSERT(length <= GPR_UINT32_MAX - str->length);
+  str->length += (gpr_uint32)length;
 }

 static int append_string(grpc_chttp2_hpack_parser *p, const gpr_uint8 *cur,
@ -1099,7 +1101,7 @@ static int append_string(grpc_chttp2_hpack_parser *p, const gpr_uint8 *cur,
  gpr_uint8 decoded[3];
  switch ((binary_state)p->binary) {
    case NOT_BINARY:
-      append_bytes(str, cur, end - cur);
+      append_bytes(str, cur, (size_t)(end - cur));
      return 1;
    b64_byte0:
    case B64_BYTE0:
@ -1157,9 +1159,9 @@ static int append_string(grpc_chttp2_hpack_parser *p, const gpr_uint8 *cur,
        goto b64_byte3;
      p->base64_buffer |= bits;
      bits = p->base64_buffer;
-      decoded[0] = bits >> 16;
-      decoded[1] = bits >> 8;
-      decoded[2] = bits;
+      decoded[0] = (gpr_uint8)(bits >> 16);
+      decoded[1] = (gpr_uint8)(bits >> 8);
+      decoded[2] = (gpr_uint8)(bits);
      append_bytes(str, decoded, 3);
      goto b64_byte0;
  }
@ -1189,7 +1191,7 @@ static int finish_str(grpc_chttp2_hpack_parser *p) {
                bits & 0xffff);
        return 0;
      }
-      decoded[0] = bits >> 16;
+      decoded[0] = (gpr_uint8)(bits >> 16);
      append_bytes(str, decoded, 1);
      break;
    case B64_BYTE3:
@ -1199,8 +1201,8 @@ static int finish_str(grpc_chttp2_hpack_parser *p) {
                bits & 0xff);
        return 0;
      }
-      decoded[0] = bits >> 16;
-      decoded[1] = bits >> 8;
+      decoded[0] = (gpr_uint8)(bits >> 16);
+      decoded[1] = (gpr_uint8)(bits >> 8);
      append_bytes(str, decoded, 2);
      break;
  }
@ -1249,13 +1251,14 @@ static int add_str_bytes(grpc_chttp2_hpack_parser *p, const gpr_uint8 *cur,
 static int parse_string(grpc_chttp2_hpack_parser *p, const gpr_uint8 *cur,
                        const gpr_uint8 *end) {
  size_t remaining = p->strlen - p->strgot;
-  size_t given = end - cur;
+  size_t given = (size_t)(end - cur);
  if (remaining <= given) {
    return add_str_bytes(p, cur, cur + remaining) && finish_str(p) &&
           parse_next(p, cur + remaining, end);
  } else {
    if (!add_str_bytes(p, cur, cur + given)) return 0;
-    p->strgot += given;
+    GPR_ASSERT(given <= GPR_UINT32_MAX - p->strgot);
+    p->strgot += (gpr_uint32)given;
    p->state = parse_string;
    return 1;
  }
--- a/src/core/transport/chttp2/hpack_parser.h
+++ b/src/core/transport/chttp2/hpack_parser.h
@ -79,7 +79,7 @@ struct grpc_chttp2_hpack_parser {
  /* number of source bytes read for the currently parsing string */
  gpr_uint32 strgot;
  /* huffman decoding state */
-  gpr_uint16 huff_state;
+  gpr_int16 huff_state;
  /* is the string being decoded binary? */
  gpr_uint8 binary;
  /* is the current string huffman encoded? */
--- a/src/core/transport/chttp2/hpack_table.c
+++ b/src/core/transport/chttp2/hpack_table.c
@ -139,7 +139,7 @@ grpc_mdelem *grpc_chttp2_hptbl_lookup(const grpc_chttp2_hptbl *tbl,
  /* Otherwise, find the value in the list of valid entries */
  index -= (GRPC_CHTTP2_LAST_STATIC_ENTRY + 1);
  if (index < tbl->num_ents) {
-    gpr_uint32 offset = (tbl->num_ents - 1 - index + tbl->first_ent) %
+    gpr_uint32 offset = (tbl->num_ents - 1u - index + tbl->first_ent) %
                        GRPC_CHTTP2_MAX_TABLE_COUNT;
    return tbl->ents[offset];
  }
@ -150,19 +150,22 @@ grpc_mdelem *grpc_chttp2_hptbl_lookup(const grpc_chttp2_hptbl *tbl,
 /* Evict one element from the table */
 static void evict1(grpc_chttp2_hptbl *tbl) {
  grpc_mdelem *first_ent = tbl->ents[tbl->first_ent];
-  tbl->mem_used -= GPR_SLICE_LENGTH(first_ent->key->slice) +
-                   GPR_SLICE_LENGTH(first_ent->value->slice) +
-                   GRPC_CHTTP2_HPACK_ENTRY_OVERHEAD;
-  tbl->first_ent = (tbl->first_ent + 1) % GRPC_CHTTP2_MAX_TABLE_COUNT;
+  size_t elem_bytes = GPR_SLICE_LENGTH(first_ent->key->slice) +
+                      GPR_SLICE_LENGTH(first_ent->value->slice) +
+                      GRPC_CHTTP2_HPACK_ENTRY_OVERHEAD;
+  GPR_ASSERT(elem_bytes <= tbl->mem_used);
+  tbl->mem_used = (gpr_uint16)(tbl->mem_used - elem_bytes);
+  tbl->first_ent =
+      (gpr_uint16)((tbl->first_ent + 1) % GRPC_CHTTP2_MAX_TABLE_COUNT);
  tbl->num_ents--;
  GRPC_MDELEM_UNREF(first_ent);
 }

 void grpc_chttp2_hptbl_add(grpc_chttp2_hptbl *tbl, grpc_mdelem *md) {
  /* determine how many bytes of buffer this entry represents */
-  gpr_uint16 elem_bytes = GPR_SLICE_LENGTH(md->key->slice) +
-                          GPR_SLICE_LENGTH(md->value->slice) +
-                          GRPC_CHTTP2_HPACK_ENTRY_OVERHEAD;
+  size_t elem_bytes = GPR_SLICE_LENGTH(md->key->slice) +
+                      GPR_SLICE_LENGTH(md->value->slice) +
+                      GRPC_CHTTP2_HPACK_ENTRY_OVERHEAD;

  /* we can't add elements bigger than the max table size */
  if (elem_bytes > tbl->max_bytes) {
@ -182,7 +185,7 @@ void grpc_chttp2_hptbl_add(grpc_chttp2_hptbl *tbl, grpc_mdelem *md) {
  }

  /* evict entries to ensure no overflow */
-  while (elem_bytes > tbl->max_bytes - tbl->mem_used) {
+  while (elem_bytes > (size_t)tbl->max_bytes - tbl->mem_used) {
    evict1(tbl);
  }

@ -190,28 +193,30 @@ void grpc_chttp2_hptbl_add(grpc_chttp2_hptbl *tbl, grpc_mdelem *md) {
  tbl->ents[tbl->last_ent] = md;

  /* update accounting values */
-  tbl->last_ent = (tbl->last_ent + 1) % GRPC_CHTTP2_MAX_TABLE_COUNT;
+  tbl->last_ent =
+      (gpr_uint16)((tbl->last_ent + 1) % GRPC_CHTTP2_MAX_TABLE_COUNT);
  tbl->num_ents++;
-  tbl->mem_used += elem_bytes;
+  tbl->mem_used = (gpr_uint16)(tbl->mem_used + elem_bytes);
 }

 grpc_chttp2_hptbl_find_result grpc_chttp2_hptbl_find(
    const grpc_chttp2_hptbl *tbl, grpc_mdelem *md) {
  grpc_chttp2_hptbl_find_result r = {0, 0};
-  int i;
+  gpr_uint16 i;

  /* See if the string is in the static table */
  for (i = 0; i < GRPC_CHTTP2_LAST_STATIC_ENTRY; i++) {
    grpc_mdelem *ent = tbl->static_ents[i];
    if (md->key != ent->key) continue;
-    r.index = i + 1;
+    r.index = (gpr_uint16)(i + 1);
    r.has_value = md->value == ent->value;
    if (r.has_value) return r;
  }

  /* Scan the dynamic table */
  for (i = 0; i < tbl->num_ents; i++) {
-    int idx = tbl->num_ents - i + GRPC_CHTTP2_LAST_STATIC_ENTRY;
+    gpr_uint16 idx =
+        (gpr_uint16)(tbl->num_ents - i + GRPC_CHTTP2_LAST_STATIC_ENTRY);
    grpc_mdelem *ent =
        tbl->ents[(tbl->first_ent + i) % GRPC_CHTTP2_MAX_TABLE_COUNT];
    if (md->key != ent->key) continue;
--- a/src/core/transport/chttp2/incoming_metadata.c
+++ b/src/core/transport/chttp2/incoming_metadata.c
@ -122,7 +122,7 @@ void grpc_incoming_metadata_buffer_move_to_referencing_sopb(
  for (i = 0; i < sopb->nops; i++) {
    if (sopb->ops[i].type != GRPC_OP_METADATA) continue;
    sopb->ops[i].data.metadata.list.tail =
-        (void *)(delta + (gpr_intptr)sopb->ops[i].data.metadata.list.tail);
+        (void *)(delta + (gpr_uintptr)sopb->ops[i].data.metadata.list.tail);
  }
  src->count = 0;
 }
--- a/src/core/transport/chttp2/internal.h
+++ b/src/core/transport/chttp2/internal.h
@ -168,7 +168,7 @@ typedef struct {
  grpc_iomgr_closure *pending_closures_tail;

  /** window available for us to send to peer */
-  gpr_uint32 outgoing_window;
+  gpr_int64 outgoing_window;
  /** window available for peer to send to us - updated after parse */
  gpr_uint32 incoming_window;
  /** how much window would we like to have for incoming_window */
@ -280,7 +280,7 @@ struct grpc_chttp2_transport_parsing {
  gpr_uint32 goaway_last_stream_index;
  gpr_slice goaway_text;

-  gpr_uint64 outgoing_window_update;
+  gpr_int64 outgoing_window_update;

  /** pings awaiting responses */
  grpc_chttp2_outstanding_ping pings;
@ -609,20 +609,21 @@ extern int grpc_flowctl_trace;
  else                               \
  stmt

-#define GRPC_CHTTP2_FLOWCTL_TRACE_STREAM(reason, transport, context, var,      \
-                                         delta)                                \
-  if (!(grpc_flowctl_trace)) {                                                 \
-  } else {                                                                     \
-    grpc_chttp2_flowctl_trace(__FILE__, __LINE__, reason, #context, #var,      \
-                              transport->is_client, context->id, context->var, \
-                              delta);                                          \
+#define GRPC_CHTTP2_FLOWCTL_TRACE_STREAM(reason, transport, context, var,     \
+                                         delta)                               \
+  if (!(grpc_flowctl_trace)) {                                                \
+  } else {                                                                    \
+    grpc_chttp2_flowctl_trace(__FILE__, __LINE__, reason, #context, #var,     \
+                              transport->is_client, context->id,              \
+                              (gpr_int64)(context->var), (gpr_int64)(delta)); \
  }

-#define GRPC_CHTTP2_FLOWCTL_TRACE_TRANSPORT(reason, context, var, delta)   \
-  if (!(grpc_flowctl_trace)) {                                             \
-  } else {                                                                 \
-    grpc_chttp2_flowctl_trace(__FILE__, __LINE__, reason, #context, #var,  \
-                              context->is_client, 0, context->var, delta); \
+#define GRPC_CHTTP2_FLOWCTL_TRACE_TRANSPORT(reason, context, var, delta)      \
+  if (!(grpc_flowctl_trace)) {                                                \
+  } else {                                                                    \
+    grpc_chttp2_flowctl_trace(__FILE__, __LINE__, reason, #context, #var,     \
+                              context->is_client, 0,                          \
+                              (gpr_int64)(context->var), (gpr_int64)(delta)); \
  }

 void grpc_chttp2_flowctl_trace(const char *file, int line, const char *reason,
--- a/src/core/transport/chttp2/parsing.c
+++ b/src/core/transport/chttp2/parsing.c
@ -131,7 +131,7 @@ void grpc_chttp2_publish_reads(
     published later */
  if (transport_parsing->goaway_received) {
    grpc_chttp2_add_incoming_goaway(transport_global,
-                                    transport_parsing->goaway_error,
+                                    (gpr_uint32)transport_parsing->goaway_error,
                                    transport_parsing->goaway_text);
    transport_parsing->goaway_text = gpr_empty_slice();
    transport_parsing->goaway_received = 0;
@ -194,7 +194,9 @@ void grpc_chttp2_publish_reads(
      GRPC_CHTTP2_FLOWCTL_TRACE_STREAM(
          "parsed", transport_parsing, stream_parsing, outgoing_window_update,
          -(gpr_int64)stream_parsing->outgoing_window_update);
-      stream_global->outgoing_window += stream_parsing->outgoing_window_update;
+      GPR_ASSERT(stream_parsing->outgoing_window_update <= GPR_UINT32_MAX);
+      stream_global->outgoing_window +=
+          (gpr_uint32)stream_parsing->outgoing_window_update;
      stream_parsing->outgoing_window_update = 0;
      is_zero = stream_global->outgoing_window <= 0;
      if (was_zero && !is_zero) {
@ -211,7 +213,7 @@ void grpc_chttp2_publish_reads(
    if (stream_parsing->saw_rst_stream) {
      stream_global->cancelled = 1;
      stream_global->cancelled_status = grpc_chttp2_http2_error_to_grpc_status(
-          stream_parsing->rst_stream_reason);
+          (grpc_chttp2_error_code)stream_parsing->rst_stream_reason);
      if (stream_parsing->rst_stream_reason == GRPC_CHTTP2_NO_ERROR) {
        stream_global->published_cancelled = 1;
      }
@ -379,9 +381,10 @@ int grpc_chttp2_perform_read(grpc_chttp2_transport_parsing *transport_parsing,
    case GRPC_DTS_FRAME:
      GPR_ASSERT(cur < end);
      if ((gpr_uint32)(end - cur) == transport_parsing->incoming_frame_size) {
-        if (!parse_frame_slice(
-                transport_parsing,
-                gpr_slice_sub_no_ref(slice, cur - beg, end - beg), 1)) {
+        if (!parse_frame_slice(transport_parsing,
+                               gpr_slice_sub_no_ref(slice, (size_t)(cur - beg),
+                                                    (size_t)(end - beg)),
+                               1)) {
          return 0;
        }
        transport_parsing->deframe_state = GRPC_DTS_FH_0;
@ -389,11 +392,12 @@ int grpc_chttp2_perform_read(grpc_chttp2_transport_parsing *transport_parsing,
        return 1;
      } else if ((gpr_uint32)(end - cur) >
                 transport_parsing->incoming_frame_size) {
+        size_t cur_offset = (size_t)(cur - beg);
        if (!parse_frame_slice(
                transport_parsing,
                gpr_slice_sub_no_ref(
-                    slice, cur - beg,
-                    cur + transport_parsing->incoming_frame_size - beg),
+                    slice, cur_offset,
+                    cur_offset + transport_parsing->incoming_frame_size),
                1)) {
          return 0;
        }
@ -401,12 +405,13 @@ int grpc_chttp2_perform_read(grpc_chttp2_transport_parsing *transport_parsing,
        transport_parsing->incoming_stream = NULL;
        goto dts_fh_0; /* loop */
      } else {
-        if (!parse_frame_slice(
-                transport_parsing,
-                gpr_slice_sub_no_ref(slice, cur - beg, end - beg), 0)) {
+        if (!parse_frame_slice(transport_parsing,
+                               gpr_slice_sub_no_ref(slice, (size_t)(cur - beg),
+                                                    (size_t)(end - beg)),
+                               0)) {
          return 0;
        }
-        transport_parsing->incoming_frame_size -= (end - cur);
+        transport_parsing->incoming_frame_size -= (gpr_uint32)(end - cur);
        return 1;
      }
      gpr_log(GPR_ERROR, "should never reach here");
@ -474,7 +479,7 @@ static void skip_header(void *tp, grpc_mdelem *md) { GRPC_MDELEM_UNREF(md); }
 static int init_skip_frame_parser(
    grpc_chttp2_transport_parsing *transport_parsing, int is_header) {
  if (is_header) {
-    int is_eoh = transport_parsing->expect_continuation_stream_id != 0;
+    gpr_uint8 is_eoh = transport_parsing->expect_continuation_stream_id != 0;
    transport_parsing->parser = grpc_chttp2_header_parser_parse;
    transport_parsing->parser_data = &transport_parsing->hpack_parser;
    transport_parsing->hpack_parser.on_header = skip_header;
@ -617,8 +622,8 @@ static void on_header(void *tp, grpc_mdelem *md) {

 static int init_header_frame_parser(
    grpc_chttp2_transport_parsing *transport_parsing, int is_continuation) {
-  int is_eoh = (transport_parsing->incoming_frame_flags &
-                GRPC_CHTTP2_DATA_FLAG_END_HEADERS) != 0;
+  gpr_uint8 is_eoh = (transport_parsing->incoming_frame_flags &
+                      GRPC_CHTTP2_DATA_FLAG_END_HEADERS) != 0;
  int via_accept = 0;
  grpc_chttp2_stream_parsing *stream_parsing;

--- a/src/core/transport/chttp2/stream_encoder.c
+++ b/src/core/transport/chttp2/stream_encoder.c
@ -74,17 +74,18 @@ typedef struct {
 } framer_state;

 /* fills p (which is expected to be 9 bytes long) with a data frame header */
-static void fill_header(gpr_uint8 *p, gpr_uint8 type, gpr_uint32 id,
-                        gpr_uint32 len, gpr_uint8 flags) {
-  *p++ = len >> 16;
-  *p++ = len >> 8;
-  *p++ = len;
+static void fill_header(gpr_uint8 *p, gpr_uint8 type, gpr_uint32 id, size_t len,
+                        gpr_uint8 flags) {
+  GPR_ASSERT(len < 16777316);
+  *p++ = (gpr_uint8)(len >> 16);
+  *p++ = (gpr_uint8)(len >> 8);
+  *p++ = (gpr_uint8)(len);
  *p++ = type;
  *p++ = flags;
-  *p++ = id >> 24;
-  *p++ = id >> 16;
-  *p++ = id >> 8;
-  *p++ = id;
+  *p++ = (gpr_uint8)(id >> 24);
+  *p++ = (gpr_uint8)(id >> 16);
+  *p++ = (gpr_uint8)(id >> 8);
+  *p++ = (gpr_uint8)(id);
 }

 /* finish a frame - fill in the previously reserved header */
@ -105,11 +106,12 @@ static void finish_frame(framer_state *st, int is_header_boundary,
    case NONE:
      return;
  }
-  fill_header(GPR_SLICE_START_PTR(st->output->slices[st->header_idx]), type,
-              st->stream_id,
-              st->output->length - st->output_length_at_start_of_frame,
-              (is_last_in_stream ? GRPC_CHTTP2_DATA_FLAG_END_STREAM : 0) |
-                  (is_header_boundary ? GRPC_CHTTP2_DATA_FLAG_END_HEADERS : 0));
+  fill_header(
+      GPR_SLICE_START_PTR(st->output->slices[st->header_idx]), type,
+      st->stream_id, st->output->length - st->output_length_at_start_of_frame,
+      (gpr_uint8)(
+          (is_last_in_stream ? GRPC_CHTTP2_DATA_FLAG_END_STREAM : 0) |
+          (is_header_boundary ? GRPC_CHTTP2_DATA_FLAG_END_HEADERS : 0)));
  st->cur_frame_type = NONE;
 }

@ -134,7 +136,7 @@ static void begin_new_frame(framer_state *st, frame_type type) {
   space to add at least about_to_add bytes -- finishes the current frame if
   needed */
 static void ensure_frame_type(framer_state *st, frame_type type,
-                              int need_bytes) {
+                              size_t need_bytes) {
  if (st->cur_frame_type == type &&
      st->output->length - st->output_length_at_start_of_frame + need_bytes <=
          GRPC_CHTTP2_MAX_PAYLOAD_LENGTH) {
@ -174,7 +176,7 @@ static void add_header_data(framer_state *st, gpr_slice slice) {
  }
 }

-static gpr_uint8 *add_tiny_header_data(framer_state *st, int len) {
+static gpr_uint8 *add_tiny_header_data(framer_state *st, size_t len) {
  ensure_frame_type(st, HEADER, len);
  return gpr_slice_buffer_tiny_add(st->output, len);
 }
@ -185,10 +187,12 @@ static grpc_mdelem *add_elem(grpc_chttp2_hpack_compressor *c,
  gpr_uint32 key_hash = elem->key->hash;
  gpr_uint32 elem_hash = GRPC_MDSTR_KV_HASH(key_hash, elem->value->hash);
  gpr_uint32 new_index = c->tail_remote_index + c->table_elems + 1;
-  gpr_uint32 elem_size = 32 + GPR_SLICE_LENGTH(elem->key->slice) +
-                         GPR_SLICE_LENGTH(elem->value->slice);
+  size_t elem_size = 32 + GPR_SLICE_LENGTH(elem->key->slice) +
+                     GPR_SLICE_LENGTH(elem->value->slice);
  grpc_mdelem *elem_to_unref;

+  GPR_ASSERT(elem_size < 65536);
+
  /* Reserve space for this element in the remote table: if this overflows
     the current table, drop elements until it fits, matching the decompressor
     algorithm */
@ -200,14 +204,16 @@ static grpc_mdelem *add_elem(grpc_chttp2_hpack_compressor *c,
               c->table_elem_size[c->tail_remote_index %
                                  GRPC_CHTTP2_HPACKC_MAX_TABLE_ELEMS]);
    GPR_ASSERT(c->table_elems > 0);
-    c->table_size -= c->table_elem_size[c->tail_remote_index %
-                                        GRPC_CHTTP2_HPACKC_MAX_TABLE_ELEMS];
+    c->table_size =
+        (gpr_uint16)(c->table_size -
+                     c->table_elem_size[c->tail_remote_index %
+                                        GRPC_CHTTP2_HPACKC_MAX_TABLE_ELEMS]);
    c->table_elems--;
  }
  GPR_ASSERT(c->table_elems < GRPC_CHTTP2_HPACKC_MAX_TABLE_ELEMS);
  c->table_elem_size[new_index % GRPC_CHTTP2_HPACKC_MAX_TABLE_ELEMS] =
-      elem_size;
-  c->table_size += elem_size;
+      (gpr_uint16)elem_size;
+  c->table_size = (gpr_uint16)(c->table_size + elem_size);
  c->table_elems++;

  /* Store this element into {entries,indices}_elem */
@ -270,7 +276,7 @@ static grpc_mdelem *add_elem(grpc_chttp2_hpack_compressor *c,

 static void emit_indexed(grpc_chttp2_hpack_compressor *c, gpr_uint32 index,
                         framer_state *st) {
-  int len = GRPC_CHTTP2_VARINT_LENGTH(index, 1);
+  gpr_uint32 len = GRPC_CHTTP2_VARINT_LENGTH(index, 1);
  GRPC_CHTTP2_WRITE_VARINT(index, 1, 0x80, add_tiny_header_data(st, len), len);
 }

@ -288,14 +294,16 @@ static gpr_slice get_wire_value(grpc_mdelem *elem, gpr_uint8 *huffman_prefix) {
 static void emit_lithdr_incidx(grpc_chttp2_hpack_compressor *c,
                               gpr_uint32 key_index, grpc_mdelem *elem,
                               framer_state *st) {
-  int len_pfx = GRPC_CHTTP2_VARINT_LENGTH(key_index, 2);
+  gpr_uint32 len_pfx = GRPC_CHTTP2_VARINT_LENGTH(key_index, 2);
  gpr_uint8 huffman_prefix;
  gpr_slice value_slice = get_wire_value(elem, &huffman_prefix);
-  int len_val = GPR_SLICE_LENGTH(value_slice);
-  int len_val_len = GRPC_CHTTP2_VARINT_LENGTH(len_val, 1);
+  size_t len_val = GPR_SLICE_LENGTH(value_slice);
+  gpr_uint32 len_val_len;
+  GPR_ASSERT(len_val <= GPR_UINT32_MAX);
+  len_val_len = GRPC_CHTTP2_VARINT_LENGTH((gpr_uint32)len_val, 1);
  GRPC_CHTTP2_WRITE_VARINT(key_index, 2, 0x40,
                           add_tiny_header_data(st, len_pfx), len_pfx);
-  GRPC_CHTTP2_WRITE_VARINT(len_val, 1, 0x00,
+  GRPC_CHTTP2_WRITE_VARINT((gpr_uint32)len_val, 1, 0x00,
                           add_tiny_header_data(st, len_val_len), len_val_len);
  add_header_data(st, gpr_slice_ref(value_slice));
 }
@ -303,26 +311,30 @@ static void emit_lithdr_incidx(grpc_chttp2_hpack_compressor *c,
 static void emit_lithdr_noidx(grpc_chttp2_hpack_compressor *c,
                              gpr_uint32 key_index, grpc_mdelem *elem,
                              framer_state *st) {
-  int len_pfx = GRPC_CHTTP2_VARINT_LENGTH(key_index, 4);
+  gpr_uint32 len_pfx = GRPC_CHTTP2_VARINT_LENGTH(key_index, 4);
  gpr_uint8 huffman_prefix;
  gpr_slice value_slice = get_wire_value(elem, &huffman_prefix);
-  int len_val = GPR_SLICE_LENGTH(value_slice);
-  int len_val_len = GRPC_CHTTP2_VARINT_LENGTH(len_val, 1);
+  size_t len_val = GPR_SLICE_LENGTH(value_slice);
+  gpr_uint32 len_val_len;
+  GPR_ASSERT(len_val <= GPR_UINT32_MAX);
+  len_val_len = GRPC_CHTTP2_VARINT_LENGTH((gpr_uint32)len_val, 1);
  GRPC_CHTTP2_WRITE_VARINT(key_index, 4, 0x00,
                           add_tiny_header_data(st, len_pfx), len_pfx);
-  GRPC_CHTTP2_WRITE_VARINT(len_val, 1, 0x00,
+  GRPC_CHTTP2_WRITE_VARINT((gpr_uint32)len_val, 1, 0x00,
                           add_tiny_header_data(st, len_val_len), len_val_len);
  add_header_data(st, gpr_slice_ref(value_slice));
 }

 static void emit_lithdr_incidx_v(grpc_chttp2_hpack_compressor *c,
                                 grpc_mdelem *elem, framer_state *st) {
-  int len_key = GPR_SLICE_LENGTH(elem->key->slice);
+  gpr_uint32 len_key = (gpr_uint32)GPR_SLICE_LENGTH(elem->key->slice);
  gpr_uint8 huffman_prefix;
  gpr_slice value_slice = get_wire_value(elem, &huffman_prefix);
-  int len_val = GPR_SLICE_LENGTH(value_slice);
-  int len_key_len = GRPC_CHTTP2_VARINT_LENGTH(len_key, 1);
-  int len_val_len = GRPC_CHTTP2_VARINT_LENGTH(len_val, 1);
+  gpr_uint32 len_val = (gpr_uint32)GPR_SLICE_LENGTH(value_slice);
+  gpr_uint32 len_key_len = GRPC_CHTTP2_VARINT_LENGTH(len_key, 1);
+  gpr_uint32 len_val_len = GRPC_CHTTP2_VARINT_LENGTH(len_val, 1);
+  GPR_ASSERT(len_key <= GPR_UINT32_MAX);
+  GPR_ASSERT(GPR_SLICE_LENGTH(value_slice) <= GPR_UINT32_MAX);
  *add_tiny_header_data(st, 1) = 0x40;
  GRPC_CHTTP2_WRITE_VARINT(len_key, 1, 0x00,
                           add_tiny_header_data(st, len_key_len), len_key_len);
@ -334,12 +346,14 @@ static void emit_lithdr_incidx_v(grpc_chttp2_hpack_compressor *c,

 static void emit_lithdr_noidx_v(grpc_chttp2_hpack_compressor *c,
                                grpc_mdelem *elem, framer_state *st) {
-  int len_key = GPR_SLICE_LENGTH(elem->key->slice);
+  gpr_uint32 len_key = (gpr_uint32)GPR_SLICE_LENGTH(elem->key->slice);
  gpr_uint8 huffman_prefix;
  gpr_slice value_slice = get_wire_value(elem, &huffman_prefix);
-  int len_val = GPR_SLICE_LENGTH(value_slice);
-  int len_key_len = GRPC_CHTTP2_VARINT_LENGTH(len_key, 1);
-  int len_val_len = GRPC_CHTTP2_VARINT_LENGTH(len_val, 1);
+  gpr_uint32 len_val = (gpr_uint32)GPR_SLICE_LENGTH(value_slice);
+  gpr_uint32 len_key_len = GRPC_CHTTP2_VARINT_LENGTH(len_key, 1);
+  gpr_uint32 len_val_len = GRPC_CHTTP2_VARINT_LENGTH(len_val, 1);
+  GPR_ASSERT(len_key <= GPR_UINT32_MAX);
+  GPR_ASSERT(GPR_SLICE_LENGTH(value_slice) <= GPR_UINT32_MAX);
  *add_tiny_header_data(st, 1) = 0x00;
  GRPC_CHTTP2_WRITE_VARINT(len_key, 1, 0x00,
                           add_tiny_header_data(st, len_key_len), len_key_len);
@ -488,7 +502,7 @@ gpr_uint32 grpc_chttp2_preencode(grpc_stream_op *inops, size_t *inops_count,
  gpr_uint32 flow_controlled_bytes_taken = 0;
  gpr_uint32 curop = 0;
  gpr_uint8 *p;
-  int compressed_flag_set = 0;
+  gpr_uint8 compressed_flag_set = 0;

  while (curop < *inops_count) {
    GPR_ASSERT(flow_controlled_bytes_taken <= max_flow_controlled_bytes);
@ -514,10 +528,10 @@ gpr_uint32 grpc_chttp2_preencode(grpc_stream_op *inops, size_t *inops_count,

        p = GPR_SLICE_START_PTR(slice);
        p[0] = compressed_flag_set;
-        p[1] = op->data.begin_message.length >> 24;
-        p[2] = op->data.begin_message.length >> 16;
-        p[3] = op->data.begin_message.length >> 8;
-        p[4] = op->data.begin_message.length;
+        p[1] = (gpr_uint8)(op->data.begin_message.length >> 24);
+        p[2] = (gpr_uint8)(op->data.begin_message.length >> 16);
+        p[3] = (gpr_uint8)(op->data.begin_message.length >> 8);
+        p[4] = (gpr_uint8)(op->data.begin_message.length);
        op->type = GRPC_OP_SLICE;
        op->data.slice = slice;
      /* fallthrough */
@ -541,7 +555,7 @@ gpr_uint32 grpc_chttp2_preencode(grpc_stream_op *inops, size_t *inops_count,
          grpc_sopb_append(outops, op, 1);
          curop++;
        }
-        flow_controlled_bytes_taken += GPR_SLICE_LENGTH(slice);
+        flow_controlled_bytes_taken += (gpr_uint32)GPR_SLICE_LENGTH(slice);
        break;
    }
  }
@ -565,7 +579,7 @@ void grpc_chttp2_encode(grpc_stream_op *ops, size_t ops_count, int eof,
  framer_state st;
  gpr_slice slice;
  grpc_stream_op *op;
-  gpr_uint32 max_take_size;
+  size_t max_take_size;
  gpr_uint32 curop = 0;
  gpr_uint32 unref_op;
  grpc_mdctx *mdctx = compressor->mdctx;
--- a/src/core/transport/chttp2/timeout_encoding.c
+++ b/src/core/transport/chttp2/timeout_encoding.c
@ -123,7 +123,7 @@ void grpc_chttp2_encode_timeout(gpr_timespec timeout, char *buffer) {
    enc_nanos(buffer, timeout.tv_nsec);
  } else if (timeout.tv_sec < 1000 && timeout.tv_nsec != 0) {
    enc_micros(buffer,
-               timeout.tv_sec * 1000000 +
+               (int)(timeout.tv_sec * 1000000) +
                   (timeout.tv_nsec / 1000 + (timeout.tv_nsec % 1000 != 0)));
  } else {
    enc_seconds(buffer, timeout.tv_sec + (timeout.tv_nsec != 0));
@ -137,14 +137,14 @@ static int is_all_whitespace(const char *p) {

 int grpc_chttp2_decode_timeout(const char *buffer, gpr_timespec *timeout) {
  gpr_uint32 x = 0;
-  const char *p = buffer;
+  const gpr_uint8 *p = (const gpr_uint8 *)buffer;
  int have_digit = 0;
  /* skip whitespace */
  for (; *p == ' '; p++)
    ;
  /* decode numeric part */
  for (; *p >= '0' && *p <= '9'; p++) {
-    gpr_uint32 xp = x * 10 + *p - '0';
+    gpr_uint32 xp = x * 10u + (gpr_uint32)*p - (gpr_uint32)'0';
    have_digit = 1;
    if (xp < x) {
      *timeout = gpr_inf_future(GPR_CLOCK_REALTIME);
@ -180,5 +180,5 @@ int grpc_chttp2_decode_timeout(const char *buffer, gpr_timespec *timeout) {
      return 0;
  }
  p++;
-  return is_all_whitespace(p);
+  return is_all_whitespace((const char *)p);
 }
--- a/src/core/transport/chttp2/varint.c
+++ b/src/core/transport/chttp2/varint.c
@ -33,7 +33,7 @@

 #include "src/core/transport/chttp2/varint.h"

-int grpc_chttp2_hpack_varint_length(gpr_uint32 tail_value) {
+gpr_uint32 grpc_chttp2_hpack_varint_length(gpr_uint32 tail_value) {
  if (tail_value < (1 << 7)) {
    return 2;
  } else if (tail_value < (1 << 14)) {
@ -48,7 +48,8 @@ int grpc_chttp2_hpack_varint_length(gpr_uint32 tail_value) {
 }

 void grpc_chttp2_hpack_write_varint_tail(gpr_uint32 tail_value,
-                                         gpr_uint8* target, int tail_length) {
+                                         gpr_uint8* target,
+                                         gpr_uint32 tail_length) {
  switch (tail_length) {
    case 5:
      target[4] = (gpr_uint8)((tail_value >> 28) | 0x80);
--- a/src/core/transport/chttp2/varint.h
+++ b/src/core/transport/chttp2/varint.h
@ -41,10 +41,11 @@
 /* length of a value that needs varint tail encoding (it's bigger than can be
   bitpacked into the opcode byte) - returned value includes the length of the
   opcode byte */
-int grpc_chttp2_hpack_varint_length(gpr_uint32 tail_value);
+gpr_uint32 grpc_chttp2_hpack_varint_length(gpr_uint32 tail_value);

 void grpc_chttp2_hpack_write_varint_tail(gpr_uint32 tail_value,
-                                         gpr_uint8* target, int tail_length);
+                                         gpr_uint8* target,
+                                         gpr_uint32 tail_length);

 /* maximum value that can be bitpacked with the opcode if the opcode has a
   prefix
@ -54,15 +55,15 @@ void grpc_chttp2_hpack_write_varint_tail(gpr_uint32 tail_value,
 /* length required to bitpack a value */
 #define GRPC_CHTTP2_VARINT_LENGTH(n, prefix_bits) \
  ((n) < GRPC_CHTTP2_MAX_IN_PREFIX(prefix_bits)   \
-       ? 1                                        \
+       ? 1u                                       \
       : grpc_chttp2_hpack_varint_length(         \
             (n)-GRPC_CHTTP2_MAX_IN_PREFIX(prefix_bits)))

 #define GRPC_CHTTP2_WRITE_VARINT(n, prefix_bits, prefix_or, target, length)   \
  do {                                                                        \
    gpr_uint8* tgt = target;                                                  \
-    if ((length) == 1) {                                                      \
-      (tgt)[0] = (prefix_or) | (n);                                           \
+    if ((length) == 1u) {                                                     \
+      (tgt)[0] = (gpr_uint8)((prefix_or) | (n));                              \
    } else {                                                                  \
      (tgt)[0] = (prefix_or) | GRPC_CHTTP2_MAX_IN_PREFIX(prefix_bits);        \
      grpc_chttp2_hpack_write_varint_tail(                                    \
--- a/src/core/transport/chttp2/writing.c
+++ b/src/core/transport/chttp2/writing.c
@ -32,10 +32,13 @@
 */

 #include "src/core/transport/chttp2/internal.h"
-#include "src/core/transport/chttp2/http2_errors.h"
+
+#include <limits.h>

 #include <grpc/support/log.h>

+#include "src/core/transport/chttp2/http2_errors.h"
+
 static void finalize_outbuf(grpc_chttp2_transport_writing *transport_writing);

 int grpc_chttp2_unlocking_check_writes(
@ -78,12 +81,13 @@ int grpc_chttp2_unlocking_check_writes(
    stream_writing->send_closed = GRPC_DONT_SEND_CLOSED;

    if (stream_global->outgoing_sopb) {
-      window_delta =
-          grpc_chttp2_preencode(stream_global->outgoing_sopb->ops,
-                                &stream_global->outgoing_sopb->nops,
-                                GPR_MIN(transport_global->outgoing_window,
-                                        stream_global->outgoing_window),
-                                &stream_writing->sopb);
+      window_delta = grpc_chttp2_preencode(
+          stream_global->outgoing_sopb->ops,
+          &stream_global->outgoing_sopb->nops,
+          (gpr_uint32)GPR_MIN(GPR_MIN(transport_global->outgoing_window,
+                                      stream_global->outgoing_window),
+                              GPR_UINT32_MAX),
+          &stream_writing->sopb);
      GRPC_CHTTP2_FLOWCTL_TRACE_TRANSPORT(
          "write", transport_global, outgoing_window, -(gpr_int64)window_delta);
      GRPC_CHTTP2_FLOWCTL_TRACE_STREAM("write", transport_global, stream_global,
--- a/src/core/transport/chttp2_transport.c
+++ b/src/core/transport/chttp2_transport.c
@ -209,7 +209,7 @@ static void ref_transport(grpc_chttp2_transport *t) { gpr_ref(&t->refs); }
 static void init_transport(grpc_chttp2_transport *t,
                           const grpc_channel_args *channel_args,
                           grpc_endpoint *ep, grpc_mdctx *mdctx,
-                           int is_client) {
+                           gpr_uint8 is_client) {
  size_t i;
  int j;

@ -306,7 +306,7 @@ static void init_transport(grpc_chttp2_transport *t,
                  GRPC_ARG_MAX_CONCURRENT_STREAMS);
        } else {
          push_setting(t, GRPC_CHTTP2_SETTINGS_MAX_CONCURRENT_STREAMS,
-                       channel_args->args[i].value.integer);
+                       (gpr_uint32)channel_args->args[i].value.integer);
        }
      } else if (0 == strcmp(channel_args->args[i].key,
                             GRPC_ARG_HTTP2_INITIAL_SEQUENCE_NUMBER)) {
@ -320,7 +320,8 @@ static void init_transport(grpc_chttp2_transport *t,
                  t->global.next_stream_id & 1,
                  is_client ? "client" : "server");
        } else {
-          t->global.next_stream_id = channel_args->args[i].value.integer;
+          t->global.next_stream_id =
+              (gpr_uint32)channel_args->args[i].value.integer;
        }
      }
    }
@ -682,6 +683,8 @@ static void perform_stream_op_locked(
    stream_global->publish_sopb = op->recv_ops;
    stream_global->publish_sopb->nops = 0;
    stream_global->publish_state = op->recv_state;
+    /* clamp max recv bytes */
+    op->max_recv_bytes = GPR_MIN(op->max_recv_bytes, GPR_UINT32_MAX);
    if (stream_global->max_recv_bytes < op->max_recv_bytes) {
      GRPC_CHTTP2_FLOWCTL_TRACE_STREAM(
          "op", transport_global, stream_global, max_recv_bytes,
@ -690,8 +693,8 @@ static void perform_stream_op_locked(
          "op", transport_global, stream_global, unannounced_incoming_window,
          op->max_recv_bytes - stream_global->max_recv_bytes);
      stream_global->unannounced_incoming_window +=
-          op->max_recv_bytes - stream_global->max_recv_bytes;
-      stream_global->max_recv_bytes = op->max_recv_bytes;
+          (gpr_uint32)op->max_recv_bytes - stream_global->max_recv_bytes;
+      stream_global->max_recv_bytes = (gpr_uint32)op->max_recv_bytes;
    }
    grpc_chttp2_incoming_metadata_live_op_buffer_end(
        &stream_global->outstanding_metadata);
@ -728,14 +731,14 @@ static void send_ping_locked(grpc_chttp2_transport *t,
  p->next = &t->global.pings;
  p->prev = p->next->prev;
  p->prev->next = p->next->prev = p;
-  p->id[0] = (t->global.ping_counter >> 56) & 0xff;
-  p->id[1] = (t->global.ping_counter >> 48) & 0xff;
-  p->id[2] = (t->global.ping_counter >> 40) & 0xff;
-  p->id[3] = (t->global.ping_counter >> 32) & 0xff;
-  p->id[4] = (t->global.ping_counter >> 24) & 0xff;
-  p->id[5] = (t->global.ping_counter >> 16) & 0xff;
-  p->id[6] = (t->global.ping_counter >> 8) & 0xff;
-  p->id[7] = t->global.ping_counter & 0xff;
+  p->id[0] = (gpr_uint8)((t->global.ping_counter >> 56) & 0xff);
+  p->id[1] = (gpr_uint8)((t->global.ping_counter >> 48) & 0xff);
+  p->id[2] = (gpr_uint8)((t->global.ping_counter >> 40) & 0xff);
+  p->id[3] = (gpr_uint8)((t->global.ping_counter >> 32) & 0xff);
+  p->id[4] = (gpr_uint8)((t->global.ping_counter >> 24) & 0xff);
+  p->id[5] = (gpr_uint8)((t->global.ping_counter >> 16) & 0xff);
+  p->id[6] = (gpr_uint8)((t->global.ping_counter >> 8) & 0xff);
+  p->id[7] = (gpr_uint8)(t->global.ping_counter & 0xff);
  p->on_recv = on_recv;
  gpr_slice_buffer_add(&t->global.qbuf, grpc_chttp2_ping_create(0, p->id));
 }
@ -760,7 +763,7 @@ static void perform_transport_op(grpc_transport *gt, grpc_transport_op *op) {
    t->global.sent_goaway = 1;
    grpc_chttp2_goaway_append(
        t->global.last_incoming_stream_id,
-        grpc_chttp2_grpc_status_to_http2_error(op->goaway_status),
+        (gpr_uint32)grpc_chttp2_grpc_status_to_http2_error(op->goaway_status),
        gpr_slice_ref(*op->goaway_message), &t->global.qbuf);
    close_transport = !grpc_chttp2_has_streams(t);
  }
@ -828,8 +831,9 @@ static void remove_stream(grpc_chttp2_transport *t, gpr_uint32 id) {

  new_stream_count = grpc_chttp2_stream_map_size(&t->parsing_stream_map) +
                     grpc_chttp2_stream_map_size(&t->new_stream_map);
+  GPR_ASSERT(new_stream_count <= GPR_UINT32_MAX);
  if (new_stream_count != t->global.concurrent_stream_count) {
-    t->global.concurrent_stream_count = new_stream_count;
+    t->global.concurrent_stream_count = (gpr_uint32)new_stream_count;
    maybe_start_some_streams(&t->global);
  }
 }
@ -942,7 +946,8 @@ static void cancel_from_api(grpc_chttp2_transport_global *transport_global,
    gpr_slice_buffer_add(
        &transport_global->qbuf,
        grpc_chttp2_rst_stream_create(
-            stream_global->id, grpc_chttp2_grpc_status_to_http2_error(status)));
+            stream_global->id,
+            (gpr_uint32)grpc_chttp2_grpc_status_to_http2_error(status)));
  }
  grpc_chttp2_list_add_read_write_state_changed(transport_global,
                                                stream_global);
@ -988,14 +993,14 @@ static void close_from_api(grpc_chttp2_transport_global *transport_global,
  *p++ = 's';
  if (status < 10) {
    *p++ = 1;
-    *p++ = '0' + status;
+    *p++ = (gpr_uint8)('0' + status);
  } else {
    *p++ = 2;
-    *p++ = '0' + (status / 10);
-    *p++ = '0' + (status % 10);
+    *p++ = (gpr_uint8)('0' + (status / 10));
+    *p++ = (gpr_uint8)('0' + (status % 10));
  }
  GPR_ASSERT(p == GPR_SLICE_END_PTR(status_hdr));
-  len += GPR_SLICE_LENGTH(status_hdr);
+  len += (gpr_uint32)GPR_SLICE_LENGTH(status_hdr);

  if (optional_message) {
    GPR_ASSERT(GPR_SLICE_LENGTH(*optional_message) < 127);
@ -1015,23 +1020,23 @@ static void close_from_api(grpc_chttp2_transport_global *transport_global,
    *p++ = 'a';
    *p++ = 'g';
    *p++ = 'e';
-    *p++ = GPR_SLICE_LENGTH(*optional_message);
+    *p++ = (gpr_uint8)GPR_SLICE_LENGTH(*optional_message);
    GPR_ASSERT(p == GPR_SLICE_END_PTR(message_pfx));
-    len += GPR_SLICE_LENGTH(message_pfx);
-    len += GPR_SLICE_LENGTH(*optional_message);
+    len += (gpr_uint32)GPR_SLICE_LENGTH(message_pfx);
+    len += (gpr_uint32)GPR_SLICE_LENGTH(*optional_message);
  }

  hdr = gpr_slice_malloc(9);
  p = GPR_SLICE_START_PTR(hdr);
-  *p++ = len >> 16;
-  *p++ = len >> 8;
-  *p++ = len;
+  *p++ = (gpr_uint8)(len >> 16);
+  *p++ = (gpr_uint8)(len >> 8);
+  *p++ = (gpr_uint8)(len);
  *p++ = GRPC_CHTTP2_FRAME_HEADER;
  *p++ = GRPC_CHTTP2_DATA_FLAG_END_STREAM | GRPC_CHTTP2_DATA_FLAG_END_HEADERS;
-  *p++ = stream_global->id >> 24;
-  *p++ = stream_global->id >> 16;
-  *p++ = stream_global->id >> 8;
-  *p++ = stream_global->id;
+  *p++ = (gpr_uint8)(stream_global->id >> 24);
+  *p++ = (gpr_uint8)(stream_global->id >> 16);
+  *p++ = (gpr_uint8)(stream_global->id >> 8);
+  *p++ = (gpr_uint8)(stream_global->id);
  GPR_ASSERT(p == GPR_SLICE_END_PTR(hdr));

  gpr_slice_buffer_add(&transport_global->qbuf, hdr);
@ -1120,7 +1125,7 @@ static int recv_data_loop(grpc_chttp2_transport *t, int *success) {
    grpc_chttp2_stream_map_move_into(&t->new_stream_map,
                                     &t->parsing_stream_map);
    t->global.concurrent_stream_count =
-        grpc_chttp2_stream_map_size(&t->parsing_stream_map);
+        (gpr_uint32)grpc_chttp2_stream_map_size(&t->parsing_stream_map);
    if (t->parsing.initial_window_update != 0) {
      grpc_chttp2_stream_map_for_each(&t->parsing_stream_map,
                                      update_global_window, t);
@ -1277,7 +1282,7 @@ grpc_transport *grpc_create_chttp2_transport(
    const grpc_channel_args *channel_args, grpc_endpoint *ep, grpc_mdctx *mdctx,
    int is_client) {
  grpc_chttp2_transport *t = gpr_malloc(sizeof(grpc_chttp2_transport));
-  init_transport(t, channel_args, ep, mdctx, is_client);
+  init_transport(t, channel_args, ep, mdctx, is_client != 0);
  return &t->base;
 }

--- a/src/core/transport/metadata.c
+++ b/src/core/transport/metadata.c
@ -186,7 +186,8 @@ grpc_mdctx *grpc_mdctx_create(void) {
  /* This seed is used to prevent remote connections from controlling hash table
   * collisions. It needs to be somewhat unpredictable to a remote connection.
   */
-  return grpc_mdctx_create_with_seed(gpr_now(GPR_CLOCK_REALTIME).tv_nsec);
+  return grpc_mdctx_create_with_seed(
+      (gpr_uint32)gpr_now(GPR_CLOCK_REALTIME).tv_nsec);
 }

 static void discard_metadata(grpc_mdctx *ctx) {
@ -333,7 +334,7 @@ grpc_mdstr *grpc_mdstr_from_string(grpc_mdctx *ctx, const char *str,
      grpc_mdstr *ret;
      for (i = 0; i < len; i++) {
        if (str[i] >= 'A' && str[i] <= 'Z') {
-          copy[i] = str[i] - 'A' + 'a';
+          copy[i] = (char)(str[i] - 'A' + 'a');
        } else {
          copy[i] = str[i];
        }
@ -378,7 +379,7 @@ grpc_mdstr *grpc_mdstr_from_buffer(grpc_mdctx *ctx, const gpr_uint8 *buf,
    s->slice.refcount = NULL;
    memcpy(s->slice.data.inlined.bytes, buf, length);
    s->slice.data.inlined.bytes[length] = 0;
-    s->slice.data.inlined.length = length;
+    s->slice.data.inlined.length = (gpr_uint8)length;
  } else {
    /* string data goes after the internal_string header, and we +1 for null
       terminator */
--- a/src/core/transport/transport.h
+++ b/src/core/transport/transport.h
@ -75,7 +75,7 @@ typedef struct grpc_transport_stream_op {
  /** The number of bytes this peer is currently prepared to receive.
      These bytes will be eventually used to replenish per-stream flow control
      windows. */
-  gpr_uint32 max_recv_bytes;
+  size_t max_recv_bytes;
  grpc_iomgr_closure *on_done_recv;

  grpc_pollset *bind_pollset;
--- a/src/core/tsi/fake_transport_security.c
+++ b/src/core/tsi/fake_transport_security.c
@ -100,7 +100,7 @@ static const char* tsi_fake_handshake_message_to_string(int msg) {

 static tsi_result tsi_fake_handshake_message_from_string(
    const char* msg_string, tsi_fake_handshake_message* msg) {
-  int i;
+  tsi_fake_handshake_message i;
  for (i = 0; i < TSI_FAKE_HANDSHAKE_MESSAGE_MAX; i++) {
    if (strncmp(msg_string, tsi_fake_handshake_message_strings[i],
                strlen(tsi_fake_handshake_message_strings[i])) == 0) {
@ -171,7 +171,7 @@ static tsi_result fill_frame_from_bytes(const unsigned char* incoming_bytes,
      memcpy(frame->data + frame->offset, bytes_cursor, available_size);
      bytes_cursor += available_size;
      frame->offset += available_size;
-      *incoming_bytes_size = bytes_cursor - incoming_bytes;
+      *incoming_bytes_size = (size_t)(bytes_cursor - incoming_bytes);
      return TSI_INCOMPLETE_DATA;
    }
    memcpy(frame->data + frame->offset, bytes_cursor, to_read_size);
@ -187,12 +187,12 @@ static tsi_result fill_frame_from_bytes(const unsigned char* incoming_bytes,
    memcpy(frame->data + frame->offset, bytes_cursor, available_size);
    frame->offset += available_size;
    bytes_cursor += available_size;
-    *incoming_bytes_size = bytes_cursor - incoming_bytes;
+    *incoming_bytes_size = (size_t)(bytes_cursor - incoming_bytes);
    return TSI_INCOMPLETE_DATA;
  }
  memcpy(frame->data + frame->offset, bytes_cursor, to_read_size);
  bytes_cursor += to_read_size;
-  *incoming_bytes_size = bytes_cursor - incoming_bytes;
+  *incoming_bytes_size = (size_t)(bytes_cursor - incoming_bytes);
  tsi_fake_frame_reset(frame, 1 /* needs_draining */);
  return TSI_OK;
 }
@ -219,7 +219,7 @@ static tsi_result bytes_to_frame(unsigned char* bytes, size_t bytes_size,
  frame->offset = 0;
  frame->size = bytes_size + TSI_FAKE_FRAME_HEADER_SIZE;
  if (!tsi_fake_frame_ensure_size(frame)) return TSI_OUT_OF_RESOURCES;
-  store32_little_endian(frame->size, frame->data);
+  store32_little_endian((gpr_uint32)frame->size, frame->data);
  memcpy(frame->data + TSI_FAKE_FRAME_HEADER_SIZE, bytes, bytes_size);
  tsi_fake_frame_reset(frame, 1 /* needs draining */);
  return TSI_OK;
@ -266,7 +266,7 @@ static tsi_result fake_protector_protect(tsi_frame_protector* self,
  if (frame->size == 0) {
    /* New frame, create a header. */
    size_t written_in_frame_size = 0;
-    store32_little_endian(impl->max_frame_size, frame_header);
+    store32_little_endian((gpr_uint32)impl->max_frame_size, frame_header);
    written_in_frame_size = TSI_FAKE_FRAME_HEADER_SIZE;
    result = fill_frame_from_bytes(frame_header, &written_in_frame_size, frame);
    if (result != TSI_INCOMPLETE_DATA) {
@ -303,7 +303,8 @@ static tsi_result fake_protector_protect_flush(
    frame->size = frame->offset;
    frame->offset = 0;
    frame->needs_draining = 1;
-    store32_little_endian(frame->size, frame->data); /* Overwrite header. */
+    store32_little_endian((gpr_uint32)frame->size,
+                          frame->data); /* Overwrite header. */
  }
  result = drain_frame_to_bytes(protected_output_frames,
                                protected_output_frames_size, frame);
@ -384,7 +385,8 @@ static tsi_result fake_handshaker_get_bytes_to_send_to_peer(
    return TSI_OK;
  }
  if (!impl->outgoing.needs_draining) {
-    int next_message_to_send = impl->next_message_to_send + 2;
+    tsi_fake_handshake_message next_message_to_send =
+        impl->next_message_to_send + 2;
    const char* msg_string =
        tsi_fake_handshake_message_to_string(impl->next_message_to_send);
    result = bytes_to_frame((unsigned char*)msg_string, strlen(msg_string),
--- a/src/core/tsi/ssl_transport_security.c
+++ b/src/core/tsi/ssl_transport_security.c
@ -131,10 +131,13 @@ static unsigned long openssl_thread_id_cb(void) {

 static void init_openssl(void) {
  int i;
+  int num_locks;
  SSL_library_init();
  SSL_load_error_strings();
  OpenSSL_add_all_algorithms();
-  openssl_mutexes = malloc(CRYPTO_num_locks() * sizeof(gpr_mu));
+  num_locks = CRYPTO_num_locks();
+  GPR_ASSERT(num_locks > 0);
+  openssl_mutexes = malloc((size_t)num_locks * sizeof(gpr_mu));
  GPR_ASSERT(openssl_mutexes != NULL);
  for (i = 0; i < CRYPTO_num_locks(); i++) {
    gpr_mu_init(&openssl_mutexes[i]);
@ -249,7 +252,7 @@ static tsi_result ssl_get_x509_common_name(X509* cert, unsigned char** utf8,
    gpr_log(GPR_ERROR, "Could not extract utf8 from asn1 string.");
    return TSI_OUT_OF_RESOURCES;
  }
-  *utf8_size = utf8_returned_size;
+  *utf8_size = (size_t)utf8_returned_size;
  return TSI_OK;
 }

@ -279,8 +282,8 @@ static tsi_result peer_property_from_x509_common_name(
 /* Gets the subject SANs from an X509 cert as a tsi_peer_property. */
 static tsi_result add_subject_alt_names_properties_to_peer(
    tsi_peer* peer, GENERAL_NAMES* subject_alt_names,
-    int subject_alt_name_count) {
-  int i;
+    size_t subject_alt_name_count) {
+  size_t i;
  tsi_result result = TSI_OK;

  /* Reset for DNS entries filtering. */
@ -288,7 +291,7 @@ static tsi_result add_subject_alt_names_properties_to_peer(

  for (i = 0; i < subject_alt_name_count; i++) {
    GENERAL_NAME* subject_alt_name =
-        sk_GENERAL_NAME_value(subject_alt_names, i);
+        sk_GENERAL_NAME_value(subject_alt_names, (int)i);
    /* Filter out the non-dns entries names. */
    if (subject_alt_name->type == GEN_DNS) {
      unsigned char* dns_name = NULL;
@ -301,7 +304,7 @@ static tsi_result add_subject_alt_names_properties_to_peer(
      }
      result = tsi_construct_string_peer_property(
          TSI_X509_SUBJECT_ALTERNATIVE_NAME_PEER_PROPERTY,
-          (const char*)dns_name, dns_name_size,
+          (const char*)dns_name, (size_t)dns_name_size,
          &peer->properties[peer->property_count++]);
      OPENSSL_free(dns_name);
      if (result != TSI_OK) break;
@ -318,9 +321,12 @@ static tsi_result peer_from_x509(X509* cert, int include_certificate_type,
      X509_get_ext_d2i(cert, NID_subject_alt_name, 0, 0);
  int subject_alt_name_count =
      (subject_alt_names != NULL) ? sk_GENERAL_NAME_num(subject_alt_names) : 0;
-  size_t property_count = (include_certificate_type ? 1 : 0) +
-                          1 /* common name */ + subject_alt_name_count;
-  tsi_result result = tsi_construct_peer(property_count, peer);
+  size_t property_count;
+  tsi_result result;
+  GPR_ASSERT(subject_alt_name_count >= 0);
+  property_count = (include_certificate_type ? (size_t)1 : 0) +
+                   1 /* common name */ + (size_t)subject_alt_name_count;
+  result = tsi_construct_peer(property_count, peer);
  if (result != TSI_OK) return result;
  do {
    if (include_certificate_type) {
@ -334,8 +340,8 @@ static tsi_result peer_from_x509(X509* cert, int include_certificate_type,
    if (result != TSI_OK) break;

    if (subject_alt_name_count != 0) {
-      result = add_subject_alt_names_properties_to_peer(peer, subject_alt_names,
-                                                        subject_alt_name_count);
+      result = add_subject_alt_names_properties_to_peer(
+          peer, subject_alt_names, (size_t)subject_alt_name_count);
      if (result != TSI_OK) break;
    }
  } while (0);
@ -360,7 +366,10 @@ static void log_ssl_error_stack(void) {
 /* Performs an SSL_read and handle errors. */
 static tsi_result do_ssl_read(SSL* ssl, unsigned char* unprotected_bytes,
                              size_t* unprotected_bytes_size) {
-  int read_from_ssl = SSL_read(ssl, unprotected_bytes, *unprotected_bytes_size);
+  int read_from_ssl;
+  GPR_ASSERT(*unprotected_bytes_size <= INT_MAX);
+  read_from_ssl =
+      SSL_read(ssl, unprotected_bytes, (int)*unprotected_bytes_size);
  if (read_from_ssl == 0) {
    gpr_log(GPR_ERROR, "SSL_read returned 0 unexpectedly.");
    return TSI_INTERNAL_ERROR;
@ -387,15 +396,17 @@ static tsi_result do_ssl_read(SSL* ssl, unsigned char* unprotected_bytes,
        return TSI_PROTOCOL_FAILURE;
    }
  }
-  *unprotected_bytes_size = read_from_ssl;
+  *unprotected_bytes_size = (size_t)read_from_ssl;
  return TSI_OK;
 }

 /* Performs an SSL_write and handle errors. */
 static tsi_result do_ssl_write(SSL* ssl, unsigned char* unprotected_bytes,
                               size_t unprotected_bytes_size) {
-  int ssl_write_result =
-      SSL_write(ssl, unprotected_bytes, unprotected_bytes_size);
+  int ssl_write_result;
+  GPR_ASSERT(unprotected_bytes_size <= INT_MAX);
+  ssl_write_result =
+      SSL_write(ssl, unprotected_bytes, (int)unprotected_bytes_size);
  if (ssl_write_result < 0) {
    ssl_write_result = SSL_get_error(ssl, ssl_write_result);
    if (ssl_write_result == SSL_ERROR_WANT_READ) {
@ -417,7 +428,9 @@ static tsi_result ssl_ctx_use_certificate_chain(
    size_t pem_cert_chain_size) {
  tsi_result result = TSI_OK;
  X509* certificate = NULL;
-  BIO* pem = BIO_new_mem_buf((void*)pem_cert_chain, pem_cert_chain_size);
+  BIO* pem;
+  GPR_ASSERT(pem_cert_chain_size <= INT_MAX);
+  pem = BIO_new_mem_buf((void*)pem_cert_chain, (int)pem_cert_chain_size);
  if (pem == NULL) return TSI_OUT_OF_RESOURCES;

  do {
@ -458,7 +471,9 @@ static tsi_result ssl_ctx_use_private_key(SSL_CTX* context,
                                          size_t pem_key_size) {
  tsi_result result = TSI_OK;
  EVP_PKEY* private_key = NULL;
-  BIO* pem = BIO_new_mem_buf((void*)pem_key, pem_key_size);
+  BIO* pem;
+  GPR_ASSERT(pem_key_size <= INT_MAX);
+  pem = BIO_new_mem_buf((void*)pem_key, (int)pem_key_size);
  if (pem == NULL) return TSI_OUT_OF_RESOURCES;
  do {
    private_key = PEM_read_bio_PrivateKey(pem, NULL, NULL, "");
@ -485,8 +500,11 @@ static tsi_result ssl_ctx_load_verification_certs(
  size_t num_roots = 0;
  X509* root = NULL;
  X509_NAME* root_name = NULL;
-  BIO* pem = BIO_new_mem_buf((void*)pem_roots, pem_roots_size);
-  X509_STORE* root_store = SSL_CTX_get_cert_store(context);
+  BIO* pem;
+  X509_STORE* root_store;
+  GPR_ASSERT(pem_roots_size <= INT_MAX);
+  pem = BIO_new_mem_buf((void*)pem_roots, (int)pem_roots_size);
+  root_store = SSL_CTX_get_cert_store(context);
  if (root_store == NULL) return TSI_INVALID_ARGUMENT;
  if (pem == NULL) return TSI_OUT_OF_RESOURCES;
  if (root_names != NULL) {
@ -586,7 +604,9 @@ static tsi_result extract_x509_subject_names_from_pem_cert(
    const unsigned char* pem_cert, size_t pem_cert_size, tsi_peer* peer) {
  tsi_result result = TSI_OK;
  X509* cert = NULL;
-  BIO* pem = BIO_new_mem_buf((void*)pem_cert, pem_cert_size);
+  BIO* pem;
+  GPR_ASSERT(pem_cert_size <= INT_MAX);
+  pem = BIO_new_mem_buf((void*)pem_cert, (int)pem_cert_size);
  if (pem == NULL) return TSI_OUT_OF_RESOURCES;

  cert = PEM_read_bio_X509(pem, NULL, NULL, "");
@ -616,7 +636,7 @@ static tsi_result build_alpn_protocol_name_list(
      gpr_log(GPR_ERROR, "Invalid 0-length protocol name.");
      return TSI_INVALID_ARGUMENT;
    }
-    *protocol_name_list_length += alpn_protocols_lengths[i] + 1;
+    *protocol_name_list_length += (size_t)alpn_protocols_lengths[i] + 1;
  }
  *protocol_name_list = malloc(*protocol_name_list_length);
  if (*protocol_name_list == NULL) return TSI_OUT_OF_RESOURCES;
@ -648,17 +668,18 @@ static tsi_result ssl_protector_protect(tsi_frame_protector* self,
  tsi_result result = TSI_OK;

  /* First see if we have some pending data in the SSL BIO. */
-  size_t pending_in_ssl = BIO_pending(impl->from_ssl);
+  int pending_in_ssl = BIO_pending(impl->from_ssl);
  if (pending_in_ssl > 0) {
    *unprotected_bytes_size = 0;
+    GPR_ASSERT(*protected_output_frames_size <= INT_MAX);
    read_from_ssl = BIO_read(impl->from_ssl, protected_output_frames,
-                             *protected_output_frames_size);
+                             (int)*protected_output_frames_size);
    if (read_from_ssl < 0) {
      gpr_log(GPR_ERROR,
              "Could not read from BIO even though some data is pending");
      return TSI_INTERNAL_ERROR;
    }
-    *protected_output_frames_size = read_from_ssl;
+    *protected_output_frames_size = (size_t)read_from_ssl;
    return TSI_OK;
  }

@ -678,13 +699,14 @@ static tsi_result ssl_protector_protect(tsi_frame_protector* self,
  result = do_ssl_write(impl->ssl, impl->buffer, impl->buffer_size);
  if (result != TSI_OK) return result;

+  GPR_ASSERT(*protected_output_frames_size <= INT_MAX);
  read_from_ssl = BIO_read(impl->from_ssl, protected_output_frames,
-                           *protected_output_frames_size);
+                           (int)*protected_output_frames_size);
  if (read_from_ssl < 0) {
    gpr_log(GPR_ERROR, "Could not read from BIO after SSL_write.");
    return TSI_INTERNAL_ERROR;
  }
-  *protected_output_frames_size = read_from_ssl;
+  *protected_output_frames_size = (size_t)read_from_ssl;
  *unprotected_bytes_size = available;
  impl->buffer_offset = 0;
  return TSI_OK;
@ -696,6 +718,7 @@ static tsi_result ssl_protector_protect_flush(
  tsi_result result = TSI_OK;
  tsi_ssl_frame_protector* impl = (tsi_ssl_frame_protector*)self;
  int read_from_ssl = 0;
+  int pending;

  if (impl->buffer_offset != 0) {
    result = do_ssl_write(impl->ssl, impl->buffer, impl->buffer_offset);
@ -703,17 +726,22 @@ static tsi_result ssl_protector_protect_flush(
    impl->buffer_offset = 0;
  }

-  *still_pending_size = BIO_pending(impl->from_ssl);
+  pending = BIO_pending(impl->from_ssl);
+  GPR_ASSERT(pending >= 0);
+  *still_pending_size = (size_t)pending;
  if (*still_pending_size == 0) return TSI_OK;

+  GPR_ASSERT(*protected_output_frames_size <= INT_MAX);
  read_from_ssl = BIO_read(impl->from_ssl, protected_output_frames,
-                           *protected_output_frames_size);
+                           (int)*protected_output_frames_size);
  if (read_from_ssl <= 0) {
    gpr_log(GPR_ERROR, "Could not read from BIO after SSL_write.");
    return TSI_INTERNAL_ERROR;
  }
-  *protected_output_frames_size = read_from_ssl;
-  *still_pending_size = BIO_pending(impl->from_ssl);
+  *protected_output_frames_size = (size_t)read_from_ssl;
+  pending = BIO_pending(impl->from_ssl);
+  GPR_ASSERT(pending >= 0);
+  *still_pending_size = (size_t)pending;
  return TSI_OK;
 }

@ -740,14 +768,15 @@ static tsi_result ssl_protector_unprotect(
  *unprotected_bytes_size = output_bytes_size - output_bytes_offset;

  /* Then, try to write some data to ssl. */
+  GPR_ASSERT(*protected_frames_bytes_size <= INT_MAX);
  written_into_ssl = BIO_write(impl->into_ssl, protected_frames_bytes,
-                               *protected_frames_bytes_size);
+                               (int)*protected_frames_bytes_size);
  if (written_into_ssl < 0) {
    gpr_log(GPR_ERROR, "Sending protected frame to ssl failed with %d",
            written_into_ssl);
    return TSI_INTERNAL_ERROR;
  }
-  *protected_frames_bytes_size = written_into_ssl;
+  *protected_frames_bytes_size = (size_t)written_into_ssl;

  /* Now try to read some data again. */
  result = do_ssl_read(impl->ssl, unprotected_bytes, unprotected_bytes_size);
@ -781,7 +810,8 @@ static tsi_result ssl_handshaker_get_bytes_to_send_to_peer(tsi_handshaker* self,
      *bytes_size > INT_MAX) {
    return TSI_INVALID_ARGUMENT;
  }
-  bytes_read_from_ssl = BIO_read(impl->from_ssl, bytes, *bytes_size);
+  GPR_ASSERT(*bytes_size <= INT_MAX);
+  bytes_read_from_ssl = BIO_read(impl->from_ssl, bytes, (int)*bytes_size);
  if (bytes_read_from_ssl < 0) {
    *bytes_size = 0;
    if (!BIO_should_retry(impl->from_ssl)) {
@ -811,13 +841,15 @@ static tsi_result ssl_handshaker_process_bytes_from_peer(
  if (bytes == NULL || bytes_size == 0 || *bytes_size > INT_MAX) {
    return TSI_INVALID_ARGUMENT;
  }
-  bytes_written_into_ssl_size = BIO_write(impl->into_ssl, bytes, *bytes_size);
+  GPR_ASSERT(*bytes_size <= INT_MAX);
+  bytes_written_into_ssl_size =
+      BIO_write(impl->into_ssl, bytes, (int)*bytes_size);
  if (bytes_written_into_ssl_size < 0) {
    gpr_log(GPR_ERROR, "Could not write to memory BIO.");
    impl->result = TSI_INTERNAL_ERROR;
    return impl->result;
  }
-  *bytes_size = bytes_written_into_ssl_size;
+  *bytes_size = (size_t)bytes_written_into_ssl_size;

  if (!tsi_handshaker_is_in_progress(self)) {
    impl->result = TSI_OK;
@ -1033,9 +1065,9 @@ static tsi_result create_tsi_ssl_handshaker(SSL_CTX* ctx, int is_client,
 static int select_protocol_list(const unsigned char** out,
                                unsigned char* outlen,
                                const unsigned char* client_list,
-                                unsigned int client_list_len,
+                                size_t client_list_len,
                                const unsigned char* server_list,
-                                unsigned int server_list_len) {
+                                size_t server_list_len) {
  const unsigned char* client_current = client_list;
  while ((unsigned int)(client_current - client_list) < client_list_len) {
    unsigned char client_current_len = *(client_current++);
@ -1208,7 +1240,8 @@ static int server_handshaker_factory_npn_advertised_callback(
  tsi_ssl_server_handshaker_factory* factory =
      (tsi_ssl_server_handshaker_factory*)arg;
  *out = factory->alpn_protocol_list;
-  *outlen = factory->alpn_protocol_list_length;
+  GPR_ASSERT(factory->alpn_protocol_list_length <= UINT_MAX);
+  *outlen = (unsigned int)factory->alpn_protocol_list_length;
  return SSL_TLSEXT_ERR_OK;
 }

@ -1266,8 +1299,10 @@ tsi_result tsi_create_ssl_client_handshaker_factory(
        break;
      }
 #if TSI_OPENSSL_ALPN_SUPPORT
-      if (SSL_CTX_set_alpn_protos(ssl_context, impl->alpn_protocol_list,
-                                  impl->alpn_protocol_list_length)) {
+      GPR_ASSERT(impl->alpn_protocol_list_length < UINT_MAX);
+      if (SSL_CTX_set_alpn_protos(
+              ssl_context, impl->alpn_protocol_list,
+              (unsigned int)impl->alpn_protocol_list_length)) {
        gpr_log(GPR_ERROR, "Could not set alpn protocol list to context.");
        result = TSI_INVALID_ARGUMENT;
        break;
--- a/src/cpp/server/secure_server_credentials.cc
+++ b/src/cpp/server/secure_server_credentials.cc
@ -101,7 +101,9 @@ void AuthMetadataProcessorAyncWrapper::InvokeProcessor(
                           0,
                           {{nullptr, nullptr, nullptr, nullptr}}});
  }
-  cb(user_data, &consumed_md[0], consumed_md.size(), &response_md[0],
+  auto consumed_md_data = consumed_md.empty() ? nullptr : &consumed_md[0];
+  auto response_md_data = response_md.empty() ? nullptr : &response_md[0];
+  cb(user_data, consumed_md_data, consumed_md.size(), response_md_data,
     response_md.size(), static_cast<grpc_status_code>(status.error_code()),
     status.error_message().c_str());
 }
@ -130,8 +132,8 @@ std::shared_ptr<ServerCredentials> SslServerCredentials(
  }
  grpc_server_credentials* c_creds = grpc_ssl_server_credentials_create(
      options.pem_root_certs.empty() ? nullptr : options.pem_root_certs.c_str(),
-      &pem_key_cert_pairs[0], pem_key_cert_pairs.size(),
-      options.force_client_auth, nullptr);
+      pem_key_cert_pairs.empty() ? nullptr : &pem_key_cert_pairs[0],
+      pem_key_cert_pairs.size(), options.force_client_auth, nullptr);
  return std::shared_ptr<ServerCredentials>(
      new SecureServerCredentials(c_creds));
 }
--- a/src/cpp/server/server.cc
+++ b/src/cpp/server/server.cc
@ -252,28 +252,36 @@ class Server::SyncRequest GRPC_FINAL : public CompletionQueueTag {
  grpc_completion_queue* cq_;
 };

-static grpc_server* CreateServer(int max_message_size) {
+static grpc_server* CreateServer(
+    int max_message_size, const grpc_compression_options& compression_options) {
+  grpc_arg args[2];
+  size_t args_idx = 0;
  if (max_message_size > 0) {
-    grpc_arg arg;
-    arg.type = GRPC_ARG_INTEGER;
-    arg.key = const_cast<char*>(GRPC_ARG_MAX_MESSAGE_LENGTH);
-    arg.value.integer = max_message_size;
-    grpc_channel_args args = {1, &arg};
-    return grpc_server_create(&args, nullptr);
-  } else {
-    return grpc_server_create(nullptr, nullptr);
+    args[args_idx].type = GRPC_ARG_INTEGER;
+    args[args_idx].key = const_cast<char*>(GRPC_ARG_MAX_MESSAGE_LENGTH);
+    args[args_idx].value.integer = max_message_size;
+    args_idx++;
  }
+
+  args[args_idx].type = GRPC_ARG_INTEGER;
+  args[args_idx].key = const_cast<char*>(GRPC_COMPRESSION_ALGORITHM_STATE_ARG);
+  args[args_idx].value.integer = compression_options.enabled_algorithms_bitset;
+  args_idx++;
+
+  grpc_channel_args channel_args = {args_idx, args};
+  return grpc_server_create(&channel_args, nullptr);
 }

 Server::Server(ThreadPoolInterface* thread_pool, bool thread_pool_owned,
-               int max_message_size)
+               int max_message_size,
+               grpc_compression_options compression_options)
    : max_message_size_(max_message_size),
      started_(false),
      shutdown_(false),
      num_running_cb_(0),
      sync_methods_(new std::list<SyncRequest>),
      has_generic_service_(false),
-      server_(CreateServer(max_message_size)),
+      server_(CreateServer(max_message_size, compression_options)),
      thread_pool_(thread_pool),
      thread_pool_owned_(thread_pool_owned) {
  grpc_server_register_completion_queue(server_, cq_.cq(), nullptr);
--- a/src/cpp/server/server_builder.cc
+++ b/src/cpp/server/server_builder.cc
@ -43,7 +43,9 @@
 namespace grpc {

 ServerBuilder::ServerBuilder()
-    : max_message_size_(-1), generic_service_(nullptr), thread_pool_(nullptr) {}
+    : max_message_size_(-1), generic_service_(nullptr), thread_pool_(nullptr) {
+      grpc_compression_options_init(&compression_options_);
+}

 std::unique_ptr<ServerCompletionQueue> ServerBuilder::AddCompletionQueue() {
  ServerCompletionQueue* cq = new ServerCompletionQueue();
@ -99,8 +101,9 @@ std::unique_ptr<Server> ServerBuilder::BuildAndStart() {
    thread_pool_ = CreateDefaultThreadPool();
    thread_pool_owned = true;
  }
-  std::unique_ptr<Server> server(
-      new Server(thread_pool_, thread_pool_owned, max_message_size_));
+  std::unique_ptr<Server> server(new Server(thread_pool_, thread_pool_owned,
+                                            max_message_size_,
+                                            compression_options_));
  for (auto cq = cqs_.begin(); cq != cqs_.end(); ++cq) {
    grpc_server_register_completion_queue(server->server_, (*cq)->cq(),
                                          nullptr);
@ -128,7 +131,8 @@ std::unique_ptr<Server> ServerBuilder::BuildAndStart() {
      *port->selected_port = r;
    }
  }
-  if (!server->Start(&cqs_[0], cqs_.size())) {
+  auto cqs_data = cqs_.empty() ? nullptr : &cqs_[0];
+  if (!server->Start(cqs_data, cqs_.size())) {
    return nullptr;
  }
  return server;
--- a/src/csharp/Grpc.IntegrationTesting/Grpc.IntegrationTesting.csproj
+++ b/src/csharp/Grpc.IntegrationTesting/Grpc.IntegrationTesting.csproj
@ -42,6 +42,9 @@
      <SpecificVersion>False</SpecificVersion>
      <HintPath>..\packages\BouncyCastle.1.7.0\lib\Net40-Client\BouncyCastle.Crypto.dll</HintPath>
    </Reference>
+    <Reference Include="CommandLine">
+      <HintPath>..\packages\CommandLineParser.1.9.71\lib\net45\CommandLine.dll</HintPath>
+    </Reference>
    <Reference Include="Google.Apis.Auth, Version=1.9.3.19379, Culture=neutral, PublicKeyToken=4b01fa6e34db77ab, processorArchitecture=MSIL">
      <SpecificVersion>False</SpecificVersion>
      <HintPath>..\packages\Google.Apis.Auth.1.9.3\lib\net40\Google.Apis.Auth.dll</HintPath>
--- a/src/csharp/Grpc.IntegrationTesting/InteropClient.cs
+++ b/src/csharp/Grpc.IntegrationTesting/InteropClient.cs
@ -37,6 +37,7 @@ using System.Text.RegularExpressions;
 using System.Threading;
 using System.Threading.Tasks;

+using CommandLine;
 using Google.Apis.Auth.OAuth2;
 using Google.Protobuf;
 using Grpc.Auth;
@ -44,25 +45,54 @@ using Grpc.Core;
 using Grpc.Core.Utils;
 using Grpc.Testing;
 using NUnit.Framework;
+using CommandLine.Text;
+using System.IO;

 namespace Grpc.IntegrationTesting
 {
    public class InteropClient
    {
-        private const string ServiceAccountUser = "155450119199-3psnrh1sdr3d8cpj1v46naggf81mhdnk@developer.gserviceaccount.com";
-        private const string ComputeEngineUser = "155450119199-r5aaqa2vqoa9g5mv2m6s3m1l293rlmel@developer.gserviceaccount.com";
-        private const string AuthScope = "https://www.googleapis.com/auth/xapi.zoo";
-        private const string AuthScopeResponse = "xapi.zoo";
-
        private class ClientOptions
        {
-            public bool help;
-            public string serverHost = "127.0.0.1";
-            public string serverHostOverride = TestCredentials.DefaultHostOverride;
-            public int? serverPort;
-            public string testCase = "large_unary";
-            public bool useTls;
-            public bool useTestCa;
+            [Option("server_host", DefaultValue = "127.0.0.1")]
+            public string ServerHost { get; set; }
+
+            [Option("server_host_override", DefaultValue = TestCredentials.DefaultHostOverride)]
+            public string ServerHostOverride { get; set; }
+
+            [Option("server_port", Required = true)]
+            public int ServerPort { get; set; }
+
+            [Option("test_case", DefaultValue = "large_unary")]
+            public string TestCase { get; set; }
+
+            [Option("use_tls")]
+            public bool UseTls { get; set; }
+
+            [Option("use_test_ca")]
+            public bool UseTestCa { get; set; }
+
+            [Option("default_service_account", Required = false)]
+            public string DefaultServiceAccount { get; set; }
+
+            [Option("oauth_scope", Required = false)]
+            public string OAuthScope { get; set; }
+
+            [Option("service_account_key_file", Required = false)]
+            public string ServiceAccountKeyFile { get; set; }
+
+            [HelpOption]
+            public string GetUsage()
+            {
+                var help = new HelpText
+                {
+                    Heading = "gRPC C# interop testing client",
+                    AddDashesToOption = true
+                };
+                help.AddPreOptionsLine("Usage:");
+                help.AddOptions(this);
+                return help;
+            }
        }

        ClientOptions options;
@ -74,26 +104,9 @@ namespace Grpc.IntegrationTesting

        public static void Run(string[] args)
        {
-            Console.WriteLine("gRPC C# interop testing client");
-            ClientOptions options = ParseArguments(args);
-
-            if (options.serverHost == null || !options.serverPort.HasValue || options.testCase == null)
-            {
-                Console.WriteLine("Missing required argument.");
-                Console.WriteLine();
-                options.help = true;
-            }
-
-            if (options.help)
+            var options = new ClientOptions();
+            if (!Parser.Default.ParseArguments(args, options))
            {
-                Console.WriteLine("Usage:");
-                Console.WriteLine("  --server_host=HOSTNAME");
-                Console.WriteLine("  --server_host_override=HOSTNAME");
-                Console.WriteLine("  --server_port=PORT");
-                Console.WriteLine("  --test_case=TESTCASE");
-                Console.WriteLine("  --use_tls=BOOLEAN");
-                Console.WriteLine("  --use_test_ca=BOOLEAN");
-                Console.WriteLine();
                Environment.Exit(1);
            }

@ -103,30 +116,27 @@ namespace Grpc.IntegrationTesting

        private async Task Run()
        {
-            Credentials credentials = null;
-            if (options.useTls)
-            {
-                credentials = TestCredentials.CreateTestClientCredentials(options.useTestCa);
-            }
-
+            var credentials = options.UseTls ? TestCredentials.CreateTestClientCredentials(options.UseTestCa) : Credentials.Insecure;
+            
            List<ChannelOption> channelOptions = null;
-            if (!string.IsNullOrEmpty(options.serverHostOverride))
+            if (!string.IsNullOrEmpty(options.ServerHostOverride))
            {
                channelOptions = new List<ChannelOption>
                {
-                    new ChannelOption(ChannelOptions.SslTargetNameOverride, options.serverHostOverride)
+                    new ChannelOption(ChannelOptions.SslTargetNameOverride, options.ServerHostOverride)
                };
            }
-
-            var channel = new Channel(options.serverHost, options.serverPort.Value, credentials, channelOptions);
+            Console.WriteLine(options.ServerHost);
+            Console.WriteLine(options.ServerPort);
+            var channel = new Channel(options.ServerHost, options.ServerPort, credentials, channelOptions);
            TestService.TestServiceClient client = new TestService.TestServiceClient(channel);
-            await RunTestCaseAsync(options.testCase, client);
+            await RunTestCaseAsync(client, options);
            channel.ShutdownAsync().Wait();
        }

-        private async Task RunTestCaseAsync(string testCase, TestService.TestServiceClient client)
+        private async Task RunTestCaseAsync(TestService.TestServiceClient client, ClientOptions options)
        {
-            switch (testCase)
+            switch (options.TestCase)
            {
                case "empty_unary":
                    RunEmptyUnary(client);
@ -146,20 +156,17 @@ namespace Grpc.IntegrationTesting
                case "empty_stream":
                    await RunEmptyStreamAsync(client);
                    break;
-                case "service_account_creds":
-                    await RunServiceAccountCredsAsync(client);
-                    break;
                case "compute_engine_creds":
-                    await RunComputeEngineCredsAsync(client);
+                    await RunComputeEngineCredsAsync(client, options.DefaultServiceAccount, options.OAuthScope);
                    break;
                case "jwt_token_creds":
-                    await RunJwtTokenCredsAsync(client);
+                    await RunJwtTokenCredsAsync(client, options.DefaultServiceAccount);
                    break;
                case "oauth2_auth_token":
-                    await RunOAuth2AuthTokenAsync(client);
+                    await RunOAuth2AuthTokenAsync(client, options.DefaultServiceAccount, options.OAuthScope);
                    break;
                case "per_rpc_creds":
-                    await RunPerRpcCredsAsync(client);
+                    await RunPerRpcCredsAsync(client, options.DefaultServiceAccount, options.OAuthScope);
                    break;
                case "cancel_after_begin":
                    await RunCancelAfterBeginAsync(client);
@ -174,7 +181,7 @@ namespace Grpc.IntegrationTesting
                    RunBenchmarkEmptyUnary(client);
                    break;
                default:
-                    throw new ArgumentException("Unknown test case " + testCase);
+                    throw new ArgumentException("Unknown test case " + options.TestCase);
            }
        }

@ -313,32 +320,7 @@ namespace Grpc.IntegrationTesting
            Console.WriteLine("Passed!");
        }

-        public static async Task RunServiceAccountCredsAsync(TestService.TestServiceClient client)
-        {
-            Console.WriteLine("running service_account_creds");
-            var credential = await GoogleCredential.GetApplicationDefaultAsync();
-            credential = credential.CreateScoped(new[] { AuthScope });
-            client.HeaderInterceptor = AuthInterceptors.FromCredential(credential);
-
-            var request = new SimpleRequest
-            {
-                ResponseType = PayloadType.COMPRESSABLE,
-                ResponseSize = 314159,
-                Payload = CreateZerosPayload(271828),
-                FillUsername = true,
-                FillOauthScope = true
-            };
-
-            var response = client.UnaryCall(request);
-
-            Assert.AreEqual(PayloadType.COMPRESSABLE, response.Payload.Type);
-            Assert.AreEqual(314159, response.Payload.Body.Length);
-            Assert.AreEqual(AuthScopeResponse, response.OauthScope);
-            Assert.AreEqual(ServiceAccountUser, response.Username);
-            Console.WriteLine("Passed!");
-        }
-
-        public static async Task RunComputeEngineCredsAsync(TestService.TestServiceClient client)
+        public static async Task RunComputeEngineCredsAsync(TestService.TestServiceClient client, string defaultServiceAccount, string oauthScope)
        {
            Console.WriteLine("running compute_engine_creds");
            var credential = await GoogleCredential.GetApplicationDefaultAsync();
@ -358,16 +340,16 @@ namespace Grpc.IntegrationTesting

            Assert.AreEqual(PayloadType.COMPRESSABLE, response.Payload.Type);
            Assert.AreEqual(314159, response.Payload.Body.Length);
-            Assert.AreEqual(AuthScopeResponse, response.OauthScope);
-            Assert.AreEqual(ComputeEngineUser, response.Username);
+            Assert.False(string.IsNullOrEmpty(response.OauthScope));
+            Assert.True(oauthScope.Contains(response.OauthScope));
+            Assert.AreEqual(defaultServiceAccount, response.Username);
            Console.WriteLine("Passed!");
        }

-        public static async Task RunJwtTokenCredsAsync(TestService.TestServiceClient client)
+        public static async Task RunJwtTokenCredsAsync(TestService.TestServiceClient client, string defaultServiceAccount)
        {
            Console.WriteLine("running jwt_token_creds");
            var credential = await GoogleCredential.GetApplicationDefaultAsync();
-            // check this a credential with scope support, but don't add the scope.
            Assert.IsTrue(credential.IsCreateScopedRequired);
            client.HeaderInterceptor = AuthInterceptors.FromCredential(credential);

@ -377,21 +359,20 @@ namespace Grpc.IntegrationTesting
                ResponseSize = 314159,
                Payload = CreateZerosPayload(271828),
                FillUsername = true,
-                FillOauthScope = true
            };

            var response = client.UnaryCall(request);

            Assert.AreEqual(PayloadType.COMPRESSABLE, response.Payload.Type);
            Assert.AreEqual(314159, response.Payload.Body.Length);
-            Assert.AreEqual(ServiceAccountUser, response.Username);
+            Assert.AreEqual(defaultServiceAccount, response.Username);
            Console.WriteLine("Passed!");
        }

-        public static async Task RunOAuth2AuthTokenAsync(TestService.TestServiceClient client)
+        public static async Task RunOAuth2AuthTokenAsync(TestService.TestServiceClient client, string defaultServiceAccount, string oauthScope)
        {
            Console.WriteLine("running oauth2_auth_token");
-            ITokenAccess credential = (await GoogleCredential.GetApplicationDefaultAsync()).CreateScoped(new[] { AuthScope });
+            ITokenAccess credential = (await GoogleCredential.GetApplicationDefaultAsync()).CreateScoped(new[] { oauthScope });
            string oauth2Token = await credential.GetAccessTokenForRequestAsync();

            client.HeaderInterceptor = AuthInterceptors.FromAccessToken(oauth2Token);
@ -404,31 +385,29 @@ namespace Grpc.IntegrationTesting

            var response = client.UnaryCall(request);

-            Assert.AreEqual(AuthScopeResponse, response.OauthScope);
-            Assert.AreEqual(ServiceAccountUser, response.Username);
+            Assert.False(string.IsNullOrEmpty(response.OauthScope));
+            Assert.True(oauthScope.Contains(response.OauthScope));
+            Assert.AreEqual(defaultServiceAccount, response.Username);
            Console.WriteLine("Passed!");
        }

-        public static async Task RunPerRpcCredsAsync(TestService.TestServiceClient client)
+        public static async Task RunPerRpcCredsAsync(TestService.TestServiceClient client, string defaultServiceAccount, string oauthScope)
        {
            Console.WriteLine("running per_rpc_creds");
-
-            ITokenAccess credential = (await GoogleCredential.GetApplicationDefaultAsync()).CreateScoped(new[] { AuthScope });
-            string oauth2Token = await credential.GetAccessTokenForRequestAsync();
-            var headerInterceptor = AuthInterceptors.FromAccessToken(oauth2Token);
+            ITokenAccess credential = (await GoogleCredential.GetApplicationDefaultAsync()).CreateScoped(new[] { oauthScope });
+            string accessToken = await credential.GetAccessTokenForRequestAsync();
+            var headerInterceptor = AuthInterceptors.FromAccessToken(accessToken);

            var request = new SimpleRequest
            {
                FillUsername = true,
-                FillOauthScope = true
            };

            var headers = new Metadata();
            headerInterceptor(null, "", headers);
            var response = client.UnaryCall(request, headers: headers);

-            Assert.AreEqual(AuthScopeResponse, response.OauthScope);
-            Assert.AreEqual(ServiceAccountUser, response.Username);
+            Assert.AreEqual(defaultServiceAccount, response.Username);
            Console.WriteLine("Passed!");
        }

@ -508,68 +487,5 @@ namespace Grpc.IntegrationTesting
        {
            return new Payload { Body = ByteString.CopyFrom(new byte[size]) };
        }
-
-        private static ClientOptions ParseArguments(string[] args)
-        {
-            var options = new ClientOptions();
-            foreach (string arg in args)
-            {
-                ParseArgument(arg, options);
-                if (options.help)
-                {
-                    break;
-                }
-            }
-            return options;
-        }
-
-        private static void ParseArgument(string arg, ClientOptions options)
-        {
-            Match match;
-            match = Regex.Match(arg, "--server_host=(.*)");
-            if (match.Success)
-            {
-                options.serverHost = match.Groups[1].Value.Trim();
-                return;
-            }
-
-            match = Regex.Match(arg, "--server_host_override=(.*)");
-            if (match.Success)
-            {
-                options.serverHostOverride = match.Groups[1].Value.Trim();
-                return;
-            }
-
-            match = Regex.Match(arg, "--server_port=(.*)");
-            if (match.Success)
-            {
-                options.serverPort = int.Parse(match.Groups[1].Value.Trim());
-                return;
-            }
-
-            match = Regex.Match(arg, "--test_case=(.*)");
-            if (match.Success)
-            {
-                options.testCase = match.Groups[1].Value.Trim();
-                return;
-            }
-
-            match = Regex.Match(arg, "--use_tls=(.*)");
-            if (match.Success)
-            {
-                options.useTls = bool.Parse(match.Groups[1].Value.Trim());
-                return;
-            }
-
-            match = Regex.Match(arg, "--use_test_ca=(.*)");
-            if (match.Success)
-            {
-                options.useTestCa = bool.Parse(match.Groups[1].Value.Trim());
-                return;
-            }
-
-            Console.WriteLine(string.Format("Unrecognized argument \"{0}\"", arg));
-            options.help = true;
-        }
    }
 }
--- a/src/csharp/Grpc.IntegrationTesting/InteropServer.cs
+++ b/src/csharp/Grpc.IntegrationTesting/InteropServer.cs
@ -37,6 +37,9 @@ using System.Diagnostics;
 using System.IO;
 using System.Text.RegularExpressions;
 using System.Threading.Tasks;
+
+using CommandLine;
+using CommandLine.Text;
 using Grpc.Core;
 using Grpc.Core.Utils;
 using Grpc.Testing;
@ -48,9 +51,24 @@ namespace Grpc.IntegrationTesting
    {
        private class ServerOptions
        {
-            public bool help;
-            public int? port = 8070;
-            public bool useTls;
+            [Option("port", DefaultValue = 8070)]
+            public int Port { get; set; }
+
+            [Option("use_tls")]
+            public bool UseTls { get; set; }
+
+            [HelpOption]
+            public string GetUsage()
+            {
+                var help = new HelpText
+                {
+                    Heading = "gRPC C# interop testing server",
+                    AddDashesToOption = true
+                };
+                help.AddPreOptionsLine("Usage:");
+                help.AddOptions(this);
+                return help;
+            }
        }

        ServerOptions options;
@ -62,22 +80,9 @@ namespace Grpc.IntegrationTesting

        public static void Run(string[] args)
        {
-            Console.WriteLine("gRPC C# interop testing server");
-            ServerOptions options = ParseArguments(args);
-
-            if (!options.port.HasValue)
-            {
-                Console.WriteLine("Missing required argument.");
-                Console.WriteLine();
-                options.help = true;
-            }
-
-            if (options.help)
+            var options = new ServerOptions();
+            if (!Parser.Default.ParseArguments(args, options))
            {
-                Console.WriteLine("Usage:");
-                Console.WriteLine("  --port=PORT");
-                Console.WriteLine("  --use_tls=BOOLEAN");
-                Console.WriteLine();
                Environment.Exit(1);
            }

@ -93,54 +98,19 @@ namespace Grpc.IntegrationTesting
            };

            string host = "0.0.0.0";
-            int port = options.port.Value;
-            if (options.useTls)
+            int port = options.Port;
+            if (options.UseTls)
            {
                server.Ports.Add(host, port, TestCredentials.CreateTestServerCredentials());
            }
            else
            {
-                server.Ports.Add(host, options.port.Value, ServerCredentials.Insecure);
+                server.Ports.Add(host, options.Port, ServerCredentials.Insecure);
            }
            Console.WriteLine("Running server on " + string.Format("{0}:{1}", host, port));
            server.Start();

            server.ShutdownTask.Wait();
        }
-
-        private static ServerOptions ParseArguments(string[] args)
-        {
-            var options = new ServerOptions();
-            foreach (string arg in args)
-            {
-                ParseArgument(arg, options);
-                if (options.help)
-                {
-                    break;
-                }
-            }
-            return options;
-        }
-
-        private static void ParseArgument(string arg, ServerOptions options)
-        {
-            Match match;
-            match = Regex.Match(arg, "--port=(.*)");
-            if (match.Success)
-            {
-                options.port = int.Parse(match.Groups[1].Value.Trim());
-                return;
-            }
-
-            match = Regex.Match(arg, "--use_tls=(.*)");
-            if (match.Success)
-            {
-                options.useTls = bool.Parse(match.Groups[1].Value.Trim());
-                return;
-            }
-
-            Console.WriteLine(string.Format("Unrecognized argument \"{0}\"", arg));
-            options.help = true;
-        }
    }
 }
--- a/src/csharp/Grpc.IntegrationTesting/packages.config
+++ b/src/csharp/Grpc.IntegrationTesting/packages.config
@ -1,6 +1,7 @@
 <?xml version="1.0" encoding="utf-8"?>
 <packages>
  <package id="BouncyCastle" version="1.7.0" targetFramework="net45" />
+  <package id="CommandLineParser" version="1.9.71" targetFramework="net45" />
  <package id="Google.Apis.Auth" version="1.9.3" targetFramework="net45" />
  <package id="Google.Apis.Core" version="1.9.3" targetFramework="net45" />
  <package id="Google.Protobuf" version="3.0.0-alpha4" targetFramework="net45" />
--- a/src/node/README.md
+++ b/src/node/README.md
@ -11,10 +11,10 @@ Beta

 **Linux (Debian):**

-Add [Debian testing][] to your `sources.list` file. Example:
+Add [Debian jessie-backports][] to your `sources.list` file. Example:

 ```sh
-echo "deb http://ftp.us.debian.org/debian testing main contrib non-free" | \
+echo "deb http://http.debian.net/debian jessie-backports main" | \
 sudo tee -a /etc/apt/sources.list
 ```

@ -113,4 +113,4 @@ An object with factory methods for creating credential objects for servers.

 [homebrew]:http://brew.sh
 [gRPC install script]:https://raw.githubusercontent.com/grpc/homebrew-grpc/master/scripts/install
-[Debian testing]:https://www.debian.org/releases/stretch/
+[Debian jessie-backports]:http://backports.debian.org/Instructions/
--- a/src/php/README.md
+++ b/src/php/README.md
@ -32,10 +32,10 @@ $ sudo php -d detect_unicode=0 go-pear.phar

 **Linux (Debian):**

-Add [Debian testing][] to your `sources.list` file. Example:
+Add [Debian jessie-backports][] to your `sources.list` file. Example:

 ```sh
-echo "deb http://ftp.us.debian.org/debian testing main contrib non-free" | \
+echo "deb http://http.debian.net/debian jessie-backports main" | \
 sudo tee -a /etc/apt/sources.list
 ```

@ -167,4 +167,4 @@ $ ./bin/run_gen_code_test.sh
 [homebrew]:http://brew.sh
 [gRPC install script]:https://raw.githubusercontent.com/grpc/homebrew-grpc/master/scripts/install
 [Node]:https://github.com/grpc/grpc/tree/master/src/node/examples
-[Debian testing]:https://www.debian.org/releases/stretch/
+[Debian jessie-backports]:http://backports.debian.org/Instructions/
--- a/src/python/README.md
+++ b/src/python/README.md
@ -16,10 +16,10 @@ INSTALLATION

 **Linux (Debian):**

-Add [Debian testing][] to your `sources.list` file. Example:
+Add [Debian jessie-backports][] to your `sources.list` file. Example:

 ```sh
-echo "deb http://ftp.us.debian.org/debian testing main contrib non-free" | \
+echo "deb http://http.debian.net/debian jessie-backports main" | \
 sudo tee -a /etc/apt/sources.list
 ```

@ -92,4 +92,4 @@ $ ../../tools/distrib/python/submit.py
 [gRPC install script]:https://raw.githubusercontent.com/grpc/homebrew-grpc/master/scripts/install
 [Quick Start]:http://www.grpc.io/docs/tutorials/basic/python.html
 [detailed example]:http://www.grpc.io/docs/installation/python.html
-[Debian testing]:https://www.debian.org/releases/stretch/
+[Debian jessie-backports]:http://backports.debian.org/Instructions/
--- a/src/python/grpcio/commands.py
+++ b/src/python/grpcio/commands.py
@ -64,7 +64,7 @@ class SphinxDocumentation(setuptools.Command):
    import sphinx.apidoc
    metadata = self.distribution.metadata
    src_dir = os.path.join(
-        os.getcwd(), self.distribution.package_dir['grpc'])
+        os.getcwd(), self.distribution.package_dir[''], 'grpc')
    sys.path.append(src_dir)
    sphinx.apidoc.main([
        '', '--force', '--full', '-H', metadata.name, '-A', metadata.author,
--- a/src/python/grpcio/grpc/_adapter/_intermediary_low.py
+++ b/src/python/grpcio/grpc/_adapter/_intermediary_low.py
@ -59,6 +59,7 @@ from grpc._adapter import _types

 _IGNORE_ME_TAG = object()
 Code = _types.StatusCode
+WriteFlags = _types.OpWriteFlags


 class Status(collections.namedtuple('Status', ['code', 'details'])):
@ -125,9 +126,9 @@ class Call(object):
      ], _TagAdapter(finish_tag, Event.Kind.FINISH))
    return err0 if err0 != _types.CallError.OK else err1 if err1 != _types.CallError.OK else err2 if err2 != _types.CallError.OK else _types.CallError.OK

-  def write(self, message, tag):
+  def write(self, message, tag, flags):
    return self._internal.start_batch([
-          _types.OpArgs.send_message(message, 0)
+          _types.OpArgs.send_message(message, flags)
      ], _TagAdapter(tag, Event.Kind.WRITE_ACCEPTED))

  def complete(self, tag):
@ -163,8 +164,11 @@ class Call(object):
  def cancel(self):
    return self._internal.cancel()

+  def peer(self):
+    return self._internal.peer()
+
  def set_credentials(self, creds):
-    return self._internal.set_credentials(creds)
+    return self._internal.set_credentials(creds._internal)


 class Channel(object):
--- a/src/python/grpcio/grpc/_adapter/fore.py
+++ b/src/python/grpcio/grpc/_adapter/fore.py
@ -56,7 +56,7 @@ class _LowWrite(enum.Enum):
 def _write(call, rpc_state, payload):
  serialized_payload = rpc_state.serializer(payload)
  if rpc_state.write.low is _LowWrite.OPEN:
-    call.write(serialized_payload, call)
+    call.write(serialized_payload, call, 0)
    rpc_state.write.low = _LowWrite.ACTIVE
  else:
    rpc_state.write.pending.append(serialized_payload)
@ -164,7 +164,7 @@ class ForeLink(base_interfaces.ForeLink, activated.Activated):

    if rpc_state.write.pending:
      serialized_payload = rpc_state.write.pending.pop(0)
-      call.write(serialized_payload, call)
+      call.write(serialized_payload, call, 0)
    elif rpc_state.write.high is _common.HighWrite.CLOSED:
      _status(call, rpc_state)
    else:
--- a/src/python/grpcio/grpc/_adapter/rear.py
+++ b/src/python/grpcio/grpc/_adapter/rear.py
@ -78,7 +78,7 @@ class _RPCState(object):

 def _write(operation_id, call, outstanding, write_state, serialized_payload):
  if write_state.low is _LowWrite.OPEN:
-    call.write(serialized_payload, operation_id)
+    call.write(serialized_payload, operation_id, 0)
    outstanding.add(_low.Event.Kind.WRITE_ACCEPTED)
    write_state.low = _LowWrite.ACTIVE
  elif write_state.low is _LowWrite.ACTIVE:
@ -144,7 +144,7 @@ class RearLink(base_interfaces.RearLink, activated.Activated):
    if event.write_accepted:
      if rpc_state.common.write.pending:
        rpc_state.call.write(
-            rpc_state.common.write.pending.pop(0), operation_id)
+            rpc_state.common.write.pending.pop(0), operation_id, 0)
        rpc_state.outstanding.add(_low.Event.Kind.WRITE_ACCEPTED)
      elif rpc_state.common.write.high is _common.HighWrite.CLOSED:
        rpc_state.call.complete(operation_id)
@ -263,7 +263,7 @@ class RearLink(base_interfaces.RearLink, activated.Activated):
        low_state = _LowWrite.OPEN
    else:
      serialized_payload = request_serializer(payload)
-      call.write(serialized_payload, operation_id)
+      call.write(serialized_payload, operation_id, 0)
      outstanding.add(_low.Event.Kind.WRITE_ACCEPTED)
      low_state = _LowWrite.ACTIVE

--- a/src/python/grpcio/grpc/_links/invocation.py
+++ b/src/python/grpcio/grpc/_links/invocation.py
@ -37,6 +37,7 @@ import time

 from grpc._adapter import _intermediary_low
 from grpc._links import _constants
+from grpc.beta import interfaces as beta_interfaces
 from grpc.framework.foundation import activated
 from grpc.framework.foundation import logging_pool
 from grpc.framework.foundation import relay
@ -73,11 +74,28 @@ class _LowWrite(enum.Enum):
  CLOSED = 'CLOSED'


+class _Context(beta_interfaces.GRPCInvocationContext):
+
+  def __init__(self):
+    self._lock = threading.Lock()
+    self._disable_next_compression = False
+
+  def disable_next_request_compression(self):
+    with self._lock:
+      self._disable_next_compression = True
+
+  def next_compression_disabled(self):
+    with self._lock:
+      disabled = self._disable_next_compression
+      self._disable_next_compression = False
+      return disabled
+
+
 class _RPCState(object):

  def __init__(
      self, call, request_serializer, response_deserializer, sequence_number,
-      read, allowance, high_write, low_write, due):
+      read, allowance, high_write, low_write, due, context):
    self.call = call
    self.request_serializer = request_serializer
    self.response_deserializer = response_deserializer
@ -87,6 +105,7 @@ class _RPCState(object):
    self.high_write = high_write
    self.low_write = low_write
    self.due = due
+    self.context = context


 def _no_longer_due(kind, rpc_state, key, rpc_states):
@ -209,7 +228,7 @@ class _Kernel(object):

  def _invoke(
      self, operation_id, group, method, initial_metadata, payload, termination,
-      timeout, allowance):
+      timeout, allowance, options):
    """Invoke an RPC.

    Args:
@ -224,6 +243,7 @@ class _Kernel(object):
      timeout: A duration of time in seconds to allow for the RPC.
      allowance: The number of payloads (beyond the free first one) that the
        local ticket exchange mate has granted permission to be read.
+      options: A beta_interfaces.GRPCCallOptions value or None.
    """
    if termination is links.Ticket.Termination.COMPLETION:
      high_write = _HighWrite.CLOSED
@ -241,6 +261,8 @@ class _Kernel(object):
    call = _intermediary_low.Call(
        self._channel, self._completion_queue, '/%s/%s' % (group, method),
        self._host, time.time() + timeout)
+    if options is not None and options.credentials is not None:
+      call.set_credentials(options.credentials._intermediary_low_credentials)
    if transformed_initial_metadata is not None:
      for metadata_key, metadata_value in transformed_initial_metadata:
        call.add_metadata(metadata_key, metadata_value)
@ -254,17 +276,33 @@ class _Kernel(object):
        low_write = _LowWrite.OPEN
        due = set((_METADATA, _FINISH,))
    else:
-      call.write(request_serializer(payload), operation_id)
+      if options is not None and options.disable_compression:
+        flags = _intermediary_low.WriteFlags.WRITE_NO_COMPRESS
+      else:
+        flags = 0
+      call.write(request_serializer(payload), operation_id, flags)
      low_write = _LowWrite.ACTIVE
      due = set((_WRITE, _METADATA, _FINISH,))
+    context = _Context()
    self._rpc_states[operation_id] = _RPCState(
-        call, request_serializer, response_deserializer, 0,
+        call, request_serializer, response_deserializer, 1,
        _Read.AWAITING_METADATA, 1 if allowance is None else (1 + allowance),
-        high_write, low_write, due)
+        high_write, low_write, due, context)
+    protocol = links.Protocol(links.Protocol.Kind.INVOCATION_CONTEXT, context)
+    ticket = links.Ticket(
+        operation_id, 0, None, None, None, None, None, None, None, None, None,
+        None, None, protocol)
+    self._relay.add_value(ticket)

  def _advance(self, operation_id, rpc_state, payload, termination, allowance):
    if payload is not None:
-      rpc_state.call.write(rpc_state.request_serializer(payload), operation_id)
+      disable_compression = rpc_state.context.next_compression_disabled()
+      if disable_compression:
+        flags = _intermediary_low.WriteFlags.WRITE_NO_COMPRESS
+      else:
+        flags = 0
+      rpc_state.call.write(
+          rpc_state.request_serializer(payload), operation_id, flags)
      rpc_state.low_write = _LowWrite.ACTIVE
      rpc_state.due.add(_WRITE)

@ -292,10 +330,15 @@ class _Kernel(object):
        if self._completion_queue is None:
          logging.error('Received invocation ticket %s after stop!', ticket)
        else:
+          if (ticket.protocol is not None and
+              ticket.protocol.kind is links.Protocol.Kind.CALL_OPTION):
+            grpc_call_options = ticket.protocol.value
+          else:
+            grpc_call_options = None
          self._invoke(
              ticket.operation_id, ticket.group, ticket.method,
              ticket.initial_metadata, ticket.payload, ticket.termination,
-              ticket.timeout, ticket.allowance)
+              ticket.timeout, ticket.allowance, grpc_call_options)
      else:
        rpc_state = self._rpc_states.get(ticket.operation_id)
        if rpc_state is not None:
--- a/src/python/grpcio/grpc/_links/service.py
+++ b/src/python/grpcio/grpc/_links/service.py
@ -37,6 +37,7 @@ import time

 from grpc._adapter import _intermediary_low
 from grpc._links import _constants
+from grpc.beta import interfaces as beta_interfaces
 from grpc.framework.foundation import logging_pool
 from grpc.framework.foundation import relay
 from grpc.framework.interfaces.links import links
@ -89,12 +90,34 @@ class _LowWrite(enum.Enum):
  CLOSED = 'CLOSED'


+class _Context(beta_interfaces.GRPCServicerContext):
+
+  def __init__(self, call):
+    self._lock = threading.Lock()
+    self._call = call
+    self._disable_next_compression = False
+
+  def peer(self):
+    with self._lock:
+      return self._call.peer()
+
+  def disable_next_response_compression(self):
+    with self._lock:
+      self._disable_next_compression = True
+
+  def next_compression_disabled(self):
+    with self._lock:
+      disabled = self._disable_next_compression
+      self._disable_next_compression = False
+      return disabled
+
+
 class _RPCState(object):

  def __init__(
      self, request_deserializer, response_serializer, sequence_number, read,
      early_read, allowance, high_write, low_write, premetadataed,
-      terminal_metadata, code, message, due):
+      terminal_metadata, code, message, due, context):
    self.request_deserializer = request_deserializer
    self.response_serializer = response_serializer
    self.sequence_number = sequence_number
@ -110,6 +133,7 @@ class _RPCState(object):
    self.code = code
    self.message = message
    self.due = due
+    self.context = context


 def _no_longer_due(kind, rpc_state, key, rpc_states):
@ -163,14 +187,16 @@ class _Kernel(object):
        (group, method), _IDENTITY)

    call.read(call)
+    context = _Context(call)
    self._rpc_states[call] = _RPCState(
        request_deserializer, response_serializer, 1, _Read.READING, None, 1,
        _HighWrite.OPEN, _LowWrite.OPEN, False, None, None, None,
-        set((_READ, _FINISH,)))
+        set((_READ, _FINISH,)), context)
+    protocol = links.Protocol(links.Protocol.Kind.SERVICER_CONTEXT, context)
    ticket = links.Ticket(
        call, 0, group, method, links.Ticket.Subscription.FULL,
        service_acceptance.deadline - time.time(), None, event.metadata, None,
-        None, None, None, None, 'TODO: Service Context Object!')
+        None, None, None, None, protocol)
    self._relay.add_value(ticket)

  def _on_read_event(self, event):
@ -311,7 +337,12 @@ class _Kernel(object):
          self._relay.add_value(early_read_ticket)

      if ticket.payload is not None:
-        call.write(rpc_state.response_serializer(ticket.payload), call)
+        disable_compression = rpc_state.context.next_compression_disabled()
+        if disable_compression:
+          flags = _intermediary_low.WriteFlags.WRITE_NO_COMPRESS
+        else:
+          flags = 0
+        call.write(rpc_state.response_serializer(ticket.payload), call, flags)
        rpc_state.due.add(_WRITE)
        rpc_state.low_write = _LowWrite.ACTIVE

--- a/src/python/grpcio/grpc/beta/_connectivity_channel.py
+++ b/src/python/grpcio/grpc/beta/_connectivity_channel.py
@ -33,18 +33,24 @@ import threading
 import time

 from grpc._adapter import _low
+from grpc._adapter import _types
+from grpc.beta import interfaces
 from grpc.framework.foundation import callable_util

 _CHANNEL_SUBSCRIPTION_CALLBACK_ERROR_LOG_MESSAGE = (
    'Exception calling channel subscription callback!')

+_LOW_CONNECTIVITY_STATE_TO_CHANNEL_CONNECTIVITY = {
+    state: connectivity for state, connectivity in zip(
+        _types.ConnectivityState, interfaces.ChannelConnectivity)
+}
+

 class ConnectivityChannel(object):

-  def __init__(self, low_channel, mapping):
+  def __init__(self, low_channel):
    self._lock = threading.Lock()
    self._low_channel = low_channel
-    self._mapping = mapping

    self._polling = False
    self._connectivity = None
@ -88,7 +94,8 @@ class ConnectivityChannel(object):
    try_to_connect = initial_try_to_connect
    low_connectivity = low_channel.check_connectivity_state(try_to_connect)
    with self._lock:
-      self._connectivity = self._mapping[low_connectivity]
+      self._connectivity = _LOW_CONNECTIVITY_STATE_TO_CHANNEL_CONNECTIVITY[
+          low_connectivity]
      callbacks = tuple(
          callback for callback, unused_but_known_to_be_none_connectivity
          in self._callbacks_and_connectivities)
@ -112,7 +119,8 @@ class ConnectivityChannel(object):
      if event.success or try_to_connect:
        low_connectivity = low_channel.check_connectivity_state(try_to_connect)
        with self._lock:
-          self._connectivity = self._mapping[low_connectivity]
+          self._connectivity = _LOW_CONNECTIVITY_STATE_TO_CHANNEL_CONNECTIVITY[
+              low_connectivity]
          if not self._delivering:
            callbacks = self._deliveries(self._connectivity)
            if callbacks:
--- a/Show More
+++ b/Show More