diff --git a/src/core/transport/transport.h b/src/core/transport/transport.h
new file mode 100644
index 0000000..1872947
--- /dev/null
+++ b/src/core/transport/transport.h
@@ -0,0 +1,245 @@
+/*
+ *
+ * Copyright 2014, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#ifndef __GRPC_INTERNAL_TRANSPORT_TRANSPORT_H__
+#define __GRPC_INTERNAL_TRANSPORT_TRANSPORT_H__
+
+#include <stddef.h>
+
+#include "src/core/transport/stream_op.h"
+
+/* forward declarations */
+typedef struct grpc_transport grpc_transport;
+typedef struct grpc_transport_callbacks grpc_transport_callbacks;
+
+/* grpc_stream doesn't actually exist. It's used as a typesafe
+   opaque pointer for whatever data the transport wants to track
+   for a stream. */
+typedef struct grpc_stream grpc_stream;
+
+/* Represents the send/recv closed state of a stream. */
+typedef enum grpc_stream_state {
+  /* the stream is open for sends and receives */
+  GRPC_STREAM_OPEN,
+  /* the stream is closed for sends, but may still receive data */
+  GRPC_STREAM_SEND_CLOSED,
+  /* the stream is closed for receives, but may still send data */
+  GRPC_STREAM_RECV_CLOSED,
+  /* the stream is closed for both sends and receives */
+  GRPC_STREAM_CLOSED
+} grpc_stream_state;
+
+/* Callbacks made from the transport to the upper layers of grpc. */
+struct grpc_transport_callbacks {
+  /* Allocate a buffer to receive data into.
+     It's safe to call grpc_slice_new() to do this, but performance minded
+     proxies may want to carefully place data into optimal locations for
+     transports.
+     This function must return a valid, non-empty slice.
+
+     Arguments:
+       user_data - the transport user data set at transport creation time
+       transport - the grpc_transport instance making this call
+       stream    - the grpc_stream instance the buffer will be used for, or
+                   NULL if this is not known
+       size_hint - how big of a buffer would the transport optimally like?
+                   the actual returned buffer can be smaller or larger than
+                   size_hint as the implementation finds convenient */
+  struct gpr_slice (*alloc_recv_buffer)(void *user_data,
+                                        grpc_transport *transport,
+                                        grpc_stream *stream, size_t size_hint);
+
+  /* Initialize a new stream on behalf of the transport.
+     Must result in a call to
+     grpc_transport_init_stream(transport, ..., request) in the same call
+     stack.
+     Must not result in any other calls to the transport.
+
+     Arguments:
+       user_data     - the transport user data set at transport creation time
+       transport     - the grpc_transport instance making this call
+       request       - request parameters for this stream (owned by the caller)
+       server_data   - opaque transport dependent argument that should be passed
+                       to grpc_transport_init_stream
+     */
+  void (*accept_stream)(void *user_data, grpc_transport *transport,
+                        const void *server_data);
+
+  /* Process a set of stream ops that have been received by the transport.
+     Called by network threads, so must be careful not to block on network
+     activity.
+
+     If final_state == GRPC_STREAM_CLOSED, the upper layers should arrange to
+     call grpc_transport_destroy_stream.
+
+     Ownership of any objects contained in ops is transferred to the callee.
+
+     Arguments:
+       user_data   - the transport user data set at transport creation time
+       transport   - the grpc_transport instance making this call
+       stream      - the stream this data was received for
+       ops         - stream operations that are part of this batch
+       ops_count   - the number of stream operations in this batch
+       final_state - the state of the stream as of the final operation in this
+                     batch */
+  void (*recv_batch)(void *user_data, grpc_transport *transport,
+                     grpc_stream *stream, grpc_stream_op *ops, size_t ops_count,
+                     grpc_stream_state final_state);
+
+  /* The transport has been closed */
+  void (*closed)(void *user_data, grpc_transport *transport);
+};
+
+/* Returns the amount of memory required to store a grpc_stream for this
+   transport */
+size_t grpc_transport_stream_size(grpc_transport *transport);
+
+/* Initialize transport data for a stream.
+
+   Returns 0 on success, any other (transport-defined) value for failure.
+
+   Arguments:
+     transport   - the transport on which to create this stream
+     stream      - a pointer to uninitialized memory to initialize
+     server_data - either NULL for a client initiated stream, or a pointer
+                   supplied from the accept_stream callback function */
+int grpc_transport_init_stream(grpc_transport *transport, grpc_stream *stream,
+                               const void *server_data);
+
+/* Destroy transport data for a stream.
+
+   Requires: a recv_batch with final_state == GRPC_STREAM_CLOSED has been
+   received by the up-layer. Must not be called in the same call stack as
+   recv_frame.
+
+   Arguments:
+     transport - the transport on which to create this stream
+     stream    - the grpc_stream to destroy (memory is still owned by the
+                 caller, but any child memory must be cleaned up) */
+void grpc_transport_destroy_stream(grpc_transport *transport,
+                                   grpc_stream *stream);
+
+/* Enable/disable incoming data for a stream.
+
+   This effectively disables new window becoming available for a given stream,
+   but does not prevent existing window from being consumed by a sender: the
+   caller must still be prepared to receive some additional data after this
+   call.
+
+   Arguments:
+     transport - the transport on which to create this stream
+     stream    - the grpc_stream to destroy (memory is still owned by the
+                 caller, but any child memory must be cleaned up)
+     allow     - is it allowed that new window be opened up? */
+void grpc_transport_set_allow_window_updates(grpc_transport *transport,
+                                             grpc_stream *stream, int allow);
+
+/* Send a batch of operations on a transport
+
+   Takes ownership of any objects contained in ops.
+
+   Arguments:
+     transport - the transport on which to initiate the stream
+     stream    - the stream on which to send the operations. This must be
+                 non-NULL and previously initialized by the same transport.
+     ops       - an array of operations to apply to the stream - can be NULL
+                 if ops_count == 0.
+     ops_count - the number of elements in ops
+     is_last   - is this the last batch of operations to be sent out */
+void grpc_transport_send_batch(grpc_transport *transport, grpc_stream *stream,
+                               grpc_stream_op *ops, size_t ops_count,
+                               int is_last);
+
+/* Send a ping on a transport
+
+   Calls cb with user data when a response is received.
+   cb *MAY* be called with arbitrary transport level locks held. It is not safe
+   to call into the transport during cb. */
+void grpc_transport_ping(grpc_transport *transport, void (*cb)(void *user_data),
+                         void *user_data);
+
+/* Abort a stream
+
+   Terminate reading and writing for a stream. A final recv_batch with no
+   operations and final_state == GRPC_STREAM_CLOSED will be received locally,
+   and no more data will be presented to the up-layer.
+
+   TODO(ctiller): consider adding a HTTP/2 reason to this function. */
+void grpc_transport_abort_stream(grpc_transport *transport, grpc_stream *stream,
+                                 grpc_status_code status);
+
+/* Close a transport. Aborts all open streams. */
+void grpc_transport_close(struct grpc_transport *transport);
+
+/* Destroy the transport */
+void grpc_transport_destroy(struct grpc_transport *transport);
+
+/* Return type for grpc_transport_setup_callback */
+typedef struct grpc_transport_setup_result {
+  void *user_data;
+  const grpc_transport_callbacks *callbacks;
+} grpc_transport_setup_result;
+
+/* Given a transport, return callbacks for that transport. Used to finalize
+   setup as a transport is being created */
+typedef grpc_transport_setup_result (*grpc_transport_setup_callback)(
+    void *setup_arg, grpc_transport *transport, grpc_mdctx *mdctx);
+
+typedef struct grpc_transport_setup grpc_transport_setup;
+typedef struct grpc_transport_setup_vtable grpc_transport_setup_vtable;
+
+struct grpc_transport_setup_vtable {
+  void (*initiate)(grpc_transport_setup *setup);
+  void (*cancel)(grpc_transport_setup *setup);
+};
+
+/* Transport setup is an asynchronous utility interface for client channels to
+   establish connections. It's transport agnostic. */
+struct grpc_transport_setup {
+  const grpc_transport_setup_vtable *vtable;
+};
+
+/* Initiate transport setup: e.g. for TCP+DNS trigger a resolve of the name
+   given at transport construction time, create the tcp connection, perform
+   handshakes, and call some grpc_transport_setup_result function provided at
+   setup construction time.
+   This *may* be implemented as a no-op if the setup process monitors something
+   continuously. */
+void grpc_transport_setup_initiate(grpc_transport_setup *setup);
+/* Cancel transport setup. After this returns, no new transports should be
+   created, and all pending transport setup callbacks should be completed.
+   After this call completes, setup should be considered invalid (this can be
+   used as a destruction call by setup). */
+void grpc_transport_setup_cancel(grpc_transport_setup *setup);
+
+#endif  /* __GRPC_INTERNAL_TRANSPORT_TRANSPORT_H__ */