diff --git a/include/grpc++/async_generic_service.h b/include/grpc++/async_generic_service.h
index d10a56c..911d31c 100644
--- a/include/grpc++/async_generic_service.h
+++ b/include/grpc++/async_generic_service.h
@@ -41,7 +41,8 @@
 
 namespace grpc {
 
-typedef ServerAsyncReaderWriter<ByteBuffer, ByteBuffer> GenericServerAsyncReaderWriter;
+typedef ServerAsyncReaderWriter<ByteBuffer, ByteBuffer>
+    GenericServerAsyncReaderWriter;
 
 class GenericServerContext GRPC_FINAL : public ServerContext {
  public:
@@ -74,6 +75,6 @@
   Server* server_;
 };
 
-} // namespace grpc
+}  // namespace grpc
 
 #endif  // GRPCXX_ASYNC_GENERIC_SERVICE_H
diff --git a/include/grpc++/async_unary_call.h b/include/grpc++/async_unary_call.h
index 658941b..d1d5be5 100644
--- a/include/grpc++/async_unary_call.h
+++ b/include/grpc++/async_unary_call.h
@@ -48,10 +48,9 @@
 class ClientAsyncResponseReader GRPC_FINAL {
  public:
   ClientAsyncResponseReader(ChannelInterface* channel, CompletionQueue* cq,
-                    const RpcMethod& method, ClientContext* context,
-                    const grpc::protobuf::Message& request, void* tag)
-      : context_(context),
-        call_(channel->CreateCall(method, context, cq)) {
+                            const RpcMethod& method, ClientContext* context,
+                            const grpc::protobuf::Message& request, void* tag)
+      : context_(context), call_(channel->CreateCall(method, context, cq)) {
     init_buf_.Reset(tag);
     init_buf_.AddSendInitialMetadata(&context->send_initial_metadata_);
     init_buf_.AddSendMessage(request);
diff --git a/include/grpc++/byte_buffer.h b/include/grpc++/byte_buffer.h
index e864ca3..ceb6262 100644
--- a/include/grpc++/byte_buffer.h
+++ b/include/grpc++/byte_buffer.h
@@ -72,9 +72,7 @@
     buffer_ = buf;
   }
 
-  grpc_byte_buffer* buffer() const {
-    return buffer_;
-  }
+  grpc_byte_buffer* buffer() const { return buffer_; }
 
   grpc_byte_buffer* buffer_;
 };
diff --git a/include/grpc++/channel_interface.h b/include/grpc++/channel_interface.h
index 51260ae..7d50b45 100644
--- a/include/grpc++/channel_interface.h
+++ b/include/grpc++/channel_interface.h
@@ -51,8 +51,8 @@
  public:
   virtual ~ChannelInterface() {}
 
-  virtual Call CreateCall(const RpcMethod &method, ClientContext *context,
-                          CompletionQueue *cq) = 0;
+  virtual Call CreateCall(const RpcMethod& method, ClientContext* context,
+                          CompletionQueue* cq) = 0;
 };
 
 }  // namespace grpc
diff --git a/include/grpc++/client_context.h b/include/grpc++/client_context.h
index c55d7c2..4e7f5a7 100644
--- a/include/grpc++/client_context.h
+++ b/include/grpc++/client_context.h
@@ -74,8 +74,8 @@
   ClientContext();
   ~ClientContext();
 
-  void AddMetadata(const grpc::string &meta_key,
-                   const grpc::string &meta_value);
+  void AddMetadata(const grpc::string& meta_key,
+                   const grpc::string& meta_value);
 
   const std::multimap<grpc::string, grpc::string>& GetServerInitialMetadata() {
     GPR_ASSERT(initial_metadata_received_);
@@ -87,19 +87,17 @@
     return trailing_metadata_;
   }
 
-  void set_absolute_deadline(const system_clock::time_point &deadline);
+  void set_absolute_deadline(const system_clock::time_point& deadline);
   system_clock::time_point absolute_deadline();
 
-  void set_authority(const grpc::string& authority) {
-    authority_ = authority;
-  }
+  void set_authority(const grpc::string& authority) { authority_ = authority; }
 
   void TryCancel();
 
  private:
   // Disallow copy and assign.
-  ClientContext(const ClientContext &);
-  ClientContext &operator=(const ClientContext &);
+  ClientContext(const ClientContext&);
+  ClientContext& operator=(const ClientContext&);
 
   friend class CallOpBuffer;
   friend class Channel;
@@ -118,24 +116,22 @@
   template <class R>
   friend class ::grpc::ClientAsyncResponseReader;
 
-  grpc_call *call() { return call_; }
-  void set_call(grpc_call *call) {
+  grpc_call* call() { return call_; }
+  void set_call(grpc_call* call) {
     GPR_ASSERT(call_ == nullptr);
     call_ = call;
   }
 
-  grpc_completion_queue *cq() { return cq_; }
-  void set_cq(grpc_completion_queue *cq) { cq_ = cq; }
+  grpc_completion_queue* cq() { return cq_; }
+  void set_cq(grpc_completion_queue* cq) { cq_ = cq; }
 
   gpr_timespec RawDeadline() { return absolute_deadline_; }
 
-  grpc::string authority() {
-    return authority_;
-  }
+  grpc::string authority() { return authority_; }
 
   bool initial_metadata_received_;
-  grpc_call *call_;
-  grpc_completion_queue *cq_;
+  grpc_call* call_;
+  grpc_completion_queue* cq_;
   gpr_timespec absolute_deadline_;
   grpc::string authority_;
   std::multimap<grpc::string, grpc::string> send_initial_metadata_;
diff --git a/include/grpc++/completion_queue.h b/include/grpc++/completion_queue.h
index d742d85..f4619a1 100644
--- a/include/grpc++/completion_queue.h
+++ b/include/grpc++/completion_queue.h
@@ -66,37 +66,38 @@
   // to do)
   // If this function returns false, the tag is dropped and not returned
   // from the completion queue
-  virtual bool FinalizeResult(void **tag, bool *status) = 0;
+  virtual bool FinalizeResult(void** tag, bool* status) = 0;
 };
 
 // grpc_completion_queue wrapper class
 class CompletionQueue {
  public:
   CompletionQueue();
-  explicit CompletionQueue(grpc_completion_queue *take);
+  explicit CompletionQueue(grpc_completion_queue* take);
   ~CompletionQueue();
 
   // Tri-state return for AsyncNext: SHUTDOWN, GOT_EVENT, TIMEOUT
-  enum NextStatus {SHUTDOWN, GOT_EVENT, TIMEOUT};
+  enum NextStatus { SHUTDOWN, GOT_EVENT, TIMEOUT };
 
   // Nonblocking (until deadline) read from queue.
   // Cannot rely on result of tag or ok if return is TIMEOUT
-  NextStatus AsyncNext(void **tag, bool *ok,
-		       std::chrono::system_clock::time_point deadline);
+  NextStatus AsyncNext(void** tag, bool* ok,
+                       std::chrono::system_clock::time_point deadline);
 
   // Blocking (until deadline) read from queue.
   // Returns false if the queue is ready for destruction, true if event
-  bool Next(void **tag, bool *ok) {
-    return (AsyncNext(tag,ok,
-		      std::chrono::system_clock::time_point::max()) !=
-	    SHUTDOWN);
+
+  bool Next(void** tag, bool* ok) {
+    return (
+        AsyncNext(tag, ok, (std::chrono::system_clock::time_point::max)()) !=
+        SHUTDOWN);
   }
 
   // Shutdown has to be called, and the CompletionQueue can only be
   // destructed when false is returned from Next().
   void Shutdown();
 
-  grpc_completion_queue *cq() { return cq_; }
+  grpc_completion_queue* cq() { return cq_; }
 
  private:
   // Friend synchronous wrappers so that they can access Pluck(), which is
@@ -115,20 +116,20 @@
   friend class ::grpc::ServerReaderWriter;
   friend class ::grpc::Server;
   friend class ::grpc::ServerContext;
-  friend Status BlockingUnaryCall(ChannelInterface *channel,
-                                  const RpcMethod &method,
-                                  ClientContext *context,
-                                  const grpc::protobuf::Message &request,
-                                  grpc::protobuf::Message *result);
+  friend Status BlockingUnaryCall(ChannelInterface* channel,
+                                  const RpcMethod& method,
+                                  ClientContext* context,
+                                  const grpc::protobuf::Message& request,
+                                  grpc::protobuf::Message* result);
 
   // Wraps grpc_completion_queue_pluck.
   // Cannot be mixed with calls to Next().
-  bool Pluck(CompletionQueueTag *tag);
+  bool Pluck(CompletionQueueTag* tag);
 
   // Does a single polling pluck on tag
-  void TryPluck(CompletionQueueTag *tag);
+  void TryPluck(CompletionQueueTag* tag);
 
-  grpc_completion_queue *cq_;  // owned
+  grpc_completion_queue* cq_;  // owned
 };
 
 }  // namespace grpc
diff --git a/include/grpc++/config.h b/include/grpc++/config.h
index 0267b85..35bf507 100644
--- a/include/grpc++/config.h
+++ b/include/grpc++/config.h
@@ -59,11 +59,12 @@
 
 #ifndef GRPC_CUSTOM_ZEROCOPYOUTPUTSTREAM
 #include <google/protobuf/io/zero_copy_stream.h>
-#define GRPC_CUSTOM_ZEROCOPYOUTPUTSTREAM ::google::protobuf::io::ZeroCopyOutputStream
-#define GRPC_CUSTOM_ZEROCOPYINPUTSTREAM ::google::protobuf::io::ZeroCopyInputStream
+#define GRPC_CUSTOM_ZEROCOPYOUTPUTSTREAM \
+  ::google::protobuf::io::ZeroCopyOutputStream
+#define GRPC_CUSTOM_ZEROCOPYINPUTSTREAM \
+  ::google::protobuf::io::ZeroCopyInputStream
 #endif
 
-
 namespace grpc {
 
 typedef GRPC_CUSTOM_STRING string;
diff --git a/include/grpc++/generic_stub.h b/include/grpc++/generic_stub.h
index 25361af..c34e1fc 100644
--- a/include/grpc++/generic_stub.h
+++ b/include/grpc++/generic_stub.h
@@ -59,6 +59,6 @@
   std::shared_ptr<ChannelInterface> channel_;
 };
 
-} // namespace grpc
+}  // namespace grpc
 
 #endif  // GRPCXX_GENERIC_STUB_H
diff --git a/include/grpc++/impl/call.h b/include/grpc++/impl/call.h
index a8551ad..e117ac6 100644
--- a/include/grpc++/impl/call.h
+++ b/include/grpc++/impl/call.h
@@ -55,89 +55,89 @@
   CallOpBuffer();
   ~CallOpBuffer();
 
-  void Reset(void *next_return_tag);
+  void Reset(void* next_return_tag);
 
   // Does not take ownership.
   void AddSendInitialMetadata(
-      std::multimap<grpc::string, grpc::string> *metadata);
-  void AddSendInitialMetadata(ClientContext *ctx);
-  void AddRecvInitialMetadata(ClientContext *ctx);
-  void AddSendMessage(const grpc::protobuf::Message &message);
+      std::multimap<grpc::string, grpc::string>* metadata);
+  void AddSendInitialMetadata(ClientContext* ctx);
+  void AddRecvInitialMetadata(ClientContext* ctx);
+  void AddSendMessage(const grpc::protobuf::Message& message);
   void AddSendMessage(const ByteBuffer& message);
-  void AddRecvMessage(grpc::protobuf::Message *message);
-  void AddRecvMessage(ByteBuffer *message);
+  void AddRecvMessage(grpc::protobuf::Message* message);
+  void AddRecvMessage(ByteBuffer* message);
   void AddClientSendClose();
-  void AddClientRecvStatus(ClientContext *ctx, Status *status);
-  void AddServerSendStatus(std::multimap<grpc::string, grpc::string> *metadata,
-                           const Status &status);
-  void AddServerRecvClose(bool *cancelled);
+  void AddClientRecvStatus(ClientContext* ctx, Status* status);
+  void AddServerSendStatus(std::multimap<grpc::string, grpc::string>* metadata,
+                           const Status& status);
+  void AddServerRecvClose(bool* cancelled);
 
   // INTERNAL API:
 
   // Convert to an array of grpc_op elements
-  void FillOps(grpc_op *ops, size_t *nops);
+  void FillOps(grpc_op* ops, size_t* nops);
 
   // Called by completion queue just prior to returning from Next() or Pluck()
-  bool FinalizeResult(void **tag, bool *status) GRPC_OVERRIDE;
+  bool FinalizeResult(void** tag, bool* status) GRPC_OVERRIDE;
 
   bool got_message;
 
  private:
-  void *return_tag_;
+  void* return_tag_;
   // Send initial metadata
   bool send_initial_metadata_;
   size_t initial_metadata_count_;
-  grpc_metadata *initial_metadata_;
+  grpc_metadata* initial_metadata_;
   // Recv initial metadta
-  std::multimap<grpc::string, grpc::string> *recv_initial_metadata_;
+  std::multimap<grpc::string, grpc::string>* recv_initial_metadata_;
   grpc_metadata_array recv_initial_metadata_arr_;
   // Send message
-  const grpc::protobuf::Message *send_message_;
-  const ByteBuffer *send_message_buffer_;
-  grpc_byte_buffer *send_buf_;
+  const grpc::protobuf::Message* send_message_;
+  const ByteBuffer* send_message_buffer_;
+  grpc_byte_buffer* send_buf_;
   // Recv message
-  grpc::protobuf::Message *recv_message_;
-  ByteBuffer *recv_message_buffer_;
-  grpc_byte_buffer *recv_buf_;
+  grpc::protobuf::Message* recv_message_;
+  ByteBuffer* recv_message_buffer_;
+  grpc_byte_buffer* recv_buf_;
   // Client send close
   bool client_send_close_;
   // Client recv status
-  std::multimap<grpc::string, grpc::string> *recv_trailing_metadata_;
-  Status *recv_status_;
+  std::multimap<grpc::string, grpc::string>* recv_trailing_metadata_;
+  Status* recv_status_;
   grpc_metadata_array recv_trailing_metadata_arr_;
   grpc_status_code status_code_;
-  char *status_details_;
+  char* status_details_;
   size_t status_details_capacity_;
   // Server send status
-  const Status *send_status_;
+  const Status* send_status_;
   size_t trailing_metadata_count_;
-  grpc_metadata *trailing_metadata_;
+  grpc_metadata* trailing_metadata_;
   int cancelled_buf_;
-  bool *recv_closed_;
+  bool* recv_closed_;
 };
 
 // Channel and Server implement this to allow them to hook performing ops
 class CallHook {
  public:
   virtual ~CallHook() {}
-  virtual void PerformOpsOnCall(CallOpBuffer *ops, Call *call) = 0;
+  virtual void PerformOpsOnCall(CallOpBuffer* ops, Call* call) = 0;
 };
 
 // Straightforward wrapping of the C call object
 class Call GRPC_FINAL {
  public:
   /* call is owned by the caller */
-  Call(grpc_call *call, CallHook *call_hook_, CompletionQueue *cq);
+  Call(grpc_call* call, CallHook* call_hook_, CompletionQueue* cq);
 
-  void PerformOps(CallOpBuffer *buffer);
+  void PerformOps(CallOpBuffer* buffer);
 
-  grpc_call *call() { return call_; }
-  CompletionQueue *cq() { return cq_; }
+  grpc_call* call() { return call_; }
+  CompletionQueue* cq() { return cq_; }
 
  private:
-  CallHook *call_hook_;
-  CompletionQueue *cq_;
-  grpc_call *call_;
+  CallHook* call_hook_;
+  CompletionQueue* cq_;
+  grpc_call* call_;
 };
 
 }  // namespace grpc
diff --git a/include/grpc++/impl/client_unary_call.h b/include/grpc++/impl/client_unary_call.h
index fd9715d..0e8aeed 100644
--- a/include/grpc++/impl/client_unary_call.h
+++ b/include/grpc++/impl/client_unary_call.h
@@ -45,10 +45,10 @@
 class Status;
 
 // Wrapper that performs a blocking unary call
-Status BlockingUnaryCall(ChannelInterface *channel, const RpcMethod &method,
-                         ClientContext *context,
-                         const grpc::protobuf::Message &request,
-                         grpc::protobuf::Message *result);
+Status BlockingUnaryCall(ChannelInterface* channel, const RpcMethod& method,
+                         ClientContext* context,
+                         const grpc::protobuf::Message& request,
+                         grpc::protobuf::Message* result);
 
 }  // namespace grpc
 
diff --git a/include/grpc/support/atm.h b/include/grpc/support/atm.h
index feca6b3..ba8d7f5 100644
--- a/include/grpc/support/atm.h
+++ b/include/grpc/support/atm.h
@@ -83,7 +83,7 @@
 #include <grpc/support/atm_gcc_atomic.h>
 #elif defined(GPR_GCC_SYNC)
 #include <grpc/support/atm_gcc_sync.h>
-#elif defined(GPR_WIN32)
+#elif defined(GPR_WIN32_ATOMIC)
 #include <grpc/support/atm_win32.h>
 #else
 #error could not determine platform for atm
diff --git a/include/grpc/support/atm_win32.h b/include/grpc/support/atm_win32.h
index 18bf372..8b53224 100644
--- a/include/grpc/support/atm_win32.h
+++ b/include/grpc/support/atm_win32.h
@@ -51,7 +51,7 @@
 
 static __inline gpr_atm gpr_atm_no_barrier_load(const gpr_atm *p) {
   /* TODO(dklempner): Can we implement something better here? */
-  gpr_atm_acq_load(p);
+  return gpr_atm_acq_load(p);
 }
 
 static __inline void gpr_atm_rel_store(gpr_atm *p, gpr_atm value) {
diff --git a/include/grpc/support/port_platform.h b/include/grpc/support/port_platform.h
index f04c2e7..1b613dc 100644
--- a/include/grpc/support/port_platform.h
+++ b/include/grpc/support/port_platform.h
@@ -43,11 +43,21 @@
 #define GPR_ARCH_64 1
 #define GPR_GETPID_IN_PROCESS_H 1
 #define GPR_WINSOCK_SOCKET 1
+#ifdef __GNUC__
+#define GPR_GCC_ATOMIC 1
+#else
+#define GPR_WIN32_ATOMIC 1
+#endif
 #elif defined(_WIN32) || defined(WIN32)
 #define GPR_ARCH_32 1
 #define GPR_WIN32 1
 #define GPR_GETPID_IN_PROCESS_H 1
 #define GPR_WINSOCK_SOCKET 1
+#ifdef __GNUC__
+#define GPR_GCC_ATOMIC 1
+#else
+#define GPR_WIN32_ATOMIC 1
+#endif
 #elif defined(ANDROID) || defined(__ANDROID__)
 #define GPR_ANDROID 1
 #define GPR_ARCH_32 1
@@ -167,8 +177,8 @@
 #endif
 
 /* Validate platform combinations */
-#if defined(GPR_GCC_ATOMIC) + defined(GPR_GCC_SYNC) + defined(GPR_WIN32) != 1
-#error Must define exactly one of GPR_GCC_ATOMIC, GPR_GCC_SYNC, GPR_WIN32
+#if defined(GPR_GCC_ATOMIC) + defined(GPR_GCC_SYNC) + defined(GPR_WIN32_ATOMIC) != 1
+#error Must define exactly one of GPR_GCC_ATOMIC, GPR_GCC_SYNC, GPR_WIN32_ATOMIC
 #endif
 
 #if defined(GPR_ARCH_32) + defined(GPR_ARCH_64) != 1
diff --git a/src/cpp/client/channel.h b/src/cpp/client/channel.h
index a1de381..3980eba 100644
--- a/src/cpp/client/channel.h
+++ b/src/cpp/client/channel.h
@@ -51,16 +51,16 @@
 
 class Channel GRPC_FINAL : public ChannelInterface {
  public:
-  Channel(const grpc::string &target, grpc_channel *c_channel);
+  Channel(const grpc::string& target, grpc_channel* c_channel);
   ~Channel() GRPC_OVERRIDE;
 
-  virtual Call CreateCall(const RpcMethod &method, ClientContext *context,
-                          CompletionQueue *cq) GRPC_OVERRIDE;
-  virtual void PerformOpsOnCall(CallOpBuffer *ops, Call *call) GRPC_OVERRIDE;
+  virtual Call CreateCall(const RpcMethod& method, ClientContext* context,
+                          CompletionQueue* cq) GRPC_OVERRIDE;
+  virtual void PerformOpsOnCall(CallOpBuffer* ops, Call* call) GRPC_OVERRIDE;
 
  private:
   const grpc::string target_;
-  grpc_channel *const c_channel_;  // owned
+  grpc_channel* const c_channel_;  // owned
 };
 
 }  // namespace grpc
diff --git a/src/cpp/client/channel_arguments.cc b/src/cpp/client/channel_arguments.cc
index abf0fc1..87f8349 100644
--- a/src/cpp/client/channel_arguments.cc
+++ b/src/cpp/client/channel_arguments.cc
@@ -37,7 +37,7 @@
 
 namespace grpc {
 
-void ChannelArguments::SetSslTargetNameOverride(const grpc::string &name) {
+void ChannelArguments::SetSslTargetNameOverride(const grpc::string& name) {
   SetString(GRPC_SSL_TARGET_NAME_OVERRIDE_ARG, name);
 }
 
@@ -50,32 +50,32 @@
   return "";
 }
 
-void ChannelArguments::SetInt(const grpc::string &key, int value) {
+void ChannelArguments::SetInt(const grpc::string& key, int value) {
   grpc_arg arg;
   arg.type = GRPC_ARG_INTEGER;
   strings_.push_back(key);
-  arg.key = const_cast<char *>(strings_.back().c_str());
+  arg.key = const_cast<char*>(strings_.back().c_str());
   arg.value.integer = value;
 
   args_.push_back(arg);
 }
 
-void ChannelArguments::SetString(const grpc::string &key,
-                                 const grpc::string &value) {
+void ChannelArguments::SetString(const grpc::string& key,
+                                 const grpc::string& value) {
   grpc_arg arg;
   arg.type = GRPC_ARG_STRING;
   strings_.push_back(key);
-  arg.key = const_cast<char *>(strings_.back().c_str());
+  arg.key = const_cast<char*>(strings_.back().c_str());
   strings_.push_back(value);
-  arg.value.string = const_cast<char *>(strings_.back().c_str());
+  arg.value.string = const_cast<char*>(strings_.back().c_str());
 
   args_.push_back(arg);
 }
 
-void ChannelArguments::SetChannelArgs(grpc_channel_args *channel_args) const {
+void ChannelArguments::SetChannelArgs(grpc_channel_args* channel_args) const {
   channel_args->num_args = args_.size();
   if (channel_args->num_args > 0) {
-    channel_args->args = const_cast<grpc_arg *>(&args_[0]);
+    channel_args->args = const_cast<grpc_arg*>(&args_[0]);
   }
 }
 
diff --git a/src/cpp/client/client_context.cc b/src/cpp/client/client_context.cc
index 9f99f7b..de9f8c7 100644
--- a/src/cpp/client/client_context.cc
+++ b/src/cpp/client/client_context.cc
@@ -53,7 +53,7 @@
   if (cq_) {
     grpc_completion_queue_shutdown(cq_);
     // Drain cq_.
-    grpc_event *ev;
+    grpc_event* ev;
     grpc_completion_type t;
     do {
       ev = grpc_completion_queue_next(cq_, gpr_inf_future);
@@ -65,7 +65,7 @@
 }
 
 void ClientContext::set_absolute_deadline(
-    const system_clock::time_point &deadline) {
+    const system_clock::time_point& deadline) {
   Timepoint2Timespec(deadline, &absolute_deadline_);
 }
 
@@ -73,8 +73,8 @@
   return Timespec2Timepoint(absolute_deadline_);
 }
 
-void ClientContext::AddMetadata(const grpc::string &meta_key,
-                                const grpc::string &meta_value) {
+void ClientContext::AddMetadata(const grpc::string& meta_key,
+                                const grpc::string& meta_value) {
   send_initial_metadata_.insert(std::make_pair(meta_key, meta_value));
 }
 
diff --git a/src/cpp/client/client_unary_call.cc b/src/cpp/client/client_unary_call.cc
index 5c179de..7e7ea78 100644
--- a/src/cpp/client/client_unary_call.cc
+++ b/src/cpp/client/client_unary_call.cc
@@ -42,10 +42,10 @@
 namespace grpc {
 
 // Wrapper that performs a blocking unary call
-Status BlockingUnaryCall(ChannelInterface *channel, const RpcMethod &method,
-                         ClientContext *context,
-                         const grpc::protobuf::Message &request,
-                         grpc::protobuf::Message *result) {
+Status BlockingUnaryCall(ChannelInterface* channel, const RpcMethod& method,
+                         ClientContext* context,
+                         const grpc::protobuf::Message& request,
+                         grpc::protobuf::Message* result) {
   CompletionQueue cq;
   Call call(channel->CreateCall(method, context, &cq));
   CallOpBuffer buf;
diff --git a/src/cpp/client/create_channel.cc b/src/cpp/client/create_channel.cc
index 57d215d..3014305 100644
--- a/src/cpp/client/create_channel.cc
+++ b/src/cpp/client/create_channel.cc
@@ -41,9 +41,10 @@
 class ChannelArguments;
 
 std::shared_ptr<ChannelInterface> CreateChannel(
-    const grpc::string &target, const std::unique_ptr<Credentials> &creds,
-    const ChannelArguments &args) {
-  return creds ? creds->CreateChannel(target, args) : 
-  	std::shared_ptr<ChannelInterface>(new Channel(target, grpc_lame_client_channel_create()));
+    const grpc::string& target, const std::unique_ptr<Credentials>& creds,
+    const ChannelArguments& args) {
+  return creds ? creds->CreateChannel(target, args)
+               : std::shared_ptr<ChannelInterface>(
+                     new Channel(target, grpc_lame_client_channel_create()));
 }
 }  // namespace grpc
diff --git a/src/cpp/proto/proto_utils.cc b/src/cpp/proto/proto_utils.cc
index 9254e58..b8de2ea 100644
--- a/src/cpp/proto/proto_utils.cc
+++ b/src/cpp/proto/proto_utils.cc
@@ -45,7 +45,7 @@
 class GrpcBufferWriter GRPC_FINAL
     : public ::grpc::protobuf::io::ZeroCopyOutputStream {
  public:
-  explicit GrpcBufferWriter(grpc_byte_buffer **bp,
+  explicit GrpcBufferWriter(grpc_byte_buffer** bp,
                             int block_size = kMaxBufferLength)
       : block_size_(block_size), byte_count_(0), have_backup_(false) {
     *bp = grpc_byte_buffer_create(NULL, 0);
@@ -58,7 +58,7 @@
     }
   }
 
-  bool Next(void **data, int *size) GRPC_OVERRIDE {
+  bool Next(void** data, int* size) GRPC_OVERRIDE {
     if (have_backup_) {
       slice_ = backup_slice_;
       have_backup_ = false;
@@ -89,7 +89,7 @@
  private:
   const int block_size_;
   gpr_int64 byte_count_;
-  gpr_slice_buffer *slice_buffer_;
+  gpr_slice_buffer* slice_buffer_;
   bool have_backup_;
   gpr_slice backup_slice_;
   gpr_slice slice_;
@@ -98,7 +98,7 @@
 class GrpcBufferReader GRPC_FINAL
     : public ::grpc::protobuf::io::ZeroCopyInputStream {
  public:
-  explicit GrpcBufferReader(grpc_byte_buffer *buffer)
+  explicit GrpcBufferReader(grpc_byte_buffer* buffer)
       : byte_count_(0), backup_count_(0) {
     reader_ = grpc_byte_buffer_reader_create(buffer);
   }
@@ -106,7 +106,7 @@
     grpc_byte_buffer_reader_destroy(reader_);
   }
 
-  bool Next(const void **data, int *size) GRPC_OVERRIDE {
+  bool Next(const void** data, int* size) GRPC_OVERRIDE {
     if (backup_count_ > 0) {
       *data = GPR_SLICE_START_PTR(slice_) + GPR_SLICE_LENGTH(slice_) -
               backup_count_;
@@ -123,12 +123,10 @@
     return true;
   }
 
-  void BackUp(int count) GRPC_OVERRIDE {
-    backup_count_ = count;
-  }
+  void BackUp(int count) GRPC_OVERRIDE { backup_count_ = count; }
 
   bool Skip(int count) GRPC_OVERRIDE {
-    const void *data;
+    const void* data;
     int size;
     while (Next(&data, &size)) {
       if (size >= count) {
@@ -149,18 +147,18 @@
  private:
   gpr_int64 byte_count_;
   gpr_int64 backup_count_;
-  grpc_byte_buffer_reader *reader_;
+  grpc_byte_buffer_reader* reader_;
   gpr_slice slice_;
 };
 
 namespace grpc {
 
-bool SerializeProto(const grpc::protobuf::Message &msg, grpc_byte_buffer **bp) {
+bool SerializeProto(const grpc::protobuf::Message& msg, grpc_byte_buffer** bp) {
   GrpcBufferWriter writer(bp);
   return msg.SerializeToZeroCopyStream(&writer);
 }
 
-bool DeserializeProto(grpc_byte_buffer *buffer, grpc::protobuf::Message *msg) {
+bool DeserializeProto(grpc_byte_buffer* buffer, grpc::protobuf::Message* msg) {
   GrpcBufferReader reader(buffer);
   return msg->ParseFromZeroCopyStream(&reader);
 }
diff --git a/src/cpp/proto/proto_utils.h b/src/cpp/proto/proto_utils.h
index 7a1b1f8..bc60dc9 100644
--- a/src/cpp/proto/proto_utils.h
+++ b/src/cpp/proto/proto_utils.h
@@ -43,11 +43,11 @@
 // Serialize the msg into a buffer created inside the function. The caller
 // should destroy the returned buffer when done with it. If serialization fails,
 // false is returned and buffer is left unchanged.
-bool SerializeProto(const grpc::protobuf::Message &msg,
-                    grpc_byte_buffer **buffer);
+bool SerializeProto(const grpc::protobuf::Message& msg,
+                    grpc_byte_buffer** buffer);
 
 // The caller keeps ownership of buffer and msg.
-bool DeserializeProto(grpc_byte_buffer *buffer, grpc::protobuf::Message *msg);
+bool DeserializeProto(grpc_byte_buffer* buffer, grpc::protobuf::Message* msg);
 
 }  // namespace grpc
 
diff --git a/src/cpp/server/async_generic_service.cc b/src/cpp/server/async_generic_service.cc
index 2009af7..07cb933 100644
--- a/src/cpp/server/async_generic_service.cc
+++ b/src/cpp/server/async_generic_service.cc
@@ -47,5 +47,4 @@
   return &server_->cq_;
 }
 
-} // namespace grpc
-
+}  // namespace grpc
diff --git a/src/cpp/server/async_server_context.cc b/src/cpp/server/async_server_context.cc
index f21efcf..628822a 100644
--- a/src/cpp/server/async_server_context.cc
+++ b/src/cpp/server/async_server_context.cc
@@ -42,7 +42,7 @@
 namespace grpc {
 
 AsyncServerContext::AsyncServerContext(
-    grpc_call *call, const grpc::string &method, const grpc::string &host,
+    grpc_call* call, const grpc::string& method, const grpc::string& host,
     system_clock::time_point absolute_deadline)
     : method_(method),
       host_(host),
@@ -52,22 +52,22 @@
 
 AsyncServerContext::~AsyncServerContext() { grpc_call_destroy(call_); }
 
-void AsyncServerContext::Accept(grpc_completion_queue *cq) {
+void AsyncServerContext::Accept(grpc_completion_queue* cq) {
   GPR_ASSERT(grpc_call_server_accept_old(call_, cq, this) == GRPC_CALL_OK);
   GPR_ASSERT(grpc_call_server_end_initial_metadata_old(
                  call_, GRPC_WRITE_BUFFER_HINT) == GRPC_CALL_OK);
 }
 
-bool AsyncServerContext::StartRead(grpc::protobuf::Message *request) {
+bool AsyncServerContext::StartRead(grpc::protobuf::Message* request) {
   GPR_ASSERT(request);
   request_ = request;
   grpc_call_error err = grpc_call_start_read_old(call_, this);
   return err == GRPC_CALL_OK;
 }
 
-bool AsyncServerContext::StartWrite(const grpc::protobuf::Message &response,
+bool AsyncServerContext::StartWrite(const grpc::protobuf::Message& response,
                                     int flags) {
-  grpc_byte_buffer *buffer = nullptr;
+  grpc_byte_buffer* buffer = nullptr;
   if (!SerializeProto(response, &buffer)) {
     return false;
   }
@@ -76,16 +76,16 @@
   return err == GRPC_CALL_OK;
 }
 
-bool AsyncServerContext::StartWriteStatus(const Status &status) {
+bool AsyncServerContext::StartWriteStatus(const Status& status) {
   grpc_call_error err = grpc_call_start_write_status_old(
       call_, static_cast<grpc_status_code>(status.code()),
       status.details().empty() ? nullptr
-                               : const_cast<char *>(status.details().c_str()),
+                               : const_cast<char*>(status.details().c_str()),
       this);
   return err == GRPC_CALL_OK;
 }
 
-bool AsyncServerContext::ParseRead(grpc_byte_buffer *read_buffer) {
+bool AsyncServerContext::ParseRead(grpc_byte_buffer* read_buffer) {
   GPR_ASSERT(request_);
   bool success = DeserializeProto(read_buffer, request_);
   request_ = nullptr;
diff --git a/src/cpp/server/insecure_server_credentials.cc b/src/cpp/server/insecure_server_credentials.cc
index f5e4732..55dd90d 100644
--- a/src/cpp/server/insecure_server_credentials.cc
+++ b/src/cpp/server/insecure_server_credentials.cc
@@ -46,7 +46,8 @@
 }  // namespace
 
 std::shared_ptr<ServerCredentials> InsecureServerCredentials() {
-  return std::shared_ptr<ServerCredentials>(new InsecureServerCredentialsImpl());
+  return std::shared_ptr<ServerCredentials>(
+      new InsecureServerCredentialsImpl());
 }
 
 }  // namespace grpc
diff --git a/src/cpp/server/secure_server_credentials.cc b/src/cpp/server/secure_server_credentials.cc
index ff35638..88f7a9b 100644
--- a/src/cpp/server/secure_server_credentials.cc
+++ b/src/cpp/server/secure_server_credentials.cc
@@ -40,7 +40,8 @@
 namespace {
 class SecureServerCredentials GRPC_FINAL : public ServerCredentials {
  public:
-  explicit SecureServerCredentials(grpc_server_credentials* creds) : creds_(creds) {}
+  explicit SecureServerCredentials(grpc_server_credentials* creds)
+      : creds_(creds) {}
   ~SecureServerCredentials() GRPC_OVERRIDE {
     grpc_server_credentials_release(creds_);
   }
@@ -56,16 +57,17 @@
 }  // namespace
 
 std::shared_ptr<ServerCredentials> SslServerCredentials(
-    const SslServerCredentialsOptions &options) {
+    const SslServerCredentialsOptions& options) {
   std::vector<grpc_ssl_pem_key_cert_pair> pem_key_cert_pairs;
-  for (const auto &key_cert_pair : options.pem_key_cert_pairs) {
+  for (const auto& key_cert_pair : options.pem_key_cert_pairs) {
     pem_key_cert_pairs.push_back(
         {key_cert_pair.private_key.c_str(), key_cert_pair.cert_chain.c_str()});
   }
-  grpc_server_credentials *c_creds = grpc_ssl_server_credentials_create(
+  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());
-  return std::shared_ptr<ServerCredentials>(new SecureServerCredentials(c_creds));
+  return std::shared_ptr<ServerCredentials>(
+      new SecureServerCredentials(c_creds));
 }
 
 }  // namespace grpc
diff --git a/src/cpp/server/server.cc b/src/cpp/server/server.cc
index 4d5e77e..4ed4c45 100644
--- a/src/cpp/server/server.cc
+++ b/src/cpp/server/server.cc
@@ -322,11 +322,10 @@
         payload_(nullptr) {
     memset(&array_, 0, sizeof(array_));
     grpc_call_details_init(&call_details_);
-    grpc_server_request_call(
-        server->server_, &call_, &call_details_, &array_, cq->cq(), this);
+    grpc_server_request_call(server->server_, &call_, &call_details_, &array_,
+                             cq->cq(), this);
   }
 
-
   ~AsyncRequest() {
     if (payload_) {
       grpc_byte_buffer_destroy(payload_);
diff --git a/src/cpp/server/server_builder.cc b/src/cpp/server/server_builder.cc
index 835596d..2f5a0dc 100644
--- a/src/cpp/server/server_builder.cc
+++ b/src/cpp/server/server_builder.cc
@@ -56,7 +56,8 @@
   if (generic_service_) {
     gpr_log(GPR_ERROR,
             "Adding multiple AsyncGenericService is unsupported for now. "
-            "Dropping the service %p", service);
+            "Dropping the service %p",
+            service);
     return;
   }
   generic_service_ = service;
diff --git a/src/cpp/server/thread_pool.cc b/src/cpp/server/thread_pool.cc
index 5dc9bcf..d3013b8 100644
--- a/src/cpp/server/thread_pool.cc
+++ b/src/cpp/server/thread_pool.cc
@@ -66,12 +66,12 @@
     shutdown_ = true;
     cv_.notify_all();
   }
-  for (auto &t : threads_) {
+  for (auto& t : threads_) {
     t.join();
   }
 }
 
-void ThreadPool::ScheduleCallback(const std::function<void()> &callback) {
+void ThreadPool::ScheduleCallback(const std::function<void()>& callback) {
   std::lock_guard<std::mutex> lock(mu_);
   callbacks_.push(callback);
   cv_.notify_one();
diff --git a/src/cpp/server/thread_pool.h b/src/cpp/server/thread_pool.h
index 6157e40..6225d82 100644
--- a/src/cpp/server/thread_pool.h
+++ b/src/cpp/server/thread_pool.h
@@ -50,7 +50,7 @@
   explicit ThreadPool(int num_threads);
   ~ThreadPool();
 
-  void ScheduleCallback(const std::function<void()> &callback) GRPC_OVERRIDE;
+  void ScheduleCallback(const std::function<void()>& callback) GRPC_OVERRIDE;
 
  private:
   std::mutex mu_;
diff --git a/src/cpp/util/slice.cc b/src/cpp/util/slice.cc
index a549c50..57370da 100644
--- a/src/cpp/util/slice.cc
+++ b/src/cpp/util/slice.cc
@@ -37,9 +37,7 @@
 
 Slice::Slice() : slice_(gpr_empty_slice()) {}
 
-Slice::~Slice() {
-  gpr_slice_unref(slice_);
-}
+Slice::~Slice() { gpr_slice_unref(slice_); }
 
 Slice::Slice(gpr_slice slice, AddRef) : slice_(gpr_slice_ref(slice)) {}
 
diff --git a/src/cpp/util/status.cc b/src/cpp/util/status.cc
index bbf8030..b694a51 100644
--- a/src/cpp/util/status.cc
+++ b/src/cpp/util/status.cc
@@ -35,7 +35,7 @@
 
 namespace grpc {
 
-const Status &Status::OK = Status();
-const Status &Status::Cancelled = Status(StatusCode::CANCELLED);
+const Status& Status::OK = Status();
+const Status& Status::Cancelled = Status(StatusCode::CANCELLED);
 
 }  // namespace grpc
diff --git a/src/cpp/util/time.cc b/src/cpp/util/time.cc
index 919e562..44d2283 100644
--- a/src/cpp/util/time.cc
+++ b/src/cpp/util/time.cc
@@ -43,8 +43,8 @@
 namespace grpc {
 
 // TODO(yangg) prevent potential overflow.
-void Timepoint2Timespec(const system_clock::time_point &from,
-                        gpr_timespec *to) {
+void Timepoint2Timespec(const system_clock::time_point& from,
+                        gpr_timespec* to) {
   system_clock::duration deadline = from.time_since_epoch();
   seconds secs = duration_cast<seconds>(deadline);
   nanoseconds nsecs = duration_cast<nanoseconds>(deadline - secs);
diff --git a/src/cpp/util/time.h b/src/cpp/util/time.h
index 1994848..8b7fcf5 100644
--- a/src/cpp/util/time.h
+++ b/src/cpp/util/time.h
@@ -41,8 +41,8 @@
 namespace grpc {
 
 // from and to should be absolute time.
-void Timepoint2Timespec(const std::chrono::system_clock::time_point &from,
-                        gpr_timespec *to);
+void Timepoint2Timespec(const std::chrono::system_clock::time_point& from,
+                        gpr_timespec* to);
 
 std::chrono::system_clock::time_point Timespec2Timepoint(gpr_timespec t);
 
diff --git a/src/node/ext/call.cc b/src/node/ext/call.cc
index afb6541..8cc3e38 100644
--- a/src/node/ext/call.cc
+++ b/src/node/ext/call.cc
@@ -75,6 +75,9 @@
 NanCallback *Call::constructor;
 Persistent<FunctionTemplate> Call::fun_tpl;
 
+bool EndsWith(const char *str, const char *substr) {
+  return strcmp(str+strlen(str)-strlen(substr), substr) == 0;
+}
 
 bool CreateMetadataArray(Handle<Object> metadata, grpc_metadata_array *array,
                          shared_ptr<Resources> resources) {
@@ -99,14 +102,19 @@
       Handle<Value> value = values->Get(j);
       grpc_metadata *current = &array->metadata[array->count];
       current->key = **utf8_key;
-      if (::node::Buffer::HasInstance(value)) {
-        current->value = ::node::Buffer::Data(value);
-        current->value_length = ::node::Buffer::Length(value);
-        Persistent<Value> *handle = new Persistent<Value>();
-        NanAssignPersistent(*handle, value);
-        resources->handles.push_back(unique_ptr<PersistentHolder>(
-            new PersistentHolder(handle)));
-      } else if (value->IsString()) {
+      // Only allow binary headers for "-bin" keys
+      if (EndsWith(current->key, "-bin")) {
+        if (::node::Buffer::HasInstance(value)) {
+          current->value = ::node::Buffer::Data(value);
+          current->value_length = ::node::Buffer::Length(value);
+          Persistent<Value> *handle = new Persistent<Value>();
+          NanAssignPersistent(*handle, value);
+          resources->handles.push_back(unique_ptr<PersistentHolder>(
+              new PersistentHolder(handle)));
+          continue;
+        }
+      }
+      if (value->IsString()) {
         Handle<String> string_value = value->ToString();
         NanUtf8String *utf8_value = new NanUtf8String(string_value);
         resources->strings.push_back(unique_ptr<NanUtf8String>(utf8_value));
@@ -146,9 +154,13 @@
       array = NanNew<Array>(size_map[elem->key]);
       metadata_object->Set(key_string, array);
     }
-    array->Set(index_map[elem->key],
-               MakeFastBuffer(
-                   NanNewBufferHandle(elem->value, elem->value_length)));
+    if (EndsWith(elem->key, "-bin")) {
+      array->Set(index_map[elem->key],
+                 MakeFastBuffer(
+                     NanNewBufferHandle(elem->value, elem->value_length)));
+    } else {
+      array->Set(index_map[elem->key], NanNew(elem->value));
+    }
     index_map[elem->key] += 1;
   }
   return NanEscapeScope(metadata_object);
diff --git a/src/node/package.json b/src/node/package.json
index 1d0aa0e..9f52f8c 100644
--- a/src/node/package.json
+++ b/src/node/package.json
@@ -1,6 +1,6 @@
 {
   "name": "grpc",
-  "version": "0.5.5",
+  "version": "0.6.0",
   "author": "Google Inc.",
   "description": "gRPC Library for Node",
   "homepage": "http://www.grpc.io/",
diff --git a/src/node/test/call_test.js b/src/node/test/call_test.js
index 7b2b36a..98158ff 100644
--- a/src/node/test/call_test.js
+++ b/src/node/test/call_test.js
@@ -142,8 +142,8 @@
       assert.doesNotThrow(function() {
         var batch = {};
         batch[grpc.opType.SEND_INITIAL_METADATA] = {
-          'key1': [new Buffer('value1')],
-          'key2': [new Buffer('value2')]
+          'key1-bin': [new Buffer('value1')],
+          'key2-bin': [new Buffer('value2')]
         };
         call.startBatch(batch, function(err, resp) {
           assert.ifError(err);
diff --git a/src/node/test/end_to_end_test.js b/src/node/test/end_to_end_test.js
index c39364d..60e9861 100644
--- a/src/node/test/end_to_end_test.js
+++ b/src/node/test/end_to_end_test.js
@@ -138,21 +138,21 @@
     client_batch[grpc.opType.RECV_STATUS_ON_CLIENT] = true;
     call.startBatch(client_batch, function(err, response) {
       assert.ifError(err);
-      assert(response['send metadata']);
-      assert(response['client close']);
-      assert(response.hasOwnProperty('metadata'));
-      assert.strictEqual(response.metadata.server_key[0].toString(),
-                         'server_value');
-      assert.deepEqual(response.status, {'code': grpc.status.OK,
-                                         'details': status_text,
-                                         'metadata': {}});
+      assert.deepEqual(response,{
+        'send metadata': true,
+        'client close': true,
+        metadata: {server_key: ['server_value']},
+        status: {'code': grpc.status.OK,
+                 'details': status_text,
+                 'metadata': {}}
+      });
       done();
     });
 
     server.requestCall(function(err, call_details) {
       var new_call = call_details['new call'];
       assert.notEqual(new_call, null);
-      assert.strictEqual(new_call.metadata.client_key[0].toString(),
+      assert.strictEqual(new_call.metadata.client_key[0],
                          'client_value');
       var server_call = new_call.call;
       assert.notEqual(server_call, null);
diff --git a/test/core/transport/metadata_test.c b/test/core/transport/metadata_test.c
index f345ceb..66b5407 100644
--- a/test/core/transport/metadata_test.c
+++ b/test/core/transport/metadata_test.c
@@ -178,7 +178,7 @@
   grpc_mdctx *ctx;
   int i, j;
   char *buffer;
-  int nstrs = 10000;
+  int nstrs = 1000;
   grpc_mdstr **strs = gpr_malloc(sizeof(grpc_mdstr *) * nstrs);
   int *shuf = gpr_malloc(sizeof(int) * nstrs);
   grpc_mdstr *test;
diff --git a/test/cpp/client/credentials_test.cc b/test/cpp/client/credentials_test.cc
index 59ca33c..24251f2 100644
--- a/test/cpp/client/credentials_test.cc
+++ b/test/cpp/client/credentials_test.cc
@@ -54,7 +54,7 @@
 }  // namespace testing
 }  // namespace grpc
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   ::testing::InitGoogleTest(&argc, argv);
   grpc_init();
   int ret = RUN_ALL_TESTS();
diff --git a/test/cpp/end2end/async_end2end_test.cc b/test/cpp/end2end/async_end2end_test.cc
index e011b78..4a71a84 100644
--- a/test/cpp/end2end/async_end2end_test.cc
+++ b/test/cpp/end2end/async_end2end_test.cc
@@ -66,7 +66,7 @@
 
 namespace {
 
-void* tag(int i) { return (void*)(gpr_intptr)i; }
+void* tag(int i) { return (void*)(gpr_intptr) i; }
 
 void verify_ok(CompletionQueue* cq, int i, bool expect_ok) {
   bool ok;
@@ -76,11 +76,11 @@
   EXPECT_EQ(tag(i), got_tag);
 }
 
-void verify_timed_ok(CompletionQueue* cq, int i, bool expect_ok,
-		     std::chrono::system_clock::time_point deadline =
-		     std::chrono::system_clock::time_point::max(),
-		     CompletionQueue::NextStatus expected_outcome =
-		     CompletionQueue::GOT_EVENT) {
+void verify_timed_ok(
+    CompletionQueue* cq, int i, bool expect_ok,
+    std::chrono::system_clock::time_point deadline =
+        std::chrono::system_clock::time_point::max(),
+    CompletionQueue::NextStatus expected_outcome = CompletionQueue::GOT_EVENT) {
   bool ok;
   void* got_tag;
   EXPECT_EQ(cq->AsyncNext(&got_tag, &ok, deadline), expected_outcome);
@@ -195,18 +195,17 @@
   grpc::ServerAsyncResponseWriter<EchoResponse> response_writer(&srv_ctx);
 
   send_request.set_message("Hello");
-  std::unique_ptr<ClientAsyncResponseReader<EchoResponse> >
-    response_reader(stub_->AsyncEcho(&cli_ctx, send_request,
-				     &cli_cq_, tag(1)));
+  std::unique_ptr<ClientAsyncResponseReader<EchoResponse> > response_reader(
+      stub_->AsyncEcho(&cli_ctx, send_request, &cli_cq_, tag(1)));
 
-  std::chrono::system_clock::time_point
-    time_now(std::chrono::system_clock::now()),
-    time_limit(std::chrono::system_clock::now()+std::chrono::seconds(5));
+  std::chrono::system_clock::time_point time_now(
+      std::chrono::system_clock::now()),
+      time_limit(std::chrono::system_clock::now() + std::chrono::seconds(5));
   verify_timed_ok(&srv_cq_, -1, true, time_now, CompletionQueue::TIMEOUT);
   verify_timed_ok(&cli_cq_, -1, true, time_now, CompletionQueue::TIMEOUT);
 
   service_.RequestEcho(&srv_ctx, &recv_request, &response_writer, &srv_cq_,
-		       tag(2));
+                       tag(2));
 
   verify_timed_ok(&srv_cq_, 2, true, time_limit);
   EXPECT_EQ(send_request.message(), recv_request.message());
@@ -221,9 +220,8 @@
 
   EXPECT_EQ(send_response.message(), recv_response.message());
   EXPECT_TRUE(recv_status.IsOk());
-
 }
-  
+
 // Two pings and a final pong.
 TEST_F(AsyncEnd2endTest, SimpleClientStreaming) {
   ResetStub();
diff --git a/test/cpp/end2end/generic_end2end_test.cc b/test/cpp/end2end/generic_end2end_test.cc
index 4a0d2c5..a2faa62 100644
--- a/test/cpp/end2end/generic_end2end_test.cc
+++ b/test/cpp/end2end/generic_end2end_test.cc
@@ -68,7 +68,7 @@
 namespace testing {
 namespace {
 
-void* tag(int i) { return (void*)(gpr_intptr)i; }
+void* tag(int i) { return (void*)(gpr_intptr) i; }
 
 void verify_ok(CompletionQueue* cq, int i, bool expect_ok) {
   bool ok;
@@ -91,7 +91,7 @@
 
 class GenericEnd2endTest : public ::testing::Test {
  protected:
-  GenericEnd2endTest() :  generic_service_("*") {}
+  GenericEnd2endTest() : generic_service_("*") {}
 
   void SetUp() GRPC_OVERRIDE {
     int port = grpc_pick_unused_port_or_die();
@@ -116,8 +116,8 @@
   }
 
   void ResetStub() {
-    std::shared_ptr<ChannelInterface> channel =
-        CreateChannel(server_address_.str(), InsecureCredentials(), ChannelArguments());
+    std::shared_ptr<ChannelInterface> channel = CreateChannel(
+        server_address_.str(), InsecureCredentials(), ChannelArguments());
     stub_ = std::move(grpc::cpp::test::util::TestService::NewStub(channel));
   }
 
@@ -238,7 +238,6 @@
   client_ok(6);
   EXPECT_EQ(send_response.message(), recv_response.message());
 
-
   cli_stream->WritesDone(tag(7));
   client_ok(7);
 
diff --git a/test/cpp/interop/client.cc b/test/cpp/interop/client.cc
index e5645e5..de6c6b7 100644
--- a/test/cpp/interop/client.cc
+++ b/test/cpp/interop/client.cc
@@ -161,6 +161,15 @@
   }
 }
 
+void AssertOkOrPrintErrorStatus(const grpc::Status& s) {
+  if (s.IsOk()) {
+    return;
+  }
+  gpr_log(GPR_INFO, "Error status code: %d, message: %s", s.code(),
+          s.details().c_str());
+  GPR_ASSERT(0);
+}
+
 void DoEmpty() {
   gpr_log(GPR_INFO, "Sending an empty rpc...");
   std::shared_ptr<ChannelInterface> channel =
@@ -172,8 +181,8 @@
   ClientContext context;
 
   grpc::Status s = stub->EmptyCall(&context, request, &response);
+  AssertOkOrPrintErrorStatus(s);
 
-  GPR_ASSERT(s.IsOk());
   gpr_log(GPR_INFO, "Empty rpc done.");
 }
 
@@ -190,7 +199,7 @@
 
   grpc::Status s = stub->UnaryCall(&context, *request, response);
 
-  GPR_ASSERT(s.IsOk());
+  AssertOkOrPrintErrorStatus(s);
   GPR_ASSERT(response->payload().type() ==
              grpc::testing::PayloadType::COMPRESSABLE);
   GPR_ASSERT(response->payload().body() ==
@@ -237,8 +246,7 @@
 }
 
 void DoJwtTokenCreds() {
-  gpr_log(GPR_INFO,
-          "Sending a large unary rpc with JWT token credentials ...");
+  gpr_log(GPR_INFO, "Sending a large unary rpc with JWT token credentials ...");
   std::shared_ptr<ChannelInterface> channel =
       CreateChannelForTestCase("jwt_token_creds");
   SimpleRequest request;
@@ -285,7 +293,7 @@
   grpc::Status s = stream->Finish();
 
   GPR_ASSERT(response.aggregated_payload_size() == aggregated_payload_size);
-  GPR_ASSERT(s.IsOk());
+  AssertOkOrPrintErrorStatus(s);
   gpr_log(GPR_INFO, "Request streaming done.");
 }
 
@@ -314,7 +322,7 @@
   GPR_ASSERT(response_stream_sizes.size() == i);
   grpc::Status s = stream->Finish();
 
-  GPR_ASSERT(s.IsOk());
+  AssertOkOrPrintErrorStatus(s);
   gpr_log(GPR_INFO, "Response streaming done.");
 }
 
@@ -346,7 +354,7 @@
   GPR_ASSERT(kNumResponseMessages == i);
   grpc::Status s = stream->Finish();
 
-  GPR_ASSERT(s.IsOk());
+  AssertOkOrPrintErrorStatus(s);
   gpr_log(GPR_INFO, "Response streaming done.");
 }
 
@@ -379,7 +387,7 @@
   }
   GPR_ASSERT(response_stream_sizes.size() == i);
   grpc::Status s = stream->Finish();
-  GPR_ASSERT(s.IsOk());
+  AssertOkOrPrintErrorStatus(s);
   gpr_log(GPR_INFO, "Half-duplex streaming rpc done.");
 }
 
@@ -412,7 +420,7 @@
   stream->WritesDone();
   GPR_ASSERT(!stream->Read(&response));
   grpc::Status s = stream->Finish();
-  GPR_ASSERT(s.IsOk());
+  AssertOkOrPrintErrorStatus(s);
   gpr_log(GPR_INFO, "Ping pong streaming done.");
 }
 
diff --git a/test/cpp/interop/interop_test.cc b/test/cpp/interop/interop_test.cc
index 811e0eb..a7a5cc0 100644
--- a/test/cpp/interop/interop_test.cc
+++ b/test/cpp/interop/interop_test.cc
@@ -54,13 +54,13 @@
 #include <grpc/support/log.h>
 #include "test/core/util/port.h"
 
-int test_client(const char *root, const char *host, int port) {
+int test_client(const char* root, const char* host, int port) {
   int status;
   pid_t cli;
   cli = fork();
   if (cli == 0) {
-    char *binary_path;
-    char *port_arg;
+    char* binary_path;
+    char* port_arg;
     gpr_asprintf(&binary_path, "%s/interop_client", root);
     gpr_asprintf(&port_arg, "--server_port=%d", port);
 
@@ -78,9 +78,9 @@
   return 0;
 }
 
-int main(int argc, char **argv) {
-  char *me = argv[0];
-  char *lslash = strrchr(me, '/');
+int main(int argc, char** argv) {
+  char* me = argv[0];
+  char* lslash = strrchr(me, '/');
   char root[1024];
   int port = grpc_pick_unused_port_or_die();
   int status;
@@ -104,8 +104,8 @@
   /* start the server */
   svr = fork();
   if (svr == 0) {
-    char *binary_path;
-    char *port_arg;
+    char* binary_path;
+    char* port_arg;
     gpr_asprintf(&binary_path, "%s/interop_server", root);
     gpr_asprintf(&port_arg, "--port=%d", port);
 
diff --git a/test/cpp/qps/client_async.cc b/test/cpp/qps/client_async.cc
index c6535be..526f37a 100644
--- a/test/cpp/qps/client_async.cc
+++ b/test/cpp/qps/client_async.cc
@@ -61,23 +61,23 @@
   virtual ~ClientRpcContext() {}
   virtual bool RunNextState() = 0;  // do next state, return false if steps done
   virtual void StartNewClone() = 0;
-  static void *tag(ClientRpcContext *c) { return reinterpret_cast<void *>(c); }
-  static ClientRpcContext *detag(void *t) {
-    return reinterpret_cast<ClientRpcContext *>(t);
+  static void* tag(ClientRpcContext* c) { return reinterpret_cast<void*>(c); }
+  static ClientRpcContext* detag(void* t) {
+    return reinterpret_cast<ClientRpcContext*>(t);
   }
-  virtual void report_stats(Histogram *hist) = 0;
+  virtual void report_stats(Histogram* hist) = 0;
 };
 
 template <class RequestType, class ResponseType>
 class ClientRpcContextUnaryImpl : public ClientRpcContext {
  public:
   ClientRpcContextUnaryImpl(
-      TestService::Stub *stub, const RequestType &req,
+      TestService::Stub* stub, const RequestType& req,
       std::function<
           std::unique_ptr<grpc::ClientAsyncResponseReader<ResponseType>>(
-              TestService::Stub *, grpc::ClientContext *, const RequestType &,
-              void *)> start_req,
-      std::function<void(grpc::Status, ResponseType *)> on_done)
+              TestService::Stub*, grpc::ClientContext*, const RequestType&,
+              void*)> start_req,
+      std::function<void(grpc::Status, ResponseType*)> on_done)
       : context_(),
         stub_(stub),
         req_(req),
@@ -90,7 +90,7 @@
             start_req(stub_, &context_, req_, ClientRpcContext::tag(this))) {}
   ~ClientRpcContextUnaryImpl() GRPC_OVERRIDE {}
   bool RunNextState() GRPC_OVERRIDE { return (this->*next_state_)(); }
-  void report_stats(Histogram *hist) GRPC_OVERRIDE {
+  void report_stats(Histogram* hist) GRPC_OVERRIDE {
     hist->Add((Timer::Now() - start_) * 1e9);
   }
 
@@ -113,13 +113,13 @@
     return false;
   }
   grpc::ClientContext context_;
-  TestService::Stub *stub_;
+  TestService::Stub* stub_;
   RequestType req_;
   ResponseType response_;
   bool (ClientRpcContextUnaryImpl::*next_state_)();
-  std::function<void(grpc::Status, ResponseType *)> callback_;
+  std::function<void(grpc::Status, ResponseType*)> callback_;
   std::function<std::unique_ptr<grpc::ClientAsyncResponseReader<ResponseType>>(
-      TestService::Stub *, grpc::ClientContext *, const RequestType &, void *)>
+      TestService::Stub*, grpc::ClientContext*, const RequestType&, void*)>
       start_req_;
   grpc::Status status_;
   double start_;
@@ -129,13 +129,13 @@
 
 class AsyncClient GRPC_FINAL : public Client {
  public:
-  explicit AsyncClient(const ClientConfig &config) : Client(config) {
+  explicit AsyncClient(const ClientConfig& config) : Client(config) {
     for (int i = 0; i < config.async_client_threads(); i++) {
       cli_cqs_.emplace_back(new CompletionQueue);
     }
 
     auto payload_size = config.payload_size();
-    auto check_done = [payload_size](grpc::Status s, SimpleResponse *response) {
+    auto check_done = [payload_size](grpc::Status s, SimpleResponse* response) {
       GPR_ASSERT(s.IsOk() && (response->payload().type() ==
                               grpc::testing::PayloadType::COMPRESSABLE) &&
                  (response->payload().body().length() ==
@@ -144,16 +144,16 @@
 
     int t = 0;
     for (int i = 0; i < config.outstanding_rpcs_per_channel(); i++) {
-      for (auto &channel : channels_) {
-        auto *cq = cli_cqs_[t].get();
+      for (auto& channel : channels_) {
+        auto* cq = cli_cqs_[t].get();
         t = (t + 1) % cli_cqs_.size();
-        auto start_req = [cq](TestService::Stub *stub, grpc::ClientContext *ctx,
-                              const SimpleRequest &request, void *tag) {
+        auto start_req = [cq](TestService::Stub* stub, grpc::ClientContext* ctx,
+                              const SimpleRequest& request, void* tag) {
           return stub->AsyncUnaryCall(ctx, request, cq, tag);
         };
 
-        TestService::Stub *stub = channel.get_stub();
-        const SimpleRequest &request = request_;
+        TestService::Stub* stub = channel.get_stub();
+        const SimpleRequest& request = request_;
         new ClientRpcContextUnaryImpl<SimpleRequest, SimpleResponse>(
             stub, request, start_req, check_done);
       }
@@ -165,9 +165,9 @@
   ~AsyncClient() GRPC_OVERRIDE {
     EndThreads();
 
-    for (auto &cq : cli_cqs_) {
+    for (auto& cq : cli_cqs_) {
       cq->Shutdown();
-      void *got_tag;
+      void* got_tag;
       bool ok;
       while (cq->Next(&got_tag, &ok)) {
         delete ClientRpcContext::detag(got_tag);
@@ -175,12 +175,12 @@
     }
   }
 
-  void ThreadFunc(Histogram *histogram, size_t thread_idx) GRPC_OVERRIDE {
-    void *got_tag;
+  void ThreadFunc(Histogram* histogram, size_t thread_idx) GRPC_OVERRIDE {
+    void* got_tag;
     bool ok;
     cli_cqs_[thread_idx]->Next(&got_tag, &ok);
 
-    ClientRpcContext *ctx = ClientRpcContext::detag(got_tag);
+    ClientRpcContext* ctx = ClientRpcContext::detag(got_tag);
     if (ctx->RunNextState() == false) {
       // call the callback and then delete it
       ctx->report_stats(histogram);
@@ -193,7 +193,7 @@
   std::vector<std::unique_ptr<CompletionQueue>> cli_cqs_;
 };
 
-std::unique_ptr<Client> CreateAsyncClient(const ClientConfig &args) {
+std::unique_ptr<Client> CreateAsyncClient(const ClientConfig& args) {
   return std::unique_ptr<Client>(new AsyncClient(args));
 }
 
diff --git a/test/cpp/qps/qps_driver.cc b/test/cpp/qps/qps_driver.cc
index bf51e74..5e9a577 100644
--- a/test/cpp/qps/qps_driver.cc
+++ b/test/cpp/qps/qps_driver.cc
@@ -69,7 +69,7 @@
 using namespace google;
 using namespace gflags;
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   grpc_init();
   ParseCommandLineFlags(&argc, &argv, true);
 
diff --git a/test/cpp/qps/server.cc b/test/cpp/qps/server.cc
index 005f0f9..6a207d8 100644
--- a/test/cpp/qps/server.cc
+++ b/test/cpp/qps/server.cc
@@ -73,8 +73,8 @@
 
 // In some distros, gflags is in the namespace google, and in some others,
 // in gflags. This hack is enabling us to find both.
-namespace google { }
-namespace gflags { }
+namespace google {}
+namespace gflags {}
 using namespace google;
 using namespace gflags;
 
diff --git a/test/cpp/qps/server_async.cc b/test/cpp/qps/server_async.cc
index 19778e5..fcb5ac6 100644
--- a/test/cpp/qps/server_async.cc
+++ b/test/cpp/qps/server_async.cc
@@ -62,9 +62,9 @@
 
 class AsyncQpsServerTest : public Server {
  public:
-  AsyncQpsServerTest(const ServerConfig &config, int port)
+  AsyncQpsServerTest(const ServerConfig& config, int port)
       : srv_cq_(), async_service_(&srv_cq_), server_(nullptr) {
-    char *server_address = NULL;
+    char* server_address = NULL;
     gpr_join_host_port(&server_address, "::", port);
 
     ServerBuilder builder;
@@ -87,10 +87,10 @@
       threads_.push_back(std::thread([=]() {
         // Wait until work is available or we are shutting down
         bool ok;
-        void *got_tag;
+        void* got_tag;
         while (srv_cq_.Next(&got_tag, &ok)) {
           if (ok) {
-            ServerRpcContext *ctx = detag(got_tag);
+            ServerRpcContext* ctx = detag(got_tag);
             // The tag is a pointer to an RPC context to invoke
             if (ctx->RunNextState() == false) {
               // this RPC context is done, so refresh it
@@ -105,7 +105,7 @@
   ~AsyncQpsServerTest() {
     server_->Shutdown();
     srv_cq_.Shutdown();
-    for (auto &thr : threads_) {
+    for (auto& thr : threads_) {
       thr.join();
     }
     while (!contexts_.empty()) {
@@ -122,21 +122,21 @@
     virtual bool RunNextState() = 0;  // do next state, return false if all done
     virtual void Reset() = 0;         // start this back at a clean state
   };
-  static void *tag(ServerRpcContext *func) {
-    return reinterpret_cast<void *>(func);
+  static void* tag(ServerRpcContext* func) {
+    return reinterpret_cast<void*>(func);
   }
-  static ServerRpcContext *detag(void *tag) {
-    return reinterpret_cast<ServerRpcContext *>(tag);
+  static ServerRpcContext* detag(void* tag) {
+    return reinterpret_cast<ServerRpcContext*>(tag);
   }
 
   template <class RequestType, class ResponseType>
   class ServerRpcContextUnaryImpl : public ServerRpcContext {
    public:
     ServerRpcContextUnaryImpl(
-        std::function<void(ServerContext *, RequestType *,
-                           grpc::ServerAsyncResponseWriter<ResponseType> *,
-                           void *)> request_method,
-        std::function<grpc::Status(const RequestType *, ResponseType *)>
+        std::function<void(ServerContext*, RequestType*,
+                           grpc::ServerAsyncResponseWriter<ResponseType>*,
+                           void*)> request_method,
+        std::function<grpc::Status(const RequestType*, ResponseType*)>
             invoke_method)
         : next_state_(&ServerRpcContextUnaryImpl::invoker),
           request_method_(request_method),
@@ -175,16 +175,16 @@
     ServerContext srv_ctx_;
     RequestType req_;
     bool (ServerRpcContextUnaryImpl::*next_state_)();
-    std::function<void(ServerContext *, RequestType *,
-                       grpc::ServerAsyncResponseWriter<ResponseType> *, void *)>
+    std::function<void(ServerContext*, RequestType*,
+                       grpc::ServerAsyncResponseWriter<ResponseType>*, void*)>
         request_method_;
-    std::function<grpc::Status(const RequestType *, ResponseType *)>
+    std::function<grpc::Status(const RequestType*, ResponseType*)>
         invoke_method_;
     grpc::ServerAsyncResponseWriter<ResponseType> response_writer_;
   };
 
-  static Status UnaryCall(const SimpleRequest *request,
-                          SimpleResponse *response) {
+  static Status UnaryCall(const SimpleRequest* request,
+                          SimpleResponse* response) {
     if (request->has_response_size() && request->response_size() > 0) {
       if (!SetPayload(request->response_type(), request->response_size(),
                       response->mutable_payload())) {
@@ -197,13 +197,13 @@
   TestService::AsyncService async_service_;
   std::vector<std::thread> threads_;
   std::unique_ptr<grpc::Server> server_;
-  std::function<void(ServerContext *, SimpleRequest *,
-                     grpc::ServerAsyncResponseWriter<SimpleResponse> *, void *)>
+  std::function<void(ServerContext*, SimpleRequest*,
+                     grpc::ServerAsyncResponseWriter<SimpleResponse>*, void*)>
       request_unary_;
-  std::forward_list<ServerRpcContext *> contexts_;
+  std::forward_list<ServerRpcContext*> contexts_;
 };
 
-std::unique_ptr<Server> CreateAsyncServer(const ServerConfig &config,
+std::unique_ptr<Server> CreateAsyncServer(const ServerConfig& config,
                                           int port) {
   return std::unique_ptr<Server>(new AsyncQpsServerTest(config, port));
 }
diff --git a/test/cpp/util/create_test_channel.cc b/test/cpp/util/create_test_channel.cc
index d3b84b2..f040acc 100644
--- a/test/cpp/util/create_test_channel.cc
+++ b/test/cpp/util/create_test_channel.cc
@@ -72,8 +72,7 @@
     const grpc::string& connect_to =
         server.empty() ? override_hostname : server;
     if (creds.get()) {
-      channel_creds =
-          CompositeCredentials(creds, channel_creds);
+      channel_creds = CompositeCredentials(creds, channel_creds);
     }
     return CreateChannel(connect_to, channel_creds, channel_args);
   } else {
diff --git a/test/cpp/util/status_test.cc b/test/cpp/util/status_test.cc
index 8c6a335..17b92ab 100644
--- a/test/cpp/util/status_test.cc
+++ b/test/cpp/util/status_test.cc
@@ -36,7 +36,7 @@
 #include <grpc/support/log.h>
 
 // Make sure the existing grpc_status_code match with grpc::Code.
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   GPR_ASSERT(grpc::StatusCode::OK ==
              static_cast<grpc::StatusCode>(GRPC_STATUS_OK));
   GPR_ASSERT(grpc::StatusCode::CANCELLED ==
diff --git a/tools/dockerfile/grpc_dist_proto/Dockerfile b/tools/dockerfile/grpc_dist_proto/Dockerfile
new file mode 100644
index 0000000..b4ed3b6
--- /dev/null
+++ b/tools/dockerfile/grpc_dist_proto/Dockerfile
@@ -0,0 +1,76 @@
+# Copyright 2015, Google Inc.
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+#     * Redistributions of source code must retain the above copyright
+# notice, this list of conditions and the following disclaimer.
+#     * Redistributions in binary form must reproduce the above
+# copyright notice, this list of conditions and the following disclaimer
+# in the documentation and/or other materials provided with the
+# distribution.
+#     * Neither the name of Google Inc. nor the names of its
+# contributors may be used to endorse or promote products derived from
+# this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+# Dockerfile to build protoc and plugins for inclusion in a release.
+FROM grpc/base
+
+# Add the file containing the gRPC version
+ADD version.txt version.txt
+
+# Install tools needed for building protoc.
+RUN apt-get update && apt-get -y install libgflags-dev libgtest-dev
+
+# Get the protobuf source from GitHub.
+RUN mkdir -p /var/local/git
+RUN git clone https://github.com/google/protobuf.git /var/local/git/protobuf
+
+# Build the protobuf library statically and install to /tmp/protoc_static.
+WORKDIR /var/local/git/protobuf
+RUN ./autogen.sh && \
+    ./configure --disable-shared --prefix=/tmp/protoc_static \
+    LDFLAGS="-lgcc_eh -static-libgcc -static-libstdc++" && \
+    make -j12 && make check && make install
+
+# Build the protobuf library dynamically and install to /usr/local.
+WORKDIR /var/local/git/protobuf
+RUN ./autogen.sh && \
+    ./configure --prefix=/usr/local && \
+    make -j12 && make check && make install
+
+# Build the grpc plugins.
+RUN git clone https://github.com/google/grpc.git /var/local/git/grpc
+WORKDIR /var/local/git/grpc
+RUN LDFLAGS=-static make plugins
+
+# Create an archive containing all the generated binaries.
+RUN mkdir /tmp/proto-bins_$(cat /version.txt)_linux-$(uname -m)
+RUN cp -v bins/opt/* /tmp/proto-bins_$(cat /version.txt)_linux-$(uname -m)
+RUN cp -v /tmp/protoc_static/bin/protoc /tmp/proto-bins_$(cat /version.txt)_linux-$(uname -m)
+RUN cd /tmp && \
+    tar -czf proto-bins_$(cat /version.txt)_linux-$(uname -m).tar.gz proto-bins_$(cat /version.txt)_linux-$(uname -m)
+
+# List the tar contents: provides a way to visually confirm that the contents
+# are correct.
+RUN echo 'proto-bins_$(cat /version.txt)_linux-tar-$(uname -m) contents:' && \
+    tar -ztf /tmp/proto-bins_$(cat /version.txt)_linux-$(uname -m).tar.gz
+
+
+
+
+
diff --git a/tools/dockerfile/grpc_dist_proto/version.txt b/tools/dockerfile/grpc_dist_proto/version.txt
new file mode 100644
index 0000000..8f0916f
--- /dev/null
+++ b/tools/dockerfile/grpc_dist_proto/version.txt
@@ -0,0 +1 @@
+0.5.0
diff --git a/tools/gce_setup/cloud_prod_runner.sh b/tools/gce_setup/cloud_prod_runner.sh
index 3a9ae51..e236c92 100755
--- a/tools/gce_setup/cloud_prod_runner.sh
+++ b/tools/gce_setup/cloud_prod_runner.sh
@@ -36,7 +36,7 @@
 main() {
   source grpc_docker.sh
   test_cases=(large_unary empty_unary ping_pong client_streaming server_streaming cancel_after_begin cancel_after_first_response)
-  auth_test_cases=(service_account_creds compute_engine_creds)
+  auth_test_cases=(service_account_creds compute_engine_creds jwt_token_creds)
   clients=(cxx java go ruby node csharp_mono)
   for test_case in "${test_cases[@]}"
   do
diff --git a/tools/gce_setup/grpc_docker.sh b/tools/gce_setup/grpc_docker.sh
index 3deef05..497112c 100755
--- a/tools/gce_setup/grpc_docker.sh
+++ b/tools/gce_setup/grpc_docker.sh
@@ -560,7 +560,7 @@
   _grpc_ensure_gcloud_ssh || return 1;
 
   # declare vars local so that they don't pollute the shell environment
-  # where they this func is used.
+  # where this func is used.
   local grpc_zone grpc_project dry_run  # set by _grpc_set_project_and_zone
   local grpc_hosts grpc_gce_script_root
 
@@ -600,7 +600,7 @@
   _grpc_ensure_gcloud_ssh || return 1;
 
   # declare vars local so that they don't pollute the shell environment
-  # where they this func is used.
+  # where this func is used.
   local grpc_zone grpc_project dry_run  # set by _grpc_set_project_and_zone
   local grpc_hosts
 
@@ -645,7 +645,7 @@
 # Shows the grpc servers on the GCE instance <server_name>
 grpc_show_servers() {
   # declare vars local so that they don't pollute the shell environment
-  # where they this func is used.
+  # where this func is used.
   local grpc_zone grpc_project dry_run  # set by _grpc_set_project_and_zone
   # set by _grpc_show_servers
   local host
@@ -663,6 +663,58 @@
   gcloud compute $project_opt ssh $zone_opt $host --command "$cmd"
 }
 
+_grpc_build_proto_bins_args() {
+  [[ -n $1 ]] && {  # host
+    host=$1
+    shift
+  } || {
+    host='grpc-docker-builder'
+  }
+}
+
+# grpc_build_proto_bins
+# 
+# - rebuilds the dist_proto docker image
+#   * doing this builds the protoc and the ruby, python and cpp bins statically
+#
+# - runs a docker command that copies the built protos to the GCE host
+# - copies the built protos to the local machine
+grpc_build_proto_bins() {
+  _grpc_ensure_gcloud_ssh || return 1;
+
+  # declare vars local so that they don't pollute the shell environment
+  # where this func is used.
+  local grpc_zone grpc_project dry_run  # set by _grpc_set_project_and_zone
+  # set by _grpc_build_proto_bins_args
+  local host
+
+  # set the project zone and check that all necessary args are provided
+  _grpc_set_project_and_zone -f _grpc_build_proto_bins_args "$@" || return 1
+  gce_has_instance $grpc_project $host || return 1;
+  local project_opt="--project $grpc_project"
+  local zone_opt="--zone $grpc_zone"
+  
+  # rebuild the dist_proto image
+  local label='dist_proto'
+  grpc_update_image -- -h $host $label || return 1
+ 
+  # run a command to copy the generated archive to the docker host
+  local docker_prefix='sudo docker run -v /tmp:/tmp/proto_bins_out'
+  local tar_name='proto-bins*.tar.gz'
+  local cp_cmd="/bin/bash -c 'cp -v /tmp/$tar_name /tmp/proto_bins_out'"
+  local cmd="$docker_prefix grpc/$label $cp_cmd"
+  local ssh_cmd="bash -l -c \"$cmd\""
+  echo "will run:"
+  echo "  $ssh_cmd"
+  echo "on $host"
+  gcloud compute $project_opt ssh $zone_opt $host --command "$cmd" || return 1
+
+  # copy the tar.gz locally
+  local rmt_tar="$host:/tmp/$tar_name"
+  local local_copy="$(pwd)"
+  gcloud compute copy-files $rmt_tar $local_copy $project_opt $zone_opt || return 1
+}
+
 _grpc_launch_servers_args() {
   [[ -n $1 ]] && {  # host
     host=$1
@@ -690,7 +742,7 @@
 # If no servers are specified, it launches all known servers
 grpc_launch_servers() {
   # declare vars local so that they don't pollute the shell environment
-  # where they this func is used.
+  # where this func is used.
   local grpc_zone grpc_project dry_run  # set by _grpc_set_project_and_zone
   # set by _grpc_launch_servers_args
   local host servers
@@ -811,7 +863,7 @@
 grpc_interop_test() {
   _grpc_ensure_gcloud_ssh || return 1;
   # declare vars local so that they don't pollute the shell environment
-  # where they this func is used.
+  # where this func is used.
 
   local grpc_zone grpc_project dry_run  # set by _grpc_set_project_and_zone
   #  grpc_interop_test_args
@@ -853,7 +905,7 @@
 grpc_cloud_prod_test() {
   _grpc_ensure_gcloud_ssh || return 1;
   # declare vars local so that they don't pollute the shell environment
-  # where they this func is used.
+  # where this func is used.
 
   local grpc_zone grpc_project dry_run  # set by _grpc_set_project_and_zone
   #  grpc_cloud_prod_test_args
@@ -892,7 +944,7 @@
 grpc_cloud_prod_auth_test() {
   _grpc_ensure_gcloud_ssh || return 1;
   # declare vars local so that they don't pollute the shell environment
-  # where they this func is used.
+  # where this func is used.
 
   local grpc_zone grpc_project dry_run  # set by _grpc_set_project_and_zone
   #  grpc_cloud_prod_test_args
@@ -1192,6 +1244,20 @@
     echo $the_cmd
 }
 
+# constructs the full dockerized cpp jwt_token auth interop test cmd.
+#
+# call-seq:
+#   flags= .... # generic flags to include the command
+#   cmd=$($grpc_gen_test_cmd $flags)
+grpc_cloud_prod_auth_jwt_token_creds_gen_cxx_cmd() {
+    local cmd_prefix="sudo docker run grpc/cxx";
+    local test_script="/var/local/git/grpc/bins/opt/interop_client --enable_ssl --use_prod_roots";
+    local gfe_flags=$(_grpc_prod_gfe_flags)
+    local added_gfe_flags=$(_grpc_jwt_token_test_flags)
+    local the_cmd="$cmd_prefix $test_script $gfe_flags $added_gfe_flags $@";
+    echo $the_cmd
+}
+
 # constructs the full dockerized csharp-mono interop test cmd.
 #
 # call-seq:
@@ -1230,6 +1296,11 @@
   echo " --service_account_key_file=/service_account/stubbyCloudTestingTest-7dd63462c60c.json --oauth_scope=https://www.googleapis.com/auth/xapi.zoo"
 }
 
+# outputs the flags passed to the service account auth tests
+_grpc_jwt_token_test_flags() {
+  echo " --service_account_key_file=/service_account/stubbyCloudTestingTest-7dd63462c60c.json"
+}
+
 # default credentials test flag
 _grpc_default_creds_test_flags() {
   echo " --oauth_scope=https://www.googleapis.com/auth/xapi.zoo"